Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "mmix_init_expanders", "(", ")", "{", "init_machine_status", "=", "mmix_init_machine_status", ";", "}", "</s>" ]

[ "INIT_EXPANDERS", "." ]

[ "mmix" ]

[]

[ "<s>", "void", "AMDGPUPreLegalizerCombiner", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "AU", ".", "setPreservesCFG", "(", ")", ";", "getSelectionDAGFallbackAnalysisUsage", "(", "AU", ")", ";", "AU", ".", "addRequired", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ";", "if", "(", "!", "IsOptNone", ")", "{", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "}", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

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

[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]

[ "MMIX" ]

[]

[ "<s>", "static", "bool", "mep_store_data_bypass_1", "(", "rtx_insn", "*", "prev", ",", "rtx", "pat", ")", "{", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "pat", ",", "0", ")", ";", "i", "++", ")", "if", "(", "mep_store_data_bypass_p", "(", "prev", ",", "as_a", "<", "rtx_insn", "*", ">", "(", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", "||", "GET_CODE", "(", "SET_DEST", "(", "pat", ")", ")", "!=", "MEM", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "UNSPEC", ")", "{", "rtx", "src", ";", "int", "i", ";", "src", "=", "SET_SRC", "(", "pat", ")", ";", "for", "(", "i", "=", "1", ";", "i", "<", "XVECLEN", "(", "src", ",", "0", ")", ";", "i", "++", ")", "if", "(", "mep_store_find_set", "(", "XVECEXP", "(", "src", ",", "0", ",", "i", ")", ",", "prev", ")", ")", "return", "false", ";", "return", "true", ";", "}", "return", "!", "mep_store_find_set", "(", "SET_DEST", "(", "pat", ")", ",", "prev", ")", ";", "}", "</s>" ]

[ "Like", "mep_store_bypass_p", ",", "but", "takes", "a", "pattern", "as", "the", "second", "argument", ",", "not", "the", "containing", "insn", "." ]

[ "mep", "0", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "static", "bool", "isF128SoftLibCall", "(", "const", "char", "*", "CallSym", ")", "{", "const", "char", "*", "const", "LibCalls", "[", "]", "=", "{", "\"__addtf3\"", ",", "\"__divtf3\"", ",", "\"__eqtf2\"", ",", "\"__extenddftf2\"", ",", "\"__extendsftf2\"", ",", "\"__fixtfdi\"", ",", "\"__fixtfsi\"", ",", "\"__fixtfti\"", ",", "\"__fixunstfdi\"", ",", "\"__fixunstfsi\"", ",", "\"__fixunstfti\"", ",", "\"__floatditf\"", ",", "\"__floatsitf\"", ",", "\"__floattitf\"", ",", "\"__floatunditf\"", ",", "\"__floatunsitf\"", ",", "\"__floatuntitf\"", ",", "\"__getf2\"", ",", "\"__gttf2\"", ",", "\"__letf2\"", ",", "\"__lttf2\"", ",", "\"__multf3\"", ",", "\"__netf2\"", ",", "\"__powitf2\"", ",", "\"__subtf3\"", ",", "\"__trunctfdf2\"", ",", "\"__trunctfsf2\"", ",", "\"__unordtf2\"", ",", "\"ceill\"", ",", "\"copysignl\"", ",", "\"cosl\"", ",", "\"exp2l\"", ",", "\"expl\"", ",", "\"floorl\"", ",", "\"fmal\"", ",", "\"fmodl\"", ",", "\"log10l\"", ",", "\"log2l\"", ",", "\"logl\"", ",", "\"nearbyintl\"", ",", "\"powl\"", ",", "\"rintl\"", ",", "\"sinl\"", ",", "\"sqrtl\"", ",", "\"truncl\"", "}", ";", "const", "char", "*", "const", "*", "End", "=", "LibCalls", "+", "array_lengthof", "(", "LibCalls", ")", ";", "MipsTargetLowering", "::", "LTStr", "Comp", ";", "for", "(", "const", "char", "*", "const", "*", "I", "=", "LibCalls", ";", "I", "<", "End", "-", "1", ";", "++", "I", ")", "assert", "(", "Comp", "(", "*", "I", ",", "*", "(", "I", "+", "1", ")", ")", ")", ";", "return", "std", "::", "binary_search", "(", "LibCalls", ",", "End", ",", "CallSym", ",", "Comp", ")", ";", "}", "</s>" ]

[ "This", "function", "returns", "true", "if", "CallSym", "is", "a", "long", "double", "emulation", "routine", "." ]

[ "Mips", "\"__addtf3\"", "\"__divtf3\"", "\"__eqtf2\"", "\"__extenddftf2\"", "\"__extendsftf2\"", "\"__fixtfdi\"", "\"__fixtfsi\"", "\"__fixtfti\"", "\"__fixunstfdi\"", "\"__fixunstfsi\"", "\"__fixunstfti\"", "\"__floatditf\"", "\"__floatsitf\"", "\"__floattitf\"", "\"__floatunditf\"", "\"__floatunsitf\"", "\"__floatuntitf\"", "\"__getf2\"", "\"__gttf2\"", "\"__letf2\"", "\"__lttf2\"", "\"__multf3\"", "\"__netf2\"", "\"__powitf2\"", "\"__subtf3\"", "\"__trunctfdf2\"", "\"__trunctfsf2\"", "\"__unordtf2\"", "\"ceill\"", "\"copysignl\"", "\"cosl\"", "\"exp2l\"", "\"expl\"", "\"floorl\"", "\"fmal\"", "\"fmodl\"", "\"log10l\"", "\"log2l\"", "\"logl\"", "\"nearbyintl\"", "\"powl\"", "\"rintl\"", "\"sinl\"", "\"sqrtl\"", "\"truncl\"", "Mips", "1", "1" ]

[]

[ "<s>", "void", "MipsCallLowering", "::", "splitToValueTypes", "(", "const", "DataLayout", "&", "DL", ",", "const", "ArgInfo", "&", "OrigArg", ",", "unsigned", "OriginalIndex", ",", "SmallVectorImpl", "<", "ArgInfo", ">", "&", "SplitArgs", ",", "SmallVectorImpl", "<", "unsigned", ">", "&", "SplitArgsOrigIndices", ")", "const", "{", "SmallVector", "<", "EVT", ",", "4", ">", "SplitEVTs", ";", "SmallVector", "<", "Register", ",", "4", ">", "SplitVRegs", ";", "const", "MipsTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "MipsTargetLowering", ">", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "OrigArg", ".", "Ty", "->", "getContext", "(", ")", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "OrigArg", ".", "Ty", ",", "SplitEVTs", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "SplitEVTs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "ArgInfo", "Info", "=", "ArgInfo", "{", "OrigArg", ".", "Regs", "[", "i", "]", ",", "SplitEVTs", "[", "i", "]", ".", "getTypeForEVT", "(", "Ctx", ")", "}", ";", "Info", ".", "Flags", "=", "OrigArg", ".", "Flags", ";", "SplitArgs", ".", "push_back", "(", "Info", ")", ";", "SplitArgsOrigIndices", ".", "push_back", "(", "OriginalIndex", ")", ";", "}", "}", "</s>" ]

[ "Break", "OrigArgInfo", "into", "one", "or", "more", "pieces", "the", "calling", "convention", "can", "process", ",", "returned", "in", "SplitArgs", "." ]

[ "Mips", "Mips", "4", "4", "Mips", "Mips", "0" ]

[]

[ "<s>", "void", "ARMTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "if", "(", "!", "ST", "->", "isMClass", "(", ")", ")", "return", "BasicTTIImplBase", "::", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ")", ";", "UP", ".", "OptSizeThreshold", "=", "0", ";", "UP", ".", "PartialOptSizeThreshold", "=", "0", ";", "if", "(", "L", "->", "getHeader", "(", ")", "->", "getParent", "(", ")", "->", "hasOptSize", "(", ")", ")", "return", ";", "if", "(", "!", "ST", "->", "isThumb2", "(", ")", ")", "return", ";", "SmallVector", "<", "BasicBlock", "*", ",", "4", ">", "ExitingBlocks", ";", "L", "->", "getExitingBlocks", "(", "ExitingBlocks", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Loop has:\\n\"", "<<", "\"Blocks: \"", "<<", "L", "->", "getNumBlocks", "(", ")", "<<", "\"\\n\"", "<<", "\"Exit blocks: \"", "<<", "ExitingBlocks", ".", "size", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "ExitingBlocks", ".", "size", "(", ")", ">", "2", ")", "return", ";", "if", "(", "ST", "->", "hasBranchPredictor", "(", ")", "&&", "L", "->", "getNumBlocks", "(", ")", ">", "4", ")", "return", ";", "if", "(", "getBooleanLoopAttribute", "(", "L", ",", "\"llvm.loop.isvectorized\"", ")", ")", "return", ";", "unsigned", "Cost", "=", "0", ";", "for", "(", "auto", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "I", ".", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "return", ";", "if", "(", "isa", "<", "CallInst", ">", "(", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "I", ")", ")", "{", "if", "(", "const", "Function", "*", "F", "=", "cast", "<", "CallBase", ">", "(", "I", ")", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "!", "isLoweredToCall", "(", "F", ")", ")", "continue", ";", "}", "return", ";", "}", "SmallVector", "<", "const", "Value", "*", ",", "4", ">", "Operands", "(", "I", ".", "operand_values", "(", ")", ")", ";", "Cost", "+=", "getUserCost", "(", "&", "I", ",", "Operands", ",", "TargetTransformInfo", "::", "TCK_SizeAndLatency", ")", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Cost of loop: \"", "<<", "Cost", "<<", "\"\\n\"", ")", ";", "UP", ".", "Partial", "=", "true", ";", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "UpperBound", "=", "true", ";", "UP", ".", "UnrollRemainder", "=", "true", ";", "UP", ".", "DefaultUnrollRuntimeCount", "=", "4", ";", "UP", ".", "UnrollAndJam", "=", "true", ";", "UP", ".", "UnrollAndJamInnerLoopThreshold", "=", "60", ";", "if", "(", "Cost", "<", "12", ")", "UP", ".", "Force", "=", "true", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "ARM", "ARM", "0", "0", "4", "\"Loop has:\\n\"", "\"Blocks: \"", "\"\\n\"", "\"Exit blocks: \"", "\"\\n\"", "2", "4", "\"llvm.loop.isvectorized\"", "0", "4", "\"Cost of loop: \"", "\"\\n\"", "4", "60", "12" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "MutableArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "isFuncletReturnInstr", "(", "*", "MI", ")", "&&", "STI", ".", "isOSWindows", "(", ")", ")", "{", "if", "(", "STI", ".", "is32Bit", "(", ")", ")", "return", "true", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "CATCHRET", ")", "{", "const", "Function", "&", "F", "=", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", ";", "bool", "IsSEH", "=", "isAsynchronousEHPersonality", "(", "classifyEHPersonality", "(", "F", ".", "getPersonalityFn", "(", ")", ")", ")", ";", "if", "(", "IsSEH", ")", "return", "true", ";", "}", "}", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "I", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "I", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "MVT", "VT", "=", "MVT", "::", "Other", ";", "if", "(", "X86", "::", "VK16RegClass", ".", "contains", "(", "Reg", ")", ")", "VT", "=", "STI", ".", "hasBWI", "(", ")", "?", "MVT", "::", "v64i1", ":", "MVT", "::", "v16i1", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ",", "VT", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "I", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "unsigned", "Opc", "=", "STI", ".", "is64Bit", "(", ")", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ";", "for", "(", "const", "CalleeSavedInfo", "&", "I", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "I", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "Reg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::CATCHRET", "X86::GR64RegClass", "X86::GR32RegClass", "MVT::Other", "X86::VK16RegClass", "MVT::v64i1", "MVT::v16i1", "X86::POP64r", "X86::POP32r", "X86::GR64RegClass", "X86::GR32RegClass" ]

[]

[ "<s>", "static", "void", "aarch64_print_hint_for_core_or_arch", "(", "const", "char", "*", "str", ",", "bool", "arch", ")", "{", "auto_vec", "<", "const", "char", "*", ">", "candidates", ";", "const", "struct", "processor", "*", "entry", "=", "arch", "?", "all_architectures", ":", "all_cores", ";", "for", "(", ";", "entry", "->", "name", "!=", "NULL", ";", "entry", "++", ")", "candidates", ".", "safe_push", "(", "entry", "->", "name", ")", ";", "if", "(", "arch", ")", "candidates", ".", "safe_push", "(", "\"native\"", ")", ";", "char", "*", "s", ";", "const", "char", "*", "hint", "=", "candidates_list_and_hint", "(", "str", ",", "s", ",", "candidates", ")", ";", "if", "(", "hint", ")", "inform", "(", "input_location", ",", "\"valid arguments are: %s;\"", "\" did you mean %qs?\"", ",", "s", ",", "hint", ")", ";", "else", "inform", "(", "input_location", ",", "\"valid arguments are: %s\"", ",", "s", ")", ";", "XDELETEVEC", "(", "s", ")", ";", "}", "</s>" ]

[ "Print", "a", "hint", "with", "a", "suggestion", "for", "a", "core", "or", "architecture", "name", "that", "most", "closely", "resembles", "what", "the", "user", "passed", "in", "STR", ".", "ARCH", "is", "true", "if", "the", "user", "is", "asking", "for", "an", "architecture", "name", ".", "ARCH", "is", "false", "if", "the", "user", "is", "asking", "for", "a", "core", "name", "." ]

[ "aarch64", "\"native\"", "\"valid arguments are: %s;\"", "\" did you mean %qs?\"", "\"valid arguments are: %s\"" ]

[]

