Datasets:

---

docz1105

/

ComBack

like 9

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

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

[ "Mips", "1" ]

[]

[ "<s>", "bool", "WasmPEI", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "Function", "*", "F", "=", "Fn", ".", "getFunction", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "RS", "=", "TRI", "->", "requiresRegisterScavenging", "(", "Fn", ")", "?", "new", "RegScavenger", "(", ")", ":", "nullptr", ";", "FrameIndexVirtualScavenging", "=", "TRI", "->", "requiresFrameIndexScavenging", "(", "Fn", ")", ";", "calculateCallsInformation", "(", "Fn", ")", ";", "BitVector", "SavedRegs", ";", "TFI", "->", "determineCalleeSaves", "(", "Fn", ",", "SavedRegs", ",", "RS", ")", ";", "assignCalleeSavedSpillSlots", "(", "Fn", ",", "SavedRegs", ")", ";", "calculateSets", "(", "Fn", ")", ";", "if", "(", "!", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "Naked", ")", ")", "insertCSRSpillsAndRestores", "(", "Fn", ")", ";", "TFI", "->", "processFunctionBeforeFrameFinalized", "(", "Fn", ",", "RS", ")", ";", "calculateFrameObjectOffsets", "(", "Fn", ")", ";", "if", "(", "!", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "Naked", ")", ")", "insertPrologEpilogCode", "(", "Fn", ")", ";", "replaceFrameIndices", "(", "Fn", ")", ";", "if", "(", "TRI", "->", "requiresRegisterScavenging", "(", "Fn", ")", "&&", "FrameIndexVirtualScavenging", ")", "{", "scavengeFrameVirtualRegs", "(", "Fn", ")", ";", "Fn", ".", "getRegInfo", "(", ")", ".", "clearVirtRegs", "(", ")", ";", "}", "MachineFrameInfo", "*", "MFI", "=", "Fn", ".", "getFrameInfo", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "WarnStackSize", ".", "getNumOccurrences", "(", ")", ">", "0", "&&", "WarnStackSize", "<", "StackSize", ")", "{", "DiagnosticInfoStackSize", "DiagStackSize", "(", "*", "F", ",", "StackSize", ")", ";", "F", "->", "getContext", "(", ")", ".", "diagnose", "(", "DiagStackSize", ")", ";", "}", "delete", "RS", ";", "SaveBlocks", ".", "clear", "(", ")", ";", "RestoreBlocks", ".", "clear", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "0" ]

[]

[ "<s>", "void", "emitTableType", "(", "const", "MCSymbolWasm", "*", ")", "override", "{", "}", "</s>" ]

[ ".tabletype" ]

[ "WebAssembly" ]

[]

