shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions 6 Packages Projects Releases Wiki Activity
llvm-project/llvm/include/llvm/AsmParser/LLParser.h
Matt Arsenault 5da674492a IR: Add nofpclass parameter attribute 
This carries a bitmask indicating forbidden floating-point value kinds
in the argument or return value. This will enable interprocedural
-ffinite-math-only optimizations. This is primarily to cover the
no-nans and no-infinities cases, but also covers the other floating
point classes for free. Textually, this provides a number of names
corresponding to bits in FPClassTest, e.g.

  call nofpclass(nan inf) @must_be_finite()
  call nofpclass(snan) @cannot_be_snan()

This is more expressive than the existing nnan and ninf fast math
flags. As an added bonus, you can represent fun things like nanf:

  declare nofpclass(inf zero sub norm) float @only_nans()

Compared to nnan/ninf:
  - Can be applied to individual call operands as well as the return value
  - Can distinguish signaling and quiet nans
  - Distinguishes the sign of infinities
  - Can be safely propagated since it doesn't imply anything about
    other operands.
  - Does not apply to FP instructions; it's not a flag

This is one step closer to being able to retire "no-nans-fp-math" and
"no-infs-fp-math". The one remaining situation where we have no way to
represent no-nans/infs is for loads (if we wanted to solve this we
could introduce !nofpclass metadata, following along with
noundef/!noundef).

This is to help simplify the GPU builtin math library
distribution. Currently the library code has explicit finite math only
checks, read from global constants the compiler driver needs to set
based on the compiler flags during linking. We end up having to
internalize the library into each translation unit in case different
linked modules have different math flags. By propagating known-not-nan
and known-not-infinity information, we can automatically prune the
edge case handling in most functions if the function is only reached
from fast math uses.
2023-02-24 07:41:29 -04:00

647 lines
28 KiB
C++
Raw Blame History

