Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "bool", "valid_bL_core_p", "(", "unsigned", "int", "*", "core", ",", "unsigned", "int", "bL_core", ")", "{", "return", "AARCH64_BIG_LITTLE", "(", "core", "[", "0", "]", ",", "core", "[", "1", "]", ")", "==", "bL_core", "||", "AARCH64_BIG_LITTLE", "(", "core", "[", "1", "]", ",", "core", "[", "0", "]", ")", "==", "bL_core", ";", "}", "</s>" ]

[ "Check", "wether", "the", "CORE", "array", "is", "the", "same", "as", "the", "big.LITTLE", "BL_CORE", ".", "For", "an", "example", "CORE=", "{", "0xd08", ",", "0xd03", "}", "and", "BL_CORE=AARCH64_BIG_LITTLE", "(", "0xd08", ",", "0xd03", ")", "will", "return", "true", "." ]

[ "aarch64", "0", "1", "1", "0" ]

[]

[ "<s>", "static", "int", "noncall_uses_reg", "(", "rtx", "reg", ",", "rtx", "insn", ",", "rtx", "*", "set", ")", "{", "rtx", "pattern", ",", "reg2", ";", "*", "set", "=", "NULL_RTX", ";", "reg2", "=", "sfunc_uses_reg", "(", "insn", ")", ";", "if", "(", "reg2", "&&", "REGNO", "(", "reg2", ")", "==", "REGNO", "(", "reg", ")", ")", "{", "pattern", "=", "single_set", "(", "insn", ")", ";", "if", "(", "pattern", "&&", "GET_CODE", "(", "SET_DEST", "(", "pattern", ")", ")", "==", "REG", "&&", "REGNO", "(", "reg", ")", "==", "REGNO", "(", "SET_DEST", "(", "pattern", ")", ")", ")", "*", "set", "=", "pattern", ";", "return", "0", ";", "}", "if", "(", "GET_CODE", "(", "insn", ")", "!=", "CALL_INSN", ")", "{", "pattern", "=", "single_set", "(", "insn", ")", ";", "if", "(", "pattern", "&&", "GET_CODE", "(", "SET_DEST", "(", "pattern", ")", ")", "==", "REG", "&&", "REGNO", "(", "reg", ")", "==", "REGNO", "(", "SET_DEST", "(", "pattern", ")", ")", ")", "{", "rtx", "par", ",", "part", ";", "int", "i", ";", "*", "set", "=", "pattern", ";", "par", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "par", ")", "==", "PARALLEL", ")", "for", "(", "i", "=", "XVECLEN", "(", "par", ",", "0", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "part", "=", "XVECEXP", "(", "par", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "part", ")", "!=", "SET", "&&", "reg_mentioned_p", "(", "reg", ",", "part", ")", ")", "return", "1", ";", "}", "return", "reg_mentioned_p", "(", "reg", ",", "SET_SRC", "(", "pattern", ")", ")", ";", "}", "return", "1", ";", "}", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "PARALLEL", ")", "{", "int", "i", ";", "for", "(", "i", "=", "XVECLEN", "(", "pattern", ",", "0", ")", "-", "1", ";", "i", ">=", "1", ";", "i", "--", ")", "if", "(", "reg_mentioned_p", "(", "reg", ",", "XVECEXP", "(", "pattern", ",", "0", ",", "i", ")", ")", ")", "return", "1", ";", "pattern", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "SET", ")", "{", "if", "(", "reg_mentioned_p", "(", "reg", ",", "SET_DEST", "(", "pattern", ")", ")", ")", "{", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "pattern", ")", ")", "!=", "REG", "||", "REGNO", "(", "reg", ")", "!=", "REGNO", "(", "SET_DEST", "(", "pattern", ")", ")", ")", "return", "1", ";", "*", "set", "=", "pattern", ";", "}", "pattern", "=", "SET_SRC", "(", "pattern", ")", ";", "}", "if", "(", "GET_CODE", "(", "pattern", ")", "!=", "CALL", "||", "GET_CODE", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", "!=", "MEM", "||", "!", "rtx_equal_p", "(", "reg", ",", "XEXP", "(", "XEXP", "(", "pattern", ",", "0", ")", ",", "0", ")", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "See", "if", "the", "only", "way", "in", "which", "INSN", "uses", "REG", "is", "by", "calling", "it", ",", "or", "by", "setting", "it", "while", "calling", "it", ".", "Set", "*", "SET", "to", "a", "SET", "rtx", "if", "the", "register", "is", "set", "by", "INSN", "." ]

[ "sh", "0", "0", "1", "0", "0", "1", "1", "0", "1", "1", "0", "1", "0", "0", "1", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "inline", "static", "void", "aarch64_print_hint_for_arch", "(", "const", "char", "*", "str", ")", "{", "aarch64_print_hint_for_core_or_arch", "(", "str", ",", "true", ")", ";", "}", "</s>" ]

[ "Print", "a", "hint", "with", "a", "suggestion", "for", "an", "architecture", "name", "that", "most", "closely", "resembles", "what", "the", "user", "passed", "in", "STR", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "aarch64_sve_float_mul_immediate_p", "(", "rtx", "x", ")", "{", "rtx", "elt", ";", "return", "(", "const_vec_duplicate_p", "(", "x", ",", "&", "elt", ")", "&&", "GET_CODE", "(", "elt", ")", "==", "CONST_DOUBLE", "&&", "real_equal", "(", "CONST_DOUBLE_REAL_VALUE", "(", "elt", ")", ",", "&", "dconsthalf", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "immediate", "operand", "for", "an", "SVE", "FMUL", "instruction", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "MipsRegisterInfo", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "DisableFramePointerElim", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "void", "SystemZPostRASchedStrategy", "::", "leaveMBB", "(", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"** Leaving \"", "<<", "printMBBReference", "(", "*", "MBB", ")", "<<", "\"\\n\"", ";", ")", ";", "advanceTo", "(", "MBB", "->", "getFirstTerminator", "(", ")", ")", ";", "}", "</s>" ]

[ "Tell", "the", "strategy", "that", "current", "MBB", "is", "done", "." ]

[ "SystemZ", "SystemZ", "\"** Leaving \"", "\"\\n\"" ]

[]

[ "<s>", "void", "rs6000_emit_sCOND", "(", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "condition_rtx", ";", "machine_mode", "op_mode", ";", "enum", "rtx_code", "cond_code", ";", "rtx", "result", "=", "operands", "[", "0", "]", ";", "condition_rtx", "=", "rs6000_generate_compare", "(", "operands", "[", "1", "]", ",", "mode", ")", ";", "cond_code", "=", "GET_CODE", "(", "condition_rtx", ")", ";", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", "&&", "!", "TARGET_FPRS", "&&", "TARGET_HARD_FLOAT", ")", "{", "rtx", "t", ";", "PUT_MODE", "(", "condition_rtx", ",", "SImode", ")", ";", "t", "=", "XEXP", "(", "condition_rtx", ",", "0", ")", ";", "gcc_assert", "(", "cond_code", "==", "NE", "||", "cond_code", "==", "EQ", ")", ";", "if", "(", "cond_code", "==", "NE", ")", "emit_insn", "(", "gen_e500_flip_gt_bit", "(", "t", ",", "t", ")", ")", ";", "emit_insn", "(", "gen_move_from_CR_gt_bit", "(", "result", ",", "t", ")", ")", ";", "return", ";", "}", "if", "(", "cond_code", "==", "NE", "||", "cond_code", "==", "GE", "||", "cond_code", "==", "LE", "||", "cond_code", "==", "GEU", "||", "cond_code", "==", "LEU", "||", "cond_code", "==", "ORDERED", "||", "cond_code", "==", "UNGE", "||", "cond_code", "==", "UNLE", ")", "{", "rtx", "not_result", "=", "gen_reg_rtx", "(", "CCEQmode", ")", ";", "rtx", "not_op", ",", "rev_cond_rtx", ";", "machine_mode", "cc_mode", ";", "cc_mode", "=", "GET_MODE", "(", "XEXP", "(", "condition_rtx", ",", "0", ")", ")", ";", "rev_cond_rtx", "=", "gen_rtx_fmt_ee", "(", "rs6000_reverse_condition", "(", "cc_mode", ",", "cond_code", ")", ",", "SImode", ",", "XEXP", "(", "condition_rtx", ",", "0", ")", ",", "const0_rtx", ")", ";", "not_op", "=", "gen_rtx_COMPARE", "(", "CCEQmode", ",", "rev_cond_rtx", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "not_result", ",", "not_op", ")", ")", ";", "condition_rtx", "=", "gen_rtx_EQ", "(", "VOIDmode", ",", "not_result", ",", "const0_rtx", ")", ";", "}", "op_mode", "=", "GET_MODE", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ")", ";", "if", "(", "op_mode", "==", "VOIDmode", ")", "op_mode", "=", "GET_MODE", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "1", ")", ")", ";", "if", "(", "TARGET_POWERPC64", "&&", "(", "op_mode", "==", "DImode", "||", "FLOAT_MODE_P", "(", "mode", ")", ")", ")", "{", "PUT_MODE", "(", "condition_rtx", ",", "DImode", ")", ";", "convert_move", "(", "result", ",", "condition_rtx", ",", "0", ")", ";", "}", "else", "{", "PUT_MODE", "(", "condition_rtx", ",", "SImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "result", ",", "condition_rtx", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "the", "RTL", "for", "an", "sCOND", "pattern", "." ]

[ "rs6000", "0", "1", "0", "0", "0", "1", "0", "1", "1", "0" ]

[]

[ "<s>", "void", "dump", "(", ")", "{", "dbgs", "(", ")", "<<", "\"Start is \"", ";", "if", "(", "StartSel", ")", "{", "dbgs", "(", ")", "<<", "Start", ".", "ImmVal", "<<", "\"\\n\"", ";", "}", "else", "{", "dbgs", "(", ")", "<<", "\"%vreg\"", "<<", "Start", ".", "Reg", "<<", "\"\\n\"", ";", "}", "dbgs", "(", ")", "<<", "\"Boundary is \"", ";", "if", "(", "BoundarySel", ")", "{", "dbgs", "(", ")", "<<", "Boundary", ".", "ImmVal", "<<", "\"\\n\"", ";", "}", "else", "{", "dbgs", "(", ")", "<<", "\"%vreg\"", "<<", "Boundary", ".", "Reg", "<<", "\"\\n\"", ";", "}", "dbgs", "(", ")", "<<", "\"Step is \"", ";", "if", "(", "StepSel", ")", "{", "dbgs", "(", ")", "<<", "Step", ".", "ImmVal", "<<", "\"\\n\"", ";", "}", "else", "{", "dbgs", "(", ")", "<<", "\"%vreg\"", "<<", "Step", ".", "Reg", "<<", "\"\\n\"", ";", "}", "dbgs", "(", ")", "<<", "\"Cmp mode is \"", "<<", "Mode", "<<", "\"\\n\"", ";", "}", "</s>" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "TPC", "\"Start is \"", "\"\\n\"", "\"%vreg\"", "\"\\n\"", "\"Boundary is \"", "\"\\n\"", "\"%vreg\"", "\"\\n\"", "\"Step is \"", "\"\\n\"", "\"%vreg\"", "\"\\n\"", "\"Cmp mode is \"", "\"\\n\"" ]

[]

[ "<s>", "rtx", "spu_const_from_ints", "(", "machine_mode", "mode", ",", "int", "a", ",", "int", "b", ",", "int", "c", ",", "int", "d", ")", "{", "unsigned", "char", "arr", "[", "16", "]", ";", "arr", "[", "0", "]", "=", "(", "a", ">>", "24", ")", "&", "0xff", ";", "arr", "[", "1", "]", "=", "(", "a", ">>", "16", ")", "&", "0xff", ";", "arr", "[", "2", "]", "=", "(", "a", ">>", "8", ")", "&", "0xff", ";", "arr", "[", "3", "]", "=", "(", "a", ">>", "0", ")", "&", "0xff", ";", "arr", "[", "4", "]", "=", "(", "b", ">>", "24", ")", "&", "0xff", ";", "arr", "[", "5", "]", "=", "(", "b", ">>", "16", ")", "&", "0xff", ";", "arr", "[", "6", "]", "=", "(", "b", ">>", "8", ")", "&", "0xff", ";", "arr", "[", "7", "]", "=", "(", "b", ">>", "0", ")", "&", "0xff", ";", "arr", "[", "8", "]", "=", "(", "c", ">>", "24", ")", "&", "0xff", ";", "arr", "[", "9", "]", "=", "(", "c", ">>", "16", ")", "&", "0xff", ";", "arr", "[", "10", "]", "=", "(", "c", ">>", "8", ")", "&", "0xff", ";", "arr", "[", "11", "]", "=", "(", "c", ">>", "0", ")", "&", "0xff", ";", "arr", "[", "12", "]", "=", "(", "d", ">>", "24", ")", "&", "0xff", ";", "arr", "[", "13", "]", "=", "(", "d", ">>", "16", ")", "&", "0xff", ";", "arr", "[", "14", "]", "=", "(", "d", ">>", "8", ")", "&", "0xff", ";", "arr", "[", "15", "]", "=", "(", "d", ">>", "0", ")", "&", "0xff", ";", "return", "array_to_constant", "(", "mode", ",", "arr", ")", ";", "}", "</s>" ]

[ "Create", "a", "MODE", "vector", "constant", "from", "4", "ints", "." ]

[ "spu", "16", "0", "24", "0xff", "1", "16", "0xff", "2", "8", "0xff", "3", "0", "0xff", "4", "24", "0xff", "5", "16", "0xff", "6", "8", "0xff", "7", "0", "0xff", "8", "24", "0xff", "9", "16", "0xff", "10", "8", "0xff", "11", "0", "0xff", "12", "24", "0xff", "13", "16", "0xff", "14", "8", "0xff", "15", "0", "0xff" ]

[]

[ "<s>", "enum", "attr_cc", "compute_a_shift_cc", "(", "rtx", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "*", "operands", ")", "{", "rtx", "shift", "=", "operands", "[", "3", "]", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "shift", ")", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "shift", ")", ";", "enum", "shift_type", "shift_type", ";", "enum", "shift_mode", "shift_mode", ";", "struct", "shift_info", "info", ";", "int", "n", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "shift_mode", "=", "QIshift", ";", "break", ";", "case", "HImode", ":", "shift_mode", "=", "HIshift", ";", "break", ";", "case", "SImode", ":", "shift_mode", "=", "SIshift", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "ASHIFTRT", ":", "shift_type", "=", "SHIFT_ASHIFTRT", ";", "break", ";", "case", "LSHIFTRT", ":", "shift_type", "=", "SHIFT_LSHIFTRT", ";", "break", ";", "case", "ASHIFT", ":", "shift_type", "=", "SHIFT_ASHIFT", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", ";", "n", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "n", "<", "0", ")", "n", "=", "0", ";", "else", "if", "(", "(", "unsigned", "int", ")", "n", ">", "GET_MODE_BITSIZE", "(", "mode", ")", ")", "n", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "get_shift_alg", "(", "shift_type", ",", "shift_mode", ",", "n", ",", "&", "info", ")", ";", "switch", "(", "info", ".", "alg", ")", "{", "case", "SHIFT_SPECIAL", ":", "if", "(", "info", ".", "remainder", "==", "0", ")", "return", "info", ".", "cc_special", ";", "case", "SHIFT_INLINE", ":", "return", "info", ".", "cc_inline", ";", "case", "SHIFT_ROT_AND", ":", "return", "CC_SET_ZNV", ";", "case", "SHIFT_LOOP", ":", "if", "(", "info", ".", "shift2", "!=", "NULL", ")", "{", "if", "(", "n", "%", "2", ")", "return", "info", ".", "cc_inline", ";", "}", "return", "CC_CLOBBER", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Compute", "which", "flag", "bits", "are", "valid", "after", "a", "shift", "insn", "." ]

[ "h8300", "3", "2", "2", "0", "0", "0", "2" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "RISCV_INSERT_VSETVLI_NAME", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "static", "int", "unspec_cond_fcmla", "(", "int", "rot", ")", "{", "switch", "(", "rot", ")", "{", "case", "0", ":", "return", "UNSPEC_COND_FCMLA", ";", "case", "90", ":", "return", "UNSPEC_COND_FCMLA90", ";", "case", "180", ":", "return", "UNSPEC_COND_FCMLA180", ";", "case", "270", ":", "return", "UNSPEC_COND_FCMLA270", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "UNSPEC_COND_FCMLA", "*", "unspec", "for", "rotation", "amount", "ROT", "." ]

[ "aarch64", "0", "90", "180", "270" ]

[]

[ "<s>", "bool", "small_data_pattern", "(", "rtx", "op", ",", "machine_mode", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "SEQUENCE", ")", "return", "false", ";", "rtx", "rgp", "=", "gen_rtx_REG", "(", "Pmode", ",", "SDATA_BASE_REGNUM", ")", ";", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "op", ",", "ALL", ")", "{", "const_rtx", "x", "=", "*", "iter", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "rtx_equal_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "rgp", ")", ")", "iter", ".", "skip_subrtxes", "(", ")", ";", "else", "if", "(", "arc_rewrite_small_data_p", "(", "x", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "refers", "to", "small", "data", "symbols", "directly", ",", "not", "through", "a", "PLUS", "." ]

[ "arc", "0" ]

[]

[ "<s>", "static", "inline", "int", "multcosts", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "sh_multcost", ">=", "0", ")", "return", "sh_multcost", ";", "if", "(", "TARGET_SHMEDIA", ")", "return", "TARGET_SMALLCODE", "?", "2", ":", "3", ";", "if", "(", "TARGET_SH2", ")", "{", "if", "(", "TARGET_SMALLCODE", ")", "return", "2", ";", "return", "3", ";", "}", "if", "(", "TARGET_SMALLCODE", ")", "return", "5", ";", "return", "20", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "a", "multiply", "." ]

[ "sh", "0", "2", "3", "2", "3", "5", "20" ]

[]

[ "<s>", "void", "XCoreFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "XCoreInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "XCoreInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "if", "(", "FP", ")", "{", "unsigned", "FramePtr", "=", "XCore", "::", "R10", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "XCore", "::", "SETSP_1r", ")", ")", ".", "addReg", "(", "FramePtr", ")", ";", "}", "int", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "assert", "(", "FrameSize", "%", "4", "==", "0", "&&", "\"Misaligned frame size\"", ")", ";", "FrameSize", "/=", "4", ";", "bool", "isU6", "=", "isImmU6", "(", "FrameSize", ")", ";", "if", "(", "!", "isU6", "&&", "!", "isImmU16", "(", "FrameSize", ")", ")", "{", "report_fatal_error", "(", "\"emitEpilogue Frame size too big: \"", "+", "Twine", "(", "FrameSize", ")", ")", ";", "}", "if", "(", "FrameSize", ")", "{", "XCoreFunctionInfo", "*", "XFI", "=", "MF", ".", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "if", "(", "FP", ")", "{", "int", "FPSpillOffset", "=", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getFPSpillSlot", "(", ")", ")", ";", "FPSpillOffset", "+=", "FrameSize", "*", "4", ";", "loadFromStack", "(", "MBB", ",", "MBBI", ",", "XCore", "::", "R10", ",", "FPSpillOffset", ",", "dl", ",", "TII", ")", ";", "}", "bool", "restoreLR", "=", "XFI", "->", "getUsesLR", "(", ")", ";", "if", "(", "restoreLR", "&&", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getLRSpillSlot", "(", ")", ")", "!=", "0", ")", "{", "int", "LRSpillOffset", "=", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getLRSpillSlot", "(", ")", ")", ";", "LRSpillOffset", "+=", "FrameSize", "*", "4", ";", "loadFromStack", "(", "MBB", ",", "MBBI", ",", "XCore", "::", "LR", ",", "LRSpillOffset", ",", "dl", ",", "TII", ")", ";", "restoreLR", "=", "false", ";", "}", "if", "(", "restoreLR", ")", "{", "assert", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "XCore", "::", "RETSP_u6", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "XCore", "::", "RETSP_lu6", ")", ";", "int", "Opcode", "=", "(", "isU6", ")", "?", "XCore", "::", "RETSP_u6", ":", "XCore", "::", "RETSP_lu6", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "addImm", "(", "FrameSize", ")", ";", "MBB", ".", "erase", "(", "MBBI", ")", ";", "}", "else", "{", "int", "Opcode", "=", "(", "isU6", ")", "?", "XCore", "::", "LDAWSP_ru6_RRegs", ":", "XCore", "::", "LDAWSP_lru6_RRegs", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "XCore", "::", "SP", ")", ".", "addImm", "(", "FrameSize", ")", ";", "}", "}", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "XCore", "XCore", "XCore", "XCore", "XCore::R10", "XCore::SETSP_1r", "4", "0", "\"Misaligned frame size\"", "4", "\"emitEpilogue Frame size too big: \"", "XCore", "XCore", "4", "XCore::R10", "0", "4", "XCore::LR", "XCore::RETSP_u6", "XCore::RETSP_lu6", "XCore::RETSP_u6", "XCore::RETSP_lu6", "XCore::LDAWSP_ru6_RRegs", "XCore::LDAWSP_lru6_RRegs", "XCore::SP" ]