[ "<s>", "int", "SIFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "SIRegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "FrameReg", "=", "RI", "->", "getFrameRegister", "(", "MF", ")", ";", "return", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FI", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "HexagonMCInst", "::", "getMinValue", "(", "void", ")", "const", "{", "const", "uint64_t", "F", "=", "getDesc", "(", ")", ".", "TSFlags", ";", "unsigned", "isSigned", "=", "(", "F", ">>", "HexagonII", "::", "ExtentSignedPos", ")", "&", "HexagonII", "::", "ExtentSignedMask", ";", "unsigned", "bits", "=", "(", "F", ">>", "HexagonII", "::", "ExtentBitsPos", ")", "&", "HexagonII", "::", "ExtentBitsMask", ";", "if", "(", "isSigned", ")", "return", "-", "1U", "<<", "(", "bits", "-", "1", ")", ";", "else", "return", "0", ";", "}", "</s>" ]

[ "Return", "the", "minimal", "unsigned", "value", "possible", "given", "these", "KnownBits", "." ]

[ "Hexagon", "Hexagon", "HexagonII::ExtentSignedPos", "HexagonII::ExtentSignedMask", "HexagonII::ExtentBitsPos", "HexagonII::ExtentBitsMask", "1U", "1", "0" ]

[]

[ "<s>", "static", "int", "avr_signal_function_p", "(", "tree", "func", ")", "{", "return", "avr_lookup_function_attribute1", "(", "func", ",", "\"signal\"", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "FUNC", "is", "a", "signal", "function", "as", "specified", "by", "the", "``", "signal", "''", "attribute", "." ]

[ "avr", "\"signal\"" ]

[]

[ "<s>", "InstructionCost", "getIntImmCost", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "if", "(", "Imm", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "isInt", "<", "16", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Basic", ";", "if", "(", "isInt", "<", "21", ">", "(", "Imm", ".", "getZExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Basic", ";", "if", "(", "isInt", "<", "32", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "{", "if", "(", "(", "Imm", ".", "getSExtValue", "(", ")", "&", "0xFFFF", ")", "==", "0", ")", "return", "TTI", "::", "TCC_Basic", ";", "return", "2", "*", "TTI", "::", "TCC_Basic", ";", "}", "return", "4", "*", "TTI", "::", "TCC_Basic", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "Lanai", "0", "16", "21", "32", "0xFFFF", "0", "2", "4" ]

[]

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

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

[ "BPF" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "VEFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "int", "Size", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "VE", "::", "ADJCALLSTACKDOWN", ")", "Size", "=", "-", "Size", ";", "if", "(", "Size", ")", "emitSPAdjustment", "(", "MF", ",", "MBB", ",", "I", ",", "Size", ")", ";", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "VE", "VE", "0", "VE::ADJCALLSTACKDOWN" ]

[]

[ "<s>", "static", "void", "nios2_load_pic_register", "(", "void", ")", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "TEMP_REG_NUM", ")", ";", "emit_insn", "(", "gen_load_got_register", "(", "pic_offset_table_rtx", ",", "tmp", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "pic_offset_table_rtx", ",", "pic_offset_table_rtx", ",", "tmp", ")", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "load", "the", "PIC", "register", "." ]

[ "nios2" ]

[]

[ "<s>", "static", "void", "ia64_free_sched_context", "(", "void", "*", "_sc", ")", "{", "gcc_assert", "(", "_sc", "!=", "NULL", ")", ";", "free", "(", "_sc", ")", ";", "}", "</s>" ]

[ "Frees", "the", "_SC", "scheduling", "context", "." ]

[ "ia64" ]

[]

[ "<s>", "void", "unicosmk_add_extern", "(", "const", "char", "*", "name", ")", "{", "struct", "unicosmk_extern_list", "*", "p", ";", "p", "=", "(", "struct", "unicosmk_extern_list", "*", ")", "xmalloc", "(", "sizeof", "(", "struct", "unicosmk_extern_list", ")", ")", ";", "p", "->", "next", "=", "unicosmk_extern_head", ";", "p", "->", "name", "=", "name", ";", "unicosmk_extern_head", "=", "p", ";", "}", "</s>" ]

[ "Record", "an", "extern", "." ]

[ "alpha" ]

[]

[ "<s>", "bool", "X86CallFrameOptimization", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TFL", "=", "STI", "->", "getFrameLowering", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "const", "X86RegisterInfo", "&", "RegInfo", "=", "*", "static_cast", "<", "const", "X86RegisterInfo", "*", ">", "(", "STI", "->", "getRegisterInfo", "(", ")", ")", ";", "SlotSize", "=", "RegInfo", ".", "getSlotSize", "(", ")", ";", "assert", "(", "isPowerOf2_32", "(", "SlotSize", ")", "&&", "\"Expect power of 2 stack slot size\"", ")", ";", "Log2SlotSize", "=", "Log2_32", "(", "SlotSize", ")", ";", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", "||", "!", "isLegal", "(", "MF", ")", ")", "return", "false", ";", "unsigned", "FrameSetupOpcode", "=", "TII", "->", "getCallFrameSetupOpcode", "(", ")", ";", "bool", "Changed", "=", "false", ";", "ContextVector", "CallSeqVector", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "FrameSetupOpcode", ")", "{", "CallContext", "Context", ";", "collectCallInfo", "(", "MF", ",", "MBB", ",", "MI", ",", "Context", ")", ";", "CallSeqVector", ".", "push_back", "(", "Context", ")", ";", "}", "if", "(", "!", "isProfitable", "(", "MF", ",", "CallSeqVector", ")", ")", "return", "false", ";", "for", "(", "auto", "CC", ":", "CallSeqVector", ")", "{", "if", "(", "CC", ".", "UsePush", ")", "{", "adjustCallSequence", "(", "MF", ",", "CC", ")", ";", "Changed", "=", "true", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "\"Expect power of 2 stack slot size\"" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "MMIX" ]

[]

[ "<s>", "virtual", "bool", "check", "(", "function_checker", "&", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Perform", "semantic", "checks", "on", "the", "call", ".", "Return", "true", "if", "the", "call", "is", "valid", ",", "otherwise", "report", "a", "suitable", "error", "." ]

[ "riscv" ]

[]

[ "<s>", "static", "void", "seh_cfa_adjust_cfa", "(", "FILE", "*", "f", ",", "struct", "seh_frame_state", "*", "seh", ",", "rtx", "pat", ")", "{", "rtx", "dest", ",", "src", ";", "HOST_WIDE_INT", "reg_offset", "=", "0", ";", "unsigned", "int", "dest_regno", ";", "dest", "=", "SET_DEST", "(", "pat", ")", ";", "src", "=", "SET_SRC", "(", "pat", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "PLUS", ")", "{", "reg_offset", "=", "INTVAL", "(", "XEXP", "(", "src", ",", "1", ")", ")", ";", "src", "=", "XEXP", "(", "src", ",", "0", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "MINUS", ")", "{", "reg_offset", "=", "-", "INTVAL", "(", "XEXP", "(", "src", ",", "1", ")", ")", ";", "src", "=", "XEXP", "(", "src", ",", "0", ")", ";", "}", "gcc_assert", "(", "src", "==", "stack_pointer_rtx", ")", ";", "gcc_assert", "(", "seh", "->", "cfa_reg", "==", "stack_pointer_rtx", ")", ";", "dest_regno", "=", "REGNO", "(", "dest", ")", ";", "if", "(", "dest_regno", "==", "STACK_POINTER_REGNUM", ")", "seh_emit_stackalloc", "(", "f", ",", "seh", ",", "reg_offset", ")", ";", "else", "if", "(", "dest_regno", "==", "HARD_FRAME_POINTER_REGNUM", ")", "{", "HOST_WIDE_INT", "offset", ";", "seh", "->", "cfa_reg", "=", "dest", ";", "seh", "->", "cfa_offset", "-=", "reg_offset", ";", "offset", "=", "seh", "->", "sp_offset", "-", "seh", "->", "cfa_offset", ";", "gcc_assert", "(", "(", "offset", "&", "15", ")", "==", "0", ")", ";", "gcc_assert", "(", "IN_RANGE", "(", "offset", ",", "0", ",", "240", ")", ")", ";", "fputs", "(", "\"\\t.seh_setframe\\t\"", ",", "f", ")", ";", "print_reg", "(", "seh", "->", "cfa_reg", ",", "0", ",", "f", ")", ";", "fprintf", "(", "f", ",", "\", \"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "offset", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Process", "REG_CFA_ADJUST_CFA", "for", "SEH", "." ]

[ "i386", "0", "1", "0", "1", "0", "15", "0", "0", "240", "\"\\t.seh_setframe\\t\"", "0", "\", \"", "\"\\n\"" ]

[]

[ "<s>", "static", "void", "moxie_compute_frame", "(", "void", ")", "{", "int", "stack_alignment", "=", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ";", "int", "padding_locals", ";", "int", "regno", ";", "cfun", "->", "machine", "->", "local_vars_size", "=", "get_frame_size", "(", ")", ";", "padding_locals", "=", "cfun", "->", "machine", "->", "local_vars_size", "%", "stack_alignment", ";", "if", "(", "padding_locals", ")", "padding_locals", "=", "stack_alignment", "-", "padding_locals", ";", "cfun", "->", "machine", "->", "local_vars_size", "+=", "padding_locals", ";", "cfun", "->", "machine", "->", "callee_saved_reg_size", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "(", "!", "call_used_regs", "[", "regno", "]", ")", ")", "cfun", "->", "machine", "->", "callee_saved_reg_size", "+=", "4", ";", "cfun", "->", "machine", "->", "size_for_adjusting_sp", "=", "crtl", "->", "args", ".", "pretend_args_size", "+", "cfun", "->", "machine", "->", "local_vars_size", "+", "(", "ACCUMULATE_OUTGOING_ARGS", "?", "(", "HOST_WIDE_INT", ")", "crtl", "->", "outgoing_args_size", ":", "0", ")", ";", "}", "</s>" ]

[ "Compute", "the", "size", "of", "the", "local", "area", "and", "the", "size", "to", "be", "adjusted", "by", "the", "*", "prologue", "and", "epilogue", "." ]

[ "moxie", "0", "0", "4", "0" ]

[]

[ "<s>", "BitVector", "MipsRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "static", "const", "uint16_t", "ReservedGPR32", "[", "]", "=", "{", "Mips", "::", "ZERO", ",", "Mips", "::", "K0", ",", "Mips", "::", "K1", ",", "Mips", "::", "SP", "}", ";", "static", "const", "uint16_t", "ReservedGPR64", "[", "]", "=", "{", "Mips", "::", "ZERO_64", ",", "Mips", "::", "K0_64", ",", "Mips", "::", "K1_64", ",", "Mips", "::", "SP_64", "}", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "typedef", "TargetRegisterClass", "::", "const_iterator", "RegIter", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "array_lengthof", "(", "ReservedGPR32", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "ReservedGPR32", "[", "I", "]", ")", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "array_lengthof", "(", "ReservedGPR64", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "ReservedGPR64", "[", "I", "]", ")", ";", "if", "(", "Subtarget", ".", "hasMips64", "(", ")", ")", "{", "for", "(", "RegIter", "Reg", "=", "Mips", "::", "AFGR64RegClass", ".", "begin", "(", ")", ",", "EReg", "=", "Mips", "::", "AFGR64RegClass", ".", "end", "(", ")", ";", "Reg", "!=", "EReg", ";", "++", "Reg", ")", "Reserved", ".", "set", "(", "*", "Reg", ")", ";", "}", "else", "{", "for", "(", "RegIter", "Reg", "=", "Mips", "::", "FGR64RegClass", ".", "begin", "(", ")", ",", "EReg", "=", "Mips", "::", "FGR64RegClass", ".", "end", "(", ")", ";", "Reg", "!=", "EReg", ";", "++", "Reg", ")", "Reserved", ".", "set", "(", "*", "Reg", ")", ";", "}", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", "->", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "Reserved", ".", "set", "(", "Mips", "::", "S0", ")", ";", "else", "{", "Reserved", ".", "set", "(", "Mips", "::", "FP", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "FP_64", ")", ";", "}", "}", "Reserved", ".", "set", "(", "Mips", "::", "HWR29", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "HWR29_64", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "DSPPos", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "DSPSCount", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "DSPCarry", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "DSPEFI", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "DSPOutFlag", ")", ";", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "{", "Reserved", ".", "set", "(", "Mips", "::", "RA", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "RA_64", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "T0", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "T1", ")", ";", "}", "if", "(", "Subtarget", ".", "useSmallSection", "(", ")", ")", "{", "Reserved", ".", "set", "(", "Mips", "::", "GP", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "GP_64", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::ZERO", "Mips::K0", "Mips::K1", "Mips::SP", "Mips::ZERO_64", "Mips::K0_64", "Mips::K1_64", "Mips::SP_64", "0", "0", "Mips", "Mips::AFGR64RegClass", "Mips::AFGR64RegClass", "Mips::FGR64RegClass", "Mips::FGR64RegClass", "Mips", "Mips::S0", "Mips::FP", "Mips::FP_64", "Mips::HWR29", "Mips::HWR29_64", "Mips::DSPPos", "Mips::DSPSCount", "Mips::DSPCarry", "Mips::DSPEFI", "Mips::DSPOutFlag", "Mips", "Mips::RA", "Mips::RA_64", "Mips::T0", "Mips::T1", "Mips::GP", "Mips::GP_64" ]

[]

[ "<s>", "static", "int", "ix86_reassociation_width", "(", "unsigned", "int", ",", "machine_mode", "mode", ")", "{", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", ")", "{", "if", "(", "TARGET_VECTOR_PARALLEL_EXECUTION", ")", "return", "2", ";", "else", "return", "1", ";", "}", "if", "(", "INTEGRAL_MODE_P", "(", "mode", ")", "&&", "TARGET_REASSOC_INT_TO_PARALLEL", ")", "return", "2", ";", "else", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", "&&", "TARGET_REASSOC_FP_TO_PARALLEL", ")", "return", "2", ";", "else", "return", "1", ";", "}", "</s>" ]

[ "Implementation", "of", "reassociation_width", "target", "hook", "used", "by", "reassoc", "phase", "to", "identify", "parallelism", "level", "in", "reassociated", "tree", ".", "Statements", "tree_code", "is", "passed", "in", "OPC", ".", "Arguments", "type", "is", "passed", "in", "MODE", ".", "Currently", "parallel", "reassociation", "is", "enabled", "for", "Atom", "processors", "only", "and", "we", "set", "reassociation", "width", "to", "be", "2", "because", "Atom", "may", "issue", "up", "to", "2", "instructions", "per", "cycle", ".", "Return", "value", "should", "be", "fixed", "if", "parallel", "reassociation", "is", "enabled", "for", "other", "processors", "." ]

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

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "AVRMachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AVRMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "MFI", ".", "getNumObjects", "(", ")", "!=", "MFI", ".", "getNumFixedObjects", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MFI", ".", "getObjectIndexEnd", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "MFI", ".", "getObjectSize", "(", "i", ")", ")", "{", "AFI", "->", "setHasAllocas", "(", "true", ")", ";", "break", ";", "}", "}", "}", "if", "(", "MFI", ".", "getNumFixedObjects", "(", ")", "==", "0", ")", "{", "return", "false", ";", "}", "for", "(", "const", "MachineBasicBlock", "&", "BB", ":", "MF", ")", "{", "for", "(", "const", "MachineInstr", "&", "MI", ":", "BB", ")", "{", "int", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "(", "Opcode", "!=", "AVR", "::", "LDDRdPtrQ", ")", "&&", "(", "Opcode", "!=", "AVR", "::", "LDDWRdPtrQ", ")", "&&", "(", "Opcode", "!=", "AVR", "::", "STDPtrQRr", ")", "&&", "(", "Opcode", "!=", "AVR", "::", "STDWPtrQRr", ")", ")", "{", "continue", ";", "}", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "!", "MO", ".", "isFI", "(", ")", ")", "{", "continue", ";", "}", "if", "(", "MFI", ".", "isFixedObjectIndex", "(", "MO", ".", "getIndex", "(", ")", ")", ")", "{", "AFI", "->", "setHasStackArgs", "(", "true", ")", ";", "return", "false", ";", "}", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "0", "0", "AVR::LDDRdPtrQ", "AVR::LDDWRdPtrQ", "AVR::STDPtrQRr", "AVR::STDWPtrQRr" ]

[]

[ "<s>", "bool", "BTFDebug", "::", "InstLower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "BPF", "::", "LD_imm64", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "1", ")", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "const", "GlobalValue", "*", "GVal", "=", "MO", ".", "getGlobal", "(", ")", ";", "auto", "*", "GVar", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GVal", ")", ";", "if", "(", "GVar", "&&", "GVar", "->", "hasAttribute", "(", "BPFCoreSharedInfo", "::", "AmaAttr", ")", ")", "{", "uint32_t", "Imm", "=", "PatchImms", "[", "GVar", "->", "getName", "(", ")", ".", "str", "(", ")", "]", ";", "OutMI", ".", "setOpcode", "(", "BPF", "::", "MOV_ri", ")", ";", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", ";", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Imm", ")", ")", ";", "return", "true", ";", "}", "else", "if", "(", "GVar", "&&", "!", "GVar", "->", "hasInitializer", "(", ")", "&&", "GVar", "->", "hasExternalLinkage", "(", ")", "&&", "GVar", "->", "getSection", "(", ")", "==", "BPFCoreSharedInfo", "::", "PatchableExtSecName", ")", "{", "const", "IntegerType", "*", "IntTy", "=", "dyn_cast", "<", "IntegerType", ">", "(", "GVar", "->", "getValueType", "(", ")", ")", ";", "assert", "(", "IntTy", ")", ";", "if", "(", "IntTy", "->", "getBitWidth", "(", ")", "==", "64", ")", "OutMI", ".", "setOpcode", "(", "BPF", "::", "LD_imm64", ")", ";", "else", "OutMI", ".", "setOpcode", "(", "BPF", "::", "MOV_ri", ")", ";", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", ";", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Emit", "proper", "patchable", "instructions", "." ]

[ "BPF", "BPF::LD_imm64", "1", "BPFCoreSharedInfo::AmaAttr", "BPF::MOV_ri", "0", "BPFCoreSharedInfo::PatchableExtSecName", "64", "BPF::LD_imm64", "BPF::MOV_ri", "0", "0" ]

[]

[ "<s>", "unsigned", "getExceptionPointerRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "override", "{", "return", "SystemZ", "::", "R6D", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "address", "on", "entry", "to", "an", "EH", "pad", "." ]

[ "SystemZ", "SystemZ::R6D" ]

[]

[ "<s>", "void", "HexagonSubtarget", "::", "adjustSchedDependency", "(", "SUnit", "*", "Src", ",", "SUnit", "*", "Dst", ",", "SDep", "&", "Dep", ")", "const", "{", "MachineInstr", "*", "SrcInst", "=", "Src", "->", "getInstr", "(", ")", ";", "MachineInstr", "*", "DstInst", "=", "Dst", "->", "getInstr", "(", ")", ";", "if", "(", "!", "Src", "->", "isInstr", "(", ")", "||", "!", "Dst", "->", "isInstr", "(", ")", ")", "return", ";", "const", "HexagonInstrInfo", "*", "QII", "=", "static_cast", "<", "const", "HexagonInstrInfo", "*", ">", "(", "getInstrInfo", "(", ")", ")", ";", "if", "(", "QII", "->", "canExecuteInBundle", "(", "SrcInst", ",", "DstInst", ")", "&&", "isBestZeroLatency", "(", "Src", ",", "Dst", ",", "QII", ")", ")", "{", "Dep", ".", "setLatency", "(", "0", ")", ";", "return", ";", "}", "if", "(", "!", "hasV60TOps", "(", ")", ")", "return", ";", "if", "(", "QII", "->", "isPostIncrement", "(", "SrcInst", ")", "&&", "Dep", ".", "isAssignedRegDep", "(", ")", ")", "{", "if", "(", "SrcInst", "->", "mayStore", "(", ")", ")", "return", ";", "if", "(", "Dep", ".", "getReg", "(", ")", "!=", "SrcInst", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "return", ";", "}", "else", "if", "(", "QII", "->", "isPostIncrement", "(", "DstInst", ")", "&&", "Dep", ".", "getKind", "(", ")", "==", "SDep", "::", "Anti", ")", "{", "if", "(", "DstInst", "->", "mayStore", "(", ")", ")", "return", ";", "if", "(", "Dep", ".", "getReg", "(", ")", "!=", "DstInst", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "return", ";", "}", "else", "if", "(", "QII", "->", "isPostIncrement", "(", "DstInst", ")", "&&", "DstInst", "->", "mayStore", "(", ")", "&&", "Dep", ".", "isAssignedRegDep", "(", ")", ")", "{", "MachineOperand", "&", "Op", "=", "DstInst", "->", "getOperand", "(", "DstInst", "->", "getNumOperands", "(", ")", "-", "1", ")", ";", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "Dep", ".", "getReg", "(", ")", "!=", "Op", ".", "getReg", "(", ")", ")", "return", ";", "}", "if", "(", "useBSBScheduling", "(", ")", "&&", "SrcInst", "->", "isPHI", "(", ")", ")", "{", "changePhiLatency", "(", "SrcInst", ",", "Dst", ",", "Dep", ")", ";", "return", ";", "}", "if", "(", "DstInst", "->", "isRegSequence", "(", ")", "&&", "Dst", "->", "NumSuccs", "==", "1", ")", "DstInst", "=", "Dst", "->", "Succs", "[", "0", "]", ".", "getSUnit", "(", ")", "->", "getInstr", "(", ")", ";", "if", "(", "EnableDotCurSched", "&&", "QII", "->", "isToBeScheduledASAP", "(", "SrcInst", ",", "DstInst", ")", "&&", "isBestZeroLatency", "(", "Src", ",", "Dst", ",", "QII", ")", ")", "{", "Dep", ".", "setLatency", "(", "0", ")", ";", "return", ";", "}", "updateLatency", "(", "SrcInst", ",", "DstInst", ",", "Dep", ")", ";", "}", "</s>" ]

[ "Perform", "target", "specific", "adjustments", "to", "the", "latency", "of", "a", "schedule", "dependency", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "0", "0", "0", "1", "1", "0", "0" ]

[]

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

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

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

[]

[ "<s>", "static", "void", "h8300_print_operand_address", "(", "FILE", "*", "file", ",", "machine_mode", "mode", ",", "rtx", "addr", ")", "{", "rtx", "index", ";", "int", "size", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "\"%s\"", ",", "h8_reg_names", "[", "REGNO", "(", "addr", ")", "]", ")", ";", "break", ";", "case", "PRE_DEC", ":", "fprintf", "(", "file", ",", "\"-%s\"", ",", "h8_reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "POST_INC", ":", "fprintf", "(", "file", ",", "\"%s+\"", ",", "h8_reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "PRE_INC", ":", "fprintf", "(", "file", ",", "\"+%s\"", ",", "h8_reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "POST_DEC", ":", "fprintf", "(", "file", ",", "\"%s-\"", ",", "h8_reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "PLUS", ":", "fprintf", "(", "file", ",", "\"(\"", ")", ";", "index", "=", "h8300_get_index", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "VOIDmode", ",", "&", "size", ")", ";", "if", "(", "GET_CODE", "(", "index", ")", "==", "REG", ")", "{", "h8300_print_operand_address", "(", "file", ",", "mode", ",", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "fprintf", "(", "file", ",", "\",\"", ")", ";", "switch", "(", "size", ")", "{", "case", "0", ":", "h8300_print_operand_address", "(", "file", ",", "mode", ",", "index", ")", ";", "break", ";", "case", "1", ":", "h8300_print_operand", "(", "file", ",", "index", ",", "'X'", ")", ";", "fputs", "(", "\".b\"", ",", "file", ")", ";", "break", ";", "case", "2", ":", "h8300_print_operand", "(", "file", ",", "index", ",", "'T'", ")", ";", "fputs", "(", "\".w\"", ",", "file", ")", ";", "break", ";", "case", "4", ":", "h8300_print_operand", "(", "file", ",", "index", ",", "'S'", ")", ";", "fputs", "(", "\".l\"", ",", "file", ")", ";", "break", ";", "}", "}", "else", "{", "h8300_print_operand_address", "(", "file", ",", "mode", ",", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"+\"", ")", ";", "h8300_print_operand_address", "(", "file", ",", "mode", ",", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "}", "fprintf", "(", "file", ",", "\")\"", ")", ";", "break", ";", "case", "CONST_INT", ":", "{", "int", "n", "=", "INTVAL", "(", "addr", ")", ";", "fprintf", "(", "file", ",", "\"%d\"", ",", "n", ")", ";", "break", ";", "}", "default", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Output", "assembly", "language", "output", "for", "the", "address", "ADDR", "to", "FILE", "." ]

[ "h8300", "\"%s\"", "\"-%s\"", "0", "\"%s+\"", "0", "\"+%s\"", "0", "\"%s-\"", "0", "\"(\"", "0", "1", "\",\"", "0", "1", "\".b\"", "2", "\".w\"", "4", "\".l\"", "0", "\"+\"", "1", "\")\"", "\"%d\"" ]

[]

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

[ "If", "true", ",", "then", "instruction", "selection", "should", "seek", "to", "shrink", "the", "FP", "constant", "of", "the", "specified", "type", "to", "a", "smaller", "type", "in", "order", "to", "save", "space", "and", "/", "or", "reduce", "runtime", "." ]

[ "TPC" ]

[]

[ "<s>", "int", "cris_side_effect_mode_ok", "(", "enum", "rtx_code", "code", ",", "rtx", "*", "ops", ",", "int", "lreg", ",", "int", "rreg", ",", "int", "rval", ",", "int", "multop", ",", "int", "other_op", ")", "{", "int", "mult", "=", "multop", "<", "0", "?", "1", ":", "INTVAL", "(", "ops", "[", "multop", "]", ")", ";", "rtx", "reg_rtx", "=", "ops", "[", "rreg", "]", ";", "rtx", "val_rtx", "=", "ops", "[", "rval", "]", ";", "if", "(", "!", "cris_base_p", "(", "reg_rtx", ",", "reload_in_progress", "||", "reload_completed", ")", ")", "reg_rtx", "=", "val_rtx", ",", "val_rtx", "=", "ops", "[", "rreg", "]", ";", "if", "(", "!", "cris_base_p", "(", "reg_rtx", ",", "reload_in_progress", "||", "reload_completed", ")", ")", "return", "0", ";", "if", "(", "!", "TARGET_SIDE_EFFECT_PREFIXES", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "val_rtx", ")", "==", "MULT", ")", "{", "mult", "=", "INTVAL", "(", "XEXP", "(", "val_rtx", ",", "1", ")", ")", ";", "val_rtx", "=", "XEXP", "(", "val_rtx", ",", "0", ")", ";", "code", "=", "MULT", ";", "}", "if", "(", "other_op", ">=", "0", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "ops", "[", "other_op", "]", ")", ")", ">", "UNITS_PER_WORD", ")", "return", "0", ";", "if", "(", "(", "cris_base_p", "(", "ops", "[", "lreg", "]", ",", "reload_in_progress", "||", "reload_completed", ")", "&&", "cris_base_p", "(", "ops", "[", "other_op", "]", ",", "reload_in_progress", "||", "reload_completed", ")", "&&", "REGNO", "(", "ops", "[", "lreg", "]", ")", "==", "REGNO", "(", "ops", "[", "other_op", "]", ")", ")", "||", "rtx_equal_p", "(", "ops", "[", "other_op", "]", ",", "ops", "[", "lreg", "]", ")", ")", "return", "0", ";", "}", "if", "(", "ops", "[", "lreg", "]", "==", "frame_pointer_rtx", "||", "ops", "[", "rreg", "]", "==", "frame_pointer_rtx", "||", "ops", "[", "rval", "]", "==", "frame_pointer_rtx", "||", "(", "other_op", ">=", "0", "&&", "ops", "[", "other_op", "]", "==", "frame_pointer_rtx", ")", ")", "return", "0", ";", "if", "(", "code", "==", "PLUS", "&&", "!", "cris_base_p", "(", "val_rtx", ",", "reload_in_progress", "||", "reload_completed", ")", ")", "{", "if", "(", "rtx_equal_p", "(", "ops", "[", "lreg", "]", ",", "reg_rtx", ")", "&&", "CONST_INT_P", "(", "val_rtx", ")", "&&", "(", "INTVAL", "(", "val_rtx", ")", "<=", "63", "&&", "INTVAL", "(", "val_rtx", ")", ">=", "-", "63", ")", ")", "return", "0", ";", "if", "(", "CONSTANT_P", "(", "val_rtx", ")", ")", "return", "1", ";", "if", "(", "MEM_P", "(", "val_rtx", ")", "&&", "cris_base_or_autoincr_p", "(", "XEXP", "(", "val_rtx", ",", "0", ")", ",", "reload_in_progress", "||", "reload_completed", ")", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "val_rtx", ")", "==", "SIGN_EXTEND", "&&", "MEM_P", "(", "XEXP", "(", "val_rtx", ",", "0", ")", ")", "&&", "cris_base_or_autoincr_p", "(", "XEXP", "(", "XEXP", "(", "val_rtx", ",", "0", ")", ",", "0", ")", ",", "reload_in_progress", "||", "reload_completed", ")", ")", "return", "1", ";", "return", "0", ";", "}", "else", "if", "(", "code", "==", "MULT", "||", "(", "code", "==", "PLUS", "&&", "cris_base_p", "(", "val_rtx", ",", "reload_in_progress", "||", "reload_completed", ")", ")", ")", "{", "if", "(", "rtx_equal_p", "(", "ops", "[", "lreg", "]", ",", "reg_rtx", ")", "||", "(", "mult", "==", "1", "&&", "rtx_equal_p", "(", "ops", "[", "lreg", "]", ",", "val_rtx", ")", ")", ")", "return", "0", ";", "if", "(", "mult", "!=", "1", "&&", "mult", "!=", "2", "&&", "mult", "!=", "4", ")", "return", "0", ";", "if", "(", "!", "cris_base_p", "(", "reg_rtx", ",", "reload_in_progress", "||", "reload_completed", ")", ")", "return", "0", ";", "return", "1", ";", "}", "internal_error", "(", "\"internal error: %<cris_side_effect_mode_ok%> with bad operands\"", ")", ";", "}", "</s>" ]

[ "Check", "various", "objections", "to", "the", "side-effect", ".", "Used", "in", "the", "test-part", "of", "an", "anonymous", "insn", "describing", "an", "insn", "with", "a", "possible", "side-effect", ".", "Returns", "nonzero", "if", "the", "implied", "side-effect", "is", "ok.", "code", ":", "PLUS", "or", "MULT", "ops", ":", "An", "array", "of", "rtx", ":", "es", ".", "lreg", ",", "rreg", ",", "rval", ",", "The", "variables", "multop", "and", "other_op", "are", "indexes", "into", "this", ",", "or", "-1", "if", "they", "are", "not", "applicable", ".", "lreg", ":", "The", "register", "that", "gets", "assigned", "in", "the", "side-effect", ".", "rreg", ":", "One", "register", "in", "the", "side-effect", "expression", "rval", ":", "The", "other", "register", ",", "or", "an", "int", ".", "multop", ":", "An", "integer", "to", "multiply", "rval", "with", ".", "other_op", ":", "One", "of", "the", "entities", "of", "the", "main", "effect", ",", "whose", "mode", "we", "must", "consider", "." ]

[ "cris", "0", "1", "0", "0", "1", "0", "0", "0", "0", "0", "0", "63", "63", "0", "1", "0", "1", "0", "0", "0", "1", "0", "1", "0", "1", "2", "4", "0", "0", "1", "\"internal error: %<cris_side_effect_mode_ok%> with bad operands\"" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "return", "performAddSubLongCombine", "(", "N", ",", "DCI", ",", "DAG", ")", ";", "case", "ISD", "::", "XOR", ":", "return", "performXorCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "performMulCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "performIntToFpCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "performORCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "performIntrinsicCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "ANY_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "performExtendCombine", "(", "N", ",", "DCI", ",", "DAG", ")", ";", "case", "ISD", "::", "BITCAST", ":", "return", "performBitcastCombine", "(", "N", ",", "DCI", ",", "DAG", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "performConcatVectorsCombine", "(", "N", ",", "DCI", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "performSelectCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "VSELECT", ":", "return", "performVSelectCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "performSTORECombine", "(", "N", ",", "DCI", ",", "DAG", ",", "Subtarget", ")", ";", "case", "AArch64ISD", "::", "BRCOND", ":", "return", "performBRCONDCombine", "(", "N", ",", "DCI", ",", "DAG", ")", ";", "case", "AArch64ISD", "::", "CSEL", ":", "return", "performCONDCombine", "(", "N", ",", "DCI", ",", "DAG", ",", "2", ",", "3", ")", ";", "case", "AArch64ISD", "::", "DUP", ":", "return", "performPostLD1Combine", "(", "N", ",", "DCI", ",", "false", ")", ";", "case", "AArch64ISD", "::", "NVCAST", ":", "return", "performNVCASTCombine", "(", "N", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "performPostLD1Combine", "(", "N", ",", "DCI", ",", "true", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "performAcrossLaneReductionCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "case", "Intrinsic", "::", "aarch64_neon_ld2", ":", "case", "Intrinsic", "::", "aarch64_neon_ld3", ":", "case", "Intrinsic", "::", "aarch64_neon_ld4", ":", "case", "Intrinsic", "::", "aarch64_neon_ld1x2", ":", "case", "Intrinsic", "::", "aarch64_neon_ld1x3", ":", "case", "Intrinsic", "::", "aarch64_neon_ld1x4", ":", "case", "Intrinsic", "::", "aarch64_neon_ld2lane", ":", "case", "Intrinsic", "::", "aarch64_neon_ld3lane", ":", "case", "Intrinsic", "::", "aarch64_neon_ld4lane", ":", "case", "Intrinsic", "::", "aarch64_neon_ld2r", ":", "case", "Intrinsic", "::", "aarch64_neon_ld3r", ":", "case", "Intrinsic", "::", "aarch64_neon_ld4r", ":", "case", "Intrinsic", "::", "aarch64_neon_st2", ":", "case", "Intrinsic", "::", "aarch64_neon_st3", ":", "case", "Intrinsic", "::", "aarch64_neon_st4", ":", "case", "Intrinsic", "::", "aarch64_neon_st1x2", ":", "case", "Intrinsic", "::", "aarch64_neon_st1x3", ":", "case", "Intrinsic", "::", "aarch64_neon_st1x4", ":", "case", "Intrinsic", "::", "aarch64_neon_st2lane", ":", "case", "Intrinsic", "::", "aarch64_neon_st3lane", ":", "case", "Intrinsic", "::", "aarch64_neon_st4lane", ":", "return", "performNEONPostLDSTCombine", "(", "N", ",", "DCI", ",", "DAG", ")", ";", "default", ":", "break", ";", "}", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "ISD::ADD", "ISD::SUB", "ISD::XOR", "ISD::MUL", "ISD::SINT_TO_FP", "ISD::UINT_TO_FP", "ISD::OR", "ISD::INTRINSIC_WO_CHAIN", "ISD::ANY_EXTEND", "ISD::ZERO_EXTEND", "ISD::SIGN_EXTEND", "ISD::BITCAST", "ISD::CONCAT_VECTORS", "ISD::SELECT", "ISD::VSELECT", "ISD::STORE", "AArch64ISD::BRCOND", "AArch64ISD::CSEL", "2", "3", "AArch64ISD::DUP", "AArch64ISD::NVCAST", "ISD::INSERT_VECTOR_ELT", "ISD::EXTRACT_VECTOR_ELT", "ISD::INTRINSIC_VOID", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::aarch64_neon_ld2", "Intrinsic::aarch64_neon_ld3", "Intrinsic::aarch64_neon_ld4", "Intrinsic::aarch64_neon_ld1x2", "Intrinsic::aarch64_neon_ld1x3", "Intrinsic::aarch64_neon_ld1x4", "Intrinsic::aarch64_neon_ld2lane", "Intrinsic::aarch64_neon_ld3lane", "Intrinsic::aarch64_neon_ld4lane", "Intrinsic::aarch64_neon_ld2r", "Intrinsic::aarch64_neon_ld3r", "Intrinsic::aarch64_neon_ld4r", "Intrinsic::aarch64_neon_st2", "Intrinsic::aarch64_neon_st3", "Intrinsic::aarch64_neon_st4", "Intrinsic::aarch64_neon_st1x2", "Intrinsic::aarch64_neon_st1x3", "Intrinsic::aarch64_neon_st1x4", "Intrinsic::aarch64_neon_st2lane", "Intrinsic::aarch64_neon_st3lane", "Intrinsic::aarch64_neon_st4lane" ]

[]

[ "<s>", "int", "use_return_insn", "(", "int", "iscond", ",", "rtx", "sibling", ")", "{", "int", "regno", ";", "unsigned", "int", "func_type", ";", "unsigned", "long", "saved_int_regs", ";", "unsigned", "HOST_WIDE_INT", "stack_adjust", ";", "arm_stack_offsets", "*", "offsets", ";", "if", "(", "!", "reload_completed", ")", "return", "0", ";", "func_type", "=", "arm_current_func_type", "(", ")", ";", "if", "(", "func_type", "&", "(", "ARM_FT_VOLATILE", "|", "ARM_FT_NAKED", "|", "ARM_FT_STACKALIGN", ")", ")", "return", "0", ";", "if", "(", "IS_INTERRUPT", "(", "func_type", ")", "&&", "(", "frame_pointer_needed", "||", "TARGET_THUMB", ")", ")", "return", "0", ";", "if", "(", "TARGET_LDRD", "&&", "current_tune", "->", "prefer_ldrd_strd", "&&", "!", "optimize_function_for_size_p", "(", "cfun", ")", ")", "return", "0", ";", "offsets", "=", "arm_get_frame_offsets", "(", ")", ";", "stack_adjust", "=", "offsets", "->", "outgoing_args", "-", "offsets", "->", "saved_regs", ";", "if", "(", "crtl", "->", "args", ".", "pretend_args_size", "||", "cfun", "->", "machine", "->", "uses_anonymous_args", "||", "crtl", "->", "calls_eh_return", "||", "cfun", "->", "calls_alloca", "||", "!", "(", "stack_adjust", "==", "0", "||", "(", "TARGET_APCS_FRAME", "&&", "frame_pointer_needed", "&&", "stack_adjust", "==", "4", ")", ")", ")", "return", "0", ";", "saved_int_regs", "=", "offsets", "->", "saved_regs_mask", ";", "if", "(", "stack_adjust", "==", "4", "&&", "!", "arm_arch5", "&&", "TARGET_ARM", ")", "{", "if", "(", "!", "call_used_regs", "[", "3", "]", ")", "return", "0", ";", "if", "(", "arm_size_return_regs", "(", ")", ">=", "(", "4", "*", "UNITS_PER_WORD", ")", ")", "return", "0", ";", "if", "(", "sibling", ")", "{", "gcc_assert", "(", "CALL_P", "(", "sibling", ")", ")", ";", "if", "(", "find_regno_fusage", "(", "sibling", ",", "USE", ",", "3", ")", ")", "return", "0", ";", "}", "if", "(", "saved_int_regs", "&", "0x7", ")", "return", "0", ";", "}", "if", "(", "TARGET_INTERWORK", "&&", "saved_int_regs", "!=", "0", "&&", "!", "IS_INTERRUPT", "(", "func_type", ")", ")", "return", "0", ";", "if", "(", "iscond", "&&", "arm_tune_strongarm", ")", "{", "if", "(", "saved_int_regs", "!=", "0", "&&", "saved_int_regs", "!=", "(", "1", "<<", "LR_REGNUM", ")", ")", "return", "0", ";", "if", "(", "flag_pic", "&&", "arm_pic_register", "!=", "INVALID_REGNUM", "&&", "df_regs_ever_live_p", "(", "PIC_OFFSET_TABLE_REGNUM", ")", ")", "return", "0", ";", "}", "if", "(", "saved_int_regs", "&&", "!", "(", "saved_int_regs", "&", "(", "1", "<<", "LR_REGNUM", ")", ")", ")", "return", "0", ";", "if", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_VFP", ")", "for", "(", "regno", "=", "FIRST_VFP_REGNUM", ";", "regno", "<=", "LAST_VFP_REGNUM", ";", "regno", "++", ")", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "return", "0", ";", "if", "(", "TARGET_REALLY_IWMMXT", ")", "for", "(", "regno", "=", "FIRST_IWMMXT_REGNUM", ";", "regno", "<=", "LAST_IWMMXT_REGNUM", ";", "regno", "++", ")", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "function", "'s", "epilogue", "can", "be", "output", "as", "RTL", "." ]

[ "arm", "0", "0", "0", "0", "0", "4", "0", "4", "3", "0", "4", "0", "3", "0", "0x7", "0", "0", "0", "0", "1", "0", "0", "1", "0", "0", "0", "1" ]

[]

[ "<s>", "static", "void", "adjust_xxpermdi", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "set", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "select", "=", "XEXP", "(", "set", ",", "1", ")", ";", "rtx", "concat", "=", "XEXP", "(", "select", ",", "0", ")", ";", "rtx", "src0", "=", "XEXP", "(", "concat", ",", "0", ")", ";", "XEXP", "(", "concat", ",", "0", ")", "=", "XEXP", "(", "concat", ",", "1", ")", ";", "XEXP", "(", "concat", ",", "1", ")", "=", "src0", ";", "rtx", "parallel", "=", "XEXP", "(", "select", ",", "1", ")", ";", "int", "lane0", "=", "INTVAL", "(", "XVECEXP", "(", "parallel", ",", "0", ",", "0", ")", ")", ";", "int", "lane1", "=", "INTVAL", "(", "XVECEXP", "(", "parallel", ",", "0", ",", "1", ")", ")", ";", "int", "new_lane0", "=", "3", "-", "lane1", ";", "int", "new_lane1", "=", "3", "-", "lane0", ";", "XVECEXP", "(", "parallel", ",", "0", ",", "0", ")", "=", "GEN_INT", "(", "new_lane0", ")", ";", "XVECEXP", "(", "parallel", ",", "0", ",", "1", ")", "=", "GEN_INT", "(", "new_lane1", ")", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "df_insn_rescan", "(", "insn", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Changing lanes for xxpermdi %d\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Given", "OP", "that", "contains", "an", "XXPERMDI", "operation", "(", "that", "is", "not", "a", "doubleword", "swap", ")", ",", "reverse", "the", "order", "of", "the", "source", "operands", "and", "adjust", "the", "indices", "of", "the", "source", "lanes", "to", "account", "for", "doubleword", "reversal", "." ]

[ "powerpcspe", "1", "0", "0", "0", "1", "1", "1", "0", "0", "0", "1", "3", "3", "0", "0", "0", "1", "1", "\"Changing lanes for xxpermdi %d\\n\"" ]

[]

[ "<s>", "const", "char", "*", "LC3bAsmPrinter", "::", "getCurrentABIString", "(", ")", "const", "{", "llvm_unreachable", "(", "\"Unknown LC3b ABI\"", ")", ";", ";", "}", "</s>" ]

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

[ "LC3b", "LC3b", "\"Unknown LC3b ABI\"" ]

[]

[ "<s>", "static", "bool", "legitimate_scaled_address_p", "(", "machine_mode", "mode", ",", "rtx", "op", ",", "bool", "strict", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "PLUS", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "!=", "MULT", ")", "return", "false", ";", "if", "(", "!", "RTX_OK_FOR_INDEX_P", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ",", "strict", ")", ")", "return", "false", ";", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", ")", "return", "false", ";", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "2", ":", "if", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", "!=", "2", ")", "return", "false", ";", "break", ";", "case", "8", ":", "if", "(", "!", "TARGET_LL64", ")", "return", "false", ";", "case", "4", ":", "if", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", "!=", "4", ")", "return", "false", ";", "default", ":", "return", "false", ";", "}", "if", "(", "RTX_OK_FOR_BASE_P", "(", "XEXP", "(", "op", ",", "1", ")", ",", "(", "strict", ")", ")", ")", "return", "true", ";", "if", "(", "flag_pic", ")", "{", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "if", "(", "legitimate_small_data_address_p", "(", "op", ")", ")", "return", "false", ";", "if", "(", "CONSTANT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "TRUE", "if", "op", "is", "an", "scaled", "address", "." ]

[ "arc", "0", "0", "0", "0", "1", "2", "0", "1", "2", "8", "4", "0", "1", "4", "1", "1", "1" ]

[]

[ "<s>", "MachineBasicBlock", "*", "RISCVTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "case", "RISCV", "::", "ReadCycleWide", ":", "assert", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "\"ReadCycleWrite is only to be used on riscv32\"", ")", ";", "return", "emitReadCycleWidePseudo", "(", "MI", ",", "BB", ")", ";", "case", "RISCV", "::", "Select_GPR_Using_CC_GPR", ":", "case", "RISCV", "::", "Select_GPCR_Using_CC_GPR", ":", "case", "RISCV", "::", "Select_FPR16_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::ReadCycleWide", "\"ReadCycleWrite is only to be used on riscv32\"", "RISCV::Select_GPR_Using_CC_GPR", "RISCV::Select_GPCR_Using_CC_GPR", "RISCV::Select_FPR16_Using_CC_GPR", "RISCV::Select_FPR32_Using_CC_GPR", "RISCV::Select_FPR64_Using_CC_GPR", "RISCV::BuildPairF64Pseudo", "RISCV::SplitF64Pseudo" ]

[]

[ "<s>", "void", "addBlock", "(", "MachineBasicBlock", "*", "MBB", ")", "{", "Blocks", ".", "push_back", "(", "MBB", ")", ";", "BlockSet", ".", "insert", "(", "MBB", ")", ";", "}", "</s>" ]

[ "Add", "block", "data", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "const", "SparcSubtarget", "*", "SparcTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "CPUAttr", ".", "isValid", "(", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "FSAttr", ".", "isValid", "(", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "bool", "softFloat", "=", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ".", "getValueAsBool", "(", ")", ";", "if", "(", "softFloat", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\",+soft-float\"", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "SparcSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "this", "->", "is64Bit", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc", "\"target-cpu\"", "\"target-features\"", "\"use-soft-float\"", "\"+soft-float\"", "\",+soft-float\"", "Sparc" ]

[]

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

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

[ "AGC", "\"AGC Assembly Printer\"" ]

[]

[ "<s>", "bool", "M68kOperand", "::", "isImm", "(", ")", "const", "{", "return", "Kind", "==", "Kind", "::", "Imm", ";", "}", "</s>" ]

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "M68k", "M68k" ]

[]

[ "<s>", "int", "standard_sse_constant_p", "(", "rtx", "x", ",", "machine_mode", "pred_mode", ")", "{", "machine_mode", "mode", ";", "if", "(", "!", "TARGET_SSE", ")", "return", "0", ";", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "x", "==", "const0_rtx", "||", "const0_operand", "(", "x", ",", "mode", ")", ")", "return", "1", ";", "if", "(", "x", "==", "constm1_rtx", "||", "vector_all_ones_operand", "(", "x", ",", "mode", ")", "||", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_FLOAT", "||", "GET_MODE_CLASS", "(", "pred_mode", ")", "==", "MODE_VECTOR_FLOAT", ")", "&&", "float_vector_all_ones_operand", "(", "x", ",", "mode", ")", ")", ")", "{", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "pred_mode", ";", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "64", ":", "if", "(", "TARGET_AVX512F", ")", "return", "2", ";", "break", ";", "case", "32", ":", "if", "(", "TARGET_AVX2", ")", "return", "2", ";", "break", ";", "case", "16", ":", "if", "(", "TARGET_SSE2", ")", "return", "2", ";", "break", ";", "case", "0", ":", "gcc_unreachable", "(", ")", ";", "default", ":", "break", ";", "}", "}", "if", "(", "vector_all_ones_zero_extend_half_operand", "(", "x", ",", "mode", ")", "||", "vector_all_ones_zero_extend_quarter_operand", "(", "x", ",", "mode", ")", ")", "return", "3", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "X", "is", "all", "0s", "and", "2", "if", "x", "is", "all", "1s", "in", "supported", "SSE/AVX", "vector", "mode", "." ]

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

[]

[ "<s>", "bool", "BlackfinIntrinsicInfo", "::", "isOverloaded", "(", "unsigned", "IntrID", ")", "const", "{", "const", "bool", "OTable", "[", "]", "=", "{", "}", ";", "if", "(", "IntrID", "==", "0", ")", "return", "false", ";", "else", "return", "OTable", "[", "IntrID", "-", "Intrinsic", "::", "num_intrinsics", "]", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "intrinsic", "can", "be", "overloaded", "." ]

[ "Blackfin", "0", "Intrinsic::num_intrinsics" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "Op", "->", "dump", "(", "&", "DAG", ")", ";", "llvm_unreachable", "(", "\"Custom lowering code for this\"", "\"instruction is not implemented yet!\"", ")", ";", "break", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "LowerSIGN_EXTEND_INREG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "LowerEXTRACT_SUBVECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIVREM", ":", "return", "LowerUDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "return", "LowerSDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FREM", ":", "return", "LowerFREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCEIL", ":", "return", "LowerFCEIL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FTRUNC", ":", "return", "LowerFTRUNC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRINT", ":", "return", "LowerFRINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FNEARBYINT", ":", "return", "LowerFNEARBYINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FROUND", ":", "return", "LowerFROUND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FFLOOR", ":", "return", "LowerFFLOOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerUINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_UINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTLZ", ":", "case", "ISD", "::", "CTLZ_ZERO_UNDEF", ":", "return", "LowerCTLZ", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "}", "return", "Op", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "r10k_protected_bb_p", "(", "basic_block", "bb", ",", "sbitmap", "protected_bbs", ")", "{", "edge_iterator", "ei", ";", "edge", "e", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "bb", "->", "preds", ")", "if", "(", "!", "single_succ_p", "(", "e", "->", "src", ")", "||", "!", "bitmap_bit_p", "(", "protected_bbs", ",", "e", "->", "src", "->", "index", ")", "||", "(", "e", "->", "flags", "&", "EDGE_COMPLEX", ")", "!=", "0", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "BB", "is", "only", "reached", "by", "blocks", "in", "PROTECTED_BBS", "and", "if", "every", "edge", "is", "unconditional", "." ]

[ "mips", "0" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"SPARC DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "Sparc", "\"SPARC DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "bool", "convertSelectOfConstantsToMath", "(", "EVT", "VT", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "select", "of", "constants", "(", "select", "Cond", ",", "C1", ",", "C2", ")", "should", "be", "transformed", "into", "simple", "math", "ops", "with", "the", "condition", "value", "." ]

[ "RI5CY" ]

[]

[ "<s>", "bool", "runOnFunction", "(", "Function", "&", "F", ")", "override", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "std", "::", "set", "<", "Instruction", "*", ">", "WorkList", ";", "for", "(", "Instruction", "&", "I", ":", "instructions", "(", "&", "F", ")", ")", "WorkList", ".", "insert", "(", "&", "I", ")", ";", "while", "(", "!", "WorkList", ".", "empty", "(", ")", ")", "{", "Instruction", "*", "I", "=", "*", "WorkList", ".", "begin", "(", ")", ";", "WorkList", ".", "erase", "(", "WorkList", ".", "begin", "(", ")", ")", ";", "if", "(", "!", "I", "->", "use_empty", "(", ")", ")", "{", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "TPC" ]

[]

[ "<s>", "virtual", "const", "X86Subtarget", "*", "getSubtarget", "(", ")", "{", "return", "Subtarget", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Patmos Single-Path Bundling (machine code)\"", ";", "}", "</s>" ]

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

[ "Patmos", "\"Patmos Single-Path Bundling (machine code)\"" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "APInt", "&", "KnownZero", ",", "APInt", "&", "KnownOne", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "BitWidth", "=", "KnownOne", ".", "getBitWidth", "(", ")", ";", "KnownZero", "=", "KnownOne", "=", "APInt", "(", "BitWidth", ",", "0", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARMISD", "::", "ADDC", ":", "case", "ARMISD", "::", "ADDE", ":", "case", "ARMISD", "::", "SUBC", ":", "case", "ARMISD", "::", "SUBE", ":", "if", "(", "Op", ".", "getResNo", "(", ")", "==", "0", ")", "break", ";", "KnownZero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "1", ")", ";", "break", ";", "case", "ARMISD", "::", "CMOV", ":", "{", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "KnownZero", ",", "KnownOne", ",", "Depth", "+", "1", ")", ";", "if", "(", "KnownZero", "==", "0", "&&", "KnownOne", "==", "0", ")", "return", ";", "APInt", "KnownZeroRHS", ",", "KnownOneRHS", ";", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "KnownZeroRHS", ",", "KnownOneRHS", ",", "Depth", "+", "1", ")", ";", "KnownZero", "&=", "KnownZeroRHS", ";", "KnownOne", "&=", "KnownOneRHS", ";", "return", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "ConstantSDNode", "*", "CN", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "1", ")", ")", ";", "Intrinsic", "::", "ID", "IntID", "=", "static_cast", "<", "Intrinsic", "::", "ID", ">", "(", "CN", "->", "getZExtValue", "(", ")", ")", ";", "switch", "(", "IntID", ")", "{", "default", ":", "return", ";", "case", "Intrinsic", "::", "arm_ldaex", ":", "case", "Intrinsic", "::", "arm_ldrex", ":", "{", "EVT", "VT", "=", "cast", "<", "MemIntrinsicSDNode", ">", "(", "Op", ")", "->", "getMemoryVT", "(", ")", ";", "unsigned", "MemBits", "=", "VT", ".", "getScalarType", "(", ")", ".", "getSizeInBits", "(", ")", ";", "KnownZero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "MemBits", ")", ";", "return", ";", "}", "}", "}", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "ARMISD::ADDC", "ARMISD::ADDE", "ARMISD::SUBC", "ARMISD::SUBE", "0", "1", "ARMISD::CMOV", "0", "1", "0", "0", "1", "1", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::ID", "Intrinsic::ID", "Intrinsic::arm_ldaex", "Intrinsic::arm_ldrex" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Hexagon Split Const32s and Const64s\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon Split Const32s and Const64s\"" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "getRegAllocationHints", "(", "Register", "VirtReg", ",", "ArrayRef", "<", "MCPhysReg", ">", "Order", ",", "SmallVectorImpl", "<", "MCPhysReg", ">", "&", "Hints", ",", "const", "MachineFunction", "&", "MF", ",", "const", "VirtRegMap", "*", "VRM", ",", "const", "LiveRegMatrix", "*", "Matrix", ")", "const", "{", "const", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "BaseImplRetVal", "=", "TargetRegisterInfo", "::", "getRegAllocationHints", "(", "VirtReg", ",", "Order", ",", "Hints", ",", "MF", ",", "VRM", ",", "Matrix", ")", ";", "for", "(", "MachineInstr", "&", "Use", ":", "MRI", "->", "reg_nodbg_instructions", "(", "VirtReg", ")", ")", "{", "const", "MachineOperand", "*", "ResultOp", "=", "nullptr", ";", "Register", "ResultReg", ";", "switch", "(", "Use", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "COPY", ":", "{", "ResultOp", "=", "&", "Use", ".", "getOperand", "(", "0", ")", ";", "ResultReg", "=", "ResultOp", "->", "getReg", "(", ")", ";", "if", "(", "Register", "::", "isVirtualRegister", "(", "ResultReg", ")", "&&", "MRI", "->", "getRegClass", "(", "ResultReg", ")", "->", "contains", "(", "PPC", "::", "UACC0", ")", "&&", "VRM", "->", "hasPhys", "(", "ResultReg", ")", ")", "{", "Register", "UACCPhys", "=", "VRM", "->", "getPhys", "(", "ResultReg", ")", ";", "Register", "HintReg", "=", "getSubReg", "(", "UACCPhys", ",", "ResultOp", "->", "getSubReg", "(", ")", ")", ";", "if", "(", "HintReg", ">=", "PPC", "::", "VSRp0", "&&", "HintReg", "<=", "PPC", "::", "VSRp31", ")", "Hints", ".", "push_back", "(", "HintReg", ")", ";", "}", "break", ";", "}", "case", "PPC", "::", "BUILD_UACC", ":", "{", "ResultOp", "=", "&", "Use", ".", "getOperand", "(", "0", ")", ";", "ResultReg", "=", "ResultOp", "->", "getReg", "(", ")", ";", "if", "(", "MRI", "->", "getRegClass", "(", "ResultReg", ")", "->", "contains", "(", "PPC", "::", "ACC0", ")", "&&", "VRM", "->", "hasPhys", "(", "ResultReg", ")", ")", "{", "Register", "ACCPhys", "=", "VRM", "->", "getPhys", "(", "ResultReg", ")", ";", "assert", "(", "(", "ACCPhys", ">=", "PPC", "::", "ACC0", "&&", "ACCPhys", "<=", "PPC", "::", "ACC7", ")", "&&", "\"Expecting an ACC register for BUILD_UACC.\"", ")", ";", "Register", "HintReg", "=", "PPC", "::", "UACC0", "+", "(", "ACCPhys", "-", "PPC", "::", "ACC0", ")", ";", "Hints", ".", "push_back", "(", "HintReg", ")", ";", "}", "break", ";", "}", "}", "}", "return", "BaseImplRetVal", ";", "}", "</s>" ]

[ "Get", "a", "list", "of", "'hint", "'", "registers", "that", "the", "register", "allocator", "should", "try", "first", "when", "allocating", "a", "physical", "register", "for", "the", "virtual", "register", "VirtReg", "." ]

[ "PowerPC", "PPC", "0", "PPC::UACC0", "PPC::VSRp0", "PPC::VSRp31", "PPC::BUILD_UACC", "0", "PPC::ACC0", "PPC::ACC0", "PPC::ACC7", "\"Expecting an ACC register for BUILD_UACC.\"", "PPC::UACC0", "PPC::ACC0" ]

[]

[ "<s>", "SDValue", "BPFTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "break", ";", "}", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_BPF64", ")", ";", "for", "(", "auto", "&", "VA", ":", "ArgLocs", ")", "{", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "switch", "(", "RegVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "{", "errs", "(", ")", "<<", "\"LowerFormalArguments Unhandled argument type: \"", "<<", "RegVT", ".", "getEVTString", "(", ")", "<<", "'\\n'", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "case", "MVT", "::", "i64", ":", "unsigned", "VReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "BPF", "::", "GPRRegClass", ")", ";", "RegInfo", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "SDValue", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VReg", ",", "RegVT", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "DL", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "DL", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "ArgValue", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "}", "}", "else", "{", "fail", "(", "DL", ",", "DAG", ",", "\"defined with too many args\"", ")", ";", "InVals", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "}", "if", "(", "IsVarArg", "||", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "fail", "(", "DL", ",", "DAG", ",", "\"functions with VarArgs or StructRet are not supported\"", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "ISD::InputArg", "\"Unsupported calling convention\"", "16", "BPF", "\"LowerFormalArguments Unhandled argument type: \"", "0", "MVT::i64", "BPF::GPRRegClass", "ISD::AssertSext", "ISD::AssertZext", "ISD::TRUNCATE", "\"defined with too many args\"", "0", "\"functions with VarArgs or StructRet are not supported\"" ]

[]

[ "<s>", "static", "int", "arc_sched_adjust_priority", "(", "rtx_insn", "*", "insn", ",", "int", "priority", ")", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", "&&", "GET_MODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "DFmode", "&&", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "REG", ")", "{", "return", "priority", "+", "20", ";", "}", "return", "priority", ";", "}", "</s>" ]

[ "Try", "to", "keep", "the", "(", "mov", ":", "DF", "_", ",", "reg", ")", "as", "early", "as", "possible", "so", "that", "the", "d", "<", "add/sub/mul", ">", "h-lr", "insns", "appear", "together", "and", "can", "use", "the", "peephole2", "pattern", "." ]

[ "arc", "20" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "X86RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "assert", "(", "MF", "&&", "\"MachineFunction required\"", ")", ";", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "HasSSE", "=", "Subtarget", ".", "hasSSE1", "(", ")", ";", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "Subtarget", ".", "hasAVX512", "(", ")", ";", "bool", "CallsEHReturn", "=", "MF", "->", "callsEHReturn", "(", ")", ";", "CallingConv", "::", "ID", "CC", "=", "MF", "->", "getFunction", "(", ")", "->", "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", ")", "{", "if", "(", "IsWin64", ")", "{", "if", "(", "!", "HasSSE", ")", "return", "CSR_Win64_NoSSE_SaveList", ";", "return", "CSR_Win64_SaveList", ";", "}", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "if", "(", "Subtarget", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", "->", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_64_SwiftError_SaveList", ";", "return", "CSR_64_SaveList", ";", "}", "if", "(", "CallsEHReturn", ")", "return", "CSR_32EHRet_SaveList", ";", "return", "CSR_32_SaveList", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Thumb IT blocks insertion pass\"", ";", "}", "</s>" ]

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

[ "ARM", "\"Thumb IT blocks insertion pass\"" ]

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "BuildSDIVPow2", "(", "SDNode", "*", "N", ",", "const", "APInt", "&", "Divisor", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDNode", "*", ">", "&", "Created", ")", "const", "{", "AttributeList", "Attr", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ";", "if", "(", "isIntDivCheap", "(", "N", "->", "getValueType", "(", "0", ")", ",", "Attr", ")", ")", "return", "SDValue", "(", "N", ",", "0", ")", ";", "assert", "(", "(", "Divisor", ".", "isPowerOf2", "(", ")", "||", "Divisor", ".", "isNegatedPowerOf2", "(", ")", ")", "&&", "\"Unexpected divisor!\"", ")", ";", "if", "(", "!", "Subtarget", ".", "hasStdExtZbt", "(", ")", ")", "return", "SDValue", "(", ")", ";", "unsigned", "Lg2", "=", "Divisor", ".", "countTrailingZeros", "(", ")", ";", "if", "(", "Lg2", "==", "1", "||", "Lg2", ">=", "12", ")", "return", "SDValue", "(", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "VT", "!=", "MVT", "::", "i32", "&&", "!", "(", "Subtarget", ".", "is64Bit", "(", ")", "&&", "VT", "==", "MVT", "::", "i64", ")", ")", "return", "SDValue", "(", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Zero", "=", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "VT", ")", ";", "SDValue", "Pow2MinusOne", "=", "DAG", ".", "getConstant", "(", "(", "1ULL", "<<", "Lg2", ")", "-", "1", ",", "DL", ",", "VT", ")", ";", "SDValue", "Cmp", "=", "DAG", ".", "getSetCC", "(", "DL", ",", "VT", ",", "N0", ",", "Zero", ",", "ISD", "::", "SETLT", ")", ";", "SDValue", "Add", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "VT", ",", "N0", ",", "Pow2MinusOne", ")", ";", "SDValue", "Sel", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT", ",", "DL", ",", "VT", ",", "Cmp", ",", "Add", ",", "N0", ")", ";", "Created", ".", "push_back", "(", "Cmp", ".", "getNode", "(", ")", ")", ";", "Created", ".", "push_back", "(", "Add", ".", "getNode", "(", ")", ")", ";", "Created", ".", "push_back", "(", "Sel", ".", "getNode", "(", ")", ")", ";", "SDValue", "SRA", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRA", ",", "DL", ",", "VT", ",", "Sel", ",", "DAG", ".", "getConstant", "(", "Lg2", ",", "DL", ",", "VT", ")", ")", ";", "if", "(", "Divisor", ".", "isNonNegative", "(", ")", ")", "return", "SRA", ";", "Created", ".", "push_back", "(", "SRA", ".", "getNode", "(", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "DL", ",", "VT", ",", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "VT", ")", ",", "SRA", ")", ";", "}", "</s>" ]

[ "Targets", "may", "override", "this", "function", "to", "provide", "custom", "SDIV", "lowering", "for", "power-of-2", "denominators", "." ]

[ "RISCV", "RISCV", "0", "0", "\"Unexpected divisor!\"", "1", "12", "0", "MVT::i32", "MVT::i64", "0", "0", "1ULL", "1", "ISD::SETLT", "ISD::ADD", "ISD::SELECT", "ISD::SRA", "ISD::SUB", "0" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "bool", "FPS", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "FPIsUsed", "=", "false", ";", "assert", "(", "X86", "::", "FP6", "==", "X86", "::", "FP0", "+", "6", "&&", "\"Register enums aren't sorted right!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<=", "6", ";", "++", "i", ")", "if", "(", "MF", ".", "getRegInfo", "(", ")", ".", "isPhysRegUsed", "(", "X86", "::", "FP0", "+", "i", ")", ")", "{", "FPIsUsed", "=", "true", ";", "break", ";", "}", "if", "(", "!", "FPIsUsed", ")", "return", "false", ";", "Bundles", "=", "&", "getAnalysis", "<", "EdgeBundles", ">", "(", ")", ";", "TII", "=", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bundleCFG", "(", "MF", ")", ";", "StackTop", "=", "0", ";", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "8", ">", "Processed", ";", "MachineBasicBlock", "*", "Entry", "=", "MF", ".", "begin", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "df_ext_iterator", "<", "MachineBasicBlock", "*", ",", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "8", ">", ">", "I", "=", "df_ext_begin", "(", "Entry", ",", "Processed", ")", ",", "E", "=", "df_ext_end", "(", "Entry", ",", "Processed", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Changed", "|=", "processBasicBlock", "(", "MF", ",", "*", "*", "I", ")", ";", "if", "(", "MF", ".", "size", "(", ")", "!=", "Processed", ".", "size", "(", ")", ")", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "E", ";", "++", "BB", ")", "if", "(", "Processed", ".", "insert", "(", "BB", ")", ")", "Changed", "|=", "processBasicBlock", "(", "MF", ",", "*", "BB", ")", ";", "LiveBundles", ".", "clear", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86::FP6", "X86::FP0", "6", "\"Register enums aren't sorted right!\"", "0", "6", "X86::FP0", "0", "8", "8" ]

[]

[ "<s>", "FastISel", "*", "ARM", "::", "createFastISel", "(", "FunctionLoweringInfo", "&", "funcInfo", ",", "const", "TargetLibraryInfo", "*", "libInfo", ")", "{", "const", "TargetMachine", "&", "TM", "=", "funcInfo", ".", "MF", "->", "getTarget", "(", ")", ";", "const", "ARMSubtarget", "*", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", "->", "isTargetIOS", "(", ")", "&&", "!", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "new", "ARMFastISel", "(", "funcInfo", ",", "libInfo", ")", ";", "return", "0", ";", "}", "</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", "0" ]

[]

[ "<s>", "bool", "aarch64_emit_approx_div", "(", "rtx", "quo", ",", "rtx", "num", ",", "rtx", "den", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "quo", ")", ";", "if", "(", "GET_MODE_INNER", "(", "mode", ")", "==", "HFmode", ")", "return", "false", ";", "bool", "use_approx_division_p", "=", "(", "flag_mlow_precision_div", "||", "(", "aarch64_tune_params", ".", "approx_modes", "->", "division", "&", "AARCH64_APPROX_MODE", "(", "mode", ")", ")", ")", ";", "if", "(", "!", "flag_finite_math_only", "||", "flag_trapping_math", "||", "!", "flag_unsafe_math_optimizations", "||", "optimize_function_for_size_p", "(", "cfun", ")", "||", "!", "use_approx_division_p", ")", "return", "false", ";", "if", "(", "!", "TARGET_SIMD", "&&", "VECTOR_MODE_P", "(", "mode", ")", ")", "return", "false", ";", "rtx", "xrcp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "(", "*", "get_recpe_type", "(", "mode", ")", ")", "(", "xrcp", ",", "den", ")", ")", ";", "int", "iterations", "=", "(", "GET_MODE_INNER", "(", "mode", ")", "==", "DFmode", ")", "?", "3", ":", "2", ";", "if", "(", "flag_mlow_precision_div", ")", "iterations", "--", ";", "rtx", "xtmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "while", "(", "iterations", "--", ")", "{", "emit_insn", "(", "(", "*", "get_recps_type", "(", "mode", ")", ")", "(", "xtmp", ",", "xrcp", ",", "den", ")", ")", ";", "if", "(", "iterations", ">", "0", ")", "emit_set_insn", "(", "xrcp", ",", "gen_rtx_MULT", "(", "mode", ",", "xrcp", ",", "xtmp", ")", ")", ";", "}", "if", "(", "num", "!=", "CONST1_RTX", "(", "mode", ")", ")", "{", "rtx", "xnum", "=", "force_reg", "(", "mode", ",", "num", ")", ";", "emit_set_insn", "(", "xrcp", ",", "gen_rtx_MULT", "(", "mode", ",", "xrcp", ",", "xnum", ")", ")", ";", "}", "emit_set_insn", "(", "quo", ",", "gen_rtx_MULT", "(", "mode", ",", "xrcp", ",", "xtmp", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Emit", "the", "instruction", "sequence", "to", "compute", "the", "approximation", "for", "the", "division", "of", "NUM", "by", "DEN", "in", "QUO", "and", "return", "whether", "the", "sequence", "was", "emitted", "or", "not", "." ]

[ "aarch64", "3", "2", "0" ]

[]

[ "<s>", "SDValue", "TGSITargetLowering", "::", "LowerOperation", "(", "SDValue", "op", ",", "SelectionDAG", "&", "dag", ")", "const", "{", "switch", "(", "op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "{", "unsigned", "IntrinsicID", "=", "cast", "<", "ConstantSDNode", ">", "(", "op", ".", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", ";", "EVT", "VT", "=", "op", ".", "getValueType", "(", ")", ";", "switch", "(", "IntrinsicID", ")", "{", "case", "Intrinsic", "::", "tgsi_read_blockid_x", ":", "return", "CreateLiveInRegister", "(", "dag", ",", "&", "TGSI", "::", "IRegsRegClass", ",", "TGSI_BLOCK_ID", "(", "x", ")", ",", "VT", ")", ";", "case", "Intrinsic", "::", "tgsi_read_blockid_y", ":", "return", "CreateLiveInRegister", "(", "dag", ",", "&", "TGSI", "::", "IRegsRegClass", ",", "TGSI_BLOCK_ID", "(", "y", ")", ",", "VT", ")", ";", "case", "Intrinsic", "::", "tgsi_read_blockid_z", ":", "return", "CreateLiveInRegister", "(", "dag", ",", "&", "TGSI", "::", "IRegsRegClass", ",", "TGSI_BLOCK_ID", "(", "z", ")", ",", "VT", ")", ";", "case", "Intrinsic", "::", "tgsi_read_blocksize_x", ":", "return", "CreateLiveInRegister", "(", "dag", ",", "&", "TGSI", "::", "IRegsRegClass", ",", "TGSI_BLOCK_SIZE", "(", "x", ")", ",", "VT", ")", ";", "case", "Intrinsic", "::", "tgsi_read_blocksize_y", ":", "return", "CreateLiveInRegister", "(", "dag", ",", "&", "TGSI", "::", "IRegsRegClass", ",", "TGSI_BLOCK_SIZE", "(", "y", ")", ",", "VT", ")", ";", "case", "Intrinsic", "::", "tgsi_read_blocksize_z", ":", "return", "CreateLiveInRegister", "(", "dag", ",", "&", "TGSI", "::", "IRegsRegClass", ",", "TGSI_BLOCK_SIZE", "(", "z", ")", ",", "VT", ")", ";", "case", "Intrinsic", "::", "tgsi_read_gridsize_x", ":", "return", "CreateLiveInRegister", "(", "dag", ",", "&", "TGSI", "::", "IRegsRegClass", ",", "TGSI_GRID_SIZE", "(", "x", ")", ",", "VT", ")", ";", "case", "Intrinsic", "::", "tgsi_read_gridsize_y", ":", "return", "CreateLiveInRegister", "(", "dag", ",", "&", "TGSI", "::", "IRegsRegClass", ",", "TGSI_GRID_SIZE", "(", "y", ")", ",", "VT", ")", ";", "case", "Intrinsic", "::", "tgsi_read_gridsize_z", ":", "return", "CreateLiveInRegister", "(", "dag", ",", "&", "TGSI", "::", "IRegsRegClass", ",", "TGSI_GRID_SIZE", "(", "z", ")", ",", "VT", ")", ";", "case", "Intrinsic", "::", "tgsi_read_threadid_x", ":", "return", "CreateLiveInRegister", "(", "dag", ",", "&", "TGSI", "::", "IRegsRegClass", ",", "TGSI_THREAD_ID", "(", "x", ")", ",", "VT", ")", ";", "case", "Intrinsic", "::", "tgsi_read_threadid_y", ":", "return", "CreateLiveInRegister", "(", "dag", ",", "&", "TGSI", "::", "IRegsRegClass", ",", "TGSI_THREAD_ID", "(", "y", ")", ",", "VT", ")", ";", "case", "Intrinsic", "::", "tgsi_read_threadid_z", ":", "return", "CreateLiveInRegister", "(", "dag", ",", "&", "TGSI", "::", "IRegsRegClass", ",", "TGSI_THREAD_ID", "(", "z", ")", ",", "VT", ")", ";", "case", "Intrinsic", "::", "tgsi_read_workdim", ":", "return", "CreateLiveInRegister", "(", "dag", ",", "&", "TGSI", "::", "IRegsRegClass", ",", "TGSI_WORK_DIM", ",", "VT", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Unknown TGSI Intrinsic\"", ")", ";", "}", "break", ";", "}", "default", ":", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "}", "}", "</s>" ]

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

[ "TGSI", "TGSI", "ISD::INTRINSIC_WO_CHAIN", "0", "Intrinsic::tgsi_read_blockid_x", "TGSI::IRegsRegClass", "TGSI", "Intrinsic::tgsi_read_blockid_y", "TGSI::IRegsRegClass", "TGSI", "Intrinsic::tgsi_read_blockid_z", "TGSI::IRegsRegClass", "TGSI", "Intrinsic::tgsi_read_blocksize_x", "TGSI::IRegsRegClass", "TGSI", "Intrinsic::tgsi_read_blocksize_y", "TGSI::IRegsRegClass", "TGSI", "Intrinsic::tgsi_read_blocksize_z", "TGSI::IRegsRegClass", "TGSI", "Intrinsic::tgsi_read_gridsize_x", "TGSI::IRegsRegClass", "TGSI", "Intrinsic::tgsi_read_gridsize_y", "TGSI::IRegsRegClass", "TGSI", "Intrinsic::tgsi_read_gridsize_z", "TGSI::IRegsRegClass", "TGSI", "Intrinsic::tgsi_read_threadid_x", "TGSI::IRegsRegClass", "TGSI", "Intrinsic::tgsi_read_threadid_y", "TGSI::IRegsRegClass", "TGSI", "Intrinsic::tgsi_read_threadid_z", "TGSI::IRegsRegClass", "TGSI", "Intrinsic::tgsi_read_workdim", "TGSI::IRegsRegClass", "TGSI", "\"Unknown TGSI Intrinsic\"", "\"Should not custom lower this!\"" ]

[]

[ "<s>", "void", "s390_expand_vec_compare_cc", "(", "rtx", "target", ",", "enum", "rtx_code", "code", ",", "rtx", "cmp1", ",", "rtx", "cmp2", ",", "bool", "all_p", ")", "{", "machine_mode", "cc_producer_mode", ",", "cc_consumer_mode", ",", "scratch_mode", ";", "rtx", "tmp_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "bool", "swap_p", "=", "false", ";", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "cmp1", ")", ")", "==", "MODE_VECTOR_INT", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "NE", ":", "cc_producer_mode", "=", "CCVEQmode", ";", "break", ";", "case", "GE", ":", "case", "LT", ":", "code", "=", "swap_condition", "(", "code", ")", ";", "swap_p", "=", "true", ";", "case", "GT", ":", "case", "LE", ":", "cc_producer_mode", "=", "CCVIHmode", ";", "break", ";", "case", "GEU", ":", "case", "LTU", ":", "code", "=", "swap_condition", "(", "code", ")", ";", "swap_p", "=", "true", ";", "case", "GTU", ":", "case", "LEU", ":", "cc_producer_mode", "=", "CCVIHUmode", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "scratch_mode", "=", "GET_MODE", "(", "cmp1", ")", ";", "if", "(", "code", "==", "NE", "||", "code", "==", "LE", "||", "code", "==", "LEU", ")", "all_p", "=", "!", "all_p", ";", "cc_consumer_mode", "=", "all_p", "?", "CCVIALLmode", ":", "CCVIANYmode", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "cmp1", ")", ")", "==", "MODE_VECTOR_FLOAT", ")", "{", "bool", "inv_p", "=", "false", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "cc_producer_mode", "=", "CCVEQmode", ";", "break", ";", "case", "NE", ":", "cc_producer_mode", "=", "CCVEQmode", ";", "inv_p", "=", "true", ";", "break", ";", "case", "GT", ":", "cc_producer_mode", "=", "CCVFHmode", ";", "break", ";", "case", "GE", ":", "cc_producer_mode", "=", "CCVFHEmode", ";", "break", ";", "case", "UNLE", ":", "cc_producer_mode", "=", "CCVFHmode", ";", "inv_p", "=", "true", ";", "break", ";", "case", "UNLT", ":", "cc_producer_mode", "=", "CCVFHEmode", ";", "inv_p", "=", "true", ";", "break", ";", "case", "LT", ":", "cc_producer_mode", "=", "CCVFHmode", ";", "code", "=", "GT", ";", "swap_p", "=", "true", ";", "break", ";", "case", "LE", ":", "cc_producer_mode", "=", "CCVFHEmode", ";", "code", "=", "GE", ";", "swap_p", "=", "true", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "scratch_mode", "=", "mode_for_vector", "(", "int_mode_for_mode", "(", "GET_MODE_INNER", "(", "GET_MODE", "(", "cmp1", ")", ")", ")", ",", "GET_MODE_NUNITS", "(", "GET_MODE", "(", "cmp1", ")", ")", ")", ";", "gcc_assert", "(", "scratch_mode", "!=", "BLKmode", ")", ";", "if", "(", "inv_p", ")", "all_p", "=", "!", "all_p", ";", "cc_consumer_mode", "=", "all_p", "?", "CCVFALLmode", ":", "CCVFANYmode", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "swap_p", ")", "{", "rtx", "tmp", "=", "cmp2", ";", "cmp2", "=", "cmp1", ";", "cmp1", "=", "tmp", ";", "}", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "cc_producer_mode", ",", "CC_REGNUM", ")", ",", "gen_rtx_COMPARE", "(", "cc_producer_mode", ",", "cmp1", ",", "cmp2", ")", ")", ",", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "scratch_mode", ")", ")", ")", ")", ")", ";", "emit_move_insn", "(", "target", ",", "const0_rtx", ")", ";", "emit_move_insn", "(", "tmp_reg", ",", "const1_rtx", ")", ";", "emit_move_insn", "(", "target", ",", "gen_rtx_IF_THEN_ELSE", "(", "SImode", ",", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "gen_rtx_REG", "(", "cc_consumer_mode", ",", "CC_REGNUM", ")", ",", "const0_rtx", ")", ",", "tmp_reg", ",", "target", ")", ")", ";", "}", "</s>" ]

