Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "const", "std", "::", "string", "&", "HexagonAbsoluteStub", "::", "name", "(", ")", "const", "{", "return", "m_Name", ";", "}", "</s>" ]

[ "Gets", "the", "name", "of", "the", "pass", "we", "are", "mixed", "into", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "int", "set_exe", "(", "const", "char", "*", "arg", ")", "{", "char", "allargs", "[", "1024", "]", ";", "int", "res", ";", "snprintf", "(", "allargs", ",", "sizeof", "(", "allargs", ")", ",", "\"$@gnu:[bin]set_exe %s %s\"", ",", "exefullfilename", ",", "arg", ")", ";", "if", "(", "verbose", ")", "printf", "(", "\"%s\\n\"", ",", "allargs", ")", ";", "res", "=", "system", "(", "allargs", ")", ";", "if", "(", "verbose", ">", "1", ")", "printf", "(", "\"$!status = %d\\n\"", ",", "res", ")", ";", "if", "(", "(", "res", "&", "1", ")", "!=", "1", ")", "{", "fprintf", "(", "stderr", ",", "\"ld error: popen set_exe\\n\"", ")", ";", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Set", "environment", "defined", "executable", "attributes", "." ]

[ "vms", "1024", "\"$@gnu:[bin]set_exe %s %s\"", "\"%s\\n\"", "1", "\"$!status = %d\\n\"", "1", "1", "\"ld error: popen set_exe\\n\"", "1", "0" ]

[]

[ "<s>", "static", "rtx", "ia64_function_incoming_arg", "(", "cumulative_args_t", "cum", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "return", "ia64_function_arg_1", "(", "cum", ",", "mode", ",", "type", ",", "named", ",", "true", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCION_INCOMING_ARG", "target", "hook", "." ]

[ "ia64" ]

[]

[ "<s>", "virtual", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TM", "=", "static_cast", "<", "const", "PPCTargetMachine", "*", ">", "(", "&", "MF", ".", "getTarget", "(", ")", ")", ";", "TII", "=", "TM", "->", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "if", "(", "MF", ".", "size", "(", ")", "<", "2", ")", "return", "Changed", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ";", "I", "!=", "MF", ".", "end", "(", ")", ";", ")", "{", "MachineBasicBlock", "&", "B", "=", "*", "I", "++", ";", "if", "(", "processBlock", "(", "B", ")", ")", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "2" ]

[]

[ "<s>", "static", "reg_class_t", "csky_spill_class", "(", "reg_class_t", "rclass", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "(", "rclass", "==", "MINI_REGS", "&&", "!", "TARGET_MINI_REGISTERS", ")", "||", "(", "rclass", "==", "LOW_REGS", "&&", "TARGET_HIGH_REGISTERS", ")", ")", "return", "GENERAL_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Implement", "TARGET_SPILL_CLASS", ".", "Try", "spilling", "to", "a", "larger", "register", "class", "before", "spilling", "to", "memory", "." ]

[ "csky" ]

[]

[ "<s>", "static", "const", "char", "*", "svpattern_token", "(", "enum", "aarch64_svpattern", "pattern", ")", "{", "switch", "(", "pattern", ")", "{", "AARCH64_FOR_SVPATTERN", "(", "CASE", ")", "case", "AARCH64_NUM_SVPATTERNS", ":", "break", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "assembly", "token", "for", "svpattern", "value", "VALUE", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "int", "num_insns_constant_gpr", "(", "HOST_WIDE_INT", "value", ")", "{", "if", "(", "SIGNED_INTEGER_16BIT_P", "(", "value", ")", ")", "return", "1", ";", "else", "if", "(", "(", "value", "&", "0xffff", ")", "==", "0", "&&", "(", "value", ">>", "31", "==", "-", "1", "||", "value", ">>", "31", "==", "0", ")", ")", "return", "1", ";", "else", "if", "(", "TARGET_PREFIXED", "&&", "SIGNED_INTEGER_34BIT_P", "(", "value", ")", ")", "return", "1", ";", "else", "if", "(", "TARGET_POWERPC64", ")", "{", "HOST_WIDE_INT", "low", "=", "sext_hwi", "(", "value", ",", "32", ")", ";", "HOST_WIDE_INT", "high", "=", "value", ">>", "31", ";", "if", "(", "high", "==", "0", "||", "high", "==", "-", "1", ")", "return", "2", ";", "high", ">>=", "1", ";", "if", "(", "low", "==", "0", "||", "low", "==", "high", ")", "return", "num_insns_constant_gpr", "(", "high", ")", "+", "1", ";", "else", "if", "(", "high", "==", "0", ")", "return", "num_insns_constant_gpr", "(", "low", ")", "+", "1", ";", "else", "return", "(", "num_insns_constant_gpr", "(", "high", ")", "+", "num_insns_constant_gpr", "(", "low", ")", "+", "1", ")", ";", "}", "else", "return", "2", ";", "}", "</s>" ]

[ "Helper", "for", "num_insns_constant", ".", "Calculate", "number", "of", "instructions", "to", "load", "VALUE", "to", "a", "single", "gpr", "using", "combinations", "of", "addi", ",", "addis", ",", "ori", ",", "oris", ",", "sldi", "and", "rldimi", "instructions", "." ]

[ "rs6000", "1", "0xffff", "0", "31", "1", "31", "0", "1", "1", "32", "31", "0", "1", "2", "1", "0", "1", "0", "1", "1", "2" ]

[]

[ "<s>", "bool", "aarch64_expand_setmem", "(", "rtx", "*", "operands", ")", "{", "int", "n", ",", "mode_bits", ";", "unsigned", "HOST_WIDE_INT", "len", ";", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "val", "=", "operands", "[", "2", "]", ",", "src", ";", "rtx", "base", ";", "machine_mode", "cur_mode", "=", "BLKmode", ",", "next_mode", ";", "if", "(", "!", "CONST_INT_P", "(", "operands", "[", "1", "]", ")", ")", "return", "false", ";", "bool", "speed_p", "=", "!", "optimize_function_for_size_p", "(", "cfun", ")", ";", "unsigned", "max_set_size", "=", "256", ";", "max_set_size", "=", "(", "!", "speed_p", "||", "(", "aarch64_tune_params", ".", "extra_tuning_flags", "&", "AARCH64_EXTRA_TUNE_NO_LDP_STP_QREGS", ")", ")", "?", "max_set_size", "/", "2", ":", "max_set_size", ";", "len", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "len", ">", "max_set_size", ")", "return", "false", ";", "base", "=", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "dst", ",", "0", ")", ")", ";", "dst", "=", "adjust_automodify_address", "(", "dst", ",", "VOIDmode", ",", "base", ",", "0", ")", ";", "src", "=", "expand_vector_broadcast", "(", "V16QImode", ",", "val", ")", ";", "src", "=", "force_reg", "(", "V16QImode", ",", "src", ")", ";", "n", "=", "len", "*", "BITS_PER_UNIT", ";", "const", "int", "copy_limit", "=", "(", "speed_p", "&&", "(", "aarch64_tune_params", ".", "extra_tuning_flags", "&", "AARCH64_EXTRA_TUNE_NO_LDP_STP_QREGS", ")", ")", "?", "GET_MODE_BITSIZE", "(", "TImode", ")", ":", "256", ";", "while", "(", "n", ">", "0", ")", "{", "opt_scalar_int_mode", "mode_iter", ";", "FOR_EACH_MODE_IN_CLASS", "(", "mode_iter", ",", "MODE_INT", ")", "if", "(", "GET_MODE_BITSIZE", "(", "mode_iter", ".", "require", "(", ")", ")", "<=", "MIN", "(", "n", ",", "copy_limit", ")", ")", "cur_mode", "=", "mode_iter", ".", "require", "(", ")", ";", "gcc_assert", "(", "cur_mode", "!=", "BLKmode", ")", ";", "mode_bits", "=", "GET_MODE_BITSIZE", "(", "cur_mode", ")", ".", "to_constant", "(", ")", ";", "aarch64_set_one_block_and_progress_pointer", "(", "src", ",", "&", "dst", ",", "cur_mode", ")", ";", "n", "-=", "mode_bits", ";", "if", "(", "n", ">", "0", "&&", "n", "<", "copy_limit", "/", "2", ")", "{", "next_mode", "=", "smallest_mode_for_size", "(", "n", ",", "MODE_INT", ")", ";", "int", "n_bits", "=", "GET_MODE_BITSIZE", "(", "next_mode", ")", ".", "to_constant", "(", ")", ";", "gcc_assert", "(", "n_bits", "<=", "mode_bits", ")", ";", "dst", "=", "aarch64_move_pointer", "(", "dst", ",", "(", "n", "-", "n_bits", ")", "/", "BITS_PER_UNIT", ")", ";", "n", "=", "n_bits", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Expand", "setmem", ",", "as", "if", "from", "a", "__builtin_memset", ".", "Return", "true", "if", "we", "succeed", ",", "otherwise", "return", "false", "." ]

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

[]

[ "<s>", "const", "char", "*", "msp430_select_hwmult_lib", "(", "int", "argc", "ATTRIBUTE_UNUSED", ",", "const", "char", "*", "*", "argv", "ATTRIBUTE_UNUSED", ")", "{", "int", "i", ";", "switch", "(", "argc", ")", "{", "case", "1", ":", "if", "(", "strcasecmp", "(", "argv", "[", "0", "]", ",", "\"default\"", ")", ")", "error", "(", "\"unexpected argument to msp430_select_hwmult_lib: %s\"", ",", "argv", "[", "0", "]", ")", ";", "break", ";", "default", ":", "if", "(", "strcasecmp", "(", "argv", "[", "0", "]", ",", "\"hwmult\"", ")", "==", "0", ")", "{", "static", "struct", "hwmult_options", "{", "const", "char", "*", "name", ";", "const", "char", "*", "lib", ";", "}", "hwmult_options", "[", "]", "=", "{", "{", "\"none\"", ",", "\"-lmul_none\"", "}", ",", "{", "\"auto\"", ",", "\"-lmul_AUTO\"", "}", ",", "{", "\"16bit\"", ",", "\"-lmul_16\"", "}", ",", "{", "\"32bit\"", ",", "\"-lmul_32\"", "}", ",", "{", "\"f5series\"", ",", "\"-lmul_f5\"", "}", "}", ";", "for", "(", "i", "=", "ARRAY_SIZE", "(", "hwmult_options", ")", ";", "i", "--", ";", ")", "if", "(", "strcasecmp", "(", "argv", "[", "argc", "-", "1", "]", ",", "hwmult_options", "[", "i", "]", ".", "name", ")", "==", "0", ")", "return", "hwmult_options", "[", "i", "]", ".", "lib", ";", "}", "else", "if", "(", "strcasecmp", "(", "argv", "[", "0", "]", ",", "\"mcu\"", ")", "==", "0", ")", "{", "for", "(", "i", "=", "ARRAY_SIZE", "(", "msp430_mcu_data", ")", ";", "i", "--", ";", ")", "if", "(", "strcasecmp", "(", "argv", "[", "argc", "-", "1", "]", ",", "msp430_mcu_data", "[", "i", "]", ".", "name", ")", "==", "0", ")", "{", "switch", "(", "msp430_mcu_data", "[", "i", "]", ".", "hwmpy", ")", "{", "case", "0", ":", "return", "\"-lmul_none\"", ";", "case", "2", ":", "case", "1", ":", "return", "\"-lmul_16\"", ";", "case", "4", ":", "return", "\"-lmul_32\"", ";", "case", "8", ":", "return", "\"-lmul_f5\"", ";", "default", ":", "error", "(", "\"unrecognized hwpy field in msp430_mcu_data[%d]: %d\"", ",", "i", ",", "msp430_mcu_data", "[", "i", "]", ".", "hwmpy", ")", ";", "break", ";", "}", "}", "}", "else", "error", "(", "\"unexpected first argument to msp430_select_hwmult_lib: %s\"", ",", "argv", "[", "0", "]", ")", ";", "break", ";", "case", "0", ":", "error", "(", "\"msp430_select_hwmult_lib needs one or more arguments\"", ")", ";", "break", ";", "}", "return", "\"-lmul_none\"", ";", "}", "</s>" ]

[ "Implement", "spec", "function", "`", "msp430_hwmult_lib麓", "." ]

[ "msp430", "1", "0", "\"default\"", "\"unexpected argument to msp430_select_hwmult_lib: %s\"", "0", "0", "\"hwmult\"", "0", "\"none\"", "\"-lmul_none\"", "\"auto\"", "\"-lmul_AUTO\"", "\"16bit\"", "\"-lmul_16\"", "\"32bit\"", "\"-lmul_32\"", "\"f5series\"", "\"-lmul_f5\"", "1", "0", "0", "\"mcu\"", "0", "1", "0", "0", "\"-lmul_none\"", "2", "1", "\"-lmul_16\"", "4", "\"-lmul_32\"", "8", "\"-lmul_f5\"", "\"unrecognized hwpy field in msp430_mcu_data[%d]: %d\"", "\"unexpected first argument to msp430_select_hwmult_lib: %s\"", "0", "0", "\"msp430_select_hwmult_lib needs one or more arguments\"", "\"-lmul_none\"" ]

[]

[ "<s>", "const", "char", "*", "output_probe_stack_range", "(", "rtx", "reg1", ",", "rtx", "reg2", ")", "{", "static", "int", "labelno", "=", "0", ";", "char", "loop_lab", "[", "32", "]", ";", "rtx", "xops", "[", "2", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "loop_lab", ",", "\"LPSRL\"", ",", "labelno", "++", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "loop_lab", ")", ";", "xops", "[", "0", "]", "=", "reg1", ";", "xops", "[", "1", "]", "=", "GEN_INT", "(", "PROBE_INTERVAL", ")", ";", "output_asm_insn", "(", "\"sub\\t%0, %0, %1\"", ",", "xops", ")", ";", "output_asm_insn", "(", "\"str\\tr0, [%0, #0]\"", ",", "xops", ")", ";", "xops", "[", "1", "]", "=", "reg2", ";", "output_asm_insn", "(", "\"cmp\\t%0, %1\"", ",", "xops", ")", ";", "fputs", "(", "\"\\tbne\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "loop_lab", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Wrapper", "around", "the", "output_probe_stack_range", "routines", "." ]

[ "arm", "0", "32", "2", "\"LPSRL\"", "0", "1", "\"sub\\t%0, %0, %1\"", "\"str\\tr0, [%0, #0]\"", "1", "\"cmp\\t%0, %1\"", "\"\\tbne\\t\"", "\"\"" ]

[]

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

[ "Return", "true", "if", "branch", "divergence", "exists", "." ]

[ "R600" ]

[]

[ "<s>", "BitVector", "ARMBaseRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "const", "ARMFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "SP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "PC", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "FPSCR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "APSR_NZCV", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "getFramePointerReg", "(", "STI", ")", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "BasePtr", ")", ";", "if", "(", "STI", ".", "isR9Reserved", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "R9", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "isPagerando", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "R9", ")", ";", "if", "(", "!", "STI", ".", "hasVFP3", "(", ")", "||", "STI", ".", "hasD16", "(", ")", ")", "{", "static_assert", "(", "ARM", "::", "D31", "==", "ARM", "::", "D16", "+", "15", ",", "\"Register list not consecutive!\"", ")", ";", "for", "(", "unsigned", "R", "=", "0", ";", "R", "<", "16", ";", "++", "R", ")", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "D16", "+", "R", ")", ";", "}", "const", "TargetRegisterClass", "&", "RC", "=", "ARM", "::", "GPRPairRegClass", ";", "for", "(", "unsigned", "Reg", ":", "RC", ")", "for", "(", "MCSubRegIterator", "SI", "(", "Reg", ",", "this", ")", ";", "SI", ".", "isValid", "(", ")", ";", "++", "SI", ")", "if", "(", "Reserved", ".", "test", "(", "*", "SI", ")", ")", "markSuperRegs", "(", "Reserved", ",", "Reg", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "&", "PostRAHazardRecognizerID", ")", ";", "addPass", "(", "createSIInsertWaitsPass", "(", ")", ")", ";", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "addPass", "(", "&", "SIInsertSkipsPassID", ")", ";", "addPass", "(", "createSIDebuggerInsertNopsPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "X86AvoidTrailingCallPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "const", "X86InstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "assert", "(", "STI", ".", "isTargetWin64", "(", ")", "&&", "\"pass only runs on Win64\"", ")", ";", "if", "(", "!", "MF", ".", "hasWinCFI", "(", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "*", "NextMBB", "=", "MBB", ".", "getNextNode", "(", ")", ";", "if", "(", "NextMBB", "&&", "!", "NextMBB", "->", "isEHFuncletEntry", "(", ")", ")", "continue", ";", "auto", "LastRealInstr", "=", "llvm", "::", "find_if", "(", "reverse", "(", "MBB", ")", ",", "isCallOrRealInstruction", ")", ";", "bool", "IsEmpty", "=", "LastRealInstr", "==", "MBB", ".", "rend", "(", ")", ";", "bool", "IsCall", "=", "!", "IsEmpty", "&&", "isCallInstruction", "(", "*", "LastRealInstr", ")", ";", "if", "(", "IsEmpty", "||", "IsCall", ")", "{", "LLVM_DEBUG", "(", "{", "if", "(", "IsCall", ")", "{", "dbgs", "(", ")", "<<", "\"inserting int3 after trailing call instruction:\\n\"", ";", "LastRealInstr", "->", "dump", "(", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ";", "}", "else", "{", "dbgs", "(", ")", "<<", "\"inserting int3 in trailing empty MBB:\\n\"", ";", "MBB", ".", "dump", "(", ")", ";", "}", "}", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "end", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "IsCall", ")", "{", "MBBI", "=", "std", "::", "next", "(", "LastRealInstr", ".", "getReverse", "(", ")", ")", ";", "DL", "=", "LastRealInstr", "->", "getDebugLoc", "(", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "INT3", ")", ")", ";", "Changed", "=", "true", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "\"pass only runs on Win64\"", "\"inserting int3 after trailing call instruction:\\n\"", "\"inserting int3 in trailing empty MBB:\\n\"", "X86::INT3" ]

[]

[ "<s>", "SDValue", "TPCSelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "ConstantSDNode", "*", "V", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Src", ")", ";", "assert", "(", "V", "&&", "\"Fill value of memset must be a compile time constant\"", ")", ";", "ConstantSDNode", "*", "SizeValue", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ";", "assert", "(", "SizeValue", "&&", "\"Size in memset call must be a compile time constant\"", ")", ";", "int", "AS", "=", "DstPtrInfo", ".", "getAddrSpace", "(", ")", ";", "assert", "(", "(", "AS", "==", "1", "||", "AS", "==", "2", ")", "&&", "\"memset may be called only for local memory\"", ")", ";", "unsigned", "Sz", "=", "SizeValue", "->", "getZExtValue", "(", ")", ";", "unsigned", "UnitSz", "=", "(", "AS", "==", "1", ")", "?", "4", ":", "256", ";", "assert", "(", "(", "Sz", "%", "UnitSz", "==", "0", ")", "&&", "\"Size in memset must be a multiple of space unit\"", ")", ";", "MVT", "VT", "=", "(", "AS", "==", "1", ")", "?", "MVT", "::", "i32", ":", "MVT", "::", "v64i32", ";", "const", "TPCSubtarget", "&", "STI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getSubtarget", "<", "TPCSubtarget", ">", "(", ")", ";", "const", "TPCTargetLowering", "&", "TLI", "=", "*", "STI", ".", "getTargetLowering", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TLI", ".", "getRegClassFor", "(", "VT", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "uint64_t", "Val", "=", "V", "->", "getZExtValue", "(", ")", "&", "255", ";", "assert", "(", "V", "->", "getZExtValue", "(", ")", "==", "Val", "&&", "\"Non-char value in memset?\"", ")", ";", "Val", "=", "(", "Val", "<<", "8", ")", "|", "Val", ";", "Val", "=", "(", "Val", "<<", "16", ")", "|", "Val", ";", "unsigned", "ValueReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "ValueReg", ",", "DAG", ".", "getConstant", "(", "Val", ",", "dl", ",", "VT", ")", ")", ";", "SDValue", "ZeroV", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "ValueReg", ",", "VT", ")", ";", "Chain", "=", "ZeroV", ".", "getValue", "(", "1", ")", ";", "unsigned", "DstOffs", "=", "0", ";", "SmallVector", "<", "SDValue", ",", "8", ">", "Chains", ";", "for", "(", "unsigned", "I", "=", "0", ",", "SZ", "=", "Sz", "/", "UnitSz", ";", "I", "!=", "SZ", ";", "++", "I", ")", "{", "SDValue", "NewChain", "=", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "ZeroV", ",", "DAG", ".", "getMemBasePlusOffset", "(", "Dst", ",", "DstOffs", ",", "dl", ")", ",", "DstPtrInfo", ".", "getWithOffset", "(", "DstOffs", ")", ",", "Align", ")", ";", "Chains", ".", "push_back", "(", "NewChain", ")", ";", "DstOffs", "+=", "UnitSz", ";", "}", "return", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "Chains", ")", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "\"Fill value of memset must be a compile time constant\"", "\"Size in memset call must be a compile time constant\"", "1", "2", "\"memset may be called only for local memory\"", "1", "4", "256", "0", "\"Size in memset must be a multiple of space unit\"", "1", "MVT::i32", "MVT::v64i32", "TPC", "TPC", "TPC", "255", "\"Non-char value in memset?\"", "8", "16", "1", "0", "8", "0", "ISD::TokenFactor", "MVT::Other" ]

[]

[ "<s>", "void", "MetadataStreamerV2", "::", "verify", "(", "StringRef", "HSAMetadataString", ")", "const", "{", "errs", "(", ")", "<<", "\"AMDGPU HSA Metadata Parser Test: \"", ";", "HSAMD", "::", "Metadata", "FromHSAMetadataString", ";", "if", "(", "fromString", "(", "std", "::", "string", "(", "HSAMetadataString", ")", ",", "FromHSAMetadataString", ")", ")", "{", "errs", "(", ")", "<<", "\"FAIL\\n\"", ";", "return", ";", "}", "std", "::", "string", "ToHSAMetadataString", ";", "if", "(", "toString", "(", "FromHSAMetadataString", ",", "ToHSAMetadataString", ")", ")", "{", "errs", "(", ")", "<<", "\"FAIL\\n\"", ";", "return", ";", "}", "errs", "(", ")", "<<", "(", "HSAMetadataString", "==", "ToHSAMetadataString", "?", "\"PASS\"", ":", "\"FAIL\"", ")", "<<", "'\\n'", ";", "if", "(", "HSAMetadataString", "!=", "ToHSAMetadataString", ")", "{", "errs", "(", ")", "<<", "\"Original input: \"", "<<", "HSAMetadataString", "<<", "'\\n'", "<<", "\"Produced output: \"", "<<", "ToHSAMetadataString", "<<", "'\\n'", ";", "}", "}", "</s>" ]

[ "Check", "if", "this", "register", "bank", "is", "valid", "." ]

[ "AMDGPU", "\"AMDGPU HSA Metadata Parser Test: \"", "\"FAIL\\n\"", "\"FAIL\\n\"", "\"PASS\"", "\"FAIL\"", "\"Original input: \"", "\"Produced output: \"" ]

[]

[ "<s>", "bool", "ARCFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "HasFP", "=", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", "||", "MF", ".", "getFrameInfo", "(", ")", ".", "isFrameAddressTaken", "(", ")", "||", "RegInfo", "->", "hasStackRealignment", "(", "MF", ")", ";", "return", "HasFP", ";", "}", "</s>" ]

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

[ "ARC", "ARC" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "RISCVRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "auto", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_NoRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "if", "(", "Subtarget", ".", "hasStdExtD", "(", ")", ")", "return", "CSR_XLEN_F64_Interrupt_SaveList", ";", "if", "(", "Subtarget", ".", "hasStdExtF", "(", ")", ")", "return", "CSR_XLEN_F32_Interrupt_SaveList", ";", "return", "CSR_Interrupt_SaveList", ";", "}", "switch", "(", "Subtarget", ".", "getTargetABI", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unrecognized ABI\"", ")", ";", "case", "RISCVABI", "::", "ABI_ILP32", ":", "case", "RISCVABI", "::", "ABI_LP64", ":", "return", "CSR_ILP32_LP64_SaveList", ";", "case", "RISCVABI", "::", "ABI_ILP32F", ":", "case", "RISCVABI", "::", "ABI_LP64F", ":", "return", "CSR_ILP32F_LP64F_SaveList", ";", "case", "RISCVABI", "::", "ABI_ILP32D", ":", "case", "RISCVABI", "::", "ABI_LP64D", ":", "return", "CSR_ILP32D_LP64D_SaveList", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "\"interrupt\"", "\"Unrecognized ABI\"", "RISCVABI::ABI_ILP32", "RISCVABI::ABI_LP64", "RISCVABI::ABI_ILP32F", "RISCVABI::ABI_LP64F", "RISCVABI::ABI_ILP32D", "RISCVABI::ABI_LP64D" ]

[]

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

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

[ "Sparc", "\"Sparc Assembly Printer\"" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "auto", "&", "HST", "=", "static_cast", "<", "const", "HexagonSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "auto", "&", "HRI", "=", "*", "HST", ".", "getRegisterInfo", "(", ")", ";", "bool", "HasEHReturn", "=", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", "->", "hasEHReturn", "(", ")", ";", "if", "(", "HasEHReturn", ")", "{", "for", "(", "const", "MCPhysReg", "*", "CSRegs", "=", "HRI", ".", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "*", "CSRegs", ";", "++", "CSRegs", ")", "SavedRegs", ".", "set", "(", "*", "CSRegs", ")", ";", "}", "const", "TargetRegisterClass", "&", "RC", "=", "Hexagon", "::", "IntRegsRegClass", ";", "bool", "HasReplacedPseudoInst", "=", "replacePredRegPseudoSpillCode", "(", "MF", ")", ";", "if", "(", "HasReplacedPseudoInst", "&&", "needToReserveScavengingSpillSlots", "(", "MF", ",", "HRI", ")", ")", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "NumberScavengerSlots", ";", "i", "++", ")", "RS", "->", "addScavengingFrameIndex", "(", "MFI", "->", "CreateSpillStackObject", "(", "RC", ".", "getSize", "(", ")", ",", "RC", ".", "getAlignment", "(", ")", ")", ")", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon::IntRegsRegClass", "0" ]

[]

[ "<s>", "bool", "NVPTXPrologEpilogPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetSubtargetInfo", "&", "STI", "=", "MF", ".", "getSubtarget", "(", ")", ";", "const", "TargetFrameLowering", "&", "TFI", "=", "*", "STI", ".", "getFrameLowering", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "calculateFrameObjectOffsets", "(", "MF", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "continue", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "{", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "assert", "(", "MI", ".", "isDebugOperand", "(", "&", "Op", ")", "&&", "\"Frame indices can only appear as a debug operand in a DBG_VALUE*\"", "\" machine instruction\"", ")", ";", "Register", "Reg", ";", "auto", "Offset", "=", "TFI", ".", "getFrameIndexReference", "(", "MF", ",", "Op", ".", "getIndex", "(", ")", ",", "Reg", ")", ";", "Op", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "Op", ".", "setIsDebug", "(", ")", ";", "const", "DIExpression", "*", "DIExpr", "=", "MI", ".", "getDebugExpression", "(", ")", ";", "if", "(", "MI", ".", "isNonListDebugValue", "(", ")", ")", "{", "DIExpr", "=", "TRI", ".", "prependOffsetExpression", "(", "MI", ".", "getDebugExpression", "(", ")", ",", "DIExpression", "::", "ApplyOffset", ",", "Offset", ")", ";", "}", "else", "{", "SmallVector", "<", "uint64_t", ",", "3", ">", "Ops", ";", "TRI", ".", "getOffsetOpcodes", "(", "Offset", ",", "Ops", ")", ";", "unsigned", "OpIdx", "=", "MI", ".", "getDebugOperandIndex", "(", "&", "Op", ")", ";", "DIExpr", "=", "DIExpression", "::", "appendOpsToArg", "(", "DIExpr", ",", "Ops", ",", "OpIdx", ")", ";", "}", "MI", ".", "getDebugExpressionOp", "(", ")", ".", "setMetadata", "(", "DIExpr", ")", ";", "continue", ";", "}", "TRI", ".", "eliminateFrameIndex", "(", "MI", ",", "0", ",", "i", ",", "nullptr", ")", ";", "Modified", "=", "true", ";", "}", "}", "}", "TFI", ".", "emitPrologue", "(", "MF", ",", "MF", ".", "front", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isReturnBlock", "(", ")", ")", "TFI", ".", "emitEpilogue", "(", "MF", ",", "*", "I", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "0", "\"Frame indices can only appear as a debug operand in a DBG_VALUE*\"", "\" machine instruction\"", "3", "0" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "Shape", "*", "S", ")", "{", "return", "S", "->", "getKind", "(", ")", "==", "SK_Loop", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "WebAssembly" ]

[]

[ "<s>", "const", "char", "*", "Cpu0AsmPrinter", "::", "getCurrentABIString", "(", ")", "const", "{", "switch", "(", "static_cast", "<", "Cpu0TargetMachine", "&", ">", "(", "TM", ")", ".", "getABI", "(", ")", ".", "GetEnumValue", "(", ")", ")", "{", "case", "Cpu0ABIInfo", "::", "ABI", "::", "O32", ":", "return", "\"abiO32\"", ";", "case", "Cpu0ABIInfo", "::", "ABI", "::", "S32", ":", "return", "\"abiS32\"", ";", "default", ":", "llvm_unreachable", "(", "\"Unknown Cpu0 ABI\"", ")", ";", "}", "}", "</s>" ]

[ "Emit", "Set", "directives", "." ]

[ "Cpu0", "Cpu0", "Cpu0", "Cpu0", "ABI::O32", "\"abiO32\"", "Cpu0", "ABI::S32", "\"abiS32\"", "\"Unknown Cpu0 ABI\"" ]

[]

[ "<s>", "static", "void", "set_rop_modrm_reg_bits", "(", "int", "base", ",", "HARD_REG_SET", "&", "in", ",", "HARD_REG_SET", "&", "out", ")", "{", "SET_HARD_REG_BIT", "(", "out", ",", "base", ")", ";", "SET_HARD_REG_BIT", "(", "out", ",", "base", "+", "1", ")", ";", "SET_HARD_REG_BIT", "(", "in", ",", "base", "+", "2", ")", ";", "SET_HARD_REG_BIT", "(", "in", ",", "base", "+", "3", ")", ";", "}", "</s>" ]

[ "Given", "a", "register", "number", "BASE", ",", "the", "lowest", "of", "a", "group", "of", "registers", ",", "update", "regsets", "IN", "and", "OUT", "with", "the", "registers", "that", "should", "be", "avoided", "in", "input", "and", "output", "operands", "respectively", "when", "trying", "to", "avoid", "generating", "a", "modr/m", "byte", "for", "-mmitigate-rop", "." ]

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

[]

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

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

[ "R600", "0" ]

[]

[ "<s>", "unsigned", "TGSIRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "llvm_unreachable", "(", "\"What is the frame register\"", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "TGSI", "TGSI", "\"What is the frame register\"", "0" ]

[]

[ "<s>", "void", "arc_expand_prologue", "(", "void", ")", "{", "int", "size", "=", "get_frame_size", "(", ")", ";", "unsigned", "int", "gmask", "=", "cfun", "->", "machine", "->", "frame_info", ".", "gmask", ";", "unsigned", "int", "frame_size_to_allocate", ";", "int", "first_offset", "=", "0", ";", "size", "=", "ARC_STACK_ALIGN", "(", "size", ")", ";", "size", "=", "(", "!", "cfun", "->", "machine", "->", "frame_info", ".", "initialized", "?", "arc_compute_frame_size", "(", "size", ")", ":", "cfun", "->", "machine", "->", "frame_info", ".", "total_size", ")", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "size", ";", "frame_size_to_allocate", "=", "size", ";", "gcc_assert", "(", "!", "(", "size", "==", "0", "&&", "gmask", ")", ")", ";", "if", "(", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", "!=", "0", ")", "{", "gcc_assert", "(", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", "<=", "32", ")", ";", "frame_stack_add", "(", "-", "(", "HOST_WIDE_INT", ")", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", ")", ";", "frame_size_to_allocate", "-=", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", ";", "}", "if", "(", "MUST_SAVE_RETURN_ADDR", ")", "{", "rtx", "ra", "=", "gen_rtx_REG", "(", "SImode", ",", "RETURN_ADDR_REGNUM", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ")", ";", "frame_move_inc", "(", "mem", ",", "ra", ",", "stack_pointer_rtx", ",", "0", ")", ";", "frame_size_to_allocate", "-=", "UNITS_PER_WORD", ";", "}", "if", "(", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ")", "{", "first_offset", "=", "-", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ";", "arc_save_restore", "(", "stack_pointer_rtx", ",", "gmask", ",", "0", ",", "&", "first_offset", ")", ";", "frame_size_to_allocate", "-=", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ";", "}", "if", "(", "frame_pointer_needed", ")", "{", "rtx", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "UNITS_PER_WORD", "+", "first_offset", ")", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "gen_rtx_PRE_MODIFY", "(", "Pmode", ",", "stack_pointer_rtx", ",", "addr", ")", ")", ";", "frame_move_inc", "(", "mem", ",", "frame_pointer_rtx", ",", "stack_pointer_rtx", ",", "0", ")", ";", "frame_size_to_allocate", "-=", "UNITS_PER_WORD", ";", "first_offset", "=", "0", ";", "frame_move", "(", "frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "}", "frame_size_to_allocate", "-=", "first_offset", ";", "if", "(", "frame_size_to_allocate", ">", "0", ")", "frame_stack_add", "(", "(", "HOST_WIDE_INT", ")", "0", "-", "frame_size_to_allocate", ")", ";", "if", "(", "crtl", "->", "uses_pic_offset_table", ")", "arc_finalize_pic", "(", ")", ";", "}", "</s>" ]

[ "Set", "up", "the", "stack", "and", "frame", "pointer", "(", "if", "desired", ")", "for", "the", "function", "." ]

[ "arc", "0", "0", "0", "32", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "rtx", "rx_function_value", "(", "const_tree", "ret_type", ",", "const_tree", "fn_decl_or_type", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "machine_mode", "mode", "=", "TYPE_MODE", "(", "ret_type", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "0", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<", "4", "&&", "!", "COMPLEX_MODE_P", "(", "mode", ")", "&&", "!", "VECTOR_TYPE_P", "(", "ret_type", ")", "&&", "!", "VECTOR_MODE_P", "(", "mode", ")", ")", "return", "gen_rtx_REG", "(", "SImode", ",", "FUNC_RETURN_REGNUM", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "FUNC_RETURN_REGNUM", ")", ";", "}", "</s>" ]

[ "Return", "an", "RTL", "describing", "where", "a", "function", "return", "value", "of", "type", "RET_TYPE", "is", "held", "." ]

[ "rx", "0", "4" ]

[]

[ "<s>", "const", "char", "*", "AArch64TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "AArch64ISD", "::", "BR_CC", ":", "return", "\"AArch64ISD::BR_CC\"", ";", "case", "AArch64ISD", "::", "Call", ":", "return", "\"AArch64ISD::Call\"", ";", "case", "AArch64ISD", "::", "FPMOV", ":", "return", "\"AArch64ISD::FPMOV\"", ";", "case", "AArch64ISD", "::", "GOTLoad", ":", "return", "\"AArch64ISD::GOTLoad\"", ";", "case", "AArch64ISD", "::", "BFI", ":", "return", "\"AArch64ISD::BFI\"", ";", "case", "AArch64ISD", "::", "EXTR", ":", "return", "\"AArch64ISD::EXTR\"", ";", "case", "AArch64ISD", "::", "Ret", ":", "return", "\"AArch64ISD::Ret\"", ";", "case", "AArch64ISD", "::", "SBFX", ":", "return", "\"AArch64ISD::SBFX\"", ";", "case", "AArch64ISD", "::", "SELECT_CC", ":", "return", "\"AArch64ISD::SELECT_CC\"", ";", "case", "AArch64ISD", "::", "SETCC", ":", "return", "\"AArch64ISD::SETCC\"", ";", "case", "AArch64ISD", "::", "TC_RETURN", ":", "return", "\"AArch64ISD::TC_RETURN\"", ";", "case", "AArch64ISD", "::", "THREAD_POINTER", ":", "return", "\"AArch64ISD::THREAD_POINTER\"", ";", "case", "AArch64ISD", "::", "TLSDESCCALL", ":", "return", "\"AArch64ISD::TLSDESCCALL\"", ";", "case", "AArch64ISD", "::", "WrapperLarge", ":", "return", "\"AArch64ISD::WrapperLarge\"", ";", "case", "AArch64ISD", "::", "WrapperSmall", ":", "return", "\"AArch64ISD::WrapperSmall\"", ";", "case", "AArch64ISD", "::", "NEON_BSL", ":", "return", "\"AArch64ISD::NEON_BSL\"", ";", "case", "AArch64ISD", "::", "NEON_MOVIMM", ":", "return", "\"AArch64ISD::NEON_MOVIMM\"", ";", "case", "AArch64ISD", "::", "NEON_MVNIMM", ":", "return", "\"AArch64ISD::NEON_MVNIMM\"", ";", "case", "AArch64ISD", "::", "NEON_FMOVIMM", ":", "return", "\"AArch64ISD::NEON_FMOVIMM\"", ";", "case", "AArch64ISD", "::", "NEON_CMP", ":", "return", "\"AArch64ISD::NEON_CMP\"", ";", "case", "AArch64ISD", "::", "NEON_CMPZ", ":", "return", "\"AArch64ISD::NEON_CMPZ\"", ";", "case", "AArch64ISD", "::", "NEON_TST", ":", "return", "\"AArch64ISD::NEON_TST\"", ";", "case", "AArch64ISD", "::", "NEON_DUPIMM", ":", "return", "\"AArch64ISD::NEON_DUPIMM\"", ";", "case", "AArch64ISD", "::", "NEON_QSHLs", ":", "return", "\"AArch64ISD::NEON_QSHLs\"", ";", "case", "AArch64ISD", "::", "NEON_QSHLu", ":", "return", "\"AArch64ISD::NEON_QSHLu\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64ISD::BR_CC", "\"AArch64ISD::BR_CC\"", "AArch64ISD::Call", "\"AArch64ISD::Call\"", "AArch64ISD::FPMOV", "\"AArch64ISD::FPMOV\"", "AArch64ISD::GOTLoad", "\"AArch64ISD::GOTLoad\"", "AArch64ISD::BFI", "\"AArch64ISD::BFI\"", "AArch64ISD::EXTR", "\"AArch64ISD::EXTR\"", "AArch64ISD::Ret", "\"AArch64ISD::Ret\"", "AArch64ISD::SBFX", "\"AArch64ISD::SBFX\"", "AArch64ISD::SELECT_CC", "\"AArch64ISD::SELECT_CC\"", "AArch64ISD::SETCC", "\"AArch64ISD::SETCC\"", "AArch64ISD::TC_RETURN", "\"AArch64ISD::TC_RETURN\"", "AArch64ISD::THREAD_POINTER", "\"AArch64ISD::THREAD_POINTER\"", "AArch64ISD::TLSDESCCALL", "\"AArch64ISD::TLSDESCCALL\"", "AArch64ISD::WrapperLarge", "\"AArch64ISD::WrapperLarge\"", "AArch64ISD::WrapperSmall", "\"AArch64ISD::WrapperSmall\"", "AArch64ISD::NEON_BSL", "\"AArch64ISD::NEON_BSL\"", "AArch64ISD::NEON_MOVIMM", "\"AArch64ISD::NEON_MOVIMM\"", "AArch64ISD::NEON_MVNIMM", "\"AArch64ISD::NEON_MVNIMM\"", "AArch64ISD::NEON_FMOVIMM", "\"AArch64ISD::NEON_FMOVIMM\"", "AArch64ISD::NEON_CMP", "\"AArch64ISD::NEON_CMP\"", "AArch64ISD::NEON_CMPZ", "\"AArch64ISD::NEON_CMPZ\"", "AArch64ISD::NEON_TST", "\"AArch64ISD::NEON_TST\"", "AArch64ISD::NEON_DUPIMM", "\"AArch64ISD::NEON_DUPIMM\"", "AArch64ISD::NEON_QSHLs", "\"AArch64ISD::NEON_QSHLs\"", "AArch64ISD::NEON_QSHLu", "\"AArch64ISD::NEON_QSHLu\"" ]

[]

[ "<s>", "bool", "riscv_can_use_return_insn", "(", "void", ")", "{", "return", "(", "reload_completed", "&&", "cfun", "->", "machine", "->", "frame", ".", "total_size", "==", "0", "&&", "!", "cfun", "->", "machine", "->", "interrupt_handler_p", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", ".", "This", "allows", "the", "optimizer", "to", "omit", "jumps", "to", "jumps", "if", "no", "stack", "was", "created", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "bool", "DLXAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "StringRef", "Mnemonic", "=", "splitMnemonic", "(", "Name", ",", "NameLoc", ",", "&", "Operands", ")", ";", "if", "(", "Lexer", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "parseOperand", "(", "&", "Operands", ",", "Mnemonic", ")", "!=", "MatchOperand_Success", ")", "return", "true", ";", "if", "(", "Lexer", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "Name", "==", "\"st\"", "&&", "Operands", ".", "size", "(", ")", "==", "2", ")", "{", "Operands", ".", "erase", "(", "Operands", ".", "begin", "(", ")", ",", "Operands", ".", "begin", "(", ")", "+", "1", ")", ";", "Operands", ".", "insert", "(", "Operands", ".", "begin", "(", ")", ",", "DLXOperand", "::", "CreateToken", "(", "\"s\"", ",", "NameLoc", ")", ")", ";", "Operands", ".", "insert", "(", "Operands", ".", "begin", "(", ")", "+", "1", ",", "DLXOperand", "::", "createImm", "(", "MCConstantExpr", "::", "create", "(", "LPCC", "::", "ICC_T", ",", "getContext", "(", ")", ")", ",", "NameLoc", ",", "NameLoc", ")", ")", ";", "}", "if", "(", "Lexer", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "Name", ".", "startswith", "(", "\"bt\"", ")", "&&", "Operands", ".", "size", "(", ")", "==", "3", ")", "{", "Operands", ".", "erase", "(", "Operands", ".", "begin", "(", ")", ",", "Operands", ".", "begin", "(", ")", "+", "2", ")", ";", "Operands", ".", "insert", "(", "Operands", ".", "begin", "(", ")", ",", "DLXOperand", "::", "CreateToken", "(", "\"bt\"", ",", "NameLoc", ")", ")", ";", "}", "while", "(", "Lexer", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "Lexer", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "&", "Operands", ",", "Mnemonic", ")", "!=", "MatchOperand_Success", ")", "return", "true", ";", "}", "if", "(", "IsMemoryAssignmentError", "(", "Operands", ")", ")", "{", "Error", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ",", "\"the destination register can't equal the base register in an \"", "\"instruction that modifies the base register.\"", ")", ";", "return", "true", ";", "}", "if", "(", "MaybePredicatedInst", "(", "Operands", ")", ")", "{", "Operands", ".", "insert", "(", "Operands", ".", "begin", "(", ")", "+", "1", ",", "DLXOperand", "::", "createImm", "(", "MCConstantExpr", "::", "create", "(", "LPCC", "::", "ICC_T", ",", "getContext", "(", ")", ")", ",", "NameLoc", ",", "NameLoc", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "DLX", "DLX", "\"st\"", "2", "1", "DLXOperand::CreateToken", "\"s\"", "1", "DLXOperand::createImm", "\"bt\"", "3", "2", "DLXOperand::CreateToken", "\"bt\"", "\"the destination register can't equal the base register in an \"", "\"instruction that modifies the base register.\"", "1", "DLXOperand::createImm" ]

[]

[ "<s>", "virtual", "MVT", "getShiftAmountTy", "(", "EVT", "LHSTy", ")", "const", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "Returns", "the", "type", "for", "the", "shift", "amount", "of", "a", "shift", "opcode", "." ]

[ "Kudeyar", "MVT::i32" ]

[]

[ "<s>", "MachineInstr", "*", "AArch64InstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "int", "FrameIndex", ")", "const", "{", "if", "(", "MI", "->", "isCopy", "(", ")", ")", "{", "unsigned", "DstReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "SrcReg", "==", "AArch64", "::", "SP", "&&", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DstReg", ")", ")", "{", "MF", ".", "getRegInfo", "(", ")", ".", "constrainRegClass", "(", "DstReg", ",", "&", "AArch64", "::", "GPR64RegClass", ")", ";", "return", "nullptr", ";", "}", "if", "(", "DstReg", "==", "AArch64", "::", "SP", "&&", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "SrcReg", ")", ")", "{", "MF", ".", "getRegInfo", "(", ")", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "AArch64", "::", "GPR64RegClass", ")", ";", "return", "nullptr", ";", "}", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "1", "AArch64::SP", "AArch64::GPR64RegClass", "AArch64::SP", "AArch64::GPR64RegClass" ]

[]

[ "<s>", "bool", "ix86_using_red_zone", "(", "void", ")", "{", "return", "TARGET_RED_ZONE", "&&", "!", "TARGET_64BIT_MS_ABI", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "red-zone", "is", "in", "use", "." ]

[ "i386" ]

[]

[ "<s>", "InstructionCost", "HexagonTTIImpl", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "TTI", "::", "OperandValueKind", "Opd1Info", ",", "TTI", "::", "OperandValueKind", "Opd2Info", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", ",", "ArrayRef", "<", "const", "Value", "*", ">", "Args", ",", "const", "Instruction", "*", "CxtI", ")", "{", "if", "(", "CostKind", "!=", "TTI", "::", "TCK_RecipThroughput", ")", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "CostKind", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ",", "Args", ",", "CxtI", ")", ";", "if", "(", "Ty", "->", "isVectorTy", "(", ")", ")", "{", "std", "::", "pair", "<", "InstructionCost", ",", "MVT", ">", "LT", "=", "TLI", ".", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "if", "(", "LT", ".", "second", ".", "isFloatingPoint", "(", ")", ")", "return", "LT", ".", "first", "+", "FloatFactor", "*", "getTypeNumElements", "(", "Ty", ")", ";", "}", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "CostKind", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ",", "Args", ",", "CxtI", ")", ";", "}", "</s>" ]

