Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<FIXS>", "cfa", "=", "gen_rtx_SET", "(", "frame_pointer", ",", "<FIXE>", "<FIXS>", "insn", "=", "gen_rtx_SET", "(", "frame_pointer", ",", "<FIXE>" ]

[ "offset", "=", "area_bottom", "<NUM_LIT>", "?", "-", "area_bottom", ":", "<NUM_LIT>", ";", "frame_off", "=", "GEN_INT", "(", "cfun_frame_layout", ".", "frame_size", "-", "offset", ")", ";", "<BUGS>", "cfa", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "frame_pointer", ",", "<BUGE>", "gen_rtx_PLUS", "(", "Pmode", ",", "frame_pointer", ",", "frame_off", ")", ")", ";", "if", "(", "DISP_IN_RANGE", "(", "INTVAL", "(", "frame_off", ")", ")", ")", "{", "<BUGS>", "insn", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "frame_pointer", ",", "<BUGE>", "gen_rtx_PLUS", "(", "Pmode", ",", "frame_pointer", ",", "frame_off", ")", ")", ";", "insn", "=", "emit_insn", "(", "insn", ")", ";", "}" ]

[ "(", ")", "->", "stripPointerCastsAndAliases", "(", ")", ")", ";" ]

[ "return", "nullptr", ";", "}", "return", "cast", "<", "Function", ">", "(", "Op", ".", "getGlobal" ]

[ "BuildMI", "(", "MBB", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "WebAssembly", "::", "EQZ_I32", ")", ",", "Tmp", ")", ".", "addReg", "(", "Cond", ")", ";" ]

[ "Inverted", "=", "true", ";", "break", ";", "case", "LE_S_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "GT_S_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "GT_U_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "LE_U_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "GE_U_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "LT_U_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "LT_U_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "GE_U_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "LE_U_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "GT_U_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "EQ_F32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "NE_F32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "NE_F32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "EQ_F32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "EQ_F64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "NE_F64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "NE_F64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "EQ_F64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "EQZ_I32", ":", "{", "Cond", "=", "Def", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Def", "->", "eraseFromParent", "(", ")", ";", "Inverted", "=", "true", ";", "break", ";", "}", "default", ":", "break", ";", "}", "}", "if", "(", "!", "Inverted", ")", "{", "unsigned", "Tmp", "=", "MRI", ".", "createVirtualRegister", "(", "&", "WebAssembly", "::", "I32RegClass", ")", ";" ]

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

[ "def", "M2_mpyd_nac_ll_s1", ":", "T_M2_mpyd_acc", "<", "<NUM_LIT>", ",", "<NUM_LIT>", "," ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Rt", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "bits", "<", "<NUM_LIT>", ">", "extend", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "extend", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "extend", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-" ]

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

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

[ "}" ]

[ "auto", "&", "RF", "=", "cast", "<", "MCRelaxableFragment", ">", "(", "*", "K", ")", ";", "auto", "&", "Inst", "=", "const_cast", "<", "MCInst", "&", ">", "(", "RF", ".", "getInst", "(", ")", ")", ";", "while", "(", "Size", ">", "<NUM_LIT>", "&&", "HexagonMCInstrInfo", "::", "bundleSize", "(", "Inst", ")", "<", "<NUM_LIT>", ")", "{", "MCInst", "*", "Nop", "=", "new", "(", "Context", ")", "MCInst", ";", "Nop", "->", "setOpcode", "(", "Hexagon", "::", "A2_nop", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "Nop", ")", ")", ";", "Size", "-=", "<NUM_LIT>", ";", "if", "(", "!", "HexagonMCChecker", "(", "Context", ",", "*", "MCII", ",", "*", "RF", ".", "getSubtargetInfo", "(", ")", ",", "Inst", ",", "*", "Context", ".", "getRegisterInfo", "(", ")", ",", "false", ")", ".", "check", "(", ")", ")", "{", "Inst", ".", "erase", "(", "Inst", ".", "end", "(", ")", "-", "<NUM_LIT>", ")", ";", "Size", "=", "<NUM_LIT>", ";", "}", "}", "bool", "Error", "=", "HexagonMCShuffle", "(", "Context", ",", "true", ",", "*", "MCII", ",", "*", "RF", ".", "getSubtargetInfo", "(", ")", ",", "Inst", ")", ";", "(", "void", ")", "Error", ";", "ReplaceInstruction", "(", "Asm", ".", "getEmitter", "(", ")", ",", "RF", ",", "Inst", ")", ";", "Layout", ".", "invalidateFragmentsFrom", "(", "&", "RF", ")", ";", "Size", "=", "<NUM_LIT>", ";", "break", ";", "}", "}", "}", "}", "}", "}", "}" ]

[ "<FIXS>", "let", "Defs", "=", "[", "USR_OVF", "]", ",", "Itinerary", "=", "S_3op_tc_3x_SLOT23", "in", "{", "<FIXE>", "<FIXS>", "let", "isFP", "=", "<NUM_LIT>", "in", "<FIXE>", "<FIXS>", "let", "isFP", "=", "<NUM_LIT>", "in", "<FIXE>" ]

[ "}", "<BUGS>", "let", "Defs", "=", "[", "USR_OVF", "]", ",", "Itinerary", "=", "S_3op_tc_3x_SLOT23", ",", "isCodeGenOnly", "=", "<NUM_LIT>", "in", "{", "<BUGE>", "def", "M4_cmpyi_whc", ":", "T_S3op_8", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ">", ";", "def", "M4_cmpyr_whc", ":", "T_S3op_8", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ">", ";", "}", "<BUGS>", "let", "isFP", "=", "<NUM_LIT>", ",", "isCodeGenOnly", "=", "<NUM_LIT>", "in", "<BUGE>", "def", "F2_sfclass", ":", "T_TEST_BIT_IMM", "<STR_LIT>", ",", "<NUM_LIT>", ">", ";", "<BUGS>", "let", "isFP", "=", "<NUM_LIT>", ",", "isCodeGenOnly", "=", "<NUM_LIT>", "in", "<BUGE>", "def", "F2_dfclass", ":", "ALU64Inst", "(", "outs", "PredRegs", ":", "$", "Pd", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss", ",", "u5Imm", ":", "$", "u5", ")", ",", "<STR_LIT>", ",", "[", "]", ",", "<STR_LIT>", ",", "ALU64_tc_2early_SLOT23", ">", ",", "Requires", "[", "HasV5T", "]", ">", "{" ]

[ "<STR_LIT>", ";" ]

[ "const", "MCInstrDesc", "&", "MCID", "=", "TII", ".", "get", "(", "Opcode", ")", ";", "isLoad", "=", "MCID", ".", "mayLoad", "(", ")", ";", "isStore", "=", "MCID", ".", "mayStore", "(", ")", ";", "uint64_t", "TSFlags", "=", "MCID", ".", "TSFlags", ";", "isFirst", "=", "TSFlags", "&", "<STR_LIT>", "::" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "minus", ":", "DF", "(", "float_extend", ":", "DF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "float_extend", ":", "DF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "]" ]

[ "(", "zero_extend", ":", "V4SI", "(", "match_operand", ":", "V4HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "const_vector", ":", "V4SI", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")" ]

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

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

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

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "size", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "U", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opcode", ";" ]

[ ";" ]

[ "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "NE", ":", "{", "if", "(", "y_lo", "==", "const0_rtx", "||", "y_hi", "==", "const0_rtx", ")", "{", "if", "(", "y_lo", "!=", "const0_rtx", ")", "{", "rtx", "scratch2", "=", "scratch", "?", "scratch", ":", "gen_reg_rtx", "(", "SImode", ")", ";", "gcc_assert", "(", "y_hi", "==", "const0_rtx", ")", ";", "y_lo", "=", "gen_int_mode", "(", "-", "INTVAL", "(", "y_lo", ")", ",", "SImode", ")", ";", "if", "(", "!", "arm_add_operand", "(", "y_lo", ",", "SImode", ")", ")", "y_lo", "=", "force_reg", "(", "SImode", ",", "y_lo", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "scratch2", ",", "x_lo", ",", "y_lo", ")", ")", ";", "x_lo", "=", "scratch2", ";", "}", "else", "if", "(", "y_hi", "!=", "const0_rtx", ")", "{", "rtx", "scratch2", "=", "scratch", "?", "scratch", ":", "gen_reg_rtx", "(", "SImode", ")", ";", "y_hi", "=", "gen_int_mode", "(", "-", "INTVAL", "(", "y_hi", ")", ",", "SImode", ")", ";", "if", "(", "!", "arm_add_operand", "(", "y_hi", ",", "SImode", ")", ")", "y_hi", "=", "force_reg", "(", "SImode", ",", "y_hi", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "scratch2", ",", "x_hi", ",", "y_hi", ")", ")", ";", "x_hi", "=", "scratch2", ";", "}", "if", "(", "!", "scratch", ")", "{", "gcc_assert", "(", "!", "reload_completed", ")", ";", "scratch", "=", "gen_rtx_SCRATCH", "(", "SImode", ")", ";", "}", "rtx", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "scratch", ")", ";", "cc_reg", "=", "gen_rtx_REG", "(", "CC_NZmode", ",", "CC_REGNUM", ")", ";", "rtx", "set", "=", "gen_rtx_SET", "(", "cc_reg", ",", "gen_rtx_COMPARE", "(", "CC_NZmode", ",", "gen_rtx_IOR", "(", "SImode", ",", "x_lo", ",", "x_hi", ")", ",", "const0_rtx", ")", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "set", ",", "clobber", ")", ")", ")", ";", "return", "cc_reg", ";", "}", "if", "(", "!", "arm_add_operand", "(", "y_lo", ",", "SImode", ")", ")", "y_lo", "=", "force_reg", "(", "SImode", ",", "y_lo", ")", ";", "if", "(", "!", "arm_add_operand", "(", "y_hi", ",", "SImode", ")", ")", "y_hi", "=", "force_reg", "(", "SImode", ",", "y_hi", ")", ";", "rtx", "cmp1", "=", "gen_rtx_NE", "(", "SImode", ",", "x_lo", ",", "y_lo", ")", ";", "rtx", "cmp2", "=", "gen_rtx_NE", "(", "SImode", ",", "x_hi", ",", "y_hi", ")", ";", "rtx", "conjunction", "=", "gen_rtx_IOR", "(", "SImode", ",", "cmp1", ",", "cmp2", ")", ";", "mode", "=", "SELECT_CC_MODE", "(", "code", ",", "conjunction", ",", "const0_rtx", ")", ";", "cc_reg", "=", "gen_rtx_REG", "(", "mode", ",", "CC_REGNUM", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cc_reg", ",", "gen_rtx_COMPARE", "(", "mode", ",", "conjunction", ",", "const0_rtx", ")", ")", ")", ";", "return", "cc_reg" ]