[ "Expand", "the", "comparison", "CODE", "of", "CMP1", "and", "CMP2", "and", "copy", "1", "or", "0", "into", "TARGET", "if", "either", "all", "(", "ALL_P", "is", "true", ")", "or", "any", "(", "ALL_P", "is", "false", ")", "of", "the", "elements", "in", "CMP1", "and", "CMP2", "fulfill", "the", "comparison", "." ]

[ "s390", "2" ]

[]

[ "<s>", "bool", "arm_pad_reg_upward", "(", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "tree", "type", ",", "int", "first", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_AAPCS_BASED", "&&", "BYTES_BIG_ENDIAN", "&&", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", ")", "&&", "int_size_in_bytes", "(", "type", ")", "<=", "4", ")", "return", "true", ";", "return", "!", "BYTES_BIG_ENDIAN", ";", "}", "</s>" ]

[ "Similarly", ",", "for", "use", "by", "BLOCK_REG_PADDING", "(", "MODE", ",", "TYPE", ",", "FIRST", ")", ".", "For", "non-AAPCS", ",", "return", "!", "BYTES_BIG_ENDIAN", "if", "the", "least", "significant", "byte", "of", "the", "register", "has", "useful", "data", ",", "and", "return", "the", "opposite", "if", "the", "most", "significant", "byte", "does", ".", "For", "AAPCS", ",", "small", "aggregates", "and", "small", "complex", "types", "are", "always", "padded", "upwards", "." ]

