Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "const", "char", "*", "ashrsi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", "{", "int", "k", ";", "int", "*", "t", "=", "len", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "case", "8", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "*", "len", "=", "6", ";", "if", "(", "reg0", "<=", "reg1", ")", "return", "(", "\"mov %A0,%B1\"", "CR_TAB", "\"mov %B0,%C1\"", "CR_TAB", "\"mov %C0,%D1\"", "CR_TAB", "\"clr %D0\"", "CR_TAB", "\"sbrc %C0,7\"", "CR_TAB", "\"dec %D0\"", ")", ";", "else", "return", "(", "\"clr %D0\"", "CR_TAB", "\"sbrc %D1,7\"", "CR_TAB", "\"dec %D0\"", "CR_TAB", "\"mov %C0,%D1\"", "CR_TAB", "\"mov %B0,%C1\"", "CR_TAB", "\"mov %A0,%B1\"", ")", ";", "}", "case", "16", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "reg0", "==", "reg1", "+", "2", ")", "return", "*", "len", "=", "4", ",", "(", "\"clr %D0\"", "CR_TAB", "\"sbrc %B0,7\"", "CR_TAB", "\"com %D0\"", "CR_TAB", "\"mov %C0,%D0\"", ")", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "5", ",", "(", "\"movw %A0,%C1\"", "CR_TAB", "\"clr %D0\"", "CR_TAB", "\"sbrc %B0,7\"", "CR_TAB", "\"com %D0\"", "CR_TAB", "\"mov %C0,%D0\"", ")", ";", "else", "return", "*", "len", "=", "6", ",", "(", "\"mov %B0,%D1\"", "CR_TAB", "\"mov %A0,%C1\"", "CR_TAB", "\"clr %D0\"", "CR_TAB", "\"sbrc %B0,7\"", "CR_TAB", "\"com %D0\"", "CR_TAB", "\"mov %C0,%D0\"", ")", ";", "}", "case", "24", ":", "return", "*", "len", "=", "6", ",", "(", "\"mov %A0,%D1\"", "CR_TAB", "\"clr %D0\"", "CR_TAB", "\"sbrc %A0,7\"", "CR_TAB", "\"com %D0\"", "CR_TAB", "\"mov %B0,%D0\"", "CR_TAB", "\"mov %C0,%D0\"", ")", ";", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "32", ")", "break", ";", "case", "31", ":", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "4", ",", "(", "\"lsl %D0\"", "CR_TAB", "\"sbc %A0,%A0\"", "CR_TAB", "\"mov %B0,%A0\"", "CR_TAB", "\"movw %C0,%A0\"", ")", ";", "else", "return", "*", "len", "=", "5", ",", "(", "\"lsl %D0\"", "CR_TAB", "\"sbc %A0,%A0\"", "CR_TAB", "\"mov %B0,%A0\"", "CR_TAB", "\"mov %C0,%A0\"", "CR_TAB", "\"mov %D0,%A0\"", ")", ";", "}", "len", "=", "t", ";", "}", "out_shift_with_cnt", "(", "\"asr %D0\"", "CR_TAB", "\"ror %C0\"", "CR_TAB", "\"ror %B0\"", "CR_TAB", "\"ror %A0\"", ",", "insn", ",", "operands", ",", "len", ",", "4", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "32bit", "arithmetic", "shift", "right", "(", "(", "signed", "long", ")", "x", ">", ">", "i", ")" ]

[ "avr", "2", "2", "8", "0", "1", "6", "\"mov %A0,%B1\"", "\"mov %B0,%C1\"", "\"mov %C0,%D1\"", "\"clr %D0\"", "\"sbrc %C0,7\"", "\"dec %D0\"", "\"clr %D0\"", "\"sbrc %D1,7\"", "\"dec %D0\"", "\"mov %C0,%D1\"", "\"mov %B0,%C1\"", "\"mov %A0,%B1\"", "16", "0", "1", "2", "4", "\"clr %D0\"", "\"sbrc %B0,7\"", "\"com %D0\"", "\"mov %C0,%D0\"", "5", "\"movw %A0,%C1\"", "\"clr %D0\"", "\"sbrc %B0,7\"", "\"com %D0\"", "\"mov %C0,%D0\"", "6", "\"mov %B0,%D1\"", "\"mov %A0,%C1\"", "\"clr %D0\"", "\"sbrc %B0,7\"", "\"com %D0\"", "\"mov %C0,%D0\"", "24", "6", "\"mov %A0,%D1\"", "\"clr %D0\"", "\"sbrc %A0,7\"", "\"com %D0\"", "\"mov %B0,%D0\"", "\"mov %C0,%D0\"", "2", "32", "31", "4", "\"lsl %D0\"", "\"sbc %A0,%A0\"", "\"mov %B0,%A0\"", "\"movw %C0,%A0\"", "5", "\"lsl %D0\"", "\"sbc %A0,%A0\"", "\"mov %B0,%A0\"", "\"mov %C0,%A0\"", "\"mov %D0,%A0\"", "\"asr %D0\"", "\"ror %C0\"", "\"ror %B0\"", "\"ror %A0\"", "4", "\"\"" ]

[]

[ "<s>", "SDValue", "XNCMTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "return", "LowerCCCArguments", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "XNCM", "XNCM", "ISD::InputArg", "\"Unsupported calling convention\"" ]

[]

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

[ "Returns", "true", "if", "the", "target", "wants", "the", "LocalStackAllocation", "pass", "to", "be", "run", "and", "virtual", "base", "registers", "used", "for", "more", "efficient", "stack", "access", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "isToken", "(", ")", "const", "override", "{", "return", "Kind", "==", "TOKEN", ";", "}", "</s>" ]

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

[ "Lanai" ]

[]

[ "<s>", "bool", "Cpu0DAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Ret", "=", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "Ret", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "BitVector", "R600RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "R600Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "R600Subtarget", ">", "(", ")", ";", "const", "R600InstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "ZERO", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "HALF", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "ONE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "ONE_INT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "NEG_HALF", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "NEG_ONE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "PV_X", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "ALU_LITERAL_X", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "ALU_CONST", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "PREDICATE_BIT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "PRED_SEL_OFF", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "PRED_SEL_ZERO", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "PRED_SEL_ONE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "INDIRECT_BASE_ADDR", ")", ";", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "AMDGPU", "::", "R600_AddrRegClass", ".", "begin", "(", ")", ",", "E", "=", "AMDGPU", "::", "R600_AddrRegClass", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "*", "I", ")", ";", "}", "TII", "->", "reserveIndirectRegisters", "(", "Reserved", ",", "MF", ",", "*", "this", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "R600", "R600", "R600", "AMDGPU::ZERO", "AMDGPU::HALF", "AMDGPU::ONE", "AMDGPU::ONE_INT", "AMDGPU::NEG_HALF", "AMDGPU::NEG_ONE", "AMDGPU::PV_X", "AMDGPU::ALU_LITERAL_X", "AMDGPU::ALU_CONST", "AMDGPU::PREDICATE_BIT", "AMDGPU::PRED_SEL_OFF", "AMDGPU::PRED_SEL_ZERO", "AMDGPU::PRED_SEL_ONE", "AMDGPU::INDIRECT_BASE_ADDR", "AMDGPU::R600_AddrRegClass", "AMDGPU::R600_AddrRegClass" ]

[]

[ "<s>", "std", "::", "vector", "<", "std", "::", "pair", "<", "uint64_t", ",", "uint64_t", ">>", "findPltEntries", "(", "uint64_t", "PltSectionVA", ",", "ArrayRef", "<", "uint8_t", ">", "PltContents", ",", "uint64_t", "GotPltSectionVA", ",", "const", "Triple", "&", "TargetTriple", ")", "const", "override", "{", "std", "::", "vector", "<", "std", "::", "pair", "<", "uint64_t", ",", "uint64_t", ">>", "Result", ";", "for", "(", "uint64_t", "Byte", "=", "0", ",", "End", "=", "PltContents", ".", "size", "(", ")", ";", "Byte", "+", "7", "<", "End", ";", "Byte", "+=", "4", ")", "{", "uint32_t", "Insn", "=", "support", "::", "endian", "::", "read32le", "(", "PltContents", ".", "data", "(", ")", "+", "Byte", ")", ";", "if", "(", "(", "Insn", "&", "0x9f000000", ")", "!=", "0x90000000", ")", "continue", ";", "uint64_t", "Imm", "=", "(", "(", "(", "PltSectionVA", "+", "Byte", ")", ">>", "12", ")", "<<", "12", ")", "+", "(", "(", "(", "Insn", ">>", "29", ")", "&", "3", ")", "<<", "12", ")", "+", "(", "(", "(", "Insn", ">>", "5", ")", "&", "0x3ffff", ")", "<<", "14", ")", ";", "uint32_t", "Insn2", "=", "support", "::", "endian", "::", "read32le", "(", "PltContents", ".", "data", "(", ")", "+", "Byte", "+", "4", ")", ";", "if", "(", "Insn2", ">>", "22", "==", "0x3e5", ")", "{", "Imm", "+=", "(", "(", "Insn2", ">>", "10", ")", "&", "0xfff", ")", "<<", "3", ";", "Result", ".", "push_back", "(", "std", "::", "make_pair", "(", "PltSectionVA", "+", "Byte", ",", "Imm", ")", ")", ";", "Byte", "+=", "4", ";", "}", "}", "return", "Result", ";", "}", "</s>" ]

[ "Returns", "(", "PLT", "virtual", "address", ",", "GOT", "virtual", "address", ")", "pairs", "for", "PLT", "entries", "." ]

[ "AArch64", "0", "7", "4", "support::endian", "0x9f000000", "0x90000000", "12", "12", "29", "3", "12", "5", "0x3ffff", "14", "support::endian", "4", "22", "0x3e5", "10", "0xfff", "3", "4" ]

[]

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

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

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

[]

[ "<s>", "void", "JVMPassConfig", "::", "addMachinePasses", "(", ")", "{", "addPass", "(", "&", "PHIEliminationID", ",", "false", ")", ";", "addPass", "(", "createJVMPreAllocationFixups", "(", ")", ")", ";", "addPass", "(", "createJVMCopyElision", "(", ")", ")", ";", "addPreEmitPass", "(", ")", ";", "}", "</s>" ]

[ "Add", "the", "complete", ",", "standard", "set", "of", "LLVM", "CodeGen", "passes", "." ]

[ "JVM", "JVM", "JVM", "JVM" ]

[]

[ "<s>", "static", "rtx", "loongarch_got_load_tls_le", "(", "rtx", "dest", ",", "rtx", "sym", ")", "{", "return", "gen_got_load_tls_le", "(", "Pmode", ",", "dest", ",", "sym", ")", ";", "}", "</s>" ]

[ "Add", "in", "the", "thread", "pointer", "for", "a", "TLS", "LE", "access", "." ]

[ "loongarch" ]

[]

[ "<s>", "bool", "fp_one_operand", "(", "rtx", "op", ")", "{", "if", "(", "GET_MODE", "(", "op", ")", "!=", "SFmode", ")", "return", "false", ";", "return", "real_equal", "(", "CONST_DOUBLE_REAL_VALUE", "(", "op", ")", ",", "&", "dconst1", ")", ";", "}", "</s>" ]

[ "Nonzero", "if", "OP", "is", "a", "floating", "point", "value", "with", "value", "1.0", "." ]

[ "sh" ]

[]

[ "<s>", "static", "int", "arc_save_callee_milli", "(", "unsigned", "int", "gmask", ",", "bool", "save_blink", ",", "bool", "save_fp", ",", "HOST_WIDE_INT", "offset", ",", "HOST_WIDE_INT", "reg_size", ")", "{", "int", "start_reg", "=", "13", ";", "int", "end_reg", "=", "25", ";", "int", "regno", ",", "indx", ",", "off", ",", "nregs", ";", "rtx", "insn", ",", "reg", ",", "mem", ";", "int", "frame_allocated", "=", "0", ";", "for", "(", "regno", "=", "start_reg", ";", "regno", "<=", "end_reg", "&&", "(", "gmask", "&", "(", "1L", "<<", "regno", ")", ")", ";", ")", "regno", "++", ";", "end_reg", "=", "regno", "-", "1", ";", "nregs", "=", "end_reg", "-", "start_reg", "+", "1", ";", "gcc_assert", "(", "end_reg", ">", "14", ")", ";", "if", "(", "save_blink", ")", "{", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "frame_allocated", "+=", "frame_save_reg", "(", "reg", ",", "offset", ")", ";", "offset", "=", "0", ";", "}", "if", "(", "reg_size", "||", "offset", ")", "{", "frame_stack_add", "(", "offset", "-", "reg_size", ")", ";", "frame_allocated", "+=", "nregs", "*", "UNITS_PER_WORD", "-", "offset", ";", "offset", "=", "0", ";", "}", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "nregs", "+", "1", ")", ")", ";", "indx", "=", "0", ";", "XVECEXP", "(", "insn", ",", "0", ",", "nregs", ")", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ")", ";", "for", "(", "regno", "=", "start_reg", ",", "indx", "=", "0", ",", "off", "=", "0", ";", "regno", "<=", "end_reg", ";", "regno", "++", ",", "indx", "++", ",", "off", "+=", "UNITS_PER_WORD", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", ")", "=", "1", ";", "gmask", "=", "gmask", "&", "~", "(", "1L", "<<", "regno", ")", ";", "}", "insn", "=", "frame_insn", "(", "insn", ")", ";", "for", "(", "regno", "=", "start_reg", ",", "off", "=", "0", ";", "regno", "<=", "end_reg", ";", "regno", "++", ",", "off", "+=", "UNITS_PER_WORD", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "}", "if", "(", "arc_must_save_return_addr", "(", "cfun", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ",", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "reg_size", ")", ")", ")", ")", ";", "}", "for", "(", "regno", "=", "0", ";", "regno", "<=", "31", ";", "regno", "++", ")", "{", "if", "(", "(", "gmask", "&", "(", "1L", "<<", "regno", ")", ")", "==", "0", ")", "continue", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "frame_move_inc", "(", "mem", ",", "reg", ",", "stack_pointer_rtx", ",", "0", ")", ";", "frame_allocated", "+=", "UNITS_PER_WORD", ";", "off", "+=", "UNITS_PER_WORD", ";", "}", "if", "(", "save_fp", ")", "frame_allocated", "+=", "frame_save_reg", "(", "hard_frame_pointer_rtx", ",", "offset", ")", ";", "if", "(", "arc_frame_pointer_needed", "(", ")", ")", "frame_move", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "return", "frame_allocated", ";", "}", "</s>" ]

[ "Millicode", "thunks", "implementation", ":", "Generates", "calls", "to", "millicodes", "for", "registers", "starting", "from", "r13", "to", "r25", "Present", "Limitations", ":", "-", "Only", "one", "range", "supported", ".", "The", "remaining", "regs", "will", "have", "the", "ordinary", "st", "and", "ld", "instructions", "for", "store", "and", "loads", ".", "Hence", "a", "gmask", "asking", "to", "store", "r13-14", ",", "r16-r25", "will", "only", "generate", "calls", "to", "store", "and", "load", "r13", "to", "r14", "while", "store", "and", "load", "insns", "will", "be", "generated", "for", "r16", "to", "r25", "in", "the", "prologue", "and", "epilogue", "respectively", ".", "-", "Presently", "library", "only", "supports", "register", "ranges", "starting", "from", "r13", "." ]

[ "arc", "13", "25", "0", "1L", "1", "1", "14", "0", "0", "1", "0", "0", "0", "0", "0", "0", "1", "1L", "0", "0", "31", "1L", "0", "0" ]

[]

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

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

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

[]

[ "<s>", "const", "char", "*", "avr_out_tstpsi", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "if", "(", "compare_sign_p", "(", "insn", ")", ")", "{", "avr_asm_len", "(", "\"tst %C0\"", ",", "op", ",", "plen", ",", "-", "1", ")", ";", "}", "else", "if", "(", "reg_unused_after", "(", "insn", ",", "op", "[", "0", "]", ")", "&&", "compare_eq_p", "(", "insn", ")", ")", "{", "avr_asm_len", "(", "\"or %A0,%B0\"", "CR_TAB", "\"or %A0,%C0\"", ",", "op", ",", "plen", ",", "-", "2", ")", ";", "}", "else", "{", "avr_out_compare", "(", "insn", ",", "op", ",", "plen", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "test", "instruction", "for", "PSImode", "." ]

[ "avr", "\"tst %C0\"", "1", "0", "\"or %A0,%B0\"", "\"or %A0,%C0\"", "2", "\"\"" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "override", "{", "}", "</s>" ]

[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]