[ "<STR_LIT>", ")" ]

[ "(", "match_operator", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "[", "(", "cc0", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", "]" ]

[ "!", "G", "->", "getGlobal", "(", ")", "->", "isWeakForLinker", "(", ")", ";" ]

[ "static", "bool", "isLocalCall", "(", "const", "SDValue", "&", "Callee", ")", "{", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "return", "!", "G", "->", "getGlobal", "(", ")", "->", "isDeclaration", "(", ")", "&&" ]

[ "<FIXS>", "explicit", "SparcAsmPrinter", "(", "raw_ostream", "&", "O", ",", "TargetMachine", "&", "TM", ",", "const", "TargetAsmInfo", "*", "T", ",", "unsigned", "OL", ",", "bool", "V", ")", ":", "AsmPrinter", "(", "O", ",", "TM", ",", "T", ",", "OL", ",", "V", ")", "{", "}", "<FIXE>" ]

[ "typedef", "std", "::", "map", "const", "Value", "*", ",", "unsigned", ">", "ValueMapTy", ";", "ValueMapTy", "NumberForBB", ";", "public", ":", "<BUGS>", "SparcAsmPrinter", "(", "raw_ostream", "&", "O", ",", "TargetMachine", "&", "TM", ",", "const", "TargetAsmInfo", "*", "T", ",", "bool", "F", ",", "bool", "V", ")", ":", "AsmPrinter", "(", "O", ",", "TM", ",", "T", ",", "F", ",", "V", ")", "{", "}", "<BUGE>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "<STR_LIT>", "Sparc Assembly Printer", "<STR_LIT>", ";" ]

[ ":" ]

[ "break", ";", "case", "MULT", ":", "internal_error", "(", "<STR_LIT>", "MULT case in cris_op_str", "<STR_LIT>", ")", ";", "break", ";", "case", "DIV", ":", "return", "<STR_LIT>", "div", "<STR_LIT>", ";", "break", ";", "case", "AND", ":", "return", "<STR_LIT>", "and", "<STR_LIT>", ";", "break", ";", "case", "IOR", ":", "return", "<STR_LIT>", "or", "<STR_LIT>", ";", "break", ";", "case", "XOR", ":", "return", "<STR_LIT>", "xor", "<STR_LIT>", ";", "break", ";", "case", "NOT", ":", "return", "<STR_LIT>", "not", "<STR_LIT>", ";", "break", ";", "case", "ASHIFT", ":", "return", "<STR_LIT>", "lsl", "<STR_LIT>", ";", "break", ";", "case", "LSHIFTRT", ":", "return", "<STR_LIT>", "lsr", "<STR_LIT>", ";", "break", ";", "case", "ASHIFTRT", ":", "return", "<STR_LIT>", "asr", "<STR_LIT>", ";", "break", ";", "case", "UMIN" ]

[ "case", "X86", "::", "KSET1B", ":" ]

[ "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VPCMPEQDYrr", ")", ")", ";", "case", "X86", "::", "AVX512_512_SETALLONES", ":", "{", "unsigned", "Reg", "=", "MIB", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "MIB", "->", "setDesc", "(", "get", "(", "X86", "::", "VPTERNLOGDZrri", ")", ")", ";", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Undef", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "case", "X86", "::", "TEST8ri_NOREX", ":", "MI", ".", "setDesc", "(", "get", "(", "X86", "::", "TEST8ri", ")", ")", ";", "return", "true", ";", "case", "X86", "::", "MOV32ri64", ":", "MI", ".", "setDesc", "(", "get", "(", "X86", "::", "MOV32ri", ")", ")", ";", "return", "true", ";", "case", "X86", "::", "KSET0B", ":", "case", "X86", "::", "KSET0W", ":", "return", "Expand2AddrKreg", "(", "MIB", ",", "get", "(", "X86", "::", "KXORWrr", ")", ",", "X86", "::", "K0", ")", ";", "case", "X86", "::", "KSET0D", ":", "return", "Expand2AddrKreg", "(", "MIB", ",", "get", "(", "X86", "::", "KXORDrr", ")", ",", "X86", "::", "K0", ")", ";", "case", "X86", "::", "KSET0Q", ":", "return", "Expand2AddrKreg", "(", "MIB", ",", "get", "(", "X86", "::", "KXORQrr", ")", ",", "X86", "::", "K0", ")", ";" ]

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

[ "(", "zero_extend", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", ")" ]

[ "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "]", "<NUM_LIT>", ")", ")", "]", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGS>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGE>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGS>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGE>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGS>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGE>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "<BUGS>", "]", "<NUM_LIT>", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP32", ":", "return", "<NUM_LIT>", ";", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT64", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP64", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT64", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP64", ":", "return", "<NUM_LIT>", ";", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP16", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP16", ":" ]

[ "}" ]