[ "arm", "4" ]

[]

[ "<s>", "static", "int", "ia64_mode_to_int", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "BImode", ":", "return", "0", ";", "case", "QImode", ":", "return", "1", ";", "case", "HImode", ":", "return", "2", ";", "case", "SImode", ":", "return", "3", ";", "case", "DImode", ":", "return", "4", ";", "case", "SFmode", ":", "return", "5", ";", "case", "DFmode", ":", "return", "6", ";", "case", "XFmode", ":", "return", "7", ";", "case", "TImode", ":", "return", "SPEC_MODE_INVALID", ";", "default", ":", "return", "SPEC_MODE_INVALID", ";", "}", "}", "</s>" ]

[ "Return", "index", "of", "the", "MODE", "." ]

[ "ia64", "0", "1", "2", "3", "4", "5", "6", "7" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createPostMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "const", "AArch64Subtarget", "&", "ST", "=", "C", "->", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "hasFuseAES", "(", ")", "||", "ST", ".", "hasFuseLiterals", "(", ")", ")", "{", "ScheduleDAGMI", "*", "DAG", "=", "createGenericSchedPostRA", "(", "C", ")", ";", "DAG", "->", "addMutation", "(", "createAArch64MacroFusionDAGMutation", "(", ")", ")", ";", "return", "DAG", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "Similar", "to", "createMachineScheduler", "but", "used", "when", "postRA", "machine", "scheduling", "is", "enabled", "." ]

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