[ "This", "is", "an", "approximation", "of", "reciprocal", "throughput", "of", "a", "math/logic", "op", "." ]

[ "Hexagon", "Hexagon" ]

[]

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

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

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

[]

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

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

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

[]

[ "<s>", "char", "*", "construct_restore_jr", "(", "rtx", "op", ")", "{", "int", "count", "=", "XVECLEN", "(", "op", ",", "0", ")", ";", "int", "stack_bytes", ";", "unsigned", "long", "int", "mask", ";", "unsigned", "long", "int", "first", ";", "unsigned", "long", "int", "last", ";", "int", "i", ";", "static", "char", "buff", "[", "256", "]", ";", "if", "(", "count", "<=", "2", ")", "{", "error", "(", "\"bogus JR construction: %d\"", ",", "count", ")", ";", "return", "NULL", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "XVECEXP", "(", "op", ",", "0", ",", "1", ")", ")", "==", "SET", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "0", ",", "1", ")", ")", ")", "==", "PLUS", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "0", ",", "1", ")", ")", ",", "1", ")", ")", "==", "CONST_INT", ")", ";", "stack_bytes", "=", "INTVAL", "(", "XEXP", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "0", ",", "1", ")", ")", ",", "1", ")", ")", ";", "stack_bytes", "-=", "(", "count", "-", "2", ")", "*", "4", ";", "if", "(", "stack_bytes", "!=", "0", ")", "{", "error", "(", "\"bad amount of stack space removal: %d\"", ",", "stack_bytes", ")", ";", "return", "NULL", ";", "}", "mask", "=", "0", ";", "for", "(", "i", "=", "2", ";", "i", "<", "count", ";", "i", "++", ")", "{", "rtx", "vector_element", "=", "XVECEXP", "(", "op", ",", "0", ",", "i", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "vector_element", ")", "==", "SET", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_DEST", "(", "vector_element", ")", ")", "==", "REG", ")", ";", "gcc_assert", "(", "register_is_ok_for_epilogue", "(", "SET_DEST", "(", "vector_element", ")", ",", "SImode", ")", ")", ";", "mask", "|=", "1", "<<", "REGNO", "(", "SET_DEST", "(", "vector_element", ")", ")", ";", "}", "for", "(", "first", "=", "0", ";", "first", "<", "32", ";", "first", "++", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "first", ")", ")", "break", ";", "}", "gcc_assert", "(", "first", "<", "32", ")", ";", "if", "(", "mask", "&", "(", "1", "<<", "LINK_POINTER_REGNUM", ")", ")", "{", "last", "=", "LINK_POINTER_REGNUM", ";", "}", "else", "{", "gcc_assert", "(", "!", "stack_bytes", ")", ";", "gcc_assert", "(", "mask", "&", "(", "1", "<<", "29", ")", ")", ";", "last", "=", "29", ";", "}", "if", "(", "TARGET_LONG_CALLS", ")", "{", "char", "name", "[", "40", "]", ";", "if", "(", "first", "==", "last", ")", "sprintf", "(", "name", ",", "\"__return_%s\"", ",", "reg_names", "[", "first", "]", ")", ";", "else", "sprintf", "(", "name", ",", "\"__return_%s_%s\"", ",", "reg_names", "[", "first", "]", ",", "reg_names", "[", "last", "]", ")", ";", "sprintf", "(", "buff", ",", "\"movhi hi(%s), r0, r6\\n\\tmovea lo(%s), r6, r6\\n\\tjmp r6\"", ",", "name", ",", "name", ")", ";", "}", "else", "{", "if", "(", "first", "==", "last", ")", "sprintf", "(", "buff", ",", "\"jr __return_%s\"", ",", "reg_names", "[", "first", "]", ")", ";", "else", "sprintf", "(", "buff", ",", "\"jr __return_%s_%s\"", ",", "reg_names", "[", "first", "]", ",", "reg_names", "[", "last", "]", ")", ";", "}", "return", "buff", ";", "}", "</s>" ]

[ "Construct", "a", "JR", "instruction", "to", "a", "routine", "that", "will", "perform", "the", "equivalent", "of", "the", "RTL", "passed", "in", "as", "an", "argument", ".", "This", "RTL", "is", "a", "function", "epilogue", "that", "pops", "registers", "off", "the", "stack", "and", "possibly", "releases", "some", "extra", "stack", "space", "as", "well", ".", "The", "code", "has", "already", "verified", "that", "the", "RTL", "matches", "these", "requirements", "." ]

[ "v850", "0", "256", "2", "\"bogus JR construction: %d\"", "0", "1", "0", "1", "0", "1", "1", "0", "1", "1", "2", "4", "0", "\"bad amount of stack space removal: %d\"", "0", "2", "0", "1", "0", "32", "1", "32", "1", "1", "29", "29", "40", "\"__return_%s\"", "\"__return_%s_%s\"", "\"movhi hi(%s), r0, r6\\n\\tmovea lo(%s), r6, r6\\n\\tjmp r6\"", "\"jr __return_%s\"", "\"jr __return_%s_%s\"" ]

[]

[ "<s>", "int", "m68hc11_register_move_cost", "(", "enum", "machine_mode", "mode", ",", "enum", "reg_class", "from", ",", "enum", "reg_class", "to", ")", "{", "if", "(", "from", "<", "to", ")", "{", "enum", "reg_class", "tmp", "=", "to", ";", "to", "=", "from", ",", "from", "=", "tmp", ";", "}", "if", "(", "to", ">=", "S_REGS", ")", "return", "m68hc11_memory_move_cost", "(", "mode", ",", "S_REGS", ",", "0", ")", ";", "else", "if", "(", "from", "<=", "S_REGS", ")", "return", "COSTS_N_INSNS", "(", "1", ")", "+", "(", "reload_completed", "|", "reload_in_progress", ")", ";", "else", "return", "COSTS_N_INSNS", "(", "2", ")", ";", "}", "</s>" ]

[ "Cost", "of", "moving", "data", "from", "a", "register", "of", "class", "'from", "'", "to", "on", "in", "class", "'to", "'", ".", "Reload", "does", "not", "check", "the", "constraint", "of", "set", "insns", "when", "the", "two", "registers", "have", "a", "move", "cost", "of", "2", ".", "Setting", "a", "higher", "cost", "will", "force", "reload", "to", "check", "the", "constraints", "." ]

[ "m68hc11", "0", "1", "2" ]

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addCodeGenPrepare", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "*", "getAMDGPUTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", ";", "if", "(", "ST", ".", "isPromoteAllocaEnabled", "(", ")", ")", "{", "addPass", "(", "createAMDGPUPromoteAlloca", "(", "ST", ")", ")", ";", "addPass", "(", "createSROAPass", "(", ")", ")", ";", "}", "TargetPassConfig", "::", "addCodeGenPrepare", "(", ")", ";", "}", "</s>" ]

