Datasets:

---

docz1105

/

ComBack

like 9

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

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

[ "AArch64" ]

[]

[ "<s>", "LLVM_DUMP_METHOD", "void", "GCNRegPressure", "::", "print", "(", "raw_ostream", "&", "OS", ",", "const", "GCNSubtarget", "*", "ST", ")", "const", "{", "OS", "<<", "\"VGPRs: \"", "<<", "Value", "[", "VGPR32", "]", "<<", "' '", ";", "OS", "<<", "\"AGPRs: \"", "<<", "Value", "[", "AGPR32", "]", ";", "if", "(", "ST", ")", "OS", "<<", "\"(O\"", "<<", "ST", "->", "getOccupancyWithNumVGPRs", "(", "getVGPRNum", "(", "ST", "->", "hasGFX90AInsts", "(", ")", ")", ")", "<<", "')'", ";", "OS", "<<", "\", SGPRs: \"", "<<", "getSGPRNum", "(", ")", ";", "if", "(", "ST", ")", "OS", "<<", "\"(O\"", "<<", "ST", "->", "getOccupancyWithNumSGPRs", "(", "getSGPRNum", "(", ")", ")", "<<", "')'", ";", "OS", "<<", "\", LVGPR WT: \"", "<<", "getVGPRTuplesWeight", "(", ")", "<<", "\", LSGPR WT: \"", "<<", "getSGPRTuplesWeight", "(", ")", ";", "if", "(", "ST", ")", "OS", "<<", "\" -> Occ: \"", "<<", "getOccupancy", "(", "*", "ST", ")", ";", "OS", "<<", "'\\n'", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"VGPRs: \"", "\"AGPRs: \"", "\"(O\"", "\", SGPRs: \"", "\"(O\"", "\", LVGPR WT: \"", "\", LSGPR WT: \"", "\" -> Occ: \"" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "return", "createR600MachineScheduler", "(", "C", ")", ";", "}", "</s>" ]

[ "Create", "an", "instance", "of", "ScheduleDAGInstrs", "to", "be", "run", "within", "the", "standard", "MachineScheduler", "pass", "for", "this", "function", "and", "target", "at", "the", "current", "optimization", "level", "." ]

[ "AMDGPU", "R600" ]

[]

[ "<s>", "static", "unsigned", "long", "arm_compute_save_core_reg_mask", "(", "void", ")", "{", "unsigned", "int", "save_reg_mask", "=", "0", ";", "unsigned", "long", "func_type", "=", "arm_current_func_type", "(", ")", ";", "unsigned", "int", "reg", ";", "if", "(", "IS_NAKED", "(", "func_type", ")", ")", "return", "0", ";", "if", "(", "TARGET_APCS_FRAME", "&&", "frame_pointer_needed", "&&", "TARGET_ARM", ")", "save_reg_mask", "|=", "(", "1", "<<", "ARM_HARD_FRAME_POINTER_REGNUM", ")", "|", "(", "1", "<<", "IP_REGNUM", ")", "|", "(", "1", "<<", "LR_REGNUM", ")", "|", "(", "1", "<<", "PC_REGNUM", ")", ";", "save_reg_mask", "|=", "arm_compute_save_reg0_reg12_mask", "(", ")", ";", "if", "(", "arm_current_function_pac_enabled_p", "(", ")", ")", "save_reg_mask", "|=", "1", "<<", "IP_REGNUM", ";", "if", "(", "df_regs_ever_live_p", "(", "LR_REGNUM", ")", "||", "(", "save_reg_mask", "&&", "optimize_size", "&&", "ARM_FUNC_TYPE", "(", "func_type", ")", "==", "ARM_FT_NORMAL", "&&", "!", "crtl", "->", "tail_call_emit", "&&", "!", "crtl", "->", "calls_eh_return", ")", ")", "save_reg_mask", "|=", "1", "<<", "LR_REGNUM", ";", "if", "(", "cfun", "->", "machine", "->", "lr_save_eliminated", ")", "save_reg_mask", "&=", "~", "(", "1", "<<", "LR_REGNUM", ")", ";", "if", "(", "TARGET_REALLY_IWMMXT", "&&", "(", "(", "bit_count", "(", "save_reg_mask", ")", "+", "ARM_NUM_INTS", "(", "crtl", "->", "args", ".", "pretend_args_size", "+", "arm_compute_static_chain_stack_bytes", "(", ")", ")", ")", "%", "2", ")", "!=", "0", ")", "{", "for", "(", "reg", "=", "4", ";", "reg", "<=", "12", ";", "reg", "++", ")", "if", "(", "(", "save_reg_mask", "&", "(", "1", "<<", "reg", ")", ")", "==", "0", ")", "break", ";", "if", "(", "reg", "<=", "12", ")", "save_reg_mask", "|=", "(", "1", "<<", "reg", ")", ";", "else", "{", "cfun", "->", "machine", "->", "sibcall_blocked", "=", "1", ";", "save_reg_mask", "|=", "(", "1", "<<", "3", ")", ";", "}", "}", "if", "(", "TARGET_THUMB2", "&&", "IS_NESTED", "(", "func_type", ")", "&&", "flag_pic", "&&", "(", "save_reg_mask", "&", "THUMB2_WORK_REGS", ")", "==", "0", ")", "{", "reg", "=", "thumb_find_work_register", "(", "1", "<<", "4", ")", ";", "if", "(", "!", "call_used_or_fixed_reg_p", "(", "reg", ")", ")", "save_reg_mask", "|=", "(", "1", "<<", "reg", ")", ";", "}", "return", "save_reg_mask", ";", "}", "</s>" ]

[ "Compute", "a", "bit", "mask", "of", "which", "core", "registers", "need", "to", "be", "saved", "on", "the", "stack", "for", "the", "current", "function", ".", "This", "is", "used", "by", "arm_compute_frame_layout", ",", "which", "may", "add", "extra", "registers", "." ]

[ "arm", "0", "0", "1", "1", "1", "1", "1", "1", "1", "2", "0", "4", "12", "1", "0", "12", "1", "1", "1", "3", "0", "1", "4", "1" ]

[]

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

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

[ "Mips", "Mips", "MVT::i32" ]

[]

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

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

[ "ARM" ]

[]