[]

[ "<s>", "static", "rtx", "get_vector_offset", "(", "rtx", "mem", ",", "rtx", "element", ",", "rtx", "base_tmp", ",", "unsigned", "scalar_size", ")", "{", "if", "(", "CONST_INT_P", "(", "element", ")", ")", "return", "GEN_INT", "(", "INTVAL", "(", "element", ")", "*", "scalar_size", ")", ";", "gcc_assert", "(", "satisfies_constraint_Q", "(", "mem", ")", ")", ";", "rtx", "num_ele_m1", "=", "GEN_INT", "(", "GET_MODE_NUNITS", "(", "GET_MODE", "(", "mem", ")", ")", "-", "1", ")", ";", "rtx", "and_op", "=", "gen_rtx_AND", "(", "Pmode", ",", "element", ",", "num_ele_m1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "base_tmp", ",", "and_op", ")", ")", ";", "int", "shift", "=", "exact_log2", "(", "scalar_size", ")", ";", "gcc_assert", "(", "shift", ">=", "0", ")", ";", "if", "(", "shift", ">", "0", ")", "{", "rtx", "shift_op", "=", "gen_rtx_ASHIFT", "(", "Pmode", ",", "base_tmp", ",", "GEN_INT", "(", "shift", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "base_tmp", ",", "shift_op", ")", ")", ";", "}", "return", "base_tmp", ";", "}", "</s>" ]

[ "Return", "the", "offset", "within", "a", "memory", "object", "(", "MEM", ")", "of", "a", "vector", "type", "to", "a", "given", "element", "within", "the", "vector", "(", "ELEMENT", ")", "with", "an", "element", "size", "(", "SCALAR_SIZE", ")", ".", "If", "the", "element", "is", "constant", ",", "we", "return", "a", "constant", "integer", ".", "Otherwise", ",", "we", "use", "a", "base", "register", "temporary", "to", "calculate", "the", "offset", "after", "masking", "it", "to", "fit", "within", "the", "bounds", "of", "the", "vector", "and", "scaling", "it", ".", "The", "masking", "is", "required", "by", "the", "64-bit", "ELF", "version", "2", "ABI", "for", "the", "vec_extract", "built-in", "function", "." ]

[ "rs6000", "1", "0", "0" ]

[]

[ "<s>", "static", "void", "arm_output_function_prologue", "(", "FILE", "*", "f", ",", "HOST_WIDE_INT", "frame_size", ")", "{", "unsigned", "long", "func_type", ";", "gcc_assert", "(", "!", "arm_ccfsm_state", "&&", "!", "arm_target_insn", ")", ";", "func_type", "=", "arm_current_func_type", "(", ")", ";", "switch", "(", "(", "int", ")", "ARM_FUNC_TYPE", "(", "func_type", ")", ")", "{", "default", ":", "case", "ARM_FT_NORMAL", ":", "break", ";", "case", "ARM_FT_INTERWORKED", ":", "asm_fprintf", "(", "f", ",", "\"\\t%@ Function supports interworking.\\n\"", ")", ";", "break", ";", "case", "ARM_FT_ISR", ":", "asm_fprintf", "(", "f", ",", "\"\\t%@ Interrupt Service Routine.\\n\"", ")", ";", "break", ";", "case", "ARM_FT_FIQ", ":", "asm_fprintf", "(", "f", ",", "\"\\t%@ Fast Interrupt Service Routine.\\n\"", ")", ";", "break", ";", "case", "ARM_FT_EXCEPTION", ":", "asm_fprintf", "(", "f", ",", "\"\\t%@ ARM Exception Handler.\\n\"", ")", ";", "break", ";", "}", "if", "(", "IS_NAKED", "(", "func_type", ")", ")", "asm_fprintf", "(", "f", ",", "\"\\t%@ Naked Function: prologue and epilogue provided by programmer.\\n\"", ")", ";", "if", "(", "IS_VOLATILE", "(", "func_type", ")", ")", "asm_fprintf", "(", "f", ",", "\"\\t%@ Volatile: function does not return.\\n\"", ")", ";", "if", "(", "IS_NESTED", "(", "func_type", ")", ")", "asm_fprintf", "(", "f", ",", "\"\\t%@ Nested: function declared inside another function.\\n\"", ")", ";", "if", "(", "IS_STACKALIGN", "(", "func_type", ")", ")", "asm_fprintf", "(", "f", ",", "\"\\t%@ Stack Align: May be called with mis-aligned SP.\\n\"", ")", ";", "if", "(", "IS_CMSE_ENTRY", "(", "func_type", ")", ")", "asm_fprintf", "(", "f", ",", "\"\\t%@ Non-secure entry function: called from non-secure code.\\n\"", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\t%@ args = %d, pretend = %d, frame = %wd\\n\"", ",", "crtl", "->", "args", ".", "size", ",", "crtl", "->", "args", ".", "pretend_args_size", ",", "frame_size", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\t%@ frame_needed = %d, uses_anonymous_args = %d\\n\"", ",", "frame_pointer_needed", ",", "cfun", "->", "machine", "->", "uses_anonymous_args", ")", ";", "if", "(", "cfun", "->", "machine", "->", "lr_save_eliminated", ")", "asm_fprintf", "(", "f", ",", "\"\\t%@ link register save eliminated.\\n\"", ")", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "asm_fprintf", "(", "f", ",", "\"\\t@ Calls __builtin_eh_return.\\n\"", ")", ";", "}", "</s>" ]

[ "Place", "some", "comments", "into", "the", "assembler", "stream", "describing", "the", "current", "function", "." ]

[ "arm", "\"\\t%@ Function supports interworking.\\n\"", "\"\\t%@ Interrupt Service Routine.\\n\"", "\"\\t%@ Fast Interrupt Service Routine.\\n\"", "\"\\t%@ ARM Exception Handler.\\n\"", "\"\\t%@ Naked Function: prologue and epilogue provided by programmer.\\n\"", "\"\\t%@ Volatile: function does not return.\\n\"", "\"\\t%@ Nested: function declared inside another function.\\n\"", "\"\\t%@ Stack Align: May be called with mis-aligned SP.\\n\"", "\"\\t%@ Non-secure entry function: called from non-secure code.\\n\"", "\"\\t%@ args = %d, pretend = %d, frame = %wd\\n\"", "\"\\t%@ frame_needed = %d, uses_anonymous_args = %d\\n\"", "\"\\t%@ link register save eliminated.\\n\"", "\"\\t@ Calls __builtin_eh_return.\\n\"" ]

[]

[ "<s>", "bool", "isZero", "(", ")", "const", "{", "return", "K", "==", "ConstZero", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "expression", "is", "a", "constant", "zero", "." ]

[ "PowerPC" ]

[]

[ "<s>", "bool", "ix86_expand_fp_vcond", "(", "rtx", "operands", "[", "]", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "3", "]", ")", ";", "rtx", "cmp", ";", "code", "=", "ix86_prepare_sse_fp_compare_args", "(", "operands", "[", "0", "]", ",", "code", ",", "&", "operands", "[", "4", "]", ",", "&", "operands", "[", "5", "]", ")", ";", "if", "(", "code", "==", "UNKNOWN", ")", "{", "rtx", "temp", ";", "switch", "(", "GET_CODE", "(", "operands", "[", "3", "]", ")", ")", "{", "case", "LTGT", ":", "temp", "=", "ix86_expand_sse_cmp", "(", "operands", "[", "0", "]", ",", "ORDERED", ",", "operands", "[", "4", "]", ",", "operands", "[", "5", "]", ",", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ")", ";", "cmp", "=", "ix86_expand_sse_cmp", "(", "operands", "[", "0", "]", ",", "NE", ",", "operands", "[", "4", "]", ",", "operands", "[", "5", "]", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ";", "code", "=", "AND", ";", "break", ";", "case", "UNEQ", ":", "temp", "=", "ix86_expand_sse_cmp", "(", "operands", "[", "0", "]", ",", "UNORDERED", ",", "operands", "[", "4", "]", ",", "operands", "[", "5", "]", ",", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ")", ";", "cmp", "=", "ix86_expand_sse_cmp", "(", "operands", "[", "0", "]", ",", "EQ", ",", "operands", "[", "4", "]", ",", "operands", "[", "5", "]", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ";", "code", "=", "IOR", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "cmp", "=", "expand_simple_binop", "(", "GET_MODE", "(", "cmp", ")", ",", "code", ",", "temp", ",", "cmp", ",", "cmp", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "ix86_expand_sse_movcc", "(", "operands", "[", "0", "]", ",", "cmp", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ";", "return", "true", ";", "}", "if", "(", "ix86_expand_sse_fp_minmax", "(", "operands", "[", "0", "]", ",", "code", ",", "operands", "[", "4", "]", ",", "operands", "[", "5", "]", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ")", "return", "true", ";", "cmp", "=", "ix86_expand_sse_cmp", "(", "operands", "[", "0", "]", ",", "code", ",", "operands", "[", "4", "]", ",", "operands", "[", "5", "]", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ";", "ix86_expand_sse_movcc", "(", "operands", "[", "0", "]", ",", "cmp", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Expand", "a", "floating-point", "vector", "conditional", "move", ";", "a", "vcond", "operation", "rather", "than", "a", "movcc", "operation", "." ]

[ "i386", "3", "0", "4", "5", "3", "0", "4", "5", "0", "0", "0", "4", "5", "1", "2", "0", "4", "5", "0", "0", "0", "4", "5", "1", "2", "1", "0", "1", "2", "0", "4", "5", "1", "2", "0", "4", "5", "1", "2", "0", "1", "2" ]

[]

[ "<s>", "static", "void", "aarch64_emit_probe_stack_range", "(", "HOST_WIDE_INT", "first", ",", "poly_int64", "poly_size", ")", "{", "HOST_WIDE_INT", "size", ";", "if", "(", "!", "poly_size", ".", "is_constant", "(", "&", "size", ")", ")", "{", "sorry", "(", "\"stack probes for SVE frames\"", ")", ";", "return", ";", "}", "rtx", "reg1", "=", "gen_rtx_REG", "(", "Pmode", ",", "PROBE_STACK_FIRST_REG", ")", ";", "gcc_assert", "(", "(", "first", "%", "ARITH_FACTOR", ")", "==", "0", ")", ";", "if", "(", "size", "<=", "PROBE_INTERVAL", ")", "{", "const", "HOST_WIDE_INT", "base", "=", "ROUND_UP", "(", "size", ",", "ARITH_FACTOR", ")", ";", "emit_set_insn", "(", "reg1", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "base", ")", ")", ")", ";", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "reg1", ",", "base", "-", "size", ")", ")", ";", "}", "else", "if", "(", "size", "<=", "4", "*", "PROBE_INTERVAL", ")", "{", "HOST_WIDE_INT", "i", ",", "rem", ";", "emit_set_insn", "(", "reg1", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "PROBE_INTERVAL", ")", ")", ")", ";", "emit_stack_probe", "(", "reg1", ")", ";", "for", "(", "i", "=", "2", "*", "PROBE_INTERVAL", ";", "i", "<", "size", ";", "i", "+=", "PROBE_INTERVAL", ")", "{", "emit_set_insn", "(", "reg1", ",", "plus_constant", "(", "Pmode", ",", "reg1", ",", "-", "PROBE_INTERVAL", ")", ")", ";", "emit_stack_probe", "(", "reg1", ")", ";", "}", "rem", "=", "size", "-", "(", "i", "-", "PROBE_INTERVAL", ")", ";", "if", "(", "rem", ">", "256", ")", "{", "const", "HOST_WIDE_INT", "base", "=", "ROUND_UP", "(", "rem", ",", "ARITH_FACTOR", ")", ";", "emit_set_insn", "(", "reg1", ",", "plus_constant", "(", "Pmode", ",", "reg1", ",", "-", "base", ")", ")", ";", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "reg1", ",", "base", "-", "rem", ")", ")", ";", "}", "else", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "reg1", ",", "-", "rem", ")", ")", ";", "}", "else", "{", "rtx", "reg2", "=", "gen_rtx_REG", "(", "Pmode", ",", "PROBE_STACK_SECOND_REG", ")", ";", "HOST_WIDE_INT", "rounded_size", "=", "size", "&", "-", "PROBE_INTERVAL", ";", "emit_set_insn", "(", "reg1", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "first", ")", ")", ";", "HOST_WIDE_INT", "adjustment", "=", "-", "(", "first", "+", "rounded_size", ")", ";", "if", "(", "!", "aarch64_uimm12_shift", "(", "adjustment", ")", ")", "{", "aarch64_internal_mov_immediate", "(", "reg2", ",", "GEN_INT", "(", "adjustment", ")", ",", "true", ",", "Pmode", ")", ";", "emit_set_insn", "(", "reg2", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "reg2", ")", ")", ";", "}", "else", "emit_set_insn", "(", "reg2", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "adjustment", ")", ")", ";", "emit_insn", "(", "gen_probe_stack_range", "(", "reg1", ",", "reg1", ",", "reg2", ")", ")", ";", "if", "(", "size", "!=", "rounded_size", ")", "{", "HOST_WIDE_INT", "rem", "=", "size", "-", "rounded_size", ";", "if", "(", "rem", ">", "256", ")", "{", "const", "HOST_WIDE_INT", "base", "=", "ROUND_UP", "(", "rem", ",", "ARITH_FACTOR", ")", ";", "emit_set_insn", "(", "reg2", ",", "plus_constant", "(", "Pmode", ",", "reg2", ",", "-", "base", ")", ")", ";", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "reg2", ",", "base", "-", "rem", ")", ")", ";", "}", "else", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "reg2", ",", "-", "rem", ")", ")", ";", "}", "}", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "probe", "a", "range", "of", "stack", "addresses", "from", "FIRST", "to", "FIRST+SIZE", ",", "inclusive", ".", "These", "are", "offsets", "from", "the", "current", "stack", "pointer", "." ]

[ "aarch64", "\"stack probes for SVE frames\"", "0", "4", "2", "256", "256" ]

[]

[ "<s>", "unsigned", "AAPInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "AAP", "::", "LDB", ":", "case", "AAP", "::", "LDW", ":", "case", "AAP", "::", "LDB_postinc", ":", "case", "AAP", "::", "LDW_postinc", ":", "case", "AAP", "::", "LDB_predec", ":", "case", "AAP", "::", "LDW_predec", ":", "break", ";", "}", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "AAP", "AAP", "0", "AAP::LDB", "AAP::LDW", "AAP::LDB_postinc", "AAP::LDW_postinc", "AAP::LDB_predec", "AAP::LDW_predec", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isFpOrNEON", "(", "const", "MachineInstr", "&", "MI", ")", "{", "auto", "IsFPR", "=", "[", "&", "]", "(", "const", "MachineOperand", "&", "Op", ")", "{", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "return", "false", ";", "auto", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "if", "(", "Reg", ".", "isPhysical", "(", ")", ")", "return", "AArch64", "::", "FPR128RegClass", ".", "contains", "(", "Reg", ")", "||", "AArch64", "::", "FPR64RegClass", ".", "contains", "(", "Reg", ")", "||", "AArch64", "::", "FPR32RegClass", ".", "contains", "(", "Reg", ")", "||", "AArch64", "::", "FPR16RegClass", ".", "contains", "(", "Reg", ")", "||", "AArch64", "::", "FPR8RegClass", ".", "contains", "(", "Reg", ")", ";", "const", "TargetRegisterClass", "*", "TRC", "=", "::", "getRegClass", "(", "MI", ",", "Reg", ")", ";", "return", "TRC", "==", "&", "AArch64", "::", "FPR128RegClass", "||", "TRC", "==", "&", "AArch64", "::", "FPR128_loRegClass", "||", "TRC", "==", "&", "AArch64", "::", "FPR64RegClass", "||", "TRC", "==", "&", "AArch64", "::", "FPR64_loRegClass", "||", "TRC", "==", "&", "AArch64", "::", "FPR32RegClass", "||", "TRC", "==", "&", "AArch64", "::", "FPR16RegClass", "||", "TRC", "==", "&", "AArch64", "::", "FPR8RegClass", ";", "}", ";", "return", "llvm", "::", "any_of", "(", "MI", ".", "operands", "(", ")", ",", "IsFPR", ")", ";", "}", "</s>" ]