[ "<s>", "MCSymbol", "*", "mprocMCInstLower", "::", "GetBlockAddressSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "switch", "(", "MO", ".", "getTargetFlags", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown target flag on GV operand\"", ")", ";", "case", "0", ":", "break", ";", "}", "return", "Printer", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "used", "to", "satisfy", "BlockAddress", "uses", "of", "the", "specified", "basic", "block", "." ]

[ "mproc", "mproc", "\"Unknown target flag on GV operand\"", "0" ]

[]

[ "<s>", "void", "NVPTXPassConfig", "::", "addIRPasses", "(", ")", "{", "disablePass", "(", "&", "PrologEpilogCodeInserterID", ")", ";", "disablePass", "(", "&", "MachineCopyPropagationID", ")", ";", "disablePass", "(", "&", "TailDuplicateID", ")", ";", "disablePass", "(", "&", "StackMapLivenessID", ")", ";", "disablePass", "(", "&", "LiveDebugValuesID", ")", ";", "disablePass", "(", "&", "PostRAMachineSinkingID", ")", ";", "disablePass", "(", "&", "PostRASchedulerID", ")", ";", "disablePass", "(", "&", "FuncletLayoutID", ")", ";", "disablePass", "(", "&", "PatchableFunctionID", ")", ";", "disablePass", "(", "&", "ShrinkWrapID", ")", ";", "const", "NVPTXSubtarget", "&", "ST", "=", "*", "getTM", "<", "NVPTXTargetMachine", ">", "(", ")", ".", "getSubtargetImpl", "(", ")", ";", "addPass", "(", "createNVVMReflectPass", "(", "ST", ".", "getSmVersion", "(", ")", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createNVPTXImageOptimizerPass", "(", ")", ")", ";", "addPass", "(", "createNVPTXAssignValidGlobalNamesPass", "(", ")", ")", ";", "addPass", "(", "createGenericToNVVMPass", "(", ")", ")", ";", "addPass", "(", "createNVPTXLowerArgsPass", "(", "&", "getNVPTXTargetMachine", "(", ")", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addAddressSpaceInferencePasses", "(", ")", ";", "addStraightLineScalarOptimizationPasses", "(", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addEarlyCSEOrGVNPass", "(", ")", ";", "if", "(", "!", "DisableLoadStoreVectorizer", ")", "addPass", "(", "createLoadStoreVectorizerPass", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX" ]

[]

[ "<s>", "static", "rtx", "zero_all_vector_registers", "(", "HARD_REG_SET", "need_zeroed_hardregs", ")", "{", "if", "(", "!", "TARGET_AVX", ")", "return", "NULL", ";", "for", "(", "unsigned", "int", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "(", "LEGACY_SSE_REGNO_P", "(", "regno", ")", "||", "(", "TARGET_64BIT", "&&", "(", "REX_SSE_REGNO_P", "(", "regno", ")", "||", "(", "TARGET_AVX512F", "&&", "EXT_REX_SSE_REGNO_P", "(", "regno", ")", ")", ")", ")", ")", "&&", "!", "TEST_HARD_REG_BIT", "(", "need_zeroed_hardregs", ",", "regno", ")", ")", "return", "NULL", ";", "return", "gen_avx_vzeroall", "(", ")", ";", "}", "</s>" ]

[ "Generate", "a", "rtx", "to", "zero", "all", "vector", "registers", "together", "if", "possible", ",", "otherwise", ",", "return", "NULL", "." ]

[ "i386", "0" ]

[]

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

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

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

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isZExtFree", "(", "SDValue", "Val", ",", "EVT", "VT2", ")", "const", "{", "if", "(", "auto", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "Val", ")", ")", "{", "EVT", "MemVT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "if", "(", "(", "MemVT", "==", "MVT", "::", "i8", "||", "MemVT", "==", "MVT", "::", "i16", "||", "(", "Subtarget", ".", "is64Bit", "(", ")", "&&", "MemVT", "==", "MVT", "::", "i32", ")", ")", "&&", "(", "LD", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "NON_EXTLOAD", "||", "LD", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "ZEXTLOAD", ")", ")", "return", "true", ";", "}", "return", "TargetLowering", "::", "isZExtFree", "(", "Val", ",", "VT2", ")", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "MVT::i8", "MVT::i16", "MVT::i32", "ISD::NON_EXTLOAD", "ISD::ZEXTLOAD" ]

[]

[ "<s>", "static", "bool", "ix86_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_SSE", "&&", "VALID_SSE_REG_MODE", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "TARGET_SSE2", "&&", "VALID_SSE2_REG_MODE", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "TARGET_AVX", "&&", "VALID_AVX256_REG_MODE", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "TARGET_AVX512F", "&&", "VALID_AVX512F_REG_MODE", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "TARGET_MMX", "&&", "VALID_MMX_REG_MODE", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "TARGET_3DNOW", "&&", "VALID_MMX_REG_MODE_3DNOW", "(", "mode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implements", "target", "hook", "vector_mode_supported_p", "." ]

[ "i386" ]

[]

[ "<s>", "static", "rtx", "gen_rx_store_vector", "(", "unsigned", "int", "low", ",", "unsigned", "int", "high", ")", "{", "unsigned", "int", "i", ";", "unsigned", "int", "count", "=", "(", "high", "-", "low", ")", "+", "2", ";", "rtx", "vector", ";", "vector", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", ")", ")", ";", "XVECEXP", "(", "vector", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "gen_rtx_MINUS", "(", "SImode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "(", "count", "-", "1", ")", "*", "UNITS_PER_WORD", ")", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "count", "-", "1", ";", "i", "++", ")", "XVECEXP", "(", "vector", ",", "0", ",", "i", "+", "1", ")", "=", "gen_rtx_SET", "(", "gen_rtx_MEM", "(", "SImode", ",", "gen_rtx_MINUS", "(", "SImode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "(", "i", "+", "1", ")", "*", "UNITS_PER_WORD", ")", ")", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "high", "-", "i", ")", ")", ";", "return", "vector", ";", "}", "</s>" ]

[ "Generate", "a", "PARALLEL", "that", "will", "pass", "the", "rx_store_multiple_vector", "predicate", "." ]

[ "rx", "2", "0", "0", "1", "0", "1", "0", "1", "1" ]

[]

[ "<s>", "bool", "PPCPassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "!", "DisablePreIncPrep", "&&", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createPPCLoopPreIncPrepPass", "(", "getPPCTargetMachine", "(", ")", ")", ")", ";", "if", "(", "!", "DisableCTRLoops", "&&", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createHardwareLoopsPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "shouldConvertConstantLoadToIntImm", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "it", "is", "beneficial", "to", "convert", "a", "load", "of", "a", "constant", "to", "just", "the", "constant", "itself", "." ]

[ "RISCV" ]

[]

[ "<s>", "bool", "ThumbRegisterInfo", "::", "saveScavengerRegister", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "MachineBasicBlock", "::", "iterator", "&", "UseMI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Reg", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MBB", ".", "getParent", "(", ")", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "!", "STI", ".", "isThumb1Only", "(", ")", ")", "return", "ARMBaseRegisterInfo", "::", "saveScavengerRegister", "(", "MBB", ",", "I", ",", "UseMI", ",", "RC", ",", "Reg", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVr", ")", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "bool", "done", "=", "false", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "II", "=", "I", ";", "!", "done", "&&", "II", "!=", "UseMI", ";", "++", "II", ")", "{", "if", "(", "II", "->", "isDebugInstr", "(", ")", ")", "continue", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "II", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "II", "->", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isRegMask", "(", ")", "&&", "MO", ".", "clobbersPhysReg", "(", "ARM", "::", "R12", ")", ")", "{", "UseMI", "=", "II", ";", "done", "=", "true", ";", "break", ";", "}", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isUndef", "(", ")", "||", "!", "MO", ".", "getReg", "(", ")", "||", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "continue", ";", "if", "(", "MO", ".", "getReg", "(", ")", "==", "ARM", "::", "R12", ")", "{", "UseMI", "=", "II", ";", "done", "=", "true", ";", "break", ";", "}", "}", "}", "BuildMI", "(", "MBB", ",", "UseMI", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVr", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Kill", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Spill", "the", "register", "so", "it", "can", "be", "used", "by", "the", "register", "scavenger", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM::tMOVr", "ARM::R12", "ARMCC::AL", "0", "ARM::R12", "ARM::R12", "ARM::tMOVr", "ARM::R12", "ARMCC::AL" ]

[]

[ "<s>", "void", "xstormy16_expand_arith", "(", "machine_mode", "mode", ",", "enum", "rtx_code", "code", ",", "rtx", "dest", ",", "rtx", "src0", ",", "rtx", "src1", ")", "{", "int", "num_words", "=", "GET_MODE_BITSIZE", "(", "mode", ")", "/", "BITS_PER_WORD", ";", "int", "i", ";", "int", "firstloop", "=", "1", ";", "if", "(", "code", "==", "NEG", ")", "emit_move_insn", "(", "src0", ",", "const0_rtx", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "num_words", ";", "i", "++", ")", "{", "rtx", "w_src0", ",", "w_src1", ",", "w_dest", ";", "rtx", "insn", ";", "w_src0", "=", "simplify_gen_subreg", "(", "word_mode", ",", "src0", ",", "mode", ",", "i", "*", "UNITS_PER_WORD", ")", ";", "w_src1", "=", "simplify_gen_subreg", "(", "word_mode", ",", "src1", ",", "mode", ",", "i", "*", "UNITS_PER_WORD", ")", ";", "w_dest", "=", "simplify_gen_subreg", "(", "word_mode", ",", "dest", ",", "mode", ",", "i", "*", "UNITS_PER_WORD", ")", ";", "switch", "(", "code", ")", "{", "case", "PLUS", ":", "if", "(", "firstloop", "&&", "CONST_INT_P", "(", "w_src1", ")", "&&", "INTVAL", "(", "w_src1", ")", "==", "0", ")", "continue", ";", "if", "(", "firstloop", ")", "insn", "=", "gen_addchi4", "(", "w_dest", ",", "w_src0", ",", "w_src1", ")", ";", "else", "insn", "=", "gen_addchi5", "(", "w_dest", ",", "w_src0", ",", "w_src1", ")", ";", "break", ";", "case", "NEG", ":", "case", "MINUS", ":", "case", "COMPARE", ":", "if", "(", "code", "==", "COMPARE", "&&", "i", "==", "num_words", "-", "1", ")", "{", "rtx", "branch", ",", "sub", ",", "clobber", ",", "sub_1", ";", "sub_1", "=", "gen_rtx_MINUS", "(", "HImode", ",", "w_src0", ",", "gen_rtx_ZERO_EXTEND", "(", "HImode", ",", "gen_rtx_REG", "(", "BImode", ",", "CARRY_REGNUM", ")", ")", ")", ";", "sub", "=", "gen_rtx_SET", "(", "w_dest", ",", "gen_rtx_MINUS", "(", "HImode", ",", "sub_1", ",", "w_src1", ")", ")", ";", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "BImode", ",", "CARRY_REGNUM", ")", ")", ";", "branch", "=", "gen_rtx_SET", "(", "pc_rtx", ",", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "gen_rtx_EQ", "(", "HImode", ",", "sub_1", ",", "w_src1", ")", ",", "pc_rtx", ",", "pc_rtx", ")", ")", ";", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "3", ",", "branch", ",", "sub", ",", "clobber", ")", ")", ";", "}", "else", "if", "(", "firstloop", "&&", "code", "!=", "COMPARE", "&&", "CONST_INT_P", "(", "w_src1", ")", "&&", "INTVAL", "(", "w_src1", ")", "==", "0", ")", "continue", ";", "else", "if", "(", "firstloop", ")", "insn", "=", "gen_subchi4", "(", "w_dest", ",", "w_src0", ",", "w_src1", ")", ";", "else", "insn", "=", "gen_subchi5", "(", "w_dest", ",", "w_src0", ",", "w_src1", ")", ";", "break", ";", "case", "IOR", ":", "case", "XOR", ":", "case", "AND", ":", "if", "(", "CONST_INT_P", "(", "w_src1", ")", "&&", "INTVAL", "(", "w_src1", ")", "==", "-", "(", "code", "==", "AND", ")", ")", "continue", ";", "insn", "=", "gen_rtx_SET", "(", "w_dest", ",", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "w_src0", ",", "w_src1", ")", ")", ";", "break", ";", "case", "NOT", ":", "insn", "=", "gen_rtx_SET", "(", "w_dest", ",", "gen_rtx_NOT", "(", "mode", ",", "w_src0", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "firstloop", "=", "0", ";", "emit", "(", "insn", ")", ";", "}", "if", "(", "firstloop", ")", "emit", "(", "gen_nop", "(", ")", ")", ";", "}", "</s>" ]

[ "Expander", "for", "arithmetic", "operations", ";", "emit", "insns", "to", "compute", "(", "set", "DEST", "(", "CODE", ":", "MODE", "SRC0", "SRC1", ")", ")", "using", "CARRY", "as", "a", "temporary", ".", "When", "CODE", "is", "COMPARE", ",", "a", "branch", "template", "is", "generated", "(", "this", "saves", "duplicating", "code", "in", "xstormy16_split_cbranch", ")", "." ]

[ "stormy16", "1", "0", "0", "1", "3", "0", "0" ]

[]

[ "<s>", "InstructionCost", "PPCTTIImpl", "::", "getIntrinsicInstrCost", "(", "const", "IntrinsicCostAttributes", "&", "ICA", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "ICA", ",", "CostKind", ")", ";", "}", "</s>" ]

[ "Get", "intrinsic", "cost", "based", "on", "arguments", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "unsigned", "XCoreInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "int", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "XCore", "::", "STWFI", ")", "{", "if", "(", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "&&", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "&&", "(", "isZeroImm", "(", "MI", "->", "getOperand", "(", "2", ")", ")", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore::STWFI", "1", "2", "2", "1", "0", "0" ]

[]

[ "<s>", "void", "loongarch_emit_binary", "(", "enum", "rtx_code", "code", ",", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "gen_rtx_fmt_ee", "(", "code", ",", "GET_MODE", "(", "target", ")", ",", "op0", ",", "op1", ")", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "instruction", "of", "the", "form", "(", "set", "TARGET", "(", "CODE", "OP0", "OP1", ")", ")", "." ]

[ "loongarch" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "MSP430", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_10_pcrel\"", ",", "0", ",", "10", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_16_pcrel\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_16_byte\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_16_pcrel_byte\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_2x_pcrel\"", ",", "0", ",", "10", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_rl_pcrel\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_8\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_sym_diff\"", ",", "0", ",", "32", ",", "0", "}", ",", "}", ";", "static_assert", "(", "(", "array_lengthof", "(", "Infos", ")", ")", "==", "MSP430", "::", "NumTargetFixupKinds", ",", "\"Not all fixup kinds added to Infos array\"", ")", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430::NumTargetFixupKinds", "\"fixup_32\"", "0", "32", "0", "\"fixup_10_pcrel\"", "0", "10", "\"fixup_16\"", "0", "16", "0", "\"fixup_16_pcrel\"", "0", "16", "\"fixup_16_byte\"", "0", "16", "0", "\"fixup_16_pcrel_byte\"", "0", "16", "\"fixup_2x_pcrel\"", "0", "10", "\"fixup_rl_pcrel\"", "0", "16", "\"fixup_8\"", "0", "8", "0", "\"fixup_sym_diff\"", "0", "32", "0", "MSP430::NumTargetFixupKinds", "\"Not all fixup kinds added to Infos array\"" ]

[]

[ "<s>", "unsigned", "VEInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "3", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"VE branch conditions should have three component!\"", ")", ";", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "assert", "(", "!", "FBB", "&&", "\"Unconditional branch with multiple successors!\"", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "VE", "::", "BCRLa", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "assert", "(", "Cond", "[", "0", "]", ".", "isImm", "(", ")", "&&", "Cond", "[", "2", "]", ".", "isReg", "(", ")", "&&", "\"not implemented\"", ")", ";", "unsigned", "opc", "[", "2", "]", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "unsigned", "Reg", "=", "Cond", "[", "2", "]", ".", "getReg", "(", ")", ";", "if", "(", "IsIntegerCC", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", "{", "if", "(", "TRI", "->", "getRegSizeInBits", "(", "Reg", ",", "MRI", ")", "==", "32", ")", "{", "opc", "[", "0", "]", "=", "VE", "::", "BCRWir", ";", "opc", "[", "1", "]", "=", "VE", "::", "BCRWrr", ";", "}", "else", "{", "opc", "[", "0", "]", "=", "VE", "::", "BCRLir", ";", "opc", "[", "1", "]", "=", "VE", "::", "BCRLrr", ";", "}", "}", "else", "{", "if", "(", "TRI", "->", "getRegSizeInBits", "(", "Reg", ",", "MRI", ")", "==", "32", ")", "{", "opc", "[", "0", "]", "=", "VE", "::", "BCRSir", ";", "opc", "[", "1", "]", "=", "VE", "::", "BCRSrr", ";", "}", "else", "{", "opc", "[", "0", "]", "=", "VE", "::", "BCRDir", ";", "opc", "[", "1", "]", "=", "VE", "::", "BCRDrr", ";", "}", "}", "if", "(", "Cond", "[", "1", "]", ".", "isImm", "(", ")", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "opc", "[", "0", "]", ")", ")", ".", "add", "(", "Cond", "[", "0", "]", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ".", "add", "(", "Cond", "[", "2", "]", ")", ".", "addMBB", "(", "TBB", ")", ";", "}", "else", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "opc", "[", "1", "]", ")", ")", ".", "add", "(", "Cond", "[", "0", "]", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ".", "add", "(", "Cond", "[", "2", "]", ")", ".", "addMBB", "(", "TBB", ")", ";", "}", "if", "(", "!", "FBB", ")", "return", "1", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "VE", "::", "BCRLa", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "return", "2", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "VE", "VE", "\"insertBranch must not be told to insert a fallthrough\"", "3", "0", "\"VE branch conditions should have three component!\"", "\"code size not handled\"", "\"Unconditional branch with multiple successors!\"", "VE::BCRLa", "1", "0", "2", "\"not implemented\"", "2", "2", "0", "32", "0", "VE::BCRWir", "1", "VE::BCRWrr", "0", "VE::BCRLir", "1", "VE::BCRLrr", "32", "0", "VE::BCRSir", "1", "VE::BCRSrr", "0", "VE::BCRDir", "1", "VE::BCRDrr", "1", "0", "0", "1", "2", "1", "0", "1", "2", "1", "VE::BCRLa", "2" ]

