Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "unsigned", "int", "aarch64_function_arg_boundary", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "unsigned", "int", "alignment", "=", "aarch64_function_arg_alignment", "(", "mode", ",", "type", ")", ";", "return", "MIN", "(", "MAX", "(", "alignment", ",", "PARM_BOUNDARY", ")", ",", "STACK_BOUNDARY", ")", ";", "}", "</s>" ]

[ "Implement", "FUNCTION_ARG_BOUNDARY", ".", "Every", "parameter", "gets", "at", "least", "PARM_BOUNDARY", "bits", "of", "alignment", ",", "but", "will", "be", "given", "anything", "up", "to", "STACK_BOUNDARY", "bits", "if", "the", "type", "requires", "it", ".", "This", "makes", "sure", "that", "both", "before", "and", "after", "the", "layout", "of", "each", "argument", ",", "the", "Next", "Stacked", "Argument", "Address", "(", "NSAA", ")", "will", "have", "a", "minimum", "alignment", "of", "8", "bytes", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "TOYPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createTOYPreEmit", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "TOY", "TOY", "TOY" ]

[]

[ "<s>", "void", "rl78_expand_movsi", "(", "rtx", "*", "operands", ")", "{", "rtx", "op00", ",", "op02", ",", "op10", ",", "op12", ";", "op00", "=", "rl78_subreg", "(", "HImode", ",", "operands", "[", "0", "]", ",", "SImode", ",", "0", ")", ";", "op02", "=", "rl78_subreg", "(", "HImode", ",", "operands", "[", "0", "]", ",", "SImode", ",", "2", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST", "||", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "SYMBOL_REF", ")", "{", "op10", "=", "gen_rtx_ZERO_EXTRACT", "(", "HImode", ",", "operands", "[", "1", "]", ",", "GEN_INT", "(", "16", ")", ",", "GEN_INT", "(", "0", ")", ")", ";", "op10", "=", "gen_rtx_CONST", "(", "HImode", ",", "op10", ")", ";", "op12", "=", "gen_rtx_ZERO_EXTRACT", "(", "HImode", ",", "operands", "[", "1", "]", ",", "GEN_INT", "(", "16", ")", ",", "GEN_INT", "(", "16", ")", ")", ";", "op12", "=", "gen_rtx_CONST", "(", "HImode", ",", "op12", ")", ";", "}", "else", "{", "op10", "=", "rl78_subreg", "(", "HImode", ",", "operands", "[", "1", "]", ",", "SImode", ",", "0", ")", ";", "op12", "=", "rl78_subreg", "(", "HImode", ",", "operands", "[", "1", "]", ",", "SImode", ",", "2", ")", ";", "}", "if", "(", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", ";", "else", "if", "(", "rtx_equal_p", "(", "op00", ",", "op12", ")", ")", "{", "emit_move_insn", "(", "op02", ",", "op12", ")", ";", "emit_move_insn", "(", "op00", ",", "op10", ")", ";", "}", "else", "{", "emit_move_insn", "(", "op00", ",", "op10", ")", ";", "emit_move_insn", "(", "op02", ",", "op12", ")", ";", "}", "}", "</s>" ]

[ "Used", "by", "movsi", ".", "Split", "SImode", "moves", "into", "two", "HImode", "moves", ",", "using", "appropriate", "patterns", "for", "the", "upper", "and", "lower", "halves", "of", "symbols", "." ]

[ "rl78", "0", "0", "0", "2", "1", "1", "1", "16", "0", "1", "16", "16", "1", "0", "1", "2", "0", "1" ]

[]

