Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "const", "ARMSubtarget", "&", "ARMMCInstLower", "::", "getSubtarget", "(", ")", "const", "{", "return", "AsmPrinter", ".", "getSubtarget", "(", ")", ";", "}", "</s>" ]

[ "getSubtarget", "-", "Return", "the", "subtarget", "for", "which", "this", "machine", "code", "is", "being", "compiled", "." ]

[ "ARM", "ARM", "ARM" ]

[]

[ "<s>", "void", "aarch64_expand_mov_immediate", "(", "rtx", "dest", ",", "rtx", "imm", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "gcc_assert", "(", "mode", "==", "SImode", "||", "mode", "==", "DImode", ")", ";", "if", "(", "GET_CODE", "(", "imm", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "imm", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "imm", ")", "==", "CONST", ")", "{", "rtx", "mem", ",", "base", ",", "offset", ";", "enum", "aarch64_symbol_type", "sty", ";", "split_const", "(", "imm", ",", "&", "base", ",", "&", "offset", ")", ";", "sty", "=", "aarch64_classify_symbol", "(", "base", ",", "offset", ")", ";", "switch", "(", "sty", ")", "{", "case", "SYMBOL_FORCE_TO_MEM", ":", "if", "(", "offset", "!=", "const0_rtx", "&&", "targetm", ".", "cannot_force_const_mem", "(", "mode", ",", "imm", ")", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "base", "=", "aarch64_force_temporary", "(", "mode", ",", "dest", ",", "base", ")", ";", "base", "=", "aarch64_add_offset", "(", "mode", ",", "NULL", ",", "base", ",", "INTVAL", "(", "offset", ")", ")", ";", "aarch64_emit_move", "(", "dest", ",", "base", ")", ";", "return", ";", "}", "mem", "=", "force_const_mem", "(", "ptr_mode", ",", "imm", ")", ";", "gcc_assert", "(", "mem", ")", ";", "if", "(", "aarch64_nopcrelative_literal_loads", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "base", "=", "gen_reg_rtx", "(", "ptr_mode", ")", ";", "aarch64_expand_mov_immediate", "(", "base", ",", "XEXP", "(", "mem", ",", "0", ")", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "ptr_mode", ",", "base", ")", ";", "}", "if", "(", "mode", "!=", "ptr_mode", ")", "mem", "=", "gen_rtx_ZERO_EXTEND", "(", "mode", ",", "mem", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "mem", ")", ")", ";", "return", ";", "case", "SYMBOL_SMALL_TLSGD", ":", "case", "SYMBOL_SMALL_TLSDESC", ":", "case", "SYMBOL_SMALL_TLSIE", ":", "case", "SYMBOL_SMALL_GOT_28K", ":", "case", "SYMBOL_SMALL_GOT_4G", ":", "case", "SYMBOL_TINY_GOT", ":", "case", "SYMBOL_TINY_TLSIE", ":", "if", "(", "offset", "!=", "const0_rtx", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "base", "=", "aarch64_force_temporary", "(", "mode", ",", "dest", ",", "base", ")", ";", "base", "=", "aarch64_add_offset", "(", "mode", ",", "NULL", ",", "base", ",", "INTVAL", "(", "offset", ")", ")", ";", "aarch64_emit_move", "(", "dest", ",", "base", ")", ";", "return", ";", "}", "case", "SYMBOL_SMALL_ABSOLUTE", ":", "case", "SYMBOL_TINY_ABSOLUTE", ":", "case", "SYMBOL_TLSLE12", ":", "case", "SYMBOL_TLSLE24", ":", "case", "SYMBOL_TLSLE32", ":", "case", "SYMBOL_TLSLE48", ":", "aarch64_load_symref_appropriately", "(", "dest", ",", "imm", ",", "sty", ")", ";", "return", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "!", "CONST_INT_P", "(", "imm", ")", ")", "{", "if", "(", "GET_CODE", "(", "imm", ")", "==", "HIGH", ")", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "imm", ")", ")", ";", "else", "{", "rtx", "mem", "=", "force_const_mem", "(", "mode", ",", "imm", ")", ";", "gcc_assert", "(", "mem", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "mem", ")", ")", ";", "}", "return", ";", "}", "aarch64_internal_mov_immediate", "(", "dest", ",", "imm", ",", "true", ",", "GET_MODE", "(", "dest", ")", ")", ";", "}", "</s>" ]

[ "Set", "DEST", "to", "immediate", "IMM", ".", "For", "SVE", "vector", "modes", ",", "GEN_VEC_DUPLICATE", "is", "a", "pattern", "that", "can", "be", "used", "to", "set", "DEST", "to", "a", "replicated", "scalar", "element", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "void", "arm_split_atomic_op", "(", "enum", "rtx_code", "code", ",", "rtx", "old_out", ",", "rtx", "new_out", ",", "rtx", "mem", ",", "rtx", "value", ",", "rtx", "model_rtx", ",", "rtx", "cond", ")", "{", "enum", "memmodel", "model", "=", "memmodel_from_int", "(", "INTVAL", "(", "model_rtx", ")", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "machine_mode", "wmode", "=", "(", "mode", "==", "DImode", "?", "DImode", ":", "SImode", ")", ";", "rtx_code_label", "*", "label", ";", "rtx", "x", ";", "bool", "is_armv8_sync", "=", "arm_arch8", "&&", "is_mm_sync", "(", "model", ")", ";", "bool", "use_acquire", "=", "TARGET_HAVE_LDACQ", "&&", "!", "(", "is_mm_relaxed", "(", "model", ")", "||", "is_mm_consume", "(", "model", ")", "||", "is_mm_release", "(", "model", ")", ")", ";", "bool", "use_release", "=", "TARGET_HAVE_LDACQ", "&&", "!", "(", "is_mm_relaxed", "(", "model", ")", "||", "is_mm_consume", "(", "model", ")", "||", "is_mm_acquire", "(", "model", ")", ")", ";", "if", "(", "is_armv8_sync", ")", "use_acquire", "=", "false", ";", "if", "(", "!", "(", "use_acquire", "||", "use_release", ")", ")", "arm_pre_atomic_barrier", "(", "model", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "if", "(", "new_out", ")", "new_out", "=", "gen_lowpart", "(", "wmode", ",", "new_out", ")", ";", "if", "(", "old_out", ")", "old_out", "=", "gen_lowpart", "(", "wmode", ",", "old_out", ")", ";", "else", "old_out", "=", "new_out", ";", "value", "=", "simplify_gen_subreg", "(", "wmode", ",", "value", ",", "mode", ",", "0", ")", ";", "arm_emit_load_exclusive", "(", "mode", ",", "old_out", ",", "mem", ",", "use_acquire", ")", ";", "switch", "(", "code", ")", "{", "case", "SET", ":", "new_out", "=", "value", ";", "break", ";", "case", "NOT", ":", "x", "=", "gen_rtx_AND", "(", "wmode", ",", "old_out", ",", "value", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "new_out", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_NOT", "(", "wmode", ",", "new_out", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "new_out", ",", "x", ")", ")", ";", "break", ";", "case", "MINUS", ":", "if", "(", "CONST_INT_P", "(", "value", ")", ")", "{", "value", "=", "GEN_INT", "(", "-", "INTVAL", "(", "value", ")", ")", ";", "code", "=", "PLUS", ";", "}", "case", "PLUS", ":", "if", "(", "mode", "==", "DImode", ")", "{", "emit_move_insn", "(", "new_out", ",", "old_out", ")", ";", "if", "(", "code", "==", "PLUS", ")", "x", "=", "gen_adddi3", "(", "new_out", ",", "new_out", ",", "value", ")", ";", "else", "x", "=", "gen_subdi3", "(", "new_out", ",", "new_out", ",", "value", ")", ";", "emit_insn", "(", "x", ")", ";", "break", ";", "}", "default", ":", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "wmode", ",", "old_out", ",", "value", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "new_out", ",", "x", ")", ")", ";", "break", ";", "}", "arm_emit_store_exclusive", "(", "mode", ",", "cond", ",", "mem", ",", "gen_lowpart", "(", "mode", ",", "new_out", ")", ",", "use_release", ")", ";", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "gen_cbranchsi4", "(", "x", ",", "cond", ",", "const0_rtx", ",", "label", ")", ")", ";", "if", "(", "is_armv8_sync", "||", "!", "(", "use_acquire", "||", "use_release", ")", ")", "arm_post_atomic_barrier", "(", "model", ")", ";", "}", "</s>" ]

[ "Split", "an", "atomic", "operation", "pattern", ".", "Operation", "is", "given", "by", "CODE", "and", "is", "one", "of", "PLUS", ",", "MINUS", ",", "IOR", ",", "XOR", ",", "SET", "(", "for", "an", "exchange", "operation", ")", "or", "NOT", "(", "for", "a", "nand", "operation", ")", ".", "Operation", "is", "performed", "on", "the", "content", "at", "MEM", "and", "on", "VALUE", "following", "the", "memory", "model", "MODEL_RTX", ".", "The", "content", "at", "MEM", "before", "and", "after", "the", "operation", "is", "returned", "in", "OLD_OUT", "and", "NEW_OUT", "respectively", "while", "the", "success", "of", "the", "operation", "is", "returned", "in", "COND", ".", "Using", "a", "scratch", "register", "or", "an", "operand", "register", "for", "these", "determines", "what", "result", "is", "returned", "for", "that", "pattern", "." ]

[ "arm", "0" ]

[]

[ "<s>", "bool", "X86NaClRewritePass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Modified", "=", "false", ";", "TM", "=", "&", "MF", ".", "getTarget", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "Is64Bit", "=", "Subtarget", "->", "is64Bit", "(", ")", ";", "assert", "(", "Subtarget", "->", "isTargetNaCl", "(", ")", "&&", "\"Unexpected target in NaClRewritePass!\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*************** NaCl Rewrite Pass ***************\\n\"", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{", "Modified", "|=", "runOnMachineBasicBlock", "(", "*", "MFI", ")", ";", "}", "Modified", "|=", "AlignJumpTableTargets", "(", "MF", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*************** NaCl Rewrite DONE ***************\\n\"", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"Unexpected target in NaClRewritePass!\"", "\"*************** NaCl Rewrite Pass ***************\\n\"", "\"*************** NaCl Rewrite DONE ***************\\n\"" ]

[]

[ "<s>", "void", "Warning", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ")", "{", "Parser", ".", "Warning", "(", "L", ",", "Msg", ")", ";", "}", "</s>" ]

[ "Emit", "a", "warning", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "Patmos" ]

[]

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

[ "Return", "true", "if", "this", "asm", "streamer", "supports", "emitting", "unformatted", "text", "to", "the", ".s", "file", "with", "EmitRawText", "." ]

[ "F2003f" ]

[]

[ "<s>", "static", "bool", "arm_evpc_neon_vuzp", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "odd", ",", "mask", ",", "nelt", "=", "d", "->", "nelt", ";", "rtx", "out0", ",", "out1", ",", "in0", ",", "in1", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "int", "first_elem", ";", "int", "swap_nelt", ";", "if", "(", "GET_MODE_UNIT_SIZE", "(", "d", "->", "vmode", ")", ">=", "8", ")", "return", "false", ";", "swap_nelt", "=", "BYTES_BIG_ENDIAN", "&&", "!", "d", "->", "one_vector_p", "&&", "GET_MODE_SIZE", "(", "d", "->", "vmode", ")", "==", "8", "?", "d", "->", "nelt", ":", "0", ";", "first_elem", "=", "d", "->", "perm", "[", "neon_endian_lane_map", "(", "d", "->", "vmode", ",", "0", ")", "]", "^", "swap_nelt", ";", "if", "(", "first_elem", "==", "neon_endian_lane_map", "(", "d", "->", "vmode", ",", "0", ")", ")", "odd", "=", "0", ";", "else", "if", "(", "first_elem", "==", "neon_endian_lane_map", "(", "d", "->", "vmode", ",", "1", ")", ")", "odd", "=", "1", ";", "else", "return", "false", ";", "mask", "=", "(", "d", "->", "one_vector_p", "?", "nelt", "-", "1", ":", "2", "*", "nelt", "-", "1", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "++", ")", "{", "unsigned", "elt", "=", "(", "neon_pair_endian_lane_map", "(", "d", "->", "vmode", ",", "i", ")", "*", "2", "+", "odd", ")", "&", "mask", ";", "if", "(", "(", "d", "->", "perm", "[", "i", "]", "^", "swap_nelt", ")", "!=", "neon_pair_endian_lane_map", "(", "d", "->", "vmode", ",", "elt", ")", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "switch", "(", "d", "->", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_neon_vuzpv16qi_internal", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_neon_vuzpv8qi_internal", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_neon_vuzpv8hi_internal", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_neon_vuzpv4hi_internal", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_neon_vuzpv4si_internal", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_neon_vuzpv2si_internal", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_neon_vuzpv2sf_internal", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_neon_vuzpv4sf_internal", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "in0", "=", "d", "->", "op0", ";", "in1", "=", "d", "->", "op1", ";", "if", "(", "swap_nelt", "!=", "0", ")", "std", "::", "swap", "(", "in0", ",", "in1", ")", ";", "out0", "=", "d", "->", "target", ";", "out1", "=", "gen_reg_rtx", "(", "d", "->", "vmode", ")", ";", "if", "(", "odd", ")", "std", "::", "swap", "(", "out0", ",", "out1", ")", ";", "emit_insn", "(", "gen", "(", "out0", ",", "in0", ",", "in1", ",", "out1", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "the", "VUZP", "insns", "." ]

[ "arm", "8", "8", "0", "0", "0", "0", "1", "1", "1", "2", "1", "0", "2", "0" ]

[]

[ "<s>", "bool", "X86FastTileConfig", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MFunc", ")", "{", "MF", "=", "&", "MFunc", ";", "MRI", "=", "&", "MFunc", ".", "getRegInfo", "(", ")", ";", "const", "TargetSubtargetInfo", "*", "ST", "=", "&", "MFunc", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "TRI", "=", "ST", "->", "getRegisterInfo", "(", ")", ";", "TII", "=", "MFunc", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "X86FI", "=", "MFunc", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "bool", "Change", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MFunc", ")", "Change", "|=", "configBasicBlock", "(", "MBB", ")", ";", "return", "Change", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "Thumb1InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "assert", "(", "(", "RC", "==", "&", "ARM", "::", "tGPRRegClass", "||", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "DestReg", ")", "&&", "isARMLowRegister", "(", "DestReg", ")", ")", ")", "&&", "\"Unknown regclass!\"", ")", ";", "if", "(", "RC", "==", "&", "ARM", "::", "tGPRRegClass", "||", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "DestReg", ")", "&&", "isARMLowRegister", "(", "DestReg", ")", ")", ")", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tLDRspi", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM::tGPRRegClass", "ARM", "\"Unknown regclass!\"", "ARM::tGPRRegClass", "ARM", "ARM::tLDRspi", "0", "ARMCC::AL" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "VERegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "switch", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ")", "{", "case", "CallingConv", "::", "Fast", ":", "default", ":", "return", "CSR_SaveList", ";", "case", "CallingConv", "::", "PreserveAll", ":", "return", "CSR_preserve_all_SaveList", ";", "}", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "VE", "VE" ]

[]

[ "<s>", "static", "void", "emit_unlikely_jump", "(", "rtx", "cond", ",", "rtx", "label", ")", "{", "int", "very_unlikely", "=", "REG_BR_PROB_BASE", "/", "100", "-", "1", ";", "rtx", "x", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "cond", ",", "label", ",", "pc_rtx", ")", ";", "x", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "add_int_reg_note", "(", "x", ",", "REG_BR_PROB", ",", "very_unlikely", ")", ";", "}", "</s>" ]

[ "Mark", "the", "previous", "jump", "instruction", "as", "unlikely", "." ]

[ "rs6000", "100", "1" ]

[]

