Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "void", "arc_setup_incoming_varargs", "(", "cumulative_args_t", "args_so_far", ",", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "int", "first_anon_arg", ";", "CUMULATIVE_ARGS", "next_cum", ";", "next_cum", "=", "*", "get_cumulative_args", "(", "args_so_far", ")", ";", "arc_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "next_cum", ")", ",", "mode", ",", "type", ",", "1", ")", ";", "first_anon_arg", "=", "next_cum", ";", "if", "(", "first_anon_arg", "<", "MAX_ARC_PARM_REGS", ")", "{", "int", "first_reg_offset", "=", "first_anon_arg", ";", "if", "(", "!", "no_rtl", ")", "{", "rtx", "regblock", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "Pmode", ",", "arg_pointer_rtx", ",", "FIRST_PARM_OFFSET", "(", "0", ")", ")", ")", ";", "move_block_from_reg", "(", "first_reg_offset", ",", "regblock", ",", "MAX_ARC_PARM_REGS", "-", "first_reg_offset", ")", ";", "}", "*", "pretend_size", "=", "(", "(", "MAX_ARC_PARM_REGS", "-", "first_reg_offset", ")", "*", "UNITS_PER_WORD", ")", ";", "}", "}", "</s>" ]

[ "Do", "any", "needed", "setup", "for", "a", "variadic", "function", ".", "For", "the", "ARC", ",", "we", "must", "create", "a", "register", "parameter", "block", ",", "and", "then", "copy", "any", "anonymous", "arguments", "in", "registers", "to", "memory", ".", "CUM", "has", "not", "been", "updated", "for", "the", "last", "named", "argument", "which", "has", "type", "TYPE", "and", "mode", "MODE", ",", "and", "we", "rely", "on", "this", "fact", "." ]

[ "arc", "1", "0" ]

[]

[ "<s>", "BitVector", "AArch64RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AArch64FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "WSP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "WZR", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", "||", "TT", ".", "isOSDarwin", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "W29", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "AArch64", "::", "GPR32commonRegClass", ".", "getNumRegs", "(", ")", ";", "++", "i", ")", "{", "if", "(", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isXRegisterReserved", "(", "i", ")", ")", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "GPR32commonRegClass", ".", "getRegister", "(", "i", ")", ")", ";", "}", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "W19", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "SpeculativeLoadHardening", ")", ")", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "W16", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "isPagerando", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "W20", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "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", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64::WSP", "AArch64::WZR", "AArch64::W29", "0", "AArch64::GPR32commonRegClass", "AArch64", "AArch64::GPR32commonRegClass", "AArch64::W19", "AArch64::W16", "AArch64::W20" ]

[]

[ "<s>", "const", "CallLowering", "*", "X86Subtarget", "::", "getCallLowering", "(", ")", "const", "{", "assert", "(", "GISel", "&&", "\"Access to GlobalISel APIs not set\"", ")", ";", "return", "GISel", "->", "getCallLowering", "(", ")", ";", "}", "</s>" ]

[ "Methods", "used", "by", "Global", "ISel", "." ]

[ "X86", "X86", "\"Access to GlobalISel APIs not set\"" ]

[]

[ "<s>", "static", "rtx_insn", "*", "mips_break_sequence", "(", "rtx_insn", "*", "insn", ")", "{", "rtx_insn", "*", "before", "=", "PREV_INSN", "(", "insn", ")", ";", "rtx_insn", "*", "branch", "=", "SEQ_BEGIN", "(", "insn", ")", ";", "rtx_insn", "*", "ds", "=", "SEQ_END", "(", "insn", ")", ";", "remove_insn", "(", "insn", ")", ";", "add_insn_after", "(", "ds", ",", "before", ",", "NULL", ")", ";", "add_insn_after", "(", "branch", ",", "ds", ",", "NULL", ")", ";", "return", "ds", ";", "}", "</s>" ]

[ "Remove", "a", "SEQUENCE", "and", "replace", "it", "with", "the", "delay", "slot", "instruction", "followed", "by", "the", "branch", "and", "return", "the", "instruction", "in", "the", "delay", "slot", ".", "Return", "the", "first", "of", "the", "two", "new", "instructions", ".", "Subroutine", "of", "mips_reorg_process_insns", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "X86PartialReduction", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "!", "TPC", ")", "return", "false", ";", "auto", "&", "TM", "=", "TPC", "->", "getTM", "<", "X86TargetMachine", ">", "(", ")", ";", "ST", "=", "TM", ".", "getSubtargetImpl", "(", "F", ")", ";", "DL", "=", "&", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "auto", "&", "BB", ":", "F", ")", "{", "for", "(", "auto", "&", "I", ":", "BB", ")", "{", "auto", "*", "EE", "=", "dyn_cast", "<", "ExtractElementInst", ">", "(", "&", "I", ")", ";", "if", "(", "!", "EE", ")", "continue", ";", "bool", "ReduceInOneBB", ";", "Value", "*", "Root", "=", "matchAddReduction", "(", "*", "EE", ",", "ReduceInOneBB", ")", ";", "if", "(", "!", "Root", ")", "continue", ";", "SmallVector", "<", "Instruction", "*", ",", "8", ">", "Leaves", ";", "collectLeaves", "(", "Root", ",", "Leaves", ")", ";", "for", "(", "Instruction", "*", "I", ":", "Leaves", ")", "{", "if", "(", "tryMAddReplacement", "(", "I", ",", "ReduceInOneBB", ")", ")", "{", "MadeChange", "=", "true", ";", "continue", ";", "}", "if", "(", "I", "!=", "Root", "&&", "trySADReplacement", "(", "I", ")", ")", "MadeChange", "=", "true", ";", "}", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

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

[]

[ "<s>", "const", "MCExpr", "*", "getSubExpr", "(", ")", "const", "{", "return", "Expr", ";", "}", "</s>" ]

[ "getSubExpr", "-", "Get", "the", "child", "of", "this", "expression", "." ]

[ "Mips" ]

[]

[ "<s>", "void", "btf_ext_init", "(", "void", ")", "{", "btf_ext_info_section", "=", "get_section", "(", "BTF_EXT_INFO_SECTION_NAME", ",", "BTF_EXT_INFO_SECTION_FLAGS", ",", "NULL", ")", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "btf_ext_info_section_label", ",", "BTF_EXT_INFO_SECTION_LABEL", ",", "btf_ext_label_num", "++", ")", ";", "vec_alloc", "(", "bpf_core_sections", ",", "1", ")", ";", "}", "</s>" ]

[ "Initialize", "sections", ",", "labels", ",", "and", "data", "structures", "for", "BTF.ext", "output", "." ]

[ "bpf", "1" ]

[]

[ "<s>", "static", "enum", "attr_op_type", "sched_attr_op_type", "(", "rtx_insn", "*", "insn", ",", "bool", "opx_p", ",", "bool", "address_p", ")", "{", "rtx", "op", ";", "op", "=", "sched_get_operand", "(", "insn", ",", "opx_p", ")", ";", "if", "(", "op", "==", "NULL", ")", "{", "gcc_assert", "(", "!", "reload_completed", ")", ";", "return", "OP_TYPE_RN", ";", "}", "if", "(", "address_p", ")", "return", "sched_address_type", "(", "QImode", ",", "op", ")", ";", "if", "(", "memory_operand", "(", "op", ",", "VOIDmode", ")", ")", "return", "sched_address_type", "(", "GET_MODE", "(", "op", ")", ",", "XEXP", "(", "op", ",", "0", ")", ")", ";", "if", "(", "register_operand", "(", "op", ",", "VOIDmode", ")", ")", "{", "if", "(", "(", "!", "reload_completed", "&&", "FLOAT_MODE_P", "(", "GET_MODE", "(", "op", ")", ")", ")", "||", "(", "reload_completed", "&&", "FP_REG_P", "(", "op", ")", ")", ")", "return", "OP_TYPE_FPN", ";", "return", "OP_TYPE_RN", ";", "}", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", ")", "{", "int", "ival", ";", "ival", "=", "INTVAL", "(", "op", ")", ";", "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_ALUQ_L", ":", "if", "(", "IN_RANGE", "(", "ival", ",", "1", ",", "8", ")", "||", "IN_RANGE", "(", "ival", ",", "-", "8", ",", "-", "1", ")", ")", "return", "OP_TYPE_IMM_Q", ";", "gcc_assert", "(", "!", "reload_completed", ")", ";", "break", ";", "case", "TYPE_MOVEQ_L", ":", "if", "(", "USE_MOVQ", "(", "ival", ")", ")", "return", "OP_TYPE_IMM_Q", ";", "gcc_assert", "(", "!", "reload_completed", ")", ";", "break", ";", "case", "TYPE_MOV3Q_L", ":", "if", "(", "valid_mov3q_const", "(", "ival", ")", ")", "return", "OP_TYPE_IMM_Q", ";", "gcc_assert", "(", "!", "reload_completed", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "IN_RANGE", "(", "ival", ",", "-", "0x8000", ",", "0x7fff", ")", ")", "return", "OP_TYPE_IMM_W", ";", "return", "OP_TYPE_IMM_L", ";", "}", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_DOUBLE", ")", "{", "switch", "(", "GET_MODE", "(", "op", ")", ")", "{", "case", "SFmode", ":", "return", "OP_TYPE_IMM_W", ";", "case", "VOIDmode", ":", "case", "DFmode", ":", "return", "OP_TYPE_IMM_L", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST", "||", "symbolic_operand", "(", "op", ",", "VOIDmode", ")", "||", "LABEL_P", "(", "op", ")", ")", "{", "switch", "(", "GET_MODE", "(", "op", ")", ")", "{", "case", "QImode", ":", "return", "OP_TYPE_IMM_Q", ";", "case", "HImode", ":", "return", "OP_TYPE_IMM_W", ";", "case", "SImode", ":", "return", "OP_TYPE_IMM_L", ";", "default", ":", "if", "(", "symbolic_operand", "(", "m68k_unwrap_symbol", "(", "op", ",", "false", ")", ",", "VOIDmode", ")", ")", "return", "OP_TYPE_IMM_W", ";", "return", "OP_TYPE_IMM_L", ";", "}", "}", "gcc_assert", "(", "!", "reload_completed", ")", ";", "if", "(", "FLOAT_MODE_P", "(", "GET_MODE", "(", "op", ")", ")", ")", "return", "OP_TYPE_FPN", ";", "return", "OP_TYPE_RN", ";", "}", "</s>" ]

[ "Return", "type", "of", "INSN", "'s", "operand", "X", "(", "if", "OPX_P", ")", "or", "operand", "Y", "(", "if", "!", "OPX_P", ")", ".", "If", "ADDRESS_P", "is", "true", ",", "return", "type", "of", "memory", "location", "operand", "refers", "to", "." ]

[ "m68k", "0", "1", "8", "8", "1", "0x8000", "0x7fff" ]

[]

[ "<s>", "static", "rtx", "mips_expand_builtin_compare", "(", "enum", "mips_builtin_type", "builtin_type", ",", "enum", "insn_code", "icode", ",", "enum", "mips_fp_condition", "cond", ",", "rtx", "target", ",", "tree", "arglist", ")", "{", "rtx", "label1", ",", "label2", ",", "if_then_else", ";", "rtx", "pat", ",", "cmp_result", ",", "ops", "[", "MAX_RECOG_OPERANDS", "]", ";", "rtx", "target_if_equal", ",", "target_if_unequal", ";", "int", "cmp_value", ",", "i", ";", "if", "(", "target", "==", "0", "||", "GET_MODE", "(", "target", ")", "!=", "SImode", ")", "target", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "cmp_result", "=", "mips_prepare_builtin_target", "(", "icode", ",", "0", ",", "0", ")", ";", "for", "(", "i", "=", "1", ";", "i", "<", "insn_data", "[", "icode", "]", ".", "n_operands", "-", "1", ";", "i", "++", ")", "ops", "[", "i", "]", "=", "mips_prepare_builtin_arg", "(", "icode", ",", "i", ",", "&", "arglist", ")", ";", "switch", "(", "insn_data", "[", "icode", "]", ".", "n_operands", ")", "{", "case", "4", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "cmp_result", ",", "ops", "[", "1", "]", ",", "ops", "[", "2", "]", ",", "GEN_INT", "(", "cond", ")", ")", ";", "break", ";", "case", "6", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "cmp_result", ",", "ops", "[", "1", "]", ",", "ops", "[", "2", "]", ",", "ops", "[", "3", "]", ",", "ops", "[", "4", "]", ",", "GEN_INT", "(", "cond", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "builtin_type", "==", "MIPS_BUILTIN_CMP_ALL", ")", "{", "cmp_value", "=", "-", "1", ";", "target_if_equal", "=", "const1_rtx", ";", "target_if_unequal", "=", "const0_rtx", ";", "}", "else", "{", "cmp_value", "=", "0", ";", "target_if_equal", "=", "const0_rtx", ";", "target_if_unequal", "=", "const1_rtx", ";", "if", "(", "builtin_type", "==", "MIPS_BUILTIN_CMP_UPPER", ")", "cmp_result", "=", "simplify_gen_subreg", "(", "CCmode", ",", "cmp_result", ",", "CCV2mode", ",", "4", ")", ";", "else", "if", "(", "builtin_type", "==", "MIPS_BUILTIN_CMP_LOWER", ")", "cmp_result", "=", "simplify_gen_subreg", "(", "CCmode", ",", "cmp_result", ",", "CCV2mode", ",", "0", ")", ";", "}", "emit_move_insn", "(", "target", ",", "target_if_equal", ")", ";", "emit_insn", "(", "pat", ")", ";", "label1", "=", "gen_label_rtx", "(", ")", ";", "label2", "=", "gen_label_rtx", "(", ")", ";", "if_then_else", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "gen_rtx_fmt_ee", "(", "NE", ",", "GET_MODE", "(", "cmp_result", ")", ",", "cmp_result", ",", "GEN_INT", "(", "cmp_value", ")", ")", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "label1", ")", ",", "pc_rtx", ")", ";", "emit_jump_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "if_then_else", ")", ")", ";", "emit_jump_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "label2", ")", ")", ")", ";", "emit_barrier", "(", ")", ";", "emit_label", "(", "label1", ")", ";", "emit_move_insn", "(", "target", ",", "target_if_unequal", ")", ";", "emit_label", "(", "label2", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "a", "comparison", "builtin", "of", "type", "BUILTIN_TYPE", ".", "ICODE", "is", "the", "code", "of", "the", "comparison", "instruction", "and", "COND", "is", "the", "condition", "it", "should", "test", ".", "ARGLIST", "is", "the", "list", "of", "function", "arguments", "and", "TARGET", ",", "if", "nonnull", ",", "suggests", "a", "good", "place", "to", "put", "the", "boolean", "result", "." ]

[ "mips", "0", "0", "0", "1", "1", "4", "1", "2", "6", "1", "2", "3", "4", "1", "0", "4", "0" ]

[]

[ "<s>", "bool", "ARMFastISel", "::", "isTypeLegal", "(", "const", "Type", "*", "Ty", ",", "MVT", "&", "VT", ")", "{", "EVT", "evt", "=", "TLI", ".", "getValueType", "(", "Ty", ",", "true", ")", ";", "if", "(", "evt", "==", "MVT", "::", "Other", "||", "!", "evt", ".", "isSimple", "(", ")", ")", "return", "false", ";", "VT", "=", "evt", ".", "getSimpleVT", "(", ")", ";", "return", "TLI", ".", "isTypeLegal", "(", "VT", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "type", "is", "legal", "." ]