[ "<s>", "bool", "LanaiInstrInfo", "::", "analyzeSelect", "(", "const", "MachineInstr", "&", "MI", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "unsigned", "&", "TrueOp", ",", "unsigned", "&", "FalseOp", ",", "bool", "&", "Optimizable", ")", "const", "{", "assert", "(", "MI", ".", "getOpcode", "(", ")", "==", "Lanai", "::", "SELECT", "&&", "\"unknown select instruction\"", ")", ";", "TrueOp", "=", "1", ";", "FalseOp", "=", "2", ";", "Cond", ".", "push_back", "(", "MI", ".", "getOperand", "(", "3", ")", ")", ";", "Optimizable", "=", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Analyze", "the", "given", "select", "instruction", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "." ]

[ "Lanai", "Lanai", "Lanai::SELECT", "\"unknown select instruction\"", "1", "2", "3" ]

[]

[ "<s>", "const", "char", "*", "riscv_output_move", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "enum", "rtx_code", "dest_code", ",", "src_code", ";", "enum", "machine_mode", "mode", ";", "bool", "dbl_p", ";", "dest_code", "=", "GET_CODE", "(", "dest", ")", ";", "src_code", "=", "GET_CODE", "(", "src", ")", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "dbl_p", "=", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", ";", "if", "(", "dbl_p", "&&", "riscv_split_64bit_move_p", "(", "dest", ",", "src", ")", ")", "return", "\"#\"", ";", "if", "(", "dest_code", "==", "REG", "&&", "GP_REG_P", "(", "REGNO", "(", "dest", ")", ")", ")", "{", "if", "(", "src_code", "==", "REG", "&&", "FP_REG_P", "(", "REGNO", "(", "src", ")", ")", ")", "return", "dbl_p", "?", "\"fmv.x.d\\t%0,%1\"", ":", "\"fmv.x.s\\t%0,%1\"", ";", "if", "(", "src_code", "==", "MEM", ")", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "1", ":", "return", "\"lbu\\t%0,%1\"", ";", "case", "2", ":", "return", "\"lhu\\t%0,%1\"", ";", "case", "4", ":", "return", "\"lw\\t%0,%1\"", ";", "case", "8", ":", "return", "\"ld\\t%0,%1\"", ";", "}", "if", "(", "src_code", "==", "CONST_INT", ")", "return", "\"li\\t%0,%1\"", ";", "if", "(", "src_code", "==", "HIGH", ")", "return", "\"lui\\t%0,%h1\"", ";", "if", "(", "symbolic_operand", "(", "src", ",", "VOIDmode", ")", ")", "switch", "(", "riscv_classify_symbolic_expression", "(", "src", ")", ")", "{", "case", "SYMBOL_GOT_DISP", ":", "return", "\"la\\t%0,%1\"", ";", "case", "SYMBOL_ABSOLUTE", ":", "return", "\"lla\\t%0,%1\"", ";", "case", "SYMBOL_PCREL", ":", "return", "\"lla\\t%0,%1\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "(", "src_code", "==", "REG", "&&", "GP_REG_P", "(", "REGNO", "(", "src", ")", ")", ")", "||", "(", "src", "==", "CONST0_RTX", "(", "mode", ")", ")", ")", "{", "if", "(", "dest_code", "==", "REG", ")", "{", "if", "(", "GP_REG_P", "(", "REGNO", "(", "dest", ")", ")", ")", "return", "\"mv\\t%0,%z1\"", ";", "if", "(", "FP_REG_P", "(", "REGNO", "(", "dest", ")", ")", ")", "{", "if", "(", "!", "dbl_p", ")", "return", "\"fmv.s.x\\t%0,%z1\"", ";", "if", "(", "TARGET_64BIT", ")", "return", "\"fmv.d.x\\t%0,%z1\"", ";", "gcc_assert", "(", "src", "==", "CONST0_RTX", "(", "mode", ")", ")", ";", "return", "\"fcvt.d.w\\t%0,x0\"", ";", "}", "}", "if", "(", "dest_code", "==", "MEM", ")", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "1", ":", "return", "\"sb\\t%z1,%0\"", ";", "case", "2", ":", "return", "\"sh\\t%z1,%0\"", ";", "case", "4", ":", "return", "\"sw\\t%z1,%0\"", ";", "case", "8", ":", "return", "\"sd\\t%z1,%0\"", ";", "}", "}", "if", "(", "src_code", "==", "REG", "&&", "FP_REG_P", "(", "REGNO", "(", "src", ")", ")", ")", "{", "if", "(", "dest_code", "==", "REG", "&&", "FP_REG_P", "(", "REGNO", "(", "dest", ")", ")", ")", "return", "dbl_p", "?", "\"fmv.d\\t%0,%1\"", ":", "\"fmv.s\\t%0,%1\"", ";", "if", "(", "dest_code", "==", "MEM", ")", "return", "dbl_p", "?", "\"fsd\\t%1,%0\"", ":", "\"fsw\\t%1,%0\"", ";", "}", "if", "(", "dest_code", "==", "REG", "&&", "FP_REG_P", "(", "REGNO", "(", "dest", ")", ")", ")", "{", "if", "(", "src_code", "==", "MEM", ")", "return", "dbl_p", "?", "\"fld\\t%0,%1\"", ":", "\"flw\\t%0,%1\"", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "appropriate", "instructions", "to", "move", "SRC", "into", "DEST", ".", "Assume", "that", "SRC", "is", "operand", "1", "and", "DEST", "is", "operand", "0", "." ]

[ "riscv", "8", "\"#\"", "\"fmv.x.d\\t%0,%1\"", "\"fmv.x.s\\t%0,%1\"", "1", "\"lbu\\t%0,%1\"", "2", "\"lhu\\t%0,%1\"", "4", "\"lw\\t%0,%1\"", "8", "\"ld\\t%0,%1\"", "\"li\\t%0,%1\"", "\"lui\\t%0,%h1\"", "\"la\\t%0,%1\"", "\"lla\\t%0,%1\"", "\"lla\\t%0,%1\"", "\"mv\\t%0,%z1\"", "\"fmv.s.x\\t%0,%z1\"", "\"fmv.d.x\\t%0,%z1\"", "\"fcvt.d.w\\t%0,x0\"", "1", "\"sb\\t%z1,%0\"", "2", "\"sh\\t%z1,%0\"", "4", "\"sw\\t%z1,%0\"", "8", "\"sd\\t%z1,%0\"", "\"fmv.d\\t%0,%1\"", "\"fmv.s\\t%0,%1\"", "\"fsd\\t%1,%0\"", "\"fsw\\t%1,%0\"", "\"fld\\t%0,%1\"", "\"flw\\t%0,%1\"" ]

[]

[ "<s>", "static", "void", "winnt_d_os_builtins", "(", "void", ")", "{", "d_add_builtin_version", "(", "\"Windows\"", ")", ";", "EXTRA_TARGET_D_OS_VERSIONS", "(", ")", ";", "}", "</s>" ]

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

[ "i386", "\"Windows\"" ]

[]

[ "<s>", "bool", "xtensa_match_CLAMPS_imms_p", "(", "rtx", "cst_max", ",", "rtx", "cst_min", ")", "{", "int", "max", ",", "min", ";", "return", "IN_RANGE", "(", "max", "=", "exact_log2", "(", "-", "INTVAL", "(", "cst_max", ")", ")", ",", "7", ",", "22", ")", "&&", "IN_RANGE", "(", "min", "=", "exact_log2", "(", "INTVAL", "(", "cst_min", ")", "+", "1", ")", ",", "7", ",", "22", ")", "&&", "max", "==", "min", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "constants", "used", "in", "the", "application", "of", "smin", "(", ")", "following", "smax", "(", ")", "meet", "the", "specifications", "of", "the", "CLAMPS", "machine", "instruction", "." ]

[ "xtensa", "7", "22", "1", "7", "22" ]

[]

[ "<s>", "bool", "isProfitableToDupForIfCvt", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "NumCycles", ",", "BranchProbability", "Probability", ")", "const", "override", "{", "const", "MCInstrDesc", "&", "MCID", "=", "std", "::", "prev", "(", "MBB", ".", "end", "(", ")", ")", "->", "getDesc", "(", ")", ";", "if", "(", "MCID", ".", "isReturn", "(", ")", "||", "MCID", ".", "isCall", "(", ")", ")", "return", "false", ";", "return", "NumCycles", "<=", "4", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "profitable", "for", "if-converter", "to", "duplicate", "instructions", "of", "specified", "accumulated", "instruction", "latencies", "in", "the", "specified", "MBB", "to", "enable", "if-conversion", "." ]

[ "Patmos", "4" ]

[]

[ "<s>", "bool", "R600TargetLowering", "::", "isZero", "(", "SDValue", "Op", ")", "const", "{", "if", "(", "ConstantSDNode", "*", "Cst", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "return", "Cst", "->", "isZero", "(", ")", ";", "}", "else", "if", "(", "ConstantFPSDNode", "*", "CstFP", "=", "dyn_cast", "<", "ConstantFPSDNode", ">", "(", "Op", ")", ")", "{", "return", "CstFP", "->", "isZero", "(", ")", ";", "}", "else", "{", "return", "false", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "R600" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"RISCV RI5CY IR pass\"", ";", "}", "</s>" ]

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

[ "RISCV", "\"RISCV RI5CY IR pass\"" ]

[]

[ "<s>", "static", "bool", "frv_function_symbol_referenced_p", "(", "rtx", "x", ")", "{", "const", "char", "*", "format", ";", "int", "length", ";", "int", "j", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "return", "SYMBOL_REF_FUNCTION_P", "(", "x", ")", ";", "length", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "x", ")", ")", ";", "format", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "x", ")", ")", ";", "for", "(", "j", "=", "0", ";", "j", "<", "length", ";", "++", "j", ")", "{", "switch", "(", "format", "[", "j", "]", ")", "{", "case", "'e'", ":", "if", "(", "frv_function_symbol_referenced_p", "(", "XEXP", "(", "x", ",", "j", ")", ")", ")", "return", "TRUE", ";", "break", ";", "case", "'V'", ":", "case", "'E'", ":", "if", "(", "XVEC", "(", "x", ",", "j", ")", "!=", "0", ")", "{", "int", "k", ";", "for", "(", "k", "=", "0", ";", "k", "<", "XVECLEN", "(", "x", ",", "j", ")", ";", "++", "k", ")", "if", "(", "frv_function_symbol_referenced_p", "(", "XVECEXP", "(", "x", ",", "j", ",", "k", ")", ")", ")", "return", "TRUE", ";", "}", "break", ";", "default", ":", "break", ";", "}", "}", "return", "FALSE", ";", "}", "</s>" ]

[ "Look", "for", "a", "SYMBOL_REF", "of", "a", "function", "in", "an", "rtx", ".", "We", "always", "want", "to", "process", "these", "separately", "from", "any", "offsets", ",", "such", "that", "we", "add", "any", "offsets", "to", "the", "function", "descriptor", "(", "the", "actual", "pointer", ")", ",", "not", "to", "the", "function", "address", "." ]

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

[]

[ "<s>", "virtual", "void", "EmitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "EmitA64MappingSymbol", "(", ")", ";", "MCELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

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

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

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

[]

[ "<s>", "static", "rtx", "ix86_expand_v1ti_to_ti", "(", "rtx", "x", ")", "{", "rtx", "result", "=", "gen_reg_rtx", "(", "TImode", ")", ";", "if", "(", "TARGET_SSE2", ")", "{", "rtx", "temp", "=", "force_reg", "(", "V2DImode", ",", "gen_lowpart", "(", "V2DImode", ",", "x", ")", ")", ";", "rtx", "lo", "=", "gen_lowpart", "(", "DImode", ",", "result", ")", ";", "emit_insn", "(", "gen_vec_extractv2didi", "(", "lo", ",", "temp", ",", "const0_rtx", ")", ")", ";", "rtx", "hi", "=", "gen_highpart", "(", "DImode", ",", "result", ")", ";", "emit_insn", "(", "gen_vec_extractv2didi", "(", "hi", ",", "temp", ",", "const1_rtx", ")", ")", ";", "}", "else", "emit_move_insn", "(", "result", ",", "gen_lowpart", "(", "TImode", ",", "x", ")", ")", ";", "return", "result", ";", "}", "</s>" ]

[ "Expand", "move", "of", "V1TI", "mode", "register", "X", "to", "a", "new", "TI", "mode", "register", "." ]

[ "i386" ]

[]

[ "<s>", "static", "bool", "m32r_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "cumulative_args_t", "dummy", "=", "pack_cumulative_args", "(", "NULL", ")", ";", "function_arg_info", "arg", "(", "const_cast", "<", "tree", ">", "(", "type", ")", ",", "false", ")", ";", "return", "m32r_pass_by_reference", "(", "dummy", ",", "arg", ")", ";", "}", "</s>" ]

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

[ "m32r" ]

[]

[ "<s>", "TargetLoweringBase", "::", "LegalizeTypeAction", "WebAssemblyTargetLowering", "::", "getPreferredVectorAction", "(", "MVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "isFixedLengthVector", "(", ")", ")", "{", "MVT", "EltVT", "=", "VT", ".", "getVectorElementType", "(", ")", ";", "if", "(", "EltVT", "==", "MVT", "::", "i8", "||", "EltVT", "==", "MVT", "::", "i16", "||", "EltVT", "==", "MVT", "::", "i32", "||", "EltVT", "==", "MVT", "::", "i64", "||", "EltVT", "==", "MVT", "::", "f32", "||", "EltVT", "==", "MVT", "::", "f64", ")", "return", "TypeWidenVector", ";", "}", "return", "TargetLoweringBase", "::", "getPreferredVectorAction", "(", "VT", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::i64", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "unsigned", "Tile64InstrInfo", "::", "getGlobalBaseReg", "(", "MachineFunction", "*", "MF", ")", "const", "{", "Tile64MachineFunctionInfo", "*", "FI", "=", "MF", "->", "getInfo", "<", "Tile64MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "FI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "!=", "0", ")", "return", "GlobalBaseReg", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "GlobalBaseReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "T64", "::", "T64GPRFRegClass", ")", ";", "DebugLoc", "DL", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "get", "(", "T64", "::", "GBR", ")", ",", "GlobalBaseReg", ")", ";", "FI", "->", "setGlobalBaseReg", "(", "GlobalBaseReg", ")", ";", "return", "GlobalBaseReg", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "Tile64", "0", "T64::T64GPRFRegClass", "T64::GBR" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "MOV8rm", ":", "case", "X86", "::", "MOV16rm", ":", "case", "X86", "::", "MOV32rm", ":", "case", "X86", "::", "MOV64rm", ":", "case", "X86", "::", "LD_Fp64m", ":", "case", "X86", "::", "MOVSSrm", ":", "case", "X86", "::", "MOVSDrm", ":", "case", "X86", "::", "MOVAPSrm", ":", "case", "X86", "::", "MOVAPDrm", ":", "case", "X86", "::", "MOVDQArm", ":", "case", "X86", "::", "MMX_MOVD64rm", ":", "case", "X86", "::", "MMX_MOVQ64rm", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "4", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "1", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", "==", "0", "&&", "MI", "->", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::MOV8rm", "X86::MOV16rm", "X86::MOV32rm", "X86::MOV64rm", "X86::LD_Fp64m", "X86::MOVSSrm", "X86::MOVSDrm", "X86::MOVAPSrm", "X86::MOVAPDrm", "X86::MOVDQArm", "X86::MMX_MOVD64rm", "X86::MMX_MOVQ64rm", "1", "2", "3", "4", "2", "1", "3", "0", "4", "0", "1", "0", "0" ]

[]

[ "<s>", "void", "SPUInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "unsigned", "opc", ";", "bool", "isValidFrameIdx", "=", "(", "FrameIdx", "<", "SPUFrameLowering", "::", "maxFrameOffset", "(", ")", ")", ";", "if", "(", "RC", "==", "SPU", "::", "GPRCRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr128", ":", "SPU", "::", "STQXr128", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R64CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr64", ":", "SPU", "::", "STQXr64", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R64FPRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr64", ":", "SPU", "::", "STQXr64", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R32CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr32", ":", "SPU", "::", "STQXr32", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R32FPRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr32", ":", "SPU", "::", "STQXr32", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R16CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr16", ":", "SPU", "::", "STQXr16", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R8CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr8", ":", "SPU", "::", "STQXr8", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "VECREGRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", ")", "?", "SPU", "::", "STQDv16i8", ":", "SPU", "::", "STQXv16i8", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Unknown regclass!\"", ")", ";", "}", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "opc", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "SPU", "SPU::GPRCRegisterClass", "SPU::STQDr128", "SPU::STQXr128", "SPU::R64CRegisterClass", "SPU::STQDr64", "SPU::STQXr64", "SPU::R64FPRegisterClass", "SPU::STQDr64", "SPU::STQXr64", "SPU::R32CRegisterClass", "SPU::STQDr32", "SPU::STQXr32", "SPU::R32FPRegisterClass", "SPU::STQDr32", "SPU::STQXr32", "SPU::R16CRegisterClass", "SPU::STQDr16", "SPU::STQXr16", "SPU::R8CRegisterClass", "SPU::STQDr8", "SPU::STQXr8", "SPU::VECREGRegisterClass", "SPU::STQDv16i8", "SPU::STQXv16i8", "\"Unknown regclass!\"" ]

[]

[ "<s>", "bool", "JVMPreAllocationFixups", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MFN", ")", "{", "MF", "=", "&", "MFN", ";", "TII", "=", "static_cast", "<", "const", "JVMInstrInfo", "*", ">", "(", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "static_cast", "<", "const", "JVMRegisterInfo", "*", ">", "(", "MF", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "MRI", "=", "&", "MF", "->", "getRegInfo", "(", ")", ";", "DT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n******** JVM Extend Fixups ********\\n\"", ")", ";", "PerformExtendFixups", "(", "DT", "->", "getRootNode", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "JVM", "JVM", "JVM", "JVM", "\"\\n******** JVM Extend Fixups ********\\n\"" ]

[]

[ "<s>", "static", "void", "aarch64_push_regs", "(", "unsigned", "regno1", ",", "unsigned", "regno2", ",", "HOST_WIDE_INT", "adjustment", ")", "{", "rtx_insn", "*", "insn", ";", "machine_mode", "mode", "=", "aarch64_reg_save_mode", "(", "regno1", ")", ";", "if", "(", "regno2", "==", "INVALID_REGNUM", ")", "return", "aarch64_pushwb_single_reg", "(", "mode", ",", "regno1", ",", "adjustment", ")", ";", "rtx", "reg1", "=", "gen_rtx_REG", "(", "mode", ",", "regno1", ")", ";", "rtx", "reg2", "=", "gen_rtx_REG", "(", "mode", ",", "regno2", ")", ";", "insn", "=", "emit_insn", "(", "aarch64_gen_storewb_pair", "(", "mode", ",", "stack_pointer_rtx", ",", "reg1", ",", "reg2", ",", "adjustment", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "2", ")", ")", "=", "1", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "1", ")", ")", "=", "1", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Push", "registers", "numbered", "REGNO1", "and", "REGNO2", "to", "the", "stack", ",", "adjusting", "the", "stack", "pointer", "by", "ADJUSTMENT", "." ]

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

[]

[ "<s>", "bool", "PatmosInstrInfo", "::", "isPseudo", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "MachineBasicBlock", "::", "const_instr_iterator", "II", "=", "MI", ";", "++", "II", ";", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "while", "(", "II", "!=", "MBB", "->", "instr_end", "(", ")", "&&", "II", "->", "isBundledWithPred", "(", ")", ")", "{", "if", "(", "!", "isPseudo", "(", "II", ")", ")", "return", "false", ";", "II", "++", ";", "}", "return", "true", ";", "}", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "return", "true", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", ")", "return", "false", ";", "const", "MCInstrDesc", "&", "TID", "=", "MI", "->", "getDesc", "(", ")", ";", "unsigned", "SchedClass", "=", "TID", ".", "getSchedClass", "(", ")", ";", "const", "InstrStage", "*", "IS", "=", "PST", ".", "getInstrItineraryData", "(", ")", ".", "beginStage", "(", "SchedClass", ")", ";", "unsigned", "FuncUnits", "=", "IS", "->", "getUnits", "(", ")", ";", "return", "!", "FuncUnits", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "is", "a", "pseudo", "instruction", "that", "does", "n't", "correspond", "to", "a", "real", "machine", "instruction", "." ]

[ "Patmos", "Patmos" ]

[]

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

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

[ "NVPTX", "MVT::i32" ]

[]

[ "<s>", "SDValue", "AAPTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "ADD", ":", "return", "PerformADDCombine", "(", "N", ",", "DCI", ")", ";", "default", ":", "break", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "AAP", "AAP", "ISD::ADD" ]

[]

[ "<s>", "static", "void", "visium_conditional_register_usage", "(", "void", ")", "{", "if", "(", "!", "TARGET_SV_MODE", ")", "{", "if", "(", "visium_cpu_and_features", "==", "PROCESSOR_GR5", ")", "{", "fixed_regs", "[", "24", "]", "=", "1", ";", "fixed_regs", "[", "25", "]", "=", "1", ";", "fixed_regs", "[", "26", "]", "=", "1", ";", "fixed_regs", "[", "27", "]", "=", "1", ";", "fixed_regs", "[", "28", "]", "=", "1", ";", "call_used_regs", "[", "24", "]", "=", "0", ";", "call_used_regs", "[", "25", "]", "=", "0", ";", "call_used_regs", "[", "26", "]", "=", "0", ";", "call_used_regs", "[", "27", "]", "=", "0", ";", "call_used_regs", "[", "28", "]", "=", "0", ";", "}", "fixed_regs", "[", "31", "]", "=", "1", ";", "call_used_regs", "[", "31", "]", "=", "0", ";", "if", "(", "visium_cpu_and_features", "==", "PROCESSOR_GR5", ")", "long_branch_regnum", "=", "20", ";", "else", "long_branch_regnum", "=", "28", ";", "}", "if", "(", "!", "TARGET_FPU", ")", "{", "for", "(", "int", "i", "=", "FP_FIRST_REGNUM", ";", "i", "<=", "FP_LAST_REGNUM", ";", "i", "++", ")", "{", "fixed_regs", "[", "i", "]", "=", "1", ";", "call_used_regs", "[", "i", "]", "=", "0", ";", "}", "}", "}", "</s>" ]

[ "Conditionally", "modify", "the", "settings", "of", "the", "register", "file", "." ]

[ "visium", "24", "1", "25", "1", "26", "1", "27", "1", "28", "1", "24", "0", "25", "0", "26", "0", "27", "0", "28", "0", "31", "1", "31", "0", "20", "28", "1", "0" ]

[]

[ "<s>", "static", "bool", "s390_function_arg_float", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "if", "(", "s390_function_arg_size", "(", "mode", ",", "type", ")", ">", "8", ")", "return", "false", ";", "if", "(", "TARGET_SOFT_FLOAT", ")", "return", "false", ";", "if", "(", "!", "type", ")", "return", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", "||", "mode", "==", "SDmode", "||", "mode", "==", "DDmode", ";", "while", "(", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", ")", "{", "tree", "field", ",", "single", "=", "NULL_TREE", ";", "for", "(", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "DECL_CHAIN", "(", "field", ")", ")", "{", "if", "(", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", ")", "continue", ";", "if", "(", "single", "==", "NULL_TREE", ")", "single", "=", "TREE_TYPE", "(", "field", ")", ";", "else", "return", "false", ";", "}", "if", "(", "single", "==", "NULL_TREE", ")", "return", "false", ";", "else", "type", "=", "single", ";", "}", "return", "TREE_CODE", "(", "type", ")", "==", "REAL_TYPE", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "function", "argument", "of", "type", "TYPE", "and", "mode", "MODE", "is", "to", "be", "passed", "in", "a", "floating-point", "register", ",", "if", "available", "." ]

[ "s390", "8" ]

[]

[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "assert", "(", "Expr", "&&", "\"Expr shouldn't be null!\"", ")", ";", "int64_t", "Imm", "=", "0", ";", "bool", "IsConstant", "=", "false", ";", "if", "(", "auto", "*", "RE", "=", "dyn_cast", "<", "CAHPMCExpr", ">", "(", "Expr", ")", ")", "{", "IsConstant", "=", "RE", "->", "evaluateAsConstant", "(", "Imm", ")", ";", "}", "else", "if", "(", "auto", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "{", "IsConstant", "=", "true", ";", "Imm", "=", "CE", "->", "getValue", "(", ")", ";", "}", "if", "(", "IsConstant", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Imm", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "MCExpr", "operand", "." ]

[ "CAHP", "\"Expr shouldn't be null!\"", "0", "CAHP" ]

[]

[ "<s>", "static", "tree", "c6x_builtin_decl", "(", "unsigned", "code", ",", "bool", "initialize_p", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "code", ">=", "C6X_BUILTIN_MAX", ")", "return", "error_mark_node", ";", "return", "c6x_builtin_decls", "[", "code", "]", ";", "}", "</s>" ]

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

[ "c6x" ]

[]

[ "<s>", "void", "ARMBaseInstrInfo", "::", "setExecutionDomain", "(", "MachineInstr", "*", "MI", ",", "unsigned", "Domain", ")", "const", "{", "assert", "(", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "VMOVD", "&&", "\"Can only swizzle VMOVD\"", ")", ";", "if", "(", "Domain", "!=", "ExeNEON", ")", "return", ";", "assert", "(", "!", "isPredicated", "(", "MI", ")", "&&", "\"Cannot predicate a VORRd\"", ")", ";", "MI", "->", "RemoveOperand", "(", "3", ")", ";", "MI", "->", "RemoveOperand", "(", "2", ")", ";", "MI", "->", "setDesc", "(", "get", "(", "ARM", "::", "VORRd", ")", ")", ";", "AddDefaultPred", "(", "MachineInstrBuilder", "(", "MI", ")", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "1", ")", ")", ")", ";", "}", "</s>" ]

[ "Change", "the", "opcode", "of", "MI", "to", "execute", "in", "Domain", "." ]

[ "ARM", "ARM", "ARM::VMOVD", "\"Can only swizzle VMOVD\"", "\"Cannot predicate a VORRd\"", "3", "2", "ARM::VORRd", "1" ]

[]

[ "<s>", "const", "char", "*", "output_movedouble", "(", "rtx", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "operands", "[", "]", ",", "machine_mode", "mode", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "if", "(", "MEM_P", "(", "dst", ")", "&&", "GET_CODE", "(", "XEXP", "(", "dst", ",", "0", ")", ")", "==", "PRE_DEC", ")", "return", "\"mov.l\t%T1,%0\"", "\"\\n\"", "\"\tmov.l\t%1,%0\"", ";", "if", "(", "register_operand", "(", "dst", ",", "mode", ")", "&&", "register_operand", "(", "src", ",", "mode", ")", ")", "{", "if", "(", "REGNO", "(", "src", ")", "==", "MACH_REG", ")", "return", "\"sts\tmach,%S0\"", "\"\\n\"", "\"\tsts\tmacl,%R0\"", ";", "if", "(", "REGNO", "(", "src", ")", "+", "1", "==", "REGNO", "(", "dst", ")", ")", "return", "\"mov\t%T1,%T0\"", "\"\\n\"", "\"\tmov\t%1,%0\"", ";", "else", "return", "\"mov\t%1,%0\"", "\"\\n\"", "\"\tmov\t%T1,%T0\"", ";", "}", "else", "if", "(", "CONST_INT_P", "(", "src", ")", ")", "{", "if", "(", "INTVAL", "(", "src", ")", "<", "0", ")", "output_asm_insn", "(", "\"mov\t#-1,%S0\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"mov\t#0,%S0\"", ",", "operands", ")", ";", "return", "\"mov\t%1,%R0\"", ";", "}", "else", "if", "(", "MEM_P", "(", "src", ")", ")", "{", "int", "ptrreg", "=", "-", "1", ";", "int", "dreg", "=", "REGNO", "(", "dst", ")", ";", "rtx", "inside", "=", "XEXP", "(", "src", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "inside", ")", ")", "{", "case", "REG", ":", "ptrreg", "=", "REGNO", "(", "inside", ")", ";", "break", ";", "case", "SUBREG", ":", "ptrreg", "=", "subreg_regno", "(", "inside", ")", ";", "break", ";", "case", "PLUS", ":", "ptrreg", "=", "REGNO", "(", "XEXP", "(", "inside", ",", "0", ")", ")", ";", "gcc_assert", "(", "!", "REG_P", "(", "XEXP", "(", "inside", ",", "1", ")", ")", ")", ";", "break", ";", "case", "LABEL_REF", ":", "return", "\"mov.l\t%1,%0\"", "\"\\n\"", "\"\tmov.l\t%1+4,%T0\"", ";", "case", "POST_INC", ":", "return", "\"mov.l\t%1,%0\"", "\"\\n\"", "\"\tmov.l\t%1,%T0\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "dreg", "==", "ptrreg", ")", "return", "\"mov.l\t%T1,%T0\"", "\"\\n\"", "\"\tmov.l\t%1,%0\"", ";", "}", "return", "\"mov.l\t%1,%0\"", "\"\\n\"", "\"\tmov.l\t%T1,%T0\"", ";", "}", "</s>" ]

[ "Return", "a", "sequence", "of", "instructions", "to", "perform", "DI", "or", "DF", "move", ".", "Since", "the", "SH", "can", "not", "move", "a", "DI", "or", "DF", "in", "one", "instruction", ",", "we", "have", "to", "take", "care", "when", "we", "see", "overlapping", "source", "and", "dest", "registers", "." ]

[ "sh", "0", "1", "0", "\"mov.l\t%T1,%0\"", "\"\\n\"", "\"\tmov.l\t%1,%0\"", "\"sts\tmach,%S0\"", "\"\\n\"", "\"\tsts\tmacl,%R0\"", "1", "\"mov\t%T1,%T0\"", "\"\\n\"", "\"\tmov\t%1,%0\"", "\"mov\t%1,%0\"", "\"\\n\"", "\"\tmov\t%T1,%T0\"", "0", "\"mov\t#-1,%S0\"", "\"mov\t#0,%S0\"", "\"mov\t%1,%R0\"", "1", "0", "0", "1", "\"mov.l\t%1,%0\"", "\"\\n\"", "\"\tmov.l\t%1+4,%T0\"", "\"mov.l\t%1,%0\"", "\"\\n\"", "\"\tmov.l\t%1,%T0\"", "\"mov.l\t%T1,%T0\"", "\"\\n\"", "\"\tmov.l\t%1,%0\"", "\"mov.l\t%1,%0\"", "\"\\n\"", "\"\tmov.l\t%T1,%T0\"" ]

[]

[ "<s>", "unsigned", "int", "rs6000_special_round_type_align", "(", "tree", "type", ",", "int", "computed", ",", "int", "specified", ")", "{", "tree", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "while", "(", "field", "!=", "NULL", "&&", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", ")", "field", "=", "TREE_CHAIN", "(", "field", ")", ";", "if", "(", "field", "==", "NULL", "||", "field", "==", "type", "||", "DECL_MODE", "(", "field", ")", "!=", "DFmode", ")", "return", "MAX", "(", "computed", ",", "specified", ")", ";", "return", "MAX", "(", "MAX", "(", "computed", ",", "specified", ")", ",", "64", ")", ";", "}", "</s>" ]

[ "Darwin", ",", "AIX", "increases", "natural", "record", "alignment", "to", "doubleword", "if", "the", "first", "field", "is", "an", "FP", "double", "while", "the", "FP", "fields", "remain", "word", "aligned", "." ]

[ "rs6000", "64" ]

[]

[ "<s>", "static", "bool", "tilepro_emit_setcc_internal", "(", "rtx", "res", ",", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ",", "machine_mode", "cmp_mode", ")", "{", "rtx", "tmp", ";", "bool", "swap", "=", "false", ";", "if", "(", "cmp_mode", "==", "DImode", ")", "{", "return", "tilepro_emit_setcc_internal_di", "(", "res", ",", "code", ",", "op0", ",", "op1", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "NE", ":", "case", "LE", ":", "case", "LT", ":", "case", "LEU", ":", "case", "LTU", ":", "break", ";", "case", "GE", ":", "case", "GT", ":", "case", "GEU", ":", "case", "GTU", ":", "swap", "=", "true", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "swap", ")", "{", "code", "=", "swap_condition", "(", "code", ")", ";", "tmp", "=", "op0", ",", "op0", "=", "op1", ",", "op1", "=", "tmp", ";", "}", "if", "(", "!", "reg_or_0_operand", "(", "op0", ",", "SImode", ")", ")", "op0", "=", "force_reg", "(", "SImode", ",", "op0", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op1", ")", "&&", "!", "register_operand", "(", "op1", ",", "SImode", ")", ")", "op1", "=", "force_reg", "(", "SImode", ",", "op1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "res", ",", "gen_rtx_fmt_ee", "(", "code", ",", "SImode", ",", "op0", ",", "op1", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Certain", "simplifications", "can", "be", "done", "to", "make", "invalid", "setcc", "operations", "valid", ".", "Return", "the", "final", "comparison", ",", "or", "NULL", "if", "we", "ca", "n't", "work", "." ]

[ "tilepro" ]

[]

[ "<s>", "void", "SystemZRegisterInfo", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "const", "TargetFrameInfo", "&", "TFI", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "SystemZMFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "StackSize", "-=", "SystemZMFI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "StackSize", "-", "TFI", ".", "getOffsetOfLocalArea", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "SystemZ", "::", "MOV64mr", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "SystemZ", "::", "MOV64mrm", ")", ")", "++", "MBBI", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "StackSize", "||", "MFI", "->", "hasCalls", "(", ")", ")", "{", "assert", "(", "MF", ".", "getRegInfo", "(", ")", ".", "isPhysRegUsed", "(", "SystemZ", "::", "R15D", ")", "&&", "\"Invalid stack frame calculation!\"", ")", ";", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "-", "(", "int64_t", ")", "NumBytes", ",", "TII", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "SystemZ", "::", "MOV64rr", ")", ",", "SystemZ", "::", "R11D", ")", ".", "addReg", "(", "SystemZ", "::", "R15D", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "llvm", "::", "next", "(", "MF", ".", "begin", "(", ")", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "I", "->", "addLiveIn", "(", "SystemZ", "::", "R11D", ")", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ::MOV64mr", "SystemZ::MOV64mrm", "SystemZ::R15D", "\"Invalid stack frame calculation!\"", "SystemZ::MOV64rr", "SystemZ::R11D", "SystemZ::R15D", "SystemZ::R11D" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "unsigned", "FIOperandNum", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "isFI", "(", ")", ")", "{", "++", "FIOperandNum", ";", "assert", "(", "FIOperandNum", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BaseReg", ",", "false", ")", ";", "unsigned", "OffsetOperandNo", "=", "getOffsetONFromFION", "(", "MI", ",", "FIOperandNum", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "OffsetOperandNo", ")", ".", "getImm", "(", ")", ";", "MI", ".", "getOperand", "(", "OffsetOperandNo", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "MI", ".", "getDesc", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "BaseReg", ",", "TII", ".", "getRegClass", "(", "MCID", ",", "FIOperandNum", ",", "this", ",", "MF", ")", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "\"Instr doesn't have FrameIndex operand!\"", "PPC", "PPC" ]

[]

[ "<s>", "void", "PPCTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "dl", "(", "N", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Do not know how to custom type legalize this operation!\"", ")", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "{", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "i32", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ")", ";", "SDValue", "RTB", "=", "DAG", ".", "getNode", "(", "PPCISD", "::", "READ_TIME_BASE", ",", "dl", ",", "VTs", ",", "N", "->", "getOperand", "(", "0", ")", ")", ";", "Results", ".", "push_back", "(", "RTB", ")", ";", "Results", ".", "push_back", "(", "RTB", ".", "getValue", "(", "1", ")", ")", ";", "Results", ".", "push_back", "(", "RTB", ".", "getValue", "(", "2", ")", ")", ";", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "if", "(", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", "!=", "Intrinsic", "::", "loop_decrement", ")", "break", ";", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i1", "&&", "\"Unexpected result type for CTR decrement intrinsic\"", ")", ";", "EVT", "SVT", "=", "getSetCCResultType", "(", "DAG", ".", "getDataLayout", "(", ")", ",", "*", "DAG", ".", "getContext", "(", ")", ",", "N", "->", "getValueType", "(", "0", ")", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "SVT", ",", "MVT", "::", "Other", ")", ";", "SDValue", "NewInt", "=", "DAG", ".", "getNode", "(", "N", "->", "getOpcode", "(", ")", ",", "dl", ",", "VTs", ",", "N", "->", "getOperand", "(", "0", ")", ",", "N", "->", "getOperand", "(", "1", ")", ")", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i1", ",", "NewInt", ")", ")", ";", "Results", ".", "push_back", "(", "NewInt", ".", "getValue", "(", "1", ")", ")", ";", "break", ";", "}", "case", "ISD", "::", "VAARG", ":", "{", "if", "(", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", "||", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "{", "SDValue", "NewNode", "=", "LowerVAARG", "(", "SDValue", "(", "N", ",", "1", ")", ",", "DAG", ")", ";", "Results", ".", "push_back", "(", "NewNode", ")", ";", "Results", ".", "push_back", "(", "NewNode", ".", "getValue", "(", "1", ")", ")", ";", "}", "return", ";", "}", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "FP_TO_UINT", ":", "if", "(", "N", "->", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "ppcf128", ")", "return", ";", "Results", ".", "push_back", "(", "LowerFP_TO_INT", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ",", "dl", ")", ")", ";", "return", ";", "case", "ISD", "::", "TRUNCATE", ":", "{", "EVT", "TrgVT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "TrgVT", ".", "isVector", "(", ")", "&&", "isOperationCustom", "(", "N", "->", "getOpcode", "(", ")", ",", "TrgVT", ")", "&&", "N", "->", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", ".", "getSizeInBits", "(", ")", "<=", "128", ")", "Results", ".", "push_back", "(", "LowerTRUNCATEVector", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ")", ";", "return", ";", "}", "case", "ISD", "::", "BITCAST", ":", "return", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"Do not know how to custom type legalize this operation!\"", "ISD::READCYCLECOUNTER", "MVT::i32", "MVT::i32", "MVT::Other", "PPCISD::READ_TIME_BASE", "0", "1", "2", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::loop_decrement", "0", "MVT::i1", "\"Unexpected result type for CTR decrement intrinsic\"", "0", "MVT::Other", "0", "1", "ISD::TRUNCATE", "MVT::i1", "1", "ISD::VAARG", "PPC", "0", "MVT::i64", "1", "1", "ISD::FP_TO_SINT", "ISD::FP_TO_UINT", "0", "MVT::ppcf128", "0", "ISD::TRUNCATE", "0", "0", "128", "0", "ISD::BITCAST" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "false", ";", "if", "(", "isBranch", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "return", "true", ";", "if", "(", "!", "isJump", "(", "static_cast", "<", "MachineInstr", "*", ">", "(", "I", ")", "->", "getOpcode", "(", ")", ")", ")", "{", "return", "false", ";", "}", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", "&&", "std", "::", "prev", "(", "I", ")", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "JUMP", ")", "{", "MachineBasicBlock", "::", "iterator", "PriorI", "=", "std", "::", "prev", "(", "I", ")", ";", "if", "(", "AllowModify", ")", "I", "->", "removeFromParent", "(", ")", ";", "I", "=", "PriorI", ";", "}", "MachineInstr", "&", "LastInst", "=", "*", "I", ";", "unsigned", "LastOpc", "=", "LastInst", ".", "getOpcode", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", "||", "!", "isJump", "(", "static_cast", "<", "MachineInstr", "*", ">", "(", "--", "I", ")", "->", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "LastOpc", "==", "AMDGPU", "::", "JUMP", ")", "{", "TBB", "=", "LastInst", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "else", "if", "(", "LastOpc", "==", "AMDGPU", "::", "JUMP_COND", ")", "{", "auto", "predSet", "=", "I", ";", "while", "(", "!", "isPredicateSetter", "(", "predSet", "->", "getOpcode", "(", ")", ")", ")", "{", "predSet", "=", "--", "I", ";", "}", "TBB", "=", "LastInst", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "predSet", "->", "getOperand", "(", "1", ")", ")", ";", "Cond", ".", "push_back", "(", "predSet", "->", "getOperand", "(", "2", ")", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateReg", "(", "AMDGPU", "::", "PRED_SEL_ONE", ",", "false", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "MachineInstr", "&", "SecondLastInst", "=", "*", "I", ";", "unsigned", "SecondLastOpc", "=", "SecondLastInst", ".", "getOpcode", "(", ")", ";", "if", "(", "SecondLastOpc", "==", "AMDGPU", "::", "JUMP_COND", "&&", "LastOpc", "==", "AMDGPU", "::", "JUMP", ")", "{", "auto", "predSet", "=", "--", "I", ";", "while", "(", "!", "isPredicateSetter", "(", "predSet", "->", "getOpcode", "(", ")", ")", ")", "{", "predSet", "=", "--", "I", ";", "}", "TBB", "=", "SecondLastInst", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "FBB", "=", "LastInst", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "predSet", "->", "getOperand", "(", "1", ")", ")", ";", "Cond", ".", "push_back", "(", "predSet", "->", "getOperand", "(", "2", ")", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateReg", "(", "AMDGPU", "::", "PRED_SEL_ONE", ",", "false", ")", ")", ";", "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", "." ]

[ "AMDGPU", "R600", "AMDGPU::JUMP", "AMDGPU::JUMP", "0", "AMDGPU::JUMP_COND", "0", "1", "2", "AMDGPU::PRED_SEL_ONE", "AMDGPU::JUMP_COND", "AMDGPU::JUMP", "0", "0", "1", "2", "AMDGPU::PRED_SEL_ONE" ]

[]

[ "<s>", "static", "void", "alpha_output_function_end_prologue", "(", "FILE", "*", "file", ")", "{", "if", "(", "TARGET_ABI_OPEN_VMS", ")", "fputs", "(", "\"\\t.prologue\\n\"", ",", "file", ")", ";", "else", "if", "(", "!", "flag_inhibit_size_directive", ")", "fprintf", "(", "file", ",", "\"\\t.prologue %d\\n\"", ",", "alpha_function_needs_gp", "||", "cfun", "->", "is_thunk", ")", ";", "}", "</s>" ]

[ "Emit", "the", ".prologue", "note", "at", "the", "scheduled", "end", "of", "the", "prologue", "." ]

[ "alpha", "\"\\t.prologue\\n\"", "\"\\t.prologue %d\\n\"" ]

[]

[ "<s>", "static", "void", "mips_va_start", "(", "tree", "valist", ",", "rtx", "nextarg", ")", "{", "if", "(", "EABI_FLOAT_VARARGS_P", ")", "{", "const", "CUMULATIVE_ARGS", "*", "cum", ";", "tree", "f_ovfl", ",", "f_gtop", ",", "f_ftop", ",", "f_goff", ",", "f_foff", ";", "tree", "ovfl", ",", "gtop", ",", "ftop", ",", "goff", ",", "foff", ";", "tree", "t", ";", "int", "gpr_save_area_size", ";", "int", "fpr_save_area_size", ";", "int", "fpr_offset", ";", "cum", "=", "&", "crtl", "->", "args", ".", "info", ";", "gpr_save_area_size", "=", "(", "MAX_ARGS_IN_REGISTERS", "-", "cum", "->", "num_gprs", ")", "*", "UNITS_PER_WORD", ";", "fpr_save_area_size", "=", "(", "MAX_ARGS_IN_REGISTERS", "-", "cum", "->", "num_fprs", ")", "*", "UNITS_PER_FPREG", ";", "f_ovfl", "=", "TYPE_FIELDS", "(", "va_list_type_node", ")", ";", "f_gtop", "=", "DECL_CHAIN", "(", "f_ovfl", ")", ";", "f_ftop", "=", "DECL_CHAIN", "(", "f_gtop", ")", ";", "f_goff", "=", "DECL_CHAIN", "(", "f_ftop", ")", ";", "f_foff", "=", "DECL_CHAIN", "(", "f_goff", ")", ";", "ovfl", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_ovfl", ")", ",", "valist", ",", "f_ovfl", ",", "NULL_TREE", ")", ";", "gtop", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_gtop", ")", ",", "valist", ",", "f_gtop", ",", "NULL_TREE", ")", ";", "ftop", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_ftop", ")", ",", "valist", ",", "f_ftop", ",", "NULL_TREE", ")", ";", "goff", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_goff", ")", ",", "valist", ",", "f_goff", ",", "NULL_TREE", ")", ";", "foff", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_foff", ")", ",", "valist", ",", "f_foff", ",", "NULL_TREE", ")", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "ovfl", ")", ",", "virtual_incoming_args_rtx", ")", ";", "if", "(", "cum", "->", "stack_words", ">", "0", ")", "t", "=", "fold_build_pointer_plus_hwi", "(", "t", ",", "cum", "->", "stack_words", "*", "UNITS_PER_WORD", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "ovfl", ")", ",", "ovfl", ",", "t", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "gtop", ")", ",", "virtual_incoming_args_rtx", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "gtop", ")", ",", "gtop", ",", "t", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "ftop", ")", ",", "virtual_incoming_args_rtx", ")", ";", "fpr_offset", "=", "gpr_save_area_size", "+", "UNITS_PER_FPVALUE", "-", "1", ";", "fpr_offset", "&=", "-", "UNITS_PER_FPVALUE", ";", "if", "(", "fpr_offset", ")", "t", "=", "fold_build_pointer_plus_hwi", "(", "t", ",", "-", "fpr_offset", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "ftop", ")", ",", "ftop", ",", "t", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "goff", ")", ",", "goff", ",", "build_int_cst", "(", "TREE_TYPE", "(", "goff", ")", ",", "gpr_save_area_size", ")", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "foff", ")", ",", "foff", ",", "build_int_cst", "(", "TREE_TYPE", "(", "foff", ")", ",", "fpr_save_area_size", ")", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "else", "{", "nextarg", "=", "plus_constant", "(", "Pmode", ",", "nextarg", ",", "-", "cfun", "->", "machine", "->", "varargs_size", ")", ";", "std_expand_builtin_va_start", "(", "valist", ",", "nextarg", ")", ";", "}", "}", "</s>" ]