[ "Returns", "whether", "the", "instruction", "is", "FP", "or", "NEON", "." ]

[ "AArch64", "AArch64", "AArch64::FPR128RegClass", "AArch64::FPR64RegClass", "AArch64::FPR32RegClass", "AArch64::FPR16RegClass", "AArch64::FPR8RegClass", "AArch64::FPR128RegClass", "AArch64::FPR128_loRegClass", "AArch64::FPR64RegClass", "AArch64::FPR64_loRegClass", "AArch64::FPR32RegClass", "AArch64::FPR16RegClass", "AArch64::FPR8RegClass" ]

[]

[ "<s>", "bool", "ix86_use_lea_for_mov", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ")", "{", "unsigned", "int", "regno0", ",", "regno1", ";", "if", "(", "!", "TARGET_OPT_AGU", "||", "optimize_function_for_size_p", "(", "cfun", ")", ")", "return", "false", ";", "if", "(", "!", "REG_P", "(", "operands", "[", "0", "]", ")", "||", "!", "REG_P", "(", "operands", "[", "1", "]", ")", ")", "return", "false", ";", "regno0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "regno1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "return", "ix86_lea_outperforms", "(", "insn", ",", "regno0", ",", "regno1", ",", "INVALID_REGNUM", ",", "0", ",", "false", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "should", "emit", "lea", "instruction", "instead", "of", "mov", "instruction", "." ]

[ "i386", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "static", "rtx", "frv_ifcvt_load_value", "(", "rtx", "value", ",", "rtx", "insn", "ATTRIBUTE_UNUSED", ")", "{", "int", "num_alloc", "=", "frv_ifcvt", ".", "cur_scratch_regs", ";", "int", "i", ";", "rtx", "reg", ";", "if", "(", "value", "==", "const0_rtx", ")", "return", "gen_rtx_REG", "(", "SImode", ",", "GPR_FIRST", ")", ";", "if", "(", "CONSTANT_P", "(", "value", ")", "||", "(", "GET_CODE", "(", "value", ")", "==", "REG", "&&", "REGNO", "(", "value", ")", "==", "LR_REGNO", ")", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "num_alloc", ";", "i", "++", ")", "{", "if", "(", "rtx_equal_p", "(", "SET_SRC", "(", "frv_ifcvt", ".", "scratch_regs", "[", "i", "]", ")", ",", "value", ")", ")", "return", "SET_DEST", "(", "frv_ifcvt", ".", "scratch_regs", "[", "i", "]", ")", ";", "}", "}", "if", "(", "num_alloc", ">=", "GPR_TEMP_NUM", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Too many temporary registers allocated\\n\"", ")", ";", "return", "NULL_RTX", ";", "}", "reg", "=", "frv_alloc_temp_reg", "(", "&", "frv_ifcvt", ".", "tmp_reg", ",", "GPR_REGS", ",", "SImode", ",", "TRUE", ",", "TRUE", ")", ";", "if", "(", "!", "reg", ")", "{", "if", "(", "dump_file", ")", "fputs", "(", "\"Could not find a scratch register\\n\"", ",", "dump_file", ")", ";", "return", "NULL_RTX", ";", "}", "frv_ifcvt", ".", "cur_scratch_regs", "++", ";", "frv_ifcvt", ".", "scratch_regs", "[", "num_alloc", "]", "=", "gen_rtx_SET", "(", "reg", ",", "value", ")", ";", "if", "(", "dump_file", ")", "{", "if", "(", "GET_CODE", "(", "value", ")", "==", "CONST_INT", ")", "fprintf", "(", "dump_file", ",", "\"Register %s will hold %ld\\n\"", ",", "reg_names", "[", "REGNO", "(", "reg", ")", "]", ",", "(", "long", ")", "INTVAL", "(", "value", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "value", ")", "==", "REG", "&&", "REGNO", "(", "value", ")", "==", "LR_REGNO", ")", "fprintf", "(", "dump_file", ",", "\"Register %s will hold LR\\n\"", ",", "reg_names", "[", "REGNO", "(", "reg", ")", "]", ")", ";", "else", "fprintf", "(", "dump_file", ",", "\"Register %s will hold a saved value\\n\"", ",", "reg_names", "[", "REGNO", "(", "reg", ")", "]", ")", ";", "}", "return", "reg", ";", "}", "</s>" ]

[ "Return", "a", "register", "which", "will", "be", "loaded", "with", "a", "value", "if", "an", "IF", "block", "is", "converted", "to", "conditional", "execution", ".", "This", "is", "used", "to", "rewrite", "instructions", "that", "use", "constants", "to", "ones", "that", "just", "use", "registers", "." ]

[ "frv", "0", "\"Too many temporary registers allocated\\n\"", "\"Could not find a scratch register\\n\"", "\"Register %s will hold %ld\\n\"", "\"Register %s will hold LR\\n\"", "\"Register %s will hold a saved value\\n\"" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isInlineConstant", "(", "const", "MachineOperand", "&", "MO", ",", "uint8_t", "OperandType", ")", "const", "{", "if", "(", "!", "MO", ".", "isImm", "(", ")", "||", "OperandType", "<", "AMDGPU", "::", "OPERAND_SRC_FIRST", "||", "OperandType", ">", "AMDGPU", "::", "OPERAND_SRC_LAST", ")", "return", "false", ";", "int64_t", "Imm", "=", "MO", ".", "getImm", "(", ")", ";", "switch", "(", "OperandType", ")", "{", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP32", ":", "{", "int32_t", "Trunc", "=", "static_cast", "<", "int32_t", ">", "(", "Imm", ")", ";", "return", "Trunc", "==", "Imm", "&&", "AMDGPU", "::", "isInlinableLiteral32", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "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", "AMDGPU", "::", "isInlinableLiteral64", "(", "MO", ".", "getImm", "(", ")", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP16", ":", "{", "if", "(", "isInt", "<", "16", ">", "(", "Imm", ")", "||", "isUInt", "<", "16", ">", "(", "Imm", ")", ")", "{", "int16_t", "Trunc", "=", "static_cast", "<", "int16_t", ">", "(", "Imm", ")", ";", "return", "ST", ".", "has16BitInsts", "(", ")", "&&", "AMDGPU", "::", "isInlinableLiteral16", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "return", "false", ";", "}", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_V2INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_V2FP16", ":", "{", "uint32_t", "Trunc", "=", "static_cast", "<", "uint32_t", ">", "(", "Imm", ")", ";", "return", "AMDGPU", "::", "isInlinableLiteralV216", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "default", ":", "llvm_unreachable", "(", "\"invalid bitwidth\"", ")", ";", "}", "}", "</s>" ]

[ "returns", "true", "if", "the", "operand", "OpIdx", "in", "MI", "is", "a", "valid", "inline", "immediate", "." ]

[ "AMDGPU", "SI", "AMDGPU::OPERAND_SRC_FIRST", "AMDGPU::OPERAND_SRC_LAST", "AMDGPU::OPERAND_REG_IMM_INT32", "AMDGPU::OPERAND_REG_IMM_FP32", "AMDGPU::OPERAND_REG_INLINE_C_INT32", "AMDGPU::OPERAND_REG_INLINE_C_FP32", "AMDGPU::isInlinableLiteral32", "AMDGPU::OPERAND_REG_IMM_INT64", "AMDGPU::OPERAND_REG_IMM_FP64", "AMDGPU::OPERAND_REG_INLINE_C_INT64", "AMDGPU::OPERAND_REG_INLINE_C_FP64", "AMDGPU::isInlinableLiteral64", "AMDGPU::OPERAND_REG_IMM_INT16", "AMDGPU::OPERAND_REG_IMM_FP16", "AMDGPU::OPERAND_REG_INLINE_C_INT16", "AMDGPU::OPERAND_REG_INLINE_C_FP16", "16", "16", "AMDGPU::isInlinableLiteral16", "AMDGPU::OPERAND_REG_INLINE_C_V2INT16", "AMDGPU::OPERAND_REG_INLINE_C_V2FP16", "AMDGPU::isInlinableLiteralV216", "\"invalid bitwidth\"" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "AdjustInstrPostInstrSelection", "(", "MachineInstr", "*", "MI", ",", "SDNode", "*", "Node", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "Subtarget", "->", "getInstrInfo", "(", ")", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "TII", "->", "legalizeOperands", "(", "MI", ")", ";", "if", "(", "TII", "->", "isMIMG", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "{", "unsigned", "VReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "Writemask", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "BitsSet", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "4", ";", "++", "i", ")", "BitsSet", "+=", "Writemask", "&", "(", "1", "<<", "i", ")", "?", "1", ":", "0", ";", "const", "TargetRegisterClass", "*", "RC", ";", "switch", "(", "BitsSet", ")", "{", "default", ":", "return", ";", "case", "1", ":", "RC", "=", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "break", ";", "case", "2", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_64RegClass", ";", "break", ";", "case", "3", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_96RegClass", ";", "break", ";", "}", "unsigned", "NewOpcode", "=", "TII", "->", "getMaskedMIMGOp", "(", "MI", "->", "getOpcode", "(", ")", ",", "BitsSet", ")", ";", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "NewOpcode", ")", ")", ";", "MRI", ".", "setRegClass", "(", "VReg", ",", "RC", ")", ";", "return", ";", "}", "int", "NoRetAtomicOp", "=", "AMDGPU", "::", "getAtomicNoRetOp", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "NoRetAtomicOp", "!=", "-", "1", ")", "{", "if", "(", "!", "Node", "->", "hasAnyUseOfValue", "(", "0", ")", ")", "{", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "NoRetAtomicOp", ")", ")", ";", "MI", "->", "RemoveOperand", "(", "0", ")", ";", "}", "return", ";", "}", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'hasPostISelHook", "'", "flag", "." ]

[ "R600", "SI", "SI", "SI", "0", "1", "0", "0", "4", "1", "1", "0", "1", "2", "3", "1", "0", "0" ]

[]

[ "<s>", "GCNSubtarget", "&", "GCNSubtarget", "::", "initializeSubtargetDependencies", "(", "const", "Triple", "&", "TT", ",", "StringRef", "GPU", ",", "StringRef", "FS", ")", "{", "SmallString", "<", "256", ">", "FullFS", "(", "\"+promote-alloca,+load-store-opt,+enable-ds128,\"", ")", ";", "if", "(", "isAmdHsaOS", "(", ")", ")", "FullFS", "+=", "\"+flat-for-global,+unaligned-access-mode,+trap-handler,\"", ";", "FullFS", "+=", "\"+enable-prt-strict-null,\"", ";", "if", "(", "FS", ".", "find_lower", "(", "\"+wavefrontsize\"", ")", "!=", "StringRef", "::", "npos", ")", "{", "if", "(", "FS", ".", "find_lower", "(", "\"wavefrontsize16\"", ")", "==", "StringRef", "::", "npos", ")", "FullFS", "+=", "\"-wavefrontsize16,\"", ";", "if", "(", "FS", ".", "find_lower", "(", "\"wavefrontsize32\"", ")", "==", "StringRef", "::", "npos", ")", "FullFS", "+=", "\"-wavefrontsize32,\"", ";", "if", "(", "FS", ".", "find_lower", "(", "\"wavefrontsize64\"", ")", "==", "StringRef", "::", "npos", ")", "FullFS", "+=", "\"-wavefrontsize64,\"", ";", "}", "FullFS", "+=", "FS", ";", "ParseSubtargetFeatures", "(", "GPU", ",", "GPU", ",", "FullFS", ")", ";", "if", "(", "Gen", "==", "AMDGPUSubtarget", "::", "INVALID", ")", "{", "Gen", "=", "TT", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", "?", "AMDGPUSubtarget", "::", "SEA_ISLANDS", ":", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ";", "}", "assert", "(", "!", "hasFP64", "(", ")", "||", "(", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", ")", ";", "assert", "(", "hasAddr64", "(", ")", "||", "hasFlat", "(", ")", ")", ";", "if", "(", "!", "hasAddr64", "(", ")", "&&", "!", "FS", ".", "contains", "(", "\"flat-for-global\"", ")", "&&", "!", "FlatForGlobal", ")", "{", "ToggleFeature", "(", "AMDGPU", "::", "FeatureFlatForGlobal", ")", ";", "FlatForGlobal", "=", "true", ";", "}", "if", "(", "!", "hasFlat", "(", ")", "&&", "!", "FS", ".", "contains", "(", "\"flat-for-global\"", ")", "&&", "FlatForGlobal", ")", "{", "ToggleFeature", "(", "AMDGPU", "::", "FeatureFlatForGlobal", ")", ";", "FlatForGlobal", "=", "false", ";", "}", "if", "(", "MaxPrivateElementSize", "==", "0", ")", "MaxPrivateElementSize", "=", "4", ";", "if", "(", "LDSBankCount", "==", "0", ")", "LDSBankCount", "=", "32", ";", "if", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "{", "if", "(", "LocalMemorySize", "==", "0", ")", "LocalMemorySize", "=", "32768", ";", "if", "(", "!", "HasMovrel", "&&", "!", "HasVGPRIndexMode", ")", "HasMovrel", "=", "true", ";", "}", "if", "(", "WavefrontSizeLog2", "==", "0", ")", "WavefrontSizeLog2", "=", "5", ";", "HasFminFmaxLegacy", "=", "getGeneration", "(", ")", "<", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ";", "TargetID", ".", "setTargetIDFromFeaturesString", "(", "FS", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"xnack setting for subtarget: \"", "<<", "TargetID", ".", "getXnackSetting", "(", ")", "<<", "'\\n'", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"sramecc setting for subtarget: \"", "<<", "TargetID", ".", "getSramEccSetting", "(", ")", "<<", "'\\n'", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "AMDGPU", "256", "\"+promote-alloca,+load-store-opt,+enable-ds128,\"", "\"+flat-for-global,+unaligned-access-mode,+trap-handler,\"", "\"+enable-prt-strict-null,\"", "\"+wavefrontsize\"", "\"wavefrontsize16\"", "\"-wavefrontsize16,\"", "\"wavefrontsize32\"", "\"-wavefrontsize32,\"", "\"wavefrontsize64\"", "\"-wavefrontsize64,\"", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "\"flat-for-global\"", "AMDGPU::FeatureFlatForGlobal", "\"flat-for-global\"", "AMDGPU::FeatureFlatForGlobal", "0", "4", "0", "32", "0", "32768", "0", "5", "AMDGPU", "\"xnack setting for subtarget: \"", "\"sramecc setting for subtarget: \"" ]

[]

[ "<s>", "static", "void", "visium_option_override", "(", "void", ")", "{", "if", "(", "flag_pic", "==", "1", ")", "warning", "(", "OPT_fpic", ",", "\"%<-fpic%> is not supported\"", ")", ";", "if", "(", "flag_pic", "==", "2", ")", "warning", "(", "OPT_fPIC", ",", "\"%<-fPIC%> is not supported\"", ")", ";", "target_flags", "|=", "MASK_MCM", ";", "if", "(", "(", "target_flags_explicit", "&", "MASK_FPU", ")", "==", "0", ")", "target_flags", "|=", "MASK_FPU", ";", "if", "(", "(", "target_flags_explicit", "&", "MASK_SV_MODE", ")", "==", "0", ")", "target_flags", "|=", "MASK_SV_MODE", ";", "if", "(", "visium_cpu_and_features", "==", "PROCESSOR_GR6", ")", "{", "target_flags", "|=", "MASK_BMI", ";", "if", "(", "target_flags", "&", "MASK_FPU", ")", "target_flags", "|=", "MASK_FPU_IEEE", ";", "}", "if", "(", "!", "global_options_set", ".", "x_visium_cpu", ")", "visium_cpu", "=", "visium_cpu_and_features", ";", "if", "(", "flag_align_functions", "&&", "!", "str_align_functions", ")", "{", "if", "(", "visium_cpu", "==", "PROCESSOR_GR6", ")", "str_align_functions", "=", "\"64\"", ";", "else", "str_align_functions", "=", "\"256\"", ";", "maybe_set_param_value", "(", "PARAM_INLINE_UNIT_GROWTH", ",", "100", ",", "global_options", ".", "x_param_values", ",", "global_options_set", ".", "x_param_values", ")", ";", "}", "if", "(", "flag_align_loops", "&&", "!", "str_align_loops", ")", "{", "if", "(", "visium_cpu", "==", "PROCESSOR_GR6", ")", "str_align_loops", "=", "\"64\"", ";", "else", "{", "str_align_loops", "=", "\"256:32:8\"", ";", "}", "}", "if", "(", "flag_align_jumps", "&&", "!", "str_align_jumps", ")", "{", "if", "(", "visium_cpu", "==", "PROCESSOR_GR6", ")", "str_align_jumps", "=", "\"64\"", ";", "else", "str_align_jumps", "=", "\"8\"", ";", "}", "}", "</s>" ]

[ "Options", "override", "for", "Visium", "." ]

[ "visium", "1", "\"%<-fpic%> is not supported\"", "2", "\"%<-fPIC%> is not supported\"", "0", "0", "\"64\"", "\"256\"", "100", "\"64\"", "\"256:32:8\"", "\"64\"", "\"8\"" ]

[]

[ "<s>", "void", "MOSMCCodeEmitter", "::", "emitInstruction", "(", "uint64_t", "Val", ",", "unsigned", "Size", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "const", "{", "for", "(", "int64_t", "I", "=", "0", ";", "I", "<", "Size", ";", "++", "I", ")", "{", "OS", "<<", "(", "char", ")", "(", "Val", "&", "0xff", ")", ";", "Val", "=", "Val", ">>", "8", ";", "}", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "MOS", "MOS", "0", "0xff", "8" ]

[]

[ "<s>", "static", "opt_machine_mode", "aarch64_get_mask_mode", "(", "poly_uint64", "nunits", ",", "poly_uint64", "nbytes", ")", "{", "if", "(", "TARGET_SVE", "&&", "known_eq", "(", "nbytes", ",", "BYTES_PER_SVE_VECTOR", ")", ")", "{", "unsigned", "int", "elem_nbytes", "=", "vector_element_size", "(", "nbytes", ",", "nunits", ")", ";", "machine_mode", "pred_mode", ";", "if", "(", "aarch64_sve_pred_mode", "(", "elem_nbytes", ")", ".", "exists", "(", "&", "pred_mode", ")", ")", "return", "pred_mode", ";", "}", "return", "default_get_mask_mode", "(", "nunits", ",", "nbytes", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_VECTORIZE_GET_MASK_MODE", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "SystemZTargetLowering", "::", "hasInlineStackProbe", "(", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"probe-stack\"", ")", ")", "return", "MF", ".", "getFunction", "(", ")", ".", "getFnAttribute", "(", "\"probe-stack\"", ")", ".", "getValueAsString", "(", ")", "==", "\"inline-asm\"", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "stack", "probing", "through", "inline", "assembly", "is", "requested", "." ]

[ "SystemZ", "SystemZ", "\"probe-stack\"", "\"probe-stack\"", "\"inline-asm\"" ]

[]

[ "<s>", "bool", "isIncomingArgumentHandler", "(", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "handler", "is", "dealing", "with", "incoming", "arguments", ",", "i.e", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "X86AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "X86MCInstLower", "MCInstLowering", "(", "Mang", ",", "*", "MF", ",", "*", "this", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "if", "(", "isVerbose", "(", ")", "&&", "OutStreamer", ".", "hasRawTextSupport", "(", ")", ")", "{", "std", "::", "string", "TmpStr", ";", "raw_string_ostream", "OS", "(", "TmpStr", ")", ";", "PrintDebugValueComment", "(", "MI", ",", "OS", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "OS", ".", "str", "(", ")", ")", ")", ";", "}", "return", ";", "case", "X86", "::", "Int_MemBarrier", ":", "if", "(", "OutStreamer", ".", "hasRawTextSupport", "(", ")", ")", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "\"\\t#MEMBARRIER\"", ")", ")", ";", "return", ";", "case", "X86", "::", "EH_RETURN", ":", "case", "X86", "::", "EH_RETURN64", ":", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "OutStreamer", ".", "AddComment", "(", "StringRef", "(", "\"eh_return, addr: %\"", ")", "+", "X86ATTInstPrinter", "::", "getRegisterName", "(", "Reg", ")", ")", ";", "break", ";", "}", "case", "X86", "::", "TAILJMPr", ":", "case", "X86", "::", "TAILJMPd", ":", "case", "X86", "::", "TAILJMPd64", ":", "OutStreamer", ".", "AddComment", "(", "\"TAILCALL\"", ")", ";", "break", ";", "case", "X86", "::", "TLS_addr32", ":", "case", "X86", "::", "TLS_addr64", ":", "case", "X86", "::", "TLS_base_addr32", ":", "case", "X86", "::", "TLS_base_addr64", ":", "return", "LowerTlsAddr", "(", "OutStreamer", ",", "MCInstLowering", ",", "*", "MI", ")", ";", "case", "X86", "::", "MOVPC32r", ":", "{", "MCSymbol", "*", "PICBase", "=", "MF", "->", "getPICBaseSymbol", "(", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "MCInstBuilder", "(", "getSubtarget", "(", ")", ".", "isTargetNaCl", "(", ")", "?", "X86", "::", "NACL_CALL32d", ":", "X86", "::", "CALLpcrel32", ")", ".", "addExpr", "(", "MCSymbolRefExpr", "::", "Create", "(", "PICBase", ",", "OutContext", ")", ")", ")", ";", "OutStreamer", ".", "EmitLabel", "(", "PICBase", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "MCInstBuilder", "(", "X86", "::", "POP32r", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", ";", "return", ";", "}", "case", "X86", "::", "ADD32ri", ":", "{", "if", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getTargetFlags", "(", ")", "!=", "X86II", "::", "MO_GOT_ABSOLUTE_ADDRESS", ")", "break", ";", "MCSymbol", "*", "DotSym", "=", "OutContext", ".", "CreateTempSymbol", "(", ")", ";", "OutStreamer", ".", "EmitLabel", "(", "DotSym", ")", ";", "MCSymbol", "*", "OpSym", "=", "MCInstLowering", ".", "GetSymbolFromOperand", "(", "MI", "->", "getOperand", "(", "2", ")", ")", ";", "const", "MCExpr", "*", "DotExpr", "=", "MCSymbolRefExpr", "::", "Create", "(", "DotSym", ",", "OutContext", ")", ";", "const", "MCExpr", "*", "PICBase", "=", "MCSymbolRefExpr", "::", "Create", "(", "MF", "->", "getPICBaseSymbol", "(", ")", ",", "OutContext", ")", ";", "DotExpr", "=", "MCBinaryExpr", "::", "CreateSub", "(", "DotExpr", ",", "PICBase", ",", "OutContext", ")", ";", "DotExpr", "=", "MCBinaryExpr", "::", "CreateAdd", "(", "MCSymbolRefExpr", "::", "Create", "(", "OpSym", ",", "OutContext", ")", ",", "DotExpr", ",", "OutContext", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "MCInstBuilder", "(", "X86", "::", "ADD32ri", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addExpr", "(", "DotExpr", ")", ")", ";", "return", ";", "}", "}", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "X86", "X86", "X86", "X86::Int_MemBarrier", "\"\\t#MEMBARRIER\"", "X86::EH_RETURN", "X86::EH_RETURN64", "0", "\"eh_return, addr: %\"", "X86", "X86::TAILJMPr", "X86::TAILJMPd", "X86::TAILJMPd64", "\"TAILCALL\"", "X86::TLS_addr32", "X86::TLS_addr64", "X86::TLS_base_addr32", "X86::TLS_base_addr64", "X86::MOVPC32r", "X86::NACL_CALL32d", "X86::CALLpcrel32", "X86::POP32r", "0", "X86::ADD32ri", "2", "X86II::MO_GOT_ABSOLUTE_ADDRESS", "2", "X86::ADD32ri", "0", "1" ]