[]

[ "<s>", "static", "rtx", "aarch64_function_value", "(", "const_tree", "type", ",", "const_tree", "func", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "machine_mode", "mode", ";", "int", "unsignedp", ";", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "if", "(", "INTEGRAL_TYPE_P", "(", "type", ")", ")", "mode", "=", "promote_function_mode", "(", "type", ",", "mode", ",", "&", "unsignedp", ",", "func", ",", "1", ")", ";", "pure_scalable_type_info", "pst_info", ";", "if", "(", "type", "&&", "pst_info", ".", "analyze_registers", "(", "type", ")", ")", "return", "pst_info", ".", "get_rtx", "(", "mode", ",", "V0_REGNUM", ",", "P0_REGNUM", ")", ";", "unsigned", "int", "vec_flags", "=", "aarch64_classify_vector_mode", "(", "mode", ")", ";", "bool", "sve_p", "=", "(", "vec_flags", "&", "VEC_ANY_SVE", ")", ";", "if", "(", "aarch64_return_in_msb", "(", "type", ")", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "size", "%", "UNITS_PER_WORD", "!=", "0", ")", "{", "size", "+=", "UNITS_PER_WORD", "-", "size", "%", "UNITS_PER_WORD", ";", "mode", "=", "int_mode_for_size", "(", "size", "*", "BITS_PER_UNIT", ",", "0", ")", ".", "require", "(", ")", ";", "}", "}", "int", "count", ";", "machine_mode", "ag_mode", ";", "if", "(", "aarch64_vfp_is_call_or_return_candidate", "(", "mode", ",", "type", ",", "&", "ag_mode", ",", "&", "count", ",", "NULL", ",", "false", ")", ")", "{", "gcc_assert", "(", "!", "sve_p", ")", ";", "if", "(", "!", "aarch64_composite_type_p", "(", "type", ",", "mode", ")", ")", "{", "gcc_assert", "(", "count", "==", "1", "&&", "mode", "==", "ag_mode", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "V0_REGNUM", ")", ";", "}", "else", "{", "int", "i", ";", "rtx", "par", ";", "par", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "count", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "count", ";", "i", "++", ")", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "ag_mode", ",", "V0_REGNUM", "+", "i", ")", ";", "rtx", "offset", "=", "gen_int_mode", "(", "i", "*", "GET_MODE_SIZE", "(", "ag_mode", ")", ",", "Pmode", ")", ";", "tmp", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "tmp", ",", "offset", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "i", ")", "=", "tmp", ";", "}", "return", "par", ";", "}", "}", "else", "{", "if", "(", "sve_p", ")", "{", "gcc_assert", "(", "type", "&&", "(", "aarch64_some_values_include_pst_objects_p", "(", "type", ")", "||", "(", "vec_flags", "&", "VEC_PARTIAL", ")", ")", ")", ";", "scalar_int_mode", "int_mode", "=", "int_mode_for_mode", "(", "mode", ")", ".", "require", "(", ")", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "int_mode", ",", "R0_REGNUM", ")", ";", "rtx", "pair", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "const0_rtx", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "1", ",", "pair", ")", ")", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "R0_REGNUM", ")", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_VALUE", ".", "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "function", "." ]

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

[]

[ "<s>", "bool", "MipsAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".ent\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".end\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".frame\"", ")", "{", "Parser", ".", "EatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".set\"", ")", "{", "Parser", ".", "EatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".fmask\"", ")", "{", "Parser", ".", "EatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".mask\"", ")", "{", "Parser", ".", "EatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".gpword\"", ")", "{", "Parser", ".", "EatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\".ent\"", "\".end\"", "\".frame\"", "\".set\"", "\".fmask\"", "\".mask\"", "\".gpword\"" ]

[]

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

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

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

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"AMDGPU Promote Alloca\"", ";", "}", "</s>" ]

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

[ "R600", "\"AMDGPU Promote Alloca\"" ]

[]

[ "<s>", "bool", "loongarch_12bit_offset_address_p", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "struct", "loongarch_address_info", "addr", ";", "return", "(", "loongarch_classify_address", "(", "&", "addr", ",", "x", ",", "mode", ",", "false", ")", "&&", "(", "(", "addr", ".", "type", "==", "ADDRESS_REG", "&&", "CONST_INT_P", "(", "addr", ".", "offset", ")", "&&", "LARCH_12BIT_OFFSET_P", "(", "INTVAL", "(", "addr", ".", "offset", ")", ")", ")", "||", "addr", ".", "type", "==", "ADDRESS_LO_SUM", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "legitimate", "address", "with", "a", "12-bit", "offset", "or", "addr.type", "is", "ADDRESS_LO_SUM", ".", "MODE", "is", "the", "mode", "of", "the", "value", "being", "accessed", "." ]

[ "loongarch" ]

[]

[ "<s>", "static", "bool", "must_save_p", "(", "bool", "is_inthandler", ",", "unsigned", "regno", ")", "{", "if", "(", "D_REGNO_P", "(", "regno", ")", ")", "{", "bool", "is_eh_return_reg", "=", "false", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "unsigned", "j", ";", "for", "(", "j", "=", "0", ";", ";", "j", "++", ")", "{", "unsigned", "test", "=", "EH_RETURN_DATA_REGNO", "(", "j", ")", ";", "if", "(", "test", "==", "INVALID_REGNUM", ")", "break", ";", "if", "(", "test", "==", "regno", ")", "is_eh_return_reg", "=", "true", ";", "}", "}", "return", "(", "is_eh_return_reg", "||", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "fixed_regs", "[", "regno", "]", "&&", "(", "is_inthandler", "||", "!", "call_used_regs", "[", "regno", "]", ")", ")", ")", ";", "}", "else", "if", "(", "P_REGNO_P", "(", "regno", ")", ")", "{", "return", "(", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "fixed_regs", "[", "regno", "]", "&&", "(", "is_inthandler", "||", "!", "call_used_regs", "[", "regno", "]", ")", ")", "||", "(", "is_inthandler", "&&", "(", "ENABLE_WA_05000283", "||", "ENABLE_WA_05000315", ")", "&&", "regno", "==", "REG_P5", ")", "||", "(", "!", "TARGET_FDPIC", "&&", "regno", "==", "PIC_OFFSET_TABLE_REGNUM", "&&", "(", "crtl", "->", "uses_pic_offset_table", "||", "(", "TARGET_ID_SHARED_LIBRARY", "&&", "!", "crtl", "->", "is_leaf", ")", ")", ")", ")", ";", "}", "else", "return", "(", "(", "is_inthandler", "||", "!", "call_used_regs", "[", "regno", "]", ")", "&&", "(", "df_regs_ever_live_p", "(", "regno", ")", "||", "(", "!", "leaf_function_p", "(", ")", "&&", "call_used_regs", "[", "regno", "]", ")", ")", ")", ";", "}", "</s>" ]

[ "For", "a", "given", "REGNO", ",", "determine", "whether", "it", "must", "be", "saved", "in", "the", "function", "prologue", ".", "IS_INTHANDLER", "specifies", "whether", "we", "'re", "generating", "a", "normal", "prologue", "or", "an", "interrupt/exception", "one", "." ]

[ "bfin", "0" ]

[]

[ "<s>", "static", "void", "sparc_asm_function_epilogue", "(", "FILE", "*", "file", ",", "HOST_WIDE_INT", "size", "ATTRIBUTE_UNUSED", ")", "{", "rtx_insn", "*", "insn", "=", "get_last_insn", "(", ")", ";", "rtx", "last_real_insn", "=", "prev_real_insn", "(", "insn", ")", ";", "if", "(", "last_real_insn", "&&", "NONJUMP_INSN_P", "(", "last_real_insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "last_real_insn", ")", ")", "==", "SEQUENCE", ")", "last_real_insn", "=", "XVECEXP", "(", "PATTERN", "(", "last_real_insn", ")", ",", "0", ",", "0", ")", ";", "if", "(", "last_real_insn", "&&", "CALL_P", "(", "last_real_insn", ")", "&&", "!", "SIBLING_CALL_P", "(", "last_real_insn", ")", ")", "fputs", "(", "\"\\tnop\\n\"", ",", "file", ")", ";", "sparc_output_deferred_case_vectors", "(", ")", ";", "}", "</s>" ]

[ "This", "function", "generates", "the", "assembly", "code", "for", "function", "exit", "." ]

[ "sparc", "0", "0", "\"\\tnop\\n\"" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Imm", ".", "isPosZero", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "f64", "||", "VT", "==", "MVT", "::", "f32", ")", ")", "return", "true", ";", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "return", "AArch64_AM", "::", "getFP64Imm", "(", "Imm", ")", "!=", "-", "1", ";", "else", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "AArch64_AM", "::", "getFP32Imm", "(", "Imm", ")", "!=", "-", "1", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "can", "instruction", "select", "the", "specified", "FP", "immediate", "natively", "." ]

[ "AArch64", "AArch64", "MVT::f64", "MVT::f32", "MVT::f64", "AArch64_AM::getFP64Imm", "1", "MVT::f32", "AArch64_AM::getFP32Imm", "1" ]

[]

[ "<s>", "bool", "aarch64_move_imm", "(", "HOST_WIDE_INT", "val", ",", "machine_mode", "mode", ")", "{", "if", "(", "aarch64_movw_imm", "(", "val", ",", "mode", ")", "||", "aarch64_movw_imm", "(", "~", "val", ",", "mode", ")", ")", "return", "1", ";", "return", "aarch64_bitmask_imm", "(", "val", ",", "mode", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "val", "is", "an", "immediate", "that", "can", "be", "loaded", "into", "a", "register", "in", "a", "single", "instruction", "." ]

[ "aarch64", "1" ]

[]

[ "<s>", "static", "inline", "bool", "offset_6bit_unsigned_scaled_p", "(", "machine_mode", "mode", ",", "poly_int64", "offset", ")", "{", "HOST_WIDE_INT", "multiple", ";", "return", "(", "constant_multiple_p", "(", "offset", ",", "GET_MODE_SIZE", "(", "mode", ")", ",", "&", "multiple", ")", "&&", "IN_RANGE", "(", "multiple", ",", "0", ",", "63", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OFFSET", "is", "an", "unsigned", "6-bit", "value", "multiplied", "by", "the", "size", "of", "MODE", "." ]

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

[]

[ "<s>", "bool", "m68k_epilogue_uses", "(", "int", "regno", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "reload_completed", "&&", "(", "m68k_get_function_kind", "(", "current_function_decl", ")", "==", "m68k_fk_interrupt_handler", ")", ")", ";", "}", "</s>" ]

[ "Implements", "EPILOGUE_USES", ".", "All", "registers", "are", "live", "on", "exit", "from", "an", "interrupt", "routine", "." ]

[ "m68k" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "ARM64RegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "return", "&", "ARM64", "::", "GPR64RegClass", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "ARM64::GPR64RegClass" ]

[]

[ "<s>", "const", "SchedDFSResult", "*", "getDFSResult", "(", ")", "const", "{", "return", "DFSResult", ";", "}", "</s>" ]

[ "Return", "a", "non-null", "DFS", "result", "if", "the", "scheduling", "strategy", "initialized", "it", "." ]

[ "Patmos" ]

[]

[ "<s>", "void", "WebAssemblyAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ",", "MCContext", "&", "Ctx", ")", "const", "{", "const", "MCFixupKindInfo", "&", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "assert", "(", "Info", ".", "Flags", "==", "0", "&&", "\"WebAssembly does not use MCFixupKindInfo flags\"", ")", ";", "unsigned", "NumBytes", "=", "alignTo", "(", "Info", ".", "TargetSize", ",", "8", ")", "/", "8", ";", "if", "(", "Value", "==", "0", ")", "return", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "0", "\"WebAssembly does not use MCFixupKindInfo flags\"", "8", "8", "0", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "static", "void", "tilegx_option_override", "(", "void", ")", "{", "if", "(", "OPTION_SET_P", "(", "tilegx_cmodel", ")", ")", "{", "switch", "(", "tilegx_cmodel", ")", "{", "case", "CM_SMALL", ":", "case", "CM_SMALL_PIC", ":", "if", "(", "flag_pic", ")", "tilegx_cmodel", "=", "CM_SMALL_PIC", ";", "break", ";", "case", "CM_LARGE", ":", "case", "CM_LARGE_PIC", ":", "if", "(", "flag_pic", ")", "tilegx_cmodel", "=", "CM_LARGE_PIC", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "tilegx_cmodel", "=", "flag_pic", "?", "CM_SMALL_PIC", ":", "CM_SMALL", ";", "if", "(", "flag_modulo_sched", ")", "flag_resched_modulo_sched", "=", "1", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "." ]

[ "tilegx", "1" ]

[]

[ "<s>", "void", "MOSAsmPrinter", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "{", "if", "(", "!", "InstLowering", ".", "lowerOperand", "(", "MO", ",", "MCOp", ")", ")", "llvm_unreachable", "(", "\"Failed to lower operand.\"", ")", ";", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "MOS", "MOS", "\"Failed to lower operand.\"" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isLegalRegOperand", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "MCOperandInfo", "&", "OpInfo", ",", "const", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "return", "false", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Reg", ")", "?", "MRI", ".", "getRegClass", "(", "Reg", ")", ":", "RI", ".", "getPhysRegClass", "(", "Reg", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "MRI", ".", "getTargetRegisterInfo", "(", ")", ")", ";", "RC", "=", "TRI", "->", "getSubRegClass", "(", "RC", ",", "MO", ".", "getSubReg", "(", ")", ")", ";", "return", "RI", ".", "getCommonSubClass", "(", "RC", ",", "RI", ".", "getRegClass", "(", "OpInfo", ".", "RegClass", ")", ")", "==", "RC", ";", "}", "</s>" ]

[ "Check", "if", "MO", "(", "a", "register", "operand", ")", "is", "a", "legal", "register", "for", "the", "given", "operand", "description", "." ]

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

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "TBB", "=", "nullptr", ";", "FBB", "=", "nullptr", ";", "MachineBasicBlock", "::", "instr_iterator", "I", "=", "MBB", ".", "instr_end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "instr_begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "while", "(", "isPredicated", "(", "*", "I", ")", "||", "I", "->", "isTerminator", "(", ")", "||", "I", "->", "isDebugValue", "(", ")", ")", "{", "bool", "CantAnalyze", "=", "false", ";", "while", "(", "I", "->", "isDebugInstr", "(", ")", "||", "!", "I", "->", "isTerminator", "(", ")", "||", "isSpeculationBarrierEndBBOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "I", "==", "MBB", ".", "instr_begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "}", "if", "(", "isIndirectBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "isJumpTableBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "CantAnalyze", "=", "true", ";", "}", "else", "if", "(", "isUncondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "}", "else", "if", "(", "isCondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "!", "Cond", ".", "empty", "(", ")", ")", "return", "true", ";", "assert", "(", "!", "FBB", "&&", "\"FBB should have been null.\"", ")", ";", "FBB", "=", "TBB", ";", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "1", ")", ")", ";", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "2", ")", ")", ";", "}", "else", "if", "(", "I", "->", "isReturn", "(", ")", ")", "{", "CantAnalyze", "=", "true", ";", "}", "else", "{", "return", "true", ";", "}", "if", "(", "!", "isPredicated", "(", "*", "I", ")", "&&", "(", "isUncondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "isIndirectBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "isJumpTableBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "I", "->", "isReturn", "(", ")", ")", ")", "{", "Cond", ".", "clear", "(", ")", ";", "FBB", "=", "nullptr", ";", "if", "(", "AllowModify", ")", "{", "MachineBasicBlock", "::", "iterator", "DI", "=", "std", "::", "next", "(", "I", ")", ";", "while", "(", "DI", "!=", "MBB", ".", "instr_end", "(", ")", ")", "{", "MachineInstr", "&", "InstToDelete", "=", "*", "DI", ";", "++", "DI", ";", "if", "(", "isSpeculationBarrierEndBBOpcode", "(", "InstToDelete", ".", "getOpcode", "(", ")", ")", ")", "continue", ";", "InstToDelete", ".", "eraseFromParent", "(", ")", ";", "}", "}", "}", "if", "(", "CantAnalyze", ")", "{", "if", "(", "AllowModify", "&&", "!", "isPredicated", "(", "MBB", ".", "back", "(", ")", ")", "&&", "isUncondBranchOpcode", "(", "MBB", ".", "back", "(", ")", ".", "getOpcode", "(", ")", ")", "&&", "TBB", "&&", "MBB", ".", "isLayoutSuccessor", "(", "TBB", ")", ")", "removeBranch", "(", "MBB", ")", ";", "return", "true", ";", "}", "if", "(", "I", "==", "MBB", ".", "instr_begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "\"FBB should have been null.\"", "0", "1", "2" ]

[]

[ "<s>", "unsigned", "ARMFastISel", "::", "fastEmitInst_r", "(", "unsigned", "MachineInstOpcode", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Op0", ")", "{", "Register", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "const", "MCInstrDesc", "&", "II", "=", "TII", ".", "get", "(", "MachineInstOpcode", ")", ";", "Op0", "=", "constrainOperandRegClass", "(", "II", ",", "Op0", ",", "1", ")", ";", "if", "(", "II", ".", "getNumDefs", "(", ")", ">=", "1", ")", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ",", "ResultReg", ")", ".", "addReg", "(", "Op0", ")", ")", ";", "}", "else", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ")", ".", "addReg", "(", "Op0", ")", ")", ";", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "II", ".", "ImplicitDefs", "[", "0", "]", ")", ")", ";", "}", "return", "ResultReg", ";", "}", "</s>" ]