[ "Implement", "va_start", "." ]

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

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "assert", "(", "isReg", "(", ")", "&&", "\"Invalid type access!\"", ")", ";", "return", "Reg", ".", "RegNum", ";", "}", "</s>" ]

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

[ "DLX", "\"Invalid type access!\"" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "assert", "(", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ">=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", "&&", "\"Stack slot too small for store\"", ")", ";", "if", "(", "RC", "->", "getID", "(", ")", "==", "X86", "::", "TILERegClassID", ")", "{", "unsigned", "Opc", "=", "X86", "::", "TILESTORED", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "Register", "VirtReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "X86", "::", "GR64_NOSPRegClass", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DebugLoc", "(", ")", ",", "get", "(", "X86", "::", "MOV64ri", ")", ",", "VirtReg", ")", ".", "addImm", "(", "64", ")", ";", "MachineInstr", "*", "NewMI", "=", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ")", ",", "FrameIdx", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "MachineOperand", "&", "MO", "=", "NewMI", "->", "getOperand", "(", "2", ")", ";", "MO", ".", "setReg", "(", "VirtReg", ")", ";", "MO", ".", "setIsKill", "(", "true", ")", ";", "}", "else", "{", "unsigned", "Alignment", "=", "std", "::", "max", "<", "uint32_t", ">", "(", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ",", "16", ")", ";", "bool", "isAligned", "=", "(", "Subtarget", ".", "getFrameLowering", "(", ")", "->", "getStackAlign", "(", ")", ">=", "Alignment", ")", "||", "(", "RI", ".", "canRealignStack", "(", "MF", ")", "&&", "!", "MFI", ".", "isFixedObjectIndex", "(", "FrameIdx", ")", ")", ";", "unsigned", "Opc", "=", "getStoreRegOpcode", "(", "SrcReg", ",", "RC", ",", "isAligned", ",", "Subtarget", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ")", ",", "FrameIdx", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "\"Stack slot too small for store\"", "X86::TILERegClassID", "X86::TILESTORED", "X86::GR64_NOSPRegClass", "X86::MOV64ri", "64", "2", "16" ]