[ "ARM", "ARM", "MVT::Other" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isMulAddWithConstProfitable", "(", "const", "SDValue", "&", "AddNode", ",", "const", "SDValue", "&", "ConstNode", ")", "const", "{", "const", "EVT", "VT", "=", "AddNode", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "isVector", "(", ")", "||", "VT", ".", "getScalarSizeInBits", "(", ")", ">", "32", ")", "return", "true", ";", "const", "ConstantSDNode", "*", "C0Node", "=", "cast", "<", "ConstantSDNode", ">", "(", "AddNode", ".", "getOperand", "(", "1", ")", ")", ";", "const", "ConstantSDNode", "*", "C1Node", "=", "cast", "<", "ConstantSDNode", ">", "(", "ConstNode", ")", ";", "const", "int64_t", "C0", "=", "C0Node", "->", "getSExtValue", "(", ")", ";", "APInt", "CA", "=", "C0Node", "->", "getAPIntValue", "(", ")", "*", "C1Node", "->", "getAPIntValue", "(", ")", ";", "if", "(", "!", "isLegalAddImmediate", "(", "C0", ")", "||", "isLegalAddImmediate", "(", "CA", ".", "getSExtValue", "(", ")", ")", ")", "return", "true", ";", "if", "(", "ConstantMaterializationCost", "(", "(", "unsigned", ")", "CA", ".", "getZExtValue", "(", ")", ",", "Subtarget", ")", ">", "1", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "may", "be", "profitable", "to", "transform", "(", "mul", "(", "add", "x", ",", "c1", ")", ",", "c2", ")", "-", ">", "(", "add", "(", "mul", "x", ",", "c2", ")", ",", "c1", "*", "c2", ")", "." ]

[ "ARM", "ARM", "32", "1", "1" ]

[]

[ "<s>", "unsigned", "getOffsetReg", "(", ")", "const", "{", "return", "OffsetReg", ";", "}", "</s>" ]

[ "Get", "the", "offset", "register", "of", "the", "pointer", "value", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "MF", ".", "hasEHFunclets", "(", ")", ")", "return", "true", ";", "if", "(", "MFI", ".", "hasCalls", "(", ")", "&&", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", ")", "return", "true", ";", "if", "(", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", "||", "MFI", ".", "hasStackMap", "(", ")", "||", "MFI", ".", "hasPatchPoint", "(", ")", "||", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ")", "return", "true", ";", "if", "(", "!", "MFI", ".", "isMaxCallFrameSizeComputed", "(", ")", "||", "MFI", ".", "getMaxCallFrameSize", "(", ")", ">", "DefaultSafeSPDisplacement", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "xstormy16_below100_symbol", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "return", "(", "SYMBOL_REF_FLAGS", "(", "x", ")", "&", "SYMBOL_FLAG_XSTORMY16_BELOW100", ")", "!=", "0", ";", "if", "(", "CONST_INT_P", "(", "x", ")", ")", "{", "HOST_WIDE_INT", "i", "=", "INTVAL", "(", "x", ")", ";", "if", "(", "(", "i", ">=", "0x0000", "&&", "i", "<=", "0x00ff", ")", "||", "(", "i", ">=", "0x7f00", "&&", "i", "<=", "0x7fff", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Predicate", "for", "symbols", "and", "addresses", "that", "reflect", "special", "8-bit", "addressing", "." ]

[ "stormy16", "0", "1", "0", "0", "0x0000", "0x00ff", "0x7f00", "0x7fff", "1", "0" ]

[]

[ "<s>", "static", "bool", "arc_must_save_register", "(", "int", "regno", ",", "struct", "function", "*", "func", ")", "{", "unsigned", "int", "fn_type", "=", "arc_compute_function_type", "(", "func", ")", ";", "bool", "irq_auto_save_p", "=", "(", "(", "irq_ctrl_saved", ".", "irq_save_last_reg", ">=", "regno", ")", "&&", "ARC_AUTO_IRQ_P", "(", "fn_type", ")", ")", ";", "bool", "firq_auto_save_p", "=", "ARC_FAST_INTERRUPT_P", "(", "fn_type", ")", ";", "switch", "(", "rgf_banked_register_count", ")", "{", "case", "4", ":", "firq_auto_save_p", "&=", "(", "regno", "<", "4", ")", ";", "break", ";", "case", "8", ":", "firq_auto_save_p", "&=", "(", "(", "regno", "<", "4", ")", "||", "(", "(", "regno", ">", "11", ")", "&&", "(", "regno", "<", "16", ")", ")", ")", ";", "break", ";", "case", "16", ":", "firq_auto_save_p", "&=", "(", "(", "regno", "<", "4", ")", "||", "(", "(", "regno", ">", "9", ")", "&&", "(", "regno", "<", "16", ")", ")", "||", "(", "(", "regno", ">", "25", ")", "&&", "(", "regno", "<", "29", ")", ")", "||", "(", "(", "regno", ">", "29", ")", "&&", "(", "regno", "<", "32", ")", ")", ")", ";", "break", ";", "case", "32", ":", "firq_auto_save_p", "&=", "(", "regno", "!=", "29", ")", "&&", "(", "regno", "<", "32", ")", ";", "break", ";", "default", ":", "firq_auto_save_p", "=", "false", ";", "break", ";", "}", "if", "(", "(", "regno", ")", "!=", "RETURN_ADDR_REGNUM", "&&", "(", "regno", ")", "!=", "FRAME_POINTER_REGNUM", "&&", "df_regs_ever_live_p", "(", "regno", ")", "&&", "(", "!", "call_used_regs", "[", "regno", "]", "||", "ARC_INTERRUPT_P", "(", "fn_type", ")", ")", "&&", "!", "irq_auto_save_p", "&&", "!", "firq_auto_save_p", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Tell", "prologue", "and", "epilogue", "if", "register", "REGNO", "should", "be", "saved", "/", "restored", ".", "The", "return", "address", ",", "stack", "pointer", "and", "frame", "pointer", "are", "treated", "separately", ".", "Do", "n't", "consider", "them", "here", ".", "Addition", "for", "pic", ":", "The", "gp", "register", "needs", "to", "be", "saved", "if", "the", "current", "function", "changes", "it", "to", "access", "gotoff", "variables", ".", "FIXME", ":", "This", "will", "not", "be", "needed", "if", "we", "used", "some", "arbitrary", "register", "instead", "of", "r26", "." ]

[ "arc", "4", "4", "8", "4", "11", "16", "16", "4", "9", "16", "25", "29", "29", "32", "32", "29", "32" ]

[]

[ "<s>", "bool", "WaitcntBrackets", "::", "merge", "(", "const", "WaitcntBrackets", "&", "Other", ")", "{", "bool", "StrictDom", "=", "false", ";", "for", "(", "auto", "T", ":", "inst_counter_types", "(", ")", ")", "{", "const", "bool", "OldOutOfOrder", "=", "counterOutOfOrder", "(", "T", ")", ";", "const", "uint32_t", "OldEvents", "=", "PendingEvents", "&", "WaitEventMaskForInst", "[", "T", "]", ";", "const", "uint32_t", "OtherEvents", "=", "Other", ".", "PendingEvents", "&", "WaitEventMaskForInst", "[", "T", "]", ";", "if", "(", "OtherEvents", "&", "~", "OldEvents", ")", "StrictDom", "=", "true", ";", "if", "(", "Other", ".", "MixedPendingEvents", "[", "T", "]", "||", "(", "OldEvents", "&&", "OtherEvents", "&&", "OldEvents", "!=", "OtherEvents", ")", ")", "MixedPendingEvents", "[", "T", "]", "=", "true", ";", "PendingEvents", "|=", "OtherEvents", ";", "const", "uint32_t", "MyPending", "=", "ScoreUBs", "[", "T", "]", "-", "ScoreLBs", "[", "T", "]", ";", "const", "uint32_t", "OtherPending", "=", "Other", ".", "ScoreUBs", "[", "T", "]", "-", "Other", ".", "ScoreLBs", "[", "T", "]", ";", "MergeInfo", "M", ";", "M", ".", "OldLB", "=", "ScoreLBs", "[", "T", "]", ";", "M", ".", "OtherLB", "=", "Other", ".", "ScoreLBs", "[", "T", "]", ";", "M", ".", "MyShift", "=", "OtherPending", ">", "MyPending", "?", "OtherPending", "-", "MyPending", ":", "0", ";", "M", ".", "OtherShift", "=", "ScoreUBs", "[", "T", "]", "-", "Other", ".", "ScoreUBs", "[", "T", "]", "+", "M", ".", "MyShift", ";", "const", "uint32_t", "NewUB", "=", "ScoreUBs", "[", "T", "]", "+", "M", ".", "MyShift", ";", "if", "(", "NewUB", "<", "ScoreUBs", "[", "T", "]", ")", "report_fatal_error", "(", "\"waitcnt score overflow\"", ")", ";", "ScoreUBs", "[", "T", "]", "=", "NewUB", ";", "ScoreLBs", "[", "T", "]", "=", "std", "::", "min", "(", "M", ".", "OldLB", "+", "M", ".", "MyShift", ",", "M", ".", "OtherLB", "+", "M", ".", "OtherShift", ")", ";", "StrictDom", "|=", "mergeScore", "(", "M", ",", "LastFlat", "[", "T", "]", ",", "Other", ".", "LastFlat", "[", "T", "]", ")", ";", "bool", "RegStrictDom", "=", "false", ";", "for", "(", "int", "J", "=", "0", ",", "E", "=", "std", "::", "max", "(", "getMaxVGPR", "(", ")", ",", "Other", ".", "getMaxVGPR", "(", ")", ")", "+", "1", ";", "J", "!=", "E", ";", "J", "++", ")", "{", "RegStrictDom", "|=", "mergeScore", "(", "M", ",", "VgprScores", "[", "T", "]", "[", "J", "]", ",", "Other", ".", "VgprScores", "[", "T", "]", "[", "J", "]", ")", ";", "}", "if", "(", "T", "==", "LGKM_CNT", ")", "{", "for", "(", "int", "J", "=", "0", ",", "E", "=", "std", "::", "max", "(", "getMaxSGPR", "(", ")", ",", "Other", ".", "getMaxSGPR", "(", ")", ")", "+", "1", ";", "J", "!=", "E", ";", "J", "++", ")", "{", "RegStrictDom", "|=", "mergeScore", "(", "M", ",", "SgprScores", "[", "J", "]", ",", "Other", ".", "SgprScores", "[", "J", "]", ")", ";", "}", "}", "if", "(", "RegStrictDom", "&&", "!", "OldOutOfOrder", ")", "StrictDom", "=", "true", ";", "}", "return", "StrictDom", ";", "}", "</s>" ]

[ "Merge", "target", "triples", "." ]

[ "AMDGPU", "0", "\"waitcnt score overflow\"", "0", "1", "0", "1" ]

[]

[ "<s>", "SDValue", "ARMSelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "Align", "Alignment", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "const", "ARMSubtarget", "&", "Subtarget", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "ConstantSDNode", "*", "ConstantSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ";", "if", "(", "Subtarget", ".", "hasMVEIntegerOps", "(", ")", "&&", "shouldGenerateInlineTPLoop", "(", "Subtarget", ",", "DAG", ",", "ConstantSize", ",", "Alignment", ",", "false", ")", ")", "{", "Src", "=", "DAG", ".", "getSplatBuildVector", "(", "MVT", "::", "v16i8", ",", "dl", ",", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i8", ",", "Src", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ARMISD", "::", "MEMSETLOOP", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Dst", ",", "Src", ",", "DAG", ".", "getZExtOrTrunc", "(", "Size", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "}", "return", "EmitSpecializedLibcall", "(", "DAG", ",", "dl", ",", "Chain", ",", "Dst", ",", "Src", ",", "Size", ",", "Alignment", ".", "value", "(", ")", ",", "RTLIB", "::", "MEMSET", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memset", "." ]

[ "ARM", "ARM", "ARM", "ARM", "MVT::v16i8", "ISD::TRUNCATE", "MVT::i8", "ARMISD::MEMSETLOOP", "MVT::Other", "MVT::i32" ]

[]

[ "<s>", "static", "tree", "neon_dereference_pointer", "(", "tree", "exp", ",", "tree", "type", ",", "machine_mode", "mem_mode", ",", "machine_mode", "reg_mode", ",", "machine_mode", "vector_mode", ")", "{", "HOST_WIDE_INT", "reg_size", ",", "vector_size", ",", "nvectors", ",", "nelems", ";", "tree", "elem_type", ",", "upper_bound", ",", "array_type", ";", "reg_size", "=", "GET_MODE_SIZE", "(", "reg_mode", ")", ";", "vector_size", "=", "GET_MODE_SIZE", "(", "vector_mode", ")", ";", "gcc_assert", "(", "reg_size", "%", "vector_size", "==", "0", ")", ";", "nvectors", "=", "reg_size", "/", "vector_size", ";", "gcc_assert", "(", "POINTER_TYPE_P", "(", "type", ")", ")", ";", "elem_type", "=", "TREE_TYPE", "(", "type", ")", ";", "if", "(", "mem_mode", "==", "reg_mode", ")", "nelems", "=", "vector_size", "*", "nvectors", "/", "int_size_in_bytes", "(", "elem_type", ")", ";", "else", "nelems", "=", "nvectors", ";", "upper_bound", "=", "build_int_cst", "(", "size_type_node", ",", "nelems", "-", "1", ")", ";", "array_type", "=", "build_array_type", "(", "elem_type", ",", "build_index_type", "(", "upper_bound", ")", ")", ";", "return", "fold_build2", "(", "MEM_REF", ",", "array_type", ",", "exp", ",", "build_int_cst", "(", "build_pointer_type", "(", "array_type", ")", ",", "0", ")", ")", ";", "}", "</s>" ]

[ "EXP", "is", "a", "pointer", "argument", "to", "a", "Neon", "load", "or", "store", "intrinsic", ".", "Derive", "and", "return", "an", "expression", "for", "the", "accessed", "memory", ".", "The", "intrinsic", "function", "operates", "on", "a", "block", "of", "registers", "that", "has", "mode", "REG_MODE", ".", "This", "block", "contains", "vectors", "of", "type", "TYPE_MODE", ".", "The", "function", "references", "the", "memory", "at", "EXP", "of", "type", "TYPE", "and", "in", "mode", "MEM_MODE", ";", "this", "mode", "may", "be", "BLKmode", "if", "no", "more", "suitable", "mode", "is", "available", "." ]

[ "arm", "0", "1", "0" ]

[]

[ "<s>", "bool", "HexagonMCInstrInfo", "::", "isDuplexPair", "(", "MCInst", "const", "&", "MIa", ",", "MCInst", "const", "&", "MIb", ")", "{", "unsigned", "MIaG", "=", "getDuplexCandidateGroup", "(", "MIa", ")", ",", "MIbG", "=", "getDuplexCandidateGroup", "(", "MIb", ")", ";", "return", "(", "isDuplexPairMatch", "(", "MIaG", ",", "MIbG", ")", "||", "isDuplexPairMatch", "(", "MIbG", ",", "MIaG", ")", ")", ";", "}", "</s>" ]

[ "Symmetrical", ".", "See", "if", "these", "two", "instructions", "are", "fit", "for", "duplex", "pair", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "legalizeOperandsVOP2", "(", "MachineRegisterInfo", "&", "MRI", ",", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "InstrDesc", "=", "get", "(", "Opc", ")", ";", "int", "Src1Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "MachineOperand", "&", "Src1", "=", "MI", ".", "getOperand", "(", "Src1Idx", ")", ";", "bool", "HasImplicitSGPR", "=", "findImplicitSGPRRead", "(", "MI", ")", "!=", "AMDGPU", "::", "NoRegister", ";", "if", "(", "HasImplicitSGPR", ")", "{", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "MachineOperand", "&", "Src0", "=", "MI", ".", "getOperand", "(", "Src0Idx", ")", ";", "if", "(", "Src0", ".", "isReg", "(", ")", "&&", "RI", ".", "isSGPRReg", "(", "MRI", ",", "Src0", ".", "getReg", "(", ")", ")", ")", "legalizeOpWithMove", "(", "MI", ",", "Src0Idx", ")", ";", "}", "if", "(", "isLegalRegOperand", "(", "MRI", ",", "InstrDesc", ".", "OpInfo", "[", "Src1Idx", "]", ",", "Src1", ")", ")", "return", ";", "if", "(", "Opc", "==", "AMDGPU", "::", "V_READLANE_B32", "&&", "Src1", ".", "isReg", "(", ")", "&&", "RI", ".", "isVGPR", "(", "MRI", ",", "Src1", ".", "getReg", "(", ")", ")", ")", "{", "unsigned", "Reg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_READFIRSTLANE_B32", ")", ",", "Reg", ")", ".", "add", "(", "Src1", ")", ";", "Src1", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "return", ";", "}", "if", "(", "HasImplicitSGPR", "||", "!", "MI", ".", "isCommutable", "(", ")", ")", "{", "legalizeOpWithMove", "(", "MI", ",", "Src1Idx", ")", ";", "return", ";", "}", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "MachineOperand", "&", "Src0", "=", "MI", ".", "getOperand", "(", "Src0Idx", ")", ";", "if", "(", "(", "!", "Src1", ".", "isImm", "(", ")", "&&", "!", "Src1", ".", "isReg", "(", ")", ")", "||", "!", "isLegalRegOperand", "(", "MRI", ",", "InstrDesc", ".", "OpInfo", "[", "Src1Idx", "]", ",", "Src0", ")", ")", "{", "legalizeOpWithMove", "(", "MI", ",", "Src1Idx", ")", ";", "return", ";", "}", "int", "CommutedOpc", "=", "commuteOpcode", "(", "MI", ")", ";", "if", "(", "CommutedOpc", "==", "-", "1", ")", "{", "legalizeOpWithMove", "(", "MI", ",", "Src1Idx", ")", ";", "return", ";", "}", "MI", ".", "setDesc", "(", "get", "(", "CommutedOpc", ")", ")", ";", "unsigned", "Src0Reg", "=", "Src0", ".", "getReg", "(", ")", ";", "unsigned", "Src0SubReg", "=", "Src0", ".", "getSubReg", "(", ")", ";", "bool", "Src0Kill", "=", "Src0", ".", "isKill", "(", ")", ";", "if", "(", "Src1", ".", "isImm", "(", ")", ")", "Src0", ".", "ChangeToImmediate", "(", "Src1", ".", "getImm", "(", ")", ")", ";", "else", "if", "(", "Src1", ".", "isReg", "(", ")", ")", "{", "Src0", ".", "ChangeToRegister", "(", "Src1", ".", "getReg", "(", ")", ",", "false", ",", "false", ",", "Src1", ".", "isKill", "(", ")", ")", ";", "Src0", ".", "setSubReg", "(", "Src1", ".", "getSubReg", "(", ")", ")", ";", "}", "else", "llvm_unreachable", "(", "\"Should only have register or immediate operands\"", ")", ";", "Src1", ".", "ChangeToRegister", "(", "Src0Reg", ",", "false", ",", "false", ",", "Src0Kill", ")", ";", "Src1", ".", "setSubReg", "(", "Src0SubReg", ")", ";", "}", "</s>" ]

[ "Legalize", "operands", "in", "MI", "by", "either", "commuting", "it", "or", "inserting", "a", "copy", "of", "src1", "." ]

[ "AMDGPU", "SI", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::NoRegister", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::V_READLANE_B32", "AMDGPU::SReg_32_XM0RegClass", "AMDGPU::V_READFIRSTLANE_B32", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "\"Should only have register or immediate operands\"" ]

[]

[ "<s>", "void", "MSP430RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "MSP430FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "MSP430", "::", "R4", ":", "MSP430", "::", "SP", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "Offset", "+=", "2", ";", "if", "(", "!", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "else", "Offset", "+=", "2", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "MSP430", "::", "ADDframe", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "if", "(", "Offset", "==", "0", ")", "return", ";", "Register", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "Offset", "<", "0", ")", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "-", "Offset", ")", ";", "else", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "Offset", ")", ";", "return", ";", "}", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "0", "\"Unexpected\"", "MSP430", "MSP430::R4", "MSP430::SP", "2", "2", "1", "MSP430::ADDframe", "MSP430::MOV16rr", "0", "0", "0", "MSP430::SUB16ri", "MSP430::ADD16ri", "1" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "for", "(", "MachineFunction", "::", "iterator", "bItr", "=", "MF", ".", "begin", "(", ")", ";", "bItr", "!=", "MF", ".", "end", "(", ")", ";", "++", "bItr", ")", "{", "bool", "foundTestFunc", "=", "false", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "iItr", "=", "bItr", "->", "begin", "(", ")", ";", "iItr", "!=", "bItr", "->", "end", "(", ")", ";", "++", "iItr", ")", "{", "if", "(", "foundTestFunc", ")", "{", "errs", "(", ")", "<<", "*", "iItr", "<<", "\"\\n\"", ";", "}", "if", "(", "iItr", "->", "isCall", "(", ")", ")", "{", "MachineOperand", "MO", "=", "iItr", "->", "getOperand", "(", "0", ")", ";", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "std", "::", "string", "funcName", "=", "GV", "->", "getName", "(", ")", ";", "if", "(", "!", "compareCallToFunctionNames", "(", "funcName", ")", ")", "{", "foundTestFunc", "=", "false", ";", "}", "else", "{", "foundTestFunc", "=", "true", ";", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "\"\\n\"", "0" ]

[]

[ "<s>", "rtx", "arm_gen_compare_reg", "(", "rtx_code", "code", ",", "rtx", "x", ",", "rtx", "y", ",", "rtx", "scratch", ")", "{", "if", "(", "GET_MODE", "(", "x", ")", "==", "DImode", "||", "GET_MODE", "(", "y", ")", "==", "DImode", ")", "return", "arm_gen_dicompare_reg", "(", "code", ",", "x", ",", "y", ",", "scratch", ")", ";", "machine_mode", "mode", "=", "SELECT_CC_MODE", "(", "code", ",", "x", ",", "y", ")", ";", "rtx", "cc_reg", "=", "gen_rtx_REG", "(", "mode", ",", "CC_REGNUM", ")", ";", "if", "(", "mode", "==", "CC_RSBmode", ")", "{", "if", "(", "!", "scratch", ")", "scratch", "=", "gen_rtx_SCRATCH", "(", "SImode", ")", ";", "emit_insn", "(", "gen_rsb_imm_compare_scratch", "(", "scratch", ",", "GEN_INT", "(", "~", "UINTVAL", "(", "x", ")", ")", ",", "y", ")", ")", ";", "}", "else", "emit_set_insn", "(", "cc_reg", ",", "gen_rtx_COMPARE", "(", "mode", ",", "x", ",", "y", ")", ")", ";", "return", "cc_reg", ";", "}", "</s>" ]

[ "X", "and", "Y", "are", "two", "things", "to", "compare", "using", "CODE", ".", "Emit", "the", "compare", "insn", "and", "return", "the", "rtx", "for", "register", "0", "in", "the", "proper", "mode", ".", "FP", "means", "this", "is", "a", "floating", "point", "compare", ":", "I", "do", "n't", "think", "that", "it", "is", "needed", "on", "the", "arm", "." ]

[ "arm" ]

[]

[ "<s>", "static", "void", "arm_output_fldmx", "(", "FILE", "*", "stream", ",", "unsigned", "int", "base", ",", "int", "reg", ",", "int", "count", ")", "{", "int", "i", ";", "if", "(", "count", "==", "2", "&&", "!", "arm_arch6", ")", "{", "if", "(", "reg", "==", "15", ")", "reg", "--", ";", "count", "++", ";", "}", "fputc", "(", "'\\t'", ",", "stream", ")", ";", "asm_fprintf", "(", "stream", ",", "\"fldmfdx\\t%r!, {\"", ",", "base", ")", ";", "for", "(", "i", "=", "reg", ";", "i", "<", "reg", "+", "count", ";", "i", "++", ")", "{", "if", "(", "i", ">", "reg", ")", "fputs", "(", "\", \"", ",", "stream", ")", ";", "asm_fprintf", "(", "stream", ",", "\"d%d\"", ",", "i", ")", ";", "}", "fputs", "(", "\"}\\n\"", ",", "stream", ")", ";", "}", "</s>" ]

[ "Output", "a", "FLDMX", "instruction", "to", "STREAM", ".", "BASE", "if", "the", "register", "containing", "the", "address", ".", "REG", "and", "COUNT", "specify", "the", "register", "range", ".", "Extra", "registers", "may", "be", "added", "to", "avoid", "hardware", "bugs", "." ]

[ "arm", "2", "15", "\"fldmfdx\\t%r!, {\"", "\", \"", "\"d%d\"", "\"}\\n\"" ]

[]

[ "<s>", "static", "bool", "nvptx_return_in_memory", "(", "const_tree", "type", ",", "const_tree", ")", "{", "return", "pass_in_memory", "(", "TYPE_MODE", "(", "type", ")", ",", "type", ",", "true", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_RETURN_IN_MEMORY", "." ]

[ "nvptx" ]

[]

[ "<s>", "static", "const", "char", "*", "arm_identify_fpu_from_isa", "(", "sbitmap", "isa", ")", "{", "auto_sbitmap", "fpubits", "(", "isa_num_bits", ")", ";", "auto_sbitmap", "cand_fpubits", "(", "isa_num_bits", ")", ";", "bitmap_and", "(", "fpubits", ",", "isa", ",", "isa_all_fpubits_internal", ")", ";", "if", "(", "bitmap_empty_p", "(", "fpubits", ")", ")", "return", "\"softvfp\"", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "TARGET_FPU_auto", ";", "i", "++", ")", "{", "arm_initialize_isa", "(", "cand_fpubits", ",", "all_fpus", "[", "i", "]", ".", "isa_bits", ")", ";", "if", "(", "bitmap_equal_p", "(", "fpubits", ",", "cand_fpubits", ")", ")", "return", "all_fpus", "[", "i", "]", ".", "name", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Match", "an", "ISA", "feature", "bitmap", "to", "a", "named", "FPU", ".", "We", "always", "use", "the", "first", "entry", "that", "exactly", "matches", "the", "feature", "set", ",", "so", "that", "we", "effectively", "canonicalize", "the", "FPU", "name", "for", "the", "assembler", "." ]

[ "arm", "\"softvfp\"", "0" ]

[]

[ "<s>", "unsigned", "SparcCodeEmitter", "::", "getBranchTargetOpValue", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "opIdx", ")", "const", "{", "const", "MachineOperand", "MO", "=", "MI", ".", "getOperand", "(", "opIdx", ")", ";", "return", "getMachineOpValue", "(", "MI", ",", "MO", ")", ";", "}", "</s>" ]

[ "getBranchTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]

[ "Sparc", "Sparc" ]

[]

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

[ "Do", "not", "merge", "vector", "stores", "after", "legalization", "because", "that", "may", "conflict", "with", "x86-specific", "store", "splitting", "optimizations", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "Mips16TargetLowering", "::", "getOpndList", "(", "SmallVectorImpl", "<", "SDValue", ">", "&", "Ops", ",", "std", "::", "deque", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">", ">", "&", "RegsToPass", ",", "bool", "IsPICCall", ",", "bool", "GlobalOrExternal", ",", "bool", "InternalLinkage", ",", "CallLoweringInfo", "&", "CLI", ",", "SDValue", "Callee", ",", "SDValue", "Chain", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "const", "char", "*", "Mips16HelperFunction", "=", "0", ";", "bool", "NeedMips16Helper", "=", "false", ";", "if", "(", "getTargetMachine", "(", ")", ".", "Options", ".", "UseSoftFloat", "&&", "Subtarget", "->", "inMips16HardFloat", "(", ")", ")", "{", "bool", "LookupHelper", "=", "true", ";", "if", "(", "ExternalSymbolSDNode", "*", "S", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "CLI", ".", "Callee", ")", ")", "{", "Mips16Libcall", "Find", "=", "{", "RTLIB", "::", "UNKNOWN_LIBCALL", ",", "S", "->", "getSymbol", "(", ")", "}", ";", "if", "(", "std", "::", "binary_search", "(", "HardFloatLibCalls", ",", "array_endof", "(", "HardFloatLibCalls", ")", ",", "Find", ")", ")", "LookupHelper", "=", "false", ";", "}", "else", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "CLI", ".", "Callee", ")", ")", "{", "Mips16Libcall", "Find", "=", "{", "RTLIB", "::", "UNKNOWN_LIBCALL", ",", "G", "->", "getGlobal", "(", ")", "->", "getName", "(", ")", ".", "data", "(", ")", "}", ";", "if", "(", "std", "::", "binary_search", "(", "HardFloatLibCalls", ",", "array_endof", "(", "HardFloatLibCalls", ")", ",", "Find", ")", ")", "LookupHelper", "=", "false", ";", "}", "if", "(", "LookupHelper", ")", "Mips16HelperFunction", "=", "getMips16HelperFunction", "(", "CLI", ".", "RetTy", ",", "CLI", ".", "Args", ",", "NeedMips16Helper", ")", ";", "}", "SDValue", "JumpTarget", "=", "Callee", ";", "if", "(", "IsPICCall", "||", "!", "GlobalOrExternal", ")", "{", "unsigned", "V0Reg", "=", "Mips", "::", "V0", ";", "if", "(", "NeedMips16Helper", ")", "{", "RegsToPass", ".", "push_front", "(", "std", "::", "make_pair", "(", "V0Reg", ",", "Callee", ")", ")", ";", "JumpTarget", "=", "DAG", ".", "getExternalSymbol", "(", "Mips16HelperFunction", ",", "getPointerTy", "(", ")", ")", ";", "JumpTarget", "=", "getAddrGlobal", "(", "JumpTarget", ",", "DAG", ",", "MipsII", "::", "MO_GOT", ")", ";", "}", "else", "RegsToPass", ".", "push_front", "(", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "T9", ",", "Callee", ")", ")", ";", "}", "Ops", ".", "push_back", "(", "JumpTarget", ")", ";", "MipsTargetLowering", "::", "getOpndList", "(", "Ops", ",", "RegsToPass", ",", "IsPICCall", ",", "GlobalOrExternal", ",", "InternalLinkage", ",", "CLI", ",", "Callee", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "0", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::V0", "Mips", "Mips", "MipsII::MO_GOT", "Mips::T9", "Mips" ]

[]

[ "<s>", "SDValue", "PIC16TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "NumRet", "=", "Outs", ".", "size", "(", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "std", "::", "string", "FuncName", "=", "F", "->", "getName", "(", ")", ";", "const", "char", "*", "tmpName", "=", "ESNames", "::", "createESName", "(", "PAN", "::", "getFrameLabel", "(", "FuncName", ")", ")", ";", "SDValue", "ES", "=", "DAG", ".", "getTargetExternalSymbol", "(", "tmpName", ",", "MVT", "::", "i8", ")", ";", "SDValue", "BS", "=", "DAG", ".", "getConstant", "(", "1", ",", "MVT", "::", "i8", ")", ";", "SDValue", "RetVal", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "NumRet", ";", "++", "i", ")", "{", "RetVal", "=", "OutVals", "[", "i", "]", ";", "Chain", "=", "DAG", ".", "getNode", "(", "PIC16ISD", "::", "PIC16Store", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "RetVal", ",", "ES", ",", "BS", ",", "DAG", ".", "getConstant", "(", "i", ",", "MVT", "::", "i8", ")", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "PIC16ISD", "::", "RET", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "PIC16", "PIC16", "ISD::OutputArg", "MVT::i8", "1", "MVT::i8", "0", "PIC16ISD::PIC16Store", "MVT::Other", "MVT::i8", "PIC16ISD::RET", "MVT::Other" ]

[]

[ "<s>", "unsigned", "PPCFastISel", "::", "fastMaterializeAlloca", "(", "const", "AllocaInst", "*", "AI", ")", "{", "if", "(", "!", "FuncInfo", ".", "StaticAllocaMap", ".", "count", "(", "AI", ")", ")", "return", "0", ";", "MVT", "VT", ";", "if", "(", "!", "isLoadTypeLegal", "(", "AI", "->", "getType", "(", ")", ",", "VT", ")", ")", "return", "0", ";", "DenseMap", "<", "const", "AllocaInst", "*", ",", "int", ">", "::", "iterator", "SI", "=", "FuncInfo", ".", "StaticAllocaMap", ".", "find", "(", "AI", ")", ";", "if", "(", "SI", "!=", "FuncInfo", ".", "StaticAllocaMap", ".", "end", "(", ")", ")", "{", "Register", "ResultReg", "=", "createResultReg", "(", "&", "PPC", "::", "G8RC_and_G8RC_NOX0RegClass", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "PPC", "::", "ADDI8", ")", ",", "ResultReg", ")", ".", "addFrameIndex", "(", "SI", "->", "second", ")", ".", "addImm", "(", "0", ")", ";", "return", "ResultReg", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Emit", "an", "alloca", "address", "in", "a", "register", "using", "target-specific", "logic", "." ]

[ "PowerPC", "PPC", "0", "0", "PPC::G8RC_and_G8RC_NOX0RegClass", "PPC::ADDI8", "0", "0" ]

[]

[ "<s>", "bool", "FISCAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ";", "case", "'X'", ":", "if", "(", "(", "MO", ".", "getType", "(", ")", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "O", "<<", "\"0x\"", "<<", "StringRef", "(", "utohexstr", "(", "MO", ".", "getImm", "(", ")", ")", ")", ".", "lower", "(", ")", ";", "return", "false", ";", "case", "'x'", ":", "if", "(", "(", "MO", ".", "getType", "(", ")", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "O", "<<", "\"0x\"", "<<", "StringRef", "(", "utohexstr", "(", "MO", ".", "getImm", "(", ")", "&", "0xffff", ")", ")", ".", "lower", "(", ")", ";", "return", "false", ";", "case", "'d'", ":", "if", "(", "(", "MO", ".", "getType", "(", ")", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "O", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "'m'", ":", "if", "(", "(", "MO", ".", "getType", "(", ")", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "O", "<<", "MO", ".", "getImm", "(", ")", "-", "1", ";", "return", "false", ";", "case", "'z'", ":", "{", "if", "(", "MO", ".", "getType", "(", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "int64_t", "Val", "=", "MO", ".", "getImm", "(", ")", ";", "if", "(", "Val", ")", "O", "<<", "Val", ";", "else", "O", "<<", "\"xzr\"", ";", "return", "false", ";", "}", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "FISC", "FISC", "0", "1", "0", "0", "\"0x\"", "\"0x\"", "0xffff", "1", "\"xzr\"" ]

[]

[ "<s>", "unsigned", "LanaiInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Lanai", "::", "SW_RI", ")", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "Lanai", "Lanai", "Lanai::SW_RI", "0", "1", "1", "0", "0", "2", "0" ]

[]

[ "<s>", "bool", "shouldSplitFunctionArgumentsAsLittleEndian", "(", "const", "DataLayout", "&", "DL", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "For", "most", "targets", ",", "an", "LLVM", "type", "must", "be", "broken", "down", "into", "multiple", "smaller", "types", "." ]

[ "AVR" ]

[]

[ "<s>", "unsigned", "MBlazeRegisterInfo", "::", "getRARegister", "(", ")", "const", "{", "return", "MBlaze", "::", "R15", ";", "}", "</s>" ]

[ "This", "method", "should", "return", "the", "register", "where", "the", "return", "address", "can", "be", "found", "." ]

[ "MBlaze", "MBlaze", "MBlaze::R15" ]

[]

[ "<s>", "static", "int", "pa_reloc_rw_mask", "(", "void", ")", "{", "if", "(", "flag_pic", "||", "(", "TARGET_SOM", "&&", "!", "TARGET_HPUX_11", ")", ")", "return", "3", ";", "return", "TARGET_SOM", "?", "2", ":", "0", ";", "}", "</s>" ]

[ "Implement", "pa_reloc_rw_mask", "." ]

[ "pa", "3", "2", "0" ]

[]

[ "<s>", "const", "MCSection", "*", "X86ELFMCAsmInfo", "::", "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", "." ]

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

[]

[ "<s>", "int", "X86FrameLowering", "::", "mergeSPUpdates", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "bool", "doMergeWithPrevious", ")", "const", "{", "if", "(", "(", "doMergeWithPrevious", "&&", "MBBI", "==", "MBB", ".", "begin", "(", ")", ")", "||", "(", "!", "doMergeWithPrevious", "&&", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", ")", "return", "0", ";", "MachineBasicBlock", "::", "iterator", "PI", "=", "doMergeWithPrevious", "?", "std", "::", "prev", "(", "MBBI", ")", ":", "MBBI", ";", "MachineBasicBlock", "::", "iterator", "NI", "=", "doMergeWithPrevious", "?", "nullptr", ":", "std", "::", "next", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "int", "Offset", "=", "0", ";", "if", "(", "!", "doMergeWithPrevious", "&&", "NI", "!=", "MBB", ".", "end", "(", ")", "&&", "NI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", "{", "return", "Offset", ";", "}", "if", "(", "(", "Opc", "==", "X86", "::", "ADD64ri32", "||", "Opc", "==", "X86", "::", "ADD64ri8", "||", "Opc", "==", "X86", "::", "ADD32ri", "||", "Opc", "==", "X86", "::", "ADD32ri8", ")", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "assert", "(", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", ";", "Offset", "+=", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "!", "doMergeWithPrevious", ")", "MBBI", "=", "NI", ";", "}", "else", "if", "(", "(", "Opc", "==", "X86", "::", "LEA32r", "||", "Opc", "==", "X86", "::", "LEA64_32r", ")", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", "&&", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", "&&", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "1", "&&", "PI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", "==", "X86", "::", "NoRegister", "&&", "PI", "->", "getOperand", "(", "5", ")", ".", "getReg", "(", ")", "==", "X86", "::", "NoRegister", ")", "{", "Offset", "+=", "PI", "->", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", ";", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "!", "doMergeWithPrevious", ")", "MBBI", "=", "NI", ";", "}", "else", "if", "(", "(", "Opc", "==", "X86", "::", "SUB64ri32", "||", "Opc", "==", "X86", "::", "SUB64ri8", "||", "Opc", "==", "X86", "::", "SUB32ri", "||", "Opc", "==", "X86", "::", "SUB32ri8", ")", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "assert", "(", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", ";", "Offset", "-=", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "!", "doMergeWithPrevious", ")", "MBBI", "=", "NI", ";", "}", "return", "Offset", ";", "}", "</s>" ]

[ "Check", "the", "instruction", "before/after", "the", "passed", "instruction", "." ]

[ "X86", "X86", "0", "0", "X86::ADD64ri32", "X86::ADD64ri8", "X86::ADD32ri", "X86::ADD32ri8", "0", "1", "2", "X86::LEA32r", "X86::LEA64_32r", "0", "1", "2", "1", "3", "X86::NoRegister", "5", "X86::NoRegister", "4", "X86::SUB64ri32", "X86::SUB64ri8", "X86::SUB32ri", "X86::SUB32ri8", "0", "1", "2" ]

[]

[ "<s>", "static", "bool", "aarch64_legitimize_address_displacement", "(", "rtx", "*", "disp", ",", "rtx", "*", "off", ",", "machine_mode", "mode", ")", "{", "HOST_WIDE_INT", "offset", "=", "INTVAL", "(", "*", "disp", ")", ";", "HOST_WIDE_INT", "base", "=", "offset", "&", "~", "(", "GET_MODE_SIZE", "(", "mode", ")", "<", "4", "?", "0xfff", ":", "0x3ffc", ")", ";", "if", "(", "mode", "==", "TImode", "||", "mode", "==", "TFmode", "||", "(", "offset", "&", "(", "GET_MODE_SIZE", "(", "mode", ")", "-", "1", ")", ")", "!=", "0", ")", "base", "=", "(", "offset", "+", "0x100", ")", "&", "~", "0x1ff", ";", "*", "off", "=", "GEN_INT", "(", "base", ")", ";", "*", "disp", "=", "GEN_INT", "(", "offset", "-", "base", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Split", "an", "out-of-range", "address", "displacement", "into", "a", "base", "and", "offset", ".", "Use", "4KB", "range", "for", "1-", "and", "2-byte", "accesses", "and", "a", "16KB", "range", "otherwise", "to", "increase", "opportunities", "for", "sharing", "the", "base", "address", "of", "different", "sizes", ".", "For", "unaligned", "accesses", "and", "TI/TF", "mode", "use", "the", "signed", "9-bit", "range", "." ]

[ "aarch64", "4", "0xfff", "0x3ffc", "1", "0", "0x100", "0x1ff" ]

[]

[ "<s>", "const", "MCExpr", "*", "getExpr", "(", ")", "const", "{", "assert", "(", "Kind", "==", "Expression", "&&", "\"Invalid access!\"", ")", ";", "return", "Expr", ".", "Val", ";", "}", "</s>" ]

[ "Implementation", "of", "the", "SCEVPredicate", "interface", "." ]

[ "PowerPC", "\"Invalid access!\"" ]

[]

[ "<s>", "void", "MSP430FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MSP430FI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "const", "MSP430InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MSP430InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "RetOpcode", ")", "{", "case", "MSP430", "::", "RET", ":", "case", "MSP430", "::", "RETI", ":", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Can only insert epilog into returning blocks\"", ")", ";", "}", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "CSSize", "=", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "2", ";", "NumBytes", "=", "FrameSize", "-", "CSSize", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "POP16r", ")", ",", "MSP430", "::", "FPW", ")", ";", "}", "else", "NumBytes", "=", "StackSize", "-", "CSSize", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "std", "::", "prev", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "MSP430", "::", "POP16r", "&&", "!", "PI", "->", "isTerminator", "(", ")", ")", "break", ";", "--", "MBBI", ";", "}", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "FPW", ")", ";", "if", "(", "CSSize", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "CSSize", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "else", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "NumBytes", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430::RET", "MSP430::RETI", "\"Can only insert epilog into returning blocks\"", "MSP430", "0", "2", "MSP430::POP16r", "MSP430::FPW", "MSP430::POP16r", "MSP430::MOV16rr", "MSP430::SPW", "MSP430::FPW", "MSP430::SUB16ri", "MSP430::SPW", "MSP430::SPW", "3", "MSP430::ADD16ri", "MSP430::SPW", "MSP430::SPW", "3" ]

[]

[ "<s>", "tree", "function_resolver", "::", "resolve", "(", ")", "{", "return", "shape", "->", "resolve", "(", "*", "this", ")", ";", "}", "</s>" ]

[ "If", "the", "call", "is", "erroneous", ",", "report", "an", "appropriate", "error", "and", "return", "error_mark_node", ".", "Otherwise", ",", "if", "the", "function", "is", "overloaded", ",", "return", "the", "decl", "of", "the", "non-overloaded", "function", ".", "Return", "NULL_TREE", "otherwise", ",", "indicating", "that", "the", "call", "should", "be", "processed", "in", "the", "normal", "way", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "rtx", "nvptx_gen_wcast", "(", "rtx", "reg", ",", "propagate_mask", "pm", ",", "unsigned", "rep", ",", "wcast_data_t", "*", "data", ")", "{", "rtx", "res", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "reg", ")", ";", "switch", "(", "mode", ")", "{", "case", "BImode", ":", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "start_sequence", "(", ")", ";", "if", "(", "pm", "&", "PM_read", ")", "emit_insn", "(", "gen_sel_truesi", "(", "tmp", ",", "reg", ",", "GEN_INT", "(", "1", ")", ",", "const0_rtx", ")", ")", ";", "emit_insn", "(", "nvptx_gen_wcast", "(", "tmp", ",", "pm", ",", "rep", ",", "data", ")", ")", ";", "if", "(", "pm", "&", "PM_write", ")", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "gen_rtx_NE", "(", "BImode", ",", "tmp", ",", "const0_rtx", ")", ")", ")", ";", "res", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "}", "break", ";", "default", ":", "{", "rtx", "addr", "=", "data", "->", "ptr", ";", "if", "(", "!", "addr", ")", "{", "unsigned", "align", "=", "GET_MODE_ALIGNMENT", "(", "mode", ")", "/", "BITS_PER_UNIT", ";", "if", "(", "align", ">", "worker_bcast_align", ")", "worker_bcast_align", "=", "align", ";", "data", "->", "offset", "=", "(", "data", "->", "offset", "+", "align", "-", "1", ")", "&", "~", "(", "align", "-", "1", ")", ";", "addr", "=", "data", "->", "base", ";", "if", "(", "data", "->", "offset", ")", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "addr", ",", "GEN_INT", "(", "data", "->", "offset", ")", ")", ";", "}", "addr", "=", "gen_rtx_MEM", "(", "mode", ",", "addr", ")", ";", "if", "(", "pm", "==", "PM_read", ")", "res", "=", "gen_rtx_SET", "(", "addr", ",", "reg", ")", ";", "else", "if", "(", "pm", "==", "PM_write", ")", "res", "=", "gen_rtx_SET", "(", "reg", ",", "addr", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "data", "->", "ptr", ")", "{", "start_sequence", "(", ")", ";", "emit_insn", "(", "res", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "data", "->", "ptr", ",", "data", "->", "ptr", ",", "GEN_INT", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "reg", ")", ")", ")", ")", ")", ";", "res", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "}", "else", "rep", "=", "1", ";", "data", "->", "offset", "+=", "rep", "*", "GET_MODE_SIZE", "(", "GET_MODE", "(", "reg", ")", ")", ";", "}", "break", ";", "}", "return", "res", ";", "}", "</s>" ]

[ "Generate", "instruction", "(", "s", ")", "to", "spill", "or", "fill", "register", "REG", "to/from", "the", "worker", "broadcast", "array", ".", "PM", "indicates", "what", "is", "to", "be", "done", ",", "REP", "how", "many", "loop", "iterations", "will", "be", "executed", "(", "0", "for", "not", "a", "loop", ")", "." ]

[ "nvptx", "1", "1", "1", "1" ]

[]

[ "<s>", "static", "bool", "pdp11_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "regno", "<=", "PC_REGNUM", ")", "return", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "<=", "16", "||", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ">=", "32", "&&", "!", "(", "regno", "&", "1", ")", "&&", "!", "FLOAT_MODE_P", "(", "mode", ")", ")", ")", ";", "return", "FLOAT_MODE_P", "(", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_MODE_OK", ".", "On", "the", "pdp", ",", "the", "cpu", "registers", "can", "hold", "any", "mode", "other", "than", "float", "(", "because", "otherwise", "we", "may", "end", "up", "being", "asked", "to", "move", "from", "CPU", "to", "FPU", "register", ",", "which", "is", "n't", "a", "valid", "operation", "on", "the", "PDP11", ")", ".", "For", "CPU", "registers", ",", "check", "alignment", ".", "FPU", "accepts", "SF", "and", "DF", "but", "actually", "holds", "a", "DF", "-", "simplifies", "life", "!" ]

[ "pdp11", "16", "32", "1" ]

[]

[ "<s>", "void", "MSP430FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MSP430FI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "const", "MSP430InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MSP430InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "RetOpcode", ")", "{", "case", "MSP430", "::", "RET", ":", "case", "MSP430", "::", "RETI", ":", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Can only insert epilog into returning blocks\"", ")", ";", "}", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "unsigned", "CSSize", "=", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "2", ";", "NumBytes", "=", "FrameSize", "-", "CSSize", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "POP16r", ")", ",", "MSP430", "::", "FP", ")", ";", "}", "else", "NumBytes", "=", "StackSize", "-", "CSSize", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "std", "::", "prev", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "MSP430", "::", "POP16r", "&&", "!", "PI", "->", "isTerminator", "(", ")", ")", "break", ";", "--", "MBBI", ";", "}", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "FP", ")", ";", "if", "(", "CSSize", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ".", "addImm", "(", "CSSize", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "else", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ".", "addImm", "(", "NumBytes", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430::RET", "MSP430::RETI", "\"Can only insert epilog into returning blocks\"", "MSP430", "0", "2", "MSP430::POP16r", "MSP430::FP", "MSP430::POP16r", "MSP430::MOV16rr", "MSP430::SP", "MSP430::FP", "MSP430::SUB16ri", "MSP430::SP", "MSP430::SP", "3", "MSP430::ADD16ri", "MSP430::SP", "MSP430::SP", "3" ]

[]

[ "<s>", "bool", "VideoCore4PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createVideoCore4ISelDag", "(", "getVideoCore4TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "VideoCore4", "VideoCore4", "VideoCore4", "VideoCore4" ]

[]

[ "<s>", "unsigned", "PPCFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ",", "bool", "UpdateMF", ",", "bool", "UseEstimate", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "UseEstimate", "?", "MFI", ".", "estimateStackSize", "(", "MF", ")", ":", "MFI", ".", "getStackSize", "(", ")", ";", "unsigned", "TargetAlign", "=", "getStackAlignment", "(", ")", ";", "unsigned", "MaxAlign", "=", "MFI", ".", "getMaxAlignment", "(", ")", ";", "unsigned", "AlignMask", "=", "std", "::", "max", "(", "MaxAlign", ",", "TargetAlign", ")", "-", "1", ";", "const", "PPCRegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "LR", "=", "RegInfo", "->", "getRARegister", "(", ")", ";", "bool", "DisableRedZone", "=", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoRedZone", ")", ";", "bool", "CanUseRedZone", "=", "!", "MFI", ".", "hasVarSizedObjects", "(", ")", "&&", "!", "MFI", ".", "adjustsStack", "(", ")", "&&", "!", "MustSaveLR", "(", "MF", ",", "LR", ")", "&&", "!", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ";", "bool", "FitsInRedZone", "=", "FrameSize", "<=", "Subtarget", ".", "getRedZoneSize", "(", ")", ";", "if", "(", "!", "DisableRedZone", "&&", "CanUseRedZone", "&&", "FitsInRedZone", ")", "{", "NumNoNeedForFrame", "++", ";", "if", "(", "UpdateMF", ")", "MFI", ".", "setStackSize", "(", "0", ")", ";", "return", "0", ";", "}", "unsigned", "maxCallFrameSize", "=", "MFI", ".", "getMaxCallFrameSize", "(", ")", ";", "unsigned", "minCallFrameSize", "=", "getLinkageSize", "(", ")", ";", "maxCallFrameSize", "=", "std", "::", "max", "(", "maxCallFrameSize", ",", "minCallFrameSize", ")", ";", "if", "(", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "(", "maxCallFrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "if", "(", "UpdateMF", ")", "MFI", ".", "setMaxCallFrameSize", "(", "maxCallFrameSize", ")", ";", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "(", "FrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "if", "(", "UpdateMF", ")", "MFI", ".", "setStackSize", "(", "FrameSize", ")", ";", "return", "FrameSize", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

[ "PowerPC", "PPC", "1", "PPC", "0", "0" ]

[]

[ "<s>", "static", "rtx", "frame_subreg_note", "(", "rtx", "set", ",", "int", "offset", ")", "{", "rtx", "src", "=", "simplify_gen_subreg", "(", "SImode", ",", "SET_SRC", "(", "set", ")", ",", "DImode", ",", "offset", ")", ";", "rtx", "dst", "=", "simplify_gen_subreg", "(", "SImode", ",", "SET_DEST", "(", "set", ")", ",", "DImode", ",", "offset", ")", ";", "set", "=", "gen_rtx_SET", "(", "dst", ",", "src", ")", ";", "RTX_FRAME_RELATED_P", "(", "set", ")", "=", "1", ";", "return", "set", ";", "}", "</s>" ]

[ "For", "a", "DImode", "load", "/", "store", "SET", ",", "make", "a", "SImode", "set", "for", "a", "REG_FRAME_RELATED_EXPR", "note", ",", "using", "OFFSET", "to", "create", "a", "high", "or", "lowpart", "subreg", "." ]

[ "epiphany", "1" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "auto", "PrintImmValue", "=", "[", "&", "]", "(", "const", "MCExpr", "*", "Val", ",", "const", "char", "*", "VName", ")", "{", "if", "(", "Val", "->", "getKind", "(", ")", "==", "MCExpr", "::", "Constant", ")", "{", "if", "(", "auto", "Imm", "=", "cast", "<", "MCConstantExpr", ">", "(", "Val", ")", "->", "getValue", "(", ")", ")", "OS", "<<", "VName", "<<", "Imm", ";", "}", "else", "if", "(", "Val", "->", "getKind", "(", ")", "==", "MCExpr", "::", "SymbolRef", ")", "{", "if", "(", "auto", "*", "SRE", "=", "dyn_cast", "<", "MCSymbolRefExpr", ">", "(", "Val", ")", ")", "{", "const", "MCSymbol", "&", "Sym", "=", "SRE", "->", "getSymbol", "(", ")", ";", "if", "(", "auto", "SymName", "=", "Sym", ".", "getName", "(", ")", ".", "data", "(", ")", ")", "OS", "<<", "VName", "<<", "SymName", ";", "}", "}", "}", ";", "switch", "(", "Kind", ")", "{", "case", "Token", ":", "OS", "<<", "Tok", ".", "Data", ";", "break", ";", "case", "Register", ":", "OS", "<<", "\"Reg:\"", "<<", "X86IntelInstPrinter", "::", "getRegisterName", "(", "Reg", ".", "RegNo", ")", ";", "break", ";", "case", "DXRegister", ":", "OS", "<<", "\"DXReg\"", ";", "break", ";", "case", "Immediate", ":", "PrintImmValue", "(", "Imm", ".", "Val", ",", "\"Imm:\"", ")", ";", "break", ";", "case", "Prefix", ":", "OS", "<<", "\"Prefix:\"", "<<", "Pref", ".", "Prefixes", ";", "break", ";", "case", "Memory", ":", "OS", "<<", "\"Memory: ModeSize=\"", "<<", "Mem", ".", "ModeSize", ";", "if", "(", "Mem", ".", "Size", ")", "OS", "<<", "\",Size=\"", "<<", "Mem", ".", "Size", ";", "if", "(", "Mem", ".", "BaseReg", ")", "OS", "<<", "\",BaseReg=\"", "<<", "X86IntelInstPrinter", "::", "getRegisterName", "(", "Mem", ".", "BaseReg", ")", ";", "if", "(", "Mem", ".", "IndexReg", ")", "OS", "<<", "\",IndexReg=\"", "<<", "X86IntelInstPrinter", "::", "getRegisterName", "(", "Mem", ".", "IndexReg", ")", ";", "if", "(", "Mem", ".", "Scale", ")", "OS", "<<", "\",Scale=\"", "<<", "Mem", ".", "Scale", ";", "if", "(", "Mem", ".", "Disp", ")", "PrintImmValue", "(", "Mem", ".", "Disp", ",", "\",Disp=\"", ")", ";", "if", "(", "Mem", ".", "SegReg", ")", "OS", "<<", "\",SegReg=\"", "<<", "X86IntelInstPrinter", "::", "getRegisterName", "(", "Mem", ".", "SegReg", ")", ";", "break", ";", "}", "}", "</s>" ]

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

[ "X86", "\"Reg:\"", "X86", "\"DXReg\"", "\"Imm:\"", "\"Prefix:\"", "\"Memory: ModeSize=\"", "\",Size=\"", "\",BaseReg=\"", "X86", "\",IndexReg=\"", "X86", "\",Scale=\"", "\",Disp=\"", "\",SegReg=\"", "X86" ]

[]

[ "<s>", "void", "TGSIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "fi", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "dl", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "&", "TGSI", "::", "IRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "TGSI", "::", "STpis", ")", ")", ".", "addFrameIndex", "(", "fi", ")", ".", "addReg", "(", "SrcReg", ")", ";", "else", "if", "(", "RC", "==", "&", "TGSI", "::", "IVRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "TGSI", "::", "STpiv", ")", ")", ".", "addFrameIndex", "(", "fi", ")", ".", "addReg", "(", "SrcReg", ")", ";", "else", "if", "(", "RC", "==", "&", "TGSI", "::", "FRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "TGSI", "::", "STpfs", ")", ")", ".", "addFrameIndex", "(", "fi", ")", ".", "addReg", "(", "SrcReg", ")", ";", "else", "if", "(", "RC", "==", "&", "TGSI", "::", "FVRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "TGSI", "::", "STpfv", ")", ")", ".", "addFrameIndex", "(", "fi", ")", ".", "addReg", "(", "SrcReg", ")", ";", "else", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "TGSI", "TGSI", "TGSI::IRegsRegClass", "TGSI::STpis", "TGSI::IVRegsRegClass", "TGSI::STpiv", "TGSI::FRegsRegClass", "TGSI::STpfs", "TGSI::FVRegsRegClass", "TGSI::STpfv", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "unsigned", "AArch64AsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "*", "AsmOp", ",", "unsigned", "Kind", ")", "{", "AArch64Operand", "*", "Op", "=", "static_cast", "<", "AArch64Operand", "*", ">", "(", "AsmOp", ")", ";", "int64_t", "ExpectedVal", ";", "switch", "(", "Kind", ")", "{", "default", ":", "return", "Match_InvalidOperand", ";", "case", "MCK__35_0", ":", "ExpectedVal", "=", "0", ";", "break", ";", "case", "MCK__35_1", ":", "ExpectedVal", "=", "1", ";", "break", ";", "case", "MCK__35_12", ":", "ExpectedVal", "=", "12", ";", "break", ";", "case", "MCK__35_16", ":", "ExpectedVal", "=", "16", ";", "break", ";", "case", "MCK__35_2", ":", "ExpectedVal", "=", "2", ";", "break", ";", "case", "MCK__35_24", ":", "ExpectedVal", "=", "24", ";", "break", ";", "case", "MCK__35_3", ":", "ExpectedVal", "=", "3", ";", "break", ";", "case", "MCK__35_32", ":", "ExpectedVal", "=", "32", ";", "break", ";", "case", "MCK__35_4", ":", "ExpectedVal", "=", "4", ";", "break", ";", "case", "MCK__35_48", ":", "ExpectedVal", "=", "48", ";", "break", ";", "case", "MCK__35_6", ":", "ExpectedVal", "=", "6", ";", "break", ";", "case", "MCK__35_64", ":", "ExpectedVal", "=", "64", ";", "break", ";", "case", "MCK__35_8", ":", "ExpectedVal", "=", "8", ";", "break", ";", "}", "if", "(", "!", "Op", "->", "isImm", "(", ")", ")", "return", "Match_InvalidOperand", ";", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", "->", "getImm", "(", ")", ")", ";", "if", "(", "!", "CE", ")", "return", "Match_InvalidOperand", ";", "if", "(", "CE", "->", "getValue", "(", ")", "==", "ExpectedVal", ")", "return", "Match_Success", ";", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "0", "1", "12", "16", "2", "24", "3", "32", "4", "48", "6", "64", "8" ]

[]

[ "<s>", "static", "tree", "rs6000_builtin_vectorized_libmass", "(", "combined_fn", "fn", ",", "tree", "type_out", ",", "tree", "type_in", ")", "{", "char", "name", "[", "32", "]", ";", "const", "char", "*", "suffix", "=", "NULL", ";", "tree", "fntype", ",", "new_fndecl", ",", "bdecl", "=", "NULL_TREE", ";", "int", "n_args", "=", "1", ";", "const", "char", "*", "bname", ";", "machine_mode", "el_mode", ",", "in_mode", ";", "int", "n", ",", "in_n", ";", "if", "(", "!", "flag_unsafe_math_optimizations", "||", "!", "TARGET_VSX", ")", "return", "NULL_TREE", ";", "el_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_out", ")", ")", ";", "n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_out", ")", ";", "in_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_in", ")", ")", ";", "in_n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_in", ")", ";", "if", "(", "el_mode", "!=", "in_mode", "||", "n", "!=", "in_n", ")", "return", "NULL_TREE", ";", "switch", "(", "fn", ")", "{", "CASE_CFN_ATAN2", ":", "CASE_CFN_HYPOT", ":", "CASE_CFN_POW", ":", "n_args", "=", "2", ";", "CASE_CFN_ACOS", ":", "CASE_CFN_ACOSH", ":", "CASE_CFN_ASIN", ":", "CASE_CFN_ASINH", ":", "CASE_CFN_ATAN", ":", "CASE_CFN_ATANH", ":", "CASE_CFN_CBRT", ":", "CASE_CFN_COS", ":", "CASE_CFN_COSH", ":", "CASE_CFN_ERF", ":", "CASE_CFN_ERFC", ":", "CASE_CFN_EXP2", ":", "CASE_CFN_EXP", ":", "CASE_CFN_EXPM1", ":", "CASE_CFN_LGAMMA", ":", "CASE_CFN_LOG10", ":", "CASE_CFN_LOG1P", ":", "CASE_CFN_LOG2", ":", "CASE_CFN_LOG", ":", "CASE_CFN_SIN", ":", "CASE_CFN_SINH", ":", "CASE_CFN_SQRT", ":", "CASE_CFN_TAN", ":", "CASE_CFN_TANH", ":", "if", "(", "el_mode", "==", "DFmode", "&&", "n", "==", "2", ")", "{", "bdecl", "=", "mathfn_built_in", "(", "double_type_node", ",", "fn", ")", ";", "suffix", "=", "\"d2\"", ";", "}", "else", "if", "(", "el_mode", "==", "SFmode", "&&", "n", "==", "4", ")", "{", "bdecl", "=", "mathfn_built_in", "(", "float_type_node", ",", "fn", ")", ";", "suffix", "=", "\"4\"", ";", "}", "else", "return", "NULL_TREE", ";", "if", "(", "!", "bdecl", ")", "return", "NULL_TREE", ";", "break", ";", "default", ":", "return", "NULL_TREE", ";", "}", "gcc_assert", "(", "suffix", "!=", "NULL", ")", ";", "bname", "=", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "bdecl", ")", ")", ";", "if", "(", "!", "bname", ")", "return", "NULL_TREE", ";", "strcpy", "(", "name", ",", "bname", "+", "sizeof", "(", "\"__builtin_\"", ")", "-", "1", ")", ";", "strcat", "(", "name", ",", "suffix", ")", ";", "if", "(", "n_args", "==", "1", ")", "fntype", "=", "build_function_type_list", "(", "type_out", ",", "type_in", ",", "NULL", ")", ";", "else", "if", "(", "n_args", "==", "2", ")", "fntype", "=", "build_function_type_list", "(", "type_out", ",", "type_in", ",", "type_in", ",", "NULL", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "new_fndecl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FUNCTION_DECL", ",", "get_identifier", "(", "name", ")", ",", "fntype", ")", ";", "TREE_PUBLIC", "(", "new_fndecl", ")", "=", "1", ";", "DECL_EXTERNAL", "(", "new_fndecl", ")", "=", "1", ";", "DECL_IS_NOVOPS", "(", "new_fndecl", ")", "=", "1", ";", "TREE_READONLY", "(", "new_fndecl", ")", "=", "1", ";", "return", "new_fndecl", ";", "}", "</s>" ]

[ "Handler", "for", "the", "Mathematical", "Acceleration", "Subsystem", "(", "mass", ")", "interface", "to", "a", "library", "with", "vectorized", "intrinsics", "." ]

[ "rs6000", "32", "1", "2", "2", "\"d2\"", "4", "\"4\"", "\"__builtin_\"", "1", "1", "2", "1", "1", "1", "1" ]

[]

[ "<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__\"", ")", ";", "}", "</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__\"" ]

[]

[ "<s>", "FastISel", "*", "Mips", "::", "createFastISel", "(", "FunctionLoweringInfo", "&", "funcInfo", ",", "const", "TargetLibraryInfo", "*", "libInfo", ")", "{", "return", "new", "MipsFastISel", "(", "funcInfo", ",", "libInfo", ")", ";", "}", "</s>" ]

[ "This", "method", "returns", "a", "target", "specific", "FastISel", "object", ",", "or", "null", "if", "the", "target", "does", "not", "support", "``", "fast", "''", "ISel", "." ]

[ "Mips", "Mips::createFastISel", "Mips" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "void", "PPCAsmPrinter", "::", "PrintSymbolOperand", "(", "const", "MachineOperand", "&", "MO", ",", "raw_ostream", "&", "O", ")", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "getSymbol", "(", "GV", ")", "->", "print", "(", "O", ",", "MAI", ")", ";", "printOffset", "(", "MO", ".", "getOffset", "(", ")", ",", "O", ")", ";", "}", "</s>" ]

[ "Print", "the", "MachineOperand", "as", "a", "symbol", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "isMem", "(", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "PowerPC" ]

[]

[ "<s>", "bool", "xxspltib_constant_p", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "int", "*", "num_insns_ptr", ",", "int", "*", "constant_ptr", ")", "{", "size_t", "nunits", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "size_t", "i", ";", "HOST_WIDE_INT", "value", ";", "rtx", "element", ";", "*", "num_insns_ptr", "=", "-", "1", ";", "*", "constant_ptr", "=", "256", ";", "if", "(", "!", "TARGET_P9_VECTOR", ")", "return", "false", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "GET_MODE", "(", "op", ")", ";", "else", "if", "(", "mode", "!=", "GET_MODE", "(", "op", ")", "&&", "GET_MODE", "(", "op", ")", "!=", "VOIDmode", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "VEC_DUPLICATE", ")", "{", "if", "(", "mode", "!=", "V16QImode", "&&", "mode", "!=", "V8HImode", "&&", "mode", "!=", "V4SImode", "&&", "mode", "!=", "V2DImode", ")", "return", "false", ";", "element", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "element", ")", ")", "return", "false", ";", "value", "=", "INTVAL", "(", "element", ")", ";", "if", "(", "!", "IN_RANGE", "(", "value", ",", "-", "128", ",", "127", ")", ")", "return", "false", ";", "}", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_VECTOR", ")", "{", "if", "(", "mode", "!=", "V16QImode", "&&", "mode", "!=", "V8HImode", "&&", "mode", "!=", "V4SImode", "&&", "mode", "!=", "V2DImode", ")", "return", "false", ";", "element", "=", "CONST_VECTOR_ELT", "(", "op", ",", "0", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "element", ")", ")", "return", "false", ";", "value", "=", "INTVAL", "(", "element", ")", ";", "if", "(", "!", "IN_RANGE", "(", "value", ",", "-", "128", ",", "127", ")", ")", "return", "false", ";", "for", "(", "i", "=", "1", ";", "i", "<", "nunits", ";", "i", "++", ")", "{", "element", "=", "CONST_VECTOR_ELT", "(", "op", ",", "i", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "element", ")", ")", "return", "false", ";", "if", "(", "value", "!=", "INTVAL", "(", "element", ")", ")", "return", "false", ";", "}", "}", "else", "if", "(", "CONST_INT_P", "(", "op", ")", ")", "{", "if", "(", "!", "SCALAR_INT_MODE_P", "(", "mode", ")", ")", "return", "false", ";", "value", "=", "INTVAL", "(", "op", ")", ";", "if", "(", "!", "IN_RANGE", "(", "value", ",", "-", "128", ",", "127", ")", ")", "return", "false", ";", "if", "(", "!", "IN_RANGE", "(", "value", ",", "-", "1", ",", "0", ")", ")", "{", "if", "(", "!", "(", "reg_addr", "[", "mode", "]", ".", "addr_mask", "[", "RELOAD_REG_VMX", "]", "&", "RELOAD_REG_VALID", ")", ")", "return", "false", ";", "if", "(", "EASY_VECTOR_15", "(", "value", ")", ")", "return", "false", ";", "}", "}", "else", "return", "false", ";", "if", "(", "(", "mode", "==", "V4SImode", "||", "mode", "==", "V8HImode", ")", "&&", "!", "IN_RANGE", "(", "value", ",", "-", "1", ",", "0", ")", "&&", "EASY_VECTOR_15", "(", "value", ")", ")", "return", "false", ";", "if", "(", "mode", "==", "V16QImode", ")", "*", "num_insns_ptr", "=", "1", ";", "else", "if", "(", "IN_RANGE", "(", "value", ",", "-", "1", ",", "0", ")", ")", "*", "num_insns_ptr", "=", "1", ";", "else", "if", "(", "vsx_prefixed_constant", "(", "op", ",", "mode", ")", ")", "return", "false", ";", "else", "*", "num_insns_ptr", "=", "2", ";", "*", "constant_ptr", "=", "(", "int", ")", "value", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "of", "the", "given", "MODE", "and", "can", "be", "synthesized", "with", "ISA", "3.0", "instructions", "(", "xxspltib", ",", "vupkhsb/vextsb2w/vextb2d", ")", ".", "Return", "the", "number", "of", "instructions", "needed", "(", "1", "or", "2", ")", "into", "the", "address", "pointed", "via", "NUM_INSNS_PTR", ".", "Return", "the", "constant", "that", "is", "being", "split", "via", "CONSTANT_PTR", "." ]

[ "rs6000", "1", "256", "0", "128", "127", "0", "128", "127", "1", "128", "127", "1", "0", "1", "0", "1", "1", "0", "1", "2" ]

[]

[ "<s>", "static", "bool", "chain_contains_only_swaps", "(", "swap_web_entry", "*", "insn_entry", ",", "struct", "df_link", "*", "link", ",", "enum", "chain_purpose", "purpose", ")", "{", "if", "(", "!", "link", ")", "return", "false", ";", "for", "(", ";", "link", ";", "link", "=", "link", "->", "next", ")", "{", "if", "(", "!", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "GET_MODE", "(", "DF_REF_REG", "(", "link", "->", "ref", ")", ")", ")", ")", "continue", ";", "if", "(", "DF_REF_IS_ARTIFICIAL", "(", "link", "->", "ref", ")", ")", "return", "false", ";", "rtx", "reached_insn", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "unsigned", "uid", "=", "INSN_UID", "(", "reached_insn", ")", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "reached_insn", ")", ";", "if", "(", "!", "insn_entry", "[", "uid", "]", ".", "is_swap", "||", "insn_entry", "[", "uid", "]", ".", "is_load", "||", "insn_entry", "[", "uid", "]", ".", "is_store", ")", "return", "false", ";", "if", "(", "purpose", "==", "FOR_LOADS", ")", "{", "df_ref", "use", ";", "FOR_EACH_INSN_INFO_USE", "(", "use", ",", "insn_info", ")", "{", "struct", "df_link", "*", "swap_link", "=", "DF_REF_CHAIN", "(", "use", ")", ";", "while", "(", "swap_link", ")", "{", "if", "(", "DF_REF_IS_ARTIFICIAL", "(", "link", "->", "ref", ")", ")", "return", "false", ";", "rtx", "swap_def_insn", "=", "DF_REF_INSN", "(", "swap_link", "->", "ref", ")", ";", "unsigned", "uid2", "=", "INSN_UID", "(", "swap_def_insn", ")", ";", "if", "(", "!", "insn_entry", "[", "uid2", "]", ".", "is_swap", "||", "!", "insn_entry", "[", "uid2", "]", ".", "is_load", ")", "return", "false", ";", "swap_link", "=", "swap_link", "->", "next", ";", "}", "}", "}", "else", "if", "(", "purpose", "==", "FOR_STORES", ")", "{", "df_ref", "def", ";", "FOR_EACH_INSN_INFO_DEF", "(", "def", ",", "insn_info", ")", "{", "struct", "df_link", "*", "swap_link", "=", "DF_REF_CHAIN", "(", "def", ")", ";", "while", "(", "swap_link", ")", "{", "if", "(", "DF_REF_IS_ARTIFICIAL", "(", "link", "->", "ref", ")", ")", "return", "false", ";", "rtx", "swap_use_insn", "=", "DF_REF_INSN", "(", "swap_link", "->", "ref", ")", ";", "unsigned", "uid2", "=", "INSN_UID", "(", "swap_use_insn", ")", ";", "if", "(", "!", "insn_entry", "[", "uid2", "]", ".", "is_swap", "||", "insn_entry", "[", "uid2", "]", ".", "is_load", ")", "return", "false", ";", "swap_link", "=", "swap_link", "->", "next", ";", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "UD", "or", "DU", "chain", "headed", "by", "LINK", "is", "non-empty", ",", "and", "every", "entry", "on", "the", "chain", "references", "an", "insn", "that", "is", "a", "register", "swap", ".", "Furthermore", ",", "if", "PURPOSE", "is", "FOR_LOADS", ",", "each", "such", "register", "swap", "must", "have", "only", "permuting", "loads", "as", "reaching", "defs", ".", "If", "PURPOSE", "is", "FOR_STORES", ",", "each", "such", "register", "swap", "must", "have", "only", "register", "swaps", "or", "permuting", "stores", "as", "reached", "uses", "." ]

[ "rs6000" ]

[]

[ "<s>", "unsigned", "AVRInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "{", "const", "MCInstrDesc", "&", "Desc", "=", "get", "(", "Opcode", ")", ";", "return", "Desc", ".", "getSize", "(", ")", ";", "}", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "0", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "case", "TargetOpcode", "::", "INLINEASM_BR", ":", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "AVRTargetMachine", "&", "TM", "=", "static_cast", "<", "const", "AVRTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "return", "TII", ".", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "TM", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "AVR", "AVR", "0", "AVR", "AVR", "AVR", "AVR", "0" ]

[]

[ "<s>", "void", "Z80FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "StackSize", "=", "-", "int", "(", "MFI", ".", "getStackSize", "(", ")", ")", ";", "unsigned", "ScratchReg", "=", "Is24Bit", "?", "Z80", "::", "UHL", ":", "Z80", "::", "HL", ";", "while", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "MI", "->", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ")", "++", "MI", ";", "int", "FPOffset", "=", "-", "1", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeList", "::", "FunctionIndex", ",", "Attribute", "::", "OptimizeForSize", ")", ")", "{", "if", "(", "StackSize", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Is24Bit", "?", "Z80", "::", "LD24ri", ":", "Z80", "::", "LD16ri", ")", ",", "ScratchReg", ")", ".", "addImm", "(", "StackSize", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Is24Bit", "?", "Z80", "::", "CALL24i", ":", "Z80", "::", "CALL16i", ")", ")", ".", "addExternalSymbol", "(", "\"_frameset\"", ")", ".", "addReg", "(", "ScratchReg", ",", "RegState", "::", "ImplicitKill", ")", ";", "return", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Is24Bit", "?", "Z80", "::", "CALL24i", ":", "Z80", "::", "CALL16i", ")", ")", ".", "addExternalSymbol", "(", "\"_frameset0\"", ")", ";", "return", ";", "}", "unsigned", "FrameReg", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Is24Bit", "?", "Z80", "::", "PUSH24r", ":", "Z80", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "FrameReg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Is24Bit", "?", "Z80", "::", "LD24ri", ":", "Z80", "::", "LD16ri", ")", ",", "FrameReg", ")", ".", "addImm", "(", "0", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Is24Bit", "?", "Z80", "::", "ADD24SP", ":", "Z80", "::", "ADD16SP", ")", ",", "FrameReg", ")", ".", "addReg", "(", "FrameReg", ")", ";", "FPOffset", "=", "0", ";", "}", "BuildStackAdjustment", "(", "MF", ",", "MBB", ",", "MI", ",", "DL", ",", "ScratchReg", ",", "StackSize", ",", "FPOffset", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "Z80::UHL", "Z80::HL", "1", "Z80::LD24ri", "Z80::LD16ri", "Z80::CALL24i", "Z80::CALL16i", "\"_frameset\"", "Z80::CALL24i", "Z80::CALL16i", "\"_frameset0\"", "Z80::PUSH24r", "Z80::PUSH16r", "Z80::LD24ri", "Z80::LD16ri", "0", "Z80::ADD24SP", "Z80::ADD16SP", "0" ]

[]

[ "<s>", "TargetLoweringBase", "::", "LegalizeTypeAction", "NVPTXTargetLowering", "::", "getPreferredVectorAction", "(", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "!=", "1", "&&", "VT", ".", "getScalarType", "(", ")", "==", "MVT", "::", "i1", ")", "return", "TypeSplitVector", ";", "return", "TargetLoweringBase", "::", "getPreferredVectorAction", "(", "VT", ")", ";", "}", "</s>" ]

[ "Customize", "the", "preferred", "legalization", "strategy", "for", "certain", "types", "." ]

[ "NVPTX", "NVPTX", "1", "MVT::i1" ]

[]

[ "<s>", "static", "bool", "mcore_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "const", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "return", "(", "size", "==", "-", "1", "||", "size", ">", "2", "*", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_RETURN_IN_MEMORY", "." ]

[ "mcore", "1", "2" ]

[]

[ "<s>", "static", "void", "fix_range", "(", "const", "char", "*", "const_str", ")", "{", "int", "i", ",", "first", ",", "last", ";", "char", "*", "str", ",", "*", "dash", ",", "*", "comma", ";", "i", "=", "strlen", "(", "const_str", ")", ";", "str", "=", "(", "char", "*", ")", "alloca", "(", "i", "+", "1", ")", ";", "memcpy", "(", "str", ",", "const_str", ",", "i", "+", "1", ")", ";", "while", "(", "1", ")", "{", "dash", "=", "strchr", "(", "str", ",", "'-'", ")", ";", "if", "(", "!", "dash", ")", "{", "warning", "(", "0", ",", "\"value of %<-mfixed-range%> must have form REG1-REG2\"", ")", ";", "return", ";", "}", "*", "dash", "=", "'\\0'", ";", "comma", "=", "strchr", "(", "dash", "+", "1", ",", "','", ")", ";", "if", "(", "comma", ")", "*", "comma", "=", "'\\0'", ";", "first", "=", "decode_reg_name", "(", "str", ")", ";", "if", "(", "first", "<", "0", ")", "{", "warning", "(", "0", ",", "\"unknown register name: %s\"", ",", "str", ")", ";", "return", ";", "}", "last", "=", "decode_reg_name", "(", "dash", "+", "1", ")", ";", "if", "(", "last", "<", "0", ")", "{", "warning", "(", "0", ",", "\"unknown register name: %s\"", ",", "dash", "+", "1", ")", ";", "return", ";", "}", "*", "dash", "=", "'-'", ";", "if", "(", "first", ">", "last", ")", "{", "warning", "(", "0", ",", "\"%s-%s is an empty range\"", ",", "str", ",", "dash", "+", "1", ")", ";", "return", ";", "}", "for", "(", "i", "=", "first", ";", "i", "<=", "last", ";", "++", "i", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "1", ";", "if", "(", "!", "comma", ")", "break", ";", "*", "comma", "=", "','", ";", "str", "=", "comma", "+", "1", ";", "}", "}", "</s>" ]

[ "Parse", "the", "-mfixed-range=", "option", "string", "." ]

[ "spu", "1", "1", "1", "0", "\"value of %<-mfixed-range%> must have form REG1-REG2\"", "1", "0", "0", "\"unknown register name: %s\"", "1", "0", "0", "\"unknown register name: %s\"", "1", "0", "\"%s-%s is an empty range\"", "1", "1", "1" ]

[]

[ "<s>", "static", "void", "ix86_test_loading_unspec", "(", ")", "{", "rtl_dump_test", "t", "(", "SELFTEST_LOCATION", ",", "locate_file", "(", "\"x86_64/unspec.rtl\"", ")", ")", ";", "ASSERT_STREQ", "(", "\"test_unspec\"", ",", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "cfun", "->", "decl", ")", ")", ")", ";", "ASSERT_TRUE", "(", "cfun", ")", ";", "rtx_insn", "*", "insn", "=", "get_insns", "(", ")", ";", "ASSERT_EQ", "(", "INSN", ",", "GET_CODE", "(", "insn", ")", ")", ";", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "ASSERT_NE", "(", "NULL", ",", "set", ")", ";", "rtx", "dst", "=", "SET_DEST", "(", "set", ")", ";", "ASSERT_EQ", "(", "MEM", ",", "GET_CODE", "(", "dst", ")", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "set", ")", ";", "ASSERT_EQ", "(", "UNSPEC", ",", "GET_CODE", "(", "src", ")", ")", ";", "ASSERT_EQ", "(", "BLKmode", ",", "GET_MODE", "(", "src", ")", ")", ";", "ASSERT_EQ", "(", "UNSPEC_MEMORY_BLOCKAGE", ",", "XINT", "(", "src", ",", "1", ")", ")", ";", "rtx", "v0", "=", "XVECEXP", "(", "src", ",", "0", ",", "0", ")", ";", "rtx", "scratch_a", "=", "XEXP", "(", "dst", ",", "0", ")", ";", "ASSERT_EQ", "(", "SCRATCH", ",", "GET_CODE", "(", "scratch_a", ")", ")", ";", "rtx", "scratch_b", "=", "XEXP", "(", "v0", ",", "0", ")", ";", "ASSERT_EQ", "(", "SCRATCH", ",", "GET_CODE", "(", "scratch_b", ")", ")", ";", "ASSERT_EQ", "(", "scratch_a", ",", "scratch_b", ")", ";", "ASSERT_TRUE", "(", "rtx_equal_p", "(", "dst", ",", "v0", ")", ")", ";", "ASSERT_NE", "(", "-", "1", ",", "recog_memoized", "(", "insn", ")", ")", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "ASSERT_EQ", "(", "INSN", ",", "GET_CODE", "(", "insn", ")", ")", ";", "set", "=", "single_set", "(", "insn", ")", ";", "ASSERT_NE", "(", "NULL", ",", "set", ")", ";", "src", "=", "SET_SRC", "(", "set", ")", ";", "ASSERT_EQ", "(", "UNSPEC_VOLATILE", ",", "GET_CODE", "(", "src", ")", ")", ";", "ASSERT_EQ", "(", "UNSPECV_RDTSCP", ",", "XINT", "(", "src", ",", "1", ")", ")", ";", "}", "</s>" ]

[ "Verify", "that", "the", "RTL", "loader", "copes", "with", "UNSPEC", "and", "UNSPEC_VOLATILE", "insns", ".", "In", "particular", ",", "verify", "that", "it", "correctly", "loads", "the", "2nd", "operand", ".", "This", "test", "is", "target-specific", "since", "these", "are", "machine-specific", "operands", "(", "and", "enums", ")", "." ]

[ "i386", "\"x86_64/unspec.rtl\"", "\"test_unspec\"", "1", "0", "0", "0", "0", "1", "1" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "isFrameOffsetLegal", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MI", "->", "getDesc", "(", ")", ";", "unsigned", "AddrMode", "=", "(", "Desc", ".", "TSFlags", "&", "ARMII", "::", "AddrModeMask", ")", ";", "unsigned", "i", "=", "0", ";", "for", "(", ";", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ";", "++", "i", ")", "assert", "(", "i", "+", "1", "<", "MI", "->", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "if", "(", "AddrMode", "==", "ARMII", "::", "AddrMode4", "||", "AddrMode", "==", "ARMII", "::", "AddrMode6", ")", "return", "Offset", "==", "0", ";", "unsigned", "NumBits", "=", "0", ";", "unsigned", "Scale", "=", "1", ";", "bool", "isSigned", "=", "true", ";", "switch", "(", "AddrMode", ")", "{", "case", "ARMII", "::", "AddrModeT2_i8", ":", "case", "ARMII", "::", "AddrModeT2_i12", ":", "Scale", "=", "1", ";", "if", "(", "Offset", "<", "0", ")", "{", "NumBits", "=", "8", ";", "Offset", "=", "-", "Offset", ";", "}", "else", "{", "NumBits", "=", "12", ";", "}", "break", ";", "case", "ARMII", "::", "AddrMode5", ":", "NumBits", "=", "8", ";", "Scale", "=", "4", ";", "break", ";", "case", "ARMII", "::", "AddrMode_i12", ":", "case", "ARMII", "::", "AddrMode2", ":", "NumBits", "=", "12", ";", "break", ";", "case", "ARMII", "::", "AddrMode3", ":", "NumBits", "=", "8", ";", "break", ";", "case", "ARMII", "::", "AddrModeT1_s", ":", "NumBits", "=", "(", "BaseReg", "==", "ARM", "::", "SP", "?", "8", ":", "5", ")", ";", "Scale", "=", "4", ";", "isSigned", "=", "false", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unsupported addressing mode!\"", ")", ";", "}", "Offset", "+=", "getFrameIndexInstrOffset", "(", "MI", ",", "i", ")", ";", "if", "(", "(", "Offset", "&", "(", "Scale", "-", "1", ")", ")", "!=", "0", ")", "return", "false", ";", "if", "(", "isSigned", "&&", "Offset", "<", "0", ")", "Offset", "=", "-", "Offset", ";", "unsigned", "Mask", "=", "(", "1", "<<", "NumBits", ")", "-", "1", ";", "if", "(", "(", "unsigned", ")", "Offset", "<=", "Mask", "*", "Scale", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "given", "base", "register", "plus", "offset", "immediate", "is", "encodable", "to", "resolve", "a", "frame", "index", "." ]

[ "ARM", "ARM", "ARMII::AddrModeMask", "0", "1", "\"Instr doesn't have FrameIndex operand!\"", "ARMII::AddrMode4", "ARMII::AddrMode6", "0", "0", "1", "ARMII::AddrModeT2_i8", "ARMII::AddrModeT2_i12", "1", "0", "8", "12", "ARMII::AddrMode5", "8", "4", "ARMII::AddrMode_i12", "ARMII::AddrMode2", "12", "ARMII::AddrMode3", "8", "ARMII::AddrModeT1_s", "ARM::SP", "8", "5", "4", "\"Unsupported addressing mode!\"", "1", "0", "0", "1", "1" ]

[]

[ "<s>", "void", "ix86_expand_fp_absneg_operator", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "set", ",", "dst", ",", "src", ";", "bool", "use_sse", "=", "false", ";", "bool", "vector_mode", "=", "VECTOR_MODE_P", "(", "mode", ")", ";", "machine_mode", "vmode", "=", "mode", ";", "rtvec", "par", ";", "if", "(", "vector_mode", "||", "mode", "==", "TFmode", ")", "use_sse", "=", "true", ";", "else", "if", "(", "TARGET_SSE_MATH", ")", "{", "use_sse", "=", "SSE_FLOAT_MODE_P", "(", "mode", ")", ";", "if", "(", "mode", "==", "SFmode", ")", "vmode", "=", "V4SFmode", ";", "else", "if", "(", "mode", "==", "DFmode", ")", "vmode", "=", "V2DFmode", ";", "}", "dst", "=", "operands", "[", "0", "]", ";", "src", "=", "operands", "[", "1", "]", ";", "set", "=", "gen_rtx_fmt_e", "(", "code", ",", "mode", ",", "src", ")", ";", "set", "=", "gen_rtx_SET", "(", "dst", ",", "set", ")", ";", "if", "(", "use_sse", ")", "{", "rtx", "mask", ",", "use", ",", "clob", ";", "mask", "=", "ix86_build_signbit_mask", "(", "vmode", ",", "vector_mode", ",", "code", "==", "ABS", ")", ";", "use", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "mask", ")", ";", "if", "(", "vector_mode", "||", "mode", "==", "TFmode", ")", "par", "=", "gen_rtvec", "(", "2", ",", "set", ",", "use", ")", ";", "else", "{", "clob", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ")", ";", "par", "=", "gen_rtvec", "(", "3", ",", "set", ",", "use", ",", "clob", ")", ";", "}", "}", "else", "{", "rtx", "clob", ";", "clob", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ")", ";", "par", "=", "gen_rtvec", "(", "2", ",", "set", ",", "clob", ")", ";", "}", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "par", ")", ")", ";", "}", "</s>" ]

[ "Generate", "code", "for", "floating", "point", "ABS", "or", "NEG", "." ]

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

[]

[ "<s>", "bool", "GCNRegBankReassign", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", "->", "hasRegisterBanking", "(", ")", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TRI", "=", "ST", "->", "getRegisterInfo", "(", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "VRM", "=", "&", "getAnalysis", "<", "VirtRegMap", ">", "(", ")", ";", "LRM", "=", "&", "getAnalysis", "<", "LiveRegMatrix", ">", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Occupancy", "=", "MFI", "->", "getOccupancy", "(", ")", ";", "MaxNumVGPRs", "=", "ST", "->", "getMaxNumVGPRs", "(", "MF", ")", ";", "MaxNumSGPRs", "=", "ST", "->", "getMaxNumSGPRs", "(", "MF", ")", ";", "MaxNumVGPRs", "=", "std", "::", "min", "(", "ST", "->", "getMaxNumVGPRs", "(", "Occupancy", ")", ",", "MaxNumVGPRs", ")", ";", "MaxNumSGPRs", "=", "std", "::", "min", "(", "ST", "->", "getMaxNumSGPRs", "(", "Occupancy", ",", "true", ")", ",", "MaxNumSGPRs", ")", ";", "CSRegs", "=", "MRI", "->", "getCalleeSavedRegs", "(", ")", ";", "unsigned", "NumRegBanks", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", "+", "AMDGPU", "::", "SReg_32RegClass", ".", "getNumRegs", "(", ")", "/", "2", "+", "1", ";", "RegsUsed", ".", "resize", "(", "NumRegBanks", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"=== RegBanks reassign analysis on function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "unsigned", "StallCycles", "=", "collectCandidates", "(", "MF", ")", ";", "NumStallsDetected", "+=", "StallCycles", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"=== \"", "<<", "StallCycles", "<<", "\" stall cycles detected in \"", "\"function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "LLVM_DEBUG", "(", "Candidates", ".", "dump", "(", "this", ")", ")", ";", "unsigned", "CyclesSaved", "=", "0", ";", "while", "(", "!", "Candidates", ".", "empty", "(", ")", ")", "{", "Candidate", "C", "=", "Candidates", ".", "back", "(", ")", ";", "unsigned", "LocalCyclesSaved", "=", "tryReassign", "(", "C", ")", ";", "CyclesSaved", "+=", "LocalCyclesSaved", ";", "if", "(", "VerifyStallCycles", ">", "1", "&&", "!", "verifyCycles", "(", "MF", ",", "StallCycles", ",", "CyclesSaved", ")", ")", "report_fatal_error", "(", "\"RegBank reassign stall cycles verification failed.\"", ")", ";", "Candidates", ".", "pop_back", "(", ")", ";", "if", "(", "LocalCyclesSaved", ")", "{", "removeCandidates", "(", "C", ".", "Reg", ")", ";", "computeStallCycles", "(", "C", ".", "Reg", ",", "AMDGPU", "::", "NoRegister", ",", "0", ",", "-", "1", ",", "true", ")", ";", "LLVM_DEBUG", "(", "Candidates", ".", "dump", "(", "this", ")", ")", ";", "}", "}", "NumStallsRecovered", "+=", "CyclesSaved", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"=== After the pass \"", "<<", "CyclesSaved", "<<", "\" cycles saved in function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "Candidates", ".", "clear", "(", ")", ";", "if", "(", "VerifyStallCycles", "==", "1", "&&", "!", "verifyCycles", "(", "MF", ",", "StallCycles", ",", "CyclesSaved", ")", ")", "report_fatal_error", "(", "\"RegBank reassign stall cycles verification failed.\"", ")", ";", "RegsUsed", ".", "clear", "(", ")", ";", "return", "CyclesSaved", ">", "0", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "AMDGPU::VGPR_32RegClass", "AMDGPU::SReg_32RegClass", "2", "1", "\"=== RegBanks reassign analysis on function \"", "\"=== \"", "\" stall cycles detected in \"", "\"function \"", "0", "1", "\"RegBank reassign stall cycles verification failed.\"", "AMDGPU::NoRegister", "0", "1", "\"=== After the pass \"", "\" cycles saved in function \"", "1", "\"RegBank reassign stall cycles verification failed.\"", "0" ]

[]

[ "<s>", "rtx", "ix86_gen_scratch_sse_rtx", "(", "machine_mode", "mode", ")", "{", "return", "gen_reg_rtx", "(", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_GEN_MEMSET_SCRATCH_RTX", "hook", ".", "Return", "a", "scratch", "register", "in", "MODE", "for", "vector", "load", "and", "store", "." ]

[ "i386" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "WebAssemblyTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "assert", "(", "VT", "!=", "MVT", "::", "iPTR", "&&", "\"Pointer MVT not expected here\"", ")", ";", "if", "(", "VT", ".", "isInteger", "(", ")", "&&", "!", "VT", ".", "isVector", "(", ")", ")", "{", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "<=", "32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "WebAssembly", "::", "I32RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "<=", "64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "WebAssembly", "::", "I64RegClass", ")", ";", "}", "break", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "1", "0", "MVT::iPTR", "\"Pointer MVT not expected here\"", "32", "0U", "WebAssembly::I32RegClass", "64", "0U", "WebAssembly::I64RegClass" ]

[]

[ "<s>", "HOST_WIDE_INT", "s390_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "HOST_WIDE_INT", "offset", ";", "if", "(", "!", "s390_can_eliminate", "(", "from", ",", "to", ")", ")", "return", "0", ";", "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "offset", "=", "(", "get_frame_size", "(", ")", "+", "STACK_POINTER_OFFSET", "+", "crtl", "->", "outgoing_args_size", ")", ";", "break", ";", "case", "ARG_POINTER_REGNUM", ":", "s390_init_frame_layout", "(", ")", ";", "offset", "=", "cfun_frame_layout", ".", "frame_size", "+", "STACK_POINTER_OFFSET", ";", "break", ";", "case", "RETURN_ADDRESS_POINTER_REGNUM", ":", "s390_init_frame_layout", "(", ")", ";", "if", "(", "cfun_frame_layout", ".", "first_save_gpr_slot", "==", "-", "1", ")", "{", "if", "(", "cfun", "->", "stdarg", "&&", "!", "cfun_save_arg_fprs_p", ")", "return", "0", ";", "gcc_unreachable", "(", ")", ";", "}", "offset", "=", "(", "cfun_frame_layout", ".", "frame_size", "+", "cfun_frame_layout", ".", "gprs_offset", "+", "(", "RETURN_REGNUM", "-", "cfun_frame_layout", ".", "first_save_gpr_slot", ")", "*", "UNITS_PER_LONG", ")", ";", "break", ";", "case", "BASE_REGNUM", ":", "offset", "=", "0", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "offset", ";", "}", "</s>" ]

[ "Return", "offset", "between", "register", "FROM", "and", "TO", "initially", "after", "prolog", "." ]

[ "s390", "0", "1", "0", "0" ]

[]

[ "<s>", "const_iterator", "begin", "(", ")", "const", "{", "return", "m_SectToExData", ".", "begin", "(", ")", ";", "}", "</s>" ]

[ "Recipe", "iterator", "methods", "." ]

[ "ARM" ]

[]

[ "<s>", "unsigned", "HOST_WIDE_INT", "aarch64_and_split_imm2", "(", "HOST_WIDE_INT", "val_in", ")", "{", "return", "val_in", "|", "~", "aarch64_and_split_imm1", "(", "val_in", ")", ";", "}", "</s>" ]

[ "Create", "constant", "where", "bits", "outside", "of", "lowest", "bit", "set", "to", "highest", "bit", "set", "are", "set", "to", "1", "." ]

[ "aarch64" ]

[]

[ "<s>", "inline", "hashval_t", "libcall_hasher", "::", "hash", "(", "const", "value_type", "*", "p1", ")", "{", "return", "hash_rtx", "(", "p1", ",", "VOIDmode", ",", "NULL", ",", "NULL", ",", "FALSE", ")", ";", "}", "</s>" ]

[ "Hash", "function", "for", "builtin", "functions", "with", "up", "to", "3", "arguments", "and", "a", "return", "type", "." ]

[ "arm" ]

[]

[ "<s>", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "SystemZSelectionDAGInfo", "::", "EmitTargetCodeForMemcmp", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "DL", ",", "SDValue", "Chain", ",", "SDValue", "Src1", ",", "SDValue", "Src2", ",", "SDValue", "Size", ",", "MachinePointerInfo", "Op1PtrInfo", ",", "MachinePointerInfo", "Op2PtrInfo", ")", "const", "{", "if", "(", "auto", "*", "CSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ")", "{", "uint64_t", "Bytes", "=", "CSize", "->", "getZExtValue", "(", ")", ";", "assert", "(", "Bytes", ">", "0", "&&", "\"Caller should have handled 0-size case\"", ")", ";", "Chain", "=", "emitCLC", "(", "DAG", ",", "DL", ",", "Chain", ",", "Src1", ",", "Src2", ",", "Bytes", ")", ";", "SDValue", "Glue", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "return", "std", "::", "make_pair", "(", "addIPMSequence", "(", "DL", ",", "Glue", ",", "DAG", ")", ",", "Chain", ")", ";", "}", "return", "std", "::", "make_pair", "(", "SDValue", "(", ")", ",", "SDValue", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memcmp/bcmp", ",", "in", "cases", "where", "that", "is", "faster", "than", "a", "libcall", "." ]

[ "SystemZ", "SystemZ", "0", "\"Caller should have handled 0-size case\"", "1" ]

[]

[ "<s>", "bool", "SystemZXPLINKFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "MutableArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "ZFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "const", "SystemZSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SystemZSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "Regs", "=", "Subtarget", ".", "getSpecialRegisters", "<", "SystemZXPLINK64Registers", ">", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "CSI", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Register", "Reg", "=", "CSI", "[", "I", "]", ".", "getReg", "(", ")", ";", "if", "(", "SystemZ", "::", "FP64BitRegClass", ".", "contains", "(", "Reg", ")", ")", "TII", "->", "loadRegFromStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "CSI", "[", "I", "]", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "FP64BitRegClass", ",", "TRI", ")", ";", "if", "(", "SystemZ", "::", "VR128BitRegClass", ".", "contains", "(", "Reg", ")", ")", "TII", "->", "loadRegFromStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "CSI", "[", "I", "]", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "VR128BitRegClass", ",", "TRI", ")", ";", "}", "SystemZ", "::", "GPRRegs", "RestoreGPRs", "=", "ZFI", "->", "getRestoreGPRRegs", "(", ")", ";", "if", "(", "RestoreGPRs", ".", "LowGPR", ")", "{", "assert", "(", "isInt", "<", "20", ">", "(", "Regs", ".", "getStackPointerBias", "(", ")", "+", "RestoreGPRs", ".", "GPROffset", ")", ")", ";", "if", "(", "RestoreGPRs", ".", "LowGPR", "==", "RestoreGPRs", ".", "HighGPR", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "SystemZ", "::", "LG", ")", ",", "RestoreGPRs", ".", "LowGPR", ")", ".", "addReg", "(", "Regs", ".", "getStackPointerRegister", "(", ")", ")", ".", "addImm", "(", "Regs", ".", "getStackPointerBias", "(", ")", "+", "RestoreGPRs", ".", "GPROffset", ")", ".", "addReg", "(", "0", ")", ";", "else", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "SystemZ", "::", "LMG", ")", ")", ";", "MIB", ".", "addReg", "(", "RestoreGPRs", ".", "LowGPR", ",", "RegState", "::", "Define", ")", ";", "MIB", ".", "addReg", "(", "RestoreGPRs", ".", "HighGPR", ",", "RegState", "::", "Define", ")", ";", "MIB", ".", "addReg", "(", "Regs", ".", "getStackPointerRegister", "(", ")", ")", ";", "MIB", ".", "addImm", "(", "Regs", ".", "getStackPointerBias", "(", ")", "+", "RestoreGPRs", ".", "GPROffset", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "CSI", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Register", "Reg", "=", "CSI", "[", "I", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", ">", "RestoreGPRs", ".", "LowGPR", "&&", "Reg", "<", "RestoreGPRs", ".", "HighGPR", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "restoreCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "restore", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "load", "instructions", "via", "loadRegToStackSlot", "(", ")", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "0", "SystemZ::FP64BitRegClass", "SystemZ::FP64BitRegClass", "SystemZ::VR128BitRegClass", "SystemZ::VR128BitRegClass", "SystemZ::GPRRegs", "20", "SystemZ::LG", "0", "SystemZ::LMG", "0" ]

[]

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

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

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

[]

[ "<s>", "void", "setupMF", "(", "MachineFunction", "&", "MF", ",", "GISelKnownBits", "&", "KB", ",", "CodeGenCoverage", "&", "CoverageInfo", ")", "override", "{", "InstructionSelector", "::", "setupMF", "(", "MF", ",", "KB", ",", "CoverageInfo", ")", ";", "ProduceNonFlagSettingCondBr", "=", "!", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "SpeculativeLoadHardening", ")", ";", "MFReturnAddr", "=", "Register", "(", ")", ";", "}", "</s>" ]

[ "Setup", "per-MF", "executor", "state", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "&", "MI", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown rematerializable operation!\"", ")", ";", "break", ";", "case", "PPC", "::", "LI", ":", "case", "PPC", "::", "LI8", ":", "case", "PPC", "::", "LIS", ":", "case", "PPC", "::", "LIS8", ":", "case", "PPC", "::", "QVGPCI", ":", "case", "PPC", "::", "ADDIStocHA", ":", "case", "PPC", "::", "ADDItocL", ":", "case", "PPC", "::", "LOAD_STACK_GUARD", ":", "case", "PPC", "::", "XXLXORz", ":", "case", "PPC", "::", "XXLXORspz", ":", "case", "PPC", "::", "XXLXORdpz", ":", "case", "PPC", "::", "V_SET0B", ":", "case", "PPC", "::", "V_SET0H", ":", "case", "PPC", "::", "V_SET0", ":", "case", "PPC", "::", "V_SETALLONESB", ":", "case", "PPC", "::", "V_SETALLONESH", ":", "case", "PPC", "::", "V_SETALLONES", ":", "case", "PPC", "::", "CRSET", ":", "case", "PPC", "::", "CRUNSET", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "For", "instructions", "with", "opcodes", "for", "which", "the", "M_REMATERIALIZABLE", "flag", "is", "set", ",", "this", "hook", "lets", "the", "target", "specify", "whether", "the", "instruction", "is", "actually", "trivially", "rematerializable", ",", "taking", "into", "consideration", "its", "operands", "." ]

[ "PowerPC", "PPC", "\"Unknown rematerializable operation!\"", "PPC::LI", "PPC::LI8", "PPC::LIS", "PPC::LIS8", "PPC::QVGPCI", "PPC::ADDIStocHA", "PPC::ADDItocL", "PPC::LOAD_STACK_GUARD", "PPC::XXLXORz", "PPC::XXLXORspz", "PPC::XXLXORdpz", "PPC::V_SET0B", "PPC::V_SET0H", "PPC::V_SET0", "PPC::V_SETALLONESB", "PPC::V_SETALLONESH", "PPC::V_SETALLONES", "PPC::CRSET", "PPC::CRUNSET" ]

[]

[ "<s>", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "override", "{", "return", "getSubtargetImpl", "(", ")", "->", "getDataLayout", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "Sparc" ]

[]

[ "<s>", "bool", "VEAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "applyMnemonicAliases", "(", "Name", ",", "getAvailableFeatures", "(", ")", ",", "0", ")", ";", "StringRef", "Mnemonic", "=", "splitMnemonic", "(", "Name", ",", "NameLoc", ",", "&", "Operands", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "parseOperand", "(", "Operands", ",", "Mnemonic", ")", "!=", "MatchOperand_Success", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Mnemonic", ")", "!=", "MatchOperand_Success", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "VE", "VE", "0", "\"unexpected token\"", "\"unexpected token\"", "\"unexpected token\"" ]

[]

[ "<s>", "const", "char", "*", "msp430_mcu_name", "(", "void", ")", "{", "if", "(", "target_mcu", ")", "{", "unsigned", "int", "i", ";", "static", "char", "mcu_name", "[", "64", "]", ";", "snprintf", "(", "mcu_name", ",", "sizeof", "(", "mcu_name", ")", "-", "1", ",", "\"__%s__\"", ",", "target_mcu", ")", ";", "for", "(", "i", "=", "strlen", "(", "mcu_name", ")", ";", "i", "--", ";", ")", "mcu_name", "[", "i", "]", "=", "TOUPPER", "(", "mcu_name", "[", "i", "]", ")", ";", "return", "mcu_name", ";", "}", "return", "msp430x", "?", "\"__MSP430XGENERIC__\"", ":", "\"__MSP430GENERIC__\"", ";", "}", "</s>" ]

[ "Generate", "a", "C", "preprocessor", "symbol", "based", "upon", "the", "MCU", "selected", "by", "the", "user", ".", "If", "a", "specific", "MCU", "has", "not", "been", "selected", "then", "return", "a", "generic", "symbol", "instead", "." ]

[ "msp430", "64", "1", "\"__%s__\"", "\"__MSP430XGENERIC__\"", "\"__MSP430GENERIC__\"" ]

[]

[ "<s>", "static", "void", "register_svpattern", "(", ")", "{", "auto_vec", "<", "string_int_pair", ",", "32", ">", "values", ";", "values", ".", "quick_push", "(", "string_int_pair", "(", "\"SV_\"", "#", "UPPER", ",", "VALUE", ")", ")", ";", "AARCH64_FOR_SVPATTERN", "(", "PUSH", ")", "acle_svpattern", "=", "lang_hooks", ".", "types", ".", "simulate_enum_decl", "(", "input_location", ",", "\"svpattern\"", ",", "values", ")", ";", "}", "</s>" ]

[ "Register", "the", "svpattern", "enum", "." ]

[ "aarch64", "32", "\"SV_\"", "\"svpattern\"" ]

[]

[ "<s>", "RegisterAggr", "&", "RegisterAggr", "::", "intersect", "(", "const", "RegisterAggr", "&", "RG", ")", "{", "Units", "&=", "RG", ".", "Units", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "Intersect", "this", "set", "with", "a", "temporary", "other", "set", "in", "place", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "ix86_target_macros", "(", "void", ")", "{", "if", "(", "TARGET_64BIT", ")", "{", "cpp_assert", "(", "parse_in", ",", "\"cpu=x86_64\"", ")", ";", "cpp_assert", "(", "parse_in", ",", "\"machine=x86_64\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__amd64\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__amd64__\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__x86_64\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__x86_64__\"", ")", ";", "if", "(", "TARGET_X32", ")", "{", "cpp_define", "(", "parse_in", ",", "\"_ILP32\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__ILP32__\"", ")", ";", "}", "}", "else", "{", "cpp_assert", "(", "parse_in", ",", "\"cpu=i386\"", ")", ";", "cpp_assert", "(", "parse_in", ",", "\"machine=i386\"", ")", ";", "builtin_define_std", "(", "\"i386\"", ")", ";", "}", "if", "(", "!", "TARGET_80387", ")", "cpp_define", "(", "parse_in", ",", "\"_SOFT_FLOAT\"", ")", ";", "if", "(", "TARGET_LONG_DOUBLE_64", ")", "cpp_define", "(", "parse_in", ",", "\"__LONG_DOUBLE_64__\"", ")", ";", "if", "(", "TARGET_LONG_DOUBLE_128", ")", "cpp_define", "(", "parse_in", ",", "\"__LONG_DOUBLE_128__\"", ")", ";", "if", "(", "TARGET_128BIT_LONG_DOUBLE", ")", "cpp_define", "(", "parse_in", ",", "\"__SIZEOF_FLOAT80__=16\"", ")", ";", "else", "cpp_define", "(", "parse_in", ",", "\"__SIZEOF_FLOAT80__=12\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__SIZEOF_FLOAT128__=16\"", ")", ";", "cpp_define_formatted", "(", "parse_in", ",", "\"__ATOMIC_HLE_ACQUIRE=%d\"", ",", "IX86_HLE_ACQUIRE", ")", ";", "cpp_define_formatted", "(", "parse_in", ",", "\"__ATOMIC_HLE_RELEASE=%d\"", ",", "IX86_HLE_RELEASE", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__GCC_ASM_FLAG_OUTPUTS__\"", ")", ";", "ix86_target_macros_internal", "(", "ix86_isa_flags", ",", "ix86_arch", ",", "ix86_tune", ",", "ix86_fpmath", ",", "cpp_define", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__SEG_FS\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__SEG_GS\"", ")", ";", "}", "</s>" ]

[ "Function", "to", "tell", "the", "preprocessor", "about", "the", "defines", "for", "the", "current", "target", "." ]

[ "i386", "\"cpu=x86_64\"", "\"machine=x86_64\"", "\"__amd64\"", "\"__amd64__\"", "\"__x86_64\"", "\"__x86_64__\"", "\"_ILP32\"", "\"__ILP32__\"", "\"cpu=i386\"", "\"machine=i386\"", "\"i386\"", "\"_SOFT_FLOAT\"", "\"__LONG_DOUBLE_64__\"", "\"__LONG_DOUBLE_128__\"", "\"__SIZEOF_FLOAT80__=16\"", "\"__SIZEOF_FLOAT80__=12\"", "\"__SIZEOF_FLOAT128__=16\"", "\"__ATOMIC_HLE_ACQUIRE=%d\"", "\"__ATOMIC_HLE_RELEASE=%d\"", "\"__GCC_ASM_FLAG_OUTPUTS__\"", "\"__SEG_FS\"", "\"__SEG_GS\"" ]

[]

[ "<s>", "void", "SparcCodeEmitter", "::", "emitInstruction", "(", "MachineBasicBlock", "::", "instr_iterator", "MI", ",", "MachineBasicBlock", "&", "MBB", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"JIT: \"", "<<", "(", "void", "*", ")", "MCE", ".", "getCurrentPCValue", "(", ")", "<<", "\":\\t\"", "<<", "*", "MI", ")", ";", "MCE", ".", "processDebugLoc", "(", "MI", "->", "getDebugLoc", "(", ")", ",", "true", ")", ";", "++", "NumEmitted", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "{", "emitWord", "(", "getBinaryCodeForInstr", "(", "*", "MI", ")", ")", ";", "break", ";", "}", "case", "TargetOpcode", "::", "INLINEASM", ":", "{", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", "[", "0", "]", ")", "{", "report_fatal_error", "(", "\"JIT does not support inline asm!\"", ")", ";", "}", "break", ";", "}", "case", "TargetOpcode", "::", "PROLOG_LABEL", ":", "case", "TargetOpcode", "::", "EH_LABEL", ":", "{", "MCE", ".", "emitLabel", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getMCSymbol", "(", ")", ")", ";", "break", ";", "}", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "{", "break", ";", "}", "case", "SP", "::", "GETPCX", ":", "{", "report_fatal_error", "(", "\"JIT does not support pseudo instruction GETPCX yet!\"", ")", ";", "break", ";", "}", "}", "MCE", ".", "processDebugLoc", "(", "MI", "->", "getDebugLoc", "(", ")", ",", "false", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "\"JIT: \"", "\":\\t\"", "0", "0", "\"JIT does not support inline asm!\"", "0", "SP::GETPCX", "\"JIT does not support pseudo instruction GETPCX yet!\"" ]

[]

[ "<s>", "rtx", "legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", ",", "enum", "machine_mode", "mode", ")", "{", "x", "=", "oldx", ";", "if", "(", "TARGET_ALL_DEBUG", ")", "{", "fprintf", "(", "stderr", ",", "\"legitimize_address mode: %s\"", ",", "GET_MODE_NAME", "(", "mode", ")", ")", ";", "debug_rtx", "(", "oldx", ")", ";", "}", "if", "(", "GET_CODE", "(", "oldx", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "oldx", ",", "0", ")", ")", ")", "{", "if", "(", "REG_P", "(", "XEXP", "(", "oldx", ",", "1", ")", ")", ")", "x", "=", "force_reg", "(", "GET_MODE", "(", "oldx", ")", ",", "oldx", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "oldx", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "int", "offs", "=", "INTVAL", "(", "XEXP", "(", "oldx", ",", "1", ")", ")", ";", "if", "(", "frame_pointer_rtx", "!=", "XEXP", "(", "oldx", ",", "0", ")", ")", "if", "(", "offs", ">", "MAX_LD_OFFSET", "(", "mode", ")", ")", "{", "if", "(", "TARGET_ALL_DEBUG", ")", "fprintf", "(", "stderr", ",", "\"force_reg (big offset)\\n\"", ")", ";", "x", "=", "force_reg", "(", "GET_MODE", "(", "oldx", ")", ",", "oldx", ")", ";", "}", "}", "}", "return", "x", ";", "}", "</s>" ]

[ "Try", "machine-dependent", "ways", "of", "modifying", "an", "illegitimate", "address", "X", "to", "be", "legitimate", ".", "If", "we", "find", "one", ",", "return", "the", "new", ",", "valid", "address", ".", "OLDX", "is", "the", "address", "as", "it", "was", "before", "break_out_memory_refs", "was", "called", ".", "In", "some", "cases", "it", "is", "useful", "to", "look", "at", "this", "to", "decide", "what", "needs", "to", "be", "done", ".", "MODE", "is", "the", "mode", "of", "the", "operand", "pointed", "to", "by", "X", "." ]

[ "avr", "\"legitimize_address mode: %s\"", "0", "1", "1", "1", "0", "\"force_reg (big offset)\\n\"" ]

[]

[ "<s>", "const", "Thumb2RegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "RI", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "ARM" ]

[]

[ "<s>", "void", "PPCFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "const", "PPCRegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "PPCFunctionInfo", "*", "FI", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "unsigned", "LR", "=", "RegInfo", "->", "getRARegister", "(", ")", ";", "FI", "->", "setMustSaveLR", "(", "MustSaveLR", "(", "MF", ",", "LR", ")", ")", ";", "SavedRegs", ".", "reset", "(", "LR", ")", ";", "int", "FPSI", "=", "FI", "->", "getFramePointerSaveIndex", "(", ")", ";", "const", "bool", "isPPC64", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "const", "bool", "IsDarwinABI", "=", "Subtarget", ".", "isDarwinABI", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "FPSI", "&&", "needsFP", "(", "MF", ")", ")", "{", "int", "FPOffset", "=", "getFramePointerSaveOffset", "(", ")", ";", "FPSI", "=", "MFI", ".", "CreateFixedObject", "(", "isPPC64", "?", "8", ":", "4", ",", "FPOffset", ",", "true", ")", ";", "FI", "->", "setFramePointerSaveIndex", "(", "FPSI", ")", ";", "}", "int", "BPSI", "=", "FI", "->", "getBasePointerSaveIndex", "(", ")", ";", "if", "(", "!", "BPSI", "&&", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "int", "BPOffset", "=", "getBasePointerSaveOffset", "(", ")", ";", "BPSI", "=", "MFI", ".", "CreateFixedObject", "(", "isPPC64", "?", "8", ":", "4", ",", "BPOffset", ",", "true", ")", ";", "FI", "->", "setBasePointerSaveIndex", "(", "BPSI", ")", ";", "}", "if", "(", "FI", "->", "usesPICBase", "(", ")", ")", "{", "int", "PBPSI", "=", "MFI", ".", "CreateFixedObject", "(", "4", ",", "-", "8", ",", "true", ")", ";", "FI", "->", "setPICBasePointerSaveIndex", "(", "PBPSI", ")", ";", "}", "if", "(", "needsFP", "(", "MF", ")", ")", "SavedRegs", ".", "reset", "(", "isPPC64", "?", "PPC", "::", "X31", ":", "PPC", "::", "R31", ")", ";", "if", "(", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "SavedRegs", ".", "reset", "(", "RegInfo", "->", "getBaseRegister", "(", "MF", ")", ")", ";", "if", "(", "FI", "->", "usesPICBase", "(", ")", ")", "SavedRegs", ".", "reset", "(", "PPC", "::", "R30", ")", ";", "int", "TCSPDelta", "=", "0", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", "&&", "(", "TCSPDelta", "=", "FI", "->", "getTailCallSPDelta", "(", ")", ")", "<", "0", ")", "{", "MFI", ".", "CreateFixedObject", "(", "-", "1", "*", "TCSPDelta", ",", "TCSPDelta", ",", "true", ")", ";", "}", "if", "(", "!", "isPPC64", "&&", "!", "IsDarwinABI", "&&", "(", "SavedRegs", ".", "test", "(", "PPC", "::", "CR2", ")", "||", "SavedRegs", ".", "test", "(", "PPC", "::", "CR3", ")", "||", "SavedRegs", ".", "test", "(", "PPC", "::", "CR4", ")", ")", ")", "{", "int", "FrameIdx", "=", "MFI", ".", "CreateFixedObject", "(", "(", "uint64_t", ")", "4", ",", "(", "int64_t", ")", "-", "4", ",", "true", ")", ";", "FI", "->", "setCRSpillFrameIndex", "(", "FrameIdx", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "8", "4", "PPC", "8", "4", "4", "8", "PPC", "PPC::X31", "PPC::R31", "PPC::R30", "0", "0", "1", "PPC", "PPC::CR2", "PPC::CR3", "PPC::CR4", "4", "4" ]

[]

[ "<s>", "static", "void", "h8300_conditional_register_usage", "(", "void", ")", "{", "if", "(", "!", "TARGET_MAC", ")", "fixed_regs", "[", "MAC_REG", "]", "=", "call_used_regs", "[", "MAC_REG", "]", "=", "1", ";", "}", "</s>" ]

[ "Conditionally", "modify", "register", "usage", "based", "on", "target", "flags", "." ]

[ "h8300", "1" ]

[]

[ "<s>", "MachineInstr", "*", "SIInstrInfo", "::", "commuteInstruction", "(", "MachineInstr", "*", "MI", ",", "bool", "NewMI", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "if", "(", "MI", "->", "getNumOperands", "(", ")", "<", "3", "||", "!", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ")", "return", "0", ";", "if", "(", "isVOP2", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "RI", ".", "isSGPRClass", "(", "MRI", ".", "getRegClass", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", ")", "return", "0", ";", "if", "(", "!", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", ")", "{", "if", "(", "NewMI", "||", "MI", "->", "getOperand", "(", "2", ")", ".", "isFPImm", "(", ")", "||", "(", "!", "isVOP2", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "!", "isVOP3", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ")", "{", "return", "0", ";", "}", "if", "(", "isVOP3", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "(", "MI", "->", "getOperand", "(", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "abs", ")", ")", ".", "getImm", "(", ")", "||", "MI", "->", "getOperand", "(", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "neg", ")", ")", ".", "getImm", "(", ")", ")", ")", "return", "0", ";", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "unsigned", "SubReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getSubReg", "(", ")", ";", "MI", "->", "getOperand", "(", "1", ")", ".", "ChangeToImmediate", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ")", ";", "MI", "->", "getOperand", "(", "2", ")", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "MI", "->", "getOperand", "(", "2", ")", ".", "setSubReg", "(", "SubReg", ")", ";", "}", "else", "{", "MI", "=", "TargetInstrInfo", "::", "commuteInstruction", "(", "MI", ",", "NewMI", ")", ";", "}", "if", "(", "MI", ")", "MI", "->", "setDesc", "(", "get", "(", "commuteOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ")", ";", "return", "MI", ";", "}", "</s>" ]

[ "This", "method", "commutes", "the", "operands", "of", "the", "given", "machine", "instruction", "MI", "." ]

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

[]

[ "<s>", "X86Subtarget", "&", "X86Subtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "initSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "WebAssemblyAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"EmitInstruction: \"", "<<", "*", "MI", "<<", "'\\n'", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "ARGUMENT_I32", ":", "case", "WebAssembly", "::", "ARGUMENT_I64", ":", "case", "WebAssembly", "::", "ARGUMENT_F32", ":", "case", "WebAssembly", "::", "ARGUMENT_F64", ":", "case", "WebAssembly", "::", "ARGUMENT_v16i8", ":", "case", "WebAssembly", "::", "ARGUMENT_v8i16", ":", "case", "WebAssembly", "::", "ARGUMENT_v4i32", ":", "case", "WebAssembly", "::", "ARGUMENT_v4f32", ":", "break", ";", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_I32", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_I64", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_F32", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_F64", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v16i8", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v8i16", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v4i32", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v4f32", ":", "{", "assert", "(", "MFI", "->", "isVRegStackified", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", ";", "if", "(", "isVerbose", "(", ")", ")", "{", "OutStreamer", "->", "AddComment", "(", "\"fallthrough-return: $pop\"", "+", "Twine", "(", "MFI", "->", "getWARegStackId", "(", "MFI", "->", "getWAReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", ")", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "break", ";", "}", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_VOID", ":", "if", "(", "isVerbose", "(", ")", ")", "{", "OutStreamer", "->", "AddComment", "(", "\"fallthrough-return\"", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "break", ";", "default", ":", "{", "WebAssemblyMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"EmitInstruction: \"", "WebAssembly::ARGUMENT_I32", "WebAssembly::ARGUMENT_I64", "WebAssembly::ARGUMENT_F32", "WebAssembly::ARGUMENT_F64", "WebAssembly::ARGUMENT_v16i8", "WebAssembly::ARGUMENT_v8i16", "WebAssembly::ARGUMENT_v4i32", "WebAssembly::ARGUMENT_v4f32", "WebAssembly::FALLTHROUGH_RETURN_I32", "WebAssembly::FALLTHROUGH_RETURN_I64", "WebAssembly::FALLTHROUGH_RETURN_F32", "WebAssembly::FALLTHROUGH_RETURN_F64", "WebAssembly::FALLTHROUGH_RETURN_v16i8", "WebAssembly::FALLTHROUGH_RETURN_v8i16", "WebAssembly::FALLTHROUGH_RETURN_v4i32", "WebAssembly::FALLTHROUGH_RETURN_v4f32", "0", "\"fallthrough-return: $pop\"", "0", "WebAssembly::FALLTHROUGH_RETURN_VOID", "\"fallthrough-return\"", "WebAssembly" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "return", "createELFObjectWriter", "(", "OS", ",", "false", ",", "OSType", ",", "ELF", "::", "EM_MBLAZE", ",", "false", ",", "true", ")", ";", "}", "</s>" ]

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

[ "MBlaze" ]

[]

[ "<s>", "const", "ARMSubtarget", "*", "ARMBaseTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "CPUAttr", ".", "isValid", "(", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "FSAttr", ".", "isValid", "(", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "bool", "SoftFloat", "=", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ".", "getValueAsBool", "(", ")", ";", "if", "(", "SoftFloat", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\",+soft-float\"", ";", "std", "::", "string", "Key", "=", "CPU", "+", "FS", ";", "if", "(", "F", ".", "hasMinSize", "(", ")", ")", "Key", "+=", "\"+minsize\"", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "ARMSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "isLittle", ",", "F", ".", "hasMinSize", "(", ")", ")", ";", "if", "(", "!", "I", "->", "isThumb", "(", ")", "&&", "!", "I", "->", "hasARMOps", "(", ")", ")", "F", ".", "getContext", "(", ")", ".", "emitError", "(", "\"Function '\"", "+", "F", ".", "getName", "(", ")", "+", "\"' uses ARM \"", "\"instructions, but the target does not support ARM mode execution.\"", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "\"target-cpu\"", "\"target-features\"", "\"use-soft-float\"", "\"+soft-float\"", "\",+soft-float\"", "\"+minsize\"", "ARM", "ARM", "\"Function '\"", "\"' uses ARM \"", "\"instructions, but the target does not support ARM mode execution.\"" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "DLXAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "static", "const", "MCFixupKindInfo", "Infos", "[", "DLX", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"FIXUP_DLX_NONE\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"FIXUP_DLX_21\"", ",", "16", ",", "16", ",", "0", "}", ",", "{", "\"FIXUP_DLX_21_F\"", ",", "16", ",", "16", ",", "0", "}", ",", "{", "\"FIXUP_DLX_25\"", ",", "7", ",", "25", ",", "0", "}", ",", "{", "\"FIXUP_DLX_32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"FIXUP_DLX_HI16\"", ",", "16", ",", "16", ",", "0", "}", ",", "{", "\"FIXUP_DLX_LO16\"", ",", "16", ",", "16", ",", "0", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "DLX", "DLX", "DLX::NumTargetFixupKinds", "\"FIXUP_DLX_NONE\"", "0", "32", "0", "\"FIXUP_DLX_21\"", "16", "16", "0", "\"FIXUP_DLX_21_F\"", "16", "16", "0", "\"FIXUP_DLX_25\"", "7", "25", "0", "\"FIXUP_DLX_32\"", "0", "32", "0", "\"FIXUP_DLX_HI16\"", "16", "16", "0", "\"FIXUP_DLX_LO16\"", "16", "16", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "static", "void", "rs6000_init_dwarf_reg_sizes_extra", "(", "tree", "address", ")", "{", "if", "(", "TARGET_SPE", ")", "{", "int", "i", ";", "machine_mode", "mode", "=", "TYPE_MODE", "(", "char_type_node", ")", ";", "rtx", "addr", "=", "expand_expr", "(", "address", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "rtx", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "addr", ")", ";", "rtx", "value", "=", "gen_int_mode", "(", "4", ",", "mode", ")", ";", "for", "(", "i", "=", "FIRST_SPE_HIGH_REGNO", ";", "i", "<", "LAST_SPE_HIGH_REGNO", "+", "1", ";", "i", "++", ")", "{", "int", "column", "=", "DWARF_REG_TO_UNWIND_COLUMN", "(", "DWARF2_FRAME_REG_OUT", "(", "DWARF_FRAME_REGNUM", "(", "i", ")", ",", "true", ")", ")", ";", "HOST_WIDE_INT", "offset", "=", "column", "*", "GET_MODE_SIZE", "(", "mode", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "mem", ",", "mode", ",", "offset", ")", ",", "value", ")", ";", "}", "}", "if", "(", "TARGET_MACHO", "&&", "!", "TARGET_ALTIVEC", ")", "{", "int", "i", ";", "machine_mode", "mode", "=", "TYPE_MODE", "(", "char_type_node", ")", ";", "rtx", "addr", "=", "expand_expr", "(", "address", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "rtx", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "addr", ")", ";", "rtx", "value", "=", "gen_int_mode", "(", "16", ",", "mode", ")", ";", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", ";", "i", "<", "LAST_ALTIVEC_REGNO", "+", "1", ";", "i", "++", ")", "{", "int", "column", "=", "DWARF_REG_TO_UNWIND_COLUMN", "(", "DWARF2_FRAME_REG_OUT", "(", "DWARF_FRAME_REGNUM", "(", "i", ")", ",", "true", ")", ")", ";", "HOST_WIDE_INT", "offset", "=", "column", "*", "GET_MODE_SIZE", "(", "mode", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "mem", ",", "mode", ",", "offset", ")", ",", "value", ")", ";", "}", "}", "}", "</s>" ]

[ "Fill", "in", "sizes", "of", "registers", "used", "by", "unwinder", "." ]

[ "rs6000", "4", "1", "16", "1" ]

[]

[ "<s>", "void", "rs6000_sibcall_aix", "(", "rtx", "value", ",", "rtx", "func_desc", ",", "rtx", "tlsarg", ",", "rtx", "cookie", ")", "{", "rtx", "call", "[", "2", "]", ";", "rtx", "insn", ";", "rtx", "r12", "=", "NULL_RTX", ";", "rtx", "func_addr", "=", "func_desc", ";", "gcc_assert", "(", "INTVAL", "(", "cookie", ")", "==", "0", ")", ";", "if", "(", "global_tlsarg", ")", "tlsarg", "=", "global_tlsarg", ";", "if", "(", "GET_CODE", "(", "func_desc", ")", "!=", "SYMBOL_REF", "&&", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "{", "r12", "=", "gen_rtx_REG", "(", "Pmode", ",", "12", ")", ";", "emit_move_insn", "(", "r12", ",", "func_desc", ")", ";", "func_addr", "=", "gen_rtx_REG", "(", "Pmode", ",", "CTR_REGNO", ")", ";", "emit_move_insn", "(", "func_addr", ",", "r12", ")", ";", "}", "call", "[", "0", "]", "=", "gen_rtx_CALL", "(", "VOIDmode", ",", "gen_rtx_MEM", "(", "SImode", ",", "func_addr", ")", ",", "tlsarg", ")", ";", "if", "(", "value", "!=", "NULL_RTX", ")", "call", "[", "0", "]", "=", "gen_rtx_SET", "(", "value", ",", "call", "[", "0", "]", ")", ";", "call", "[", "1", "]", "=", "simple_return_rtx", ";", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec_v", "(", "2", ",", "call", ")", ")", ";", "insn", "=", "emit_call_insn", "(", "insn", ")", ";", "if", "(", "!", "rs6000_pcrel_p", "(", ")", ")", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "TOC_REGNUM", ")", ")", ";", "if", "(", "r12", ")", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "r12", ")", ";", "}", "</s>" ]

[ "Expand", "code", "to", "perform", "a", "sibling", "call", "under", "the", "AIX", "or", "ELFv2", "ABI", "." ]

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

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsZeroVal", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "IsZeroVal", "&&", "!", "F", "->", "hasFnAttr", "(", "Attribute", "::", "NoImplicitFloat", ")", ")", "{", "if", "(", "Size", ">=", "16", "&&", "(", "Subtarget", "->", "isUnalignedMemAccessFast", "(", ")", "||", "(", "(", "DstAlign", "==", "0", "||", "DstAlign", ">=", "16", ")", "&&", "(", "SrcAlign", "==", "0", "||", "SrcAlign", ">=", "16", ")", ")", ")", "&&", "Subtarget", "->", "getStackAlignment", "(", ")", ">=", "16", ")", "{", "if", "(", "Subtarget", "->", "hasAVX", "(", ")", "&&", "Subtarget", "->", "getStackAlignment", "(", ")", ">=", "32", ")", "return", "MVT", "::", "v8f32", ";", "if", "(", "Subtarget", "->", "hasXMMInt", "(", ")", ")", "return", "MVT", "::", "v4i32", ";", "if", "(", "Subtarget", "->", "hasXMM", "(", ")", ")", "return", "MVT", "::", "v4f32", ";", "}", "else", "if", "(", "!", "MemcpyStrSrc", "&&", "Size", ">=", "8", "&&", "!", "Subtarget", "->", "is64Bit", "(", ")", "&&", "Subtarget", "->", "getStackAlignment", "(", ")", ">=", "8", "&&", "Subtarget", "->", "hasXMMInt", "(", ")", ")", "{", "return", "MVT", "::", "f64", ";", "}", "}", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", "&&", "Size", ">=", "8", ")", "return", "MVT", "::", "i64", ";", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "X86", "X86", "16", "0", "16", "0", "16", "16", "32", "MVT::v8f32", "MVT::v4i32", "MVT::v4f32", "8", "8", "MVT::f64", "8", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "static", "void", "som_output_comdat_data_section_asm_op", "(", "const", "char", "*", "data", ")", "{", "in_section", "=", "NULL", ";", "output_section_asm_op", "(", "data", ")", ";", "}", "</s>" ]

[ "A", "get_unnamed_section", "callback", "for", "switching", "to", "comdat", "data", "sections", ".", "This", "function", "is", "only", "used", "with", "SOM", "." ]

[ "pa" ]

[]