[ "static", "bool", "spu_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "reloc_diagnostic", "(", "x", ")", ";", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";" ]

[ "(", "plus", ":", "SI", "(", "mult", ":", "SI", "(", "zero_extend", ":", "SI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "}" ]

[ "if", "(", "M", ".", "debug_compile_units", "(", ")", ".", "empty", "(", ")", ")", "return", "false", ";", "return", "doTransformation", "(", "M", ")", ";" ]

[ "_", "mmask8", "_", "_", "U", ",", "_", "_", "m256i", "_", "_", "A", ",", "const", "unsigned", "int", "_", "_", "imm", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_maskz_srai_epi64", "(", "_" ]

[ "<FIXS>", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<FIXE>" ]

[ "[", "(", "set", "(", "match_operand", ":", "SSEMODE248", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ashift", ":", "SSEMODE248", "(", "match_operand", ":", "SSEMODE248", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "match_operand", ":", "TI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ")" ]

[ "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ "ScheduleHazardRecognizer", "*", "PPCInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "const", "TargetMachine", "*", "TM", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "const", "TargetInstrInfo", "*", "TII", "=", "TM", "->", "getInstrInfo", "(", ")", ";", "assert", "(", "TII", "&&", "<STR_LIT>", "No InstrInfo?", "<STR_LIT>", ")", ";", "return", "new", "PPCHazardRecognizer970", "(", "*", "TII", ")", ";", "}" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "this", "target", "when", "scheduling", "the", "machine", "instructions", "before", "register", "allocation", "." ]

[ "static", "tree", "ix86_d_handle_target_object_format", "(", "void", ")", "{", "const", "char", "*", "objfmt", "=", "NULL", ";", "if", "(", "TARGET_MACHO", ")", "objfmt", "=", "<STR_LIT>", "macho", "<STR_LIT>", ";", "else", "if", "(", "TARGET_COFF", "||", "TARGET_PECOFF", ")", "objfmt", "=", "<STR_LIT>", "coff", "<STR_LIT>", ";", "if", "(", "objfmt", "==", "NULL", ")", "return", "NULL_TREE", ";", "return", "build_string_literal", "(", "strlen", "(", "objfmt", ")", "+", "<NUM_LIT>", ",", "objfmt", ")", ";", "}" ]

[ "Handle", "a", "call", "to", "`", "__traits", "(", "getTargetInfo", ",", "``", "objectFormat", "''", ")", "'", "." ]

[ "else", "LOSE_AND_RETURN", "(", "<STR_LIT>", "unrecognized address", "<STR_LIT>", ",", "x", ")", ";" ]

[ "}", "else", "if", "(", "cris_base_p", "(", "x2", ",", "true", ")", ")", "{", "cris_print_base", "(", "x2", ",", "file", ")", ";", "cris_print_index", "(", "x1", ",", "file", ")", ";", "}", "else", "LOSE_AND_RETURN", "(", "<STR_LIT>", "unrecognized address", "<STR_LIT>", ",", "x", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "x", ")", ")", "{", "putc", "(", "'", "[", "'", ",", "file", ")", ";", "cris_print_base", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "file", ")", ";", "putc", "(", "'", "]", "'", ",", "file", ")", ";", "}" ]

[ ")", ")" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "<STR_LIT>", ")" ]

[ "(", "and", "(", "and", "(", "and", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "return", "describe_cache", "(", "l1_sizekb", ",", "l1_line", ",", "l1_assoc", ",", "l2_sizekb", ")", ";" ]

[ "size_t", "len", "=", "<NUM_LIT>", ";", "sysctlbyname", "(", "<STR_LIT>", "machdep.cacheline_size", "<STR_LIT>", ",", "&", "l1_line", ",", "&", "len", ",", "NULL", ",", "<NUM_LIT>", ")", ";", "l1_sizekb", "=", "<NUM_LIT>", ";", "l1_assoc", "=", "<NUM_LIT>", ";", "l2_sizekb", "=", "<NUM_LIT>", ";" ]

[ "void", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "override", "{", "unsigned", "Size", "=", "<NUM_LIT>", "<<", "getFixupKindLog2Size", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "assert", "(", "Fixup", ".", "getOffset", "(", ")", "+", "Size", "<=", "Data", ".", "size", "(", ")", "&&", "<STR_LIT>", "Invalid fixup offset!", "<STR_LIT>", ")", ";", "assert", "(", "isIntN", "(", "Size", "*", "<NUM_LIT>", "+", "<NUM_LIT>", ",", "Value", ")", "&&", "<STR_LIT>", "Value does not fit in the Fixup field", "<STR_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "Size", ";", "++", "i", ")", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "i", "]", "=", "uint8_t", "(", "Value", ">>", "(", "(", "Size", "-", "i", "-", "<NUM_LIT>", ")", "*", "<NUM_LIT>", ")", ")", ";", "}" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "c", ")", "{" ]

[ "_", "_", "arm_vabavq_s16", "(", "uint32_t", "_", "_", "a", ",", "int16x8_t", "_", "_", "b", ",", "int16x8_t", "_", "_" ]

[ "ScaledIndex", ";" ]

[ "else", "{", "SDValue", "ScaleBroadcast", "=", "getBroadcast", "(", "IndexVT", ",", "Scale", ",", "AVL", ")", ";", "ScaledIndex", "=", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "IndexVT", ",", "{", "Index", ",", "ScaleBroadcast", ",", "Mask", ",", "AVL", "}", ")", ";", "}", "if", "(", "isNullConstant", "(", "BasePtr", ")", ")", "return" ]

[ "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";" ]

[ "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP6_TTMP7", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP8_TTMP9", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP10_TTMP11", ")", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "unsigned", "MaxNumSGPRs", "=", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumSGPRs", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumSGPRs", ";", "i", "<", "TotalNumSGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "unsigned", "MaxNumVGPRs", "=", "ST", ".", "getMaxNumVGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumVGPRs", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumVGPRs", ";", "i", "<", "TotalNumVGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}" ]

[ "_", "_", "P", ")", ";" ]

[ "return", "(", "_", "_", "m512i", ")", "(", "*", "(", "_", "_", "v64qi_u", "*", ")" ]

[ "<FIXS>", "Chain", ",", "dl", ",", "Ext64", ",", "FIdx", ",", "<FIXE>", "<FIXS>", "MVT", "::", "f64", ",", "dl", ",", "Chain", ",", "FIdx", ",", "<FIXE>", "<FIXS>", "SDValue", "FP", "=", "convertIntToFP", "(", "Op", ",", "Ld", ",", "DAG", ",", "Subtarget", ",", "Chain", ")", ";", "if", "(", "IsStrict", ")", "Chain", "=", "FP", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "if", "(", "Op", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", "&&", "!", "Subtarget", ".", "hasFPCVT", "(", ")", ")", "{", "if", "(", "IsStrict", ")", "FP", "=", "DAG", ".", "getNode", "(", "ISD", "::", "STRICT_FP_ROUND", ",", "dl", ",", "{", "MVT", "::", "f32", ",", "MVT", "::", "Other", "}", ",", "{", "Chain", ",", "FP", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "dl", ")", "}", ")", ";", "elseFP", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_ROUND", ",", "dl", ",", "MVT", "::", "f32", ",", "FP", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "dl", ")", ")", ";", "}", "<FIXE>" ]

[ "SDValue", "Store", "=", "DAG", ".", "getStore", "(", "<BUGS>", "DAG", ".", "getEntryNode", "(", ")", ",", "dl", ",", "Ext64", ",", "FIdx", ",", "<BUGE>", "MachinePointerInfo", "::", "getFixedStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "FrameIdx", ")", ")", ";", "Ld", "=", "DAG", ".", "getLoad", "(", "<BUGS>", "MVT", "::", "f64", ",", "dl", ",", "Store", ",", "FIdx", ",", "<BUGE>", "MachinePointerInfo", "::", "getFixedStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "FrameIdx", ")", ")", ";", "}", "<BUGS>", "SDValue", "FP", "=", "convertIntToFP", "(", "Op", ",", "Ld", ",", "DAG", ",", "Subtarget", ")", ";", "if", "(", "Op", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", "&&", "!", "Subtarget", ".", "hasFPCVT", "(", ")", ")", "FP", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_ROUND", ",", "dl", ",", "MVT", "::", "f32", ",", "FP", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "dl", ")", ")", ";", "<BUGE>", "return", "FP", ";", "}" ]

[ "a", ")", ";" ]

[ "return", "_", "_", "builtin_neon_vcvtmhusi", "(", "_", "_" ]

[ ",", "(", "_", "_", "v16si", ")", "_", "_", "W", ",", "(", "_", "_", "mmask16", ")", "_", "_", "U", ")", ";" ]

[ "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_pandnd512_mask", "(", "(", "_", "_", "v16si", ")", "_", "_", "A", ",", "(", "_", "_", "v16si", ")", "_", "_", "B" ]

[ ")", "{" ]

[ "static", "llvm", "::", "DenseMap", "<", "unsigned", ",", "MCFixupKindInfo", ">", "Infos", "=", "{", "{", "<STR_LIT>", "::", "<STR_LIT>", "::", "fixup_csky_addr32", ",", "{", "<STR_LIT>", "fixup_csky_addr32", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", "::", "fixup_csky_addr_hi16", ",", "{", "<STR_LIT>", "fixup_csky_addr_hi16", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", "::", "fixup_csky_addr_lo16", ",", "{", "<STR_LIT>", "fixup_csky_addr_lo16", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", "::", "fixup_csky_pcrel_imm16_scale2", ",", "{", "<STR_LIT>", "fixup_csky_pcrel_imm16_scale2", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", "::", "fixup_csky_pcrel_uimm16_scale4", ",", "{", "<STR_LIT>", "fixup_csky_pcrel_uimm16_scale4", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", "::", "fixup_csky_pcrel_uimm8_scale4", ",", "{", "<STR_LIT>", "fixup_csky_pcrel_uimm8_scale4", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", "::", "fixup_csky_pcrel_imm26_scale2", ",", "{", "<STR_LIT>", "fixup_csky_pcrel_imm26_scale2", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", "::", "fixup_csky_pcrel_imm18_scale2", ",", "{", "<STR_LIT>", "fixup_csky_pcrel_imm18_scale2", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", "::", "fixup_csky_got32", ",", "{", "<STR_LIT>", "fixup_csky_got32", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", "::", "fixup_csky_got_imm18_scale4", ",", "{", "<STR_LIT>", "fixup_csky_got_imm18_scale4", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", "::", "fixup_csky_gotoff", ",", "{", "<STR_LIT>", "fixup_csky_gotoff", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", "::", "fixup_csky_gotpc", ",", "{", "<STR_LIT>", "fixup_csky_gotpc", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", "::", "fixup_csky_plt32", ",", "{", "<STR_LIT>", "fixup_csky_plt32", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", "::", "fixup_csky_plt_imm18_scale4", ",", "{", "<STR_LIT>", "fixup_csky_plt_imm18_scale4", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", "::", "fixup_csky_pcrel_imm10_scale2", ",", "{", "<STR_LIT>", "fixup_csky_pcrel_imm10_scale2", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", "::", "fixup_csky_pcrel_uimm7_scale4", ",", "{", "<STR_LIT>", "fixup_csky_pcrel_uimm7_scale4", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", "::", "fixup_csky_doffset_imm18", ",", "{", "<STR_LIT>", "fixup_csky_doffset_imm18", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", "::", "fixup_csky_doffset_imm18_scale2", ",", "{", "<STR_LIT>", "fixup_csky_doffset_imm18_scale2", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", "::", "fixup_csky_doffset_imm18_scale4", ",", "{", "<STR_LIT>", "fixup_csky_doffset_imm18_scale4", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", "}", ";", "assert", "(", "Infos", ".", "size", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "<STR_LIT>", "Not all fixup kinds added to Infos array", "<STR_LIT>", ")", ";", "if", "(", "FirstTargetFixupKind", "<=", "Kind", "&&", "Kind", "<", "FirstLiteralRelocationKind", ")", "{", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "<STR_LIT>", "Invalid kind!", "<STR_LIT>", ")", ";", "return", "Infos", "[", "Kind", "]", ";", "}", "else", "if", "(", "Kind", "<", "FirstTargetFixupKind" ]

[ "void", "x86_emit_floatuns", "(", "rtx", "operands", "[", "<NUM_LIT>", "]", ")", "{", "rtx_code_label", "*", "neglab", ",", "*", "donelab", ";", "rtx", "i0", ",", "i1", ",", "f0", ",", "in", ",", "out", ";", "machine_mode", "mode", ",", "inmode", ";", "inmode", "=", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "gcc_assert", "(", "inmode", "==", "SImode", "||", "inmode", "==", "DImode", ")", ";", "out", "=", "operands", "[", "<NUM_LIT>", "]", ";", "in", "=", "force_reg", "(", "inmode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "mode", "=", "GET_MODE", "(", "out", ")", ";", "neglab", "=", "gen_label_rtx", "(", ")", ";", "donelab", "=", "gen_label_rtx", "(", ")", ";", "f0", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_cmp_and_jump_insns", "(", "in", ",", "const0_rtx", ",", "LT", ",", "const0_rtx", ",", "inmode", ",", "<NUM_LIT>", ",", "neglab", ")", ";", "expand_float", "(", "out", ",", "in", ",", "<NUM_LIT>", ")", ";", "emit_jump_insn", "(", "gen_jump", "(", "donelab", ")", ")", ";", "emit_barrier", "(", ")", ";", "emit_label", "(", "neglab", ")", ";", "i0", "=", "expand_simple_binop", "(", "inmode", ",", "LSHIFTRT", ",", "in", ",", "const1_rtx", ",", "NULL", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "i1", "=", "expand_simple_binop", "(", "inmode", ",", "AND", ",", "in", ",", "const1_rtx", ",", "NULL", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "i0", "=", "expand_simple_binop", "(", "inmode", ",", "IOR", ",", "i0", ",", "i1", ",", "i0", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "expand_float", "(", "f0", ",", "i0", ",", "<NUM_LIT>", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "out", ",", "gen_rtx_PLUS", "(", "mode", ",", "f0", ",", "f0", ")", ")", ")", ";", "emit_label", "(", "donelab", ")", ";", "}" ]

[ "Generate", "an", "unsigned", "DImode/SImode", "to", "FP", "conversion", ".", "This", "is", "the", "same", "code", "optabs", "would", "emit", "if", "we", "did", "n't", "have", "TFmode", "patterns", "." ]

[ "}" ]

[ "if", "(", "auto", "*", "ShiftConst", "=", "BVAmt", "->", "getConstantSplatNode", "(", ")", ")", "{", "uint64_t", "ShiftAmt", "=", "ShiftConst", "->", "getZExtValue", "(", ")", ";", "if", "(", "SupportedVectorShiftWithImm", "(", "VT", ",", "Subtarget", ",", "Op", ".", "getOpcode", "(", ")", ")", ")", "return", "getTargetVShiftByConstNode", "(", "X86Opc", ",", "dl", ",", "VT", ",", "R", ",", "ShiftAmt", ",", "DAG", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "v2i64", "||", "(", "Subtarget", "->", "hasInt256", "(", ")", "&&", "VT", "==", "MVT", "::", "v4i64", ")", ")", "&&", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SRA", ")", "return", "ArithmeticShiftRight64", "(", "ShiftAmt", ")", ";", "if", "(", "VT", "==", "MVT", "::", "v16i8", "||", "(", "Subtarget", "->", "hasInt256", "(", ")", "&&", "VT", "==", "MVT", "::", "v32i8", ")", ")", "{", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "MVT", "ShiftVT", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i16", ",", "NumElts", "/", "<NUM_LIT>", ")", ";", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SHL", ")", "{", "if", "(", "ShiftAmt", "==", "<NUM_LIT>", ")", "return", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "VT", ",", "R", ",", "R", ")", ";", "SDValue", "SHL", "=", "getTargetVShiftByConstNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ShiftVT", ",", "R", ",", "ShiftAmt", ",", "DAG", ")", ";", "SHL", "=", "DAG", ".", "getBitcast", "(", "VT", ",", "SHL", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "V", "(", "NumElts", ",", "DAG", ".", "getConstant", "(", "uint8_t", "(", "-", "<NUM_LIT>", "U", "<<", "ShiftAmt", ")", ",", "dl", ",", "MVT", "::", "i8", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "dl", ",", "VT", ",", "SHL", ",", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "dl", ",", "VT", ",", "V", ")", ")", ";", "}", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SRL", ")", "{", "SDValue", "SRL", "=", "getTargetVShiftByConstNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ShiftVT", ",", "R", ",", "ShiftAmt", ",", "DAG", ")", ";", "SRL", "=", "DAG", ".", "getBitcast", "(", "VT", ",", "SRL", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "V", "(", "NumElts", ",", "DAG", ".", "getConstant", "(", "uint8_t", "(", "-", "<NUM_LIT>", "U", ")", ">>", "ShiftAmt", ",", "dl", ",", "MVT", "::", "i8", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "dl", ",", "VT", ",", "SRL", ",", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "dl", ",", "VT", ",", "V", ")", ")", ";", "}", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SRA", ")", "{", "if", "(", "ShiftAmt", "==", "<NUM_LIT>", ")", "{", "SDValue", "Zeros", "=", "getZeroVector", "(", "VT", ",", "Subtarget", ",", "DAG", ",", "dl", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "Zeros", ",", "R", ")", ";", "}", "SDValue", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "dl", ",", "VT", ",", "R", ",", "Amt", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "V", "(", "NumElts", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ">>", "ShiftAmt", ",", "dl", ",", "MVT", "::", "i8", ")", ")", ";", "SDValue", "Mask", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "dl", ",", "VT", ",", "V", ")", ";", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "XOR", ",", "dl", ",", "VT", ",", "Res", ",", "Mask", ")", ";", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "dl", ",", "VT", ",", "Res", ",", "Mask", ")", ";", "return", "Res", ";", "}", "llvm_unreachable", "(", "<STR_LIT>", "Unknown shift opcode.", "<STR_LIT>", ")", ";", "}", "}", "}", "if", "(", "!", "Subtarget", "->", "is64Bit", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "v2i64", "||", "(", "Subtarget", "->", "hasInt256", "(", ")", "&&", "VT", "==", "MVT", "::", "v4i64", ")", ")", "&&", "Amt", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", "&&", "Amt", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BUILD_VECTOR", ")", "{", "Amt", "=", "Amt", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "unsigned", "Ratio", "=", "Amt", ".", "getSimpleValueType", "(", ")", ".", "getVectorNumElements", "(", ")", "/", "VT", ".", "getVectorNumElements", "(", ")", ";", "unsigned", "RatioInLog2", "=", "Log2_32_Ceil", "(", "Ratio", ")", ";", "uint64_t", "ShiftAmt", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "Ratio", ";", "++", "i", ")", "{", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Amt", ".", "getOperand", "(", "i", ")", ")", ";", "if", "(", "!", "C", ")", "return", "SDValue", "(", ")", ";", "ShiftAmt", "|=", "C", "->", "getZExtValue", "(", ")", "<<", "(", "i", "*", "(", "<NUM_LIT>", "<<", "(", "<NUM_LIT>", "-", "RatioInLog2", ")", ")", ")", ";" ]