[]

[ "<s>", "int", "nds32_can_use_return_insn", "(", "void", ")", "{", "int", "sp_adjust", ";", "if", "(", "!", "reload_completed", ")", "return", "0", ";", "if", "(", "cfun", "->", "machine", "->", "attr_naked_p", "&&", "!", "flag_ret_in_naked_func", ")", "return", "0", ";", "sp_adjust", "=", "cfun", "->", "machine", "->", "local_size", "+", "cfun", "->", "machine", "->", "out_args_size", "+", "cfun", "->", "machine", "->", "callee_saved_area_gpr_padding_bytes", "+", "cfun", "->", "machine", "->", "callee_saved_fpr_regs_size", ";", "if", "(", "!", "cfun", "->", "machine", "->", "fp_as_gp_p", "&&", "satisfies_constraint_Iu08", "(", "GEN_INT", "(", "sp_adjust", ")", ")", "&&", "NDS32_DOUBLE_WORD_ALIGN_P", "(", "sp_adjust", ")", "&&", "!", "cfun", "->", "calls_alloca", "&&", "NDS32_V3PUSH_AVAILABLE_P", "&&", "!", "(", "TARGET_HARD_FLOAT", "&&", "(", "cfun", "->", "machine", "->", "callee_saved_first_fpr_regno", "!=", "SP_REGNUM", ")", ")", ")", "return", "1", ";", "return", "(", "cfun", "->", "machine", "->", "naked_p", "&&", "(", "cfun", "->", "machine", "->", "va_args_size", "==", "0", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "Optional", "<", "Instruction", "*", ">", "AArch64TTIImpl", "::", "instCombineIntrinsic", "(", "InstCombiner", "&", "IC", ",", "IntrinsicInst", "&", "II", ")", "const", "{", "Intrinsic", "::", "ID", "IID", "=", "II", ".", "getIntrinsicID", "(", ")", ";", "switch", "(", "IID", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "aarch64_sve_convert_from_svbool", ":", "return", "instCombineConvertFromSVBool", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_dup", ":", "return", "instCombineSVEDup", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_dup_x", ":", "return", "instCombineSVEDupX", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cmpne", ":", "case", "Intrinsic", "::", "aarch64_sve_cmpne_wide", ":", "return", "instCombineSVECmpNE", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_rdffr", ":", "return", "instCombineRDFFR", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_lasta", ":", "case", "Intrinsic", "::", "aarch64_sve_lastb", ":", "return", "instCombineSVELast", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cntd", ":", "return", "instCombineSVECntElts", "(", "IC", ",", "II", ",", "2", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cntw", ":", "return", "instCombineSVECntElts", "(", "IC", ",", "II", ",", "4", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cnth", ":", "return", "instCombineSVECntElts", "(", "IC", ",", "II", ",", "8", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cntb", ":", "return", "instCombineSVECntElts", "(", "IC", ",", "II", ",", "16", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_ptest_any", ":", "case", "Intrinsic", "::", "aarch64_sve_ptest_first", ":", "case", "Intrinsic", "::", "aarch64_sve_ptest_last", ":", "return", "instCombineSVEPTest", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_mul", ":", "case", "Intrinsic", "::", "aarch64_sve_fmul", ":", "return", "instCombineSVEVectorMul", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_fadd", ":", "return", "instCombineSVEVectorFAdd", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_fsub", ":", "return", "instCombineSVEVectorBinOp", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_tbl", ":", "return", "instCombineSVETBL", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_uunpkhi", ":", "case", "Intrinsic", "::", "aarch64_sve_uunpklo", ":", "case", "Intrinsic", "::", "aarch64_sve_sunpkhi", ":", "case", "Intrinsic", "::", "aarch64_sve_sunpklo", ":", "return", "instCombineSVEUnpack", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_tuple_get", ":", "return", "instCombineSVETupleGet", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_zip1", ":", "case", "Intrinsic", "::", "aarch64_sve_zip2", ":", "return", "instCombineSVEZip", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_ld1_gather_index", ":", "return", "instCombineLD1GatherIndex", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_st1_scatter_index", ":", "return", "instCombineST1ScatterIndex", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_ld1", ":", "return", "instCombineSVELD1", "(", "IC", ",", "II", ",", "DL", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_st1", ":", "return", "instCombineSVEST1", "(", "IC", ",", "II", ",", "DL", ")", ";", "}", "return", "None", ";", "}", "</s>" ]

[ "Targets", "can", "implement", "their", "own", "combinations", "for", "target-specific", "intrinsics", "." ]

[ "AArch64", "AArch64", "Intrinsic::ID", "Intrinsic::aarch64_sve_convert_from_svbool", "Intrinsic::aarch64_sve_dup", "Intrinsic::aarch64_sve_dup_x", "Intrinsic::aarch64_sve_cmpne", "Intrinsic::aarch64_sve_cmpne_wide", "Intrinsic::aarch64_sve_rdffr", "Intrinsic::aarch64_sve_lasta", "Intrinsic::aarch64_sve_lastb", "Intrinsic::aarch64_sve_cntd", "2", "Intrinsic::aarch64_sve_cntw", "4", "Intrinsic::aarch64_sve_cnth", "8", "Intrinsic::aarch64_sve_cntb", "16", "Intrinsic::aarch64_sve_ptest_any", "Intrinsic::aarch64_sve_ptest_first", "Intrinsic::aarch64_sve_ptest_last", "Intrinsic::aarch64_sve_mul", "Intrinsic::aarch64_sve_fmul", "Intrinsic::aarch64_sve_fadd", "Intrinsic::aarch64_sve_fsub", "Intrinsic::aarch64_sve_tbl", "Intrinsic::aarch64_sve_uunpkhi", "Intrinsic::aarch64_sve_uunpklo", "Intrinsic::aarch64_sve_sunpkhi", "Intrinsic::aarch64_sve_sunpklo", "Intrinsic::aarch64_sve_tuple_get", "Intrinsic::aarch64_sve_zip1", "Intrinsic::aarch64_sve_zip2", "Intrinsic::aarch64_sve_ld1_gather_index", "Intrinsic::aarch64_sve_st1_scatter_index", "Intrinsic::aarch64_sve_ld1", "Intrinsic::aarch64_sve_st1" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "expandPostRAPseudo", "(", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "LOAD_STACK_GUARD", ")", "{", "assert", "(", "getSubtarget", "(", ")", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatMachO", "(", ")", "&&", "\"LOAD_STACK_GUARD currently supported only for MachO.\"", ")", ";", "expandLoadStackGuard", "(", "MI", ")", ";", "MI", ".", "getParent", "(", ")", "->", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "MEMCPY", ")", "{", "expandMEMCPY", "(", "MI", ")", ";", "return", "true", ";", "}", "if", "(", "!", "MI", ".", "isCopy", "(", ")", "||", "Subtarget", ".", "dontWidenVMOVS", "(", ")", "||", "Subtarget", ".", "isFPOnlySP", "(", ")", ")", "return", "false", ";", "unsigned", "DstRegS", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "SrcRegS", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "ARM", "::", "SPRRegClass", ".", "contains", "(", "DstRegS", ",", "SrcRegS", ")", ")", "return", "false", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "unsigned", "DstRegD", "=", "TRI", "->", "getMatchingSuperReg", "(", "DstRegS", ",", "ARM", "::", "ssub_0", ",", "&", "ARM", "::", "DPRRegClass", ")", ";", "unsigned", "SrcRegD", "=", "TRI", "->", "getMatchingSuperReg", "(", "SrcRegS", ",", "ARM", "::", "ssub_0", ",", "&", "ARM", "::", "DPRRegClass", ")", ";", "if", "(", "!", "DstRegD", "||", "!", "SrcRegD", ")", "return", "false", ";", "if", "(", "!", "MI", ".", "definesRegister", "(", "DstRegD", ",", "TRI", ")", "||", "MI", ".", "readsRegister", "(", "DstRegD", ",", "TRI", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"widening: \"", "<<", "MI", ")", ";", "MachineInstrBuilder", "MIB", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "int", "ImpDefIdx", "=", "MI", ".", "findRegisterDefOperandIdx", "(", "DstRegD", ")", ";", "if", "(", "ImpDefIdx", "!=", "-", "1", ")", "MI", ".", "RemoveOperand", "(", "ImpDefIdx", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "ARM", "::", "VMOVD", ")", ")", ";", "MI", ".", "getOperand", "(", "0", ")", ".", "setReg", "(", "DstRegD", ")", ";", "MI", ".", "getOperand", "(", "1", ")", ".", "setReg", "(", "SrcRegD", ")", ";", "MIB", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "MI", ".", "getOperand", "(", "1", ")", ".", "setIsUndef", "(", ")", ";", "MIB", ".", "addReg", "(", "SrcRegS", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isKill", "(", ")", ")", "{", "MI", ".", "getOperand", "(", "1", ")", ".", "setIsKill", "(", "false", ")", ";", "MI", ".", "addRegisterKilled", "(", "SrcRegS", ",", "TRI", ",", "true", ")", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"replaced by: \"", "<<", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "ARM", "ARM", "\"LOAD_STACK_GUARD currently supported only for MachO.\"", "ARM::MEMCPY", "0", "1", "ARM::SPRRegClass", "ARM::ssub_0", "ARM::DPRRegClass", "ARM::ssub_0", "ARM::DPRRegClass", "0", "\"widening: \"", "1", "ARM::VMOVD", "0", "1", "ARMCC::AL", "1", "1", "1", "\"replaced by: \"" ]

[]

[ "<s>", "TargetIRAnalysis", "XCoreTargetMachine", "::", "getTargetIRAnalysis", "(", ")", "{", "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "Function", "&", ")", "{", "return", "TargetTransformInfo", "(", "XCoreTTIImpl", "(", "this", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetIRAnalysis", "appropriate", "for", "the", "target", "." ]

[ "XCore", "XCore", "XCore" ]

[]

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

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

[ "RI5CY" ]

[]

[ "<s>", "void", "WebAssemblyAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"EmitInstruction: \"", "<<", "*", "MI", "<<", "'\\n'", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "ARGUMENT_I32", ":", "case", "WebAssembly", "::", "ARGUMENT_I64", ":", "case", "WebAssembly", "::", "ARGUMENT_F32", ":", "case", "WebAssembly", "::", "ARGUMENT_F64", ":", "break", ";", "case", "WebAssembly", "::", "LOOP_END", ":", "break", ";", "default", ":", "{", "WebAssemblyMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"EmitInstruction: \"", "WebAssembly::ARGUMENT_I32", "WebAssembly::ARGUMENT_I64", "WebAssembly::ARGUMENT_F32", "WebAssembly::ARGUMENT_F64", "WebAssembly::LOOP_END", "WebAssembly" ]

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "static", "bool", "arm_can_inline_p", "(", "tree", "caller", ",", "tree", "callee", ")", "{", "tree", "caller_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "caller", ")", ";", "tree", "callee_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "callee", ")", ";", "bool", "can_inline", "=", "true", ";", "struct", "cl_target_option", "*", "caller_opts", "=", "TREE_TARGET_OPTION", "(", "caller_tree", "?", "caller_tree", ":", "target_option_default_node", ")", ";", "struct", "cl_target_option", "*", "callee_opts", "=", "TREE_TARGET_OPTION", "(", "callee_tree", "?", "callee_tree", ":", "target_option_default_node", ")", ";", "if", "(", "callee_opts", "==", "caller_opts", ")", "return", "true", ";", "struct", "arm_build_target", "caller_target", ";", "struct", "arm_build_target", "callee_target", ";", "caller_target", ".", "isa", "=", "sbitmap_alloc", "(", "isa_num_bits", ")", ";", "callee_target", ".", "isa", "=", "sbitmap_alloc", "(", "isa_num_bits", ")", ";", "arm_configure_build_target", "(", "&", "caller_target", ",", "caller_opts", ",", "false", ")", ";", "arm_configure_build_target", "(", "&", "callee_target", ",", "callee_opts", ",", "false", ")", ";", "if", "(", "!", "bitmap_subset_p", "(", "callee_target", ".", "isa", ",", "caller_target", ".", "isa", ")", ")", "can_inline", "=", "false", ";", "sbitmap_free", "(", "caller_target", ".", "isa", ")", ";", "sbitmap_free", "(", "callee_target", ".", "isa", ")", ";", "return", "can_inline", ";", "}", "</s>" ]

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

[ "arm" ]

[]

[ "<s>", "static", "int", "const_costs", "(", "rtx", "r", ",", "enum", "rtx_code", "c", ")", "{", "HOST_WIDE_INT", "high", ",", "low", ";", "switch", "(", "c", ")", "{", "case", "CONST_INT", ":", "return", "const_costs_int", "(", "INTVAL", "(", "r", ")", ",", "0", ")", ";", "case", "CONST_DOUBLE", ":", "const_double_split", "(", "r", ",", "&", "high", ",", "&", "low", ")", ";", "if", "(", "GET_MODE", "(", "r", ")", "==", "SFmode", ")", "return", "const_costs_int", "(", "high", ",", "1", ")", ";", "else", "return", "const_costs_int", "(", "high", ",", "1", ")", "+", "const_costs_int", "(", "low", ",", "1", ")", ";", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "case", "CONST", ":", "return", "2", ";", "case", "HIGH", ":", "return", "1", ";", "default", ":", "return", "4", ";", "}", "}", "</s>" ]

[ "Return", "the", "cost", "of", "the", "rtx", "R", "with", "code", "CODE", "." ]

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

[]

[ "<s>", "static", "void", "rs6000_conditional_register_usage", "(", "void", ")", "{", "int", "i", ";", "if", "(", "TARGET_DEBUG_TARGET", ")", "fprintf", "(", "stderr", ",", "\"rs6000_conditional_register_usage called\\n\"", ")", ";", "fixed_regs", "[", "64", "]", "=", "1", ";", "if", "(", "TARGET_64BIT", ")", "fixed_regs", "[", "13", "]", "=", "call_used_regs", "[", "13", "]", "=", "call_really_used_regs", "[", "13", "]", "=", "1", ";", "if", "(", "TARGET_SOFT_FLOAT", "||", "!", "TARGET_FPRS", ")", "for", "(", "i", "=", "32", ";", "i", "<", "64", ";", "i", "++", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "call_really_used_regs", "[", "2", "]", "=", "0", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "flag_pic", "==", "2", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "flag_pic", "==", "1", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_really_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "flag_pic", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_really_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "TARGET_TOC", "&&", "TARGET_MINIMAL_TOC", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "TARGET_SPE", ")", "{", "global_regs", "[", "SPEFSCR_REGNO", "]", "=", "1", ";", "fixed_regs", "[", "14", "]", "=", "call_used_regs", "[", "14", "]", "=", "call_really_used_regs", "[", "14", "]", "=", "1", ";", "}", "if", "(", "!", "TARGET_ALTIVEC", "&&", "!", "TARGET_VSX", ")", "{", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", ";", "i", "<=", "LAST_ALTIVEC_REGNO", ";", "++", "i", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "call_really_used_regs", "[", "VRSAVE_REGNO", "]", "=", "1", ";", "}", "if", "(", "TARGET_ALTIVEC", "||", "TARGET_VSX", ")", "global_regs", "[", "VSCR_REGNO", "]", "=", "1", ";", "if", "(", "TARGET_ALTIVEC_ABI", ")", "{", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", ";", "i", "<", "FIRST_ALTIVEC_REGNO", "+", "20", ";", "++", "i", ")", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "if", "(", "TARGET_XCOFF", ")", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", "+", "20", ";", "i", "<", "FIRST_ALTIVEC_REGNO", "+", "32", ";", "++", "i", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "}", "}", "</s>" ]