[ "Emit", "a", "MachineInstr", "with", "one", "register", "operand", "and", "a", "result", "register", "in", "the", "given", "register", "class", "." ]

[ "ARM", "ARM", "1", "1", "0" ]

[]

[ "<s>", "Cpu0TargetLowering", "::", "ConstraintType", "Cpu0TargetLowering", "::", "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", "." ]

[ "Cpu0", "Cpu0", "Cpu0", "1", "0" ]

[]

[ "<s>", "static", "rtx", "avr_addr_space_convert", "(", "rtx", "src", ",", "tree", "type_from", ",", "tree", "type_to", ")", "{", "addr_space_t", "as_from", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "type_from", ")", ")", ";", "addr_space_t", "as_to", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "type_to", ")", ")", ";", "if", "(", "avr_log", ".", "progmem", ")", "avr_edump", "(", "\"\\n%!: op = %r\\nfrom = %t\\nto = %t\\n\"", ",", "src", ",", "type_from", ",", "type_to", ")", ";", "if", "(", "as_from", "!=", "ADDR_SPACE_MEMX", "&&", "as_to", "==", "ADDR_SPACE_MEMX", ")", "{", "int", "msb", ";", "rtx", "sym", "=", "src", ";", "rtx", "reg", "=", "gen_reg_rtx", "(", "PSImode", ")", ";", "while", "(", "CONST", "==", "GET_CODE", "(", "sym", ")", "||", "PLUS", "==", "GET_CODE", "(", "sym", ")", ")", "sym", "=", "XEXP", "(", "sym", ",", "0", ")", ";", "if", "(", "SYMBOL_REF", "==", "GET_CODE", "(", "sym", ")", "&&", "ADDR_SPACE_FLASH", "==", "AVR_SYMBOL_GET_ADDR_SPACE", "(", "sym", ")", ")", "{", "as_from", "=", "ADDR_SPACE_FLASH", ";", "}", "msb", "=", "ADDR_SPACE_GENERIC_P", "(", "as_from", ")", "?", "0x80", ":", "avr_addrspace", "[", "as_from", "]", ".", "segment", ";", "src", "=", "force_reg", "(", "Pmode", ",", "src", ")", ";", "emit_insn", "(", "msb", "==", "0", "?", "gen_zero_extendhipsi2", "(", "reg", ",", "src", ")", ":", "gen_n_extendhipsi2", "(", "reg", ",", "gen_int_mode", "(", "msb", ",", "QImode", ")", ",", "src", ")", ")", ";", "return", "reg", ";", "}", "if", "(", "as_from", "==", "ADDR_SPACE_MEMX", "&&", "as_to", "!=", "ADDR_SPACE_MEMX", ")", "{", "rtx", "new_src", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "src", "=", "force_reg", "(", "PSImode", ",", "src", ")", ";", "emit_move_insn", "(", "new_src", ",", "simplify_gen_subreg", "(", "Pmode", ",", "src", ",", "PSImode", ",", "0", ")", ")", ";", "return", "new_src", ";", "}", "return", "src", ";", "}", "</s>" ]

[ "Implement", "`", "TARGET_ADDR_SPACE_CONVERT", "'", "." ]

[ "avr", "\"\\n%!: op = %r\\nfrom = %t\\nto = %t\\n\"", "0", "0x80", "0", "0" ]

[]

[ "<s>", "void", "X86DAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "OptForSize", "=", "MF", "->", "getFunction", "(", ")", "->", "optForSize", "(", ")", ";", "OptForMinSize", "=", "MF", "->", "getFunction", "(", ")", "->", "optForMinSize", "(", ")", ";", "assert", "(", "(", "!", "OptForMinSize", "||", "OptForSize", ")", "&&", "\"OptForMinSize implies OptForSize\"", ")", ";", "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", "(", ")", ".", "isPositionIndependent", "(", ")", ")", ")", ")", ")", "{", "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", "*", ">", "(", "TLI", ")", ";", "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", "\"OptForMinSize implies OptForSize\"", "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", "AArch64TargetLowering", "::", "enableAggressiveFMAFusion", "(", "EVT", "VT", ")", "const", "{", "return", "Subtarget", "->", "hasAggressiveFMA", "(", ")", "&&", "VT", ".", "isFloatingPoint", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "target", "always", "benefits", "from", "combining", "into", "FMA", "for", "a", "given", "value", "type", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "const", "char", "*", "SPUTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "if", "(", "node_names", ".", "empty", "(", ")", ")", "{", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "RET_FLAG", "]", "=", "\"SPUISD::RET_FLAG\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "Hi", "]", "=", "\"SPUISD::Hi\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "Lo", "]", "=", "\"SPUISD::Lo\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "PCRelAddr", "]", "=", "\"SPUISD::PCRelAddr\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "AFormAddr", "]", "=", "\"SPUISD::AFormAddr\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "IndirectAddr", "]", "=", "\"SPUISD::IndirectAddr\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "LDRESULT", "]", "=", "\"SPUISD::LDRESULT\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "CALL", "]", "=", "\"SPUISD::CALL\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "SHUFB", "]", "=", "\"SPUISD::SHUFB\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "SHUFFLE_MASK", "]", "=", "\"SPUISD::SHUFFLE_MASK\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "CNTB", "]", "=", "\"SPUISD::CNTB\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "PREFSLOT2VEC", "]", "=", "\"SPUISD::PREFSLOT2VEC\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "VEC2PREFSLOT", "]", "=", "\"SPUISD::VEC2PREFSLOT\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "SHL_BITS", "]", "=", "\"SPUISD::SHL_BITS\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "SHL_BYTES", "]", "=", "\"SPUISD::SHL_BYTES\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "VEC_ROTL", "]", "=", "\"SPUISD::VEC_ROTL\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "VEC_ROTR", "]", "=", "\"SPUISD::VEC_ROTR\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "ROTBYTES_LEFT", "]", "=", "\"SPUISD::ROTBYTES_LEFT\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "ROTBYTES_LEFT_BITS", "]", "=", "\"SPUISD::ROTBYTES_LEFT_BITS\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "SELECT_MASK", "]", "=", "\"SPUISD::SELECT_MASK\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "SELB", "]", "=", "\"SPUISD::SELB\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "ADD64_MARKER", "]", "=", "\"SPUISD::ADD64_MARKER\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "SUB64_MARKER", "]", "=", "\"SPUISD::SUB64_MARKER\"", ";", "node_names", "[", "(", "unsigned", ")", "SPUISD", "::", "MUL64_MARKER", "]", "=", "\"SPUISD::MUL64_MARKER\"", ";", "}", "std", "::", "map", "<", "unsigned", ",", "const", "char", "*", ">", "::", "iterator", "i", "=", "node_names", ".", "find", "(", "Opcode", ")", ";", "return", "(", "(", "i", "!=", "node_names", ".", "end", "(", ")", ")", "?", "i", "->", "second", ":", "0", ")", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "SPUISD::RET_FLAG", "\"SPUISD::RET_FLAG\"", "SPUISD::Hi", "\"SPUISD::Hi\"", "SPUISD::Lo", "\"SPUISD::Lo\"", "SPUISD::PCRelAddr", "\"SPUISD::PCRelAddr\"", "SPUISD::AFormAddr", "\"SPUISD::AFormAddr\"", "SPUISD::IndirectAddr", "\"SPUISD::IndirectAddr\"", "SPUISD::LDRESULT", "\"SPUISD::LDRESULT\"", "SPUISD::CALL", "\"SPUISD::CALL\"", "SPUISD::SHUFB", "\"SPUISD::SHUFB\"", "SPUISD::SHUFFLE_MASK", "\"SPUISD::SHUFFLE_MASK\"", "SPUISD::CNTB", "\"SPUISD::CNTB\"", "SPUISD::PREFSLOT2VEC", "\"SPUISD::PREFSLOT2VEC\"", "SPUISD::VEC2PREFSLOT", "\"SPUISD::VEC2PREFSLOT\"", "SPUISD::SHL_BITS", "\"SPUISD::SHL_BITS\"", "SPUISD::SHL_BYTES", "\"SPUISD::SHL_BYTES\"", "SPUISD::VEC_ROTL", "\"SPUISD::VEC_ROTL\"", "SPUISD::VEC_ROTR", "\"SPUISD::VEC_ROTR\"", "SPUISD::ROTBYTES_LEFT", "\"SPUISD::ROTBYTES_LEFT\"", "SPUISD::ROTBYTES_LEFT_BITS", "\"SPUISD::ROTBYTES_LEFT_BITS\"", "SPUISD::SELECT_MASK", "\"SPUISD::SELECT_MASK\"", "SPUISD::SELB", "\"SPUISD::SELB\"", "SPUISD::ADD64_MARKER", "\"SPUISD::ADD64_MARKER\"", "SPUISD::SUB64_MARKER", "\"SPUISD::SUB64_MARKER\"", "SPUISD::MUL64_MARKER", "\"SPUISD::MUL64_MARKER\"", "0" ]

[]

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

[ "Generate", "code", "to", "move", "an", "SImode", "value", "." ]

[ "rl78", "0", "0", "0", "2", "1", "1", "1", "16", "0", "1", "16", "16", "1", "0", "1", "2", "0", "1", "2", "4", "3", "5", "2", "4", "3", "5" ]

[]

[ "<s>", "bool", "WebAssemblyRegNumbering", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Register Numbering **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "WebAssemblyFunctionInfo", "&", "MFI", "=", "*", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "MFI", ".", "initWARegs", "(", ")", ";", "MachineBasicBlock", "&", "EntryMBB", "=", "MF", ".", "front", "(", ")", ";", "for", "(", "MachineInstr", "&", "MI", ":", "EntryMBB", ")", "{", "if", "(", "!", "WebAssembly", "::", "isArgument", "(", "MI", ")", ")", "break", ";", "int64_t", "Imm", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Arg VReg \"", "<<", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "<<", "\" -> WAReg \"", "<<", "Imm", "<<", "\"\\n\"", ")", ";", "MFI", ".", "setWAReg", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "Imm", ")", ";", "}", "unsigned", "NumVRegs", "=", "MF", ".", "getRegInfo", "(", ")", ".", "getNumVirtRegs", "(", ")", ";", "unsigned", "NumStackRegs", "=", "0", ";", "unsigned", "CurReg", "=", "MFI", ".", "getParams", "(", ")", ".", "size", "(", ")", ";", "for", "(", "unsigned", "VRegIdx", "=", "0", ";", "VRegIdx", "<", "NumVRegs", ";", "++", "VRegIdx", ")", "{", "unsigned", "VReg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "VRegIdx", ")", ";", "if", "(", "MRI", ".", "use_empty", "(", "VReg", ")", ")", "continue", ";", "if", "(", "MFI", ".", "isVRegStackified", "(", "VReg", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"VReg \"", "<<", "VReg", "<<", "\" -> WAReg \"", "<<", "(", "INT32_MIN", "|", "NumStackRegs", ")", "<<", "\"\\n\"", ")", ";", "MFI", ".", "setWAReg", "(", "VReg", ",", "INT32_MIN", "|", "NumStackRegs", "++", ")", ";", "continue", ";", "}", "if", "(", "MFI", ".", "getWAReg", "(", "VReg", ")", "==", "WebAssemblyFunctionInfo", "::", "UnusedReg", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"VReg \"", "<<", "VReg", "<<", "\" -> WAReg \"", "<<", "CurReg", "<<", "\"\\n\"", ")", ";", "MFI", ".", "setWAReg", "(", "VReg", ",", "CurReg", "++", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Register Numbering **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "WebAssembly::isArgument", "1", "\"Arg VReg \"", "0", "\" -> WAReg \"", "\"\\n\"", "0", "0", "0", "\"VReg \"", "\" -> WAReg \"", "\"\\n\"", "WebAssembly", "\"VReg \"", "\" -> WAReg \"", "\"\\n\"" ]

[]

[ "<s>", "Align", "getStackAlignment", "(", ")", "const", "{", "return", "stackAlignment", ";", "}", "</s>" ]

[ "Returns", "the", "minimum", "alignment", "known", "to", "hold", "of", "the", "stack", "frame", "on", "entry", "to", "the", "function", "and", "which", "must", "be", "maintained", "by", "every", "function", "for", "this", "subtarget", "." ]

[ "X86" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 Atom LEA Fixup\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Atom LEA Fixup\"" ]

[]

[ "<s>", "static", "rtx", "function_arg_union_value", "(", "int", "size", ",", "enum", "machine_mode", "mode", ",", "int", "slotno", ",", "int", "regno", ")", "{", "int", "nwords", "=", "ROUND_ADVANCE", "(", "size", ")", ",", "i", ";", "rtx", "regs", ";", "if", "(", "nwords", "==", "0", ")", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "if", "(", "slotno", "==", "SPARC_INT_ARG_MAX", "-", "1", ")", "nwords", "=", "1", ";", "regs", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "nwords", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nwords", ";", "i", "++", ")", "{", "XVECEXP", "(", "regs", ",", "0", ",", "i", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "word_mode", ",", "regno", ")", ",", "GEN_INT", "(", "UNITS_PER_WORD", "*", "i", ")", ")", ";", "regno", "++", ";", "}", "return", "regs", ";", "}", "</s>" ]