[ ")", "if", "(", "!", "isCalleeSavedRegister", "(", "MI", ".", "getOperand", "(", "i", ")", ".", "getReg", "(", ")", ",", "CSRegs", ")", ")", "return", "false", ";" ]

[ "for", "(", "int", "i", "=", "<NUM_LIT>", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ";", "i", "!=", "e", ";", "++", "i" ]

[ ",", "<STR_LIT>", ">", ";" ]

[ "def", "CondVariantLE", ":", "CondVariant", "<", "<NUM_LIT>", ",", "<STR_LIT>", ",", "<NUM_LIT>" ]

[ "(", "decl", ")", ")", ";" ]

[ "if", "(", "!", "(", "HAS_DECL_ASSEMBLER_NAME_P", "(", "decl", ")", "&&", "DECL_ASSEMBLER_NAME_SET_P", "(", "decl", ")", ")", ")", "return", "false", ";", "const", "char", "*", "name", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME" ]

[ "}" ]

[ "else", "setCodeModel", "(", "CodeModel", "::", "Large", ")", ";", "}", "PM", ".", "add", "(", "createX86CodeEmitterPass", "(", "*", "this", ",", "MCE", ")", ")", ";", "if", "(", "DumpAsm", ")", "{", "assert", "(", "AsmPrinterCtor", "&&", "<STR_LIT>", "AsmPrinter was not linked in", "<STR_LIT>", ")", ";", "if", "(", "AsmPrinterCtor", ")", "PM", ".", "add", "(", "AsmPrinterCtor", "(", "errs", "(", ")", ",", "*", "this", ",", "Fast", ")", ")", ";", "}", "return", "false", ";" ]

[ ")", "const", "{" ]

[ "bool", "isPredictableSelectIsExpensive", "(" ]

[ ")" ]

[ "(", "define_automaton", "<STR_LIT>" ]

[ "<FIXS>", "multiclass", "NI_2VE_v3_2op", "bit", "u", ",", "bits", "<NUM_LIT>", ">", "opcode", ",", "string", "asmop", ">", "{", "<FIXE>" ]

[ "defm", "SQDMLALvve", ":", "NI_2VE_v3", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "defm", "SQDMLSLvve", ":", "NI_2VE_v3", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "<BUGS>", "multiclass", "NI_2VE_v3_2op", "bit", "u", ",", "bits", "<NUM_LIT>", ">", "opcode", ",", "string", "asmop", ">", "{", "<BUGE>", "def", "_2d2s", ":", "NI_2VE_2op", "<NUM_LIT>", ",", "u", ",", "<NUM_LIT>", ",", "opcode", ",", "asmop", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "neon_uimm2_bare", ",", "VPR128", ",", "VPR64", ",", "VPR128", ">", "{" ]

[ "bool", "DirectXTargetMachine", "::", "addPassesToEmitFile", "(", "PassManagerBase", "&", "PM", ",", "raw_pwrite_stream", "&", "Out", ",", "raw_pwrite_stream", "*", "DwoOut", ",", "CodeGenFileType", "FileType", ",", "bool", "DisableVerify", ",", "MachineModuleInfoWrapperPass", "*", "MMIWP", ")", "{", "switch", "(", "FileType", ")", "{", "case", "CGFT_AssemblyFile", ":", "PM", ".", "add", "(", "createPrintModulePass", "(", "Out", ",", "<STR_LIT>", "<STR_LIT>", ",", "true", ")", ")", ";", "break", ";", "case", "CGFT_ObjectFile", ":", "PM", ".", "add", "(", "createBitcodeWriterPass", "(", "Out", ",", "true", ",", "false", ",", "false", ")", ")", ";", "break", ";", "case", "CGFT_Null", ":", "break", ";", "}", "return", "false", ";", "}" ]

[ "Add", "passes", "to", "the", "specified", "pass", "manager", "to", "get", "the", "specified", "file", "emitted", "." ]

[ "_", "p", ")", ";" ]

[ "_", "_", "arm_vld1q_z_f32", "(", "float32_t", "const", "*", "_", "_", "base", ",", "mve_pred16_t", "_", "_", "p", ")", "{", "return", "vldrwq_z_f32", "(", "_", "_", "base", ",", "_" ]

[ "}" ]

[ "unsigned", "getEUsPerCU", "(", ")", "const", "{", "return", "AMDGPU", "::", "IsaInfo", "::", "getEUsPerCU", "(", "getFeatureBits", "(", ")", ")", ";" ]

[ "void", "SIRegisterInfo", "::", "materializeFrameBaseRegister", "(", "MachineBasicBlock", "*", "MBB", ",", "Register", "BaseReg", ",", "int", "FrameIdx", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "Ins", "=", "MBB", "->", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "Ins", "!=", "MBB", "->", "end", "(", ")", ")", "DL", "=", "Ins", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "if", "(", "Offset", "==", "<NUM_LIT>", ")", "{", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "BaseReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ";", "return", ";", "}", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "Register", "OffsetReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "Register", "FIReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "Offset", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "FIReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ";", "TII", "->", "getAddNoCarry", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "BaseReg", ")", ".", "addReg", "(", "OffsetReg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "FIReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}" ]