[ "Add", "pass", "to", "prepare", "the", "LLVM", "IR", "for", "code", "generation", "." ]

[ "R600" ]

[]

[ "<s>", "static", "void", "ix86_warn_parameter_passing_abi", "(", "cumulative_args_t", "cum_v", ",", "tree", "type", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "!", "cum", "->", "warn_empty", ")", "return", ";", "if", "(", "!", "TYPE_EMPTY_P", "(", "type", ")", ")", "return", ";", "if", "(", "cum", "->", "decl", "&&", "!", "TREE_PUBLIC", "(", "cum", "->", "decl", ")", ")", "return", ";", "const_tree", "ctx", "=", "get_ultimate_context", "(", "cum", "->", "decl", ")", ";", "if", "(", "ctx", "!=", "NULL_TREE", "&&", "!", "TRANSLATION_UNIT_WARN_EMPTY_P", "(", "ctx", ")", ")", "return", ";", "if", "(", "int_size_in_bytes", "(", "type", ")", "==", "0", ")", "return", ";", "warning", "(", "OPT_Wabi", ",", "\"empty class %qT parameter passing ABI \"", "\"changes in %<-fabi-version=12%> (GCC 8)\"", ",", "type", ")", ";", "cum", "->", "warn_empty", "=", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_WARN_PARAMETER_PASSING_ABI", "." ]

[ "i386", "0", "\"empty class %qT parameter passing ABI \"", "\"changes in %<-fabi-version=12%> (GCC 8)\"" ]

[]

[ "<s>", "static", "bool", "h8300_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict", ")", "{", "if", "(", "h8300_rtx_ok_for_base_p", "(", "x", ",", "strict", ")", ")", "return", "1", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "return", "1", ";", "if", "(", "TARGET_H8300SX", "&&", "(", "GET_CODE", "(", "x", ")", "==", "PRE_INC", "||", "GET_CODE", "(", "x", ")", "==", "PRE_DEC", "||", "GET_CODE", "(", "x", ")", "==", "POST_INC", "||", "GET_CODE", "(", "x", ")", "==", "POST_DEC", ")", "&&", "h8300_rtx_ok_for_base_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict", ")", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "CONSTANT_ADDRESS_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "h8300_rtx_ok_for_base_p", "(", "h8300_get_index", "(", "XEXP", "(", "x", ",", "0", ")", ",", "mode", ",", "0", ")", ",", "strict", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "nozero", "if", "X", "is", "a", "legitimate", "address", ".", "On", "the", "H8/300", ",", "a", "legitimate", "address", "has", "the", "form", "REG", ",", "REG+CONSTANT_ADDRESS", "or", "CONSTANT_ADDRESS", "." ]

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

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "const", "MachineInstr", "&", "MIa", ",", "const", "MachineInstr", "&", "MIb", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "const", "MachineOperand", "*", "BaseOpA", "=", "nullptr", ",", "*", "BaseOpB", "=", "nullptr", ";", "int64_t", "OffsetA", "=", "0", ",", "OffsetB", "=", "0", ";", "unsigned", "WidthA", "=", "0", ",", "WidthB", "=", "0", ";", "assert", "(", "MIa", ".", "mayLoadOrStore", "(", ")", "&&", "\"MIa must be a load or store.\"", ")", ";", "assert", "(", "MIb", ".", "mayLoadOrStore", "(", ")", "&&", "\"MIb must be a load or store.\"", ")", ";", "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "getMemOperandWithOffsetWidth", "(", "MIa", ",", "BaseOpA", ",", "OffsetA", ",", "WidthA", ",", "TRI", ")", "&&", "getMemOperandWithOffsetWidth", "(", "MIb", ",", "BaseOpB", ",", "OffsetB", ",", "WidthB", ",", "TRI", ")", ")", "{", "if", "(", "BaseOpA", "->", "isIdenticalTo", "(", "*", "BaseOpB", ")", ")", "{", "int", "LowOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetA", ":", "OffsetB", ";", "int", "HighOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetB", ":", "OffsetA", ";", "int", "LowWidth", "=", "(", "LowOffset", "==", "OffsetA", ")", "?", "WidthA", ":", "WidthB", ";", "if", "(", "LowOffset", "+", "LowWidth", "<=", "HighOffset", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

[ "AArch64", "AArch64", "0", "0", "0", "0", "\"MIa must be a load or store.\"", "\"MIb must be a load or store.\"" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "X86TargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "unsigned", "NativeWidth", "=", "Subtarget", ".", "is64Bit", "(", ")", "?", "64", ":", "32", ";", "Type", "*", "MemType", "=", "AI", "->", "getType", "(", ")", ";", "if", "(", "MemType", "->", "getPrimitiveSizeInBits", "(", ")", ">", "NativeWidth", ")", "{", "return", "needsCmpXchgNb", "(", "MemType", ")", "?", "AtomicExpansionKind", "::", "CmpXChg", ":", "AtomicExpansionKind", "::", "None", ";", "}", "AtomicRMWInst", "::", "BinOp", "Op", "=", "AI", "->", "getOperation", "(", ")", ";", "switch", "(", "Op", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown atomic operation\"", ")", ";", "case", "AtomicRMWInst", "::", "Xchg", ":", "case", "AtomicRMWInst", "::", "Add", ":", "case", "AtomicRMWInst", "::", "Sub", ":", "return", "AtomicExpansionKind", "::", "None", ";", "case", "AtomicRMWInst", "::", "Or", ":", "case", "AtomicRMWInst", "::", "And", ":", "case", "AtomicRMWInst", "::", "Xor", ":", "return", "shouldExpandLogicAtomicRMWInIR", "(", "AI", ")", ";", "case", "AtomicRMWInst", "::", "Nand", ":", "case", "AtomicRMWInst", "::", "Max", ":", "case", "AtomicRMWInst", "::", "Min", ":", "case", "AtomicRMWInst", "::", "UMax", ":", "case", "AtomicRMWInst", "::", "UMin", ":", "case", "AtomicRMWInst", "::", "FAdd", ":", "case", "AtomicRMWInst", "::", "FSub", ":", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "}", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

[ "X86", "X86", "64", "32", "\"Unknown atomic operation\"" ]

[]

[ "<s>", "static", "tree", "mcore_handle_naked_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to functions\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

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

[ "mcore", "\"%qE attribute only applies to functions\"" ]

[]

[ "<s>", "static", "bool", "arm_evpc_neon_vzip", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "high", ",", "mask", ",", "nelt", "=", "d", "->", "nelt", ";", "rtx", "out0", ",", "out1", ",", "in0", ",", "in1", ",", "x", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "if", "(", "GET_MODE_UNIT_SIZE", "(", "d", "->", "vmode", ")", ">=", "8", ")", "return", "false", ";", "high", "=", "nelt", "/", "2", ";", "if", "(", "d", "->", "perm", "[", "0", "]", "==", "high", ")", ";", "else", "if", "(", "d", "->", "perm", "[", "0", "]", "==", "0", ")", "high", "=", "0", ";", "else", "return", "false", ";", "mask", "=", "(", "d", "->", "one_vector_p", "?", "nelt", "-", "1", ":", "2", "*", "nelt", "-", "1", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", "/", "2", ";", "i", "++", ")", "{", "unsigned", "elt", "=", "(", "i", "+", "high", ")", "&", "mask", ";", "if", "(", "d", "->", "perm", "[", "i", "*", "2", "]", "!=", "elt", ")", "return", "false", ";", "elt", "=", "(", "elt", "+", "nelt", ")", "&", "mask", ";", "if", "(", "d", "->", "perm", "[", "i", "*", "2", "+", "1", "]", "!=", "elt", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "switch", "(", "d", "->", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_neon_vzipv16qi_internal", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_neon_vzipv8qi_internal", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_neon_vzipv8hi_internal", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_neon_vzipv4hi_internal", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_neon_vzipv4si_internal", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_neon_vzipv2si_internal", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_neon_vzipv2sf_internal", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_neon_vzipv4sf_internal", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "in0", "=", "d", "->", "op0", ";", "in1", "=", "d", "->", "op1", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "{", "x", "=", "in0", ",", "in0", "=", "in1", ",", "in1", "=", "x", ";", "high", "=", "!", "high", ";", "}", "out0", "=", "d", "->", "target", ";", "out1", "=", "gen_reg_rtx", "(", "d", "->", "vmode", ")", ";", "if", "(", "high", ")", "x", "=", "out0", ",", "out0", "=", "out1", ",", "out1", "=", "x", ";", "emit_insn", "(", "gen", "(", "out0", ",", "in0", ",", "in1", ",", "out1", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "RISCVAsmBackend", "::", "fixupNeedsRelaxationAdvanced", "(", "const", "MCFixup", "&", "Fixup", ",", "bool", "Resolved", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ",", "const", "bool", "WasForced", ")", "const", "{", "if", "(", "!", "Resolved", "&&", "!", "WasForced", ")", "return", "true", ";", "int64_t", "Offset", "=", "int64_t", "(", "Value", ")", ";", "switch", "(", "Fixup", ".", "getTargetKind", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "RISCV", "::", "fixup_riscv_rvc_branch", ":", "return", "Offset", ">", "254", "||", "Offset", "<", "-", "256", ";", "case", "RISCV", "::", "fixup_riscv_rvc_jump", ":", "return", "Offset", ">", "2046", "||", "Offset", "<", "-", "2048", ";", "}", "}", "</s>" ]

[ "Target", "specific", "predicate", "for", "whether", "a", "given", "fixup", "requires", "the", "associated", "instruction", "to", "be", "relaxed", "." ]

[ "RISCV", "RISCV", "RISCV::fixup_riscv_rvc_branch", "254", "256", "RISCV::fixup_riscv_rvc_jump", "2046", "2048" ]

[]

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

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

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

[]

[ "<s>", "static", "const", "char", "*", "detect_processor_aix", "(", "void", ")", "{", "switch", "(", "_system_configuration", ".", "implementation", ")", "{", "case", "0x0008", ":", "return", "\"601\"", ";", "case", "0x0020", ":", "return", "\"603\"", ";", "case", "0x0010", ":", "return", "\"604\"", ";", "case", "0x0040", ":", "return", "\"620\"", ";", "case", "0x0080", ":", "return", "\"630\"", ";", "case", "0x0100", ":", "case", "0x0200", ":", "case", "0x0400", ":", "return", "\"rs64\"", ";", "case", "0x0800", ":", "return", "\"power4\"", ";", "case", "0x2000", ":", "if", "(", "_system_configuration", ".", "version", "==", "0x0F0000", ")", "return", "\"power5\"", ";", "else", "return", "\"power5+\"", ";", "case", "0x4000", ":", "return", "\"power6\"", ";", "case", "0x8000", ":", "return", "\"power7\"", ";", "case", "0x10000", ":", "return", "\"power8\"", ";", "case", "0x20000", ":", "return", "\"power9\"", ";", "default", ":", "return", "\"powerpc\"", ";", "}", "}", "</s>" ]

[ "Returns", "the", "processor", "implementation", "on", "AIX", "." ]

[ "powerpcspe", "0x0008", "\"601\"", "0x0020", "\"603\"", "0x0010", "\"604\"", "0x0040", "\"620\"", "0x0080", "\"630\"", "0x0100", "0x0200", "0x0400", "\"rs64\"", "0x0800", "\"power4\"", "0x2000", "0x0F0000", "\"power5\"", "\"power5+\"", "0x4000", "\"power6\"", "0x8000", "\"power7\"", "0x10000", "\"power8\"", "0x20000", "\"power9\"", "\"powerpc\"" ]

[]

[ "<s>", "bool", "X86ATTAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'b'", ":", "case", "'h'", ":", "case", "'w'", ":", "case", "'k'", ":", "case", "'q'", ":", "break", ";", "case", "'P'", ":", "printMemReference", "(", "MI", ",", "OpNo", ",", "\"no-rip\"", ")", ";", "return", "false", ";", "}", "}", "printMemReference", "(", "MI", ",", "OpNo", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "X86", "X86", "0", "1", "0", "0", "\"no-rip\"" ]

[]

[ "<s>", "static", "void", "pru_elf_asm_destructor", "(", "rtx", "symbol", ",", "int", "priority", ")", "{", "char", "buf", "[", "23", "]", ";", "section", "*", "s", ";", "if", "(", "priority", "==", "DEFAULT_INIT_PRIORITY", ")", "snprintf", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "\".fini_array\"", ")", ";", "else", "{", "snprintf", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "\".fini_array.%.5u\"", ",", "priority", ")", ";", "}", "s", "=", "get_section", "(", "buf", ",", "SECTION_WRITE", "|", "SECTION_NOTYPE", ",", "NULL", ")", ";", "switch_to_section", "(", "s", ")", ";", "assemble_aligned_integer", "(", "INIT_ARRAY_ENTRY_BYTES", ",", "symbol", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_DESTRUCTOR", "." ]

[ "pru", "23", "\".fini_array\"", "\".fini_array.%.5u\"" ]

[]

[ "<s>", "void", "PatmosFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "TM", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "MFI", "->", "getMaxAlignment", "(", ")", ">", "4", ")", "{", "dbgs", "(", ")", "<<", "\"Stack alignment \"", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ")", "dbgs", "(", ")", "<<", "\"in \"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\" \"", ";", "dbgs", "(", ")", "<<", "\"too large (\"", "<<", "MFI", "->", "getMaxAlignment", "(", ")", "<<", "\").\\n\"", ";", "report_fatal_error", "(", "\"Stack alignment other than 4 byte is not supported\"", ")", ";", "}", "unsigned", "stackSize", "=", "assignFrameObjects", "(", "MF", ",", "!", "DisableStackCache", ")", ";", "if", "(", "!", "DisableStackCache", ")", "{", "MachineInstr", "*", "MI", "=", "emitSTC", "(", "MF", ",", "MBB", ",", "MBBI", ",", "Patmos", "::", "SRESi", ")", ";", "if", "(", "MI", ")", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "patchCallSites", "(", "MF", ")", ";", "}", "if", "(", "stackSize", ")", "{", "if", "(", "stackSize", "<=", "0xFFF", ")", "{", "MachineInstr", "*", "MI", "=", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", "->", "get", "(", "Patmos", "::", "SUBi", ")", ",", "Patmos", "::", "RSP", ")", ")", ".", "addReg", "(", "Patmos", "::", "RSP", ")", ".", "addImm", "(", "stackSize", ")", ";", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "else", "{", "MachineInstr", "*", "MI", "=", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", "->", "get", "(", "Patmos", "::", "SUBl", ")", ",", "Patmos", "::", "RSP", ")", ")", ".", "addReg", "(", "Patmos", "::", "RSP", ")", ".", "addImm", "(", "stackSize", ")", ";", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "}", "}", "</s>" ]

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

[ "Patmos", "Patmos", "4", "\"Stack alignment \"", "\"in \"", "\" \"", "\"too large (\"", "\").\\n\"", "\"Stack alignment other than 4 byte is not supported\"", "Patmos::SRESi", "0xFFF", "Patmos::SUBi", "Patmos::RSP", "Patmos::RSP", "Patmos::SUBl", "Patmos::RSP", "Patmos::RSP" ]

[]

[ "<s>", "unsigned", "GCNTTIImpl", "::", "getNumberOfRegisters", "(", "unsigned", "RCID", ")", "const", "{", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", "->", "getRegisterInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getRegClass", "(", "RCID", ")", ";", "unsigned", "NumVGPRs", "=", "(", "TRI", "->", "getRegSizeInBits", "(", "*", "RC", ")", "+", "31", ")", "/", "32", ";", "return", "getHardwareNumberOfRegisters", "(", "false", ")", "/", "NumVGPRs", ";", "}", "</s>" ]

[ "�", "?", "Vector", "TTI", "begin", "�", "?" ]

[ "AMDGPU", "SI", "31", "32" ]

[]

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

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

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

[]

[ "<s>", "static", "bool", "nds32_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "!", "TARGET_V3PUSH", "&&", "!", "nds32_isr_function_p", "(", "current_function_decl", ")", "&&", "(", "cfun", "->", "machine", "->", "va_args_size", "==", "0", ")", "&&", "decl", "&&", "!", "flag_pic", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "ok", "to", "do", "sibling", "call", "optimization", "." ]

[ "nds32", "0" ]

[]

[ "<s>", "static", "bool", "s390_decompose_constant_pool_ref", "(", "rtx", "*", "ref", ",", "rtx", "*", "disp", ",", "bool", "*", "is_ptr", ",", "bool", "*", "is_base_ptr", ",", "bool", "*", "is_pool_ptr", ")", "{", "if", "(", "!", "*", "ref", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "*", "ref", ")", "==", "UNSPEC", ")", "switch", "(", "XINT", "(", "*", "ref", ",", "1", ")", ")", "{", "case", "UNSPEC_LTREF", ":", "if", "(", "!", "*", "disp", ")", "*", "disp", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "XVECEXP", "(", "*", "ref", ",", "0", ",", "0", ")", ")", ",", "UNSPEC_LTREL_OFFSET", ")", ";", "else", "return", "false", ";", "*", "ref", "=", "XVECEXP", "(", "*", "ref", ",", "0", ",", "1", ")", ";", "break", ";", "default", ":", "return", "false", ";", "}", "if", "(", "!", "REG_P", "(", "*", "ref", ")", "||", "GET_MODE", "(", "*", "ref", ")", "!=", "Pmode", ")", "return", "false", ";", "if", "(", "REGNO", "(", "*", "ref", ")", "==", "STACK_POINTER_REGNUM", "||", "REGNO", "(", "*", "ref", ")", "==", "FRAME_POINTER_REGNUM", "||", "(", "(", "reload_completed", "||", "reload_in_progress", ")", "&&", "frame_pointer_needed", "&&", "REGNO", "(", "*", "ref", ")", "==", "HARD_FRAME_POINTER_REGNUM", ")", "||", "REGNO", "(", "*", "ref", ")", "==", "ARG_POINTER_REGNUM", "||", "(", "flag_pic", "&&", "REGNO", "(", "*", "ref", ")", "==", "PIC_OFFSET_TABLE_REGNUM", ")", ")", "*", "is_ptr", "=", "*", "is_base_ptr", "=", "true", ";", "if", "(", "(", "reload_completed", "||", "reload_in_progress", ")", "&&", "*", "ref", "==", "cfun", "->", "machine", "->", "base_reg", ")", "*", "is_ptr", "=", "*", "is_base_ptr", "=", "*", "is_pool_ptr", "=", "true", ";", "return", "true", ";", "}", "</s>" ]

[ "Attempts", "to", "split", "`", "ref", "'", ",", "which", "should", "be", "UNSPEC_LTREF", ",", "into", "(", "base", "+", "`", "disp", "'", ")", ".", "If", "successful", ",", "also", "determines", "the", "following", "characteristics", "of", "`", "ref", "'", ":", "`", "is_ptr", "'", "-", "whether", "it", "can", "be", "an", "LA", "argument", ",", "`", "is_base_ptr", "'", "-", "whether", "the", "resulting", "base", "is", "a", "well-known", "base", "register", "(", "stack/frame", "pointer", ",", "etc", ")", ",", "`", "is_pool_ptr", "`", "-", "whether", "it", "is", "considered", "a", "literal", "pool", "pointer", "for", "purposes", "of", "avoiding", "two", "different", "literal", "pool", "pointers", "per", "insn", "during", "or", "after", "reload", "(", "`", "B", "'", "constraint", ")", "." ]

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

[]

[ "<s>", "bool", "CSKYInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "TBB", "=", "FBB", "=", "nullptr", ";", "Cond", ".", "clear", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", "||", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "iterator", "FirstUncondOrIndirectBr", "=", "MBB", ".", "end", "(", ")", ";", "int", "NumTerminators", "=", "0", ";", "for", "(", "auto", "J", "=", "I", ".", "getReverse", "(", ")", ";", "J", "!=", "MBB", ".", "rend", "(", ")", "&&", "isUnpredicatedTerminator", "(", "*", "J", ")", ";", "J", "++", ")", "{", "NumTerminators", "++", ";", "if", "(", "J", "->", "getDesc", "(", ")", ".", "isUnconditionalBranch", "(", ")", "||", "J", "->", "getDesc", "(", ")", ".", "isIndirectBranch", "(", ")", ")", "{", "FirstUncondOrIndirectBr", "=", "J", ".", "getReverse", "(", ")", ";", "}", "}", "if", "(", "AllowModify", "&&", "FirstUncondOrIndirectBr", "!=", "MBB", ".", "end", "(", ")", ")", "{", "while", "(", "std", "::", "next", "(", "FirstUncondOrIndirectBr", ")", "!=", "MBB", ".", "end", "(", ")", ")", "{", "std", "::", "next", "(", "FirstUncondOrIndirectBr", ")", "->", "eraseFromParent", "(", ")", ";", "NumTerminators", "--", ";", "}", "I", "=", "FirstUncondOrIndirectBr", ";", "}", "if", "(", "I", "->", "getDesc", "(", ")", ".", "isIndirectBranch", "(", ")", ")", "return", "true", ";", "if", "(", "NumTerminators", ">", "2", ")", "return", "true", ";", "if", "(", "NumTerminators", "==", "1", "&&", "I", "->", "getDesc", "(", ")", ".", "isUnconditionalBranch", "(", ")", ")", "{", "TBB", "=", "getBranchDestBlock", "(", "*", "I", ")", ";", "return", "false", ";", "}", "if", "(", "NumTerminators", "==", "1", "&&", "I", "->", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", ")", "{", "parseCondBranch", "(", "*", "I", ",", "TBB", ",", "Cond", ")", ";", "return", "false", ";", "}", "if", "(", "NumTerminators", "==", "2", "&&", "std", "::", "prev", "(", "I", ")", "->", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", "&&", "I", "->", "getDesc", "(", ")", ".", "isUnconditionalBranch", "(", ")", ")", "{", "parseCondBranch", "(", "*", "std", "::", "prev", "(", "I", ")", ",", "TBB", ",", "Cond", ")", ";", "FBB", "=", "getBranchDestBlock", "(", "*", "I", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "0", "2", "1", "1", "2" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DstReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RISCV", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "RISCV", "::", "LW", ")", ",", "DstReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::GPRRegClass", "RISCV::LW", "0", "\"Can't load this register from stack slot\"" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "adjustStackMapLiveOutMask", "(", "uint32_t", "*", "Mask", ")", "const", "{", "for", "(", "unsigned", "PseudoReg", ":", "{", "PPC", "::", "ZERO", ",", "PPC", "::", "ZERO8", ",", "PPC", "::", "RM", "}", ")", "Mask", "[", "PseudoReg", "/", "32", "]", "&=", "~", "(", "1u", "<<", "(", "PseudoReg", "%", "32", ")", ")", ";", "}", "</s>" ]

[ "Prior", "to", "adding", "the", "live-out", "mask", "to", "a", "stackmap", "or", "patchpoint", "instruction", ",", "provide", "the", "target", "the", "opportunity", "to", "adjust", "it", "(", "mainly", "to", "remove", "pseudo-registers", "that", "should", "be", "ignored", ")", "." ]

[ "PowerPC", "PPC", "PPC::ZERO", "PPC::ZERO8", "PPC::RM", "32", "1u", "32" ]

[]

[ "<s>", "void", "Z80FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Cannot handle this call frame pseudo instruction\"", ")", ";", "case", "Z80", "::", "ADJCALLSTACKDOWN", ":", "case", "Z80", "::", "ADJCALLSTACKUP", ":", "break", ";", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "\"Cannot handle this call frame pseudo instruction\"", "Z80::ADJCALLSTACKDOWN", "Z80::ADJCALLSTACKUP" ]

[]

[ "<s>", "BitVector", "MipsRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "static", "const", "uint16_t", "ReservedCPURegs", "[", "]", "=", "{", "Mips", "::", "ZERO", ",", "Mips", "::", "K0", ",", "Mips", "::", "K1", ",", "Mips", "::", "SP", "}", ";", "static", "const", "uint16_t", "ReservedCPU64Regs", "[", "]", "=", "{", "Mips", "::", "ZERO_64", ",", "Mips", "::", "K0_64", ",", "Mips", "::", "K1_64", ",", "Mips", "::", "SP_64", "}", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "typedef", "TargetRegisterClass", "::", "const_iterator", "RegIter", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "array_lengthof", "(", "ReservedCPURegs", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "ReservedCPURegs", "[", "I", "]", ")", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "array_lengthof", "(", "ReservedCPU64Regs", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "ReservedCPU64Regs", "[", "I", "]", ")", ";", "if", "(", "Subtarget", ".", "hasMips64", "(", ")", ")", "{", "for", "(", "RegIter", "Reg", "=", "Mips", "::", "AFGR64RegClass", ".", "begin", "(", ")", ",", "EReg", "=", "Mips", "::", "AFGR64RegClass", ".", "end", "(", ")", ";", "Reg", "!=", "EReg", ";", "++", "Reg", ")", "Reserved", ".", "set", "(", "*", "Reg", ")", ";", "}", "else", "{", "for", "(", "RegIter", "Reg", "=", "Mips", "::", "FGR64RegClass", ".", "begin", "(", ")", ",", "EReg", "=", "Mips", "::", "FGR64RegClass", ".", "end", "(", ")", ";", "Reg", "!=", "EReg", ";", "++", "Reg", ")", "Reserved", ".", "set", "(", "*", "Reg", ")", ";", "}", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", "->", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "Reserved", ".", "set", "(", "Mips", "::", "S0", ")", ";", "else", "{", "Reserved", ".", "set", "(", "Mips", "::", "FP", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "FP_64", ")", ";", "}", "}", "Reserved", ".", "set", "(", "Mips", "::", "HWR29", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "HWR29_64", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "DSPCtrl", ")", ";", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "{", "Reserved", ".", "set", "(", "Mips", "::", "RA", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "RA_64", ")", ";", "}", "if", "(", "Subtarget", ".", "useSmallSection", "(", ")", ")", "{", "Reserved", ".", "set", "(", "Mips", "::", "GP", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "GP_64", ")", ";", "}", "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", "." ]

[ "Mips", "Mips", "Mips::ZERO", "Mips::K0", "Mips::K1", "Mips::SP", "Mips::ZERO_64", "Mips::K0_64", "Mips::K1_64", "Mips::SP_64", "0", "0", "Mips", "Mips::AFGR64RegClass", "Mips::AFGR64RegClass", "Mips::FGR64RegClass", "Mips::FGR64RegClass", "Mips", "Mips::S0", "Mips::FP", "Mips::FP_64", "Mips::HWR29", "Mips::HWR29_64", "Mips::DSPCtrl", "Mips", "Mips::RA", "Mips::RA_64", "Mips::GP", "Mips::GP_64" ]

[]

[ "<s>", "static", "bool", "c6x_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", ")", "{", "if", "(", "c6x_call_saved_register_used", "(", "exp", ")", ")", "return", "false", ";", "if", "(", "!", "flag_pic", ")", "return", "true", ";", "if", "(", "TARGET_DSBT", ")", "{", "struct", "cgraph_local_info", "*", "this_func", ";", "if", "(", "!", "decl", ")", "return", "false", ";", "this_func", "=", "cgraph_node", "::", "local_info", "(", "current_function_decl", ")", ";", "return", "this_func", "->", "local", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Decide", "whether", "we", "can", "make", "a", "sibling", "call", "to", "a", "function", ".", "DECL", "is", "the", "declaration", "of", "the", "function", "being", "targeted", "by", "the", "call", "and", "EXP", "is", "the", "CALL_EXPR", "representing", "the", "call", "." ]

[ "c6x" ]

[]

[ "<s>", "bool", "MipsTargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ",", "bool", "Fast", ")", "{", "PM", ".", "add", "(", "createMipsDelaySlotFillerPass", "(", "*", "this", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "rtx", "rs6000_emit_set_const", "(", "rtx", "dest", ",", "enum", "machine_mode", "mode", ",", "rtx", "source", ",", "int", "n", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "result", ",", "insn", ",", "set", ";", "HOST_WIDE_INT", "c0", ",", "c1", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "case", "HImode", ":", "if", "(", "dest", "==", "NULL", ")", "dest", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "source", ")", ")", ";", "return", "dest", ";", "case", "SImode", ":", "result", "=", "no_new_pseudos", "?", "dest", ":", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "result", ",", "GEN_INT", "(", "INTVAL", "(", "source", ")", "&", "(", "~", "(", "HOST_WIDE_INT", ")", "0xffff", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "gen_rtx_IOR", "(", "SImode", ",", "result", ",", "GEN_INT", "(", "INTVAL", "(", "source", ")", "&", "0xffff", ")", ")", ")", ")", ";", "result", "=", "dest", ";", "break", ";", "case", "DImode", ":", "switch", "(", "GET_CODE", "(", "source", ")", ")", "{", "case", "CONST_INT", ":", "c0", "=", "INTVAL", "(", "source", ")", ";", "c1", "=", "-", "(", "c0", "<", "0", ")", ";", "break", ";", "case", "CONST_DOUBLE", ":", "c0", "=", "CONST_DOUBLE_LOW", "(", "source", ")", ";", "c1", "=", "-", "(", "c0", "<", "0", ")", ";", "c0", "=", "CONST_DOUBLE_LOW", "(", "source", ")", ";", "c1", "=", "CONST_DOUBLE_HIGH", "(", "source", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "result", "=", "rs6000_emit_set_long_const", "(", "dest", ",", "c0", ",", "c1", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "insn", "=", "get_last_insn", "(", ")", ";", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "!", "CONSTANT_P", "(", "SET_SRC", "(", "set", ")", ")", ")", "set_unique_reg_note", "(", "insn", ",", "REG_EQUAL", ",", "source", ")", ";", "return", "result", ";", "}", "</s>" ]

[ "Try", "to", "output", "insns", "to", "set", "TARGET", "equal", "to", "the", "constant", "C", "if", "it", "can", "be", "done", "in", "less", "than", "N", "insns", ".", "Do", "all", "computations", "in", "MODE", ".", "Returns", "the", "place", "where", "the", "output", "has", "been", "placed", "if", "it", "can", "be", "done", "and", "the", "insns", "have", "been", "emitted", ".", "If", "it", "would", "take", "more", "than", "N", "insns", ",", "zero", "is", "returned", "and", "no", "insns", "and", "emitted", "." ]

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

[]

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

[ "Some", "HW", "prefetchers", "can", "handle", "accesses", "up", "to", "a", "certain", "constant", "stride", "." ]

[ "AArch64" ]

[]

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

[ "Returns", "physical", "register", "used", "as", "frame", "pointer", "." ]

[ "X86" ]

[]

[ "<s>", "void", "HexagonEarlyIfConversion", "::", "removeBlock", "(", "MachineBasicBlock", "*", "B", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Removing block \"", "<<", "PrintMB", "(", "B", ")", "<<", "\"\\n\"", ")", ";", "MachineDomTreeNode", "*", "N", "=", "MDT", "->", "getNode", "(", "B", ")", ";", "MachineDomTreeNode", "*", "IDN", "=", "N", "->", "getIDom", "(", ")", ";", "if", "(", "IDN", ")", "{", "MachineBasicBlock", "*", "IDB", "=", "IDN", "->", "getBlock", "(", ")", ";", "using", "GTN", "=", "GraphTraits", "<", "MachineDomTreeNode", "*", ">", ";", "using", "DTNodeVectType", "=", "SmallVector", "<", "MachineDomTreeNode", "*", ",", "4", ">", ";", "DTNodeVectType", "Cn", "(", "GTN", "::", "child_begin", "(", "N", ")", ",", "GTN", "::", "child_end", "(", "N", ")", ")", ";", "for", "(", "DTNodeVectType", "::", "iterator", "I", "=", "Cn", ".", "begin", "(", ")", ",", "E", "=", "Cn", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineBasicBlock", "*", "SB", "=", "(", "*", "I", ")", "->", "getBlock", "(", ")", ";", "MDT", "->", "changeImmediateDominator", "(", "SB", ",", "IDB", ")", ";", "}", "}", "while", "(", "!", "B", "->", "succ_empty", "(", ")", ")", "B", "->", "removeSuccessor", "(", "B", "->", "succ_begin", "(", ")", ")", ";", "for", "(", "auto", "I", "=", "B", "->", "pred_begin", "(", ")", ",", "E", "=", "B", "->", "pred_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "(", "*", "I", ")", "->", "removeSuccessor", "(", "B", ",", "true", ")", ";", "Deleted", ".", "insert", "(", "B", ")", ";", "MDT", "->", "eraseNode", "(", "B", ")", ";", "MFN", "->", "erase", "(", "B", "->", "getIterator", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "completely", "removes", "BB", "from", "all", "data", "structures", ",", "including", "all", "of", "the", "Loop", "objects", "it", "is", "nested", "in", "and", "our", "mapping", "from", "MachineBasicBlocks", "to", "loops", "." ]

[ "Hexagon", "Hexagon", "\"Removing block \"", "\"\\n\"", "4" ]

[]

[ "<s>", "static", "void", "loongarch_emit_probe_stack_range", "(", "HOST_WIDE_INT", "first", ",", "HOST_WIDE_INT", "size", ")", "{", "if", "(", "(", "TARGET_64BIT", "&&", "(", "first", "+", "size", "<=", "32768", ")", ")", "||", "(", "!", "TARGET_64BIT", "&&", "(", "first", "+", "size", "<=", "2048", ")", ")", ")", "{", "HOST_WIDE_INT", "i", ";", "for", "(", "i", "=", "PROBE_INTERVAL", ";", "i", "<", "size", ";", "i", "+=", "PROBE_INTERVAL", ")", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "i", ")", ")", ")", ";", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "size", ")", ")", ")", ";", "}", "else", "{", "HOST_WIDE_INT", "rounded_size", ";", "rtx", "r13", "=", "LARCH_PROLOGUE_TEMP", "(", "Pmode", ")", ";", "rtx", "r12", "=", "LARCH_PROLOGUE_TEMP2", "(", "Pmode", ")", ";", "rtx", "r14", "=", "LARCH_PROLOGUE_TEMP3", "(", "Pmode", ")", ";", "gcc_assert", "(", "first", "<=", "16384", ")", ";", "rounded_size", "=", "ROUND_DOWN", "(", "size", ",", "PROBE_INTERVAL", ")", ";", "if", "(", "first", "!=", "0", ")", "{", "emit_move_insn", "(", "r14", ",", "GEN_INT", "(", "first", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "r13", ",", "gen_rtx_MINUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "r14", ")", ")", ")", ";", "}", "else", "emit_move_insn", "(", "r13", ",", "stack_pointer_rtx", ")", ";", "emit_move_insn", "(", "r14", ",", "GEN_INT", "(", "PROBE_INTERVAL", ")", ")", ";", "if", "(", "rounded_size", "==", "0", ")", "emit_move_insn", "(", "r12", ",", "r13", ")", ";", "else", "{", "emit_move_insn", "(", "r12", ",", "GEN_INT", "(", "rounded_size", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "r12", ",", "gen_rtx_MINUS", "(", "Pmode", ",", "r13", ",", "r12", ")", ")", ")", ";", "emit_insn", "(", "gen_probe_stack_range", "(", "Pmode", ",", "r13", ",", "r13", ",", "r12", ",", "r14", ")", ")", ";", "}", "if", "(", "size", "!=", "rounded_size", ")", "{", "if", "(", "TARGET_64BIT", ")", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "r12", ",", "rounded_size", "-", "size", ")", ")", ";", "else", "{", "HOST_WIDE_INT", "i", ";", "for", "(", "i", "=", "2048", ";", "i", "<", "(", "size", "-", "rounded_size", ")", ";", "i", "+=", "2048", ")", "{", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "r12", ",", "-", "i", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "r12", ",", "plus_constant", "(", "Pmode", ",", "r12", ",", "-", "2048", ")", ")", ")", ";", "}", "rtx", "r1", "=", "plus_constant", "(", "Pmode", ",", "r12", ",", "-", "(", "size", "-", "rounded_size", "-", "i", "+", "2048", ")", ")", ";", "emit_stack_probe", "(", "r1", ")", ";", "}", "}", "}", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

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

[ "loongarch", "32768", "2048", "16384", "0", "0", "2048", "2048", "2048", "2048" ]

[]

[ "<s>", "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "MipsRegisterBankInfo", "::", "getInstrMapping", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "Mapping", "=", "getInstrMappingImpl", "(", "MI", ")", ";", "if", "(", "Mapping", ".", "isValid", "(", ")", ")", "return", "Mapping", ";", "using", "namespace", "TargetOpcode", ";", "unsigned", "NumOperands", "=", "MI", ".", "getNumOperands", "(", ")", ";", "const", "ValueMapping", "*", "OperandsMapping", "=", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ";", "switch", "(", "Opc", ")", "{", "case", "G_ADD", ":", "case", "G_LOAD", ":", "case", "G_STORE", ":", "case", "G_GEP", ":", "OperandsMapping", "=", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ";", "break", ";", "case", "G_CONSTANT", ":", "case", "G_FRAME_INDEX", ":", "case", "G_GLOBAL_VALUE", ":", "OperandsMapping", "=", "getOperandsMapping", "(", "{", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ",", "nullptr", "}", ")", ";", "break", ";", "default", ":", "return", "getInvalidInstructionMapping", "(", ")", ";", "}", "return", "getInstructionMapping", "(", "DefaultMappingID", ",", "1", ",", "OperandsMapping", ",", "NumOperands", ")", ";", "}", "</s>" ]

[ "Get", "the", "mapping", "of", "the", "different", "operands", "of", "MI", "on", "the", "register", "bank", "." ]

[ "Mips", "Mips", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "1" ]

[]

[ "<s>", "void", "MandarinInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "MD", "::", "GenericRegsRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "MD", "::", "MOVrr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "if", "(", "MD", "::", "DoubleRegsRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "MD", "::", "MOV2rr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "if", "(", "MD", "::", "DoubleRegsRegClass", ".", "contains", "(", "DestReg", ")", "&&", "(", "SrcReg", "==", "MD", "::", "R0", "||", "SrcReg", "==", "MD", "::", "R2", ")", ")", "{", "printf", "(", "\"Registers are already there\\n\"", ")", ";", "}", "else", "if", "(", "MD", "::", "QuadRegsRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "MD", "::", "MOV4rr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "if", "(", "MD", "::", "QuadRegsRegClass", ".", "contains", "(", "DestReg", ")", "&&", "SrcReg", "==", "MD", "::", "R0", ")", "{", "printf", "(", "\"Registers are already there\\n\"", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "Mandarin", "MD::GenericRegsRegClass", "MD::MOVrr", "MD::DoubleRegsRegClass", "MD::MOV2rr", "MD::DoubleRegsRegClass", "MD::R0", "MD::R2", "\"Registers are already there\\n\"", "MD::QuadRegsRegClass", "MD::MOV4rr", "MD::QuadRegsRegClass", "MD::R0", "\"Registers are already there\\n\"", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "unsigned", "TMS320C64XInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "const", "TargetInstrDesc", "desc", "=", "MI", "->", "getDesc", "(", ")", ";", "if", "(", "desc", ".", "TSFlags", "&", "TMS320C64XII", "::", "is_memaccess", "&&", "!", "(", "desc", ".", "TSFlags", "&", "TMS320C64XII", "::", "is_store", ")", ")", "{", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "TMS320C64X", "::", "B15", ")", "{", "MachineOperand", "op", "=", "MI", "->", "getOperand", "(", "1", ")", ";", "if", "(", "op", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "op", ".", "getIndex", "(", ")", ";", "return", "true", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Found load-from-stack sans \"", "\"frame index operand\"", ")", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "TMS320C64X", "TMS320C64X", "TMS320C64XII::is_memaccess", "TMS320C64XII::is_store", "0", "TMS320C64X::B15", "1", "\"Found load-from-stack sans \"", "\"frame index operand\"" ]

[]

[ "<s>", "static", "bool", "avr_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict", ")", "{", "bool", "ok", "=", "CONSTANT_ADDRESS_P", "(", "x", ")", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "ok", "=", "avr_reg_ok_for_addr_p", "(", "x", ",", "ADDR_SPACE_GENERIC", ",", "MEM", ",", "strict", ")", ";", "if", "(", "strict", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", "&&", "REG_X", "==", "REGNO", "(", "x", ")", ")", "{", "ok", "=", "false", ";", "}", "break", ";", "case", "POST_INC", ":", "case", "PRE_DEC", ":", "ok", "=", "avr_reg_ok_for_addr_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "ADDR_SPACE_GENERIC", ",", "GET_CODE", "(", "x", ")", ",", "strict", ")", ";", "break", ";", "case", "PLUS", ":", "{", "rtx", "reg", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "REG_P", "(", "reg", ")", "&&", "CONST_INT_P", "(", "op1", ")", "&&", "INTVAL", "(", "op1", ")", ">=", "0", ")", "{", "bool", "fit", "=", "IN_RANGE", "(", "INTVAL", "(", "op1", ")", ",", "0", ",", "MAX_LD_OFFSET", "(", "mode", ")", ")", ";", "if", "(", "fit", ")", "{", "ok", "=", "(", "!", "strict", "||", "avr_reg_ok_for_addr_p", "(", "reg", ",", "ADDR_SPACE_GENERIC", ",", "PLUS", ",", "strict", ")", ")", ";", "if", "(", "reg", "==", "frame_pointer_rtx", "||", "reg", "==", "arg_pointer_rtx", ")", "{", "ok", "=", "true", ";", "}", "}", "else", "if", "(", "frame_pointer_needed", "&&", "reg", "==", "frame_pointer_rtx", ")", "{", "ok", "=", "true", ";", "}", "}", "}", "break", ";", "default", ":", "break", ";", "}", "if", "(", "AVR_TINY", "&&", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "{", "ok", "=", "(", "CONST_INT_P", "(", "x", ")", "&&", "IN_RANGE", "(", "INTVAL", "(", "x", ")", ",", "0", ",", "0xc0", "-", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ";", "}", "if", "(", "avr_log", ".", "legitimate_address_p", ")", "{", "avr_edump", "(", "\"\\n%?: ret=%d, mode=%m strict=%d \"", "\"reload_completed=%d reload_in_progress=%d %s:\"", ",", "ok", ",", "mode", ",", "strict", ",", "reload_completed", ",", "reload_in_progress", ",", "reg_renumber", "?", "\"(reg_renumber)\"", ":", "\"\"", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "IN_RANGE", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ",", "0", ",", "MAX_LD_OFFSET", "(", "mode", ")", ")", "&&", "reg_renumber", ")", "{", "avr_edump", "(", "\"(r%d ---> r%d)\"", ",", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ",", "true_regnum", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "}", "avr_edump", "(", "\"\\n%r\\n\"", ",", "x", ")", ";", "}", "return", "ok", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "X", "(", "an", "RTX", ")", "is", "a", "legitimate", "memory", "address", "on", "the", "target", "machine", "for", "a", "memory", "operand", "of", "mode", "MODE", "." ]

[ "avr", "4", "0", "0", "1", "0", "0", "0", "0xc0", "\"\\n%?: ret=%d, mode=%m strict=%d \"", "\"reload_completed=%d reload_in_progress=%d %s:\"", "\"(reg_renumber)\"", "\"\"", "0", "1", "1", "0", "\"(r%d ---> r%d)\"", "0", "0", "\"\\n%r\\n\"" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isShuffleMaskLegal", "(", "ArrayRef", "<", "int", ">", "M", ",", "EVT", "VT", ")", "const", "{", "if", "(", "useSVEForFixedLengthVectorVT", "(", "VT", ")", ")", "return", "false", ";", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "4", "&&", "(", "VT", ".", "is128BitVector", "(", ")", "||", "VT", ".", "is64BitVector", "(", ")", ")", ")", "{", "unsigned", "Cost", "=", "getPerfectShuffleCost", "(", "M", ")", ";", "if", "(", "Cost", "<=", "1", ")", "return", "true", ";", "}", "bool", "DummyBool", ";", "int", "DummyInt", ";", "unsigned", "DummyUnsigned", ";", "return", "(", "ShuffleVectorSDNode", "::", "isSplatMask", "(", "&", "M", "[", "0", "]", ",", "VT", ")", "||", "isREVMask", "(", "M", ",", "VT", ",", "64", ")", "||", "isREVMask", "(", "M", ",", "VT", ",", "32", ")", "||", "isREVMask", "(", "M", ",", "VT", ",", "16", ")", "||", "isEXTMask", "(", "M", ",", "VT", ",", "DummyBool", ",", "DummyUnsigned", ")", "||", "isTRNMask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isUZPMask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isZIPMask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isTRN_v_undef_Mask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isUZP_v_undef_Mask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isZIP_v_undef_Mask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isINSMask", "(", "M", ",", "VT", ".", "getVectorNumElements", "(", ")", ",", "DummyBool", ",", "DummyInt", ")", "||", "isConcatMask", "(", "M", ",", "VT", ",", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", ")", ";", "}", "</s>" ]

[ "Targets", "can", "use", "this", "to", "indicate", "that", "they", "only", "support", "some", "VECTOR_SHUFFLE", "operations", ",", "those", "with", "specific", "masks", "." ]

[ "AArch64", "AArch64", "4", "1", "0", "64", "32", "16", "128" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isVectorClearMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "Mask", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "MVT", "SVT", "=", "VT", ".", "getSimpleVT", "(", ")", ";", "if", "(", "ExperimentalVectorShuffleLegality", ")", "return", "isShuffleMaskLegal", "(", "Mask", ",", "VT", ")", ";", "unsigned", "NumElts", "=", "SVT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "NumElts", "==", "2", ")", "return", "true", ";", "if", "(", "NumElts", "==", "4", "&&", "SVT", ".", "is128BitVector", "(", ")", ")", "{", "return", "(", "isMOVLMask", "(", "Mask", ",", "SVT", ")", "||", "isCommutedMOVLMask", "(", "Mask", ",", "SVT", ",", "true", ")", "||", "isSHUFPMask", "(", "Mask", ",", "SVT", ")", "||", "isSHUFPMask", "(", "Mask", ",", "SVT", ",", "true", ")", "||", "isBlendMask", "(", "Mask", ",", "SVT", ",", "Subtarget", "->", "hasSSE41", "(", ")", ",", "Subtarget", "->", "hasInt256", "(", ")", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Similar", "to", "isShuffleMaskLegal", "." ]

[ "X86", "X86", "2", "4" ]

[]

[ "<s>", "enum", "indirect_thunk_prefix", "indirect_thunk_need_prefix", "(", "rtx_insn", "*", "insn", ")", "{", "enum", "indirect_thunk_prefix", "need_prefix", ";", "if", "(", "ix86_bnd_prefixed_insn_p", "(", "insn", ")", ")", "need_prefix", "=", "indirect_thunk_prefix_bnd", ";", "else", "if", "(", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "==", "indirect_branch_thunk_extern", ")", "&&", "ix86_notrack_prefixed_insn_p", "(", "insn", ")", ")", "{", "need_prefix", "=", "indirect_thunk_prefix_nt", ";", "}", "else", "need_prefix", "=", "indirect_thunk_prefix_none", ";", "return", "need_prefix", ";", "}", "</s>" ]

[ "Return", "the", "prefix", "needed", "for", "an", "indirect", "branch", "INSN", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "XNCMPassConfig", "::", "addPreEmitPass", "(", ")", "{", "return", "false", ";", "}", "</s>" ]

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

[ "XNCM", "XNCM" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isZExtFree", "(", "SDValue", "Val", ",", "EVT", "VT2", ")", "const", "{", "EVT", "VT1", "=", "Val", ".", "getValueType", "(", ")", ";", "if", "(", "isZExtFree", "(", "VT1", ",", "VT2", ")", ")", "return", "true", ";", "if", "(", "Val", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "LOAD", ")", "return", "false", ";", "if", "(", "!", "VT1", ".", "isSimple", "(", ")", "||", "!", "VT1", ".", "isInteger", "(", ")", "||", "!", "VT2", ".", "isSimple", "(", ")", "||", "!", "VT2", ".", "isInteger", "(", ")", ")", "return", "false", ";", "switch", "(", "VT1", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "break", ";", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "ISD::LOAD", "MVT::i8", "MVT::i16", "MVT::i32" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "KillFlag", "=", "isKill", "?", "RegState", "::", "Kill", ":", "0", ";", "if", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", ")", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "\"SIInstrInfo::storeRegToStackSlot - Can't spill VGPR!\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "AMDGPU", "::", "VGPR0", ")", ".", "addReg", "(", "SrcReg", ")", ";", "}", "else", "if", "(", "TRI", "->", "getCommonSubClass", "(", "RC", ",", "&", "AMDGPU", "::", "SGPR_32RegClass", ")", ")", "{", "unsigned", "Lane", "=", "MFI", "->", "SpillTracker", ".", "reserveLanes", "(", "MRI", ",", "MF", ")", ";", "unsigned", "TgtReg", "=", "MFI", "->", "SpillTracker", ".", "LaneVGPR", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_WRITELANE_B32", ")", ",", "TgtReg", ")", ".", "addReg", "(", "SrcReg", ",", "KillFlag", ")", ".", "addImm", "(", "Lane", ")", ";", "MFI", "->", "SpillTracker", ".", "addSpilledReg", "(", "FrameIndex", ",", "TgtReg", ",", "Lane", ")", ";", "}", "else", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "unsigned", "NumSubRegs", "=", "RC", "->", "getSize", "(", ")", "/", "4", ";", "unsigned", "FirstLane", "=", "MFI", "->", "SpillTracker", ".", "reserveLanes", "(", "MRI", ",", "MF", ",", "NumSubRegs", ")", ";", "MFI", "->", "SpillTracker", ".", "addSpilledReg", "(", "FrameIndex", ",", "MFI", "->", "SpillTracker", ".", "LaneVGPR", ",", "FirstLane", ")", ";", "unsigned", "Opcode", ";", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "8", ")", "{", "case", "64", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S64_SAVE", ";", "break", ";", "case", "128", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S128_SAVE", ";", "break", ";", "case", "256", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S256_SAVE", ";", "break", ";", "case", "512", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S512_SAVE", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Cannot spill register class\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "MFI", "->", "SpillTracker", ".", "LaneVGPR", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addImm", "(", "FrameIndex", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"VGPR spilling not supported\"", ")", ";", "}", "}", "</s>" ]

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

[ "R600", "SI", "SI", "SI", "0", "\"SIInstrInfo::storeRegToStackSlot - Can't spill VGPR!\"", "4", "8", "64", "SI", "128", "SI", "256", "SI", "512", "SI", "\"Cannot spill register class\"", "\"VGPR spilling not supported\"" ]

[]

[ "<s>", "static", "bool", "aarch64_vectorize_vec_perm_const", "(", "machine_mode", "vmode", ",", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "const", "vec_perm_indices", "&", "sel", ")", "{", "struct", "expand_vec_perm_d", "d", ";", "if", "(", "op0", "&&", "rtx_equal_p", "(", "op0", ",", "op1", ")", ")", "d", ".", "one_vector_p", "=", "true", ";", "else", "if", "(", "sel", ".", "all_from_input_p", "(", "0", ")", ")", "{", "d", ".", "one_vector_p", "=", "true", ";", "op1", "=", "op0", ";", "}", "else", "if", "(", "sel", ".", "all_from_input_p", "(", "1", ")", ")", "{", "d", ".", "one_vector_p", "=", "true", ";", "op0", "=", "op1", ";", "}", "else", "d", ".", "one_vector_p", "=", "false", ";", "d", ".", "perm", ".", "new_vector", "(", "sel", ".", "encoding", "(", ")", ",", "d", ".", "one_vector_p", "?", "1", ":", "2", ",", "sel", ".", "nelts_per_input", "(", ")", ")", ";", "d", ".", "vmode", "=", "vmode", ";", "d", ".", "vec_flags", "=", "aarch64_classify_vector_mode", "(", "d", ".", "vmode", ")", ";", "d", ".", "target", "=", "target", ";", "d", ".", "op0", "=", "op0", ";", "d", ".", "op1", "=", "op1", ";", "d", ".", "testing_p", "=", "!", "target", ";", "if", "(", "!", "d", ".", "testing_p", ")", "return", "aarch64_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "rtx_insn", "*", "last", "=", "get_last_insn", "(", ")", ";", "bool", "ret", "=", "aarch64_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "gcc_assert", "(", "last", "==", "get_last_insn", "(", ")", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Implement", "TARGET_VECTORIZE_VEC_PERM_CONST", "." ]

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

[]

[ "<s>", "AtomicRMWExpansionKind", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "override", "{", "return", "AtomicRMWExpansionKind", "::", "LLSC", ";", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

[ "Hexagon" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", "=", "0", ")", "const", "override", "{", "return", "&", "RISCV", "::", "GPRRegClass", ";", "}", "</s>" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

[ "RISCV", "0", "RISCV::GPRRegClass" ]

[]

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

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

[ "BPF" ]

[]

[ "<s>", "static", "void", "permute_store", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "src_reg", "=", "SET_SRC", "(", "body", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "src_reg", ")", ";", "int", "n_elts", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "int", "half_elts", "=", "n_elts", "/", "2", ";", "rtx", "par", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "n_elts", ")", ")", ";", "int", "i", ",", "j", ";", "for", "(", "i", "=", "0", ",", "j", "=", "half_elts", ";", "i", "<", "half_elts", ";", "++", "i", ",", "++", "j", ")", "XVECEXP", "(", "par", ",", "0", ",", "i", ")", "=", "GEN_INT", "(", "j", ")", ";", "for", "(", "i", "=", "half_elts", ",", "j", "=", "0", ";", "j", "<", "half_elts", ";", "++", "i", ",", "++", "j", ")", "XVECEXP", "(", "par", ",", "0", ",", "i", ")", "=", "GEN_INT", "(", "j", ")", ";", "rtx", "sel", "=", "gen_rtx_VEC_SELECT", "(", "mode", ",", "src_reg", ",", "par", ")", ";", "SET_SRC", "(", "body", ")", "=", "sel", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "df_insn_rescan", "(", "insn", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Replacing store %d with permuted store\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Convert", "the", "non-permuting", "store", "INSN", "to", "a", "permuting", "one", "." ]

[ "powerpcspe", "2", "0", "0", "0", "0", "1", "\"Replacing store %d with permuted store\\n\"" ]

[]

[ "<s>", "ARMBaseTargetMachine", "::", "ARMBaseTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "isLittle", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "CPU", ",", "Options", ",", "isLittle", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "RM", ")", ",", "getEffectiveCodeModel", "(", "CM", ",", "CodeModel", "::", "Small", ")", ",", "OL", ")", ",", "TargetABI", "(", "computeTargetABI", "(", "TT", ",", "CPU", ",", "Options", ")", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "isLittle", "(", "isLittle", ")", "{", "if", "(", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "{", "if", "(", "isTargetHardFloat", "(", ")", ")", "this", "->", "Options", ".", "FloatABIType", "=", "FloatABI", "::", "Hard", ";", "else", "this", "->", "Options", ".", "FloatABIType", "=", "FloatABI", "::", "Soft", ";", "}", "if", "(", "Options", ".", "EABIVersion", "==", "EABI", "::", "Default", "||", "Options", ".", "EABIVersion", "==", "EABI", "::", "Unknown", ")", "{", "if", "(", "(", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUEABI", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUEABIHF", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "MuslEABI", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "MuslEABIHF", ")", "&&", "!", "(", "TargetTriple", ".", "isOSWindows", "(", ")", "||", "TargetTriple", ".", "isOSDarwin", "(", ")", ")", ")", "this", "->", "Options", ".", "EABIVersion", "=", "EABI", "::", "GNU", ";", "else", "this", "->", "Options", ".", "EABIVersion", "=", "EABI", "::", "EABI5", ";", "}", "if", "(", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "NoTrapAfterNoreturn", "=", "true", ";", "}", "setSupportsDebugEntryValues", "(", "true", ")", ";", "initAsmInfo", "(", ")", ";", "setMachineOutliner", "(", "true", ")", ";", "setSupportsDefaultOutlining", "(", "false", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "const", "char", "*", "i386_find_on_wrapper_list", "(", "const", "char", "*", "target", ")", "{", "static", "char", "first_time", "=", "1", ";", "static", "hash_table", "<", "nofree_string_hash", ">", "*", "wrappers", ";", "if", "(", "first_time", ")", "{", "static", "char", "wrapper_list_buffer", "[", "]", "=", "CXX_WRAP_SPEC_LIST", ";", "char", "*", "bufptr", ";", "wrappers", "=", "new", "hash_table", "<", "nofree_string_hash", ">", "(", "8", ")", ";", "for", "(", "bufptr", "=", "wrapper_list_buffer", ";", "*", "bufptr", ";", "++", "bufptr", ")", "{", "char", "*", "found", "=", "NULL", ";", "if", "(", "ISSPACE", "(", "*", "bufptr", ")", ")", "continue", ";", "if", "(", "*", "bufptr", "==", "'_'", ")", "found", "=", "bufptr", ";", "while", "(", "*", "bufptr", "&&", "!", "ISSPACE", "(", "*", "bufptr", ")", ")", "++", "bufptr", ";", "if", "(", "*", "bufptr", ")", "*", "bufptr", "=", "0", ";", "if", "(", "found", ")", "*", "wrappers", "->", "find_slot", "(", "found", ",", "INSERT", ")", "=", "found", ";", "}", "first_time", "=", "0", ";", "}", "return", "wrappers", "->", "find", "(", "target", ")", ";", "}", "</s>" ]

[ "Search", "for", "a", "function", "named", "TARGET", "in", "the", "list", "of", "library", "wrappers", "we", "are", "using", ",", "returning", "a", "pointer", "to", "it", "if", "found", "or", "NULL", "if", "not", ".", "This", "function", "might", "be", "called", "on", "quite", "a", "few", "symbols", ",", "and", "we", "only", "have", "the", "list", "of", "names", "of", "wrapped", "functions", "available", "to", "us", "as", "a", "spec", "string", ",", "so", "first", "time", "round", "we", "lazily", "initialise", "a", "hash", "table", "to", "make", "things", "quicker", "." ]

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

[]

[ "<s>", "void", "Hexagon_CCState", "::", "HandleByVal", "(", "unsigned", "ValNo", ",", "EVT", "ValVT", ",", "EVT", "LocVT", ",", "CCValAssign", "::", "LocInfo", "LocInfo", ",", "int", "MinSize", ",", "int", "MinAlign", ",", "ISD", "::", "ArgFlagsTy", "ArgFlags", ")", "{", "unsigned", "Align", "=", "ArgFlags", ".", "getByValAlign", "(", ")", ";", "unsigned", "Size", "=", "ArgFlags", ".", "getByValSize", "(", ")", ";", "if", "(", "MinSize", ">", "(", "int", ")", "Size", ")", "Size", "=", "MinSize", ";", "if", "(", "MinAlign", ">", "(", "int", ")", "Align", ")", "Align", "=", "MinAlign", ";", "unsigned", "Offset", "=", "AllocateStack", "(", "Size", ",", "Align", ")", ";", "addLoc", "(", "CCValAssign", "::", "getMem", "(", "ValNo", ",", "ValVT", ".", "getSimpleVT", "(", ")", ",", "Offset", ",", "LocVT", ".", "getSimpleVT", "(", ")", ",", "LocInfo", ")", ")", ";", "}", "</s>" ]

[ "Target-specific", "cleanup", "for", "formal", "ByVal", "parameters", "." ]

[ "Hexagon", "Hexagon", "ISD::ArgFlagsTy" ]

[]

[ "<s>", "void", "MipsPassConfig", "::", "addPreEmitPass", "(", ")", "{", "MipsTargetMachine", "&", "TM", "=", "getMipsTargetMachine", "(", ")", ";", "addPass", "(", "createMipsDelaySlotFillerPass", "(", "TM", ")", ")", ";", "addPass", "(", "createMipsHazardSchedule", "(", ")", ")", ";", "addPass", "(", "createMipsLongBranchPass", "(", "TM", ")", ")", ";", "addPass", "(", "createMipsConstantIslandPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "reg_class_t", "csky_secondary_reload", "(", "bool", "in_p", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ",", "reg_class_t", "rclass", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", "ATTRIBUTE_UNUSED", ")", "{", "int", "regno", "=", "-", "1", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SIGN_EXTEND", ")", "{", "int", "off", "=", "0", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "reg_renumber", ")", "regno", "=", "true_regnum", "(", "x", ")", ";", "else", "{", "while", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "{", "off", "+=", "subreg_regno_offset", "(", "REGNO", "(", "SUBREG_REG", "(", "x", ")", ")", ",", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ",", "SUBREG_BYTE", "(", "x", ")", ",", "GET_MODE", "(", "x", ")", ")", ";", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", ")", "regno", "=", "REGNO", "(", "x", ")", "+", "off", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", "||", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "regno", "=", "true_regnum", "(", "x", ")", ";", "if", "(", "rclass", "==", "HILO_REGS", "&&", "!", "CSKY_GENERAL_REGNO_P", "(", "regno", ")", ")", "return", "GENERAL_REGS", ";", "if", "(", "rclass", "==", "V_REGS", "&&", "!", "CSKY_GENERAL_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "MEM_P", "(", "x", ")", "&&", "(", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", ")", ")", "return", "NO_REGS", ";", "else", "return", "GENERAL_REGS", ";", "}", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Implement", "TARGET_SECONDARY_RELOAD", ".", "If", "copying", "a", "register", "of", "RCLASS", "from/to", "X", "requires", "an", "intermediate", "register", ",", "the", "hook", "should", "return", "the", "REGISTER_CLASS", "required", "for", "this", "intermediate", "register", ".", "If", "no", "intermediate", "register", "is", "required", ",", "it", "should", "return", "NO_REGS", ".", "If", "more", "than", "one", "intermediate", "register", "is", "required", ",", "describe", "the", "one", "that", "is", "closest", "in", "the", "copy", "chain", "to", "the", "reload", "register", "." ]

[ "csky", "1", "0", "0" ]

[]

[ "<s>", "static", "rtx", "get_branch_target", "(", "rtx_insn", "*", "branch", ")", "{", "if", "(", "JUMP_P", "(", "branch", ")", ")", "{", "rtx", "set", ",", "src", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "branch", ")", ")", "==", "RETURN", ")", "return", "gen_rtx_REG", "(", "SImode", ",", "LINK_REGISTER_REGNUM", ")", ";", "if", "(", "extract_asm_operands", "(", "PATTERN", "(", "branch", ")", ")", "!=", "NULL", ")", "return", "NULL", ";", "set", "=", "single_set", "(", "branch", ")", ";", "src", "=", "SET_SRC", "(", "set", ")", ";", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "set", ")", ")", "!=", "PC", ")", "abort", "(", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "IF_THEN_ELSE", ")", "{", "rtx", "lab", "=", "0", ";", "rtx", "note", "=", "find_reg_note", "(", "branch", ",", "REG_BR_PROB", ",", "0", ")", ";", "if", "(", "note", ")", "{", "int", "prob", "=", "XINT", "(", "note", ",", "0", ")", ";", "if", "(", "prob", ">", "(", "REG_BR_PROB_BASE", "*", "6", "/", "10", ")", "&&", "GET_CODE", "(", "XEXP", "(", "src", ",", "1", ")", ")", "!=", "PC", ")", "lab", "=", "XEXP", "(", "src", ",", "1", ")", ";", "else", "if", "(", "prob", "<", "(", "REG_BR_PROB_BASE", "*", "4", "/", "10", ")", "&&", "GET_CODE", "(", "XEXP", "(", "src", ",", "2", ")", ")", "!=", "PC", ")", "lab", "=", "XEXP", "(", "src", ",", "2", ")", ";", "}", "if", "(", "lab", ")", "{", "if", "(", "GET_CODE", "(", "lab", ")", "==", "RETURN", ")", "return", "gen_rtx_REG", "(", "SImode", ",", "LINK_REGISTER_REGNUM", ")", ";", "return", "lab", ";", "}", "return", "0", ";", "}", "return", "src", ";", "}", "else", "if", "(", "CALL_P", "(", "branch", ")", ")", "{", "rtx", "call", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "branch", ")", ")", "!=", "PARALLEL", ")", "abort", "(", ")", ";", "call", "=", "XVECEXP", "(", "PATTERN", "(", "branch", ")", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "call", ")", "==", "SET", ")", "call", "=", "SET_SRC", "(", "call", ")", ";", "if", "(", "GET_CODE", "(", "call", ")", "!=", "CALL", ")", "abort", "(", ")", ";", "return", "XEXP", "(", "XEXP", "(", "call", ",", "0", ")", ",", "0", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Returns", "0", "if", "we", "do", "n't", "want", "a", "hint", "for", "this", "branch", ".", "Otherwise", "return", "the", "rtx", "for", "the", "branch", "target", "." ]

[ "spu", "0", "0", "0", "6", "10", "1", "1", "4", "10", "2", "2", "0", "0", "0", "0", "0", "0" ]

[]

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

[ "Tests", "whether", "the", "target", "is", "64-bit", "PowerPC", "(", "little", "and", "big", "endian", ")", "." ]

[ "PowerPC", "PPC", "PPC" ]

[]

[ "<s>", "void", "JVMAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "return", ";", "}", "</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", "." ]

[ "JVM", "JVM" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isProfitableToUnpredicate", "(", "MachineBasicBlock", "&", "TMBB", ",", "MachineBasicBlock", "&", "FMBB", ")", "const", "{", "return", "Subtarget", ".", "isProfitableToUnpredicate", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "profitable", "to", "unpredicate", "one", "side", "of", "a", "'diamond", "'", ",", "i.e", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "TargetTransformInfo", "ARCTargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "const", "{", "return", "TargetTransformInfo", "(", "ARCTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetTransformInfo", "implementation", "for", "the", "target", "." ]

[ "ARC", "ARC", "ARC" ]

[]

[ "<s>", "unsigned", "SparcInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "SP", "::", "BA", "&&", "I", "->", "getOpcode", "(", ")", "!=", "SP", "::", "BCOND", "&&", "I", "->", "getOpcode", "(", ")", "!=", "SP", "::", "FBCOND", ")", "break", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "Sparc", "Sparc", "\"code size not handled\"", "0", "SP::BA", "SP::BCOND", "SP::FBCOND" ]

[]

[ "<s>", "static", "int", "enough_regs_for_param", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "const_tree", "type", ",", "machine_mode", "mode", ")", "{", "int", "type_size", ";", "int", "remaining_size", ";", "if", "(", "mode", "!=", "BLKmode", ")", "type_size", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "else", "type_size", "=", "int_size_in_bytes", "(", "type", ")", "*", "BITS_PER_UNIT", ";", "remaining_size", "=", "BITS_PER_WORD", "*", "(", "MAX_REG_FOR_PASSING_ARGS", "-", "(", "MIN_REG_FOR_PASSING_ARGS", "+", "cum", "->", "ints", ")", "+", "1", ")", ";", "if", "(", "(", "remaining_size", ">=", "type_size", ")", "&&", "(", "type_size", "<=", "2", "*", "BITS_PER_WORD", ")", ")", "return", "(", "type_size", "+", "BITS_PER_WORD", "-", "1", ")", "/", "BITS_PER_WORD", ";", "return", "0", ";", "}", "</s>" ]

[ "If", "enough", "param", "regs", "are", "available", "for", "passing", "the", "param", "of", "type", "TYPE", "return", "*", "the", "number", "of", "registers", "needed", "else", "0", "." ]

[ "cr16", "1", "2", "1", "0" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "RISCV", "::", "SB", ":", "case", "RISCV", "::", "SH", ":", "case", "RISCV", "::", "SW", ":", "case", "RISCV", "::", "FSH", ":", "case", "RISCV", "::", "FSW", ":", "case", "RISCV", "::", "SD", ":", "case", "RISCV", "::", "FSD", ":", "case", "RISCV", "::", "SC_64", ":", "case", "RISCV", "::", "SC_128", ":", "case", "RISCV", "::", "CSB", ":", "case", "RISCV", "::", "CSH", ":", "case", "RISCV", "::", "CSW", ":", "case", "RISCV", "::", "CFSW", ":", "case", "RISCV", "::", "CSD", ":", "case", "RISCV", "::", "CFSD", ":", "case", "RISCV", "::", "CSC_64", ":", "case", "RISCV", "::", "CSC_128", ":", "break", ";", "}", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "0", "RISCV::SB", "RISCV::SH", "RISCV::SW", "RISCV::FSH", "RISCV::FSW", "RISCV::SD", "RISCV::FSD", "RISCV::SC_64", "RISCV::SC_128", "RISCV::CSB", "RISCV::CSH", "RISCV::CSW", "RISCV::CFSW", "RISCV::CSD", "RISCV::CFSD", "RISCV::CSC_64", "RISCV::CSC_128", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "DecodeStatus", "VideocoreDisassembler", "::", "getInstruction", "(", "MCInst", "&", "instr", ",", "uint64_t", "&", "Size", ",", "const", "MemoryObject", "&", "Region", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "vStream", ",", "raw_ostream", "&", "cStream", ")", "const", "{", "DecodeStatus", "Result", ";", "VideocoreBinaryInstr", "Insn", "(", "Region", ",", "Address", ")", ";", "Size", "=", "Insn", ".", "size", "(", ")", ";", "if", "(", "Insn", ".", "type", "(", ")", "==", "VideocoreBinaryInstr", "::", "Invalid", ")", "return", "MCDisassembler", "::", "Fail", ";", "const", "uint8_t", "*", "Table", ";", "switch", "(", "Size", ")", "{", "case", "2", ":", "Table", "=", "llvm", "::", "DecoderTable16", ";", "break", ";", "case", "4", ":", "Table", "=", "llvm", "::", "DecoderTable32", ";", "break", ";", "case", "6", ":", "Table", "=", "llvm", "::", "DecoderTable48", ";", "break", ";", "case", "10", ":", "Table", "=", "llvm", "::", "DecoderTable80", ";", "break", ";", "}", "Result", "=", "llvm", "::", "decodeInstruction", "(", "Table", ",", "instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "return", "Result", ";", "}", "switch", "(", "Insn", ".", "type", "(", ")", ")", "{", "case", "VideocoreBinaryInstr", "::", "Scalar16", ":", "instr", ".", "setOpcode", "(", "VC", "::", "SCALAR16", ")", ";", "break", ";", "case", "VideocoreBinaryInstr", "::", "Scalar32", ":", "instr", ".", "setOpcode", "(", "VC", "::", "SCALAR32", ")", ";", "break", ";", "case", "VideocoreBinaryInstr", "::", "Scalar48", ":", "instr", ".", "setOpcode", "(", "VC", "::", "SCALAR48", ")", ";", "break", ";", "case", "VideocoreBinaryInstr", "::", "Vector48", ":", "instr", ".", "setOpcode", "(", "VC", "::", "VECTOR48", ")", ";", "break", ";", "case", "VideocoreBinaryInstr", "::", "Vector80", ":", "instr", ".", "setOpcode", "(", "VC", "::", "VECTOR80", ")", ";", "break", ";", "default", ":", "return", "MCDisassembler", "::", "Fail", ";", "}", "return", "MCDisassembler", "::", "SoftFail", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "Videocore", "Videocore", "Videocore", "VideocoreBinaryInstr::Invalid", "2", "4", "6", "10", "VideocoreBinaryInstr::Scalar16", "VC::SCALAR16", "VideocoreBinaryInstr::Scalar32", "VC::SCALAR32", "VideocoreBinaryInstr::Scalar48", "VC::SCALAR48", "VideocoreBinaryInstr::Vector48", "VC::VECTOR48", "VideocoreBinaryInstr::Vector80", "VC::VECTOR80" ]

[]

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

[ "Called", "by", "the", "STACK_POINTER_OFFSET", "macro", "." ]

[ "pdp10", "1" ]

[]

[ "<s>", "static", "int", "rs6000_hard_regno_mode_ok", "(", "int", "regno", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "INT_REGNO_P", "(", "regno", ")", ")", "return", "INT_REGNO_P", "(", "regno", "+", "HARD_REGNO_NREGS", "(", "regno", ",", "mode", ")", "-", "1", ")", ";", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "return", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "&&", "FP_REGNO_P", "(", "regno", "+", "HARD_REGNO_NREGS", "(", "regno", ",", "mode", ")", "-", "1", ")", ")", "||", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "UNITS_PER_FP_WORD", ")", ";", "if", "(", "CR_REGNO_P", "(", "regno", ")", ")", "return", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ";", "if", "(", "XER_REGNO_P", "(", "regno", ")", ")", "return", "mode", "==", "PSImode", ";", "if", "(", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "return", "ALTIVEC_VECTOR_MODE", "(", "mode", ")", ";", "if", "(", "SPE_SIMD_REGNO_P", "(", "regno", ")", "&&", "TARGET_SPE", "&&", "SPE_VECTOR_MODE", "(", "mode", ")", ")", "return", "1", ";", "return", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Value", "is", "1", "if", "hard", "register", "REGNO", "can", "hold", "a", "value", "of", "machine-mode", "MODE", "." ]

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

[]

[ "<s>", "void", "SystemZPostRASchedStrategy", "::", "initPolicy", "(", "MachineBasicBlock", "::", "iterator", "Begin", ",", "MachineBasicBlock", "::", "iterator", "End", ",", "unsigned", "NumRegionInstrs", ")", "{", "if", "(", "Begin", "->", "isTerminator", "(", ")", ")", "return", ";", "advanceTo", "(", "Begin", ")", ";", "}", "</s>" ]

[ "Called", "for", "a", "region", "before", "scheduling", "." ]

[ "SystemZ", "SystemZ" ]

[]