[ "Used", "by", "function_arg", "and", "sparc_function_value_1", "to", "implement", "the", "conventions", "of", "the", "64-bit", "ABI", "for", "passing", "and", "returning", "unions", ".", "Return", "an", "expression", "valid", "as", "a", "return", "value", "for", "the", "FUNCTION_ARG", "and", "TARGET_FUNCTION_VALUE", ".", "SIZE", "is", "the", "size", "in", "bytes", "of", "the", "union", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "REGNO", "is", "the", "hard", "register", "the", "union", "will", "be", "passed", "in", "." ]

[ "sparc", "0", "1", "1", "0", "0" ]

[]

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

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

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "AMDGPUPromoteAlloca", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "if", "(", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ")", "TM", "=", "&", "TPC", "->", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "else", "return", "false", ";", "const", "Triple", "&", "TT", "=", "TM", "->", "getTargetTriple", "(", ")", ";", "IsAMDGCN", "=", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ";", "IsAMDHSA", "=", "TT", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "AMDGPUSubtarget", "::", "get", "(", "*", "TM", ",", "F", ")", ";", "if", "(", "!", "ST", ".", "isPromoteAllocaEnabled", "(", ")", ")", "return", "false", ";", "bool", "SufficientLDS", "=", "hasSufficientLocalMem", "(", "F", ")", ";", "bool", "Changed", "=", "false", ";", "BasicBlock", "&", "EntryBB", "=", "*", "F", ".", "begin", "(", ")", ";", "for", "(", "auto", "I", "=", "EntryBB", ".", "begin", "(", ")", ",", "E", "=", "EntryBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "AllocaInst", "*", "AI", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "I", ")", ";", "++", "I", ";", "if", "(", "AI", ")", "Changed", "|=", "handleAlloca", "(", "*", "AI", ",", "SufficientLDS", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "rtx_insn", "*", "s390_emit_call", "(", "rtx", "addr_location", ",", "rtx", "tls_call", ",", "rtx", "result_reg", ",", "rtx", "retaddr_reg", ")", "{", "bool", "plt_call", "=", "false", ";", "rtx_insn", "*", "insn", ";", "rtx", "call", ";", "rtx", "clobber", ";", "rtvec", "vec", ";", "if", "(", "GET_CODE", "(", "addr_location", ")", "==", "SYMBOL_REF", ")", "{", "if", "(", "flag_pic", "&&", "!", "SYMBOL_REF_LOCAL_P", "(", "addr_location", ")", ")", "{", "if", "(", "TARGET_64BIT", "||", "retaddr_reg", "!=", "NULL_RTX", ")", "{", "addr_location", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "addr_location", ")", ",", "UNSPEC_PLT", ")", ";", "addr_location", "=", "gen_rtx_CONST", "(", "Pmode", ",", "addr_location", ")", ";", "plt_call", "=", "true", ";", "}", "else", "addr_location", "=", "force_reg", "(", "Pmode", ",", "addr_location", ")", ";", "}", "if", "(", "!", "TARGET_SMALL_EXEC", "&&", "!", "TARGET_CPU_ZARCH", ")", "{", "if", "(", "flag_pic", ")", "addr_location", "=", "legitimize_pic_address", "(", "addr_location", ",", "0", ")", ";", "else", "addr_location", "=", "force_reg", "(", "Pmode", ",", "addr_location", ")", ";", "}", "}", "if", "(", "retaddr_reg", "==", "NULL_RTX", "&&", "GET_CODE", "(", "addr_location", ")", "!=", "SYMBOL_REF", "&&", "!", "plt_call", ")", "{", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "SIBCALL_REGNUM", ")", ",", "addr_location", ")", ";", "addr_location", "=", "gen_rtx_REG", "(", "Pmode", ",", "SIBCALL_REGNUM", ")", ";", "}", "addr_location", "=", "gen_rtx_MEM", "(", "QImode", ",", "addr_location", ")", ";", "call", "=", "gen_rtx_CALL", "(", "VOIDmode", ",", "addr_location", ",", "const0_rtx", ")", ";", "if", "(", "result_reg", "!=", "NULL_RTX", ")", "call", "=", "gen_rtx_SET", "(", "result_reg", ",", "call", ")", ";", "if", "(", "retaddr_reg", "!=", "NULL_RTX", ")", "{", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "retaddr_reg", ")", ";", "if", "(", "tls_call", "!=", "NULL_RTX", ")", "vec", "=", "gen_rtvec", "(", "3", ",", "call", ",", "clobber", ",", "gen_rtx_USE", "(", "VOIDmode", ",", "tls_call", ")", ")", ";", "else", "vec", "=", "gen_rtvec", "(", "2", ",", "call", ",", "clobber", ")", ";", "call", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "vec", ")", ";", "}", "insn", "=", "emit_call_insn", "(", "call", ")", ";", "if", "(", "(", "!", "TARGET_64BIT", "&&", "plt_call", ")", "||", "tls_call", "!=", "NULL_RTX", ")", "{", "gcc_assert", "(", "retaddr_reg", "!=", "NULL_RTX", ")", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "12", ")", ")", ";", "}", "return", "insn", ";", "}", "</s>" ]

[ "This", "function", "is", "used", "by", "the", "call", "expanders", "of", "the", "machine", "description", ".", "It", "emits", "the", "call", "insn", "itself", "together", "with", "the", "necessary", "operations", "to", "adjust", "the", "target", "address", "and", "returns", "the", "emitted", "insn", ".", "ADDR_LOCATION", "is", "the", "target", "address", "rtx", "TLS_CALL", "the", "location", "of", "the", "thread-local", "symbol", "RESULT_REG", "the", "register", "where", "the", "result", "of", "the", "call", "should", "be", "stored", "RETADDR_REG", "the", "register", "where", "the", "return", "address", "should", "be", "stored", "If", "this", "parameter", "is", "NULL_RTX", "the", "call", "is", "considered", "to", "be", "a", "sibling", "call", "." ]

[ "s390", "1", "0", "3", "2", "12" ]

[]

[ "<s>", "void", "TeeRISCInstrInfo", "::", "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", "(", ")", ";", "if", "(", "RC", "==", "&", "TeeRISC", "::", "IntRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "TeeRISC", "::", "LD", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "}", "</s>" ]

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

[ "TeeRISC", "TeeRISC", "TeeRISC::IntRegsRegClass", "TeeRISC::LD", "0", "\"Can't load this register from stack slot\"" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "&&", "!", "Outs", ".", "empty", "(", ")", ")", "report_fatal_error", "(", "\"ISRs cannot return any value\"", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "AnalyzeReturnValues", "(", "CCInfo", ",", "RVLocs", ",", "Outs", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "MSP430MachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "FuncInfo", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "llvm_unreachable", "(", "\"sret virtual register not created in entry block\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "unsigned", "R12", "=", "MSP430", "::", "R12", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "R12", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "R12", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ")", ";", "}", "unsigned", "Opc", "=", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "?", "MSP430ISD", "::", "RETI_FLAG", ":", "MSP430ISD", "::", "RET_FLAG", ")", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "ISD::OutputArg", "16", "MSP430", "\"ISRs cannot return any value\"", "4", "1", "0", "\"Can only return in registers!\"", "1", "MSP430", "MSP430", "\"sret virtual register not created in entry block\"", "MSP430::R12", "1", "MSP430", "MSP430ISD::RETI_FLAG", "MSP430ISD::RET_FLAG", "0", "MVT::Other" ]

[]