[ "Insert", "defining", "instruction", "(", "s", ")", "for", "a", "pointer", "to", "FrameIdx", "before", "insertion", "point", "I", "." ]

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

[ "const", "LLT", "F32", "=", "LLT", "::", "float32", "(", ")", ";", "if", "(", "Ty", "==", "F32", ")", "{", "auto", "Log", "=", "B", ".", "buildFLog2", "(", "F32", ",", "Src0", ",", "Flags", ")", ";", "auto", "Mul", "=", "B", ".", "buildIntrinsic", "(", "Intrinsic", "::", "amdgcn_fmul_legacy", ",", "{", "F32", "}", ")", ".", "addUse", "(", "Log", ".", "getReg", "(", "<NUM_LIT>", ")", ")", ".", "addUse", "(", "Src1", ")", ".", "setMIFlags", "(", "Flags", ")", ";", "B", ".", "buildFExp2", "(", "Dst", ",", "Mul", ",", "Flags", ")", ";", "}", "else", "if", "(", "Ty", "==", "F16", ")", "{", "auto", "Log", "=", "B", ".", "buildFLog2", "(", "F16", ",", "Src0", ",", "Flags", ")", ";", "auto", "Ext0", "=", "B", ".", "buildFPExt", "(", "F32", ",", "Log", ",", "Flags", ")", ";", "auto", "Ext1", "=", "B", ".", "buildFPExt", "(", "F32", ",", "Src1", ",", "Flags", ")", ";", "auto", "Mul", "=", "B", ".", "buildIntrinsic", "(", "Intrinsic", "::", "amdgcn_fmul_legacy", ",", "{", "F32", "}", ")", ".", "addUse", "(", "Ext0", ".", "getReg", "(", "<NUM_LIT>", ")", ")", ".", "addUse", "(", "Ext1", ".", "getReg", "(", "<NUM_LIT>", ")", ")", ".", "setMIFlags", "(", "Flags", ")", ";", "B", ".", "buildFExp2", "(", "Dst", ",", "B", ".", "buildFPTrunc", "(", "F16", ",", "Mul", ")", ",", "Flags", ")", ";", "}", "else", "return", "false", ";", "MI", ".", "eraseFromParent" ]

[ "}" ]

[ "bool", "hasInstFwdPrefetchBug", "(", ")", "const", "{", "return", "HasInstFwdPrefetchBug", ";" ]

[ ",", "STI", ")", ";" ]

[ "return", "llvm", "::", "createCpu0SETargetLowering", "(", "TM" ]