[ "LoongArch" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "canInsertSelect", "(", "const", "MachineBasicBlock", "&", "MBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "Register", "DstReg", ",", "Register", "TrueReg", ",", "Register", "FalseReg", ",", "int", "&", "CondCycles", ",", "int", "&", "TrueCycles", ",", "int", "&", "FalseCycles", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getCommonSubClass", "(", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ",", "MRI", ".", "getRegClass", "(", "FalseReg", ")", ")", ";", "if", "(", "!", "RC", ")", "return", "false", ";", "if", "(", "!", "RI", ".", "getCommonSubClass", "(", "RC", ",", "MRI", ".", "getRegClass", "(", "DstReg", ")", ")", ")", "return", "false", ";", "unsigned", "ExtraCondLat", "=", "Cond", ".", "size", "(", ")", "!=", "1", ";", "if", "(", "AArch64", "::", "GPR64allRegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "AArch64", "::", "GPR32allRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "CondCycles", "=", "1", "+", "ExtraCondLat", ";", "TrueCycles", "=", "FalseCycles", "=", "1", ";", "if", "(", "canFoldIntoCSel", "(", "MRI", ",", "TrueReg", ")", ")", "TrueCycles", "=", "0", ";", "else", "if", "(", "canFoldIntoCSel", "(", "MRI", ",", "FalseReg", ")", ")", "FalseCycles", "=", "0", ";", "return", "true", ";", "}", "if", "(", "AArch64", "::", "FPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "AArch64", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "CondCycles", "=", "5", "+", "ExtraCondLat", ";", "TrueCycles", "=", "FalseCycles", "=", "2", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "possible", "to", "insert", "a", "select", "instruction", "that", "chooses", "between", "TrueReg", "and", "FalseReg", "based", "on", "the", "condition", "code", "in", "Cond", "." ]

[ "AArch64", "AArch64", "1", "AArch64::GPR64allRegClass", "AArch64::GPR32allRegClass", "1", "1", "0", "0", "AArch64::FPR64RegClass", "AArch64::FPR32RegClass", "5", "2" ]

[]

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

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

[ "Mips" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "X86RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "assert", "(", "MF", "&&", "\"MachineFunction required\"", ")", ";", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "bool", "HasSSE", "=", "Subtarget", ".", "hasSSE1", "(", ")", ";", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "Subtarget", ".", "hasAVX512", "(", ")", ";", "bool", "CallsEHReturn", "=", "MF", "->", "callsEHReturn", "(", ")", ";", "CallingConv", "::", "ID", "CC", "=", "F", "->", "getCallingConv", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "\"no_caller_saved_registers\"", ")", ")", "CC", "=", "CallingConv", "::", "X86_INTR", ";", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_SaveList", ";", "case", "CallingConv", "::", "AnyReg", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveMost", ":", "return", "CSR_64_RT_MostRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveAll", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_RT_AllRegs_AVX_SaveList", ";", "return", "CSR_64_RT_AllRegs_SaveList", ";", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "if", "(", "Is64Bit", ")", "return", "MF", "->", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", "?", "CSR_64_CXX_TLS_Darwin_PE_SaveList", ":", "CSR_64_TLS_Darwin_SaveList", ";", "break", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_SaveList", ";", "break", ";", "}", "case", "CallingConv", "::", "HHVM", ":", "return", "CSR_64_HHVM_SaveList", ";", "case", "CallingConv", "::", "X86_RegCall", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "{", "return", "(", "HasSSE", "?", "CSR_Win64_RegCall_SaveList", ":", "CSR_Win64_RegCall_NoSSE_SaveList", ")", ";", "}", "else", "{", "return", "(", "HasSSE", "?", "CSR_SysV64_RegCall_SaveList", ":", "CSR_SysV64_RegCall_NoSSE_SaveList", ")", ";", "}", "}", "else", "{", "return", "(", "HasSSE", "?", "CSR_32_RegCall_SaveList", ":", "CSR_32_RegCall_NoSSE_SaveList", ")", ";", "}", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_SaveList", ";", "break", ";", "case", "CallingConv", "::", "Win64", ":", "if", "(", "!", "HasSSE", ")", "return", "CSR_Win64_NoSSE_SaveList", ";", "return", "CSR_Win64_SaveList", ";", "case", "CallingConv", "::", "X86_64_SysV", ":", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "return", "CSR_64_SaveList", ";", "case", "CallingConv", "::", "X86_INTR", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "HasAVX512", ")", "return", "CSR_64_AllRegs_AVX512_SaveList", ";", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_SaveList", ";", "if", "(", "HasSSE", ")", "return", "CSR_64_AllRegs_SaveList", ";", "return", "CSR_64_AllRegs_NoSSE_SaveList", ";", "}", "else", "{", "if", "(", "HasAVX512", ")", "return", "CSR_32_AllRegs_AVX512_SaveList", ";", "if", "(", "HasAVX", ")", "return", "CSR_32_AllRegs_AVX_SaveList", ";", "if", "(", "HasSSE", ")", "return", "CSR_32_AllRegs_SSE_SaveList", ";", "return", "CSR_32_AllRegs_SaveList", ";", "}", "default", ":", "break", ";", "}", "if", "(", "Is64Bit", ")", "{", "bool", "IsSwiftCC", "=", "Subtarget", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "F", "->", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ";", "if", "(", "IsSwiftCC", ")", "return", "IsWin64", "?", "CSR_Win64_SwiftError_SaveList", ":", "CSR_64_SwiftError_SaveList", ";", "if", "(", "IsWin64", ")", "return", "HasSSE", "?", "CSR_Win64_SaveList", ":", "CSR_Win64_NoSSE_SaveList", ";", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "return", "CSR_64_SaveList", ";", "}", "return", "CallsEHReturn", "?", "CSR_32EHRet_SaveList", ":", "CSR_32_SaveList", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"MachineFunction required\"", "X86", "X86", "\"no_caller_saved_registers\"", "X86", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "static", "void", "riscv_block_move_loop", "(", "rtx", "dest", ",", "rtx", "src", ",", "unsigned", "HOST_WIDE_INT", "length", ",", "unsigned", "HOST_WIDE_INT", "bytes_per_iter", ")", "{", "rtx", "label", ",", "src_reg", ",", "dest_reg", ",", "final_src", ",", "test", ";", "unsigned", "HOST_WIDE_INT", "leftover", ";", "leftover", "=", "length", "%", "bytes_per_iter", ";", "length", "-=", "leftover", ";", "riscv_adjust_block_mem", "(", "src", ",", "bytes_per_iter", ",", "&", "src_reg", ",", "&", "src", ")", ";", "riscv_adjust_block_mem", "(", "dest", ",", "bytes_per_iter", ",", "&", "dest_reg", ",", "&", "dest", ")", ";", "final_src", "=", "expand_simple_binop", "(", "Pmode", ",", "PLUS", ",", "src_reg", ",", "GEN_INT", "(", "length", ")", ",", "0", ",", "0", ",", "OPTAB_WIDEN", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "riscv_block_move_straight", "(", "dest", ",", "src", ",", "bytes_per_iter", ")", ";", "riscv_emit_move", "(", "src_reg", ",", "plus_constant", "(", "Pmode", ",", "src_reg", ",", "bytes_per_iter", ")", ")", ";", "riscv_emit_move", "(", "dest_reg", ",", "plus_constant", "(", "Pmode", ",", "dest_reg", ",", "bytes_per_iter", ")", ")", ";", "test", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "src_reg", ",", "final_src", ")", ";", "emit_jump_insn", "(", "gen_cbranch4", "(", "Pmode", ",", "test", ",", "src_reg", ",", "final_src", ",", "label", ")", ")", ";", "if", "(", "leftover", ")", "riscv_block_move_straight", "(", "dest", ",", "src", ",", "leftover", ")", ";", "else", "emit_insn", "(", "gen_nop", "(", ")", ")", ";", "}", "</s>" ]

[ "Move", "LENGTH", "bytes", "from", "SRC", "to", "DEST", "using", "a", "loop", "that", "moves", "BYTES_PER_ITER", "bytes", "at", "a", "time", ".", "LENGTH", "must", "be", "at", "least", "BYTES_PER_ITER", ".", "Assume", "that", "the", "memory", "regions", "do", "not", "overlap", "." ]

[ "riscv", "0", "0" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerCall", "(", "SDValue", "Chain", ",", "SDValue", "Callee", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "bool", "&", "isTailCall", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "isTailCall", ")", "isTailCall", "=", "IsEligibleForTailCallOptimization", "(", "Callee", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "DAG", ")", ";", "if", "(", "PPCSubTarget", ".", "isSVR4ABI", "(", ")", "&&", "!", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "LowerCall_SVR4", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "return", "LowerCall_Darwin", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "PowerPC", "PPC", "ISD::OutputArg", "ISD::InputArg", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "const", "NyuziSubtarget", "*", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

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

[ "Nyuzi", "Nyuzi" ]

[]

[ "<s>", "MCFragment", "*", "findAssociatedFragment", "(", ")", "const", "override", "{", "return", "getSubExpr", "(", ")", "->", "findAssociatedFragment", "(", ")", ";", "}", "</s>" ]

[ "Find", "the", "``", "associated", "section", "''", "for", "this", "expression", ",", "which", "is", "currently", "defined", "as", "the", "absolute", "section", "for", "constants", ",", "or", "otherwise", "the", "section", "associated", "with", "the", "first", "defined", "symbol", "in", "the", "expression", "." ]

[ "VE" ]

[]

[ "<s>", "unsigned", "internalKnownBits", "(", ")", "const", "{", "unsigned", "Bits", "=", "Unalign", "?", "Unalign", ":", "KnownBits", ";", "if", "(", "Size", "&", "(", "(", "1u", "<<", "Bits", ")", "-", "1", ")", ")", "Bits", "=", "countTrailingZeros", "(", "Size", ")", ";", "return", "Bits", ";", "}", "</s>" ]

[ "Compute", "the", "number", "of", "known", "offset", "bits", "internally", "to", "this", "block", "." ]

[ "AArch64", "1u", "1" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "bool", "is64Bit", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ";", "unsigned", "SlotSize", "=", "is64Bit", "?", "8", ":", "4", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "X86FI", "->", "setCalleeSavedFrameSize", "(", "CSI", ".", "size", "(", ")", "*", "SlotSize", ")", ";", "unsigned", "Opc", "=", "is64Bit", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "8", "4", "X86", "X86", "X86", "X86", "X86::PUSH64r", "X86::PUSH32r", "0", "1" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "&", "MI", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred", ")", "const", "{", "assert", "(", "Pred", ".", "size", "(", ")", "==", "2", "&&", "\"Invalid condition\"", ")", ";", "unsigned", "CCValid", "=", "Pred", "[", "0", "]", ".", "getImm", "(", ")", ";", "unsigned", "CCMask", "=", "Pred", "[", "1", "]", ".", "getImm", "(", ")", ";", "assert", "(", "CCMask", ">", "0", "&&", "CCMask", "<", "15", "&&", "\"Invalid predicate\"", ")", ";", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "SystemZ", "::", "Trap", ")", "{", "MI", ".", "setDesc", "(", "get", "(", "SystemZ", "::", "CondTrap", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "addReg", "(", "SystemZ", "::", "CC", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "if", "(", "Opcode", "==", "SystemZ", "::", "Return", "||", "Opcode", "==", "SystemZ", "::", "Return_XPLINK", ")", "{", "MI", ".", "setDesc", "(", "get", "(", "Opcode", "==", "SystemZ", "::", "Return", "?", "SystemZ", "::", "CondReturn", ":", "SystemZ", "::", "CondReturn_XPLINK", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "addReg", "(", "SystemZ", "::", "CC", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "if", "(", "Opcode", "==", "SystemZ", "::", "CallJG", ")", "{", "MachineOperand", "FirstOp", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "const", "uint32_t", "*", "RegMask", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getRegMask", "(", ")", ";", "MI", ".", "removeOperand", "(", "1", ")", ";", "MI", ".", "removeOperand", "(", "0", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "SystemZ", "::", "CallBRCL", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "add", "(", "FirstOp", ")", ".", "addRegMask", "(", "RegMask", ")", ".", "addReg", "(", "SystemZ", "::", "CC", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "if", "(", "Opcode", "==", "SystemZ", "::", "CallBR", ")", "{", "MachineOperand", "Target", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "const", "uint32_t", "*", "RegMask", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getRegMask", "(", ")", ";", "MI", ".", "removeOperand", "(", "1", ")", ";", "MI", ".", "removeOperand", "(", "0", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "SystemZ", "::", "CallBCR", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "add", "(", "Target", ")", ".", "addRegMask", "(", "RegMask", ")", ".", "addReg", "(", "SystemZ", "::", "CC", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "2", "\"Invalid condition\"", "0", "1", "0", "15", "\"Invalid predicate\"", "SystemZ::Trap", "SystemZ::CondTrap", "SystemZ::CC", "SystemZ::Return", "SystemZ::Return_XPLINK", "SystemZ::Return", "SystemZ::CondReturn", "SystemZ::CondReturn_XPLINK", "SystemZ::CC", "SystemZ::CallJG", "0", "1", "1", "0", "SystemZ::CallBRCL", "SystemZ::CC", "SystemZ::CallBR", "0", "1", "1", "0", "SystemZ::CallBCR", "SystemZ::CC" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "XCoreInstrInfo", "::", "loadImmediate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "Reg", ",", "uint64_t", "Value", ")", "const", "{", "DebugLoc", "dl", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "MI", "->", "isDebugValue", "(", ")", ")", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "isImmMskBitp", "(", "Value", ")", ")", "{", "int", "N", "=", "Log2_32", "(", "Value", ")", "+", "1", ";", "return", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "XCore", "::", "MKMSK_rus", ")", ",", "Reg", ")", ".", "addImm", "(", "N", ")", ".", "getInstr", "(", ")", ";", "}", "if", "(", "isImmU16", "(", "Value", ")", ")", "{", "int", "Opcode", "=", "isImmU6", "(", "Value", ")", "?", "XCore", "::", "LDC_ru6", ":", "XCore", "::", "LDC_lru6", ";", "return", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "Opcode", ")", ",", "Reg", ")", ".", "addImm", "(", "Value", ")", ".", "getInstr", "(", ")", ";", "}", "MachineConstantPool", "*", "ConstantPool", "=", "MBB", ".", "getParent", "(", ")", "->", "getConstantPool", "(", ")", ";", "const", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ",", "Value", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "4", ")", ";", "return", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "XCore", "::", "LDWCP_lru6", ")", ",", "Reg", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "getInstr", "(", ")", ";", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "load", "an", "immediate", "." ]

[ "XCore", "XCore", "1", "XCore::MKMSK_rus", "XCore::LDC_ru6", "XCore::LDC_lru6", "4", "XCore::LDWCP_lru6" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "AdjustInstrPostInstrSelection", "(", "MachineInstr", "&", "MI", ",", "SDNode", "*", "Node", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "if", "(", "TII", "->", "isVOP3", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "TII", "->", "legalizeOperandsVOP3", "(", "MRI", ",", "MI", ")", ";", "if", "(", "const", "MCOperandInfo", "*", "OpInfo", "=", "MI", ".", "getDesc", "(", ")", ".", "OpInfo", ")", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "for", "(", "auto", "I", ":", "{", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ",", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", "}", ")", "{", "if", "(", "I", "==", "-", "1", ")", "break", ";", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "I", ")", ";", "if", "(", "(", "OpInfo", "[", "I", "]", ".", "RegClass", "!=", "llvm", "::", "AMDGPU", "::", "AV_64RegClassID", "&&", "OpInfo", "[", "I", "]", ".", "RegClass", "!=", "llvm", "::", "AMDGPU", "::", "AV_32RegClassID", ")", "||", "!", "Register", "::", "isVirtualRegister", "(", "Op", ".", "getReg", "(", ")", ")", "||", "!", "TRI", "->", "isAGPR", "(", "MRI", ",", "Op", ".", "getReg", "(", ")", ")", ")", "continue", ";", "auto", "*", "Src", "=", "MRI", ".", "getUniqueVRegDef", "(", "Op", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "Src", "||", "!", "Src", "->", "isCopy", "(", ")", "||", "!", "TRI", "->", "isSGPRReg", "(", "MRI", ",", "Src", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", "continue", ";", "auto", "*", "RC", "=", "TRI", "->", "getRegClassForReg", "(", "MRI", ",", "Op", ".", "getReg", "(", ")", ")", ";", "auto", "*", "NewRC", "=", "TRI", "->", "getEquivalentVGPRClass", "(", "RC", ")", ";", "MRI", ".", "setRegClass", "(", "Op", ".", "getReg", "(", ")", ",", "NewRC", ")", ";", "}", "}", "return", ";", "}", "int", "NoRetAtomicOp", "=", "AMDGPU", "::", "getAtomicNoRetOp", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "NoRetAtomicOp", "!=", "-", "1", ")", "{", "if", "(", "!", "Node", "->", "hasAnyUseOfValue", "(", "0", ")", ")", "{", "MI", ".", "setDesc", "(", "TII", "->", "get", "(", "NoRetAtomicOp", ")", ")", ";", "MI", ".", "RemoveOperand", "(", "0", ")", ";", "return", ";", "}", "if", "(", "(", "Node", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", "&&", "Node", "->", "use_begin", "(", ")", "->", "isMachineOpcode", "(", ")", "&&", "Node", "->", "use_begin", "(", ")", "->", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "EXTRACT_SUBREG", "&&", "!", "Node", "->", "use_begin", "(", ")", "->", "hasAnyUseOfValue", "(", "0", ")", ")", ")", "{", "Register", "Def", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "MI", ".", "setDesc", "(", "TII", "->", "get", "(", "NoRetAtomicOp", ")", ")", ";", "MI", ".", "RemoveOperand", "(", "0", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "IMPLICIT_DEF", ")", ",", "Def", ")", ";", "}", "return", ";", "}", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'hasPostISelHook", "'", "flag", "." ]

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "AMDGPU::AV_64RegClassID", "AMDGPU::AV_32RegClassID", "1", "AMDGPU::getAtomicNoRetOp", "1", "0", "0", "1", "0", "AMDGPU::EXTRACT_SUBREG", "0", "0", "0", "AMDGPU::IMPLICIT_DEF" ]

[]

