Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "OptimizeLEAPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "if", "(", "!", "EnableX86LEAOpt", "||", "!", "MF", ".", "getFunction", "(", ")", "->", "optForSize", "(", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "SmallVector", "<", "MachineInstr", "*", ",", "16", ">", "LEAs", ";", "findLEAs", "(", "MBB", ",", "LEAs", ")", ";", "if", "(", "LEAs", ".", "empty", "(", ")", ")", "continue", ";", "Changed", "|=", "removeRedundantAddrCalc", "(", "LEAs", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

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

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

[ "Lanai" ]

[]

[ "<s>", "const", "char", "*", "lshrqi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "int", "k", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "8", ")", "break", ";", "*", "len", "=", "1", ";", "return", "\"clr %0\"", ";", "case", "1", ":", "*", "len", "=", "1", ";", "return", "\"lsr %0\"", ";", "case", "2", ":", "*", "len", "=", "2", ";", "return", "(", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", ")", ";", "case", "3", ":", "*", "len", "=", "3", ";", "return", "(", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", ")", ";", "case", "4", ":", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "0", "]", ")", ")", "{", "*", "len", "=", "2", ";", "return", "(", "\"swap %0\"", "CR_TAB", "\"andi %0,0x0f\"", ")", ";", "}", "*", "len", "=", "4", ";", "return", "(", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", ")", ";", "case", "5", ":", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "0", "]", ")", ")", "{", "*", "len", "=", "3", ";", "return", "(", "\"swap %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"andi %0,0x7\"", ")", ";", "}", "*", "len", "=", "5", ";", "return", "(", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", ")", ";", "case", "6", ":", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "0", "]", ")", ")", "{", "*", "len", "=", "4", ";", "return", "(", "\"swap %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"andi %0,0x3\"", ")", ";", "}", "*", "len", "=", "6", ";", "return", "(", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", ")", ";", "case", "7", ":", "*", "len", "=", "3", ";", "return", "(", "\"rol %0\"", "CR_TAB", "\"clr %0\"", "CR_TAB", "\"rol %0\"", ")", ";", "}", "}", "else", "if", "(", "CONSTANT_P", "(", "operands", "[", "2", "]", ")", ")", "fatal_insn", "(", "\"internal compiler error. Incorrect shift:\"", ",", "insn", ")", ";", "out_shift_with_cnt", "(", "\"lsr %0\"", ",", "insn", ",", "operands", ",", "len", ",", "1", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "8bit", "logic", "shift", "right", "(", "(", "unsigned", "char", ")", "x", ">", ">", "i", ")" ]

[ "avr", "2", "2", "2", "8", "1", "\"clr %0\"", "1", "1", "\"lsr %0\"", "2", "2", "\"lsr %0\"", "\"lsr %0\"", "3", "3", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "4", "0", "2", "\"swap %0\"", "\"andi %0,0x0f\"", "4", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "5", "0", "3", "\"swap %0\"", "\"lsr %0\"", "\"andi %0,0x7\"", "5", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "6", "0", "4", "\"swap %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"andi %0,0x3\"", "6", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "7", "3", "\"rol %0\"", "\"clr %0\"", "\"rol %0\"", "2", "\"internal compiler error. Incorrect shift:\"", "\"lsr %0\"", "1", "\"\"" ]

[]

[ "<s>", "static", "rtx", "emit_memmov", "(", "rtx", "destmem", ",", "rtx", "*", "srcmem", ",", "rtx", "destptr", ",", "rtx", "srcptr", ",", "HOST_WIDE_INT", "size_to_move", ")", "{", "rtx", "dst", "=", "destmem", ",", "src", "=", "*", "srcmem", ",", "adjust", ",", "tempreg", ";", "enum", "insn_code", "code", ";", "machine_mode", "move_mode", ";", "int", "piece_size", ",", "i", ";", "piece_size", "=", "1", "<<", "floor_log2", "(", "size_to_move", ")", ";", "move_mode", "=", "mode_for_size", "(", "piece_size", "*", "BITS_PER_UNIT", ",", "MODE_INT", ",", "0", ")", ";", "code", "=", "optab_handler", "(", "mov_optab", ",", "move_mode", ")", ";", "while", "(", "code", "==", "CODE_FOR_nothing", "&&", "piece_size", ">", "1", ")", "{", "piece_size", ">>=", "1", ";", "move_mode", "=", "mode_for_size", "(", "piece_size", "*", "BITS_PER_UNIT", ",", "MODE_INT", ",", "0", ")", ";", "code", "=", "optab_handler", "(", "mov_optab", ",", "move_mode", ")", ";", "}", "if", "(", "GET_MODE_SIZE", "(", "move_mode", ")", ">", "GET_MODE_SIZE", "(", "word_mode", ")", ")", "{", "int", "nunits", "=", "GET_MODE_SIZE", "(", "move_mode", ")", "/", "GET_MODE_SIZE", "(", "word_mode", ")", ";", "move_mode", "=", "mode_for_vector", "(", "word_mode", ",", "nunits", ")", ";", "code", "=", "optab_handler", "(", "mov_optab", ",", "move_mode", ")", ";", "if", "(", "code", "==", "CODE_FOR_nothing", ")", "{", "move_mode", "=", "word_mode", ";", "piece_size", "=", "GET_MODE_SIZE", "(", "move_mode", ")", ";", "code", "=", "optab_handler", "(", "mov_optab", ",", "move_mode", ")", ";", "}", "}", "gcc_assert", "(", "code", "!=", "CODE_FOR_nothing", ")", ";", "dst", "=", "adjust_automodify_address_nv", "(", "dst", ",", "move_mode", ",", "destptr", ",", "0", ")", ";", "src", "=", "adjust_automodify_address_nv", "(", "src", ",", "move_mode", ",", "srcptr", ",", "0", ")", ";", "gcc_assert", "(", "size_to_move", "%", "piece_size", "==", "0", ")", ";", "adjust", "=", "GEN_INT", "(", "piece_size", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "size_to_move", ";", "i", "+=", "piece_size", ")", "{", "tempreg", "=", "gen_reg_rtx", "(", "move_mode", ")", ";", "emit_insn", "(", "GEN_FCN", "(", "code", ")", "(", "tempreg", ",", "src", ")", ")", ";", "emit_insn", "(", "GEN_FCN", "(", "code", ")", "(", "dst", ",", "tempreg", ")", ")", ";", "emit_move_insn", "(", "destptr", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "copy_rtx", "(", "destptr", ")", ",", "adjust", ")", ")", ";", "emit_move_insn", "(", "srcptr", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "copy_rtx", "(", "srcptr", ")", ",", "adjust", ")", ")", ";", "dst", "=", "adjust_automodify_address_nv", "(", "dst", ",", "move_mode", ",", "destptr", ",", "piece_size", ")", ";", "src", "=", "adjust_automodify_address_nv", "(", "src", ",", "move_mode", ",", "srcptr", ",", "piece_size", ")", ";", "}", "*", "srcmem", "=", "src", ";", "return", "dst", ";", "}", "</s>" ]

[ "This", "function", "emits", "moves", "to", "copy", "SIZE_TO_MOVE", "bytes", "from", "SRCMEM", "to", "DESTMEM", ".", "SRC", "is", "passed", "by", "pointer", "to", "be", "updated", "on", "return", ".", "Return", "value", "is", "updated", "DST", "." ]

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

[]

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

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

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

[]

[ "<s>", "static", "rtx", "load_cr_save", "(", "int", "regno", ",", "rtx", "frame_reg_rtx", ",", "int", "offset", ",", "bool", "exit_func", ")", "{", "rtx", "mem", "=", "gen_frame_mem_offset", "(", "SImode", ",", "frame_reg_rtx", ",", "offset", ")", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "rtx_insn", "*", "insn", "=", "emit_move_insn", "(", "reg", ",", "mem", ")", ";", "if", "(", "!", "exit_func", "&&", "DEFAULT_ABI", "==", "ABI_V4", ")", "{", "rtx", "cr", "=", "gen_rtx_REG", "(", "SImode", ",", "CR2_REGNO", ")", ";", "rtx", "set", "=", "gen_rtx_SET", "(", "reg", ",", "cr", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_REGISTER", ",", "set", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "return", "reg", ";", "}", "</s>" ]

[ "Restoring", "cr", "is", "a", "two", "step", "process", ":", "loading", "a", "reg", "from", "the", "frame", "save", ",", "then", "moving", "the", "reg", "to", "cr", ".", "For", "ABI_V4", "we", "must", "let", "the", "unwinder", "know", "that", "the", "stack", "location", "is", "no", "longer", "valid", "at", "or", "before", "the", "stack", "deallocation", ",", "but", "we", "ca", "n't", "emit", "a", "cfa_restore", "for", "cr", "at", "the", "stack", "deallocation", "like", "we", "do", "for", "other", "registers", ".", "The", "trouble", "is", "that", "it", "is", "possible", "for", "the", "move", "to", "cr", "to", "be", "scheduled", "after", "the", "stack", "deallocation", ".", "So", "say", "exactly", "where", "cr", "is", "located", "on", "each", "of", "the", "two", "insns", "." ]

[ "powerpcspe", "1" ]

[]

[ "<s>", "BitVector", "ARMBaseRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "const", "ARMFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "PC", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "FPSCR", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "APSR_NZCV", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "getFramePointerReg", "(", "STI", ")", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "BasePtr", ")", ";", "if", "(", "STI", ".", "isR9Reserved", "(", ")", ")", "Reserved", ".", "set", "(", "ARM", "::", "R9", ")", ";", "if", "(", "!", "STI", ".", "hasVFP3", "(", ")", "||", "STI", ".", "hasD16", "(", ")", ")", "{", "static_assert", "(", "ARM", "::", "D31", "==", "ARM", "::", "D16", "+", "15", ",", "\"Register list not consecutive!\"", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "D16", ",", "ARM", "::", "D31", "+", "1", ")", ";", "}", "const", "TargetRegisterClass", "*", "RC", "=", "&", "ARM", "::", "GPRPairRegClass", ";", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "RC", "->", "begin", "(", ")", ",", "E", "=", "RC", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "for", "(", "MCSubRegIterator", "SI", "(", "*", "I", ",", "this", ")", ";", "SI", ".", "isValid", "(", ")", ";", "++", "SI", ")", "if", "(", "Reserved", ".", "test", "(", "*", "SI", ")", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "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", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM::SP", "ARM::PC", "ARM::FPSCR", "ARM::APSR_NZCV", "ARM::R9", "ARM::D31", "ARM::D16", "15", "\"Register list not consecutive!\"", "ARM::D16", "ARM::D31", "1", "ARM::GPRPairRegClass" ]

[]

[ "<s>", "rtx", "function_arg", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", "ATTRIBUTE_UNUSED", ")", "{", "int", "bytes", "=", "avr_num_arg_regs", "(", "mode", ",", "type", ")", ";", "if", "(", "cum", "->", "nregs", "&&", "bytes", "<=", "cum", "->", "nregs", ")", "return", "gen_rtx_REG", "(", "mode", ",", "cum", "->", "regno", "-", "bytes", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Return", "an", "RTL", "expression", "containing", "the", "register", "for", "the", "given", "mode", ",", "or", "0", "if", "the", "argument", "is", "to", "be", "passed", "on", "the", "stack", ".", "INCOMING_P", "is", "nonzero", "if", "this", "is", "an", "incoming", "argument", "to", "the", "current", "function", "." ]

[ "avr" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Mips OptimizePICCall\"", ";", "}", "</s>" ]

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

[ "Mips", "\"Mips OptimizePICCall\"" ]

[]

[ "<s>", "static", "bool", "rs6000_cannot_force_const_mem", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "HIGH", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "UNSPEC", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "!=", "0", ")", "return", "true", ";", "return", "TARGET_ELF", "&&", "tls_referenced_p", "(", "x", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CANNOT_FORCE_CONST_MEM", "." ]

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

[]

[ "<s>", "const", "ARM64RegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64" ]

[]

[ "<s>", "static", "rtx", "tilegx_function_arg", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "cum", "=", "*", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "byte_size", "=", "arg", ".", "promoted_size_in_bytes", "(", ")", ";", "bool", "doubleword_aligned_p", ";", "if", "(", "cum", ">=", "TILEGX_NUM_ARG_REGS", ")", "return", "NULL_RTX", ";", "doubleword_aligned_p", "=", "tilegx_function_arg_boundary", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ">", "BITS_PER_WORD", ";", "if", "(", "doubleword_aligned_p", ")", "cum", "+=", "cum", "&", "1", ";", "if", "(", "(", "cum", "+", "(", "byte_size", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ">", "TILEGX_NUM_ARG_REGS", ")", "return", "NULL_RTX", ";", "return", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "cum", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG", "." ]

[ "tilegx", "1", "1" ]

[]

[ "<s>", "static", "bool", "mips_lx_address_p", "(", "rtx", "addr", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "PLUS", "||", "!", "REG_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "||", "!", "REG_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "return", "false", ";", "if", "(", "ISA_HAS_LBX", "&&", "mode", "==", "QImode", ")", "return", "true", ";", "if", "(", "ISA_HAS_LHX", "&&", "mode", "==", "HImode", ")", "return", "true", ";", "if", "(", "ISA_HAS_LWX", "&&", "mode", "==", "SImode", ")", "return", "true", ";", "if", "(", "ISA_HAS_LDX", "&&", "mode", "==", "DImode", ")", "return", "true", ";", "if", "(", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "ADDR", "matches", "the", "pattern", "for", "the", "L", "{", "B", ",", "H", ",", "W", ",", "D", "}", "{", ",", "U", "}", "X", "load", "indexed", "address", "instruction", ".", "Note", "that", "such", "addresses", "are", "not", "considered", "legitimate", "in", "the", "TARGET_LEGITIMATE_ADDRESS_P", "sense", ",", "because", "their", "use", "is", "so", "restricted", "." ]

[ "mips", "0", "1" ]

[]

[ "<s>", "M68kSubtarget", "&", "M68kSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "Triple", "TT", ",", "StringRef", "FS", ",", "const", "M68kTargetMachine", "&", "TM", ")", "{", "std", "::", "string", "CPUName", "=", "selectM68kCPU", "(", "TT", ",", "CPU", ")", ".", "str", "(", ")", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "CPUName", ",", "FS", ")", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "stackAlignment", "=", "8", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "M68k", "M68k", "M68k", "M68k", "M68k", "8" ]

[]

[ "<s>", "const", "R600Subtarget", "*", "R600TargetLowering", "::", "getSubtarget", "(", ")", "const", "{", "return", "static_cast", "<", "const", "R600Subtarget", "*", ">", "(", "Subtarget", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "R600", "R600" ]

[]

[ "<s>", "static", "unsigned", "int", "h8300_binary_length", "(", "rtx_insn", "*", "insn", ",", "const", "h8300_length_table", "*", "table", ")", "{", "rtx", "set", ";", "rtx", "pattern", ";", "if", "(", "GET_CODE", "(", "insn", ")", "!=", "INSN", ")", "gcc_unreachable", "(", ")", ";", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "PARALLEL", "&&", "GET_CODE", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ")", ")", "==", "COMPARE", ")", "set", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "1", ")", ";", "else", "set", "=", "single_set", "(", "insn", ")", ";", "gcc_assert", "(", "set", ")", ";", "if", "(", "BINARY_P", "(", "SET_SRC", "(", "set", ")", ")", ")", "return", "h8300_length_from_table", "(", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "0", ")", ",", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", ",", "table", ")", ";", "else", "{", "gcc_assert", "(", "GET_RTX_CLASS", "(", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", ")", "==", "RTX_TERNARY", ")", ";", "return", "h8300_length_from_table", "(", "XEXP", "(", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", ",", "0", ")", ",", "XEXP", "(", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", ",", "1", ")", ",", "table", ")", ";", "}", "}", "</s>" ]

[ "Calculate", "the", "length", "of", "general", "binary", "instruction", "INSN", "using", "TABLE", "." ]

[ "h8300", "0", "0", "0", "0", "0", "1", "0", "1", "1", "0", "1", "1" ]

[]

[ "<s>", "int", "nios2_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "int", "offset", ";", "nios2_compute_frame_layout", "(", ")", ";", "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "offset", "=", "cfun", "->", "machine", "->", "args_size", "+", "cfun", "->", "machine", "->", "var_size", ";", "break", ";", "case", "ARG_POINTER_REGNUM", ":", "offset", "=", "cfun", "->", "machine", "->", "total_size", ";", "offset", "-=", "crtl", "->", "args", ".", "pretend_args_size", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "offset", "-=", "(", "cfun", "->", "machine", "->", "save_regs_offset", "+", "cfun", "->", "machine", "->", "fp_save_offset", ")", ";", "return", "offset", ";", "}", "</s>" ]

[ "Implement", "INITIAL_ELIMINATION_OFFSET", "macro", "." ]

[ "nios2" ]

[]

[ "<s>", "void", "MCS51PassConfig", "::", "addPreSched2", "(", ")", "{", "addPass", "(", "createMCS51RelaxMemPass", "(", ")", ")", ";", "addPass", "(", "createMCS51ExpandPseudoPass", "(", ")", ")", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51", "MCS51", "MCS51" ]

[]

[ "<s>", "void", "AlphaTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "{", "DebugLoc", "dl", "=", "N", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", "&&", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "VAARG", "&&", "\"Unknown node to custom promote!\"", ")", ";", "SDValue", "Chain", ",", "DataPtr", ";", "LowerVAARG", "(", "N", ",", "Chain", ",", "DataPtr", ",", "DAG", ")", ";", "SDValue", "Res", "=", "DAG", ".", "getLoad", "(", "N", "->", "getValueType", "(", "0", ")", ",", "dl", ",", "Chain", ",", "DataPtr", ",", "NULL", ",", "0", ",", "false", ",", "false", ",", "0", ")", ";", "Results", ".", "push_back", "(", "Res", ")", ";", "Results", ".", "push_back", "(", "SDValue", "(", "Res", ".", "getNode", "(", ")", ",", "1", ")", ")", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha", "0", "MVT::i32", "ISD::VAARG", "\"Unknown node to custom promote!\"", "0", "0", "0", "1" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "Op", "->", "print", "(", "errs", "(", ")", ",", "&", "DAG", ")", ";", "llvm_unreachable", "(", "\"Custom lowering code for this\"", "\"instruction is not implemented yet!\"", ")", ";", "break", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "LowerSIGN_EXTEND_INREG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "LowerEXTRACT_SUBVECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIVREM", ":", "return", "LowerUDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "return", "LowerSDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FREM", ":", "return", "LowerFREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCEIL", ":", "return", "LowerFCEIL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FTRUNC", ":", "return", "LowerFTRUNC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRINT", ":", "return", "LowerFRINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FNEARBYINT", ":", "return", "LowerFNEARBYINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FROUND", ":", "return", "LowerFROUND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FFLOOR", ":", "return", "LowerFFLOOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FLOG", ":", "return", "LowerFLOG", "(", "Op", ",", "DAG", ",", "1.0F", "/", "numbers", "::", "log2ef", ")", ";", "case", "ISD", "::", "FLOG10", ":", "return", "LowerFLOG", "(", "Op", ",", "DAG", ",", "numbers", "::", "ln2f", "/", "numbers", "::", "ln10f", ")", ";", "case", "ISD", "::", "FEXP", ":", "return", "lowerFEXP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerUINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_FP16", ":", "return", "LowerFP_TO_FP16", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_UINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTTZ", ":", "case", "ISD", "::", "CTTZ_ZERO_UNDEF", ":", "case", "ISD", "::", "CTLZ", ":", "case", "ISD", "::", "CTLZ_ZERO_UNDEF", ":", "return", "LowerCTLZ_CTTZ", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "}", "return", "Op", ";", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "AMDGPU", "AMDGPU", "\"Custom lowering code for this\"", "\"instruction is not implemented yet!\"", "ISD::SIGN_EXTEND_INREG", "SI", "ISD::CONCAT_VECTORS", "ISD::EXTRACT_SUBVECTOR", "ISD::UDIVREM", "ISD::SDIVREM", "ISD::FREM", "ISD::FCEIL", "ISD::FTRUNC", "ISD::FRINT", "ISD::FNEARBYINT", "ISD::FROUND", "ISD::FFLOOR", "ISD::FLOG", "1.0F", "ISD::FLOG10", "ISD::FEXP", "ISD::SINT_TO_FP", "SI", "ISD::UINT_TO_FP", "ISD::FP_TO_FP16", "ISD::FP_TO_SINT", "SI", "ISD::FP_TO_UINT", "ISD::CTTZ", "ISD::CTTZ_ZERO_UNDEF", "ISD::CTLZ", "ISD::CTLZ_ZERO_UNDEF", "ISD::DYNAMIC_STACKALLOC" ]

[]

[ "<s>", "bool", "RISCVRegisterInfo", "::", "isAsmClobberable", "(", "const", "MachineFunction", "&", "MF", ",", "MCRegister", "PhysReg", ")", "const", "{", "return", "!", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "isRegisterReservedByUser", "(", "PhysReg", ")", ";", "}", "</s>" ]

[ "Returns", "false", "if", "we", "ca", "n't", "guarantee", "that", "Physreg", ",", "specified", "as", "an", "IR", "asm", "clobber", "constraint", ",", "will", "be", "preserved", "across", "the", "statement", "." ]

[ "RI5CY", "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "Context", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC_X86", ")", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "X86", "X86", "ISD::OutputArg", "16", "X86" ]

[]

[ "<s>", "Value", "*", "RISCVTargetLowering", "::", "emitMaskedAtomicRMWIntrinsic", "(", "IRBuilderBase", "&", "Builder", ",", "AtomicRMWInst", "*", "AI", ",", "Value", "*", "AlignedAddr", ",", "Value", "*", "Incr", ",", "Value", "*", "Mask", ",", "Value", "*", "ShiftAmt", ",", "AtomicOrdering", "Ord", ")", "const", "{", "unsigned", "XLen", "=", "Subtarget", ".", "getXLen", "(", ")", ";", "Value", "*", "Ordering", "=", "Builder", ".", "getIntN", "(", "XLen", ",", "static_cast", "<", "uint64_t", ">", "(", "AI", "->", "getOrdering", "(", ")", ")", ")", ";", "Type", "*", "Tys", "[", "]", "=", "{", "AlignedAddr", "->", "getType", "(", ")", "}", ";", "Function", "*", "LrwOpScwLoop", "=", "Intrinsic", "::", "getDeclaration", "(", "AI", "->", "getModule", "(", ")", ",", "getIntrinsicForMaskedAtomicRMWBinOp", "(", "XLen", ",", "AI", "->", "getOperation", "(", ")", ")", ",", "Tys", ")", ";", "if", "(", "XLen", "==", "64", ")", "{", "Incr", "=", "Builder", ".", "CreateSExt", "(", "Incr", ",", "Builder", ".", "getInt64Ty", "(", ")", ")", ";", "Mask", "=", "Builder", ".", "CreateSExt", "(", "Mask", ",", "Builder", ".", "getInt64Ty", "(", ")", ")", ";", "ShiftAmt", "=", "Builder", ".", "CreateSExt", "(", "ShiftAmt", ",", "Builder", ".", "getInt64Ty", "(", ")", ")", ";", "}", "Value", "*", "Result", ";", "if", "(", "AI", "->", "getOperation", "(", ")", "==", "AtomicRMWInst", "::", "Min", "||", "AI", "->", "getOperation", "(", ")", "==", "AtomicRMWInst", "::", "Max", ")", "{", "const", "DataLayout", "&", "DL", "=", "AI", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "unsigned", "ValWidth", "=", "DL", ".", "getTypeStoreSizeInBits", "(", "AI", "->", "getValOperand", "(", ")", "->", "getType", "(", ")", ")", ";", "Value", "*", "SextShamt", "=", "Builder", ".", "CreateSub", "(", "Builder", ".", "getIntN", "(", "XLen", ",", "XLen", "-", "ValWidth", ")", ",", "ShiftAmt", ")", ";", "Result", "=", "Builder", ".", "CreateCall", "(", "LrwOpScwLoop", ",", "{", "AlignedAddr", ",", "Incr", ",", "Mask", ",", "SextShamt", ",", "Ordering", "}", ")", ";", "}", "else", "{", "Result", "=", "Builder", ".", "CreateCall", "(", "LrwOpScwLoop", ",", "{", "AlignedAddr", ",", "Incr", ",", "Mask", ",", "Ordering", "}", ")", ";", "}", "if", "(", "XLen", "==", "64", ")", "Result", "=", "Builder", ".", "CreateTrunc", "(", "Result", ",", "Builder", ".", "getInt32Ty", "(", ")", ")", ";", "return", "Result", ";", "}", "</s>" ]

[ "Perform", "a", "masked", "atomicrmw", "using", "a", "target-specific", "intrinsic", "." ]

[ "RISCV", "RISCV", "Intrinsic::getDeclaration", "64", "64" ]

[]

[ "<s>", "static", "void", "emitSPUpdate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "unsigned", "StackPtr", ",", "int64_t", "NumBytes", ",", "bool", "Is64Bit", ",", "bool", "UseLEA", ",", "const", "TargetInstrInfo", "&", "TII", ",", "const", "TargetRegisterInfo", "&", "TRI", ",", "DebugLoc", "DL", ")", "{", "bool", "isSub", "=", "NumBytes", "<", "0", ";", "uint64_t", "Offset", "=", "isSub", "?", "-", "NumBytes", ":", "NumBytes", ";", "unsigned", "Opc", ";", "if", "(", "UseLEA", ")", "Opc", "=", "getLEArOpcode", "(", "Is64Bit", ")", ";", "else", "Opc", "=", "isSub", "?", "getSUBriOpcode", "(", "Is64Bit", ",", "Offset", ")", ":", "getADDriOpcode", "(", "Is64Bit", ",", "Offset", ")", ";", "uint64_t", "Chunk", "=", "(", "1LL", "<<", "31", ")", "-", "1", ";", "while", "(", "Offset", ")", "{", "uint64_t", "ThisVal", "=", "(", "Offset", ">", "Chunk", ")", "?", "Chunk", ":", "Offset", ";", "if", "(", "ThisVal", "==", "(", "Is64Bit", "?", "8", ":", "4", ")", ")", "{", "unsigned", "Reg", "=", "isSub", "?", "(", "unsigned", ")", "(", "Is64Bit", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ")", ":", "findDeadCallerSavedReg", "(", "MBB", ",", "MBBI", ",", "TRI", ",", "Is64Bit", ")", ";", "if", "(", "Reg", ")", "{", "Opc", "=", "isSub", "?", "(", "Is64Bit", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ")", ":", "(", "Is64Bit", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "getDefRegState", "(", "!", "isSub", ")", "|", "getUndefRegState", "(", "isSub", ")", ")", ";", "if", "(", "isSub", ")", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "Offset", "-=", "ThisVal", ";", "continue", ";", "}", "}", "MachineInstr", "*", "MI", "=", "NULL", ";", "if", "(", "UseLEA", ")", "{", "MI", "=", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ",", "StackPtr", ",", "false", ",", "isSub", "?", "-", "ThisVal", ":", "ThisVal", ")", ";", "}", "else", "{", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "ThisVal", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "if", "(", "isSub", ")", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "Offset", "-=", "ThisVal", ";", "}", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "increment", "/", "decrement", "the", "stack", "pointer", "by", "a", "constant", "value", "." ]

[ "X86", "0", "1LL", "31", "1", "8", "4", "X86::RAX", "X86::EAX", "X86::PUSH64r", "X86::PUSH32r", "X86::POP64r", "X86::POP32r", "3" ]

[]

[ "<s>", "CCAssignFn", "*", "ARMFastISel", "::", "CCAssignFnForCall", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "Return", ")", "{", "switch", "(", "CC", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "Fast", ":", "(", "void", ")", "RetFastCC_ARM_APCS", ";", "(", "void", ")", "FastCC_ARM_APCS", ";", "case", "CallingConv", "::", "C", ":", "if", "(", "Subtarget", "->", "isAAPCS_ABI", "(", ")", ")", "{", "if", "(", "Subtarget", "->", "hasVFP2", "(", ")", "&&", "TM", ".", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Hard", ")", "return", "(", "Return", "?", "RetCC_ARM_AAPCS_VFP", ":", "CC_ARM_AAPCS_VFP", ")", ";", "else", "return", "(", "Return", "?", "RetCC_ARM_AAPCS", ":", "CC_ARM_AAPCS", ")", ";", "}", "else", "return", "(", "Return", "?", "RetCC_ARM_APCS", ":", "CC_ARM_APCS", ")", ";", "case", "CallingConv", "::", "ARM_AAPCS_VFP", ":", "return", "(", "Return", "?", "RetCC_ARM_AAPCS_VFP", ":", "CC_ARM_AAPCS_VFP", ")", ";", "case", "CallingConv", "::", "ARM_AAPCS", ":", "return", "(", "Return", "?", "RetCC_ARM_AAPCS", ":", "CC_ARM_AAPCS", ")", ";", "case", "CallingConv", "::", "ARM_APCS", ":", "return", "(", "Return", "?", "RetCC_ARM_APCS", ":", "CC_ARM_APCS", ")", ";", "}", "}", "</s>" ]

[ "Selects", "the", "correct", "CCAssignFn", "for", "a", "given", "CallingConvention", "value", "." ]

[ "ARM", "ARM", "\"Unsupported calling convention\"", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "static", "void", "nvptx_goacc_reduction", "(", "gcall", "*", "call", ")", "{", "unsigned", "code", "=", "(", "unsigned", ")", "TREE_INT_CST_LOW", "(", "gimple_call_arg", "(", "call", ",", "0", ")", ")", ";", "switch", "(", "code", ")", "{", "case", "IFN_GOACC_REDUCTION_SETUP", ":", "nvptx_goacc_reduction_setup", "(", "call", ")", ";", "break", ";", "case", "IFN_GOACC_REDUCTION_INIT", ":", "nvptx_goacc_reduction_init", "(", "call", ")", ";", "break", ";", "case", "IFN_GOACC_REDUCTION_FINI", ":", "nvptx_goacc_reduction_fini", "(", "call", ")", ";", "break", ";", "case", "IFN_GOACC_REDUCTION_TEARDOWN", ":", "nvptx_goacc_reduction_teardown", "(", "call", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "NVPTX", "reduction", "expander", "." ]

[ "nvptx", "0" ]

[]

[ "<s>", "const", "uint32_t", "*", "SystemZRegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "return", "CSR_SystemZ_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "SystemZ", "SystemZ", "SystemZ" ]

[]

[ "<s>", "void", "SystemZMCAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "BitSize", "=", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ";", "unsigned", "Size", "=", "(", "BitSize", "+", "7", ")", "/", "8", ";", "assert", "(", "Offset", "+", "Size", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "Value", "=", "extractBitsForFixup", "(", "Kind", ",", "Value", ")", ";", "if", "(", "BitSize", "<", "64", ")", "Value", "&=", "(", "(", "uint64_t", ")", "1", "<<", "BitSize", ")", "-", "1", ";", "unsigned", "ShiftValue", "=", "(", "Size", "*", "8", ")", "-", "8", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "!=", "Size", ";", "++", "I", ")", "{", "Data", "[", "Offset", "+", "I", "]", "|=", "uint8_t", "(", "Value", ">>", "ShiftValue", ")", ";", "ShiftValue", "-=", "8", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "7", "8", "\"Invalid fixup offset!\"", "64", "1", "1", "8", "8", "0", "8" ]

[]

[ "<s>", "void", "build_mask64_2_operands", "(", "rtx", "in", ",", "rtx", "*", "out", ")", "{", "unsigned", "HOST_WIDE_INT", "c", ",", "lsb", ",", "m1", ",", "m2", ";", "int", "shift", ";", "gcc_assert", "(", "GET_CODE", "(", "in", ")", "==", "CONST_INT", ")", ";", "c", "=", "INTVAL", "(", "in", ")", ";", "if", "(", "c", "&", "1", ")", "{", "c", "=", "~", "c", ";", "lsb", "=", "c", "&", "-", "c", ";", "m1", "=", "-", "lsb", ";", "c", "=", "~", "c", ";", "c", "&=", "-", "lsb", ";", "lsb", "=", "c", "&", "-", "c", ";", "c", "=", "~", "c", ";", "c", "&=", "-", "lsb", ";", "shift", "=", "0", ";", "while", "(", "(", "lsb", ">>=", "1", ")", "!=", "0", ")", "shift", "++", ";", "m1", "<<=", "64", "-", "shift", ";", "m1", "=", "~", "m1", ";", "m2", "=", "~", "c", ";", "}", "else", "{", "lsb", "=", "c", "&", "-", "c", ";", "m2", "=", "-", "lsb", ";", "c", "=", "~", "c", ";", "c", "&=", "-", "lsb", ";", "lsb", "=", "c", "&", "-", "c", ";", "c", "=", "~", "c", ";", "c", "&=", "-", "lsb", ";", "shift", "=", "0", ";", "while", "(", "(", "lsb", ">>=", "1", ")", "!=", "0", ")", "shift", "++", ";", "m1", "=", "~", "c", ";", "m1", ">>=", "shift", ";", "m1", "=", "~", "m1", ";", "}", "out", "[", "0", "]", "=", "GEN_INT", "(", "64", "-", "shift", ")", ";", "out", "[", "1", "]", "=", "GEN_INT", "(", "m1", ")", ";", "out", "[", "2", "]", "=", "GEN_INT", "(", "shift", ")", ";", "out", "[", "3", "]", "=", "GEN_INT", "(", "m2", ")", ";", "}", "</s>" ]

[ "Generates", "shifts", "and", "masks", "for", "a", "pair", "of", "rldicl", "or", "rldicr", "insns", "to", "implement", "ANDing", "by", "the", "mask", "IN", "." ]

[ "rs6000", "1", "0", "1", "0", "64", "0", "1", "0", "0", "64", "1", "2", "3" ]

[]

[ "<s>", "void", "sparc_expand_prologue", "(", "void", ")", "{", "HOST_WIDE_INT", "size", ";", "rtx_insn", "*", "insn", ";", "sparc_leaf_function_p", "=", "optimize", ">", "0", "&&", "crtl", "->", "is_leaf", "&&", "only_leaf_regs_used", "(", ")", ";", "size", "=", "sparc_compute_frame_size", "(", "get_frame_size", "(", ")", ",", "sparc_leaf_function_p", ")", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "size", ";", "if", "(", "flag_stack_check", "==", "STATIC_BUILTIN_STACK_CHECK", "||", "flag_stack_clash_protection", ")", "{", "if", "(", "crtl", "->", "is_leaf", "&&", "!", "cfun", "->", "calls_alloca", ")", "{", "if", "(", "size", ">", "PROBE_INTERVAL", "&&", "size", ">", "get_stack_check_protect", "(", ")", ")", "sparc_emit_probe_stack_range", "(", "get_stack_check_protect", "(", ")", ",", "size", "-", "get_stack_check_protect", "(", ")", ")", ";", "}", "else", "if", "(", "size", ">", "0", ")", "sparc_emit_probe_stack_range", "(", "get_stack_check_protect", "(", ")", ",", "size", ")", ";", "}", "if", "(", "size", "==", "0", ")", ";", "else", "if", "(", "sparc_leaf_function_p", ")", "{", "rtx", "size_int_rtx", "=", "GEN_INT", "(", "-", "size", ")", ";", "if", "(", "size", "<=", "4096", ")", "insn", "=", "emit_insn", "(", "gen_stack_pointer_inc", "(", "size_int_rtx", ")", ")", ";", "else", "if", "(", "size", "<=", "8192", ")", "{", "insn", "=", "emit_insn", "(", "gen_stack_pointer_inc", "(", "GEN_INT", "(", "-", "4096", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "emit_insn", "(", "gen_stack_pointer_inc", "(", "GEN_INT", "(", "4096", "-", "size", ")", ")", ")", ";", "}", "else", "{", "rtx", "size_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "emit_move_insn", "(", "size_rtx", ",", "size_int_rtx", ")", ";", "insn", "=", "emit_insn", "(", "gen_stack_pointer_inc", "(", "size_rtx", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_stack_pointer_inc", "(", "size_int_rtx", ")", ")", ";", "}", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "else", "{", "rtx", "size_int_rtx", "=", "GEN_INT", "(", "-", "size", ")", ";", "if", "(", "size", "<=", "4096", ")", "emit_window_save", "(", "size_int_rtx", ")", ";", "else", "if", "(", "size", "<=", "8192", ")", "{", "emit_window_save", "(", "GEN_INT", "(", "-", "4096", ")", ")", ";", "emit_insn", "(", "gen_stack_pointer_inc", "(", "GEN_INT", "(", "4096", "-", "size", ")", ")", ")", ";", "emit_insn", "(", "gen_frame_blockage", "(", ")", ")", ";", "}", "else", "{", "rtx", "size_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "emit_move_insn", "(", "size_rtx", ",", "size_int_rtx", ")", ";", "emit_window_save", "(", "size_rtx", ")", ";", "}", "}", "if", "(", "sparc_leaf_function_p", ")", "{", "sparc_frame_base_reg", "=", "stack_pointer_rtx", ";", "sparc_frame_base_offset", "=", "size", "+", "SPARC_STACK_BIAS", ";", "}", "else", "{", "sparc_frame_base_reg", "=", "hard_frame_pointer_rtx", ";", "sparc_frame_base_offset", "=", "SPARC_STACK_BIAS", ";", "}", "if", "(", "sparc_n_global_fp_regs", ">", "0", ")", "emit_save_or_restore_global_fp_regs", "(", "sparc_frame_base_reg", ",", "sparc_frame_base_offset", "-", "sparc_apparent_frame_size", ",", "SORR_SAVE", ")", ";", "sparc_prologue_data_valid_p", "=", "true", ";", "}", "</s>" ]

[ "Expand", "the", "function", "prologue", ".", "The", "prologue", "is", "responsible", "for", "reserving", "storage", "for", "the", "frame", ",", "saving", "the", "call-saved", "registers", "and", "loading", "the", "PIC", "register", "if", "needed", "." ]

[ "sparc", "0", "0", "0", "4096", "8192", "4096", "1", "4096", "1", "1", "4096", "8192", "4096", "4096", "1", "0" ]

[]

[ "<s>", "bool", "M88kInstrInfo", "::", "isBranchOffsetInRange", "(", "unsigned", "BranchOpc", ",", "int64_t", "BrOffset", ")", "const", "{", "assert", "(", "isAnalyzableBranchOpc", "(", "BranchOpc", ")", "&&", "\"Unexpected branch opcode\"", ")", ";", "int", "Bits", "=", "(", "BranchOpc", "==", "M88k", "::", "BR", "||", "BranchOpc", "==", "M88k", "::", "BSR", ")", "?", "26", ":", "16", ";", "return", "isIntN", "(", "Bits", ",", "BrOffset", "/", "4", ")", ";", "}", "</s>" ]

[ "Determine", "if", "the", "branch", "target", "is", "in", "range", "." ]

[ "M88k", "M88k", "\"Unexpected branch opcode\"", "M88k::BR", "M88k::BSR", "26", "16", "4" ]

[]

[ "<s>", "bool", "AArch64AsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "OS", ".", "write_zeros", "(", "Count", "%", "4", ")", ";", "Count", "/=", "4", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "Count", ";", "++", "i", ")", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "OS", ",", "0xd503201f", ",", "Endian", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "4", "4", "0", "support::endian", "0xd503201f" ]

[]

[ "<s>", "bool", "AArch64CompressJumpTables", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MFIn", ")", "{", "bool", "Changed", "=", "false", ";", "MF", "=", "&", "MFIn", ";", "const", "auto", "&", "ST", "=", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "if", "(", "ST", ".", "force32BitJumpTables", "(", ")", "&&", "!", "MF", "->", "getFunction", "(", ")", ".", "hasMinSize", "(", ")", ")", "return", "false", ";", "if", "(", "!", "scanFunction", "(", ")", ")", "return", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "*", "MF", ")", "{", "int", "Offset", "=", "BlockInfo", "[", "MBB", ".", "getNumber", "(", ")", "]", ";", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "Changed", "|=", "compressJumpTable", "(", "MI", ",", "Offset", ")", ";", "Offset", "+=", "TII", "->", "getInstSizeInBytes", "(", "MI", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "unsigned", "Intrinsic", ")", "const", "{", "switch", "(", "Intrinsic", ")", "{", "case", "Intrinsic", "::", "arm_neon_vld1", ":", "case", "Intrinsic", "::", "arm_neon_vld2", ":", "case", "Intrinsic", "::", "arm_neon_vld3", ":", "case", "Intrinsic", "::", "arm_neon_vld4", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "uint64_t", "NumElts", "=", "getDataLayout", "(", ")", "->", "getTypeAllocSize", "(", "I", ".", "getType", "(", ")", ")", "/", "8", ";", "Info", ".", "memVT", "=", "EVT", "::", "getVectorVT", "(", "I", ".", "getType", "(", ")", "->", "getContext", "(", ")", ",", "MVT", "::", "i64", ",", "NumElts", ")", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Value", "*", "AlignArg", "=", "I", ".", "getArgOperand", "(", "I", ".", "getNumArgOperands", "(", ")", "-", "1", ")", ";", "Info", ".", "align", "=", "cast", "<", "ConstantInt", ">", "(", "AlignArg", ")", "->", "getZExtValue", "(", ")", ";", "Info", ".", "vol", "=", "false", ";", "Info", ".", "readMem", "=", "true", ";", "Info", ".", "writeMem", "=", "false", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "arm_neon_vst1", ":", "case", "Intrinsic", "::", "arm_neon_vst2", ":", "case", "Intrinsic", "::", "arm_neon_vst3", ":", "case", "Intrinsic", "::", "arm_neon_vst4", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_VOID", ";", "unsigned", "NumElts", "=", "0", ";", "for", "(", "unsigned", "ArgI", "=", "1", ",", "ArgE", "=", "I", ".", "getNumArgOperands", "(", ")", ";", "ArgI", "<", "ArgE", ";", "++", "ArgI", ")", "{", "Type", "*", "ArgTy", "=", "I", ".", "getArgOperand", "(", "ArgI", ")", "->", "getType", "(", ")", ";", "if", "(", "!", "ArgTy", "->", "isVectorTy", "(", ")", ")", "break", ";", "NumElts", "+=", "getDataLayout", "(", ")", "->", "getTypeAllocSize", "(", "ArgTy", ")", "/", "8", ";", "}", "Info", ".", "memVT", "=", "EVT", "::", "getVectorVT", "(", "I", ".", "getType", "(", ")", "->", "getContext", "(", ")", ",", "MVT", "::", "i64", ",", "NumElts", ")", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Value", "*", "AlignArg", "=", "I", ".", "getArgOperand", "(", "I", ".", "getNumArgOperands", "(", ")", "-", "1", ")", ";", "Info", ".", "align", "=", "cast", "<", "ConstantInt", ">", "(", "AlignArg", ")", "->", "getZExtValue", "(", ")", ";", "Info", ".", "vol", "=", "false", ";", "Info", ".", "readMem", "=", "false", ";", "Info", ".", "writeMem", "=", "true", ";", "return", "true", ";", "}", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Given", "an", "intrinsic", ",", "checks", "if", "on", "the", "target", "the", "intrinsic", "will", "need", "to", "map", "to", "a", "MemIntrinsicNode", "(", "touches", "memory", ")", "." ]

[ "AArch64", "AArch64", "Intrinsic::arm_neon_vld1", "Intrinsic::arm_neon_vld2", "Intrinsic::arm_neon_vld3", "Intrinsic::arm_neon_vld4", "ISD::INTRINSIC_W_CHAIN", "8", "MVT::i64", "0", "0", "1", "Intrinsic::arm_neon_vst1", "Intrinsic::arm_neon_vst2", "Intrinsic::arm_neon_vst3", "Intrinsic::arm_neon_vst4", "ISD::INTRINSIC_VOID", "0", "1", "8", "MVT::i64", "0", "0", "1" ]

[]

[ "<s>", "static", "bool", "aarch64_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fndecl", "ATTRIBUTE_UNUSED", ")", "{", "pure_scalable_type_info", "pst_info", ";", "switch", "(", "pst_info", ".", "analyze", "(", "type", ")", ")", "{", "case", "pure_scalable_type_info", "::", "IS_PST", ":", "return", "(", "pst_info", ".", "num_zr", "(", ")", ">", "NUM_FP_ARG_REGS", "||", "pst_info", ".", "num_pr", "(", ")", ">", "NUM_PR_ARG_REGS", ")", ";", "case", "pure_scalable_type_info", "::", "DOESNT_MATTER", ":", "gcc_assert", "(", "aarch64_return_in_memory_1", "(", "type", ")", ")", ";", "return", "true", ";", "case", "pure_scalable_type_info", "::", "NO_ABI_IDENTITY", ":", "case", "pure_scalable_type_info", "::", "ISNT_PST", ":", "return", "aarch64_return_in_memory_1", "(", "type", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_RETURN_IN_MEMORY", ".", "If", "the", "type", "T", "of", "the", "result", "of", "a", "function", "is", "such", "that", "void", "func", "(", "T", "arg", ")", "would", "require", "that", "arg", "be", "passed", "as", "a", "value", "in", "a", "register", "(", "or", "set", "of", "registers", ")", "according", "to", "the", "parameter", "passing", "rules", ",", "then", "the", "result", "is", "returned", "in", "the", "same", "registers", "as", "would", "be", "used", "for", "such", "an", "argument", "." ]

[ "aarch64" ]

[]

[ "<s>", "rtx", "mips_unspec_address", "(", "rtx", "address", ",", "enum", "mips_symbol_type", "symbol_type", ")", "{", "rtx", "base", ",", "offset", ";", "split_const", "(", "address", ",", "&", "base", ",", "&", "offset", ")", ";", "return", "mips_unspec_address_offset", "(", "base", ",", "offset", ",", "symbol_type", ")", ";", "}", "</s>" ]

[ "Return", "an", "UNSPEC", "address", "with", "underlying", "address", "ADDRESS", "and", "symbol", "type", "SYMBOL_TYPE", "." ]

[ "mips" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "emitFrameDirective", "(", ")", "{", "const", "TargetRegisterInfo", "&", "RI", "=", "*", "TM", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "stackReg", "=", "RI", ".", "getFrameRegister", "(", "*", "MF", ")", ";", "unsigned", "returnReg", "=", "RI", ".", "getRARegister", "(", ")", ";", "unsigned", "stackSize", "=", "MF", "->", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "getTargetStreamer", "(", ")", ".", "emitFrame", "(", "stackReg", ",", "stackSize", ",", "returnReg", ")", ";", "}", "</s>" ]

[ "Frame", "Directive", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addILPOpts", "(", ")", "{", "if", "(", "EnableCondOpt", ")", "addPass", "(", "createAArch64ConditionOptimizerPass", "(", ")", ")", ";", "if", "(", "EnableCCMP", ")", "addPass", "(", "createAArch64ConditionalCompares", "(", ")", ")", ";", "if", "(", "EnableMCR", ")", "addPass", "(", "&", "MachineCombinerID", ")", ";", "if", "(", "EnableCondBrTuning", ")", "addPass", "(", "createAArch64CondBrTuning", "(", ")", ")", ";", "if", "(", "EnableEarlyIfConversion", ")", "addPass", "(", "&", "EarlyIfConverterID", ")", ";", "if", "(", "EnableStPairSuppress", ")", "addPass", "(", "createAArch64StorePairSuppressPass", "(", ")", ")", ";", "addPass", "(", "createAArch64SIMDInstrOptPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Add", "passes", "that", "optimize", "instruction", "level", "parallelism", "for", "out-of-order", "targets", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "void", "MOSFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "MF", ".", "getRegInfo", "(", ")", ".", "getTargetRegisterInfo", "(", ")", ";", "MachineIRBuilder", "Builder", "(", "MBB", ",", "MBB", ".", "begin", "(", ")", ")", ";", "int64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "isISR", "(", "MF", ")", ")", "StackSize", "+=", "256", ";", "if", "(", "StackSize", ")", "offsetSP", "(", "Builder", ",", "-", "StackSize", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "return", ";", "auto", "MBBI", "=", "std", "::", "find_if_not", "(", "Builder", ".", "getInsertPt", "(", ")", ",", "MBB", ".", "end", "(", ")", ",", "[", "]", "(", "const", "MachineInstr", "&", "MI", ")", "{", "return", "MI", ".", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", ")", ";", "Builder", ".", "setInsertPt", "(", "MBB", ",", "MBBI", ")", ";", "Builder", ".", "buildCopy", "(", "TRI", ".", "getFrameRegister", "(", "MF", ")", ",", "Register", "(", "MOS", "::", "RS0", ")", ")", ";", "}", "</s>" ]

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

[ "MOS", "MOS", "256", "MOS::RS0" ]

[]

[ "<s>", "void", "X86TargetLowering", "::", "insertCopiesSplitCSR", "(", "MachineBasicBlock", "*", "Entry", ",", "const", "SmallVectorImpl", "<", "MachineBasicBlock", "*", ">", "&", "Exits", ")", "const", "{", "const", "X86RegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "const", "MCPhysReg", "*", "IStart", "=", "TRI", "->", "getCalleeSavedRegsViaCopy", "(", "Entry", "->", "getParent", "(", ")", ")", ";", "if", "(", "!", "IStart", ")", "return", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "*", "MRI", "=", "&", "Entry", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "Entry", "->", "begin", "(", ")", ";", "for", "(", "const", "MCPhysReg", "*", "I", "=", "IStart", ";", "*", "I", ";", "++", "I", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "X86", "::", "GR64RegClass", ";", "else", "llvm_unreachable", "(", "\"Unexpected register class in CSRsViaCopy!\"", ")", ";", "unsigned", "NewVR", "=", "MRI", "->", "createVirtualRegister", "(", "RC", ")", ";", "assert", "(", "Entry", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", "&&", "\"Function should be nounwind in insertCopiesSplitCSR!\"", ")", ";", "Entry", "->", "addLiveIn", "(", "*", "I", ")", ";", "BuildMI", "(", "*", "Entry", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "NewVR", ")", ".", "addReg", "(", "*", "I", ")", ";", "for", "(", "auto", "*", "Exit", ":", "Exits", ")", "BuildMI", "(", "*", "Exit", ",", "Exit", "->", "getFirstTerminator", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "*", "I", ")", ".", "addReg", "(", "NewVR", ")", ";", "}", "}", "</s>" ]

[ "Insert", "explicit", "copies", "in", "entry", "and", "exit", "blocks", "." ]

[ "X86", "X86", "X86", "X86::GR64RegClass", "X86::GR64RegClass", "\"Unexpected register class in CSRsViaCopy!\"", "\"Function should be nounwind in insertCopiesSplitCSR!\"" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "const", "Function", "*", "Fn", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "STI", ".", "is64Bit", "(", ")", "||", "!", "MF", ".", "getMMI", "(", ")", ".", "hasEHFunclets", "(", ")", "||", "classifyEHPersonality", "(", "Fn", "->", "getPersonalityFn", "(", ")", ")", "!=", "EHPersonality", "::", "MSVC_CXX", ")", "return", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "WinEHFuncInfo", "&", "EHInfo", "=", "*", "MF", ".", "getWinEHFuncInfo", "(", ")", ";", "int64_t", "MinFixedObjOffset", "=", "-", "SlotSize", ";", "for", "(", "int", "I", "=", "MFI", ".", "getObjectIndexBegin", "(", ")", ";", "I", "<", "0", ";", "++", "I", ")", "MinFixedObjOffset", "=", "std", "::", "min", "(", "MinFixedObjOffset", ",", "MFI", ".", "getObjectOffset", "(", "I", ")", ")", ";", "for", "(", "WinEHTryBlockMapEntry", "&", "TBME", ":", "EHInfo", ".", "TryBlockMap", ")", "{", "for", "(", "WinEHHandlerType", "&", "H", ":", "TBME", ".", "HandlerArray", ")", "{", "int", "FrameIndex", "=", "H", ".", "CatchObj", ".", "FrameIndex", ";", "if", "(", "FrameIndex", "!=", "INT_MAX", ")", "{", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MinFixedObjOffset", "-=", "std", "::", "abs", "(", "MinFixedObjOffset", ")", "%", "Align", ";", "MinFixedObjOffset", "-=", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "MFI", ".", "setObjectOffset", "(", "FrameIndex", ",", "MinFixedObjOffset", ")", ";", "}", "}", "}", "MinFixedObjOffset", "-=", "std", "::", "abs", "(", "MinFixedObjOffset", ")", "%", "8", ";", "int64_t", "UnwindHelpOffset", "=", "MinFixedObjOffset", "-", "SlotSize", ";", "int", "UnwindHelpFI", "=", "MFI", ".", "CreateFixedObject", "(", "SlotSize", ",", "UnwindHelpOffset", ",", "false", ")", ";", "EHInfo", ".", "UnwindHelpFrameIdx", "=", "UnwindHelpFI", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "auto", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "MBBI", "->", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ")", "++", "MBBI", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MOV64mi32", ")", ")", ",", "UnwindHelpFI", ")", ".", "addImm", "(", "-", "2", ")", ";", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "X86", "X86", "0", "8", "X86::MOV64mi32", "2" ]

[]

[ "<s>", "void", "ARMBaseInstrInfo", "::", "reMaterialize", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "const", "MachineInstr", "*", "Orig", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "SubIdx", "&&", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "DestReg", ")", ")", "{", "DestReg", "=", "TRI", "->", "getSubReg", "(", "DestReg", ",", "SubIdx", ")", ";", "SubIdx", "=", "0", ";", "}", "unsigned", "Opcode", "=", "Orig", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "{", "MachineInstr", "*", "MI", "=", "MBB", ".", "getParent", "(", ")", "->", "CloneMachineInstr", "(", "Orig", ")", ";", "MI", "->", "getOperand", "(", "0", ")", ".", "setReg", "(", "DestReg", ")", ";", "MBB", ".", "insert", "(", "I", ",", "MI", ")", ";", "break", ";", "}", "case", "ARM", "::", "tLDRpci_pic", ":", "case", "ARM", "::", "t2LDRpci_pic", ":", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "CPI", "=", "Orig", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "unsigned", "PCLabelId", "=", "duplicateCPV", "(", "MF", ",", "CPI", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "Orig", "->", "getDebugLoc", "(", ")", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addConstantPoolIndex", "(", "CPI", ")", ".", "addImm", "(", "PCLabelId", ")", ";", "(", "*", "MIB", ")", ".", "setMemRefs", "(", "Orig", "->", "memoperands_begin", "(", ")", ",", "Orig", "->", "memoperands_end", "(", ")", ")", ";", "break", ";", "}", "}", "MachineInstr", "*", "NewMI", "=", "prior", "(", "I", ")", ";", "NewMI", "->", "getOperand", "(", "0", ")", ".", "setSubReg", "(", "SubIdx", ")", ";", "}", "</s>" ]

[ "Re-issue", "the", "specified", "'original", "'", "instruction", "at", "the", "specific", "location", "targeting", "a", "new", "destination", "register", "." ]

[ "ARM", "ARM", "0", "0", "ARM::tLDRpci_pic", "ARM::t2LDRpci_pic", "1", "0" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "verifyInstruction", "(", "const", "MachineInstr", "*", "MI", ",", "StringRef", "&", "ErrInfo", ")", "const", "{", "uint16_t", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "int", "Src1Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "int", "Src2Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src2", ")", ";", "if", "(", "isVOP1", "(", "Opcode", ")", "||", "isVOP2", "(", "Opcode", ")", "||", "isVOP3", "(", "Opcode", ")", "||", "isVOPC", "(", "Opcode", ")", ")", "{", "unsigned", "ConstantBusCount", "=", "0", ";", "unsigned", "SGPRUsed", "=", "AMDGPU", "::", "NoRegister", ";", "for", "(", "int", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isUse", "(", ")", "&&", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "{", "if", "(", "!", "MO", ".", "isImplicit", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "EXEC", ")", "++", "ConstantBusCount", ";", "if", "(", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "M0", "||", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "VCC", "||", "(", "!", "MO", ".", "isImplicit", "(", ")", "&&", "(", "AMDGPU", "::", "SGPR_32RegClass", ".", "contains", "(", "MO", ".", "getReg", "(", ")", ")", "||", "AMDGPU", "::", "SGPR_64RegClass", ".", "contains", "(", "MO", ".", "getReg", "(", ")", ")", ")", ")", ")", "{", "if", "(", "SGPRUsed", "!=", "MO", ".", "getReg", "(", ")", ")", "{", "++", "ConstantBusCount", ";", "SGPRUsed", "=", "MO", ".", "getReg", "(", ")", ";", "}", "}", "}", "if", "(", "isLiteralConstant", "(", "MO", ")", ")", "++", "ConstantBusCount", ";", "}", "if", "(", "ConstantBusCount", ">", "1", ")", "{", "ErrInfo", "=", "\"VOP* instruction uses the constant bus more than once\"", ";", "return", "false", ";", "}", "}", "if", "(", "Src1Idx", "!=", "-", "1", "&&", "(", "isVOP2", "(", "Opcode", ")", "||", "isVOPC", "(", "Opcode", ")", ")", ")", "{", "const", "MachineOperand", "&", "Src1", "=", "MI", "->", "getOperand", "(", "Src1Idx", ")", ";", "if", "(", "Src1", ".", "isImm", "(", ")", "||", "Src1", ".", "isFPImm", "(", ")", ")", "{", "ErrInfo", "=", "\"VOP[2C] src1 cannot be an immediate.\"", ";", "return", "false", ";", "}", "}", "if", "(", "isVOP3", "(", "Opcode", ")", ")", "{", "if", "(", "Src0Idx", "!=", "-", "1", "&&", "isLiteralConstant", "(", "MI", "->", "getOperand", "(", "Src0Idx", ")", ")", ")", "{", "ErrInfo", "=", "\"VOP3 src0 cannot be a literal constant.\"", ";", "return", "false", ";", "}", "if", "(", "Src1Idx", "!=", "-", "1", "&&", "isLiteralConstant", "(", "MI", "->", "getOperand", "(", "Src1Idx", ")", ")", ")", "{", "ErrInfo", "=", "\"VOP3 src1 cannot be a literal constant.\"", ";", "return", "false", ";", "}", "if", "(", "Src2Idx", "!=", "-", "1", "&&", "isLiteralConstant", "(", "MI", "->", "getOperand", "(", "Src2Idx", ")", ")", ")", "{", "ErrInfo", "=", "\"VOP3 src2 cannot be a literal constant.\"", ";", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Perform", "target-specific", "instruction", "verification", "." ]

[ "R600", "SI", "0", "0", "1", "\"VOP* instruction uses the constant bus more than once\"", "1", "\"VOP[2C] src1 cannot be an immediate.\"", "1", "\"VOP3 src0 cannot be a literal constant.\"", "1", "\"VOP3 src1 cannot be a literal constant.\"", "1", "\"VOP3 src2 cannot be a literal constant.\"" ]

[]

[ "<s>", "bool", "AArch64AsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "OS", ".", "write_zeros", "(", "Count", "%", "4", ")", ";", "Count", "/=", "4", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "Count", ";", "++", "i", ")", "OS", ".", "write", "(", "\"\\x1f\\x20\\x03\\xd5\"", ",", "4", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "4", "4", "0", "\"\\x1f\\x20\\x03\\xd5\"", "4" ]

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "1", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "AGC", "1" ]

[]

[ "<s>", "uint64_t", "VEMCCodeEmitter", "::", "getBranchTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isImm", "(", ")", ")", "return", "getMachineOpValue", "(", "MI", ",", "MO", ",", "Fixups", ",", "STI", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "MO", ".", "getExpr", "(", ")", ",", "(", "MCFixupKind", ")", "VE", "::", "fixup_ve_pc_lo32", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "VE", "VE", "0", "VE::fixup_ve_pc_lo32", "0" ]

[]

[ "<s>", "static", "void", "mips_sim_issue_nop", "(", "struct", "mips_sim", "*", "state", ")", "{", "if", "(", "state", "->", "insns_left", "==", "0", ")", "mips_sim_next_cycle", "(", "state", ")", ";", "state", "->", "insns_left", "--", ";", "}", "</s>" ]

[ "Simulate", "issuing", "a", "NOP", "in", "state", "STATE", "." ]

[ "mips", "0" ]

[]

[ "<s>", "void", "arc_final_prescan_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "opvec", "ATTRIBUTE_UNUSED", ",", "int", "noperands", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_DUMPISIZE", ")", "fprintf", "(", "asm_out_file", ",", "\"\\n; at %04x\\n\"", ",", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ")", ";", "if", "(", "!", "cfun", "->", "machine", "->", "prescan_initialized", ")", "{", "memset", "(", "&", "arc_ccfsm_current", ",", "0", ",", "sizeof", "arc_ccfsm_current", ")", ";", "cfun", "->", "machine", "->", "prescan_initialized", "=", "1", ";", "}", "arc_ccfsm_advance", "(", "insn", ",", "&", "arc_ccfsm_current", ")", ";", "cfun", "->", "machine", "->", "size_reason", "=", "0", ";", "}", "</s>" ]

[ "The", "state", "of", "the", "fsm", "controlling", "condition", "codes", "are", ":", "0", ":", "normal", ",", "do", "nothing", "special", "1", ":", "do", "n't", "output", "this", "insn", "2", ":", "do", "n't", "output", "this", "insn", "3", ":", "make", "insns", "conditional", "4", ":", "make", "insns", "conditional", "State", "transitions", "(", "state-", ">", "state", "by", "whom", ",", "under", "what", "condition", ")", ":", "0", "-", ">", "1", "final_prescan_insn", ",", "if", "insn", "is", "conditional", "branch", "0", "-", ">", "2", "final_prescan_insn", ",", "if", "the", "`", "target", "'", "is", "an", "unconditional", "branch", "1", "-", ">", "3", "branch", "patterns", ",", "after", "having", "not", "output", "the", "conditional", "branch", "2", "-", ">", "4", "branch", "patterns", ",", "after", "having", "not", "output", "the", "conditional", "branch", "3", "-", ">", "0", "(", "*", "targetm.asm_out.internal_label", ")", ",", "if", "the", "`", "target", "'", "label", "is", "reached", "(", "the", "target", "label", "has", "CODE_LABEL_NUMBER", "equal", "to", "arc_ccfsm_target_label", ")", ".", "4", "-", ">", "0", "final_prescan_insn", ",", "if", "`", "target", "'", "unconditional", "branch", "is", "reached", "If", "the", "jump", "clobbers", "the", "conditions", "then", "we", "use", "states", "2", "and", "4", ".", "A", "similar", "thing", "can", "be", "done", "with", "conditional", "return", "insns", ".", "We", "also", "handle", "separating", "branches", "from", "sets", "of", "the", "condition", "code", ".", "This", "is", "done", "here", "because", "knowledge", "of", "the", "ccfsm", "state", "is", "required", ",", "we", "may", "not", "be", "outputting", "the", "branch", "." ]

[ "arc", "\"\\n; at %04x\\n\"", "0", "1", "0" ]

[]

[ "<s>", "bool", "LanaiAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveId", ")", "{", "return", "true", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "bool", "Is64Bit", "=", "Subtarget", "->", "is64Bit", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_X86", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "EVT", "CopyVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "if", "(", "(", "CopyVT", "==", "MVT", "::", "f32", "||", "CopyVT", "==", "MVT", "::", "f64", ")", "&&", "(", "(", "Is64Bit", "||", "Ins", "[", "i", "]", ".", "Flags", ".", "isInReg", "(", ")", ")", "&&", "!", "Subtarget", "->", "hasSSE1", "(", ")", ")", ")", "{", "report_fatal_error", "(", "\"SSE register return with SSE disabled\"", ")", ";", "}", "bool", "RoundAfterCopy", "=", "false", ";", "if", "(", "(", "VA", ".", "getLocReg", "(", ")", "==", "X86", "::", "FP0", "||", "VA", ".", "getLocReg", "(", ")", "==", "X86", "::", "FP1", ")", "&&", "isScalarFPTypeInSSEReg", "(", "VA", ".", "getValVT", "(", ")", ")", ")", "{", "CopyVT", "=", "MVT", "::", "f80", ";", "RoundAfterCopy", "=", "(", "CopyVT", "!=", "VA", ".", "getLocVT", "(", ")", ")", ";", "}", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "CopyVT", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "SDValue", "Val", "=", "Chain", ".", "getValue", "(", "0", ")", ";", "if", "(", "RoundAfterCopy", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_ROUND", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ",", "DAG", ".", "getIntPtrConstant", "(", "1", ",", "dl", ")", ")", ";", "if", "(", "VA", ".", "isExtInLoc", "(", ")", "&&", "VA", ".", "getValVT", "(", ")", ".", "getScalarType", "(", ")", "==", "MVT", "::", "i1", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "X86", "X86", "ISD::InputArg", "16", "X86", "0", "MVT::f32", "MVT::f64", "\"SSE register return with SSE disabled\"", "X86::FP0", "X86::FP1", "MVT::f80", "1", "0", "ISD::FP_ROUND", "1", "MVT::i1", "ISD::TRUNCATE", "2" ]

[]

[ "<s>", "static", "unsigned", "getReg", "(", "const", "void", "*", "D", ",", "unsigned", "RC", ",", "unsigned", "RegNo", ")", "{", "const", "MipsDisassemblerBase", "*", "Dis", "=", "static_cast", "<", "const", "MipsDisassemblerBase", "*", ">", "(", "D", ")", ";", "return", "*", "(", "Dis", "->", "getRegInfo", "(", ")", "->", "getRegClass", "(", "RC", ")", ".", "begin", "(", ")", "+", "RegNo", ")", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

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

[]

[ "<s>", "MCInst", "const", "&", "getDesc", "(", ")", "const", "{", "return", "*", "ID", ";", "}", "</s>" ]

[ "Returns", "the", "target", "instruction", "descriptor", "of", "this", "MachineInstr", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "MipsSEInstrInfo", "::", "adjustStackPtr", "(", "unsigned", "SP", ",", "int64_t", "Amount", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MipsABIInfo", "ABI", "=", "Subtarget", ".", "getABI", "(", ")", ";", "DebugLoc", "DL", ";", "unsigned", "ADDiu", "=", "ABI", ".", "GetPtrAddiuOp", "(", ")", ";", "if", "(", "Amount", "==", "0", ")", "return", ";", "if", "(", "ABI", ".", "IsCheriPureCap", "(", ")", ")", "{", "if", "(", "isInt", "<", "11", ">", "(", "Amount", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Mips", "::", "CIncOffsetImm", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "unsigned", "Reg", "=", "loadImmediate", "(", "Amount", ",", "MBB", ",", "I", ",", "DL", ",", "nullptr", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Mips", "::", "CIncOffset", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "else", "if", "(", "isInt", "<", "16", ">", "(", "Amount", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ADDiu", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "unsigned", "Opc", "=", "ABI", ".", "GetPtrAdduOp", "(", ")", ";", "if", "(", "Amount", "<", "0", ")", "{", "Opc", "=", "ABI", ".", "GetPtrSubuOp", "(", ")", ";", "Amount", "=", "-", "Amount", ";", "}", "unsigned", "Reg", "=", "loadImmediate", "(", "Amount", ",", "MBB", ",", "I", ",", "DL", ",", "nullptr", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "</s>" ]

[ "Adjust", "SP", "by", "Amount", "bytes", "." ]

[ "Mips", "Mips", "Mips", "0", "11", "Mips::CIncOffsetImm", "Mips::CIncOffset", "16", "0" ]

[]

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

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

[ "Z80old", "Z80old" ]

[]

[ "<s>", "static", "int", "mn10300_arg_partial_bytes", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "size", ";", "int", "nregs", "=", "2", ";", "if", "(", "mode", "==", "BLKmode", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "cum", "->", "nbytes", "=", "(", "cum", "->", "nbytes", "+", "3", ")", "&", "~", "3", ";", "if", "(", "cum", "->", "nbytes", ">", "nregs", "*", "UNITS_PER_WORD", ")", "return", "0", ";", "if", "(", "cum", "->", "nbytes", "+", "size", "<=", "nregs", "*", "UNITS_PER_WORD", ")", "return", "0", ";", "if", "(", "type", "==", "NULL_TREE", "&&", "cum", "->", "nbytes", "+", "size", ">", "nregs", "*", "UNITS_PER_WORD", ")", "return", "0", ";", "return", "nregs", "*", "UNITS_PER_WORD", "-", "cum", "->", "nbytes", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "bytes", "of", "registers", "to", "use", "for", "an", "argument", "passed", "partially", "in", "registers", "and", "partially", "in", "memory", "." ]

[ "mn10300", "2", "3", "3", "0", "0", "0" ]

[]

[ "<s>", "bool", "error", "(", "const", "Twine", "&", "Msg", ")", "{", "return", "Parser", ".", "Error", "(", "Lexer", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ",", "Msg", ")", ";", "}", "</s>" ]

[ "Convenience", "method", "for", "printing", "``", "error", ":", "``", "to", "the", "given", "stream", "." ]

[ "WebAssembly" ]

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "post", "PEI", "scavenging", "of", "registers", "for", "materializing", "frame", "index", "constants", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "void", "sparc_solaris_elf_asm_named_section", "(", "const", "char", "*", "name", ",", "unsigned", "int", "flags", ",", "tree", "decl", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "HAVE_COMDAT_GROUP", "&&", "flags", "&", "SECTION_LINKONCE", ")", "{", "solaris_elf_asm_comdat_section", "(", "name", ",", "flags", ",", "decl", ")", ";", "return", ";", "}", "fprintf", "(", "asm_out_file", ",", "\"\\t.section\\t\\\"%s\\\"\"", ",", "name", ")", ";", "if", "(", "!", "(", "flags", "&", "SECTION_DEBUG", ")", ")", "fputs", "(", "\",#alloc\"", ",", "asm_out_file", ")", ";", "if", "(", "flags", "&", "SECTION_WRITE", ")", "fputs", "(", "\",#write\"", ",", "asm_out_file", ")", ";", "if", "(", "flags", "&", "SECTION_TLS", ")", "fputs", "(", "\",#tls\"", ",", "asm_out_file", ")", ";", "if", "(", "flags", "&", "SECTION_CODE", ")", "fputs", "(", "\",#execinstr\"", ",", "asm_out_file", ")", ";", "if", "(", "HAVE_AS_SPARC_NOBITS", ")", "{", "if", "(", "flags", "&", "SECTION_BSS", ")", "fputs", "(", "\",#nobits\"", ",", "asm_out_file", ")", ";", "else", "fputs", "(", "\",#progbits\"", ",", "asm_out_file", ")", ";", "}", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Solaris", "implementation", "of", "TARGET_ASM_NAMED_SECTION", "." ]

[ "sparc", "\"\\t.section\\t\\\"%s\\\"\"", "\",#alloc\"", "\",#write\"", "\",#tls\"", "\",#execinstr\"", "\",#nobits\"", "\",#progbits\"" ]

[]

[ "<s>", "void", "R600MCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "RETURN", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "FETCH_CLAUSE", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "ALU_CLAUSE", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "BUNDLE", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "KILL", ")", "{", "return", ";", "}", "else", "if", "(", "IS_VTX", "(", "Desc", ")", ")", "{", "uint64_t", "InstWord01", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "uint32_t", "InstWord2", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "if", "(", "!", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "AMDGPU", "::", "FeatureCaymanISA", "]", ")", ")", "{", "InstWord2", "|=", "1", "<<", "19", ";", "}", "Emit", "(", "InstWord01", ",", "OS", ")", ";", "Emit", "(", "InstWord2", ",", "OS", ")", ";", "Emit", "(", "(", "uint32_t", ")", "0", ",", "OS", ")", ";", "}", "else", "if", "(", "IS_TEX", "(", "Desc", ")", ")", "{", "int64_t", "Sampler", "=", "MI", ".", "getOperand", "(", "14", ")", ".", "getImm", "(", ")", ";", "int64_t", "SrcSelect", "[", "4", "]", "=", "{", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ",", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ",", "MI", ".", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", ",", "MI", ".", "getOperand", "(", "5", ")", ".", "getImm", "(", ")", "}", ";", "int64_t", "Offsets", "[", "3", "]", "=", "{", "MI", ".", "getOperand", "(", "6", ")", ".", "getImm", "(", ")", "&", "0x1F", ",", "MI", ".", "getOperand", "(", "7", ")", ".", "getImm", "(", ")", "&", "0x1F", ",", "MI", ".", "getOperand", "(", "8", ")", ".", "getImm", "(", ")", "&", "0x1F", "}", ";", "uint64_t", "Word01", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "uint32_t", "Word2", "=", "Sampler", "<<", "15", "|", "SrcSelect", "[", "ELEMENT_X", "]", "<<", "20", "|", "SrcSelect", "[", "ELEMENT_Y", "]", "<<", "23", "|", "SrcSelect", "[", "ELEMENT_Z", "]", "<<", "26", "|", "SrcSelect", "[", "ELEMENT_W", "]", "<<", "29", "|", "Offsets", "[", "0", "]", "<<", "0", "|", "Offsets", "[", "1", "]", "<<", "5", "|", "Offsets", "[", "2", "]", "<<", "10", ";", "Emit", "(", "Word01", ",", "OS", ")", ";", "Emit", "(", "Word2", ",", "OS", ")", ";", "Emit", "(", "(", "uint32_t", ")", "0", ",", "OS", ")", ";", "}", "else", "{", "uint64_t", "Inst", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "if", "(", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "AMDGPU", "::", "FeatureR600ALUInst", "]", ")", "&&", "(", "(", "Desc", ".", "TSFlags", "&", "R600_InstFlag", "::", "OP1", ")", "||", "Desc", ".", "TSFlags", "&", "R600_InstFlag", "::", "OP2", ")", ")", "{", "uint64_t", "ISAOpCode", "=", "Inst", "&", "(", "0x3FFULL", "<<", "39", ")", ";", "Inst", "&=", "~", "(", "0x3FFULL", "<<", "39", ")", ";", "Inst", "|=", "ISAOpCode", "<<", "1", ";", "}", "Emit", "(", "Inst", ",", "OS", ")", ";", "}", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "AMDGPU", "R600", "AMDGPU::RETURN", "AMDGPU::FETCH_CLAUSE", "AMDGPU::ALU_CLAUSE", "AMDGPU::BUNDLE", "AMDGPU::KILL", "2", "AMDGPU::FeatureCaymanISA", "1", "19", "0", "14", "4", "2", "3", "4", "5", "3", "6", "0x1F", "7", "0x1F", "8", "0x1F", "15", "20", "23", "26", "29", "0", "0", "1", "5", "2", "10", "0", "AMDGPU::FeatureR600ALUInst", "R600_InstFlag::OP1", "R600_InstFlag::OP2", "0x3FFULL", "39", "0x3FFULL", "39", "1" ]

[]

[ "<s>", "int", "m32c_extra_address_constraint", "(", "char", "c", ",", "const", "char", "*", "str", "ATTRIBUTE_UNUSED", ")", "{", "return", "c", "==", "'A'", ";", "}", "</s>" ]

[ "Implements", "EXTRA_ADDRESS_CONSTRAINT", ".", "We", "reserve", "'", "A", "'", "strings", "for", "these", ",", "but", "do", "n't", "currently", "define", "any", "." ]

[ "m32c" ]

[]

[ "<s>", "static", "bool", "isAbsolute", "(", "SDValue", "CmpOp", ",", "SDValue", "Pos", ",", "SDValue", "Neg", ")", "{", "return", "(", "Neg", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SUB", "&&", "Neg", ".", "getOperand", "(", "0", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", "&&", "cast", "<", "ConstantSDNode", ">", "(", "Neg", ".", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", "==", "0", "&&", "Neg", ".", "getOperand", "(", "1", ")", "==", "Pos", "&&", "(", "Pos", "==", "CmpOp", "||", "(", "Pos", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SIGN_EXTEND", "&&", "Pos", ".", "getOperand", "(", "0", ")", "==", "CmpOp", ")", ")", ")", ";", "}", "</s>" ]

[ "Is", "this", "an", "absolute", "(", "as", "opposed", "to", "relocatable", ")", "value", "." ]

[ "SystemZ", "ISD::SUB", "0", "ISD::Constant", "0", "0", "1", "ISD::SIGN_EXTEND", "0" ]

[]

[ "<s>", "static", "bool", "aarch64_hard_regno_mode_ok", "(", "unsigned", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ")", "return", "regno", "==", "CC_REGNUM", ";", "if", "(", "regno", "==", "VG_REGNUM", ")", "return", "mode", "==", "DImode", ";", "unsigned", "int", "vec_flags", "=", "aarch64_classify_vector_mode", "(", "mode", ")", ";", "if", "(", "vec_flags", "&", "VEC_SVE_PRED", ")", "return", "PR_REGNUM_P", "(", "regno", ")", ";", "if", "(", "PR_REGNUM_P", "(", "regno", ")", ")", "return", "0", ";", "if", "(", "regno", "==", "SP_REGNUM", ")", "return", "mode", "==", "Pmode", "||", "mode", "==", "ptr_mode", ";", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", "||", "regno", "==", "ARG_POINTER_REGNUM", ")", "return", "mode", "==", "Pmode", ";", "if", "(", "GP_REGNUM_P", "(", "regno", ")", "&&", "known_le", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "16", ")", ")", "return", "true", ";", "if", "(", "FP_REGNUM_P", "(", "regno", ")", ")", "{", "if", "(", "vec_flags", "&", "VEC_STRUCT", ")", "return", "end_hard_regno", "(", "mode", ",", "regno", ")", "-", "1", "<=", "V31_REGNUM", ";", "else", "return", "!", "VECTOR_MODE_P", "(", "mode", ")", "||", "vec_flags", "!=", "0", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "HARD_REGNO_MODE_OK", "." ]

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

[]

[ "<s>", "int", "getExtendResourceLenLimit", "(", ")", "const", "override", "{", "return", "1", ";", "}", "</s>" ]

[ "The", "limit", "on", "resource", "length", "extension", "we", "accept", "in", "MachineCombiner", "Pass", "." ]

[ "PowerPC", "1" ]

[]

[ "<s>", "NVPTXSubtarget", "::", "NVPTXSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "is64Bit", ")", ":", "NVPTXGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "Is64Bit", "(", "is64Bit", ")", ",", "PTXVersion", "(", "0", ")", ",", "SmVersion", "(", "10", ")", "{", "drvInterface", "=", "DriverInterface", ";", "std", "::", "string", "defCPU", "=", "\"sm_10\"", ";", "ParseSubtargetFeatures", "(", "(", "CPU", ".", "empty", "(", ")", "?", "defCPU", ":", "CPU", ")", ",", "FS", ")", ";", "if", "(", "FS", ".", "empty", "(", ")", "&&", "CPU", ".", "empty", "(", ")", ")", "TargetName", "=", "defCPU", ";", "else", "if", "(", "!", "CPU", ".", "empty", "(", ")", ")", "TargetName", "=", "CPU", ";", "else", "llvm_unreachable", "(", "\"we are not using FeatureStr\"", ")", ";", "if", "(", "PTXVersion", "==", "0", ")", "{", "PTXVersion", "=", "31", ";", "}", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "module", "." ]

[ "NVPTX", "NVPTX", "NVPTX", "NVPTX", "0", "10", "\"sm_10\"", "\"we are not using FeatureStr\"", "0", "31" ]

[]

[ "<s>", "bool", "rvexPassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "static_cast", "<", "rvexTargetMachine", "*", ">", "(", "TM", ")", "->", "getSubtargetImpl", "(", ")", "->", "isVLIWEnabled", "(", ")", ")", "{", "addPass", "(", "creatervexVLIWPacketizer", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "rvex", "rvex", "rvex", "rvex" ]

[]

[ "<s>", "bool", "WebAssemblyPeephole", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Peephole **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "WebAssemblyFunctionInfo", "&", "MFI", "=", "*", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "const", "auto", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "WebAssemblyTargetLowering", "&", "TLI", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", ";", "auto", "&", "LibInfo", "=", "getAnalysis", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ".", "getTLI", "(", "MF", ".", "getFunction", "(", ")", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "WebAssembly", "::", "CALL_i32", ":", "case", "WebAssembly", "::", "CALL_i64", ":", "{", "MachineOperand", "&", "Op1", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "if", "(", "Op1", ".", "isSymbol", "(", ")", ")", "{", "StringRef", "Name", "(", "Op1", ".", "getSymbolName", "(", ")", ")", ";", "if", "(", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMCPY", ")", "||", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMMOVE", ")", "||", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMSET", ")", ")", "{", "LibFunc", "Func", ";", "if", "(", "LibInfo", ".", "getLibFunc", "(", "Name", ",", "Func", ")", ")", "{", "const", "auto", "&", "Op2", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "if", "(", "!", "Op2", ".", "isReg", "(", ")", ")", "report_fatal_error", "(", "\"Peephole: call to builtin function with \"", "\"wrong signature, not consuming reg\"", ")", ";", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "Register", "OldReg", "=", "MO", ".", "getReg", "(", ")", ";", "Register", "NewReg", "=", "Op2", ".", "getReg", "(", ")", ";", "if", "(", "MRI", ".", "getRegClass", "(", "NewReg", ")", "!=", "MRI", ".", "getRegClass", "(", "OldReg", ")", ")", "report_fatal_error", "(", "\"Peephole: call to builtin function with \"", "\"wrong signature, from/to mismatch\"", ")", ";", "Changed", "|=", "maybeRewriteToDrop", "(", "OldReg", ",", "NewReg", ",", "MO", ",", "MFI", ",", "MRI", ")", ";", "}", "}", "}", "break", ";", "}", "case", "WebAssembly", "::", "RETURN", ":", "Changed", "|=", "maybeRewriteToFallthrough", "(", "MI", ",", "MBB", ",", "MF", ",", "MFI", ",", "MRI", ",", "TII", ")", ";", "break", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Peephole **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly::CALL_i32", "WebAssembly::CALL_i64", "1", "2", "\"Peephole: call to builtin function with \"", "\"wrong signature, not consuming reg\"", "0", "\"Peephole: call to builtin function with \"", "\"wrong signature, from/to mismatch\"", "WebAssembly::RETURN" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isExtendLikelyToBeFolded", "(", "MachineInstr", "&", "ExtMI", ",", "MachineRegisterInfo", "&", "MRI", ")", "const", "{", "assert", "(", "ExtMI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_SEXT", "||", "ExtMI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_ZEXT", "||", "ExtMI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_ANYEXT", ")", ";", "if", "(", "ExtMI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_ANYEXT", ")", "return", "true", ";", "Register", "DefReg", "=", "ExtMI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "MRI", ".", "hasOneNonDBGUse", "(", "DefReg", ")", ")", "return", "false", ";", "auto", "*", "UserMI", "=", "&", "*", "MRI", ".", "use_instr_nodbg_begin", "(", "DefReg", ")", ";", "return", "UserMI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_PTR_ADD", ";", "}", "</s>" ]

[ "Given", "the", "generic", "extension", "instruction", "ExtMI", ",", "returns", "true", "if", "this", "extension", "is", "a", "likely", "candidate", "for", "being", "folded", "into", "an", "another", "instruction", "." ]

[ "AArch64", "AArch64", "0" ]

[]

[ "<s>", "bool", "MipsTargetLowering", "::", "hasBitTest", "(", "SDValue", "X", ",", "SDValue", "Y", ")", "const", "{", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Y", ")", ")", "return", "C", "->", "getAPIntValue", "(", ")", ".", "ule", "(", "15", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "has", "a", "bit-test", "instruction", ":", "(", "X", "&", "(", "1", "<", "<", "Y", ")", ")", "==/", "!", "=", "0", "This", "knowledge", "can", "be", "used", "to", "prevent", "breaking", "the", "pattern", ",", "or", "creating", "it", "if", "it", "could", "be", "recognized", "." ]

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

[]

[ "<s>", "bool", "Cpu0AsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0" ]

[]

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

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

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

[]

[ "<s>", "RegisterSet", "&", "remove", "(", "const", "RegisterSet", "&", "Rs", ")", "{", "for", "(", "unsigned", "R", "=", "Rs", ".", "find_first", "(", ")", ";", "R", ";", "R", "=", "Rs", ".", "find_next", "(", "R", ")", ")", "remove", "(", "R", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "remove", "-", "Remove", "the", "specified", "key/value", "pair", "from", "the", "map", ",", "but", "do", "not", "erase", "it", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "AMDGPUTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "APInt", "&", "KnownZero", ",", "APInt", "&", "KnownOne", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "KnownZero", "=", "KnownOne", "=", "APInt", "(", "KnownOne", ".", "getBitWidth", "(", ")", ",", "0", ")", ";", "APInt", "KnownZero2", ";", "APInt", "KnownOne2", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "{", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "case", "AMDGPUIntrinsic", "::", "AMDGPU_imax", ":", "case", "AMDGPUIntrinsic", "::", "AMDGPU_umax", ":", "case", "AMDGPUIntrinsic", "::", "AMDGPU_imin", ":", "case", "AMDGPUIntrinsic", "::", "AMDGPU_umin", ":", "computeKnownBitsForMinMax", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "Op", ".", "getOperand", "(", "2", ")", ",", "KnownZero", ",", "KnownOne", ",", "DAG", ",", "Depth", ")", ";", "break", ";", "default", ":", "break", ";", "}", "break", ";", "}", "case", "AMDGPUISD", "::", "SMAX", ":", "case", "AMDGPUISD", "::", "UMAX", ":", "case", "AMDGPUISD", "::", "SMIN", ":", "case", "AMDGPUISD", "::", "UMIN", ":", "computeKnownBitsForMinMax", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "Op", ".", "getOperand", "(", "1", ")", ",", "KnownZero", ",", "KnownOne", ",", "DAG", ",", "Depth", ")", ";", "break", ";", "case", "AMDGPUISD", "::", "BFE_I32", ":", "case", "AMDGPUISD", "::", "BFE_U32", ":", "{", "ConstantSDNode", "*", "CWidth", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "if", "(", "!", "CWidth", ")", "return", ";", "unsigned", "BitWidth", "=", "32", ";", "uint32_t", "Width", "=", "CWidth", "->", "getZExtValue", "(", ")", "&", "0x1f", ";", "if", "(", "Width", "==", "0", ")", "{", "KnownZero", "=", "APInt", "::", "getAllOnesValue", "(", "BitWidth", ")", ";", "KnownOne", "=", "APInt", "::", "getNullValue", "(", "BitWidth", ")", ";", "return", ";", "}", "if", "(", "Opc", "==", "AMDGPUISD", "::", "BFE_I32", ")", "KnownOne", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "Width", ")", ";", "else", "KnownZero", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "Width", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

[ "R600", "0", "ISD::INTRINSIC_WO_CHAIN", "0", "AMDGPUIntrinsic::AMDGPU_imax", "AMDGPUIntrinsic::AMDGPU_umax", "AMDGPUIntrinsic::AMDGPU_imin", "AMDGPUIntrinsic::AMDGPU_umin", "1", "2", "AMDGPUISD::SMAX", "AMDGPUISD::UMAX", "AMDGPUISD::SMIN", "AMDGPUISD::UMIN", "0", "1", "AMDGPUISD::BFE_I32", "AMDGPUISD::BFE_U32", "2", "32", "0x1f", "0", "AMDGPUISD::BFE_I32" ]

[]

[ "<s>", "static", "int", "ix86_get_modrm_for_rop", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ",", "int", "noperands", ",", "int", "*", "popno0", "=", "0", ",", "int", "*", "popno1", "=", "0", ")", "{", "if", "(", "asm_noperands", "(", "PATTERN", "(", "insn", ")", ")", ">=", "0", ")", "return", "-", "1", ";", "int", "has_modrm", "=", "get_attr_modrm", "(", "insn", ")", ";", "if", "(", "!", "has_modrm", ")", "return", "-", "1", ";", "enum", "attr_modrm_class", "cls", "=", "get_attr_modrm_class", "(", "insn", ")", ";", "rtx", "op0", ",", "op1", ";", "switch", "(", "cls", ")", "{", "case", "MODRM_CLASS_OP02", ":", "gcc_assert", "(", "noperands", ">=", "3", ")", ";", "if", "(", "popno0", ")", "{", "*", "popno0", "=", "0", ";", "*", "popno1", "=", "2", ";", "}", "op0", "=", "operands", "[", "0", "]", ";", "op1", "=", "operands", "[", "2", "]", ";", "break", ";", "case", "MODRM_CLASS_OP01", ":", "gcc_assert", "(", "noperands", ">=", "2", ")", ";", "if", "(", "popno0", ")", "{", "*", "popno0", "=", "0", ";", "*", "popno1", "=", "1", ";", "}", "op0", "=", "operands", "[", "0", "]", ";", "op1", "=", "operands", "[", "1", "]", ";", "break", ";", "default", ":", "return", "-", "1", ";", "}", "if", "(", "REG_P", "(", "op0", ")", "&&", "REG_P", "(", "op1", ")", ")", "{", "int", "enc0", "=", "reg_encoded_number", "(", "op0", ")", ";", "int", "enc1", "=", "reg_encoded_number", "(", "op1", ")", ";", "return", "0xc0", "+", "(", "enc1", "<<", "3", ")", "+", "enc0", ";", "}", "return", "-", "1", ";", "}", "</s>" ]

[ "Given", "an", "insn", "INSN", "with", "NOPERANDS", "OPERANDS", ",", "return", "the", "modr/m", "byte", "used", "in", "its", "encoding", "if", "it", "could", "be", "relevant", "for", "ROP", "mitigation", ",", "otherwise", "return", "-1", ".", "If", "POPNO0", "and", "POPNO1", "are", "nonnull", ",", "store", "the", "operand", "numbers", "used", "for", "calculating", "it", "into", "them", "." ]

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

[]

[ "<s>", "unsigned", "VideoCore4RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "VideoCore4", "::", "SP", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "VideoCore4", "VideoCore4", "VideoCore4::SP" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "*", "MI", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred", ")", "const", "{", "int", "PIdx", "=", "MI", "->", "findFirstPredOperandIdx", "(", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "CF_ALU", ")", "{", "MI", "->", "getOperand", "(", "8", ")", ".", "setImm", "(", "0", ")", ";", "return", "true", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "DOT_4", ")", "{", "MI", "->", "getOperand", "(", "getOperandIdx", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "pred_sel_X", ")", ")", ".", "setReg", "(", "Pred", "[", "2", "]", ".", "getReg", "(", ")", ")", ";", "MI", "->", "getOperand", "(", "getOperandIdx", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "pred_sel_Y", ")", ")", ".", "setReg", "(", "Pred", "[", "2", "]", ".", "getReg", "(", ")", ")", ";", "MI", "->", "getOperand", "(", "getOperandIdx", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "pred_sel_Z", ")", ")", ".", "setReg", "(", "Pred", "[", "2", "]", ".", "getReg", "(", ")", ")", ";", "MI", "->", "getOperand", "(", "getOperandIdx", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "pred_sel_W", ")", ")", ".", "setReg", "(", "Pred", "[", "2", "]", ".", "getReg", "(", ")", ")", ";", "MachineInstrBuilder", "MIB", "(", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "MIB", ".", "addReg", "(", "AMDGPU", "::", "PREDICATE_BIT", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "if", "(", "PIdx", "!=", "-", "1", ")", "{", "MachineOperand", "&", "PMO", "=", "MI", "->", "getOperand", "(", "PIdx", ")", ";", "PMO", ".", "setReg", "(", "Pred", "[", "2", "]", ".", "getReg", "(", ")", ")", ";", "MachineInstrBuilder", "MIB", "(", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "MIB", ".", "addReg", "(", "AMDGPU", "::", "PREDICATE_BIT", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Convert", "the", "instruction", "into", "a", "predicated", "instruction", "." ]

[ "AMDGPU", "R600", "AMDGPU::CF_ALU", "8", "0", "AMDGPU::DOT_4", "AMDGPU::OpName", "2", "AMDGPU::OpName", "2", "AMDGPU::OpName", "2", "AMDGPU::OpName", "2", "AMDGPU::PREDICATE_BIT", "1", "2", "AMDGPU::PREDICATE_BIT" ]

[]

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

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

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

[]

[ "<s>", "bool", "SIAnnotateControlFlow", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "LLVMContext", "&", "Context", "=", "M", ".", "getContext", "(", ")", ";", "Void", "=", "Type", "::", "getVoidTy", "(", "Context", ")", ";", "Boolean", "=", "Type", "::", "getInt1Ty", "(", "Context", ")", ";", "Int64", "=", "Type", "::", "getInt64Ty", "(", "Context", ")", ";", "ReturnStruct", "=", "StructType", "::", "get", "(", "Boolean", ",", "Int64", ",", "(", "Type", "*", ")", "nullptr", ")", ";", "BoolTrue", "=", "ConstantInt", "::", "getTrue", "(", "Context", ")", ";", "BoolFalse", "=", "ConstantInt", "::", "getFalse", "(", "Context", ")", ";", "BoolUndef", "=", "UndefValue", "::", "get", "(", "Boolean", ")", ";", "Int64Zero", "=", "ConstantInt", "::", "get", "(", "Int64", ",", "0", ")", ";", "If", "=", "M", ".", "getOrInsertFunction", "(", "IfIntrinsic", ",", "ReturnStruct", ",", "Boolean", ",", "(", "Type", "*", ")", "nullptr", ")", ";", "Else", "=", "M", ".", "getOrInsertFunction", "(", "ElseIntrinsic", ",", "ReturnStruct", ",", "Int64", ",", "(", "Type", "*", ")", "nullptr", ")", ";", "Break", "=", "M", ".", "getOrInsertFunction", "(", "BreakIntrinsic", ",", "Int64", ",", "Int64", ",", "(", "Type", "*", ")", "nullptr", ")", ";", "cast", "<", "Function", ">", "(", "Break", ")", "->", "setDoesNotAccessMemory", "(", ")", ";", "IfBreak", "=", "M", ".", "getOrInsertFunction", "(", "IfBreakIntrinsic", ",", "Int64", ",", "Boolean", ",", "Int64", ",", "(", "Type", "*", ")", "nullptr", ")", ";", "cast", "<", "Function", ">", "(", "IfBreak", ")", "->", "setDoesNotAccessMemory", "(", ")", ";", ";", "ElseBreak", "=", "M", ".", "getOrInsertFunction", "(", "ElseBreakIntrinsic", ",", "Int64", ",", "Int64", ",", "Int64", ",", "(", "Type", "*", ")", "nullptr", ")", ";", "cast", "<", "Function", ">", "(", "ElseBreak", ")", "->", "setDoesNotAccessMemory", "(", ")", ";", "Loop", "=", "M", ".", "getOrInsertFunction", "(", "LoopIntrinsic", ",", "Boolean", ",", "Int64", ",", "(", "Type", "*", ")", "nullptr", ")", ";", "EndCf", "=", "M", ".", "getOrInsertFunction", "(", "EndCfIntrinsic", ",", "Void", ",", "Int64", ",", "(", "Type", "*", ")", "nullptr", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "AMDGPU", "SI", "0" ]

[]

[ "<s>", "static", "bool", "s390_can_inline_p", "(", "tree", "caller", ",", "tree", "callee", ")", "{", "const", "unsigned", "HOST_WIDE_INT", "caller_required_masks", "=", "MASK_OPT_HTM", ";", "unsigned", "HOST_WIDE_INT", "must_match_masks", "=", "(", "MASK_64BIT", "|", "MASK_ZARCH", "|", "MASK_HARD_DFP", "|", "MASK_SOFT_FLOAT", "|", "MASK_LONG_DOUBLE_128", "|", "MASK_OPT_VX", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "always_inline_safe_masks", "=", "MASK_MVCLE", "|", "MASK_BACKCHAIN", "|", "MASK_SMALL_EXEC", ";", "const", "HOST_WIDE_INT", "all_masks", "=", "(", "caller_required_masks", "|", "must_match_masks", "|", "always_inline_safe_masks", "|", "MASK_DEBUG_ARG", "|", "MASK_PACKED_STACK", "|", "MASK_ZVECTOR", ")", ";", "tree", "caller_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "caller", ")", ";", "tree", "callee_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "callee", ")", ";", "if", "(", "!", "callee_tree", ")", "callee_tree", "=", "target_option_default_node", ";", "if", "(", "!", "caller_tree", ")", "caller_tree", "=", "target_option_default_node", ";", "if", "(", "callee_tree", "==", "caller_tree", ")", "return", "true", ";", "struct", "cl_target_option", "*", "caller_opts", "=", "TREE_TARGET_OPTION", "(", "caller_tree", ")", ";", "struct", "cl_target_option", "*", "callee_opts", "=", "TREE_TARGET_OPTION", "(", "callee_tree", ")", ";", "gcc_assert", "(", "!", "(", "caller_opts", "->", "x_target_flags", "&", "~", "all_masks", ")", ")", ";", "gcc_assert", "(", "!", "(", "callee_opts", "->", "x_target_flags", "&", "~", "all_masks", ")", ")", ";", "bool", "always_inline", "=", "(", "DECL_DISREGARD_INLINE_LIMITS", "(", "callee", ")", "&&", "lookup_attribute", "(", "\"always_inline\"", ",", "DECL_ATTRIBUTES", "(", "callee", ")", ")", ")", ";", "if", "(", "!", "always_inline", ")", "must_match_masks", "|=", "always_inline_safe_masks", ";", "if", "(", "always_inline", "&&", "ipa_fn_summaries", "&&", "!", "ipa_fn_summaries", "->", "get", "(", "cgraph_node", "::", "get", "(", "callee", ")", ")", "->", "fp_expressions", ")", "must_match_masks", "&=", "~", "(", "MASK_HARD_DFP", "|", "MASK_SOFT_FLOAT", ")", ";", "if", "(", "(", "caller_opts", "->", "x_target_flags", "&", "must_match_masks", ")", "!=", "(", "callee_opts", "->", "x_target_flags", "&", "must_match_masks", ")", ")", "return", "false", ";", "if", "(", "~", "(", "caller_opts", "->", "x_target_flags", "&", "caller_required_masks", ")", "&", "(", "callee_opts", "->", "x_target_flags", "&", "caller_required_masks", ")", ")", "return", "false", ";", "if", "(", "caller_opts", "->", "x_s390_arch", "<", "callee_opts", "->", "x_s390_arch", ")", "return", "false", ";", "if", "(", "!", "always_inline", "&&", "caller_opts", "->", "x_s390_tune", "!=", "callee_opts", "->", "x_s390_tune", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

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

[ "s390", "\"always_inline\"" ]

[]

[ "<s>", "SDNode", "*", "MipsDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "NULL", ";", "}", "std", "::", "pair", "<", "bool", ",", "SDNode", "*", ">", "Ret", "=", "selectNode", "(", "Node", ")", ";", "if", "(", "Ret", ".", "first", ")", "return", "Ret", ".", "second", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "return", "getGlobalBaseReg", "(", ")", ";", "case", "ISD", "::", "LOAD", ":", "case", "ISD", "::", "STORE", ":", "assert", "(", "cast", "<", "MemSDNode", ">", "(", "Node", ")", "->", "getMemoryVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "8", "<=", "cast", "<", "MemSDNode", ">", "(", "Node", ")", "->", "getAlignment", "(", ")", "&&", "\"Unexpected unaligned loads/stores.\"", ")", ";", "break", ";", "}", "SDNode", "*", "ResNode", "=", "SelectCode", "(", "Node", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"=> \"", ")", ";", "if", "(", "ResNode", "==", "NULL", "||", "ResNode", "==", "Node", ")", "DEBUG", "(", "Node", "->", "dump", "(", "CurDAG", ")", ")", ";", "else", "DEBUG", "(", "ResNode", "->", "dump", "(", "CurDAG", ")", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "ResNode", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "Mips", "Mips", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "ISD::GLOBAL_OFFSET_TABLE", "ISD::LOAD", "ISD::STORE", "8", "\"Unexpected unaligned loads/stores.\"", "\"=> \"", "\"\\n\"" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "(", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", "+", "7", ")", "/", "8", ";", "unsigned", "FullSize", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "case", "FK_Data_2", ":", "case", "Mips", "::", "fixup_Mips_16", ":", "FullSize", "=", "2", ";", "break", ";", "case", "FK_Data_8", ":", "case", "Mips", "::", "fixup_Mips_64", ":", "FullSize", "=", "8", ";", "break", ";", "case", "FK_Data_4", ":", "default", ":", "FullSize", "=", "4", ";", "break", ";", "}", "uint64_t", "CurVal", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittle", "?", "i", ":", "(", "FullSize", "-", "1", "-", "i", ")", ";", "CurVal", "|=", "(", "uint64_t", ")", "(", "(", "uint8_t", ")", "Data", "[", "Offset", "+", "Idx", "]", ")", "<<", "(", "i", "*", "8", ")", ";", "}", "uint64_t", "Mask", "=", "(", "(", "uint64_t", ")", "(", "-", "1", ")", ">>", "(", "64", "-", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ")", ")", ";", "CurVal", "|=", "Value", "&", "Mask", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittle", "?", "i", ":", "(", "FullSize", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "=", "(", "uint8_t", ")", "(", "(", "CurVal", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

[ "Mips", "7", "8", "Mips::fixup_Mips_16", "2", "Mips::fixup_Mips_64", "8", "4", "0", "0", "1", "8", "1", "64", "0", "1", "8", "0xff" ]

[]

[ "<s>", "Value", "*", "X86TargetLowering", "::", "getSSPStackGuardCheck", "(", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "Subtarget", ".", "getTargetTriple", "(", ")", ".", "isWindowsMSVCEnvironment", "(", ")", "||", "Subtarget", ".", "getTargetTriple", "(", ")", ".", "isWindowsItaniumEnvironment", "(", ")", ")", "{", "return", "M", ".", "getFunction", "(", "\"__security_check_cookie\"", ")", ";", "}", "return", "TargetLowering", "::", "getSSPStackGuardCheck", "(", "M", ")", ";", "}", "</s>" ]

[ "If", "the", "target", "has", "a", "standard", "stack", "protection", "check", "function", "that", "performs", "validation", "and", "error", "handling", ",", "returns", "the", "function", "." ]

[ "X86", "X86", "\"__security_check_cookie\"" ]

[]

[ "<s>", "static", "void", "rs6000_debug_reg_print", "(", "int", "first_regno", ",", "int", "last_regno", ",", "const", "char", "*", "reg_name", ")", "{", "int", "r", ",", "m", ";", "for", "(", "r", "=", "first_regno", ";", "r", "<=", "last_regno", ";", "++", "r", ")", "{", "const", "char", "*", "comma", "=", "\"\"", ";", "int", "len", ";", "if", "(", "first_regno", "==", "last_regno", ")", "fprintf", "(", "stderr", ",", "\"%s:\\t\"", ",", "reg_name", ")", ";", "else", "fprintf", "(", "stderr", ",", "\"%s%d:\\t\"", ",", "reg_name", ",", "r", "-", "first_regno", ")", ";", "len", "=", "8", ";", "for", "(", "m", "=", "0", ";", "m", "<", "NUM_MACHINE_MODES", ";", "++", "m", ")", "if", "(", "rs6000_hard_regno_mode_ok_p", "[", "m", "]", "[", "r", "]", "&&", "rs6000_hard_regno_nregs", "[", "m", "]", "[", "r", "]", ")", "{", "if", "(", "len", ">", "70", ")", "{", "fprintf", "(", "stderr", ",", "\",\\n\\t\"", ")", ";", "len", "=", "8", ";", "comma", "=", "\"\"", ";", "}", "if", "(", "rs6000_hard_regno_nregs", "[", "m", "]", "[", "r", "]", ">", "1", ")", "len", "+=", "fprintf", "(", "stderr", ",", "\"%s%s/%d\"", ",", "comma", ",", "GET_MODE_NAME", "(", "m", ")", ",", "rs6000_hard_regno_nregs", "[", "m", "]", "[", "r", "]", ")", ";", "else", "len", "+=", "fprintf", "(", "stderr", ",", "\"%s%s\"", ",", "comma", ",", "GET_MODE_NAME", "(", "m", ")", ")", ";", "comma", "=", "\", \"", ";", "}", "if", "(", "call_used_regs", "[", "r", "]", ")", "{", "if", "(", "len", ">", "70", ")", "{", "fprintf", "(", "stderr", ",", "\",\\n\\t\"", ")", ";", "len", "=", "8", ";", "comma", "=", "\"\"", ";", "}", "len", "+=", "fprintf", "(", "stderr", ",", "\"%s%s\"", ",", "comma", ",", "\"call-used\"", ")", ";", "comma", "=", "\", \"", ";", "}", "if", "(", "fixed_regs", "[", "r", "]", ")", "{", "if", "(", "len", ">", "70", ")", "{", "fprintf", "(", "stderr", ",", "\",\\n\\t\"", ")", ";", "len", "=", "8", ";", "comma", "=", "\"\"", ";", "}", "len", "+=", "fprintf", "(", "stderr", ",", "\"%s%s\"", ",", "comma", ",", "\"fixed\"", ")", ";", "comma", "=", "\", \"", ";", "}", "if", "(", "len", ">", "70", ")", "{", "fprintf", "(", "stderr", ",", "\",\\n\\t\"", ")", ";", "comma", "=", "\"\"", ";", "}", "len", "+=", "fprintf", "(", "stderr", ",", "\"%sreg-class = %s\"", ",", "comma", ",", "reg_class_names", "[", "(", "int", ")", "rs6000_regno_regclass", "[", "r", "]", "]", ")", ";", "comma", "=", "\", \"", ";", "if", "(", "len", ">", "70", ")", "{", "fprintf", "(", "stderr", ",", "\",\\n\\t\"", ")", ";", "comma", "=", "\"\"", ";", "}", "fprintf", "(", "stderr", ",", "\"%sregno = %d\\n\"", ",", "comma", ",", "r", ")", ";", "}", "}", "</s>" ]

[ "Print", "interesting", "facts", "about", "registers", "." ]

[ "rs6000", "\"\"", "\"%s:\\t\"", "\"%s%d:\\t\"", "8", "0", "70", "\",\\n\\t\"", "8", "\"\"", "1", "\"%s%s/%d\"", "\"%s%s\"", "\", \"", "70", "\",\\n\\t\"", "8", "\"\"", "\"%s%s\"", "\"call-used\"", "\", \"", "70", "\",\\n\\t\"", "8", "\"\"", "\"%s%s\"", "\"fixed\"", "\", \"", "70", "\",\\n\\t\"", "\"\"", "\"%sreg-class = %s\"", "\", \"", "70", "\",\\n\\t\"", "\"\"", "\"%sregno = %d\\n\"" ]

[]

[ "<s>", "void", "LM32TargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sbss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "}", "</s>" ]

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

[ "LM32", "LM32", "\".sdata\"", "\".sbss\"" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "AMDGPUOperand", ">", "CreateReg", "(", "unsigned", "RegNo", ",", "SMLoc", "S", ",", "SMLoc", "E", ",", "const", "MCRegisterInfo", "*", "TRI", ",", "const", "MCSubtargetInfo", "*", "STI", ",", "bool", "ForceVOP3", ")", "{", "auto", "Op", "=", "llvm", "::", "make_unique", "<", "AMDGPUOperand", ">", "(", "Register", ")", ";", "Op", "->", "Reg", ".", "RegNo", "=", "RegNo", ";", "Op", "->", "Reg", ".", "TRI", "=", "TRI", ";", "Op", "->", "Reg", ".", "STI", "=", "STI", ";", "Op", "->", "Reg", ".", "Modifiers", "=", "0", ";", "Op", "->", "Reg", ".", "IsForcedVOP3", "=", "ForceVOP3", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "0" ]

[]

[ "<s>", "unsigned", "ARMTargetLowering", "::", "getMaxSupportedInterleaveFactor", "(", ")", "const", "{", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", ")", "return", "4", ";", "if", "(", "Subtarget", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "MVEMaxSupportedInterleaveFactor", ";", "return", "TargetLoweringBase", "::", "getMaxSupportedInterleaveFactor", "(", ")", ";", "}", "</s>" ]

[ "Get", "the", "maximum", "supported", "factor", "for", "interleaved", "memory", "accesses", "." ]

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

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "HexagonTargetLowering", "::", "shouldExpandAtomicStoreInIR", "(", "StoreInst", "*", "SI", ")", "const", "{", "return", "SI", "->", "getValueOperand", "(", ")", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ">", "64", "?", "AtomicExpansionKind", "::", "Expand", ":", "AtomicExpansionKind", "::", "None", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "(", "atomic", ")", "store", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "into", "." ]

[ "Hexagon", "Hexagon", "64" ]

[]

[ "<s>", "static", "int", "rs6000_sched_reorder2", "(", "FILE", "*", "dump", ",", "int", "sched_verbose", ",", "rtx_insn", "*", "*", "ready", ",", "int", "*", "pn_ready", ",", "int", "clock_var", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "sched_verbose", ")", "fprintf", "(", "dump", ",", "\"// rs6000_sched_reorder2 :\\n\"", ")", ";", "if", "(", "rs6000_tune", "==", "PROCESSOR_POWER6", "&&", "last_scheduled_insn", ")", "return", "power6_sched_reorder2", "(", "ready", ",", "*", "pn_ready", "-", "1", ")", ";", "if", "(", "rs6000_tune", "==", "PROCESSOR_POWER9", "&&", "last_scheduled_insn", "&&", "recog_memoized", "(", "last_scheduled_insn", ")", ">=", "0", ")", "return", "power9_sched_reorder2", "(", "ready", ",", "*", "pn_ready", "-", "1", ")", ";", "if", "(", "rs6000_tune", "==", "PROCESSOR_POWER10", "&&", "last_scheduled_insn", ")", "return", "power10_sched_reorder", "(", "ready", ",", "*", "pn_ready", "-", "1", ")", ";", "return", "cached_can_issue_more", ";", "}", "</s>" ]

[ "Like", "rs6000_sched_reorder", ",", "but", "called", "after", "issuing", "each", "insn", "." ]

[ "rs6000", "\"// rs6000_sched_reorder2 :\\n\"", "1", "0", "1", "1" ]

[]

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

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "void", "WebAssemblyFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "auto", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "!", "needsSP", "(", "MF", ",", "MFI", ")", "||", "!", "needsSPWriteback", "(", "MF", ",", "MFI", ")", ")", "return", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "InsertPt", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "InsertPt", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "InsertPt", "->", "getDebugLoc", "(", ")", ";", "unsigned", "SPReg", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "InsertAddr", "=", "InsertPt", ";", "if", "(", "hasBP", "(", "MF", ")", ")", "{", "auto", "FI", "=", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "SPReg", "=", "FI", "->", "getBasePointerVreg", "(", ")", ";", "}", "else", "if", "(", "StackSize", ")", "{", "const", "TargetRegisterClass", "*", "PtrRC", "=", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getPointerRegClass", "(", "MF", ")", ";", "unsigned", "OffsetReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "InsertAddr", "=", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "CONST_I32", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "StackSize", ")", ";", "SPReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "ADD_I32", ")", ",", "SPReg", ")", ".", "addReg", "(", "hasFP", "(", "MF", ")", "?", "WebAssembly", "::", "FP32", ":", "WebAssembly", "::", "SP32", ")", ".", "addReg", "(", "OffsetReg", ")", ";", "}", "else", "{", "SPReg", "=", "hasFP", "(", "MF", ")", "?", "WebAssembly", "::", "FP32", ":", "WebAssembly", "::", "SP32", ";", "}", "writeSPToMemory", "(", "SPReg", ",", "MF", ",", "MBB", ",", "InsertAddr", ",", "InsertPt", ",", "DL", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "0", "WebAssembly", "WebAssembly::CONST_I32", "WebAssembly::ADD_I32", "WebAssembly::FP32", "WebAssembly::SP32", "WebAssembly::FP32", "WebAssembly::SP32" ]

[]

[ "<s>", "rtx", "extract_base_reg", "(", "rtx_insn", "*", "insn", ")", "{", "int", "post_update_rtx_index", ";", "rtx", "mem_rtx", ";", "rtx", "plus_rtx", ";", "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_LOAD_MULTIPLE", ":", "post_update_rtx_index", "=", "find_post_update_rtx", "(", "insn", ")", ";", "if", "(", "post_update_rtx_index", "!=", "-", "1", ")", "return", "SET_DEST", "(", "parallel_element", "(", "insn", ",", "post_update_rtx_index", ")", ")", ";", "mem_rtx", "=", "SET_SRC", "(", "parallel_element", "(", "insn", ",", "0", ")", ")", ";", "break", ";", "case", "TYPE_STORE_MULTIPLE", ":", "post_update_rtx_index", "=", "find_post_update_rtx", "(", "insn", ")", ";", "if", "(", "post_update_rtx_index", "!=", "-", "1", ")", "return", "SET_DEST", "(", "parallel_element", "(", "insn", ",", "post_update_rtx_index", ")", ")", ";", "mem_rtx", "=", "SET_DEST", "(", "parallel_element", "(", "insn", ",", "0", ")", ")", ";", "break", ";", "case", "TYPE_LOAD", ":", "case", "TYPE_FLOAD", ":", "case", "TYPE_STORE", ":", "case", "TYPE_FSTORE", ":", "mem_rtx", "=", "extract_mem_rtx", "(", "insn", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_assert", "(", "MEM_P", "(", "mem_rtx", ")", ")", ";", "if", "(", "REG_P", "(", "XEXP", "(", "mem_rtx", ",", "0", ")", ")", ")", "return", "XEXP", "(", "mem_rtx", ",", "0", ")", ";", "plus_rtx", "=", "XEXP", "(", "mem_rtx", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "plus_rtx", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "plus_rtx", ")", "==", "CONST", ")", "return", "NULL_RTX", ";", "gcc_assert", "(", "GET_CODE", "(", "plus_rtx", ")", "==", "PLUS", "||", "GET_CODE", "(", "plus_rtx", ")", "==", "POST_INC", "||", "GET_CODE", "(", "plus_rtx", ")", "==", "POST_DEC", "||", "GET_CODE", "(", "plus_rtx", ")", "==", "POST_MODIFY", ")", ";", "gcc_assert", "(", "REG_P", "(", "XEXP", "(", "plus_rtx", ",", "0", ")", ")", ")", ";", "return", "XEXP", "(", "plus_rtx", ",", "0", ")", ";", "}", "</s>" ]

[ "Extract", "the", "base", "register", "from", "load/store", "insns", ".", "The", "function", "returns", "NULL_RTX", "if", "the", "address", "is", "not", "consist", "of", "any", "registers", "." ]

[ "nds32", "1", "0", "1", "0", "0", "0", "0", "0", "0" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "void", "XCoreTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "APInt", "&", "KnownZero", ",", "APInt", "&", "KnownOne", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "KnownZero", "=", "KnownOne", "=", "APInt", "(", "KnownZero", ".", "getBitWidth", "(", ")", ",", "0", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "XCoreISD", "::", "LADD", ":", "case", "XCoreISD", "::", "LSUB", ":", "if", "(", "Op", ".", "getResNo", "(", ")", "==", "1", ")", "{", "KnownZero", "=", "APInt", "::", "getHighBitsSet", "(", "KnownZero", ".", "getBitWidth", "(", ")", ",", "KnownZero", ".", "getBitWidth", "(", ")", "-", "1", ")", ";", "}", "break", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "unsigned", "IntNo", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", ";", "switch", "(", "IntNo", ")", "{", "case", "Intrinsic", "::", "xcore_getts", ":", "KnownZero", "=", "APInt", "::", "getHighBitsSet", "(", "KnownZero", ".", "getBitWidth", "(", ")", ",", "KnownZero", ".", "getBitWidth", "(", ")", "-", "16", ")", ";", "break", ";", "case", "Intrinsic", "::", "xcore_int", ":", "case", "Intrinsic", "::", "xcore_inct", ":", "KnownZero", "=", "APInt", "::", "getHighBitsSet", "(", "KnownZero", ".", "getBitWidth", "(", ")", ",", "KnownZero", ".", "getBitWidth", "(", ")", "-", "8", ")", ";", "break", ";", "case", "Intrinsic", "::", "xcore_testct", ":", "KnownZero", "=", "APInt", "::", "getHighBitsSet", "(", "KnownZero", ".", "getBitWidth", "(", ")", ",", "KnownZero", ".", "getBitWidth", "(", ")", "-", "1", ")", ";", "break", ";", "case", "Intrinsic", "::", "xcore_testwct", ":", "KnownZero", "=", "APInt", "::", "getHighBitsSet", "(", "KnownZero", ".", "getBitWidth", "(", ")", ",", "KnownZero", ".", "getBitWidth", "(", ")", "-", "3", ")", ";", "break", ";", "}", "}", "break", ";", "}", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

[ "XCore", "XCore", "0", "XCoreISD::LADD", "XCoreISD::LSUB", "1", "1", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::xcore_getts", "16", "Intrinsic::xcore_int", "Intrinsic::xcore_inct", "8", "Intrinsic::xcore_testct", "1", "Intrinsic::xcore_testwct", "3" ]

[]

[ "<s>", "const", "char", "*", "mips_output_order_conditional_branch", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ",", "bool", "inverted_p", ")", "{", "const", "char", "*", "branch", "[", "2", "]", ";", "if", "(", "operands", "[", "3", "]", "!=", "const0_rtx", ")", "{", "if", "(", "REGNO", "(", "operands", "[", "2", "]", ")", "==", "REGNO", "(", "operands", "[", "3", "]", ")", ")", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", ")", "{", "case", "LT", ":", "case", "LTU", ":", "inverted_p", "=", "!", "inverted_p", ";", "case", "GE", ":", "case", "GEU", ":", "branch", "[", "!", "inverted_p", "]", "=", "MIPS_BRANCH_C", "(", "\"b\"", ",", "\"%0\"", ")", ";", "branch", "[", "inverted_p", "]", "=", "\"%*\\t\\t# branch never\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "{", "branch", "[", "!", "inverted_p", "]", "=", "MIPS_BRANCH_C", "(", "\"b%C1\"", ",", "\"%2,%3,%0\"", ")", ";", "branch", "[", "inverted_p", "]", "=", "MIPS_BRANCH_C", "(", "\"b%N1\"", ",", "\"%2,%3,%0\"", ")", ";", "}", "}", "else", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", ")", "{", "case", "LEU", ":", "inverted_p", "=", "!", "inverted_p", ";", "case", "GTU", ":", "if", "(", "TARGET_CB_MAYBE", ")", "{", "branch", "[", "!", "inverted_p", "]", "=", "MIPS_BRANCH_C", "(", "\"bnez\"", ",", "\"%2,%0\"", ")", ";", "branch", "[", "inverted_p", "]", "=", "MIPS_BRANCH_C", "(", "\"beqz\"", ",", "\"%2,%0\"", ")", ";", "}", "else", "{", "branch", "[", "!", "inverted_p", "]", "=", "MIPS_BRANCH", "(", "\"bne\"", ",", "\"%2,%.,%0\"", ")", ";", "branch", "[", "inverted_p", "]", "=", "MIPS_BRANCH", "(", "\"beq\"", ",", "\"%2,%.,%0\"", ")", ";", "}", "break", ";", "case", "LTU", ":", "inverted_p", "=", "!", "inverted_p", ";", "case", "GEU", ":", "if", "(", "TARGET_CB_MAYBE", ")", "{", "branch", "[", "!", "inverted_p", "]", "=", "MIPS_BRANCH_C", "(", "\"b\"", ",", "\"%0\"", ")", ";", "branch", "[", "inverted_p", "]", "=", "\"%*\\t\\t# branch never\"", ";", "}", "else", "{", "branch", "[", "!", "inverted_p", "]", "=", "MIPS_BRANCH", "(", "\"beq\"", ",", "\"%.,%.,%0\"", ")", ";", "branch", "[", "inverted_p", "]", "=", "MIPS_BRANCH", "(", "\"bne\"", ",", "\"%.,%.,%0\"", ")", ";", "}", "break", ";", "default", ":", "if", "(", "TARGET_CB_MAYBE", ")", "{", "branch", "[", "!", "inverted_p", "]", "=", "MIPS_BRANCH_C", "(", "\"b%C1z\"", ",", "\"%2,%0\"", ")", ";", "branch", "[", "inverted_p", "]", "=", "MIPS_BRANCH_C", "(", "\"b%N1z\"", ",", "\"%2,%0\"", ")", ";", "}", "else", "{", "branch", "[", "!", "inverted_p", "]", "=", "MIPS_BRANCH", "(", "\"b%C1z\"", ",", "\"%2,%0\"", ")", ";", "branch", "[", "inverted_p", "]", "=", "MIPS_BRANCH", "(", "\"b%N1z\"", ",", "\"%2,%0\"", ")", ";", "}", "break", ";", "}", "}", "return", "mips_output_conditional_branch", "(", "insn", ",", "operands", ",", "branch", "[", "1", "]", ",", "branch", "[", "0", "]", ")", ";", "}", "</s>" ]

[ "Return", "the", "assembly", "code", "for", "INSN", ",", "which", "branches", "to", "OPERANDS", "[", "0", "]", "if", "some", "ordering", "condition", "is", "true", ".", "The", "condition", "is", "given", "by", "OPERANDS", "[", "1", "]", "if", "!", "INVERTED_P", ",", "otherwise", "it", "is", "the", "inverse", "of", "OPERANDS", "[", "1", "]", ".", "OPERANDS", "[", "2", "]", "is", "the", "comparison", "'s", "first", "operand", ";", "its", "second", "is", "always", "zero", "." ]

[ "mips", "2", "3", "2", "3", "1", "\"b\"", "\"%0\"", "\"%*\\t\\t# branch never\"", "\"b%C1\"", "\"%2,%3,%0\"", "\"b%N1\"", "\"%2,%3,%0\"", "1", "\"bnez\"", "\"%2,%0\"", "\"beqz\"", "\"%2,%0\"", "\"bne\"", "\"%2,%.,%0\"", "\"beq\"", "\"%2,%.,%0\"", "\"b\"", "\"%0\"", "\"%*\\t\\t# branch never\"", "\"beq\"", "\"%.,%.,%0\"", "\"bne\"", "\"%.,%.,%0\"", "\"b%C1z\"", "\"%2,%0\"", "\"b%N1z\"", "\"%2,%0\"", "\"b%C1z\"", "\"%2,%0\"", "\"b%N1z\"", "\"%2,%0\"", "1", "0" ]

[]

[ "<s>", "void", "frv_expand_prologue", "(", "void", ")", "{", "frv_stack_t", "*", "info", "=", "frv_stack_info", "(", ")", ";", "rtx", "sp", "=", "stack_pointer_rtx", ";", "rtx", "fp", "=", "frame_pointer_rtx", ";", "frv_frame_accessor_t", "accessor", ";", "if", "(", "TARGET_DEBUG_STACK", ")", "frv_debug_stack", "(", "info", ")", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "info", "->", "total_size", ";", "if", "(", "info", "->", "total_size", "==", "0", ")", "return", ";", "accessor", ".", "op", "=", "FRV_STORE", ";", "if", "(", "frame_pointer_needed", "&&", "info", "->", "total_size", ">", "2048", ")", "{", "accessor", ".", "base", "=", "gen_rtx_REG", "(", "Pmode", ",", "OLD_SP_REGNO", ")", ";", "accessor", ".", "base_offset", "=", "info", "->", "total_size", ";", "emit_insn", "(", "gen_movsi", "(", "accessor", ".", "base", ",", "sp", ")", ")", ";", "}", "else", "{", "accessor", ".", "base", "=", "stack_pointer_rtx", ";", "accessor", ".", "base_offset", "=", "0", ";", "}", "{", "rtx", "asm_offset", "=", "frv_frame_offset_rtx", "(", "-", "info", "->", "total_size", ")", ";", "rtx", "dwarf_offset", "=", "GEN_INT", "(", "-", "info", "->", "total_size", ")", ";", "frv_frame_insn", "(", "gen_stack_adjust", "(", "sp", ",", "sp", ",", "asm_offset", ")", ",", "gen_rtx_SET", "(", "sp", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "sp", ",", "dwarf_offset", ")", ")", ")", ";", "}", "if", "(", "frame_pointer_needed", ")", "{", "int", "fp_offset", "=", "info", "->", "reg_offset", "[", "FRAME_POINTER_REGNUM", "]", ";", "rtx", "asm_src", "=", "plus_constant", "(", "Pmode", ",", "accessor", ".", "base", ",", "fp_offset", "-", "accessor", ".", "base_offset", ")", ";", "rtx", "dwarf_src", "=", "plus_constant", "(", "Pmode", ",", "sp", ",", "fp_offset", ")", ";", "frv_frame_access", "(", "&", "accessor", ",", "fp", ",", "fp_offset", ")", ";", "frv_frame_insn", "(", "gen_rtx_SET", "(", "fp", ",", "asm_src", ")", ",", "gen_rtx_SET", "(", "fp", ",", "dwarf_src", ")", ")", ";", "accessor", ".", "base", "=", "fp", ";", "accessor", ".", "base_offset", "=", "fp_offset", ";", "}", "frv_frame_access_multi", "(", "&", "accessor", ",", "info", ",", "STACK_REGS_STRUCT", ")", ";", "frv_frame_access_multi", "(", "&", "accessor", ",", "info", ",", "STACK_REGS_LR", ")", ";", "frv_frame_access_multi", "(", "&", "accessor", ",", "info", ",", "STACK_REGS_STDARG", ")", ";", "frv_frame_access_standard_regs", "(", "FRV_STORE", ",", "info", ")", ";", "if", "(", "info", "->", "stdarg_size", ">", "0", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "if", "(", "!", "TARGET_FDPIC", "&&", "flag_pic", "&&", "crtl", "->", "uses_pic_offset_table", ")", "emit_insn", "(", "gen_pic_prologue", "(", "gen_rtx_REG", "(", "Pmode", ",", "PIC_REGNO", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "LR_REGNO", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "OFFSET_REGNO", ")", ")", ")", ";", "}", "</s>" ]

[ "Called", "after", "register", "allocation", "to", "add", "any", "instructions", "needed", "for", "the", "prologue", ".", "Using", "a", "prologue", "insn", "is", "favored", "compared", "to", "putting", "all", "of", "the", "instructions", "in", "the", "TARGET_ASM_FUNCTION_PROLOGUE", "target", "hook", ",", "since", "it", "allows", "the", "scheduler", "to", "intermix", "instructions", "with", "the", "saves", "of", "the", "caller", "saved", "registers", ".", "In", "some", "cases", ",", "it", "might", "be", "necessary", "to", "emit", "a", "barrier", "instruction", "as", "the", "last", "insn", "to", "prevent", "such", "scheduling", ".", "Also", "any", "insns", "generated", "here", "should", "have", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", "so", "that", "the", "debug", "info", "generation", "code", "can", "handle", "them", "properly", "." ]

[ "frv", "0", "2048", "0", "0" ]

[]

[ "<s>", "bool", "WebAssemblyCFGStackify", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** CFG Stackifying **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "releaseMemory", "(", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "invalidateLiveness", "(", ")", ";", "placeMarkers", "(", "MF", ")", ";", "rewriteDepthImmediates", "(", "MF", ")", ";", "fixEndsAtEndOfFunction", "(", "MF", ")", ";", "const", "auto", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "!", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", ")", "appendEndToFunction", "(", "MF", ",", "TII", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** CFG Stackifying **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "static", "tree", "find_sole_member", "(", "tree", "type", ")", "{", "tree", "field", ",", "member", "=", "NULL_TREE", ";", "for", "(", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "TREE_CHAIN", "(", "field", ")", ")", "{", "if", "(", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", ")", "continue", ";", "if", "(", "!", "DECL_SIZE", "(", "field", ")", ")", "return", "NULL_TREE", ";", "if", "(", "integer_zerop", "(", "DECL_SIZE", "(", "field", ")", ")", ")", "continue", ";", "if", "(", "member", ")", "return", "NULL_TREE", ";", "member", "=", "field", ";", "}", "return", "member", ";", "}", "</s>" ]

[ "TYPE", "is", "a", "RECORD_TYPE", ".", "If", "there", "is", "only", "a", "single", "non-zero-sized", "member", ",", "return", "it", "." ]

[ "sh" ]

[]

[ "<s>", "unsigned", "MipsTargetLowering", "::", "getNumRegistersForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "divideCeil", "(", "VT", ".", "getSizeInBits", "(", ")", ",", "Subtarget", ".", "isABI_O32", "(", ")", "?", "32", ":", "64", ")", ";", "return", "MipsTargetLowering", "::", "getNumRegisters", "(", "Context", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "targets", "require", "unusual", "breakdowns", "of", "certain", "types", "." ]

[ "Mips", "Mips", "32", "64", "Mips" ]

[]

[ "<s>", "SDValue", "MBlazeTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_MBlaze", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "unsigned", "Ret", "=", "(", "CallConv", "==", "CallingConv", "::", "MBLAZE_INTR", ")", "?", "MBlazeISD", "::", "IRet", ":", "MBlazeISD", "::", "Ret", ";", "unsigned", "Reg", "=", "(", "CallConv", "==", "CallingConv", "::", "MBLAZE_INTR", ")", "?", "MBlaze", "::", "R14", ":", "MBlaze", "::", "R15", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "Reg", ",", "MVT", "::", "i32", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Ret", ",", "dl", ",", "MVT", "::", "Other", ",", "&", "RetOps", "[", "0", "]", ",", "RetOps", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "ISD::OutputArg", "16", "MBlaze", "4", "1", "MBlazeISD::IRet", "MBlazeISD::Ret", "MBlaze::R14", "MBlaze::R15", "MVT::i32", "0", "\"Can only return in registers!\"", "1", "0", "MVT::Other", "0" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "bool", "isAligned", "=", "(", "RI", ".", "getStackAlignment", "(", ")", ">=", "16", ")", "||", "RI", ".", "needsStackRealignment", "(", "MF", ")", ";", "unsigned", "Opc", "=", "getLoadRegOpcode", "(", "DestReg", ",", "RC", ",", "isAligned", ",", "TM", ")", ";", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addPreservedID", "(", "MachineLoopInfoID", ")", ";", "AU", ".", "addPreservedID", "(", "MachineDominatorsID", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "M68k" ]

[]