[ "<s>", "MachineInstr", "*", "SIInstrInfo", "::", "commuteInstructionImpl", "(", "MachineInstr", "*", "MI", ",", "bool", "NewMI", ",", "unsigned", "OpIdx0", ",", "unsigned", "OpIdx1", ")", "const", "{", "int", "CommutedOpcode", "=", "commuteOpcode", "(", "*", "MI", ")", ";", "if", "(", "CommutedOpcode", "==", "-", "1", ")", "return", "nullptr", ";", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "MachineOperand", "&", "Src0", "=", "MI", "->", "getOperand", "(", "Src0Idx", ")", ";", "if", "(", "!", "Src0", ".", "isReg", "(", ")", ")", "return", "nullptr", ";", "int", "Src1Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "if", "(", "(", "OpIdx0", "!=", "static_cast", "<", "unsigned", ">", "(", "Src0Idx", ")", "||", "OpIdx1", "!=", "static_cast", "<", "unsigned", ">", "(", "Src1Idx", ")", ")", "&&", "(", "OpIdx0", "!=", "static_cast", "<", "unsigned", ">", "(", "Src1Idx", ")", "||", "OpIdx1", "!=", "static_cast", "<", "unsigned", ">", "(", "Src0Idx", ")", ")", ")", "return", "nullptr", ";", "MachineOperand", "&", "Src1", "=", "MI", "->", "getOperand", "(", "Src1Idx", ")", ";", "if", "(", "isVOP2", "(", "*", "MI", ")", "&&", "(", "!", "isOperandLegal", "(", "MI", ",", "Src0Idx", ",", "&", "Src1", ")", "||", "!", "isOperandLegal", "(", "MI", ",", "Src1Idx", ",", "&", "Src0", ")", ")", ")", "{", "return", "nullptr", ";", "}", "if", "(", "!", "Src1", ".", "isReg", "(", ")", ")", "{", "if", "(", "NewMI", "||", "!", "Src1", ".", "isImm", "(", ")", "||", "(", "!", "isVOP2", "(", "*", "MI", ")", "&&", "!", "isVOP3", "(", "*", "MI", ")", ")", ")", "{", "return", "nullptr", ";", "}", "if", "(", "MachineOperand", "*", "Src0Mods", "=", "getNamedOperand", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src0_modifiers", ")", ")", "{", "MachineOperand", "*", "Src1Mods", "=", "getNamedOperand", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src1_modifiers", ")", ";", "int", "Src0ModsVal", "=", "Src0Mods", "->", "getImm", "(", ")", ";", "if", "(", "!", "Src1Mods", "&&", "Src0ModsVal", "!=", "0", ")", "return", "nullptr", ";", "int", "Src1ModsVal", "=", "Src1Mods", "->", "getImm", "(", ")", ";", "assert", "(", "(", "Src1ModsVal", "==", "0", ")", "&&", "\"Not expecting modifiers with immediates\"", ")", ";", "Src1Mods", "->", "setImm", "(", "Src0ModsVal", ")", ";", "Src0Mods", "->", "setImm", "(", "Src1ModsVal", ")", ";", "}", "unsigned", "Reg", "=", "Src0", ".", "getReg", "(", ")", ";", "unsigned", "SubReg", "=", "Src0", ".", "getSubReg", "(", ")", ";", "if", "(", "Src1", ".", "isImm", "(", ")", ")", "Src0", ".", "ChangeToImmediate", "(", "Src1", ".", "getImm", "(", ")", ")", ";", "else", "llvm_unreachable", "(", "\"Should only have immediates\"", ")", ";", "Src1", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "Src1", ".", "setSubReg", "(", "SubReg", ")", ";", "}", "else", "{", "MI", "=", "TargetInstrInfo", "::", "commuteInstructionImpl", "(", "MI", ",", "NewMI", ",", "OpIdx0", ",", "OpIdx1", ")", ";", "}", "if", "(", "MI", ")", "MI", "->", "setDesc", "(", "get", "(", "CommutedOpcode", ")", ")", ";", "return", "MI", ";", "}", "</s>" ]

[ "Commutes", "the", "operands", "in", "the", "given", "instruction", "by", "changing", "the", "operands", "order", "and/or", "changing", "the", "instruction", "'s", "opcode", "and/or", "the", "immediate", "value", "operand", "." ]

[ "AMDGPU", "SI", "1", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "0", "0", "\"Not expecting modifiers with immediates\"", "\"Should only have immediates\"" ]

[]

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

[ "Return", "the", "register", "storing", "the", "value", "of", "the", "global", "offset", "table", "." ]

[ "tilegx" ]

[]

[ "<s>", "static", "inline", "bool", "is_interrupt_func", "(", "const_tree", "decl", ")", "{", "return", "has_func_attr", "(", "decl", ",", "\"interrupt\"", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "provided", "function", "has", "the", "``", "interrupt", "''", "attribute", "." ]

[ "rx", "\"interrupt\"" ]

[]

[ "<s>", "bool", "mprocFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

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

[ "mproc", "mproc" ]

[]

[ "<s>", "bool", "Mips16TargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", ",", "unsigned", ",", "bool", "*", "Fast", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "arm_fusion_enabled_p", "(", "tune_params", "::", "fuse_ops", "op", ")", "{", "return", "current_tune", "->", "fusible_ops", "&", "op", ";", "}", "</s>" ]

[ "Return", "true", "iff", "the", "instruction", "fusion", "described", "by", "OP", "is", "enabled", "." ]

[ "arm" ]

[]

[ "<s>", "int", "mips_class_max_nregs", "(", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", ")", "{", "int", "size", ";", "HARD_REG_SET", "left", ";", "size", "=", "0x8000", ";", "COPY_HARD_REG_SET", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "rclass", "]", ")", ";", "if", "(", "hard_reg_set_intersect_p", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "ST_REGS", "]", ")", ")", "{", "if", "(", "HARD_REGNO_MODE_OK", "(", "ST_REG_FIRST", ",", "mode", ")", ")", "size", "=", "MIN", "(", "size", ",", "4", ")", ";", "AND_COMPL_HARD_REG_SET", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "ST_REGS", "]", ")", ";", "}", "if", "(", "hard_reg_set_intersect_p", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "FP_REGS", "]", ")", ")", "{", "if", "(", "HARD_REGNO_MODE_OK", "(", "FP_REG_FIRST", ",", "mode", ")", ")", "{", "if", "(", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", ")", "size", "=", "MIN", "(", "size", ",", "UNITS_PER_MSA_REG", ")", ";", "else", "size", "=", "MIN", "(", "size", ",", "UNITS_PER_FPREG", ")", ";", "}", "AND_COMPL_HARD_REG_SET", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "FP_REGS", "]", ")", ";", "}", "if", "(", "!", "hard_reg_set_empty_p", "(", "left", ")", ")", "size", "=", "MIN", "(", "size", ",", "UNITS_PER_WORD", ")", ";", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "size", "-", "1", ")", "/", "size", ";", "}", "</s>" ]

[ "Implement", "CLASS_MAX_NREGS", ".", "Usually", "all", "registers", "are", "word-sized", ".", "The", "only", "supported", "exception", "is", "-mgp64", "-msingle-float", ",", "which", "has", "64-bit", "words", "but", "32-bit", "float", "registers", ".", "A", "word-based", "calculation", "is", "correct", "even", "in", "that", "case", ",", "since", "-msingle-float", "disallows", "multi-FPR", "values", ".", "The", "FP", "status", "registers", "are", "an", "exception", "to", "this", "rule", ".", "They", "are", "always", "4", "bytes", "wide", "as", "they", "only", "hold", "condition", "code", "modes", ",", "and", "CCmode", "is", "always", "considered", "to", "be", "4", "bytes", "wide", "." ]

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

[]

[ "<s>", "int", "i386_pe_reloc_rw_mask", "(", "void", ")", "{", "return", "0", ";", "}", "</s>" ]

[ "Local", "and", "global", "relocs", "can", "be", "placed", "always", "into", "readonly", "memory", "for", "memory", "for", "PE-COFF", "targets", "." ]

[ "i386", "0" ]

[]

[ "<s>", "void", "LC2200FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "bool", "hasFramePointer", "=", "hasFP", "(", "MF", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "LC2200RegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "const", "LC2200InstrInfo", "*", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "Register", "FPReg", "=", "LC2200", "::", "fp", ";", "Register", "SPReg", "=", "LC2200", "::", "sp", ";", "auto", "LastFrameDestroy", "=", "std", "::", "prev", "(", "MBBI", ",", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "hasFramePointer", ")", "StackSize", "++", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "assert", "(", "hasFP", "(", "MF", ")", "&&", "\"frame pointer should not have been eliminated\"", ")", ";", "BuildMI", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "TII", "->", "get", "(", "LC2200", "::", "ADD", ")", ")", ".", "addReg", "(", "LC2200", "::", "sp", ")", ".", "addReg", "(", "LC2200", "::", "fp", ")", ".", "addReg", "(", "LC2200", "::", "zero", ")", ";", "}", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "for", "(", "const", "auto", "&", "Entry", ":", "CSI", ")", "{", "Register", "Reg", "=", "Entry", ".", "getReg", "(", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createRestore", "(", "nullptr", ",", "RI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "if", "(", "hasFramePointer", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "LC2200", "::", "LW", ")", ")", ".", "addReg", "(", "LC2200", "::", "fp", ")", ".", "addReg", "(", "LC2200", "::", "fp", ")", ".", "addImm", "(", "StackSize", "-", "1", ")", ";", "}", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "StackSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaOffset", "(", "nullptr", ",", "0", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "</s>" ]

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

[ "LC2200", "LC2200", "LC2200", "LC2200", "LC2200::fp", "LC2200::sp", "\"frame pointer should not have been eliminated\"", "LC2200::ADD", "LC2200::sp", "LC2200::fp", "LC2200::zero", "LC2200::LW", "LC2200::fp", "LC2200::fp", "1", "0" ]

[]

[ "<s>", "void", "SICMCInstLower", "::", "Initialize", "(", "MCContext", "*", "C", ")", "{", "Ctx", "=", "C", ";", "}", "</s>" ]

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

[ "SIC", "SIC" ]

[]

[ "<s>", "static", "bool", "rs6000_use_blocks_for_constant_p", "(", "machine_mode", "mode", ",", "const_rtx", "x", ")", "{", "return", "!", "ASM_OUTPUT_SPECIAL_POOL_ENTRY_P", "(", "x", ",", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_USE_BLOCKS_FOR_CONSTANT_P", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this!\"", ")", ";", "case", "ISD", "::", "BITCAST", ":", "Res", "=", "ExpandBITCAST", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "Res", "=", "Expand64BitShift", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "ReplaceREADCYCLECOUNTER", "(", "N", ",", "Results", ",", "DAG", ",", "Subtarget", ")", ";", "return", ";", "}", "if", "(", "Res", ".", "getNode", "(", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"Don't know how to custom expand this!\"", "ISD::BITCAST", "ISD::SRL", "ISD::SRA", "ISD::READCYCLECOUNTER" ]

[]

[ "<s>", "static", "int", "rs6000_arg_partial_bytes", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "bool", "passed_in_gprs", "=", "true", ";", "int", "ret", "=", "0", ";", "int", "align_words", ";", "machine_mode", "elt_mode", ";", "int", "n_elts", ";", "rs6000_discover_homogeneous_aggregate", "(", "mode", ",", "type", ",", "&", "elt_mode", ",", "&", "n_elts", ")", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", ")", "return", "0", ";", "if", "(", "USE_ALTIVEC_FOR_ARG_P", "(", "cum", ",", "elt_mode", ",", "named", ")", ")", "{", "if", "(", "TARGET_64BIT", "&&", "!", "cum", "->", "prototype", "&&", "(", "!", "cum", "->", "libcall", "||", "!", "FLOAT128_VECTOR_P", "(", "elt_mode", ")", ")", ")", "return", "0", ";", "passed_in_gprs", "=", "false", ";", "if", "(", "cum", "->", "vregno", "+", "n_elts", ">", "ALTIVEC_ARG_MAX_REG", "+", "1", ")", "ret", "=", "(", "ALTIVEC_ARG_MAX_REG", "+", "1", "-", "cum", "->", "vregno", ")", "*", "16", ";", "}", "if", "(", "TARGET_MACHO", "&&", "rs6000_darwin64_struct_check_p", "(", "mode", ",", "type", ")", ")", "return", "0", ";", "align_words", "=", "rs6000_parm_start", "(", "mode", ",", "type", ",", "cum", "->", "words", ")", ";", "if", "(", "USE_FP_FOR_ARG_P", "(", "cum", ",", "elt_mode", ")", ")", "{", "unsigned", "long", "n_fpreg", "=", "(", "GET_MODE_SIZE", "(", "elt_mode", ")", "+", "7", ")", ">>", "3", ";", "if", "(", "type", "&&", "(", "cum", "->", "nargs_prototype", "<=", "0", "||", "(", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "&&", "TARGET_XL_COMPAT", "&&", "align_words", ">=", "GP_ARG_NUM_REG", ")", ")", ")", "return", "0", ";", "passed_in_gprs", "=", "false", ";", "if", "(", "cum", "->", "fregno", "+", "n_elts", "*", "n_fpreg", ">", "FP_ARG_MAX_REG", "+", "1", ")", "{", "int", "fpr", "=", "(", "(", "FP_ARG_MAX_REG", "+", "1", "-", "cum", "->", "fregno", ")", "*", "MIN", "(", "8", ",", "GET_MODE_SIZE", "(", "elt_mode", ")", ")", ")", ";", "int", "fpr_words", "=", "fpr", "/", "(", "TARGET_32BIT", "?", "4", ":", "8", ")", ";", "if", "(", "align_words", "+", "fpr_words", "<", "GP_ARG_NUM_REG", ")", "passed_in_gprs", "=", "true", ";", "else", "ret", "=", "fpr", ";", "}", "}", "if", "(", "passed_in_gprs", "&&", "align_words", "<", "GP_ARG_NUM_REG", "&&", "GP_ARG_NUM_REG", "<", "align_words", "+", "rs6000_arg_size", "(", "mode", ",", "type", ")", ")", "ret", "=", "(", "GP_ARG_NUM_REG", "-", "align_words", ")", "*", "(", "TARGET_32BIT", "?", "4", ":", "8", ")", ";", "if", "(", "ret", "!=", "0", "&&", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"rs6000_arg_partial_bytes: %d\\n\"", ",", "ret", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "For", "an", "arg", "passed", "partly", "in", "registers", "and", "partly", "in", "memory", ",", "this", "is", "the", "number", "of", "bytes", "passed", "in", "registers", ".", "For", "args", "passed", "entirely", "in", "registers", "or", "entirely", "in", "memory", ",", "zero", ".", "When", "an", "arg", "is", "described", "by", "a", "PARALLEL", ",", "perhaps", "using", "more", "than", "one", "register", "type", ",", "this", "function", "returns", "the", "number", "of", "bytes", "used", "by", "the", "first", "element", "of", "the", "PARALLEL", "." ]

[ "rs6000", "0", "0", "0", "1", "1", "16", "0", "7", "3", "0", "0", "1", "1", "8", "4", "8", "4", "8", "0", "\"rs6000_arg_partial_bytes: %d\\n\"" ]

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "classifyGlobalFunctionReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "M", ",", "GV", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "assert", "(", "!", "isTargetCOFF", "(", ")", ")", ";", "const", "Function", "*", "F", "=", "dyn_cast_or_null", "<", "Function", ">", "(", "GV", ")", ";", "if", "(", "isTargetELF", "(", ")", ")", "{", "if", "(", "is64Bit", "(", ")", "&&", "F", "&&", "(", "CallingConv", "::", "X86_RegCall", "==", "F", "->", "getCallingConv", "(", ")", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "return", "X86II", "::", "MO_PLT", ";", "}", "if", "(", "is64Bit", "(", ")", ")", "{", "if", "(", "F", "&&", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "NonLazyBind", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "</s>" ]

[ "Classify", "a", "global", "function", "reference", "for", "the", "current", "subtarget", "." ]

[ "X86", "X86", "X86II::MO_NO_FLAG", "X86", "X86II::MO_GOTPCREL", "X86II::MO_PLT", "X86II::MO_GOTPCREL", "X86II::MO_NO_FLAG", "X86II::MO_NO_FLAG" ]

[]

[ "<s>", "void", "riscv_expand_prologue", "(", "void", ")", "{", "struct", "riscv_frame_info", "*", "frame", "=", "&", "cfun", "->", "machine", "->", "frame", ";", "poly_int64", "size", "=", "frame", "->", "total_size", ";", "unsigned", "mask", "=", "frame", "->", "mask", ";", "rtx", "insn", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "constant_lower_bound", "(", "size", ")", ";", "if", "(", "cfun", "->", "machine", "->", "naked_p", ")", "return", ";", "if", "(", "riscv_use_save_libcall", "(", "frame", ")", ")", "{", "rtx", "dwarf", "=", "NULL_RTX", ";", "dwarf", "=", "riscv_adjust_libcall_cfi_prologue", "(", ")", ";", "size", "-=", "frame", "->", "save_libcall_adjustment", ";", "insn", "=", "emit_insn", "(", "riscv_gen_gpr_save_insn", "(", "frame", ")", ")", ";", "frame", "->", "mask", "=", "0", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "REG_NOTES", "(", "insn", ")", "=", "dwarf", ";", "}", "if", "(", "(", "frame", "->", "mask", "|", "frame", "->", "fmask", ")", "!=", "0", ")", "{", "HOST_WIDE_INT", "step1", "=", "riscv_first_stack_step", "(", "frame", ")", ";", "if", "(", "size", ".", "is_constant", "(", ")", ")", "step1", "=", "MIN", "(", "size", ".", "to_constant", "(", ")", ",", "step1", ")", ";", "insn", "=", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "step1", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "emit_insn", "(", "insn", ")", ")", "=", "1", ";", "size", "-=", "step1", ";", "riscv_for_each_saved_reg", "(", "size", ",", "riscv_save_reg", ",", "false", ",", "false", ")", ";", "}", "frame", "->", "mask", "=", "mask", ";", "if", "(", "frame_pointer_needed", ")", "{", "insn", "=", "gen_add3_insn", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "(", "frame", "->", "hard_frame_pointer_offset", "-", "size", ")", ".", "to_constant", "(", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "emit_insn", "(", "insn", ")", ")", "=", "1", ";", "riscv_emit_stack_tie", "(", ")", ";", "}", "if", "(", "known_gt", "(", "size", ",", "0", ")", ")", "{", "poly_int64", "scalable_frame", "(", "0", ",", "0", ")", ";", "if", "(", "!", "size", ".", "is_constant", "(", ")", ")", "{", "poly_int64", "scalable_frame", "=", "size", ";", "scalable_frame", ".", "coeffs", "[", "0", "]", "=", "size", ".", "coeffs", "[", "1", "]", ";", "riscv_v_adjust_scalable_frame", "(", "stack_pointer_rtx", ",", "scalable_frame", ",", "false", ")", ";", "size", "-=", "scalable_frame", ";", "}", "HOST_WIDE_INT", "constant_frame", "=", "size", ".", "to_constant", "(", ")", ";", "if", "(", "constant_frame", "==", "0", ")", "return", ";", "if", "(", "SMALL_OPERAND", "(", "-", "constant_frame", ")", ")", "{", "insn", "=", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "constant_frame", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "emit_insn", "(", "insn", ")", ")", "=", "1", ";", "}", "else", "{", "riscv_emit_move", "(", "RISCV_PROLOGUE_TEMP", "(", "Pmode", ")", ",", "GEN_INT", "(", "-", "constant_frame", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "RISCV_PROLOGUE_TEMP", "(", "Pmode", ")", ")", ")", ";", "insn", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "constant_frame", ")", ";", "insn", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "insn", ")", ";", "riscv_set_frame_expr", "(", "insn", ")", ";", "}", "}", "}", "</s>" ]

[ "Expand", "the", "``", "prologue", "''", "pattern", "." ]

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

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createExecutionDependencyFixPass", "(", "&", "X86", "::", "VR128RegClass", ")", ")", ";", "if", "(", "UseVZeroUpper", ")", "addPass", "(", "createX86IssueVZeroUpperPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createX86PadShortFunctions", "(", ")", ")", ";", "addPass", "(", "createX86FixupLEAs", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "X86::VR128RegClass", "X86", "X86", "X86" ]

[]

[ "<s>", "static", "rtx", "mips16_local_alias", "(", "rtx", "func", ")", "{", "if", "(", "mips16_local_aliases", "==", "NULL", ")", "mips16_local_aliases", "=", "hash_map", "<", "rtx", ",", "rtx", ",", "local_alias_traits", ">", "::", "create_ggc", "(", "37", ")", ";", "bool", "existed", ";", "rtx", "*", "slot", "=", "&", "mips16_local_aliases", "->", "get_or_insert", "(", "func", ",", "&", "existed", ")", ";", "gcc_assert", "(", "slot", "!=", "NULL", ")", ";", "if", "(", "!", "existed", ")", "{", "const", "char", "*", "func_name", ",", "*", "local_name", ";", "rtx", "local", ";", "func_name", "=", "targetm", ".", "strip_name_encoding", "(", "XSTR", "(", "func", ",", "0", ")", ")", ";", "local_name", "=", "ACONCAT", "(", "(", "\"__fn_local_\"", ",", "func_name", ",", "NULL", ")", ")", ";", "local", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "local_name", ")", ")", ";", "SYMBOL_REF_FLAGS", "(", "local", ")", "=", "SYMBOL_REF_FLAGS", "(", "func", ")", "|", "SYMBOL_FLAG_LOCAL", ";", "*", "slot", "=", "local", ";", "}", "return", "*", "slot", ";", "}", "</s>" ]

[ "FUNC", "is", "the", "symbol", "for", "a", "locally-defined", "hard-float", "MIPS16", "function", ".", "Return", "a", "local", "alias", "for", "it", ",", "creating", "a", "new", "one", "if", "necessary", "." ]

[ "mips", "37", "0", "\"__fn_local_\"" ]

[]

[ "<s>", "static", "rtx", "gen_rx_popm_vector", "(", "unsigned", "int", "low", ",", "unsigned", "int", "high", ")", "{", "unsigned", "int", "i", ";", "unsigned", "int", "count", "=", "(", "high", "-", "low", ")", "+", "2", ";", "rtx", "vector", ";", "vector", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", ")", ")", ";", "XVECEXP", "(", "vector", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "(", "count", "-", "1", ")", "*", "UNITS_PER_WORD", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "count", "-", "1", ";", "i", "++", ")", "XVECEXP", "(", "vector", ",", "0", ",", "i", "+", "1", ")", "=", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "SImode", ",", "low", "+", "i", ")", ",", "gen_rtx_MEM", "(", "SImode", ",", "i", "==", "0", "?", "stack_pointer_rtx", ":", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "i", "*", "UNITS_PER_WORD", ")", ")", ")", ";", "return", "vector", ";", "}", "</s>" ]

[ "Generate", "a", "PARALLEL", "which", "will", "satisfy", "the", "rx_load_multiple_vector", "predicate", "." ]

[ "rx", "2", "0", "0", "1", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "bool", "Nios2PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createNios2ISelDag", "(", "getNios2TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Nios2", "Nios2", "Nios2", "Nios2" ]

[]

[ "<s>", "bool", "ARMAsmBackend", "::", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "getRelaxedOpcode", "(", "Inst", ".", "getOpcode", "(", ")", ",", "STI", ")", "!=", "Inst", ".", "getOpcode", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "void", "m32r_output_function_epilogue", "(", "FILE", "*", ")", "{", "current_frame_info", "=", "zero_frame_info", ";", "m32r_compute_function_type", "(", "NULL_TREE", ")", ";", "}", "</s>" ]

[ "Do", "any", "necessary", "cleanup", "after", "a", "function", "to", "restore", "stack", ",", "frame", ",", "and", "regs", "." ]

[ "m32r" ]

[]

[ "<s>", "rtx", "legitimize_pic_address", "(", "rtx", "orig", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "reg", ")", "{", "if", "(", "tls_symbolic_operand", "(", "orig", ",", "Pmode", ")", "!=", "TLS_MODEL_NONE", ")", "return", "orig", ";", "if", "(", "GET_CODE", "(", "orig", ")", "==", "LABEL_REF", "||", "(", "GET_CODE", "(", "orig", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_LOCAL_P", "(", "orig", ")", ")", ")", "{", "if", "(", "reg", "==", "NULL_RTX", ")", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "if", "(", "TARGET_FDPIC", "&&", "GET_CODE", "(", "orig", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_FUNCTION_P", "(", "orig", ")", ")", "{", "if", "(", "SYMBOL_REF_WEAK", "(", "orig", ")", ")", "emit_insn", "(", "gen_symGOTFUNCDESC2reg", "(", "reg", ",", "orig", ")", ")", ";", "else", "emit_insn", "(", "gen_symGOTOFFFUNCDESC2reg", "(", "reg", ",", "orig", ")", ")", ";", "}", "else", "if", "(", "TARGET_FDPIC", "&&", "(", "GET_CODE", "(", "orig", ")", "==", "LABEL_REF", "||", "(", "GET_CODE", "(", "orig", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_DECL", "(", "orig", ")", "&&", "(", "TREE_READONLY", "(", "SYMBOL_REF_DECL", "(", "orig", ")", ")", "||", "SYMBOL_REF_EXTERNAL_P", "(", "orig", ")", "||", "DECL_SECTION_NAME", "(", "SYMBOL_REF_DECL", "(", "orig", ")", ")", ")", ")", ")", ")", "emit_insn", "(", "gen_symGOT2reg", "(", "reg", ",", "orig", ")", ")", ";", "else", "emit_insn", "(", "gen_symGOTOFF2reg", "(", "reg", ",", "orig", ")", ")", ";", "return", "reg", ";", "}", "else", "if", "(", "GET_CODE", "(", "orig", ")", "==", "SYMBOL_REF", ")", "{", "if", "(", "reg", "==", "NULL_RTX", ")", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "if", "(", "TARGET_FDPIC", "&&", "SYMBOL_REF_FUNCTION_P", "(", "orig", ")", ")", "emit_insn", "(", "gen_symGOTFUNCDESC2reg", "(", "reg", ",", "orig", ")", ")", ";", "else", "emit_insn", "(", "gen_symGOT2reg", "(", "reg", ",", "orig", ")", ")", ";", "return", "reg", ";", "}", "return", "orig", ";", "}", "</s>" ]