[ "<s>", "DecodeStatus", "AMDGPUDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes_", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "WS", ",", "raw_ostream", "&", "CS", ")", "const", "{", "CommentStream", "=", "&", "CS", ";", "assert", "(", "AMDGPU", "::", "isVI", "(", "STI", ")", "&&", "\"Can disassemble only VI ISA.\"", ")", ";", "const", "unsigned", "MaxInstBytesNum", "=", "(", "std", "::", "min", ")", "(", "(", "size_t", ")", "8", ",", "Bytes_", ".", "size", "(", ")", ")", ";", "Bytes", "=", "Bytes_", ".", "slice", "(", "0", ",", "MaxInstBytesNum", ")", ";", "DecodeStatus", "Res", "=", "MCDisassembler", "::", "Fail", ";", "do", "{", "if", "(", "Bytes", ".", "size", "(", ")", ">=", "8", ")", "{", "const", "uint64_t", "QW", "=", "eatBytes", "<", "uint64_t", ">", "(", "Bytes", ")", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableDPP64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableSDWA64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "}", "Bytes", "=", "Bytes_", ".", "slice", "(", "0", ",", "MaxInstBytesNum", ")", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "break", ";", "const", "uint32_t", "DW", "=", "eatBytes", "<", "uint32_t", ">", "(", "Bytes", ")", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableVI32", ",", "MI", ",", "DW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableAMDGPU32", ",", "MI", ",", "DW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "break", ";", "const", "uint64_t", "QW", "=", "(", "(", "uint64_t", ")", "eatBytes", "<", "uint32_t", ">", "(", "Bytes", ")", "<<", "32", ")", "|", "DW", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableVI64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableAMDGPU64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "}", "while", "(", "false", ")", ";", "Size", "=", "Res", "?", "(", "MaxInstBytesNum", "-", "Bytes", ".", "size", "(", ")", ")", ":", "0", ";", "return", "Res", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::isVI", "\"Can disassemble only VI ISA.\"", "8", "0", "8", "0", "4", "AMDGPU", "4", "32", "AMDGPU", "0" ]

[]

[ "<s>", "void", "Cpu0InstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "O", ")", ")", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "override", "{", "return", "createFISCELFObjectWriter", "(", "OS", ",", "OSABI", ")", ";", "}", "</s>" ]

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

[ "FISC", "FISC" ]

[]

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

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

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

[]

[ "<s>", "bool", "addRegAssignAndRewriteFast", "(", ")", "override", "{", "llvm_unreachable", "(", "\"should not be used\"", ")", ";", "}", "</s>" ]

[ "Add", "core", "register", "allocator", "passes", "which", "do", "the", "actual", "register", "assignment", "and", "rewriting", "." ]

[ "NVPTX", "\"should not be used\"" ]

[]

[ "<s>", "bool", "constant_address_p", "(", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "LABEL_REF", ":", "case", "CONST_INT", ":", "case", "HIGH", ":", "return", "true", ";", "case", "CONST", ":", "if", "(", "flag_pic", "&&", "pic_address_needs_scratch", "(", "x", ")", ")", "return", "false", ";", "return", "sparc_legitimate_constant_p", "(", "Pmode", ",", "x", ")", ";", "case", "SYMBOL_REF", ":", "return", "!", "flag_pic", "&&", "sparc_legitimate_constant_p", "(", "Pmode", ",", "x", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Determine", "if", "a", "given", "RTX", "is", "a", "valid", "constant", "address", "." ]

[ "sparc" ]

[]

[ "<s>", "static", "rtx_insn", "*", "m68k_emit_movem", "(", "rtx", "base", ",", "HOST_WIDE_INT", "offset", ",", "unsigned", "int", "count", ",", "unsigned", "int", "regno", ",", "unsigned", "int", "mask", ",", "bool", "store_p", ",", "bool", "adjust_stack_p", ")", "{", "int", "i", ";", "rtx", "body", ",", "addr", ",", "src", ",", "operands", "[", "2", "]", ";", "machine_mode", "mode", ";", "body", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "adjust_stack_p", "+", "count", ")", ")", ";", "mode", "=", "reg_raw_mode", "[", "regno", "]", ";", "i", "=", "0", ";", "if", "(", "adjust_stack_p", ")", "{", "src", "=", "plus_constant", "(", "Pmode", ",", "base", ",", "(", "count", "*", "GET_MODE_SIZE", "(", "mode", ")", "*", "(", "HOST_WIDE_INT", ")", "(", "store_p", "?", "-", "1", ":", "1", ")", ")", ")", ";", "XVECEXP", "(", "body", ",", "0", ",", "i", "++", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "base", ",", "src", ")", ";", "}", "for", "(", ";", "mask", "!=", "0", ";", "mask", ">>=", "1", ",", "regno", "++", ")", "if", "(", "mask", "&", "1", ")", "{", "addr", "=", "plus_constant", "(", "Pmode", ",", "base", ",", "offset", ")", ";", "operands", "[", "!", "store_p", "]", "=", "gen_frame_mem", "(", "mode", ",", "addr", ")", ";", "operands", "[", "store_p", "]", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "XVECEXP", "(", "body", ",", "0", ",", "i", "++", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "offset", "+=", "GET_MODE_SIZE", "(", "mode", ")", ";", "}", "gcc_assert", "(", "i", "==", "XVECLEN", "(", "body", ",", "0", ")", ")", ";", "return", "emit_insn", "(", "body", ")", ";", "}", "</s>" ]

[ "Emit", "RTL", "for", "a", "MOVEM", "or", "FMOVEM", "instruction", ".", "BASE", "+", "OFFSET", "represents", "the", "lowest", "memory", "address", ".", "COUNT", "is", "the", "number", "of", "registers", "to", "be", "moved", ",", "with", "register", "REGNO", "+", "I", "being", "moved", "if", "bit", "I", "of", "MASK", "is", "set", ".", "STORE_P", "specifies", "the", "direction", "of", "the", "move", "and", "ADJUST_STACK_P", "says", "whether", "or", "not", "this", "is", "pre-decrement", "(", "if", "STORE_P", ")", "or", "post-increment", "(", "if", "!", "STORE_P", ")", "operation", "." ]

[ "m68k", "2", "0", "1", "1", "0", "0", "1", "1", "0", "0", "1", "0" ]

[]

[ "<s>", "static", "bool", "cris_output_addr_const_extra", "(", "FILE", "*", "file", ",", "rtx", "xconst", ")", "{", "switch", "(", "GET_CODE", "(", "xconst", ")", ")", "{", "rtx", "x", ";", "case", "UNSPEC", ":", "x", "=", "XVECEXP", "(", "xconst", ",", "0", ",", "0", ")", ";", "CRIS_ASSERT", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "x", ")", "==", "CONST", ")", ";", "output_addr_const", "(", "file", ",", "x", ")", ";", "switch", "(", "XINT", "(", "xconst", ",", "1", ")", ")", "{", "case", "CRIS_UNSPEC_PCREL", ":", "gcc_assert", "(", "TARGET_V32", "&&", "flag_pic", ")", ";", "break", ";", "case", "CRIS_UNSPEC_PLT_PCREL", ":", "gcc_assert", "(", "TARGET_V32", ")", ";", "fprintf", "(", "file", ",", "\":PLT\"", ")", ";", "break", ";", "case", "CRIS_UNSPEC_PLT_GOTREL", ":", "gcc_assert", "(", "!", "TARGET_V32", ")", ";", "fprintf", "(", "file", ",", "\":PLTG\"", ")", ";", "break", ";", "case", "CRIS_UNSPEC_GOTREL", ":", "gcc_assert", "(", "!", "TARGET_V32", ")", ";", "fprintf", "(", "file", ",", "\":GOTOFF\"", ")", ";", "break", ";", "case", "CRIS_UNSPEC_GOTREAD", ":", "if", "(", "flag_pic", "==", "1", ")", "fprintf", "(", "file", ",", "\":GOT16\"", ")", ";", "else", "fprintf", "(", "file", ",", "\":GOT\"", ")", ";", "break", ";", "case", "CRIS_UNSPEC_PLTGOTREAD", ":", "if", "(", "flag_pic", "==", "1", ")", "fprintf", "(", "file", ",", "CRIS_GOTPLT_SUFFIX", "\"16\"", ")", ";", "else", "fprintf", "(", "file", ",", "CRIS_GOTPLT_SUFFIX", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

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

[ "cris", "0", "0", "1", "\":PLT\"", "\":PLTG\"", "\":GOTOFF\"", "1", "\":GOT16\"", "\":GOT\"", "1", "\"16\"" ]

[]

[ "<s>", "void", "print", "(", ")", "{", "if", "(", "numSymbols", "==", "0", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "size", ";", "i", "++", ")", "{", "if", "(", "i", ")", "O", "<<", "\", \"", ";", "O", "<<", "(", "unsigned", "int", ")", "buffer", "[", "i", "]", ";", "}", "}", "else", "{", "unsigned", "int", "pos", "=", "0", ";", "unsigned", "int", "nSym", "=", "0", ";", "unsigned", "int", "nextSymbolPos", "=", "symbolPosInBuffer", "[", "nSym", "]", ";", "unsigned", "int", "nBytes", "=", "4", ";", "if", "(", "AP", ".", "nvptxSubtarget", ".", "is64Bit", "(", ")", ")", "nBytes", "=", "8", ";", "for", "(", "pos", "=", "0", ";", "pos", "<", "size", ";", "pos", "+=", "nBytes", ")", "{", "if", "(", "pos", ")", "O", "<<", "\", \"", ";", "if", "(", "pos", "==", "nextSymbolPos", ")", "{", "const", "Value", "*", "v", "=", "Symbols", "[", "nSym", "]", ";", "if", "(", "const", "GlobalValue", "*", "GVar", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "v", ")", ")", "{", "MCSymbol", "*", "Name", "=", "AP", ".", "getSymbol", "(", "GVar", ")", ";", "PointerType", "*", "PTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "GVar", "->", "getType", "(", ")", ")", ";", "bool", "IsNonGenericPointer", "=", "false", ";", "if", "(", "PTy", "&&", "PTy", "->", "getAddressSpace", "(", ")", "!=", "0", ")", "{", "IsNonGenericPointer", "=", "true", ";", "}", "if", "(", "EmitGeneric", "&&", "!", "isa", "<", "Function", ">", "(", "v", ")", "&&", "!", "IsNonGenericPointer", ")", "{", "O", "<<", "\"generic(\"", ";", "O", "<<", "*", "Name", ";", "O", "<<", "\")\"", ";", "}", "else", "{", "O", "<<", "*", "Name", ";", "}", "}", "else", "if", "(", "const", "ConstantExpr", "*", "Cexpr", "=", "dyn_cast", "<", "ConstantExpr", ">", "(", "v", ")", ")", "{", "O", "<<", "*", "nvptx", "::", "LowerConstant", "(", "Cexpr", ",", "AP", ")", ";", "}", "else", "llvm_unreachable", "(", "\"symbol type unknown\"", ")", ";", "nSym", "++", ";", "if", "(", "nSym", ">=", "numSymbols", ")", "nextSymbolPos", "=", "size", "+", "1", ";", "else", "nextSymbolPos", "=", "symbolPosInBuffer", "[", "nSym", "]", ";", "}", "else", "if", "(", "nBytes", "==", "4", ")", "O", "<<", "*", "(", "unsigned", "int", "*", ")", "(", "&", "buffer", "[", "pos", "]", ")", ";", "else", "O", "<<", "*", "(", "unsigned", "long", "long", "*", ")", "(", "&", "buffer", "[", "pos", "]", ")", ";", "}", "}", "}", "</s>" ]

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

[ "NVPTX", "0", "0", "\", \"", "0", "0", "4", "8", "0", "\", \"", "0", "\"generic(\"", "\")\"", "nvptx::LowerConstant", "\"symbol type unknown\"", "1", "4" ]

[]

[ "<s>", "bool", "PPCExpandAtomicPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "TII", "=", "static_cast", "<", "const", "PPCInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "I", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ",", "MBBE", "=", "MBB", ".", "end", "(", ")", ";", "MBBI", "!=", "MBBE", ";", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MBBI", ";", "MachineBasicBlock", "::", "iterator", "NMBBI", "=", "std", "::", "next", "(", "MBBI", ")", ";", "Changed", "|=", "expandMI", "(", "MBB", ",", "MI", ",", "NMBBI", ")", ";", "MBBI", "=", "NMBBI", ";", "}", "}", "if", "(", "Changed", ")", "MF", ".", "RenumberBlocks", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "PrintAsmOperand", "(", "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", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "O", ")", ";", "case", "'r'", ":", "break", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "0", "1", "0", "0" ]

[]

[ "<s>", "bool", "ARM64InstrInfo", "::", "isCoalescableExtInstr", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "DstReg", ",", "unsigned", "&", "SubIdx", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "ARM64", "::", "SBFMXri", ":", "case", "ARM64", "::", "UBFMXri", ":", "if", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "!=", "0", "||", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "!=", "31", ")", "return", "false", ";", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SubIdx", "=", "ARM64", "::", "sub_32", ";", "return", "true", ";", "}", "}", "</s>" ]

[ "isCoalescableExtInstr", "-", "Return", "true", "if", "the", "instruction", "is", "a", "``", "coalescable", "''", "extension", "instruction", "." ]

[ "ARM64", "ARM64", "ARM64::SBFMXri", "ARM64::UBFMXri", "2", "0", "3", "31", "1", "0", "ARM64::sub_32" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "override", "{", "unsigned", "Size", "=", "1", "<<", "getFixupKindLog2Size", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "assert", "(", "Fixup", ".", "getOffset", "(", ")", "+", "Size", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "assert", "(", "isIntN", "(", "Size", "*", "8", "+", "1", ",", "Value", ")", "&&", "\"Value does not fit in the Fixup field\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "Size", ";", "++", "i", ")", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "i", "]", "=", "uint8_t", "(", "Value", ">>", "(", "(", "Size", "-", "i", "-", "1", ")", "*", "8", ")", ")", ";", "}", "</s>" ]

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

[ "M68k", "1", "\"Invalid fixup offset!\"", "8", "1", "\"Value does not fit in the Fixup field\"", "0", "1", "8" ]

[]

[ "<s>", "rtx", "function_expander", "::", "use_widen_ternop_insn", "(", "insn_code", "icode", ")", "{", "int", "arg_offset", "=", "0", ";", "if", "(", "use_real_mask_p", "(", "pred", ")", ")", "add_input_operand", "(", "arg_offset", "++", ")", ";", "else", "add_all_one_mask_operand", "(", "mask_mode", "(", ")", ")", ";", "for", "(", "int", "argno", "=", "arg_offset", ";", "argno", "<", "call_expr_nargs", "(", "exp", ")", ";", "argno", "++", ")", "add_input_operand", "(", "argno", ")", ";", "add_input_operand", "(", "Pmode", ",", "get_tail_policy_for_pred", "(", "pred", ")", ")", ";", "add_input_operand", "(", "Pmode", ",", "get_mask_policy_for_pred", "(", "pred", ")", ")", ";", "add_input_operand", "(", "Pmode", ",", "get_avl_type_rtx", "(", "avl_type", "::", "NONVLMAX", ")", ")", ";", "return", "generate_insn", "(", "icode", ")", ";", "}", "</s>" ]

[ "Implement", "the", "call", "using", "instruction", "ICODE", ",", "with", "a", "1:1", "mapping", "between", "arguments", "and", "input", "operands", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "MachineBasicBlock", "*", "RISCVTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "case", "RISCV", "::", "Select_GPR_Using_CC_GPR", ":", "case", "RISCV", "::", "Select_FPR32_Using_CC_GPR", ":", "case", "RISCV", "::", "Select_FPR64_Using_CC_GPR", ":", "return", "emitSelectPseudo", "(", "MI", ",", "BB", ")", ";", "case", "RISCV", "::", "BuildPairF64Pseudo", ":", "return", "emitBuildPairF64Pseudo", "(", "MI", ",", "BB", ")", ";", "case", "RISCV", "::", "SplitF64Pseudo", ":", "return", "emitSplitF64Pseudo", "(", "MI", ",", "BB", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "RISCV", "RISCV", "\"Unexpected instr type to insert\"", "RISCV::Select_GPR_Using_CC_GPR", "RISCV::Select_FPR32_Using_CC_GPR", "RISCV::Select_FPR64_Using_CC_GPR", "RISCV::BuildPairF64Pseudo", "RISCV::SplitF64Pseudo" ]

[]

[ "<s>", "static", "int", "rs6000_emit_p9_fp_minmax", "(", "rtx", "dest", ",", "rtx", "op", ",", "rtx", "true_cond", ",", "rtx", "false_cond", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "rtx", "op0", "=", "XEXP", "(", "op", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "op", ",", "1", ")", ";", "machine_mode", "compare_mode", "=", "GET_MODE", "(", "op0", ")", ";", "machine_mode", "result_mode", "=", "GET_MODE", "(", "dest", ")", ";", "bool", "max_p", "=", "false", ";", "if", "(", "result_mode", "!=", "compare_mode", ")", "return", "0", ";", "if", "(", "code", "==", "GE", "||", "code", "==", "GT", ")", "max_p", "=", "true", ";", "else", "if", "(", "code", "==", "LE", "||", "code", "==", "LT", ")", "max_p", "=", "false", ";", "else", "return", "0", ";", "if", "(", "rtx_equal_p", "(", "op0", ",", "true_cond", ")", "&&", "rtx_equal_p", "(", "op1", ",", "false_cond", ")", ")", ";", "else", "if", "(", "rtx_equal_p", "(", "op1", ",", "true_cond", ")", "&&", "rtx_equal_p", "(", "op0", ",", "false_cond", ")", "&&", "!", "HONOR_NANS", "(", "compare_mode", ")", "&&", "!", "HONOR_SIGNED_ZEROS", "(", "compare_mode", ")", ")", "max_p", "=", "!", "max_p", ";", "else", "return", "0", ";", "rs6000_emit_minmax", "(", "dest", ",", "max_p", "?", "SMAX", ":", "SMIN", ",", "op0", ",", "op1", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "ISA", "3.0", "(", "power9", ")", "minmax", "subcase", "to", "emit", "a", "XSMAXCDP", "or", "XSMINCDP", "instruction", "for", "SF/DF", "scalars", ".", "Move", "TRUE_COND", "to", "DEST", "if", "OP", "of", "the", "operands", "of", "the", "last", "comparison", "is", "nonzero/true", ",", "FALSE_COND", "if", "it", "is", "zero/false", ".", "Return", "0", "if", "the", "hardware", "has", "no", "such", "operation", "." ]

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

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI annotate control flow\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"SI annotate control flow\"" ]