[ "Change", "register", "usage", "conditional", "on", "target", "flags", "." ]

[ "rs6000", "\"rs6000_conditional_register_usage called\\n\"", "64", "1", "13", "13", "13", "1", "32", "64", "1", "2", "0", "2", "1", "1", "1", "1", "1", "1", "14", "14", "14", "1", "1", "1", "1", "20", "1", "20", "32", "1" ]

[]

[ "<s>", "bool", "RISCVAsmBackend", "::", "shouldInsertExtraNopBytesForCodeAlign", "(", "const", "MCAlignFragment", "&", "AF", ",", "unsigned", "&", "Size", ")", "{", "if", "(", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureRelax", "]", ")", "return", "false", ";", "bool", "HasStdExtC", "=", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureStdExtC", "]", ";", "unsigned", "MinNopLen", "=", "HasStdExtC", "?", "2", ":", "4", ";", "Size", "=", "AF", ".", "getAlignment", "(", ")", "-", "MinNopLen", ";", "return", "true", ";", "}", "</s>" ]

[ "Hook", "to", "check", "if", "extra", "nop", "bytes", "must", "be", "inserted", "for", "alignment", "directive", "." ]

[ "RISCV", "RISCV", "RISCV::FeatureRelax", "RISCV::FeatureStdExtC", "2", "4" ]