[ "(", "ior", ":", "VEC", "(", "not", ":", "DI", "(", "match_operand", ":", "VEC", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "VEC", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "X86_INTRINSIC_DATA", "(", "avx512_mask_cvtpd2udq_128", ",", "CVTPD2I_MASK", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<FIXE>" ]

[ "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ")", ",", "X86_INTRINSIC_DATA", "(", "avx512_mask_cvtpd2qq_512", ",", "INTR_TYPE_1OP_MASK", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<BUGS>", "X86_INTRINSIC_DATA", "(", "avx512_mask_cvtpd2udq_128", ",", "INTR_TYPE_1OP_MASK", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ")", ",", "<BUGE>", "X86_INTRINSIC_DATA", "(", "avx512_mask_cvtpd2udq_256", ",", "INTR_TYPE_1OP_MASK", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ")", ",", "X86_INTRINSIC_DATA", "(", "avx512_mask_cvtpd2udq_512", ",", "INTR_TYPE_1OP_MASK", "," ]

[ "}" ]

[ "}", "}", "switch", "(", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "EmitByte", "(", "<NUM_LIT>", ",", "CurByte", ",", "OS", ")", ";", "break", ";", "}", "switch", "(", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "EmitByte", "(", "<NUM_LIT>", ",", "CurByte", ",", "OS", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "EmitByte", "(", "<NUM_LIT>", ",", "CurByte", ",", "OS", ")", ";", "break", ";", "}", "return", "Ret", ";" ]

[ "_", "b", ")", ";" ]

[ "return", "_", "_", "builtin_neon_vdup_lanev8hf", "(", "_", "_", "a", ",", "_" ]

[ "MinFixedObjOffset", "-=", "std", "::", "abs", "(", "MinFixedObjOffset", ")", "%", "<NUM_LIT>", ";" ]

[ "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "WinEHFuncInfo", "&", "EHInfo", "=", "*", "MF", ".", "getWinEHFuncInfo", "(", ")", ";", "int64_t", "MinFixedObjOffset", "=", "-", "SlotSize", ";", "for", "(", "int", "I", "=", "MFI", ".", "getObjectIndexBegin", "(", ")", ";", "I", "<", "<NUM_LIT>", ";", "++", "I", ")", "MinFixedObjOffset", "=", "std", "::", "min", "(", "MinFixedObjOffset", ",", "MFI", ".", "getObjectOffset", "(", "I", ")", ")", ";", "for", "(", "WinEHTryBlockMapEntry", "&", "TBME", ":", "EHInfo", ".", "TryBlockMap", ")", "{", "for", "(", "WinEHHandlerType", "&", "H", ":", "TBME", ".", "HandlerArray", ")", "{", "int", "FrameIndex", "=", "H", ".", "CatchObj", ".", "FrameIndex", ";", "if", "(", "FrameIndex", "!=", "INT_MAX", ")", "{", "unsigned", "Align", "=", "MFI", ".", "getObjectAlign", "(", "FrameIndex", ")", ".", "value", "(", ")", ";", "MinFixedObjOffset", "-=", "std", "::", "abs", "(", "MinFixedObjOffset", ")", "%", "Align", ";", "MinFixedObjOffset", "-=", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "MFI", ".", "setObjectOffset", "(", "FrameIndex", ",", "MinFixedObjOffset", ")", ";", "}", "}", "}" ]

[ "+", "<NUM_LIT>", ")", "/", "<NUM_LIT>", ";" ]

[ "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "GetElementPtr", ":", "if", "(", "Idx", "==", "<NUM_LIT>", ")", "return", "<NUM_LIT>", "*", "TTI", "::", "TCC_Basic", ";", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "Store", ":", "ImmIdx", "=", "<NUM_LIT>", ";", "break", ";", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Mul", ":", "case", "Instruction", "::", "UDiv", ":", "case", "Instruction", "::", "SDiv", ":", "case", "Instruction", "::", "URem", ":", "case", "Instruction", "::", "SRem", ":", "case", "Instruction", "::", "And", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "case", "Instruction", "::", "ICmp", ":", "ImmIdx", "=", "<NUM_LIT>", ";", "break", ";", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "if", "(", "Idx", "==", "<NUM_LIT>", ")", "return", "TTI", "::", "TCC_Free", ";", "break", ";", "case", "Instruction", "::", "Trunc", ":", "case", "Instruction", "::", "ZExt", ":", "case", "Instruction", "::", "SExt", ":", "case", "Instruction", "::", "IntToPtr", ":", "case", "Instruction", "::", "PtrToInt", ":", "case", "Instruction", "::", "BitCast", ":", "case", "Instruction", "::", "PHI", ":", "case", "Instruction", "::", "Call", ":", "case", "Instruction", "::", "Select", ":", "case", "Instruction", "::", "Ret", ":", "case", "Instruction", "::", "Load", ":", "break", ";", "}", "if", "(", "Idx", "==", "ImmIdx", ")", "{", "int", "NumConstants", "=", "(", "BitSize" ]

[ ";" ]

[ "mode", "=", "GET_MODE", "(", "recog_data", ".", "operand", "[", "<NUM_LIT>", "]", ")", ";", "switch", "(", "mode", ")", "{", "case", "OImode", ":", "return", "<NUM_LIT>", ";", "case", "CImode", ":", "return", "<NUM_LIT>" ]

[ "<STR_LIT>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "unspec_volatile", ":", "SI", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_VOLATILE_CCTL_VA_WBINVAL_LA", ")", "]", "<STR_LIT>" ]

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

[ "(", "if_then_else", "(", "match_operator", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "{", "insn", "=", "emit_insn", "(", "gen_movsi", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "}", "<FIXE>", "<FIXS>", "{", "insn", "=", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "amount", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "}", "<FIXE>" ]

[ "}", "if", "(", "frame_pointer_needed", ")", "<BUGS>", "emit_insn", "(", "gen_movsi", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ")", ";", "<BUGE>", "if", "(", "amount", ")", "{", "amount", "=", "ROUND_UP_WORD", "(", "amount", ")", ";", "if", "(", "amount", "<NUM_LIT>", ")", "<BUGS>", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "amount", ")", ")", ")", ";", "<BUGE>", "else", "{", "int", "regno", ";" ]

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

[ "(", "mem", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI" ]

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

[ "(", "unspec", ":", "DI", "[", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ "}" ]

[ "class", "BGTZALC_MMR6_DESC", ":", "CMP_CBR_RT_Z_MMR6_DESC_BASE", "<", "<STR_LIT>", ",", "brtarget_mm", ",", "GPR32Opnd", ">", "{", "list", "<", "Register", ">", "Defs", "=", "[", "RA", "]", ";" ]

[ "MadeChange", "=", "false", ";" ]

[ "const", "MipsInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "inMips16Mode", "(", ")", ")", "return", "false", ";", "if", "(", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "&&", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "isABI_O32", "(", ")", "&&", "F", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "globalBaseRegSet", "(", ")", ")", "emitGPDisp", "(", "F", ",", "TII", ")", ";", "if", "(", "SkipLongBranch", ")", "return", "true", ";", "MF", "=", "&", "F", ";", "initMBBInfo", "(", ")", ";", "SmallVectorImpl", "<", "MBBInfo", ">", "::", "iterator", "I", ",", "E", "=", "MBBInfos", ".", "end", "(", ")", ";", "bool", "EverMadeChange", "=", "false", ",", "MadeChange", "=", "true", ";", "while", "(", "MadeChange", ")", "{" ]

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

[ "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits" ]

[ "::", "<STR_LIT>", ":" ]

[ "switch", "(", "Desc", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown instruction size!", "<STR_LIT>", ")", ";", "case", "TargetOpcode", "::", "PROLOG_LABEL", ":", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "<NUM_LIT>", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "{", "const", "MachineFunction", "*", "MF", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "return", "TII", ".", "getInlineAsmLength", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSymbolName", "(", ")", ",", "*", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown instruction size!", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "case", "<STR_LIT>" ]

[ "<STR_LIT>", ";" ]

[ "int32_t", "OffImm", "=", "(", "int32_t", ")", "MO2", ".", "getImm", "(", ")", ";", "if", "(", "OffImm", "<", "<NUM_LIT>", ")", "O", "<<", "<STR_LIT>", ", #-", "<STR_LIT>", "<<", "-", "OffImm", ";", "else", "if", "(", "OffImm", ">", "<NUM_LIT>", ")", "O", "<<", "<STR_LIT>", ", #", "<STR_LIT>", "<<", "OffImm", ";", "O", "<<", "<STR_LIT>", "]" ]

[ "<FIXS>", "buildScratchExecCopy", "(", "LiveRegs", ",", "MF", ",", "MBB", ",", "MBBI", ",", "DL", ",", "true", ")", ";", "<FIXE>" ]

[ "for", "(", "auto", "ReservedWWM", ":", "FuncInfo", "->", "wwmAllocation", "(", ")", ")", "{", "if", "(", "!", "ScratchExecCopy", ")", "ScratchExecCopy", "=", "<BUGS>", "buildScratchExecCopy", "(", "LiveRegs", ",", "MF", ",", "MBB", ",", "MBBI", ",", "true", ")", ";", "<BUGE>", "buildPrologSpill", "(", "ST", ",", "TRI", ",", "*", "FuncInfo", ",", "LiveRegs", ",", "MF", ",", "MBB", ",", "MBBI", ",", "DL", ",", "std", "::", "get", "<NUM_LIT>", ">", "(", "ReservedWWM", ")", ",", "std", "::", "get", "<NUM_LIT>", ">", "(", "ReservedWWM", ")", ")", ";" ]

[ "}" ]

[ "rtx", "(", "*", "gen_mem_ref", ")", "(", "machine_mode", ",", "rtx", ")", "=", "(", "frame_pointer_needed", "?", "gen_frame_mem", ":", "gen_rtx_MEM", ")", ";", "unsigned", "regno", ";", "unsigned", "regno2", ";", "HOST_WIDE_INT", "offset", ";", "for", "(", "regno", "=", "aarch64_next_callee_save", "(", "start", ",", "limit", ")", ";", "regno", "<=", "limit", ";", "regno", "=", "aarch64_next_callee_save", "(", "regno", "+", "<NUM_LIT>", ",", "limit", ")", ")", "{", "if", "(", "cfun", "->", "machine", "->", "reg_is_wrapped_separately", "[", "regno", "]", ")", "continue", ";", "rtx", "reg", ",", "mem", ";", "if", "(", "skip_wb", "&&", "(", "regno", "==", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate1", "||", "regno", "==", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate2", ")", ")", "continue", ";", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "offset", "=", "start_offset", "+", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", ";", "mem", "=", "gen_mem_ref", "(", "mode", ",", "plus_constant", "(", "Pmode", ",", "base_rtx", ",", "offset", ")", ")", ";", "regno2", "=", "aarch64_next_callee_save", "(", "regno", "+", "<NUM_LIT>", ",", "limit", ")", ";", "if", "(", "regno2", "<=", "limit", "&&", "!", "cfun", "->", "machine", "->", "reg_is_wrapped_separately", "[", "regno2", "]", "&&", "(", "(", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", "+", "UNITS_PER_WORD", ")", "==", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno2", "]", ")", ")", "{", "rtx", "reg2", "=", "gen_rtx_REG", "(", "mode", ",", "regno2", ")", ";", "rtx", "mem2", ";", "offset", "=", "start_offset", "+", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno2", "]", ";", "mem2", "=", "gen_mem_ref", "(", "mode", ",", "plus_constant", "(", "Pmode", ",", "base_rtx", ",", "offset", ")", ")", ";", "emit_insn", "(", "aarch64_gen_load_pair", "(", "mode", ",", "reg", ",", "mem", ",", "reg2", ",", "mem2", ")", ")", ";", "*", "cfi_ops", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg2", ",", "*", "cfi_ops", ")", ";", "regno", "=", "regno2", ";", "}", "else", "emit_move_insn", "(", "reg", ",", "mem", ")", ";", "*", "cfi_ops", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "*", "cfi_ops", ")", ";" ]

[ "bool", "aarch64_is_noplt_call_p", "(", "rtx", "sym", ")", "{", "const_tree", "decl", "=", "SYMBOL_REF_DECL", "(", "sym", ")", ";", "if", "(", "flag_pic", "&&", "decl", "&&", "(", "!", "flag_plt", "||", "lookup_attribute", "(", "<STR_LIT>", "noplt", "<STR_LIT>", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", "&&", "!", "targetm", ".", "binds_local_p", "(", "decl", ")", ")", "return", "true", ";", "return", "false", ";", "}" ]

[ "Return", "true", "if", "calls", "to", "symbol-ref", "SYM", "should", "not", "go", "through", "plt", "stubs", "." ]

[ ".", "addReg", "(", "IfTrueReg", ")", ".", "addFrameIndex", "(", "ScratchFI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";" ]

[ "const", "BasicBlock", "*", "LLVM_BB", "=", "MBB", "->", "getBasicBlock", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "::", "iterator", "It", "=", "MBB", ";", "++", "It", ";", "unsigned", "DestReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "IfTrueReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "IfFalseReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "CondCode", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "bool", "NZCVKilled", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isKill", "(", ")", ";", "MachineBasicBlock", "*", "TrueBB", "=", "MF", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "EndBB", "=", "MF", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MF", "->", "insert", "(", "It", ",", "TrueBB", ")", ";", "MF", "->", "insert", "(", "It", ",", "EndBB", ")", ";", "EndBB", "->", "splice", "(", "EndBB", "->", "begin", "(", ")", ",", "MBB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "MBB", "->", "end", "(", ")", ")", ";", "EndBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "MBB", ")", ";", "int", "ScratchFI", "=", "MF", "->", "getFrameInfo", "(", ")", "->", "CreateSpillStackObject", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "IfFalseReg", ")", ".", "addFrameIndex", "(", "ScratchFI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "CondCode", ")", ".", "addMBB", "(", "TrueBB", ")", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addMBB", "(", "EndBB", ")", ";", "MBB", "->", "addSuccessor", "(", "TrueBB", ")", ";", "MBB", "->", "addSuccessor", "(", "EndBB", ")", ";", "if", "(", "!", "NZCVKilled", ")", "{", "TrueBB", "->", "addLiveIn", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "EndBB", "->", "addLiveIn", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "BuildMI", "(", "TrueBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")" ]

[ "<FIXS>", "static", "boolix86_libc_has_fast_function", "(", "int", "fcode", "ATTRIBUTE_UNUSED", ")", "<FIXE>" ]

[ "#", "undef", "TARGET_MEMTAG_TAG_SIZE", "#", "define", "TARGET_MEMTAG_TAG_SIZE", "ix86_memtag_tag_size", "<BUGS>", "static", "bool", "ix86_libc_has_fast_function", "(", "int", "fcode", "ATTRIBUTE_UNUSED", ")", "<BUGE>", "{", "#", "ifdef", "OPTION_GLIBCif", "(", "OPTION_GLIBC", ")" ]

[ "<STR_LIT>", ")" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", ")" ]

[ "void", "AArch64RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected", "<STR_LIT>", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "AArch64InstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "AArch64FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "bool", "Tagged", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getTargetFlags", "(", ")", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "unsigned", "FrameReg", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", "||", "MI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "STACKMAP", "||", "MI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "PATCHPOINT", ")", "{", "StackOffset", "Offset", "=", "TFI", "->", "resolveFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ",", "true", ",", "false", ")", ";", "Offset", "+=", "StackOffset", "(", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ",", "MVT", "::", "i8", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "<NUM_LIT>", ")", ".", "ChangeToImmediate", "(", "Offset", ".", "getBytes", "(", ")", ")", ";", "return", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "LOCAL_ESCAPE", ")", "{", "MachineOperand", "&", "FI", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "int", "Offset", "=", "TFI", "->", "getNonLocalFrameIndexReference", "(", "MF", ",", "FrameIndex", ")", ";", "FI", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "StackOffset", "Offset", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "const", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "FrameReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Offset", "=", "{", "MFI", ".", "getObjectOffset", "(", "FrameIndex", ")", "+", "AFI", "->", "getTaggedBasePointerOffset", "(", ")", ",", "MVT", "::", "i8", "}", ";", "}", "else", "if", "(", "Tagged", ")", "{", "StackOffset", "SPOffset", "=", "{", "MFI", ".", "getObjectOffset", "(", "FrameIndex", ")", "+", "(", "int64_t", ")", "MFI", ".", "getStackSize", "(", ")", ",", "MVT", "::", "i8", "}", ";", "if", "(", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "isAArch64FrameOffsetLegal", "(", "MI", ",", "SPOffset", ",", "nullptr", ",", "nullptr", ",", "nullptr", ")", "!=", "(", "AArch64FrameOffsetCanUpdate", "|", "AArch64FrameOffsetIsLegal", ")", ")", "{", "Offset", "=", "TFI", "->", "resolveFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ",", "false", ",", "true", ")", ";", "Register", "ScratchReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "emitFrameOffset", "(", "MBB", ",", "II", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "ScratchReg", ",", "FrameReg", ",", "Offset", ",", "TII", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "ScratchReg", ")", ".", "addReg", "(", "ScratchReg", ")", ".", "addReg", "(", "ScratchReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "ScratchReg", ",", "false", ",", "false", ",", "true", ")", ";", "return", ";", "}", "FrameReg", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "{", "MFI", ".", "getObjectOffset", "(", "FrameIndex", ")", "+", "(", "int64_t", ")", "MFI", ".", "getStackSize", "(", ")", ",", "MVT", "::", "i8", "}", ";", "}", "else", "{", "Offset", "=", "TFI", "->", "resolveFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ",", "false", ",", "true", ")", ";", "}", "if", "(", "rewriteAArch64FrameIndex", "(", "MI", ",", "FIOperandNum", ",", "FrameReg", ",", "Offset", ",", "TII", ")", ")", "return", ";", "assert", "(", "(", "!", "RS", "||", "!", "RS", "->", "isScavengingFrameIndex", "(", "FrameIndex", ")", ")", "&&", "<STR_LIT>", "Emergency spill slot is out of reach", "<STR_LIT>", ")", ";", "Register", "ScratchReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "emitFrameOffset", "(", "MBB", ",", "II", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "ScratchReg", ",", "FrameReg", ",", "Offset", ",", "TII", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "ScratchReg", ",", "false", ",", "false", ",", "true", ")", ";", "}" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ ")", "]", ")" ]

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

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

[ "def", "v2i32_shift", ":", "BaseSIMDVectorShift", "<", "<NUM_LIT>", ",", "U", ",", "opc", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "?", ",", "?", ",", "?", ",", "?", ",", "?", "}", ",", "V128", ",", "V64", ",", "vecshiftL32", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "v2i64", "V128", ":", "$", "Rd", ")", ",", "(", "OpNode", "(", "v2i32", "V64", ":", "$", "Rn", ")", ",", "vecshiftL32", ":", "$", "imm", ")", ")", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "imm", ";" ]

[ "}", ")" ]

[ "emit_insn", "(", "gen_extendsfdf2_i4", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "DONE" ]

[ "}" ]

[ "SmallString", "<", "<NUM_LIT>", ">", "Name", ";", "raw_svector_ostream", "(", "Name", ")", "<<", "DL", ".", "getPrivateGlobalPrefix", "(", ")", "<<", "<STR_LIT>", "JTI", "<STR_LIT>", "<<", "Printer", ".", "getFunctionNumber", "(", ")", "<<", "'", "_", "'", "<<", "MO", ".", "getIndex", "(", ")", ";", "switch", "(", "MO", ".", "getTargetFlags", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown target flag on GV operand", "<STR_LIT>", ")", ";", "case", "<NUM_LIT>", ":", "break", ";", "}", "return", "Ctx", ".", "getOrCreateSymbol", "(", "Name", ")", ";" ]

[ "push", "(", "err", ".", "s", ")", ";", "}" ]

[ "void", "addErrInfo", "(", "HexagonMCErrInfo", "&", "err", ")", "{", "ErrInfoQ", "." ]

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

[ "def", "C2_cmpgtu", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "IntRegs", ":", "$", "Rt32", ")", ",", "<STR_LIT>", ",", "tc_de4df740", ",", "TypeALU32_3op", ">", ",", "Enc_c2b48e", ",", "ImmRegRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m512", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask3_fmsubadd_round_ps", "(", "_", "_", "m512", "_", "_", "A", ",", "_", "_", "m512", "_", "_", "B", ",", "_", "_", "m512", "_", "_", "C", ",", "_", "_", "mmask16", "_", "_", "U", ",", "const", "int", "_", "_", "R", ")", "{", "return", "(", "_", "_", "m512", ")", "_", "_", "builtin_ia32_vfmsubaddps512_mask3", "(", "(", "_", "_", "v16sf", ")", "_", "_", "A", ",", "(", "_", "_", "v16sf", ")", "_", "_", "B", ",", "(", "_", "_", "v16sf", ")", "_", "_", "C", ",", "(", "_", "_", "mmask16", ")", "_", "_", "U", ",", "_", "_", "R", ")", ";" ]

[ "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "<STR_LIT>", "Hexagon Expand Predicate Spill Code", "<STR_LIT>", ";", "}" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ ",", "dl", ",", "DAG", ",", "InVals", ")", ";" ]

[ "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported calling convention", "<STR_LIT>", ")", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "return", "LowerCCCCallTo", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins" ]

[ ";" ]

[ "Register", "Src2Reg", "=", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "Ty", ".", "isVector", "(", ")", ")", "return", "false", ";", "unsigned", "Opc", "=", "<NUM_LIT>", ";", "if", "(", "Ty", "==", "LLT", "::", "vector", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "{", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "if", "(", "Ty", "==", "LLT", "::", "vector", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "{", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Unhandled G_SHL type", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "MachineIRBuilder", "MIB", "(", "I", ")" ]

[ ",", "VT", ".", "getVectorElementType", "(", ")", ".", "getSizeInBits", "(", ")", ")", ";" ]

[ "if", "(", "SrcEltTy", ".", "bitsLT", "(", "SmallestEltTy", ")", ")", "SmallestEltTy", "=", "SrcEltTy", ";", "}", "unsigned", "ResMultiplier", "=", "VT", ".", "getVectorElementType", "(", ")", ".", "getSizeInBits", "(", ")", "/", "SmallestEltTy", ".", "getSizeInBits", "(", ")", ";", "NumElts", "=", "VT", ".", "getSizeInBits", "(", ")", "/", "SmallestEltTy", ".", "getSizeInBits", "(", ")", ";", "EVT", "ShuffleVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "SmallestEltTy", ",", "NumElts", ")", ";", "for", "(", "auto", "&", "Src", ":", "Sources", ")", "{", "EVT", "SrcVT", "=", "Src", ".", "ShuffleVec", ".", "getValueType", "(", ")", ";", "if", "(", "SrcVT", ".", "getSizeInBits", "(", ")", "==", "VT", ".", "getSizeInBits", "(", ")", ")", "continue", ";", "EVT", "EltVT", "=", "SrcVT", ".", "getVectorElementType", "(", ")", ";", "unsigned", "NumSrcElts", "=", "VT", ".", "getSizeInBits", "(", ")", "/", "EltVT", ".", "getSizeInBits", "(", ")", ";", "EVT", "DestVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "EltVT", ",", "NumSrcElts", ")", ";", "if", "(", "SrcVT", ".", "getSizeInBits", "(", ")", "<", "VT", ".", "getSizeInBits", "(", ")", ")", "{", "if", "(", "<NUM_LIT>", "*", "SrcVT", ".", "getSizeInBits", "(", ")", "!=", "VT", ".", "getSizeInBits", "(", ")", ")", "return", "SDValue", "(", ")", ";", "Src", ".", "ShuffleVec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "CONCAT_VECTORS", ",", "dl", ",", "DestVT", ",", "Src", ".", "ShuffleVec", ",", "DAG", ".", "getUNDEF", "(", "Src", ".", "ShuffleVec", ".", "getValueType", "(", ")", ")", ")", ";", "continue", ";", "}", "if", "(", "SrcVT", ".", "getSizeInBits", "(", ")", "!=", "<NUM_LIT>", "*", "VT", ".", "getSizeInBits", "(", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "Src", ".", "MaxElt", "-", "Src", ".", "MinElt", ">=", "NumSrcElts", ")", "{", "return", "SDValue", "(", ")", ";", "}", "if", "(", "Src", ".", "MinElt", ">=", "NumSrcElts", ")", "{", "Src", ".", "ShuffleVec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "dl", ",", "DestVT", ",", "Src", ".", "ShuffleVec", ",", "DAG", ".", "getConstant", "(", "NumSrcElts", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "Src", ".", "WindowBase", "=", "-", "NumSrcElts", ";", "}", "else", "if", "(", "Src", ".", "MaxElt", "<", "NumSrcElts", ")", "{", "Src", ".", "ShuffleVec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "dl", ",", "DestVT", ",", "Src", ".", "ShuffleVec", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "}", "else", "{", "SDValue", "VEXTSrc1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "dl", ",", "DestVT", ",", "Src", ".", "ShuffleVec", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "VEXTSrc2", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "dl", ",", "DestVT", ",", "Src", ".", "ShuffleVec", ",", "DAG", ".", "getConstant", "(", "NumSrcElts", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "unsigned", "Imm", "=", "Src", ".", "MinElt", "*", "getExtFactor", "(", "VEXTSrc1", ")", ";", "Src", ".", "ShuffleVec", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "DestVT", ",", "VEXTSrc1", ",", "VEXTSrc2", ",", "DAG", ".", "getConstant", "(", "Imm", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "Src", ".", "WindowBase", "=", "-", "Src", ".", "MinElt", ";", "}", "}", "for", "(", "auto", "&", "Src", ":", "Sources", ")", "{", "EVT", "SrcEltTy", "=", "Src", ".", "ShuffleVec", ".", "getValueType", "(", ")", ".", "getVectorElementType", "(", ")", ";", "if", "(", "SrcEltTy", "==", "SmallestEltTy", ")", "continue", ";", "assert", "(", "ShuffleVT", ".", "getVectorElementType", "(", ")", "==", "SmallestEltTy", ")", ";", "Src", ".", "ShuffleVec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "ShuffleVT", ",", "Src", ".", "ShuffleVec", ")", ";", "Src", ".", "WindowScale", "=", "SrcEltTy", ".", "getSizeInBits", "(", ")", "/", "SmallestEltTy", ".", "getSizeInBits", "(", ")", ";", "Src", ".", "WindowBase", "*=", "Src", ".", "WindowScale", ";", "}", "DEBUG", "(", "for", "(", "auto", "Src", ":", "Sources", ")", "assert", "(", "Src", ".", "ShuffleVec", ".", "getValueType", "(", ")", "==", "ShuffleVT", ")", ";", ")", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "Mask", "(", "ShuffleVT", ".", "getVectorNumElements", "(", ")", ",", "-", "<NUM_LIT>", ")", ";", "int", "BitsPerShuffleLane", "=", "ShuffleVT", ".", "getVectorElementType", "(", ")", ".", "getSizeInBits", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "VT", ".", "getVectorNumElements", "(", ")", ";", "++", "i", ")", "{", "SDValue", "Entry", "=", "Op", ".", "getOperand", "(", "i", ")", ";", "if", "(", "Entry", ".", "getOpcode", "(", ")", "==", "ISD", "::", "UNDEF", ")", "continue", ";", "auto", "Src", "=", "std", "::", "find", "(", "Sources", ".", "begin", "(", ")", ",", "Sources", ".", "end", "(", ")", ",", "Entry", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "int", "EltNo", "=", "cast", "<", "ConstantSDNode", ">", "(", "Entry", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getSExtValue", "(", ")", ";", "EVT", "OrigEltTy", "=", "Entry", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ".", "getVectorElementType", "(", ")", ";", "int", "BitsDefined", "=", "std", "::", "min", "(", "OrigEltTy", ".", "getSizeInBits", "(", ")" ]

[ "<FIXS>", "def", "PSrm_Int", ":", "PSI", "opc", ",", "MRMSrcMem", ",", "(", "outs", "VR128", ":", "$", "dst", ")", ",", "(", "ins", "VR128", ":", "$", "src1", ",", "f128mem", ":", "$", "src2", ")", ",", "<FIXE>" ]

[ "}", "<BUGS>", "def", "PSrm_Int", ":", "PSI", "opc", ",", "MRMSrcMem", ",", "(", "outs", "VR128", ":", "$", "dst", ")", ",", "(", "ins", "VR128", ":", "$", "src1", ",", "f32mem", ":", "$", "src2", ")", ",", "<BUGE>", "!", "strconcat", "(", "OpcodeStr", ",", "<STR_LIT>", ")", ",", "[", "(", "set", "VR128", ":", "$", "dst", ",", "(", "V4F32Int", "VR128", ":", "$", "src1", ",", "(", "load", "addr", ":", "$", "src2", ")", ")", ")", "]", ">", ";", "}" ]

[ ";" ]

[ "static", "std", "::", "string", "computeDataLayout", "(", "const", "Triple", "&", "TT", ")", "{", "std", "::", "string", "Ret", "=", "<STR_LIT>", "e", "<STR_LIT>", ";", "Ret", "+=", "DataLayout", "::", "getManglingComponent", "(", "TT", ")", ";", "if", "(", "!", "TT", ".", "isArch64Bit", "(", ")", "||", "TT", ".", "isX32", "(", ")", "||", "TT", ".", "isOSNaCl", "(", ")", ")", "Ret", "+=", "<STR_LIT>", "-p:32:32", "<STR_LIT>", ";", "Ret", "+=", "<STR_LIT>", "-p270:32:32-p271:32:32-p272:64:64", "<STR_LIT>", ";", "if", "(", "TT", ".", "isArch64Bit", "(", ")", "||", "TT", ".", "isOSWindows", "(", ")", "||", "TT", ".", "isOSNaCl", "(", ")", ")", "Ret", "+=", "<STR_LIT>", "-i64:64-i128:128", "<STR_LIT>", ";", "else", "if", "(", "TT", ".", "isOSIAMCU", "(", ")", ")", "Ret", "+=", "<STR_LIT>", "-i64:32-f64:32", "<STR_LIT>", ";", "else", "Ret", "+=", "<STR_LIT>", "-i128:128-f64:32:64", "<STR_LIT>", ";", "if", "(", "TT", ".", "isOSNaCl", "(", ")", "||", "TT", ".", "isOSIAMCU", "(", ")", ")", ";", "else", "if", "(", "TT", ".", "isArch64Bit", "(", ")", "||", "TT", ".", "isOSDarwin", "(", ")", "||", "TT", ".", "isWindowsMSVCEnvironment", "(", ")", ")", "Ret", "+=", "<STR_LIT>", "-f80:128", "<STR_LIT>", ";", "else", "Ret", "+=", "<STR_LIT>", "-f80:32", "<STR_LIT>", ";", "if", "(", "TT", ".", "isOSIAMCU", "(", ")", ")", "Ret", "+=", "<STR_LIT>", "-f128:32", "<STR_LIT>", ";", "if", "(", "TT", ".", "isArch64Bit", "(", ")", ")", "Ret", "+=", "<STR_LIT>", "-n8:16:32:64", "<STR_LIT>", ";", "else", "Ret", "+=", "<STR_LIT>", "-n8:16:32", "<STR_LIT>", ";", "if", "(", "(", "!", "TT", ".", "isArch64Bit", "(", ")", "&&", "TT", ".", "isOSWindows", "(", ")", ")", "||", "TT", ".", "isOSIAMCU", "(", ")", ")", "Ret", "+=", "<STR_LIT>", "-a:0:32-S32", "<STR_LIT>", ";", "else", "Ret", "+=", "<STR_LIT>", "-S128", "<STR_LIT>", ";", "return", "Ret" ]

[ "PC", "]", ";" ]

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", "," ]

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

[ "_", "_", "v2df", "_", "_", "r", "=", "{", "(", "(", "_", "_", "v2df", ")", "_", "_", "B", ")", "[", "<NUM_LIT>", "]", ",", "(", "(", "_", "_", "v2df", ")", "_", "_", "A", ")" ]

[ ";" ]

[ "if", "(", "X86MCRegisterClasses", "[", "X86", "::", "GR32RegClassID", "]", ".", "contains", "(", "IndexReg", ")", "||", "X86MCRegisterClasses", "[", "X86", "::", "GR64RegClassID", "]", ".", "contains", "(", "IndexReg", ")", ")", "{", "ErrMsg", "=", "<STR_LIT>", "base register is 16-bit, but index register is not", "<STR_LIT>", ";", "return", "true", ";", "}", "if", "(", "(", "(", "BaseReg", "==", "X86", "::", "BX", "||", "BaseReg", "==", "X86", "::", "BP", ")", "&&", "IndexReg", "!=", "X86", "::", "SI", "&&", "IndexReg", "!=", "X86", "::", "DI", ")", "||", "(", "(", "BaseReg", "==", "X86", "::", "SI", "||", "BaseReg", "==", "X86", "::", "DI", ")", "&&", "IndexReg", "!=", "X86", "::", "BX", "&&", "IndexReg", "!=", "X86", "::", "BP", ")", ")", "{", "ErrMsg", "=", "<STR_LIT>", "invalid 16-bit base/index register combination", "<STR_LIT>", ";", "return", "true" ]

[ "return", "DAG", ".", "getLoad", "(", "PtrVT", ",", "dl", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "RetAddrFI", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";" ]

[ "SDValue", "X86TargetLowering", "::", "LowerRETURNADDR", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFrameInfo", "(", ")", ";", "MFI", "->", "setReturnAddressIsTaken", "(", "true", ")", ";", "if", "(", "verifyReturnAddressArgumentIsConstant", "(", "Op", ",", "DAG", ")", ")", "return", "SDValue", "(", ")", ";", "unsigned", "Depth", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "SDLoc", "dl", "(", "Op", ")", ";", "EVT", "PtrVT", "=", "getPointerTy", "(", ")", ";", "if", "(", "Depth", ">", "<NUM_LIT>", ")", "{", "SDValue", "FrameAddr", "=", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "const", "X86RegisterInfo", "*", "RegInfo", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "SDValue", "Offset", "=", "DAG", ".", "getConstant", "(", "RegInfo", "->", "getSlotSize", "(", ")", ",", "dl", ",", "PtrVT", ")", ";", "return", "DAG", ".", "getLoad", "(", "PtrVT", ",", "dl", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "FrameAddr", ",", "Offset", ")", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "}", "SDValue", "RetAddrFI", "=", "getReturnAddressFrameIndex", "(", "DAG", ")", ";" ]