[ "<s>", "static", "bool", "ix86_can_inline_p", "(", "tree", "caller", ",", "tree", "callee", ")", "{", "bool", "ret", "=", "false", ";", "tree", "caller_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "caller", ")", ";", "tree", "callee_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "callee", ")", ";", "if", "(", "!", "callee_tree", ")", "ret", "=", "true", ";", "else", "if", "(", "!", "caller_tree", ")", "ret", "=", "false", ";", "else", "{", "struct", "cl_target_option", "*", "caller_opts", "=", "TREE_TARGET_OPTION", "(", "caller_tree", ")", ";", "struct", "cl_target_option", "*", "callee_opts", "=", "TREE_TARGET_OPTION", "(", "callee_tree", ")", ";", "if", "(", "(", "(", "caller_opts", "->", "x_ix86_isa_flags", "&", "callee_opts", "->", "x_ix86_isa_flags", ")", "!=", "callee_opts", "->", "x_ix86_isa_flags", ")", "||", "(", "(", "caller_opts", "->", "x_ix86_isa_flags2", "&", "callee_opts", "->", "x_ix86_isa_flags2", ")", "!=", "callee_opts", "->", "x_ix86_isa_flags2", ")", ")", "ret", "=", "false", ";", "else", "if", "(", "caller_opts", "->", "x_target_flags", "!=", "callee_opts", "->", "x_target_flags", ")", "ret", "=", "false", ";", "else", "if", "(", "caller_opts", "->", "arch", "!=", "callee_opts", "->", "arch", ")", "ret", "=", "false", ";", "else", "if", "(", "caller_opts", "->", "tune", "!=", "callee_opts", "->", "tune", ")", "ret", "=", "false", ";", "else", "if", "(", "caller_opts", "->", "x_ix86_fpmath", "!=", "callee_opts", "->", "x_ix86_fpmath", ")", "ret", "=", "false", ";", "else", "if", "(", "caller_opts", "->", "branch_cost", "!=", "callee_opts", "->", "branch_cost", ")", "ret", "=", "false", ";", "else", "ret", "=", "true", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "Hook", "to", "determine", "if", "one", "function", "can", "safely", "inline", "another", "." ]

[ "i386" ]

[]

