Lines Matching defs:PFS
1209 if (parseValID(ID, /*PFS=*/nullptr))
3012 PerFunctionState &PFS, bool IsMustTailCall,
3044 if (parseMetadataAsValue(V, PFS))
3048 if (parseOptionalParamAttrs(ArgAttrs) || parseValue(ArgTy, V, PFS))
3178 SmallVectorImpl<OperandBundleDef> &BundleList, PerFunctionState &PFS) {
3205 if (parseType(Ty) || parseValue(Ty, Input, PFS))
3790 /// basic correctness. PFS is used to convert function-local operands of
3792 /// converted to values). PFS can be null when we are not parsing metadata
3794 bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS, Type *ExpectedTy) {
3966 parseValID(Fn, PFS) ||
3969 parseValID(Label, PFS) ||
4013 } else if (PFS) {
4015 FwdDeclAS = PFS->getFunction().getAddressSpace();
4029 // We found the function; now find the basic block. Don't use PFS, since we
4060 if (parseValID(Fn, PFS))
4105 if (parseValID(ID, PFS))
4448 bool Parsed = parseValID(ID, /*PFS=*/nullptr, Ty) ||
5898 bool LLParser::parseDIArgList(Metadata *&MD, PerFunctionState *PFS) {
5899 assert(PFS && "Expected valid function state");
5910 if (parseValueAsMetadata(MD, "expected value-as-metadata operand", PFS))
5991 bool LLParser::parseMetadataAsValue(Value *&V, PerFunctionState &PFS) {
5994 if (parseMetadata(MD, &PFS))
6006 PerFunctionState *PFS) {
6015 if (parseValue(Ty, V, PFS))
6030 bool LLParser::parseMetadata(Metadata *&MD, PerFunctionState *PFS) {
6036 if (parseDIArgList(AL, PFS))
6052 return parseValueAsMetadata(MD, "expected metadata operand", PFS);
6083 PerFunctionState *PFS) {
6089 if (!PFS)
6091 V = PFS->getVal(ID.UIntVal, Ty, ID.Loc);
6094 if (!PFS)
6096 V = PFS->getVal(ID.StrVal, Ty, ID.Loc);
6244 if (parseValID(ID, /*PFS=*/nullptr))
6255 if (convertValIDToValue(Ty, ID, V, /*PFS=*/nullptr))
6269 bool LLParser::parseValue(Type *Ty, Value *&V, PerFunctionState *PFS) {
6272 return parseValID(ID, PFS, Ty) ||
6273 convertValIDToValue(Ty, ID, V, PFS);
6276 bool LLParser::parseTypeAndValue(Value *&V, PerFunctionState *PFS) {
6278 return parseType(Ty) || parseValue(Ty, V, PFS);
6282 PerFunctionState &PFS) {
6285 if (parseTypeAndValue(V, PFS))
6604 PerFunctionState PFS(*this, Fn, FunctionNumber, UnnamedArgNums);
6608 if (PFS.resolveForwardRefBlockAddresses())
6610 SaveAndRestore ScopeExit(BlockAddressPFS, &PFS);
6618 if (parseBasicBlock(PFS))
6622 if (parseUseListOrder(&PFS))
6629 return PFS.finishFunction();
6634 bool LLParser::parseBasicBlock(PerFunctionState &PFS) {
6647 BasicBlock *BB = PFS.defineBB(Name, NameID, NameLoc);
6673 if (parseDebugRecord(DR, PFS))
6696 switch (parseInstruction(Inst, BB, PFS)) {
6720 if (PFS.setInstName(NameID, NameStr, NameLoc, Inst))
6739 bool LLParser::parseDebugRecord(DbgRecord *&DR, PerFunctionState &PFS) {
6782 if (parseMetadata(ValLocMD, &PFS))
6813 if (parseMetadata(AddressLocation, &PFS))
6844 PerFunctionState &PFS) {
6858 return parseRet(Inst, BB, PFS);
6860 return parseBr(Inst, PFS);
6862 return parseSwitch(Inst, PFS);
6864 return parseIndirectBr(Inst, PFS);
6866 return parseInvoke(Inst, PFS);
6868 return parseResume(Inst, PFS);
6870 return parseCleanupRet(Inst, PFS);
6872 return parseCatchRet(Inst, PFS);
6874 return parseCatchSwitch(Inst, PFS);
6876 return parseCatchPad(Inst, PFS);
6878 return parseCleanupPad(Inst, PFS);
6880 return parseCallBr(Inst, PFS);
6884 int Res = parseUnaryOp(Inst, PFS, KeywordVal, /*IsFP*/ true);
6900 if (parseArithmetic(Inst, PFS, KeywordVal, /*IsFP*/ false))
6913 int Res = parseArithmetic(Inst, PFS, KeywordVal, /*IsFP*/ true);
6927 if (parseArithmetic(Inst, PFS, KeywordVal, /*IsFP*/ false))
6935 return parseArithmetic(Inst, PFS, KeywordVal,
6939 if (parseLogical(Inst, PFS, KeywordVal))
6947 return parseLogical(Inst, PFS, KeywordVal);
6949 return parseCompare(Inst, PFS, KeywordVal);
6952 int Res = parseCompare(Inst, PFS, KeywordVal);
6964 bool Res = parseCast(Inst, PFS, KeywordVal);
6976 if (parseCast(Inst, PFS, KeywordVal))
6994 return parseCast(Inst, PFS, KeywordVal);
6998 int Res = parseSelect(Inst, PFS);
7010 return parseVAArg(Inst, PFS);
7012 return parseExtractElement(Inst, PFS);
7014 return parseInsertElement(Inst, PFS);
7016 return parseShuffleVector(Inst, PFS);
7019 int Res = parsePHI(Inst, PFS);
7031 return parseLandingPad(Inst, PFS);
7033 return parseFreeze(Inst, PFS);
7036 return parseCall(Inst, PFS, CallInst::TCK_None);
7038 return parseCall(Inst, PFS, CallInst::TCK_Tail);
7040 return parseCall(Inst, PFS, CallInst::TCK_MustTail);
7042 return parseCall(Inst, PFS, CallInst::TCK_NoTail);
7045 return parseAlloc(Inst, PFS);
7047 return parseLoad(Inst, PFS);
7049 return parseStore(Inst, PFS);
7051 return parseCmpXchg(Inst, PFS);
7053 return parseAtomicRMW(Inst, PFS);
7055 return parseFence(Inst, PFS);
7057 return parseGetElementPtr(Inst, PFS);
7059 return parseExtractValue(Inst, PFS);
7061 return parseInsertValue(Inst, PFS);
7116 PerFunctionState &PFS) {
7122 Type *ResType = PFS.getFunction().getReturnType();
7134 if (parseValue(Ty, RV, PFS))
7148 bool LLParser::parseBr(Instruction *&Inst, PerFunctionState &PFS) {
7152 if (parseTypeAndValue(Op0, Loc, PFS))
7164 parseTypeAndBasicBlock(Op1, Loc, PFS) ||
7166 parseTypeAndBasicBlock(Op2, Loc2, PFS))
7178 bool LLParser::parseSwitch(Instruction *&Inst, PerFunctionState &PFS) {
7182 if (parseTypeAndValue(Cond, CondLoc, PFS) ||
7184 parseTypeAndBasicBlock(DefaultBB, BBLoc, PFS) ||
7198 if (parseTypeAndValue(Constant, CondLoc, PFS) ||
7200 parseTypeAndBasicBlock(DestBB, PFS))
7223 bool LLParser::parseIndirectBr(Instruction *&Inst, PerFunctionState &PFS) {
7226 if (parseTypeAndValue(Address, AddrLoc, PFS) ||
7239 if (parseTypeAndBasicBlock(DestBB, PFS))
7244 if (parseTypeAndBasicBlock(DestBB, PFS))
7284 bool LLParser::parseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
7301 parseValID(CalleeID, &PFS) || parseParameterList(ArgList, PFS) ||
7304 parseOptionalOperandBundles(BundleList, PFS) ||
7306 parseTypeAndBasicBlock(NormalBB, PFS) ||
7308 parseTypeAndBasicBlock(UnwindBB, PFS))
7323 Callee, &PFS))
7368 bool LLParser::parseResume(Instruction *&Inst, PerFunctionState &PFS) {
7370 if (parseTypeAndValue(Exn, ExnLoc, PFS))
7379 PerFunctionState &PFS) {
7397 if (parseMetadataAsValue(V, PFS))
7400 if (parseValue(ArgTy, V, PFS))
7412 bool LLParser::parseCleanupRet(Instruction *&Inst, PerFunctionState &PFS) {
7418 if (parseValue(Type::getTokenTy(Context), CleanupPad, PFS))
7430 if (parseTypeAndBasicBlock(UnwindBB, PFS)) {
7441 bool LLParser::parseCatchRet(Instruction *&Inst, PerFunctionState &PFS) {
7447 if (parseValue(Type::getTokenTy(Context), CatchPad, PFS))
7452 parseTypeAndBasicBlock(BB, PFS))
7461 bool LLParser::parseCatchSwitch(Instruction *&Inst, PerFunctionState &PFS) {
7471 if (parseValue(Type::getTokenTy(Context), ParentPad, PFS))
7480 if (parseTypeAndBasicBlock(DestBB, PFS))
7496 if (parseTypeAndBasicBlock(UnwindBB, PFS))
7510 bool LLParser::parseCatchPad(Instruction *&Inst, PerFunctionState &PFS) {
7519 if (parseValue(Type::getTokenTy(Context), CatchSwitch, PFS))
7523 if (parseExceptionArgs(Args, PFS))
7532 bool LLParser::parseCleanupPad(Instruction *&Inst, PerFunctionState &PFS) {
7542 if (parseValue(Type::getTokenTy(Context), ParentPad, PFS))
7546 if (parseExceptionArgs(Args, PFS))
7562 bool LLParser::parseUnaryOp(Instruction *&Inst, PerFunctionState &PFS,
7565 if (parseTypeAndValue(LHS, Loc, PFS))
7582 bool LLParser::parseCallBr(Instruction *&Inst, PerFunctionState &PFS) {
7597 parseValID(CalleeID, &PFS) || parseParameterList(ArgList, PFS) ||
7600 parseOptionalOperandBundles(BundleList, PFS) ||
7602 parseTypeAndBasicBlock(DefaultDest, PFS) ||
7611 if (parseTypeAndBasicBlock(DestBB, PFS))
7616 if (parseTypeAndBasicBlock(DestBB, PFS))
7636 if (convertValIDToValue(PointerType::getUnqual(Ty), CalleeID, Callee, &PFS))
7689 bool LLParser::parseArithmetic(Instruction *&Inst, PerFunctionState &PFS,
7692 if (parseTypeAndValue(LHS, Loc, PFS) ||
7694 parseValue(LHS->getType(), RHS, PFS))
7709 bool LLParser::parseLogical(Instruction *&Inst, PerFunctionState &PFS,
7712 if (parseTypeAndValue(LHS, Loc, PFS) ||
7714 parseValue(LHS->getType(), RHS, PFS))
7728 bool LLParser::parseCompare(Instruction *&Inst, PerFunctionState &PFS,
7734 if (parseCmpPredicate(Pred, Opc) || parseTypeAndValue(LHS, Loc, PFS) ||
7736 parseValue(LHS->getType(), RHS, PFS))
7759 bool LLParser::parseCast(Instruction *&Inst, PerFunctionState &PFS,
7764 if (parseTypeAndValue(Op, Loc, PFS) ||
7781 bool LLParser::parseSelect(Instruction *&Inst, PerFunctionState &PFS) {
7784 if (parseTypeAndValue(Op0, Loc, PFS) ||
7786 parseTypeAndValue(Op1, PFS) ||
7788 parseTypeAndValue(Op2, PFS))
7800 bool LLParser::parseVAArg(Instruction *&Inst, PerFunctionState &PFS) {
7804 if (parseTypeAndValue(Op, PFS) ||
7818 bool LLParser::parseExtractElement(Instruction *&Inst, PerFunctionState &PFS) {
7821 if (parseTypeAndValue(Op0, Loc, PFS) ||
7823 parseTypeAndValue(Op1, PFS))
7835 bool LLParser::parseInsertElement(Instruction *&Inst, PerFunctionState &PFS) {
7838 if (parseTypeAndValue(Op0, Loc, PFS) ||
7840 parseTypeAndValue(Op1, PFS) ||
7842 parseTypeAndValue(Op2, PFS))
7854 bool LLParser::parseShuffleVector(Instruction *&Inst, PerFunctionState &PFS) {
7857 if (parseTypeAndValue(Op0, Loc, PFS) ||
7859 parseTypeAndValue(Op1, PFS) ||
7861 parseTypeAndValue(Op2, PFS))
7873 int LLParser::parsePHI(Instruction *&Inst, PerFunctionState &PFS) {
7901 parseValue(Ty, Op0, PFS) ||
7903 parseValue(Type::getLabelTy(Context), Op1, PFS) ||
7923 bool LLParser::parseLandingPad(Instruction *&Inst, PerFunctionState &PFS) {
7943 if (parseTypeAndValue(V, VLoc, PFS))
7968 bool LLParser::parseFreeze(Instruction *&Inst, PerFunctionState &PFS) {
7971 if (parseTypeAndValue(Op, Loc, PFS))
7987 bool LLParser::parseCall(Instruction *&Inst, PerFunctionState &PFS,
8011 parseValID(CalleeID, &PFS) ||
8012 parseParameterList(ArgList, PFS, TCK == CallInst::TCK_MustTail,
8013 PFS.getFunction().isVarArg()) ||
8015 parseOptionalOperandBundles(BundleList, PFS))
8030 &PFS))
8101 int LLParser::parseAlloc(Instruction *&Inst, PerFunctionState &PFS) {
8131 if (parseTypeAndValue(Size, SizeLoc, PFS))
8169 int LLParser::parseLoad(Instruction *&Inst, PerFunctionState &PFS) {
8192 parseTypeAndValue(Val, Loc, PFS) ||
8219 int LLParser::parseStore(Instruction *&Inst, PerFunctionState &PFS) {
8238 if (parseTypeAndValue(Val, Loc, PFS) ||
8240 parseTypeAndValue(Ptr, PtrLoc, PFS) ||
8268 int LLParser::parseCmpXchg(Instruction *&Inst, PerFunctionState &PFS) {
8284 if (parseTypeAndValue(Ptr, PtrLoc, PFS) ||
8286 parseTypeAndValue(Cmp, CmpLoc, PFS) ||
8288 parseTypeAndValue(New, NewLoc, PFS) ||
8306 PFS.getFunction().getDataLayout().getTypeStoreSize(
8322 int LLParser::parseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS) {
8374 if (parseTypeAndValue(Ptr, PtrLoc, PFS) ||
8376 parseTypeAndValue(Val, ValLoc, PFS) ||
8412 PFS.getFunction().getDataLayout().getTypeStoreSizeInBits(
8418 PFS.getFunction().getDataLayout().getTypeStoreSize(
8430 int LLParser::parseFence(Instruction *&Inst, PerFunctionState &PFS) {
8447 int LLParser::parseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) {
8467 parseTypeAndValue(Ptr, Loc, PFS))
8488 if (parseTypeAndValue(Val, EltLoc, PFS))
8523 int LLParser::parseExtractValue(Instruction *&Inst, PerFunctionState &PFS) {
8527 if (parseTypeAndValue(Val, Loc, PFS) ||
8542 int LLParser::parseInsertValue(Instruction *&Inst, PerFunctionState &PFS) {
8546 if (parseTypeAndValue(Val0, Loc0, PFS) ||
8548 parseTypeAndValue(Val1, Loc1, PFS) ||
8669 bool LLParser::parseUseListOrder(PerFunctionState *PFS) {
8676 if (parseTypeAndValue(V, PFS) ||
8693 if (parseValID(Fn, /*PFS=*/nullptr) ||
8695 parseValID(Label, /*PFS=*/nullptr) ||