Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<FIXS>", "aarch64_cannot_force_const_mem", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "<FIXE>" ]

[ "}", "static", "bool", "<BUGS>", "aarch64_cannot_force_const_mem", "(", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "<BUGE>", "{", "rtx", "base", ",", "offset", ";" ]

[ ")", ")" ]

[ "(", "const", "(", "if_then_else", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", ")" ]

[ "}" ]

[ "water_iterator", "IP", "=", "llvm", "::", "lower_bound", "(", "WaterList", ",", "NewBB", ",", "compareMbbNumbers", ")", ";", "WaterList", ".", "insert", "(", "IP", ",", "NewBB", ")", ";" ]

[ "dst", ")", ",", "(", "MOVUPSmr", "addr", ":", "$", "dst", ",", "VR128", ":", "$", "src", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "store", "(", "v16i8", "VR128", ":", "$", "src", ")", ",", "addr", ":", "$" ]

[ "return", "BB", ";" ]

[ "unsigned", "Fs", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "Wt", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "Mips", "::", "MSA128DRegClass", ")", ";", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "SUBREG_TO_REG", ")", ",", "Wt", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "Fs", ")", ".", "addImm", "(", "Mips", "::", "sub_64", ")", ";", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "INSVE_D", ")", ",", "Wd", ")", ".", "addReg", "(", "Wd_in", ")", ".", "addImm", "(", "Lane", ")", ".", "addReg", "(", "Wt", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";" ]

[ "assert", "(", "(", "*", "StubCallAddr", ">>", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Call in stub is not indirect!", "<STR_LIT>", ")", ";" ]