[]

[ "<s>", "FastISel", "*", "ARM", "::", "createFastISel", "(", "FunctionLoweringInfo", "&", "funcInfo", ",", "const", "TargetLibraryInfo", "*", "libInfo", ")", "{", "const", "TargetMachine", "&", "TM", "=", "funcInfo", ".", "MF", "->", "getTarget", "(", ")", ";", "const", "ARMSubtarget", "&", "STI", "=", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "funcInfo", ".", "MF", "->", "getSubtarget", "(", ")", ")", ";", "bool", "UseFastISel", "=", "false", ";", "UseFastISel", "|=", "STI", ".", "isTargetMachO", "(", ")", "&&", "!", "STI", ".", "isThumb1Only", "(", ")", ";", "UseFastISel", "|=", "STI", ".", "isTargetLinux", "(", ")", "&&", "!", "STI", ".", "isThumb", "(", ")", ";", "UseFastISel", "|=", "STI", ".", "isTargetNaCl", "(", ")", "&&", "!", "STI", ".", "isThumb", "(", ")", ";", "if", "(", "UseFastISel", ")", "{", "TM", ".", "Options", ".", "NoFramePointerElim", "=", "true", ";", "return", "new", "ARMFastISel", "(", "funcInfo", ",", "libInfo", ")", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "ARM", "ARM::createFastISel", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "rtx", "spu_gen_exp2", "(", "machine_mode", "mode", ",", "rtx", "scale", ")", "{", "gcc_assert", "(", "mode", "==", "V4SFmode", ")", ";", "gcc_assert", "(", "GET_MODE", "(", "scale", ")", "==", "SImode", "||", "GET_CODE", "(", "scale", ")", "==", "CONST_INT", ")", ";", "if", "(", "GET_CODE", "(", "scale", ")", "!=", "CONST_INT", ")", "{", "rtx", "reg", "=", "force_reg", "(", "SImode", ",", "scale", ")", ";", "rtx", "exp", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "mul", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "exp", ",", "reg", ",", "GEN_INT", "(", "127", ")", ")", ")", ";", "emit_insn", "(", "gen_ashlsi3", "(", "exp", ",", "exp", ",", "GEN_INT", "(", "23", ")", ")", ")", ";", "emit_insn", "(", "gen_spu_splats", "(", "mul", ",", "gen_rtx_SUBREG", "(", "GET_MODE_INNER", "(", "mode", ")", ",", "exp", ",", "0", ")", ")", ")", ";", "return", "mul", ";", "}", "else", "{", "HOST_WIDE_INT", "exp", "=", "127", "+", "INTVAL", "(", "scale", ")", ";", "unsigned", "char", "arr", "[", "16", "]", ";", "arr", "[", "0", "]", "=", "arr", "[", "4", "]", "=", "arr", "[", "8", "]", "=", "arr", "[", "12", "]", "=", "exp", ">>", "1", ";", "arr", "[", "1", "]", "=", "arr", "[", "5", "]", "=", "arr", "[", "9", "]", "=", "arr", "[", "13", "]", "=", "exp", "<<", "7", ";", "arr", "[", "2", "]", "=", "arr", "[", "6", "]", "=", "arr", "[", "10", "]", "=", "arr", "[", "14", "]", "=", "0", ";", "arr", "[", "3", "]", "=", "arr", "[", "7", "]", "=", "arr", "[", "11", "]", "=", "arr", "[", "15", "]", "=", "0", ";", "return", "array_to_constant", "(", "mode", ",", "arr", ")", ";", "}", "}", "</s>" ]

[ "Generate", "a", "constant", "or", "register", "which", "contains", "2^SCALE", ".", "We", "assume", "the", "result", "is", "valid", "for", "MODE", ".", "Currently", ",", "MODE", "must", "be", "V4SFmode", "and", "SCALE", "must", "be", "SImode", "." ]

[ "spu", "127", "23", "0", "127", "16", "0", "4", "8", "12", "1", "1", "5", "9", "13", "7", "2", "6", "10", "14", "0", "3", "7", "11", "15", "0" ]

[]