[ "Legitimize", "PIC", "addresses", ".", "If", "the", "address", "is", "already", "position-independent", ",", "we", "return", "ORIG", ".", "Newly", "generated", "position-independent", "addresses", "go", "into", "a", "reg", ".", "This", "is", "REG", "if", "nonzero", ",", "otherwise", "we", "allocate", "register", "(", "s", ")", "as", "necessary", "." ]

[ "sh" ]

[]

[ "<s>", "static", "bool", "tryAddingSymbolicOperand", "(", "uint64_t", "Address", ",", "int32_t", "Value", ",", "bool", "isBranch", ",", "uint64_t", "InstSize", ",", "MCInst", "&", "MI", ",", "const", "void", "*", "Decoder", ")", "{", "const", "MCDisassembler", "*", "Dis", "=", "static_cast", "<", "const", "MCDisassembler", "*", ">", "(", "Decoder", ")", ";", "return", "Dis", "->", "tryAddingSymbolicOperand", "(", "MI", ",", "(", "uint32_t", ")", "Value", ",", "Address", ",", "isBranch", ",", "0", ",", "InstSize", ")", ";", "}", "</s>" ]

[ "Try", "to", "add", "a", "symbolic", "operand", "instead", "of", "Value", "to", "the", "MCInst", "." ]

[ "ARM", "0" ]

[]

[ "<s>", "unsigned", "M680x0InstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "TBB", "&&", "\"InsertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "1", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"M680x0 branch conditions have one component!\"", ")", ";", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "assert", "(", "!", "FBB", "&&", "\"Unconditional branch with multiple successors!\"", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "M680x0", "::", "BRA8", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "bool", "FallThru", "=", "FBB", "==", "nullptr", ";", "unsigned", "Count", "=", "0", ";", "M680x0", "::", "CondCode", "CC", "=", "(", "M680x0", "::", "CondCode", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "unsigned", "Opc", "=", "GetCondBranchFromCond", "(", "CC", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "++", "Count", ";", "if", "(", "!", "FallThru", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "M680x0", "::", "BRA8", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "M680x0", "M680x0", "\"InsertBranch must not be told to insert a fallthrough\"", "1", "0", "\"M680x0 branch conditions have one component!\"", "\"code size not handled\"", "\"Unconditional branch with multiple successors!\"", "M680x0::BRA8", "1", "0", "M680x0::CondCode", "M680x0::CondCode", "0", "M680x0::BRA8" ]

[]

[ "<s>", "enum", "reg_class", "s390_secondary_output_reload_class", "(", "enum", "reg_class", "class", ",", "enum", "machine_mode", "mode", ",", "rtx", "out", ")", "{", "if", "(", "(", "TARGET_64BIT", "?", "(", "mode", "==", "TImode", "||", "mode", "==", "TFmode", ")", ":", "(", "mode", "==", "DImode", "||", "mode", "==", "DFmode", ")", ")", "&&", "reg_classes_intersect_p", "(", "GENERAL_REGS", ",", "class", ")", "&&", "GET_CODE", "(", "out", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "out", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "out", ",", "0", ")", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "out", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", "&&", "!", "DISP_IN_RANGE", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "out", ",", "0", ")", ",", "1", ")", ")", "+", "GET_MODE_SIZE", "(", "mode", ")", "-", "1", ")", ")", "return", "ADDR_REGS", ";", "if", "(", "reg_classes_intersect_p", "(", "FP_REGS", ",", "class", ")", "&&", "mode", "==", "TFmode", "&&", "GET_CODE", "(", "out", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "out", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "out", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", "&&", "!", "DISP_IN_RANGE", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "out", ",", "0", ")", ",", "1", ")", ")", "+", "GET_MODE_SIZE", "(", "mode", ")", "-", "1", ")", ")", "return", "ADDR_REGS", ";", "if", "(", "reg_classes_intersect_p", "(", "CC_REGS", ",", "class", ")", ")", "return", "GENERAL_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Return", "the", "register", "class", "of", "a", "scratch", "register", "needed", "to", "store", "a", "register", "of", "class", "CLASS", "in", "MODE", "into", "OUT", ":", "We", "need", "a", "temporary", "when", "storing", "a", "double-word", "to", "a", "non-offsettable", "memory", "address", "." ]

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

[]

[ "<s>", "bool", "SILowerI1Copies", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "TheMF", ")", "{", "if", "(", "TheMF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "Selected", ")", ")", "return", "false", ";", "MF", "=", "&", "TheMF", ";", "MRI", "=", "&", "MF", "->", "getRegInfo", "(", ")", ";", "DT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "PDT", "=", "&", "getAnalysis", "<", "MachinePostDominatorTree", ">", "(", ")", ";", "ST", "=", "&", "MF", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", "->", "getInstrInfo", "(", ")", ";", "IsWave32", "=", "ST", "->", "isWave32", "(", ")", ";", "if", "(", "IsWave32", ")", "{", "ExecReg", "=", "AMDGPU", "::", "EXEC_LO", ";", "MovOp", "=", "AMDGPU", "::", "S_MOV_B32", ";", "AndOp", "=", "AMDGPU", "::", "S_AND_B32", ";", "OrOp", "=", "AMDGPU", "::", "S_OR_B32", ";", "XorOp", "=", "AMDGPU", "::", "S_XOR_B32", ";", "AndN2Op", "=", "AMDGPU", "::", "S_ANDN2_B32", ";", "OrN2Op", "=", "AMDGPU", "::", "S_ORN2_B32", ";", "}", "else", "{", "ExecReg", "=", "AMDGPU", "::", "EXEC", ";", "MovOp", "=", "AMDGPU", "::", "S_MOV_B64", ";", "AndOp", "=", "AMDGPU", "::", "S_AND_B64", ";", "OrOp", "=", "AMDGPU", "::", "S_OR_B64", ";", "XorOp", "=", "AMDGPU", "::", "S_XOR_B64", ";", "AndN2Op", "=", "AMDGPU", "::", "S_ANDN2_B64", ";", "OrN2Op", "=", "AMDGPU", "::", "S_ORN2_B64", ";", "}", "lowerCopiesFromI1", "(", ")", ";", "lowerPhis", "(", ")", ";", "lowerCopiesToI1", "(", ")", ";", "for", "(", "unsigned", "Reg", ":", "ConstrainRegs", ")", "MRI", "->", "constrainRegClass", "(", "Reg", ",", "&", "AMDGPU", "::", "SReg_1_XEXECRegClass", ")", ";", "ConstrainRegs", ".", "clear", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::EXEC_LO", "AMDGPU::S_MOV_B32", "AMDGPU::S_AND_B32", "AMDGPU::S_OR_B32", "AMDGPU::S_XOR_B32", "AMDGPU::S_ANDN2_B32", "AMDGPU::S_ORN2_B32", "AMDGPU::EXEC", "AMDGPU::S_MOV_B64", "AMDGPU::S_AND_B64", "AMDGPU::S_OR_B64", "AMDGPU::S_XOR_B64", "AMDGPU::S_ANDN2_B64", "AMDGPU::S_ORN2_B64", "AMDGPU::SReg_1_XEXECRegClass" ]

[]

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

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

[ "ARM64" ]

[]