[ "<s>", "bool", "AMDGPUMachineCFGStructurizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "(", "MF", ".", "getRegInfo", "(", ")", ")", ";", "initFallthroughMap", "(", "MF", ")", ";", "checkRegOnlyPHIInputs", "(", "MF", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"----STRUCTURIZER START----\\n\"", ")", ";", "LLVM_DEBUG", "(", "MF", ".", "dump", "(", ")", ")", ";", "Regions", "=", "&", "(", "getAnalysis", "<", "MachineRegionInfoPass", ">", "(", ")", ".", "getRegionInfo", "(", ")", ")", ";", "LLVM_DEBUG", "(", "Regions", "->", "dump", "(", ")", ")", ";", "RegionMRT", "*", "RTree", "=", "MRT", "::", "buildMRT", "(", "MF", ",", "Regions", ",", "TII", ",", "MRI", ")", ";", "setRegionMRT", "(", "RTree", ")", ";", "initializeSelectRegisters", "(", "RTree", ",", "0", ",", "MRI", ",", "TII", ")", ";", "LLVM_DEBUG", "(", "RTree", "->", "dump", "(", "TRI", ")", ")", ";", "bool", "result", "=", "structurizeRegions", "(", "RTree", ",", "true", ")", ";", "delete", "RTree", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"----STRUCTURIZER END----\\n\"", ")", ";", "initFallthroughMap", "(", "MF", ")", ";", "return", "result", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "SI", "\"----STRUCTURIZER START----\\n\"", "0", "\"----STRUCTURIZER END----\\n\"" ]

[]

[ "<s>", "void", "Cpu0InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "GetMemOperand", "(", "MBB", ",", "FI", ",", "MachineMemOperand", "::", "MOLoad", ")", ";", "unsigned", "Opc", "=", "0", ";", "if", "(", "Cpu0", "::", "CPURegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "Cpu0", "::", "LD", ";", "assert", "(", "Opc", "&&", "\"Register class not handled!\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "0", "Cpu0::CPURegsRegClass", "Cpu0::LD", "\"Register class not handled!\"", "0" ]

[]

[ "<s>", "bool", "MSP430AsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "Loc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "Inst", ".", "setLoc", "(", "Loc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", "false", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "Loc", ",", "\"invalid instruction mnemonic\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "Loc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "ErrorLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "MSP430Operand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "Loc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "MSP430", "MSP430", "\"invalid instruction mnemonic\"", "0U", "\"too few operands for instruction\"", "MSP430", "\"invalid operand for instruction\"" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "X86Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "const", "X86RegisterInfo", "&", "RegInfo", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "StackPtr", "=", "RegInfo", ".", "getStackRegister", "(", ")", ";", "bool", "reserveCallFrame", "=", "hasReservedCallFrame", "(", "MF", ")", ";", "unsigned", "Opcode", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "isDestroy", "=", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ";", "bool", "IsLP64", "=", "STI", ".", "isTarget64BitLP64", "(", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Amount", "=", "!", "reserveCallFrame", "?", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ":", "0", ";", "uint64_t", "InternalAmt", "=", "(", "isDestroy", "||", "Amount", ")", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "I", "=", "MBB", ".", "erase", "(", "I", ")", ";", "if", "(", "!", "reserveCallFrame", ")", "{", "if", "(", "Amount", "==", "0", ")", "return", ";", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "RoundUpToAlignment", "(", "Amount", ",", "StackAlign", ")", ";", "MachineInstr", "*", "New", "=", "nullptr", ";", "Amount", "-=", "InternalAmt", ";", "if", "(", "Amount", ")", "{", "if", "(", "Opcode", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "getSUBriOpcode", "(", "IsLP64", ",", "Amount", ")", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "unsigned", "Opc", "=", "getADDriOpcode", "(", "IsLP64", ",", "Amount", ")", ";", "New", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "}", "if", "(", "New", ")", "{", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "return", ";", "}", "if", "(", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", "&&", "InternalAmt", ")", "{", "unsigned", "Opc", "=", "getSUBriOpcode", "(", "IsLP64", ",", "InternalAmt", ")", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "InternalAmt", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "B", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "I", "!=", "B", "&&", "!", "std", "::", "prev", "(", "I", ")", "->", "isCall", "(", ")", ")", "--", "I", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "0", "0", "1", "0", "0", "3", "3" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreRegBankSelect", "(", ")", "{", "bool", "IsOptNone", "=", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ";", "if", "(", "!", "IsOptNone", ")", "addPass", "(", "createAArch64PostLegalizerCombiner", "(", "IsOptNone", ")", ")", ";", "addPass", "(", "createAArch64PostLegalizerLowering", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "TargetRegisterClass", "*", "MipsSERegisterInfo", "::", "intRegClass", "(", "unsigned", "Size", ")", "const", "{", "if", "(", "Size", "==", "4", ")", "return", "&", "Mips", "::", "CPURegsRegClass", ";", "assert", "(", "Size", "==", "8", ")", ";", "return", "&", "Mips", "::", "CPU64RegsRegClass", ";", "}", "</s>" ]

[ "Return", "GPR", "register", "class", "." ]

[ "Mips", "Mips", "4", "Mips::CPURegsRegClass", "8", "Mips::CPU64RegsRegClass" ]

[]

[ "<s>", "bool", "AVRFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "{", "return", "false", ";", "}", "unsigned", "CalleeFrameSize", "=", "0", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "AVRMachineFunctionInfo", "*", "AVRFI", "=", "MF", ".", "getInfo", "<", "AVRMachineFunctionInfo", ">", "(", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "I", ":", "llvm", "::", "reverse", "(", "CSI", ")", ")", "{", "unsigned", "Reg", "=", "I", ".", "getReg", "(", ")", ";", "bool", "IsNotLiveIn", "=", "!", "MBB", ".", "isLiveIn", "(", "Reg", ")", ";", "assert", "(", "TRI", "->", "getRegSizeInBits", "(", "*", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ")", "==", "8", "&&", "\"Invalid register size\"", ")", ";", "if", "(", "IsNotLiveIn", ")", "{", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "PUSHRr", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "IsNotLiveIn", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "++", "CalleeFrameSize", ";", "}", "AVRFI", "->", "setCalleeSavedFrameSize", "(", "CalleeFrameSize", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "0", "AVR", "AVR", "AVR", "AVR", "AVR", "8", "\"Invalid register size\"", "AVR::PUSHRr", "AVR" ]

[]

[ "<s>", "static", "machine_mode", "rs6000_secondary_memory_needed_mode", "(", "machine_mode", "mode", ")", "{", "if", "(", "lra_in_progress", "&&", "mode", "==", "SDmode", ")", "return", "DDmode", ";", "return", "mode", ";", "}", "</s>" ]

[ "Return", "the", "mode", "to", "be", "used", "for", "memory", "when", "a", "secondary", "memory", "location", "is", "needed", ".", "For", "SDmode", "values", "we", "need", "to", "use", "DDmode", ",", "in", "all", "other", "cases", "we", "can", "use", "the", "same", "mode", "." ]

[ "rs6000" ]

[]

[ "<s>", "int", "arc_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "if", "(", "!", "cfun", "->", "machine", "->", "frame_info", ".", "initialized", ")", "arc_compute_frame_size", "(", ")", ";", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "{", "return", "(", "cfun", "->", "machine", "->", "frame_info", ".", "extra_size", "+", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ")", ";", "}", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "{", "return", "(", "cfun", "->", "machine", "->", "frame_info", ".", "total_size", "-", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", ")", ";", "}", "if", "(", "(", "from", "==", "FRAME_POINTER_REGNUM", ")", "&&", "(", "to", "==", "STACK_POINTER_REGNUM", ")", ")", "{", "return", "(", "cfun", "->", "machine", "->", "frame_info", ".", "total_size", "-", "(", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", "+", "cfun", "->", "machine", "->", "frame_info", ".", "extra_size", "+", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ")", ")", ";", "}", "if", "(", "(", "from", "==", "FRAME_POINTER_REGNUM", ")", "&&", "(", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", ")", "return", "0", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Define", "the", "offset", "between", "two", "registers", ",", "one", "to", "be", "eliminated", ",", "and", "the", "other", "its", "replacement", ",", "at", "the", "start", "of", "a", "routine", "." ]

[ "arc", "0" ]

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "return", "lowerIntrinsics", "(", "M", ")", ";", "}", "</s>" ]

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

[ "DirectX" ]

[]

[ "<s>", "const", "char", "*", "thumb_load_double_from_address", "(", "rtx", "*", "operands", ")", "{", "rtx", "addr", ";", "rtx", "base", ";", "rtx", "offset", ";", "rtx", "arg1", ";", "rtx", "arg2", ";", "gcc_assert", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "REG", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "MEM", ")", ";", "addr", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "operands", "[", "2", "]", "=", "adjust_address", "(", "operands", "[", "1", "]", ",", "SImode", ",", "4", ")", ";", "if", "(", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "REGNO", "(", "addr", ")", ")", "{", "output_asm_insn", "(", "\"ldr\\t%H0, %2\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"ldr\\t%0, %1\"", ",", "operands", ")", ";", "}", "else", "{", "output_asm_insn", "(", "\"ldr\\t%0, %1\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"ldr\\t%H0, %2\"", ",", "operands", ")", ";", "}", "break", ";", "case", "CONST", ":", "operands", "[", "2", "]", "=", "adjust_address", "(", "operands", "[", "1", "]", ",", "SImode", ",", "4", ")", ";", "output_asm_insn", "(", "\"ldr\\t%0, %1\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"ldr\\t%H0, %2\"", ",", "operands", ")", ";", "break", ";", "case", "PLUS", ":", "arg1", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "arg2", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "CONSTANT_P", "(", "arg1", ")", ")", "base", "=", "arg2", ",", "offset", "=", "arg1", ";", "else", "base", "=", "arg1", ",", "offset", "=", "arg2", ";", "gcc_assert", "(", "GET_CODE", "(", "base", ")", "==", "REG", ")", ";", "if", "(", "GET_CODE", "(", "offset", ")", "==", "REG", ")", "{", "int", "reg_offset", "=", "REGNO", "(", "offset", ")", ";", "int", "reg_base", "=", "REGNO", "(", "base", ")", ";", "int", "reg_dest", "=", "REGNO", "(", "operands", "[", "0", "]", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\tadd\\t%r, %r, %r\"", ",", "reg_dest", "+", "1", ",", "reg_base", ",", "reg_offset", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\tldr\\t%r, [%r, #0]\"", ",", "reg_dest", ",", "reg_dest", "+", "1", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\tldr\\t%r, [%r, #4]\"", ",", "reg_dest", "+", "1", ",", "reg_dest", "+", "1", ")", ";", "}", "else", "{", "operands", "[", "2", "]", "=", "adjust_address", "(", "operands", "[", "1", "]", ",", "SImode", ",", "4", ")", ";", "if", "(", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "REGNO", "(", "base", ")", ")", "{", "output_asm_insn", "(", "\"ldr\\t%H0, %2\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"ldr\\t%0, %1\"", ",", "operands", ")", ";", "}", "else", "{", "output_asm_insn", "(", "\"ldr\\t%0, %1\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"ldr\\t%H0, %2\"", ",", "operands", ")", ";", "}", "}", "break", ";", "case", "LABEL_REF", ":", "operands", "[", "2", "]", "=", "adjust_address", "(", "operands", "[", "1", "]", ",", "SImode", ",", "4", ")", ";", "output_asm_insn", "(", "\"ldr\\t%H0, %2\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"ldr\\t%0, %1\"", ",", "operands", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Handle", "the", "case", "of", "a", "double", "word", "load", "into", "a", "low", "register", "from", "a", "computed", "memory", "address", ".", "The", "computed", "address", "may", "involve", "a", "register", "which", "is", "overwritten", "by", "the", "load", "." ]

[ "arm", "0", "1", "1", "0", "2", "1", "4", "0", "\"ldr\\t%H0, %2\"", "\"ldr\\t%0, %1\"", "\"ldr\\t%0, %1\"", "\"ldr\\t%H0, %2\"", "2", "1", "4", "\"ldr\\t%0, %1\"", "\"ldr\\t%H0, %2\"", "0", "1", "0", "\"\\tadd\\t%r, %r, %r\"", "1", "\"\\tldr\\t%r, [%r, #0]\"", "1", "\"\\tldr\\t%r, [%r, #4]\"", "1", "1", "2", "1", "4", "0", "\"ldr\\t%H0, %2\"", "\"ldr\\t%0, %1\"", "\"ldr\\t%0, %1\"", "\"ldr\\t%H0, %2\"", "2", "1", "4", "\"ldr\\t%H0, %2\"", "\"ldr\\t%0, %1\"", "\"\"" ]

[]

[ "<s>", "static", "bool", "isBranch", "(", "unsigned", "Opcode", ")", "{", "return", "Opcode", "==", "AMDGPU", "::", "BRANCH", "||", "Opcode", "==", "AMDGPU", "::", "BRANCH_COND_i32", "||", "Opcode", "==", "AMDGPU", "::", "BRANCH_COND_f32", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "is", "a", "conditional", ",", "unconditional", ",", "or", "indirect", "branch", "." ]

[ "AMDGPU", "AMDGPU::BRANCH", "AMDGPU::BRANCH_COND_i32", "AMDGPU::BRANCH_COND_f32" ]

[]

[ "<s>", "void", "Finish", "(", ")", "{", "const", "size_t", "VendorHeaderSize", "=", "4", "+", "CurrentVendor", ".", "size", "(", ")", "+", "1", ";", "const", "size_t", "TagHeaderSize", "=", "1", "+", "4", ";", "Streamer", ".", "EmitIntValue", "(", "VendorHeaderSize", "+", "TagHeaderSize", "+", "ContentsSize", ",", "4", ")", ";", "Streamer", ".", "EmitBytes", "(", "CurrentVendor", ",", "0", ")", ";", "Streamer", ".", "EmitIntValue", "(", "0", ",", "1", ")", ";", "Streamer", ".", "EmitIntValue", "(", "ARMBuildAttrs", "::", "File", ",", "1", ")", ";", "Streamer", ".", "EmitIntValue", "(", "TagHeaderSize", "+", "ContentsSize", ",", "4", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "Contents", ".", "size", "(", ")", ";", "++", "i", ")", "{", "AttributeItemType", "item", "=", "Contents", "[", "i", "]", ";", "Streamer", ".", "EmitULEB128IntValue", "(", "item", ".", "Tag", ",", "0", ")", ";", "switch", "(", "item", ".", "Type", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid attribute type\"", ")", ";", "case", "AttributeItemType", "::", "NumericAttribute", ":", "Streamer", ".", "EmitULEB128IntValue", "(", "item", ".", "IntValue", ",", "0", ")", ";", "break", ";", "case", "AttributeItemType", "::", "TextAttribute", ":", "Streamer", ".", "EmitBytes", "(", "item", ".", "StringValue", ".", "upper", "(", ")", ",", "0", ")", ";", "Streamer", ".", "EmitIntValue", "(", "0", ",", "1", ")", ";", "break", ";", "}", "}", "Contents", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "Finish", "-", "Do", "final", "processing", "and", "write", "the", "object", "to", "the", "output", "stream", "." ]

[ "ARM", "4", "1", "1", "4", "4", "0", "0", "1", "ARMBuildAttrs::File", "1", "4", "0", "0", "\"Invalid attribute type\"", "0", "0", "0", "1" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "IsEligibleForTailCallOptimization", "(", "SDValue", "Callee", ",", "unsigned", "CalleeCC", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "isVarArg", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "unsigned", "CallerCC", "=", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ";", "if", "(", "CalleeCC", "==", "CallingConv", "::", "Fast", "&&", "CallerCC", "==", "CalleeCC", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "Ins", ".", "size", "(", ")", ";", "i", "++", ")", "{", "ISD", "::", "ArgFlagsTy", "Flags", "=", "Ins", "[", "i", "]", ".", "Flags", ";", "if", "(", "Flags", ".", "isByVal", "(", ")", ")", "return", "false", ";", "}", "if", "(", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", ")", "return", "true", ";", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "return", "G", "->", "getGlobal", "(", ")", "->", "hasHiddenVisibility", "(", ")", "||", "G", "->", "getGlobal", "(", ")", "->", "hasProtectedVisibility", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "IsEligibleForTailCallOptimization", "-", "Check", "whether", "the", "call", "is", "eligible", "for", "tail", "call", "optimization", "." ]

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

[]

[ "<s>", "const", "uint16_t", "*", "rvexRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "CSR_O32_SaveList", ";", "}", "</s>" ]

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

[ "rvex", "rvex" ]

[]

[ "<s>", "FISCTargetLowering", "::", "ConstraintType", "FISCTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'c'", ":", "return", "C_RegisterClass", ";", "case", "'R'", ":", "return", "C_Memory", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "FISC", "FISC", "FISC", "1", "0" ]

[]

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

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

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

[]

[ "<s>", "static", "bool", "ix86_pass_by_reference", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "TARGET_64BIT", ")", "{", "enum", "calling_abi", "call_abi", "=", "cum", "?", "cum", "->", "call_abi", ":", "ix86_abi", ";", "if", "(", "call_abi", "==", "MS_ABI", ")", "{", "HOST_WIDE_INT", "msize", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "type", ")", "{", "if", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "return", "true", ";", "if", "(", "RECORD_OR_UNION_TYPE_P", "(", "type", ")", ")", "{", "msize", "=", "int_size_in_bytes", "(", "type", ")", ";", "}", "}", "return", "msize", "!=", "1", "&&", "msize", "!=", "2", "&&", "msize", "!=", "4", "&&", "msize", "!=", "8", ";", "}", "else", "if", "(", "type", "&&", "int_size_in_bytes", "(", "type", ")", "==", "-", "1", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "A", "C", "expression", "that", "indicates", "when", "an", "argument", "must", "be", "passed", "by", "reference", ".", "If", "nonzero", "for", "an", "argument", ",", "a", "copy", "of", "that", "argument", "is", "made", "in", "memory", "and", "a", "pointer", "to", "the", "argument", "is", "passed", "instead", "of", "the", "argument", "itself", ".", "The", "pointer", "is", "passed", "in", "whatever", "way", "is", "appropriate", "for", "passing", "a", "pointer", "to", "that", "type", "." ]

[ "i386", "1", "2", "4", "8", "1" ]

[]

[ "<s>", "void", "IncomingValueHandler", "::", "assignValueToAddress", "(", "Register", "ValVReg", ",", "const", "CCValAssign", "&", "VA", ")", "{", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", "||", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", "||", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "AExt", ")", "{", "auto", "Load", "=", "buildLoad", "(", "LLT", "::", "scalar", "(", "32", ")", ",", "VA", ")", ";", "MIRBuilder", ".", "buildTrunc", "(", "ValVReg", ",", "Load", ")", ";", "}", "else", "buildLoad", "(", "ValVReg", ",", "VA", ")", ";", "}", "</s>" ]

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

[ "Mips", "32" ]

[]

[ "<s>", "void", "th_mempair_order_operands", "(", "rtx", "operands", "[", "4", "]", ",", "bool", "load_p", ",", "machine_mode", "mode", ")", "{", "int", "mem_op", "=", "load_p", "?", "1", ":", "0", ";", "bool", "reversed", "=", "false", ";", "if", "(", "!", "th_mempair_check_consecutive_mems", "(", "mode", ",", "operands", "+", "mem_op", ",", "operands", "+", "mem_op", "+", "2", ",", "&", "reversed", ")", ")", "gcc_unreachable", "(", ")", ";", "if", "(", "reversed", ")", "{", "std", "::", "swap", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ";", "std", "::", "swap", "(", "operands", "[", "1", "]", ",", "operands", "[", "3", "]", ")", ";", "}", "}", "</s>" ]

[ "Given", "OPERANDS", "of", "consecutive", "load/store", "that", "can", "be", "merged", ",", "swap", "them", "if", "they", "are", "not", "in", "ascending", "order", ".", "Return", "true", "if", "swap", "was", "performed", "." ]

[ "riscv", "4", "1", "0", "2", "0", "2", "1", "3" ]

[]

[ "<s>", "static", "bool", "mmix_pass_by_reference", "(", "const", "CUMULATIVE_ARGS", "*", "argsp", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "true", ";", "if", "(", "MMIX_FUNCTION_ARG_SIZE", "(", "mode", ",", "type", ")", ">", "8", "&&", "!", "TARGET_LIBFUNC", "&&", "(", "!", "argsp", "||", "!", "argsp", "->", "lib", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "nonzero", "for", "everything", "that", "goes", "by", "reference", ",", "0", "for", "everything", "that", "goes", "by", "value", "." ]

[ "mmix", "8" ]

[]

[ "<s>", "static", "void", "gen_int_relational", "(", "enum", "rtx_code", "code", ",", "rtx", "result", ",", "rtx", "cmp0", ",", "rtx", "cmp1", ",", "rtx", "destination", ")", "{", "machine_mode", "mode", ";", "int", "branch_p", ";", "mode", "=", "GET_MODE", "(", "cmp0", ")", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "GET_MODE", "(", "cmp1", ")", ";", "branch_p", "=", "(", "destination", "!=", "0", ")", ";", "switch", "(", "code", ")", "{", "case", "LE", ":", "case", "LT", ":", "case", "LEU", ":", "case", "LTU", ":", "{", "rtx", "temp", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "temp", "=", "cmp0", ";", "cmp0", "=", "cmp1", ";", "cmp1", "=", "temp", ";", "break", ";", "}", "default", ":", "break", ";", "}", "if", "(", "branch_p", ")", "{", "rtx", "insn", ",", "cond", ",", "label", ";", "if", "(", "!", "register_operand", "(", "cmp0", ",", "mode", ")", ")", "cmp0", "=", "force_reg", "(", "mode", ",", "cmp0", ")", ";", "if", "(", "!", "register_operand", "(", "cmp1", ",", "mode", ")", ")", "cmp1", "=", "force_reg", "(", "mode", ",", "cmp1", ")", ";", "cond", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "cmp0", ",", "cmp1", ")", ";", "label", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "destination", ")", ";", "insn", "=", "gen_rtx_SET", "(", "pc_rtx", ",", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "cond", ",", "label", ",", "pc_rtx", ")", ")", ";", "emit_jump_insn", "(", "insn", ")", ";", "}", "else", "{", "if", "(", "(", "GET_CODE", "(", "cmp0", ")", "==", "CONST_INT", ")", "&&", "(", "INTVAL", "(", "cmp0", ")", "!=", "0", ")", ")", "cmp0", "=", "force_reg", "(", "mode", ",", "cmp0", ")", ";", "if", "(", "GET_CODE", "(", "cmp1", ")", "==", "CONST_INT", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "NE", ":", "case", "LE", ":", "case", "LT", ":", "case", "GE", ":", "case", "GT", ":", "if", "(", "!", "satisfies_constraint_K", "(", "cmp1", ")", ")", "cmp1", "=", "force_reg", "(", "mode", ",", "cmp1", ")", ";", "break", ";", "case", "LEU", ":", "case", "LTU", ":", "case", "GEU", ":", "case", "GTU", ":", "if", "(", "!", "satisfies_constraint_L", "(", "cmp1", ")", ")", "cmp1", "=", "force_reg", "(", "mode", ",", "cmp1", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "emit_move_insn", "(", "result", ",", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "cmp0", ",", "cmp1", ")", ")", ";", "}", "}", "</s>" ]

[ "Generate", "the", "code", "to", "compare", "two", "integer", "values", ".", "The", "return", "value", "is", "the", "comparison", "expression", "." ]

[ "lm32", "0", "0" ]

[]

[ "<s>", "bool", "VEInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "false", ";", "if", "(", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "return", "false", ";", "MachineInstr", "*", "LastInst", "=", "&", "*", "I", ";", "unsigned", "LastOpc", "=", "LastInst", "->", "getOpcode", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", "||", "!", "isUnpredicatedTerminator", "(", "*", "--", "I", ")", ")", "{", "if", "(", "isUncondBranchOpcode", "(", "LastOpc", ")", ")", "{", "TBB", "=", "LastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "if", "(", "isCondBranchOpcode", "(", "LastOpc", ")", ")", "{", "parseCondBranch", "(", "LastInst", ",", "TBB", ",", "Cond", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "MachineInstr", "*", "SecondLastInst", "=", "&", "*", "I", ";", "unsigned", "SecondLastOpc", "=", "SecondLastInst", "->", "getOpcode", "(", ")", ";", "if", "(", "AllowModify", "&&", "isUncondBranchOpcode", "(", "LastOpc", ")", ")", "{", "while", "(", "isUncondBranchOpcode", "(", "SecondLastOpc", ")", ")", "{", "LastInst", "->", "eraseFromParent", "(", ")", ";", "LastInst", "=", "SecondLastInst", ";", "LastOpc", "=", "LastInst", "->", "getOpcode", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", "||", "!", "isUnpredicatedTerminator", "(", "*", "--", "I", ")", ")", "{", "TBB", "=", "LastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "SecondLastInst", "=", "&", "*", "I", ";", "SecondLastOpc", "=", "SecondLastInst", "->", "getOpcode", "(", ")", ";", "}", "}", "if", "(", "SecondLastInst", "&&", "I", "!=", "MBB", ".", "begin", "(", ")", "&&", "isUnpredicatedTerminator", "(", "*", "--", "I", ")", ")", "return", "true", ";", "if", "(", "isCondBranchOpcode", "(", "SecondLastOpc", ")", "&&", "isUncondBranchOpcode", "(", "LastOpc", ")", ")", "{", "parseCondBranch", "(", "SecondLastInst", ",", "TBB", ",", "Cond", ")", ";", "FBB", "=", "LastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "if", "(", "isUncondBranchOpcode", "(", "SecondLastOpc", ")", "&&", "isUncondBranchOpcode", "(", "LastOpc", ")", ")", "{", "TBB", "=", "SecondLastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "VE", "VE", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "aarch64_record_potential_advsimd_unrolling", "(", "loop_vec_info", "loop_vinfo", ",", "aarch64_vector_costs", "*", "costs", ")", "{", "if", "(", "!", "(", "aarch64_tune_params", ".", "extra_tuning_flags", "&", "AARCH64_EXTRA_TUNE_MATCHED_VECTOR_THROUGHPUT", ")", ")", "return", ";", "if", "(", "!", "(", "costs", "->", "vec_flags", "&", "VEC_ANY_SVE", ")", ")", "return", ";", "if", "(", "aarch64_autovec_preference", "==", "2", ")", "return", ";", "if", "(", "LOOP_VINFO_LOOP", "(", "loop_vinfo", ")", "->", "inner", ")", "return", ";", "if", "(", "!", "LOOP_VINFO_NITERS_KNOWN_P", "(", "loop_vinfo", ")", "||", "aarch64_sve_vg", ".", "is_constant", "(", ")", ")", "return", ";", "unsigned", "int", "estimated_vq", "=", "aarch64_estimated_sve_vq", "(", ")", ";", "unsigned", "int", "advsimd_vf", "=", "CEIL", "(", "vect_vf_for_cost", "(", "loop_vinfo", ")", ",", "estimated_vq", ")", ";", "unsigned", "HOST_WIDE_INT", "unrolled_advsimd_niters", "=", "LOOP_VINFO_INT_NITERS", "(", "loop_vinfo", ")", "/", "advsimd_vf", ";", "if", "(", "unrolled_advsimd_niters", ">", "(", "unsigned", "int", ")", "param_max_completely_peel_times", ")", "return", ";", "costs", "->", "unrolled_advsimd_niters", "=", "unrolled_advsimd_niters", ";", "}", "</s>" ]

[ "Decide", "whether", "to", "use", "the", "unrolling", "heuristic", "described", "above", "aarch64_vector_costs", ":", ":unrolled_advsimd_niters", ",", "updating", "that", "field", "if", "so", ".", "LOOP_VINFO", "describes", "the", "loop", "that", "we", "'re", "vectorizing", "and", "COSTS", "are", "the", "costs", "that", "we", "'re", "calculating", "for", "it", "." ]

[ "aarch64", "2" ]

[]

[ "<s>", "static", "rtx", "mips_cprestore_slot", "(", "rtx", "temp", ",", "bool", "load_p", ")", "{", "rtx", "base", ";", "HOST_WIDE_INT", "offset", ";", "mips_get_cprestore_base_and_offset", "(", "&", "base", ",", "&", "offset", ",", "load_p", ")", ";", "return", "gen_frame_mem", "(", "Pmode", ",", "mips_add_offset", "(", "temp", ",", "base", ",", "offset", ")", ")", ";", "}", "</s>" ]

[ "Return", "a", "MEM", "rtx", "for", "the", "cprestore", "slot", ".", "LOAD_P", "is", "true", "if", "we", "are", "going", "to", "load", "from", "it", ",", "false", "if", "we", "are", "going", "to", "store", "to", "it", ".", "Use", "TEMP", "as", "a", "temporary", "register", "if", "need", "be", "." ]

[ "mips" ]

[]

[ "<s>", "static", "bool", "aapcs_vfp_is_call_or_return_candidate", "(", "enum", "arm_pcs", "pcs_variant", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "machine_mode", "*", "base_mode", ",", "int", "*", "count", ")", "{", "machine_mode", "new_mode", "=", "VOIDmode", ";", "if", "(", "type", ")", "{", "unsigned", "int", "warn_psabi_flags", "=", "0", ";", "int", "ag_count", "=", "aapcs_vfp_sub_candidate", "(", "type", ",", "&", "new_mode", ",", "&", "warn_psabi_flags", ")", ";", "if", "(", "ag_count", ">", "0", "&&", "ag_count", "<=", "4", ")", "{", "static", "unsigned", "last_reported_type_uid", ";", "unsigned", "uid", "=", "TYPE_UID", "(", "TYPE_MAIN_VARIANT", "(", "type", ")", ")", ";", "int", "alt", ";", "if", "(", "warn_psabi", "&&", "warn_psabi_flags", "&&", "uid", "!=", "last_reported_type_uid", "&&", "(", "(", "alt", "=", "aapcs_vfp_sub_candidate", "(", "type", ",", "&", "new_mode", ",", "NULL", ")", ")", "!=", "ag_count", ")", ")", "{", "const", "char", "*", "url10", "=", "CHANGES_ROOT_URL", "\"gcc-10/changes.html#empty_base\"", ";", "const", "char", "*", "url12", "=", "CHANGES_ROOT_URL", "\"gcc-12/changes.html#zero_width_bitfields\"", ";", "gcc_assert", "(", "alt", "==", "-", "1", ")", ";", "last_reported_type_uid", "=", "uid", ";", "if", "(", "warn_psabi_flags", "&", "WARN_PSABI_NO_UNIQUE_ADDRESS", ")", "inform", "(", "input_location", ",", "\"parameter passing for argument of \"", "\"type %qT with %<[[no_unique_address]]%> members \"", "\"changed %{in GCC 10.1%}\"", ",", "TYPE_MAIN_VARIANT", "(", "type", ")", ",", "url10", ")", ";", "else", "if", "(", "warn_psabi_flags", "&", "WARN_PSABI_EMPTY_CXX17_BASE", ")", "inform", "(", "input_location", ",", "\"parameter passing for argument of \"", "\"type %qT when C++17 is enabled changed to match \"", "\"C++14 %{in GCC 10.1%}\"", ",", "TYPE_MAIN_VARIANT", "(", "type", ")", ",", "url10", ")", ";", "else", "if", "(", "warn_psabi_flags", "&", "WARN_PSABI_ZERO_WIDTH_BITFIELD", ")", "inform", "(", "input_location", ",", "\"parameter passing for argument of \"", "\"type %qT changed %{in GCC 12.1%}\"", ",", "TYPE_MAIN_VARIANT", "(", "type", ")", ",", "url12", ")", ";", "}", "*", "count", "=", "ag_count", ";", "}", "else", "return", "false", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_FLOAT", ")", "{", "*", "count", "=", "1", ";", "new_mode", "=", "mode", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", "{", "*", "count", "=", "2", ";", "new_mode", "=", "(", "mode", "==", "DCmode", "?", "DFmode", ":", "SFmode", ")", ";", "}", "else", "return", "false", ";", "if", "(", "!", "use_vfp_abi", "(", "pcs_variant", ",", "ARM_NUM_REGS", "(", "new_mode", ")", ">", "1", ")", ")", "return", "false", ";", "*", "base_mode", "=", "new_mode", ";", "if", "(", "TARGET_GENERAL_REGS_ONLY", ")", "error", "(", "\"argument of type %qT not permitted with %<-mgeneral-regs-only%>\"", ",", "type", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "argument", "whose", "type", "is", "TYPE", ",", "or", "mode", "is", "MODE", ",", "is", "suitable", "for", "passing", "or", "returning", "in", "VFP", "registers", "for", "the", "PCS", "variant", "selected", ".", "If", "it", "is", ",", "then", "*", "BASE_MODE", "is", "updated", "to", "contain", "a", "machine", "mode", "describing", "each", "element", "of", "the", "argument", "'s", "type", "and", "*", "COUNT", "to", "hold", "the", "number", "of", "such", "elements", "." ]

[ "arm", "0", "0", "4", "\"gcc-10/changes.html#empty_base\"", "\"gcc-12/changes.html#zero_width_bitfields\"", "1", "\"parameter passing for argument of \"", "\"type %qT with %<[[no_unique_address]]%> members \"", "\"changed %{in GCC 10.1%}\"", "\"parameter passing for argument of \"", "\"type %qT when C++17 is enabled changed to match \"", "\"C++14 %{in GCC 10.1%}\"", "\"parameter passing for argument of \"", "\"type %qT changed %{in GCC 12.1%}\"", "1", "2", "1", "\"argument of type %qT not permitted with %<-mgeneral-regs-only%>\"" ]

[]

[ "<s>", "MachineInstr", "*", "X86InstrInfo", "::", "optimizeLoadInstr", "(", "MachineInstr", "*", "MI", ",", "const", "MachineRegisterInfo", "*", "MRI", ",", "unsigned", "&", "FoldAsLoadDefReg", ",", "MachineInstr", "*", "&", "DefMI", ")", "const", "{", "if", "(", "FoldAsLoadDefReg", "==", "0", ")", "return", "nullptr", ";", "if", "(", "MI", "->", "mayLoad", "(", ")", ")", "{", "FoldAsLoadDefReg", "=", "0", ";", "return", "nullptr", ";", "}", "DefMI", "=", "MRI", "->", "getVRegDef", "(", "FoldAsLoadDefReg", ")", ";", "assert", "(", "DefMI", ")", ";", "bool", "SawStore", "=", "false", ";", "if", "(", "!", "DefMI", "->", "isSafeToMove", "(", "this", ",", "nullptr", ",", "SawStore", ")", ")", "return", "nullptr", ";", "unsigned", "SrcOperandId", "=", "0", ";", "bool", "FoundSrcOperand", "=", "false", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "!=", "FoldAsLoadDefReg", ")", "continue", ";", "if", "(", "MO", ".", "getSubReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", "||", "FoundSrcOperand", ")", "return", "nullptr", ";", "SrcOperandId", "=", "i", ";", "FoundSrcOperand", "=", "true", ";", "}", "if", "(", "!", "FoundSrcOperand", ")", "return", "nullptr", ";", "SmallVector", "<", "unsigned", ",", "8", ">", "Ops", ";", "Ops", ".", "push_back", "(", "SrcOperandId", ")", ";", "MachineInstr", "*", "FoldMI", "=", "foldMemoryOperand", "(", "MI", ",", "Ops", ",", "DefMI", ")", ";", "if", "(", "FoldMI", ")", "{", "FoldAsLoadDefReg", "=", "0", ";", "return", "FoldMI", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "optimizeLoadInstr", "-", "Try", "to", "remove", "the", "load", "by", "folding", "it", "to", "a", "register", "operand", "at", "the", "use", "." ]

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

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableGlobalMerge", "==", "cl", "::", "BOU_UNSET", ")", "||", "EnableGlobalMerge", "==", "cl", "::", "BOU_TRUE", ")", "{", "bool", "OnlyOptimizeForSize", "=", "(", "TM", "->", "getOptLevel", "(", ")", "<", "CodeGenOpt", "::", "Aggressive", ")", "&&", "(", "EnableGlobalMerge", "==", "cl", "::", "BOU_UNSET", ")", ";", "bool", "MergeExternalByDefault", "=", "!", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSBinFormatMachO", "(", ")", ";", "addPass", "(", "createGlobalMergePass", "(", "TM", ",", "127", ",", "OnlyOptimizeForSize", ",", "MergeExternalByDefault", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "AArch64InstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MCAsmInfo", "*", "MAI", "=", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ";", "{", "auto", "Op", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Op", "==", "AArch64", "::", "INLINEASM", "||", "Op", "==", "AArch64", "::", "INLINEASM_BR", ")", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "MAI", ")", ";", "}", "unsigned", "NumBytes", "=", "0", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MI", ".", "getDesc", "(", ")", ";", "switch", "(", "Desc", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "NumBytes", "=", "4", ";", "break", ";", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "NumBytes", "=", "0", ";", "break", ";", "case", "TargetOpcode", "::", "STACKMAP", ":", "NumBytes", "=", "StackMapOpers", "(", "&", "MI", ")", ".", "getNumPatchBytes", "(", ")", ";", "assert", "(", "NumBytes", "%", "4", "==", "0", "&&", "\"Invalid number of NOP bytes requested!\"", ")", ";", "break", ";", "case", "TargetOpcode", "::", "PATCHPOINT", ":", "NumBytes", "=", "PatchPointOpers", "(", "&", "MI", ")", ".", "getNumPatchBytes", "(", ")", ";", "assert", "(", "NumBytes", "%", "4", "==", "0", "&&", "\"Invalid number of NOP bytes requested!\"", ")", ";", "break", ";", "case", "AArch64", "::", "TLSDESC_CALLSEQ", ":", "NumBytes", "=", "16", ";", "break", ";", "case", "AArch64", "::", "JumpTableDest32", ":", "case", "AArch64", "::", "JumpTableDest16", ":", "case", "AArch64", "::", "JumpTableDest8", ":", "NumBytes", "=", "12", ";", "break", ";", "case", "AArch64", "::", "SPACE", ":", "NumBytes", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "break", ";", "}", "return", "NumBytes", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64::INLINEASM", "AArch64::INLINEASM_BR", "0", "0", "4", "0", "4", "0", "\"Invalid number of NOP bytes requested!\"", "4", "0", "\"Invalid number of NOP bytes requested!\"", "AArch64::TLSDESC_CALLSEQ", "16", "AArch64::JumpTableDest32", "AArch64::JumpTableDest16", "AArch64::JumpTableDest8", "12", "AArch64::SPACE", "1" ]

[]

[ "<s>", "static", "void", "init_float128_ibm", "(", "machine_mode", "mode", ")", "{", "if", "(", "!", "TARGET_XL_COMPAT", ")", "{", "set_optab_libfunc", "(", "add_optab", ",", "mode", ",", "\"__gcc_qadd\"", ")", ";", "set_optab_libfunc", "(", "sub_optab", ",", "mode", ",", "\"__gcc_qsub\"", ")", ";", "set_optab_libfunc", "(", "smul_optab", ",", "mode", ",", "\"__gcc_qmul\"", ")", ";", "set_optab_libfunc", "(", "sdiv_optab", ",", "mode", ",", "\"__gcc_qdiv\"", ")", ";", "if", "(", "!", "TARGET_HARD_FLOAT", ")", "{", "set_optab_libfunc", "(", "neg_optab", ",", "mode", ",", "\"__gcc_qneg\"", ")", ";", "set_optab_libfunc", "(", "eq_optab", ",", "mode", ",", "\"__gcc_qeq\"", ")", ";", "set_optab_libfunc", "(", "ne_optab", ",", "mode", ",", "\"__gcc_qne\"", ")", ";", "set_optab_libfunc", "(", "gt_optab", ",", "mode", ",", "\"__gcc_qgt\"", ")", ";", "set_optab_libfunc", "(", "ge_optab", ",", "mode", ",", "\"__gcc_qge\"", ")", ";", "set_optab_libfunc", "(", "lt_optab", ",", "mode", ",", "\"__gcc_qlt\"", ")", ";", "set_optab_libfunc", "(", "le_optab", ",", "mode", ",", "\"__gcc_qle\"", ")", ";", "set_optab_libfunc", "(", "unord_optab", ",", "mode", ",", "\"__gcc_qunord\"", ")", ";", "set_conv_libfunc", "(", "sext_optab", ",", "mode", ",", "SFmode", ",", "\"__gcc_stoq\"", ")", ";", "set_conv_libfunc", "(", "sext_optab", ",", "mode", ",", "DFmode", ",", "\"__gcc_dtoq\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "SFmode", ",", "mode", ",", "\"__gcc_qtos\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "DFmode", ",", "mode", ",", "\"__gcc_qtod\"", ")", ";", "set_conv_libfunc", "(", "sfix_optab", ",", "SImode", ",", "mode", ",", "\"__gcc_qtoi\"", ")", ";", "set_conv_libfunc", "(", "ufix_optab", ",", "SImode", ",", "mode", ",", "\"__gcc_qtou\"", ")", ";", "set_conv_libfunc", "(", "sfloat_optab", ",", "mode", ",", "SImode", ",", "\"__gcc_itoq\"", ")", ";", "set_conv_libfunc", "(", "ufloat_optab", ",", "mode", ",", "SImode", ",", "\"__gcc_utoq\"", ")", ";", "}", "}", "else", "{", "set_optab_libfunc", "(", "add_optab", ",", "mode", ",", "\"_xlqadd\"", ")", ";", "set_optab_libfunc", "(", "sub_optab", ",", "mode", ",", "\"_xlqsub\"", ")", ";", "set_optab_libfunc", "(", "smul_optab", ",", "mode", ",", "\"_xlqmul\"", ")", ";", "set_optab_libfunc", "(", "sdiv_optab", ",", "mode", ",", "\"_xlqdiv\"", ")", ";", "}", "if", "(", "mode", "==", "IFmode", ")", "{", "set_conv_libfunc", "(", "sext_optab", ",", "mode", ",", "SDmode", ",", "\"__dpd_extendsdtf2\"", ")", ";", "set_conv_libfunc", "(", "sext_optab", ",", "mode", ",", "DDmode", ",", "\"__dpd_extendddtf2\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "mode", ",", "TDmode", ",", "\"__dpd_trunctftd2\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "SDmode", ",", "mode", ",", "\"__dpd_trunctfsd2\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "DDmode", ",", "mode", ",", "\"__dpd_trunctfdd2\"", ")", ";", "set_conv_libfunc", "(", "sext_optab", ",", "TDmode", ",", "mode", ",", "\"__dpd_extendtdtf2\"", ")", ";", "if", "(", "TARGET_POWERPC64", ")", "{", "set_conv_libfunc", "(", "sfix_optab", ",", "TImode", ",", "mode", ",", "\"__fixtfti\"", ")", ";", "set_conv_libfunc", "(", "ufix_optab", ",", "TImode", ",", "mode", ",", "\"__fixunstfti\"", ")", ";", "set_conv_libfunc", "(", "sfloat_optab", ",", "mode", ",", "TImode", ",", "\"__floattitf\"", ")", ";", "set_conv_libfunc", "(", "ufloat_optab", ",", "mode", ",", "TImode", ",", "\"__floatuntitf\"", ")", ";", "}", "}", "}", "</s>" ]

[ "Set", "up", "AIX/Darwin/64-bit", "Linux", "quad", "floating", "point", "routines", "." ]

[ "rs6000", "\"__gcc_qadd\"", "\"__gcc_qsub\"", "\"__gcc_qmul\"", "\"__gcc_qdiv\"", "\"__gcc_qneg\"", "\"__gcc_qeq\"", "\"__gcc_qne\"", "\"__gcc_qgt\"", "\"__gcc_qge\"", "\"__gcc_qlt\"", "\"__gcc_qle\"", "\"__gcc_qunord\"", "\"__gcc_stoq\"", "\"__gcc_dtoq\"", "\"__gcc_qtos\"", "\"__gcc_qtod\"", "\"__gcc_qtoi\"", "\"__gcc_qtou\"", "\"__gcc_itoq\"", "\"__gcc_utoq\"", "\"_xlqadd\"", "\"_xlqsub\"", "\"_xlqmul\"", "\"_xlqdiv\"", "\"__dpd_extendsdtf2\"", "\"__dpd_extendddtf2\"", "\"__dpd_trunctftd2\"", "\"__dpd_trunctfsd2\"", "\"__dpd_trunctfdd2\"", "\"__dpd_extendtdtf2\"", "\"__fixtfti\"", "\"__fixunstfti\"", "\"__floattitf\"", "\"__floatuntitf\"" ]

[]

[ "<s>", "bool", "X86AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", ".", "startswith", "(", "\".code\"", ")", ")", "return", "ParseDirectiveCode", "(", "IDVal", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".att_syntax\"", ")", ")", "{", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"prefix\"", ")", "Parser", ".", "Lex", "(", ")", ";", "else", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"noprefix\"", ")", "return", "Error", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "\"'.att_syntax noprefix' is not \"", "\"supported: registers must have a \"", "\"'%' prefix in .att_syntax\"", ")", ";", "}", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "0", ")", ";", "return", "false", ";", "}", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".intel_syntax\"", ")", ")", "{", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "1", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"noprefix\"", ")", "Parser", ".", "Lex", "(", ")", ";", "else", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"prefix\"", ")", "return", "Error", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "\"'.intel_syntax prefix' is not \"", "\"supported: registers must not have \"", "\"a '%' prefix in .intel_syntax\"", ")", ";", "}", "return", "false", ";", "}", "else", "if", "(", "IDVal", "==", "\".even\"", ")", "return", "parseDirectiveEven", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".cv_fpo_proc\"", ")", "return", "parseDirectiveFPOProc", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".cv_fpo_setframe\"", ")", "return", "parseDirectiveFPOSetFrame", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".cv_fpo_pushreg\"", ")", "return", "parseDirectiveFPOPushReg", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".cv_fpo_stackalloc\"", ")", "return", "parseDirectiveFPOStackAlloc", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".cv_fpo_stackalign\"", ")", "return", "parseDirectiveFPOStackAlign", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".cv_fpo_endprologue\"", ")", "return", "parseDirectiveFPOEndPrologue", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".cv_fpo_endproc\"", ")", "return", "parseDirectiveFPOEndProc", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "\".code\"", "\".att_syntax\"", "\"prefix\"", "\"noprefix\"", "\"'.att_syntax noprefix' is not \"", "\"supported: registers must have a \"", "\"'%' prefix in .att_syntax\"", "0", "\".intel_syntax\"", "1", "\"noprefix\"", "\"prefix\"", "\"'.intel_syntax prefix' is not \"", "\"supported: registers must not have \"", "\"a '%' prefix in .intel_syntax\"", "\".even\"", "\".cv_fpo_proc\"", "\".cv_fpo_setframe\"", "\".cv_fpo_pushreg\"", "\".cv_fpo_stackalloc\"", "\".cv_fpo_stackalign\"", "\".cv_fpo_endprologue\"", "\".cv_fpo_endproc\"" ]

[]

[ "<s>", "static", "void", "emit_save_or_restore_regs", "(", "int", "action", ")", "{", "HOST_WIDE_INT", "offset", ";", "rtx", "base", ";", "offset", "=", "frame_base_offset", "-", "apparent_fsize", ";", "if", "(", "offset", "<", "-", "4096", "||", "offset", "+", "num_gfregs", "*", "4", ">", "4095", ")", "{", "base", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "emit_move_insn", "(", "base", ",", "GEN_INT", "(", "offset", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "base", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "frame_base_reg", ",", "base", ")", ")", ")", ";", "offset", "=", "0", ";", "}", "else", "base", "=", "frame_base_reg", ";", "offset", "=", "save_or_restore_regs", "(", "0", ",", "8", ",", "base", ",", "offset", ",", "action", ")", ";", "save_or_restore_regs", "(", "32", ",", "TARGET_V9", "?", "96", ":", "64", ",", "base", ",", "offset", ",", "action", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "save", "call-saved", "registers", "." ]

[ "sparc", "4096", "4", "4095", "1", "0", "0", "8", "32", "96", "64" ]

[]

[ "<s>", "unsigned", "PPCRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "hasFP", "(", "MF", ")", "?", "PPC", "::", "R31", ":", "PPC", "::", "R1", ";", "else", "return", "hasFP", "(", "MF", ")", "?", "PPC", "::", "X31", ":", "PPC", "::", "X1", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC::R31", "PPC::R1", "PPC::X31", "PPC::X1" ]

[]

[ "<s>", "void", "WebAssemblyInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "auto", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DestReg", ")", "?", "MRI", ".", "getRegClass", "(", "DestReg", ")", ":", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getMinimalPhysRegClass", "(", "DestReg", ")", ";", "unsigned", "CopyOpcode", ";", "if", "(", "RC", "==", "&", "WebAssembly", "::", "I32RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_I32", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "I64RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_I64", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "F32RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_F32", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "F64RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_F64", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "V128RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_V128", ";", "else", "llvm_unreachable", "(", "\"Unexpected register class\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "CopyOpcode", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "KillSrc", "?", "RegState", "::", "Kill", ":", "0", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly::I32RegClass", "WebAssembly::COPY_I32", "WebAssembly::I64RegClass", "WebAssembly::COPY_I64", "WebAssembly::F32RegClass", "WebAssembly::COPY_F32", "WebAssembly::F64RegClass", "WebAssembly::COPY_F64", "WebAssembly::V128RegClass", "WebAssembly::COPY_V128", "\"Unexpected register class\"", "0" ]

[]

[ "<s>", "MachineBasicBlock", "*", "RISCVTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "RISCV", "::", "SELECT_CC", ":", "case", "RISCV", "::", "SELECT_CC64", ":", "case", "RISCV", "::", "FSELECT_CC_F", ":", "case", "RISCV", "::", "FSELECT_CC_D", ":", "return", "emitSelectCC", "(", "MI", ",", "MBB", ")", ";", "case", "RISCV", "::", "CALL", ":", "case", "RISCV", "::", "CALLREG", ":", "case", "RISCV", "::", "CALL64", ":", "case", "RISCV", "::", "CALLREG64", ":", "return", "emitCALL", "(", "MI", ",", "MBB", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::SELECT_CC", "RISCV::SELECT_CC64", "RISCV::FSELECT_CC_F", "RISCV::FSELECT_CC_D", "RISCV::CALL", "RISCV::CALLREG", "RISCV::CALL64", "RISCV::CALLREG64", "\"Unexpected instr type to insert\"" ]

[]

[ "<s>", "bool", "HexagonExpandCondsets", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "HII", "=", "static_cast", "<", "const", "HexagonInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "LocalImpDefs", ".", "clear", "(", ")", ";", "DEBUG", "(", "LIS", "->", "print", "(", "dbgs", "(", ")", "<<", "\"Before expand-condsets\\n\"", ",", "MF", ".", "getFunction", "(", ")", "->", "getParent", "(", ")", ")", ")", ";", "bool", "Changed", "=", "false", ";", "std", "::", "set", "<", "unsigned", ">", "SplitUpd", ",", "PredUpd", ";", "Changed", "|=", "coalesceSegments", "(", "MF", ")", ";", "for", "(", "auto", "&", "B", ":", "MF", ")", "Changed", "|=", "splitInBlock", "(", "B", ",", "SplitUpd", ")", ";", "updateLiveness", "(", "SplitUpd", ",", "true", ",", "true", ",", "false", ")", ";", "for", "(", "auto", "&", "B", ":", "MF", ")", "Changed", "|=", "predicateInBlock", "(", "B", ",", "PredUpd", ")", ";", "updateLiveness", "(", "PredUpd", ",", "true", ",", "true", ",", "true", ")", ";", "std", "::", "set", "<", "unsigned", ">", "Diff", ";", "std", "::", "set_difference", "(", "SplitUpd", ".", "begin", "(", ")", ",", "SplitUpd", ".", "end", "(", ")", ",", "PredUpd", ".", "begin", "(", ")", ",", "PredUpd", ".", "end", "(", ")", ",", "std", "::", "inserter", "(", "Diff", ",", "Diff", ".", "begin", "(", ")", ")", ")", ";", "updateLiveness", "(", "Diff", ",", "false", ",", "false", ",", "true", ")", ";", "for", "(", "auto", "*", "ImpD", ":", "LocalImpDefs", ")", "removeInstr", "(", "*", "ImpD", ")", ";", "DEBUG", "(", "{", "if", "(", "Changed", ")", "LIS", "->", "print", "(", "dbgs", "(", ")", "<<", "\"After expand-condsets\\n\"", ",", "MF", ".", "getFunction", "(", ")", "->", "getParent", "(", ")", ")", ";", "}", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "\"Before expand-condsets\\n\"", "\"After expand-condsets\\n\"" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "LDRrs", ":", "case", "ARM", "::", "t2LDRs", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "0", "&&", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "LDRi12", ":", "case", "ARM", "::", "t2LDRi12", ":", "case", "ARM", "::", "tLDRspi", ":", "case", "ARM", "::", "VLDRD", ":", "case", "ARM", "::", "VLDRS", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VLD1q64", ":", "case", "ARM", "::", "VLD1d64TPseudo", ":", "case", "ARM", "::", "VLD1d64QPseudo", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VLDMQIA", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::LDRrs", "ARM::t2LDRs", "1", "2", "3", "2", "0", "3", "0", "1", "0", "ARM::LDRi12", "ARM::t2LDRi12", "ARM::tLDRspi", "ARM::VLDRD", "ARM::VLDRS", "1", "2", "2", "0", "1", "0", "ARM::VLD1q64", "ARM::VLD1d64TPseudo", "ARM::VLD1d64QPseudo", "1", "0", "0", "1", "0", "ARM::VLDMQIA", "1", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "static", "rtx", "rs6000_emit_savres_rtx", "(", "rs6000_stack_t", "*", "info", ",", "rtx", "frame_reg_rtx", ",", "int", "save_area_offset", ",", "int", "lr_offset", ",", "machine_mode", "reg_mode", ",", "int", "sel", ")", "{", "int", "i", ";", "int", "offset", ",", "start_reg", ",", "end_reg", ",", "n_regs", ",", "use_reg", ";", "int", "reg_size", "=", "GET_MODE_SIZE", "(", "reg_mode", ")", ";", "rtx", "sym", ";", "rtvec", "p", ";", "rtx", "par", ",", "insn", ";", "offset", "=", "0", ";", "start_reg", "=", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_GPR", "?", "info", "->", "first_gp_reg_save", ":", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_FPR", "?", "info", "->", "first_fp_reg_save", ":", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_VR", "?", "info", "->", "first_altivec_reg_save", ":", "-", "1", ")", ";", "end_reg", "=", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_GPR", "?", "32", ":", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_FPR", "?", "64", ":", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_VR", "?", "LAST_ALTIVEC_REGNO", "+", "1", ":", "-", "1", ")", ";", "n_regs", "=", "end_reg", "-", "start_reg", ";", "p", "=", "rtvec_alloc", "(", "3", "+", "(", "(", "sel", "&", "SAVRES_LR", ")", "?", "1", ":", "0", ")", "+", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_VR", "?", "1", ":", "0", ")", "+", "n_regs", ")", ";", "if", "(", "!", "(", "sel", "&", "SAVRES_SAVE", ")", "&&", "(", "sel", "&", "SAVRES_LR", ")", ")", "RTVEC_ELT", "(", "p", ",", "offset", "++", ")", "=", "ret_rtx", ";", "RTVEC_ELT", "(", "p", ",", "offset", "++", ")", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "LR_REGNO", ")", ")", ";", "sym", "=", "rs6000_savres_routine_sym", "(", "info", ",", "sel", ")", ";", "RTVEC_ELT", "(", "p", ",", "offset", "++", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "sym", ")", ";", "use_reg", "=", "ptr_regno_for_savres", "(", "sel", ")", ";", "if", "(", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_VR", ")", "{", "RTVEC_ELT", "(", "p", ",", "offset", "++", ")", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "use_reg", ")", ")", ";", "RTVEC_ELT", "(", "p", ",", "offset", "++", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ")", ";", "}", "else", "RTVEC_ELT", "(", "p", ",", "offset", "++", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "use_reg", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "end_reg", "-", "start_reg", ";", "i", "++", ")", "RTVEC_ELT", "(", "p", ",", "i", "+", "offset", ")", "=", "gen_frame_set", "(", "gen_rtx_REG", "(", "reg_mode", ",", "start_reg", "+", "i", ")", ",", "frame_reg_rtx", ",", "save_area_offset", "+", "reg_size", "*", "i", ",", "(", "sel", "&", "SAVRES_SAVE", ")", "!=", "0", ")", ";", "if", "(", "(", "sel", "&", "SAVRES_SAVE", ")", "&&", "(", "sel", "&", "SAVRES_LR", ")", ")", "RTVEC_ELT", "(", "p", ",", "i", "+", "offset", ")", "=", "gen_frame_store", "(", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ",", "frame_reg_rtx", ",", "lr_offset", ")", ";", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "p", ")", ";", "if", "(", "!", "(", "sel", "&", "SAVRES_SAVE", ")", "&&", "(", "sel", "&", "SAVRES_LR", ")", ")", "{", "insn", "=", "emit_jump_insn", "(", "par", ")", ";", "JUMP_LABEL", "(", "insn", ")", "=", "ret_rtx", ";", "}", "else", "insn", "=", "emit_insn", "(", "par", ")", ";", "return", "insn", ";", "}", "</s>" ]

[ "Construct", "a", "parallel", "rtx", "describing", "the", "effect", "of", "a", "call", "to", "an", "out-of-line", "register", "save/restore", "routine", ",", "and", "emit", "the", "insn", "or", "jump_insn", "as", "appropriate", "." ]

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

[]

[ "<s>", "static", "bool", "nds32_sp_base_or_plus_load_store_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "mem_src", "=", "NULL_RTX", ";", "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_LOAD", ":", "mem_src", "=", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ";", "break", ";", "case", "TYPE_STORE", ":", "mem_src", "=", "SET_DEST", "(", "PATTERN", "(", "insn", ")", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "mem_src", "!=", "NULL_RTX", ")", "{", "if", "(", "(", "GET_CODE", "(", "mem_src", ")", "==", "ZERO_EXTEND", ")", "||", "(", "GET_CODE", "(", "mem_src", ")", "==", "SIGN_EXTEND", ")", ")", "mem_src", "=", "XEXP", "(", "mem_src", ",", "0", ")", ";", "if", "(", "(", "GET_CODE", "(", "XEXP", "(", "mem_src", ",", "0", ")", ")", "==", "PLUS", ")", ")", "mem_src", "=", "XEXP", "(", "mem_src", ",", "0", ")", ";", "if", "(", "REG_P", "(", "XEXP", "(", "mem_src", ",", "0", ")", ")", "&&", "(", "(", "frame_pointer_needed", "&&", "REGNO", "(", "XEXP", "(", "mem_src", ",", "0", ")", ")", "==", "FP_REGNUM", ")", "||", "REGNO", "(", "XEXP", "(", "mem_src", ",", "0", ")", ")", "==", "SP_REGNUM", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "insn", "is", "a", "sp/fp", "base", "or", "sp/fp", "plus", "load-store", "instruction", "." ]

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

[]

[ "<s>", "bool", "runOnFunction", "(", "Function", "&", "F", ")", "override", "{", "visit", "(", "F", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "getMachineCombinerPatterns", "(", "MachineInstr", "&", "Root", ",", "SmallVectorImpl", "<", "MachineCombinerPattern", ">", "&", "Patterns", ",", "bool", "DoRegPressureReduce", ")", "const", "{", "if", "(", "getMaddPatterns", "(", "Root", ",", "Patterns", ")", ")", "return", "true", ";", "if", "(", "getFMULPatterns", "(", "Root", ",", "Patterns", ")", ")", "return", "true", ";", "if", "(", "getFMAPatterns", "(", "Root", ",", "Patterns", ")", ")", "return", "true", ";", "return", "TargetInstrInfo", "::", "getMachineCombinerPatterns", "(", "Root", ",", "Patterns", ",", "DoRegPressureReduce", ")", ";", "}", "</s>" ]

[ "Return", "true", "when", "there", "is", "potentially", "a", "faster", "code", "sequence", "for", "an", "instruction", "chain", "ending", "in", "Root", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "void", "PPCPassConfig", "::", "addMachineSSAOptimization", "(", ")", "{", "if", "(", "EnableBranchCoalescing", "&&", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createPPCBranchCoalescingPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addMachineSSAOptimization", "(", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "ppc64le", "&&", "!", "DisableVSXSwapRemoval", ")", "addPass", "(", "createPPCVSXSwapRemovalPass", "(", ")", ")", ";", "if", "(", "!", "DisableMIPeephole", ")", "{", "addPass", "(", "createPPCMIPeepholePass", "(", ")", ")", ";", "addPass", "(", "&", "DeadMachineInstructionElimID", ")", ";", "}", "}", "</s>" ]

[ "Methods", "with", "trivial", "inline", "returns", "are", "convenient", "points", "in", "the", "common", "codegen", "pass", "pipeline", "where", "targets", "may", "insert", "passes", "." ]

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

[]

[ "<s>", "const", "char", "*", "HexagonTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "HexagonISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "HexagonISD", "::", "ALLOCA", ":", "return", "\"HexagonISD::ALLOCA\"", ";", "case", "HexagonISD", "::", "AT_GOT", ":", "return", "\"HexagonISD::AT_GOT\"", ";", "case", "HexagonISD", "::", "AT_PCREL", ":", "return", "\"HexagonISD::AT_PCREL\"", ";", "case", "HexagonISD", "::", "BARRIER", ":", "return", "\"HexagonISD::BARRIER\"", ";", "case", "HexagonISD", "::", "CALL", ":", "return", "\"HexagonISD::CALL\"", ";", "case", "HexagonISD", "::", "CALLnr", ":", "return", "\"HexagonISD::CALLnr\"", ";", "case", "HexagonISD", "::", "CALLR", ":", "return", "\"HexagonISD::CALLR\"", ";", "case", "HexagonISD", "::", "COMBINE", ":", "return", "\"HexagonISD::COMBINE\"", ";", "case", "HexagonISD", "::", "CONST32_GP", ":", "return", "\"HexagonISD::CONST32_GP\"", ";", "case", "HexagonISD", "::", "CONST32", ":", "return", "\"HexagonISD::CONST32\"", ";", "case", "HexagonISD", "::", "CP", ":", "return", "\"HexagonISD::CP\"", ";", "case", "HexagonISD", "::", "DCFETCH", ":", "return", "\"HexagonISD::DCFETCH\"", ";", "case", "HexagonISD", "::", "EH_RETURN", ":", "return", "\"HexagonISD::EH_RETURN\"", ";", "case", "HexagonISD", "::", "TSTBIT", ":", "return", "\"HexagonISD::TSTBIT\"", ";", "case", "HexagonISD", "::", "EXTRACTU", ":", "return", "\"HexagonISD::EXTRACTU\"", ";", "case", "HexagonISD", "::", "INSERT", ":", "return", "\"HexagonISD::INSERT\"", ";", "case", "HexagonISD", "::", "JT", ":", "return", "\"HexagonISD::JT\"", ";", "case", "HexagonISD", "::", "RET_FLAG", ":", "return", "\"HexagonISD::RET_FLAG\"", ";", "case", "HexagonISD", "::", "TC_RETURN", ":", "return", "\"HexagonISD::TC_RETURN\"", ";", "case", "HexagonISD", "::", "VASL", ":", "return", "\"HexagonISD::VASL\"", ";", "case", "HexagonISD", "::", "VASR", ":", "return", "\"HexagonISD::VASR\"", ";", "case", "HexagonISD", "::", "VLSR", ":", "return", "\"HexagonISD::VLSR\"", ";", "case", "HexagonISD", "::", "VSPLAT", ":", "return", "\"HexagonISD::VSPLAT\"", ";", "case", "HexagonISD", "::", "VEXTRACTW", ":", "return", "\"HexagonISD::VEXTRACTW\"", ";", "case", "HexagonISD", "::", "VINSERTW0", ":", "return", "\"HexagonISD::VINSERTW0\"", ";", "case", "HexagonISD", "::", "VROR", ":", "return", "\"HexagonISD::VROR\"", ";", "case", "HexagonISD", "::", "READCYCLE", ":", "return", "\"HexagonISD::READCYCLE\"", ";", "case", "HexagonISD", "::", "VZERO", ":", "return", "\"HexagonISD::VZERO\"", ";", "case", "HexagonISD", "::", "D2P", ":", "return", "\"HexagonISD::D2P\"", ";", "case", "HexagonISD", "::", "P2D", ":", "return", "\"HexagonISD::P2D\"", ";", "case", "HexagonISD", "::", "V2Q", ":", "return", "\"HexagonISD::V2Q\"", ";", "case", "HexagonISD", "::", "Q2V", ":", "return", "\"HexagonISD::Q2V\"", ";", "case", "HexagonISD", "::", "QCAT", ":", "return", "\"HexagonISD::QCAT\"", ";", "case", "HexagonISD", "::", "QTRUE", ":", "return", "\"HexagonISD::QTRUE\"", ";", "case", "HexagonISD", "::", "QFALSE", ":", "return", "\"HexagonISD::QFALSE\"", ";", "case", "HexagonISD", "::", "TYPECAST", ":", "return", "\"HexagonISD::TYPECAST\"", ";", "case", "HexagonISD", "::", "OP_END", ":", "break", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "HexagonISD::NodeType", "HexagonISD::ALLOCA", "\"HexagonISD::ALLOCA\"", "HexagonISD::AT_GOT", "\"HexagonISD::AT_GOT\"", "HexagonISD::AT_PCREL", "\"HexagonISD::AT_PCREL\"", "HexagonISD::BARRIER", "\"HexagonISD::BARRIER\"", "HexagonISD::CALL", "\"HexagonISD::CALL\"", "HexagonISD::CALLnr", "\"HexagonISD::CALLnr\"", "HexagonISD::CALLR", "\"HexagonISD::CALLR\"", "HexagonISD::COMBINE", "\"HexagonISD::COMBINE\"", "HexagonISD::CONST32_GP", "\"HexagonISD::CONST32_GP\"", "HexagonISD::CONST32", "\"HexagonISD::CONST32\"", "HexagonISD::CP", "\"HexagonISD::CP\"", "HexagonISD::DCFETCH", "\"HexagonISD::DCFETCH\"", "HexagonISD::EH_RETURN", "\"HexagonISD::EH_RETURN\"", "HexagonISD::TSTBIT", "\"HexagonISD::TSTBIT\"", "HexagonISD::EXTRACTU", "\"HexagonISD::EXTRACTU\"", "HexagonISD::INSERT", "\"HexagonISD::INSERT\"", "HexagonISD::JT", "\"HexagonISD::JT\"", "HexagonISD::RET_FLAG", "\"HexagonISD::RET_FLAG\"", "HexagonISD::TC_RETURN", "\"HexagonISD::TC_RETURN\"", "HexagonISD::VASL", "\"HexagonISD::VASL\"", "HexagonISD::VASR", "\"HexagonISD::VASR\"", "HexagonISD::VLSR", "\"HexagonISD::VLSR\"", "HexagonISD::VSPLAT", "\"HexagonISD::VSPLAT\"", "HexagonISD::VEXTRACTW", "\"HexagonISD::VEXTRACTW\"", "HexagonISD::VINSERTW0", "\"HexagonISD::VINSERTW0\"", "HexagonISD::VROR", "\"HexagonISD::VROR\"", "HexagonISD::READCYCLE", "\"HexagonISD::READCYCLE\"", "HexagonISD::VZERO", "\"HexagonISD::VZERO\"", "HexagonISD::D2P", "\"HexagonISD::D2P\"", "HexagonISD::P2D", "\"HexagonISD::P2D\"", "HexagonISD::V2Q", "\"HexagonISD::V2Q\"", "HexagonISD::Q2V", "\"HexagonISD::Q2V\"", "HexagonISD::QCAT", "\"HexagonISD::QCAT\"", "HexagonISD::QTRUE", "\"HexagonISD::QTRUE\"", "HexagonISD::QFALSE", "\"HexagonISD::QFALSE\"", "HexagonISD::TYPECAST", "\"HexagonISD::TYPECAST\"", "HexagonISD::OP_END" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isAsCheapAsAMove", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "hasCustomCheapAsMoveHandling", "(", ")", ")", "return", "MI", ".", "isAsCheapAsAMove", "(", ")", ";", "const", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Subtarget", ".", "hasZeroCycleZeroingFP", "(", ")", ")", "{", "if", "(", "Opcode", "==", "AArch64", "::", "FMOVH0", "||", "Opcode", "==", "AArch64", "::", "FMOVS0", "||", "Opcode", "==", "AArch64", "::", "FMOVD0", ")", "return", "true", ";", "}", "if", "(", "Subtarget", ".", "hasZeroCycleZeroingGP", "(", ")", ")", "{", "if", "(", "Opcode", "==", "TargetOpcode", "::", "COPY", "&&", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "AArch64", "::", "WZR", "||", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "AArch64", "::", "XZR", ")", ")", "return", "true", ";", "}", "if", "(", "Subtarget", ".", "hasExynosCheapAsMoveHandling", "(", ")", ")", "{", "if", "(", "isExynosResetFast", "(", "MI", ")", "||", "isExynosShiftLeftFast", "(", "MI", ")", ")", "return", "true", ";", "else", "return", "MI", ".", "isAsCheapAsAMove", "(", ")", ";", "}", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "false", ";", "case", "AArch64", "::", "ADDWri", ":", "case", "AArch64", "::", "ADDXri", ":", "case", "AArch64", "::", "SUBWri", ":", "case", "AArch64", "::", "SUBXri", ":", "return", "(", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", ";", "case", "AArch64", "::", "ANDWri", ":", "case", "AArch64", "::", "ANDXri", ":", "case", "AArch64", "::", "EORWri", ":", "case", "AArch64", "::", "EORXri", ":", "case", "AArch64", "::", "ORRWri", ":", "case", "AArch64", "::", "ORRXri", ":", "return", "true", ";", "case", "AArch64", "::", "ANDWrr", ":", "case", "AArch64", "::", "ANDXrr", ":", "case", "AArch64", "::", "BICWrr", ":", "case", "AArch64", "::", "BICXrr", ":", "case", "AArch64", "::", "EONWrr", ":", "case", "AArch64", "::", "EONXrr", ":", "case", "AArch64", "::", "EORWrr", ":", "case", "AArch64", "::", "EORXrr", ":", "case", "AArch64", "::", "ORNWrr", ":", "case", "AArch64", "::", "ORNXrr", ":", "case", "AArch64", "::", "ORRWrr", ":", "case", "AArch64", "::", "ORRXrr", ":", "return", "true", ";", "case", "AArch64", "::", "MOVi32imm", ":", "return", "canBeExpandedToORR", "(", "MI", ",", "32", ")", ";", "case", "AArch64", "::", "MOVi64imm", ":", "return", "canBeExpandedToORR", "(", "MI", ",", "64", ")", ";", "}", "llvm_unreachable", "(", "\"Unknown opcode to check as cheap as a move!\"", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "is", "as", "cheap", "as", "a", "move", "instruction", "." ]

[ "AArch64", "AArch64", "AArch64::FMOVH0", "AArch64::FMOVS0", "AArch64::FMOVD0", "1", "AArch64::WZR", "1", "AArch64::XZR", "AArch64::ADDWri", "AArch64::ADDXri", "AArch64::SUBWri", "AArch64::SUBXri", "3", "0", "AArch64::ANDWri", "AArch64::ANDXri", "AArch64::EORWri", "AArch64::EORXri", "AArch64::ORRWri", "AArch64::ORRXri", "AArch64::ANDWrr", "AArch64::ANDXrr", "AArch64::BICWrr", "AArch64::BICXrr", "AArch64::EONWrr", "AArch64::EONXrr", "AArch64::EORWrr", "AArch64::EORXrr", "AArch64::ORNWrr", "AArch64::ORNXrr", "AArch64::ORRWrr", "AArch64::ORRXrr", "AArch64::MOVi32imm", "32", "AArch64::MOVi64imm", "64", "\"Unknown opcode to check as cheap as a move!\"" ]

[]

[ "<s>", "int", "null_prologue", "(", ")", "{", "if", "(", "!", "reload_completed", ")", "return", "0", ";", "if", "(", "!", "frame_laid_out", ")", "m88k_layout_frame", "(", ")", ";", "return", "(", "!", "frame_pointer_needed", "&&", "nregs", "==", "0", "&&", "nxregs", "==", "0", "&&", "m88k_stack_size", "==", "0", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "function", "is", "known", "to", "have", "a", "null", "prologue", "." ]

[ "m88k", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "mcore_add_gc_roots", "(", ")", "{", "ggc_add_rtx_root", "(", "&", "arch_compare_op0", ",", "1", ")", ";", "ggc_add_rtx_root", "(", "&", "arch_compare_op1", ",", "1", ")", ";", "}", "</s>" ]

[ "Called", "to", "register", "all", "of", "our", "global", "variables", "with", "the", "garbage", "collector", "." ]

[ "mcore", "1", "1" ]

[]

[ "<s>", "void", "PTXInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DstReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "for", "(", "int", "i", "=", "0", ",", "e", "=", "sizeof", "(", "map", ")", "/", "sizeof", "(", "map", "[", "0", "]", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "if", "(", "PTX", "::", "RRegs32RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "PTX", "::", "MOVrr", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "0", "0", "PTX::RRegs32RegClass", "PTX::MOVrr", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "MVT", "::", "i8", ";", "if", "(", "VT", ".", "isSimple", "(", ")", ")", "{", "MVT", "VVT", "=", "VT", ".", "getSimpleVT", "(", ")", ";", "const", "unsigned", "NumElts", "=", "VVT", ".", "getVectorNumElements", "(", ")", ";", "MVT", "EltVT", "=", "VVT", ".", "getVectorElementType", "(", ")", ";", "if", "(", "VVT", ".", "is512BitVector", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasAVX512", "(", ")", ")", "if", "(", "EltVT", "==", "MVT", "::", "i32", "||", "EltVT", "==", "MVT", "::", "i64", "||", "EltVT", "==", "MVT", "::", "f32", "||", "EltVT", "==", "MVT", "::", "f64", ")", "switch", "(", "NumElts", ")", "{", "case", "8", ":", "return", "MVT", "::", "v8i1", ";", "case", "16", ":", "return", "MVT", "::", "v16i1", ";", "}", "if", "(", "Subtarget", ".", "hasBWI", "(", ")", ")", "if", "(", "EltVT", "==", "MVT", "::", "i8", "||", "EltVT", "==", "MVT", "::", "i16", ")", "switch", "(", "NumElts", ")", "{", "case", "32", ":", "return", "MVT", "::", "v32i1", ";", "case", "64", ":", "return", "MVT", "::", "v64i1", ";", "}", "}", "if", "(", "Subtarget", ".", "hasBWI", "(", ")", "&&", "Subtarget", ".", "hasVLX", "(", ")", ")", "return", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i1", ",", "NumElts", ")", ";", "if", "(", "!", "isTypeLegal", "(", "VT", ")", "&&", "getTypeAction", "(", "Context", ",", "VT", ")", "==", "TypePromoteInteger", ")", "{", "EVT", "LegalVT", "=", "getTypeToTransformTo", "(", "Context", ",", "VT", ")", ";", "EltVT", "=", "LegalVT", ".", "getVectorElementType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "}", "if", "(", "Subtarget", ".", "hasVLX", "(", ")", "&&", "EltVT", ".", "getSizeInBits", "(", ")", ">=", "32", ")", "switch", "(", "NumElts", ")", "{", "case", "2", ":", "return", "MVT", "::", "v2i1", ";", "case", "4", ":", "return", "MVT", "::", "v4i1", ";", "case", "8", ":", "return", "MVT", "::", "v8i1", ";", "}", "}", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "MVT::i8", "MVT::i32", "MVT::i64", "MVT::f32", "MVT::f64", "8", "MVT::v8i1", "16", "MVT::v16i1", "MVT::i8", "MVT::i16", "32", "MVT::v32i1", "64", "MVT::v64i1", "MVT::getVectorVT", "MVT::i1", "32", "2", "MVT::v2i1", "4", "MVT::v4i1", "8", "MVT::v8i1" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "end", "(", ")", "{", "assert", "(", "End", "!=", "nullptr", ")", ";", "return", "End", ";", "}", "</s>" ]

[ "Get", "a", "const_iterator", "to", "the", "end", "of", "the", "symbol", "table", "." ]

[ "M68k" ]

[]

[ "<s>", "MachineBasicBlock", "*", "SparcTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown Custom Instruction!\"", ")", ";", "case", "SP", "::", "SELECT_CC_Int_ICC", ":", "case", "SP", "::", "SELECT_CC_FP_ICC", ":", "case", "SP", "::", "SELECT_CC_DFP_ICC", ":", "case", "SP", "::", "SELECT_CC_QFP_ICC", ":", "return", "expandSelectCC", "(", "MI", ",", "BB", ",", "SP", "::", "BCOND", ")", ";", "case", "SP", "::", "SELECT_CC_Int_FCC", ":", "case", "SP", "::", "SELECT_CC_FP_FCC", ":", "case", "SP", "::", "SELECT_CC_DFP_FCC", ":", "case", "SP", "::", "SELECT_CC_QFP_FCC", ":", "return", "expandSelectCC", "(", "MI", ",", "BB", ",", "SP", "::", "FBCOND", ")", ";", "case", "SP", "::", "EH_SJLJ_SETJMP32ri", ":", "case", "SP", "::", "EH_SJLJ_SETJMP32rr", ":", "return", "emitEHSjLjSetJmp", "(", "MI", ",", "BB", ")", ";", "case", "SP", "::", "EH_SJLJ_LONGJMP32rr", ":", "case", "SP", "::", "EH_SJLJ_LONGJMP32ri", ":", "return", "emitEHSjLjLongJmp", "(", "MI", ",", "BB", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "\"Unknown Custom Instruction!\"", "SP::SELECT_CC_Int_ICC", "SP::SELECT_CC_FP_ICC", "SP::SELECT_CC_DFP_ICC", "SP::SELECT_CC_QFP_ICC", "SP::BCOND", "SP::SELECT_CC_Int_FCC", "SP::SELECT_CC_FP_FCC", "SP::SELECT_CC_DFP_FCC", "SP::SELECT_CC_QFP_FCC", "SP::FBCOND", "SP::EH_SJLJ_SETJMP32ri", "SP::EH_SJLJ_SETJMP32rr", "SP::EH_SJLJ_LONGJMP32rr", "SP::EH_SJLJ_LONGJMP32ri" ]

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "R600", "SI", "ISD::BRCOND", "ISD::SELECT_CC" ]

[]

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

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

[ "Blackfin" ]

[]

[ "<s>", "int", "sign_extended_p", "(", "rtx", "x", ",", "int", "bits", ",", "rtx", "insn", ")", "{", "HOST_WIDE_INT", "w", ";", "int", "i", ",", "n", ";", "do", "{", "while", "(", "REG_P", "(", "x", ")", ")", "{", "x", "=", "pdp10_find_last_value", "(", "x", ",", "&", "insn", ")", ";", "if", "(", "x", "==", "NULL_RTX", ")", "return", "0", ";", "}", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "ASHIFTRT", ":", "n", "=", "INTVAL_OR_ELSE", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "break", ";", "case", "SIGN_EXTRACT", ":", "n", "=", "BITS_PER_WORD", "-", "INTVAL_OR_ELSE", "(", "XEXP", "(", "x", ",", "1", ")", ",", "BITS_PER_WORD", ")", ";", "x", "=", "NULL_RTX", ";", "break", ";", "case", "IOR", ":", "w", "=", "INTVAL_OR_ELSE", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ";", "for", "(", "i", "=", "BITS_PER_WORD", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "!", "(", "w", "&", "(", "(", "HWINT", "(", "1", ")", ")", "<<", "i", ")", ")", ")", "break", ";", "}", "n", "=", "BITS_PER_WORD", "-", "i", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "break", ";", "default", ":", "return", "0", ";", "}", "if", "(", "n", ">=", "bits", ")", "return", "1", ";", "bits", "-=", "n", ";", "}", "while", "(", "x", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "iff", "the", "last", "value", "X", "was", "set", "to", "before", "INSN", "had", "BITS", "sign-extended", "bits", "." ]

[ "pdp10", "0", "1", "0", "0", "1", "1", "0", "1", "0", "1", "0", "0", "1", "0" ]

[]

[ "<s>", "uint32_t", "AMDGPUTargetLowering", "::", "getImplicitParameterOffset", "(", "const", "MachineFunction", "&", "MF", ",", "const", "ImplicitParameter", "Param", ")", "const", "{", "const", "AMDGPUMachineFunction", "*", "MFI", "=", "MF", ".", "getInfo", "<", "AMDGPUMachineFunction", ">", "(", ")", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "AMDGPUSubtarget", "::", "get", "(", "getTargetMachine", "(", ")", ",", "MF", ".", "getFunction", "(", ")", ")", ";", "unsigned", "ExplicitArgOffset", "=", "ST", ".", "getExplicitKernelArgOffset", "(", "MF", ".", "getFunction", "(", ")", ")", ";", "unsigned", "Alignment", "=", "ST", ".", "getAlignmentForImplicitArgPtr", "(", ")", ";", "uint64_t", "ArgOffset", "=", "alignTo", "(", "MFI", "->", "getExplicitKernArgSize", "(", ")", ",", "Alignment", ")", "+", "ExplicitArgOffset", ";", "switch", "(", "Param", ")", "{", "case", "GRID_DIM", ":", "return", "ArgOffset", ";", "case", "GRID_OFFSET", ":", "return", "ArgOffset", "+", "4", ";", "}", "llvm_unreachable", "(", "\"unexpected implicit parameter type\"", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "X86RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", ";", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "bool", "AfterFPPop", "=", "Opc", "==", "X86", "::", "TAILJMPm64", "||", "Opc", "==", "X86", "::", "TAILJMPm", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "BasePtr", "=", "(", "FrameIndex", "<", "0", "?", "FramePtr", ":", "getBaseRegister", "(", ")", ")", ";", "else", "if", "(", "needsStackRealignment", "(", "MF", ")", ")", "BasePtr", "=", "(", "FrameIndex", "<", "0", "?", "FramePtr", ":", "StackPtr", ")", ";", "else", "if", "(", "AfterFPPop", ")", "BasePtr", "=", "StackPtr", ";", "else", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ")", ";", "if", "(", "Opc", "==", "X86", "::", "LEA64_32r", "&&", "X86", "::", "GR32RegClass", ".", "contains", "(", "BasePtr", ")", ")", "BasePtr", "=", "getX86SubSuperRegister", "(", "BasePtr", ",", "MVT", "::", "i64", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "int", "FIOffset", ";", "if", "(", "AfterFPPop", ")", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "FIOffset", "=", "MFI", "->", "getObjectOffset", "(", "FrameIndex", ")", "-", "TFI", "->", "getOffsetOfLocalArea", "(", ")", ";", "}", "else", "FIOffset", "=", "TFI", "->", "getFrameIndexOffset", "(", "MF", ",", "FrameIndex", ")", ";", "if", "(", "BasePtr", "==", "StackPtr", ")", "FIOffset", "+=", "SPAdj", ";", "if", "(", "Opc", "==", "TargetOpcode", "::", "STACKMAP", "||", "Opc", "==", "TargetOpcode", "::", "PATCHPOINT", ")", "{", "assert", "(", "BasePtr", "==", "FramePtr", "&&", "\"Expected the FP as base register\"", ")", ";", "int64_t", "Offset", "=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", "+", "FIOffset", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "if", "(", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "isImm", "(", ")", ")", "{", "int", "Imm", "=", "(", "int", ")", "(", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "getImm", "(", ")", ")", ";", "int", "Offset", "=", "FIOffset", "+", "Imm", ";", "assert", "(", "(", "!", "Is64Bit", "||", "isInt", "<", "32", ">", "(", "(", "long", "long", ")", "FIOffset", "+", "Imm", ")", ")", "&&", "\"Requesting 64-bit offset in 32-bit immediate!\"", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "{", "uint64_t", "Offset", "=", "FIOffset", "+", "(", "uint64_t", ")", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "getOffset", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "setOffset", "(", "Offset", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "X86", "X86", "X86::TAILJMPm64", "X86::TAILJMPm", "0", "0", "X86::LEA64_32r", "X86::GR32RegClass", "X86", "MVT::i64", "\"Expected the FP as base register\"", "1", "1", "3", "3", "32", "\"Requesting 64-bit offset in 32-bit immediate!\"", "3", "3", "3" ]

[]

[ "<s>", "const", "X86Subtarget", "*", "X86TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "StringRef", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetCPU", ";", "StringRef", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetFS", ";", "SmallString", "<", "512", ">", "Key", ";", "Key", ".", "reserve", "(", "CPU", ".", "size", "(", ")", "+", "FS", ".", "size", "(", ")", ")", ";", "Key", "+=", "CPU", ";", "Key", "+=", "FS", ";", "bool", "SoftFloat", "=", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ";", "if", "(", "SoftFloat", ")", "Key", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\",+soft-float\"", ";", "unsigned", "CPUFSWidth", "=", "Key", ".", "size", "(", ")", ";", "unsigned", "PreferVectorWidthOverride", "=", "0", ";", "if", "(", "F", ".", "hasFnAttribute", "(", "\"prefer-vector-width\"", ")", ")", "{", "StringRef", "Val", "=", "F", ".", "getFnAttribute", "(", "\"prefer-vector-width\"", ")", ".", "getValueAsString", "(", ")", ";", "unsigned", "Width", ";", "if", "(", "!", "Val", ".", "getAsInteger", "(", "0", ",", "Width", ")", ")", "{", "Key", "+=", "\",prefer-vector-width=\"", ";", "Key", "+=", "Val", ";", "PreferVectorWidthOverride", "=", "Width", ";", "}", "}", "unsigned", "RequiredVectorWidth", "=", "UINT32_MAX", ";", "if", "(", "F", ".", "hasFnAttribute", "(", "\"min-legal-vector-width\"", ")", ")", "{", "StringRef", "Val", "=", "F", ".", "getFnAttribute", "(", "\"min-legal-vector-width\"", ")", ".", "getValueAsString", "(", ")", ";", "unsigned", "Width", ";", "if", "(", "!", "Val", ".", "getAsInteger", "(", "0", ",", "Width", ")", ")", "{", "Key", "+=", "\",min-legal-vector-width=\"", ";", "Key", "+=", "Val", ";", "RequiredVectorWidth", "=", "Width", ";", "}", "}", "FS", "=", "Key", ".", "slice", "(", "CPU", ".", "size", "(", ")", ",", "CPUFSWidth", ")", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "X86Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "MaybeAlign", "(", "Options", ".", "StackAlignmentOverride", ")", ",", "PreferVectorWidthOverride", ",", "RequiredVectorWidth", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"target-cpu\"", "\"target-features\"", "512", "\"use-soft-float\"", "\"true\"", "\"+soft-float\"", "\",+soft-float\"", "0", "\"prefer-vector-width\"", "\"prefer-vector-width\"", "0", "\",prefer-vector-width=\"", "\"min-legal-vector-width\"", "\"min-legal-vector-width\"", "0", "\",min-legal-vector-width=\"", "X86" ]

[]

[ "<s>", "static", "bool", "loongarch_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict_p", ")", "{", "struct", "loongarch_address_info", "addr", ";", "return", "loongarch_classify_address", "(", "&", "addr", ",", "x", ",", "mode", ",", "strict_p", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_ADDRESS_P", "." ]

[ "loongarch" ]

[]

[ "<s>", "static", "int", "s390_check_qrst_address", "(", "char", "c", ",", "rtx", "op", ",", "bool", "lit_pool_ok", ")", "{", "struct", "s390_address", "addr", ";", "bool", "decomposed", "=", "false", ";", "if", "(", "s390_loadrelative_operand_p", "(", "op", ",", "NULL", ",", "NULL", ")", ")", "return", "0", ";", "if", "(", "!", "lit_pool_ok", ")", "{", "if", "(", "!", "s390_decompose_address", "(", "op", ",", "&", "addr", ")", ")", "return", "0", ";", "if", "(", "addr", ".", "literal_pool", ")", "return", "0", ";", "decomposed", "=", "true", ";", "}", "switch", "(", "c", ")", "{", "case", "'Q'", ":", "if", "(", "!", "decomposed", "&&", "!", "s390_decompose_address", "(", "op", ",", "&", "addr", ")", ")", "return", "0", ";", "if", "(", "addr", ".", "indx", ")", "return", "0", ";", "if", "(", "!", "s390_short_displacement", "(", "addr", ".", "disp", ")", ")", "return", "0", ";", "break", ";", "case", "'R'", ":", "if", "(", "TARGET_LONG_DISPLACEMENT", ")", "{", "if", "(", "!", "decomposed", "&&", "!", "s390_decompose_address", "(", "op", ",", "&", "addr", ")", ")", "return", "0", ";", "if", "(", "!", "s390_short_displacement", "(", "addr", ".", "disp", ")", ")", "return", "0", ";", "}", "break", ";", "case", "'S'", ":", "if", "(", "!", "TARGET_LONG_DISPLACEMENT", ")", "return", "0", ";", "if", "(", "!", "decomposed", "&&", "!", "s390_decompose_address", "(", "op", ",", "&", "addr", ")", ")", "return", "0", ";", "if", "(", "addr", ".", "indx", ")", "return", "0", ";", "if", "(", "s390_short_displacement", "(", "addr", ".", "disp", ")", ")", "return", "0", ";", "break", ";", "case", "'T'", ":", "if", "(", "!", "TARGET_LONG_DISPLACEMENT", ")", "return", "0", ";", "if", "(", "(", "decomposed", "||", "s390_decompose_address", "(", "op", ",", "&", "addr", ")", ")", "&&", "s390_short_displacement", "(", "addr", ".", "disp", ")", ")", "return", "0", ";", "break", ";", "default", ":", "return", "0", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "address", "in", "OP", "is", "valid", "for", "constraint", "letter", "C", "if", "wrapped", "in", "a", "MEM", "rtx", ".", "Set", "LIT_POOL_OK", "to", "true", "if", "it", "literal", "pool", "MEMs", "should", "be", "accepted", ".", "Only", "the", "Q", ",", "R", ",", "S", ",", "T", "constraint", "letters", "are", "allowed", "for", "C", "." ]

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

[]

[ "<s>", "void", "X86DAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "OptForSize", "=", "MF", "->", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "OptimizeForSize", ")", ";", "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "SDNode", "*", "N", "=", "I", "++", ";", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "(", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", "&&", "!", "Subtarget", "->", "callRegIndirect", "(", ")", ")", "||", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "TC_RETURN", "&&", "(", "Subtarget", "->", "is64Bit", "(", ")", "||", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", ")", ")", ")", ")", "{", "bool", "HasCallSeq", "=", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", ";", "SDValue", "Chain", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Load", "=", "N", "->", "getOperand", "(", "1", ")", ";", "if", "(", "!", "isCalleeLoad", "(", "Load", ",", "Chain", ",", "HasCallSeq", ")", ")", "continue", ";", "MoveBelowOrigChain", "(", "CurDAG", ",", "Load", ",", "SDValue", "(", "N", ",", "0", ")", ",", "Chain", ")", ";", "++", "NumLoadMoved", ";", "continue", ";", "}", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_ROUND", "&&", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "MVT", "SrcVT", "=", "N", "->", "getOperand", "(", "0", ")", ".", "getSimpleValueType", "(", ")", ";", "MVT", "DstVT", "=", "N", "->", "getSimpleValueType", "(", "0", ")", ";", "if", "(", "SrcVT", ".", "isVector", "(", ")", "||", "DstVT", ".", "isVector", "(", ")", ")", "continue", ";", "const", "X86TargetLowering", "*", "X86Lowering", "=", "static_cast", "<", "const", "X86TargetLowering", "*", ">", "(", "getTargetLowering", "(", ")", ")", ";", "bool", "SrcIsSSE", "=", "X86Lowering", "->", "isScalarFPTypeInSSEReg", "(", "SrcVT", ")", ";", "bool", "DstIsSSE", "=", "X86Lowering", "->", "isScalarFPTypeInSSEReg", "(", "DstVT", ")", ";", "if", "(", "SrcIsSSE", "&&", "DstIsSSE", ")", "continue", ";", "if", "(", "!", "SrcIsSSE", "&&", "!", "DstIsSSE", ")", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "if", "(", "N", "->", "getConstantOperandVal", "(", "1", ")", ")", "continue", ";", "}", "MVT", "MemVT", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_ROUND", ")", "MemVT", "=", "DstVT", ";", "else", "MemVT", "=", "SrcIsSSE", "?", "SrcVT", ":", "DstVT", ";", "SDValue", "MemTmp", "=", "CurDAG", "->", "CreateStackTemporary", "(", "MemVT", ")", ";", "SDLoc", "dl", "(", "N", ")", ";", "SDValue", "Store", "=", "CurDAG", "->", "getTruncStore", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "dl", ",", "N", "->", "getOperand", "(", "0", ")", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ",", "false", ",", "false", ",", "0", ")", ";", "SDValue", "Result", "=", "CurDAG", "->", "getExtLoad", "(", "ISD", "::", "EXTLOAD", ",", "dl", ",", "DstVT", ",", "Store", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ",", "false", ",", "false", ",", "false", ",", "0", ")", ";", "--", "I", ";", "CurDAG", "->", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "0", ")", ",", "Result", ")", ";", "++", "I", ";", "CurDAG", "->", "DeleteNode", "(", "N", ")", ";", "}", "}", "</s>" ]

[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]

[ "X86", "X86", "X86ISD::CALL", "X86ISD::TC_RETURN", "X86ISD::CALL", "0", "1", "0", "ISD::FP_ROUND", "ISD::FP_EXTEND", "0", "0", "X86", "X86", "X86", "X86", "X86", "ISD::FP_EXTEND", "1", "ISD::FP_ROUND", "0", "0", "ISD::EXTLOAD", "0", "0" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "getIncrementValue", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "Value", ")", "const", "{", "if", "(", "isPostIncrement", "(", "MI", ")", ")", "{", "unsigned", "AccessSize", ";", "return", "getBaseAndOffset", "(", "MI", ",", "Value", ",", "AccessSize", ")", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Hexagon", "::", "A2_addi", ")", "{", "Value", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "the", "instruction", "is", "an", "increment", "of", "a", "constant", "value", ",", "return", "the", "amount", "." ]

[ "Hexagon", "Hexagon", "Hexagon::A2_addi", "2" ]

[]

[ "<s>", "bool", "HexagonPassConfig", "::", "addInstSelector", "(", ")", "{", "HexagonTargetMachine", "&", "TM", "=", "getHexagonTargetMachine", "(", ")", ";", "bool", "NoOpt", "=", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ";", "if", "(", "!", "NoOpt", ")", "addPass", "(", "createHexagonOptimizeSZextends", "(", ")", ")", ";", "addPass", "(", "createHexagonISelDag", "(", "TM", ",", "getOptLevel", "(", ")", ")", ")", ";", "if", "(", "!", "NoOpt", ")", "{", "if", "(", "EnableGenPred", ")", "addPass", "(", "createHexagonGenPredicate", "(", ")", ")", ";", "if", "(", "EnableLoopResched", ")", "addPass", "(", "createHexagonLoopRescheduling", "(", ")", ")", ";", "if", "(", "!", "DisableHSDR", ")", "addPass", "(", "createHexagonSplitDoubleRegs", "(", ")", ")", ";", "if", "(", "EnableBitSimplify", ")", "addPass", "(", "createHexagonBitSimplify", "(", ")", ")", ";", "addPass", "(", "createHexagonPeephole", "(", ")", ")", ";", "if", "(", "!", "DisableHCP", ")", "{", "addPass", "(", "createHexagonConstPropagationPass", "(", ")", ")", ";", "addPass", "(", "&", "UnreachableMachineBlockElimID", ")", ";", "}", "if", "(", "EnableGenInsert", ")", "addPass", "(", "createHexagonGenInsert", "(", ")", ")", ";", "if", "(", "EnableEarlyIf", ")", "addPass", "(", "createHexagonEarlyIfConversion", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isLegalFLATOffset", "(", "int64_t", "Offset", ",", "unsigned", "AddrSpace", ",", "bool", "Signed", ")", "const", "{", "if", "(", "!", "ST", ".", "hasFlatInstOffsets", "(", ")", ")", "return", "false", ";", "if", "(", "ST", ".", "hasFlatSegmentOffsetBug", "(", ")", "&&", "AddrSpace", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", "return", "false", ";", "unsigned", "N", "=", "AMDGPU", "::", "getNumFlatOffsetBits", "(", "ST", ",", "Signed", ")", ";", "return", "Signed", "?", "isIntN", "(", "N", ",", "Offset", ")", ":", "isUIntN", "(", "N", ",", "Offset", ")", ";", "}", "</s>" ]

[ "Returns", "if", "Offset", "is", "legal", "for", "the", "subtarget", "as", "the", "offset", "to", "a", "FLAT", "encoded", "instruction", "." ]

[ "AMDGPU", "SI", "AMDGPU", "AMDGPU::getNumFlatOffsetBits" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "{", "if", "(", "MI", ".", "getParent", "(", ")", "&&", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ")", "{", "const", "auto", "MF", "=", "MI", ".", "getMF", "(", ")", ";", "const", "auto", "&", "TM", "=", "static_cast", "<", "const", "RISCVTargetMachine", "&", ">", "(", "MF", "->", "getTarget", "(", ")", ")", ";", "const", "MCRegisterInfo", "&", "MRI", "=", "*", "TM", ".", "getMCRegisterInfo", "(", ")", ";", "const", "MCSubtargetInfo", "&", "STI", "=", "*", "TM", ".", "getMCSubtargetInfo", "(", ")", ";", "const", "RISCVSubtarget", "&", "ST", "=", "MF", "->", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "if", "(", "isCompressibleInst", "(", "MI", ",", "&", "ST", ",", "MRI", ",", "STI", ")", ")", "return", "2", ";", "}", "return", "get", "(", "Opcode", ")", ".", "getSize", "(", ")", ";", "}", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "0", ";", "case", "RISCV", "::", "PseudoCALLReg", ":", "case", "RISCV", "::", "PseudoCALL", ":", "case", "RISCV", "::", "PseudoJump", ":", "case", "RISCV", "::", "PseudoTAIL", ":", "case", "RISCV", "::", "PseudoLLA", ":", "case", "RISCV", "::", "PseudoLA", ":", "case", "RISCV", "::", "PseudoLA_TLS_IE", ":", "case", "RISCV", "::", "PseudoLA_TLS_GD", ":", "return", "8", ";", "case", "RISCV", "::", "PseudoAtomicLoadNand32", ":", "case", "RISCV", "::", "PseudoAtomicLoadNand64", ":", "return", "20", ";", "case", "RISCV", "::", "PseudoMaskedAtomicSwap32", ":", "case", "RISCV", "::", "PseudoMaskedAtomicLoadAdd32", ":", "case", "RISCV", "::", "PseudoMaskedAtomicLoadSub32", ":", "return", "28", ";", "case", "RISCV", "::", "PseudoMaskedAtomicLoadNand32", ":", "return", "32", ";", "case", "RISCV", "::", "PseudoMaskedAtomicLoadMax32", ":", "case", "RISCV", "::", "PseudoMaskedAtomicLoadMin32", ":", "return", "44", ";", "case", "RISCV", "::", "PseudoMaskedAtomicLoadUMax32", ":", "case", "RISCV", "::", "PseudoMaskedAtomicLoadUMin32", ":", "return", "36", ";", "case", "RISCV", "::", "PseudoCmpXchg32", ":", "case", "RISCV", "::", "PseudoCmpXchg64", ":", "return", "16", ";", "case", "RISCV", "::", "PseudoMaskedCmpXchg32", ":", "return", "32", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "case", "TargetOpcode", "::", "INLINEASM_BR", ":", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "auto", "&", "TM", "=", "static_cast", "<", "const", "RISCVTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "TM", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "RISCV", "RISCV", "RISCV", "2", "0", "RISCV::PseudoCALLReg", "RISCV::PseudoCALL", "RISCV::PseudoJump", "RISCV::PseudoTAIL", "RISCV::PseudoLLA", "RISCV::PseudoLA", "RISCV::PseudoLA_TLS_IE", "RISCV::PseudoLA_TLS_GD", "8", "RISCV::PseudoAtomicLoadNand32", "RISCV::PseudoAtomicLoadNand64", "20", "RISCV::PseudoMaskedAtomicSwap32", "RISCV::PseudoMaskedAtomicLoadAdd32", "RISCV::PseudoMaskedAtomicLoadSub32", "28", "RISCV::PseudoMaskedAtomicLoadNand32", "32", "RISCV::PseudoMaskedAtomicLoadMax32", "RISCV::PseudoMaskedAtomicLoadMin32", "44", "RISCV::PseudoMaskedAtomicLoadUMax32", "RISCV::PseudoMaskedAtomicLoadUMin32", "36", "RISCV::PseudoCmpXchg32", "RISCV::PseudoCmpXchg64", "16", "RISCV::PseudoMaskedCmpXchg32", "32", "RISCV", "0" ]

[]

[ "<s>", "bool", "isAllocated", "(", "unsigned", "Reg", ")", "const", "{", "return", "UsedRegs", "[", "Reg", "/", "32", "]", "&", "(", "1", "<<", "(", "Reg", "&", "31", ")", ")", ";", "}", "</s>" ]

[ "isAllocated", "-", "Return", "true", "if", "the", "specified", "register", "(", "or", "an", "alias", ")", "is", "allocated", "." ]

[ "Hexagon", "32", "1", "31" ]

[]

[ "<s>", "static", "rtx", "tilepro_function_value", "(", "const_tree", "valtype", ",", "const_tree", "fn_decl_or_type", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "machine_mode", "mode", ";", "int", "unsigned_p", ";", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "unsigned_p", "=", "TYPE_UNSIGNED", "(", "valtype", ")", ";", "mode", "=", "promote_function_mode", "(", "valtype", ",", "mode", ",", "&", "unsigned_p", ",", "fn_decl_or_type", ",", "1", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "0", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_VALUE", "." ]

[ "tilepro", "1", "0" ]

[]

[ "<s>", "void", "PatmosInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "O", ")", "{", "printInstPrefix", "(", "MI", ",", "O", ")", ";", "printInstruction", "(", "MI", ",", "Address", ",", "O", ")", ";", "if", "(", "!", "isBundled", "(", "MI", ")", "&&", "InBundle", ")", "{", "O", "<<", "\" }\"", ";", "InBundle", "=", "false", ";", "}", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "\" }\"" ]

[]

[ "<s>", "void", "emitThumbFunc", "(", "MCSymbol", "*", "Func", ")", "override", "{", "}", "</s>" ]

[ "Note", "in", "the", "output", "that", "the", "specified", "Func", "is", "a", "Thumb", "mode", "function", "(", "ARM", "target", "only", ")", "." ]

[ "Patmos" ]

[]

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

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

[ "JVM", "JVM" ]

[]

[ "<s>", "static", "bool", "rs6000_cannot_substitute_mem_equiv_p", "(", "rtx", "mem", ")", "{", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "mem", ",", "0", ")", ")", "==", "AND", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_CANNOT_SUBSTITUTE_MEM_EQUIV_P", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "static", "rtx", "mips_call_tls_get_addr", "(", "rtx", "sym", ",", "enum", "mips_symbol_type", "type", ",", "rtx", "v0", ")", "{", "rtx", "insn", ",", "loc", ",", "a0", ";", "a0", "=", "gen_rtx_REG", "(", "Pmode", ",", "GP_ARG_FIRST", ")", ";", "if", "(", "!", "mips_tls_symbol", ")", "mips_tls_symbol", "=", "init_one_libfunc", "(", "\"__tls_get_addr\"", ")", ";", "loc", "=", "mips_unspec_address", "(", "sym", ",", "type", ")", ";", "start_sequence", "(", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "a0", ",", "gen_rtx_LO_SUM", "(", "Pmode", ",", "pic_offset_table_rtx", ",", "loc", ")", ")", ")", ";", "insn", "=", "mips_expand_call", "(", "MIPS_CALL_NORMAL", ",", "v0", ",", "mips_tls_symbol", ",", "const0_rtx", ",", "NULL_RTX", ",", "false", ")", ";", "RTL_CONST_CALL_P", "(", "insn", ")", "=", "1", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "a0", ")", ";", "insn", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "insn", ";", "}", "</s>" ]

[ "Return", "an", "instruction", "sequence", "that", "calls", "__tls_get_addr", ".", "SYM", "is", "the", "TLS", "symbol", "we", "are", "referencing", "and", "TYPE", "is", "the", "symbol", "type", "to", "use", "(", "either", "global", "dynamic", "or", "local", "dynamic", ")", ".", "V0", "is", "an", "RTX", "for", "the", "return", "value", "location", "." ]

[ "mips", "\"__tls_get_addr\"", "1" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"ARM64 Address Type Promotion\"", ";", "}", "</s>" ]

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

[ "ARM64", "\"ARM64 Address Type Promotion\"" ]

[]

[ "<s>", "static", "bool", "rs6000_must_pass_in_stack", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "if", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", "||", "TARGET_64BIT", ")", "return", "must_pass_in_stack_var_size", "(", "mode", ",", "type", ")", ";", "else", "return", "must_pass_in_stack_var_size_or_pad", "(", "mode", ",", "type", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "TYPE", "must", "be", "passed", "on", "the", "stack", "and", "not", "in", "registers", "." ]

[ "rs6000" ]

[]

[ "<s>", "MachineInstrBuilder", "MipsInstrInfo", "::", "genInstrWithNewOpc", "(", "unsigned", "NewOpc", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MachineInstrBuilder", "MIB", ";", "int", "ZeroOperandPosition", "=", "-", "1", ";", "bool", "BranchWithZeroOperand", "=", "false", ";", "if", "(", "I", "->", "isBranch", "(", ")", "&&", "!", "I", "->", "isPseudo", "(", ")", ")", "{", "auto", "TRI", "=", "I", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "ZeroOperandPosition", "=", "I", "->", "findRegisterUseOperandIdx", "(", "Mips", "::", "ZERO", ",", "false", ",", "TRI", ")", ";", "BranchWithZeroOperand", "=", "ZeroOperandPosition", "!=", "-", "1", ";", "}", "if", "(", "BranchWithZeroOperand", ")", "{", "switch", "(", "NewOpc", ")", "{", "case", "Mips", "::", "BEQC", ":", "NewOpc", "=", "Mips", "::", "BEQZC", ";", "break", ";", "case", "Mips", "::", "BNEC", ":", "NewOpc", "=", "Mips", "::", "BNEZC", ";", "break", ";", "case", "Mips", "::", "BGEC", ":", "NewOpc", "=", "Mips", "::", "BGEZC", ";", "break", ";", "case", "Mips", "::", "BLTC", ":", "NewOpc", "=", "Mips", "::", "BLTZC", ";", "break", ";", "case", "Mips", "::", "BEQC64", ":", "NewOpc", "=", "Mips", "::", "BEQZC64", ";", "break", ";", "case", "Mips", "::", "BNEC64", ":", "NewOpc", "=", "Mips", "::", "BNEZC64", ";", "break", ";", "}", "}", "MIB", "=", "BuildMI", "(", "*", "I", "->", "getParent", "(", ")", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "get", "(", "NewOpc", ")", ")", ";", "if", "(", "NewOpc", "==", "Mips", "::", "JIC", "||", "NewOpc", "==", "Mips", "::", "JIALC", "||", "NewOpc", "==", "Mips", "::", "JIC64", "||", "NewOpc", "==", "Mips", "::", "JIALC64", ")", "{", "if", "(", "NewOpc", "==", "Mips", "::", "JIALC", "||", "NewOpc", "==", "Mips", "::", "JIALC64", ")", "MIB", "->", "RemoveOperand", "(", "0", ")", ";", "for", "(", "unsigned", "J", "=", "0", ",", "E", "=", "I", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ";", "J", "<", "E", ";", "++", "J", ")", "{", "MIB", ".", "add", "(", "I", "->", "getOperand", "(", "J", ")", ")", ";", "}", "MIB", ".", "addImm", "(", "0", ")", ";", "for", "(", "unsigned", "J", "=", "I", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ",", "E", "=", "I", "->", "getNumOperands", "(", ")", ";", "J", "<", "E", ";", "++", "J", ")", "{", "const", "MachineOperand", "&", "MO", "=", "I", "->", "getOperand", "(", "J", ")", ";", "if", "(", "MO", ".", "isMCSymbol", "(", ")", "&&", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "MipsII", "::", "MO_JALR", ")", ")", "MIB", ".", "addSym", "(", "MO", ".", "getMCSymbol", "(", ")", ",", "MipsII", "::", "MO_JALR", ")", ";", "}", "}", "else", "{", "for", "(", "unsigned", "J", "=", "0", ",", "E", "=", "I", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ";", "J", "<", "E", ";", "++", "J", ")", "{", "if", "(", "BranchWithZeroOperand", "&&", "(", "unsigned", ")", "ZeroOperandPosition", "==", "J", ")", "continue", ";", "MIB", ".", "add", "(", "I", "->", "getOperand", "(", "J", ")", ")", ";", "}", "}", "MIB", ".", "copyImplicitOps", "(", "*", "I", ")", ";", "MIB", ".", "cloneMemRefs", "(", "*", "I", ")", ";", "return", "MIB", ";", "}", "</s>" ]

[ "Create", "an", "instruction", "which", "has", "the", "same", "operands", "and", "memory", "operands", "as", "MI", "but", "has", "a", "new", "opcode", "." ]

[ "Mips", "Mips", "1", "Mips::ZERO", "1", "Mips::BEQC", "Mips::BEQZC", "Mips::BNEC", "Mips::BNEZC", "Mips::BGEC", "Mips::BGEZC", "Mips::BLTC", "Mips::BLTZC", "Mips::BEQC64", "Mips::BEQZC64", "Mips::BNEC64", "Mips::BNEZC64", "Mips::JIC", "Mips::JIALC", "Mips::JIC64", "Mips::JIALC64", "Mips::JIALC", "Mips::JIALC64", "0", "0", "0", "MipsII::MO_JALR", "MipsII::MO_JALR", "0" ]

[]

[ "<s>", "static", "recps_type", "get_recps_type", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_SFmode", ":", "return", "(", "gen_aarch64_frecpssf", ")", ";", "case", "E_V2SFmode", ":", "return", "(", "gen_aarch64_frecpsv2sf", ")", ";", "case", "E_V4SFmode", ":", "return", "(", "gen_aarch64_frecpsv4sf", ")", ";", "case", "E_DFmode", ":", "return", "(", "gen_aarch64_frecpsdf", ")", ";", "case", "E_V2DFmode", ":", "return", "(", "gen_aarch64_frecpsv2df", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Select", "reciprocal", "series", "step", "insn", "depending", "on", "machine", "mode", "." ]

[ "aarch64" ]

[]

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

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "int", "frv_function_contains_far_jump", "(", "void", ")", "{", "rtx_insn", "*", "insn", "=", "get_insns", "(", ")", ";", "while", "(", "insn", "!=", "NULL", "&&", "!", "(", "JUMP_P", "(", "insn", ")", "&&", "get_attr_far_jump", "(", "insn", ")", "==", "FAR_JUMP_YES", ")", ")", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "return", "(", "insn", "!=", "NULL", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "current", "function", "contains", "a", "far", "jump", "." ]

[ "frv" ]

[]

[ "<s>", "void", "aarch64_init_builtin_rsqrt", "(", "void", ")", "{", "tree", "fndecl", "=", "NULL", ";", "tree", "ftype", "=", "NULL", ";", "tree", "V2SF_type_node", "=", "build_vector_type", "(", "float_type_node", ",", "2", ")", ";", "tree", "V2DF_type_node", "=", "build_vector_type", "(", "double_type_node", ",", "2", ")", ";", "tree", "V4SF_type_node", "=", "build_vector_type", "(", "float_type_node", ",", "4", ")", ";", "struct", "builtin_decls_data", "{", "tree", "type_node", ";", "const", "char", "*", "builtin_name", ";", "int", "function_code", ";", "}", ";", "builtin_decls_data", "bdda", "[", "]", "=", "{", "{", "double_type_node", ",", "\"__builtin_aarch64_rsqrt_df\"", ",", "AARCH64_BUILTIN_RSQRT_DF", "}", ",", "{", "float_type_node", ",", "\"__builtin_aarch64_rsqrt_sf\"", ",", "AARCH64_BUILTIN_RSQRT_SF", "}", ",", "{", "V2DF_type_node", ",", "\"__builtin_aarch64_rsqrt_v2df\"", ",", "AARCH64_BUILTIN_RSQRT_V2DF", "}", ",", "{", "V2SF_type_node", ",", "\"__builtin_aarch64_rsqrt_v2sf\"", ",", "AARCH64_BUILTIN_RSQRT_V2SF", "}", ",", "{", "V4SF_type_node", ",", "\"__builtin_aarch64_rsqrt_v4sf\"", ",", "AARCH64_BUILTIN_RSQRT_V4SF", "}", "}", ";", "builtin_decls_data", "*", "bdd", "=", "bdda", ";", "builtin_decls_data", "*", "bdd_end", "=", "bdd", "+", "(", "sizeof", "(", "bdda", ")", "/", "sizeof", "(", "builtin_decls_data", ")", ")", ";", "for", "(", ";", "bdd", "<", "bdd_end", ";", "bdd", "++", ")", "{", "ftype", "=", "build_function_type_list", "(", "bdd", "->", "type_node", ",", "bdd", "->", "type_node", ",", "NULL_TREE", ")", ";", "fndecl", "=", "add_builtin_function", "(", "bdd", "->", "builtin_name", ",", "ftype", ",", "bdd", "->", "function_code", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "aarch64_builtin_decls", "[", "bdd", "->", "function_code", "]", "=", "fndecl", ";", "}", "}", "</s>" ]

[ "Add", "builtins", "for", "reciprocal", "square", "root", "." ]

[ "aarch64", "2", "2", "4", "\"__builtin_aarch64_rsqrt_df\"", "\"__builtin_aarch64_rsqrt_sf\"", "\"__builtin_aarch64_rsqrt_v2df\"", "\"__builtin_aarch64_rsqrt_v2sf\"", "\"__builtin_aarch64_rsqrt_v4sf\"" ]

[]

[ "<s>", "int", "rx_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "unsigned", "int", "low", ";", "unsigned", "int", "high", ";", "unsigned", "int", "frame_size", ";", "unsigned", "int", "stack_size", ";", "unsigned", "int", "mask", ";", "rx_get_stack_layout", "(", "&", "low", ",", "&", "high", ",", "&", "mask", ",", "&", "frame_size", ",", "&", "stack_size", ")", ";", "if", "(", "from", "==", "ARG_POINTER_REGNUM", ")", "{", "if", "(", "low", ")", "frame_size", "+=", "(", "(", "high", "-", "low", ")", "+", "1", ")", "*", "UNITS_PER_WORD", ";", "else", "frame_size", "+=", "bit_count", "(", "mask", ")", "*", "UNITS_PER_WORD", ";", "frame_size", "+=", "1", "*", "UNITS_PER_WORD", ";", "if", "(", "to", "==", "FRAME_POINTER_REGNUM", ")", "return", "frame_size", ";", "gcc_assert", "(", "to", "==", "STACK_POINTER_REGNUM", ")", ";", "return", "frame_size", "+", "stack_size", ";", "}", "gcc_assert", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", ";", "return", "stack_size", ";", "}", "</s>" ]

[ "Compute", "the", "offset", "(", "in", "words", ")", "between", "FROM", "(", "arg", "pointer", "or", "frame", "pointer", ")", "and", "TO", "(", "frame", "pointer", "or", "stack", "pointer", ")", ".", "See", "ASCII", "art", "comment", "at", "the", "start", "of", "rx_expand_prologue", "for", "more", "information", "." ]

[ "rx", "1", "1" ]

[]

[ "<s>", "bool", "HexagonCopyToCombine", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "IsCombinesDisabled", ")", "return", "false", ";", "bool", "HasChanged", "=", "false", ";", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "TRI", "=", "ST", "->", "getRegisterInfo", "(", ")", ";", "TII", "=", "ST", "->", "getInstrInfo", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "OptForSize", "=", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "OptimizeForSize", ")", ";", "ShouldCombineAggressively", "=", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "<=", "CodeGenOpt", "::", "Default", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "PotentiallyNewifiableTFR", ".", "clear", "(", ")", ";", "findPotentialNewifiableTFRs", "(", "*", "BI", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MI", "=", "BI", "->", "begin", "(", ")", ",", "End", "=", "BI", "->", "end", "(", ")", ";", "MI", "!=", "End", ";", ")", "{", "MachineInstr", "&", "I1", "=", "*", "MI", "++", ";", "if", "(", "I1", ".", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "ShouldCombineAggressively", "&&", "PotentiallyNewifiableTFR", ".", "count", "(", "&", "I1", ")", ")", "continue", ";", "if", "(", "!", "isCombinableInstType", "(", "I1", ",", "TII", ",", "ShouldCombineAggressively", ")", ")", "continue", ";", "bool", "DoInsertAtI1", "=", "false", ";", "DbgMItoMove", ".", "clear", "(", ")", ";", "MachineInstr", "*", "I2", "=", "findPairable", "(", "I1", ",", "DoInsertAtI1", ",", "OptForSize", ")", ";", "if", "(", "I2", ")", "{", "HasChanged", "=", "true", ";", "combine", "(", "I1", ",", "*", "I2", ",", "MI", ",", "DoInsertAtI1", ",", "OptForSize", ")", ";", "}", "}", "}", "return", "HasChanged", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "print_operand", "(", "FILE", "*", "file", ",", "rtx", "x", ",", "int", "code", ")", "{", "int", "abcd", "=", "0", ";", "if", "(", "code", ">=", "'A'", "&&", "code", "<=", "'D'", ")", "abcd", "=", "code", "-", "'A'", ";", "if", "(", "code", "==", "'~'", ")", "{", "if", "(", "!", "AVR_MEGA", ")", "fputc", "(", "'r'", ",", "file", ")", ";", "}", "else", "if", "(", "REG_P", "(", "x", ")", ")", "{", "if", "(", "x", "==", "zero_reg_rtx", ")", "fprintf", "(", "file", ",", "\"__zero_reg__\"", ")", ";", "else", "fprintf", "(", "file", ",", "reg_names", "[", "true_regnum", "(", "x", ")", "+", "abcd", "]", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "INTVAL", "(", "x", ")", "+", "abcd", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", ")", "{", "rtx", "addr", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "CONSTANT_P", "(", "addr", ")", "&&", "abcd", ")", "{", "fputc", "(", "'('", ",", "file", ")", ";", "output_address", "(", "addr", ")", ";", "fprintf", "(", "file", ",", "\")+%d\"", ",", "abcd", ")", ";", "}", "else", "if", "(", "code", "==", "'o'", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "PLUS", ")", "fatal_insn", "(", "\"bad address, not (reg+disp):\"", ",", "addr", ")", ";", "print_operand", "(", "file", ",", "XEXP", "(", "addr", ",", "1", ")", ",", "0", ")", ";", "}", "else", "if", "(", "code", "==", "'p'", "||", "code", "==", "'r'", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "POST_INC", "&&", "GET_CODE", "(", "addr", ")", "!=", "PRE_DEC", ")", "fatal_insn", "(", "\"bad address, not post_inc or pre_dec:\"", ",", "addr", ")", ";", "if", "(", "code", "==", "'p'", ")", "print_operand_address", "(", "file", ",", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "else", "print_operand", "(", "file", ",", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "print_operand_address", "(", "file", ",", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "if", "(", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "REG_X", ")", "fatal_insn", "(", "\"internal compiler error. Bad address:\"", ",", "addr", ")", ";", "fputc", "(", "'+'", ",", "file", ")", ";", "print_operand", "(", "file", ",", "XEXP", "(", "addr", ",", "1", ")", ",", "code", ")", ";", "}", "else", "print_operand_address", "(", "file", ",", "addr", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", ")", "{", "long", "val", ";", "REAL_VALUE_TYPE", "rv", ";", "if", "(", "GET_MODE", "(", "x", ")", "!=", "SFmode", ")", "fatal_insn", "(", "\"internal compiler error. Unknown mode:\"", ",", "x", ")", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "rv", ",", "x", ")", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "rv", ",", "val", ")", ";", "fprintf", "(", "file", ",", "\"0x%lx\"", ",", "val", ")", ";", "}", "else", "if", "(", "code", "==", "'j'", ")", "fputs", "(", "cond_string", "(", "GET_CODE", "(", "x", ")", ")", ",", "file", ")", ";", "else", "if", "(", "code", "==", "'k'", ")", "fputs", "(", "cond_string", "(", "reverse_condition", "(", "GET_CODE", "(", "x", ")", ")", ")", ",", "file", ")", ";", "else", "print_operand_address", "(", "file", ",", "x", ")", ";", "}", "</s>" ]

[ "Use", "S", "for", "SI", "regsUse", "B", "&", "T", "for", "parts", "of", "DI", "regs", "X", "-", "stack", "pointer", "name", "Registers", "Q", "-", "byte", "sized", "register", "name", "U", "-", "high", "byte", "of", "word", "register", "V", "-", "low", "byte", "of", "word", "register", "H", "-", "word", "register", "name", "I", "-", "next", "word", "register", "name", "S", "&", "B", "-", "long", "register", "name", "T", "-", "next", "long", "register", "name", "D", "-", "quad", "register", "name", "P", "-", "register", "name", "in", "size", "of", "pointer", "Integers", "O", "-", "log", "two", "of", "value", "P", "-", "inverted", "log", "two", "H", "-", "bottom", "16", "bits", "I", "-", "top", "16", "bits", "N", "-", "negative", "B", "-", "high", "32", "bits", "of", "32bit", "number", ".", "default", ":", "value", "Memory", "I", "-", "adjusted", "upwards", "by", "two", "T", "-", "adjusted", "upwards", "by", "four", "default", ":", "value", "Address", "H", "-", "low", "16", "bits", "I", "-", "high", "16", "bits", "A", "-", "as", "long", "constant", "S", "-", "as", "A", "but", "with", "#", "default", ":", "error", "Misc", "C", "-", "conditional", "name", "D", "-", "reverse", "conditional", "name", "F", "-", "clear", "v", "flag", "if", "necessary" ]

[ "avr", "0", "\"__zero_reg__\"", "0", "\")+%d\"", "\"bad address, not (reg+disp):\"", "1", "0", "\"bad address, not post_inc or pre_dec:\"", "0", "0", "0", "0", "0", "\"internal compiler error. Bad address:\"", "1", "\"internal compiler error. Unknown mode:\"", "\"0x%lx\"" ]

[]

[ "<s>", "void", "recordRelocation", "(", "MCAssembler", "&", "Asm", ",", "const", "MCAsmLayout", "&", "Layout", ",", "const", "MCFragment", "*", "Fragment", ",", "const", "MCFixup", "&", "Fixup", ",", "MCValue", "Target", ",", "bool", "&", "IsPCRel", ",", "uint64_t", "&", "FixedValue", ")", "override", "{", "assert", "(", "!", "\"Not implemented\"", ")", ";", "}", "</s>" ]

[ "Record", "a", "relocation", "entry", "." ]

[ "AMDGPU", "\"Not implemented\"" ]

[]

[ "<s>", "static", "int", "csky_arg_partial_bytes", "(", "cumulative_args_t", "pcum_v", ",", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "pcum", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "int", "param_size", "=", "csky_num_arg_regs", "(", "mode", ",", "type", ")", ";", "if", "(", "*", "pcum", "<", "CSKY_NPARM_REGS", "&&", "*", "pcum", "+", "param_size", ">", "CSKY_NPARM_REGS", ")", "return", "(", "CSKY_NPARM_REGS", "-", "*", "pcum", ")", "*", "UNITS_PER_WORD", ";", "return", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_ARG_PARTIAL_BYTES", ".", "Return", "the", "number", "of", "bytes", "at", "the", "beginning", "of", "an", "argument", "that", "must", "be", "put", "in", "registers", ".", "The", "value", "must", "be", "zero", "for", "arguments", "that", "are", "passed", "entirely", "in", "registers", "or", "that", "are", "entirely", "pushed", "on", "the", "stack", "." ]

[ "csky", "0" ]

[]

[ "<s>", "bool", "rvexPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "creatervexISelDag", "(", "getrvexTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "EmitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "bool", ")", "override", "{", "EmitA64MappingSymbol", "(", ")", ";", "MCELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "AArch64BranchTargetAligner", "BTA", ";", "unsigned", "Opcode", "=", "Inst", ".", "getOpcode", "(", ")", ";", "if", "(", "BTA", ".", "needsSpecialAlignment", "(", "STI", ".", "getCPU", "(", ")", ",", "Opcode", ")", ")", "{", "unsigned", "BA", "=", "BTA", ".", "getBranchTargetAlignment", "(", "Inst", ")", ";", "if", "(", "BA", ")", "{", "EmitA64MappingSymbol", "(", ")", ";", "MCELFStreamer", "::", "EmitCodeAlignment", "(", "BA", ")", ";", "}", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "LEG", "LEG" ]

[]

[ "<s>", "void", "SIFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "SavedRegs", ".", "reset", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "unsigned", "int", "bfin_hard_regno_nregs", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "mode", "==", "PDImode", "&&", "(", "regno", "==", "REG_A0", "||", "regno", "==", "REG_A1", ")", ")", "return", "1", ";", "if", "(", "mode", "==", "V2PDImode", "&&", "(", "regno", "==", "REG_A0", "||", "regno", "==", "REG_A1", ")", ")", "return", "2", ";", "return", "CLASS_MAX_NREGS", "(", "GENERAL_REGS", ",", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_NREGS", "." ]

[ "bfin", "1", "2" ]

[]

[ "<s>", "static", "rtx", "iq2000_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "fun", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_INT", "||", "GET_MODE_SIZE", "(", "mode", ")", ">=", "4", ")", "?", "mode", ":", "SImode", ")", ",", "GP_RETURN", ")", ";", "}", "</s>" ]

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

[ "iq2000", "4" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "Options", ".", "ThreadModel", "==", "ThreadModel", "::", "Single", ")", "addPass", "(", "createLowerAtomicPass", "(", ")", ")", ";", "else", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", "SimplifyCFGOptions", "(", ")", ".", "hoistCommonInsts", "(", "true", ")", ".", "sinkCommonInsts", "(", "true", ")", ",", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "const", "auto", "&", "ST", "=", "this", "->", "TM", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ";", "return", "ST", ".", "hasAnyDataBarrier", "(", ")", "&&", "!", "ST", ".", "isThumb1Only", "(", ")", ";", "}", ")", ")", ";", "addPass", "(", "createMVEGatherScatterLoweringPass", "(", ")", ")", ";", "addPass", "(", "createMVELaneInterleavingPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", ")", "addPass", "(", "createARMParallelDSPPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createInterleavedAccessPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "addPass", "(", "createCFGuardCheckPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createSIInsertWaitsPass", "(", ")", ",", "false", ")", ";", "addPass", "(", "createSILowerControlFlowPass", "(", ")", ",", "false", ")", ";", "if", "(", "InsertNops", ")", "{", "addPass", "(", "createSIInsertNopsPass", "(", ")", ",", "false", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "rtx", "tilepro_text_label_rtx", "(", "void", ")", "{", "return", "cfun", "->", "machine", "->", "text_label_rtx", ";", "}", "</s>" ]

[ "Return", "the", "register", "storing", "the", "value", "of", "the", "text", "label", "." ]

[ "tilepro" ]

[]

[ "<s>", "void", "TOYRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "&", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FI", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "ImmOpIdx", "=", "0", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", ";", "case", "TOY", "::", "LDR", ":", "case", "TOY", "::", "STR", ":", "ImmOpIdx", "=", "FIOperandNum", "+", "1", ";", "break", ";", "}", "MachineOperand", "&", "ImmOp", "=", "MI", ".", "getOperand", "(", "ImmOpIdx", ")", ";", "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "FI", ")", "+", "MFI", "->", "getStackSize", "(", ")", "+", "ImmOp", ".", "getImm", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "TOY", "::", "SP", ",", "false", ")", ";", "ImmOp", ".", "setImm", "(", "Offset", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "TOY", "TOY", "0", "TOY::LDR", "TOY::STR", "1", "TOY::SP" ]

[]

[ "<s>", "void", "SPUInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "unsigned", "opc", ";", "bool", "isValidFrameIdx", "=", "(", "FrameIdx", "<", "SPUFrameInfo", "::", "maxFrameOffset", "(", ")", ")", ";", "if", "(", "RC", "==", "SPU", "::", "GPRCRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr128", ":", "SPU", "::", "LQXr128", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R64CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr64", ":", "SPU", "::", "LQXr64", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R64FPRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr64", ":", "SPU", "::", "LQXr64", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R32CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr32", ":", "SPU", "::", "LQXr32", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R32FPRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr32", ":", "SPU", "::", "LQXr32", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R16CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr16", ":", "SPU", "::", "LQXr16", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R8CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr8", ":", "SPU", "::", "LQXr8", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "VECREGRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", ")", "?", "SPU", "::", "LQDv16i8", ":", "SPU", "::", "LQXv16i8", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Unknown regclass in loadRegFromStackSlot!\"", ")", ";", "}", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "opc", ")", ",", "DestReg", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "SPU", "SPU::GPRCRegisterClass", "SPU::LQDr128", "SPU::LQXr128", "SPU::R64CRegisterClass", "SPU::LQDr64", "SPU::LQXr64", "SPU::R64FPRegisterClass", "SPU::LQDr64", "SPU::LQXr64", "SPU::R32CRegisterClass", "SPU::LQDr32", "SPU::LQXr32", "SPU::R32FPRegisterClass", "SPU::LQDr32", "SPU::LQXr32", "SPU::R16CRegisterClass", "SPU::LQDr16", "SPU::LQXr16", "SPU::R8CRegisterClass", "SPU::LQDr8", "SPU::LQXr8", "SPU::VECREGRegisterClass", "SPU::LQDv16i8", "SPU::LQXv16i8", "\"Unknown regclass in loadRegFromStackSlot!\"" ]

[]

[ "<s>", "static", "unsigned", "int", "riscv_function_arg_boundary", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "unsigned", "int", "alignment", ";", "if", "(", "type", "&&", "!", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "alignment", "=", "TYPE_ALIGN", "(", "TYPE_MAIN_VARIANT", "(", "type", ")", ")", ";", "else", "alignment", "=", "type", "?", "TYPE_ALIGN", "(", "type", ")", ":", "GET_MODE_ALIGNMENT", "(", "mode", ")", ";", "return", "MIN", "(", "PREFERRED_STACK_BOUNDARY", ",", "MAX", "(", "PARM_BOUNDARY", ",", "alignment", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG_BOUNDARY", ".", "Every", "parameter", "gets", "at", "least", "PARM_BOUNDARY", "bits", "of", "alignment", ",", "but", "will", "be", "given", "anything", "up", "to", "STACK_BOUNDARY", "bits", "if", "the", "type", "requires", "it", "." ]

[ "riscv" ]

[]