[]

[ "<s>", "bool", "TMS320C64XTargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "if", "(", "!", "Subtarget", ".", "enablePostRAScheduler", "(", ")", ")", "PM", ".", "add", "(", "createTMS320C64XDelaySlotFillerPass", "(", "*", "this", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "TMS320C64X", "TMS320C64X", "TMS320C64X" ]

[]

[ "<s>", "static", "void", "i386_pe_seh_fini", "(", "FILE", "*", "f", ")", "{", "if", "(", "!", "TARGET_SEH", ")", "return", ";", "if", "(", "cfun", "->", "is_thunk", ")", "return", ";", "fputs", "(", "\"\\t.seh_endproc\\n\"", ",", "f", ")", ";", "}", "</s>" ]

[ "Emit", "an", "assembler", "directive", "for", "the", "end", "of", "the", "function", "." ]

[ "i386", "\"\\t.seh_endproc\\n\"" ]

[]

[ "<s>", "static", "int", "sparc_tls_symbol_ref_1", "(", "rtx", "*", "x", ",", "void", "*", "data", "ATTRIBUTE_UNUSED", ")", "{", "return", "SPARC_SYMBOL_REF_TLS_P", "(", "*", "x", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "*", "X", "is", "a", "thread-local", "symbol", "." ]

[ "sparc" ]

[]

[ "<s>", "bool", "AArch64StorePairSuppress", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "TargetSubtargetInfo", "&", "ST", "=", "MF", ".", "getSubtarget", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "SchedModel", ".", "init", "(", "&", "ST", ")", ";", "Traces", "=", "&", "getAnalysis", "<", "MachineTraceMetrics", ">", "(", ")", ";", "MinInstr", "=", "nullptr", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** \"", "<<", "getPassName", "(", ")", "<<", "\": \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "!", "SchedModel", ".", "hasInstrSchedModel", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" Skipping pass: no machine model present.\\n\"", ")", ";", "return", "false", ";", "}", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "bool", "SuppressSTP", "=", "false", ";", "unsigned", "PrevBaseReg", "=", "0", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "!", "isNarrowFPStore", "(", "MI", ")", ")", "continue", ";", "const", "MachineOperand", "*", "BaseOp", ";", "int64_t", "Offset", ";", "if", "(", "TII", "->", "getMemOperandWithOffset", "(", "MI", ",", "BaseOp", ",", "Offset", ",", "TRI", ")", "&&", "BaseOp", "->", "isReg", "(", ")", ")", "{", "Register", "BaseReg", "=", "BaseOp", "->", "getReg", "(", ")", ";", "if", "(", "PrevBaseReg", "==", "BaseReg", ")", "{", "if", "(", "!", "SuppressSTP", "&&", "shouldAddSTPToBlock", "(", "MI", ".", "getParent", "(", ")", ")", ")", "break", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Unpairing store \"", "<<", "MI", "<<", "\"\\n\"", ")", ";", "SuppressSTP", "=", "true", ";", "TII", "->", "suppressLdStPair", "(", "MI", ")", ";", "}", "PrevBaseReg", "=", "BaseReg", ";", "}", "else", "PrevBaseReg", "=", "0", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "AArch64", "AArch64", "AArch64", "\"*** \"", "\": \"", "\" Skipping pass: no machine model present.\\n\"", "0", "\"Unpairing store \"", "\"\\n\"", "0" ]

[]

[ "<s>", "SMLoc", "getStartLoc", "(", ")", "const", "override", "{", "return", "StartLoc", ";", "}", "</s>" ]

[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]

[ "Lanai" ]

[]

[ "<s>", "unsigned", "int", "sh_cbranch_distance", "(", "rtx_insn", "*", "_cbranch_insn", ",", "unsigned", "int", "max_dist", ")", "{", "rtx_jump_insn", "*", "cbranch_insn", "=", "safe_as_a", "<", "rtx_jump_insn", "*", ">", "(", "_cbranch_insn", ")", ";", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\"sh_cbranch_distance insn = \\n\"", ")", ";", "print_rtl_single", "(", "dump_file", ",", "cbranch_insn", ")", ";", "}", "unsigned", "int", "dist", "=", "0", ";", "for", "(", "rtx_insn", "*", "i", "=", "next_nonnote_insn", "(", "cbranch_insn", ")", ";", "i", "!=", "NULL", "&&", "dist", "<", "max_dist", ";", "i", "=", "next_nonnote_insn", "(", "i", ")", ")", "{", "const", "unsigned", "int", "i_len", "=", "get_attr_length", "(", "i", ")", ";", "dist", "+=", "i_len", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" insn %d length = %u dist = %u\\n\"", ",", "INSN_UID", "(", "i", ")", ",", "i_len", ",", "dist", ")", ";", "if", "(", "rtx_code_label", "*", "l", "=", "dyn_cast", "<", "rtx_code_label", "*", ">", "(", "i", ")", ")", "{", "if", "(", "l", "==", "cbranch_insn", "->", "jump_target", "(", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" cbranch dist = %u\\n\"", ",", "dist", ")", ";", "return", "dist", ";", "}", "break", ";", "}", "}", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" cbranch dist = unknown\\n\"", ")", ";", "return", "unknown_cbranch_distance", ";", "}", "</s>" ]

[ "Try", "to", "calculate", "the", "branch", "distance", "of", "a", "conditional", "branch", "in", "bytes", ".", "FIXME", ":", "Because", "of", "PR", "59189", "we", "ca", "n't", "use", "the", "CFG", "here", ".", "Instead", "just", "walk", "from", "this", "insn", "into", "the", "next", "(", "fall-through", ")", "basic", "block", "and", "see", "if", "we", "hit", "the", "label", "." ]

[ "sh", "\"sh_cbranch_distance insn = \\n\"", "0", "\" insn %d length = %u dist = %u\\n\"", "\" cbranch dist = %u\\n\"", "\" cbranch dist = unknown\\n\"" ]

[]

[ "<s>", "static", "unsigned", "int", "h8300_displacement_length", "(", "rtx", "addr", ",", "int", "size", ")", "{", "rtx", "offset", ";", "offset", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "register_operand", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "VOIDmode", ")", "&&", "GET_CODE", "(", "offset", ")", "==", "CONST_INT", "&&", "(", "INTVAL", "(", "offset", ")", "==", "size", "||", "INTVAL", "(", "offset", ")", "==", "size", "*", "2", "||", "INTVAL", "(", "offset", ")", "==", "size", "*", "3", ")", ")", "return", "0", ";", "return", "h8300_constant_length", "(", "offset", ")", ";", "}", "</s>" ]

[ "Return", "the", "size", "of", "a", "displacement", "field", "in", "address", "ADDR", ",", "which", "should", "have", "the", "form", "(", "plus", "X", "constant", ")", ".", "SIZE", "is", "the", "number", "of", "bytes", "being", "accessed", "." ]

[ "h8300", "1", "0", "2", "3", "0" ]

[]

[ "<s>", "SDValue", "ARMTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADD", ":", "return", "PerformADDCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SUB", ":", "return", "PerformSUBCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMULCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformORCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "XOR", ":", "return", "PerformXORCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "PerformANDCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ARMISD", "::", "BFI", ":", "return", "PerformBFICombine", "(", "N", ",", "DCI", ")", ";", "case", "ARMISD", "::", "VMOVRRD", ":", "return", "PerformVMOVRRDCombine", "(", "N", ",", "DCI", ")", ";", "case", "ARMISD", "::", "VMOVDRR", ":", "return", "PerformVMOVDRRCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "PerformSTORECombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "PerformBUILD_VECTORCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "PerformInsertEltCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "PerformVECTOR_SHUFFLECombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ARMISD", "::", "VDUPLANE", ":", "return", "PerformVDUPLANECombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "PerformVCVTCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "PerformVDIVCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "PerformIntrinsicCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "PerformShiftCombine", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "ANY_EXTEND", ":", "return", "PerformExtendCombine", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "PerformSELECT_CCCombine", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "case", "ARMISD", "::", "CMOV", ":", "return", "PerformCMOVCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ARMISD", "::", "VLD2DUP", ":", "case", "ARMISD", "::", "VLD3DUP", ":", "case", "ARMISD", "::", "VLD4DUP", ":", "return", "CombineBaseUpdate", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "case", "Intrinsic", "::", "arm_neon_vld1", ":", "case", "Intrinsic", "::", "arm_neon_vld2", ":", "case", "Intrinsic", "::", "arm_neon_vld3", ":", "case", "Intrinsic", "::", "arm_neon_vld4", ":", "case", "Intrinsic", "::", "arm_neon_vld2lane", ":", "case", "Intrinsic", "::", "arm_neon_vld3lane", ":", "case", "Intrinsic", "::", "arm_neon_vld4lane", ":", "case", "Intrinsic", "::", "arm_neon_vst1", ":", "case", "Intrinsic", "::", "arm_neon_vst2", ":", "case", "Intrinsic", "::", "arm_neon_vst3", ":", "case", "Intrinsic", "::", "arm_neon_vst4", ":", "case", "Intrinsic", "::", "arm_neon_vst2lane", ":", "case", "Intrinsic", "::", "arm_neon_vst3lane", ":", "case", "Intrinsic", "::", "arm_neon_vst4lane", ":", "return", "CombineBaseUpdate", "(", "N", ",", "DCI", ")", ";", "default", ":", "break", ";", "}", "break", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "ARM", "ARM", "ISD::ADD", "ISD::SUB", "ISD::MUL", "ISD::OR", "ISD::XOR", "ISD::AND", "ARMISD::BFI", "ARMISD::VMOVRRD", "ARMISD::VMOVDRR", "ISD::STORE", "ISD::BUILD_VECTOR", "ISD::INSERT_VECTOR_ELT", "ISD::VECTOR_SHUFFLE", "ARMISD::VDUPLANE", "ISD::FP_TO_SINT", "ISD::FP_TO_UINT", "ISD::FDIV", "ISD::INTRINSIC_WO_CHAIN", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::ANY_EXTEND", "ISD::SELECT_CC", "ARMISD::CMOV", "ARMISD::VLD2DUP", "ARMISD::VLD3DUP", "ARMISD::VLD4DUP", "ISD::INTRINSIC_VOID", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::arm_neon_vld1", "Intrinsic::arm_neon_vld2", "Intrinsic::arm_neon_vld3", "Intrinsic::arm_neon_vld4", "Intrinsic::arm_neon_vld2lane", "Intrinsic::arm_neon_vld3lane", "Intrinsic::arm_neon_vld4lane", "Intrinsic::arm_neon_vst1", "Intrinsic::arm_neon_vst2", "Intrinsic::arm_neon_vst3", "Intrinsic::arm_neon_vst4", "Intrinsic::arm_neon_vst2lane", "Intrinsic::arm_neon_vst3lane", "Intrinsic::arm_neon_vst4lane" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "SPIRVInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "TBB", "=", "nullptr", ";", "FBB", "=", "nullptr", ";", "if", "(", "MBB", ".", "empty", "(", ")", ")", "return", "false", ";", "auto", "MI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "!", "MI", ".", "isValid", "(", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "SPIRV", "::", "OpBranch", ")", "{", "TBB", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "else", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "SPIRV", "::", "OpBranchConditional", ")", "{", "Cond", ".", "push_back", "(", "MI", "->", "getOperand", "(", "0", ")", ")", ";", "TBB", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getMBB", "(", ")", ";", "if", "(", "MI", "->", "getNumOperands", "(", ")", "==", "3", ")", "{", "FBB", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getMBB", "(", ")", ";", "}", "return", "false", ";", "}", "else", "{", "return", "true", ";", "}", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "SPIRV", "SPIRV", "SPIRV::OpBranch", "0", "SPIRV::OpBranchConditional", "0", "1", "3", "2" ]

[]

[ "<s>", "bool", "SparcTargetMachine", "::", "addInstSelector", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "PM", ".", "add", "(", "createSparcISelDag", "(", "*", "this", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "Sparc", "Sparc", "Sparc" ]

[]

[ "<s>", "void", "X86MacroFusion", "::", "apply", "(", "ScheduleDAGInstrs", "*", "DAGInstrs", ")", "{", "ScheduleDAGMI", "*", "DAG", "=", "static_cast", "<", "ScheduleDAGMI", "*", ">", "(", "DAGInstrs", ")", ";", "const", "X86Subtarget", "&", "ST", "=", "DAG", "->", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "SUnit", "&", "ExitSU", "=", "DAG", "->", "ExitSU", ";", "MachineInstr", "*", "Branch", "=", "ExitSU", ".", "getInstr", "(", ")", ";", "if", "(", "!", "Branch", "||", "!", "shouldScheduleAdjacent", "(", "ST", ",", "nullptr", ",", "Branch", ")", ")", "return", ";", "for", "(", "SDep", "&", "PredDep", ":", "ExitSU", ".", "Preds", ")", "{", "if", "(", "PredDep", ".", "isWeak", "(", ")", ")", "continue", ";", "SUnit", "&", "SU", "=", "*", "PredDep", ".", "getSUnit", "(", ")", ";", "MachineInstr", "&", "Pred", "=", "*", "SU", ".", "getInstr", "(", ")", ";", "if", "(", "!", "shouldScheduleAdjacent", "(", "ST", ",", "&", "Pred", ",", "Branch", ")", ")", "continue", ";", "bool", "Success", "=", "DAG", "->", "addEdge", "(", "&", "ExitSU", ",", "SDep", "(", "&", "SU", ",", "SDep", "::", "Cluster", ")", ")", ";", "(", "void", ")", "Success", ";", "assert", "(", "Success", "&&", "\"No DAG nodes should be reachable from ExitSU\"", ")", ";", "for", "(", "SDep", "&", "PredDep", ":", "ExitSU", ".", "Preds", ")", "if", "(", "PredDep", ".", "getSUnit", "(", ")", "==", "&", "SU", ")", "PredDep", ".", "setLatency", "(", "0", ")", ";", "for", "(", "SDep", "&", "SuccDep", ":", "SU", ".", "Succs", ")", "if", "(", "SuccDep", ".", "getSUnit", "(", ")", "==", "&", "ExitSU", ")", "SuccDep", ".", "setLatency", "(", "0", ")", ";", "++", "NumFused", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Macro fuse \"", ";", "SU", ".", "print", "(", "dbgs", "(", ")", ",", "DAG", ")", ";", "dbgs", "(", ")", "<<", "\" - ExitSU\"", "<<", "'\\n'", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Apply", "the", "profile", "inference", "algorithm", "for", "a", "given", "function", "." ]

[ "X86", "X86", "X86", "X86", "\"No DAG nodes should be reachable from ExitSU\"", "0", "0", "\"Macro fuse \"", "\" - ExitSU\"" ]

[]

[ "<s>", "void", "SystemZAsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", "{", "const", "SystemZSubtarget", "&", "Subtarget", "=", "static_cast", "<", "const", "SystemZSubtarget", "&", ">", "(", "MF", "->", "getSubtarget", "(", ")", ")", ";", "if", "(", "Subtarget", ".", "getTargetTriple", "(", ")", ".", "isOSzOS", "(", ")", ")", "{", "MCContext", "&", "OutContext", "=", "OutStreamer", "->", "getContext", "(", ")", ";", "MCSymbol", "*", "EPMarkerSym", "=", "OutContext", ".", "createTempSymbol", "(", "\"CM_\"", ",", "true", ")", ";", "const", "MachineFrameInfo", "&", "MFFrame", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "bool", "IsUsingAlloca", "=", "MFFrame", ".", "hasVarSizedObjects", "(", ")", ";", "uint8_t", "Flags", "=", "0", ";", "if", "(", "IsUsingAlloca", ")", "Flags", "|=", "0x04", ";", "uint32_t", "DSASize", "=", "MFFrame", ".", "getStackSize", "(", ")", ";", "uint32_t", "DSAAndFlags", "=", "DSASize", "&", "0xFFFFFFE0", ";", "DSAAndFlags", "|=", "Flags", ";", "OutStreamer", "->", "AddComment", "(", "\"XPLINK Routine Layout Entry\"", ")", ";", "OutStreamer", "->", "emitLabel", "(", "EPMarkerSym", ")", ";", "OutStreamer", "->", "AddComment", "(", "\"Eyecatcher 0x00C300C500C500\"", ")", ";", "OutStreamer", "->", "emitIntValueInHex", "(", "0x00C300C500C500", ",", "7", ")", ";", "OutStreamer", "->", "AddComment", "(", "\"Mark Type C'1'\"", ")", ";", "OutStreamer", "->", "emitInt8", "(", "0xF1", ")", ";", "if", "(", "OutStreamer", "->", "isVerboseAsm", "(", ")", ")", "{", "OutStreamer", "->", "AddComment", "(", "\"DSA Size 0x\"", "+", "Twine", "::", "utohexstr", "(", "DSASize", ")", ")", ";", "OutStreamer", "->", "AddComment", "(", "\"Entry Flags\"", ")", ";", "if", "(", "Flags", "&", "0x04", ")", "OutStreamer", "->", "AddComment", "(", "\" Bit 2: 1 = Uses alloca\"", ")", ";", "else", "OutStreamer", "->", "AddComment", "(", "\" Bit 2: 0 = Does not use alloca\"", ")", ";", "}", "OutStreamer", "->", "emitInt32", "(", "DSAAndFlags", ")", ";", "}", "AsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", ";", "}", "</s>" ]

[ "EmitFunctionEntryLabel", "-", "Emit", "the", "label", "that", "is", "the", "entrypoint", "for", "the", "function", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "\"CM_\"", "0", "0x04", "0xFFFFFFE0", "\"XPLINK Routine Layout Entry\"", "\"Eyecatcher 0x00C300C500C500\"", "0x00C300C500C500", "7", "\"Mark Type C'1'\"", "0xF1", "\"DSA Size 0x\"", "\"Entry Flags\"", "0x04", "\" Bit 2: 1 = Uses alloca\"", "\" Bit 2: 0 = Does not use alloca\"" ]

[]

[ "<s>", "tree", "function_resolver", "::", "get_argument_type", "(", "unsigned", "int", "i", ")", "{", "tree", "arg", "=", "m_arglist", "[", "i", "]", ";", "return", "arg", "==", "error_mark_node", "?", "arg", ":", "TREE_TYPE", "(", "arg", ")", ";", "}", "</s>" ]

[ "Return", "the", "type", "of", "argument", "I", ",", "or", "error_mark_node", "if", "it", "is", "n't", "well-formed", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "rtx_insn", "*", "rs6000_emit_probe_stack_range_stack_clash", "(", "HOST_WIDE_INT", "orig_size", ",", "rtx", "copy_reg", ")", "{", "rtx", "orig_sp", "=", "copy_reg", ";", "HOST_WIDE_INT", "probe_interval", "=", "get_stack_clash_protection_probe_interval", "(", ")", ";", "HOST_WIDE_INT", "rounded_size", "=", "ROUND_DOWN", "(", "orig_size", ",", "probe_interval", ")", ";", "if", "(", "rounded_size", "!=", "orig_size", "||", "rounded_size", ">", "probe_interval", "||", "copy_reg", ")", "{", "if", "(", "!", "copy_reg", ")", "orig_sp", "=", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ";", "emit_move_insn", "(", "orig_sp", ",", "stack_pointer_rtx", ")", ";", "}", "rtx_insn", "*", "retval", "=", "NULL", ";", "if", "(", "rounded_size", "==", "probe_interval", ")", "{", "retval", "=", "rs6000_emit_allocate_stack_1", "(", "probe_interval", ",", "stack_pointer_rtx", ")", ";", "dump_stack_clash_frame_info", "(", "PROBE_INLINE", ",", "rounded_size", "!=", "orig_size", ")", ";", "}", "else", "if", "(", "rounded_size", "<=", "8", "*", "probe_interval", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "rounded_size", ";", "i", "+=", "probe_interval", ")", "{", "rtx_insn", "*", "insn", "=", "rs6000_emit_allocate_stack_1", "(", "probe_interval", ",", "orig_sp", ")", ";", "if", "(", "i", "==", "0", ")", "retval", "=", "insn", ";", "}", "dump_stack_clash_frame_info", "(", "PROBE_INLINE", ",", "rounded_size", "!=", "orig_size", ")", ";", "}", "else", "{", "rtx", "end_addr", "=", "copy_reg", "?", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ":", "gen_rtx_REG", "(", "Pmode", ",", "12", ")", ";", "rtx", "rs", "=", "GEN_INT", "(", "-", "rounded_size", ")", ";", "rtx_insn", "*", "insn", "=", "gen_add3_insn", "(", "end_addr", ",", "stack_pointer_rtx", ",", "rs", ")", ";", "if", "(", "insn", "==", "NULL", ")", "{", "emit_move_insn", "(", "end_addr", ",", "rs", ")", ";", "insn", "=", "gen_add3_insn", "(", "end_addr", ",", "end_addr", ",", "stack_pointer_rtx", ")", ";", "gcc_assert", "(", "insn", ")", ";", "}", "bool", "add_note", "=", "false", ";", "if", "(", "!", "NONJUMP_INSN_P", "(", "insn", ")", "||", "NEXT_INSN", "(", "insn", ")", ")", "add_note", "=", "true", ";", "else", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", "==", "NULL_RTX", "||", "SET_DEST", "(", "set", ")", "!=", "end_addr", "||", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "!=", "PLUS", "||", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "0", ")", "!=", "stack_pointer_rtx", "||", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", "!=", "rs", ")", "add_note", "=", "true", ";", "}", "insn", "=", "emit_insn", "(", "insn", ")", ";", "if", "(", "add_note", ")", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "end_addr", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "rs", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "if", "(", "TARGET_64BIT", ")", "retval", "=", "emit_insn", "(", "gen_probe_stack_rangedi", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "orig_sp", ",", "end_addr", ")", ")", ";", "else", "retval", "=", "emit_insn", "(", "gen_probe_stack_rangesi", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "orig_sp", ",", "end_addr", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "retval", ")", "=", "1", ";", "add_reg_note", "(", "retval", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "end_addr", ")", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "dump_stack_clash_frame_info", "(", "PROBE_LOOP", ",", "rounded_size", "!=", "orig_size", ")", ";", "}", "if", "(", "orig_size", "!=", "rounded_size", ")", "{", "HOST_WIDE_INT", "residual", "=", "orig_size", "-", "rounded_size", ";", "rtx_insn", "*", "insn", "=", "rs6000_emit_allocate_stack_1", "(", "residual", ",", "orig_sp", ")", ";", "if", "(", "!", "retval", ")", "retval", "=", "insn", ";", "}", "return", "retval", ";", "}", "</s>" ]

[ "Allocate", "ORIG_SIZE", "bytes", "on", "the", "stack", "and", "probe", "the", "newly", "allocated", "space", "every", "STACK_CLASH_PROTECTION_PROBE_INTERVAL", "bytes", ".", "COPY_REG", ",", "if", "non-null", ",", "should", "contain", "a", "copy", "of", "the", "original", "stack", "pointer", "at", "exit", "from", "this", "function", ".", "This", "is", "subtly", "different", "than", "the", "Ada", "probing", "in", "that", "it", "tries", "hard", "to", "prevent", "attacks", "that", "jump", "the", "stack", "guard", ".", "Thus", "it", "is", "never", "allowed", "to", "allocate", "more", "than", "STACK_CLASH_PROTECTION_PROBE_INTERVAL", "bytes", "of", "stack", "space", "without", "a", "suitable", "probe", "." ]

[ "rs6000", "0", "8", "0", "0", "0", "12", "0", "1", "1", "1" ]

[]

[ "<s>", "const", "CSKYMCExpr", "*", "CSKYMCExpr", "::", "create", "(", "const", "MCExpr", "*", "Expr", ",", "VariantKind", "Kind", ",", "MCContext", "&", "Ctx", ")", "{", "return", "new", "(", "Ctx", ")", "CSKYMCExpr", "(", "Kind", ",", "Expr", ")", ";", "}", "</s>" ]

[ "This", "creates", "an", "identified", "struct", "." ]

[ "CSKY", "CSKY", "CSKY", "CSKY" ]

[]

[ "<s>", "unsigned", "ARMTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ")", "const", "{", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"sp\"", ",", "ARM", "::", "SP", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "Twine", "(", "\"Invalid register name \\\"\"", "+", "StringRef", "(", "RegName", ")", "+", "\"\\\".\"", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "ARM", "ARM", "\"sp\"", "ARM::SP", "0", "\"Invalid register name \\\"\"", "\"\\\".\"" ]

[]

[ "<s>", "void", "ARMAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "EnableMCInst", ")", "{", "printInstructionThroughMCStreamer", "(", "MI", ")", ";", "}", "else", "{", "int", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "CONSTPOOL_ENTRY", ")", "EmitAlignment", "(", "2", ")", ";", "printInstruction", "(", "MI", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "ARM", "ARM", "ARM::CONSTPOOL_ENTRY", "2" ]

[]

[ "<s>", "void", "ARMMachOTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileMachO", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "LSDASection", "=", "getMachOSection", "(", "\"__TEXT\"", ",", "\"__gcc_except_tab\"", ",", "0", ",", "SectionKind", "::", "getReadOnlyWithRel", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

[ "ARM", "ARM", "\"__TEXT\"", "\"__gcc_except_tab\"", "0" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "R600RegisterInfo", "::", "getCFGStructurizerRegClass", "(", "MVT", "VT", ")", "const", "{", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "case", "MVT", "::", "i32", ":", "return", "&", "R600", "::", "R600_TReg32RegClass", ";", "}", "}", "</s>" ]

[ "get", "the", "register", "class", "of", "the", "specified", "type", "to", "use", "in", "the", "CFGStructurizer" ]

[ "AMDGPU", "R600", "MVT::i32", "R600::R600_TReg32RegClass" ]

[]

[ "<s>", "static", "bool", "hasIndex", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MCRegisterInfo", "&", "RI", ")", "{", "for", "(", "const", "MachineOperand", "&", "Op", ":", "MI", ".", "explicit_operands", "(", ")", ")", "if", "(", "isIndex", "(", "Op", ",", "RI", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "given", "machine", "instr", "is", "mapped", "to", "an", "index", ",", "otherwise", "returns", "false", "." ]

[ "Z80" ]

[]

[ "<s>", "void", "mmix_asm_output_addr_vec_elt", "(", "FILE", "*", "stream", ",", "int", "value", ")", "{", "fprintf", "(", "stream", ",", "\"\\tOCTA L:%d\\n\"", ",", "value", ")", ";", "}", "</s>" ]

[ "ASM_OUTPUT_ADDR_VEC_ELT", "." ]

[ "mmix", "\"\\tOCTA L:%d\\n\"" ]

[]

[ "<s>", "bool", "enableMachineScheduler", "(", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Enable", "the", "MachineScheduler", "pass", "for", "all", "X86", "subtargets", "." ]

[ "MOS" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Hexagon Copy-To-Combine Pass\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon Copy-To-Combine Pass\"" ]

[]

[ "<s>", "const", "RegisterBank", "&", "AArch64RegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "{", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "AArch64", "::", "FPR8RegClassID", ":", "case", "AArch64", "::", "FPR16RegClassID", ":", "case", "AArch64", "::", "FPR32RegClassID", ":", "case", "AArch64", "::", "FPR64RegClassID", ":", "case", "AArch64", "::", "FPR128RegClassID", ":", "case", "AArch64", "::", "FPR128_loRegClassID", ":", "case", "AArch64", "::", "DDRegClassID", ":", "case", "AArch64", "::", "DDDRegClassID", ":", "case", "AArch64", "::", "DDDDRegClassID", ":", "case", "AArch64", "::", "QQRegClassID", ":", "case", "AArch64", "::", "QQQRegClassID", ":", "case", "AArch64", "::", "QQQQRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "FPRRegBankID", ")", ";", "case", "AArch64", "::", "GPR32commonRegClassID", ":", "case", "AArch64", "::", "GPR32RegClassID", ":", "case", "AArch64", "::", "GPR32spRegClassID", ":", "case", "AArch64", "::", "GPR32sponlyRegClassID", ":", "case", "AArch64", "::", "GPR32allRegClassID", ":", "case", "AArch64", "::", "GPR64commonRegClassID", ":", "case", "AArch64", "::", "GPR64RegClassID", ":", "case", "AArch64", "::", "GPR64spRegClassID", ":", "case", "AArch64", "::", "GPR64sponlyRegClassID", ":", "case", "AArch64", "::", "GPR64allRegClassID", ":", "case", "AArch64", "::", "GPR64noipRegClassID", ":", "case", "AArch64", "::", "GPR64common_and_GPR64noipRegClassID", ":", "case", "AArch64", "::", "GPR64noip_and_tcGPR64RegClassID", ":", "case", "AArch64", "::", "tcGPR64RegClassID", ":", "case", "AArch64", "::", "WSeqPairsClassRegClassID", ":", "case", "AArch64", "::", "XSeqPairsClassRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "GPRRegBankID", ")", ";", "case", "AArch64", "::", "CCRRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "CCRegBankID", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Register class not supported\"", ")", ";", "}", "}", "</s>" ]

[ "Get", "a", "register", "bank", "that", "covers", "RC", "." ]

[ "AArch64", "AArch64", "AArch64::FPR8RegClassID", "AArch64::FPR16RegClassID", "AArch64::FPR32RegClassID", "AArch64::FPR64RegClassID", "AArch64::FPR128RegClassID", "AArch64::FPR128_loRegClassID", "AArch64::DDRegClassID", "AArch64::DDDRegClassID", "AArch64::DDDDRegClassID", "AArch64::QQRegClassID", "AArch64::QQQRegClassID", "AArch64::QQQQRegClassID", "AArch64::FPRRegBankID", "AArch64::GPR32commonRegClassID", "AArch64::GPR32RegClassID", "AArch64::GPR32spRegClassID", "AArch64::GPR32sponlyRegClassID", "AArch64::GPR32allRegClassID", "AArch64::GPR64commonRegClassID", "AArch64::GPR64RegClassID", "AArch64::GPR64spRegClassID", "AArch64::GPR64sponlyRegClassID", "AArch64::GPR64allRegClassID", "AArch64::GPR64noipRegClassID", "AArch64::GPR64common_and_GPR64noipRegClassID", "AArch64::GPR64noip_and_tcGPR64RegClassID", "AArch64::tcGPR64RegClassID", "AArch64::WSeqPairsClassRegClassID", "AArch64::XSeqPairsClassRegClassID", "AArch64::GPRRegBankID", "AArch64::CCRRegClassID", "AArch64::CCRegBankID", "\"Register class not supported\"" ]

[]

[ "<s>", "static", "bool", "nvptx_pass_by_reference", "(", "cumulative_args_t", ",", "const", "function_arg_info", "&", "arg", ")", "{", "return", "pass_in_memory", "(", "arg", ".", "mode", ",", "arg", ".", "type", ",", "false", ")", ";", "}", "</s>" ]

[ "Types", "with", "a", "mode", "other", "than", "those", "supported", "by", "the", "machine", "are", "passed", "by", "reference", "in", "memory", "." ]

[ "nvptx" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "HexagonTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "llvm_unreachable", "(", "\"getRegForInlineAsmConstraint Unhandled data type\"", ")", ";", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "f32", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Hexagon", "::", "IntRegsRegClass", ")", ";", "case", "MVT", "::", "i64", ":", "case", "MVT", "::", "f64", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Hexagon", "::", "DoubleRegsRegClass", ")", ";", "}", "default", ":", "llvm_unreachable", "(", "\"Unknown asm register class\"", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "Hexagon", "Hexagon", "1", "0", "\"getRegForInlineAsmConstraint Unhandled data type\"", "MVT::i32", "MVT::i16", "MVT::i8", "MVT::f32", "0U", "Hexagon::IntRegsRegClass", "MVT::i64", "MVT::f64", "0U", "Hexagon::DoubleRegsRegClass", "\"Unknown asm register class\"" ]

[]

[ "<s>", "void", "nvptx_record_needed_fndecl", "(", "tree", "decl", ")", "{", "if", "(", "nvptx_record_fndecl", "(", "decl", ")", ")", "return", ";", "tree", "*", "slot", "=", "needed_fndecls_htab", "->", "find_slot", "(", "decl", ",", "INSERT", ")", ";", "if", "(", "*", "slot", "==", "NULL", ")", "*", "slot", "=", "decl", ";", "}", "</s>" ]

[ "Record", "that", "we", "need", "to", "emit", "a", "ptx", "decl", "for", "DECL", ".", "Either", "do", "it", "now", ",", "or", "record", "it", "for", "later", "in", "case", "we", "have", "no", "argument", "information", "at", "this", "point", "." ]

[ "nvptx" ]

[]

[ "<s>", "static", "int", "spu_naked_function_p", "(", "tree", "func", ")", "{", "tree", "a", ";", "if", "(", "TREE_CODE", "(", "func", ")", "!=", "FUNCTION_DECL", ")", "abort", "(", ")", ";", "a", "=", "lookup_attribute", "(", "\"naked\"", ",", "DECL_ATTRIBUTES", "(", "func", ")", ")", ";", "return", "a", "!=", "NULL_TREE", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "FUNC", "is", "a", "naked", "function", "." ]

[ "spu", "\"naked\"" ]

[]

[ "<s>", "virtual", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "llvm_unreachable", "(", "\"unimplemented!\"", ")", ";", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "Mips", "\"unimplemented!\"" ]

[]

[ "<s>", "void", "AMDGPUTargetLowering", "::", "AnalyzeFormalArguments", "(", "CCState", "&", "State", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ")", "const", "{", "State", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_AMDGPU", ")", ";", "}", "</s>" ]

[ "AnalyzeFormalArguments", "-", "Analyze", "an", "array", "of", "argument", "values", ",", "incorporating", "info", "about", "the", "formals", "into", "this", "state", "." ]

[ "R600", "ISD::InputArg" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "getNegatedExpression", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "bool", "LegalOperations", ",", "bool", "ForCodeSize", ",", "unsigned", "Depth", ")", "const", "{", "if", "(", "SDValue", "Arg", "=", "isFNEG", "(", "DAG", ",", "Op", ".", "getNode", "(", ")", ",", "Depth", ")", ")", "return", "DAG", ".", "getBitcast", "(", "Op", ".", "getValueType", "(", ")", ",", "Arg", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "EVT", "SVT", "=", "VT", ".", "getScalarType", "(", ")", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "ISD", "::", "FMA", ":", "case", "X86ISD", "::", "FMSUB", ":", "case", "X86ISD", "::", "FNMADD", ":", "case", "X86ISD", "::", "FNMSUB", ":", "case", "X86ISD", "::", "FMADD_RND", ":", "case", "X86ISD", "::", "FMSUB_RND", ":", "case", "X86ISD", "::", "FNMADD_RND", ":", "case", "X86ISD", "::", "FNMSUB_RND", ":", "{", "if", "(", "!", "Op", ".", "hasOneUse", "(", ")", "||", "!", "Subtarget", ".", "hasAnyFMA", "(", ")", "||", "!", "isTypeLegal", "(", "VT", ")", "||", "!", "(", "SVT", "==", "MVT", "::", "f32", "||", "SVT", "==", "MVT", "::", "f64", ")", "||", "!", "isOperationLegal", "(", "ISD", "::", "FMA", ",", "VT", ")", ")", "break", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "NewOps", "(", "Op", ".", "getNumOperands", "(", ")", ",", "SDValue", "(", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "!=", "3", ";", "++", "i", ")", "{", "NegatibleCost", "V", "=", "getNegatibleCost", "(", "Op", ".", "getOperand", "(", "i", ")", ",", "DAG", ",", "LegalOperations", ",", "ForCodeSize", ",", "Depth", "+", "1", ")", ";", "if", "(", "V", "==", "NegatibleCost", "::", "Cheaper", ")", "NewOps", "[", "i", "]", "=", "getNegatedExpression", "(", "Op", ".", "getOperand", "(", "i", ")", ",", "DAG", ",", "LegalOperations", ",", "ForCodeSize", ",", "Depth", "+", "1", ")", ";", "}", "bool", "NegA", "=", "!", "!", "NewOps", "[", "0", "]", ";", "bool", "NegB", "=", "!", "!", "NewOps", "[", "1", "]", ";", "bool", "NegC", "=", "!", "!", "NewOps", "[", "2", "]", ";", "unsigned", "NewOpc", "=", "negateFMAOpcode", "(", "Opc", ",", "NegA", "!=", "NegB", ",", "NegC", ",", "true", ")", ";", "for", "(", "int", "i", "=", "0", ",", "e", "=", "Op", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "if", "(", "!", "NewOps", "[", "i", "]", ")", "NewOps", "[", "i", "]", "=", "Op", ".", "getOperand", "(", "i", ")", ";", "return", "DAG", ".", "getNode", "(", "NewOpc", ",", "SDLoc", "(", "Op", ")", ",", "VT", ",", "NewOps", ")", ";", "}", "case", "X86ISD", "::", "FRCP", ":", "return", "DAG", ".", "getNode", "(", "Opc", ",", "SDLoc", "(", "Op", ")", ",", "VT", ",", "getNegatedExpression", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "DAG", ",", "LegalOperations", ",", "ForCodeSize", ",", "Depth", "+", "1", ")", ")", ";", "}", "return", "TargetLowering", "::", "getNegatedExpression", "(", "Op", ",", "DAG", ",", "LegalOperations", ",", "ForCodeSize", ",", "Depth", ")", ";", "}", "</s>" ]

[ "Return", "the", "newly", "negated", "expression", "if", "the", "cost", "is", "not", "expensive", "and", "set", "the", "cost", "in", "Cost", "to", "indicate", "that", "if", "it", "is", "cheaper", "or", "neutral", "to", "do", "the", "negation", "." ]

[ "X86", "X86", "ISD::FMA", "X86ISD::FMSUB", "X86ISD::FNMADD", "X86ISD::FNMSUB", "X86ISD::FMADD_RND", "X86ISD::FMSUB_RND", "X86ISD::FNMADD_RND", "X86ISD::FNMSUB_RND", "MVT::f32", "MVT::f64", "ISD::FMA", "4", "0", "3", "1", "1", "0", "1", "2", "0", "X86ISD::FRCP", "0", "1" ]

[]

[ "<s>", "bool", "HexagonFrameLowering", "::", "hasTailCall", "(", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "return", "RetOpcode", "==", "Hexagon", "::", "TCRETURNtg", "||", "RetOpcode", "==", "Hexagon", "::", "TCRETURNtext", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "function", "contains", "a", "tail", "call", "." ]

[ "Hexagon", "Hexagon", "Hexagon::TCRETURNtg", "Hexagon::TCRETURNtext" ]

[]

[ "<s>", "void", "SystemZTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "return", "LowerOperationWrapper", "(", "N", ",", "Results", ",", "DAG", ")", ";", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "void", "ConvergingVLIWScheduler", "::", "releaseTopNode", "(", "SUnit", "*", "SU", ")", "{", "if", "(", "SU", "->", "isScheduled", ")", "return", ";", "for", "(", "const", "SDep", "&", "PI", ":", "SU", "->", "Preds", ")", "{", "unsigned", "PredReadyCycle", "=", "PI", ".", "getSUnit", "(", ")", "->", "TopReadyCycle", ";", "unsigned", "MinLatency", "=", "PI", ".", "getLatency", "(", ")", ";", "Top", ".", "MaxMinLatency", "=", "std", "::", "max", "(", "MinLatency", ",", "Top", ".", "MaxMinLatency", ")", ";", "if", "(", "SU", "->", "TopReadyCycle", "<", "PredReadyCycle", "+", "MinLatency", ")", "SU", "->", "TopReadyCycle", "=", "PredReadyCycle", "+", "MinLatency", ";", "}", "Top", ".", "releaseNode", "(", "SU", ",", "SU", "->", "TopReadyCycle", ")", ";", "}", "</s>" ]

[ "SU", "has", "had", "all", "predecessor", "dependencies", "resolved", "." ]

[ "Hexagon" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "SplitVectorLoad", "(", "const", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "2", ")", "return", "ScalarizeVectorLoad", "(", "Op", ",", "DAG", ")", ";", "LoadSDNode", "*", "Load", "=", "cast", "<", "LoadSDNode", ">", "(", "Op", ")", ";", "SDValue", "BasePtr", "=", "Load", "->", "getBasePtr", "(", ")", ";", "EVT", "PtrVT", "=", "BasePtr", ".", "getValueType", "(", ")", ";", "EVT", "MemVT", "=", "Load", "->", "getMemoryVT", "(", ")", ";", "SDLoc", "SL", "(", "Op", ")", ";", "const", "MachinePointerInfo", "&", "SrcValue", "=", "Load", "->", "getMemOperand", "(", ")", "->", "getPointerInfo", "(", ")", ";", "EVT", "LoVT", ",", "HiVT", ";", "EVT", "LoMemVT", ",", "HiMemVT", ";", "SDValue", "Lo", ",", "Hi", ";", "std", "::", "tie", "(", "LoVT", ",", "HiVT", ")", "=", "DAG", ".", "GetSplitDestVTs", "(", "VT", ")", ";", "std", "::", "tie", "(", "LoMemVT", ",", "HiMemVT", ")", "=", "DAG", ".", "GetSplitDestVTs", "(", "MemVT", ")", ";", "std", "::", "tie", "(", "Lo", ",", "Hi", ")", "=", "DAG", ".", "SplitVector", "(", "Op", ",", "SL", ",", "LoVT", ",", "HiVT", ")", ";", "unsigned", "Size", "=", "LoMemVT", ".", "getStoreSize", "(", ")", ";", "unsigned", "BaseAlign", "=", "Load", "->", "getAlignment", "(", ")", ";", "unsigned", "HiAlign", "=", "MinAlign", "(", "BaseAlign", ",", "Size", ")", ";", "SDValue", "LoLoad", "=", "DAG", ".", "getExtLoad", "(", "Load", "->", "getExtensionType", "(", ")", ",", "SL", ",", "LoVT", ",", "Load", "->", "getChain", "(", ")", ",", "BasePtr", ",", "SrcValue", ",", "LoMemVT", ",", "Load", "->", "isVolatile", "(", ")", ",", "Load", "->", "isNonTemporal", "(", ")", ",", "Load", "->", "isInvariant", "(", ")", ",", "BaseAlign", ")", ";", "SDValue", "HiPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "SL", ",", "PtrVT", ",", "BasePtr", ",", "DAG", ".", "getConstant", "(", "Size", ",", "SL", ",", "PtrVT", ")", ")", ";", "SDValue", "HiLoad", "=", "DAG", ".", "getExtLoad", "(", "Load", "->", "getExtensionType", "(", ")", ",", "SL", ",", "HiVT", ",", "Load", "->", "getChain", "(", ")", ",", "HiPtr", ",", "SrcValue", ".", "getWithOffset", "(", "LoMemVT", ".", "getStoreSize", "(", ")", ")", ",", "HiMemVT", ",", "Load", "->", "isVolatile", "(", ")", ",", "Load", "->", "isNonTemporal", "(", ")", ",", "Load", "->", "isInvariant", "(", ")", ",", "HiAlign", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "DAG", ".", "getNode", "(", "ISD", "::", "CONCAT_VECTORS", ",", "SL", ",", "VT", ",", "LoLoad", ",", "HiLoad", ")", ",", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "SL", ",", "MVT", "::", "Other", ",", "LoLoad", ".", "getValue", "(", "1", ")", ",", "HiLoad", ".", "getValue", "(", "1", ")", ")", "}", ";", "return", "DAG", ".", "getMergeValues", "(", "Ops", ",", "SL", ")", ";", "}", "</s>" ]

[ "Split", "a", "vector", "load", "into", "2", "loads", "of", "half", "the", "vector", "." ]

[ "AMDGPU", "AMDGPU", "2", "ISD::ADD", "ISD::CONCAT_VECTORS", "ISD::TokenFactor", "MVT::Other", "1", "1" ]

[]

[ "<s>", "static", "tree", "rs6000_builtin_reciprocal", "(", "tree", "fndecl", ")", "{", "switch", "(", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ")", "{", "case", "VSX_BUILTIN_XVSQRTDP", ":", "if", "(", "!", "RS6000_RECIP_AUTO_RSQRTE_P", "(", "V2DFmode", ")", ")", "return", "NULL_TREE", ";", "return", "rs6000_builtin_decls", "[", "VSX_BUILTIN_RSQRT_2DF", "]", ";", "case", "VSX_BUILTIN_XVSQRTSP", ":", "if", "(", "!", "RS6000_RECIP_AUTO_RSQRTE_P", "(", "V4SFmode", ")", ")", "return", "NULL_TREE", ";", "return", "rs6000_builtin_decls", "[", "VSX_BUILTIN_RSQRT_4SF", "]", ";", "default", ":", "return", "NULL_TREE", ";", "}", "}", "</s>" ]

[ "Returns", "a", "code", "for", "a", "target-specific", "builtin", "that", "implements", "reciprocal", "of", "the", "function", ",", "or", "NULL_TREE", "if", "not", "available", "." ]

[ "rs6000" ]

[]

[ "<s>", "const", "char", "*", "ashrqi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "int", "k", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "case", "1", ":", "*", "len", "=", "1", ";", "return", "\"asr %0\"", ";", "case", "2", ":", "*", "len", "=", "2", ";", "return", "(", "\"asr %0\"", "CR_TAB", "\"asr %0\"", ")", ";", "case", "3", ":", "*", "len", "=", "3", ";", "return", "(", "\"asr %0\"", "CR_TAB", "\"asr %0\"", "CR_TAB", "\"asr %0\"", ")", ";", "case", "4", ":", "*", "len", "=", "4", ";", "return", "(", "\"asr %0\"", "CR_TAB", "\"asr %0\"", "CR_TAB", "\"asr %0\"", "CR_TAB", "\"asr %0\"", ")", ";", "case", "5", ":", "*", "len", "=", "5", ";", "return", "(", "\"asr %0\"", "CR_TAB", "\"asr %0\"", "CR_TAB", "\"asr %0\"", "CR_TAB", "\"asr %0\"", "CR_TAB", "\"asr %0\"", ")", ";", "case", "6", ":", "*", "len", "=", "4", ";", "return", "(", "\"bst %0,6\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"sbc %0,%0\"", "CR_TAB", "\"bld %0,0\"", ")", ";", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "8", ")", "break", ";", "case", "7", ":", "*", "len", "=", "2", ";", "return", "(", "\"lsl %0\"", "CR_TAB", "\"sbc %0,%0\"", ")", ";", "}", "}", "else", "if", "(", "CONSTANT_P", "(", "operands", "[", "2", "]", ")", ")", "fatal_insn", "(", "\"internal compiler error. Incorrect shift:\"", ",", "insn", ")", ";", "out_shift_with_cnt", "(", "\"asr %0\"", ",", "insn", ",", "operands", ",", "len", ",", "1", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "8bit", "arithmetic", "shift", "right", "(", "(", "signed", "char", ")", "x", ">", ">", "i", ")" ]

[ "avr", "2", "2", "1", "1", "\"asr %0\"", "2", "2", "\"asr %0\"", "\"asr %0\"", "3", "3", "\"asr %0\"", "\"asr %0\"", "\"asr %0\"", "4", "4", "\"asr %0\"", "\"asr %0\"", "\"asr %0\"", "\"asr %0\"", "5", "5", "\"asr %0\"", "\"asr %0\"", "\"asr %0\"", "\"asr %0\"", "\"asr %0\"", "6", "4", "\"bst %0,6\"", "\"lsl %0\"", "\"sbc %0,%0\"", "\"bld %0,0\"", "2", "8", "7", "2", "\"lsl %0\"", "\"sbc %0,%0\"", "2", "\"internal compiler error. Incorrect shift:\"", "\"asr %0\"", "1", "\"\"" ]

[]

[ "<s>", "static", "void", "arm_unwind_emit", "(", "FILE", "*", "out_file", ",", "rtx_insn", "*", "insn", ")", "{", "rtx", "note", ",", "pat", ";", "bool", "handled_one", "=", "false", ";", "if", "(", "arm_except_unwind_info", "(", "&", "global_options", ")", "!=", "UI_TARGET", ")", "return", ";", "if", "(", "!", "(", "flag_unwind_tables", "||", "crtl", "->", "uses_eh_lsda", ")", "&&", "(", "TREE_NOTHROW", "(", "current_function_decl", ")", "||", "crtl", "->", "all_throwers_are_sibcalls", ")", ")", "return", ";", "if", "(", "NOTE_P", "(", "insn", ")", "||", "!", "RTX_FRAME_RELATED_P", "(", "insn", ")", ")", "return", ";", "for", "(", "note", "=", "REG_NOTES", "(", "insn", ")", ";", "note", ";", "note", "=", "XEXP", "(", "note", ",", "1", ")", ")", "{", "switch", "(", "REG_NOTE_KIND", "(", "note", ")", ")", "{", "case", "REG_FRAME_RELATED_EXPR", ":", "pat", "=", "XEXP", "(", "note", ",", "0", ")", ";", "goto", "found", ";", "case", "REG_CFA_REGISTER", ":", "pat", "=", "XEXP", "(", "note", ",", "0", ")", ";", "if", "(", "pat", "==", "NULL", ")", "{", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "}", "{", "rtx", "dest", ",", "src", ";", "unsigned", "reg", ";", "src", "=", "SET_SRC", "(", "pat", ")", ";", "dest", "=", "SET_DEST", "(", "pat", ")", ";", "gcc_assert", "(", "src", "==", "stack_pointer_rtx", ")", ";", "reg", "=", "REGNO", "(", "dest", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\t.unwind_raw 0, 0x%x @ vsp = r%d\\n\"", ",", "reg", "+", "0x90", ",", "reg", ")", ";", "}", "handled_one", "=", "true", ";", "break", ";", "case", "REG_CFA_DEF_CFA", ":", "case", "REG_CFA_ADJUST_CFA", ":", "case", "REG_CFA_RESTORE", ":", "return", ";", "case", "REG_CFA_EXPRESSION", ":", "case", "REG_CFA_OFFSET", ":", "gcc_unreachable", "(", ")", ";", "default", ":", "break", ";", "}", "}", "if", "(", "handled_one", ")", "return", ";", "pat", "=", "PATTERN", "(", "insn", ")", ";", "found", ":", "switch", "(", "GET_CODE", "(", "pat", ")", ")", "{", "case", "SET", ":", "arm_unwind_emit_set", "(", "out_file", ",", "pat", ")", ";", "break", ";", "case", "SEQUENCE", ":", "arm_unwind_emit_sequence", "(", "out_file", ",", "pat", ")", ";", "break", ";", "default", ":", "abort", "(", ")", ";", "}", "}", "</s>" ]

[ "Emit", "unwind", "directives", "for", "the", "given", "insn", "." ]

[ "arm", "1", "0", "0", "0", "0", "\"\\t.unwind_raw 0, 0x%x @ vsp = r%d\\n\"", "0x90" ]

[]

[ "<s>", "static", "bool", "nds32_rtx_costs", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "int", "outer_code", ",", "int", "opno", ",", "int", "*", "total", ",", "bool", "speed", ")", "{", "return", "nds32_rtx_costs_impl", "(", "x", ",", "mode", ",", "outer_code", ",", "opno", ",", "total", ",", "speed", ")", ";", "}", "</s>" ]

[ "This", "target", "hook", "describes", "the", "relative", "costs", "of", "RTL", "expressions", ".", "Return", "'true", "'", "when", "all", "subexpressions", "of", "x", "have", "been", "processed", ".", "Return", "'false", "'", "to", "sum", "the", "costs", "of", "sub-rtx", ",", "plus", "cost", "of", "this", "operation", ".", "Refer", "to", "gcc/rtlanal.cc", "for", "more", "information", "." ]

[ "nds32" ]

[]

[ "<s>", "static", "const", "char", "*", "avr_out_movhi_r_mr_reg_no_disp_tiny", "(", "rtx", "op", "[", "]", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "base", "=", "XEXP", "(", "src", ",", "0", ")", ";", "int", "reg_dest", "=", "true_regnum", "(", "dest", ")", ";", "int", "reg_base", "=", "true_regnum", "(", "base", ")", ";", "if", "(", "reg_dest", "==", "reg_base", ")", "return", "avr_asm_len", "(", "\"ld __tmp_reg__,%1+\"", "CR_TAB", "\"ld %B0,%1\"", "CR_TAB", "\"mov %A0,__tmp_reg__\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "return", "avr_asm_len", "(", "\"ld %A0,%1\"", "CR_TAB", "TINY_ADIW", "(", "%", "E1", ",", "%", "F1", ",", "1", ")", "CR_TAB", "\"ld %B0,%1\"", "CR_TAB", "TINY_SBIW", "(", "%", "E1", ",", "%", "F1", ",", "1", ")", ",", "op", ",", "plen", ",", "-", "6", ")", ";", "}", "</s>" ]

[ "Same", "as", "movhi_r_mr", ",", "but", "TINY", "does", "not", "have", "ADIW", ",", "SBIW", "and", "LDD" ]

[ "avr", "0", "1", "0", "\"ld __tmp_reg__,%1+\"", "\"ld %B0,%1\"", "\"mov %A0,__tmp_reg__\"", "3", "\"ld %A0,%1\"", "1", "\"ld %B0,%1\"", "1", "6" ]

[]

[ "<s>", "void", "AlphaFrameInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "assert", "(", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "Alpha", "::", "RETDAG", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "Alpha", "::", "RETDAGp", ")", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "long", "NumBytes", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "FP", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "BISr", ")", ",", "Alpha", "::", "R30", ")", ".", "addReg", "(", "Alpha", "::", "R15", ")", ".", "addReg", "(", "Alpha", "::", "R15", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDQ", ")", ",", "Alpha", "::", "R15", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "Alpha", "::", "R15", ")", ";", "}", "if", "(", "NumBytes", "!=", "0", ")", "{", "if", "(", "NumBytes", "<=", "Alpha", "::", "IMM_HIGH", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDA", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "NumBytes", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "else", "if", "(", "getUpper16", "(", "NumBytes", ")", "<=", "Alpha", "::", "IMM_HIGH", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDAH", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "getUpper16", "(", "NumBytes", ")", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDA", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "getLower16", "(", "NumBytes", ")", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "else", "{", "report_fatal_error", "(", "\"Too big a stack frame at \"", "+", "Twine", "(", "NumBytes", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "Alpha", "Alpha", "Alpha::RETDAG", "Alpha::RETDAGp", "\"Can only insert epilog into returning blocks\"", "Alpha::BISr", "Alpha::R30", "Alpha::R15", "Alpha::R15", "Alpha::LDQ", "Alpha::R15", "0", "Alpha::R15", "0", "Alpha::IMM_HIGH", "Alpha::LDA", "Alpha::R30", "Alpha::R30", "Alpha::IMM_HIGH", "Alpha::LDAH", "Alpha::R30", "Alpha::R30", "Alpha::LDA", "Alpha::R30", "Alpha::R30", "\"Too big a stack frame at \"" ]

[]

[ "<s>", "void", "aarch64_split_compare_and_swap", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "rval", ",", "mem", ",", "oldval", ",", "newval", ",", "scratch", ";", "machine_mode", "mode", ";", "bool", "is_weak", ";", "rtx_code_label", "*", "label1", ",", "*", "label2", ";", "rtx", "x", ",", "cond", ";", "enum", "memmodel", "model", ";", "rtx", "model_rtx", ";", "rval", "=", "operands", "[", "0", "]", ";", "mem", "=", "operands", "[", "1", "]", ";", "oldval", "=", "operands", "[", "2", "]", ";", "newval", "=", "operands", "[", "3", "]", ";", "is_weak", "=", "(", "operands", "[", "4", "]", "!=", "const0_rtx", ")", ";", "model_rtx", "=", "operands", "[", "5", "]", ";", "scratch", "=", "operands", "[", "7", "]", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "model", "=", "memmodel_from_int", "(", "INTVAL", "(", "model_rtx", ")", ")", ";", "label1", "=", "NULL", ";", "if", "(", "!", "is_weak", ")", "{", "label1", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label1", ")", ";", "}", "label2", "=", "gen_label_rtx", "(", ")", ";", "if", "(", "is_mm_sync", "(", "model", ")", ")", "aarch64_emit_load_exclusive", "(", "mode", ",", "rval", ",", "mem", ",", "GEN_INT", "(", "MEMMODEL_RELAXED", ")", ")", ";", "else", "aarch64_emit_load_exclusive", "(", "mode", ",", "rval", ",", "mem", ",", "model_rtx", ")", ";", "cond", "=", "aarch64_gen_compare_reg", "(", "NE", ",", "rval", ",", "oldval", ")", ";", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label2", ")", ",", "pc_rtx", ")", ";", "aarch64_emit_unlikely_jump", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "aarch64_emit_store_exclusive", "(", "mode", ",", "scratch", ",", "mem", ",", "newval", ",", "model_rtx", ")", ";", "if", "(", "!", "is_weak", ")", "{", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "scratch", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label1", ")", ",", "pc_rtx", ")", ";", "aarch64_emit_unlikely_jump", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "}", "else", "{", "cond", "=", "gen_rtx_REG", "(", "CCmode", ",", "CC_REGNUM", ")", ";", "x", "=", "gen_rtx_COMPARE", "(", "CCmode", ",", "scratch", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cond", ",", "x", ")", ")", ";", "}", "emit_label", "(", "label2", ")", ";", "if", "(", "is_mm_sync", "(", "model", ")", ")", "aarch64_emit_post_barrier", "(", "model", ")", ";", "}", "</s>" ]

[ "Split", "a", "compare", "and", "swap", "pattern", "." ]

[ "aarch64", "0", "1", "2", "3", "4", "5", "7" ]

[]

[ "<s>", "bool", "WebAssemblySubtarget", "::", "useAA", "(", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Enable", "use", "of", "alias", "analysis", "during", "code", "generation", "(", "during", "MI", "scheduling", ",", "DAGCombine", ",", "etc", ".", ")", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "static", "void", "aarch64_emit_atomic_load_op", "(", "enum", "aarch64_atomic_load_op_code", "code", ",", "machine_mode", "mode", ",", "rtx", "dst", ",", "rtx", "src", ",", "rtx", "mem", ",", "rtx", "model", ")", "{", "typedef", "rtx", "(", "*", "aarch64_atomic_load_op_fn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "const", "aarch64_atomic_load_op_fn", "plus", "[", "]", "=", "{", "gen_aarch64_atomic_loadaddqi", ",", "gen_aarch64_atomic_loadaddhi", ",", "gen_aarch64_atomic_loadaddsi", ",", "gen_aarch64_atomic_loadadddi", "}", ";", "const", "aarch64_atomic_load_op_fn", "eor", "[", "]", "=", "{", "gen_aarch64_atomic_loadeorqi", ",", "gen_aarch64_atomic_loadeorhi", ",", "gen_aarch64_atomic_loadeorsi", ",", "gen_aarch64_atomic_loadeordi", "}", ";", "const", "aarch64_atomic_load_op_fn", "ior", "[", "]", "=", "{", "gen_aarch64_atomic_loadsetqi", ",", "gen_aarch64_atomic_loadsethi", ",", "gen_aarch64_atomic_loadsetsi", ",", "gen_aarch64_atomic_loadsetdi", "}", ";", "const", "aarch64_atomic_load_op_fn", "bic", "[", "]", "=", "{", "gen_aarch64_atomic_loadclrqi", ",", "gen_aarch64_atomic_loadclrhi", ",", "gen_aarch64_atomic_loadclrsi", ",", "gen_aarch64_atomic_loadclrdi", "}", ";", "aarch64_atomic_load_op_fn", "gen", ";", "int", "idx", "=", "0", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "idx", "=", "0", ";", "break", ";", "case", "HImode", ":", "idx", "=", "1", ";", "break", ";", "case", "SImode", ":", "idx", "=", "2", ";", "break", ";", "case", "DImode", ":", "idx", "=", "3", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "AARCH64_LDOP_PLUS", ":", "gen", "=", "plus", "[", "idx", "]", ";", "break", ";", "case", "AARCH64_LDOP_XOR", ":", "gen", "=", "eor", "[", "idx", "]", ";", "break", ";", "case", "AARCH64_LDOP_OR", ":", "gen", "=", "ior", "[", "idx", "]", ";", "break", ";", "case", "AARCH64_LDOP_BIC", ":", "gen", "=", "bic", "[", "idx", "]", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen", "(", "dst", ",", "mem", ",", "src", ",", "model", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "atomic", "load-operate", "." ]

[ "aarch64", "0", "0", "1", "2", "3" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "XCoreInstrInfo", "::", "loadImmediate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "Reg", ",", "uint64_t", "Value", ")", "const", "{", "DebugLoc", "dl", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "MI", "->", "isDebugInstr", "(", ")", ")", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "isImmMskBitp", "(", "Value", ")", ")", "{", "int", "N", "=", "Log2_32", "(", "Value", ")", "+", "1", ";", "return", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "XCore", "::", "MKMSK_rus", ")", ",", "Reg", ")", ".", "addImm", "(", "N", ")", ".", "getInstr", "(", ")", ";", "}", "if", "(", "isImmU16", "(", "Value", ")", ")", "{", "int", "Opcode", "=", "isImmU6", "(", "Value", ")", "?", "XCore", "::", "LDC_ru6", ":", "XCore", "::", "LDC_lru6", ";", "return", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "Opcode", ")", ",", "Reg", ")", ".", "addImm", "(", "Value", ")", ".", "getInstr", "(", ")", ";", "}", "MachineConstantPool", "*", "ConstantPool", "=", "MBB", ".", "getParent", "(", ")", "->", "getConstantPool", "(", ")", ";", "const", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", ".", "getContext", "(", ")", ")", ",", "Value", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "4", ")", ";", "return", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "XCore", "::", "LDWCP_lru6", ")", ",", "Reg", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "getInstr", "(", ")", ";", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "load", "an", "immediate", "." ]

[ "XCore", "XCore", "1", "XCore::MKMSK_rus", "XCore::LDC_ru6", "XCore::LDC_lru6", "4", "XCore::LDWCP_lru6" ]

[]

[ "<s>", "void", "MipsTargetLowering", "::", "getOpndList", "(", "SmallVectorImpl", "<", "SDValue", ">", "&", "Ops", ",", "std", "::", "deque", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">>", "&", "RegsToPass", ",", "bool", "IsPICCall", ",", "bool", "GlobalOrExternal", ",", "bool", "InternalLinkage", ",", "bool", "IsCallReloc", ",", "CallLoweringInfo", "&", "CLI", ",", "SDValue", "Callee", ",", "SDValue", "Chain", ")", "const", "{", "if", "(", "IsPICCall", "&&", "!", "InternalLinkage", "&&", "IsCallReloc", ")", "{", "unsigned", "GPReg", "=", "ABI", ".", "IsN64", "(", ")", "?", "Mips", "::", "GP_64", ":", "Mips", "::", "GP", ";", "EVT", "Ty", "=", "ABI", ".", "IsN64", "(", ")", "?", "MVT", "::", "i64", ":", "MVT", "::", "i32", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "GPReg", ",", "getGlobalReg", "(", "CLI", ".", "DAG", ",", "Ty", ")", ")", ")", ";", "}", "SDValue", "InFlag", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Chain", "=", "CLI", ".", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "CLI", ".", "DL", ",", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "Ops", ".", "push_back", "(", "CLI", ".", "DAG", ".", "getRegister", "(", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ".", "getValueType", "(", ")", ")", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "Mask", "=", "TRI", "->", "getCallPreservedMask", "(", "CLI", ".", "DAG", ".", "getMachineFunction", "(", ")", ",", "CLI", ".", "CallConv", ")", ";", "assert", "(", "Mask", "&&", "\"Missing call preserved mask for calling convention\"", ")", ";", "if", "(", "Subtarget", ".", "inMips16HardFloat", "(", ")", ")", "{", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "CLI", ".", "Callee", ")", ")", "{", "StringRef", "Sym", "=", "G", "->", "getGlobal", "(", ")", "->", "getName", "(", ")", ";", "Function", "*", "F", "=", "G", "->", "getGlobal", "(", ")", "->", "getParent", "(", ")", "->", "getFunction", "(", "Sym", ")", ";", "if", "(", "F", "&&", "F", "->", "hasFnAttribute", "(", "\"__Mips16RetHelper\"", ")", ")", "{", "Mask", "=", "MipsRegisterInfo", "::", "getMips16RetHelperMask", "(", ")", ";", "}", "}", "}", "Ops", ".", "push_back", "(", "CLI", ".", "DAG", ".", "getRegisterMask", "(", "Mask", ")", ")", ";", "if", "(", "InFlag", ".", "getNode", "(", ")", ")", "Ops", ".", "push_back", "(", "InFlag", ")", ";", "}", "</s>" ]

[ "This", "function", "fills", "Ops", ",", "which", "is", "the", "list", "of", "operands", "that", "will", "later", "be", "used", "when", "a", "function", "call", "node", "is", "created", "." ]

[ "Mips", "Mips", "Mips::GP_64", "Mips::GP", "MVT::i64", "MVT::i32", "0", "1", "0", "\"Missing call preserved mask for calling convention\"", "Mips", "\"__Mips16RetHelper\"", "Mips", "Mips" ]

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "getNumWaitStates", "(", "const", "MachineInstr", "&", "MI", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "1", ";", "case", "AMDGPU", "::", "S_NOP", ":", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", "+", "1", ";", "}", "}", "</s>" ]

[ "Return", "the", "number", "of", "wait", "states", "that", "result", "from", "executing", "this", "instruction", "." ]

[ "AMDGPU", "SI", "1", "AMDGPU::S_NOP", "0", "1" ]

[]

[ "<s>", "void", "NVPTXInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ")", "{", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "bool", "X86LoadValueInjectionLoadHardeningPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** \"", "<<", "getPassName", "(", ")", "<<", "\" : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\" *****\\n\"", ")", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "STI", "->", "useLVILoadHardening", "(", ")", ")", "return", "false", ";", "if", "(", "!", "STI", "->", "is64Bit", "(", ")", ")", "report_fatal_error", "(", "\"LVI load hardening is only supported on 64-bit\"", ",", "false", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "F", ".", "hasOptNone", "(", ")", "&&", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "++", "NumFunctionsConsidered", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Building gadget graph...\\n\"", ")", ";", "const", "auto", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "const", "auto", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "auto", "&", "MDF", "=", "getAnalysis", "<", "MachineDominanceFrontier", ">", "(", ")", ";", "std", "::", "unique_ptr", "<", "MachineGadgetGraph", ">", "Graph", "=", "getGadgetGraph", "(", "MF", ",", "MLI", ",", "MDT", ",", "MDF", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Building gadget graph... Done\\n\"", ")", ";", "if", "(", "Graph", "==", "nullptr", ")", "return", "false", ";", "if", "(", "EmitDotVerify", ")", "{", "writeGadgetGraph", "(", "outs", "(", ")", ",", "MF", ",", "Graph", ".", "get", "(", ")", ")", ";", "return", "false", ";", "}", "if", "(", "EmitDot", "||", "EmitDotOnly", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Emitting gadget graph...\\n\"", ")", ";", "std", "::", "error_code", "FileError", ";", "std", "::", "string", "FileName", "=", "\"lvi.\"", ";", "FileName", "+=", "MF", ".", "getName", "(", ")", ";", "FileName", "+=", "\".dot\"", ";", "raw_fd_ostream", "FileOut", "(", "FileName", ",", "FileError", ")", ";", "if", "(", "FileError", ")", "errs", "(", ")", "<<", "FileError", ".", "message", "(", ")", ";", "writeGadgetGraph", "(", "FileOut", ",", "MF", ",", "Graph", ".", "get", "(", ")", ")", ";", "FileOut", ".", "close", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Emitting gadget graph... Done\\n\"", ")", ";", "if", "(", "EmitDotOnly", ")", "return", "false", ";", "}", "int", "FencesInserted", ";", "if", "(", "!", "OptimizePluginPath", ".", "empty", "(", ")", ")", "{", "if", "(", "!", "OptimizeDL", ".", "isValid", "(", ")", ")", "{", "std", "::", "string", "ErrorMsg", ";", "OptimizeDL", "=", "llvm", "::", "sys", "::", "DynamicLibrary", "::", "getPermanentLibrary", "(", "OptimizePluginPath", ".", "c_str", "(", ")", ",", "&", "ErrorMsg", ")", ";", "if", "(", "!", "ErrorMsg", ".", "empty", "(", ")", ")", "report_fatal_error", "(", "Twine", "(", "\"Failed to load opt plugin: \\\"\"", ")", "+", "ErrorMsg", "+", "\"\\\"\"", ")", ";", "OptimizeCut", "=", "(", "OptimizeCutT", ")", "OptimizeDL", ".", "getAddressOfSymbol", "(", "\"optimize_cut\"", ")", ";", "if", "(", "!", "OptimizeCut", ")", "report_fatal_error", "(", "\"Invalid optimization plugin\"", ")", ";", "}", "FencesInserted", "=", "hardenLoadsWithPlugin", "(", "MF", ",", "std", "::", "move", "(", "Graph", ")", ")", ";", "}", "else", "{", "FencesInserted", "=", "hardenLoadsWithHeuristic", "(", "MF", ",", "std", "::", "move", "(", "Graph", ")", ")", ";", "}", "if", "(", "FencesInserted", ">", "0", ")", "++", "NumFunctionsMitigated", ";", "NumFences", "+=", "FencesInserted", ";", "return", "(", "FencesInserted", ">", "0", ")", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "X86", "X86", "\"***** \"", "\" : \"", "\" *****\\n\"", "X86", "\"LVI load hardening is only supported on 64-bit\"", "\"Building gadget graph...\\n\"", "\"Building gadget graph... Done\\n\"", "\"Emitting gadget graph...\\n\"", "\"lvi.\"", "\".dot\"", "\"Emitting gadget graph... Done\\n\"", "\"Failed to load opt plugin: \\\"\"", "\"\\\"\"", "\"optimize_cut\"", "\"Invalid optimization plugin\"", "0", "0" ]

[]

[ "<s>", "const", "TargetMachine", "&", "getTarget", "(", ")", "const", "{", "return", "TM", ";", "}", "</s>" ]

[ "getTarget", "-", "Return", "the", "target", "machine", "this", "machine", "code", "is", "compiled", "with" ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "canInsertSelect", "(", "const", "MachineBasicBlock", "&", "MBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "unsigned", "DstReg", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ",", "int", "&", "CondCycles", ",", "int", "&", "TrueCycles", ",", "int", "&", "FalseCycles", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "hasCMov", "(", ")", ")", "return", "false", ";", "if", "(", "Cond", ".", "size", "(", ")", "!=", "1", ")", "return", "false", ";", "if", "(", "(", "X86", "::", "CondCode", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ">", "X86", "::", "LAST_VALID_COND", ")", "return", "false", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getCommonSubClass", "(", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ",", "MRI", ".", "getRegClass", "(", "FalseReg", ")", ")", ";", "if", "(", "!", "RC", ")", "return", "false", ";", "if", "(", "X86", "::", "GR16RegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "X86", "::", "GR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "X86", "::", "GR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "CondCycles", "=", "2", ";", "TrueCycles", "=", "2", ";", "FalseCycles", "=", "2", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "possible", "to", "insert", "a", "select", "instruction", "that", "chooses", "between", "TrueReg", "and", "FalseReg", "based", "on", "the", "condition", "code", "in", "Cond", "." ]

[ "X86", "X86", "1", "X86::CondCode", "0", "X86::LAST_VALID_COND", "X86::GR16RegClass", "X86::GR32RegClass", "X86::GR64RegClass", "2", "2", "2" ]

[]

[ "<s>", "static", "rtx", "nvptx_get_drap_rtx", "(", "void", ")", "{", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Return", "Dynamic", "ReAlignment", "Pointer", "RTX", ".", "For", "PTX", "there", "is", "n't", "any", "." ]

[ "nvptx" ]

[]

[ "<s>", "bool", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "override", "{", "if", "(", "Count", "==", "0", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "TriCore", "0" ]

[]

[ "<s>", "bool", "SparcAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "IDVal", "==", "\".byte\"", ")", "return", "parseDirectiveWord", "(", "1", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "IDVal", "==", "\".half\"", ")", "return", "parseDirectiveWord", "(", "2", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "IDVal", "==", "\".word\"", ")", "return", "parseDirectiveWord", "(", "4", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "IDVal", "==", "\".nword\"", ")", "return", "parseDirectiveWord", "(", "is64Bit", "(", ")", "?", "8", ":", "4", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "is64Bit", "(", ")", "&&", "IDVal", "==", "\".xword\"", ")", "return", "parseDirectiveWord", "(", "8", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "IDVal", "==", "\".register\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "Sparc", "Sparc", "\".byte\"", "1", "\".half\"", "2", "\".word\"", "4", "\".nword\"", "8", "4", "\".xword\"", "8", "\".register\"" ]

[]

[ "<s>", "bool", "nds32_n13_last_two_load_to_e1_p", "(", "rtx_insn", "*", "producer", ",", "rtx_insn", "*", "consumer", ")", "{", "rtx", "last_two_def_reg", "=", "extract_nth_access_reg", "(", "producer", ",", "-", "2", ")", ";", "if", "(", "last_two_def_reg", "==", "NULL_RTX", ")", "return", "false", ";", "return", "n13_consumed_by_e1_dep_p", "(", "consumer", ",", "last_two_def_reg", ")", ";", "}", "</s>" ]

[ "Check", "dependencies", "from", "LMW", "(", "N", ",", "N-1", ")", "to", "E2", "." ]

[ "nds32", "2" ]

[]

[ "<s>", "bool", "XCoreAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ")", "{", "printOperand", "(", "MI", ",", "OpNo", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "XCore", "XCore" ]

[]

[ "<s>", "bool", "MipsOs16", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "bool", "usingMask", "=", "Mips32FunctionMask", ".", "length", "(", ")", ">", "0", ";", "bool", "doneUsingMask", "=", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Run on Module MipsOs16 \\n\"", "<<", "Mips32FunctionMask", "<<", "\"\\n\"", ")", ";", "if", "(", "usingMask", ")", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"using mask \\n\"", "<<", "Mips32FunctionMask", "<<", "\"\\n\"", ")", ";", "unsigned", "int", "functionIndex", "=", "0", ";", "bool", "modified", "=", "false", ";", "for", "(", "auto", "&", "F", ":", "M", ")", "{", "if", "(", "F", ".", "isDeclaration", "(", ")", ")", "continue", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Working on \"", "<<", "F", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "usingMask", ")", "{", "if", "(", "!", "doneUsingMask", ")", "{", "if", "(", "functionIndex", "==", "Mips32FunctionMask", ".", "length", "(", ")", ")", "functionIndex", "=", "0", ";", "switch", "(", "Mips32FunctionMask", "[", "functionIndex", "]", ")", "{", "case", "'1'", ":", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"mask forced mips32: \"", "<<", "F", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "F", ".", "addFnAttr", "(", "\"nomips16\"", ")", ";", "break", ";", "case", "'.'", ":", "doneUsingMask", "=", "true", ";", "break", ";", "default", ":", "break", ";", "}", "functionIndex", "++", ";", "}", "}", "else", "{", "if", "(", "needsFP", "(", "F", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"os16 forced mips32: \"", "<<", "F", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "F", ".", "addFnAttr", "(", "\"nomips16\"", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"os16 forced mips16: \"", "<<", "F", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "F", ".", "addFnAttr", "(", "\"mips16\"", ")", ";", "}", "}", "}", "return", "modified", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "Mips", "Mips", "Mips", "0", "\"Run on Module MipsOs16 \\n\"", "Mips", "\"\\n\"", "\"using mask \\n\"", "Mips", "\"\\n\"", "0", "\"Working on \"", "\"\\n\"", "Mips", "0", "Mips", "\"mask forced mips32: \"", "\"\\n\"", "\"nomips16\"", "\"os16 forced mips32: \"", "\"\\n\"", "\"nomips16\"", "\"os16 forced mips16: \"", "\"\\n\"", "\"mips16\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "const", "TargetRegisterClass", "*", ",", "uint8_t", ">", "ARMTargetLowering", "::", "findRepresentativeClass", "(", "EVT", "VT", ")", "const", "{", "const", "TargetRegisterClass", "*", "RRC", "=", "0", ";", "uint8_t", "Cost", "=", "1", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "return", "TargetLowering", "::", "findRepresentativeClass", "(", "VT", ")", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "case", "MVT", "::", "v8i8", ":", "case", "MVT", "::", "v4i16", ":", "case", "MVT", "::", "v2i32", ":", "case", "MVT", "::", "v1i64", ":", "case", "MVT", "::", "v2f32", ":", "RRC", "=", "ARM", "::", "DPRRegisterClass", ";", "break", ";", "case", "MVT", "::", "v16i8", ":", "case", "MVT", "::", "v8i16", ":", "case", "MVT", "::", "v4i32", ":", "case", "MVT", "::", "v2i64", ":", "case", "MVT", "::", "v4f32", ":", "case", "MVT", "::", "v2f64", ":", "RRC", "=", "ARM", "::", "DPRRegisterClass", ";", "Cost", "=", "2", ";", "break", ";", "case", "MVT", "::", "v4i64", ":", "RRC", "=", "ARM", "::", "DPRRegisterClass", ";", "Cost", "=", "4", ";", "break", ";", "case", "MVT", "::", "v8i64", ":", "RRC", "=", "ARM", "::", "DPRRegisterClass", ";", "Cost", "=", "8", ";", "break", ";", "}", "return", "std", "::", "make_pair", "(", "RRC", ",", "Cost", ")", ";", "}", "</s>" ]

[ "Return", "the", "largest", "legal", "super-reg", "register", "class", "of", "the", "register", "class", "for", "the", "specified", "type", "and", "its", "associated", "``", "cost", "''", "." ]

[ "ARM", "ARM", "0", "1", "MVT::f32", "MVT::f64", "MVT::v8i8", "MVT::v4i16", "MVT::v2i32", "MVT::v1i64", "MVT::v2f32", "ARM::DPRRegisterClass", "MVT::v16i8", "MVT::v8i16", "MVT::v4i32", "MVT::v2i64", "MVT::v4f32", "MVT::v2f64", "ARM::DPRRegisterClass", "2", "MVT::v4i64", "ARM::DPRRegisterClass", "4", "MVT::v8i64", "ARM::DPRRegisterClass", "8" ]

[]

[ "<s>", "static", "tree", "ix86_builtin_decl", "(", "unsigned", "code", ",", "bool", ")", "{", "if", "(", "code", ">=", "IX86_BUILTIN_MAX", ")", "return", "error_mark_node", ";", "return", "ix86_builtins", "[", "code", "]", ";", "}", "</s>" ]

[ "Return", "the", "ix86", "builtin", "for", "CODE", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "getMemOperandsWithOffsetWidth", "(", "const", "MachineInstr", "&", "LdSt", ",", "SmallVectorImpl", "<", "const", "MachineOperand", "*", ">", "&", "BaseOps", ",", "int64_t", "&", "Offset", ",", "bool", "&", "OffsetIsScalable", ",", "unsigned", "&", "Width", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "!", "LdSt", ".", "mayLoadOrStore", "(", ")", ")", "return", "false", ";", "const", "MachineOperand", "*", "BaseOp", ";", "if", "(", "!", "getMemOperandWithOffsetWidth", "(", "LdSt", ",", "BaseOp", ",", "Offset", ",", "OffsetIsScalable", ",", "Width", ",", "TRI", ")", ")", "return", "false", ";", "BaseOps", ".", "push_back", "(", "BaseOp", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Get", "zero", "or", "more", "base", "operands", "and", "the", "byte", "offset", "of", "an", "instruction", "that", "reads/writes", "memory", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "void", "X86TargetLowering", "::", "initializeSplitCSR", "(", "MachineBasicBlock", "*", "Entry", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", ")", "return", ";", "X86MachineFunctionInfo", "*", "AFI", "=", "Entry", "->", "getParent", "(", ")", "->", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "AFI", "->", "setIsSplitCSR", "(", "true", ")", ";", "}", "</s>" ]

[ "Perform", "necessary", "initialization", "to", "handle", "a", "subset", "of", "CSRs", "explicitly", "via", "copies", "." ]

[ "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "bool", "SystemZLDCleanup", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "TII", "=", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "F", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MF", "=", "&", "F", ";", "SystemZMachineFunctionInfo", "*", "MFI", "=", "F", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "MFI", "->", "getNumLocalDynamicTLSAccesses", "(", ")", "<", "2", ")", "{", "return", "false", ";", "}", "MachineDominatorTree", "*", "DT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "return", "VisitNode", "(", "DT", "->", "getRootNode", "(", ")", ",", "0", ")", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "2", "0" ]

[]

[ "<s>", "void", "WebAssemblyFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "llvm_unreachable", "(", "\"TODO: implement emitEpilogue\"", ")", ";", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "WebAssembly", "WebAssembly", "\"TODO: implement emitEpilogue\"" ]

[]

[ "<s>", "void", "LC3AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "LC3", "LC3" ]

[]

[ "<s>", "static", "unsigned", "int", "aarch64_autovectorize_vector_modes", "(", "vector_modes", "*", "modes", ",", "bool", ")", "{", "static", "const", "machine_mode", "sve_modes", "[", "]", "=", "{", "VNx16QImode", ",", "VNx8QImode", ",", "VNx4QImode", ",", "VNx2QImode", "}", ";", "static", "const", "machine_mode", "advsimd_modes", "[", "]", "=", "{", "V16QImode", ",", "V8QImode", ",", "V4HImode", ",", "V2SImode", "}", ";", "unsigned", "int", "sve_i", "=", "TARGET_SVE", "?", "0", ":", "ARRAY_SIZE", "(", "sve_modes", ")", ";", "unsigned", "int", "advsimd_i", "=", "0", ";", "while", "(", "advsimd_i", "<", "ARRAY_SIZE", "(", "advsimd_modes", ")", ")", "{", "if", "(", "sve_i", "<", "ARRAY_SIZE", "(", "sve_modes", ")", "&&", "maybe_gt", "(", "GET_MODE_NUNITS", "(", "sve_modes", "[", "sve_i", "]", ")", ",", "GET_MODE_NUNITS", "(", "advsimd_modes", "[", "advsimd_i", "]", ")", ")", ")", "modes", "->", "safe_push", "(", "sve_modes", "[", "sve_i", "++", "]", ")", ";", "else", "modes", "->", "safe_push", "(", "advsimd_modes", "[", "advsimd_i", "++", "]", ")", ";", "}", "while", "(", "sve_i", "<", "ARRAY_SIZE", "(", "sve_modes", ")", ")", "modes", "->", "safe_push", "(", "sve_modes", "[", "sve_i", "++", "]", ")", ";", "unsigned", "int", "flags", "=", "0", ";", "if", "(", "TARGET_SVE", "&&", "aarch64_sve_compare_costs", ")", "flags", "|=", "VECT_COMPARE_COSTS", ";", "return", "flags", ";", "}", "</s>" ]

[ "Return", "a", "list", "of", "possible", "vector", "sizes", "for", "the", "vectorizer", "to", "iterate", "over", "." ]

[ "aarch64", "0", "0", "0" ]

[]

[ "<s>", "void", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "override", "{", "loadRegFromStack", "(", "MBB", ",", "MBBI", ",", "DestReg", ",", "FrameIndex", ",", "RC", ",", "TRI", ",", "0", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "SIC", "0" ]

[]