[ "<s>", "void", "load_got_register", "(", "void", ")", "{", "if", "(", "!", "global_offset_table_rtx", ")", "global_offset_table_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "GLOBAL_OFFSET_TABLE_REGNUM", ")", ";", "if", "(", "TARGET_VXWORKS_RTP", ")", "emit_insn", "(", "gen_vxworks_load_got", "(", ")", ")", ";", "else", "{", "if", "(", "!", "got_helper_rtx", ")", "{", "char", "name", "[", "32", "]", ";", "get_pc_thunk_name", "(", "name", ",", "GLOBAL_OFFSET_TABLE_REGNUM", ")", ";", "got_helper_rtx", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "name", ")", ")", ";", "}", "emit_insn", "(", "gen_load_pcrel_sym", "(", "global_offset_table_rtx", ",", "sparc_got", "(", ")", ",", "got_helper_rtx", ",", "GEN_INT", "(", "GLOBAL_OFFSET_TABLE_REGNUM", ")", ")", ")", ";", "}", "emit_use", "(", "global_offset_table_rtx", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "load", "the", "GOT", "register", "." ]

[ "sparc", "32" ]

[]

[ "<s>", "static", "void", "mips_finish_stub", "(", "mips_one_only_stub", "*", "*", "stub_ptr", ")", "{", "mips_one_only_stub", "*", "stub", "=", "*", "stub_ptr", ";", "if", "(", "!", "stub", ")", "return", ";", "const", "char", "*", "name", "=", "stub", "->", "get_name", "(", ")", ";", "mips_start_unique_function", "(", "name", ")", ";", "mips_start_function_definition", "(", "name", ",", "false", ")", ";", "stub", "->", "output_body", "(", ")", ";", "mips_end_function_definition", "(", "name", ")", ";", "delete", "stub", ";", "*", "stub_ptr", "=", "0", ";", "}", "</s>" ]

[ "If", "*", "STUB_PTR", "points", "to", "a", "stub", ",", "output", "a", "comdat-style", "definition", "for", "it", ",", "then", "free", "*", "STUB_PTR", "." ]

[ "mips", "0" ]

[]

[ "<s>", "const", "InstrItineraryData", "&", "getInstrItineraryData", "(", ")", "const", "{", "return", "InstrItins", ";", "}", "</s>" ]

[ "getInstrItineraryData", "-", "Returns", "instruction", "itinerary", "data", "for", "the", "target", "or", "specific", "subtarget", "." ]

[ "R600" ]

[]

[ "<s>", "uint16_t", "getFlags", "(", ")", "const", "{", "return", "NodeAttrs", "::", "flags", "(", "Attrs", ")", ";", "}", "</s>" ]

[ "Return", "the", "statepoint", "flags", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "c6x_long_call_p", "(", "rtx", "op", ")", "{", "tree", "decl", ";", "if", "(", "!", "TARGET_LONG_CALLS", ")", "return", "false", ";", "decl", "=", "SYMBOL_REF_DECL", "(", "op", ")", ";", "if", "(", "decl", "!=", "NULL_TREE", "&&", "!", "flag_reorder_blocks_and_partition", "&&", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", "&&", "c6x_function_in_section_p", "(", "decl", ",", "current_function_section", "(", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "call", "to", "OP", ",", "which", "is", "a", "SYMBOL_REF", ",", "must", "be", "expanded", "as", "a", "long", "call", "." ]

[ "c6x" ]

[]

[ "<s>", "unsigned", "AArch64InstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MCAsmInfo", "*", "MAI", "=", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ";", "{", "auto", "Op", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Op", "==", "AArch64", "::", "INLINEASM", "||", "Op", "==", "AArch64", "::", "INLINEASM_BR", ")", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "MAI", ")", ";", "}", "if", "(", "MI", ".", "isMetaInstruction", "(", ")", ")", "return", "0", ";", "unsigned", "NumBytes", "=", "0", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MI", ".", "getDesc", "(", ")", ";", "switch", "(", "Desc", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "NumBytes", "=", "4", ";", "break", ";", "case", "TargetOpcode", "::", "STACKMAP", ":", "NumBytes", "=", "StackMapOpers", "(", "&", "MI", ")", ".", "getNumPatchBytes", "(", ")", ";", "assert", "(", "NumBytes", "%", "4", "==", "0", "&&", "\"Invalid number of NOP bytes requested!\"", ")", ";", "break", ";", "case", "TargetOpcode", "::", "PATCHPOINT", ":", "NumBytes", "=", "PatchPointOpers", "(", "&", "MI", ")", ".", "getNumPatchBytes", "(", ")", ";", "assert", "(", "NumBytes", "%", "4", "==", "0", "&&", "\"Invalid number of NOP bytes requested!\"", ")", ";", "break", ";", "case", "AArch64", "::", "TLSDESC_CALLSEQ", ":", "NumBytes", "=", "16", ";", "break", ";", "case", "AArch64", "::", "AUT", ":", "NumBytes", "=", "24", ";", "break", ";", "case", "AArch64", "::", "AUTPAC", ":", "NumBytes", "=", "28", ";", "break", ";", "case", "AArch64", "::", "MOVaddrPAC", ":", "NumBytes", "=", "28", ";", "break", ";", "case", "AArch64", "::", "BR_JumpTable", ":", "NumBytes", "=", "44", ";", "break", ";", "case", "AArch64", "::", "JumpTableDest32", ":", "case", "AArch64", "::", "JumpTableDest16", ":", "case", "AArch64", "::", "JumpTableDest8", ":", "NumBytes", "=", "12", ";", "break", ";", "case", "AArch64", "::", "SPACE", ":", "NumBytes", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "break", ";", "}", "return", "NumBytes", ";", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "AArch64", "AArch64", "AArch64::INLINEASM", "AArch64::INLINEASM_BR", "0", "0", "0", "4", "4", "0", "\"Invalid number of NOP bytes requested!\"", "4", "0", "\"Invalid number of NOP bytes requested!\"", "AArch64::TLSDESC_CALLSEQ", "16", "AArch64::AUT", "24", "AArch64::AUTPAC", "28", "AArch64::MOVaddrPAC", "28", "AArch64::BR_JumpTable", "44", "AArch64::JumpTableDest32", "AArch64::JumpTableDest16", "AArch64::JumpTableDest8", "12", "AArch64::SPACE", "1" ]

[]

[ "<s>", "unsigned", "AVRInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "1", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"AVR branch conditions have one component!\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "assert", "(", "!", "FBB", "&&", "\"Unconditional branch with multiple successors!\"", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AVR", "::", "RJMPk", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "unsigned", "Count", "=", "0", ";", "AVRCC", "::", "CondCodes", "CC", "=", "(", "AVRCC", "::", "CondCodes", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "getBrCond", "(", "CC", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "++", "Count", ";", "if", "(", "FBB", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AVR", "::", "RJMPk", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "AVR", "AVR", "\"code size not handled\"", "\"insertBranch must not be told to insert a fallthrough\"", "1", "0", "\"AVR branch conditions have one component!\"", "\"Unconditional branch with multiple successors!\"", "AVR::RJMPk", "1", "0", "AVRCC::CondCodes", "AVRCC::CondCodes", "0", "AVR::RJMPk" ]

[]

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

[ "getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "." ]

[ "Teak" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "TII", "=", "static_cast", "<", "const", "R600InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "BB_E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "BB_E", ";", "++", "BB", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BB", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "CF_ALU", ")", "continue", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "if", "(", "isALU", "(", "I", ")", ")", "I", "=", "MakeALUClause", "(", "MBB", ",", "I", ")", ";", "else", "++", "I", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "AMDGPU::CF_ALU" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCRetInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCRetInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_PPC", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ";", "Chain", "=", "Val", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Val", ".", "getValue", "(", "2", ")", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Val", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Val", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "}", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "PowerPC", "PPC", "ISD::InputArg", "16", "PPC", "0", "\"Can only return in registers!\"", "1", "2", "\"Unknown loc info!\"", "ISD::TRUNCATE", "ISD::AssertZext", "ISD::TRUNCATE", "ISD::AssertSext", "ISD::TRUNCATE" ]

[]

[ "<s>", "rtx", "mmix_gen_compare_reg", "(", "RTX_CODE", "code", ",", "rtx", "x", ",", "rtx", "y", ")", "{", "machine_mode", "ccmode", "=", "SELECT_CC_MODE", "(", "code", ",", "x", ",", "y", ")", ";", "return", "gen_reg_rtx", "(", "ccmode", ")", ";", "}", "</s>" ]

[ "X", "and", "Y", "are", "two", "things", "to", "compare", "using", "CODE", ".", "Emit", "a", "compare", "insn", "if", "possible", "and", "return", "the", "rtx", "for", "the", "cc-reg", "in", "the", "proper", "mode", ",", "or", "NULL_RTX", "if", "this", "is", "not", "a", "valid", "comparison", "." ]

[ "mmix" ]

[]

[ "<s>", "static", "bool", "m32r_handle_option", "(", "size_t", "code", ",", "const", "char", "*", "arg", ",", "int", "value", ")", "{", "switch", "(", "code", ")", "{", "case", "OPT_m32r", ":", "target_flags", "&=", "~", "(", "MASK_M32R2", "|", "MASK_M32RX", ")", ";", "return", "true", ";", "case", "OPT_mmodel_", ":", "if", "(", "strcmp", "(", "arg", ",", "\"small\"", ")", "==", "0", ")", "m32r_model", "=", "M32R_MODEL_SMALL", ";", "else", "if", "(", "strcmp", "(", "arg", ",", "\"medium\"", ")", "==", "0", ")", "m32r_model", "=", "M32R_MODEL_MEDIUM", ";", "else", "if", "(", "strcmp", "(", "arg", ",", "\"large\"", ")", "==", "0", ")", "m32r_model", "=", "M32R_MODEL_LARGE", ";", "else", "return", "false", ";", "return", "true", ";", "case", "OPT_msdata_", ":", "if", "(", "strcmp", "(", "arg", ",", "\"none\"", ")", "==", "0", ")", "m32r_sdata", "=", "M32R_SDATA_NONE", ";", "else", "if", "(", "strcmp", "(", "arg", ",", "\"sdata\"", ")", "==", "0", ")", "m32r_sdata", "=", "M32R_SDATA_SDATA", ";", "else", "if", "(", "strcmp", "(", "arg", ",", "\"use\"", ")", "==", "0", ")", "m32r_sdata", "=", "M32R_SDATA_USE", ";", "else", "return", "false", ";", "return", "true", ";", "case", "OPT_mno_flush_func", ":", "m32r_cache_flush_func", "=", "NULL", ";", "return", "true", ";", "case", "OPT_mflush_trap_", ":", "return", "value", "<=", "15", ";", "case", "OPT_mno_flush_trap", ":", "m32r_cache_flush_trap", "=", "-", "1", ";", "return", "true", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_HANDLE_OPTION", "." ]

[ "m32r", "\"small\"", "0", "\"medium\"", "0", "\"large\"", "0", "\"none\"", "0", "\"sdata\"", "0", "\"use\"", "0", "15", "1" ]

[]

[ "<s>", "void", "SIRegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "const", "GCNSubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "bool", "SeenFI", "=", "false", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "MO", ".", "isFI", "(", ")", ")", "{", "if", "(", "SeenFI", ")", "llvm_unreachable", "(", "\"should not see multiple frame indices\"", ")", ";", "SeenFI", "=", "true", ";", "}", "}", "MachineOperand", "*", "FIOp", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "vaddr", ")", ";", "assert", "(", "FIOp", "&&", "FIOp", "->", "isFI", "(", ")", "&&", "\"frame index must be address operand\"", ")", ";", "assert", "(", "TII", "->", "isMUBUF", "(", "MI", ")", ")", ";", "assert", "(", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "soffset", ")", "->", "getReg", "(", ")", "==", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", "->", "getFrameOffsetReg", "(", ")", "&&", "\"should only be seeing frame offset relative FrameIndex\"", ")", ";", "MachineOperand", "*", "OffsetOp", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "offset", ")", ";", "int64_t", "NewOffset", "=", "OffsetOp", "->", "getImm", "(", ")", "+", "Offset", ";", "assert", "(", "isUInt", "<", "12", ">", "(", "NewOffset", ")", "&&", "\"offset should be legal\"", ")", ";", "FIOp", "->", "ChangeToRegister", "(", "BaseReg", ",", "false", ")", ";", "OffsetOp", "->", "setImm", "(", "NewOffset", ")", ";", "}", "</s>" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

[ "AMDGPU", "SI", "SI", "\"should not see multiple frame indices\"", "AMDGPU::OpName", "\"frame index must be address operand\"", "AMDGPU::OpName", "SI", "\"should only be seeing frame offset relative FrameIndex\"", "AMDGPU::OpName", "12", "\"offset should be legal\"" ]

[]

[ "<s>", "static", "void", "ia64_emit_nops", "(", ")", "{", "rtx", "insn", ";", "const", "struct", "bundle", "*", "b", "=", "0", ";", "int", "bundle_pos", "=", "0", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "rtx", "pat", ";", "enum", "attr_type", "t", ";", "pat", "=", "INSN_P", "(", "insn", ")", "?", "PATTERN", "(", "insn", ")", ":", "const0_rtx", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "USE", "||", "GET_CODE", "(", "pat", ")", "==", "CLOBBER", ")", "continue", ";", "if", "(", "(", "GET_CODE", "(", "pat", ")", "==", "UNSPEC", "&&", "XINT", "(", "pat", ",", "1", ")", "==", "22", ")", "||", "GET_CODE", "(", "insn", ")", "==", "CODE_LABEL", ")", "{", "if", "(", "b", ")", "while", "(", "bundle_pos", "<", "3", ")", "{", "emit_insn_before", "(", "gen_nop_type", "(", "b", "->", "t", "[", "bundle_pos", "]", ")", ",", "insn", ")", ";", "bundle_pos", "++", ";", "}", "if", "(", "GET_CODE", "(", "insn", ")", "!=", "CODE_LABEL", ")", "b", "=", "bundle", "+", "INTVAL", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", ";", "else", "b", "=", "0", ";", "bundle_pos", "=", "0", ";", "continue", ";", "}", "else", "if", "(", "GET_CODE", "(", "pat", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "pat", ",", "1", ")", "==", "2", ")", "{", "int", "t", "=", "INTVAL", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", ";", "if", "(", "b", ")", "while", "(", "bundle_pos", "<", "t", ")", "{", "emit_insn_before", "(", "gen_nop_type", "(", "b", "->", "t", "[", "bundle_pos", "]", ")", ",", "insn", ")", ";", "bundle_pos", "++", ";", "}", "continue", ";", "}", "if", "(", "bundle_pos", "==", "3", ")", "b", "=", "0", ";", "if", "(", "b", "&&", "INSN_P", "(", "insn", ")", ")", "{", "t", "=", "ia64_safe_type", "(", "insn", ")", ";", "if", "(", "asm_noperands", "(", "PATTERN", "(", "insn", ")", ")", ">=", "0", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ASM_INPUT", ")", "{", "while", "(", "bundle_pos", "<", "3", ")", "{", "emit_insn_before", "(", "gen_nop_type", "(", "b", "->", "t", "[", "bundle_pos", "]", ")", ",", "insn", ")", ";", "bundle_pos", "++", ";", "}", "continue", ";", "}", "if", "(", "t", "==", "TYPE_UNKNOWN", ")", "continue", ";", "while", "(", "bundle_pos", "<", "3", ")", "{", "if", "(", "t", "==", "b", "->", "t", "[", "bundle_pos", "]", "||", "(", "t", "==", "TYPE_A", "&&", "(", "b", "->", "t", "[", "bundle_pos", "]", "==", "TYPE_M", "||", "b", "->", "t", "[", "bundle_pos", "]", "==", "TYPE_I", ")", ")", ")", "break", ";", "emit_insn_before", "(", "gen_nop_type", "(", "b", "->", "t", "[", "bundle_pos", "]", ")", ",", "insn", ")", ";", "bundle_pos", "++", ";", "}", "if", "(", "bundle_pos", "<", "3", ")", "bundle_pos", "++", ";", "}", "}", "}", "</s>" ]

[ "After", "the", "last", "scheduling", "pass", ",", "fill", "in", "NOPs", ".", "It", "'s", "easier", "to", "do", "this", "here", "than", "while", "scheduling", "." ]

[ "ia64", "0", "0", "1", "22", "3", "0", "0", "0", "0", "1", "2", "0", "0", "3", "0", "0", "3", "3", "3" ]

[]

[ "<s>", "static", "void", "xstormy16_asm_out_destructor", "(", "rtx", "symbol", ",", "int", "priority", ")", "{", "const", "char", "*", "section", "=", "\".dtors\"", ";", "char", "buf", "[", "16", "]", ";", "if", "(", "priority", "!=", "DEFAULT_INIT_PRIORITY", ")", "{", "sprintf", "(", "buf", ",", "\".dtors.%.5u\"", ",", "MAX_INIT_PRIORITY", "-", "priority", ")", ";", "section", "=", "buf", ";", "}", "named_section_flags", "(", "section", ",", "0", ")", ";", "assemble_align", "(", "POINTER_SIZE", ")", ";", "assemble_integer", "(", "symbol", ",", "POINTER_SIZE", "/", "BITS_PER_UNIT", ",", "POINTER_SIZE", ",", "1", ")", ";", "}", "</s>" ]

[ "Output", "constructors", "and", "destructors", ".", "Just", "like", "default_named_section_asm_out_", "*", "but", "do", "n't", "set", "the", "sections", "writable", "." ]

[ "stormy16", "\".dtors\"", "16", "\".dtors.%.5u\"", "0", "1" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "override", "{", "bool", "Changed", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "F", ".", "begin", "(", ")", ",", "FE", "=", "F", ".", "end", "(", ")", ";", "FI", "!=", "FE", ";", "++", "FI", ")", "Changed", "|=", "runOnMachineBasicBlock", "(", "*", "FI", ")", ";", "if", "(", "Changed", ")", "F", ".", "getRegInfo", "(", ")", ".", "invalidateLiveness", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "Mips" ]

[]

[ "<s>", "void", "HexagonShuffler", "::", "reset", "(", ")", "{", "Packet", ".", "clear", "(", ")", ";", "BundleFlags", "=", "0", ";", "CheckFailure", "=", "false", ";", "}", "</s>" ]

[ "Reset", "an", "existing", "scalar", "value", "for", "Def", "and", "a", "given", "Instance", "." ]

[ "Hexagon", "Hexagon", "0" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "return", "(", "RealignStack", "&&", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "&&", "(", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "EnableBasePointer", ")", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "stack", "can", "be", "realigned", "for", "the", "target", "." ]

[ "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "isProfitableToHoist", "(", "Instruction", "*", "I", ")", "const", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "Instruction", "::", "FMul", ")", "return", "true", ";", "if", "(", "!", "I", "->", "hasOneUse", "(", ")", ")", "return", "true", ";", "Instruction", "*", "User", "=", "I", "->", "user_back", "(", ")", ";", "assert", "(", "User", "&&", "\"A single use instruction with no uses.\"", ")", ";", "if", "(", "User", "->", "getOpcode", "(", ")", "!=", "Instruction", "::", "FSub", "&&", "User", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "FAdd", ")", "return", "true", ";", "const", "TargetOptions", "&", "Options", "=", "getTargetMachine", "(", ")", ".", "Options", ";", "const", "Function", "*", "F", "=", "I", "->", "getFunction", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "F", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "Type", "*", "Ty", "=", "User", "->", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ";", "return", "!", "(", "isFMAFasterThanFMulAndFAdd", "(", "*", "F", ",", "Ty", ")", "&&", "isOperationLegalOrCustom", "(", "ISD", "::", "FMA", ",", "getValueType", "(", "DL", ",", "Ty", ")", ")", "&&", "(", "Options", ".", "AllowFPOpFusion", "==", "FPOpFusion", "::", "Fast", "||", "Options", ".", "UnsafeFPMath", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "hoist", "instruction", "in", "the", "then/else", "to", "before", "if", "." ]

[ "PowerPC", "PPC", "\"A single use instruction with no uses.\"", "0", "ISD::FMA" ]

[]

[ "<s>", "const", "MCSection", "*", "SystemZMCAsmInfo", "::", "getNonexecutableStackSection", "(", "MCContext", "&", "Ctx", ")", "const", "{", "return", "Ctx", ".", "getELFSection", "(", "\".note.GNU-stack\"", ",", "MCSectionELF", "::", "SHT_PROGBITS", ",", "0", ",", "SectionKind", "::", "getMetadata", "(", ")", ",", "false", ")", ";", "}", "</s>" ]

[ "Targets", "can", "implement", "this", "method", "to", "specify", "a", "section", "to", "switch", "to", "if", "the", "translation", "unit", "does", "n't", "have", "any", "trampolines", "that", "require", "an", "executable", "stack", "." ]

[ "SystemZ", "SystemZ", "\".note.GNU-stack\"", "0" ]

[]

[ "<s>", "MachineInstr", "*", "X86InstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "int", "FrameIndex", ")", "const", "{", "if", "(", "NoFusing", ")", "return", "nullptr", ";", "if", "(", "!", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "OptimizeForSize", ")", "&&", "hasPartialRegUpdate", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", "nullptr", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Size", "=", "MFI", "->", "getObjectSize", "(", "FrameIndex", ")", ";", "unsigned", "Alignment", "=", "MFI", "->", "getObjectAlignment", "(", "FrameIndex", ")", ";", "if", "(", "!", "RI", ".", "needsStackRealignment", "(", "MF", ")", ")", "Alignment", "=", "std", "::", "min", "(", "Alignment", ",", "Subtarget", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ")", ";", "if", "(", "Ops", ".", "size", "(", ")", "==", "2", "&&", "Ops", "[", "0", "]", "==", "0", "&&", "Ops", "[", "1", "]", "==", "1", ")", "{", "unsigned", "NewOpc", "=", "0", ";", "unsigned", "RCSize", "=", "0", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "nullptr", ";", "case", "X86", "::", "TEST8rr", ":", "NewOpc", "=", "X86", "::", "CMP8ri", ";", "RCSize", "=", "1", ";", "break", ";", "case", "X86", "::", "TEST16rr", ":", "NewOpc", "=", "X86", "::", "CMP16ri8", ";", "RCSize", "=", "2", ";", "break", ";", "case", "X86", "::", "TEST32rr", ":", "NewOpc", "=", "X86", "::", "CMP32ri8", ";", "RCSize", "=", "4", ";", "break", ";", "case", "X86", "::", "TEST64rr", ":", "NewOpc", "=", "X86", "::", "CMP64ri8", ";", "RCSize", "=", "8", ";", "break", ";", "}", "if", "(", "Size", "<", "RCSize", ")", "return", "nullptr", ";", "MI", "->", "setDesc", "(", "get", "(", "NewOpc", ")", ")", ";", "MI", "->", "getOperand", "(", "1", ")", ".", "ChangeToImmediate", "(", "0", ")", ";", "}", "else", "if", "(", "Ops", ".", "size", "(", ")", "!=", "1", ")", "return", "nullptr", ";", "SmallVector", "<", "MachineOperand", ",", "4", ">", "MOs", ";", "MOs", ".", "push_back", "(", "MachineOperand", "::", "CreateFI", "(", "FrameIndex", ")", ")", ";", "return", "foldMemoryOperandImpl", "(", "MF", ",", "MI", ",", "Ops", "[", "0", "]", ",", "MOs", ",", "Size", ",", "Alignment", ",", "true", ")", ";", "}", "</s>" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "X86", "X86", "2", "0", "0", "1", "1", "0", "0", "X86::TEST8rr", "X86::CMP8ri", "1", "X86::TEST16rr", "X86::CMP16ri8", "2", "X86::TEST32rr", "X86::CMP32ri8", "4", "X86::TEST64rr", "X86::CMP64ri8", "8", "1", "0", "1", "4", "0" ]

[]

[ "<s>", "void", "AMDGPUInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "llvm_unreachable", "(", "\"Not Implemented\"", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\"Not Implemented\"" ]

[]

[ "<s>", "void", "Mips16FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MipsInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", ")", "return", ";", "if", "(", "isInt", "<", "16", ">", "(", "-", "StackSize", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "SaveRaF16", ")", ")", ".", "addImm", "(", "StackSize", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "MoveR3216", ")", ",", "Mips", "::", "S0", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ";", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "Mips", "Mips", "Mips", "Mips", "0", "16", "Mips::SaveRaF16", "Mips::MoveR3216", "Mips::S0", "Mips::SP" ]

[]

[ "<s>", "static", "void", "frv_io_handle_use", "(", "rtx", "*", "x", ",", "void", "*", "data", ")", "{", "for_each_rtx", "(", "x", ",", "frv_io_handle_use_1", ",", "data", ")", ";", "}", "</s>" ]

[ "A", "note_stores", "callback", "that", "applies", "frv_io_handle_use_1", "to", "an", "entire", "rhs", "value", "." ]

[ "frv" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isZExtFree", "(", "EVT", "VT1", ",", "EVT", "VT2", ")", "const", "{", "return", "VT1", "==", "MVT", "::", "i32", "&&", "VT2", "==", "MVT", "::", "i64", "&&", "Subtarget", ".", "is64Bit", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "zero-extending", "the", "specific", "node", "Val", "to", "type", "VT2", "is", "free", "(", "either", "because", "it", "'s", "implicitly", "zero-extended", "such", "as", "ARM", "ldrb", "/", "ldrh", "or", "because", "it", "'s", "folded", "such", "as", "X86", "zero-extending", "loads", ")", "." ]

[ "X86", "X86", "MVT::i32", "MVT::i64" ]

[]

[ "<s>", "void", "Cpu0SEFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "Cpu0MachineFunctionInfo", "*", "Cpu0FI", "=", "MF", ".", "getInfo", "<", "Cpu0MachineFunctionInfo", ">", "(", ")", ";", "const", "Cpu0SEInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Cpu0SEInstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "const", "Cpu0RegisterInfo", "&", "RegInfo", "=", "*", "static_cast", "<", "const", "Cpu0SERegisterInfo", "*", ">", "(", "STI", ".", "getRegisterInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "Cpu0ABIInfo", "ABI", "=", "STI", ".", "getABI", "(", ")", ";", "unsigned", "SP", "=", "Cpu0", "::", "SP", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "TII", ".", "adjustStackPtr", "(", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0::SP" ]

[]

[ "<s>", "static", "bool", "avr_pgm_check_var_decl", "(", "tree", "node", ")", "{", "const", "char", "*", "reason", "=", "NULL", ";", "addr_space_t", "as", "=", "ADDR_SPACE_GENERIC", ";", "gcc_assert", "(", "as", "==", "0", ")", ";", "if", "(", "avr_log", ".", "progmem", ")", "avr_edump", "(", "\"%?: %t\\n\"", ",", "node", ")", ";", "switch", "(", "TREE_CODE", "(", "node", ")", ")", "{", "default", ":", "break", ";", "case", "VAR_DECL", ":", "if", "(", "as", "=", "avr_nonconst_pointer_addrspace", "(", "TREE_TYPE", "(", "node", ")", ")", ",", "as", ")", "reason", "=", "_", "(", "\"variable\"", ")", ";", "break", ";", "case", "PARM_DECL", ":", "if", "(", "as", "=", "avr_nonconst_pointer_addrspace", "(", "TREE_TYPE", "(", "node", ")", ")", ",", "as", ")", "reason", "=", "_", "(", "\"function parameter\"", ")", ";", "break", ";", "case", "FIELD_DECL", ":", "if", "(", "as", "=", "avr_nonconst_pointer_addrspace", "(", "TREE_TYPE", "(", "node", ")", ")", ",", "as", ")", "reason", "=", "_", "(", "\"structure field\"", ")", ";", "break", ";", "case", "FUNCTION_DECL", ":", "if", "(", "as", "=", "avr_nonconst_pointer_addrspace", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "node", ")", ")", ")", ",", "as", ")", "reason", "=", "_", "(", "\"return type of function\"", ")", ";", "break", ";", "case", "POINTER_TYPE", ":", "if", "(", "as", "=", "avr_nonconst_pointer_addrspace", "(", "node", ")", ",", "as", ")", "reason", "=", "_", "(", "\"pointer\"", ")", ";", "break", ";", "}", "if", "(", "reason", ")", "{", "if", "(", "TYPE_P", "(", "node", ")", ")", "error", "(", "\"pointer targeting address space %qs must be const in %qT\"", ",", "avr_addrspace", "[", "as", "]", ".", "name", ",", "node", ")", ";", "else", "error", "(", "\"pointer targeting address space %qs must be const\"", "\" in %s %q+D\"", ",", "avr_addrspace", "[", "as", "]", ".", "name", ",", "reason", ",", "node", ")", ";", "}", "return", "reason", "==", "NULL", ";", "}", "</s>" ]

[ "Sanity", "check", "NODE", "so", "that", "all", "pointers", "targeting", "non-generic", "address", "spaces", "go", "along", "with", "CONST", "qualifier", ".", "Writing", "to", "these", "address", "spaces", "should", "be", "detected", "and", "complained", "about", "as", "early", "as", "possible", "." ]

[ "avr", "0", "\"%?: %t\\n\"", "\"variable\"", "\"function parameter\"", "\"structure field\"", "\"return type of function\"", "\"pointer\"", "\"pointer targeting address space %qs must be const in %qT\"", "\"pointer targeting address space %qs must be const\"", "\" in %s %q+D\"" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this!\"", ")", ";", "case", "ISD", "::", "READ_REGISTER", ":", "ExpandREAD_REGISTER", "(", "N", ",", "Results", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "BITCAST", ":", "Res", "=", "ExpandBITCAST", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "Res", "=", "Expand64BitShift", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "ReplaceREADCYCLECOUNTER", "(", "N", ",", "Results", ",", "DAG", ",", "Subtarget", ")", ";", "return", ";", "}", "if", "(", "Res", ".", "getNode", "(", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"Don't know how to custom expand this!\"", "ISD::READ_REGISTER", "ISD::BITCAST", "ISD::SRL", "ISD::SRA", "ISD::READCYCLECOUNTER" ]

[]

[ "<s>", "static", "void", "nds32_register_passes", "(", "void", ")", "{", "nds32_register_pass", "(", "make_pass_nds32_fp_as_gp", ",", "PASS_POS_INSERT_BEFORE", ",", "\"ira\"", ")", ";", "nds32_register_pass", "(", "make_pass_nds32_relax_opt", ",", "PASS_POS_INSERT_AFTER", ",", "\"mach\"", ")", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "from", "nds32_option_override", "(", ")", ".", "All", "new", "passes", "should", "be", "registered", "here", "." ]

[ "nds32", "\"ira\"", "\"mach\"" ]

[]

[ "<s>", "void", "mmix_expand_epilogue", "(", "void", ")", "{", "HOST_WIDE_INT", "locals_size", "=", "get_frame_size", "(", ")", ";", "int", "regno", ";", "HOST_WIDE_INT", "stack_space_to_deallocate", "=", "(", "current_function_outgoing_args_size", "+", "current_function_pretend_args_size", "+", "locals_size", "+", "7", ")", "&", "~", "7", ";", "HOST_WIDE_INT", "offset", "=", "current_function_outgoing_args_size", ";", "for", "(", "regno", "=", "255", ";", "regno", ">=", "MMIX_FIRST_GLOBAL_REGNUM", ";", "regno", "--", ")", "if", "(", "(", "(", "regno", "!=", "MMIX_FRAME_POINTER_REGNUM", "||", "!", "frame_pointer_needed", ")", "&&", "regs_ever_live", "[", "regno", "]", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "||", "IS_MMIX_EH_RETURN_DATA_REG", "(", "regno", ")", ")", "stack_space_to_deallocate", "+=", "8", ";", "if", "(", "MMIX_CFUN_HAS_LANDING_PAD", ")", "stack_space_to_deallocate", "+=", "16", ";", "else", "if", "(", "MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS", ")", "stack_space_to_deallocate", "+=", "8", ";", "if", "(", "frame_pointer_needed", ")", "stack_space_to_deallocate", "+=", "8", ";", "if", "(", "(", "stack_space_to_deallocate", "%", "8", ")", "!=", "0", ")", "internal_error", "(", "\"stack frame not a multiple of octabyte: %wd\"", ",", "stack_space_to_deallocate", ")", ";", "for", "(", "regno", "=", "MMIX_FIRST_GLOBAL_REGNUM", ";", "regno", "<=", "255", ";", "regno", "++", ")", "if", "(", "(", "(", "regno", "!=", "MMIX_FRAME_POINTER_REGNUM", "||", "!", "frame_pointer_needed", ")", "&&", "regs_ever_live", "[", "regno", "]", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "||", "IS_MMIX_EH_RETURN_DATA_REG", "(", "regno", ")", ")", "{", "if", "(", "offset", ">", "255", ")", "{", "mmix_emit_sp_add", "(", "offset", ")", ";", "stack_space_to_deallocate", "-=", "offset", ";", "offset", "=", "0", ";", "}", "emit_move_insn", "(", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ",", "gen_rtx_MEM", "(", "DImode", ",", "plus_constant", "(", "stack_pointer_rtx", ",", "offset", ")", ")", ")", ";", "offset", "+=", "8", ";", "}", "offset", "+=", "(", "locals_size", "+", "7", ")", "&", "~", "7", ";", "if", "(", "MMIX_CFUN_HAS_LANDING_PAD", ")", "offset", "+=", "16", ";", "else", "if", "(", "MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS", ")", "offset", "+=", "8", ";", "if", "(", "frame_pointer_needed", ")", "{", "if", "(", "offset", ">", "255", ")", "{", "mmix_emit_sp_add", "(", "offset", ")", ";", "stack_space_to_deallocate", "-=", "offset", ";", "offset", "=", "0", ";", "}", "emit_move_insn", "(", "hard_frame_pointer_rtx", ",", "gen_rtx_MEM", "(", "DImode", ",", "plus_constant", "(", "stack_pointer_rtx", ",", "offset", ")", ")", ")", ";", "offset", "+=", "8", ";", "}", "if", "(", "stack_space_to_deallocate", "!=", "0", ")", "mmix_emit_sp_add", "(", "stack_space_to_deallocate", ")", ";", "if", "(", "current_function_calls_eh_return", ")", "emit_insn", "(", "gen_adddi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "gen_rtx_REG", "(", "DImode", ",", "MMIX_EH_RETURN_STACKADJ_REGNUM", ")", ")", ")", ";", "}", "</s>" ]

[ "Expands", "the", "function", "epilogue", "into", "RTX", "." ]

[ "mmix", "7", "7", "255", "8", "16", "8", "8", "8", "0", "\"stack frame not a multiple of octabyte: %wd\"", "255", "255", "0", "8", "7", "7", "16", "8", "255", "0", "8", "0" ]

[]

[ "<s>", "static", "bool", "sh_scalar_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_SHMEDIA32", "&&", "mode", "==", "TImode", ")", "return", "false", ";", "return", "default_scalar_mode_supported_p", "(", "mode", ")", ";", "}", "</s>" ]

[ "The", "scalar", "modes", "supported", "differs", "from", "the", "default", "version", "in", "TImode", "for", "32-bit", "SHMEDIA", "." ]

[ "sh" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "override", "{", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "BPF" ]

[]

[ "<s>", "WebAssemblyTargetMachine", "::", "WebAssemblyTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ".", "isArch64Bit", "(", ")", "?", "(", "TT", ".", "isOSEmscripten", "(", ")", "?", "\"e-m:e-p:64:64-p10:8:8-p20:8:8-i64:64-\"", "\"f128:64-n32:64-S128-ni:1:10:20\"", ":", "\"e-m:e-p:64:64-p10:8:8-p20:8:8-i64:64-\"", "\"n32:64-S128-ni:1:10:20\"", ")", ":", "(", "TT", ".", "isOSEmscripten", "(", ")", "?", "\"e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-\"", "\"f128:64-n32:64-S128-ni:1:10:20\"", ":", "\"e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-\"", "\"n32:64-S128-ni:1:10:20\"", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "RM", ",", "TT", ")", ",", "getEffectiveCodeModel", "(", "CM", ",", "CodeModel", "::", "Large", ")", ",", "OL", ")", ",", "TLOF", "(", "new", "WebAssemblyTargetObjectFile", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "FunctionSections", "=", "true", ";", "this", "->", "Options", ".", "DataSections", "=", "true", ";", "this", "->", "Options", ".", "UniqueSectionNames", "=", "true", ";", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "Create", "an", "WebAssembly", "architecture", "model", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"e-m:e-p:64:64-p10:8:8-p20:8:8-i64:64-\"", "\"f128:64-n32:64-S128-ni:1:10:20\"", "\"e-m:e-p:64:64-p10:8:8-p20:8:8-i64:64-\"", "\"n32:64-S128-ni:1:10:20\"", "\"e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-\"", "\"f128:64-n32:64-S128-ni:1:10:20\"", "\"e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-\"", "\"n32:64-S128-ni:1:10:20\"", "WebAssembly" ]

[]

[ "<s>", "BitVector", "AVRRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "AVRTargetMachine", "&", "TM", "=", "static_cast", "<", "const", "AVRTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getFrameLowering", "(", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "R0", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "R1", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "R1R0", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "SPL", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "SPH", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "SP", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "Reserved", ".", "set", "(", "AVR", "::", "R28", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "R29", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "R29R28", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "AVR", "AVR", "AVR", "AVR", "AVR::R0", "AVR::R1", "AVR::R1R0", "AVR::SPL", "AVR::SPH", "AVR::SP", "AVR::R28", "AVR::R29", "AVR::R29R28" ]

[]

[ "<s>", "static", "const", "char", "*", "cond_string", "(", "enum", "rtx_code", "code", ")", "{", "bool", "cc_overflow_unusable", "=", "false", ";", "switch", "(", "code", ")", "{", "case", "NE", ":", "return", "\"ne\"", ";", "case", "EQ", ":", "return", "\"eq\"", ";", "case", "GE", ":", "if", "(", "cc_overflow_unusable", ")", "return", "\"pl\"", ";", "else", "return", "\"ge\"", ";", "case", "LT", ":", "if", "(", "cc_overflow_unusable", ")", "return", "\"mi\"", ";", "else", "return", "\"lt\"", ";", "case", "GEU", ":", "return", "\"sh\"", ";", "case", "LTU", ":", "return", "\"lo\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Return", "assembly", "language", "string", "which", "identifies", "a", "comparison", "type", "." ]

[ "avr", "\"ne\"", "\"eq\"", "\"pl\"", "\"ge\"", "\"mi\"", "\"lt\"", "\"sh\"", "\"lo\"", "\"\"" ]

[]

[ "<s>", "unsigned", "int", "rs6000_dbx_register_number", "(", "unsigned", "int", "regno", ",", "unsigned", "int", "format", ")", "{", "if", "(", "SPE_HIGH_REGNO_P", "(", "regno", ")", ")", "return", "regno", "-", "FIRST_SPE_HIGH_REGNO", "+", "1200", ";", "if", "(", "(", "format", "==", "0", "&&", "write_symbols", "!=", "DWARF2_DEBUG", ")", "||", "format", "==", "2", ")", "return", "regno", ";", "if", "(", "regno", "<=", "63", ")", "return", "regno", ";", "if", "(", "regno", "==", "LR_REGNO", ")", "return", "108", ";", "if", "(", "regno", "==", "CTR_REGNO", ")", "return", "109", ";", "if", "(", "format", "==", "1", "&&", "regno", "==", "CR2_REGNO", ")", "return", "64", ";", "if", "(", "CR_REGNO_P", "(", "regno", ")", ")", "return", "regno", "-", "CR0_REGNO", "+", "86", ";", "if", "(", "regno", "==", "CA_REGNO", ")", "return", "101", ";", "if", "(", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "return", "regno", "-", "FIRST_ALTIVEC_REGNO", "+", "1124", ";", "if", "(", "regno", "==", "VRSAVE_REGNO", ")", "return", "356", ";", "if", "(", "regno", "==", "VSCR_REGNO", ")", "return", "67", ";", "if", "(", "regno", "==", "SPE_ACC_REGNO", ")", "return", "99", ";", "if", "(", "regno", "==", "SPEFSCR_REGNO", ")", "return", "612", ";", "return", "regno", ";", "}", "</s>" ]

[ "Map", "internal", "gcc", "register", "numbers", "to", "DWARF2", "register", "numbers", "." ]

[ "powerpcspe", "1200", "0", "2", "63", "108", "109", "1", "64", "86", "101", "1124", "356", "67", "99", "612" ]

[]

[ "<s>", "static", "int", "getRegClass", "(", "RegisterKind", "Is", ",", "unsigned", "RegWidth", ")", "{", "if", "(", "Is", "==", "IS_VGPR", ")", "{", "switch", "(", "RegWidth", ")", "{", "default", ":", "return", "-", "1", ";", "case", "1", ":", "return", "AMDGPU", "::", "VGPR_32RegClassID", ";", "case", "2", ":", "return", "AMDGPU", "::", "VReg_64RegClassID", ";", "case", "3", ":", "return", "AMDGPU", "::", "VReg_96RegClassID", ";", "case", "4", ":", "return", "AMDGPU", "::", "VReg_128RegClassID", ";", "case", "8", ":", "return", "AMDGPU", "::", "VReg_256RegClassID", ";", "case", "16", ":", "return", "AMDGPU", "::", "VReg_512RegClassID", ";", "}", "}", "else", "if", "(", "Is", "==", "IS_TTMP", ")", "{", "switch", "(", "RegWidth", ")", "{", "default", ":", "return", "-", "1", ";", "case", "1", ":", "return", "AMDGPU", "::", "TTMP_32RegClassID", ";", "case", "2", ":", "return", "AMDGPU", "::", "TTMP_64RegClassID", ";", "case", "4", ":", "return", "AMDGPU", "::", "TTMP_128RegClassID", ";", "case", "8", ":", "return", "AMDGPU", "::", "TTMP_256RegClassID", ";", "case", "16", ":", "return", "AMDGPU", "::", "TTMP_512RegClassID", ";", "}", "}", "else", "if", "(", "Is", "==", "IS_SGPR", ")", "{", "switch", "(", "RegWidth", ")", "{", "default", ":", "return", "-", "1", ";", "case", "1", ":", "return", "AMDGPU", "::", "SGPR_32RegClassID", ";", "case", "2", ":", "return", "AMDGPU", "::", "SGPR_64RegClassID", ";", "case", "4", ":", "return", "AMDGPU", "::", "SGPR_128RegClassID", ";", "case", "8", ":", "return", "AMDGPU", "::", "SGPR_256RegClassID", ";", "case", "16", ":", "return", "AMDGPU", "::", "SGPR_512RegClassID", ";", "}", "}", "else", "if", "(", "Is", "==", "IS_AGPR", ")", "{", "switch", "(", "RegWidth", ")", "{", "default", ":", "return", "-", "1", ";", "case", "1", ":", "return", "AMDGPU", "::", "AGPR_32RegClassID", ";", "case", "2", ":", "return", "AMDGPU", "::", "AReg_64RegClassID", ";", "case", "4", ":", "return", "AMDGPU", "::", "AReg_128RegClassID", ";", "case", "16", ":", "return", "AMDGPU", "::", "AReg_512RegClassID", ";", "case", "32", ":", "return", "AMDGPU", "::", "AReg_1024RegClassID", ";", "}", "}", "return", "-", "1", ";", "}", "</s>" ]

[ "Given", "a", "machine", "instruction", "descriptor", ",", "returns", "the", "register", "class", "constraint", "for", "OpNum", ",", "or", "NULL", "." ]

[ "AMDGPU", "1", "1", "AMDGPU::VGPR_32RegClassID", "2", "AMDGPU::VReg_64RegClassID", "3", "AMDGPU::VReg_96RegClassID", "4", "AMDGPU::VReg_128RegClassID", "8", "AMDGPU::VReg_256RegClassID", "16", "AMDGPU::VReg_512RegClassID", "1", "1", "AMDGPU::TTMP_32RegClassID", "2", "AMDGPU::TTMP_64RegClassID", "4", "AMDGPU::TTMP_128RegClassID", "8", "AMDGPU::TTMP_256RegClassID", "16", "AMDGPU::TTMP_512RegClassID", "1", "1", "AMDGPU::SGPR_32RegClassID", "2", "AMDGPU::SGPR_64RegClassID", "4", "AMDGPU::SGPR_128RegClassID", "8", "AMDGPU::SGPR_256RegClassID", "16", "AMDGPU::SGPR_512RegClassID", "1", "1", "AMDGPU::AGPR_32RegClassID", "2", "AMDGPU::AReg_64RegClassID", "4", "AMDGPU::AReg_128RegClassID", "16", "AMDGPU::AReg_512RegClassID", "32", "AMDGPU::AReg_1024RegClassID", "1" ]

[]

[ "<s>", "Value", "*", "HexagonTargetLowering", "::", "emitStoreConditional", "(", "IRBuilderBase", "&", "Builder", ",", "Value", "*", "Val", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "BasicBlock", "*", "BB", "=", "Builder", ".", "GetInsertBlock", "(", ")", ";", "Module", "*", "M", "=", "BB", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Type", "*", "Ty", "=", "Val", "->", "getType", "(", ")", ";", "unsigned", "SZ", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "Type", "*", "CastTy", "=", "Builder", ".", "getIntNTy", "(", "SZ", ")", ";", "assert", "(", "(", "SZ", "==", "32", "||", "SZ", "==", "64", ")", "&&", "\"Only 32/64-bit atomic stores supported\"", ")", ";", "Intrinsic", "::", "ID", "IntID", "=", "(", "SZ", "==", "32", ")", "?", "Intrinsic", "::", "hexagon_S2_storew_locked", ":", "Intrinsic", "::", "hexagon_S4_stored_locked", ";", "Function", "*", "Fn", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "IntID", ")", ";", "unsigned", "AS", "=", "Addr", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "CastTy", "->", "getPointerTo", "(", "AS", ")", ")", ";", "Val", "=", "Builder", ".", "CreateBitCast", "(", "Val", ",", "CastTy", ")", ";", "Value", "*", "Call", "=", "Builder", ".", "CreateCall", "(", "Fn", ",", "{", "Addr", ",", "Val", "}", ",", "\"stcx\"", ")", ";", "Value", "*", "Cmp", "=", "Builder", ".", "CreateICmpEQ", "(", "Call", ",", "Builder", ".", "getInt32", "(", "0", ")", ",", "\"\"", ")", ";", "Value", "*", "Ext", "=", "Builder", ".", "CreateZExt", "(", "Cmp", ",", "Type", "::", "getInt32Ty", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "return", "Ext", ";", "}", "</s>" ]

[ "Perform", "a", "store-conditional", "operation", "to", "Addr", "." ]

[ "Hexagon", "Hexagon", "32", "64", "\"Only 32/64-bit atomic stores supported\"", "Intrinsic::ID", "32", "Intrinsic::hexagon_S2_storew_locked", "Intrinsic::hexagon_S4_stored_locked", "Intrinsic::getDeclaration", "\"stcx\"", "0", "\"\"" ]

[]

[ "<s>", "bool", "AArch64AsmBackend", "::", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "{", "unsigned", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "if", "(", "Kind", ">=", "FirstLiteralRelocationKind", ")", "return", "true", ";", "if", "(", "Kind", "==", "AArch64", "::", "fixup_aarch64_pcrel_adrp_imm21", ")", "return", "true", ";", "AArch64MCExpr", "::", "VariantKind", "RefKind", "=", "static_cast", "<", "AArch64MCExpr", "::", "VariantKind", ">", "(", "Target", ".", "getRefKind", "(", ")", ")", ";", "AArch64MCExpr", "::", "VariantKind", "SymLoc", "=", "AArch64MCExpr", "::", "getSymbolLoc", "(", "RefKind", ")", ";", "if", "(", "Kind", "==", "AArch64", "::", "fixup_aarch64_ldr_pcrel_imm19", "&&", "SymLoc", "==", "AArch64MCExpr", "::", "VK_GOT", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Hook", "to", "check", "if", "a", "relocation", "is", "needed", "for", "some", "target", "specific", "reason", "." ]

[ "AArch64", "AArch64", "AArch64::fixup_aarch64_pcrel_adrp_imm21", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64::fixup_aarch64_ldr_pcrel_imm19", "AArch64" ]

[]

[ "<s>", "void", "LinearizedRegion", "::", "print", "(", "raw_ostream", "&", "OS", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "{", "OS", "<<", "\"Linearized Region {\"", ";", "bool", "IsFirst", "=", "true", ";", "for", "(", "const", "auto", "&", "MBB", ":", "MBBs", ")", "{", "if", "(", "IsFirst", ")", "{", "IsFirst", "=", "false", ";", "}", "else", "{", "OS", "<<", "\" ,\"", ";", "}", "OS", "<<", "MBB", "->", "getNumber", "(", ")", ";", "}", "OS", "<<", "\"} (\"", "<<", "Entry", "->", "getNumber", "(", ")", "<<", "\", \"", "<<", "(", "Exit", "==", "nullptr", "?", "-", "1", ":", "Exit", "->", "getNumber", "(", ")", ")", "<<", "\"): In:\"", "<<", "printReg", "(", "getBBSelectRegIn", "(", ")", ",", "TRI", ")", "<<", "\" Out:\"", "<<", "printReg", "(", "getBBSelectRegOut", "(", ")", ",", "TRI", ")", "<<", "\" {\"", ";", "for", "(", "auto", "&", "LI", ":", "LiveOuts", ")", "{", "OS", "<<", "printReg", "(", "LI", ",", "TRI", ")", "<<", "\" \"", ";", "}", "OS", "<<", "\"} \\n\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"Linearized Region {\"", "\" ,\"", "\"} (\"", "\", \"", "1", "\"): In:\"", "\" Out:\"", "\" {\"", "\" \"", "\"} \\n\"" ]

[]

[ "<s>", "int", "AArch64TTIImpl", "::", "getIntImmCost", "(", "Intrinsic", "::", "ID", "IID", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "switch", "(", "IID", ")", "{", "default", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Intrinsic", "::", "sadd_with_overflow", ":", "case", "Intrinsic", "::", "uadd_with_overflow", ":", "case", "Intrinsic", "::", "ssub_with_overflow", ":", "case", "Intrinsic", "::", "usub_with_overflow", ":", "case", "Intrinsic", "::", "smul_with_overflow", ":", "case", "Intrinsic", "::", "umul_with_overflow", ":", "if", "(", "Idx", "==", "1", ")", "{", "int", "NumConstants", "=", "(", "BitSize", "+", "63", ")", "/", "64", ";", "int", "Cost", "=", "AArch64TTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "return", "(", "Cost", "<=", "NumConstants", "*", "TTI", "::", "TCC_Basic", ")", "?", "static_cast", "<", "int", ">", "(", "TTI", "::", "TCC_Free", ")", ":", "Cost", ";", "}", "break", ";", "case", "Intrinsic", "::", "experimental_stackmap", ":", "if", "(", "(", "Idx", "<", "2", ")", "||", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", "&&", "isInt", "<", "64", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "break", ";", "case", "Intrinsic", "::", "experimental_patchpoint_void", ":", "case", "Intrinsic", "::", "experimental_patchpoint_i64", ":", "if", "(", "(", "Idx", "<", "4", ")", "||", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", "&&", "isInt", "<", "64", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "break", ";", "}", "return", "AArch64TTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "AArch64", "AArch64", "Intrinsic::ID", "0", "Intrinsic::sadd_with_overflow", "Intrinsic::uadd_with_overflow", "Intrinsic::ssub_with_overflow", "Intrinsic::usub_with_overflow", "Intrinsic::smul_with_overflow", "Intrinsic::umul_with_overflow", "1", "63", "64", "AArch64", "Intrinsic::experimental_stackmap", "2", "64", "64", "Intrinsic::experimental_patchpoint_void", "Intrinsic::experimental_patchpoint_i64", "4", "64", "64", "AArch64" ]

[]

[ "<s>", "bool", "RISCVTargetMachine", "::", "isNoopAddrSpaceCast", "(", "unsigned", "SrcAS", ",", "unsigned", "DstAS", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "a", "cast", "between", "SrcAS", "and", "DestAS", "is", "a", "noop", "." ]

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "bool", "e8_consumed_by_ex_p", "(", "rtx_insn", "*", "consumer", ",", "rtx", "def_reg", ")", "{", "rtx", "use_rtx", ";", "switch", "(", "get_attr_type", "(", "consumer", ")", ")", "{", "case", "TYPE_ALU", ":", "case", "TYPE_STORE", ":", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_MUL", ":", "case", "TYPE_MAC", ":", "case", "TYPE_DIV", ":", "case", "TYPE_BRANCH", ":", "case", "TYPE_STORE_MULTIPLE", ":", "return", "n8_consumed_by_ex_p", "(", "consumer", ",", "def_reg", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "reg_overlap_p", "(", "def_reg", ",", "use_rtx", ")", ";", "}", "</s>" ]

[ "Check", "the", "dependency", "between", "the", "producer", "defining", "DEF_REG", "and", "CONSUMER", "requiring", "input", "operand", "at", "EX", "." ]

[ "nds32" ]

[]

[ "<s>", "const", "char", "*", "MSP430TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "NULL", ";", "case", "MSP430ISD", "::", "RET_FLAG", ":", "return", "\"MSP430ISD::RET_FLAG\"", ";", "case", "MSP430ISD", "::", "RETI_FLAG", ":", "return", "\"MSP430ISD::RETI_FLAG\"", ";", "case", "MSP430ISD", "::", "RRA", ":", "return", "\"MSP430ISD::RRA\"", ";", "case", "MSP430ISD", "::", "RLA", ":", "return", "\"MSP430ISD::RLA\"", ";", "case", "MSP430ISD", "::", "RRC", ":", "return", "\"MSP430ISD::RRC\"", ";", "case", "MSP430ISD", "::", "CALL", ":", "return", "\"MSP430ISD::CALL\"", ";", "case", "MSP430ISD", "::", "Wrapper", ":", "return", "\"MSP430ISD::Wrapper\"", ";", "case", "MSP430ISD", "::", "BR_CC", ":", "return", "\"MSP430ISD::BR_CC\"", ";", "case", "MSP430ISD", "::", "CMP", ":", "return", "\"MSP430ISD::CMP\"", ";", "case", "MSP430ISD", "::", "SELECT_CC", ":", "return", "\"MSP430ISD::SELECT_CC\"", ";", "case", "MSP430ISD", "::", "SHL", ":", "return", "\"MSP430ISD::SHL\"", ";", "case", "MSP430ISD", "::", "SRA", ":", "return", "\"MSP430ISD::SRA\"", ";", "}", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "MSP430", "MSP430", "MSP430ISD::RET_FLAG", "\"MSP430ISD::RET_FLAG\"", "MSP430ISD::RETI_FLAG", "\"MSP430ISD::RETI_FLAG\"", "MSP430ISD::RRA", "\"MSP430ISD::RRA\"", "MSP430ISD::RLA", "\"MSP430ISD::RLA\"", "MSP430ISD::RRC", "\"MSP430ISD::RRC\"", "MSP430ISD::CALL", "\"MSP430ISD::CALL\"", "MSP430ISD::Wrapper", "\"MSP430ISD::Wrapper\"", "MSP430ISD::BR_CC", "\"MSP430ISD::BR_CC\"", "MSP430ISD::CMP", "\"MSP430ISD::CMP\"", "MSP430ISD::SELECT_CC", "\"MSP430ISD::SELECT_CC\"", "MSP430ISD::SHL", "\"MSP430ISD::SHL\"", "MSP430ISD::SRA", "\"MSP430ISD::SRA\"" ]

[]

[ "<s>", "bool", "AArch64BranchRelaxation", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "mf", ")", "{", "MF", "=", "&", "mf", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64BranchRelaxation *****\\n\"", ")", ";", "TII", "=", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "scanFunction", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" Basic blocks before relaxation\\n\"", ";", "dumpBBs", "(", ")", ";", ")", ";", "bool", "MadeChange", "=", "false", ";", "while", "(", "relaxBranchInstructions", "(", ")", ")", "MadeChange", "=", "true", ";", "verify", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" Basic blocks after relaxation\\n\\n\"", ";", "dumpBBs", "(", ")", ")", ";", "BlockInfo", ".", "clear", "(", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"***** AArch64BranchRelaxation *****\\n\"", "AArch64", "\" Basic blocks before relaxation\\n\"", "\" Basic blocks after relaxation\\n\\n\"" ]

[]

[ "<s>", "int", "LC2200FrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "int", "offset", "=", "TargetFrameLowering", "::", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ")", ";", "assert", "(", "offset", "%", "4", "==", "0", "&&", "\"4-byte addressibility\"", ")", ";", "return", "offset", "/", "4", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "LC2200", "LC2200", "4", "0", "\"4-byte addressibility\"", "4" ]

[]

[ "<s>", "bool", "arm_is_long_call_p", "(", "tree", "decl", ")", "{", "tree", "attrs", ";", "if", "(", "!", "decl", ")", "return", "TARGET_LONG_CALLS", ";", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"short_call\"", ",", "attrs", ")", ")", "return", "false", ";", "if", "(", "!", "flag_reorder_blocks_and_partition", "&&", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", "&&", "arm_function_in_section_p", "(", "decl", ",", "current_function_section", "(", ")", ")", ")", "return", "false", ";", "if", "(", "lookup_attribute", "(", "\"long_call\"", ",", "attrs", ")", ")", "return", "true", ";", "return", "TARGET_LONG_CALLS", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "a", "32-bit", "``", "long_call", "''", "should", "be", "generated", "for", "a", "call", "from", "the", "current", "function", "to", "DECL", ".", "We", "generate", "a", "long_call", "if", "the", "function", ":", "a.", "has", "an", "__attribute__", "(", "(", "long", "call", ")", ")", "or", "b.", "is", "within", "the", "scope", "of", "a", "#", "pragma", "long_calls", "or", "c.", "the", "-mlong-calls", "command", "line", "switch", "has", "been", "specified", "However", "we", "do", "not", "generate", "a", "long", "call", "if", "the", "function", ":", "d.", "has", "an", "__attribute__", "(", "(", "short_call", ")", ")", "or", "e.", "is", "inside", "the", "scope", "of", "a", "#", "pragma", "no_long_calls", "or", "f.", "is", "defined", "in", "the", "same", "section", "as", "the", "current", "function", "." ]

[ "arm", "\"short_call\"", "\"long_call\"" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addPreEmitPass", "(", ")", "{", "TargetPassConfig", "::", "addPreEmitPass", "(", ")", ";", "addPass", "(", "createWebAssemblyEHRestoreStackPointer", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyReplacePhysRegs", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyCallIndirectFixup", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createWebAssemblyPrepareForLiveIntervals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyOptimizeLiveIntervals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyStoreResults", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegStackify", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegColoring", "(", ")", ")", ";", "}", "addPass", "(", "createWebAssemblyFixIrreducibleControlFlow", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyExplicitLocals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLateEHPrepare", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyCFGSort", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyCFGStackify", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLowerBrUnless", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createWebAssemblyPeephole", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegNumbering", "(", ")", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "bool", "isFsqrtCheap", "(", "SDValue", "Operand", ",", "SelectionDAG", "&", "DAG", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "SQRT", "(", "X", ")", "should", "n't", "be", "replaced", "with", "X", "*", "RSQRT", "(", "X", ")", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "AArch64CallLowering", "::", "splitToValueTypes", "(", "const", "ArgInfo", "&", "OrigArg", ",", "SmallVectorImpl", "<", "ArgInfo", ">", "&", "SplitArgs", ",", "const", "DataLayout", "&", "DL", ",", "MachineRegisterInfo", "&", "MRI", ",", "CallingConv", "::", "ID", "CallConv", ")", "const", "{", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "OrigArg", ".", "Ty", "->", "getContext", "(", ")", ";", "SmallVector", "<", "EVT", ",", "4", ">", "SplitVTs", ";", "SmallVector", "<", "uint64_t", ",", "4", ">", "Offsets", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "OrigArg", ".", "Ty", ",", "SplitVTs", ",", "&", "Offsets", ",", "0", ")", ";", "if", "(", "SplitVTs", ".", "size", "(", ")", "==", "0", ")", "return", ";", "if", "(", "SplitVTs", ".", "size", "(", ")", "==", "1", ")", "{", "SplitArgs", ".", "emplace_back", "(", "OrigArg", ".", "Regs", "[", "0", "]", ",", "SplitVTs", "[", "0", "]", ".", "getTypeForEVT", "(", "Ctx", ")", ",", "OrigArg", ".", "Flags", "[", "0", "]", ",", "OrigArg", ".", "IsFixed", ")", ";", "return", ";", "}", "assert", "(", "OrigArg", ".", "Regs", ".", "size", "(", ")", "==", "SplitVTs", ".", "size", "(", ")", "&&", "\"Regs / types mismatch\"", ")", ";", "bool", "NeedsRegBlock", "=", "TLI", ".", "functionArgumentNeedsConsecutiveRegisters", "(", "OrigArg", ".", "Ty", ",", "CallConv", ",", "false", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "SplitVTs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "Type", "*", "SplitTy", "=", "SplitVTs", "[", "i", "]", ".", "getTypeForEVT", "(", "Ctx", ")", ";", "SplitArgs", ".", "emplace_back", "(", "OrigArg", ".", "Regs", "[", "i", "]", ",", "SplitTy", ",", "OrigArg", ".", "Flags", "[", "0", "]", ",", "OrigArg", ".", "IsFixed", ")", ";", "if", "(", "NeedsRegBlock", ")", "SplitArgs", ".", "back", "(", ")", ".", "Flags", "[", "0", "]", ".", "setInConsecutiveRegs", "(", ")", ";", "}", "SplitArgs", ".", "back", "(", ")", ".", "Flags", "[", "0", "]", ".", "setInConsecutiveRegsLast", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "4", "4", "0", "0", "1", "0", "0", "0", "\"Regs / types mismatch\"", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "ix86_emit_fp_unordered_jump", "(", "rtx", "label", ")", "{", "rtx", "reg", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "rtx", "temp", ";", "emit_insn", "(", "gen_x86_fnstsw_1", "(", "reg", ")", ")", ";", "if", "(", "TARGET_SAHF", "&&", "(", "TARGET_USE_SAHF", "||", "optimize_insn_for_size_p", "(", ")", ")", ")", "{", "emit_insn", "(", "gen_x86_sahf_1", "(", "reg", ")", ")", ";", "temp", "=", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ";", "temp", "=", "gen_rtx_UNORDERED", "(", "VOIDmode", ",", "temp", ",", "const0_rtx", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_testqi_ext_ccno_0", "(", "reg", ",", "GEN_INT", "(", "0x04", ")", ")", ")", ";", "temp", "=", "gen_rtx_REG", "(", "CCNOmode", ",", "FLAGS_REG", ")", ";", "temp", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "temp", ",", "const0_rtx", ")", ";", "}", "temp", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "temp", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "label", ")", ",", "pc_rtx", ")", ";", "temp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "temp", ")", ";", "emit_jump_insn", "(", "temp", ")", ";", "predict_jump", "(", "REG_BR_PROB_BASE", "*", "10", "/", "100", ")", ";", "}", "</s>" ]

[ "Output", "code", "to", "perform", "a", "conditional", "jump", "to", "LABEL", ",", "if", "C2", "flag", "in", "FP", "status", "register", "is", "set", "." ]

[ "i386", "0x04", "10", "100" ]

[]

[ "<s>", "bool", "requiresRegisterScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "PowerPC" ]

[]

[ "<s>", "void", "arc_cpu_cpp_builtins", "(", "cpp_reader", "*", "pfile", ")", "{", "builtin_assert", "(", "\"cpu=arc\"", ")", ";", "builtin_assert", "(", "\"machine=arc\"", ")", ";", "builtin_define", "(", "\"__arc__\"", ")", ";", "def_or_undef_macro", "(", "pfile", ",", "NAME", ",", "CONDITION", ")", ";", "builtin_define_with_int_value", "(", "\"__ARC_TLS_REGNO__\"", ",", "arc_tp_regno", ")", ";", "builtin_define_with_int_value", "(", "\"__ARC_LPC_WIDTH__\"", ",", "arc_lpcwidth", ")", ";", "builtin_define", "(", "TARGET_BIG_ENDIAN", "?", "\"__BIG_ENDIAN__\"", ":", "\"__LITTLE_ENDIAN__\"", ")", ";", "if", "(", "TARGET_BIG_ENDIAN", ")", "builtin_define", "(", "\"__big_endian__\"", ")", ";", "if", "(", "TARGET_HARD_FLOAT", ")", "{", "builtin_define", "(", "\"__arc_hard_float__\"", ")", ";", "builtin_define", "(", "\"__ARC_HARD_FLOAT__\"", ")", ";", "}", "else", "{", "builtin_define", "(", "\"__arc_soft_float__\"", ")", ";", "builtin_define", "(", "\"__ARC_SOFT_FLOAT__\"", ")", ";", "}", "}", "</s>" ]

[ "Helper", "for", "TARGET_CPU_CPP_BUILTINS", "hook", "." ]

[ "arc", "\"cpu=arc\"", "\"machine=arc\"", "\"__arc__\"", "\"__ARC_TLS_REGNO__\"", "\"__ARC_LPC_WIDTH__\"", "\"__BIG_ENDIAN__\"", "\"__LITTLE_ENDIAN__\"", "\"__big_endian__\"", "\"__arc_hard_float__\"", "\"__ARC_HARD_FLOAT__\"", "\"__arc_soft_float__\"", "\"__ARC_SOFT_FLOAT__\"" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "getPICJumpTableRelocBase", "(", "SDValue", "Table", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "is64Bit", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "X86ISD", "::", "GlobalBaseReg", ",", "SDLoc", "(", ")", ",", "getPointerTy", "(", ")", ")", ";", "return", "Table", ";", "}", "</s>" ]

[ "Returns", "relocation", "base", "for", "the", "given", "PIC", "jumptable", "." ]

[ "X86", "X86", "X86ISD::GlobalBaseReg" ]

[]

[ "<s>", "tree", "ix86_handle_shared_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "VAR_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qs attribute only applies to variables\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "a", "``", "shared", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "i386", "\"%qs attribute only applies to variables\"" ]

[]

[ "<s>", "bool", "PPCPostRASchedStrategy", "::", "tryCandidate", "(", "SchedCandidate", "&", "Cand", ",", "SchedCandidate", "&", "TryCand", ")", "{", "if", "(", "!", "Cand", ".", "isValid", "(", ")", ")", "{", "TryCand", ".", "Reason", "=", "NodeOrder", ";", "return", "true", ";", "}", "if", "(", "tryLess", "(", "Top", ".", "getLatencyStallCycles", "(", "TryCand", ".", "SU", ")", ",", "Top", ".", "getLatencyStallCycles", "(", "Cand", ".", "SU", ")", ",", "TryCand", ",", "Cand", ",", "Stall", ")", ")", "return", "TryCand", ".", "Reason", "!=", "NoCand", ";", "if", "(", "tryGreater", "(", "TryCand", ".", "SU", "==", "DAG", "->", "getNextClusterSucc", "(", ")", ",", "Cand", ".", "SU", "==", "DAG", "->", "getNextClusterSucc", "(", ")", ",", "TryCand", ",", "Cand", ",", "Cluster", ")", ")", "return", "TryCand", ".", "Reason", "!=", "NoCand", ";", "if", "(", "tryLess", "(", "TryCand", ".", "ResDelta", ".", "CritResources", ",", "Cand", ".", "ResDelta", ".", "CritResources", ",", "TryCand", ",", "Cand", ",", "ResourceReduce", ")", ")", "return", "TryCand", ".", "Reason", "!=", "NoCand", ";", "if", "(", "tryGreater", "(", "TryCand", ".", "ResDelta", ".", "DemandedResources", ",", "Cand", ".", "ResDelta", ".", "DemandedResources", ",", "TryCand", ",", "Cand", ",", "ResourceDemand", ")", ")", "return", "TryCand", ".", "Reason", "!=", "NoCand", ";", "if", "(", "Cand", ".", "Policy", ".", "ReduceLatency", "&&", "tryLatency", "(", "TryCand", ",", "Cand", ",", "Top", ")", ")", "{", "return", "TryCand", ".", "Reason", "!=", "NoCand", ";", "}", "if", "(", "TryCand", ".", "SU", "->", "NodeNum", "<", "Cand", ".", "SU", "->", "NodeNum", ")", "TryCand", ".", "Reason", "=", "NodeOrder", ";", "if", "(", "TryCand", ".", "Reason", "!=", "NodeOrder", "&&", "TryCand", ".", "Reason", "!=", "NoCand", ")", "return", "true", ";", "if", "(", "biasAddiCandidate", "(", "Cand", ",", "TryCand", ")", ")", "return", "TryCand", ".", "Reason", "!=", "NoCand", ";", "return", "TryCand", ".", "Reason", "!=", "NoCand", ";", "}", "</s>" ]

[ "Apply", "a", "set", "of", "heuristics", "to", "a", "new", "candidate", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "isToken", "(", ")", "const", "override", "{", "if", "(", "Kind", "==", "Token", ")", "return", "true", ";", "if", "(", "Kind", "!=", "Expression", "||", "!", "Expr", ")", "return", "false", ";", "return", "isa", "<", "MCSymbolRefExpr", ">", "(", "Expr", ")", ";", "}", "</s>" ]

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addPreSched2", "(", ")", "{", "PM", "->", "add", "(", "createMipsExpandPseudoPass", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

[ "Mips", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "emitFunctionBodyEnd", "(", ")", "{", "MipsTargetStreamer", "&", "TS", "=", "getTargetStreamer", "(", ")", ";", "if", "(", "!", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "{", "TS", ".", "emitDirectiveSetAt", "(", ")", ";", "TS", ".", "emitDirectiveSetMacro", "(", ")", ";", "TS", ".", "emitDirectiveSetReorder", "(", ")", ";", "}", "TS", ".", "emitDirectiveEnd", "(", "CurrentFnSym", "->", "getName", "(", ")", ")", ";", "if", "(", "!", "InConstantPool", ")", "return", ";", "InConstantPool", "=", "false", ";", "OutStreamer", "->", "emitDataRegion", "(", "MCDR_DataRegionEnd", ")", ";", "}", "</s>" ]

[ "Targets", "can", "override", "this", "to", "emit", "stuff", "after", "the", "last", "basic", "block", "in", "the", "function", "." ]

[ "Mips", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "uint64_t", "MipsAbiFlags", "::", "emit", "(", "const", "MipsAbiFlags", "&", "pInfo", ",", "MemoryRegion", "&", "pRegion", ")", "{", "auto", "*", "buf", "=", "reinterpret_cast", "<", "ElfMipsAbiFlags", "*", ">", "(", "pRegion", ".", "begin", "(", ")", ")", ";", "buf", "->", "version", "=", "0", ";", "buf", "->", "isa_level", "=", "pInfo", ".", "m_IsaLevel", ";", "buf", "->", "isa_rev", "=", "pInfo", ".", "m_IsaRev", ";", "buf", "->", "gpr_size", "=", "pInfo", ".", "m_GprSize", ";", "buf", "->", "cpr1_size", "=", "pInfo", ".", "m_Cpr1Size", ";", "buf", "->", "cpr2_size", "=", "pInfo", ".", "m_Cpr2Size", ";", "buf", "->", "fp_abi", "=", "pInfo", ".", "m_FpAbi", ";", "buf", "->", "isa_ext", "=", "pInfo", ".", "m_IsaExt", ";", "buf", "->", "ases", "=", "pInfo", ".", "m_Ases", ";", "buf", "->", "flags1", "=", "pInfo", ".", "m_Flags1", ";", "buf", "->", "flags2", "=", "0", ";", "return", "size", "(", ")", ";", "}", "</s>" ]

[ "Output", "the", "remark", "via", "the", "diagnostic", "handler", "and", "to", "the", "optimization", "record", "file", "." ]

[ "Mips", "Mips", "Mips", "Mips", "0", "0" ]

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addPreSched2", "(", ")", "{", "PM", ".", "add", "(", "createMipsExpandPseudoPass", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

[ "Mips", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "static", "ArgDescriptor", "createRegister", "(", "Register", "Reg", ",", "unsigned", "Mask", "=", "~", "0u", ")", "{", "return", "ArgDescriptor", "(", "Reg", ",", "Mask", ",", "false", ",", "true", ")", ";", "}", "</s>" ]

[ ".cfi_register", "Previous", "value", "of", "Register1", "is", "saved", "in", "register", "Register2", "." ]

[ "AMDGPU", "0u" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "return", "createMachObjectWriter", "(", "OS", ",", "true", ",", "object", "::", "mach", "::", "CTM_x86_64", ",", "object", "::", "mach", "::", "CSX86_ALL", ",", "true", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "void", "riscv_legitimize_poly_move", "(", "machine_mode", "mode", ",", "rtx", "dest", ",", "rtx", "tmp", ",", "rtx", "src", ")", "{", "poly_int64", "value", "=", "rtx_to_poly_int64", "(", "src", ")", ";", "int", "offset", "=", "value", ".", "coeffs", "[", "0", "]", ";", "int", "factor", "=", "value", ".", "coeffs", "[", "1", "]", ";", "int", "vlenb", "=", "BYTES_PER_RISCV_VECTOR", ".", "coeffs", "[", "1", "]", ";", "int", "div_factor", "=", "0", ";", "emit_move_insn", "(", "tmp", ",", "gen_int_mode", "(", "BYTES_PER_RISCV_VECTOR", ",", "mode", ")", ")", ";", "if", "(", "BYTES_PER_RISCV_VECTOR", ".", "is_constant", "(", ")", ")", "{", "gcc_assert", "(", "value", ".", "is_constant", "(", ")", ")", ";", "riscv_emit_move", "(", "dest", ",", "GEN_INT", "(", "value", ".", "to_constant", "(", ")", ")", ")", ";", "return", ";", "}", "else", "if", "(", "(", "factor", "%", "vlenb", ")", "==", "0", ")", "div_factor", "=", "1", ";", "else", "if", "(", "(", "factor", "%", "(", "vlenb", "/", "2", ")", ")", "==", "0", ")", "div_factor", "=", "2", ";", "else", "if", "(", "(", "factor", "%", "(", "vlenb", "/", "4", ")", ")", "==", "0", ")", "div_factor", "=", "4", ";", "else", "if", "(", "(", "factor", "%", "(", "vlenb", "/", "8", ")", ")", "==", "0", ")", "div_factor", "=", "8", ";", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "div_factor", "!=", "1", ")", "riscv_expand_op", "(", "LSHIFTRT", ",", "mode", ",", "tmp", ",", "tmp", ",", "gen_int_mode", "(", "exact_log2", "(", "div_factor", ")", ",", "QImode", ")", ")", ";", "riscv_expand_mult_with_const_int", "(", "mode", ",", "dest", ",", "tmp", ",", "factor", "/", "(", "vlenb", "/", "div_factor", ")", ")", ";", "HOST_WIDE_INT", "constant", "=", "offset", "-", "factor", ";", "if", "(", "constant", "==", "0", ")", "return", ";", "else", "if", "(", "SMALL_OPERAND", "(", "constant", ")", ")", "riscv_expand_op", "(", "PLUS", ",", "mode", ",", "dest", ",", "dest", ",", "gen_int_mode", "(", "constant", ",", "mode", ")", ")", ";", "else", "{", "rtx", "high", ";", "high", "=", "gen_int_mode", "(", "CONST_HIGH_PART", "(", "constant", ")", ",", "mode", ")", ";", "constant", "=", "CONST_LOW_PART", "(", "constant", ")", ";", "riscv_emit_move", "(", "tmp", ",", "high", ")", ";", "riscv_expand_op", "(", "PLUS", ",", "mode", ",", "dest", ",", "tmp", ",", "dest", ")", ";", "riscv_expand_op", "(", "PLUS", ",", "mode", ",", "dest", ",", "dest", ",", "gen_int_mode", "(", "constant", ",", "mode", ")", ")", ";", "}", "}", "</s>" ]

[ "Analyze", "src", "and", "emit", "const_poly_int", "mov", "sequence", "." ]

[ "riscv", "0", "1", "1", "0", "0", "1", "2", "0", "2", "4", "0", "4", "8", "0", "8", "1", "0" ]

[]

[ "<s>", "void", "Cpu0FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "</s>" ]

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

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addPreEmitPass", "(", ")", "{", "bool", "ShouldPrint", "=", "false", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getX86Subtarget", "(", ")", ".", "hasSSE2", "(", ")", ")", "{", "addPass", "(", "createExecutionDependencyFixPass", "(", "&", "X86", "::", "VR128RegClass", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "getX86Subtarget", "(", ")", ".", "hasAVX", "(", ")", "&&", "UseVZeroUpper", ")", "{", "addPass", "(", "createX86IssueVZeroUpperPass", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getX86Subtarget", "(", ")", ".", "padShortFunctions", "(", ")", ")", "{", "addPass", "(", "createX86PadShortFunctions", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "return", "ShouldPrint", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86::VR128RegClass", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "registered_function", "&", "function_builder", "::", "add_function", "(", "const", "function_instance", "&", "instance", ",", "const", "char", "*", "name", ",", "tree", "fntype", ",", "tree", "attrs", ",", "uint64_t", "required_extensions", ",", "bool", "overloaded_p", ")", "{", "unsigned", "int", "code", "=", "vec_safe_length", "(", "registered_functions", ")", ";", "code", "=", "(", "code", "<<", "AARCH64_BUILTIN_SHIFT", ")", "|", "AARCH64_BUILTIN_SVE", ";", "tree", "decl", "=", "simulate_builtin_function_decl", "(", "input_location", ",", "name", ",", "fntype", ",", "code", ",", "NULL", ",", "attrs", ")", ";", "registered_function", "&", "rfn", "=", "*", "ggc_alloc", "<", "registered_function", ">", "(", ")", ";", "rfn", ".", "instance", "=", "instance", ";", "rfn", ".", "decl", "=", "decl", ";", "rfn", ".", "required_extensions", "=", "required_extensions", ";", "rfn", ".", "overloaded_p", "=", "overloaded_p", ";", "vec_safe_push", "(", "registered_functions", ",", "&", "rfn", ")", ";", "return", "rfn", ";", "}", "</s>" ]

[ "Add", "a", "function", "called", "NAME", "with", "type", "FNTYPE", "and", "attributes", "ATTRS", ".", "INSTANCE", "describes", "what", "the", "function", "does", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "tilepro_expand_umulsi3_highpart", "(", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "tilepro_expand_high_multiply", "(", "op0", ",", "op1", ",", "op2", ",", "false", ")", ";", "}", "</s>" ]

[ "Implement", "umulsi3_highpart", "." ]

[ "tilepro" ]

[]

[ "<s>", "virtual", "const", "ARCompactSubtarget", "*", "getSubtargetImpl", "(", ")", "const", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "ARCompact", "ARC" ]

[]

[ "<s>", "int", "rs6000_trampoline_size", "(", "void", ")", "{", "int", "ret", "=", "0", ";", "switch", "(", "DEFAULT_ABI", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "ABI_AIX", ":", "ret", "=", "(", "TARGET_32BIT", ")", "?", "12", ":", "24", ";", "break", ";", "case", "ABI_ELFv2", ":", "gcc_assert", "(", "!", "TARGET_32BIT", ")", ";", "ret", "=", "32", ";", "break", ";", "case", "ABI_DARWIN", ":", "case", "ABI_V4", ":", "ret", "=", "(", "TARGET_32BIT", ")", "?", "40", ":", "48", ";", "break", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "Length", "in", "units", "of", "the", "trampoline", "for", "entering", "a", "nested", "function", "." ]

[ "powerpcspe", "0", "12", "24", "32", "40", "48" ]

[]

[ "<s>", "void", "mprocRegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "mproc", "mproc" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "HexagonTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "bool", "UseHVX", "=", "Subtarget", ".", "useHVXOps", "(", ")", ",", "UseHVXDbl", "=", "Subtarget", ".", "useHVXDblOps", "(", ")", ";", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "llvm_unreachable", "(", "\"getRegForInlineAsmConstraint Unhandled data type\"", ")", ";", "case", "MVT", "::", "i1", ":", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "f32", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Hexagon", "::", "IntRegsRegClass", ")", ";", "case", "MVT", "::", "i64", ":", "case", "MVT", "::", "f64", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Hexagon", "::", "DoubleRegsRegClass", ")", ";", "}", "case", "'q'", ":", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "llvm_unreachable", "(", "\"getRegForInlineAsmConstraint Unhandled data type\"", ")", ";", "case", "MVT", "::", "v1024i1", ":", "case", "MVT", "::", "v512i1", ":", "case", "MVT", "::", "v32i16", ":", "case", "MVT", "::", "v16i32", ":", "case", "MVT", "::", "v64i8", ":", "case", "MVT", "::", "v8i64", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Hexagon", "::", "VecPredRegsRegClass", ")", ";", "}", "case", "'v'", ":", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "llvm_unreachable", "(", "\"getRegForInlineAsmConstraint Unhandled data type\"", ")", ";", "case", "MVT", "::", "v16i32", ":", "case", "MVT", "::", "v32i16", ":", "case", "MVT", "::", "v64i8", ":", "case", "MVT", "::", "v8i64", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Hexagon", "::", "VectorRegsRegClass", ")", ";", "case", "MVT", "::", "v32i32", ":", "case", "MVT", "::", "v64i16", ":", "case", "MVT", "::", "v16i64", ":", "case", "MVT", "::", "v128i8", ":", "if", "(", "Subtarget", ".", "hasV60TOps", "(", ")", "&&", "UseHVX", "&&", "UseHVXDbl", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Hexagon", "::", "VectorRegs128BRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Hexagon", "::", "VecDblRegsRegClass", ")", ";", "case", "MVT", "::", "v256i8", ":", "case", "MVT", "::", "v128i16", ":", "case", "MVT", "::", "v64i32", ":", "case", "MVT", "::", "v32i64", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Hexagon", "::", "VecDblRegs128BRegClass", ")", ";", "}", "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::i1", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::f32", "0U", "Hexagon::IntRegsRegClass", "MVT::i64", "MVT::f64", "0U", "Hexagon::DoubleRegsRegClass", "\"getRegForInlineAsmConstraint Unhandled data type\"", "MVT::v1024i1", "MVT::v512i1", "MVT::v32i16", "MVT::v16i32", "MVT::v64i8", "MVT::v8i64", "0U", "Hexagon::VecPredRegsRegClass", "\"getRegForInlineAsmConstraint Unhandled data type\"", "MVT::v16i32", "MVT::v32i16", "MVT::v64i8", "MVT::v8i64", "0U", "Hexagon::VectorRegsRegClass", "MVT::v32i32", "MVT::v64i16", "MVT::v16i64", "MVT::v128i8", "0U", "Hexagon::VectorRegs128BRegClass", "0U", "Hexagon::VecDblRegsRegClass", "MVT::v256i8", "MVT::v128i16", "MVT::v64i32", "MVT::v32i64", "0U", "Hexagon::VecDblRegs128BRegClass", "\"Unknown asm register class\"" ]

[]

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

[ "True", "if", "the", "subtarget", "should", "run", "a", "scheduler", "after", "register", "allocation", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "AArch64PreLegalizerCombiner", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "AU", ".", "setPreservesCFG", "(", ")", ";", "getSelectionDAGFallbackAnalysisUsage", "(", "AU", ")", ";", "AU", ".", "addRequired", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "GISelCSEAnalysisWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "GISelCSEAnalysisWrapperPass", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "void", "xtensa_reorg", "(", "void", ")", "{", "compute_bb_for_insn", "(", ")", ";", "df_analyze", "(", ")", ";", "xtensa_reorg_loops", "(", ")", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_MACHINE_DEPENDENT_REORG", "pass", "." ]

[ "xtensa" ]

[]

[ "<s>", "const", "char", "*", "PPCTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "nullptr", ";", "case", "PPCISD", "::", "FSEL", ":", "return", "\"PPCISD::FSEL\"", ";", "case", "PPCISD", "::", "FCFID", ":", "return", "\"PPCISD::FCFID\"", ";", "case", "PPCISD", "::", "FCTIDZ", ":", "return", "\"PPCISD::FCTIDZ\"", ";", "case", "PPCISD", "::", "FCTIWZ", ":", "return", "\"PPCISD::FCTIWZ\"", ";", "case", "PPCISD", "::", "FRE", ":", "return", "\"PPCISD::FRE\"", ";", "case", "PPCISD", "::", "FRSQRTE", ":", "return", "\"PPCISD::FRSQRTE\"", ";", "case", "PPCISD", "::", "STFIWX", ":", "return", "\"PPCISD::STFIWX\"", ";", "case", "PPCISD", "::", "VMADDFP", ":", "return", "\"PPCISD::VMADDFP\"", ";", "case", "PPCISD", "::", "VNMSUBFP", ":", "return", "\"PPCISD::VNMSUBFP\"", ";", "case", "PPCISD", "::", "VPERM", ":", "return", "\"PPCISD::VPERM\"", ";", "case", "PPCISD", "::", "Hi", ":", "return", "\"PPCISD::Hi\"", ";", "case", "PPCISD", "::", "Lo", ":", "return", "\"PPCISD::Lo\"", ";", "case", "PPCISD", "::", "TOC_ENTRY", ":", "return", "\"PPCISD::TOC_ENTRY\"", ";", "case", "PPCISD", "::", "LOAD", ":", "return", "\"PPCISD::LOAD\"", ";", "case", "PPCISD", "::", "LOAD_TOC", ":", "return", "\"PPCISD::LOAD_TOC\"", ";", "case", "PPCISD", "::", "DYNALLOC", ":", "return", "\"PPCISD::DYNALLOC\"", ";", "case", "PPCISD", "::", "GlobalBaseReg", ":", "return", "\"PPCISD::GlobalBaseReg\"", ";", "case", "PPCISD", "::", "SRL", ":", "return", "\"PPCISD::SRL\"", ";", "case", "PPCISD", "::", "SRA", ":", "return", "\"PPCISD::SRA\"", ";", "case", "PPCISD", "::", "SHL", ":", "return", "\"PPCISD::SHL\"", ";", "case", "PPCISD", "::", "CALL", ":", "return", "\"PPCISD::CALL\"", ";", "case", "PPCISD", "::", "CALL_NOP", ":", "return", "\"PPCISD::CALL_NOP\"", ";", "case", "PPCISD", "::", "MTCTR", ":", "return", "\"PPCISD::MTCTR\"", ";", "case", "PPCISD", "::", "BCTRL", ":", "return", "\"PPCISD::BCTRL\"", ";", "case", "PPCISD", "::", "RET_FLAG", ":", "return", "\"PPCISD::RET_FLAG\"", ";", "case", "PPCISD", "::", "EH_SJLJ_SETJMP", ":", "return", "\"PPCISD::EH_SJLJ_SETJMP\"", ";", "case", "PPCISD", "::", "EH_SJLJ_LONGJMP", ":", "return", "\"PPCISD::EH_SJLJ_LONGJMP\"", ";", "case", "PPCISD", "::", "MFOCRF", ":", "return", "\"PPCISD::MFOCRF\"", ";", "case", "PPCISD", "::", "VCMP", ":", "return", "\"PPCISD::VCMP\"", ";", "case", "PPCISD", "::", "VCMPo", ":", "return", "\"PPCISD::VCMPo\"", ";", "case", "PPCISD", "::", "LBRX", ":", "return", "\"PPCISD::LBRX\"", ";", "case", "PPCISD", "::", "STBRX", ":", "return", "\"PPCISD::STBRX\"", ";", "case", "PPCISD", "::", "LARX", ":", "return", "\"PPCISD::LARX\"", ";", "case", "PPCISD", "::", "STCX", ":", "return", "\"PPCISD::STCX\"", ";", "case", "PPCISD", "::", "COND_BRANCH", ":", "return", "\"PPCISD::COND_BRANCH\"", ";", "case", "PPCISD", "::", "BDNZ", ":", "return", "\"PPCISD::BDNZ\"", ";", "case", "PPCISD", "::", "BDZ", ":", "return", "\"PPCISD::BDZ\"", ";", "case", "PPCISD", "::", "MFFS", ":", "return", "\"PPCISD::MFFS\"", ";", "case", "PPCISD", "::", "FADDRTZ", ":", "return", "\"PPCISD::FADDRTZ\"", ";", "case", "PPCISD", "::", "TC_RETURN", ":", "return", "\"PPCISD::TC_RETURN\"", ";", "case", "PPCISD", "::", "CR6SET", ":", "return", "\"PPCISD::CR6SET\"", ";", "case", "PPCISD", "::", "CR6UNSET", ":", "return", "\"PPCISD::CR6UNSET\"", ";", "case", "PPCISD", "::", "ADDIS_TOC_HA", ":", "return", "\"PPCISD::ADDIS_TOC_HA\"", ";", "case", "PPCISD", "::", "LD_TOC_L", ":", "return", "\"PPCISD::LD_TOC_L\"", ";", "case", "PPCISD", "::", "ADDI_TOC_L", ":", "return", "\"PPCISD::ADDI_TOC_L\"", ";", "case", "PPCISD", "::", "PPC32_GOT", ":", "return", "\"PPCISD::PPC32_GOT\"", ";", "case", "PPCISD", "::", "ADDIS_GOT_TPREL_HA", ":", "return", "\"PPCISD::ADDIS_GOT_TPREL_HA\"", ";", "case", "PPCISD", "::", "LD_GOT_TPREL_L", ":", "return", "\"PPCISD::LD_GOT_TPREL_L\"", ";", "case", "PPCISD", "::", "ADD_TLS", ":", "return", "\"PPCISD::ADD_TLS\"", ";", "case", "PPCISD", "::", "ADDIS_TLSGD_HA", ":", "return", "\"PPCISD::ADDIS_TLSGD_HA\"", ";", "case", "PPCISD", "::", "ADDI_TLSGD_L", ":", "return", "\"PPCISD::ADDI_TLSGD_L\"", ";", "case", "PPCISD", "::", "GET_TLS_ADDR", ":", "return", "\"PPCISD::GET_TLS_ADDR\"", ";", "case", "PPCISD", "::", "ADDIS_TLSLD_HA", ":", "return", "\"PPCISD::ADDIS_TLSLD_HA\"", ";", "case", "PPCISD", "::", "ADDI_TLSLD_L", ":", "return", "\"PPCISD::ADDI_TLSLD_L\"", ";", "case", "PPCISD", "::", "GET_TLSLD_ADDR", ":", "return", "\"PPCISD::GET_TLSLD_ADDR\"", ";", "case", "PPCISD", "::", "ADDIS_DTPREL_HA", ":", "return", "\"PPCISD::ADDIS_DTPREL_HA\"", ";", "case", "PPCISD", "::", "ADDI_DTPREL_L", ":", "return", "\"PPCISD::ADDI_DTPREL_L\"", ";", "case", "PPCISD", "::", "VADD_SPLAT", ":", "return", "\"PPCISD::VADD_SPLAT\"", ";", "case", "PPCISD", "::", "SC", ":", "return", "\"PPCISD::SC\"", ";", "}", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "PowerPC", "PPC", "PPCISD::FSEL", "\"PPCISD::FSEL\"", "PPCISD::FCFID", "\"PPCISD::FCFID\"", "PPCISD::FCTIDZ", "\"PPCISD::FCTIDZ\"", "PPCISD::FCTIWZ", "\"PPCISD::FCTIWZ\"", "PPCISD::FRE", "\"PPCISD::FRE\"", "PPCISD::FRSQRTE", "\"PPCISD::FRSQRTE\"", "PPCISD::STFIWX", "\"PPCISD::STFIWX\"", "PPCISD::VMADDFP", "\"PPCISD::VMADDFP\"", "PPCISD::VNMSUBFP", "\"PPCISD::VNMSUBFP\"", "PPCISD::VPERM", "\"PPCISD::VPERM\"", "PPCISD::Hi", "\"PPCISD::Hi\"", "PPCISD::Lo", "\"PPCISD::Lo\"", "PPCISD::TOC_ENTRY", "\"PPCISD::TOC_ENTRY\"", "PPCISD::LOAD", "\"PPCISD::LOAD\"", "PPCISD::LOAD_TOC", "\"PPCISD::LOAD_TOC\"", "PPCISD::DYNALLOC", "\"PPCISD::DYNALLOC\"", "PPCISD::GlobalBaseReg", "\"PPCISD::GlobalBaseReg\"", "PPCISD::SRL", "\"PPCISD::SRL\"", "PPCISD::SRA", "\"PPCISD::SRA\"", "PPCISD::SHL", "\"PPCISD::SHL\"", "PPCISD::CALL", "\"PPCISD::CALL\"", "PPCISD::CALL_NOP", "\"PPCISD::CALL_NOP\"", "PPCISD::MTCTR", "\"PPCISD::MTCTR\"", "PPCISD::BCTRL", "\"PPCISD::BCTRL\"", "PPCISD::RET_FLAG", "\"PPCISD::RET_FLAG\"", "PPCISD::EH_SJLJ_SETJMP", "\"PPCISD::EH_SJLJ_SETJMP\"", "PPCISD::EH_SJLJ_LONGJMP", "\"PPCISD::EH_SJLJ_LONGJMP\"", "PPCISD::MFOCRF", "\"PPCISD::MFOCRF\"", "PPCISD::VCMP", "\"PPCISD::VCMP\"", "PPCISD::VCMPo", "\"PPCISD::VCMPo\"", "PPCISD::LBRX", "\"PPCISD::LBRX\"", "PPCISD::STBRX", "\"PPCISD::STBRX\"", "PPCISD::LARX", "\"PPCISD::LARX\"", "PPCISD::STCX", "\"PPCISD::STCX\"", "PPCISD::COND_BRANCH", "\"PPCISD::COND_BRANCH\"", "PPCISD::BDNZ", "\"PPCISD::BDNZ\"", "PPCISD::BDZ", "\"PPCISD::BDZ\"", "PPCISD::MFFS", "\"PPCISD::MFFS\"", "PPCISD::FADDRTZ", "\"PPCISD::FADDRTZ\"", "PPCISD::TC_RETURN", "\"PPCISD::TC_RETURN\"", "PPCISD::CR6SET", "\"PPCISD::CR6SET\"", "PPCISD::CR6UNSET", "\"PPCISD::CR6UNSET\"", "PPCISD::ADDIS_TOC_HA", "\"PPCISD::ADDIS_TOC_HA\"", "PPCISD::LD_TOC_L", "\"PPCISD::LD_TOC_L\"", "PPCISD::ADDI_TOC_L", "\"PPCISD::ADDI_TOC_L\"", "PPCISD::PPC32_GOT", "\"PPCISD::PPC32_GOT\"", "PPCISD::ADDIS_GOT_TPREL_HA", "\"PPCISD::ADDIS_GOT_TPREL_HA\"", "PPCISD::LD_GOT_TPREL_L", "\"PPCISD::LD_GOT_TPREL_L\"", "PPCISD::ADD_TLS", "\"PPCISD::ADD_TLS\"", "PPCISD::ADDIS_TLSGD_HA", "\"PPCISD::ADDIS_TLSGD_HA\"", "PPCISD::ADDI_TLSGD_L", "\"PPCISD::ADDI_TLSGD_L\"", "PPCISD::GET_TLS_ADDR", "\"PPCISD::GET_TLS_ADDR\"", "PPCISD::ADDIS_TLSLD_HA", "\"PPCISD::ADDIS_TLSLD_HA\"", "PPCISD::ADDI_TLSLD_L", "\"PPCISD::ADDI_TLSLD_L\"", "PPCISD::GET_TLSLD_ADDR", "\"PPCISD::GET_TLSLD_ADDR\"", "PPCISD::ADDIS_DTPREL_HA", "\"PPCISD::ADDIS_DTPREL_HA\"", "PPCISD::ADDI_DTPREL_L", "\"PPCISD::ADDI_DTPREL_L\"", "PPCISD::VADD_SPLAT", "\"PPCISD::VADD_SPLAT\"", "PPCISD::SC", "\"PPCISD::SC\"" ]

[]

[ "<s>", "static", "rtx", "ix86_expand_aligntest", "(", "rtx", "variable", ",", "int", "value", ")", "{", "rtx", "label", "=", "gen_label_rtx", "(", ")", ";", "rtx", "tmpcount", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "variable", ")", ")", ";", "if", "(", "GET_MODE", "(", "variable", ")", "==", "DImode", ")", "emit_insn", "(", "gen_anddi3", "(", "tmpcount", ",", "variable", ",", "GEN_INT", "(", "value", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_andsi3", "(", "tmpcount", ",", "variable", ",", "GEN_INT", "(", "value", ")", ")", ")", ";", "emit_cmp_and_jump_insns", "(", "tmpcount", ",", "const0_rtx", ",", "EQ", ",", "0", ",", "GET_MODE", "(", "variable", ")", ",", "1", ",", "label", ")", ";", "return", "label", ";", "}", "</s>" ]

[ "Helper", "function", "for", "the", "string", "operations", "below", ".", "Dest", "VARIABLE", "whether", "it", "is", "aligned", "to", "VALUE", "bytes", ".", "If", "true", ",", "jump", "to", "the", "label", "." ]

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

[]

[ "<s>", "const", "TargetSchedModel", "&", "getSchedModel", "(", ")", "const", "{", "return", "SchedModel", ";", "}", "</s>" ]

[ "Get", "the", "machine", "model", "for", "this", "subtarget", "'s", "CPU", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"NVPTX DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "NVPTX", "\"NVPTX DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "static", "void", "nds32_insert_attributes", "(", "tree", "decl", ",", "tree", "*", "attributes", ")", "{", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "{", "tree", "func_attrs", ";", "tree", "intr", ",", "excp", ",", "reset", ";", "func_attrs", "=", "*", "attributes", ";", "nds32_check_isr_attrs_conflict", "(", "decl", ",", "func_attrs", ")", ";", "intr", "=", "lookup_attribute", "(", "\"interrupt\"", ",", "func_attrs", ")", ";", "excp", "=", "lookup_attribute", "(", "\"exception\"", ",", "func_attrs", ")", ";", "reset", "=", "lookup_attribute", "(", "\"reset\"", ",", "func_attrs", ")", ";", "if", "(", "intr", "||", "excp", ")", "{", "tree", "id_list", ";", "unsigned", "int", "lower_bound", ",", "upper_bound", ";", "lower_bound", "=", "(", "intr", ")", "?", "(", "0", ")", ":", "(", "1", ")", ";", "upper_bound", "=", "(", "intr", ")", "?", "(", "63", ")", ":", "(", "8", ")", ";", "id_list", "=", "(", "intr", ")", "?", "(", "TREE_VALUE", "(", "intr", ")", ")", ":", "(", "TREE_VALUE", "(", "excp", ")", ")", ";", "while", "(", "id_list", ")", "{", "tree", "id", ";", "id", "=", "TREE_VALUE", "(", "id_list", ")", ";", "if", "(", "TREE_CODE", "(", "id", ")", "!=", "INTEGER_CST", "||", "wi", "::", "ltu_p", "(", "wi", "::", "to_wide", "(", "id", ")", ",", "lower_bound", ")", "||", "wi", "::", "gtu_p", "(", "wi", "::", "to_wide", "(", "id", ")", ",", "upper_bound", ")", ")", "error", "(", "\"invalid id value for interrupt/exception attribute\"", ")", ";", "id_list", "=", "TREE_CHAIN", "(", "id_list", ")", ";", "}", "}", "else", "if", "(", "reset", ")", "{", "tree", "id_list", ";", "tree", "id", ";", "tree", "nmi", ",", "warm", ";", "unsigned", "int", "lower_bound", ";", "unsigned", "int", "upper_bound", ";", "id_list", "=", "TREE_VALUE", "(", "reset", ")", ";", "id", "=", "TREE_VALUE", "(", "id_list", ")", ";", "lower_bound", "=", "0", ";", "upper_bound", "=", "64", ";", "if", "(", "TREE_CODE", "(", "id", ")", "!=", "INTEGER_CST", "||", "wi", "::", "ltu_p", "(", "wi", "::", "to_wide", "(", "id", ")", ",", "lower_bound", ")", "||", "wi", "::", "gtu_p", "(", "wi", "::", "to_wide", "(", "id", ")", ",", "upper_bound", ")", ")", "error", "(", "\"invalid id value for reset attribute\"", ")", ";", "nmi", "=", "lookup_attribute", "(", "\"nmi\"", ",", "func_attrs", ")", ";", "warm", "=", "lookup_attribute", "(", "\"warm\"", ",", "func_attrs", ")", ";", "if", "(", "nmi", "!=", "NULL_TREE", ")", "{", "tree", "nmi_func_list", ";", "tree", "nmi_func", ";", "nmi_func_list", "=", "TREE_VALUE", "(", "nmi", ")", ";", "nmi_func", "=", "TREE_VALUE", "(", "nmi_func_list", ")", ";", "if", "(", "TREE_CODE", "(", "nmi_func", ")", "!=", "IDENTIFIER_NODE", ")", "error", "(", "\"invalid nmi function for reset attribute\"", ")", ";", "}", "if", "(", "warm", "!=", "NULL_TREE", ")", "{", "tree", "warm_func_list", ";", "tree", "warm_func", ";", "warm_func_list", "=", "TREE_VALUE", "(", "warm", ")", ";", "warm_func", "=", "TREE_VALUE", "(", "warm_func_list", ")", ";", "if", "(", "TREE_CODE", "(", "warm_func", ")", "!=", "IDENTIFIER_NODE", ")", "error", "(", "\"invalid warm function for reset attribute\"", ")", ";", "}", "}", "else", "{", "return", ";", "}", "}", "}", "</s>" ]

[ "Add", "some", "checking", "when", "inserting", "attributes", "." ]

[ "nds32", "\"interrupt\"", "\"exception\"", "\"reset\"", "0", "1", "63", "8", "\"invalid id value for interrupt/exception attribute\"", "0", "64", "\"invalid id value for reset attribute\"", "\"nmi\"", "\"warm\"", "\"invalid nmi function for reset attribute\"", "\"invalid warm function for reset attribute\"" ]

[]

[ "<s>", "static", "void", "mn10300_asm_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk_fndecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "const", "char", "*", "_this", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "_this", "=", "reg_names", "[", "FIRST_ARGUMENT_REGNUM", "+", "1", "]", ";", "else", "_this", "=", "reg_names", "[", "FIRST_ARGUMENT_REGNUM", "]", ";", "fprintf", "(", "file", ",", "\"\\t%s Thunk Entry Point:\\n\"", ",", "ASM_COMMENT_START", ")", ";", "if", "(", "delta", ")", "fprintf", "(", "file", ",", "\"\\tadd %d, %s\\n\"", ",", "(", "int", ")", "delta", ",", "_this", ")", ";", "if", "(", "vcall_offset", ")", "{", "const", "char", "*", "scratch", "=", "reg_names", "[", "FIRST_ADDRESS_REGNUM", "+", "1", "]", ";", "fprintf", "(", "file", ",", "\"\\tmov %s, %s\\n\"", ",", "_this", ",", "scratch", ")", ";", "fprintf", "(", "file", ",", "\"\\tmov (%s), %s\\n\"", ",", "scratch", ",", "scratch", ")", ";", "fprintf", "(", "file", ",", "\"\\tadd %d, %s\\n\"", ",", "(", "int", ")", "vcall_offset", ",", "scratch", ")", ";", "fprintf", "(", "file", ",", "\"\\tmov (%s), %s\\n\"", ",", "scratch", ",", "scratch", ")", ";", "fprintf", "(", "file", ",", "\"\\tadd %s, %s\\n\"", ",", "scratch", ",", "_this", ")", ";", "}", "fputs", "(", "\"\\tjmp \"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ",", "0", ")", ")", ";", "putc", "(", "'\\n'", ",", "file", ")", ";", "}", "</s>" ]

[ "Output", "the", "assembler", "code", "for", "a", "C++", "thunk", "function", ".", "THUNK_DECL", "is", "the", "declaration", "for", "the", "thunk", "function", "itself", ",", "FUNCTION", "is", "the", "decl", "for", "the", "target", "function", ".", "DELTA", "is", "an", "immediate", "constant", "offset", "to", "be", "added", "to", "the", "THIS", "parameter", ".", "If", "VCALL_OFFSET", "is", "nonzero", "the", "word", "at", "the", "adjusted", "address", "*", "(", "*", "THIS", "'", "+", "VCALL_OFFSET", ")", "should", "be", "additionally", "added", "to", "THIS", ".", "Finally", "jump", "to", "the", "entry", "point", "of", "FUNCTION", "." ]

[ "mn10300", "1", "\"\\t%s Thunk Entry Point:\\n\"", "\"\\tadd %d, %s\\n\"", "1", "\"\\tmov %s, %s\\n\"", "\"\\tmov (%s), %s\\n\"", "\"\\tadd %d, %s\\n\"", "\"\\tmov (%s), %s\\n\"", "\"\\tadd %s, %s\\n\"", "\"\\tjmp \"", "0", "0" ]

[]

[ "<s>", "void", "WebAssemblyExceptionInfo", "::", "recalculate", "(", "MachineDominatorTree", "&", "MDT", ",", "const", "MachineDominanceFrontier", "&", "MDF", ")", "{", "SmallVector", "<", "WebAssemblyException", "*", ",", "8", ">", "Exceptions", ";", "for", "(", "auto", "DomNode", ":", "post_order", "(", "&", "MDT", ")", ")", "{", "MachineBasicBlock", "*", "EHPad", "=", "DomNode", "->", "getBlock", "(", ")", ";", "if", "(", "!", "EHPad", "->", "isEHPad", "(", ")", ")", "continue", ";", "if", "(", "WebAssembly", "::", "isCatchAllTerminatePad", "(", "*", "EHPad", ")", ")", "continue", ";", "auto", "*", "WE", "=", "new", "WebAssemblyException", "(", "EHPad", ")", ";", "discoverAndMapException", "(", "WE", ",", "MDT", ",", "MDF", ")", ";", "Exceptions", ".", "push_back", "(", "WE", ")", ";", "}", "for", "(", "auto", "DomNode", ":", "post_order", "(", "&", "MDT", ")", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "DomNode", "->", "getBlock", "(", ")", ";", "WebAssemblyException", "*", "WE", "=", "getExceptionFor", "(", "MBB", ")", ";", "for", "(", ";", "WE", ";", "WE", "=", "WE", "->", "getParentException", "(", ")", ")", "WE", "->", "addBlock", "(", "MBB", ")", ";", "}", "for", "(", "auto", "*", "WE", ":", "Exceptions", ")", "{", "if", "(", "WE", "->", "getParentException", "(", ")", ")", "WE", "->", "getParentException", "(", ")", "->", "getSubExceptions", "(", ")", ".", "push_back", "(", "WE", ")", ";", "else", "addTopLevelException", "(", "WE", ")", ";", "}", "for", "(", "auto", "*", "WE", ":", "Exceptions", ")", "{", "WE", "->", "reverseBlock", "(", ")", ";", "std", "::", "reverse", "(", "WE", "->", "getSubExceptions", "(", ")", ".", "begin", "(", ")", ",", "WE", "->", "getSubExceptions", "(", ")", ".", "end", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "Notify", "DTU", "that", "the", "entry", "block", "was", "replaced", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "8", "WebAssembly::isCatchAllTerminatePad", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "static", "const", "char", "*", "rs6000_call_template_1", "(", "rtx", "*", "operands", ",", "unsigned", "int", "funop", ",", "bool", "sibcall", ")", "{", "gcc_assert", "(", "funop", "<=", "MAX_RECOG_OPERANDS", ")", ";", "char", "arg", "[", "12", "]", ";", "arg", "[", "0", "]", "=", "0", ";", "if", "(", "GET_CODE", "(", "operands", "[", "funop", "+", "1", "]", ")", "==", "UNSPEC", ")", "{", "if", "(", "XINT", "(", "operands", "[", "funop", "+", "1", "]", ",", "1", ")", "==", "UNSPEC_TLSGD", ")", "sprintf", "(", "arg", ",", "\"(%%%u@tlsgd)\"", ",", "funop", "+", "1", ")", ";", "else", "if", "(", "XINT", "(", "operands", "[", "funop", "+", "1", "]", ",", "1", ")", "==", "UNSPEC_TLSLD", ")", "sprintf", "(", "arg", ",", "\"(%%&@tlsld)\"", ")", ";", "}", "char", "z", "[", "11", "]", ";", "sprintf", "(", "z", ",", "\"%%z%u%s\"", ",", "funop", ",", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "TARGET_SECURE_PLT", "&&", "flag_pic", "==", "2", "?", "\"+32768\"", ":", "\"\"", ")", ")", ";", "static", "char", "str", "[", "32", "]", ";", "if", "(", "rs6000_pcrel_p", "(", ")", ")", "sprintf", "(", "str", ",", "\"b%s %s@notoc%s\"", ",", "sibcall", "?", "\"\"", ":", "\"l\"", ",", "z", ",", "arg", ")", ";", "else", "if", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "sprintf", "(", "str", ",", "\"b%s %s%s%s\"", ",", "sibcall", "?", "\"\"", ":", "\"l\"", ",", "z", ",", "arg", ",", "sibcall", "?", "\"\"", ":", "\"\\n\\tnop\"", ")", ";", "else", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", ")", "sprintf", "(", "str", ",", "\"b%s %s%s%s\"", ",", "sibcall", "?", "\"\"", ":", "\"l\"", ",", "z", ",", "arg", ",", "flag_pic", "?", "\"@plt\"", ":", "\"\"", ")", ";", "else", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", ")", "{", "gcc_checking_assert", "(", "GET_CODE", "(", "operands", "[", "funop", "+", "2", "]", ")", "==", "CONST_INT", ")", ";", "int", "cookie", "=", "INTVAL", "(", "operands", "[", "funop", "+", "2", "]", ")", ";", "if", "(", "cookie", "&", "CALL_LONG", ")", "{", "tree", "funname", "=", "get_identifier", "(", "XSTR", "(", "operands", "[", "funop", "]", ",", "0", ")", ")", ";", "tree", "labelname", "=", "get_prev_label", "(", "funname", ")", ";", "gcc_checking_assert", "(", "labelname", "&&", "!", "sibcall", ")", ";", "sprintf", "(", "str", ",", "\"jbsr %%z%u,%.10s\"", ",", "funop", ",", "IDENTIFIER_POINTER", "(", "labelname", ")", ")", ";", "}", "else", "sprintf", "(", "str", ",", "\"b%s %s%s\"", ",", "sibcall", "?", "\"\"", ":", "\"l\"", ",", "z", ",", "arg", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "return", "str", ";", "}", "</s>" ]

[ "Return", "a", "template", "string", "for", "assembly", "to", "emit", "when", "making", "an", "external", "call", ".", "FUNOP", "is", "the", "call", "mem", "argument", "operand", "number", "." ]

[ "rs6000", "12", "0", "0", "1", "1", "1", "\"(%%%u@tlsgd)\"", "1", "1", "1", "\"(%%&@tlsld)\"", "11", "\"%%z%u%s\"", "2", "\"+32768\"", "\"\"", "32", "\"b%s %s@notoc%s\"", "\"\"", "\"l\"", "\"b%s %s%s%s\"", "\"\"", "\"l\"", "\"\"", "\"\\n\\tnop\"", "\"b%s %s%s%s\"", "\"\"", "\"l\"", "\"@plt\"", "\"\"", "2", "2", "0", "\"jbsr %%z%u,%.10s\"", "\"b%s %s%s\"", "\"\"", "\"l\"" ]

[]

[ "<s>", "static", "void", "winnt_d_register_target_info", "(", "void", ")", "{", "const", "struct", "d_target_info_spec", "handlers", "[", "]", "=", "{", "{", "\"objectFormat\"", ",", "winnt_d_handle_target_object_format", "}", ",", "{", "NULL", ",", "NULL", "}", ",", "}", ";", "d_add_target_info_handlers", "(", "handlers", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_D_REGISTER_OS_TARGET_INFO", "for", "Windows", "targets", "." ]

[ "i386", "\"objectFormat\"" ]

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "this", "->", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "StackPU2" ]

[]

[ "<s>", "bool", "GCNHazardRecognizer", "::", "ShouldPreferAnother", "(", "SUnit", "*", "SU", ")", "{", "if", "(", "!", "SU", "->", "isInstr", "(", ")", ")", "return", "false", ";", "const", "MachineInstr", "*", "MAI", "=", "nullptr", ";", "auto", "IsMFMAFn", "=", "[", "&", "MAI", "]", "(", "const", "MachineInstr", "&", "MI", ")", "{", "MAI", "=", "nullptr", ";", "if", "(", "SIInstrInfo", "::", "isMAI", "(", "MI", ")", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "V_ACCVGPR_WRITE_B32_e64", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "V_ACCVGPR_READ_B32_e64", ")", "MAI", "=", "&", "MI", ";", "return", "MAI", "!=", "nullptr", ";", "}", ";", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "IsMFMAFn", "(", "*", "MI", ")", ")", "{", "int", "W", "=", "getWaitStatesSince", "(", "IsMFMAFn", ",", "16", ")", ";", "if", "(", "MAI", ")", "return", "W", "<", "(", "int", ")", "TSchedModel", ".", "computeInstrLatency", "(", "MAI", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "ShouldPreferAnother", "-", "This", "callback", "may", "be", "invoked", "if", "getHazardType", "returns", "NoHazard", "." ]

[ "AMDGPU", "SI", "AMDGPU::V_ACCVGPR_WRITE_B32_e64", "AMDGPU::V_ACCVGPR_READ_B32_e64", "16" ]

[]

[ "<s>", "bool", "DLXMemAluCombiner", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "DisableMemAluCombiner", ")", "return", "false", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "DLXSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MfIterator", "MFI", "=", "MF", ".", "begin", "(", ")", ";", "MFI", "!=", "MF", ".", "end", "(", ")", ";", "++", "MFI", ")", "{", "Modified", "|=", "combineMemAluInBasicBlock", "(", "&", "*", "MFI", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "DLX", "DLX", "DLX" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "&", "LiveRangeShrinkID", ")", ";", "addPass", "(", "createX86FixupSetCC", "(", ")", ")", ";", "addPass", "(", "createX86OptimizeLEAs", "(", ")", ")", ";", "addPass", "(", "createX86CallFrameOptimization", "(", ")", ")", ";", "addPass", "(", "createX86AvoidStoreForwardingBlocks", "(", ")", ")", ";", "}", "addPass", "(", "createX86SpeculativeLoadHardeningPass", "(", ")", ")", ";", "addPass", "(", "createX86FlagsCopyLoweringPass", "(", ")", ")", ";", "addPass", "(", "createX86WinAllocaExpander", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createX86PreTileConfigPass", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

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

[]