[ "void", "*", "PPCCompilationCallbackC", "(", "unsigned", "*", "StubCallAddrPlus4", ",", "unsigned", "*", "OrigCallAddrPlus4", ",", "bool", "is64Bit", ")", "{", "unsigned", "*", "StubCallAddr", "=", "StubCallAddrPlus4", "-", "<NUM_LIT>", ";", "unsigned", "*", "OrigCallAddr", "=", "OrigCallAddrPlus4", "-", "<NUM_LIT>", ";", "void", "*", "Target", "=", "JITCompilerFunction", "(", "StubCallAddr", ")", ";", "unsigned", "OrigCallInst", "=", "*", "OrigCallAddr", ";", "if", "(", "(", "OrigCallInst", ">>", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "{", "intptr_t", "Offset", "=", "(", "(", "intptr_t", ")", "Target", "-", "(", "intptr_t", ")", "OrigCallAddr", ")", ">>", "<NUM_LIT>", ";", "if", "(", "Offset", ">=", "-", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "&&", "Offset", "<", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", ")", "{", "OrigCallInst", "&=", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "|", "<NUM_LIT>", ";", "OrigCallInst", "|=", "(", "Offset", "&", "(", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ")", ")", "<<", "<NUM_LIT>", ";", "*", "OrigCallAddr", "=", "OrigCallInst", ";", "}", "}", "if", "(", "(", "*", "StubCallAddr", ">>", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "StubCallAddr", "-=", "<NUM_LIT>", ";", "else", "{" ]

[ "}" ]

[ "vreinterpretq_u8_f64", "(", "float64x2_t", "_", "_", "a", ")", "{", "return", "(", "uint8x16_t", ")", "_", "_", "a", ";" ]

[ ")", ";" ]

[ "static", "reg_class_t", "ix86_preferred_output_reload_class", "(", "rtx", "x", ",", "reg_class_t", "regclass", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x" ]

[ ")", "return", "true", ";" ]

[ "bool", "HexagonSubtarget", "::", "isHVXElementType", "(", "MVT", "Ty", ",", "bool", "IncludeBool", ")", "const", "{", "if", "(", "!", "useHVXOps", "(", ")", ")", "return", "false", ";", "if", "(", "Ty", ".", "isVector", "(", ")", ")", "Ty", "=", "Ty", ".", "getVectorElementType", "(", ")", ";", "if", "(", "IncludeBool", "&&", "Ty", "==", "MVT", "::", "i1" ]

[ "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "shift", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rd", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "shift", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "shift", "{" ]

[ "const", "int", "NumElements", "=", "<NUM_LIT>", ";" ]

[ "if", "(", "Parser", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "LCurly", ")", ")", "return", "MatchOperand_NoMatch", ";", "SMLoc", "S", "=", "getLoc", "(", ")", ";", "StringRef", "Kind", ";", "int", "FirstReg", "=", "tryMatchSVEVectorRegister", "(", "Parser", ".", "getLexer", "(", ")", ".", "peekTok", "(", ")", ",", "Kind", ",", "false", ")", ";", "if", "(", "FirstReg", "==", "-", "<NUM_LIT>", ")", "return", "MatchOperand_NoMatch", ";", "Parser", ".", "Lex", "(", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "int64_t", "PrevReg", "=", "FirstReg", ";", "unsigned", "Count", "=", "<NUM_LIT>", ";", "if", "(", "Kind", ".", "empty", "(", ")", ")", "return", "MatchOperand_NoMatch", ";", "while", "(", "Parser", ".", "getTok", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "SMLoc", "Loc", "=", "getLoc", "(", ")", ";", "StringRef", "NextKind", ";", "int", "Reg", "=", "tryMatchSVEVectorRegister", "(", "Parser", ".", "getTok", "(", ")", ",", "NextKind", ",", "false", ")", ";", "if", "(", "Reg", "==", "-", "<NUM_LIT>", ")", "return", "MatchOperand_NoMatch", ";", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "Kind", "!=", "NextKind", ")", "{", "Error", "(", "Loc", ",", "<STR_LIT>", "mismatched sve register size suffix", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "if", "(", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "Reg", ")", "!=", "(", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "PrevReg", ")", "+", "<NUM_LIT>", ")", "%", "<NUM_LIT>", ")", "{", "Error", "(", "Loc", ",", "<STR_LIT>", "sve registers must be sequential", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "PrevReg", "=", "Reg", ";", "Count", "++", ";", "}", "if", "(", "Count", ">", "<NUM_LIT>", ")", "{", "Error", "(", "S", ",", "<STR_LIT>", "invalid number of sve vectors", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "RCurly", ")", ")", "{", "Error", "(", "getLoc", "(", ")", ",", "<STR_LIT>", "'}' expected", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "Parser", ".", "Lex", "(", ")", ";" ]

[ "$", "Rn", ",", "imm0_31", ":", "$", "imm", ",", "<NUM_LIT>", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "srl", "GPR32", ":", "$", "Rn", ",", "(", "i64", "imm0_31", ":", "$", "imm", ")", ")", ",", "(", "UBFMWri", "GPR32", ":" ]

[ "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "truncate", ":", "V2SI", "(", "ashiftrt", ":", "V2DI", "(", "mult", ":", "V2DI", "(", "sign_extend", ":", "V2DI", "(", "match_operand", ":", "V2SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "sign_extend", ":", "V2DI", "(", "match_operand", ":", "V2SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "SDValue", "Lo", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ValTy", ",", "CPLo", ")", ";" ]

[ "unsigned", "GOTFlag", "=", "IsN64", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "unsigned", "OFSTFlag", "=", "IsN64", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "SDValue", "CP", "=", "DAG", ".", "getTargetConstantPool", "(", "C", ",", "ValTy", ",", "N", "->", "getAlignment", "(", ")", ",", "N", "->", "getOffset", "(", ")", ",", "GOTFlag", ")", ";", "CP", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ValTy", ",", "GetGlobalReg", "(", "DAG", ",", "ValTy", ")", ",", "CP", ")", ";", "SDValue", "Load", "=", "DAG", ".", "getLoad", "(", "ValTy", ",", "dl", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "CP", ",", "MachinePointerInfo", "::", "getConstantPool", "(", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "SDValue", "CPLo", "=", "DAG", ".", "getTargetConstantPool", "(", "C", ",", "ValTy", ",", "N", "->", "getAlignment", "(", ")", ",", "N", "->", "getOffset", "(", ")", ",", "OFSTFlag", ")", ";" ]

[ "SDValue", "PtrOff", "=", "DAG", ".", "getIntPtrConstant", "(", "LocMemOffset", ",", "DL", ")", ";" ]

[ "SDValue", "M680x0TargetLowering", "::", "LowerMemOpCallTo", "(", "SDValue", "Chain", ",", "SDValue", "StackPtr", ",", "SDValue", "Arg", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "const", "CCValAssign", "&", "VA", ",", "ISD", "::", "ArgFlagsTy", "Flags", ")", "const", "{", "unsigned", "LocMemOffset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";" ]

[ "Value", "*", "nval1", "=", "B", ".", "CreateFDiv", "(", "ConstantFP", "::", "get", "(", "opr1", "->", "getType", "(", ")", ",", "<NUM_LIT>", ")", ",", "opr1", ",", "<STR_LIT>", "__div2recip", "<STR_LIT>", ")", ";" ]

[ "ConstantFP", "*", "CF1", "=", "dyn_cast", "<", "ConstantFP", ">", "(", "opr1", ")", ";", "if", "(", "(", "CF0", "&&", "CF1", ")", "||", "(", "CF1", "&&", "(", "getArgType", "(", "FInfo", ")", "==", "AMDGPULibFunc", "::", "F32", ")", ")", ")", "{" ]

[ ":" ]

[ "case", "ARM", "::", "FK_VFPV3", ":", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "FK_VFPV3_D16", ":", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "FK_VFPV4", ":", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "FK_FPV4_SP_D16", ":", "case", "ARM", "::", "FK_VFPV4_D16", ":", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "FK_FP_ARMV8", ":", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "FK_FPV5_SP_D16", ":", "case", "ARM", "::", "FK_FPV5_D16", ":", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "FK_NEON" ]

[ ")", "{" ]

[ "_", "_", "arm_vreinterpretq_u8", "(", "float32x4_t", "_", "_", "a" ]

[ ";" ]

[ "OperandMatchResultTy", "ARMAsmParser", "::", "parseInstSyncBarrierOptOperand", "(", "OperandVector", "&", "Operands", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "SMLoc", "S", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "const", "AsmToken", "&", "Tok", "=", "Parser", ".", "getTok", "(", ")", ";", "unsigned", "Opt", ";", "if", "(", "Tok", ".", "is", "(", "AsmToken", "::", "Identifier", ")", ")", "{", "StringRef", "OptStr", "=", "Tok", ".", "getString", "(", ")", ";", "if", "(", "OptStr", ".", "equals_lower", "(", "<STR_LIT>", "sy", "<STR_LIT>", ")", ")", "Opt", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "return", "MatchOperand_NoMatch", ";", "Parser", ".", "Lex", "(", ")", ";", "}", "else", "if", "(", "Tok", ".", "is", "(", "AsmToken", "::", "Hash", ")", "||", "Tok", ".", "is", "(", "AsmToken", "::", "Dollar", ")", "||", "Tok", ".", "is", "(", "AsmToken", "::", "Integer", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Integer", ")", ")", "Parser", ".", "Lex", "(", ")", ";", "SMLoc", "Loc", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "const", "MCExpr", "*", "ISBarrierID", ";", "if", "(", "getParser", "(", ")", ".", "parseExpression", "(", "ISBarrierID", ")", ")", "{", "Error", "(", "Loc", ",", "<STR_LIT>", "illegal expression", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "ISBarrierID", ")", ";", "if", "(", "!", "CE", ")", "{", "Error", "(", "Loc", ",", "<STR_LIT>", "constant expression expected", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "int", "Val", "=", "CE", "->", "getValue", "(", ")", ";", "if", "(", "Val", "&", "~", "<NUM_LIT>", ")", "{", "Error", "(", "Loc", ",", "<STR_LIT>", "immediate value out of range", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail" ]

[ "<STR_LIT>" ]

[ "(", "unspec", ":", "FMOVE64X", "[", "(", "match_operand", ":", "TF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_P8V_FMRGOW", ")", ")", "]", "<STR_LIT>" ]

[ "Base", ",", "Offset", ")", ";" ]

[ "if", "(", "selectAddrFrameIndex", "(", "Addr", ",", "Base", ",", "Offset", ")", ")", "return", "true", ";", "if", "(", "selectAddrFrameIndexOffset", "(", "Addr", ",", "Base", ",", "Offset", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "return", "true", ";", "return", "selectAddrDefault", "(", "Addr", "," ]

[ "CCNZ", "CCZ", "]", ")" ]

[ "(", "define_mode_iterator", "VAXcc", "[", "CC", "CCN", "CCNZ", "CCZ", "]", ")", "(", "define_mode_iterator", "VAXccnz", "[", "CCN" ]

[ "op0", ";" ]

[ "int", "dstreg", "=", "REGNO", "(", "dst", ")", ";", "int", "basereg", "=", "-", "<NUM_LIT>", ";", "struct", "csky_address", "op0", ";", "decompose_csky_address", "(", "XEXP", "(", "src", ",", "<NUM_LIT>", ")", ",", "&", "op0", ")", ";", "if", "(", "GET_CODE", "(", "memexp", ")", "==", "LABEL_REF", "||", "(", "GET_CODE", "(", "memexp", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "memexp", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "memexp", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "LABEL_REF", ")", ")", "return", "<STR_LIT>", "lrw\\t%0, [%1]\\n\\tlrw\\t%R0, [%R1]", "<STR_LIT>", ";", "else", "if", "(", "GET_CODE", "(", "memexp", ")", "==", "REG", ")", "basereg", "=", "REGNO", "(", "memexp", ")", ";", "else", "if", "(", "GET_CODE", "(", "memexp", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "memexp", ",", "<NUM_LIT>", ")", ")", "==", "REG", ")", "basereg", "=", "REGNO", "(", "XEXP", "(", "memexp", ",", "<NUM_LIT>", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "memexp", ",", "<NUM_LIT>", ")", ")", "==", "REG", ")", "basereg", "=", "REGNO", "(", "XEXP", "(", "memexp", ",", "<NUM_LIT>", ")", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "dstreg", "==", "basereg", ")", "return", "<STR_LIT>", "ld.w\\t%R0, %R1\\n\\tld.w\\t%0, %1", "<STR_LIT>", ";", "else", "return", "<STR_LIT>", "ld.w\\t%0, %1\\n\\tld.w\\t%R0, %R1", "<STR_LIT>", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", "||", "GET_CODE", "(", "src", ")", "==", "CONST_DOUBLE", ")", "{", "split_double", "(", "src", ",", "operands", "+", "<NUM_LIT>", ",", "operands", "+", "<NUM_LIT>", ")", ";", "if", "(", "REGNO", "(", "dst", ")", "<=", "<NUM_LIT>", "&&", "CSKY_CONST_OK_FOR_N", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "+", "<NUM_LIT>", ")", ")", "output_asm_insn", "(", "<STR_LIT>", "movi\\t%0, %2", "<STR_LIT>", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "<STR_LIT>", "lrw\\t%0, %2", "<STR_LIT>", ",", "operands", ")", ";", "if", "(", "REGNO", "(", "dst", ")", "<=", "<NUM_LIT>", "&&", "CSKY_CONST_OK_FOR_N", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "+", "<NUM_LIT>", ")", ")", "output_asm_insn", "(", "<STR_LIT>", "movi\\t%R0, %3", "<STR_LIT>", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "<STR_LIT>", "lrw\\t%R0, %3", "<STR_LIT>", ",", "operands", ")", ";", "return", "<STR_LIT>", "<STR_LIT>", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "dst", ")", "==", "MEM", "&&", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "rtx", "memexp", "=", "XEXP", "(", "dst", ",", "<NUM_LIT>", ")", ";", "int", "srcreg", "=", "REGNO", "(", "src", ")", ";", "int", "basereg", "=", "-", "<NUM_LIT>", ";", "struct", "csky_address" ]

[ "(", ")", ",", "TF", "|", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ "MachineInstr", "*", "NewMI", "=", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "NewLdOpc", ")", ",", "DstReg", ")", ".", "addOperand", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", ";", "NewMI", "->", "setMemRefs", "(", "MI", ".", "memoperands_begin", "(", ")", ",", "MI", ".", "memoperands_end", "(", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "ARM", "::", "tPICADD", ")", ")", ".", "addReg", "(", "DstReg", ",", "getDefRegState", "(", "true", ")", ")", ".", "addReg", "(", "DstReg", ")", ".", "addOperand", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "MI", ".", "eraseFromParent", "(", ")", ";", "Modified", "=", "true", ";", "break", ";", "}", "case", "ARM", "::", "t2MOVi32imm", ":", "{", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isDead", "(", ")", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "MachineInstrBuilder", "LO16", ",", "HI16", ";", "LO16", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "ARM", "::", "t2MOVi16", ")", ",", "DstReg", ")", ";", "HI16", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "ARM", "::", "t2MOVTi16", ")", ")", ".", "addReg", "(", "DstReg", ",", "getDefRegState", "(", "true", ")", ")", ".", "addReg", "(", "DstReg", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "unsigned", "Imm", "=", "MO", ".", "getImm", "(", ")", ";", "unsigned", "Lo16", "=", "Imm", "&", "<NUM_LIT>", ";", "unsigned", "Hi16", "=", "(", "Imm", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ";", "LO16", "=", "LO16", ".", "addImm", "(", "Lo16", ")", ";", "HI16", "=", "HI16", ".", "addImm", "(", "Hi16", ")", ";", "}", "else", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "unsigned", "TF", "=", "MO", ".", "getTargetFlags", "(", ")", ";", "LO16", "=", "LO16", ".", "addGlobalAddress", "(", "GV", ",", "MO", ".", "getOffset" ]

[ ")", "(", "V2DF", "<STR_LIT>", ")", "]", ")" ]

[ "(", "V16SF", "<STR_LIT>", ")", "(", "V8SF", "<STR_LIT>", ")", "(", "V4SF", "<STR_LIT>", ")", "(", "V8DF", "<STR_LIT>", ")", "(", "V4DF", "<STR_LIT>" ]

[ "}" ]

[ "alpha_align_insns", "(", ")", ";", "return", "<NUM_LIT>", ";" ]

[ "unsigned", "AGCMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "if", "(", "MO", ".", "isExpr", "(", ")", "&&", "MO", ".", "getExpr", "(", ")", "->", "getKind", "(", ")", "==", "MCExpr", "::", "SymbolRef", ")", "return", "<NUM_LIT>", ";", "llvm_unreachable", "(", "<STR_LIT>", "Unhandled expression!", "<STR_LIT>", ")", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "_", "U", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "mmask16", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_cmp_ps_mask", "(", "_", "_", "mmask16", "_", "_", "U", ",", "_", "_", "m512", "_", "_", "X", ",", "_", "_", "m512", "_", "_", "Y", ",", "const", "int", "_", "_", "P", ")", "{", "return", "(", "_", "_", "mmask16", ")", "_", "_", "builtin_ia32_cmpps512_mask", "(", "(", "_", "_", "v16sf", ")", "_", "_", "X", ",", "(", "_", "_", "v16sf", ")", "_", "_", "Y", ",", "_", "_", "P", ",", "(", "_", "_", "mmask16", ")", "_" ]

[ "}" ]

[ "VALUNum", "=", "<NUM_LIT>", ";", "break", ";", "case", "TRANS", ":", "TRANSCycles", "=", "Cycles", ";", "TRANSNum", "=", "<NUM_LIT>", ";", "TRANSNumVALU", "=", "<NUM_LIT>", ";", "break", ";", "case", "SALU", ":", "SALUCycles", "=", "std", "::", "min", "(", "Cycles", ",", "SALU_CYCLES_MAX", ")", ";", "break", ";" ]

[ "<FIXS>", "parse_field", "(", "const", "std", "::", "string", "&", "field", ")", "<FIXE>", "<FIXS>", "const", "char", "*", "rest", "=", "strchr", "(", "field", ".", "c_str", "(", ")", ",", "'", ":", "'", ")", ";", "if", "(", "rest", "==", "NULL", ")", "return", "-", "<NUM_LIT>", ";", "<FIXE>" ]

[ "static", "unsigned", "<BUGS>", "parse_field", "(", "const", "char", "*", "field", ")", "<BUGE>", "{", "<BUGS>", "const", "char", "*", "rest", "=", "strchr", "(", "field", ",", "'", ":", "'", ")", ";", "<BUGE>", "char", "*", "after", ";", "unsigned", "fint", "=", "strtol", "(", "rest", "+", "<NUM_LIT>", ",", "&", "after", ",", "<NUM_LIT>", ")", ";", "if", "(", "after", "==", "rest", "+", "<NUM_LIT>", ")" ]

[ "}" ]

[ "def", "VecListThreeDAllLanes", ":", "RegisterOperand", "<", "DPR", ",", "<STR_LIT>", ">", "{", "let", "ParserMatchClass", "=", "VecListThreeDAllLanesAsmOperand", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "def", "Wri", ":", "BaseBitfieldImm", "<", "opc", ",", "GPR32", ",", "imm0_31", ",", "asm", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "if", "(", "MachineLoop", "*", "Loop", "=", "MLI", ".", "getLoopFor", "(", "&", "MBB", ")", ")", "if", "(", "Loop", "->", "getHeader", "(", ")", "==", "&", "MBB", ")", "{", "MachineBasicBlock", "*", "Bottom", "=", "Loop", "->", "getBottomBlock", "(", ")", ";", "auto", "Iter", "=", "next", "(", "MachineFunction", "::", "iterator", "(", "Bottom", ")", ")", ";", "if", "(", "Iter", "==", "MF", ".", "end", "(", ")", ")", "{", "MF", ".", "push_back", "(", "MF", ".", "CreateMachineBasicBlock", "(", ")", ")", ";", "Iter", "=", "next", "(", "MachineFunction", "::", "iterator", "(", "Bottom", ")", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MBB", ".", "begin", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", ".", "get", "(", "WebAssembly", "::", "LOOP", ")", ")", ".", "addMBB", "(", "Iter", ")", ";", "}", "for", "(", "auto", "&", "Term", ":", "MBB", ".", "terminators", "(", ")", ")", "for", "(", "auto", "&", "MO", ":", "Term", ".", "operands", "(", ")", ")", "if", "(", "MO", ".", "isMBB", "(", ")", ")", "PlaceBlockMarkers", "(", "MBB", ",", "*", "MO", ".", "getMBB", "(", ")", ",", "MF", ",", "MLI", ",", "TII", ")", ";" ]

[ "<FIXS>", "SDValue", "&", "Disp", ",", "SDValue", "&", "Segment", ")", "{", "<FIXE>" ]

[ "bool", "X86DAGToDAGISel", "::", "SelectTLSADDRAddr", "(", "SDNode", "*", "Op", ",", "SDValue", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Scale", ",", "SDValue", "&", "Index", ",", "<BUGS>", "SDValue", "&", "Disp", ")", "{", "<BUGE>", "assert", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "TargetGlobalTLSAddress", ")", ";", "const", "GlobalAddressSDNode", "*", "GA", "=", "cast", "GlobalAddressSDNode", ">", "(", "N", ")", ";" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "let", "Switches", "=", "{", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "<NUM_LIT>", "}", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "OutOfSlotData", "=", "<NUM_LIT>", ";", "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ "AsmTransCBE", "=", "x86_asm_table", ";" ]

[ "X86MCAsmInfoCOFF", "::", "X86MCAsmInfoCOFF", "(", "const", "Triple", "&", "Triple", ")", "{", "if", "(", "Triple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", "{", "GlobalPrefix", "=", "<STR_LIT>", "<STR_LIT>", ";", "PrivateGlobalPrefix", "=", "<STR_LIT>", ".L", "<STR_LIT>", ";", "}" ]

[ "[", "<NUM_LIT>", "]", ")" ]

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<STR_LIT>", "{", "rtx", "addr", ",", "aligned_addr", ",", "aligned_mem", ",", "offset", ",", "word", ",", "shmt", ",", "tmp", "rtx", "result", "=", "operands", "[", "<NUM_LIT>", "]", "rtx", "mem", "=", "operands", "[", "<NUM_LIT>", "]", "enum", "memmodel", "model", "=", "(", "enum", "memmodel", ")", "INTVAL", "(", "operands" ]

[ "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "if", "(", "OtherUses", ")", "{" ]

[ "unsigned", "AS", "=", "SN", "->", "getAddressSpace", "(", ")", ";", "if", "(", "!", "allowsMisalignedMemoryAccesses", "(", "VT", ",", "AS", ",", "Alignment", ",", "SN", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ",", "&", "IsFast", ")", ")", "{", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "SplitVectorStore", "(", "SDValue", "(", "SN", ",", "<NUM_LIT>", ")", ",", "DAG", ")", ";", "return", "expandUnalignedStore", "(", "SN", ",", "DAG", ")", ";", "}", "if", "(", "!", "IsFast", ")", "return", "SDValue", "(", ")", ";", "}", "if", "(", "!", "shouldCombineMemoryType", "(", "VT", ")", ")", "return", "SDValue", "(", ")", ";", "EVT", "NewVT", "=", "getEquivalentMemType", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "VT", ")", ";", "SDValue", "Val", "=", "SN", "->", "getValue", "(", ")", ";", "bool", "OtherUses", "=", "!", "Val", ".", "hasOneUse", "(", ")", ";", "SDValue", "CastVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "SL", ",", "NewVT", ",", "Val", ")", ";" ]

[ "SDValue", "ExtLoad", "=", "DAG", ".", "getNode", "(", "NewOpc", ",", "SDLoc", "(", "N", ")", ",", "VTs", ",", "Ops", ")", ";" ]

[ "if", "(", "(", "SignExtSrcVT", "!=", "GLD1SrcMemVT", ")", "||", "!", "Src", ".", "hasOneUse", "(", ")", ")", "return", "SDValue", "(", ")", ";", "EVT", "DstVT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "DstVT", ",", "MVT", "::", "Other", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Src", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Src", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Src", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Src", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Src", "->", "getOperand", "(", "<NUM_LIT>", ")", "}", ";" ]

[ "}" ]

[ "SDValue", "S", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", "ull", "<<", "i", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "Rs", "[", "i", "]", "=", "DAG", ".", "getSelect", "(", "dl", ",", "MVT", "::", "i32", ",", "Ops", "[", "i", "/", "Rep", "]", ",", "S", ",", "Z", ")", ";", "}", "for", "(", "ArrayRef", "<", "SDValue", ">", "A", "(", "Rs", ")", ";", "A", ".", "size", "(", ")", "!=", "<NUM_LIT>", ";", "A", "=", "A", ".", "drop_back", "(", "A", ".", "size", "(", ")", "/", "<NUM_LIT>", ")", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "A", ".", "size", "(", ")", "/", "<NUM_LIT>", ";", "i", "!=", "e", ";", "++", "i", ")", "Rs", "[", "i", "]", "=", "DAG", ".", "getNode", "(", "ISD", "::", "OR", ",", "dl", ",", "MVT", "::", "i32", ",", "Rs", "[", "<NUM_LIT>", "*", "i", "]", ",", "Rs", "[", "<NUM_LIT>", "*", "i", "+", "<NUM_LIT>", "]", ")", ";", "}", "return", "getInstr", "(", "Hexagon", "::", "C2_tfrrp", ",", "dl", ",", "VecTy", ",", "{", "Rs", "[", "<NUM_LIT>", "]", "}", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";" ]

[ "<FIXS>", "void", "PPC32ISel", "::", "visitSelectInst", "(", "SelectInst", "&", "SI", ")", "{", "<FIXE>" ]

[ ".", "addMBB", "(", "copy0MBB", ")", ".", "addReg", "(", "TrueValue", ")", ".", "addMBB", "(", "thisMBB", ")", ";", "}", "<BUGS>", "void", "ISel", "::", "visitSelectInst", "(", "SelectInst", "&", "SI", ")", "{", "<BUGE>", "unsigned", "DestReg", "=", "getReg", "(", "SI", ")", ";", "MachineBasicBlock", "::", "iterator", "MII", "=", "BB", "->", "end", "(", ")", ";", "emitSelectOperation", "(", "BB", ",", "MII", ",", "SI", ".", "getCondition", "(", ")", ",", "SI", ".", "getTrueValue", "(", ")", "," ]

[ ")", "_", "_", "W", ",", "(", "_", "_", "mmask32", ")", "_", "_", "U", ")", ";" ]

[ "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_movdquhi512_mask", "(", "(", "_", "_", "v32hi", ")", "_", "_", "A", ",", "(", "_", "_", "v32hi" ]

[ "if", "(", "Arg", ".", "hasNonNullAttr", "(", ")", ")", "Load", "->", "setMetadata", "(", "LLVMContext", "::", "MD_nonnull", ",", "MDNode", "::", "get", "(", "Ctx", ",", "{", "}", ")", ")", ";" ]

[ "bool", "AMDGPULowerKernelArguments", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "CallingConv", "::", "ID", "CC", "=", "F", ".", "getCallingConv", "(", ")", ";", "if", "(", "CC", "!=", "CallingConv", "::", "AMDGPU_KERNEL", "||", "F", ".", "arg_empty", "(", ")", ")", "return", "false", ";", "auto", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "const", "TargetMachine", "&", "TM", "=", "TPC", ".", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "TM", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", "F", ")", ";", "LLVMContext", "&", "Ctx", "=", "F", ".", "getParent", "(", ")", "->", "getContext", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "BasicBlock", "&", "EntryBlock", "=", "*", "F", ".", "begin", "(", ")", ";", "IRBuilder", "<", ">", "Builder", "(", "&", "*", "getInsertPt", "(", "EntryBlock", ")", ")", ";", "const", "Align", "KernArgBaseAlign", "(", "<NUM_LIT>", ")", ";", "const", "uint64_t", "BaseOffset", "=", "ST", ".", "getExplicitKernelArgOffset", "(", "F", ")", ";", "Align", "MaxAlign", ";", "const", "uint64_t", "TotalKernArgSize", "=", "ST", ".", "getKernArgSegmentSize", "(", "F", ",", "MaxAlign", ")", ";", "if", "(", "TotalKernArgSize", "==", "<NUM_LIT>", ")", "return", "false", ";", "CallInst", "*", "KernArgSegment", "=", "Builder", ".", "CreateIntrinsic", "(", "Intrinsic", "::", "amdgcn_kernarg_segment_ptr", ",", "{", "}", ",", "{", "}", ",", "nullptr", ",", "F", ".", "getName", "(", ")", "+", "<STR_LIT>", ".kernarg.segment", "<STR_LIT>", ")", ";", "KernArgSegment", "->", "addAttribute", "(", "AttributeList", "::", "ReturnIndex", ",", "Attribute", "::", "NonNull", ")", ";", "KernArgSegment", "->", "addAttribute", "(", "AttributeList", "::", "ReturnIndex", ",", "Attribute", "::", "getWithDereferenceableBytes", "(", "Ctx", ",", "TotalKernArgSize", ")", ")", ";", "unsigned", "AS", "=", "KernArgSegment", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "uint64_t", "ExplicitArgOffset", "=", "<NUM_LIT>", ";", "for", "(", "Argument", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "Type", "*", "ArgTy", "=", "Arg", ".", "getType", "(", ")", ";", "unsigned", "ABITypeAlign", "=", "DL", ".", "getABITypeAlignment", "(", "ArgTy", ")", ";", "unsigned", "Size", "=", "DL", ".", "getTypeSizeInBits", "(", "ArgTy", ")", ";", "unsigned", "AllocSize", "=", "DL", ".", "getTypeAllocSize", "(", "ArgTy", ")", ";", "uint64_t", "EltOffset", "=", "alignTo", "(", "ExplicitArgOffset", ",", "ABITypeAlign", ")", "+", "BaseOffset", ";", "ExplicitArgOffset", "=", "alignTo", "(", "ExplicitArgOffset", ",", "ABITypeAlign", ")", "+", "AllocSize", ";", "if", "(", "Arg", ".", "use_empty", "(", ")", ")", "continue", ";", "if", "(", "PointerType", "*", "PT", "=", "dyn_cast", "<", "PointerType", ">", "(", "ArgTy", ")", ")", "{", "if", "(", "(", "PT", "->", "getAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", "||", "PT", "->", "getAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "REGION_ADDRESS", ")", "&&", "!", "ST", ".", "hasUsableDSOffset", "(", ")", ")", "continue", ";", "if", "(", "Arg", ".", "hasNoAliasAttr", "(", ")", ")", "continue", ";", "}", "auto", "*", "VT", "=", "dyn_cast", "<", "FixedVectorType", ">", "(", "ArgTy", ")", ";", "bool", "IsV3", "=", "VT", "&&", "VT", "->", "getNumElements", "(", ")", "==", "<NUM_LIT>", ";", "bool", "DoShiftOpt", "=", "Size", "<", "<NUM_LIT>", "&&", "!", "ArgTy", "->", "isAggregateType", "(", ")", ";", "VectorType", "*", "V4Ty", "=", "nullptr", ";", "int64_t", "AlignDownOffset", "=", "alignDown", "(", "EltOffset", ",", "<NUM_LIT>", ")", ";", "int64_t", "OffsetDiff", "=", "EltOffset", "-", "AlignDownOffset", ";", "Align", "AdjustedAlign", "=", "commonAlignment", "(", "KernArgBaseAlign", ",", "DoShiftOpt", "?", "AlignDownOffset", ":", "EltOffset", ")", ";", "Value", "*", "ArgPtr", ";", "Type", "*", "AdjustedArgTy", ";", "if", "(", "DoShiftOpt", ")", "{", "ArgPtr", "=", "Builder", ".", "CreateConstInBoundsGEP1_64", "(", "Builder", ".", "getInt8Ty", "(", ")", ",", "KernArgSegment", ",", "AlignDownOffset", ",", "Arg", ".", "getName", "(", ")", "+", "<STR_LIT>", ".kernarg.offset.align.down", "<STR_LIT>", ")", ";", "AdjustedArgTy", "=", "Builder", ".", "getInt32Ty", "(", ")", ";", "}", "else", "{", "ArgPtr", "=", "Builder", ".", "CreateConstInBoundsGEP1_64", "(", "Builder", ".", "getInt8Ty", "(", ")", ",", "KernArgSegment", ",", "EltOffset", ",", "Arg", ".", "getName", "(", ")", "+", "<STR_LIT>", ".kernarg.offset", "<STR_LIT>", ")", ";", "AdjustedArgTy", "=", "ArgTy", ";", "}", "if", "(", "IsV3", "&&", "Size", ">=", "<NUM_LIT>", ")", "{", "V4Ty", "=", "VectorType", "::", "get", "(", "VT", "->", "getElementType", "(", ")", ",", "<NUM_LIT>", ")", ";", "AdjustedArgTy", "=", "V4Ty", ";", "}", "ArgPtr", "=", "Builder", ".", "CreateBitCast", "(", "ArgPtr", ",", "AdjustedArgTy", "->", "getPointerTo", "(", "AS", ")", ",", "ArgPtr", "->", "getName", "(", ")", "+", "<STR_LIT>", ".cast", "<STR_LIT>", ")", ";", "LoadInst", "*", "Load", "=", "Builder", ".", "CreateAlignedLoad", "(", "AdjustedArgTy", ",", "ArgPtr", ",", "AdjustedAlign", ")", ";", "Load", "->", "setMetadata", "(", "LLVMContext", "::", "MD_invariant_load", ",", "MDNode", "::", "get", "(", "Ctx", ",", "{", "}", ")", ")", ";", "MDBuilder", "MDB", "(", "Ctx", ")", ";", "if", "(", "isa", "<", "PointerType", ">", "(", "ArgTy", ")", ")", "{" ]

[ "if", "(", "QII", ".", "isHVXVec", "(", "SrcInst", ")", "||", "useBSBScheduling", "(", ")", ")", "Dep", ".", "setLatency", "(", "(", "Dep", ".", "getLatency", "(", ")", "+", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ")", ";" ]

[ "if", "(", "!", "hasV60Ops", "(", ")", ")", "return", ";", "auto", "&", "QII", "=", "static_cast", "<", "const", "HexagonInstrInfo", "&", ">", "(", "*", "getInstrInfo", "(", ")", ")", ";" ]

[ "bool", "Thumb1FrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "CFSize", "=", "MFI", ".", "getMaxCallFrameSize", "(", ")", ";", "if", "(", "CFSize", ">=", "(", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ")", "*", "<NUM_LIT>", "/", "<NUM_LIT>", ")", "return", "false", ";", "return", "!", "MFI", ".", "hasVarSizedObjects", "(", ")", ";", "}" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "<STR_LIT>", ":" ]

[ "switch", "(", "Ty", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "i32", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "i64", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "f32", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "f64", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "v128", "<STR_LIT>", ";", "case", "<STR_LIT>", "::" ]

[ "void", "AArch64CallLowering", "::", "splitToValueTypes", "(", "const", "ArgInfo", "&", "OrigArg", ",", "SmallVectorImpl", "<", "ArgInfo", ">", "&", "SplitArgs", ",", "const", "DataLayout", "&", "DL", ",", "MachineRegisterInfo", "&", "MRI", ",", "const", "SplitArgTy", "&", "PerformArgSplit", ")", "const", "{", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "OrigArg", ".", "Ty", "->", "getContext", "(", ")", ";", "SmallVector", "<", "EVT", ",", "<NUM_LIT>", ">", "SplitVTs", ";", "SmallVector", "<", "uint64_t", ",", "<NUM_LIT>", ">", "Offsets", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "OrigArg", ".", "Ty", ",", "SplitVTs", ",", "&", "Offsets", ",", "<NUM_LIT>", ")", ";", "if", "(", "SplitVTs", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "{", "SplitArgs", ".", "emplace_back", "(", "OrigArg", ".", "Reg", ",", "SplitVTs", "[", "<NUM_LIT>", "]", ".", "getTypeForEVT", "(", "Ctx", ")", ",", "OrigArg", ".", "Flags", ",", "OrigArg", ".", "IsFixed", ")", ";", "return", ";", "}", "unsigned", "FirstRegIdx", "=", "SplitArgs", ".", "size", "(", ")", ";", "for", "(", "auto", "SplitVT", ":", "SplitVTs", ")", "{", "Type", "*", "SplitTy", "=", "SplitVT", ".", "getTypeForEVT", "(", "Ctx", ")", ";", "SplitArgs", ".", "push_back", "(", "ArgInfo", "{", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "{", "*", "SplitTy", ",", "DL", "}", ")", ",", "SplitTy", ",", "OrigArg", ".", "Flags", ",", "OrigArg", ".", "IsFixed", "}", ")", ";", "}", "SmallVector", "<", "uint64_t", ",", "<NUM_LIT>", ">", "BitOffsets", ";", "for", "(", "auto", "Offset", ":", "Offsets", ")", "BitOffsets", ".", "push_back", "(", "Offset", "*", "<NUM_LIT>", ")", ";", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "SplitRegs", ";", "for", "(", "auto", "I", "=", "&", "SplitArgs", "[", "FirstRegIdx", "]", ";", "I", "!=", "SplitArgs", ".", "end", "(", ")", ";", "++", "I", ")", "SplitRegs", ".", "push_back", "(", "I", "->", "Reg", ")", ";", "PerformArgSplit", "(", "SplitRegs", ",", "BitOffsets", ")", ";", "}" ]

[ "Break", "OrigArgInfo", "into", "one", "or", "more", "pieces", "the", "calling", "convention", "can", "process", ",", "returned", "in", "SplitArgs", "." ]

[ "return", "phiLoad", ";" ]

[ "static", "PHINode", "*", "insetPhiInst", "(", "Instruction", "*", "first", ",", "Instruction", "*", "second", ",", "BasicBlock", "*", "firstBB", ",", "BasicBlock", "*", "secondBB", ",", "IRBuilder", "<", ">", "builder", ",", "Type", "*", "ptrType", ",", "int", "number", ",", "Instruction", "*", "after", ")", "{", "PHINode", "*", "phiLoad", "=", "builder", ".", "CreatePHI", "(", "VectorType", "::", "get", "(", "ptrType", ",", "number", ")", ",", "<NUM_LIT>", ")", ";", "phiLoad", "->", "addIncoming", "(", "first", ",", "firstBB", ")", ";", "phiLoad", "->", "addIncoming", "(", "second", ",", "secondBB", ")", ";", "phiLoad", "->", "moveAfter", "(", "after", ")", ";" ]

[ ")", ";" ]

[ "case", "'", "Q", "'", ":", "return", "InlineAsm", "::", "ConstraintCode", "::", "Q", ";", "}", "return", "TargetLowering", "::", "getInlineAsmMemConstraint", "(", "ConstraintCode" ]

[ "(", "match_operand", ":", "V2SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "V2SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "fma", ":", "V2SF", "(", "neg", ":", "V2SF", "(", "match_operand", ":", "V2SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isPredicable", "=", "<NUM_LIT>", ";", "let", "isAdd", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ "if", "(", "Features", "[", "KV", ".", "Value", "]", ")", "Ret", "+=", "(", "StringRef", "(", "<STR_LIT>", "+", "<STR_LIT>", ")", "+", "KV", ".", "Key", "+", "<STR_LIT>", ",", "<STR_LIT>", ")", ".", "str", "(", ")", ";" ]

[ "std", "::", "string", "getFeatureString", "(", "const", "FeatureBitset", "&", "Features", ")", "{", "std", "::", "string", "Ret", ";", "for", "(", "const", "SubtargetFeatureKV", "&", "KV", ":", "WebAssemblyFeatureKV", ")", "{" ]

[ "JTBB", "->", "removeSuccessor", "(", "BB", ")", ";" ]

[ "++", "NumJTMoved", ";", "return", "NULL", ";", "}", "MachineBasicBlock", "*", "NewBB", "=", "MF", "->", "CreateMachineBasicBlock", "(", "JTBB", "->", "getBasicBlock", "(", ")", ")", ";", "MachineFunction", "::", "iterator", "MBBI", "=", "JTBB", ";", "++", "MBBI", ";", "MF", "->", "insert", "(", "MBBI", ",", "NewBB", ")", ";", "assert", "(", "isThumb2", "&&", "<STR_LIT>", "Adjusting for TB[BH] but not in Thumb2?", "<STR_LIT>", ")", ";", "BuildMI", "(", "NewBB", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "ARM", "::", "t2B", ")", ")", ".", "addMBB", "(", "BB", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "MF", "->", "RenumberBlocks", "(", "NewBB", ")", ";", "NewBB", "->", "addSuccessor", "(", "BB", ")", ";" ]

[ "static", "bool", "aarch_macro_fusion_pair_p", "(", "rtx_insn", "*", "prev", ",", "rtx_insn", "*", "curr", ")", "{", "rtx", "set_dest", ";", "rtx", "prev_set", "=", "single_set", "(", "prev", ")", ";", "rtx", "curr_set", "=", "single_set", "(", "curr", ")", ";", "if", "(", "!", "prev_set", "||", "!", "curr_set", ")", "return", "false", ";", "if", "(", "any_condjump_p", "(", "curr", ")", ")", "return", "false", ";", "if", "(", "!", "arm_macro_fusion_p", "(", ")", ")", "return", "false", ";", "if", "(", "current_tune", "->", "fusible_ops", "&", "tune_params", "::", "FUSE_AES_AESMC", "&&", "aarch_crypto_can_dual_issue", "(", "prev", ",", "curr", ")", ")", "return", "true", ";", "if", "(", "current_tune", "->", "fusible_ops", "&", "tune_params", "::", "FUSE_MOVW_MOVT", ")", "{", "set_dest", "=", "SET_DEST", "(", "curr_set", ")", ";", "if", "(", "GET_MODE", "(", "set_dest", ")", "!=", "SImode", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "set_dest", ")", "==", "ZERO_EXTRACT", ")", "{", "if", "(", "CONST_INT_P", "(", "SET_SRC", "(", "curr_set", ")", ")", "&&", "CONST_INT_P", "(", "SET_SRC", "(", "prev_set", ")", ")", "&&", "REG_P", "(", "XEXP", "(", "set_dest", ",", "<NUM_LIT>", ")", ")", "&&", "REG_P", "(", "SET_DEST", "(", "prev_set", ")", ")", "&&", "REGNO", "(", "XEXP", "(", "set_dest", ",", "<NUM_LIT>", ")", ")", "==", "REGNO", "(", "SET_DEST", "(", "prev_set", ")", ")", ")", "return", "true", ";", "}", "else", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "curr_set", ")", ")", "==", "LO_SUM", "&&", "REG_P", "(", "SET_DEST", "(", "curr_set", ")", ")", "&&", "REG_P", "(", "SET_DEST", "(", "prev_set", ")", ")", "&&", "GET_CODE", "(", "SET_SRC", "(", "prev_set", ")", ")", "==", "HIGH", "&&", "REGNO", "(", "SET_DEST", "(", "curr_set", ")", ")", "==", "REGNO", "(", "SET_DEST", "(", "prev_set", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Implement", "TARGET_SCHED_MACRO_FUSION_PAIR_P", ".", "Return", "true", "if", "PREV", "and", "CURR", "should", "be", "kept", "together", "during", "scheduling", "." ]

[ "T", ",", "createPPCMCInstPrinter", ")", ";" ]

[ "TargetRegistry", "::", "RegisterMCSubtargetInfo", "(", "*", "T", ",", "createPPCMCSubtargetInfo", ")", ";", "TargetRegistry", "::", "RegisterMCCodeEmitter", "(", "*", "T", ",", "createPPCMCCodeEmitter", ")", ";", "TargetRegistry", "::", "RegisterMCAsmBackend", "(", "*", "T", ",", "createPPCAsmBackend", ")", ";", "TargetRegistry", "::", "RegisterELFStreamer", "(", "*", "T", ",", "createPPCMCStreamer", ")", ";", "TargetRegistry", "::", "RegisterObjectTargetStreamer", "(", "*", "T", ",", "createObjectTargetStreamer", ")", ";", "TargetRegistry", "::", "RegisterAsmTargetStreamer", "(", "*", "T", ",", "createAsmTargetStreamer", ")", ";", "TargetRegistry", "::", "RegisterMCInstPrinter", "(", "*" ]

[ "getValueType", "(", ")", ",", "Op0", ")", ";" ]

[ "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SIGN_EXTEND_INREG", ")", "return", "Op0", ";", "Op0", "=", "LoadOperand", "(", "DAG", ",", "DL", ",", "Op0", ".", "getValueType", "(", ")", ",", "Op0", ")", ";", "SDValue", "Extend", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "Op", "." ]

[ "return", "createLoongArchMCSubtargetInfoImpl", "(", "TT", ",", "CPU", ",", "CPU", ",", "FS", ")", ";" ]

[ "static", "MCSubtargetInfo", "*", "createLoongArchMCSubtargetInfo", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "if", "(", "CPU", ".", "empty", "(", ")", ")", "CPU", "=", "TT", ".", "isArch64Bit", "(", ")", "?", "<STR_LIT>", "la464", "<STR_LIT>", ":", "<STR_LIT>", "generic-la32", "<STR_LIT>", ";" ]

[ "(", "NumConcat", ")", ";" ]

[ "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "ShuffleVec", "(", "NumElems", "*", "SizeRatio", ",", "-", "<NUM_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumElems", ";", "++", "i", ")", "ShuffleVec", "[", "i", "]", "=", "i", "*", "SizeRatio", ";", "assert", "(", "DAG", ".", "getTargetLoweringInfo", "(", ")", ".", "isTypeLegal", "(", "WideVecVT", ")", "&&", "<STR_LIT>", "WideVecVT should be legal", "<STR_LIT>", ")", ";", "SDValue", "TruncatedVal", "=", "DAG", ".", "getVectorShuffle", "(", "WideVecVT", ",", "dl", ",", "WideVec", ",", "DAG", ".", "getUNDEF", "(", "WideVecVT", ")", ",", "ShuffleVec", ")", ";", "SDValue", "NewMask", ";", "SDValue", "Mask", "=", "Mst", "->", "getMask", "(", ")", ";", "if", "(", "Mask", ".", "getValueType", "(", ")", "==", "VT", ")", "{", "NewMask", "=", "DAG", ".", "getBitcast", "(", "WideVecVT", ",", "Mask", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumElems", ";", "++", "i", ")", "ShuffleVec", "[", "i", "]", "=", "i", "*", "SizeRatio", ";", "for", "(", "unsigned", "i", "=", "NumElems", ";", "i", "!=", "NumElems", "*", "SizeRatio", ";", "++", "i", ")", "ShuffleVec", "[", "i", "]", "=", "NumElems", "*", "SizeRatio", ";", "NewMask", "=", "DAG", ".", "getVectorShuffle", "(", "WideVecVT", ",", "dl", ",", "NewMask", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "WideVecVT", ")", ",", "ShuffleVec", ")", ";", "}", "else", "{", "assert", "(", "Mask", ".", "getValueType", "(", ")", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", ")", ";", "unsigned", "WidenNumElts", "=", "NumElems", "*", "SizeRatio", ";", "unsigned", "MaskNumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "EVT", "NewMaskVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "MVT", "::", "i1", ",", "WidenNumElts", ")", ";", "unsigned", "NumConcat", "=", "WidenNumElts", "/", "MaskNumElts", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops" ]

[ "raw_svector_ostream", "(", "Name", ")", "<<", "Printer", ".", "MAI", "->", "getPrivateGlobalPrefix", "(", ")", "<<", "<STR_LIT>", "CPI", "<STR_LIT>", "<<", "Printer", ".", "getFunctionNumber", "(", ")", "<<", "'", "_", "'", "<<", "MO", ".", "getIndex", "(", ")", ";" ]

[ "MCSymbol", "*", "ARMMCInstLower", "::", "GetConstantPoolIndexSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "SmallString", "<", "<NUM_LIT>", ">", "Name", ";" ]

[ "let", "prefersSlot3", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "defm", ":", "JWriteResFpuPair", "WriteFVarBlend", ",", "[", "JFPU01", ",", "JFPX", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ">", ";", "defm", ":", "JWriteResYMMPair", "WriteFVarBlendY", ",", "[", "JFPU01", ",", "JFPX", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ">", ";", "<FIXE>" ]

[ "defm", ":", "JWriteResFpuPair", "WriteFBlend", ",", "[", "JFPU01", ",", "JFPX", "]", ",", "<NUM_LIT>", ">", ";", "defm", ":", "JWriteResYMMPair", "WriteFBlendY", ",", "[", "JFPU01", ",", "JFPX", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ">", ";", "defm", ":", "X86WriteResPairUnsupported", "WriteFBlendZ", ">", ";", "<BUGS>", "defm", ":", "JWriteResFpuPair", "WriteFVarBlend", ",", "[", "JFPU01", ",", "JFPX", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ">", ";", "defm", ":", "JWriteResYMMPair", "WriteFVarBlendY", ",", "[", "JFPU01", ",", "JFPX", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ">", ";", "<BUGE>", "defm", ":", "X86WriteResPairUnsupported", "WriteFVarBlendZ", ">", ";", "defm", ":", "JWriteResFpuPair", "WriteFShuffle256", ",", "[", "JFPU01", ",", "JFPX", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ">", ";", "defm", ":", "X86WriteResPairUnsupported", "WriteFVarShuffle256", ">", ";" ]

[ "<FIXS>", "(", "OPTIONAL_CP_INSN", "ivc2", "-", "p1", "-", "isa", "(", "SLOTS", "P1", ")", "(", "INTRINSIC", "<STR_LIT>", "cpmulua1_w", "<STR_LIT>", ")", "(", "CPTYPE", "V2SI", ")", "VOLATILE", ")", "<FIXE>" ]

[ ";", "<NUM_LIT>", "<NUM_LIT>", "qqqqq", "ppppp", "<NUM_LIT>", "cpmulua1", ".", "w", "crqp", ",", "crpp", "(", "p0_1", ")", "(", "dni", "cpmulua1_w_P1", "<STR_LIT>", "cpmulua1.w $crqp,$crpp Pn", "<STR_LIT>", "<BUGS>", "(", "OPTIONAL_CP_INSN", "ivc2", "-", "p1", "-", "isa", "(", "SLOTS", "P1", ")", "(", "INTRINSIC", "<STR_LIT>", "cpmulua1_w", "<STR_LIT>", ")", "(", "CPTYPE", "V2SI", ")", ")", "<BUGE>", "<STR_LIT>", "cpmulua1.w $crqp,$crpp", "<STR_LIT>", "(", "+", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u0", "#", "x0", ")", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u8", "#", "x1e", ")", "crqp", "crpp", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u23", "#", "xe", ")", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u28", "<NUM_LIT>", ")", ")", "(", "sequence", "(", ")" ]

[ "=", "<NUM_LIT>", ";" ]

[ "break", ";", "default", ":", "warning", "(", "OPT_Wattributes", ",", "<STR_LIT>", "argument of %qE attribute is not a string constant ", "<STR_LIT>", "<STR_LIT>", "or number", "<STR_LIT>", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "break", ";", "}", "}", "const", "char", "*", "message", "=", "NULL", ";", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "message", "=", "<STR_LIT>", "%qE attribute only applies to functions", "<STR_LIT>", ";", "}", "else", "if", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_INTR", ")", ")", "{", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "*", "node", ")", ")", "==", "FUNCTION_TYPE", "&&", "!", "VOID_TYPE_P", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "*", "node", ")", ")", ")", ")", "message", "=", "<STR_LIT>", "interrupt handlers must be void", "<STR_LIT>", ";", "else", "{", "TREE_USED", "(", "*", "node", ")", "=", "<NUM_LIT>", ";", "DECL_PRESERVE_P", "(", "*", "node", ")" ]

[ "<FIXS>", "virtual", "void", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "APInt", "&", "Op", ",", "SmallVectorImpl", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "=", "<NUM_LIT>", ";", "<FIXE>", "<FIXS>", "virtual", "void", "getSOPPBrEncoding", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "APInt", "&", "Op", ",", "SmallVectorImpl", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "=", "<NUM_LIT>", ";", "<FIXE>", "<FIXS>", "virtual", "void", "getSMEMOffsetEncoding", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "APInt", "&", "Op", ",", "<FIXE>", "<FIXS>", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "=", "<NUM_LIT>", ";", "<FIXE>", "<FIXS>", "virtual", "void", "getSDWASrcEncoding", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "APInt", "&", "Op", ",", "SmallVectorImpl", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "=", "<NUM_LIT>", ";", "<FIXE>", "<FIXS>", "virtual", "void", "getSDWAVopcDstEncoding", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "APInt", "&", "Op", ",", "<FIXE>", "<FIXS>", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "=", "<NUM_LIT>", ";", "virtual", "void", "getAVOperandEncoding", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "APInt", "&", "Op", ",", "SmallVectorImpl", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "=", "<NUM_LIT>", ";", "<FIXE>" ]

[ "AMDGPUMCCodeEmitter", "(", "const", "MCInstrInfo", "&", "mcii", ")", ":", "MCII", "(", "mcii", ")", "{", "}", "public", ":", "<BUGS>", "uint64_t", "getBinaryCodeForInstr", "(", "const", "MCInst", "&", "MI", ",", "SmallVectorImpl", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", ";", "<BUGE>", "<BUGS>", "virtual", "uint64_t", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "return", "<NUM_LIT>", ";", "}", "<BUGE>", "<BUGS>", "virtual", "unsigned", "getSOPPBrEncoding", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "<BUGE>", "SmallVectorImpl", "MCFixup", ">", "&", "Fixups", ",", "<BUGS>", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "return", "<NUM_LIT>", ";", "}", "<BUGE>", "<BUGS>", "virtual", "unsigned", "getSMEMOffsetEncoding", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "return", "<NUM_LIT>", ";", "}", "<BUGE>", "<BUGS>", "virtual", "unsigned", "getSDWASrcEncoding", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "<BUGE>", "SmallVectorImpl", "MCFixup", ">", "&", "Fixups", ",", "<BUGS>", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "return", "<NUM_LIT>", ";", "}", "virtual", "unsigned", "getSDWAVopcDstEncoding", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "return", "<NUM_LIT>", ";", "}", "virtual", "unsigned", "getAVOperandEncoding", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "return", "<NUM_LIT>", ";", "}", "<BUGE>", "protected", ":", "FeatureBitset", "computeAvailableFeatures", "(", "const", "FeatureBitset", "&", "FB", ")", "const", ";" ]

[ ")", ".", "is64Bit", "(", ")", "&&", "<STR_LIT>", "X86-64 PIC uses RIP relative addressing", "<STR_LIT>", ")", ";" ]

[ "unsigned", "X86InstrInfo", "::", "getGlobalBaseReg", "(", "MachineFunction", "*", "MF", ")", "const", "{", "assert", "(", "!", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(" ]

[ "<FIXS>", "if", "(", "where", ")", "<FIXE>", "<FIXS>", "if", "(", "GET_CODE", "(", "where", ")", "==", "CODE_LABEL", ")", "<FIXE>", "<FIXS>", "rtx", "where2", "=", "prev_nonnote_insn", "(", "where", ")", ";", "if", "(", "where2", "&&", "GET_CODE", "(", "where2", ")", "==", "JUMP_INSN", ")", "where", "=", "where2", ";", "<FIXE>", "<FIXS>", "else", "if", "(", "GET_CODE", "(", "where", ")", "!=", "JUMP_INSN", ")", "where", "=", "i", ";", "<FIXE>" ]

[ "int", "nop_count", "=", "(", "align", "-", "ofs", ")", "/", "<NUM_LIT>", ";", "rtx", "where", ";", "where", "=", "prev_nonnote_insn", "(", "i", ")", ";", "<BUGS>", "if", "(", "!", "where", "||", "GET_CODE", "(", "where", ")", "!=", "CODE_LABEL", ")", "where", "=", "i", ";", "do", "<BUGE>", "{", "<BUGS>", "if", "(", "!", "(", "prev_in_use", "&", "EV5_E1", ")", ")", "{", "prev_in_use", "|=", "EV5_E1", ";", "emit_insn_before", "(", "gen_nop", "(", ")", ",", "where", ")", ";", "}", "else", "if", "(", "TARGET_FP", "&&", "!", "(", "prev_in_use", "&", "EV5_FA", ")", ")", "{", "prev_in_use", "|=", "EV5_FA", ";", "emit_insn_before", "(", "gen_fnop", "(", ")", ",", "where", ")", ";", "}", "else", "if", "(", "TARGET_FP", "&&", "!", "(", "prev_in_use", "&", "EV5_FM", ")", ")", "<BUGE>", "{", "<BUGS>", "prev_in_use", "|=", "EV5_FM", ";", "emit_insn_before", "(", "gen_fnop", "(", ")", ",", "where", ")", ";", "<BUGE>", "}", "<BUGS>", "elseemit_insn_before", "(", "gen_unop", "(", ")", ",", "where", ")", ";", "<BUGE>", "}", "while", "(", "--", "nop_count", ")", ";", "ofs", "=", "<NUM_LIT>", ";", "}" ]

[ "<FIXS>", "if", "(", "GET_CODE", "(", "from", ")", "==", "CODE_LABEL", "&&", "CODE_LABEL_NUMBER", "(", "from", ")", "<=", "max_labelno_before_reorg", ")", "<FIXE>" ]

[ "int", "inc", "=", "get_attr_length", "(", "from", ")", ";", "int", "new", "_", "align", "=", "<NUM_LIT>", ";", "<BUGS>", "if", "(", "GET_CODE", "(", "from", ")", "==", "CODE_LABEL", ")", "<BUGE>", "{", "if", "(", "optimize", ")", "new", "_", "align", "=", "<NUM_LIT>", "<<", "label_to_alignment", "(", "from", ")", ";" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "return", "<STR_LIT>", "<FIXE>", "<FIXS>", "return", "<STR_LIT>", "<FIXE>", "<FIXS>", "}", "<FIXE>" ]

[ "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "attr", "<STR_LIT>", ")", "(", "if_then_else", "(", "and", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ior", "(", "not", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "<FIXS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<FIXE>" ]

[ "(", "match_operand", ":", "V8QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_mode_iterator", "VASS", "[", "V4HI", "V2SI", "V2HI", "V1SI", "]", ")", "(", "define_code_iterator", "vis3_addsub_ss", "[", "ss_plus", "ss_minus", "]", ")" ]

[ "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";" ]

[ "Offset", ";" ]

[ "if", "(", "!", "CI", ".", "hasMergeableAddress", "(", "*", "MRI", ")", ")", "continue", ";", "if", "(", "CI", ".", "InstClass", "==", "DS_WRITE", "&&", "CI", ".", "IsAGPR", ")", "{", "continue", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Mergeable: ", "<STR_LIT>", "<<", "MI", ")", ";", "addInstToMergeableList", "(", "CI", ",", "MergeableInsts", ")", ";", "}", "for", "(", "std", "::", "list", "<", "std", "::", "list", "<", "CombineInfo", ">>", "::", "iterator", "I", "=", "MergeableInsts", ".", "begin", "(", ")", ",", "E", "=", "MergeableInsts", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "std", "::", "list", "<", "CombineInfo", ">", "&", "MergeList", "=", "*", "I", ";", "if", "(", "MergeList", ".", "size", "(", ")", "<=", "<NUM_LIT>", ")", "{", "I", "=", "MergeableInsts", ".", "erase", "(", "I", ")", ";", "continue", ";", "}", "MergeList", ".", "sort", "(", "[", "]", "(", "const", "CombineInfo", "&", "A", ",", "const", "CombineInfo", "&", "B", ")", "{", "return", "A", ".", "Offset", "<", "B", "." ]

[ "Offset", "=", "CurDAG", "->", "getTargetConstant", "(", "C", "->", "getZExtValue", "(", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ";" ]

[ "Offset", "=", "CurDAG", "->", "getTargetConstant", "(", "C", "->", "getZExtValue", "(", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "}", "else", "if", "(", "(", "Addr", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", "||", "Addr", ".", "getOpcode", "(", ")", "==", "ISD", "::", "OR", ")", "&&", "(", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Addr", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", ")", "{", "Base", "=", "Addr", ".", "getOperand", "(", "<NUM_LIT>", ")", ";" ]

[ "void", "PPCAIXAsmPrinter", "::", "emitGlobalVariable", "(", "const", "GlobalVariable", "*", "GV", ")", "{", "ValidateGV", "(", "GV", ")", ";", "MCSymbolXCOFF", "*", "GVSym", "=", "cast", "<", "MCSymbolXCOFF", ">", "(", "getSymbol", "(", "GV", ")", ")", ";", "GVSym", "->", "setStorageClass", "(", "TargetLoweringObjectFileXCOFF", "::", "getStorageClassForGlobal", "(", "GV", ")", ")", ";", "SectionKind", "GVKind", ";", "MCSectionXCOFF", "*", "Csect", "=", "cast", "<", "MCSectionXCOFF", ">", "(", "GV", "->", "isDeclaration", "(", ")", "?", "getObjFileLowering", "(", ")", ".", "getSectionForExternalReference", "(", "GV", ",", "TM", ")", ":", "getObjFileLowering", "(", ")", ".", "SectionForGlobal", "(", "GV", ",", "GVKind", "=", "getObjFileLowering", "(", ")", ".", "getKindForGlobal", "(", "GV", ",", "TM", ")", ",", "TM", ")", ")", ";", "GVSym", "->", "setContainingCsect", "(", "Csect", ")", ";", "if", "(", "GV", "->", "isDeclaration", "(", ")", ")", "return", ";", "if", "(", "!", "GVKind", ".", "isGlobalWriteableData", "(", ")", "&&", "!", "GVKind", ".", "isReadOnly", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "Encountered a global variable kind that is ", "<STR_LIT>", "<STR_LIT>", "not supported yet.", "<STR_LIT>", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Csect", ")", ";", "const", "DataLayout", "&", "DL", "=", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "if", "(", "GVKind", ".", "isCommon", "(", ")", "||", "GVKind", ".", "isBSSLocal", "(", ")", ")", "{", "unsigned", "Align", "=", "GV", "->", "getAlignment", "(", ")", "?", "GV", "->", "getAlignment", "(", ")", ":", "DL", ".", "getPreferredAlignment", "(", "GV", ")", ";", "uint64_t", "Size", "=", "DL", ".", "getTypeAllocSize", "(", "GV", "->", "getType", "(", ")", "->", "getElementType", "(", ")", ")", ";", "if", "(", "GVKind", ".", "isBSSLocal", "(", ")", ")", "OutStreamer", "->", "emitXCOFFLocalCommonSymbol", "(", "GVSym", ",", "Size", ",", "Csect", "->", "getQualNameSymbol", "(", ")", ",", "Align", ")", ";", "else", "OutStreamer", "->", "emitCommonSymbol", "(", "Csect", "->", "getQualNameSymbol", "(", ")", ",", "Size", ",", "Align", ")", ";", "return", ";", "}", "MCSymbol", "*", "EmittedInitSym", "=", "GVSym", ";", "emitLinkage", "(", "GV", ",", "EmittedInitSym", ")", ";", "emitAlignment", "(", "getGVAlignment", "(", "GV", ",", "DL", ")", ",", "GV", ")", ";", "OutStreamer", "->", "emitLabel", "(", "EmittedInitSym", ")", ";", "emitGlobalConstant", "(", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ",", "GV", "->", "getInitializer", "(", ")", ")", ";", "}" ]

[ "Emit", "the", "specified", "global", "variable", "to", "the", ".s", "file", "." ]

[ "let", "ParserMatchClass", "=", "Imm1_8Operand", ";" ]

[ "}", "]", ">", "{", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ ")", "{" ]

[ "ArgVTs", ".", "reserve", "(", "I", "->", "getNumOperands", "(", ")", ")", ";", "ArgFlags", ".", "reserve", "(", "I", "->", "getNumOperands", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "I", "->", "getNumOperands", "(", ")", ";", "++", "i", ")", "{", "Value", "*", "Op", "=", "I", "->", "getOperand", "(", "i", ")", ";", "unsigned", "Arg", "=", "getRegForValue", "(", "Op", ")", ";", "if", "(", "Arg", "==", "<NUM_LIT>", ")", "return", "false", ";", "Type", "*", "ArgTy", "=", "Op", "->", "getType", "(", ")", ";", "MVT", "ArgVT", ";", "if", "(", "!", "isTypeLegal", "(", "ArgTy", ",", "ArgVT", ")", ")", "return", "false", ";", "ISD", "::", "ArgFlagsTy", "Flags", ";", "unsigned", "OriginalAlignment", "=", "DL", ".", "getABITypeAlignment", "(", "ArgTy", ")", ";", "Flags", ".", "setOrigAlign", "(", "OriginalAlignment", ")", ";", "Args", ".", "push_back", "(", "Op", ")", ";", "ArgRegs", ".", "push_back", "(", "Arg", ")", ";", "ArgVTs", ".", "push_back", "(", "ArgVT", ")", ";", "ArgFlags", ".", "push_back", "(", "Flags", ")", ";", "}", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "RegArgs", ";", "unsigned", "NumBytes", ";", "if", "(", "!", "ProcessCallArgs", "(", "Args", ",", "ArgRegs", ",", "ArgVTs", ",", "ArgFlags", ",", "RegArgs", ",", "CC", ",", "NumBytes", ",", "false", ")", ")", "return", "false", ";", "unsigned", "CalleeReg", "=", "<NUM_LIT>", ";", "if", "(", "EnableARMLongCalls" ]

[ "<NUM_LIT>", ")" ]

[ "(", "plus", ":", "SI", "(", "mult", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "ashift", ":", "HI", "(", "match_dup" ]

[ "+", "<NUM_LIT>", ")", ".", "isCPI", "(", ")", "||", "MI", "->", "getOperand", "(", "Op", "+", "<NUM_LIT>", ")", ".", "isJTI", "(", ")", ")", ";" ]

[ "if", "(", "MI", "->", "getOperand", "(", "Op", ")", ".", "isFI", "(", ")", ")", "return", "true", ";", "return", "Op", "+", "<NUM_LIT>", "<=", "MI", "->", "getNumOperands", "(", ")", "&&", "MI", "->", "getOperand", "(", "Op", ")", ".", "isReg", "(", ")", "&&", "isScale", "(", "MI", "->", "getOperand", "(", "Op", "+", "<NUM_LIT>", ")", ")", "&&", "MI", "->", "getOperand", "(", "Op", "+", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "(", "MI", "->", "getOperand", "(", "Op", "+", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "||", "MI", "->", "getOperand", "(", "Op", "+", "<NUM_LIT>", ")", ".", "isGlobal", "(", ")", "||", "MI", "->", "getOperand", "(", "Op" ]

[ "MF", ")", ";" ]

[ "ForCodeSize", "=", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "OptimizeForSize", ")", "||", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "MinSize", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(" ]

[ "DP", "<<", "Str", ";" ]

[ "OS", "<<", "<STR_LIT>", "in function ", "<STR_LIT>", "<<", "Fn", ".", "getName", "(", ")", "<<", "'", "'", "<<", "*", "Fn", ".", "getFunctionType", "(", ")", "<<", "'", "\\n", "'", "<<", "Description", ";", "if", "(", "Value", ")", "Value", "->", "print", "(", "OS", ")", ";", "OS", "<<", "'", "\\n", "'", ";", "OS", ".", "flush", "(", ")", ";" ]

[ ";" ]

[ "return", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")" ]

[ "let", "InputType", "=", "<STR_LIT>", ";" ]

[ "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isIndirectBranch", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";" ]

[ "<FIXS>", "return", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "dl", ",", "MVT", "::", "i1", ",", "Op0", ",", "Op1", ")", ";", "<FIXE>" ]

[ "SDValue", "Op2", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "DebugLoc", "dl", "=", "Op", ".", "getDebugLoc", "(", ")", ";", "ISD", "::", "CondCode", "CC", "=", "cast", "CondCodeSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "get", "(", ")", ";", "if", "(", "Op1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", "&&", "(", "cast", "ConstantSDNode", ">", "(", "Op1", ")", "->", "getZExtValue", "(", ")", "==", "<NUM_LIT>", "||", "cast", "ConstantSDNode", ">", "(", "Op1", ")", "->", "isNullValue", "(", ")", ")", "&&", "(", "CC", "==", "ISD", "::", "SETEQ", "||", "CC", "==", "ISD", "::", "SETNE", ")", ")", "{", "<BUGS>", "return", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "dl", ",", "MVT", "::", "i1", ",", "Op0", ",", "Op1", ")", ";", "<BUGE>", "}", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SETCC", ",", "dl", ",", "MVT", "::", "i1", ",", "Op0", ",", "Op1", ",", "Op2", ")", ";", "}" ]

[ "}" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "nImmVMOVIAsmOperandReplicate", "<", "From", ",", "To", ">", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "PredNew", ";" ]

[ "let", "IClass", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "PredNot", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pu", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rs", ";" ]

[ "i32imm", ":", "$", "idx", ")", ";" ]

[ "def", "VecListThreeDHWordIndexed", ":", "Operand", "<", "i32", ">", "{", "let", "ParserMatchClass", "=", "VecListThreeDHWordIndexAsmOperand", ";", "let", "MIOperandInfo", "=", "(", "ops", "DPR", ":", "$", "Vd", "," ]

[ ")", "{" ]

[ "static", "bool", "isi32Store", "(", "unsigned", "Opc" ]

[ "||", "!", "ST", ".", "isTrapHandlerEnabled", "(", ")", ")", "{" ]

[ "bool", "AMDGPULegalizerInfo", "::", "legalizeDebugTrapIntrinsic", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "B", ")", "const", "{", "B", ".", "setInstr", "(", "MI", ")", ";", "if", "(", "ST", ".", "getTrapHandlerAbi", "(", ")", "!=", "GCNSubtarget", "::", "TrapHandlerAbiHsa" ]

[ "::", "CONSTANT_ADDRESS_32BIT", ";" ]

[ "static", "bool", "isScalarLoadLegal", "(", "const", "MachineInstr", "&", "MI", ")", "{", "if", "(", "!", "MI", ".", "hasOneMemOperand", "(", ")", ")", "return", "false", ";", "const", "MachineMemOperand", "*", "MMO", "=", "*", "MI", ".", "memoperands_begin", "(", ")", ";", "const", "unsigned", "AS", "=", "MMO", "->", "getAddrSpace", "(", ")", ";", "const", "bool", "IsConst", "=", "AS", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS", "||", "AS", "==", "AMDGPUAS" ]

[ ",", "VReg", ")", ";" ]

[ "assert", "(", "RC", "->", "contains", "(", "PReg", ")", "&&", "<STR_LIT>", "Not the correct regclass!", "<STR_LIT>", ")", ";", "unsigned", "VReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveIn", "(", "PReg" ]

[ "<NUM_LIT>", ";" ]

[ "def", "rsr", ":", "AsI1", "<", "opcod", ",", "(", "outs", "GPR", ":", "$", "Rd", ")", ",", "(", "ins", "GPR", ":", "$", "Rn", ",", "so_reg_reg", ":", "$", "shift", ")", ",", "DPSoRegRegFrm", ",", "IIC_iALUsr", ",", "opc", ",", "<STR_LIT>", ",", "[", "(", "set", "GPR", ":", "$", "Rd", ",", "CPSR", ",", "(", "opnode", "so_reg_reg", ":", "$", "shift", ",", "GPR", ":", "$", "Rn", ",", "CPSR", ")", ")", "]", ">", ",", "Requires", "<", "[", "IsARM", "]", ">", ",", "Sched", "<", "[", "WriteALUsr", ",", "ReadALUsr", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "shift", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=" ]

[ "(", "mn", ")", ")", ";" ]

[ "_", "_", "inline__", "static", "unsigned", "long", "long", "sh_media_MCNVS_WB", "(", "unsigned", "long", "long", "mm", ",", "unsigned", "long", "long", "mn", ")", "{", "unsigned", "long", "long", "res", ";", "_", "_", "asm__", "(", "<STR_LIT>", "mcnvs.wb\t%1, %2, %0", "<STR_LIT>", ":", "<STR_LIT>", "=r", "<STR_LIT>", "(", "res", ")", ":", "<STR_LIT>", "r", "<STR_LIT>", "(", "mm", ")", ",", "<STR_LIT>", "r", "<STR_LIT>" ]

[ "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "v4i32", ",", "DAG", ".", "getVectorShuffle", "(", "MVT", "::", "v4f32", ",", "DL", ",", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "v4f32", ",", "V1", ")", ",", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "v4f32", ",", "V2", ")", ",", "Mask", ")", ")", ";" ]

[ "assert", "(", "Mask", ".", "size", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected mask size for v4 shuffle!", "<STR_LIT>", ")", ";", "if", "(", "SDValue", "ZExt", "=", "lowerVectorShuffleAsZeroOrAnyExtend", "(", "DL", ",", "MVT", "::", "v4i32", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "ZExt", ";", "int", "NumV2Elements", "=", "std", "::", "count_if", "(", "Mask", ".", "begin", "(", ")", ",", "Mask", ".", "end", "(", ")", ",", "[", "]", "(", "int", "M", ")", "{", "return", "M", ">=", "<NUM_LIT>", ";", "}", ")", ";", "if", "(", "NumV2Elements", "==", "<NUM_LIT>", ")", "{", "if", "(", "SDValue", "Broadcast", "=", "lowerVectorShuffleAsBroadcast", "(", "MVT", "::", "v4i32", ",", "DL", ",", "V1", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "Broadcast", ";", "const", "int", "UnpackLoMask", "[", "]", "=", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "const", "int", "UnpackHiMask", "[", "]", "=", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "if", "(", "isShuffleEquivalent", "(", "Mask", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "Mask", "=", "UnpackLoMask", ";", "else", "if", "(", "isShuffleEquivalent", "(", "Mask", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "Mask", "=", "UnpackHiMask", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v4i32", ",", "V1", ",", "getV4X86ShuffleImm8ForMask", "(", "Mask", ",", "DAG", ")", ")", ";", "}", "if", "(", "SDValue", "Shift", "=", "lowerVectorShuffleAsBitShift", "(", "DL", ",", "MVT", "::", "v4i32", ",", "V1", ",", "V2", ",", "Mask", ",", "DAG", ")", ")", "return", "Shift", ";", "if", "(", "SDValue", "Shift", "=", "lowerVectorShuffleAsByteShift", "(", "DL", ",", "MVT", "::", "v4i32", ",", "V1", ",", "V2", ",", "Mask", ",", "DAG", ")", ")", "return", "Shift", ";", "if", "(", "NumV2Elements", "==", "<NUM_LIT>", ")", "if", "(", "SDValue", "V", "=", "lowerVectorShuffleAsElementInsertion", "(", "MVT", "::", "v4i32", ",", "DL", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "V", ";", "if", "(", "Subtarget", "->", "hasSSE41", "(", ")", ")", "if", "(", "SDValue", "Blend", "=", "lowerVectorShuffleAsBlend", "(", "DL", ",", "MVT", "::", "v4i32", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "Blend", ";", "if", "(", "SDValue", "Masked", "=", "lowerVectorShuffleAsBitMask", "(", "DL", ",", "MVT", "::", "v4i32", ",", "V1", ",", "V2", ",", "Mask", ",", "DAG", ")", ")", "return", "Masked", ";", "if", "(", "isShuffleEquivalent", "(", "Mask", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v4i32", ",", "V1", ",", "V2", ")", ";", "if", "(", "isShuffleEquivalent", "(", "Mask", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v4i32", ",", "V1", ",", "V2", ")", ";", "if", "(", "Subtarget", "->", "hasSSSE3", "(", ")", ")", "if", "(", "SDValue", "Rotate", "=", "lowerVectorShuffleAsByteRotate", "(", "DL", ",", "MVT", "::", "v4i32", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "Rotate", ";" ]

[ "<FIXS>", "def", "ISEL8", ":", "AForm_4", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<FIXE>" ]

[ "<STR_LIT>", ",", "IntGeneral", ",", "[", "]", ">", ";", "<BUGS>", "def", "ISEL8", ":", "AForm_1", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<BUGE>", "(", "outs", "G8RC", ":", "$", "rT", ")", ",", "(", "ins", "G8RC", ":", "$", "rA", ",", "G8RC", ":", "$", "rB", ",", "pred", ":", "$", "cond", ")", ",", "<STR_LIT>", ",", "IntGeneral", ",", "[", "]", ">", ";" ]

[ "dl", ",", "TII", ",", "ArgRegsSaveSize", ")", ";" ]

[ "if", "(", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "{", "fixTCReturn", "(", "MF", ",", "MBB", ")", ";", "return", ";", "}", "if", "(", "!", "AFI", "->", "hasStackFrame", "(", ")", ")", "{", "if", "(", "NumBytes", "-", "ArgRegsSaveSize", "!=", "<NUM_LIT>", ")", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "NumBytes", "-", "ArgRegsSaveSize", ")", ";", "}", "else", "{", "const", "MCPhysReg", "*", "CSRegs", "=", "RegInfo", "->", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "if", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "do", "{", "--", "MBBI", ";", "}", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", "&&", "isCSRestore", "(", "MBBI", ",", "TII", ",", "CSRegs", ")", ")", ";", "if", "(", "!", "isCSRestore", "(", "MBBI", ",", "TII", ",", "CSRegs", ")", ")", "++", "MBBI", ";", "}", "NumBytes", "-=", "(", "ArgRegsSaveSize", "+", "AFI", "->", "getGPRCalleeSavedArea1Size", "(", ")", "+", "AFI", "->", "getGPRCalleeSavedArea2Size", "(", ")", "+", "AFI", "->", "getDPRCalleeSavedGapSize", "(", ")", "+", "AFI", "->", "getDPRCalleeSavedAreaSize", "(", ")", ")", ";", "if", "(", "AFI", "->", "shouldRestoreSPFromFP", "(", ")", ")", "{", "NumBytes", "=", "AFI", "->", "getFramePtrSpillOffset", "(", ")", "-", "NumBytes", ";", "if", "(", "NumBytes", ")", "{", "if", "(", "isARM", ")", "emitARMRegPlusImmediate", "(", "MBB", ",", "MBBI", ",", "dl", ",", "ARM", "::", "SP", ",", "FramePtr", ",", "-", "NumBytes", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ",", "TII", ")", ";", "else", "{", "assert", "(", "MF", ".", "getRegInfo", "(", ")", ".", "isPhysRegUsed", "(", "ARM", "::", "R4", ")", "&&", "<STR_LIT>", "No scratch register to restore SP from FP!", "<STR_LIT>", ")", ";", "emitT2RegPlusImmediate", "(", "MBB", ",", "MBBI", ",", "dl", ",", "ARM", "::", "R4", ",", "FramePtr", ",", "-", "NumBytes", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ",", "TII", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVr", ")", ",", "ARM", "::", "SP", ")", ".", "addReg", "(", "ARM", "::", "R4", ")", ")", ";", "}", "}", "else", "{", "if", "(", "isARM", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "MOVr", ")", ",", "ARM", "::", "SP", ")", ".", "addReg", "(", "FramePtr", ")", ".", "addImm", "(", "(", "unsigned", ")", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "else", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVr", ")", ",", "ARM", "::", "SP", ")", ".", "addReg", "(", "FramePtr", ")", ")", ";", "}", "}", "else", "if", "(", "NumBytes", "&&", "!", "tryFoldSPUpdateIntoPushPop", "(", "STI", ",", "MF", ",", "MBBI", ",", "NumBytes", ")", ")", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "NumBytes", ")", ";", "if", "(", "AFI", "->", "getDPRCalleeSavedAreaSize", "(", ")", ")", "{", "MBBI", "++", ";", "while", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "VLDMDIA_UPD", ")", "MBBI", "++", ";", "}", "if", "(", "AFI", "->", "getDPRCalleeSavedGapSize", "(", ")", ")", "{", "assert", "(", "AFI", "->", "getDPRCalleeSavedGapSize", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "unexpected DPR alignment gap", "<STR_LIT>", ")", ";", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "AFI", "->", "getDPRCalleeSavedGapSize", "(", ")", ")", ";", "}", "if", "(", "AFI", "->", "getGPRCalleeSavedArea2Size", "(", ")", ")", "MBBI", "++", ";", "if", "(", "AFI", "->", "getGPRCalleeSavedArea1Size", "(", ")", ")", "MBBI", "++", ";", "}", "fixTCReturn", "(", "MF", ",", "MBB", ")", ";", "if", "(", "ArgRegsSaveSize", ")", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "MBBI", "," ]

[ ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", ":", "QI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ "bool", "LanaiAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "StringRef", "Mnemonic", "=", "splitMnemonic", "(", "Name", ",", "NameLoc", ",", "&", "Operands", ")", ";", "if", "(", "Lexer", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "parseOperand", "(", "&", "Operands", ",", "Mnemonic", ")", "!=", "MatchOperand_Success", ")", "return", "true", ";", "if", "(", "Lexer", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "Name", "==", "<STR_LIT>", "st", "<STR_LIT>", "&&", "Operands", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "{", "Operands", ".", "erase", "(", "Operands", ".", "begin", "(", ")", ",", "Operands", ".", "begin", "(", ")", "+", "<NUM_LIT>", ")", ";", "Operands", ".", "insert", "(", "Operands", ".", "begin", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", "(", "<STR_LIT>", "s", "<STR_LIT>", ",", "NameLoc", ")", ")", ";", "Operands", ".", "insert", "(", "Operands", ".", "begin", "(", ")", "+", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "(", "MCConstantExpr", "::", "create", "(", "LPCC", "::", "ICC_T", ",", "getContext", "(", ")", ")", ",", "NameLoc", ",", "NameLoc", ")", ")", ";", "}", "if", "(", "Lexer", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "Name", ".", "startswith", "(", "<STR_LIT>", "bt", "<STR_LIT>", ")", "&&", "Operands", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "{", "Operands", ".", "erase", "(", "Operands", ".", "begin", "(", ")", ",", "Operands", ".", "begin", "(", ")", "+", "<NUM_LIT>", ")", ";", "Operands", ".", "insert", "(", "Operands", ".", "begin", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", "(", "<STR_LIT>", "bt", "<STR_LIT>", ",", "NameLoc", ")", ")", ";", "}", "while", "(", "Lexer", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "Lexer", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "&", "Operands", ",", "Mnemonic", ")", "!=", "MatchOperand_Success", ")", "return", "true", ";", "}", "if", "(", "IsMemoryAssignmentError", "(", "Operands", ")", ")", "{", "Error", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "the destination register can't equal the base register in an ", "<STR_LIT>", "<STR_LIT>", "instruction that modifies the base register.", "<STR_LIT>", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "SW_FORCE_SIGN0", "=", "<NUM_LIT>", ";", "int", "RM_DEFAULT", "=", "<NUM_LIT>", ";", "int", "RM_G1_RHNE", "=", "<NUM_LIT>", ";", "int", "RM_G1_RD", "=", "<NUM_LIT>", ";", "int", "RM_G1_RU", "=", "<NUM_LIT>", ";", "int", "RM_G1_SR", "=", "<NUM_LIT>", ";", "int", "CVT_G1_RZ", "=", "<NUM_LIT>", ";", "int", "RM_RHNE", "=", "<NUM_LIT>", ";", "int", "RM_RZ", "=", "<NUM_LIT>", ";", "int", "RM_RU", "=", "<NUM_LIT>", ";", "int", "RM_RD", "=", "<NUM_LIT>", ";", "int", "RM_SR", "=", "<NUM_LIT>", ";", "int", "RM_RHAZ", "=", "<NUM_LIT>", ";", "int", "TO_FP32", "=", "<NUM_LIT>", ";", "int", "TO_BF16", "=", "<NUM_LIT>", ";", "int", "TO_INT32", "=", "<NUM_LIT>", ";", "int", "TO_UINT32", "=", "<NUM_LIT>", ";", "int", "TO_INT8", "=", "<NUM_LIT>", ";", "int", "TO_UINT8", "=", "<NUM_LIT>", ";", "int", "TO_INT16", "=", "<NUM_LIT>", ";", "int", "TO_UINT16", "=", "<NUM_LIT>", ";", "int", "TO_INT4", "=", "<NUM_LIT>", ";", "int", "TO_UINT4", "=", "<NUM_LIT>", ";", "int", "TO_FP16", "=", "<NUM_LIT>", ";", "int", "TO_FP8_152", "=", "<NUM_LIT>", ";", "int", "TO_FP8_143", "=", "<NUM_LIT>", ";", "int", "SW_CNVRT", "=", "<NUM_LIT>", ";", "int", "SW_CNVRT_INT32", "=", "<NUM_LIT>" ]

[ "}" ]

[ "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "<STR_LIT>", "SI Fold Operands", "<STR_LIT>", ";" ]