[]

[ "<s>", "static", "rtx", "rs6000_mask_atomic_subword", "(", "rtx", "oldval", ",", "rtx", "newval", ",", "rtx", "mask", ")", "{", "rtx", "x", ";", "x", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "x", ",", "gen_rtx_AND", "(", "SImode", ",", "gen_rtx_NOT", "(", "SImode", ",", "mask", ")", ",", "oldval", ")", ")", ")", ";", "x", "=", "expand_simple_binop", "(", "SImode", ",", "IOR", ",", "newval", ",", "x", ",", "x", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "the", "various", "atomic", "expanders", ".", "For", "sub-word", "operands", ",", "combine", "OLDVAL", "and", "NEWVAL", "via", "MASK", ".", "Returns", "a", "new", "pseduo", "." ]

[ "rs6000", "1" ]

[]

[ "<s>", "void", "NVPTXPassConfig", "::", "addIRPasses", "(", ")", "{", "disablePass", "(", "&", "PrologEpilogCodeInserterID", ")", ";", "disablePass", "(", "&", "MachineCopyPropagationID", ")", ";", "disablePass", "(", "&", "BranchFolderPassID", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "addPass", "(", "createGenericToNVVMPass", "(", ")", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "bool", "WebAssemblyLateEHPrepare", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Late EH Prepare **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "getExceptionHandlingType", "(", ")", "!=", "ExceptionHandling", "::", "Wasm", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasPersonalityFn", "(", ")", ")", "{", "recordCatchRetBBs", "(", "MF", ")", ";", "Changed", "|=", "addCatches", "(", "MF", ")", ";", "Changed", "|=", "replaceFuncletReturns", "(", "MF", ")", ";", "}", "Changed", "|=", "removeUnnecessaryUnreachables", "(", "MF", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasPersonalityFn", "(", ")", ")", "{", "Changed", "|=", "addExceptionExtraction", "(", "MF", ")", ";", "Changed", "|=", "restoreStackPointer", "(", "MF", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Late EH Prepare **********\\n\"", "\"********** Function: \"" ]

[]

[ "<s>", "char", "*", "aarch64_output_sve_vector_inc_dec", "(", "const", "char", "*", "operands", ",", "rtx", "x", ")", "{", "int", "factor", ";", "unsigned", "int", "nelts_per_vq", ";", "if", "(", "!", "aarch64_sve_vector_inc_dec_immediate_p", "(", "x", ",", "&", "factor", ",", "&", "nelts_per_vq", ")", ")", "gcc_unreachable", "(", ")", ";", "if", "(", "factor", "<", "0", ")", "return", "aarch64_output_sve_cnt_immediate", "(", "\"dec\"", ",", "operands", ",", "AARCH64_SV_ALL", ",", "-", "factor", ",", "nelts_per_vq", ")", ";", "else", "return", "aarch64_output_sve_cnt_immediate", "(", "\"inc\"", ",", "operands", ",", "AARCH64_SV_ALL", ",", "factor", ",", "nelts_per_vq", ")", ";", "}", "</s>" ]

[ "Return", "the", "asm", "template", "for", "an", "SVE", "vector", "INC", "or", "DEC", "instruction", ".", "OPERANDS", "gives", "the", "operands", "before", "the", "vector", "count", "and", "X", "is", "the", "value", "of", "the", "vector", "count", "operand", "itself", "." ]

[ "aarch64", "0", "\"dec\"", "\"inc\"" ]

[]

[ "<s>", "EVT", "R600TargetLowering", "::", "getSetCCResultType", "(", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "MVT", "::", "i32", ";", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "R600", "MVT::i32" ]

[]