[ "<s>", "SDValue", "AVRTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "auto", "CCFunction", "=", "CCAssignFnForReturn", "(", "CallConv", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "CCFunction", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "unsigned", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "if", "(", "e", ">", "1", ")", "{", "std", "::", "reverse", "(", "RVLocs", ".", "begin", "(", ")", ",", "RVLocs", ".", "end", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "e", ";", "++", "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", "(", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeList", "::", "FunctionIndex", ",", "Attribute", "::", "Naked", ")", ")", "{", "return", "Chain", ";", "}", "unsigned", "RetOpc", "=", "(", "CallConv", "==", "CallingConv", "::", "AVR_INTR", "||", "CallConv", "==", "CallingConv", "::", "AVR_SIGNAL", ")", "?", "AVRISD", "::", "RETI_FLAG", ":", "AVRISD", "::", "RET_FLAG", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "{", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "RetOpc", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "ISD::OutputArg", "16", "1", "4", "1", "0", "\"Can only return in registers!\"", "1", "AVR", "AVR", "AVRISD::RETI_FLAG", "AVRISD::RET_FLAG", "0", "MVT::Other" ]

[]

[ "<s>", "SDNode", "*", "SITargetLowering", "::", "PostISelFolding", "(", "MachineSDNode", "*", "Node", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "unsigned", "Opcode", "=", "Node", "->", "getMachineOpcode", "(", ")", ";", "if", "(", "TII", "->", "isMIMG", "(", "Opcode", ")", "&&", "!", "TII", "->", "get", "(", "Opcode", ")", ".", "mayStore", "(", ")", "&&", "!", "TII", "->", "isGather4", "(", "Opcode", ")", "&&", "!", "TII", "->", "isD16", "(", "Opcode", ")", ")", "{", "return", "adjustWritemask", "(", "Node", ",", "DAG", ")", ";", "}", "if", "(", "Opcode", "==", "AMDGPU", "::", "INSERT_SUBREG", "||", "Opcode", "==", "AMDGPU", "::", "REG_SEQUENCE", ")", "{", "legalizeTargetIndependentNode", "(", "Node", ",", "DAG", ")", ";", "return", "Node", ";", "}", "switch", "(", "Opcode", ")", "{", "case", "AMDGPU", "::", "V_DIV_SCALE_F32", ":", "case", "AMDGPU", "::", "V_DIV_SCALE_F64", ":", "{", "SDValue", "Src0", "=", "Node", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Src1", "=", "Node", "->", "getOperand", "(", "1", ")", ";", "SDValue", "Src2", "=", "Node", "->", "getOperand", "(", "2", ")", ";", "if", "(", "(", "Src0", ".", "isMachineOpcode", "(", ")", "&&", "Src0", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "&&", "(", "Src0", "==", "Src1", "||", "Src0", "==", "Src2", ")", ")", "break", ";", "MVT", "VT", "=", "Src0", ".", "getValueType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "getRegClassFor", "(", "VT", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ";", "SDValue", "UndefReg", "=", "DAG", ".", "getRegister", "(", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ",", "VT", ")", ";", "SDValue", "ImpDef", "=", "DAG", ".", "getCopyToReg", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "SDLoc", "(", "Node", ")", ",", "UndefReg", ",", "Src0", ",", "SDValue", "(", ")", ")", ";", "if", "(", "Src0", ".", "isMachineOpcode", "(", ")", "&&", "Src0", ".", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", ")", "{", "if", "(", "Src1", ".", "isMachineOpcode", "(", ")", "&&", "Src1", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "Src0", "=", "Src1", ";", "else", "if", "(", "Src2", ".", "isMachineOpcode", "(", ")", "&&", "Src2", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "Src0", "=", "Src2", ";", "else", "{", "assert", "(", "Src1", ".", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", ")", ";", "Src0", "=", "UndefReg", ";", "Src1", "=", "UndefReg", ";", "}", "}", "else", "break", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "Ops", "=", "{", "Src0", ",", "Src1", ",", "Src2", "}", ";", "for", "(", "unsigned", "I", "=", "3", ",", "N", "=", "Node", "->", "getNumOperands", "(", ")", ";", "I", "!=", "N", ";", "++", "I", ")", "Ops", ".", "push_back", "(", "Node", "->", "getOperand", "(", "I", ")", ")", ";", "Ops", ".", "push_back", "(", "ImpDef", ".", "getValue", "(", "1", ")", ")", ";", "return", "DAG", ".", "getMachineNode", "(", "Opcode", ",", "SDLoc", "(", "Node", ")", ",", "Node", "->", "getVTList", "(", ")", ",", "Ops", ")", ";", "}", "default", ":", "break", ";", "}", "return", "Node", ";", "}", "</s>" ]

[ "Fold", "the", "instructions", "after", "selecting", "them", "." ]

[ "AMDGPU", "SI", "SI", "AMDGPU::INSERT_SUBREG", "AMDGPU::REG_SEQUENCE", "AMDGPU::V_DIV_SCALE_F32", "AMDGPU::V_DIV_SCALE_F64", "0", "1", "2", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "4", "3", "1" ]

[]

[ "<s>", "SDValue", "VECustomDAG", "::", "getUnpack", "(", "EVT", "DestVT", ",", "SDValue", "Vec", ",", "PackElem", "Part", ",", "SDValue", "AVL", ")", "const", "{", "assert", "(", "getAnnotatedNodeAVL", "(", "AVL", ")", ".", "second", "&&", "\"Expected a pack-legalized AVL\"", ")", ";", "unsigned", "OC", "=", "(", "Part", "==", "PackElem", "::", "Lo", ")", "?", "VEISD", "::", "VEC_UNPACK_LO", ":", "VEISD", "::", "VEC_UNPACK_HI", ";", "return", "DAG", ".", "getNode", "(", "OC", ",", "DL", ",", "DestVT", ",", "Vec", ",", "AVL", ")", ";", "}", "</s>" ]

[ "}", "Legalizing", "getNode" ]

[ "VE", "VECustomDAG::getUnpack", "\"Expected a pack-legalized AVL\"", "VEISD::VEC_UNPACK_LO", "VEISD::VEC_UNPACK_HI" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "LowerFormalArguments_64SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "else", "return", "LowerFormalArguments_32SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "else", "{", "return", "LowerFormalArguments_Darwin", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "PowerPC", "PPC", "ISD::InputArg", "PPC" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "Options", ".", "ThreadModel", "==", "ThreadModel", "::", "Single", ")", "addPass", "(", "createLowerAtomicPass", "(", ")", ")", ";", "else", "addPass", "(", "createAtomicExpandPass", "(", "TM", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createWebAssemblyOptimizeReturned", "(", ")", ")", ";", "if", "(", "EnableEmException", "||", "EnableEmSjLj", ")", "addPass", "(", "createWebAssemblyLowerEmscriptenEHSjLj", "(", "EnableEmException", ",", "EnableEmSjLj", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

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

[]

[ "<s>", "bool", "PTXTargetMachine", "::", "addPassesToEmitFile", "(", "PassManagerBase", "&", "PM", ",", "formatted_raw_ostream", "&", "Out", ",", "CodeGenFileType", "FileType", ",", "bool", "DisableVerify", ")", "{", "MCContext", "*", "Context", "=", "0", ";", "if", "(", "addCommonCodeGenPasses", "(", "PM", ",", "DisableVerify", ",", "Context", ")", ")", "return", "true", ";", "assert", "(", "Context", "!=", "0", "&&", "\"Failed to get MCContext\"", ")", ";", "if", "(", "hasMCSaveTempLabels", "(", ")", ")", "Context", "->", "setAllowTemporaryLabels", "(", "false", ")", ";", "const", "MCAsmInfo", "&", "MAI", "=", "*", "getMCAsmInfo", "(", ")", ";", "const", "MCSubtargetInfo", "&", "STI", "=", "getSubtarget", "<", "MCSubtargetInfo", ">", "(", ")", ";", "OwningPtr", "<", "MCStreamer", ">", "AsmStreamer", ";", "switch", "(", "FileType", ")", "{", "case", "CGFT_AssemblyFile", ":", "{", "MCInstPrinter", "*", "InstPrinter", "=", "getTarget", "(", ")", ".", "createMCInstPrinter", "(", "MAI", ".", "getAssemblerDialect", "(", ")", ",", "MAI", ",", "STI", ")", ";", "MCCodeEmitter", "*", "MCE", "=", "0", ";", "MCAsmBackend", "*", "MAB", "=", "0", ";", "MCStreamer", "*", "S", "=", "getTarget", "(", ")", ".", "createAsmStreamer", "(", "*", "Context", ",", "Out", ",", "true", ",", "hasMCUseLoc", "(", ")", ",", "hasMCUseCFI", "(", ")", ",", "hasMCUseDwarfDirectory", "(", ")", ",", "InstPrinter", ",", "MCE", ",", "MAB", ",", "false", ")", ";", "AsmStreamer", ".", "reset", "(", "S", ")", ";", "break", ";", "}", "case", "CGFT_ObjectFile", ":", "{", "llvm_unreachable", "(", "\"Object file emission is not supported with PTX\"", ")", ";", "}", "case", "CGFT_Null", ":", "AsmStreamer", ".", "reset", "(", "createNullStreamer", "(", "*", "Context", ")", ")", ";", "break", ";", "}", "FunctionPass", "*", "Printer", "=", "getTarget", "(", ")", ".", "createAsmPrinter", "(", "*", "this", ",", "*", "AsmStreamer", ")", ";", "if", "(", "Printer", "==", "0", ")", "return", "true", ";", "AsmStreamer", ".", "take", "(", ")", ";", "PM", ".", "add", "(", "Printer", ")", ";", "PM", ".", "add", "(", "createGCInfoDeleter", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Add", "passes", "to", "the", "specified", "pass", "manager", "to", "get", "the", "specified", "file", "emitted", "." ]

[ "PTX", "PTX", "0", "0", "\"Failed to get MCContext\"", "0", "0", "\"Object file emission is not supported with PTX\"", "0" ]

[]

[ "<s>", "SDValue", "JVMTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "!", "CallingConvSupported", "(", "CallConv", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"JVM doesn't support non-C calling conventions\"", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "JVMFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "JVMFunctionInfo", ">", "(", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveIn", "(", "JVM", "::", "ARGUMENTS", ")", ";", "for", "(", "const", "ISD", "::", "InputArg", "&", "In", ":", "Ins", ")", "{", "if", "(", "In", ".", "Flags", ".", "isInAlloca", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"JVM hasn't implemented inalloca arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isNest", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"JVM hasn't implemented nest arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isInConsecutiveRegs", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"JVM hasn't implemented cons regs arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isInConsecutiveRegsLast", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"JVM hasn't implemented cons regs last arguments\"", ")", ";", "SDValue", "Arg", ";", "if", "(", "In", ".", "Used", ")", "{", "bool", "IsCompositeArg", "=", "In", ".", "Flags", ".", "isByVal", "(", ")", ";", "EVT", "ArgTy", "=", "IsCompositeArg", "?", "MVT", "::", "i32", ":", "In", ".", "VT", ";", "Arg", "=", "DAG", ".", "getNode", "(", "JVMISD", "::", "ARGUMENT", ",", "DL", ",", "ArgTy", ",", "DAG", ".", "getTargetConstant", "(", "InVals", ".", "size", "(", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "SDNodeFlags", "Flags", "=", "Arg", ".", "getNode", "(", ")", "->", "getFlags", "(", ")", ";", "Flags", ".", "setIsComposite", "(", "IsCompositeArg", ")", ";", "Arg", ".", "getNode", "(", ")", "->", "setFlags", "(", "Flags", ")", ";", "}", "else", "{", "Arg", "=", "DAG", ".", "getUNDEF", "(", "In", ".", "VT", ")", ";", "}", "InVals", ".", "push_back", "(", "Arg", ")", ";", "MFI", "->", "incrimentArgumentCount", "(", ")", ";", "}", "if", "(", "IsVarArg", ")", "llvm_unreachable", "(", "\"Unsupported variable arguments.\"", ")", ";", "return", "Chain", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "JVM", "JVM", "ISD::InputArg", "\"JVM doesn't support non-C calling conventions\"", "JVM", "JVM", "JVM::ARGUMENTS", "ISD::InputArg", "\"JVM hasn't implemented inalloca arguments\"", "\"JVM hasn't implemented nest arguments\"", "\"JVM hasn't implemented cons regs arguments\"", "\"JVM hasn't implemented cons regs last arguments\"", "MVT::i32", "JVMISD::ARGUMENT", "MVT::i32", "\"Unsupported variable arguments.\"" ]

[]

[ "<s>", "void", "XtensaInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "std", "::", "cout", "<<", "\"XtensaInstrInfo::copyPhysReg not yet implemented\"", "<<", "std", "::", "endl", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "\"XtensaInstrInfo::copyPhysReg not yet implemented\"" ]

[]

[ "<s>", "static", "bool", "nios2_symbol_binds_local_p", "(", "const_rtx", "x", ")", "{", "return", "(", "SYMBOL_REF_DECL", "(", "x", ")", "?", "targetm", ".", "binds_local_p", "(", "SYMBOL_REF_DECL", "(", "x", ")", ")", ":", "SYMBOL_REF_LOCAL_P", "(", "x", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "SYMBOL_REF", "X", "binds", "locally", "." ]

[ "nios2" ]

[]

[ "<s>", "static", "void", "mips_sim_wait_regs_1", "(", "rtx", "*", "x", ",", "void", "*", "data", ")", "{", "subrtx_var_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX_VAR", "(", "iter", ",", "array", ",", "*", "x", ",", "NONCONST", ")", "if", "(", "REG_P", "(", "*", "iter", ")", ")", "mips_sim_wait_reg", "(", "(", "struct", "mips_sim", "*", ")", "data", ",", "mips_sim_insn", ",", "*", "iter", ")", ";", "}", "</s>" ]

[ "Call", "mips_sim_wait_regs_2", "(", "R", ",", "DATA", ")", "for", "each", "register", "R", "mentioned", "in", "*", "X", "." ]

[ "mips" ]

[]

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

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

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

[]

[ "<s>", "static", "void", "expand_block_move_1", "(", "rtx", "dst_reg", ",", "rtx", "src_reg", ",", "rtx", "bytes_rtx", ")", "{", "emit_library_call", "(", "byt_memcpy_libfunc", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "dst_reg", ",", "Pmode", ",", "src_reg", ",", "Pmode", ",", "convert_to_mode", "(", "TYPE_MODE", "(", "sizetype", ")", ",", "bytes_rtx", ",", "TYPE_UNSIGNED", "(", "sizetype", ")", ")", ",", "TYPE_MODE", "(", "sizetype", ")", ")", ";", "}", "</s>" ]

[ "Generate", "a", "call", "to", "a", "library", "function", "to", "move", "BYTES_RTX", "bytes", "from", "address", "SRC_REG", "to", "address", "DST_REG", "in", "1-byte", "chunks", "." ]

[ "visium" ]

[]

[ "<s>", "void", "rs6000_xcoff_declare_function_name", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ",", "tree", "decl", ")", "{", "char", "*", "buffer", "=", "(", "char", "*", ")", "alloca", "(", "strlen", "(", "name", ")", "+", "1", ")", ";", "char", "*", "p", ";", "int", "dollar_inside", "=", "0", ";", "struct", "declare_alias_data", "data", "=", "{", "file", ",", "false", "}", ";", "strcpy", "(", "buffer", ",", "name", ")", ";", "p", "=", "strchr", "(", "buffer", ",", "'$'", ")", ";", "while", "(", "p", ")", "{", "*", "p", "=", "'_'", ";", "dollar_inside", "++", ";", "p", "=", "strchr", "(", "p", "+", "1", ",", "'$'", ")", ";", "}", "if", "(", "TREE_PUBLIC", "(", "decl", ")", ")", "{", "if", "(", "!", "RS6000_WEAK", "||", "!", "DECL_WEAK", "(", "decl", ")", ")", "{", "if", "(", "dollar_inside", ")", "{", "fprintf", "(", "file", ",", "\"\\t.rename .%s,\\\".%s\\\"\\n\"", ",", "buffer", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\t.rename %s,\\\"%s\\\"\\n\"", ",", "buffer", ",", "name", ")", ";", "}", "fputs", "(", "\"\\t.globl .\"", ",", "file", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "buffer", ")", ";", "putc", "(", "'\\n'", ",", "file", ")", ";", "}", "}", "else", "{", "if", "(", "dollar_inside", ")", "{", "fprintf", "(", "file", ",", "\"\\t.rename .%s,\\\".%s\\\"\\n\"", ",", "buffer", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\t.rename %s,\\\"%s\\\"\\n\"", ",", "buffer", ",", "name", ")", ";", "}", "fputs", "(", "\"\\t.lglobl .\"", ",", "file", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "buffer", ")", ";", "putc", "(", "'\\n'", ",", "file", ")", ";", "}", "fputs", "(", "\"\\t.csect \"", ",", "file", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "buffer", ")", ";", "fputs", "(", "TARGET_32BIT", "?", "\"[DS]\\n\"", ":", "\"[DS],3\\n\"", ",", "file", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "buffer", ")", ";", "fputs", "(", "\":\\n\"", ",", "file", ")", ";", "symtab_node", "::", "get", "(", "decl", ")", "->", "call_for_symbol_and_aliases", "(", "rs6000_declare_alias", ",", "&", "data", ",", "true", ")", ";", "fputs", "(", "TARGET_32BIT", "?", "\"\\t.long .\"", ":", "\"\\t.llong .\"", ",", "file", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "buffer", ")", ";", "fputs", "(", "\", TOC[tc0], 0\\n\"", ",", "file", ")", ";", "in_section", "=", "NULL", ";", "switch_to_section", "(", "function_section", "(", "decl", ")", ")", ";", "putc", "(", "'.'", ",", "file", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "buffer", ")", ";", "fputs", "(", "\":\\n\"", ",", "file", ")", ";", "data", ".", "function_descriptor", "=", "true", ";", "symtab_node", "::", "get", "(", "decl", ")", "->", "call_for_symbol_and_aliases", "(", "rs6000_declare_alias", ",", "&", "data", ",", "true", ")", ";", "if", "(", "write_symbols", "!=", "NO_DEBUG", "&&", "!", "DECL_IGNORED_P", "(", "decl", ")", ")", "xcoffout_declare_function", "(", "file", ",", "decl", ",", "buffer", ")", ";", "return", ";", "}", "</s>" ]

[ "This", "macro", "produces", "the", "initial", "definition", "of", "a", "function", "name", ".", "On", "the", "RS/6000", ",", "we", "need", "to", "place", "an", "extra", "'", ".", "'", "in", "the", "function", "name", "and", "output", "the", "function", "descriptor", ".", "Dollar", "signs", "are", "converted", "to", "underscores", ".", "The", "csect", "for", "the", "function", "will", "have", "already", "been", "created", "when", "text_section", "was", "selected", ".", "We", "do", "have", "to", "go", "back", "to", "that", "csect", ",", "however", ".", "The", "third", "and", "fourth", "parameters", "to", "the", ".function", "pseudo-op", "(", "16", "and", "044", ")", "are", "placeholders", "which", "no", "longer", "have", "any", "use", ".", "Because", "AIX", "assembler", "'s", ".set", "command", "has", "unexpected", "semantics", ",", "we", "output", "all", "aliases", "as", "alternative", "labels", "in", "front", "of", "the", "definition", "." ]

[ "rs6000", "1", "0", "1", "\"\\t.rename .%s,\\\".%s\\\"\\n\"", "\"\\t.rename %s,\\\"%s\\\"\\n\"", "\"\\t.globl .\"", "\"\\t.rename .%s,\\\".%s\\\"\\n\"", "\"\\t.rename %s,\\\"%s\\\"\\n\"", "\"\\t.lglobl .\"", "\"\\t.csect \"", "\"[DS]\\n\"", "\"[DS],3\\n\"", "\":\\n\"", "\"\\t.long .\"", "\"\\t.llong .\"", "\", TOC[tc0], 0\\n\"", "\":\\n\"" ]

[]

[ "<s>", "Register", "SparcTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "Register", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"i0\"", ",", "SP", "::", "I0", ")", ".", "Case", "(", "\"i1\"", ",", "SP", "::", "I1", ")", ".", "Case", "(", "\"i2\"", ",", "SP", "::", "I2", ")", ".", "Case", "(", "\"i3\"", ",", "SP", "::", "I3", ")", ".", "Case", "(", "\"i4\"", ",", "SP", "::", "I4", ")", ".", "Case", "(", "\"i5\"", ",", "SP", "::", "I5", ")", ".", "Case", "(", "\"i6\"", ",", "SP", "::", "I6", ")", ".", "Case", "(", "\"i7\"", ",", "SP", "::", "I7", ")", ".", "Case", "(", "\"o0\"", ",", "SP", "::", "O0", ")", ".", "Case", "(", "\"o1\"", ",", "SP", "::", "O1", ")", ".", "Case", "(", "\"o2\"", ",", "SP", "::", "O2", ")", ".", "Case", "(", "\"o3\"", ",", "SP", "::", "O3", ")", ".", "Case", "(", "\"o4\"", ",", "SP", "::", "O4", ")", ".", "Case", "(", "\"o5\"", ",", "SP", "::", "O5", ")", ".", "Case", "(", "\"o6\"", ",", "SP", "::", "O6", ")", ".", "Case", "(", "\"o7\"", ",", "SP", "::", "O7", ")", ".", "Case", "(", "\"l0\"", ",", "SP", "::", "L0", ")", ".", "Case", "(", "\"l1\"", ",", "SP", "::", "L1", ")", ".", "Case", "(", "\"l2\"", ",", "SP", "::", "L2", ")", ".", "Case", "(", "\"l3\"", ",", "SP", "::", "L3", ")", ".", "Case", "(", "\"l4\"", ",", "SP", "::", "L4", ")", ".", "Case", "(", "\"l5\"", ",", "SP", "::", "L5", ")", ".", "Case", "(", "\"l6\"", ",", "SP", "::", "L6", ")", ".", "Case", "(", "\"l7\"", ",", "SP", "::", "L7", ")", ".", "Case", "(", "\"g0\"", ",", "SP", "::", "G0", ")", ".", "Case", "(", "\"g1\"", ",", "SP", "::", "G1", ")", ".", "Case", "(", "\"g2\"", ",", "SP", "::", "G2", ")", ".", "Case", "(", "\"g3\"", ",", "SP", "::", "G3", ")", ".", "Case", "(", "\"g4\"", ",", "SP", "::", "G4", ")", ".", "Case", "(", "\"g5\"", ",", "SP", "::", "G5", ")", ".", "Case", "(", "\"g6\"", ",", "SP", "::", "G6", ")", ".", "Case", "(", "\"g7\"", ",", "SP", "::", "G7", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "Sparc", "Sparc", "\"i0\"", "SP::I0", "\"i1\"", "SP::I1", "\"i2\"", "SP::I2", "\"i3\"", "SP::I3", "\"i4\"", "SP::I4", "\"i5\"", "SP::I5", "\"i6\"", "SP::I6", "\"i7\"", "SP::I7", "\"o0\"", "SP::O0", "\"o1\"", "SP::O1", "\"o2\"", "SP::O2", "\"o3\"", "SP::O3", "\"o4\"", "SP::O4", "\"o5\"", "SP::O5", "\"o6\"", "SP::O6", "\"o7\"", "SP::O7", "\"l0\"", "SP::L0", "\"l1\"", "SP::L1", "\"l2\"", "SP::L2", "\"l3\"", "SP::L3", "\"l4\"", "SP::L4", "\"l5\"", "SP::L5", "\"l6\"", "SP::L6", "\"l7\"", "SP::L7", "\"g0\"", "SP::G0", "\"g1\"", "SP::G1", "\"g2\"", "SP::G2", "\"g3\"", "SP::G3", "\"g4\"", "SP::G4", "\"g5\"", "SP::G5", "\"g6\"", "SP::G6", "\"g7\"", "SP::G7", "0", "\"Invalid register name global variable\"" ]

[]

[ "<s>", "bool", "loongarch_symbolic_constant_p", "(", "rtx", "x", ",", "enum", "loongarch_symbol_type", "*", "symbol_type", ")", "{", "rtx", "offset", ";", "split_const", "(", "x", ",", "&", "x", ",", "&", "offset", ")", ";", "if", "(", "UNSPEC_ADDRESS_P", "(", "x", ")", ")", "{", "*", "symbol_type", "=", "UNSPEC_ADDRESS_TYPE", "(", "x", ")", ";", "x", "=", "UNSPEC_ADDRESS", "(", "x", ")", ";", "}", "else", "if", "(", "SYMBOL_REF_P", "(", "x", ")", "||", "LABEL_REF_P", "(", "x", ")", ")", "{", "*", "symbol_type", "=", "loongarch_classify_symbol", "(", "x", ")", ";", "if", "(", "*", "symbol_type", "==", "SYMBOL_TLS", ")", "return", "true", ";", "}", "else", "return", "false", ";", "if", "(", "offset", "==", "const0_rtx", ")", "return", "true", ";", "switch", "(", "*", "symbol_type", ")", "{", "case", "SYMBOL_TLS_IE", ":", "case", "SYMBOL_TLS_LE", ":", "case", "SYMBOL_TLSGD", ":", "case", "SYMBOL_TLSLDM", ":", "case", "SYMBOL_PCREL", ":", "case", "SYMBOL_PCREL64", ":", "return", "sext_hwi", "(", "INTVAL", "(", "offset", ")", ",", "32", ")", "==", "INTVAL", "(", "offset", ")", ";", "case", "SYMBOL_GOT_DISP", ":", "case", "SYMBOL_TLS", ":", "return", "false", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "symbolic", "constant", ".", "If", "it", "is", ",", "store", "the", "type", "of", "the", "symbol", "in", "*", "SYMBOL_TYPE", "." ]

[ "loongarch", "32" ]

[]

[ "<s>", "static", "bool", "ix86_can_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "reg_class_t", "regclass", ")", "{", "if", "(", "from", "==", "to", ")", "return", "true", ";", "if", "(", "MAYBE_FLOAT_CLASS_P", "(", "regclass", ")", ")", "return", "false", ";", "if", "(", "MAYBE_SSE_CLASS_P", "(", "regclass", ")", "||", "MAYBE_MMX_CLASS_P", "(", "regclass", ")", ")", "{", "int", "mov_size", "=", "MAYBE_SSE_CLASS_P", "(", "regclass", ")", "&&", "TARGET_SSE2", "?", "2", ":", "4", ";", "if", "(", "GET_MODE_SIZE", "(", "from", ")", "<", "mov_size", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_CHANGE_MODE_CLASS", "." ]

[ "i386", "2", "4" ]

[]

[ "<s>", "int", "R600FrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "R600RegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "<", "R600Subtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "FrameReg", "=", "RI", "->", "getFrameRegister", "(", "MF", ")", ";", "unsigned", "OffsetBytes", "=", "2", "*", "(", "getStackWidth", "(", "MF", ")", "*", "4", ")", ";", "int", "UpperBound", "=", "FI", "==", "-", "1", "?", "MFI", ".", "getNumObjects", "(", ")", ":", "FI", ";", "for", "(", "int", "i", "=", "MFI", ".", "getObjectIndexBegin", "(", ")", ";", "i", "<", "UpperBound", ";", "++", "i", ")", "{", "OffsetBytes", "=", "alignTo", "(", "OffsetBytes", ",", "MFI", ".", "getObjectAlign", "(", "i", ")", ")", ";", "OffsetBytes", "+=", "MFI", ".", "getObjectSize", "(", "i", ")", ";", "OffsetBytes", "=", "alignTo", "(", "OffsetBytes", ",", "Align", "(", "4", ")", ")", ";", "}", "if", "(", "FI", "!=", "-", "1", ")", "OffsetBytes", "=", "alignTo", "(", "OffsetBytes", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "return", "OffsetBytes", "/", "(", "getStackWidth", "(", "MF", ")", "*", "4", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "R600", "R600", "2", "4", "1", "4", "1", "4" ]

[]

[ "<s>", "void", "i386_pe_file_end", "(", "void", ")", "{", "struct", "extern_list", "*", "p", ";", "for", "(", "p", "=", "extern_head", ";", "p", "!=", "NULL", ";", "p", "=", "p", "->", "next", ")", "{", "tree", "decl", ";", "decl", "=", "p", "->", "decl", ";", "if", "(", "!", "TREE_ASM_WRITTEN", "(", "decl", ")", "&&", "TREE_SYMBOL_REFERENCED", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ")", "{", "const", "char", "*", "realsym", "=", "i386_find_on_wrapper_list", "(", "p", "->", "name", ")", ";", "if", "(", "realsym", ")", "i386_pe_declare_function_type", "(", "asm_out_file", ",", "concat", "(", "\"__real_\"", ",", "realsym", ",", "NULL", ")", ",", "TREE_PUBLIC", "(", "decl", ")", ")", ";", "TREE_ASM_WRITTEN", "(", "decl", ")", "=", "1", ";", "i386_pe_declare_function_type", "(", "asm_out_file", ",", "p", "->", "name", ",", "TREE_PUBLIC", "(", "decl", ")", ")", ";", "}", "}", "if", "(", "export_head", ")", "{", "struct", "export_list", "*", "q", ";", "drectve_section", "(", ")", ";", "for", "(", "q", "=", "export_head", ";", "q", "!=", "NULL", ";", "q", "=", "q", "->", "next", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t.ascii \\\" -export:\\\\\\\"%s\\\\\\\"%s\\\"\\n\"", ",", "default_strip_name_encoding", "(", "q", "->", "name", ")", ",", "(", "q", "->", "is_data", "?", "\",data\"", ":", "\"\"", ")", ")", ";", "}", "}", "if", "(", "stub_head", ")", "{", "struct", "stub_list", "*", "q", ";", "for", "(", "q", "=", "stub_head", ";", "q", "!=", "NULL", ";", "q", "=", "q", "->", "next", ")", "{", "const", "char", "*", "name", "=", "q", "->", "name", ";", "const", "char", "*", "oname", ";", "if", "(", "name", "[", "0", "]", "==", "'*'", ")", "++", "name", ";", "oname", "=", "name", ";", "if", "(", "name", "[", "0", "]", "==", "'.'", ")", "++", "name", ";", "if", "(", "!", "startswith", "(", "name", ",", "\"refptr.\"", ")", ")", "continue", ";", "name", "+=", "7", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.section\\t.rdata$%s, \\\"dr\\\"\\n\"", "\"\\t.globl\\t%s\\n\"", "\"\\t.linkonce\\tdiscard\\n\"", ",", "oname", ",", "oname", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"%s:\\n\\t.quad\\t%s\\n\"", ",", "oname", ",", "name", ")", ";", "}", "}", "}", "</s>" ]

[ "This", "is", "called", "at", "the", "end", "of", "assembly", ".", "For", "each", "external", "function", "which", "has", "not", "been", "defined", ",", "we", "output", "a", "declaration", "now", ".", "We", "also", "output", "the", ".drectve", "section", "." ]

[ "i386", "\"__real_\"", "1", "\"\\t.ascii \\\" -export:\\\\\\\"%s\\\\\\\"%s\\\"\\n\"", "\",data\"", "\"\"", "0", "0", "\"refptr.\"", "7", "\"\\t.section\\t.rdata$%s, \\\"dr\\\"\\n\"", "\"\\t.globl\\t%s\\n\"", "\"\\t.linkonce\\tdiscard\\n\"", "\"%s:\\n\\t.quad\\t%s\\n\"" ]

[]

[ "<s>", "bool", "SIRegisterInfo", "::", "needsFrameBaseReg", "(", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "if", "(", "!", "MI", "->", "mayLoadOrStore", "(", ")", ")", "return", "false", ";", "int64_t", "FullOffset", "=", "Offset", "+", "getMUBUFInstrOffset", "(", "MI", ")", ";", "return", "!", "isUInt", "<", "12", ">", "(", "FullOffset", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "'s", "frame", "index", "reference", "would", "be", "better", "served", "by", "a", "base", "register", "other", "than", "FP", "or", "SP", "." ]

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

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "unsigned", "StackAlignOverride", ",", "bool", "is64Bit", ")", ":", "X86GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "X86ProcFamily", "(", "Others", ")", ",", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "X86SSELevel", "(", "NoMMXSSE", ")", ",", "X863DNowLevel", "(", "NoThreeDNow", ")", ",", "HasCMov", "(", "false", ")", ",", "HasX86_64", "(", "false", ")", ",", "HasPOPCNT", "(", "false", ")", ",", "HasSSE4A", "(", "false", ")", ",", "HasAES", "(", "false", ")", ",", "HasPCLMUL", "(", "false", ")", ",", "HasFMA", "(", "false", ")", ",", "HasFMA4", "(", "false", ")", ",", "HasXOP", "(", "false", ")", ",", "HasMOVBE", "(", "false", ")", ",", "HasRDRAND", "(", "false", ")", ",", "HasF16C", "(", "false", ")", ",", "HasFSGSBase", "(", "false", ")", ",", "HasLZCNT", "(", "false", ")", ",", "HasBMI", "(", "false", ")", ",", "HasBMI2", "(", "false", ")", ",", "HasRTM", "(", "false", ")", ",", "IsBTMemSlow", "(", "false", ")", ",", "IsUAMemFast", "(", "false", ")", ",", "HasVectorUAMem", "(", "false", ")", ",", "HasCmpxchg16b", "(", "false", ")", ",", "UseLeaForSP", "(", "false", ")", ",", "HasSlowDivide", "(", "false", ")", ",", "PostRAScheduler", "(", "false", ")", ",", "stackAlignment", "(", "4", ")", ",", "MaxInlineSizeThreshold", "(", "128", ")", ",", "TargetTriple", "(", "TT", ")", ",", "In64BitMode", "(", "is64Bit", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "!", "FS", ".", "empty", "(", ")", "||", "!", "CPU", ".", "empty", "(", ")", ")", "{", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "{", "||", "defined", "(", "__x86_64__", ")", "||", "defined", "(", "_M_AMD64", ")", "||", "defined", "(", "_M_X64", ")", "CPUName", "=", "sys", "::", "getHostCPUName", "(", ")", ";", "CPUName", "=", "\"generic\"", ";", "}", "std", "::", "string", "FullFS", "=", "FS", ";", "if", "(", "In64BitMode", ")", "{", "if", "(", "!", "FullFS", ".", "empty", "(", ")", ")", "FullFS", "=", "\"+64bit,+sse2,\"", "+", "FullFS", ";", "else", "FullFS", "=", "\"+64bit,+sse2\"", ";", "}", "ParseSubtargetFeatures", "(", "CPUName", ",", "FullFS", ")", ";", "}", "else", "{", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "{", "CPUName", "=", "sys", "::", "getHostCPUName", "(", ")", ";", "CPUName", "=", "\"generic\"", ";", "}", "AutoDetectSubtargetFeatures", "(", ")", ";", "if", "(", "In64BitMode", ")", "{", "HasX86_64", "=", "true", ";", "ToggleFeature", "(", "X86", "::", "Feature64Bit", ")", ";", "HasCMov", "=", "true", ";", "ToggleFeature", "(", "X86", "::", "FeatureCMOV", ")", ";", "if", "(", "X86SSELevel", "<", "SSE2", ")", "{", "X86SSELevel", "=", "SSE2", ";", "ToggleFeature", "(", "X86", "::", "FeatureSSE1", ")", ";", "ToggleFeature", "(", "X86", "::", "FeatureSSE2", ")", ";", "}", "}", "}", "InitMCProcessorInfo", "(", "CPUName", ",", "FS", ")", ";", "if", "(", "X86ProcFamily", "==", "IntelAtom", ")", "PostRAScheduler", "=", "true", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "In64BitMode", ")", "ToggleFeature", "(", "X86", "::", "Mode64Bit", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Subtarget features: SSELevel \"", "<<", "X86SSELevel", "<<", "\", 3DNowLevel \"", "<<", "X863DNowLevel", "<<", "\", 64bit \"", "<<", "HasX86_64", "<<", "\"\\n\"", ")", ";", "assert", "(", "(", "!", "In64BitMode", "||", "HasX86_64", ")", "&&", "\"64-bit code requested on a subtarget that doesn't support it!\"", ")", ";", "if", "(", "StackAlignOverride", ")", "stackAlignment", "=", "StackAlignOverride", ";", "else", "if", "(", "isTargetDarwin", "(", ")", "||", "isTargetLinux", "(", ")", "||", "isTargetSolaris", "(", ")", "||", "In64BitMode", ")", "stackAlignment", "=", "16", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "4", "128", "\"generic\"", "\"+64bit,+sse2,\"", "\"+64bit,+sse2\"", "\"generic\"", "X86", "X86::Feature64Bit", "X86::FeatureCMOV", "X86", "X86", "X86::FeatureSSE1", "X86::FeatureSSE2", "X86", "X86::Mode64Bit", "\"Subtarget features: SSELevel \"", "X86", "\", 3DNowLevel \"", "X86", "\", 64bit \"", "X86", "\"\\n\"", "X86", "\"64-bit code requested on a subtarget that doesn't support it!\"", "16" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOLoad", ",", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "FrameInfo", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "assert", "(", "DestReg", "!=", "AMDGPU", "::", "M0", "&&", "\"m0 should not be reloaded into\"", ")", ";", "assert", "(", "DestReg", "!=", "AMDGPU", "::", "EXEC_LO", "&&", "DestReg", "!=", "AMDGPU", "::", "EXEC_HI", "&&", "DestReg", "!=", "AMDGPU", "::", "EXEC", "&&", "\"exec should not be spilled\"", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillRestoreOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "DestReg", ".", "isVirtual", "(", ")", "&&", "SpillSize", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "DestReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0_XEXECRegClass", ")", ";", "}", "if", "(", "RI", ".", "spillSGPRToVGPR", "(", ")", ")", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "TargetStackID", "::", "SGPRSpill", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "RI", ".", "isVectorSuperClass", "(", "RC", ")", "?", "getAVSpillRestoreOpcode", "(", "SpillSize", ")", ":", "RI", ".", "isAGPRClass", "(", "RC", ")", "?", "getAGPRSpillRestoreOpcode", "(", "SpillSize", ")", ":", "getVGPRSpillRestoreOpcode", "(", "SpillSize", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::M0", "\"m0 should not be reloaded into\"", "AMDGPU::EXEC_LO", "AMDGPU::EXEC_HI", "AMDGPU::EXEC", "\"exec should not be spilled\"", "4", "AMDGPU::SReg_32_XM0_XEXECRegClass", "0" ]

[]

[ "<s>", "bool", "isToken", "(", ")", "const", "override", "{", "return", "Kind", "==", "KindToken", ";", "}", "</s>" ]

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

[ "SystemZ" ]

[]

[ "<s>", "void", "FISCInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "BuildMI", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "get", "(", "FISC", "::", "MOVrr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "FISC", "FISC", "FISC::MOVrr" ]

[]

[ "<s>", "static", "void", "arm_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "if", "(", "optimize", ">", "0", "&&", "TREE_CONSTANT", "(", "decl", ")", ")", "SYMBOL_REF_FLAG", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", "=", "1", ";", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "}", "</s>" ]

[ "Symbols", "in", "the", "text", "segment", "can", "be", "accessed", "without", "indirecting", "via", "the", "constant", "pool", ";", "it", "may", "take", "an", "extra", "binary", "operation", ",", "but", "this", "is", "still", "faster", "than", "indirecting", "via", "memory", ".", "Do", "n't", "do", "this", "when", "not", "optimizing", ",", "since", "we", "wo", "n't", "be", "calculating", "al", "of", "the", "offsets", "necessary", "to", "do", "this", "simplification", "." ]

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

[]

[ "<s>", "uint32_t", "AMDGPUTargetLowering", "::", "getImplicitParameterOffset", "(", "const", "AMDGPUMachineFunction", "*", "MFI", ",", "const", "ImplicitParameter", "Param", ")", "const", "{", "uint64_t", "ArgOffset", "=", "MFI", "->", "getABIArgOffset", "(", ")", ";", "switch", "(", "Param", ")", "{", "case", "GRID_DIM", ":", "return", "ArgOffset", ";", "case", "GRID_OFFSET", ":", "return", "ArgOffset", "+", "4", ";", "}", "llvm_unreachable", "(", "\"unexpected implicit parameter type\"", ")", ";", "}", "</s>" ]

[ "Helper", "function", "that", "returns", "the", "byte", "offset", "of", "the", "given", "type", "of", "implicit", "parameter", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "4", "\"unexpected implicit parameter type\"" ]

[]

[ "<s>", "static", "bool", "expand_vec_perm_vpshufb2_vpermq", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "rtx", "rperm", "[", "2", "]", "[", "32", "]", ",", "vperm", ",", "l", ",", "h", ",", "hp", ",", "op", ",", "m128", ";", "unsigned", "int", "i", ",", "nelt", ",", "eltsz", ";", "if", "(", "!", "TARGET_AVX2", "||", "!", "d", "->", "one_operand_p", "||", "(", "d", "->", "vmode", "!=", "V32QImode", "&&", "d", "->", "vmode", "!=", "V16HImode", ")", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "nelt", "=", "d", "->", "nelt", ";", "eltsz", "=", "GET_MODE_SIZE", "(", "GET_MODE_INNER", "(", "d", "->", "vmode", ")", ")", ";", "m128", "=", "GEN_INT", "(", "-", "128", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "unsigned", "j", ",", "e", "=", "d", "->", "perm", "[", "i", "]", "&", "(", "nelt", "/", "2", "-", "1", ")", ";", "unsigned", "which", "=", "(", "(", "d", "->", "perm", "[", "i", "]", "^", "i", ")", "&", "(", "nelt", "/", "2", ")", ")", "*", "eltsz", ";", "for", "(", "j", "=", "0", ";", "j", "<", "eltsz", ";", "++", "j", ")", "{", "rperm", "[", "!", "!", "which", "]", "[", "(", "i", "*", "eltsz", "+", "j", ")", "^", "which", "]", "=", "GEN_INT", "(", "e", "*", "eltsz", "+", "j", ")", ";", "rperm", "[", "!", "which", "]", "[", "(", "i", "*", "eltsz", "+", "j", ")", "^", "(", "which", "^", "16", ")", "]", "=", "m128", ";", "}", "}", "vperm", "=", "gen_rtx_CONST_VECTOR", "(", "V32QImode", ",", "gen_rtvec_v", "(", "32", ",", "rperm", "[", "1", "]", ")", ")", ";", "vperm", "=", "force_reg", "(", "V32QImode", ",", "vperm", ")", ";", "h", "=", "gen_reg_rtx", "(", "V32QImode", ")", ";", "op", "=", "gen_lowpart", "(", "V32QImode", ",", "d", "->", "op0", ")", ";", "emit_insn", "(", "gen_avx2_pshufbv32qi3", "(", "h", ",", "op", ",", "vperm", ")", ")", ";", "hp", "=", "gen_reg_rtx", "(", "V4DImode", ")", ";", "op", "=", "gen_lowpart", "(", "V4DImode", ",", "h", ")", ";", "emit_insn", "(", "gen_avx2_permv4di_1", "(", "hp", ",", "op", ",", "const2_rtx", ",", "GEN_INT", "(", "3", ")", ",", "const0_rtx", ",", "const1_rtx", ")", ")", ";", "vperm", "=", "gen_rtx_CONST_VECTOR", "(", "V32QImode", ",", "gen_rtvec_v", "(", "32", ",", "rperm", "[", "0", "]", ")", ")", ";", "vperm", "=", "force_reg", "(", "V32QImode", ",", "vperm", ")", ";", "l", "=", "gen_reg_rtx", "(", "V32QImode", ")", ";", "op", "=", "gen_lowpart", "(", "V32QImode", ",", "d", "->", "op0", ")", ";", "emit_insn", "(", "gen_avx2_pshufbv32qi3", "(", "l", ",", "op", ",", "vperm", ")", ")", ";", "op", "=", "d", "->", "target", ";", "if", "(", "d", "->", "vmode", "!=", "V32QImode", ")", "op", "=", "gen_reg_rtx", "(", "V32QImode", ")", ";", "emit_insn", "(", "gen_iorv32qi3", "(", "op", ",", "l", ",", "gen_lowpart", "(", "V32QImode", ",", "hp", ")", ")", ")", ";", "if", "(", "op", "!=", "d", "->", "target", ")", "emit_move_insn", "(", "d", "->", "target", ",", "gen_lowpart", "(", "d", "->", "vmode", ",", "op", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "arbitrary", "permutation", "of", "one", "V32QImode", "and", "V16QImode", "operand", "with", "two", "vpshufb", "insns", ",", "vpermq", "and", "vpor", ".", "We", "should", "have", "already", "failed", "all", "two", "or", "three", "instruction", "sequences", "." ]

[ "i386", "2", "32", "128", "0", "2", "1", "2", "0", "16", "32", "1", "3", "32", "0" ]

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "findUnusedRegister", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "RC", "->", "begin", "(", ")", ",", "E", "=", "RC", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "MRI", ".", "isPhysRegUsed", "(", "*", "I", ")", ")", "return", "*", "I", ";", "}", "return", "AMDGPU", "::", "NoRegister", ";", "}", "</s>" ]

[ "Returns", "a", "lowest", "register", "that", "is", "not", "used", "at", "any", "point", "in", "the", "function", "." ]

[ "AMDGPU", "SI", "AMDGPU::NoRegister" ]

[]

[ "<s>", "const", "uint16_t", "*", "ARMBaseRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "bool", "ghcCall", "=", "false", ";", "if", "(", "MF", ")", "{", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "ghcCall", "=", "(", "F", "?", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ":", "false", ")", ";", "}", "if", "(", "ghcCall", ")", "return", "CSR_GHC_SaveList", ";", "else", "return", "(", "STI", ".", "isTargetIOS", "(", ")", "&&", "!", "STI", ".", "isAAPCS_ABI", "(", ")", ")", "?", "CSR_iOS_SaveList", ":", "CSR_AAPCS_SaveList", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "rtx", "m68k_wrap_symbol_into_got_ref", "(", "rtx", "x", ",", "enum", "m68k_reloc", "reloc", ",", "rtx", "temp_reg", ")", "{", "x", "=", "m68k_wrap_symbol", "(", "x", ",", "reloc", ",", "m68k_get_gp", "(", ")", ",", "temp_reg", ")", ";", "x", "=", "gen_rtx_MEM", "(", "Pmode", ",", "x", ")", ";", "MEM_READONLY_P", "(", "x", ")", "=", "1", ";", "return", "x", ";", "}", "</s>" ]

[ "Does", "the", "same", "as", "m68k_wrap_symbol", ",", "but", "returns", "a", "memory", "reference", "to", "GOT", "slot", "." ]

[ "m68k", "1" ]

[]

[ "<s>", "void", "ix86_function_specific_restore", "(", "struct", "gcc_options", "*", "opts", ",", "struct", "gcc_options", "*", ",", "struct", "cl_target_option", "*", "ptr", ")", "{", "enum", "processor_type", "old_tune", "=", "ix86_tune", ";", "enum", "processor_type", "old_arch", "=", "ix86_arch", ";", "unsigned", "HOST_WIDE_INT", "ix86_arch_mask", ";", "int", "i", ";", "opts", "->", "x_flag_pic", "=", "flag_pic", ";", "ix86_arch", "=", "(", "enum", "processor_type", ")", "ptr", "->", "arch", ";", "ix86_schedule", "=", "(", "enum", "attr_cpu", ")", "ptr", "->", "schedule", ";", "ix86_tune", "=", "(", "enum", "processor_type", ")", "ptr", "->", "tune", ";", "ix86_prefetch_sse", "=", "ptr", "->", "prefetch_sse", ";", "ix86_tune_defaulted", "=", "ptr", "->", "tune_defaulted", ";", "ix86_arch_specified", "=", "ptr", "->", "arch_specified", ";", "opts", "->", "x_ix86_isa_flags_explicit", "=", "ptr", "->", "x_ix86_isa_flags_explicit", ";", "opts", "->", "x_ix86_isa_flags2_explicit", "=", "ptr", "->", "x_ix86_isa_flags2_explicit", ";", "opts", "->", "x_recip_mask_explicit", "=", "ptr", "->", "x_recip_mask_explicit", ";", "opts", "->", "x_ix86_arch_string", "=", "ptr", "->", "x_ix86_arch_string", ";", "opts", "->", "x_ix86_tune_string", "=", "ptr", "->", "x_ix86_tune_string", ";", "opts", "->", "x_ix86_abi", "=", "ptr", "->", "x_ix86_abi", ";", "opts", "->", "x_ix86_asm_dialect", "=", "ptr", "->", "x_ix86_asm_dialect", ";", "opts", "->", "x_ix86_branch_cost", "=", "ptr", "->", "x_ix86_branch_cost", ";", "opts", "->", "x_ix86_dump_tunes", "=", "ptr", "->", "x_ix86_dump_tunes", ";", "opts", "->", "x_ix86_force_align_arg_pointer", "=", "ptr", "->", "x_ix86_force_align_arg_pointer", ";", "opts", "->", "x_ix86_force_drap", "=", "ptr", "->", "x_ix86_force_drap", ";", "opts", "->", "x_ix86_recip_name", "=", "ptr", "->", "x_ix86_recip_name", ";", "opts", "->", "x_ix86_section_threshold", "=", "ptr", "->", "x_ix86_section_threshold", ";", "opts", "->", "x_ix86_sse2avx", "=", "ptr", "->", "x_ix86_sse2avx", ";", "opts", "->", "x_ix86_stack_protector_guard", "=", "ptr", "->", "x_ix86_stack_protector_guard", ";", "opts", "->", "x_ix86_stringop_alg", "=", "ptr", "->", "x_ix86_stringop_alg", ";", "opts", "->", "x_ix86_tls_dialect", "=", "ptr", "->", "x_ix86_tls_dialect", ";", "opts", "->", "x_ix86_tune_ctrl_string", "=", "ptr", "->", "x_ix86_tune_ctrl_string", ";", "opts", "->", "x_ix86_tune_memcpy_strategy", "=", "ptr", "->", "x_ix86_tune_memcpy_strategy", ";", "opts", "->", "x_ix86_tune_memset_strategy", "=", "ptr", "->", "x_ix86_tune_memset_strategy", ";", "opts", "->", "x_ix86_tune_no_default", "=", "ptr", "->", "x_ix86_tune_no_default", ";", "ix86_tune_cost", "=", "processor_cost_table", "[", "ix86_tune", "]", ";", "if", "(", "opts", "->", "x_optimize_size", ")", "ix86_cost", "=", "&", "ix86_size_cost", ";", "else", "ix86_cost", "=", "ix86_tune_cost", ";", "if", "(", "old_arch", "!=", "ix86_arch", ")", "{", "ix86_arch_mask", "=", "HOST_WIDE_INT_1U", "<<", "ix86_arch", ";", "for", "(", "i", "=", "0", ";", "i", "<", "X86_ARCH_LAST", ";", "++", "i", ")", "ix86_arch_features", "[", "i", "]", "=", "!", "!", "(", "initial_ix86_arch_features", "[", "i", "]", "&", "ix86_arch_mask", ")", ";", "}", "if", "(", "old_tune", "!=", "ix86_tune", ")", "set_ix86_tune_features", "(", "opts", ",", "ix86_tune", ",", "false", ")", ";", "}", "</s>" ]

[ "Restore", "the", "current", "options" ]

[ "i386", "0" ]

[]

[ "<s>", "SDValue", "AAPTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ExternalSymbol", ":", "return", "LowerExternalSymbol", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "}", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "}", "</s>" ]

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

[ "AAP", "AAP", "ISD::GlobalAddress", "ISD::ExternalSymbol", "ISD::BlockAddress", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::VASTART", "ISD::RETURNADDR", "\"unimplemented operand\"" ]

[]

[ "<s>", "const", "uint32_t", "*", "ARMBaseRegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", ")", "const", "{", "return", "(", "STI", ".", "isTargetIOS", "(", ")", "&&", "!", "STI", ".", "isAAPCS_ABI", "(", ")", ")", "?", "CSR_iOS_RegMask", ":", "CSR_AAPCS_RegMask", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "emit_fusion_addis", "(", "rtx", "target", ",", "rtx", "addis_value", ",", "const", "char", "*", "comment", ",", "const", "char", "*", "mode_name", ")", "{", "rtx", "fuse_ops", "[", "10", "]", ";", "char", "insn_template", "[", "80", "]", ";", "const", "char", "*", "addis_str", "=", "NULL", ";", "const", "char", "*", "comment_str", "=", "ASM_COMMENT_START", ";", "if", "(", "*", "comment_str", "==", "' '", ")", "comment_str", "++", ";", "fuse_ops", "[", "0", "]", "=", "target", ";", "if", "(", "satisfies_constraint_L", "(", "addis_value", ")", ")", "{", "fuse_ops", "[", "1", "]", "=", "addis_value", ";", "addis_str", "=", "\"lis %0,%v1\"", ";", "}", "else", "if", "(", "GET_CODE", "(", "addis_value", ")", "==", "PLUS", ")", "{", "rtx", "op0", "=", "XEXP", "(", "addis_value", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "addis_value", ",", "1", ")", ";", "if", "(", "REG_P", "(", "op0", ")", "&&", "CONST_INT_P", "(", "op1", ")", "&&", "satisfies_constraint_L", "(", "op1", ")", ")", "{", "fuse_ops", "[", "1", "]", "=", "op0", ";", "fuse_ops", "[", "2", "]", "=", "op1", ";", "addis_str", "=", "\"addis %0,%1,%v2\"", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "addis_value", ")", "==", "HIGH", ")", "{", "rtx", "value", "=", "XEXP", "(", "addis_value", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "value", ")", "==", "UNSPEC", "&&", "XINT", "(", "value", ",", "1", ")", "==", "UNSPEC_TOCREL", ")", "{", "fuse_ops", "[", "1", "]", "=", "XVECEXP", "(", "value", ",", "0", ",", "0", ")", ";", "fuse_ops", "[", "2", "]", "=", "XVECEXP", "(", "value", ",", "0", ",", "1", ")", ";", "if", "(", "TARGET_ELF", ")", "addis_str", "=", "\"addis %0,%2,%1@toc@ha\"", ";", "else", "if", "(", "TARGET_XCOFF", ")", "addis_str", "=", "\"addis %0,%1@u(%2)\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "value", ")", "==", "PLUS", ")", "{", "rtx", "op0", "=", "XEXP", "(", "value", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "value", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "UNSPEC", "&&", "XINT", "(", "op0", ",", "1", ")", "==", "UNSPEC_TOCREL", "&&", "CONST_INT_P", "(", "op1", ")", ")", "{", "fuse_ops", "[", "1", "]", "=", "XVECEXP", "(", "op0", ",", "0", ",", "0", ")", ";", "fuse_ops", "[", "2", "]", "=", "XVECEXP", "(", "op0", ",", "0", ",", "1", ")", ";", "fuse_ops", "[", "3", "]", "=", "op1", ";", "if", "(", "TARGET_ELF", ")", "addis_str", "=", "\"addis %0,%2,%1+%3@toc@ha\"", ";", "else", "if", "(", "TARGET_XCOFF", ")", "addis_str", "=", "\"addis %0,%1+%3@u(%2)\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "satisfies_constraint_L", "(", "value", ")", ")", "{", "fuse_ops", "[", "1", "]", "=", "value", ";", "addis_str", "=", "\"lis %0,%v1\"", ";", "}", "else", "if", "(", "TARGET_ELF", "&&", "!", "TARGET_POWERPC64", "&&", "CONSTANT_P", "(", "value", ")", ")", "{", "fuse_ops", "[", "1", "]", "=", "value", ";", "addis_str", "=", "\"lis %0,%1@ha\"", ";", "}", "}", "if", "(", "!", "addis_str", ")", "fatal_insn", "(", "\"Could not generate addis value for fusion\"", ",", "addis_value", ")", ";", "sprintf", "(", "insn_template", ",", "\"%s\\t\\t%s %s, type %s\"", ",", "addis_str", ",", "comment_str", ",", "comment", ",", "mode_name", ")", ";", "output_asm_insn", "(", "insn_template", ",", "fuse_ops", ")", ";", "}", "</s>" ]

[ "Emit", "the", "addis", "instruction", "that", "will", "be", "part", "of", "a", "fused", "instruction", "sequence", "." ]

[ "rs6000", "10", "80", "0", "1", "\"lis %0,%v1\"", "0", "1", "1", "2", "\"addis %0,%1,%v2\"", "0", "1", "1", "0", "0", "2", "0", "1", "\"addis %0,%2,%1@toc@ha\"", "\"addis %0,%1@u(%2)\"", "0", "1", "1", "1", "0", "0", "2", "0", "1", "3", "\"addis %0,%2,%1+%3@toc@ha\"", "\"addis %0,%1+%3@u(%2)\"", "1", "\"lis %0,%v1\"", "1", "\"lis %0,%1@ha\"", "\"Could not generate addis value for fusion\"", "\"%s\\t\\t%s %s, type %s\"" ]

[]

[ "<s>", "void", "VLIWMachineScheduler", "::", "schedule", "(", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** MI Converging Scheduling VLIW BB#\"", "<<", "BB", "->", "getNumber", "(", ")", "<<", "\" \"", "<<", "BB", "->", "getName", "(", ")", "<<", "\" in_func \"", "<<", "BB", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\" at loop depth \"", "<<", "MLI", "->", "getLoopDepth", "(", "BB", ")", "<<", "\" \\n\"", ")", ";", "buildDAGWithRegPressure", "(", ")", ";", "postprocessDAG", "(", ")", ";", "SmallVector", "<", "SUnit", "*", ",", "8", ">", "TopRoots", ",", "BotRoots", ";", "findRootsAndBiasEdges", "(", "TopRoots", ",", "BotRoots", ")", ";", "SchedImpl", "->", "initialize", "(", "this", ")", ";", "DEBUG", "(", "unsigned", "maxH", "=", "0", ";", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "if", "(", "SUnits", "[", "su", "]", ".", "getHeight", "(", ")", ">", "maxH", ")", "maxH", "=", "SUnits", "[", "su", "]", ".", "getHeight", "(", ")", ";", "dbgs", "(", ")", "<<", "\"Max Height \"", "<<", "maxH", "<<", "\"\\n\"", ";", ")", ";", "DEBUG", "(", "unsigned", "maxD", "=", "0", ";", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "if", "(", "SUnits", "[", "su", "]", ".", "getDepth", "(", ")", ">", "maxD", ")", "maxD", "=", "SUnits", "[", "su", "]", ".", "getDepth", "(", ")", ";", "dbgs", "(", ")", "<<", "\"Max Depth \"", "<<", "maxD", "<<", "\"\\n\"", ";", ")", ";", "DEBUG", "(", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "SUnits", "[", "su", "]", ".", "dumpAll", "(", "this", ")", ")", ";", "initQueues", "(", "TopRoots", ",", "BotRoots", ")", ";", "bool", "IsTopNode", "=", "false", ";", "while", "(", "true", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"** VLIWMachineScheduler::schedule picking next node\\n\"", ")", ";", "SUnit", "*", "SU", "=", "SchedImpl", "->", "pickNode", "(", "IsTopNode", ")", ";", "if", "(", "!", "SU", ")", "break", ";", "if", "(", "!", "checkSchedLimit", "(", ")", ")", "break", ";", "scheduleMI", "(", "SU", ",", "IsTopNode", ")", ";", "updateQueues", "(", "SU", ",", "IsTopNode", ")", ";", "SchedImpl", "->", "schedNode", "(", "SU", ",", "IsTopNode", ")", ";", "}", "assert", "(", "CurrentTop", "==", "CurrentBottom", "&&", "\"Nonempty unscheduled zone.\"", ")", ";", "placeDebugValues", "(", ")", ";", "}", "</s>" ]

[ "Schedule", "-", "This", "is", "called", "back", "from", "ScheduleDAGInstrs", ":", ":Run", "(", ")", "when", "it", "'s", "time", "to", "do", "some", "work", "." ]

[ "Hexagon", "\"********** MI Converging Scheduling VLIW BB#\"", "\" \"", "\" in_func \"", "\" at loop depth \"", "\" \\n\"", "8", "0", "0", "\"Max Height \"", "\"\\n\"", "0", "0", "\"Max Depth \"", "\"\\n\"", "0", "\"** VLIWMachineScheduler::schedule picking next node\\n\"", "\"Nonempty unscheduled zone.\"" ]

[]

[ "<s>", "static", "void", "mips_prepare_pch_save", "(", "void", ")", "{", "mips_set_compression_mode", "(", "0", ")", ";", "mips16_globals", "=", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_PREPARE_PCH_SAVE", "." ]

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

[]

[ "<s>", "void", "MetadataStreamer", "::", "begin", "(", "const", "Module", "&", "Mod", ")", "{", "emitVersion", "(", ")", ";", "emitPrintf", "(", "Mod", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "void", "HexagonPassConfig", "::", "addPreEmitPass", "(", ")", "{", "bool", "NoOpt", "=", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ";", "if", "(", "!", "NoOpt", ")", "addPass", "(", "createHexagonNewValueJump", "(", ")", ",", "false", ")", ";", "if", "(", "!", "NoOpt", ")", "{", "if", "(", "!", "DisableHardwareLoops", ")", "addPass", "(", "createHexagonFixupHwLoops", "(", ")", ",", "false", ")", ";", "if", "(", "EnableGenMux", ")", "addPass", "(", "createHexagonGenMux", "(", ")", ",", "false", ")", ";", "addPass", "(", "createHexagonPacketizer", "(", ")", ",", "false", ")", ";", "}", "addPass", "(", "createHexagonCallFrameInformation", "(", ")", ",", "false", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "MipsSEFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "EntryBlock", "=", "&", "MF", "->", "front", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "bool", "IsRAAndRetAddrIsTaken", "=", "(", "Reg", "==", "Mips", "::", "RA", "||", "Reg", "==", "Mips", "::", "RA_64", ")", "&&", "MF", "->", "getFrameInfo", "(", ")", "->", "isReturnAddressTaken", "(", ")", ";", "if", "(", "!", "IsRAAndRetAddrIsTaken", ")", "EntryBlock", "->", "addLiveIn", "(", "Reg", ")", ";", "bool", "IsLOHI", "=", "(", "Reg", "==", "Mips", "::", "LO0", "||", "Reg", "==", "Mips", "::", "LO0_64", "||", "Reg", "==", "Mips", "::", "HI0", "||", "Reg", "==", "Mips", "::", "HI0_64", ")", ";", "const", "Function", "*", "Func", "=", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", ";", "if", "(", "IsLOHI", "&&", "Func", "->", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Op", "=", "0", ";", "if", "(", "!", "STI", ".", "getABI", "(", ")", ".", "ArePtrs64bit", "(", ")", ")", "{", "Op", "=", "(", "Reg", "==", "Mips", "::", "HI0", ")", "?", "Mips", "::", "MFHI", ":", "Mips", "::", "MFLO", ";", "Reg", "=", "Mips", "::", "K0", ";", "}", "else", "{", "Op", "=", "(", "Reg", "==", "Mips", "::", "HI0", ")", "?", "Mips", "::", "MFHI64", ":", "Mips", "::", "MFLO64", ";", "Reg", "=", "Mips", "::", "K0_64", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Op", ")", ",", "Mips", "::", "K0", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "bool", "IsKill", "=", "!", "IsRAAndRetAddrIsTaken", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "*", "EntryBlock", ",", "MI", ",", "Reg", ",", "IsKill", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "Mips::RA", "Mips::RA_64", "Mips::LO0", "Mips::LO0_64", "Mips::HI0", "Mips::HI0_64", "\"interrupt\"", "0", "Mips::HI0", "Mips::MFHI", "Mips::MFLO", "Mips::K0", "Mips::HI0", "Mips::MFHI64", "Mips::MFLO64", "Mips::K0_64", "Mips::K0" ]

[]

[ "<s>", "static", "bool", "rs6000_debug_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "reg_ok_strict", ")", "{", "bool", "ret", "=", "rs6000_legitimate_address_p", "(", "mode", ",", "x", ",", "reg_ok_strict", ")", ";", "fprintf", "(", "stderr", ",", "\"\\nrs6000_legitimate_address_p: return = %s, mode = %s, \"", "\"strict = %d, reload = %s, code = %s\\n\"", ",", "ret", "?", "\"true\"", ":", "\"false\"", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "reg_ok_strict", ",", "(", "reload_completed", "?", "\"after\"", ":", "(", "reload_in_progress", "?", "\"progress\"", ":", "\"before\"", ")", ")", ",", "GET_RTX_NAME", "(", "GET_CODE", "(", "x", ")", ")", ")", ";", "debug_rtx", "(", "x", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Debug", "version", "of", "rs6000_legitimate_address_p", "." ]

[ "powerpcspe", "\"\\nrs6000_legitimate_address_p: return = %s, mode = %s, \"", "\"strict = %d, reload = %s, code = %s\\n\"", "\"true\"", "\"false\"", "\"after\"", "\"progress\"", "\"before\"" ]

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "AttributeMask", "AttrMask", ";", "for", "(", "Attribute", "::", "AttrKind", "I", "=", "Attribute", "::", "None", ";", "I", "!=", "Attribute", "::", "EndAttrKinds", ";", "I", "=", "Attribute", "::", "AttrKind", "(", "I", "+", "1", ")", ")", "{", "if", "(", "!", "isValidForDXIL", "(", "I", ")", ")", "AttrMask", ".", "addAttribute", "(", "I", ")", ";", "}", "for", "(", "auto", "&", "F", ":", "M", ".", "functions", "(", ")", ")", "{", "F", ".", "removeFnAttrs", "(", "AttrMask", ")", ";", "F", ".", "removeRetAttrs", "(", "AttrMask", ")", ";", "for", "(", "size_t", "Idx", "=", "0", ";", "Idx", "<", "F", ".", "arg_size", "(", ")", ";", "++", "Idx", ")", "F", ".", "removeParamAttrs", "(", "Idx", ",", "AttrMask", ")", ";", "for", "(", "auto", "&", "BB", ":", "F", ")", "{", "IRBuilder", "<", ">", "Builder", "(", "&", "BB", ")", ";", "for", "(", "auto", "&", "I", ":", "make_early_inc_range", "(", "BB", ")", ")", "{", "if", "(", "I", ".", "getOpcode", "(", ")", "==", "Instruction", "::", "FNeg", ")", "{", "Builder", ".", "SetInsertPoint", "(", "&", "I", ")", ";", "Value", "*", "In", "=", "I", ".", "getOperand", "(", "0", ")", ";", "Value", "*", "Zero", "=", "ConstantFP", "::", "get", "(", "In", "->", "getType", "(", ")", ",", "-", "0.0", ")", ";", "I", ".", "replaceAllUsesWith", "(", "Builder", ".", "CreateFSub", "(", "Zero", ",", "In", ")", ")", ";", "I", ".", "eraseFromParent", "(", ")", ";", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "DirectX", "1", "DXIL", "0", "0", "0.0" ]

[]

[ "<s>", "SDValue", "LanaiTargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "SDLoc", "&", "DL", "=", "CLI", ".", "DL", ";", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "&", "IsTailCall", "=", "CLI", ".", "IsTailCall", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "bool", "IsVarArg", "=", "CLI", ".", "IsVarArg", ";", "IsTailCall", "=", "false", ";", "switch", "(", "CallConv", ")", "{", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "return", "LowerCCCCallTo", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "IsVarArg", ",", "IsTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "DL", ",", "DAG", ",", "InVals", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "Lanai", "Lanai", "ISD::OutputArg", "ISD::InputArg", "\"Unsupported calling convention\"" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "{", "return", "get", "(", "Opcode", ")", ".", "getSize", "(", ")", ";", "}", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "0", ";", "case", "RISCV", "::", "PseudoCALL", ":", "case", "RISCV", "::", "PseudoTAIL", ":", "case", "RISCV", "::", "PseudoLLA", ":", "return", "8", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "case", "TargetOpcode", "::", "INLINEASM_BR", ":", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "auto", "&", "TM", "=", "static_cast", "<", "const", "RISCVTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "TM", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "0", "RISCV::PseudoCALL", "RISCV::PseudoTAIL", "RISCV::PseudoLLA", "8", "RISCV", "0" ]

[]

[ "<s>", "static", "void", "nvptx_print_address_operand", "(", "FILE", "*", "file", ",", "rtx", "x", ",", "machine_mode", ")", "{", "rtx", "off", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "PLUS", ":", "off", "=", "XEXP", "(", "x", ",", "1", ")", ";", "output_address", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"+\"", ")", ";", "output_address", "(", "off", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "output_addr_const", "(", "file", ",", "x", ")", ";", "break", ";", "default", ":", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "!=", "MEM", ")", ";", "nvptx_print_operand", "(", "file", ",", "x", ",", "0", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Subroutine", "of", "nvptx_print_operand", ";", "used", "to", "print", "a", "memory", "reference", "X", "to", "FILE", "." ]

[ "nvptx", "0", "1", "0", "\"+\"", "0" ]

[]

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

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

[ "ARM" ]

[]

[ "<s>", "rtx", "nds32_legitimize_pic_address", "(", "rtx", "x", ")", "{", "rtx", "addr", "=", "x", ";", "rtx", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "pat", ";", "int", "relax_group_id", "=", "nds32_alloc_relax_group_id", "(", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", "||", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "(", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", "||", "SYMBOL_REF_LOCAL_P", "(", "x", ")", ")", ")", ")", "{", "addr", "=", "gen_rtx_UNSPEC", "(", "SImode", ",", "gen_rtvec", "(", "1", ",", "x", ")", ",", "UNSPEC_GOTOFF", ")", ";", "addr", "=", "gen_rtx_CONST", "(", "SImode", ",", "addr", ")", ";", "emit_insn", "(", "gen_sym_got", "(", "reg", ",", "addr", ",", "GEN_INT", "(", "relax_group_id", ")", ")", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "reg", ",", "pic_offset_table_rtx", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "{", "addr", "=", "gen_rtx_UNSPEC", "(", "SImode", ",", "gen_rtvec", "(", "1", ",", "x", ")", ",", "UNSPEC_GOT", ")", ";", "addr", "=", "gen_rtx_CONST", "(", "SImode", ",", "addr", ")", ";", "emit_insn", "(", "gen_sym_got", "(", "reg", ",", "addr", ",", "GEN_INT", "(", "relax_group_id", ")", ")", ")", ";", "x", "=", "gen_const_mem", "(", "SImode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "pic_offset_table_rtx", ",", "reg", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "{", "addr", "=", "XEXP", "(", "x", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", ";", "rtx", "op0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "(", "GET_CODE", "(", "op0", ")", "==", "LABEL_REF", "||", "(", "GET_CODE", "(", "op0", ")", "==", "SYMBOL_REF", "&&", "(", "CONSTANT_POOL_ADDRESS_P", "(", "op0", ")", "||", "SYMBOL_REF_LOCAL_P", "(", "op0", ")", ")", ")", ")", "&&", "GET_CODE", "(", "op1", ")", "==", "CONST_INT", ")", "{", "pat", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "op0", ")", ",", "UNSPEC_GOTOFF", ")", ";", "pat", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "pat", ",", "op1", ")", ";", "pat", "=", "gen_rtx_CONST", "(", "Pmode", ",", "pat", ")", ";", "emit_insn", "(", "gen_sym_got", "(", "reg", ",", "pat", ",", "GEN_INT", "(", "relax_group_id", ")", ")", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "reg", ",", "pic_offset_table_rtx", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "op0", ")", "==", "SYMBOL_REF", "&&", "GET_CODE", "(", "op1", ")", "==", "CONST_INT", ")", "{", "addr", "=", "gen_rtx_UNSPEC", "(", "SImode", ",", "gen_rtvec", "(", "1", ",", "op0", ")", ",", "UNSPEC_GOT", ")", ";", "addr", "=", "gen_rtx_CONST", "(", "SImode", ",", "addr", ")", ";", "emit_insn", "(", "gen_sym_got", "(", "reg", ",", "addr", ",", "GEN_INT", "(", "relax_group_id", ")", ")", ")", ";", "addr", "=", "gen_const_mem", "(", "SImode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "pic_offset_table_rtx", ",", "reg", ")", ")", ";", "emit_move_insn", "(", "reg", ",", "addr", ")", ";", "if", "(", "satisfies_constraint_Is15", "(", "op1", ")", ")", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "reg", ",", "op1", ")", ";", "else", "{", "rtx", "tmp_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_movsi", "(", "tmp_reg", ",", "op1", ")", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "reg", ",", "tmp_reg", ")", ";", "}", "}", "else", "{", "debug_rtx", "(", "x", ")", ";", "gcc_unreachable", "(", ")", ";", "}", "}", "return", "x", ";", "}", "</s>" ]

[ "Expand", "PIC", "code", "for", "@", "GOTOFF", "and", "@", "GOT", ".", "Example", "for", "@", "GOTOFF", ":", "la", "$", "r0", ",", "symbol", "@", "GOTOFF", "-", ">", "sethi", "$", "ta", ",", "hi20", "(", "symbol", "@", "GOTOFF", ")", "ori", "$", "ta", ",", "$", "ta", ",", "lo12", "(", "symbol", "@", "GOTOFF", ")", "add", "$", "r0", ",", "$", "ta", ",", "$", "gp", "Example", "for", "@", "GOT", ":", "la", "$", "r0", ",", "symbol", "@", "GOT", "-", ">", "sethi", "$", "ta", ",", "hi20", "(", "symbol", "@", "GOT", ")", "ori", "$", "ta", ",", "$", "ta", ",", "lo12", "(", "symbol", "@", "GOT", ")", "lw", "$", "r0", ",", "[", "$", "ta", "+", "$", "gp", "]" ]

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

[]

[ "<s>", "static", "rtx", "spu_addr_space_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", ",", "machine_mode", "mode", ",", "addr_space_t", "as", ")", "{", "if", "(", "as", "!=", "ADDR_SPACE_GENERIC", ")", "return", "x", ";", "return", "spu_legitimize_address", "(", "x", ",", "oldx", ",", "mode", ")", ";", "}", "</s>" ]

[ "Like", "spu_legitimate_address", ",", "except", "with", "named", "address", "support", "." ]

[ "spu" ]

[]

[ "<s>", "void", "pa_output_global_address", "(", "FILE", "*", "file", ",", "rtx", "x", ",", "int", "round_constant", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "HIGH", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "read_only_operand", "(", "x", ",", "VOIDmode", ")", ")", "output_addr_const", "(", "file", ",", "x", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "!", "flag_pic", ")", "{", "output_addr_const", "(", "file", ",", "x", ")", ";", "fputs", "(", "\"-$global$\"", ",", "file", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "{", "const", "char", "*", "sep", "=", "\"\"", ";", "int", "offset", "=", "0", ";", "rtx", "base", "=", "NULL_RTX", ";", "switch", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", ")", "{", "case", "SYMBOL_REF", ":", "base", "=", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ";", "output_addr_const", "(", "file", ",", "base", ")", ";", "break", ";", "case", "CONST_INT", ":", "offset", "=", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", ")", "{", "case", "SYMBOL_REF", ":", "base", "=", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ";", "output_addr_const", "(", "file", ",", "base", ")", ";", "break", ";", "case", "CONST_INT", ":", "offset", "=", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "round_constant", ")", "offset", "=", "(", "(", "offset", "+", "0x1000", ")", "&", "~", "0x1fff", ")", ";", "switch", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "{", "case", "PLUS", ":", "if", "(", "offset", "<", "0", ")", "{", "offset", "=", "-", "offset", ";", "sep", "=", "\"-\"", ";", "}", "else", "sep", "=", "\"+\"", ";", "break", ";", "case", "MINUS", ":", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ";", "sep", "=", "\"-\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "!", "read_only_operand", "(", "base", ",", "VOIDmode", ")", "&&", "!", "flag_pic", ")", "fputs", "(", "\"-$global$\"", ",", "file", ")", ";", "if", "(", "offset", ")", "fprintf", "(", "file", ",", "\"%s%d\"", ",", "sep", ",", "offset", ")", ";", "}", "else", "output_addr_const", "(", "file", ",", "x", ")", ";", "}", "</s>" ]

[ "output", "a", "SYMBOL_REF", "or", "a", "CONST", "expression", "involving", "a", "SYMBOL_REF", "." ]

[ "pa", "0", "\"-$global$\"", "\"\"", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "1", "0", "1", "0x1000", "0x1fff", "0", "0", "\"-\"", "\"+\"", "0", "0", "\"-\"", "\"-$global$\"", "\"%s%d\"" ]

[]

[ "<s>", "void", "DLXMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "Inst", ",", "raw_ostream", "&", "Ostream", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "SubtargetInfo", ")", "const", "{", "unsigned", "Value", "=", "getBinaryCodeForInstr", "(", "Inst", ",", "Fixups", ",", "SubtargetInfo", ")", ";", "++", "MCNumEmitted", ";", "for", "(", "int", "i", "=", "(", "4", "-", "1", ")", "*", "8", ";", "i", ">=", "0", ";", "i", "-=", "8", ")", "Ostream", "<<", "static_cast", "<", "char", ">", "(", "(", "Value", ">>", "i", ")", "&", "0xff", ")", ";", "}", "</s>" ]

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

[ "DLX", "DLX", "4", "1", "8", "0", "8", "0xff" ]

[]

[ "<s>", "const", "ARMBaseInstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "InstrInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

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

[ "Return", "true", "if", "instruction", "generated", "for", "equality", "comparison", "is", "folded", "with", "instruction", "generated", "for", "signed", "comparison", "." ]

[ "PowerPC" ]

[]

[ "<s>", "void", "CAHPFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "CAHPRegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "FPReg", "=", "getFPReg", "(", ")", ";", "unsigned", "SPReg", "=", "getSPReg", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "LastFrameDestroy", "=", "MBBI", ";", "std", "::", "advance", "(", "LastFrameDestroy", ",", "-", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "assert", "(", "hasFP", "(", "MF", ")", "&&", "\"frame pointer should not have been eliminated\"", ")", ";", "adjustReg", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "SPReg", ",", "FPReg", ",", "-", "StackSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "StackSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "</s>" ]

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

[ "CAHP", "CAHP", "CAHP", "\"frame pointer should not have been eliminated\"" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "SystemZMCAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "SystemZ", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"FK_390_PC16DBL\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"FK_390_PC32DBL\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"FK_390_TLS_CALL\"", ",", "0", ",", "0", ",", "0", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ::NumTargetFixupKinds", "\"FK_390_PC16DBL\"", "0", "16", "\"FK_390_PC32DBL\"", "0", "32", "\"FK_390_TLS_CALL\"", "0", "0", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "static", "void", "aarch64_disqualify_components", "(", "sbitmap", ",", "edge", ",", "sbitmap", ",", "bool", ")", "{", "}", "</s>" ]

[ "Implement", "TARGET_SHRINK_WRAP_DISQUALIFY_COMPONENTS", ".", "Nothing", "to", "do", "for", "aarch64", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "int", "ix86_function_regparm", "(", "const_tree", "type", ",", "const_tree", "decl", ")", "{", "tree", "attr", ";", "int", "regparm", ";", "unsigned", "int", "ccvt", ";", "if", "(", "TARGET_64BIT", ")", "return", "(", "ix86_function_type_abi", "(", "type", ")", "==", "SYSV_ABI", "?", "X86_64_REGPARM_MAX", ":", "X86_64_MS_REGPARM_MAX", ")", ";", "ccvt", "=", "ix86_get_callcvt", "(", "type", ")", ";", "regparm", "=", "ix86_regparm", ";", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_REGPARM", ")", "!=", "0", ")", "{", "attr", "=", "lookup_attribute", "(", "\"regparm\"", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", ";", "if", "(", "attr", ")", "{", "regparm", "=", "TREE_INT_CST_LOW", "(", "TREE_VALUE", "(", "TREE_VALUE", "(", "attr", ")", ")", ")", ";", "return", "regparm", ";", "}", "}", "else", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_FASTCALL", ")", "!=", "0", ")", "return", "2", ";", "else", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_THISCALL", ")", "!=", "0", ")", "return", "1", ";", "if", "(", "decl", "&&", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "{", "cgraph_node", "*", "target", "=", "cgraph_node", "::", "get", "(", "decl", ")", ";", "if", "(", "target", ")", "target", "=", "target", "->", "function_symbol", "(", ")", ";", "if", "(", "target", "&&", "opt_for_fn", "(", "target", "->", "decl", ",", "optimize", ")", "&&", "!", "(", "profile_flag", "&&", "!", "flag_fentry", ")", ")", "{", "cgraph_local_info", "*", "i", "=", "&", "target", "->", "local", ";", "if", "(", "i", "&&", "i", "->", "local", "&&", "i", "->", "can_change_signature", ")", "{", "int", "local_regparm", ",", "globals", "=", "0", ",", "regno", ";", "for", "(", "local_regparm", "=", "0", ";", "local_regparm", "<", "REGPARM_MAX", ";", "local_regparm", "++", ")", "if", "(", "fixed_regs", "[", "local_regparm", "]", ")", "break", ";", "if", "(", "local_regparm", "==", "3", "&&", "DECL_STATIC_CHAIN", "(", "target", "->", "decl", ")", ")", "local_regparm", "=", "2", ";", "if", "(", "local_regparm", "==", "3", "&&", "flag_split_stack", ")", "local_regparm", "=", "2", ";", "for", "(", "regno", "=", "AX_REG", ";", "regno", "<=", "DI_REG", ";", "regno", "++", ")", "if", "(", "fixed_regs", "[", "regno", "]", ")", "globals", "++", ";", "local_regparm", "=", "globals", "<", "local_regparm", "?", "local_regparm", "-", "globals", ":", "0", ";", "if", "(", "local_regparm", ">", "regparm", ")", "regparm", "=", "local_regparm", ";", "}", "}", "}", "return", "regparm", ";", "}", "</s>" ]

[ "Return", "the", "regparm", "value", "for", "a", "function", "with", "the", "indicated", "TYPE", "and", "DECL", ".", "DECL", "may", "be", "NULL", "when", "calling", "function", "indirectly", "or", "considering", "a", "libcall", "." ]

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

[]