//===-- LLParser.h - Parser Class -------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines the parser class for .ll files.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ASMPARSER_LLPARSER_H
#define LLVM_ASMPARSER_LLPARSER_H
#include "LLLexer.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/AsmParser/Parser.h"
#include "llvm/IR/Attributes.h"
#include "llvm/IR/FMF.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/ModuleSummaryIndex.h"
#include <map>
#include <optional>
namespace llvm {
class Module;
class ConstantRange;
class FunctionType;
class GlobalObject;
class SMDiagnostic;
class SMLoc;
class SourceMgr;
class Type;
struct MaybeAlign;
class Function;
class Value;
class BasicBlock;
class Instruction;
class Constant;
class GlobalValue;
class Comdat;
class MDString;
class MDNode;
class MemoryEffects;
struct SlotMapping;
/// ValID - Represents a reference of a definition of some sort with no type.
/// There are several cases where we have to parse the value but where the
/// type can depend on later context. This may either be a numeric reference
/// or a symbolic (%var) reference. This is just a discriminated union.
struct ValID {
enum {
t_LocalID, t_GlobalID, // ID in UIntVal.
t_LocalName, t_GlobalName, // Name in StrVal.
t_APSInt, t_APFloat, // Value in APSIntVal/APFloatVal.
t_Null, t_Undef, t_Zero, t_None, t_Poison, // No value.
t_EmptyArray, // No value: []
t_Constant, // Value in ConstantVal.
t_InlineAsm, // Value in FTy/StrVal/StrVal2/UIntVal.
t_ConstantStruct, // Value in ConstantStructElts.
t_PackedConstantStruct // Value in ConstantStructElts.
} Kind = t_LocalID;
LLLexer::LocTy Loc;
unsigned UIntVal;
FunctionType *FTy = nullptr;
std::string StrVal, StrVal2;
APSInt APSIntVal;
APFloat APFloatVal{0.0};
Constant *ConstantVal;
std::unique_ptr<Constant *[]> ConstantStructElts;
bool NoCFI = false;
ValID() = default;
ValID(const ValID &RHS)
: Kind(RHS.Kind), Loc(RHS.Loc), UIntVal(RHS.UIntVal), FTy(RHS.FTy),
StrVal(RHS.StrVal), StrVal2(RHS.StrVal2), APSIntVal(RHS.APSIntVal),
APFloatVal(RHS.APFloatVal), ConstantVal(RHS.ConstantVal),
NoCFI(RHS.NoCFI) {
assert(!RHS.ConstantStructElts);
}
bool operator<(const ValID &RHS) const {
assert(Kind == RHS.Kind && "Comparing ValIDs of different kinds");
if (Kind == t_LocalID || Kind == t_GlobalID)
return UIntVal < RHS.UIntVal;
assert((Kind == t_LocalName || Kind == t_GlobalName ||
Kind == t_ConstantStruct || Kind == t_PackedConstantStruct) &&
"Ordering not defined for this ValID kind yet");
return StrVal < RHS.StrVal;
}
};
class LLParser {
public:
typedef LLLexer::LocTy LocTy;
private:
LLVMContext &Context;
// Lexer to determine whether to use opaque pointers or not.
LLLexer OPLex;
LLLexer Lex;
// Module being parsed, null if we are only parsing summary index.
Module *M;
// Summary index being parsed, null if we are only parsing Module.
ModuleSummaryIndex *Index;
SlotMapping *Slots;
SmallVector<Instruction*, 64> InstsWithTBAATag;
/// DIAssignID metadata does not support temporary RAUW so we cannot use
/// the normal metadata forward reference resolution method. Instead,
/// non-temporary DIAssignID are attached to instructions (recorded here)
/// then replaced later.
DenseMap<MDNode *, SmallVector<Instruction *, 2>> TempDIAssignIDAttachments;
// Type resolution handling data structures. The location is set when we
// have processed a use of the type but not a definition yet.
StringMap<std::pair<Type*, LocTy> > NamedTypes;
std::map<unsigned, std::pair<Type*, LocTy> > NumberedTypes;
std::map<unsigned, TrackingMDNodeRef> NumberedMetadata;
std::map<unsigned, std::pair<TempMDTuple, LocTy>> ForwardRefMDNodes;
// Global Value reference information.
std::map<std::string, std::pair<GlobalValue*, LocTy> > ForwardRefVals;
std::map<unsigned, std::pair<GlobalValue*, LocTy> > ForwardRefValIDs;
std::vector<GlobalValue*> NumberedVals;
// Comdat forward reference information.
std::map<std::string, LocTy> ForwardRefComdats;
// References to blockaddress. The key is the function ValID, the value is
// a list of references to blocks in that function.
std::map<ValID, std::map<ValID, GlobalValue *>> ForwardRefBlockAddresses;
class PerFunctionState;
/// Reference to per-function state to allow basic blocks to be
/// forward-referenced by blockaddress instructions within the same
/// function.
PerFunctionState *BlockAddressPFS;
// References to dso_local_equivalent. The key is the global's ValID, the
// value is a placeholder value that will be replaced. Note there are two
// maps for tracking ValIDs that are GlobalNames and ValIDs that are
// GlobalIDs. These are needed because "operator<" doesn't discriminate
// between the two.
std::map<ValID, GlobalValue *> ForwardRefDSOLocalEquivalentNames;
std::map<ValID, GlobalValue *> ForwardRefDSOLocalEquivalentIDs;
// Attribute builder reference information.
std::map<Value*, std::vector<unsigned> > ForwardRefAttrGroups;
std::map<unsigned, AttrBuilder> NumberedAttrBuilders;
// Summary global value reference information.
std::map<unsigned, std::vector<std::pair<ValueInfo *, LocTy>>>
ForwardRefValueInfos;
std::map<unsigned, std::vector<std::pair<AliasSummary *, LocTy>>>
ForwardRefAliasees;
std::vector<ValueInfo> NumberedValueInfos;
// Summary type id reference information.
std::map<unsigned, std::vector<std::pair<GlobalValue::GUID *, LocTy>>>
ForwardRefTypeIds;
// Map of module ID to path.
std::map<unsigned, StringRef> ModuleIdMap;
/// Only the llvm-as tool may set this to false to bypass
/// UpgradeDebuginfo so it can generate broken bitcode.
bool UpgradeDebugInfo;
std::string SourceFileName;
public:
LLParser(StringRef F, SourceMgr &SM, SMDiagnostic &Err, Module *M,
ModuleSummaryIndex *Index, LLVMContext &Context,
SlotMapping *Slots = nullptr)
: Context(Context), OPLex(F, SM, Err, Context),
Lex(F, SM, Err, Context), M(M), Index(Index), Slots(Slots),
BlockAddressPFS(nullptr) {}
bool Run(
bool UpgradeDebugInfo,
DataLayoutCallbackTy DataLayoutCallback = [](StringRef, StringRef) {
return std::nullopt;
});
bool parseStandaloneConstantValue(Constant *&C, const SlotMapping *Slots);
bool parseTypeAtBeginning(Type *&Ty, unsigned &Read,
const SlotMapping *Slots);
LLVMContext &getContext() { return Context; }
private:
bool error(LocTy L, const Twine &Msg) const { return Lex.Error(L, Msg); }
bool tokError(const Twine &Msg) const { return error(Lex.getLoc(), Msg); }
/// Restore the internal name and slot mappings using the mappings that
/// were created at an earlier parsing stage.
void restoreParsingState(const SlotMapping *Slots);
/// getGlobalVal - Get a value with the specified name or ID, creating a
/// forward reference record if needed. This can return null if the value
/// exists but does not have the right type.
GlobalValue *getGlobalVal(const std::string &N, Type *Ty, LocTy Loc);
GlobalValue *getGlobalVal(unsigned ID, Type *Ty, LocTy Loc);
/// Get a Comdat with the specified name, creating a forward reference
/// record if needed.
Comdat *getComdat(const std::string &Name, LocTy Loc);
// Helper Routines.
bool parseToken(lltok::Kind T, const char *ErrMsg);
bool EatIfPresent(lltok::Kind T) {
if (Lex.getKind() != T) return false;
Lex.Lex();
return true;
}
FastMathFlags EatFastMathFlagsIfPresent() {
FastMathFlags FMF;
while (true)
switch (Lex.getKind()) {
case lltok::kw_fast: FMF.setFast(); Lex.Lex(); continue;
case lltok::kw_nnan: FMF.setNoNaNs(); Lex.Lex(); continue;
case lltok::kw_ninf: FMF.setNoInfs(); Lex.Lex(); continue;
case lltok::kw_nsz: FMF.setNoSignedZeros(); Lex.Lex(); continue;
case lltok::kw_arcp: FMF.setAllowReciprocal(); Lex.Lex(); continue;
case lltok::kw_contract:
FMF.setAllowContract(true);
Lex.Lex();
continue;
case lltok::kw_reassoc: FMF.setAllowReassoc(); Lex.Lex(); continue;
case lltok::kw_afn: FMF.setApproxFunc(); Lex.Lex(); continue;
default: return FMF;
}
return FMF;
}
bool parseOptionalToken(lltok::Kind T, bool &Present,
LocTy *Loc = nullptr) {
if (Lex.getKind() != T) {
Present = false;
} else {
if (Loc)
*Loc = Lex.getLoc();
Lex.Lex();
Present = true;
}
return false;
}
bool parseStringConstant(std::string &Result);
bool parseUInt32(unsigned &Val);
bool parseUInt32(unsigned &Val, LocTy &Loc) {
Loc = Lex.getLoc();
return parseUInt32(Val);
}
bool parseUInt64(uint64_t &Val);
bool parseUInt64(uint64_t &Val, LocTy &Loc) {
Loc = Lex.getLoc();
return parseUInt64(Val);
}
bool parseFlag(unsigned &Val);
bool parseStringAttribute(AttrBuilder &B);
bool parseTLSModel(GlobalVariable::ThreadLocalMode &TLM);
bool parseOptionalThreadLocal(GlobalVariable::ThreadLocalMode &TLM);
bool parseOptionalUnnamedAddr(GlobalVariable::UnnamedAddr &UnnamedAddr);
bool parseOptionalAddrSpace(unsigned &AddrSpace, unsigned DefaultAS = 0);
bool parseOptionalProgramAddrSpace(unsigned &AddrSpace) {
return parseOptionalAddrSpace(
AddrSpace, M->getDataLayout().getProgramAddressSpace());
};
bool parseEnumAttribute(Attribute::AttrKind Attr, AttrBuilder &B,
bool InAttrGroup);
bool parseOptionalParamOrReturnAttrs(AttrBuilder &B, bool IsParam);
bool parseOptionalParamAttrs(AttrBuilder &B) {
return parseOptionalParamOrReturnAttrs(B, true);
}
bool parseOptionalReturnAttrs(AttrBuilder &B) {
return parseOptionalParamOrReturnAttrs(B, false);
}
bool parseOptionalLinkage(unsigned &Res, bool &HasLinkage,
unsigned &Visibility, unsigned &DLLStorageClass,
bool &DSOLocal);
void parseOptionalDSOLocal(bool &DSOLocal);
void parseOptionalVisibility(unsigned &Res);
void parseOptionalDLLStorageClass(unsigned &Res);
bool parseOptionalCallingConv(unsigned &CC);
bool parseOptionalAlignment(MaybeAlign &Alignment,
bool AllowParens = false);
bool parseOptionalDerefAttrBytes(lltok::Kind AttrKind, uint64_t &Bytes);
bool parseOptionalUWTableKind(UWTableKind &Kind);
bool parseAllocKind(AllocFnKind &Kind);
std::optional<MemoryEffects> parseMemoryAttr();
unsigned parseNoFPClassAttr();
bool parseScopeAndOrdering(bool IsAtomic, SyncScope::ID &SSID,
AtomicOrdering &Ordering);
bool parseScope(SyncScope::ID &SSID);
bool parseOrdering(AtomicOrdering &Ordering);
bool parseOptionalStackAlignment(unsigned &Alignment);
bool parseOptionalCommaAlign(MaybeAlign &Alignment, bool &AteExtraComma);
bool parseOptionalCommaAddrSpace(unsigned &AddrSpace, LocTy &Loc,
bool &AteExtraComma);
bool parseAllocSizeArguments(unsigned &BaseSizeArg,
std::optional<unsigned> &HowManyArg);
bool parseVScaleRangeArguments(unsigned &MinValue, unsigned &MaxValue);
bool parseIndexList(SmallVectorImpl<unsigned> &Indices,
bool &AteExtraComma);
bool parseIndexList(SmallVectorImpl<unsigned> &Indices) {
bool AteExtraComma;
if (parseIndexList(Indices, AteExtraComma))
return true;
if (AteExtraComma)
return tokError("expected index");
return false;
}
// Top-Level Entities
bool parseTopLevelEntities();
bool validateEndOfModule(bool UpgradeDebugInfo);
bool validateEndOfIndex();
bool parseTargetDefinitions(DataLayoutCallbackTy DataLayoutCallback);
bool parseTargetDefinition(std::string &TentativeDLStr, LocTy &DLStrLoc);
bool parseModuleAsm();
bool parseSourceFileName();
bool parseUnnamedType();
bool parseNamedType();
bool parseDeclare();
bool parseDefine();
bool parseGlobalType(bool &IsConstant);
bool parseUnnamedGlobal();
bool parseNamedGlobal();
bool parseGlobal(const std::string &Name, LocTy NameLoc, unsigned Linkage,
bool HasLinkage, unsigned Visibility,
unsigned DLLStorageClass, bool DSOLocal,
GlobalVariable::ThreadLocalMode TLM,
GlobalVariable::UnnamedAddr UnnamedAddr);
bool parseAliasOrIFunc(const std::string &Name, LocTy NameLoc, unsigned L,
unsigned Visibility, unsigned DLLStorageClass,
bool DSOLocal, GlobalVariable::ThreadLocalMode TLM,
GlobalVariable::UnnamedAddr UnnamedAddr);
bool parseComdat();
bool parseStandaloneMetadata();
bool parseNamedMetadata();
bool parseMDString(MDString *&Result);
bool parseMDNodeID(MDNode *&Result);
bool parseUnnamedAttrGrp();
bool parseFnAttributeValuePairs(AttrBuilder &B,
std::vector<unsigned> &FwdRefAttrGrps,
bool inAttrGrp, LocTy &BuiltinLoc);
bool parseRequiredTypeAttr(AttrBuilder &B, lltok::Kind AttrToken,
Attribute::AttrKind AttrKind);
// Module Summary Index Parsing.
bool skipModuleSummaryEntry();
bool parseSummaryEntry();
bool parseModuleEntry(unsigned ID);
bool parseModuleReference(StringRef &ModulePath);
bool parseGVReference(ValueInfo &VI, unsigned &GVId);
bool parseSummaryIndexFlags();
bool parseBlockCount();
bool parseGVEntry(unsigned ID);
bool parseFunctionSummary(std::string Name, GlobalValue::GUID, unsigned ID);
bool parseVariableSummary(std::string Name, GlobalValue::GUID, unsigned ID);
bool parseAliasSummary(std::string Name, GlobalValue::GUID, unsigned ID);
bool parseGVFlags(GlobalValueSummary::GVFlags &GVFlags);
bool parseGVarFlags(GlobalVarSummary::GVarFlags &GVarFlags);
bool parseOptionalFFlags(FunctionSummary::FFlags &FFlags);
bool parseOptionalCalls(std::vector<FunctionSummary::EdgeTy> &Calls);
bool parseHotness(CalleeInfo::HotnessType &Hotness);
bool parseOptionalTypeIdInfo(FunctionSummary::TypeIdInfo &TypeIdInfo);
bool parseTypeTests(std::vector<GlobalValue::GUID> &TypeTests);
bool parseVFuncIdList(lltok::Kind Kind,
std::vector<FunctionSummary::VFuncId> &VFuncIdList);
bool parseConstVCallList(
lltok::Kind Kind,
std::vector<FunctionSummary::ConstVCall> &ConstVCallList);
using IdToIndexMapType =
std::map<unsigned, std::vector<std::pair<unsigned, LocTy>>>;
bool parseConstVCall(FunctionSummary::ConstVCall &ConstVCall,
IdToIndexMapType &IdToIndexMap, unsigned Index);
bool parseVFuncId(FunctionSummary::VFuncId &VFuncId,
IdToIndexMapType &IdToIndexMap, unsigned Index);
bool parseOptionalVTableFuncs(VTableFuncList &VTableFuncs);
bool parseOptionalParamAccesses(
std::vector<FunctionSummary::ParamAccess> &Params);
bool parseParamNo(uint64_t &ParamNo);
using IdLocListType = std::vector<std::pair<unsigned, LocTy>>;
bool parseParamAccess(FunctionSummary::ParamAccess &Param,
IdLocListType &IdLocList);
bool parseParamAccessCall(FunctionSummary::ParamAccess::Call &Call,
IdLocListType &IdLocList);
bool parseParamAccessOffset(ConstantRange &Range);
bool parseOptionalRefs(std::vector<ValueInfo> &Refs);
bool parseTypeIdEntry(unsigned ID);
bool parseTypeIdSummary(TypeIdSummary &TIS);
bool parseTypeIdCompatibleVtableEntry(unsigned ID);
bool parseTypeTestResolution(TypeTestResolution &TTRes);
bool parseOptionalWpdResolutions(
std::map<uint64_t, WholeProgramDevirtResolution> &WPDResMap);
bool parseWpdRes(WholeProgramDevirtResolution &WPDRes);
bool parseOptionalResByArg(
std::map<std::vector<uint64_t>, WholeProgramDevirtResolution::ByArg>
&ResByArg);
bool parseArgs(std::vector<uint64_t> &Args);
void addGlobalValueToIndex(std::string Name, GlobalValue::GUID,
GlobalValue::LinkageTypes Linkage, unsigned ID,
std::unique_ptr<GlobalValueSummary> Summary);
bool parseOptionalAllocs(std::vector<AllocInfo> &Allocs);
bool parseMemProfs(std::vector<MIBInfo> &MIBs);
bool parseAllocType(uint8_t &AllocType);
bool parseOptionalCallsites(std::vector<CallsiteInfo> &Callsites);
// Type Parsing.
bool parseType(Type *&Result, const Twine &Msg, bool AllowVoid = false);
bool parseType(Type *&Result, bool AllowVoid = false) {
return parseType(Result, "expected type", AllowVoid);
}
bool parseType(Type *&Result, const Twine &Msg, LocTy &Loc,
bool AllowVoid = false) {
Loc = Lex.getLoc();
return parseType(Result, Msg, AllowVoid);
}
bool parseType(Type *&Result, LocTy &Loc, bool AllowVoid = false) {
Loc = Lex.getLoc();
return parseType(Result, AllowVoid);
}
bool parseAnonStructType(Type *&Result, bool Packed);
bool parseStructBody(SmallVectorImpl<Type *> &Body);
bool parseStructDefinition(SMLoc TypeLoc, StringRef Name,
std::pair<Type *, LocTy> &Entry,
Type *&ResultTy);
bool parseArrayVectorType(Type *&Result, bool IsVector);
bool parseFunctionType(Type *&Result);
bool parseTargetExtType(Type *&Result);
// Function Semantic Analysis.
class PerFunctionState {
LLParser &P;
Function &F;
std::map<std::string, std::pair<Value*, LocTy> > ForwardRefVals;
std::map<unsigned, std::pair<Value*, LocTy> > ForwardRefValIDs;
std::vector<Value*> NumberedVals;
/// FunctionNumber - If this is an unnamed function, this is the slot
/// number of it, otherwise it is -1.
int FunctionNumber;
public:
PerFunctionState(LLParser &p, Function &f, int functionNumber);
~PerFunctionState();
Function &getFunction() const { return F; }
bool finishFunction();
/// GetVal - Get a value with the specified name or ID, creating a
/// forward reference record if needed. This can return null if the value
/// exists but does not have the right type.
Value *getVal(const std::string &Name, Type *Ty, LocTy Loc);
Value *getVal(unsigned ID, Type *Ty, LocTy Loc);
/// setInstName - After an instruction is parsed and inserted into its
/// basic block, this installs its name.
bool setInstName(int NameID, const std::string &NameStr, LocTy NameLoc,
Instruction *Inst);
/// GetBB - Get a basic block with the specified name or ID, creating a
/// forward reference record if needed. This can return null if the value
/// is not a BasicBlock.
BasicBlock *getBB(const std::string &Name, LocTy Loc);
BasicBlock *getBB(unsigned ID, LocTy Loc);
/// DefineBB - Define the specified basic block, which is either named or
/// unnamed. If there is an error, this returns null otherwise it returns
/// the block being defined.
BasicBlock *defineBB(const std::string &Name, int NameID, LocTy Loc);
bool resolveForwardRefBlockAddresses();
};
bool convertValIDToValue(Type *Ty, ValID &ID, Value *&V,
PerFunctionState *PFS);
Value *checkValidVariableType(LocTy Loc, const Twine &Name, Type *Ty,
Value *Val);
bool parseConstantValue(Type *Ty, Constant *&C);
bool parseValue(Type *Ty, Value *&V, PerFunctionState *PFS);
bool parseValue(Type *Ty, Value *&V, PerFunctionState &PFS) {
return parseValue(Ty, V, &PFS);
}
bool parseValue(Type *Ty, Value *&V, LocTy &Loc, PerFunctionState &PFS) {
Loc = Lex.getLoc();
return parseValue(Ty, V, &PFS);
}
bool parseTypeAndValue(Value *&V, PerFunctionState *PFS);
bool parseTypeAndValue(Value *&V, PerFunctionState &PFS) {
return parseTypeAndValue(V, &PFS);
}
bool parseTypeAndValue(Value *&V, LocTy &Loc, PerFunctionState &PFS) {
Loc = Lex.getLoc();
return parseTypeAndValue(V, PFS);
}
bool parseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
PerFunctionState &PFS);
bool parseTypeAndBasicBlock(BasicBlock *&BB, PerFunctionState &PFS) {
LocTy Loc;
return parseTypeAndBasicBlock(BB, Loc, PFS);
}
struct ParamInfo {
LocTy Loc;
Value *V;
AttributeSet Attrs;
ParamInfo(LocTy loc, Value *v, AttributeSet attrs)
: Loc(loc), V(v), Attrs(attrs) {}
};
bool parseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
PerFunctionState &PFS, bool IsMustTailCall = false,
bool InVarArgsFunc = false);
bool
parseOptionalOperandBundles(SmallVectorImpl<OperandBundleDef> &BundleList,
PerFunctionState &PFS);
bool parseExceptionArgs(SmallVectorImpl<Value *> &Args,
PerFunctionState &PFS);
bool resolveFunctionType(Type *RetType,
const SmallVector<ParamInfo, 16> &ArgList,
FunctionType *&FuncTy);
// Constant Parsing.
bool parseValID(ValID &ID, PerFunctionState *PFS,
Type *ExpectedTy = nullptr);
bool parseGlobalValue(Type *Ty, Constant *&C);
bool parseGlobalTypeAndValue(Constant *&V);
bool parseGlobalValueVector(SmallVectorImpl<Constant *> &Elts,
std::optional<unsigned> *InRangeOp = nullptr);
bool parseOptionalComdat(StringRef GlobalName, Comdat *&C);
bool parseSanitizer(GlobalVariable *GV);
bool parseMetadataAsValue(Value *&V, PerFunctionState &PFS);
bool parseValueAsMetadata(Metadata *&MD, const Twine &TypeMsg,
PerFunctionState *PFS);
bool parseMetadata(Metadata *&MD, PerFunctionState *PFS);
bool parseMDTuple(MDNode *&MD, bool IsDistinct = false);
bool parseMDNode(MDNode *&N);
bool parseMDNodeTail(MDNode *&N);
bool parseMDNodeVector(SmallVectorImpl<Metadata *> &Elts);
bool parseMetadataAttachment(unsigned &Kind, MDNode *&MD);
bool parseInstructionMetadata(Instruction &Inst);
bool parseGlobalObjectMetadataAttachment(GlobalObject &GO);
bool parseOptionalFunctionMetadata(Function &F);
template <class FieldTy>
bool parseMDField(LocTy Loc, StringRef Name, FieldTy &Result);
template <class FieldTy> bool parseMDField(StringRef Name, FieldTy &Result);
template <class ParserTy> bool parseMDFieldsImplBody(ParserTy ParseField);
template <class ParserTy>
bool parseMDFieldsImpl(ParserTy ParseField, LocTy &ClosingLoc);
bool parseSpecializedMDNode(MDNode *&N, bool IsDistinct = false);
#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
bool parse##CLASS(MDNode *&Result, bool IsDistinct);
#include "llvm/IR/Metadata.def"
bool parseDIArgList(MDNode *&Result, bool IsDistinct,
PerFunctionState *PFS);
// Function Parsing.
struct ArgInfo {
LocTy Loc;
Type *Ty;
AttributeSet Attrs;
std::string Name;
ArgInfo(LocTy L, Type *ty, AttributeSet Attr, const std::string &N)
: Loc(L), Ty(ty), Attrs(Attr), Name(N) {}
};
bool parseArgumentList(SmallVectorImpl<ArgInfo> &ArgList, bool &IsVarArg);
bool parseFunctionHeader(Function *&Fn, bool IsDefine);
bool parseFunctionBody(Function &Fn);
bool parseBasicBlock(PerFunctionState &PFS);
enum TailCallType { TCT_None, TCT_Tail, TCT_MustTail };
// Instruction Parsing. Each instruction parsing routine can return with a
// normal result, an error result, or return having eaten an extra comma.
enum InstResult { InstNormal = 0, InstError = 1, InstExtraComma = 2 };
int parseInstruction(Instruction *&Inst, BasicBlock *BB,
PerFunctionState &PFS);
bool parseCmpPredicate(unsigned &P, unsigned Opc);
bool parseRet(Instruction *&Inst, BasicBlock *BB, PerFunctionState &PFS);
bool parseBr(Instruction *&Inst, PerFunctionState &PFS);
bool parseSwitch(Instruction *&Inst, PerFunctionState &PFS);
bool parseIndirectBr(Instruction *&Inst, PerFunctionState &PFS);
bool parseInvoke(Instruction *&Inst, PerFunctionState &PFS);
bool parseResume(Instruction *&Inst, PerFunctionState &PFS);
bool parseCleanupRet(Instruction *&Inst, PerFunctionState &PFS);
bool parseCatchRet(Instruction *&Inst, PerFunctionState &PFS);
bool parseCatchSwitch(Instruction *&Inst, PerFunctionState &PFS);
bool parseCatchPad(Instruction *&Inst, PerFunctionState &PFS);
bool parseCleanupPad(Instruction *&Inst, PerFunctionState &PFS);
bool parseCallBr(Instruction *&Inst, PerFunctionState &PFS);
bool parseUnaryOp(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc,
bool IsFP);
bool parseArithmetic(Instruction *&Inst, PerFunctionState &PFS,
unsigned Opc, bool IsFP);
bool parseLogical(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);
bool parseCompare(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);
bool parseCast(Instruction *&Inst, PerFunctionState &PFS, unsigned Opc);
bool parseSelect(Instruction *&Inst, PerFunctionState &PFS);
bool parseVAArg(Instruction *&Inst, PerFunctionState &PFS);
bool parseExtractElement(Instruction *&Inst, PerFunctionState &PFS);
bool parseInsertElement(Instruction *&Inst, PerFunctionState &PFS);
bool parseShuffleVector(Instruction *&Inst, PerFunctionState &PFS);
int parsePHI(Instruction *&Inst, PerFunctionState &PFS);
bool parseLandingPad(Instruction *&Inst, PerFunctionState &PFS);
bool parseCall(Instruction *&Inst, PerFunctionState &PFS,
CallInst::TailCallKind TCK);
int parseAlloc(Instruction *&Inst, PerFunctionState &PFS);
int parseLoad(Instruction *&Inst, PerFunctionState &PFS);
int parseStore(Instruction *&Inst, PerFunctionState &PFS);
int parseCmpXchg(Instruction *&Inst, PerFunctionState &PFS);
int parseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS);
int parseFence(Instruction *&Inst, PerFunctionState &PFS);
int parseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS);
int parseExtractValue(Instruction *&Inst, PerFunctionState &PFS);
int parseInsertValue(Instruction *&Inst, PerFunctionState &PFS);
bool parseFreeze(Instruction *&I, PerFunctionState &PFS);
// Use-list order directives.
bool parseUseListOrder(PerFunctionState *PFS = nullptr);
bool parseUseListOrderBB();
bool parseUseListOrderIndexes(SmallVectorImpl<unsigned> &Indexes);
bool sortUseListOrder(Value *V, ArrayRef<unsigned> Indexes, SMLoc Loc);
};
} // End llvm namespace
#endif
Reference in New Issue View Git Blame Copy Permalink