[]

[ "<s>", "tree", "function_builder", "::", "get_attributes", "(", "const", "function_instance", "&", "instance", ")", "{", "tree", "attrs", "=", "NULL_TREE", ";", "if", "(", "!", "instance", ".", "modifies_global_state_p", "(", ")", ")", "{", "if", "(", "instance", ".", "reads_global_state_p", "(", ")", ")", "attrs", "=", "add_attribute", "(", "\"pure\"", ",", "attrs", ")", ";", "else", "attrs", "=", "add_attribute", "(", "\"const\"", ",", "attrs", ")", ";", "}", "if", "(", "!", "flag_non_call_exceptions", "||", "!", "instance", ".", "could_trap_p", "(", ")", ")", "attrs", "=", "add_attribute", "(", "\"nothrow\"", ",", "attrs", ")", ";", "return", "add_attribute", "(", "\"leaf\"", ",", "attrs", ")", ";", "}", "</s>" ]

[ "Return", "the", "appropriate", "function", "attributes", "for", "INSTANCE", "." ]

[ "riscv", "\"pure\"", "\"const\"", "\"nothrow\"", "\"leaf\"" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "ARMHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "!", "MI", "->", "isDebugValue", "(", ")", ")", "{", "if", "(", "ITBlockSize", "&&", "MI", "!=", "ITBlockMIs", "[", "ITBlockSize", "-", "1", "]", ")", "return", "Hazard", ";", "const", "TargetInstrDesc", "&", "TID", "=", "MI", "->", "getDesc", "(", ")", ";", "if", "(", "LastMI", "&&", "(", "TID", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ")", "!=", "ARMII", "::", "DomainGeneral", ")", "{", "MachineInstr", "*", "DefMI", "=", "LastMI", ";", "const", "TargetInstrDesc", "&", "LastTID", "=", "LastMI", "->", "getDesc", "(", ")", ";", "if", "(", "!", "LastTID", ".", "isBarrier", "(", ")", "&&", "(", "LastTID", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ")", "==", "ARMII", "::", "DomainGeneral", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "LastMI", ";", "if", "(", "I", "!=", "LastMI", "->", "getParent", "(", ")", "->", "begin", "(", ")", ")", "{", "I", "=", "llvm", "::", "prior", "(", "I", ")", ";", "DefMI", "=", "&", "*", "I", ";", "}", "}", "if", "(", "TII", ".", "isFpMLxInstruction", "(", "DefMI", "->", "getOpcode", "(", ")", ")", "&&", "(", "TII", ".", "canCauseFpMLxStall", "(", "MI", "->", "getOpcode", "(", ")", ")", "||", "hasRAWHazard", "(", "DefMI", ",", "MI", ",", "TRI", ")", ")", ")", "{", "if", "(", "Stalls", "==", "0", ")", "Stalls", "=", "4", ";", "return", "Hazard", ";", "}", "}", "}", "return", "ScoreboardHazardRecognizer", "::", "getHazardType", "(", "SU", ")", ";", "}", "</s>" ]

[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]

[ "ARM", "ARM", "1", "ARMII::DomainMask", "ARMII::DomainGeneral", "ARMII::DomainMask", "ARMII::DomainGeneral", "0", "4" ]

[]

[ "<s>", "static", "rtx", "arm_dwarf_register_span", "(", "rtx", "rtl", ")", "{", "machine_mode", "mode", ";", "unsigned", "regno", ";", "rtx", "parts", "[", "16", "]", ";", "int", "nregs", ";", "int", "i", ";", "regno", "=", "REGNO", "(", "rtl", ")", ";", "if", "(", "!", "IS_VFP_REGNUM", "(", "regno", ")", ")", "return", "NULL_RTX", ";", "mode", "=", "GET_MODE", "(", "rtl", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<", "8", ")", "return", "NULL_RTX", ";", "if", "(", "VFP_REGNO_OK_FOR_SINGLE", "(", "regno", ")", ")", "{", "nregs", "=", "GET_MODE_SIZE", "(", "mode", ")", "/", "4", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nregs", ";", "i", "+=", "2", ")", "if", "(", "TARGET_BIG_END", ")", "{", "parts", "[", "i", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "i", "+", "1", ")", ";", "parts", "[", "i", "+", "1", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "i", ")", ";", "}", "else", "{", "parts", "[", "i", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "i", ")", ";", "parts", "[", "i", "+", "1", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "i", "+", "1", ")", ";", "}", "}", "else", "{", "nregs", "=", "GET_MODE_SIZE", "(", "mode", ")", "/", "8", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nregs", ";", "i", "++", ")", "parts", "[", "i", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "regno", "+", "i", ")", ";", "}", "return", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec_v", "(", "nregs", ",", "parts", ")", ")", ";", "}", "</s>" ]

[ "Dwarf", "models", "VFPv3", "registers", "as", "32", "64-bit", "registers", ".", "GCC", "models", "tham", "as", "64", "32-bit", "registers", ",", "so", "we", "need", "to", "describe", "this", "to", "the", "DWARF", "generation", "code", ".", "Other", "registers", "can", "use", "the", "default", "." ]

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

[]

[ "<s>", "static", "tree", "nios2_builtin_decl", "(", "unsigned", "code", ",", "bool", "initialize_p", "ATTRIBUTE_UNUSED", ")", "{", "gcc_assert", "(", "nios2_custom_builtin_end", "==", "ARRAY_SIZE", "(", "nios2_builtin_decls", ")", ")", ";", "if", "(", "code", ">=", "nios2_custom_builtin_end", ")", "return", "error_mark_node", ";", "if", "(", "code", ">=", "nios2_fpu_builtin_base", "&&", "code", "<", "nios2_custom_builtin_base", "&&", "!", "N2FPU_ENABLED_P", "(", "code", "-", "nios2_fpu_builtin_base", ")", ")", "return", "error_mark_node", ";", "return", "nios2_builtin_decls", "[", "code", "]", ";", "}", "</s>" ]

[ "Implement", "TARGET_BUILTIN_DECL", "." ]

[ "nios2" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesAll", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineModuleInfo", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "X86" ]

[]