[ "<s>", "void", "MipsPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createMipsExpandPseudoPass", "(", ")", ")", ";", "addPass", "(", "createMicroMipsSizeReducePass", "(", ")", ")", ";", "if", "(", "EnableMulMulFix", ")", "addPass", "(", "createMipsMulMulBugPass", "(", ")", ")", ";", "addPass", "(", "createMipsDelaySlotFillerPass", "(", ")", ")", ";", "addPass", "(", "createMipsBranchExpansion", "(", ")", ")", ";", "addPass", "(", "createMipsConstantIslandPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "TPCAsmInstCompress", "::", "EmitInstruction", "(", "MCInst", "&", "Inst", ",", "MCStreamer", "&", "Out", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "Out", ".", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "TPC", "TPC" ]

[]

[ "<s>", "void", "OR1KRegisterInfo", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ")", "const", "{", "}", "</s>" ]

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

[ "OR1K", "OR1K" ]

[]

[ "<s>", "static", "bool", "isEqual", "(", "SPIRV", "::", "SpecialTypeDescriptor", "LHS", ",", "SPIRV", "::", "SpecialTypeDescriptor", "RHS", ")", "{", "return", "getHashValue", "(", "LHS", ")", "==", "getHashValue", "(", "RHS", ")", ";", "}", "</s>" ]

[ "isEqual", "-", "Compares", "two", "trees", "for", "structural", "equality", "and", "returns", "true", "if", "they", "are", "equal", "." ]

[ "SPIRV", "SPIRV::SpecialTypeDescriptor", "SPIRV::SpecialTypeDescriptor" ]

[]

[ "<s>", "bool", "ARMCodeGenPrepare", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "delete", "Promoter", ";", "return", "false", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "tree", "xstormy16_build_builtin_va_list", "(", "void", ")", "{", "tree", "f_1", ",", "f_2", ",", "record", ",", "type_decl", ";", "record", "=", "(", "*", "lang_hooks", ".", "types", ".", "make_type", ")", "(", "RECORD_TYPE", ")", ";", "type_decl", "=", "build_decl", "(", "TYPE_DECL", ",", "get_identifier", "(", "\"__va_list_tag\"", ")", ",", "record", ")", ";", "f_1", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"base\"", ")", ",", "ptr_type_node", ")", ";", "f_2", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"count\"", ")", ",", "unsigned_type_node", ")", ";", "DECL_FIELD_CONTEXT", "(", "f_1", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_2", ")", "=", "record", ";", "TREE_CHAIN", "(", "record", ")", "=", "type_decl", ";", "TYPE_NAME", "(", "record", ")", "=", "type_decl", ";", "TYPE_FIELDS", "(", "record", ")", "=", "f_1", ";", "TREE_CHAIN", "(", "f_1", ")", "=", "f_2", ";", "layout_type", "(", "record", ")", ";", "return", "record", ";", "}", "</s>" ]

[ "Build", "the", "va_list", "type", ".", "For", "this", "chip", ",", "va_list", "is", "a", "record", "containing", "a", "counter", "and", "a", "pointer", ".", "The", "counter", "is", "of", "type", "'int", "'", "and", "indicates", "how", "many", "bytes", "have", "been", "used", "to", "date", ".", "The", "pointer", "indicates", "the", "stack", "position", "for", "arguments", "that", "have", "not", "been", "passed", "in", "registers", ".", "To", "keep", "the", "layout", "nice", ",", "the", "pointer", "is", "first", "in", "the", "structure", "." ]

[ "stormy16", "\"__va_list_tag\"", "\"base\"", "\"count\"" ]

[]

[ "<s>", "const", "uint32_t", "*", "Z80oldRegisterInfo", "::", "getNoPreservedMask", "(", ")", "const", "{", "return", "CSR_NoRegs_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "register", "mask", "that", "clobbers", "everything", "." ]

[ "Z80old", "Z80old" ]

[]

[ "<s>", "virtual", "const", "GBZ80RegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "{", "return", "&", "getInstrInfo", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "GBZ80", "GB" ]

[]

[ "<s>", "bool", "forceScalarizeMaskedScatter", "(", "VectorType", "*", "VTy", ",", "Align", "Alignment", ")", "{", "return", "forceScalarizeMaskedGather", "(", "VTy", ",", "Alignment", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "forces", "scalarizing", "of", "llvm.masked.scatter", "intrinsics", "." ]

[ "X86" ]

[]

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

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

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

[]

[ "<s>", "void", "AMDGPUMCInstLower", "::", "lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "OutMI", ".", "setOpcode", "(", "getMCOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "explicit_operands", "(", ")", ")", "{", "MCOperand", "MCOp", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "{", "const", "APFloat", "&", "FloatValue", "=", "MO", ".", "getFPImm", "(", ")", "->", "getValueAPF", "(", ")", ";", "assert", "(", "&", "FloatValue", ".", "getSemantics", "(", ")", "==", "&", "APFloat", "::", "IEEEsingle", "&&", "\"Only floating point immediates are supported at the moment.\"", ")", ";", "MCOp", "=", "MCOperand", "::", "CreateFPImm", "(", "FloatValue", ".", "convertToFloat", "(", ")", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "CreateImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Register", ":", "MCOp", "=", "MCOperand", "::", "CreateReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "CreateExpr", "(", "MCSymbolRefExpr", "::", "Create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "Ctx", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "GetOrCreateSymbol", "(", "StringRef", "(", "GV", "->", "getName", "(", ")", ")", ")", ";", "MCOp", "=", "MCOperand", "::", "CreateExpr", "(", "MCSymbolRefExpr", "::", "Create", "(", "Sym", ",", "Ctx", ")", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_TargetIndex", ":", "{", "assert", "(", "MO", ".", "getIndex", "(", ")", "==", "AMDGPU", "::", "TI_CONSTDATA_START", ")", ";", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "GetOrCreateSymbol", "(", "StringRef", "(", "END_OF_TEXT_LABEL_NAME", ")", ")", ";", "const", "MCSymbolRefExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "Create", "(", "Sym", ",", "Ctx", ")", ";", "MCOp", "=", "MCOperand", "::", "CreateExpr", "(", "Expr", ")", ";", "break", ";", "}", "}", "OutMI", ".", "addOperand", "(", "MCOp", ")", ";", "}", "}", "</s>" ]

[ "The", "instruction", "is", "lowered", "." ]

[ "R600", "\"unknown operand type\"", "\"Only floating point immediates are supported at the moment.\"" ]

[]

[ "<s>", "bool", "isImm", "(", ")", "const", "{", "return", "Kind", "==", "k_Immediate", ";", "}", "</s>" ]

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "Sparc" ]

[]

[ "<s>", "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "INDIRECT_BASE_ADDR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "EXEC", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "FLAT_SCR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_SHARED_BASE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_SHARED_LIMIT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_PRIVATE_BASE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_PRIVATE_LIMIT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TBA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TMA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP0_TTMP1", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP2_TTMP3", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP4_TTMP5", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP6_TTMP7", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP8_TTMP9", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP10_TTMP11", ")", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "unsigned", "MaxNumSGPRs", "=", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumSGPRs", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumSGPRs", ";", "i", "<", "TotalNumSGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "unsigned", "MaxNumVGPRs", "=", "ST", ".", "getMaxNumVGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumVGPRs", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumVGPRs", ";", "i", "<", "TotalNumVGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "ScratchWaveOffsetReg", "=", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ";", "if", "(", "ScratchWaveOffsetReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchWaveOffsetReg", ")", ";", "}", "unsigned", "ScratchRSrcReg", "=", "MFI", "->", "getScratchRSrcReg", "(", ")", ";", "if", "(", "ScratchRSrcReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchRSrcReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "ScratchWaveOffsetReg", ")", ")", ";", "}", "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", "SI", "AMDGPU::INDIRECT_BASE_ADDR", "AMDGPU::EXEC", "AMDGPU::FLAT_SCR", "AMDGPU::SRC_SHARED_BASE", "AMDGPU::SRC_SHARED_LIMIT", "AMDGPU::SRC_PRIVATE_BASE", "AMDGPU::SRC_PRIVATE_LIMIT", "AMDGPU::TBA", "AMDGPU::TMA", "AMDGPU::TTMP0_TTMP1", "AMDGPU::TTMP2_TTMP3", "AMDGPU::TTMP4_TTMP5", "AMDGPU::TTMP6_TTMP7", "AMDGPU::TTMP8_TTMP9", "AMDGPU::TTMP10_TTMP11", "SI", "SI", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "SI", "SI", "AMDGPU::NoRegister", "AMDGPU::NoRegister" ]

[]

[ "<s>", "MachineInstr", "*", "SIInstrInfo", "::", "createPHISourceCopy", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "InsPt", ",", "const", "DebugLoc", "&", "DL", ",", "Register", "Src", ",", "unsigned", "SrcSubReg", ",", "Register", "Dst", ")", "const", "{", "if", "(", "InsPt", "!=", "MBB", ".", "end", "(", ")", "&&", "(", "InsPt", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "SI_IF", "||", "InsPt", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "SI_ELSE", "||", "InsPt", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "SI_IF_BREAK", ")", "&&", "InsPt", "->", "definesRegister", "(", "Src", ")", ")", "{", "InsPt", "++", ";", "return", "BuildMI", "(", "MBB", ",", "InsPt", ",", "DL", ",", "get", "(", "ST", ".", "isWave32", "(", ")", "?", "AMDGPU", "::", "S_MOV_B32_term", ":", "AMDGPU", "::", "S_MOV_B64_term", ")", ",", "Dst", ")", ".", "addReg", "(", "Src", ",", "0", ",", "SrcSubReg", ")", ".", "addReg", "(", "AMDGPU", "::", "EXEC", ",", "RegState", "::", "Implicit", ")", ";", "}", "return", "TargetInstrInfo", "::", "createPHISourceCopy", "(", "MBB", ",", "InsPt", ",", "DL", ",", "Src", ",", "SrcSubReg", ",", "Dst", ")", ";", "}", "</s>" ]

[ "During", "PHI", "eleimination", "lets", "target", "to", "make", "necessary", "checks", "and", "insert", "the", "copy", "to", "the", "PHI", "destination", "register", "in", "a", "target", "specific", "manner", "." ]

[ "AMDGPU", "SI", "AMDGPU::SI_IF", "AMDGPU::SI_ELSE", "AMDGPU::SI_IF_BREAK", "AMDGPU::S_MOV_B32_term", "AMDGPU::S_MOV_B64_term", "0", "AMDGPU::EXEC" ]

[]

[ "<s>", "uint8_t", "get_sew", "(", ")", "const", "{", "return", "m_sew", ";", "}", "</s>" ]

[ "Helper", "function", "to", "get", "SEW", "operand", ".", "We", "always", "have", "SEW", "value", "for", "all", "RVV", "instructions", "that", "have", "VTYPE", "OP", "." ]

[ "riscv" ]

[]

[ "<s>", "void", "WebAssemblyAsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"EmitInstruction: \"", "<<", "*", "MI", "<<", "'\\n'", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "ARGUMENT_i32", ":", "case", "WebAssembly", "::", "ARGUMENT_i32_S", ":", "case", "WebAssembly", "::", "ARGUMENT_i64", ":", "case", "WebAssembly", "::", "ARGUMENT_i64_S", ":", "case", "WebAssembly", "::", "ARGUMENT_f32", ":", "case", "WebAssembly", "::", "ARGUMENT_f32_S", ":", "case", "WebAssembly", "::", "ARGUMENT_f64", ":", "case", "WebAssembly", "::", "ARGUMENT_f64_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v16i8", ":", "case", "WebAssembly", "::", "ARGUMENT_v16i8_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v8i16", ":", "case", "WebAssembly", "::", "ARGUMENT_v8i16_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v4i32", ":", "case", "WebAssembly", "::", "ARGUMENT_v4i32_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v2i64", ":", "case", "WebAssembly", "::", "ARGUMENT_v2i64_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v4f32", ":", "case", "WebAssembly", "::", "ARGUMENT_v4f32_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v2f64", ":", "case", "WebAssembly", "::", "ARGUMENT_v2f64_S", ":", "break", ";", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN", ":", "{", "if", "(", "isVerbose", "(", ")", ")", "{", "OutStreamer", "->", "AddComment", "(", "\"fallthrough-return\"", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "break", ";", "}", "case", "WebAssembly", "::", "COMPILER_FENCE", ":", "break", ";", "default", ":", "{", "WebAssemblyMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"EmitInstruction: \"", "WebAssembly::ARGUMENT_i32", "WebAssembly::ARGUMENT_i32_S", "WebAssembly::ARGUMENT_i64", "WebAssembly::ARGUMENT_i64_S", "WebAssembly::ARGUMENT_f32", "WebAssembly::ARGUMENT_f32_S", "WebAssembly::ARGUMENT_f64", "WebAssembly::ARGUMENT_f64_S", "WebAssembly::ARGUMENT_v16i8", "WebAssembly::ARGUMENT_v16i8_S", "WebAssembly::ARGUMENT_v8i16", "WebAssembly::ARGUMENT_v8i16_S", "WebAssembly::ARGUMENT_v4i32", "WebAssembly::ARGUMENT_v4i32_S", "WebAssembly::ARGUMENT_v2i64", "WebAssembly::ARGUMENT_v2i64_S", "WebAssembly::ARGUMENT_v4f32", "WebAssembly::ARGUMENT_v4f32_S", "WebAssembly::ARGUMENT_v2f64", "WebAssembly::ARGUMENT_v2f64_S", "WebAssembly::FALLTHROUGH_RETURN", "\"fallthrough-return\"", "WebAssembly::COMPILER_FENCE", "WebAssembly" ]

[]

[ "<s>", "static", "machine_mode", "select_block_compare_mode", "(", "unsigned", "HOST_WIDE_INT", "offset", ",", "unsigned", "HOST_WIDE_INT", "bytes", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "unsigned", "HOST_WIDE_INT", "maxread", "=", "ROUND_UP", "(", "bytes", ",", "align", ")", ";", "int", "word_mode_ok", "=", "!", "(", "!", "BYTES_BIG_ENDIAN", "&&", "!", "TARGET_LDBRX", "&&", "word_mode", "==", "DImode", ")", ";", "if", "(", "word_mode_ok", "&&", "bytes", ">=", "UNITS_PER_WORD", ")", "return", "word_mode", ";", "else", "if", "(", "bytes", "==", "GET_MODE_SIZE", "(", "SImode", ")", ")", "return", "SImode", ";", "else", "if", "(", "bytes", "==", "GET_MODE_SIZE", "(", "HImode", ")", ")", "return", "HImode", ";", "else", "if", "(", "bytes", "==", "GET_MODE_SIZE", "(", "QImode", ")", ")", "return", "QImode", ";", "else", "if", "(", "bytes", "<", "GET_MODE_SIZE", "(", "SImode", ")", "&&", "TARGET_EFFICIENT_OVERLAPPING_UNALIGNED", "&&", "offset", ">=", "GET_MODE_SIZE", "(", "SImode", ")", "-", "bytes", ")", "return", "SImode", ";", "else", "if", "(", "word_mode_ok", "&&", "bytes", "<", "UNITS_PER_WORD", "&&", "TARGET_EFFICIENT_OVERLAPPING_UNALIGNED", "&&", "offset", ">=", "UNITS_PER_WORD", "-", "bytes", ")", "return", "word_mode", ";", "else", "if", "(", "word_mode_ok", "&&", "maxread", ">=", "UNITS_PER_WORD", ")", "return", "word_mode", ";", "else", "if", "(", "maxread", ">=", "GET_MODE_SIZE", "(", "SImode", ")", ")", "return", "SImode", ";", "else", "if", "(", "bytes", ">", "GET_MODE_SIZE", "(", "SImode", ")", ")", "return", "SImode", ";", "else", "if", "(", "bytes", ">", "GET_MODE_SIZE", "(", "HImode", ")", ")", "return", "HImode", ";", "return", "QImode", ";", "}", "</s>" ]

[ "Select", "the", "mode", "to", "be", "used", "for", "reading", "the", "next", "chunk", "of", "bytes", "in", "the", "compare", ".", "OFFSET", "is", "the", "current", "read", "offset", "from", "the", "beginning", "of", "the", "block", ".", "BYTES", "is", "the", "number", "of", "bytes", "remaining", "to", "be", "read", ".", "ALIGN", "is", "the", "minimum", "alignment", "of", "the", "memory", "blocks", "being", "compared", "in", "bytes", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "ARMBaseRegisterInfo", "::", "getRegAllocationHints", "(", "unsigned", "VirtReg", ",", "ArrayRef", "<", "MCPhysReg", ">", "Order", ",", "SmallVectorImpl", "<", "MCPhysReg", ">", "&", "Hints", ",", "const", "MachineFunction", "&", "MF", ",", "const", "VirtRegMap", "*", "VRM", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "Hint", "=", "MRI", ".", "getRegAllocationHint", "(", "VirtReg", ")", ";", "unsigned", "Odd", ";", "switch", "(", "Hint", ".", "first", ")", "{", "case", "ARMRI", "::", "RegPairEven", ":", "Odd", "=", "0", ";", "break", ";", "case", "ARMRI", "::", "RegPairOdd", ":", "Odd", "=", "1", ";", "break", ";", "default", ":", "TargetRegisterInfo", "::", "getRegAllocationHints", "(", "VirtReg", ",", "Order", ",", "Hints", ",", "MF", ",", "VRM", ")", ";", "return", ";", "}", "unsigned", "PairedPhys", "=", "0", ";", "if", "(", "VRM", "&&", "VRM", "->", "hasPhys", "(", "Hint", ".", "second", ")", ")", "{", "PairedPhys", "=", "getPairedGPR", "(", "VRM", "->", "getPhys", "(", "Hint", ".", "second", ")", ",", "Odd", ",", "this", ")", ";", "if", "(", "PairedPhys", "&&", "MRI", ".", "isReserved", "(", "PairedPhys", ")", ")", "PairedPhys", "=", "0", ";", "}", "if", "(", "PairedPhys", "&&", "std", "::", "find", "(", "Order", ".", "begin", "(", ")", ",", "Order", ".", "end", "(", ")", ",", "PairedPhys", ")", "!=", "Order", ".", "end", "(", ")", ")", "Hints", ".", "push_back", "(", "PairedPhys", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "Order", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "Order", "[", "I", "]", ";", "if", "(", "Reg", "==", "PairedPhys", "||", "(", "getEncodingValue", "(", "Reg", ")", "&", "1", ")", "!=", "Odd", ")", "continue", ";", "unsigned", "Paired", "=", "getPairedGPR", "(", "Reg", ",", "!", "Odd", ",", "this", ")", ";", "if", "(", "!", "Paired", "||", "MRI", ".", "isReserved", "(", "Paired", ")", ")", "continue", ";", "Hints", ".", "push_back", "(", "Reg", ")", ";", "}", "}", "</s>" ]

[ "Get", "a", "list", "of", "'hint", "'", "registers", "that", "the", "register", "allocator", "should", "try", "first", "when", "allocating", "a", "physical", "register", "for", "the", "virtual", "register", "VirtReg", "." ]

[ "ARM", "ARM", "ARMRI::RegPairEven", "0", "ARMRI::RegPairOdd", "1", "0", "0", "0", "1" ]

[]

[ "<s>", "static", "bool", "arc_handle_option", "(", "size_t", "code", ",", "const", "char", "*", "arg", ",", "int", "value", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "code", ")", "{", "case", "OPT_mcpu_", ":", "return", "strcmp", "(", "arg", ",", "\"base\"", ")", "==", "0", "||", "ARC_EXTENSION_CPU", "(", "arg", ")", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_HANDLE_OPTION", "." ]

[ "arc", "\"base\"", "0" ]

[]

[ "<s>", "static", "bool", "ix86_pic_register_p", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "VALUE", "&&", "CSELIB_VAL_PTR", "(", "x", ")", ")", "return", "(", "pic_offset_table_rtx", "&&", "rtx_equal_for_cselib_p", "(", "x", ",", "pic_offset_table_rtx", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_SET_GOT", ")", "return", "true", ";", "else", "if", "(", "!", "REG_P", "(", "x", ")", ")", "return", "false", ";", "else", "if", "(", "pic_offset_table_rtx", ")", "{", "if", "(", "REGNO", "(", "x", ")", "==", "REGNO", "(", "pic_offset_table_rtx", ")", ")", "return", "true", ";", "if", "(", "HARD_REGISTER_P", "(", "x", ")", "&&", "!", "HARD_REGISTER_P", "(", "pic_offset_table_rtx", ")", "&&", "ORIGINAL_REGNO", "(", "x", ")", "==", "REGNO", "(", "pic_offset_table_rtx", ")", ")", "return", "true", ";", "return", "false", ";", "}", "else", "return", "REGNO", "(", "x", ")", "==", "PIC_OFFSET_TABLE_REGNUM", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "representation", "of", "the", "PIC", "register", ".", "This", "copes", "with", "calls", "from", "ix86_find_base_term", ",", "where", "the", "register", "might", "have", "been", "replaced", "by", "a", "cselib", "value", "." ]

[ "i386", "1" ]

[]

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

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

[ "R600" ]

[]