[ "<s>", "void", "R600InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "VectorComponents", "=", "0", ";", "if", "(", "(", "AMDGPU", "::", "R600_Reg128RegClass", ".", "contains", "(", "DestReg", ")", "||", "AMDGPU", "::", "R600_Reg128VerticalRegClass", ".", "contains", "(", "DestReg", ")", ")", "&&", "(", "AMDGPU", "::", "R600_Reg128RegClass", ".", "contains", "(", "SrcReg", ")", "||", "AMDGPU", "::", "R600_Reg128VerticalRegClass", ".", "contains", "(", "SrcReg", ")", ")", ")", "{", "VectorComponents", "=", "4", ";", "}", "else", "if", "(", "(", "AMDGPU", "::", "R600_Reg64RegClass", ".", "contains", "(", "DestReg", ")", "||", "AMDGPU", "::", "R600_Reg64VerticalRegClass", ".", "contains", "(", "DestReg", ")", ")", "&&", "(", "AMDGPU", "::", "R600_Reg64RegClass", ".", "contains", "(", "SrcReg", ")", "||", "AMDGPU", "::", "R600_Reg64VerticalRegClass", ".", "contains", "(", "SrcReg", ")", ")", ")", "{", "VectorComponents", "=", "2", ";", "}", "if", "(", "VectorComponents", ">", "0", ")", "{", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "VectorComponents", ";", "I", "++", ")", "{", "unsigned", "SubRegIndex", "=", "RI", ".", "getSubRegFromChannel", "(", "I", ")", ";", "buildDefaultInstruction", "(", "MBB", ",", "MI", ",", "AMDGPU", "::", "MOV", ",", "RI", ".", "getSubReg", "(", "DestReg", ",", "SubRegIndex", ")", ",", "RI", ".", "getSubReg", "(", "SrcReg", ",", "SubRegIndex", ")", ")", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", "|", "RegState", "::", "Implicit", ")", ";", "}", "}", "else", "{", "MachineInstr", "*", "NewMI", "=", "buildDefaultInstruction", "(", "MBB", ",", "MI", ",", "AMDGPU", "::", "MOV", ",", "DestReg", ",", "SrcReg", ")", ";", "NewMI", "->", "getOperand", "(", "getOperandIdx", "(", "*", "NewMI", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ")", ".", "setIsKill", "(", "KillSrc", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "R600", "0", "AMDGPU::R600_Reg128RegClass", "AMDGPU::R600_Reg128VerticalRegClass", "AMDGPU::R600_Reg128RegClass", "AMDGPU::R600_Reg128VerticalRegClass", "4", "AMDGPU::R600_Reg64RegClass", "AMDGPU::R600_Reg64VerticalRegClass", "AMDGPU::R600_Reg64RegClass", "AMDGPU::R600_Reg64VerticalRegClass", "2", "0", "0", "AMDGPU::MOV", "AMDGPU::MOV", "AMDGPU::OpName" ]

[]

[ "<s>", "bool", "ARCFrameLowering", "::", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "int", "CurOffset", "=", "-", "4", ";", "unsigned", "Last", "=", "determineLastCalleeSave", "(", "CSI", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "int", "StackObj", "=", "MFI", ".", "CreateFixedSpillStackObject", "(", "4", ",", "CurOffset", ",", "true", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Creating fixed object (\"", "<<", "StackObj", "<<", "\") for FP at \"", "<<", "CurOffset", "<<", "\"\\n\"", ")", ";", "(", "void", ")", "StackObj", ";", "CurOffset", "-=", "4", ";", "}", "if", "(", "MFI", ".", "hasCalls", "(", ")", "||", "(", "UseSaveRestoreFunclet", "&&", "Last", ">", "ARC", "::", "R14", ")", ")", "{", "int", "StackObj", "=", "MFI", ".", "CreateFixedSpillStackObject", "(", "4", ",", "CurOffset", ",", "true", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Creating fixed object (\"", "<<", "StackObj", "<<", "\") for BLINK at \"", "<<", "CurOffset", "<<", "\"\\n\"", ")", ";", "(", "void", ")", "StackObj", ";", "CurOffset", "-=", "4", ";", "}", "for", "(", "unsigned", "Which", "=", "Last", ";", "Which", ">", "ARC", "::", "R12", ";", "Which", "--", ")", "{", "auto", "RegI", "=", "getSavedReg", "(", "CSI", ",", "Which", ")", ";", "if", "(", "RegI", "==", "CSI", ".", "end", "(", ")", "||", "RegI", "->", "getFrameIdx", "(", ")", "==", "0", ")", "{", "int", "FI", "=", "MFI", ".", "CreateFixedSpillStackObject", "(", "4", ",", "CurOffset", ",", "true", ")", ";", "if", "(", "RegI", "!=", "CSI", ".", "end", "(", ")", ")", "RegI", "->", "setFrameIdx", "(", "FI", ")", ";", "}", "else", "MFI", ".", "setObjectOffset", "(", "RegI", "->", "getFrameIdx", "(", ")", ",", "CurOffset", ")", ";", "CurOffset", "-=", "4", ";", "}", "for", "(", "auto", "&", "I", ":", "CSI", ")", "{", "if", "(", "I", ".", "getReg", "(", ")", ">", "ARC", "::", "R12", ")", "continue", ";", "if", "(", "I", ".", "getFrameIdx", "(", ")", "==", "0", ")", "{", "I", ".", "setFrameIdx", "(", "MFI", ".", "CreateFixedSpillStackObject", "(", "4", ",", "CurOffset", ",", "true", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Creating fixed object (\"", "<<", "I", ".", "getFrameIdx", "(", ")", "<<", "\") for other register at \"", "<<", "CurOffset", "<<", "\"\\n\"", ")", ";", "}", "else", "{", "MFI", ".", "setObjectOffset", "(", "I", ".", "getFrameIdx", "(", ")", ",", "CurOffset", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Updating fixed object (\"", "<<", "I", ".", "getFrameIdx", "(", ")", "<<", "\") for other register at \"", "<<", "CurOffset", "<<", "\"\\n\"", ")", ";", "}", "CurOffset", "-=", "4", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "will", "assign", "callee", "saved", "gprs", "to", "volatile", "vector", "registers", "for", "prologue", "spills", "when", "applicable", "." ]

[ "ARC", "ARC", "4", "4", "\"Creating fixed object (\"", "\") for FP at \"", "\"\\n\"", "4", "ARC::R14", "4", "\"Creating fixed object (\"", "\") for BLINK at \"", "\"\\n\"", "4", "ARC::R12", "0", "4", "4", "ARC::R12", "0", "4", "\"Creating fixed object (\"", "\") for other register at \"", "\"\\n\"", "\"Updating fixed object (\"", "\") for other register at \"", "\"\\n\"", "4" ]

[]

[ "<s>", "int", "neon_vector_mem_operand", "(", "rtx", "op", ",", "int", "type", ",", "bool", "strict", ")", "{", "rtx", "ind", ";", "if", "(", "strict", "&&", "!", "(", "reload_in_progress", "||", "reload_completed", ")", "&&", "(", "reg_mentioned_p", "(", "frame_pointer_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "arg_pointer_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_incoming_args_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_outgoing_args_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_stack_dynamic_rtx", ",", "op", ")", "||", "reg_mentioned_p", "(", "virtual_stack_vars_rtx", ",", "op", ")", ")", ")", "return", "FALSE", ";", "if", "(", "!", "MEM_P", "(", "op", ")", ")", "return", "FALSE", ";", "ind", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "reload_completed", "&&", "(", "LABEL_REF_P", "(", "ind", ")", "||", "(", "GET_CODE", "(", "ind", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "ind", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "0", ")", ")", "==", "LABEL_REF", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "1", ")", ")", ")", ")", ")", "return", "TRUE", ";", "if", "(", "REG_P", "(", "ind", ")", ")", "return", "arm_address_register_rtx_p", "(", "ind", ",", "0", ")", ";", "if", "(", "(", "type", "!=", "1", "&&", "GET_CODE", "(", "ind", ")", "==", "POST_INC", ")", "||", "(", "type", "==", "0", "&&", "GET_CODE", "(", "ind", ")", "==", "PRE_DEC", ")", ")", "return", "arm_address_register_rtx_p", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "0", ")", ";", "if", "(", "type", "==", "2", "&&", "GET_CODE", "(", "ind", ")", "==", "POST_MODIFY", "&&", "GET_CODE", "(", "XEXP", "(", "ind", ",", "1", ")", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "XEXP", "(", "ind", ",", "1", ")", ",", "1", ")", ")", "&&", "REG_P", "(", "XEXP", "(", "ind", ",", "0", ")", ")", "&&", "rtx_equal_p", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "XEXP", "(", "XEXP", "(", "ind", ",", "1", ")", ",", "0", ")", ")", ")", "return", "true", ";", "if", "(", "type", "==", "0", "&&", "GET_CODE", "(", "ind", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "ind", ",", "0", ")", ")", "&&", "REG_MODE_OK_FOR_BASE_P", "(", "XEXP", "(", "ind", ",", "0", ")", ",", "VOIDmode", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "ind", ",", "1", ")", ")", "&&", "INTVAL", "(", "XEXP", "(", "ind", ",", "1", ")", ")", ">", "-", "1024", "&&", "(", "INTVAL", "(", "XEXP", "(", "ind", ",", "1", ")", ")", "<", "(", "VALID_NEON_QREG_MODE", "(", "GET_MODE", "(", "op", ")", ")", "?", "1016", ":", "1024", ")", ")", "&&", "(", "INTVAL", "(", "XEXP", "(", "ind", ",", "1", ")", ")", "&", "3", ")", "==", "0", ")", "return", "TRUE", ";", "return", "FALSE", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "OP", "is", "a", "memory", "operand", "which", "we", "can", "load", "or", "store", "a", "vector", "to/from", ".", "TYPE", "is", "one", "of", "the", "following", "values", ":", "0", "-", "Vector", "load/stor", "(", "vldr", ")", "1", "-", "Core", "registers", "(", "ldm", ")", "2", "-", "Element/structure", "loads", "(", "vld1", ")" ]

[ "arm", "0", "0", "0", "0", "0", "1", "0", "1", "0", "0", "0", "2", "1", "1", "1", "0", "0", "1", "0", "0", "0", "0", "1", "1", "1024", "1", "1016", "1024", "1", "3", "0" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "RISCVRegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "uint64_t", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "unsigned", "MaxStackAlign", "=", "std", "::", "max", "(", "StackAlign", ",", "MFI", ".", "getMaxAlignment", "(", ")", ")", ";", "FrameSize", "+=", "(", "MaxStackAlign", "-", "StackAlign", ")", ";", "StackAlign", "=", "MaxStackAlign", ";", "}", "uint64_t", "MaxCallSize", "=", "alignTo", "(", "MFI", ".", "getMaxCallFrameSize", "(", ")", ",", "StackAlign", ")", ";", "MFI", ".", "setMaxCallFrameSize", "(", "MaxCallSize", ")", ";", "FrameSize", "=", "alignTo", "(", "FrameSize", ",", "StackAlign", ")", ";", "MFI", ".", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

[ "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "switch", "(", "Kind", ")", "{", "case", "Register", ":", "OS", "<<", "\"<register \"", "<<", "getReg", "(", ")", "<<", "\" mods: \"", "<<", "Reg", ".", "Modifiers", "<<", "'>'", ";", "break", ";", "case", "Immediate", ":", "if", "(", "Imm", ".", "Type", "!=", "AMDGPUOperand", "::", "ImmTyNone", ")", "OS", "<<", "getImm", "(", ")", ";", "else", "OS", "<<", "'<'", "<<", "getImm", "(", ")", "<<", "\" mods: \"", "<<", "Imm", ".", "Modifiers", "<<", "'>'", ";", "break", ";", "case", "Token", ":", "OS", "<<", "'\\''", "<<", "getToken", "(", ")", "<<", "'\\''", ";", "break", ";", "case", "Expression", ":", "OS", "<<", "\"<expr \"", "<<", "*", "Expr", "<<", "'>'", ";", "break", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "\"<register \"", "\" mods: \"", "AMDGPU", "\" mods: \"", "\"<expr \"" ]

[]

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

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

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

[]

[ "<s>", "void", "schedNode", "(", "SUnit", "*", "SU", ",", "bool", "IsTopNode", ")", "override", "{", "}", "</s>" ]

[ "ScheduleDAGMI", "has", "scheduled", "an", "instruction", "-", "tell", "HazardRec", "about", "it", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "MCELFStreamer", "&", "CSKYTargetELFStreamer", "::", "getStreamer", "(", ")", "{", "return", "static_cast", "<", "MCELFStreamer", "&", ">", "(", "Streamer", ")", ";", "}", "</s>" ]

[ "Return", "the", "output", "streamer", "for", "the", "assembler", "." ]

[ "CSKY", "CSKY" ]

[]

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

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

[ "Sparc" ]

[]

[ "<s>", "void", "AMDGPUPostLegalizerCombiner", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "AU", ".", "setPreservesCFG", "(", ")", ";", "getSelectionDAGFallbackAnalysisUsage", "(", "AU", ")", ";", "AU", ".", "addRequired", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ";", "if", "(", "!", "IsOptNone", ")", "{", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "}", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "aarch64_reinterpret_float_as_int", "(", "rtx", "value", ",", "unsigned", "HOST_WIDE_INT", "*", "intval", ")", "{", "if", "(", "aarch64_float_const_zero_rtx_p", "(", "value", ")", ")", "{", "*", "intval", "=", "0", ";", "return", "true", ";", "}", "scalar_float_mode", "mode", ";", "if", "(", "GET_CODE", "(", "value", ")", "!=", "CONST_DOUBLE", "||", "!", "is_a", "<", "scalar_float_mode", ">", "(", "GET_MODE", "(", "value", ")", ",", "&", "mode", ")", "||", "GET_MODE_BITSIZE", "(", "mode", ")", ">", "HOST_BITS_PER_WIDE_INT", "||", "GET_MODE_BITSIZE", "(", "mode", ")", ">", "GET_MODE_BITSIZE", "(", "DFmode", ")", ")", "return", "false", ";", "unsigned", "HOST_WIDE_INT", "ival", "=", "0", ";", "long", "res", "[", "2", "]", ";", "real_to_target", "(", "res", ",", "CONST_DOUBLE_REAL_VALUE", "(", "value", ")", ",", "REAL_MODE_FORMAT", "(", "mode", ")", ")", ";", "if", "(", "mode", "==", "DFmode", ")", "{", "int", "order", "=", "BYTES_BIG_ENDIAN", "?", "1", ":", "0", ";", "ival", "=", "zext_hwi", "(", "res", "[", "order", "]", ",", "32", ")", ";", "ival", "|=", "(", "zext_hwi", "(", "res", "[", "1", "-", "order", "]", ",", "32", ")", "<<", "32", ")", ";", "}", "else", "ival", "=", "zext_hwi", "(", "res", "[", "0", "]", ",", "32", ")", ";", "*", "intval", "=", "ival", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "the", "binary", "representation", "of", "floating", "point", "constant", "VALUE", "in", "INTVAL", ".", "If", "the", "value", "can", "not", "be", "converted", ",", "return", "false", "without", "setting", "INTVAL", ".", "The", "conversion", "is", "done", "in", "the", "given", "MODE", "." ]

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

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "canInsertSelect", "(", "const", "MachineBasicBlock", "&", "MBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred", ",", "unsigned", "DstReg", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ",", "int", "&", "CondCycles", ",", "int", "&", "TrueCycles", ",", "int", "&", "FalseCycles", ")", "const", "{", "if", "(", "!", "STI", ".", "hasLoadStoreOnCond", "(", ")", ")", "return", "false", ";", "if", "(", "Pred", ".", "size", "(", ")", "!=", "2", ")", "return", "false", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getCommonSubClass", "(", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ",", "MRI", ".", "getRegClass", "(", "FalseReg", ")", ")", ";", "if", "(", "!", "RC", ")", "return", "false", ";", "if", "(", "(", "STI", ".", "hasLoadStoreOnCond2", "(", ")", "&&", "SystemZ", "::", "GRX32BitRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "||", "SystemZ", "::", "GR32BitRegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "SystemZ", "::", "GR64BitRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "CondCycles", "=", "2", ";", "TrueCycles", "=", "2", ";", "FalseCycles", "=", "2", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "2", "SystemZ::GRX32BitRegClass", "SystemZ::GR32BitRegClass", "SystemZ::GR64BitRegClass", "2", "2", "2" ]

[]

[ "<s>", "const", "ARCRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

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

[ "ARC", "ARC" ]

[]

[ "<s>", "const", "char", "*", "mips_output_probe_stack_range", "(", "rtx", "reg1", ",", "rtx", "reg2", ")", "{", "static", "int", "labelno", "=", "0", ";", "char", "loop_lab", "[", "32", "]", ",", "tmp", "[", "64", "]", ";", "rtx", "xops", "[", "2", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "loop_lab", ",", "\"LPSRL\"", ",", "labelno", "++", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "loop_lab", ")", ";", "xops", "[", "0", "]", "=", "reg1", ";", "xops", "[", "1", "]", "=", "GEN_INT", "(", "-", "PROBE_INTERVAL", ")", ";", "if", "(", "TARGET_64BIT", "&&", "TARGET_LONG64", ")", "output_asm_insn", "(", "\"daddiu\\t%0,%0,%1\"", ",", "xops", ")", ";", "else", "output_asm_insn", "(", "\"addiu\\t%0,%0,%1\"", ",", "xops", ")", ";", "xops", "[", "1", "]", "=", "reg2", ";", "strcpy", "(", "tmp", ",", "\"%(%<bne\\t%0,%1,\"", ")", ";", "output_asm_insn", "(", "strcat", "(", "tmp", ",", "&", "loop_lab", "[", "1", "]", ")", ",", "xops", ")", ";", "if", "(", "TARGET_64BIT", ")", "output_asm_insn", "(", "\"sd\\t$0,0(%0)%)\"", ",", "xops", ")", ";", "else", "output_asm_insn", "(", "\"sw\\t$0,0(%0)%)\"", ",", "xops", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Probe", "a", "range", "of", "stack", "addresses", "from", "REG1", "to", "REG2", "inclusive", ".", "These", "are", "absolute", "addresses", "." ]

[ "mips", "0", "32", "64", "2", "\"LPSRL\"", "0", "1", "\"daddiu\\t%0,%0,%1\"", "\"addiu\\t%0,%0,%1\"", "1", "\"%(%<bne\\t%0,%1,\"", "1", "\"sd\\t$0,0(%0)%)\"", "\"sw\\t$0,0(%0)%)\"", "\"\"" ]

[]