[ "<s>", "SDValue", "CJGTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "AnalyzeReturnValues", "(", "CCInfo", ",", "RVLocs", ",", "Ins", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "CJG", "CJG", "ISD::InputArg", "16", "0", "1", "2", "0" ]

[]

[ "<s>", "bool", "MipsConstantIslands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "SDValue", "BPFTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "dl", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_BPF64", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "errs", "(", ")", "<<", "\"Function: \"", "<<", "DAG", ".", "getMachineFunction", "(", ")", ".", "getName", "(", ")", "<<", "\" \"", ";", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", "->", "getFunctionType", "(", ")", "->", "dump", "(", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ";", "report_fatal_error", "(", "\"BPF doesn't support struct return\"", ")", ";", "}", "unsigned", "Opc", "=", "BPFISD", "::", "RET_FLAG", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "&", "RetOps", "[", "0", "]", ",", "RetOps", ".", "size", "(", ")", ")", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "ISD::OutputArg", "16", "BPF", "0", "4", "1", "0", "\"Can only return in registers!\"", "1", "\"Function: \"", "\" \"", "\"\\n\"", "\"BPF doesn't support struct return\"", "BPFISD::RET_FLAG", "0", "MVT::Other", "0", "MVT::Other", "MVT::Other" ]

[]

[ "<s>", "unsigned", "PPCInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "LD", ":", "case", "PPC", "::", "LWZ", ":", "case", "PPC", "::", "LFS", ":", "case", "PPC", "::", "LFD", ":", "case", "PPC", "::", "RESTORE_CR", ":", "case", "PPC", "::", "RESTORE_CRBIT", ":", "case", "PPC", "::", "LVX", ":", "case", "PPC", "::", "LXVD2X", ":", "case", "PPC", "::", "LXVX", ":", "case", "PPC", "::", "QVLFDX", ":", "case", "PPC", "::", "QVLFSXs", ":", "case", "PPC", "::", "QVLFDXb", ":", "case", "PPC", "::", "RESTORE_VRSAVE", ":", "case", "PPC", "::", "SPILLTOVSR_LD", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::LD", "PPC::LWZ", "PPC::LFS", "PPC::LFD", "PPC::RESTORE_CR", "PPC::RESTORE_CRBIT", "PPC::LVX", "PPC::LXVD2X", "PPC::LXVX", "PPC::QVLFDX", "PPC::QVLFSXs", "PPC::QVLFDXb", "PPC::RESTORE_VRSAVE", "PPC::SPILLTOVSR_LD", "1", "1", "2", "2", "0", "0" ]

[]

[ "<s>", "void", "NVPTXTargetStreamer", "::", "closeLastSection", "(", ")", "{", "if", "(", "HasSections", ")", "getStreamer", "(", ")", ".", "emitRawText", "(", "\"\\t}\"", ")", ";", "}", "</s>" ]

[ "Close", "last", "section", "." ]

[ "NVPTX", "NVPTX", "\"\\t}\"" ]

[]

[ "<s>", "int", "arc_hazard", "(", "rtx_insn", "*", "pred", ",", "rtx_insn", "*", "succ", ")", "{", "if", "(", "!", "pred", "||", "!", "INSN_P", "(", "pred", ")", "||", "!", "succ", "||", "!", "INSN_P", "(", "succ", ")", ")", "return", "0", ";", "if", "(", "TARGET_ARC600", ")", "return", "arc600_corereg_hazard", "(", "pred", ",", "succ", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "For", "ARC600", ":", "A", "write", "to", "a", "core", "reg", "greater", "or", "equal", "to", "32", "must", "not", "be", "immediately", "followed", "by", "a", "use", ".", "Anticipate", "the", "length", "requirement", "to", "insert", "a", "nop", "between", "PRED", "and", "SUCC", "to", "prevent", "a", "hazard", "." ]

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

[]

[ "<s>", "const", "char", "*", "host_detect_local_cpu", "(", "int", "argc", ",", "const", "char", "*", "*", "argv", ")", "{", "const", "char", "*", "cpu", "=", "NULL", ";", "char", "buf", "[", "128", "]", ";", "FILE", "*", "f", ";", "bool", "arch", ";", "if", "(", "argc", "<", "1", ")", "return", "NULL", ";", "arch", "=", "strcmp", "(", "argv", "[", "0", "]", ",", "\"arch\"", ")", "==", "0", ";", "if", "(", "!", "arch", "&&", "strcmp", "(", "argv", "[", "0", "]", ",", "\"tune\"", ")", ")", "return", "NULL", ";", "f", "=", "fopen", "(", "\"/proc/cpuinfo\"", ",", "\"r\"", ")", ";", "if", "(", "f", "==", "NULL", ")", "return", "NULL", ";", "while", "(", "fgets", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "f", ")", "!=", "NULL", ")", "if", "(", "startswith", "(", "buf", ",", "\"cpu model\"", ")", ")", "{", "if", "(", "strstr", "(", "buf", ",", "\"Godson2 V0.2\"", ")", "!=", "NULL", "||", "strstr", "(", "buf", ",", "\"Loongson-2 V0.2\"", ")", "!=", "NULL", "||", "strstr", "(", "buf", ",", "\"Loongson-2E\"", ")", "!=", "NULL", ")", "cpu", "=", "\"loongson2e\"", ";", "else", "if", "(", "strstr", "(", "buf", ",", "\"Godson2 V0.3\"", ")", "!=", "NULL", "||", "strstr", "(", "buf", ",", "\"Loongson-2 V0.3\"", ")", "!=", "NULL", "||", "strstr", "(", "buf", ",", "\"Loongson-2F\"", ")", "!=", "NULL", ")", "cpu", "=", "\"loongson2f\"", ";", "else", "if", "(", "strstr", "(", "buf", ",", "\"Godson3 V0.5\"", ")", "!=", "NULL", "||", "strstr", "(", "buf", ",", "\"Loongson-3 V0.5\"", ")", "!=", "NULL", "||", "strstr", "(", "buf", ",", "\"Loongson-3A\"", ")", "!=", "NULL", ")", "cpu", "=", "\"loongson3a\"", ";", "else", "if", "(", "strstr", "(", "buf", ",", "\"SiByte SB1\"", ")", "!=", "NULL", ")", "cpu", "=", "\"sb1\"", ";", "else", "if", "(", "strstr", "(", "buf", ",", "\"R5000\"", ")", "!=", "NULL", ")", "cpu", "=", "\"r5000\"", ";", "else", "if", "(", "strstr", "(", "buf", ",", "\"Octeon II\"", ")", "!=", "NULL", ")", "cpu", "=", "\"octeon2\"", ";", "else", "if", "(", "strstr", "(", "buf", ",", "\"Octeon\"", ")", "!=", "NULL", ")", "cpu", "=", "\"octeon\"", ";", "break", ";", "}", "fclose", "(", "f", ")", ";", "if", "(", "cpu", "==", "NULL", ")", "return", "NULL", ";", "return", "concat", "(", "\"-m\"", ",", "argv", "[", "0", "]", ",", "\"=\"", ",", "cpu", ",", "NULL", ")", ";", "}", "</s>" ]

[ "This", "will", "be", "called", "by", "the", "spec", "parser", "in", "gcc.cc", "when", "it", "sees", "a", "%", ":", "local_cpu_detect", "(", "args", ")", "construct", ".", "Currently", "it", "will", "be", "called", "with", "either", "``", "cpu", "''", "or", "``", "tune", "''", "as", "argument", "depending", "on", "if", "-mcpu=native", "or", "-mtune=native", "is", "to", "be", "substituted", ".", "It", "returns", "a", "string", "containing", "new", "command", "line", "parameters", "to", "be", "put", "at", "the", "place", "of", "the", "above", "two", "options", ",", "depending", "on", "what", "CPU", "this", "is", "executed", ".", "E.g", ".", "``", "-mcpu=ultrasparc3", "''", "on", "an", "UltraSPARC", "III", "for", "-mcpu=native", ".", "If", "the", "routine", "ca", "n't", "detect", "a", "known", "processor", ",", "the", "-mcpu", "or", "-mtune", "option", "is", "discarded", ".", "ARGC", "and", "ARGV", "are", "set", "depending", "on", "the", "actual", "arguments", "given", "in", "the", "spec", "." ]

[ "mips", "128", "1", "0", "\"arch\"", "0", "0", "\"tune\"", "\"/proc/cpuinfo\"", "\"r\"", "\"cpu model\"", "\"Godson2 V0.2\"", "\"Loongson-2 V0.2\"", "\"Loongson-2E\"", "\"loongson2e\"", "\"Godson2 V0.3\"", "\"Loongson-2 V0.3\"", "\"Loongson-2F\"", "\"loongson2f\"", "\"Godson3 V0.5\"", "\"Loongson-3 V0.5\"", "\"Loongson-3A\"", "\"loongson3a\"", "\"SiByte SB1\"", "\"sb1\"", "\"R5000\"", "\"r5000\"", "\"Octeon II\"", "\"octeon2\"", "\"Octeon\"", "\"octeon\"", "\"-m\"", "0", "\"=\"" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "CSKYAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "static", "llvm", "::", "DenseMap", "<", "unsigned", ",", "MCFixupKindInfo", ">", "Infos", "=", "{", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_addr32", ",", "{", "\"fixup_csky_addr32\"", ",", "0", ",", "32", ",", "0", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_pcrel_imm16_scale2", ",", "{", "\"fixup_csky_pcrel_imm16_scale2\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_pcrel_uimm16_scale4", ",", "{", "\"fixup_csky_pcrel_uimm16_scale4\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_pcrel_imm26_scale2", ",", "{", "\"fixup_csky_pcrel_imm26_scale2\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_pcrel_imm18_scale2", ",", "{", "\"fixup_csky_pcrel_imm18_scale2\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", "}", ";", "assert", "(", "Infos", ".", "size", "(", ")", "==", "CSKY", "::", "NumTargetFixupKinds", "&&", "\"Not all fixup kinds added to Infos array\"", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "if", "(", "FirstTargetFixupKind", "<=", "Kind", "&&", "Kind", "<", "FirstLiteralRelocationKind", ")", "return", "Infos", "[", "Kind", "]", ";", "else", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "else", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "FK_NONE", ")", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "CSKY::Fixups", "\"fixup_csky_addr32\"", "0", "32", "0", "CSKY::Fixups", "\"fixup_csky_pcrel_imm16_scale2\"", "0", "32", "CSKY::Fixups", "\"fixup_csky_pcrel_uimm16_scale4\"", "0", "32", "CSKY::Fixups", "\"fixup_csky_pcrel_imm26_scale2\"", "0", "32", "CSKY::Fixups", "\"fixup_csky_pcrel_imm18_scale2\"", "0", "32", "CSKY::NumTargetFixupKinds", "\"Not all fixup kinds added to Infos array\"", "\"Invalid kind!\"" ]

[]

[ "<s>", "void", "SIRegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "Register", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "bool", "IsFlat", "=", "TII", "->", "isFLATScratch", "(", "MI", ")", ";", "bool", "SeenFI", "=", "false", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "MO", ".", "isFI", "(", ")", ")", "{", "if", "(", "SeenFI", ")", "llvm_unreachable", "(", "\"should not see multiple frame indices\"", ")", ";", "SeenFI", "=", "true", ";", "}", "}", "MachineOperand", "*", "FIOp", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "IsFlat", "?", "AMDGPU", "::", "OpName", "::", "saddr", ":", "AMDGPU", "::", "OpName", "::", "vaddr", ")", ";", "MachineOperand", "*", "OffsetOp", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "offset", ")", ";", "int64_t", "NewOffset", "=", "OffsetOp", "->", "getImm", "(", ")", "+", "Offset", ";", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "assert", "(", "FIOp", "&&", "FIOp", "->", "isFI", "(", ")", "&&", "\"frame index must be address operand\"", ")", ";", "assert", "(", "TII", "->", "isMUBUF", "(", "MI", ")", "||", "TII", "->", "isFLATScratch", "(", "MI", ")", ")", ";", "if", "(", "IsFlat", ")", "{", "assert", "(", "TII", "->", "isLegalFLATOffset", "(", "NewOffset", ",", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ",", "true", ")", "&&", "\"offset should be legal\"", ")", ";", "FIOp", "->", "ChangeToRegister", "(", "BaseReg", ",", "false", ")", ";", "OffsetOp", "->", "setImm", "(", "NewOffset", ")", ";", "return", ";", "}", "MachineOperand", "*", "SOffset", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "soffset", ")", ";", "assert", "(", "(", "SOffset", "->", "isReg", "(", ")", "&&", "SOffset", "->", "getReg", "(", ")", "==", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", "->", "getStackPtrOffsetReg", "(", ")", ")", "||", "(", "SOffset", "->", "isImm", "(", ")", "&&", "SOffset", "->", "getImm", "(", ")", "==", "0", ")", ")", ";", "assert", "(", "SIInstrInfo", "::", "isLegalMUBUFImmOffset", "(", "NewOffset", ")", "&&", "\"offset should be legal\"", ")", ";", "FIOp", "->", "ChangeToRegister", "(", "BaseReg", ",", "false", ")", ";", "OffsetOp", "->", "setImm", "(", "NewOffset", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "\"should not see multiple frame indices\"", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "\"frame index must be address operand\"", "AMDGPU", "\"offset should be legal\"", "AMDGPU::OpName", "SI", "0", "SI", "\"offset should be legal\"" ]

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addRegBankSelect", "(", ")", "{", "addPass", "(", "new", "RegBankSelect", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "register", "bank", "selector", "pass", ",", "which", "assigns", "register", "banks", "to", "virtual", "registers", "without", "a", "register", "class", "or", "register", "banks", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", "&&", "I", "->", "getOpcode", "(", ")", "==", "PPC", "::", "ADJCALLSTACKUP", ")", "{", "if", "(", "int", "CalleeAmt", "=", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", "{", "bool", "is64Bit", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "CalleeAmt", "*=", "-", "1", ";", "unsigned", "StackReg", "=", "is64Bit", "?", "PPC", "::", "X1", ":", "PPC", "::", "R1", ";", "unsigned", "TmpReg", "=", "is64Bit", "?", "PPC", "::", "X0", ":", "PPC", "::", "R0", ";", "unsigned", "ADDIInstr", "=", "is64Bit", "?", "PPC", "::", "ADDI8", ":", "PPC", "::", "ADDI", ";", "unsigned", "ADDInstr", "=", "is64Bit", "?", "PPC", "::", "ADD8", ":", "PPC", "::", "ADD4", ";", "unsigned", "LISInstr", "=", "is64Bit", "?", "PPC", "::", "LIS8", ":", "PPC", "::", "LIS", ";", "unsigned", "ORIInstr", "=", "is64Bit", "?", "PPC", "::", "ORI8", ":", "PPC", "::", "ORI", ";", "MachineInstr", "*", "MI", "=", "I", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "isInt", "<", "16", ">", "(", "CalleeAmt", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "ADDIInstr", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "}", "else", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "I", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "LISInstr", ")", ",", "TmpReg", ")", ".", "addImm", "(", "CalleeAmt", ">>", "16", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ORIInstr", ")", ",", "TmpReg", ")", ".", "addReg", "(", "TmpReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "CalleeAmt", "&", "0xFFFF", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ADDInstr", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "TmpReg", ")", ";", "}", "}", "}", "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", ")", "." ]

[ "PowerPC", "PPC", "PPC::ADJCALLSTACKUP", "1", "PPC", "1", "PPC::X1", "PPC::R1", "PPC::X0", "PPC::R0", "PPC::ADDI8", "PPC::ADDI", "PPC::ADD8", "PPC::ADD4", "PPC::LIS8", "PPC::LIS", "PPC::ORI8", "PPC::ORI", "16", "16", "0xFFFF" ]

[]

[ "<s>", "bool", "RISCVFrameLowering", "::", "enableShrinkWrapping", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasOptNone", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "will", "correctly", "handle", "shrink", "wrapping", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getBranchTarget7OpValueMM", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ">>", "1", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getBranchTargetOpValueMM expects only expressions or immediates\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "Expr", ",", "MCFixupKind", "(", "Mips", "::", "fixup_MICROMIPS_PC7_S1", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "1", "\"getBranchTargetOpValueMM expects only expressions or immediates\"", "0", "Mips::fixup_MICROMIPS_PC7_S1", "0" ]

[]

[ "<s>", "static", "bool", "ix86_libgcc_floating_mode_supported_p", "(", "scalar_float_mode", "mode", ")", "{", "return", "(", "(", "(", "mode", "==", "HFmode", "||", "mode", "==", "BFmode", ")", "&&", "TARGET_SSE2", ")", "?", "true", ":", "default_libgcc_floating_mode_supported_p", "(", "mode", ")", ")", ";", "}", "</s>" ]

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

[ "i386" ]

[]

[ "<s>", "void", "PPCOperand", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "case", "Immediate", ":", "OS", "<<", "getImm", "(", ")", ";", "break", ";", "case", "Expression", ":", "getExpr", "(", ")", "->", "print", "(", "OS", ")", ";", "break", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"'\"", "\"'\"" ]

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "!", "getARMSubtarget", "(", ")", ".", "isThumb1Only", "(", ")", ")", "PM", ".", "add", "(", "createARMLoadStoreOptimizationPass", "(", "true", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getARMSubtarget", "(", ")", ".", "isCortexA9", "(", ")", ")", "PM", ".", "add", "(", "createMLxExpansionPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "virtual", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "{", "return", "&", "DL", ";", "}", "</s>" ]

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

[ "AZPR" ]

[]

[ "<s>", "static", "void", "rs6000_emit_epilogue_components", "(", "sbitmap", "components", ")", "{", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "rtx", "ptr_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "frame_pointer_needed", "?", "HARD_FRAME_POINTER_REGNUM", ":", "STACK_POINTER_REGNUM", ")", ";", "machine_mode", "reg_mode", "=", "Pmode", ";", "int", "reg_size", "=", "TARGET_32BIT", "?", "4", ":", "8", ";", "machine_mode", "fp_reg_mode", "=", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_DOUBLE_FLOAT", ")", "?", "DFmode", ":", "SFmode", ";", "int", "fp_reg_size", "=", "8", ";", "int", "offset", "=", "info", "->", "fp_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "for", "(", "int", "i", "=", "info", "->", "first_fp_reg_save", ";", "i", "<", "64", ";", "i", "++", ")", "{", "if", "(", "bitmap_bit_p", "(", "components", ",", "i", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "fp_reg_mode", ",", "i", ")", ";", "rtx_insn", "*", "insn", "=", "emit_insn", "(", "gen_frame_load", "(", "reg", ",", "ptr_reg", ",", "offset", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "reg", ")", ";", "}", "offset", "+=", "fp_reg_size", ";", "}", "offset", "=", "info", "->", "gp_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "for", "(", "int", "i", "=", "info", "->", "first_gp_reg_save", ";", "i", "<", "32", ";", "i", "++", ")", "{", "if", "(", "bitmap_bit_p", "(", "components", ",", "i", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "reg_mode", ",", "i", ")", ";", "rtx_insn", "*", "insn", "=", "emit_insn", "(", "gen_frame_load", "(", "reg", ",", "ptr_reg", ",", "offset", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "reg", ")", ";", "}", "offset", "+=", "reg_size", ";", "}", "if", "(", "bitmap_bit_p", "(", "components", ",", "0", ")", ")", "{", "int", "offset", "=", "info", "->", "lr_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "reg_mode", ",", "0", ")", ";", "rtx_insn", "*", "insn", "=", "emit_insn", "(", "gen_frame_load", "(", "reg", ",", "ptr_reg", ",", "offset", ")", ")", ";", "rtx", "lr", "=", "gen_rtx_REG", "(", "Pmode", ",", "LR_REGNO", ")", ";", "insn", "=", "emit_move_insn", "(", "lr", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "lr", ")", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_SHRINK_WRAP_EMIT_EPILOGUE_COMPONENTS", "." ]

[ "rs6000", "4", "8", "8", "64", "1", "32", "1", "0", "0", "1" ]

[]

[ "<s>", "static", "void", "aarch64_emit_bic", "(", "machine_mode", "mode", ",", "rtx", "dst", ",", "rtx", "s1", ",", "rtx", "s2", ",", "int", "shift", ")", "{", "rtx", "shift_rtx", "=", "GEN_INT", "(", "shift", ")", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "switch", "(", "mode", ")", "{", "case", "SImode", ":", "gen", "=", "gen_and_one_cmpl_lshrsi3", ";", "break", ";", "case", "DImode", ":", "gen", "=", "gen_and_one_cmpl_lshrdi3", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen", "(", "dst", ",", "s2", ",", "shift_rtx", ",", "s1", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "BIC", "instruction", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "void", "arc_ccfsm_post_advance", "(", "rtx_insn", "*", "insn", ",", "struct", "arc_ccfsm", "*", "state", ")", "{", "enum", "attr_type", "type", ";", "if", "(", "LABEL_P", "(", "insn", ")", ")", "arc_ccfsm_at_label", "(", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "insn", ")", ",", "state", ")", ";", "else", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_VEC", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_DIFF_VEC", "&&", "(", "(", "type", "=", "get_attr_type", "(", "insn", ")", ")", "==", "TYPE_BRANCH", "||", "(", "type", "==", "TYPE_UNCOND_BRANCH", "&&", "ARC_CCFSM_BRANCH_DELETED_P", "(", "state", ")", ")", ")", ")", "{", "if", "(", "ARC_CCFSM_BRANCH_DELETED_P", "(", "state", ")", ")", "ARC_CCFSM_RECORD_BRANCH_DELETED", "(", "state", ")", ";", "else", "{", "rtx", "src", "=", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ";", "arc_ccfsm_record_condition", "(", "XEXP", "(", "src", ",", "0", ")", ",", "XEXP", "(", "src", ",", "1", ")", "==", "pc_rtx", ",", "insn", ",", "state", ")", ";", "}", "}", "else", "if", "(", "arc_ccfsm_current", ".", "state", "==", "5", ")", "arc_ccfsm_current", ".", "state", "=", "0", ";", "}", "</s>" ]

[ "Update", "*", "STATE", "as", "we", "would", "when", "we", "emit", "INSN", "." ]

[ "arc", "\"L\"", "0", "1", "5", "0" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "SystemZTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'d'", ":", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "GR64BitRegClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "i128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "GR128BitRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "GR32BitRegClass", ")", ";", "case", "'a'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "ADDR64BitRegClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "i128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "ADDR128BitRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "ADDR32BitRegClass", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "FP64BitRegClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "f128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "FP128BitRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "FP32BitRegClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "1", "0", "MVT::i64", "0U", "SystemZ::GR64BitRegClass", "MVT::i128", "0U", "SystemZ::GR128BitRegClass", "0U", "SystemZ::GR32BitRegClass", "MVT::i64", "0U", "SystemZ::ADDR64BitRegClass", "MVT::i128", "0U", "SystemZ::ADDR128BitRegClass", "0U", "SystemZ::ADDR32BitRegClass", "MVT::f64", "0U", "SystemZ::FP64BitRegClass", "MVT::f128", "0U", "SystemZ::FP128BitRegClass", "0U", "SystemZ::FP32BitRegClass" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"ARM pre- register allocation load / store optimization pass\"", ";", "}", "</s>" ]

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

[ "ARM", "\"ARM pre- register allocation load / store optimization pass\"" ]

[]

[ "<s>", "static", "void", "dispatch_forest", "(", "fma_forest", "*", "forest", ")", "{", "forest", "->", "dispatch", "(", ")", ";", "}", "</s>" ]

[ "Wrapper", "around", "fma_forest", ":", ":dispatch", "for", "use", "as", "parameter", "of", "function", "pointer", "type", "in", "func_fma_steering", ":", ":dfs", "." ]

[ "aarch64" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "CJGRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "CC_Save_SaveList", ";", "}", "</s>" ]

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

[ "CJG", "CJG" ]

[]

[ "<s>", "void", "WebAssemblyTargetWasmStreamer", "::", "emitLocal", "(", "ArrayRef", "<", "MVT", ">", "Types", ")", "{", "SmallVector", "<", "std", "::", "pair", "<", "MVT", ",", "uint32_t", ">", ",", "4", ">", "Grouped", ";", "for", "(", "MVT", "Type", ":", "Types", ")", "{", "if", "(", "Grouped", ".", "empty", "(", ")", "||", "Grouped", ".", "back", "(", ")", ".", "first", "!=", "Type", ")", "Grouped", ".", "push_back", "(", "std", "::", "make_pair", "(", "Type", ",", "1", ")", ")", ";", "else", "++", "Grouped", ".", "back", "(", ")", ".", "second", ";", "}", "Streamer", ".", "EmitULEB128IntValue", "(", "Grouped", ".", "size", "(", ")", ")", ";", "for", "(", "auto", "Pair", ":", "Grouped", ")", "{", "Streamer", ".", "EmitULEB128IntValue", "(", "Pair", ".", "second", ")", ";", "emitValueType", "(", "WebAssembly", "::", "toValType", "(", "Pair", ".", "first", ")", ")", ";", "}", "}", "</s>" ]

[ ".local" ]

[ "WebAssembly", "WebAssembly", "4", "1", "WebAssembly::toValType" ]

[]

[ "<s>", "static", "bool", "nds32_needs_double_word_align", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "unsigned", "int", "align", ";", "align", "=", "NDS32_MODE_TYPE_ALIGN", "(", "mode", ",", "type", ")", ";", "return", "(", "align", ">", "PARM_BOUNDARY", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "MODE/TYPE", "need", "double", "word", "alignment", "." ]

[ "nds32" ]

[]

[ "<s>", "void", "PPCAIXAsmPrinter", "::", "SetupMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "CurrentFnDescSym", "=", "getSymbol", "(", "&", "MF", ".", "getFunction", "(", ")", ")", ";", "MCSectionXCOFF", "*", "FnDescSec", "=", "cast", "<", "MCSectionXCOFF", ">", "(", "getObjFileLowering", "(", ")", ".", "getSectionForFunctionDescriptor", "(", "CurrentFnDescSym", ")", ")", ";", "FnDescSec", "->", "setAlignment", "(", "Align", "(", "Subtarget", "->", "isPPC64", "(", ")", "?", "8", ":", "4", ")", ")", ";", "cast", "<", "MCSymbolXCOFF", ">", "(", "CurrentFnDescSym", ")", "->", "setContainingCsect", "(", "FnDescSec", ")", ";", "return", "AsmPrinter", "::", "SetupMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

[ "This", "should", "be", "called", "when", "a", "new", "MachineFunction", "is", "being", "processed", "from", "runOnMachineFunction", "." ]

[ "PowerPC", "PPC", "PPC", "8", "4" ]

[]

[ "<s>", "static", "void", "mt_machine_reorg", "(", "void", ")", "{", "if", "(", "mt_flag_delayed_branch", ")", "dbr_schedule", "(", "get_insns", "(", ")", ",", "dump_file", ")", ";", "if", "(", "TARGET_MS2", ")", "{", "split_all_insns_noflow", "(", ")", ";", "mt_reorg_hazard", "(", ")", ";", "}", "}", "</s>" ]

[ "Fixup", "the", "looping", "instructions", ",", "do", "delayed", "branch", "scheduling", ",", "fixup", "scheduling", "hazards", "." ]

[ "mt" ]

[]

[ "<s>", "void", "XCoreTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "DataSection", "=", "Ctx", ".", "getELFSection", "(", "\".dp.data\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "BSSSection", "=", "Ctx", ".", "getELFSection", "(", "\".dp.bss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "MergeableConst4Section", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.cst4\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_MERGE", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getMergeableConst4", "(", ")", ")", ";", "MergeableConst8Section", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.cst8\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_MERGE", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getMergeableConst8", "(", ")", ")", ";", "MergeableConst16Section", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.cst16\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_MERGE", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getMergeableConst16", "(", ")", ")", ";", "TLSDataSection", "=", "DataSection", ";", "TLSBSSSection", "=", "BSSSection", ";", "ReadOnlySection", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getReadOnlyWithRel", "(", ")", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "\".dp.data\"", "\".dp.bss\"", "\".cp.rodata.cst4\"", "\".cp.rodata.cst8\"", "\".cp.rodata.cst16\"", "\".cp.rodata\"" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "CAHPRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "CSR_SaveList", ";", "}", "</s>" ]

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

[ "CAHP", "CAHP" ]

[]

[ "<s>", "void", "OutgoingValueHandler", "::", "assignValueToAddress", "(", "unsigned", "ValVReg", ",", "unsigned", "Addr", ",", "uint64_t", "Size", ",", "MachinePointerInfo", "&", "MPO", ")", "{", "MachineMemOperand", "*", "MMO", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "0", ")", ";", "MIRBuilder", ".", "buildStore", "(", "ValVReg", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

[ "An", "overload", "which", "takes", "an", "ArgInfo", "if", "additional", "information", "about", "the", "arg", "is", "needed", "." ]

[ "Mips", "0" ]

[]

[ "<s>", "static", "tree", "build_const_pointer", "(", "tree", "t", ")", "{", "return", "build_pointer_type", "(", "build_qualified_type", "(", "t", ",", "TYPE_QUAL_CONST", ")", ")", ";", "}", "</s>" ]

[ "Return", "a", "representation", "of", "``", "const", "T", "*", "''", "." ]

[ "aarch64" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "X86FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "bool", "reserveCallFrame", "=", "hasReservedCallFrame", "(", "MF", ")", ";", "unsigned", "Opcode", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "isDestroy", "=", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Amount", "=", "TII", ".", "getFrameSize", "(", "*", "I", ")", ";", "uint64_t", "InternalAmt", "=", "(", "isDestroy", "||", "Amount", ")", "?", "TII", ".", "getFrameAdjustment", "(", "*", "I", ")", ":", "0", ";", "I", "=", "MBB", ".", "erase", "(", "I", ")", ";", "auto", "InsertPos", "=", "skipDebugInstructionsForward", "(", "I", ",", "MBB", ".", "end", "(", ")", ")", ";", "if", "(", "!", "reserveCallFrame", ")", "{", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "alignTo", "(", "Amount", ",", "StackAlign", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "WindowsCFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ";", "bool", "DwarfCFI", "=", "!", "WindowsCFI", "&&", "MF", ".", "needsFrameMoves", "(", ")", ";", "bool", "HasDwarfEHHandlers", "=", "!", "WindowsCFI", "&&", "!", "MF", ".", "getLandingPads", "(", ")", ".", "empty", "(", ")", ";", "if", "(", "HasDwarfEHHandlers", "&&", "!", "isDestroy", "&&", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getHasPushSequences", "(", ")", ")", "BuildCFI", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "MCCFIInstruction", "::", "createGnuArgsSize", "(", "nullptr", ",", "Amount", ")", ")", ";", "if", "(", "Amount", "==", "0", ")", "return", "I", ";", "Amount", "-=", "InternalAmt", ";", "if", "(", "isDestroy", "&&", "InternalAmt", "&&", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "BuildCFI", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "-", "InternalAmt", ")", ")", ";", "int64_t", "StackAdjustment", "=", "isDestroy", "?", "Amount", ":", "-", "Amount", ";", "if", "(", "StackAdjustment", ")", "{", "StackAdjustment", "+=", "mergeSPUpdates", "(", "MBB", ",", "InsertPos", ",", "true", ")", ";", "StackAdjustment", "+=", "mergeSPUpdates", "(", "MBB", ",", "InsertPos", ",", "false", ")", ";", "if", "(", "StackAdjustment", ")", "{", "if", "(", "!", "(", "F", ".", "hasMinSize", "(", ")", "&&", "adjustStackWithPops", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "StackAdjustment", ")", ")", ")", "BuildStackAdjustment", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "StackAdjustment", ",", "false", ")", ";", "}", "}", "if", "(", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "{", "int64_t", "CfaAdjustment", "=", "-", "StackAdjustment", ";", "if", "(", "CfaAdjustment", ")", "{", "BuildCFI", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "CfaAdjustment", ")", ")", ";", "}", "}", "return", "I", ";", "}", "if", "(", "isDestroy", "&&", "InternalAmt", "&&", "!", "blockEndIsUnreachable", "(", "MBB", ",", "I", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "CI", "=", "I", ";", "MachineBasicBlock", "::", "iterator", "B", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "CI", "!=", "B", "&&", "!", "std", "::", "prev", "(", "CI", ")", "->", "isCall", "(", ")", ")", "--", "CI", ";", "BuildStackAdjustment", "(", "MBB", ",", "CI", ",", "DL", ",", "-", "InternalAmt", ",", "false", ")", ";", "}", "return", "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", ")", "." ]

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

[]

[ "<s>", "bool", "isLegalMaskedLoad", "(", "Type", "*", "DataType", ",", "Align", "Alignment", ")", "{", "return", "isLegalMaskedLoadStore", "(", "DataType", ",", "Alignment", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "load", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createAMDGPUISelDag", "(", "getAMDGPUTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "bool", "MipsAsmBackend", "::", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "{", "const", "unsigned", "FixupKind", "=", "Fixup", ".", "getKind", "(", ")", ";", "switch", "(", "FixupKind", ")", "{", "default", ":", "return", "false", ";", "case", "Mips", "::", "fixup_Mips_CALL_HI16", ":", "case", "Mips", "::", "fixup_Mips_CALL_LO16", ":", "case", "Mips", "::", "fixup_Mips_CALL16", ":", "case", "Mips", "::", "fixup_Mips_GOT", ":", "case", "Mips", "::", "fixup_Mips_GOT_PAGE", ":", "case", "Mips", "::", "fixup_Mips_GOT_OFST", ":", "case", "Mips", "::", "fixup_Mips_GOT_DISP", ":", "case", "Mips", "::", "fixup_Mips_GOT_HI16", ":", "case", "Mips", "::", "fixup_Mips_GOT_LO16", ":", "case", "Mips", "::", "fixup_Mips_GOTTPREL", ":", "case", "Mips", "::", "fixup_Mips_DTPREL_HI", ":", "case", "Mips", "::", "fixup_Mips_DTPREL_LO", ":", "case", "Mips", "::", "fixup_Mips_TLSGD", ":", "case", "Mips", "::", "fixup_Mips_TLSLDM", ":", "case", "Mips", "::", "fixup_Mips_TPREL_HI", ":", "case", "Mips", "::", "fixup_Mips_TPREL_LO", ":", "case", "Mips", "::", "fixup_Mips_JALR", ":", "case", "Mips", "::", "fixup_MICROMIPS_CALL16", ":", "case", "Mips", "::", "fixup_MICROMIPS_GOT_DISP", ":", "case", "Mips", "::", "fixup_MICROMIPS_GOT_PAGE", ":", "case", "Mips", "::", "fixup_MICROMIPS_GOT_OFST", ":", "case", "Mips", "::", "fixup_MICROMIPS_GOT16", ":", "case", "Mips", "::", "fixup_MICROMIPS_GOTTPREL", ":", "case", "Mips", "::", "fixup_MICROMIPS_TLS_DTPREL_HI16", ":", "case", "Mips", "::", "fixup_MICROMIPS_TLS_DTPREL_LO16", ":", "case", "Mips", "::", "fixup_MICROMIPS_TLS_GD", ":", "case", "Mips", "::", "fixup_MICROMIPS_TLS_LDM", ":", "case", "Mips", "::", "fixup_MICROMIPS_TLS_TPREL_HI16", ":", "case", "Mips", "::", "fixup_MICROMIPS_TLS_TPREL_LO16", ":", "case", "Mips", "::", "fixup_MICROMIPS_JALR", ":", "return", "true", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::fixup_Mips_CALL_HI16", "Mips::fixup_Mips_CALL_LO16", "Mips::fixup_Mips_CALL16", "Mips::fixup_Mips_GOT", "Mips::fixup_Mips_GOT_PAGE", "Mips::fixup_Mips_GOT_OFST", "Mips::fixup_Mips_GOT_DISP", "Mips::fixup_Mips_GOT_HI16", "Mips::fixup_Mips_GOT_LO16", "Mips::fixup_Mips_GOTTPREL", "Mips::fixup_Mips_DTPREL_HI", "Mips::fixup_Mips_DTPREL_LO", "Mips::fixup_Mips_TLSGD", "Mips::fixup_Mips_TLSLDM", "Mips::fixup_Mips_TPREL_HI", "Mips::fixup_Mips_TPREL_LO", "Mips::fixup_Mips_JALR", "Mips::fixup_MICROMIPS_CALL16", "Mips::fixup_MICROMIPS_GOT_DISP", "Mips::fixup_MICROMIPS_GOT_PAGE", "Mips::fixup_MICROMIPS_GOT_OFST", "Mips::fixup_MICROMIPS_GOT16", "Mips::fixup_MICROMIPS_GOTTPREL", "Mips::fixup_MICROMIPS_TLS_DTPREL_HI16", "Mips::fixup_MICROMIPS_TLS_DTPREL_LO16", "Mips::fixup_MICROMIPS_TLS_GD", "Mips::fixup_MICROMIPS_TLS_LDM", "Mips::fixup_MICROMIPS_TLS_TPREL_HI16", "Mips::fixup_MICROMIPS_TLS_TPREL_LO16", "Mips::fixup_MICROMIPS_JALR" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"AMDGPU Promote Alloca to vector\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"AMDGPU Promote Alloca to vector\"" ]

[]

[ "<s>", "std", "::", "string", "AMDGPUDevice", "::", "getDataLayout", "(", ")", "const", "{", "std", "::", "string", "DataLayout", "=", "std", "::", "string", "(", "\"e\"", "\"-p:32:32:32\"", "\"-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32\"", "\"-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128\"", "\"-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048\"", "\"-n32:64\"", ")", ";", "if", "(", "usesHardware", "(", "AMDGPUDeviceInfo", "::", "DoubleOps", ")", ")", "{", "DataLayout", ".", "append", "(", "\"-f64:64:64\"", ")", ";", "}", "return", "DataLayout", ";", "}", "</s>" ]

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

[ "R600", "\"e\"", "\"-p:32:32:32\"", "\"-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32\"", "\"-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128\"", "\"-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048\"", "\"-n32:64\"", "AMDGPUDeviceInfo::DoubleOps", "\"-f64:64:64\"" ]

[]

[ "<s>", "static", "bool", "mips_hard_regno_mode_ok_p", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "unsigned", "int", "size", ";", "enum", "mode_class", "mclass", ";", "if", "(", "mode", "==", "CCV2mode", ")", "return", "(", "ISA_HAS_8CC", "&&", "ST_REG_P", "(", "regno", ")", "&&", "(", "regno", "-", "ST_REG_FIRST", ")", "%", "2", "==", "0", ")", ";", "if", "(", "mode", "==", "CCV4mode", ")", "return", "(", "ISA_HAS_8CC", "&&", "ST_REG_P", "(", "regno", ")", "&&", "(", "regno", "-", "ST_REG_FIRST", ")", "%", "4", "==", "0", ")", ";", "if", "(", "mode", "==", "CCmode", ")", "return", "ISA_HAS_8CC", "?", "ST_REG_P", "(", "regno", ")", ":", "regno", "==", "FPSW_REGNUM", ";", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "mclass", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "if", "(", "GP_REG_P", "(", "regno", ")", "&&", "mode", "!=", "CCFmode", ")", "return", "(", "(", "regno", "-", "GP_REG_FIRST", ")", "&", "1", ")", "==", "0", "||", "size", "<=", "UNITS_PER_WORD", ";", "if", "(", "FP_REG_P", "(", "regno", ")", "&&", "(", "(", "(", "regno", "-", "FP_REG_FIRST", ")", "%", "MAX_FPRS_PER_FMT", ")", "==", "0", "||", "(", "MIN_FPRS_PER_FMT", "==", "1", "&&", "size", "<=", "UNITS_PER_FPREG", ")", ")", ")", "{", "if", "(", "TARGET_O32_FP64A_ABI", "&&", "size", "<=", "4", "&&", "(", "regno", "&", "1", ")", "!=", "0", ")", "return", "false", ";", "if", "(", "mode", "==", "CCFmode", ")", "return", "!", "(", "TARGET_FLOATXX", "&&", "(", "regno", "&", "1", ")", "!=", "0", ")", ";", "if", "(", "TARGET_LOONGSON_VECTORS", "&&", "(", "mode", "==", "V2SImode", "||", "mode", "==", "V4HImode", "||", "mode", "==", "V8QImode", "||", "mode", "==", "DImode", ")", ")", "return", "true", ";", "if", "(", "mclass", "==", "MODE_FLOAT", "||", "mclass", "==", "MODE_COMPLEX_FLOAT", "||", "mclass", "==", "MODE_VECTOR_FLOAT", ")", "return", "size", "<=", "UNITS_PER_FPVALUE", ";", "if", "(", "mclass", "==", "MODE_INT", ")", "return", "size", ">=", "MIN_UNITS_PER_WORD", "&&", "size", "<=", "UNITS_PER_FPREG", ";", "}", "if", "(", "ACC_REG_P", "(", "regno", ")", "&&", "!", "VECTOR_MODE_P", "(", "mode", ")", "&&", "(", "INTEGRAL_MODE_P", "(", "mode", ")", "||", "ALL_FIXED_POINT_MODE_P", "(", "mode", ")", ")", ")", "{", "if", "(", "MD_REG_P", "(", "regno", ")", ")", "{", "if", "(", "size", "<=", "UNITS_PER_WORD", "*", "2", ")", "return", "regno", "==", "(", "size", "<=", "UNITS_PER_WORD", "?", "LO_REGNUM", ":", "MD_REG_FIRST", ")", ";", "}", "else", "{", "if", "(", "size", "<=", "UNITS_PER_WORD", ")", "return", "true", ";", "if", "(", "size", "<=", "UNITS_PER_WORD", "*", "2", "&&", "(", "(", "regno", "-", "DSP_ACC_REG_FIRST", ")", "&", "1", ")", "==", "0", ")", "return", "true", ";", "}", "}", "if", "(", "ALL_COP_REG_P", "(", "regno", ")", ")", "return", "mclass", "==", "MODE_INT", "&&", "size", "<=", "UNITS_PER_WORD", ";", "if", "(", "regno", "==", "GOT_VERSION_REGNUM", ")", "return", "mode", "==", "SImode", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "register", "REGNO", "can", "store", "a", "value", "of", "mode", "MODE", ".", "The", "result", "of", "this", "function", "is", "cached", "in", "mips_hard_regno_mode_ok", "." ]

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

[]

[ "<s>", "bool", "PPCAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'L'", ":", "O", "<<", "getDataLayout", "(", ")", ".", "getPointerSize", "(", ")", "<<", "\"(\"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "\")\"", ";", "return", "false", ";", "case", "'y'", ":", "{", "const", "char", "*", "RegName", "=", "\"r0\"", ";", "if", "(", "!", "Subtarget", "->", "isDarwin", "(", ")", ")", "RegName", "=", "PPCRegisterInfo", "::", "stripRegisterPrefix", "(", "RegName", ")", ";", "O", "<<", "RegName", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "case", "'U'", ":", "case", "'X'", ":", "assert", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", ")", ";", "return", "false", ";", "}", "}", "assert", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", ")", ";", "O", "<<", "\"0(\"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "\")\"", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "1", "0", "0", "\"(\"", "\")\"", "\"r0\"", "PPC", "\", \"", "\"0(\"", "\")\"" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintType", "SystemZTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'a'", ":", "case", "'d'", ":", "case", "'f'", ":", "case", "'h'", ":", "case", "'r'", ":", "return", "C_RegisterClass", ";", "case", "'Q'", ":", "case", "'R'", ":", "case", "'S'", ":", "case", "'T'", ":", "case", "'m'", ":", "return", "C_Memory", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "return", "C_Other", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "SystemZ", "SystemZ", "1", "0" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "XCoreRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "MCPhysReg", "CalleeSavedRegs", "[", "]", "=", "{", "XCore", "::", "R4", ",", "XCore", "::", "R5", ",", "XCore", "::", "R6", ",", "XCore", "::", "R7", ",", "XCore", "::", "R8", ",", "XCore", "::", "R9", ",", "XCore", "::", "R10", ",", "0", "}", ";", "static", "const", "MCPhysReg", "CalleeSavedRegsFP", "[", "]", "=", "{", "XCore", "::", "R4", ",", "XCore", "::", "R5", ",", "XCore", "::", "R6", ",", "XCore", "::", "R7", ",", "XCore", "::", "R8", ",", "XCore", "::", "R9", ",", "0", "}", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", "->", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "*", "MF", ")", ")", "return", "CalleeSavedRegsFP", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore::R4", "XCore::R5", "XCore::R6", "XCore::R7", "XCore::R8", "XCore::R9", "XCore::R10", "0", "XCore::R4", "XCore::R5", "XCore::R6", "XCore::R7", "XCore::R8", "XCore::R9", "0" ]

[]

[ "<s>", "static", "bool", "zero_all_mm_registers", "(", "HARD_REG_SET", "need_zeroed_hardregs", ",", "unsigned", "int", "ret_mmx_regno", ")", "{", "bool", "need_zero_all_mm", "=", "false", ";", "for", "(", "unsigned", "int", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "STACK_REGNO_P", "(", "regno", ")", "&&", "TEST_HARD_REG_BIT", "(", "need_zeroed_hardregs", ",", "regno", ")", ")", "{", "need_zero_all_mm", "=", "true", ";", "break", ";", "}", "if", "(", "!", "need_zero_all_mm", ")", "return", "false", ";", "machine_mode", "mode", "=", "V2SImode", ";", "for", "(", "unsigned", "int", "regno", "=", "FIRST_MMX_REG", ";", "regno", "<=", "LAST_MMX_REG", ";", "regno", "++", ")", "if", "(", "regno", "!=", "ret_mmx_regno", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "CONST0_RTX", "(", "mode", ")", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "When", "the", "routine", "exit", "in", "MMX", "mode", ",", "if", "any", "ST", "register", "needs", "to", "be", "zeroed", ",", "we", "should", "clear", "all", "MMX", "registers", "except", "the", "RET_MMX_REGNO", "that", "holds", "the", "return", "value", "." ]

[ "i386", "0" ]

[]

[ "<s>", "void", "function_checker", "::", "report_out_of_range", "(", "unsigned", "int", "argno", ",", "HOST_WIDE_INT", "actual", ",", "HOST_WIDE_INT", "min", ",", "HOST_WIDE_INT", "max", ")", "const", "{", "error_at", "(", "location", ",", "\"passing %wd to argument %d of %qE, which expects\"", "\" a value in the range [%wd, %wd]\"", ",", "actual", ",", "argno", "+", "1", ",", "fndecl", ",", "min", ",", "max", ")", ";", "}", "</s>" ]

[ "Report", "that", "LOCATION", "has", "a", "call", "to", "FNDECL", "in", "which", "argument", "ARGNO", "has", "the", "value", "ACTUAL", ",", "whereas", "the", "function", "requires", "a", "value", "in", "the", "range", "[", "MIN", ",", "MAX", "]", ".", "ARGNO", "counts", "from", "zero", "." ]

[ "riscv", "\"passing %wd to argument %d of %qE, which expects\"", "\" a value in the range [%wd, %wd]\"", "1" ]

[]

[ "<s>", "bool", "WebAssemblyTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", ",", "MachineFunction", "&", ",", "bool", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", ")", "const", "{", "return", "Subtarget", "->", "hasMultivalue", "(", ")", "||", "Outs", ".", "size", "(", ")", "<=", "1", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "ISD::OutputArg", "1" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "setExecutionDomain", "(", "MachineInstr", "&", "MI", ",", "unsigned", "Domain", ")", "const", "{", "assert", "(", "Domain", ">", "0", "&&", "Domain", "<", "4", "&&", "\"Invalid execution domain\"", ")", ";", "uint16_t", "dom", "=", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", ">>", "X86II", "::", "SSEDomainShift", ")", "&", "3", ";", "assert", "(", "dom", "&&", "\"Not an SSE instruction\"", ")", ";", "if", "(", "setExecutionDomainCustom", "(", "MI", ",", "Domain", ")", ")", "return", ";", "const", "uint16_t", "*", "table", "=", "lookup", "(", "MI", ".", "getOpcode", "(", ")", ",", "dom", ",", "ReplaceableInstrs", ")", ";", "if", "(", "!", "table", ")", "{", "assert", "(", "(", "Subtarget", ".", "hasAVX2", "(", ")", "||", "Domain", "<", "3", ")", "&&", "\"256-bit vector operations only available in AVX2\"", ")", ";", "table", "=", "lookup", "(", "MI", ".", "getOpcode", "(", ")", ",", "dom", ",", "ReplaceableInstrsAVX2", ")", ";", "}", "if", "(", "!", "table", ")", "{", "table", "=", "lookup", "(", "MI", ".", "getOpcode", "(", ")", ",", "dom", ",", "ReplaceableInstrsFP", ")", ";", "assert", "(", "(", "!", "table", "||", "Domain", "<", "3", ")", "&&", "\"Can only select PackedSingle or PackedDouble\"", ")", ";", "}", "if", "(", "!", "table", ")", "{", "assert", "(", "Subtarget", ".", "hasAVX2", "(", ")", "&&", "\"256-bit insert/extract only available in AVX2\"", ")", ";", "table", "=", "lookup", "(", "MI", ".", "getOpcode", "(", ")", ",", "dom", ",", "ReplaceableInstrsAVX2InsertExtract", ")", ";", "}", "if", "(", "!", "table", ")", "{", "assert", "(", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "\"Requires AVX-512\"", ")", ";", "table", "=", "lookupAVX512", "(", "MI", ".", "getOpcode", "(", ")", ",", "dom", ",", "ReplaceableInstrsAVX512", ")", ";", "if", "(", "table", "&&", "Domain", "==", "3", "&&", "table", "[", "3", "]", "==", "MI", ".", "getOpcode", "(", ")", ")", "Domain", "=", "4", ";", "}", "if", "(", "!", "table", ")", "{", "assert", "(", "(", "Subtarget", ".", "hasDQI", "(", ")", "||", "Domain", ">=", "3", ")", "&&", "\"Requires AVX-512DQ\"", ")", ";", "table", "=", "lookupAVX512", "(", "MI", ".", "getOpcode", "(", ")", ",", "dom", ",", "ReplaceableInstrsAVX512DQ", ")", ";", "if", "(", "table", "&&", "Domain", "==", "3", "&&", "(", "dom", "==", "1", "||", "table", "[", "3", "]", "==", "MI", ".", "getOpcode", "(", ")", ")", ")", "Domain", "=", "4", ";", "}", "if", "(", "!", "table", ")", "{", "assert", "(", "(", "Subtarget", ".", "hasDQI", "(", ")", "||", "Domain", ">=", "3", ")", "&&", "\"Requires AVX-512DQ\"", ")", ";", "table", "=", "lookupAVX512", "(", "MI", ".", "getOpcode", "(", ")", ",", "dom", ",", "ReplaceableInstrsAVX512DQMasked", ")", ";", "if", "(", "table", "&&", "Domain", "==", "3", "&&", "(", "dom", "==", "1", "||", "table", "[", "3", "]", "==", "MI", ".", "getOpcode", "(", ")", ")", ")", "Domain", "=", "4", ";", "}", "assert", "(", "table", "&&", "\"Cannot change domain\"", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "table", "[", "Domain", "-", "1", "]", ")", ")", ";", "}", "</s>" ]

[ "Change", "the", "opcode", "of", "MI", "to", "execute", "in", "Domain", "." ]

[ "X86", "X86", "0", "4", "\"Invalid execution domain\"", "X86II::SSEDomainShift", "3", "\"Not an SSE instruction\"", "3", "\"256-bit vector operations only available in AVX2\"", "3", "\"Can only select PackedSingle or PackedDouble\"", "\"256-bit insert/extract only available in AVX2\"", "\"Requires AVX-512\"", "3", "3", "4", "3", "\"Requires AVX-512DQ\"", "3", "1", "3", "4", "3", "\"Requires AVX-512DQ\"", "3", "1", "3", "4", "\"Cannot change domain\"", "1" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this!\"", ")", ";", "case", "ISD", "::", "READ_REGISTER", ":", "ExpandREAD_REGISTER", "(", "N", ",", "Results", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "BITCAST", ":", "Res", "=", "ExpandBITCAST", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SHL", ":", "Res", "=", "Expand64BitShift", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "SREM", ":", "case", "ISD", "::", "UREM", ":", "Res", "=", "LowerREM", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "SDIVREM", ":", "case", "ISD", "::", "UDIVREM", ":", "Res", "=", "LowerDivRem", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ";", "assert", "(", "Res", ".", "getNumOperands", "(", ")", "==", "2", "&&", "\"DivRem needs two values\"", ")", ";", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "0", ")", ")", ";", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "1", ")", ")", ";", "return", ";", "case", "ISD", "::", "SADDSAT", ":", "case", "ISD", "::", "SSUBSAT", ":", "case", "ISD", "::", "UADDSAT", ":", "case", "ISD", "::", "USUBSAT", ":", "Res", "=", "LowerADDSUBSAT", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "ReplaceREADCYCLECOUNTER", "(", "N", ",", "Results", ",", "DAG", ",", "Subtarget", ")", ";", "return", ";", "case", "ISD", "::", "UDIV", ":", "case", "ISD", "::", "SDIV", ":", "assert", "(", "Subtarget", "->", "isTargetWindows", "(", ")", "&&", "\"can only expand DIV on Windows\"", ")", ";", "return", "ExpandDIV_Windows", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ",", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", ",", "Results", ")", ";", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "ReplaceCMP_SWAP_64Results", "(", "N", ",", "Results", ",", "DAG", ")", ";", "return", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "ReplaceLongIntrinsic", "(", "N", ",", "Results", ",", "DAG", ")", ";", "case", "ISD", "::", "ABS", ":", "lowerABS", "(", "N", ",", "Results", ",", "DAG", ")", ";", "return", ";", "case", "ISD", "::", "LOAD", ":", "LowerLOAD", "(", "N", ",", "Results", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "TRUNCATE", ":", "Res", "=", "LowerTruncate", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "Res", "=", "LowerVectorExtend", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "FP_TO_SINT_SAT", ":", "case", "ISD", "::", "FP_TO_UINT_SAT", ":", "Res", "=", "LowerFP_TO_INT_SAT", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "}", "if", "(", "Res", ".", "getNode", "(", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"Don't know how to custom expand this!\"", "ISD::READ_REGISTER", "ISD::BITCAST", "ISD::SRL", "ISD::SRA", "ISD::SHL", "ISD::SREM", "ISD::UREM", "ISD::SDIVREM", "ISD::UDIVREM", "0", "2", "\"DivRem needs two values\"", "0", "1", "ISD::SADDSAT", "ISD::SSUBSAT", "ISD::UADDSAT", "ISD::USUBSAT", "0", "ISD::READCYCLECOUNTER", "ISD::UDIV", "ISD::SDIV", "\"can only expand DIV on Windows\"", "0", "ISD::SDIV", "ISD::ATOMIC_CMP_SWAP", "ISD::INTRINSIC_WO_CHAIN", "ISD::ABS", "ISD::LOAD", "ISD::TRUNCATE", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::FP_TO_SINT_SAT", "ISD::FP_TO_UINT_SAT", "0" ]

[]

[ "<s>", "static", "rtx", "nvptx_cta_sync", "(", "rtx", "lock", ",", "int", "threads", ")", "{", "return", "gen_nvptx_barsync", "(", "lock", ",", "GEN_INT", "(", "threads", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "CTA-level", "synchronization", "barrier", ".", "LOCK", "is", "the", "barrier", "number", ",", "which", "is", "an", "integer", "or", "a", "register", ".", "THREADS", "is", "the", "number", "of", "threads", "controlled", "by", "the", "barrier", "." ]

[ "nvptx" ]

[]

[ "<s>", "static", "void", "aarch64_setup_incoming_varargs", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", "ATTRIBUTE_UNUSED", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "CUMULATIVE_ARGS", "local_cum", ";", "int", "gr_saved", "=", "cfun", "->", "va_list_gpr_size", ";", "int", "vr_saved", "=", "cfun", "->", "va_list_fpr_size", ";", "local_cum", "=", "*", "cum", ";", "aarch64_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "local_cum", ")", ",", "mode", ",", "type", ",", "true", ")", ";", "if", "(", "cfun", "->", "va_list_gpr_size", ")", "gr_saved", "=", "MIN", "(", "NUM_ARG_REGS", "-", "local_cum", ".", "aapcs_ncrn", ",", "cfun", "->", "va_list_gpr_size", "/", "UNITS_PER_WORD", ")", ";", "if", "(", "cfun", "->", "va_list_fpr_size", ")", "vr_saved", "=", "MIN", "(", "NUM_FP_ARG_REGS", "-", "local_cum", ".", "aapcs_nvrn", ",", "cfun", "->", "va_list_fpr_size", "/", "UNITS_PER_VREG", ")", ";", "if", "(", "!", "TARGET_FLOAT", ")", "{", "gcc_assert", "(", "local_cum", ".", "aapcs_nvrn", "==", "0", ")", ";", "vr_saved", "=", "0", ";", "}", "if", "(", "!", "no_rtl", ")", "{", "if", "(", "gr_saved", ">", "0", ")", "{", "rtx", "ptr", ",", "mem", ";", "ptr", "=", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "-", "gr_saved", "*", "UNITS_PER_WORD", ")", ";", "mem", "=", "gen_frame_mem", "(", "BLKmode", ",", "ptr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "move_block_from_reg", "(", "local_cum", ".", "aapcs_ncrn", "+", "R0_REGNUM", ",", "mem", ",", "gr_saved", ")", ";", "}", "if", "(", "vr_saved", ">", "0", ")", "{", "machine_mode", "mode", "=", "TImode", ";", "int", "off", ",", "i", ",", "vr_start", ";", "off", "=", "-", "ROUND_UP", "(", "gr_saved", "*", "UNITS_PER_WORD", ",", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "off", "-=", "vr_saved", "*", "UNITS_PER_VREG", ";", "vr_start", "=", "V0_REGNUM", "+", "local_cum", ".", "aapcs_nvrn", ";", "for", "(", "i", "=", "0", ";", "i", "<", "vr_saved", ";", "++", "i", ")", "{", "rtx", "ptr", ",", "mem", ";", "ptr", "=", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "off", ")", ";", "mem", "=", "gen_frame_mem", "(", "mode", ",", "ptr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "aarch64_emit_move", "(", "mem", ",", "gen_rtx_REG", "(", "mode", ",", "vr_start", "+", "i", ")", ")", ";", "off", "+=", "UNITS_PER_VREG", ";", "}", "}", "}", "cfun", "->", "machine", "->", "frame", ".", "saved_varargs_size", "=", "(", "ROUND_UP", "(", "gr_saved", "*", "UNITS_PER_WORD", ",", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", "+", "vr_saved", "*", "UNITS_PER_VREG", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SETUP_INCOMING_VARARGS", "." ]

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

[]

[ "<s>", "Register", "(", "const", "MachineOperand", "&", "Op", ")", ":", "Reg", "(", "Op", ".", "getReg", "(", ")", ")", ",", "Sub", "(", "Op", ".", "getSubReg", "(", ")", ")", "{", "}", "</s>" ]

[ "Base", "register", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addPreISel", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", ">", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "addPass", "(", "createStructurizeCFGPass", "(", ")", ")", ";", "addPass", "(", "createSIAnnotateControlFlowPass", "(", ")", ")", ";", "}", "else", "{", "addPass", "(", "createR600TextureIntrinsicsReplacer", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

[ "R600", "SI" ]

[]

[ "<s>", "const", "char", "*", "output_fix_trunc", "(", "rtx", "insn", ",", "rtx", "*", "operands", ",", "int", "fisttp", ")", "{", "int", "stack_top_dies", "=", "find_regno_note", "(", "insn", ",", "REG_DEAD", ",", "FIRST_STACK_REG", ")", "!=", "0", ";", "int", "dimode_p", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", "==", "DImode", ";", "int", "round_mode", "=", "get_attr_i387_cw", "(", "insn", ")", ";", "if", "(", "(", "dimode_p", "||", "fisttp", ")", "&&", "!", "stack_top_dies", ")", "output_asm_insn", "(", "\"fld\\t%y1\"", ",", "operands", ")", ";", "gcc_assert", "(", "STACK_TOP_P", "(", "operands", "[", "1", "]", ")", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "MEM", ")", ";", "if", "(", "fisttp", ")", "output_asm_insn", "(", "\"fisttp%z0\\t%0\"", ",", "operands", ")", ";", "else", "{", "if", "(", "round_mode", "!=", "I387_CW_ANY", ")", "output_asm_insn", "(", "\"fldcw\\t%3\"", ",", "operands", ")", ";", "if", "(", "stack_top_dies", "||", "dimode_p", ")", "output_asm_insn", "(", "\"fistp%z0\\t%0\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"fist%z0\\t%0\"", ",", "operands", ")", ";", "if", "(", "round_mode", "!=", "I387_CW_ANY", ")", "output_asm_insn", "(", "\"fldcw\\t%2\"", ",", "operands", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "code", "for", "INSN", "to", "convert", "a", "float", "to", "a", "signed", "int", ".", "OPERANDS", "are", "the", "insn", "operands", ".", "The", "output", "may", "be", "[", "HSD", "]", "Imode", "and", "the", "input", "operand", "may", "be", "[", "SDX", "]", "Fmode", "." ]

[ "i386", "0", "0", "\"fld\\t%y1\"", "1", "0", "\"fisttp%z0\\t%0\"", "\"fldcw\\t%3\"", "\"fistp%z0\\t%0\"", "\"fist%z0\\t%0\"", "\"fldcw\\t%2\"", "\"\"" ]

[]

[ "<s>", "bool", "doInitialization", "(", "Module", "&", "M", ")", "override", "{", "SMShadowTracker", ".", "reset", "(", "0", ")", ";", "SM", ".", "reset", "(", ")", ";", "return", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "X86", "0" ]

[]

[ "<s>", "const", "LC3InstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "LC3", "LC3" ]

[]

[ "<s>", "const", "MachineFunction", "&", "getMachineFunction", "(", ")", "const", "{", "return", "MF", ";", "}", "</s>" ]

[ "getMachineFunction", "-", "Return", "the", "last", "machine", "function", "computed", "." ]

[ "WebAssembly" ]

[]