ground_truth
sequencelengths
8
512
natrual_language
sequencelengths
1
243
TS_V_token
sequencelengths
1
182
File
stringlengths
2
45
Func
stringlengths
1
56
Target
stringclasses
175 values
Target_Clf
stringclasses
6 values
Compiler_Type
stringclasses
2 values
Idx
int64
0
36.2k
Length
int64
6
510
Cover_Rate
float64
1
1
Template_token
sequencelengths
0
0
[ "<s>", "int", "frv_legitimate_memory_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ",", "int", "condexec_p", ")", "{", "return", "(", "(", "GET_MODE", "(", "op", ")", "==", "mode", "||", "mode", "==", "VOIDmode", ")", "&&", "GET_CODE", "(", "op", ")", "==", "MEM", "&&", "frv_legitimate_address_p", "(", "mode", ",", "XEXP", "(", "op", ",", "0", ")", ",", "reload_completed", ",", "condexec_p", ",", "FALSE", ")", ")", ";", "}", "</s>" ]
[ "Return", "1", "if", "operand", "is", "a", "valid", "FRV", "address", ".", "CONDEXEC_P", "is", "true", "if", "the", "operand", "is", "used", "by", "a", "predicated", "instruction", "." ]
[ "frv", "0" ]
frv2
frv_legitimate_memory_operand
frv
VLIW
GCC
0
56
1
[]
[ "<s>", "bool", "AArch64FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "static", "const", "LoadStoreMethod", "PossibleClasses", "[", "]", "=", "{", "{", "&", "AArch64", "::", "GPR64RegClass", ",", "AArch64", "::", "LSPair64_STR", ",", "AArch64", "::", "LS64_STR", "}", ",", "{", "&", "AArch64", "::", "FPR64RegClass", ",", "AArch64", "::", "LSFPPair64_STR", ",", "AArch64", "::", "LSFP64_STR", "}", ",", "}", ";", "const", "unsigned", "NumClasses", "=", "llvm", "::", "array_lengthof", "(", "PossibleClasses", ")", ";", "emitFrameMemOps", "(", "true", ",", "MBB", ",", "MBBI", ",", "CSI", ",", "TRI", ",", "PossibleClasses", ",", "NumClasses", ")", ";", "return", "true", ";", "}", "</s>" ]
[ "spillCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "spill", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "store", "instructions", "via", "storeRegToStackSlot", "(", ")", "." ]
[ "AArch64", "AArch64", "AArch64::GPR64RegClass", "AArch64::LSPair64_STR", "AArch64::LS64_STR", "AArch64::FPR64RegClass", "AArch64::LSFPPair64_STR", "AArch64::LSFP64_STR" ]
AArch64FrameLowering24
spillCalleeSavedRegisters
AArch64
CPU
LLVM
1
114
1
[]
[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "bool", "Changed", "=", "false", ";", "if", "(", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getCFLType", "(", ")", "!=", "PatmosSubtarget", "::", "CFL_DELAYED", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n[DelaySlotKiller] \"", "<<", "F", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "F", ".", "begin", "(", ")", ",", "FE", "=", "F", ".", "end", "(", ")", ";", "FI", "!=", "FE", ";", "++", "FI", ")", "Changed", "|=", "killDelaySlots", "(", "*", "FI", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "Patmos", "Patmos", "\"\\n[DelaySlotKiller] \"", "\"\\n\"" ]
PatmosDelaySlotKiller
runOnMachineFunction
Patmos
VLIW
LLVM
2
92
1
[]
[ "<s>", "void", "WebAssemblyFrameLowering", "::", "writeSPToGlobal", "(", "unsigned", "SrcReg", ",", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "InsertStore", ",", "const", "DebugLoc", "&", "DL", ")", "const", "{", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "char", "*", "ES", "=", "\"__stack_pointer\"", ";", "auto", "*", "SPSymbol", "=", "MF", ".", "createExternalSymbolName", "(", "ES", ")", ";", "BuildMI", "(", "MBB", ",", "InsertStore", ",", "DL", ",", "TII", "->", "get", "(", "getOpcGlobSet", "(", "MF", ")", ")", ")", ".", "addExternalSymbol", "(", "SPSymbol", ")", ".", "addReg", "(", "SrcReg", ")", ";", "}", "</s>" ]
[ "Write", "SP", "back", "to", "__stack_pointer", "global", "." ]
[ "WebAssembly", "WebAssembly", "WebAssembly", "\"__stack_pointer\"" ]
WebAssemblyFrameLowering11
writeSPToGlobal
WebAssembly
Virtual ISA
LLVM
3
95
1
[]
[ "<s>", "static", "bool", "hasReassociableSibling", "(", "const", "MachineInstr", "&", "Inst", ",", "bool", "&", "Commuted", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "Inst", ".", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineInstr", "*", "MI1", "=", "MRI", ".", "getUniqueVRegDef", "(", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ";", "MachineInstr", "*", "MI2", "=", "MRI", ".", "getUniqueVRegDef", "(", "Inst", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ";", "unsigned", "AssocOpcode", "=", "Inst", ".", "getOpcode", "(", ")", ";", "Commuted", "=", "MI1", "->", "getOpcode", "(", ")", "!=", "AssocOpcode", "&&", "MI2", "->", "getOpcode", "(", ")", "==", "AssocOpcode", ";", "if", "(", "Commuted", ")", "std", "::", "swap", "(", "MI1", ",", "MI2", ")", ";", "if", "(", "MI1", "->", "getOpcode", "(", ")", "==", "AssocOpcode", "&&", "hasReassociableOperands", "(", "*", "MI1", ",", "MBB", ")", "&&", "MRI", ".", "hasOneNonDBGUse", "(", "MI1", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]
[ "Return", "true", "when", "\\P", "Inst", "has", "reassociable", "sibling", "." ]
[ "X86", "1", "2", "0" ]
X86InstrInfo123
hasReassociableSibling
X86
CPU
LLVM
4
161
1
[]
[ "<s>", "static", "unsigned", "int", "h8300_move_length", "(", "rtx", "*", "operands", ",", "const", "h8300_length_table", "*", "table", ")", "{", "unsigned", "int", "size", ";", "size", "=", "h8300_length_from_table", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "table", ")", ";", "if", "(", "REG_P", "(", "operands", "[", "0", "]", ")", "&&", "h8300_short_move_mem_p", "(", "operands", "[", "1", "]", ",", "POST_INC", ")", ")", "size", "-=", "2", ";", "if", "(", "REG_P", "(", "operands", "[", "1", "]", ")", "&&", "h8300_short_move_mem_p", "(", "operands", "[", "0", "]", ",", "PRE_DEC", ")", ")", "size", "-=", "2", ";", "return", "size", ";", "}", "</s>" ]
[ "Calculate", "the", "length", "of", "move", "instruction", "INSN", "using", "the", "given", "length", "table", ".", "Although", "the", "tables", "are", "correct", "for", "most", "cases", ",", "there", "is", "some", "irregularity", "in", "the", "length", "of", "mov.b", "and", "mov.w", ".", "The", "following", "forms", ":", "mov", "@", "ERs+", ",", "Rd", "mov", "@", "(", "d:16", ",", "ERs", ")", ",", "Rd", "mov", "Rs", ",", "@", "-ERd", "mov", "Rs", ",", "@", "(", "d:16", ",", "ERd", ")", "are", "two", "bytes", "shorter", "than", "most", "other", "``", "mov", "Rs", ",", "@", "complex", "''", "or", "``", "mov", "@", "complex", ",", "Rd", "''", "combinations", "." ]
[ "h8300", "0", "1", "0", "1", "2", "1", "0", "2" ]
h8300
h8300_move_length
h8300
MPU
GCC
5
88
1
[]
[ "<s>", "void", "ARMPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createThumb2SizeReductionPass", "(", ")", ")", ";", "addPass", "(", "createUnpackMachineBundles", "(", "[", "]", "(", "const", "MachineFunction", "&", "MF", ")", "{", "return", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isThumb2", "(", ")", ";", "}", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createARMOptimizeBarriersPass", "(", ")", ")", ";", "addPass", "(", "createARMConstantIslandPass", "(", ")", ")", ";", "}", "</s>" ]
[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]
[ "ARM", "ARM", "ARM", "ARM", "ARM" ]
ARMTargetMachine
addPreEmitPass
ARM
CPU
LLVM
6
70
1
[]
[ "<s>", "SDValue", "SparcTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "BITCAST", ":", "return", "PerformBITCASTCombine", "(", "N", ",", "DCI", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]
[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]
[ "Sparc", "Sparc", "ISD::BITCAST" ]
SparcISelLowering (2)2
PerformDAGCombine
Sparc
CPU
LLVM
7
48
1
[]
[ "<s>", "static", "bool", "arm_valid_target_attribute_rec", "(", "tree", "args", ",", "struct", "gcc_options", "*", "opts", ")", "{", "if", "(", "TREE_CODE", "(", "args", ")", "==", "TREE_LIST", ")", "{", "bool", "ret", "=", "true", ";", "for", "(", ";", "args", ";", "args", "=", "TREE_CHAIN", "(", "args", ")", ")", "if", "(", "TREE_VALUE", "(", "args", ")", "&&", "!", "arm_valid_target_attribute_rec", "(", "TREE_VALUE", "(", "args", ")", ",", "opts", ")", ")", "ret", "=", "false", ";", "return", "ret", ";", "}", "else", "if", "(", "TREE_CODE", "(", "args", ")", "!=", "STRING_CST", ")", "{", "error", "(", "\"attribute %<target%> argument not a string\"", ")", ";", "return", "false", ";", "}", "char", "*", "argstr", "=", "ASTRDUP", "(", "TREE_STRING_POINTER", "(", "args", ")", ")", ";", "char", "*", "q", ";", "while", "(", "(", "q", "=", "strtok", "(", "argstr", ",", "\",\"", ")", ")", "!=", "NULL", ")", "{", "while", "(", "ISSPACE", "(", "*", "q", ")", ")", "++", "q", ";", "argstr", "=", "NULL", ";", "if", "(", "!", "strncmp", "(", "q", ",", "\"thumb\"", ",", "5", ")", ")", "opts", "->", "x_target_flags", "|=", "MASK_THUMB", ";", "else", "if", "(", "!", "strncmp", "(", "q", ",", "\"arm\"", ",", "3", ")", ")", "opts", "->", "x_target_flags", "&=", "~", "MASK_THUMB", ";", "else", "if", "(", "!", "strncmp", "(", "q", ",", "\"fpu=\"", ",", "4", ")", ")", "{", "if", "(", "!", "opt_enum_arg_to_value", "(", "OPT_mfpu_", ",", "q", "+", "4", ",", "&", "opts", "->", "x_arm_fpu_index", ",", "CL_TARGET", ")", ")", "{", "error", "(", "\"invalid fpu for attribute(target(\\\"%s\\\"))\"", ",", "q", ")", ";", "return", "false", ";", "}", "}", "else", "{", "error", "(", "\"attribute(target(\\\"%s\\\")) is unknown\"", ",", "q", ")", ";", "return", "false", ";", "}", "arm_option_check_internal", "(", "opts", ")", ";", "}", "return", "true", ";", "}", "</s>" ]
[ "Inner", "function", "to", "process", "the", "attribute", "(", "(", "target", "(", "...", ")", ")", ")", ",", "take", "an", "argument", "and", "set", "the", "current", "options", "from", "the", "argument", ".", "If", "we", "have", "a", "list", ",", "recursively", "go", "over", "the", "list", "." ]
[ "arm", "\"attribute %<target%> argument not a string\"", "\",\"", "\"thumb\"", "5", "\"arm\"", "3", "\"fpu=\"", "4", "4", "\"invalid fpu for attribute(target(\\\"%s\\\"))\"", "\"attribute(target(\\\"%s\\\")) is unknown\"" ]
arm5
arm_valid_target_attribute_rec
arm
CPU
GCC
8
240
1
[]
[ "<s>", "enum", "reg_class", "arm_regno_class", "(", "int", "regno", ")", "{", "if", "(", "regno", "==", "PC_REGNUM", ")", "return", "NO_REGS", ";", "if", "(", "TARGET_THUMB1", ")", "{", "if", "(", "regno", "==", "STACK_POINTER_REGNUM", ")", "return", "STACK_REG", ";", "if", "(", "regno", "==", "CC_REGNUM", ")", "return", "CC_REG", ";", "if", "(", "regno", "<", "8", ")", "return", "LO_REGS", ";", "return", "HI_REGS", ";", "}", "if", "(", "TARGET_THUMB2", "&&", "regno", "<", "8", ")", "return", "LO_REGS", ";", "if", "(", "regno", "<=", "LAST_ARM_REGNUM", "||", "regno", "==", "FRAME_POINTER_REGNUM", "||", "regno", "==", "ARG_POINTER_REGNUM", ")", "return", "TARGET_THUMB2", "?", "HI_REGS", ":", "GENERAL_REGS", ";", "if", "(", "regno", "==", "CC_REGNUM", "||", "regno", "==", "VFPCC_REGNUM", ")", "return", "TARGET_THUMB2", "?", "CC_REG", ":", "NO_REGS", ";", "if", "(", "IS_VFP_REGNUM", "(", "regno", ")", ")", "{", "if", "(", "regno", "<=", "D7_VFP_REGNUM", ")", "return", "VFP_D0_D7_REGS", ";", "else", "if", "(", "regno", "<=", "LAST_LO_VFP_REGNUM", ")", "return", "VFP_LO_REGS", ";", "else", "return", "VFP_HI_REGS", ";", "}", "if", "(", "IS_IWMMXT_REGNUM", "(", "regno", ")", ")", "return", "IWMMXT_REGS", ";", "if", "(", "IS_IWMMXT_GR_REGNUM", "(", "regno", ")", ")", "return", "IWMMXT_GR_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]
[ "For", "efficiency", "and", "historical", "reasons", "LO_REGS", ",", "HI_REGS", "and", "CC_REGS", "are", "not", "used", "in", "arm", "mode", "." ]
[ "arm", "8", "8" ]
arm4
arm_regno_class
arm
CPU
GCC
9
158
1
[]
[ "<s>", "int", "X86TTIImpl", "::", "getIntrinsicInstrCost", "(", "Intrinsic", "::", "ID", "IID", ",", "Type", "*", "RetTy", ",", "ArrayRef", "<", "Value", "*", ">", "Args", ",", "FastMathFlags", "FMF", ",", "unsigned", "VF", ")", "{", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "IID", ",", "RetTy", ",", "Args", ",", "FMF", ",", "VF", ")", ";", "}", "</s>" ]
[ "Get", "intrinsic", "cost", "based", "on", "arguments", "." ]
[ "X86", "X86", "Intrinsic::ID" ]
X86TargetTransformInfo (2)
getIntrinsicInstrCost
X86
CPU
LLVM
10
45
1
[]
[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"PIC16 Memsel Optimizer\"", ";", "}", "</s>" ]
[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]
[ "PIC16", "\"PIC16 Memsel Optimizer\"" ]
PIC16MemSelOpt
getPassName
PIC16
MPU
LLVM
11
13
1
[]
[ "<s>", "SDValue", "VETargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_VE", ")", ";", "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!\"", ")", ";", "SDValue", "OutVal", "=", "OutVals", "[", "i", "]", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "OutVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "OutVal", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "OutVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "OutVal", ")", ";", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "OutVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "OutVal", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "}", "assert", "(", "!", "VA", ".", "needsCustom", "(", ")", "&&", "\"Unexpected custom lowering\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVal", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "VEISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]
[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]
[ "VE", "VE", "ISD::OutputArg", "16", "VE", "4", "1", "0", "\"Can only return in registers!\"", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::ANY_EXTEND", "\"Unknown loc info!\"", "\"Unexpected custom lowering\"", "1", "0", "VEISD::RET_FLAG", "MVT::Other" ]
VEISelLowering
LowerReturn
VE
CPU
LLVM
12
362
1
[]
[ "<s>", "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "MipsRegisterBankInfo", "::", "getInstrMapping", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "Mapping", "=", "getInstrMappingImpl", "(", "MI", ")", ";", "if", "(", "Mapping", ".", "isValid", "(", ")", ")", "return", "Mapping", ";", "using", "namespace", "TargetOpcode", ";", "unsigned", "NumOperands", "=", "MI", ".", "getNumOperands", "(", ")", ";", "const", "ValueMapping", "*", "OperandsMapping", "=", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ";", "switch", "(", "Opc", ")", "{", "case", "G_TRUNC", ":", "case", "G_ADD", ":", "case", "G_SUB", ":", "case", "G_MUL", ":", "case", "G_UMULH", ":", "case", "G_LOAD", ":", "case", "G_STORE", ":", "case", "G_ZEXTLOAD", ":", "case", "G_SEXTLOAD", ":", "case", "G_GEP", ":", "case", "G_AND", ":", "case", "G_OR", ":", "case", "G_XOR", ":", "case", "G_SHL", ":", "case", "G_ASHR", ":", "case", "G_LSHR", ":", "case", "G_SDIV", ":", "case", "G_UDIV", ":", "case", "G_SREM", ":", "case", "G_UREM", ":", "OperandsMapping", "=", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ";", "break", ";", "case", "G_FCONSTANT", ":", "{", "LLT", "Ty", "=", "MRI", ".", "getType", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ";", "unsigned", "Size", "=", "Ty", ".", "getSizeInBits", "(", ")", ";", "const", "RegisterBankInfo", "::", "ValueMapping", "*", "FPRValueMapping", "=", "Size", "==", "32", "?", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "SPRIdx", "]", ":", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "DPRIdx", "]", ";", "OperandsMapping", "=", "getOperandsMapping", "(", "{", "FPRValueMapping", ",", "nullptr", "}", ")", ";", "break", ";", "}", "case", "G_CONSTANT", ":", "case", "G_FRAME_INDEX", ":", "case", "G_GLOBAL_VALUE", ":", "case", "G_BRCOND", ":", "OperandsMapping", "=", "getOperandsMapping", "(", "{", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ",", "nullptr", "}", ")", ";", "break", ";", "case", "G_ICMP", ":", "OperandsMapping", "=", "getOperandsMapping", "(", "{", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ",", "nullptr", ",", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ",", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", "}", ")", ";", "break", ";", "case", "G_SELECT", ":", "OperandsMapping", "=", "getOperandsMapping", "(", "{", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ",", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ",", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ",", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", "}", ")", ";", "break", ";", "default", ":", "return", "getInvalidInstructionMapping", "(", ")", ";", "}", "return", "getInstructionMapping", "(", "DefaultMappingID", ",", "1", ",", "OperandsMapping", ",", "NumOperands", ")", ";", "}", "</s>" ]
[ "Get", "the", "mapping", "of", "the", "different", "operands", "of", "MI", "on", "the", "register", "bank", "." ]
[ "Mips", "Mips", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "0", "32", "Mips::ValueMappings", "Mips::SPRIdx", "Mips::ValueMappings", "Mips::DPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "1" ]
MipsRegisterBankInfo33
getInstrMapping
Mips
CPU
LLVM
13
409
1
[]
[ "<s>", "uint64_t", "getNullPointerValue", "(", "unsigned", "AddrSpace", ")", "const", "{", "return", "(", "AddrSpace", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", "||", "AddrSpace", "==", "AMDGPUAS", "::", "REGION_ADDRESS", ")", "?", "-", "1", ":", "0", ";", "}", "</s>" ]
[ "Get", "the", "integer", "value", "of", "a", "null", "pointer", "in", "the", "given", "address", "space", "." ]
[ "AMDGPU", "AMDGPU", "AMDGPU", "1", "0" ]
AMDGPUTargetMachine (2)1
getNullPointerValue
AMDGPU
GPU
LLVM
14
29
1
[]
[ "<s>", "bool", "X86FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "TRI", "->", "hasStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", "||", "MFI", ".", "hasOpaqueSPAdjustment", "(", ")", "||", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getForceFramePointer", "(", ")", "||", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "hasPreallocatedCall", "(", ")", "||", "MF", ".", "callsUnwindInit", "(", ")", "||", "MF", ".", "hasEHFunclets", "(", ")", "||", "MF", ".", "callsEHReturn", "(", ")", "||", "MFI", ".", "hasStackMap", "(", ")", "||", "MFI", ".", "hasPatchPoint", "(", ")", "||", "MFI", ".", "hasCopyImplyingStackAdjustment", "(", ")", ")", ";", "}", "</s>" ]
[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]
[ "X86", "X86", "X86", "X86" ]
X86FrameLowering1
hasFP
X86
CPU
LLVM
15
127
1
[]
[ "<s>", "XCoreSubtarget", "::", "XCoreSubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ")", ":", "XCoreGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "CPU", ",", "FS", ")", ",", "FrameLowering", "(", "*", "this", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "}", "</s>" ]
[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]
[ "XCore", "XCore", "XCore", "XCore" ]
XCoreSubtarget3
XCoreSubtarget
XCore
MPU
LLVM
16
55
1
[]
[ "<s>", "bool", "rs6000_tls_referenced_p", "(", "rtx", "x", ")", "{", "if", "(", "!", "TARGET_HAVE_TLS", ")", "return", "false", ";", "return", "for_each_rtx", "(", "&", "x", ",", "&", "rs6000_tls_symbol_ref_1", ",", "0", ")", ";", "}", "</s>" ]
[ "Return", "1", "if", "X", "contains", "a", "thread-local", "symbol", "." ]
[ "rs6000", "0" ]
rs60003
rs6000_tls_referenced_p
rs6000
CPU
GCC
17
28
1
[]
[ "<s>", "const", "char", "*", "FISCTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "NULL", ";", "case", "FISCISD", "::", "RET_FLAG", ":", "return", "\"RetFlag\"", ";", "case", "FISCISD", "::", "LOAD_SYM", ":", "return", "\"LOAD_SYM\"", ";", "case", "FISCISD", "::", "MOVEi64", ":", "return", "\"MOVEi64\"", ";", "case", "FISCISD", "::", "CALL", ":", "return", "\"CALL\"", ";", "case", "FISCISD", "::", "SELECT_CC", ":", "return", "\"SELECT_CC\"", ";", "case", "FISCISD", "::", "CMP", ":", "return", "\"CMP\"", ";", "}", "}", "</s>" ]
[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]
[ "FISC", "FISC", "FISCISD::RET_FLAG", "\"RetFlag\"", "FISCISD::LOAD_SYM", "\"LOAD_SYM\"", "FISCISD::MOVEi64", "\"MOVEi64\"", "FISCISD::CALL", "\"CALL\"", "FISCISD::SELECT_CC", "\"SELECT_CC\"", "FISCISD::CMP", "\"CMP\"" ]
FISCISelLowering
getTargetNodeName
FISC
CPU
LLVM
18
72
1
[]
[ "<s>", "bool", "PPCTargetLowering", "::", "SelectAddressPCRel", "(", "SDValue", "N", ",", "SDValue", "&", "Base", ")", "const", "{", "Base", "=", "N", ";", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "PPCISD", "::", "MAT_PCREL_ADDR", ")", "return", "true", ";", "if", "(", "isValidPCRelNode", "<", "ConstantPoolSDNode", ">", "(", "N", ")", "||", "isValidPCRelNode", "<", "GlobalAddressSDNode", ">", "(", "N", ")", "||", "isValidPCRelNode", "<", "JumpTableSDNode", ">", "(", "N", ")", "||", "isValidPCRelNode", "<", "BlockAddressSDNode", ">", "(", "N", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]
[ "SelectAddressPCRel", "-", "Represent", "the", "specified", "address", "as", "pc", "relative", "to", "be", "represented", "as", "[", "pc+imm", "]", "." ]
[ "PowerPC", "PPC", "PPCISD::MAT_PCREL_ADDR" ]
PPCISelLowering100
SelectAddressPCRel
PowerPC
CPU
LLVM
19
74
1
[]
[ "<s>", "unsigned", "AlphaRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "FrameIndexValue", "*", "Value", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToRegister", "(", "FP", "?", "Alpha", "::", "R15", ":", "Alpha", "::", "R30", ",", "false", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"FI: \"", "<<", "FrameIndex", "<<", "\" Offset: \"", "<<", "Offset", "<<", "\"\\n\"", ")", ";", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Corrected Offset \"", "<<", "Offset", "<<", "\" for stack size: \"", "<<", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Offset", ">", "IMM_HIGH", "||", "Offset", "<", "IMM_LOW", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"Unconditionally using R28 for evil purposes Offset: \"", "<<", "Offset", "<<", "\"\\n\"", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToRegister", "(", "Alpha", "::", "R28", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToImmediate", "(", "getLower16", "(", "Offset", ")", ")", ";", "MachineInstr", "*", "nMI", "=", "BuildMI", "(", "MF", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Alpha", "::", "LDAH", ")", ",", "Alpha", "::", "R28", ")", ".", "addImm", "(", "getUpper16", "(", "Offset", ")", ")", ".", "addReg", "(", "FP", "?", "Alpha", "::", "R15", ":", "Alpha", "::", "R30", ")", ";", "MBB", ".", "insert", "(", "II", ",", "nMI", ")", ";", "}", "else", "{", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "return", "0", ";", "}", "</s>" ]
[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]
[ "Alpha", "Alpha", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "1", "Alpha::R15", "Alpha::R30", "\"FI: \"", "\" Offset: \"", "\"\\n\"", "\"Corrected Offset \"", "\" for stack size: \"", "\"\\n\"", "\"Unconditionally using R28 for evil purposes Offset: \"", "\"\\n\"", "1", "Alpha::R28", "Alpha::LDAH", "Alpha::R28", "Alpha::R15", "Alpha::R30", "0" ]
AlphaRegisterInfo
eliminateFrameIndex
Alpha
MPU
LLVM
20
347
1
[]
[ "<s>", "static", "void", "ia64_copy_rbs", "(", "struct", "_Unwind_Context", "*", "info", ",", "unsigned", "long", "dst", ",", "unsigned", "long", "src", ",", "long", "len", ",", "unsigned", "long", "dst_rnat", ")", "{", "long", "count", ";", "unsigned", "long", "src_rnat", ";", "unsigned", "long", "shift1", ",", "shift2", ";", "len", "<<=", "3", ";", "dst_rnat", "&=", "(", "1UL", "<<", "(", "(", "dst", ">>", "3", ")", "&", "0x3f", ")", ")", "-", "1", ";", "src_rnat", "=", "src", ">=", "info", "->", "regstk_top", "?", "info", "->", "rnat", ":", "*", "(", "unsigned", "long", "*", ")", "(", "src", "|", "0x1f8", ")", ";", "src_rnat", "&=", "~", "(", "(", "1UL", "<<", "(", "(", "src", ">>", "3", ")", "&", "0x3f", ")", ")", "-", "1", ")", ";", "src_rnat", "&=", "~", "(", "1UL", "<<", "63", ")", ";", "shift1", "=", "(", "(", "dst", "-", "src", ")", ">>", "3", ")", "&", "0x3f", ";", "if", "(", "(", "dst", "&", "0x1f8", ")", "<", "(", "src", "&", "0x1f8", ")", ")", "shift1", "--", ";", "shift2", "=", "0x3f", "-", "shift1", ";", "if", "(", "(", "dst", "&", "0x1f8", ")", ">=", "(", "src", "&", "0x1f8", ")", ")", "{", "count", "=", "~", "dst", "&", "0x1f8", ";", "goto", "first", ";", "}", "count", "=", "~", "src", "&", "0x1f8", ";", "goto", "second", ";", "while", "(", "len", ">", "0", ")", "{", "src_rnat", "=", "src", ">=", "info", "->", "regstk_top", "?", "info", "->", "rnat", ":", "*", "(", "unsigned", "long", "*", ")", "(", "src", "|", "0x1f8", ")", ";", "src_rnat", "&=", "~", "(", "1UL", "<<", "63", ")", ";", "count", "=", "shift2", "<<", "3", ";", "first", ":", "if", "(", "count", ">", "len", ")", "count", "=", "len", ";", "memcpy", "(", "(", "char", "*", ")", "dst", ",", "(", "char", "*", ")", "src", ",", "count", ")", ";", "dst", "+=", "count", ";", "src", "+=", "count", ";", "len", "-=", "count", ";", "dst_rnat", "|=", "(", "src_rnat", "<<", "shift1", ")", "&", "~", "(", "1UL", "<<", "63", ")", ";", "if", "(", "len", "<=", "0", ")", "break", ";", "*", "(", "long", "*", ")", "dst", "=", "dst_rnat", ";", "dst", "+=", "8", ";", "dst_rnat", "=", "0", ";", "count", "=", "shift1", "<<", "3", ";", "second", ":", "if", "(", "count", ">", "len", ")", "count", "=", "len", ";", "memcpy", "(", "(", "char", "*", ")", "dst", ",", "(", "char", "*", ")", "src", ",", "count", ")", ";", "dst", "+=", "count", ";", "src", "+=", "count", "+", "8", ";", "len", "-=", "count", "+", "8", ";", "dst_rnat", "|=", "(", "src_rnat", ">>", "shift2", ")", ";", "}", "if", "(", "(", "dst", "&", "0x1f8", ")", "==", "0x1f8", ")", "{", "*", "(", "long", "*", ")", "dst", "=", "dst_rnat", ";", "dst", "+=", "8", ";", "dst_rnat", "=", "0", ";", "}", "info", "->", "regstk_top", "=", "dst", "&", "~", "0x1ffUL", ";", "info", "->", "rnat", "=", "dst_rnat", ";", "}", "</s>" ]
[ "Copy", "register", "backing", "store", "from", "SRC", "to", "DST", ",", "LEN", "words", "(", "which", "include", "both", "saved", "registers", "and", "nat", "collections", ")", ".", "DST_RNAT", "is", "a", "partial", "nat", "collection", "for", "DST", ".", "SRC", "and", "DST", "do", "n't", "have", "to", "be", "equal", "modulo", "64", "slots", ",", "so", "it", "can", "not", "be", "done", "with", "a", "simple", "memcpy", "as", "the", "nat", "collections", "will", "be", "at", "different", "relative", "offsets", "and", "need", "to", "be", "combined", "together", "." ]
[ "ia64", "3", "1UL", "3", "0x3f", "1", "0x1f8", "1UL", "3", "0x3f", "1", "1UL", "63", "3", "0x3f", "0x1f8", "0x1f8", "0x3f", "0x1f8", "0x1f8", "0x1f8", "0x1f8", "0", "0x1f8", "1UL", "63", "3", "1UL", "63", "0", "8", "0", "3", "8", "8", "0x1f8", "0x1f8", "8", "0", "0x1ffUL" ]
unwind-ia641
ia64_copy_rbs
ia64
CPU
GCC
21
419
1
[]
[ "<s>", "unsigned", "SIInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "!", "MI", ".", "mayStore", "(", ")", ")", "return", "AMDGPU", "::", "NoRegister", ";", "if", "(", "isMUBUF", "(", "MI", ")", "||", "isVGPRSpill", "(", "MI", ")", ")", "return", "isStackAccess", "(", "MI", ",", "FrameIndex", ")", ";", "if", "(", "isSGPRSpill", "(", "MI", ")", ")", "return", "isSGPRStackAccess", "(", "MI", ",", "FrameIndex", ")", ";", "return", "AMDGPU", "::", "NoRegister", ";", "}", "</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", "." ]
[ "AMDGPU", "SI", "AMDGPU::NoRegister", "AMDGPU::NoRegister" ]
SIInstrInfo (2)
isStoreToStackSlot
AMDGPU
GPU
LLVM
22
71
1
[]
[ "<s>", "void", "rs6000_asm_output_dwarf_pcrel", "(", "FILE", "*", "file", ",", "int", "size", ",", "const", "char", "*", "label", ")", "{", "fputs", "(", "integer_asm_op", "(", "size", ",", "FALSE", ")", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "label", ")", ";", "fputs", "(", "\"-$\"", ",", "file", ")", ";", "}", "</s>" ]
[ "Overide", "the", "default", "'SYMBOL-", ".", "'", "syntax", "with", "AIX", "compatible", "'SYMBOL-", "$", "'", "." ]
[ "rs6000", "\"-$\"" ]
rs6000
rs6000_asm_output_dwarf_pcrel
rs6000
CPU
GCC
23
43
1
[]
[ "<s>", "static", "struct", "machine_function", "*", "tilepro_init_machine_status", "(", "void", ")", "{", "return", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "}", "</s>" ]
[ "Functions", "to", "save", "and", "restore", "machine-specific", "function", "data", "." ]
[ "tilepro" ]
tilepro
tilepro_init_machine_status
tilepro
VLIW
GCC
24
18
1
[]
[ "<s>", "bool", "vax_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict", ")", "{", "rtx", "xfoo0", ",", "xfoo1", ";", "if", "(", "nonindexed_address_p", "(", "x", ",", "strict", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "PLUS", ")", "return", "false", ";", "xfoo0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "xfoo1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "index_term_p", "(", "xfoo0", ",", "mode", ",", "strict", ")", "&&", "nonindexed_address_p", "(", "xfoo1", ",", "strict", ")", ")", "return", "true", ";", "if", "(", "index_term_p", "(", "xfoo1", ",", "mode", ",", "strict", ")", "&&", "nonindexed_address_p", "(", "xfoo0", ",", "strict", ")", ")", "return", "true", ";", "if", "(", "indexable_address_p", "(", "xfoo0", ",", "xfoo1", ",", "mode", ",", "strict", ")", "||", "indexable_address_p", "(", "xfoo1", ",", "xfoo0", ",", "mode", ",", "strict", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]
[ "legitimate_address_p", "returns", "true", "if", "it", "recognizes", "an", "RTL", "expression", "``", "x", "''", "that", "is", "a", "valid", "memory", "address", "for", "an", "instruction", ".", "The", "MODE", "argument", "is", "the", "machine", "mode", "for", "the", "MEM", "expression", "that", "wants", "to", "use", "this", "address", "." ]
[ "vax", "0", "1" ]
vax
vax_legitimate_address_p
vax
CPU
GCC
25
133
1
[]
[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 avoid trailing call pass\"", ";", "}", "</s>" ]
[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]
[ "X86", "\"X86 avoid trailing call pass\"" ]
X86AvoidTrailingCall3
getPassName
X86
CPU
LLVM
26
11
1
[]
[ "<s>", "static", "inline", "ChildIteratorType", "child_begin", "(", "NodeRef", "N", ")", "{", "return", "N", "->", "getChildren", "(", ")", ".", "begin", "(", ")", ";", "}", "</s>" ]
[ "nodes_iterator/begin/end", "-", "Allow", "iteration", "over", "all", "nodes", "in", "the", "graph" ]
[ "Patmos" ]
PatmosStackCacheAnalysis1
child_begin
Patmos
VLIW
LLVM
27
21
1
[]
[ "<s>", "bool", "easy_altivec_constant", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "unsigned", "step", ",", "copies", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "GET_MODE", "(", "op", ")", ";", "else", "if", "(", "mode", "!=", "GET_MODE", "(", "op", ")", ")", "return", "false", ";", "step", "=", "GET_MODE_NUNITS", "(", "mode", ")", "/", "4", ";", "copies", "=", "1", ";", "if", "(", "vspltis_constant", "(", "op", ",", "step", ",", "copies", ")", ")", "return", "true", ";", "if", "(", "step", "==", "1", ")", "copies", "<<=", "1", ";", "else", "step", ">>=", "1", ";", "if", "(", "vspltis_constant", "(", "op", ",", "step", ",", "copies", ")", ")", "return", "true", ";", "if", "(", "step", "==", "1", ")", "copies", "<<=", "1", ";", "else", "step", ">>=", "1", ";", "if", "(", "vspltis_constant", "(", "op", ",", "step", ",", "copies", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]
[ "Return", "true", "if", "OP", "is", "of", "the", "given", "MODE", "and", "can", "be", "synthesized", "with", "a", "vspltisb", ",", "vspltish", "or", "vspltisw", "." ]
[ "rs6000", "4", "1", "1", "1", "1", "1", "1", "1" ]
rs60003
easy_altivec_constant
rs6000
CPU
GCC
28
131
1
[]
[ "<s>", "bool", "AArch64PassConfig", "::", "addIRTranslator", "(", ")", "{", "addPass", "(", "new", "IRTranslator", "(", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]
[ "This", "method", "should", "install", "an", "IR", "translator", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "with", "possibly", "generic", "opcodes", "." ]
[ "AArch64", "AArch64" ]
AArch64TargetMachine1
addIRTranslator
AArch64
CPU
LLVM
29
22
1
[]
[ "<s>", "void", "GCNPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createSIInsertWaits", "(", "*", "TM", ")", ",", "false", ")", ";", "addPass", "(", "createSILowerControlFlowPass", "(", "*", "TM", ")", ",", "false", ")", ";", "}", "</s>" ]
[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]
[ "AMDGPU", "SI", "SI" ]
AMDGPUTargetMachine (2)
addPreEmitPass
AMDGPU
GPU
LLVM
30
30
1
[]
[ "<s>", "unsigned", "AArch64InstrInfo", "::", "getLoadStoreImmIdx", "(", "unsigned", "Opc", ")", "{", "switch", "(", "Opc", ")", "{", "default", ":", "return", "2", ";", "case", "AArch64", "::", "LDPXi", ":", "case", "AArch64", "::", "LDPDi", ":", "case", "AArch64", "::", "STPXi", ":", "case", "AArch64", "::", "STPDi", ":", "case", "AArch64", "::", "LDNPXi", ":", "case", "AArch64", "::", "LDNPDi", ":", "case", "AArch64", "::", "STNPXi", ":", "case", "AArch64", "::", "STNPDi", ":", "case", "AArch64", "::", "LDPQi", ":", "case", "AArch64", "::", "STPQi", ":", "case", "AArch64", "::", "LDNPQi", ":", "case", "AArch64", "::", "STNPQi", ":", "case", "AArch64", "::", "LDPWi", ":", "case", "AArch64", "::", "LDPSi", ":", "case", "AArch64", "::", "STPWi", ":", "case", "AArch64", "::", "STPSi", ":", "case", "AArch64", "::", "LDNPWi", ":", "case", "AArch64", "::", "LDNPSi", ":", "case", "AArch64", "::", "STNPWi", ":", "case", "AArch64", "::", "STNPSi", ":", "case", "AArch64", "::", "LDG", ":", "case", "AArch64", "::", "STGPi", ":", "case", "AArch64", "::", "LD1B_IMM", ":", "case", "AArch64", "::", "LD1H_IMM", ":", "case", "AArch64", "::", "LD1W_IMM", ":", "case", "AArch64", "::", "LD1D_IMM", ":", "case", "AArch64", "::", "ST1B_IMM", ":", "case", "AArch64", "::", "ST1H_IMM", ":", "case", "AArch64", "::", "ST1W_IMM", ":", "case", "AArch64", "::", "ST1D_IMM", ":", "case", "AArch64", "::", "LD1B_H_IMM", ":", "case", "AArch64", "::", "LD1SB_H_IMM", ":", "case", "AArch64", "::", "LD1H_S_IMM", ":", "case", "AArch64", "::", "LD1SH_S_IMM", ":", "case", "AArch64", "::", "LD1W_D_IMM", ":", "case", "AArch64", "::", "LD1SW_D_IMM", ":", "case", "AArch64", "::", "ST1B_H_IMM", ":", "case", "AArch64", "::", "ST1H_S_IMM", ":", "case", "AArch64", "::", "ST1W_D_IMM", ":", "case", "AArch64", "::", "LD1B_S_IMM", ":", "case", "AArch64", "::", "LD1SB_S_IMM", ":", "case", "AArch64", "::", "LD1H_D_IMM", ":", "case", "AArch64", "::", "LD1SH_D_IMM", ":", "case", "AArch64", "::", "ST1B_S_IMM", ":", "case", "AArch64", "::", "ST1H_D_IMM", ":", "case", "AArch64", "::", "LD1B_D_IMM", ":", "case", "AArch64", "::", "LD1SB_D_IMM", ":", "case", "AArch64", "::", "ST1B_D_IMM", ":", "return", "3", ";", "case", "AArch64", "::", "ADDG", ":", "case", "AArch64", "::", "STGOffset", ":", "case", "AArch64", "::", "LDR_PXI", ":", "case", "AArch64", "::", "STR_PXI", ":", "return", "2", ";", "}", "}", "</s>" ]
[ "Returns", "the", "index", "for", "the", "immediate", "for", "a", "given", "instruction", "." ]
[ "AArch64", "AArch64", "2", "AArch64::LDPXi", "AArch64::LDPDi", "AArch64::STPXi", "AArch64::STPDi", "AArch64::LDNPXi", "AArch64::LDNPDi", "AArch64::STNPXi", "AArch64::STNPDi", "AArch64::LDPQi", "AArch64::STPQi", "AArch64::LDNPQi", "AArch64::STNPQi", "AArch64::LDPWi", "AArch64::LDPSi", "AArch64::STPWi", "AArch64::STPSi", "AArch64::LDNPWi", "AArch64::LDNPSi", "AArch64::STNPWi", "AArch64::STNPSi", "AArch64::LDG", "AArch64::STGPi", "AArch64::LD1B_IMM", "AArch64::LD1H_IMM", "AArch64::LD1W_IMM", "AArch64::LD1D_IMM", "AArch64::ST1B_IMM", "AArch64::ST1H_IMM", "AArch64::ST1W_IMM", "AArch64::ST1D_IMM", "AArch64::LD1B_H_IMM", "AArch64::LD1SB_H_IMM", "AArch64::LD1H_S_IMM", "AArch64::LD1SH_S_IMM", "AArch64::LD1W_D_IMM", "AArch64::LD1SW_D_IMM", "AArch64::ST1B_H_IMM", "AArch64::ST1H_S_IMM", "AArch64::ST1W_D_IMM", "AArch64::LD1B_S_IMM", "AArch64::LD1SB_S_IMM", "AArch64::LD1H_D_IMM", "AArch64::LD1SH_D_IMM", "AArch64::ST1B_S_IMM", "AArch64::ST1H_D_IMM", "AArch64::LD1B_D_IMM", "AArch64::LD1SB_D_IMM", "AArch64::ST1B_D_IMM", "3", "AArch64::ADDG", "AArch64::STGOffset", "AArch64::LDR_PXI", "AArch64::STR_PXI", "2" ]
AArch64InstrInfo107
getLoadStoreImmIdx
AArch64
CPU
LLVM
31
287
1
[]
[ "<s>", "bool", "XCoreRegisterInfo", "::", "needsFrameMoves", "(", "const", "MachineFunction", "&", "MF", ")", "{", "return", "MF", ".", "needsFrameMoves", "(", ")", ";", "}", "</s>" ]
[ "Return", "whether", "to", "emit", "frame", "moves", "." ]
[ "XCore", "XCore" ]
XCoreRegisterInfo (2)1
needsFrameMoves
XCore
MPU
LLVM
32
19
1
[]
[ "<s>", "MCSymbol", "*", "X86MCInstLower", "::", "GetSymbolFromOperand", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "assert", "(", "(", "MO", ".", "isGlobal", "(", ")", "||", "MO", ".", "isSymbol", "(", ")", "||", "MO", ".", "isMBB", "(", ")", ")", "&&", "\"Isn't a symbol reference\"", ")", ";", "MCSymbol", "*", "Sym", "=", "nullptr", ";", "SmallString", "<", "128", ">", "Name", ";", "StringRef", "Suffix", ";", "switch", "(", "MO", ".", "getTargetFlags", "(", ")", ")", "{", "case", "X86II", "::", "MO_DLLIMPORT", ":", "Name", "+=", "\"__imp_\"", ";", "break", ";", "case", "X86II", "::", "MO_DARWIN_STUB", ":", "Suffix", "=", "\"$stub\"", ";", "break", ";", "case", "X86II", "::", "MO_DARWIN_NONLAZY", ":", "case", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ":", "Suffix", "=", "\"$non_lazy_ptr\"", ";", "break", ";", "}", "if", "(", "!", "Suffix", ".", "empty", "(", ")", ")", "Name", "+=", "DL", ".", "getPrivateGlobalPrefix", "(", ")", ";", "unsigned", "PrefixLen", "=", "Name", ".", "size", "(", ")", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "AsmPrinter", ".", "getNameWithPrefix", "(", "Name", ",", "GV", ")", ";", "}", "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "{", "Mangler", "::", "getNameWithPrefix", "(", "Name", ",", "MO", ".", "getSymbolName", "(", ")", ",", "DL", ")", ";", "}", "else", "if", "(", "MO", ".", "isMBB", "(", ")", ")", "{", "assert", "(", "Suffix", ".", "empty", "(", ")", ")", ";", "Sym", "=", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ";", "}", "unsigned", "OrigLen", "=", "Name", ".", "size", "(", ")", "-", "PrefixLen", ";", "Name", "+=", "Suffix", ";", "if", "(", "!", "Sym", ")", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "Name", ")", ";", "StringRef", "OrigName", "=", "StringRef", "(", "Name", ")", ".", "substr", "(", "PrefixLen", ",", "OrigLen", ")", ";", "switch", "(", "MO", ".", "getTargetFlags", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86II", "::", "MO_DARWIN_NONLAZY", ":", "case", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ":", "{", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "getMachOMMI", "(", ")", ".", "getGVStubEntry", "(", "Sym", ")", ";", "if", "(", "!", "StubSym", ".", "getPointer", "(", ")", ")", "{", "assert", "(", "MO", ".", "isGlobal", "(", ")", "&&", "\"Extern symbol not handled yet\"", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AsmPrinter", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "break", ";", "}", "case", "X86II", "::", "MO_DARWIN_STUB", ":", "{", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "getMachOMMI", "(", ")", ".", "getFnStubEntry", "(", "Sym", ")", ";", "if", "(", "StubSym", ".", "getPointer", "(", ")", ")", "return", "Sym", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AsmPrinter", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "else", "{", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "Ctx", ".", "getOrCreateSymbol", "(", "OrigName", ")", ",", "false", ")", ";", "}", "break", ";", "}", "}", "return", "Sym", ";", "}", "</s>" ]
[ "Lower", "an", "MO_GlobalAddress", "or", "MO_ExternalSymbol", "operand", "to", "an", "MCSymbol", "." ]
[ "X86", "X86", "\"Isn't a symbol reference\"", "128", "X86II::MO_DLLIMPORT", "\"__imp_\"", "X86II::MO_DARWIN_STUB", "\"$stub\"", "X86II::MO_DARWIN_NONLAZY", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "\"$non_lazy_ptr\"", "X86II::MO_DARWIN_NONLAZY", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "\"Extern symbol not handled yet\"", "X86II::MO_DARWIN_STUB" ]
X86MCInstLower113
GetSymbolFromOperand
X86
CPU
LLVM
33
461
1
[]
[ "<s>", "TargetPassConfig", "*", "MMIXTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "MMIXPassConfig", "(", "*", "this", ",", "PM", ")", ";", "}", "</s>" ]
[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]
[ "MMIX", "MMIX", "MMIX" ]
MMIXTargetMachine
createPassConfig
MMIX
CPU
LLVM
34
22
1
[]
[ "<s>", "void", "X86FrameLowering", "::", "emitSPUpdate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "int64_t", "NumBytes", ",", "bool", "InEpilogue", ")", "const", "{", "bool", "isSub", "=", "NumBytes", "<", "0", ";", "uint64_t", "Offset", "=", "isSub", "?", "-", "NumBytes", ":", "NumBytes", ";", "uint64_t", "Chunk", "=", "(", "1LL", "<<", "31", ")", "-", "1", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "if", "(", "Offset", "==", "0", ")", "{", "MachineInstrBuilder", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "SUB64ri8", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "0", ")", ";", "if", "(", "!", "InEpilogue", ")", "MI", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "else", "MI", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "while", "(", "Offset", ")", "{", "if", "(", "Offset", ">", "Chunk", ")", "{", "unsigned", "Reg", "=", "0", ";", "if", "(", "isSub", "&&", "!", "isEAXLiveIn", "(", "MBB", ")", ")", "Reg", "=", "(", "unsigned", ")", "(", "Is64Bit", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ")", ";", "else", "Reg", "=", "findDeadCallerSavedReg", "(", "MBB", ",", "MBBI", ",", "TRI", ",", "Is64Bit", ")", ";", "if", "(", "Reg", ")", "{", "unsigned", "Opc", "=", "Is64Bit", "?", "X86", "::", "MOV64ri", ":", "X86", "::", "MOV32ri", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "Reg", ")", ".", "addImm", "(", "Offset", ")", ";", "Opc", "=", "isSub", "?", "getSUBrrOpcode", "(", "Is64Bit", ")", ":", "getADDrrOpcode", "(", "Is64Bit", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addReg", "(", "Reg", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "Offset", "=", "0", ";", "continue", ";", "}", "}", "uint64_t", "ThisVal", "=", "std", "::", "min", "(", "Offset", ",", "Chunk", ")", ";", "if", "(", "ThisVal", "==", "(", "Is64Bit", "?", "8", ":", "4", ")", "&&", "false", ")", "{", "unsigned", "Reg", "=", "isSub", "?", "(", "unsigned", ")", "(", "Is64Bit", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ")", ":", "findDeadCallerSavedReg", "(", "MBB", ",", "MBBI", ",", "TRI", ",", "Is64Bit", ")", ";", "if", "(", "Reg", ")", "{", "unsigned", "Opc", "=", "isSub", "?", "(", "Is64Bit", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ")", ":", "(", "Is64Bit", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "getDefRegState", "(", "!", "isSub", ")", "|", "getUndefRegState", "(", "isSub", ")", ")", ";", "if", "(", "isSub", ")", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "else", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "Offset", "-=", "ThisVal", ";", "continue", ";", "}", "}", "MachineInstrBuilder", "MI", "=", "BuildStackAdjustment", "(", "MBB", ",", "MBBI", ",", "DL", ",", "isSub", "?", "-", "ThisVal", ":", "ThisVal", ",", "InEpilogue", ")", ";", "if", "(", "isSub", ")", "MI", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "else", "MI", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "Offset", "-=", "ThisVal", ";", "}", "}", "</s>" ]
[ "Emit", "a", "series", "of", "instructions", "to", "increment", "/", "decrement", "the", "stack", "pointer", "by", "a", "constant", "value", "." ]
[ "X86", "X86", "0", "1LL", "31", "1", "0", "X86::SUB64ri8", "0", "0", "X86::RAX", "X86::EAX", "X86::MOV64ri", "X86::MOV32ri", "3", "0", "8", "4", "X86::RAX", "X86::EAX", "X86::PUSH64r", "X86::PUSH32r", "X86::POP64r", "X86::POP32r" ]
X86FrameLowering8
emitSPUpdate
X86
CPU
LLVM
35
499
1
[]
[ "<s>", "void", "HexagonInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "assert", "(", "HexagonMCInstrInfo", "::", "isBundle", "(", "*", "MI", ")", ")", ";", "assert", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "*", "MI", ")", "<=", "HEXAGON_PACKET_SIZE", ")", ";", "assert", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "*", "MI", ")", ">", "0", ")", ";", "HasExtender", "=", "false", ";", "for", "(", "auto", "const", "&", "I", ":", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "*", "MI", ")", ")", "{", "MCInst", "const", "&", "MCI", "=", "*", "I", ".", "getInst", "(", ")", ";", "if", "(", "HexagonMCInstrInfo", "::", "isDuplex", "(", "MII", ",", "MCI", ")", ")", "{", "printInstruction", "(", "MCI", ".", "getOperand", "(", "1", ")", ".", "getInst", "(", ")", ",", "OS", ")", ";", "OS", "<<", "'\\v'", ";", "HasExtender", "=", "false", ";", "printInstruction", "(", "MCI", ".", "getOperand", "(", "0", ")", ".", "getInst", "(", ")", ",", "OS", ")", ";", "}", "else", "printInstruction", "(", "&", "MCI", ",", "OS", ")", ";", "setExtender", "(", "MCI", ")", ";", "OS", "<<", "\"\\n\"", ";", "}", "bool", "IsLoop0", "=", "HexagonMCInstrInfo", "::", "isInnerLoop", "(", "*", "MI", ")", ";", "bool", "IsLoop1", "=", "HexagonMCInstrInfo", "::", "isOuterLoop", "(", "*", "MI", ")", ";", "if", "(", "IsLoop0", ")", "{", "OS", "<<", "(", "IsLoop1", "?", "\" :endloop01\"", ":", "\" :endloop0\"", ")", ";", "}", "else", "if", "(", "IsLoop1", ")", "{", "OS", "<<", "\" :endloop1\"", ";", "}", "}", "</s>" ]
[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]
[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "0", "Hexagon", "Hexagon", "1", "0", "\"\\n\"", "Hexagon", "Hexagon", "\" :endloop01\"", "\" :endloop0\"", "\" :endloop1\"" ]
HexagonInstPrinter9
printInst
Hexagon
DSP
LLVM
36
214
1
[]
[ "<s>", "static", "bool", "ix86_secondary_memory_needed", "(", "machine_mode", "mode", ",", "reg_class_t", "class1", ",", "reg_class_t", "class2", ")", "{", "return", "inline_secondary_memory_needed", "(", "mode", ",", "class1", ",", "class2", ",", "true", ")", ";", "}", "</s>" ]
[ "If", "we", "are", "copying", "between", "general", "and", "FP", "registers", ",", "we", "need", "a", "memory", "location", ".", "The", "same", "is", "true", "for", "SSE", "and", "MMX", "registers", ".", "The", "macro", "ca", "n't", "work", "reliably", "when", "one", "of", "the", "CLASSES", "is", "class", "containing", "registers", "from", "multiple", "units", "(", "SSE", ",", "MMX", ",", "integer", ")", ".", "We", "avoid", "this", "by", "never", "combining", "those", "units", "in", "single", "alternative", "in", "the", "machine", "description", ".", "Ensure", "that", "this", "constraint", "holds", "to", "avoid", "unexpected", "surprises", ".", "When", "STRICT", "is", "false", ",", "we", "are", "being", "called", "from", "REGISTER_MOVE_COST", ",", "so", "do", "not", "enforce", "these", "sanity", "checks", "." ]
[ "i386" ]
i386
ix86_secondary_memory_needed
i386
CPU
GCC
37
27
1
[]
[ "<s>", "void", "R600SchedStrategy", "::", "schedNode", "(", "SUnit", "*", "SU", ",", "bool", "IsTopNode", ")", "{", "if", "(", "NextInstKind", "!=", "CurInstKind", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Instruction Type Switch\\n\"", ")", ";", "if", "(", "NextInstKind", "!=", "IDAlu", ")", "OccupiedSlotsMask", "|=", "31", ";", "CurEmitted", "=", "0", ";", "CurInstKind", "=", "NextInstKind", ";", "}", "if", "(", "CurInstKind", "==", "IDAlu", ")", "{", "AluInstCount", "++", ";", "switch", "(", "getAluKind", "(", "SU", ")", ")", "{", "case", "AluT_XYZW", ":", "CurEmitted", "+=", "4", ";", "break", ";", "case", "AluDiscarded", ":", "break", ";", "default", ":", "{", "++", "CurEmitted", ";", "for", "(", "MachineInstr", "::", "mop_iterator", "It", "=", "SU", "->", "getInstr", "(", ")", "->", "operands_begin", "(", ")", ",", "E", "=", "SU", "->", "getInstr", "(", ")", "->", "operands_end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "MachineOperand", "&", "MO", "=", "*", "It", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "R600", "::", "ALU_LITERAL_X", ")", "++", "CurEmitted", ";", "}", "}", "}", "}", "else", "{", "++", "CurEmitted", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "CurEmitted", "<<", "\" Instructions Emitted in this clause\\n\"", ")", ";", "if", "(", "CurInstKind", "!=", "IDFetch", ")", "{", "MoveUnits", "(", "Pending", "[", "IDFetch", "]", ",", "Available", "[", "IDFetch", "]", ")", ";", "}", "else", "FetchInstCount", "++", ";", "}", "</s>" ]
[ "ScheduleDAGMI", "has", "scheduled", "an", "instruction", "-", "tell", "HazardRec", "about", "it", "." ]
[ "AMDGPU", "R600", "\"Instruction Type Switch\\n\"", "31", "0", "4", "R600::ALU_LITERAL_X", "\" Instructions Emitted in this clause\\n\"" ]
R600MachineScheduler10
schedNode
AMDGPU
GPU
LLVM
38
198
1
[]
[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "if", "(", "!", "Expr", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "else", "if", "(", "const", "auto", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]
[ "Add", "a", "new", "MCExpr", "operand", "." ]
[ "VE", "0" ]
VEAsmParser (2)
addExpr
VE
CPU
LLVM
39
77
1
[]
[ "<s>", "MachineInstrBuilder", "R600InstrInfo", "::", "buildIndirectRead", "(", "MachineBasicBlock", "*", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "ValueReg", ",", "unsigned", "Address", ",", "unsigned", "OffsetReg", ")", "const", "{", "unsigned", "AddrReg", "=", "AMDGPU", "::", "R600_AddrRegClass", ".", "getRegister", "(", "Address", ")", ";", "MachineInstr", "*", "MOVA", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "AMDGPU", "::", "MOVA_INT_eg", ",", "AMDGPU", "::", "AR_X", ",", "OffsetReg", ")", ";", "setImmOperand", "(", "MOVA", ",", "R600Operands", "::", "WRITE", ",", "0", ")", ";", "MachineInstrBuilder", "Mov", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "AMDGPU", "::", "MOV", ",", "ValueReg", ",", "AddrReg", ")", ".", "addReg", "(", "AMDGPU", "::", "AR_X", ",", "RegState", "::", "Implicit", "|", "RegState", "::", "Kill", ")", ";", "setImmOperand", "(", "Mov", ",", "R600Operands", "::", "SRC0_REL", ",", "1", ")", ";", "return", "Mov", ";", "}", "</s>" ]
[ "Build", "instruction", "(", "s", ")", "for", "an", "indirect", "register", "read", "." ]
[ "R600", "R600Operands::WRITE", "0", "R600Operands::SRC0_REL", "1" ]
R600InstrInfo65
buildIndirectRead
R600
GPU
LLVM
40
119
1
[]
[ "<s>", "void", "TeakFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "computeStackSize", "(", "MF", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "StackSize", "-=", "CSI", ".", "size", "(", ")", "*", "2", ";", "if", "(", "!", "StackSize", ")", "return", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Teak", "::", "MOV_regnobp016_regnob16", ")", ",", "Teak", "::", "SP", ")", ".", "addReg", "(", "Teak", "::", "R7", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Teak", "::", "NOP", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Teak", "::", "POP_regnob16", ")", ",", "Teak", "::", "R7", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "</s>" ]
[ "Insert", "epilog", "code", "into", "the", "function", "." ]
[ "Teak", "Teak", "2", "Teak::MOV_regnobp016_regnob16", "Teak::SP", "Teak::R7", "Teak::NOP", "Teak::POP_regnob16", "Teak::R7" ]
TeakFrameLowering
emitEpilogue
Teak
DSP
LLVM
41
200
1
[]
[ "<s>", "TargetPassConfig", "*", "PatmosTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "PatmosPassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]
[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]
[ "Patmos", "Patmos", "Patmos" ]
PatmosTargetMachine
createPassConfig
Patmos
VLIW
LLVM
42
21
1
[]
[ "<s>", "static", "MBlazeOperand", "*", "CreateReg", "(", "unsigned", "RegNum", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "MBlazeOperand", "*", "Op", "=", "new", "MBlazeOperand", "(", "Register", ")", ";", "Op", "->", "Reg", ".", "RegNum", "=", "RegNum", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]
[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]
[ "MBlaze", "MBlaze", "MBlaze", "MBlaze" ]
MBlazeAsmParser1
CreateReg
MBlaze
MPU
LLVM
43
49
1
[]
[ "<s>", "bool", "umips_12bit_offset_address_p", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "struct", "mips_address_info", "addr", ";", "return", "(", "mips_classify_address", "(", "&", "addr", ",", "x", ",", "mode", ",", "false", ")", "&&", "addr", ".", "type", "==", "ADDRESS_REG", "&&", "CONST_INT_P", "(", "addr", ".", "offset", ")", "&&", "UMIPS_12BIT_OFFSET_P", "(", "INTVAL", "(", "addr", ".", "offset", ")", ")", ")", ";", "}", "</s>" ]
[ "Return", "true", "if", "X", "is", "a", "legitimate", "address", "with", "a", "12-bit", "offset", ".", "MODE", "is", "the", "mode", "of", "the", "value", "being", "accessed", "." ]
[ "mips" ]
mips
umips_12bit_offset_address_p
mips
CPU
GCC
44
53
1
[]
[ "<s>", "const", "char", "*", "mcore_output_jump_label_table", "(", "void", ")", "{", "int", "i", ";", "if", "(", "pool_size", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t.align 2\\n\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "pool_size", ";", "i", "++", ")", "{", "pool_node", "*", "p", "=", "pool_vector", "+", "i", ";", "(", "*", "targetm", ".", "asm_out", ".", "internal_label", ")", "(", "asm_out_file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "p", "->", "label", ")", ")", ";", "output_asm_insn", "(", "\".long\t%0\"", ",", "&", "p", "->", "value", ")", ";", "}", "pool_size", "=", "0", ";", "}", "return", "\"\"", ";", "}", "</s>" ]
[ "Dump", "out", "any", "constants", "accumulated", "in", "the", "final", "pass", ".", "These", "will", "only", "be", "labels", "." ]
[ "mcore", "\"\\t.align 2\\n\"", "0", "\"L\"", "\".long\t%0\"", "0", "\"\"" ]
mcore
mcore_output_jump_label_table
mcore
MPU
GCC
45
86
1
[]
[ "<s>", "void", "GBZ80FrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "}", "</s>" ]
[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]
[ "GBZ80", "GB" ]
GBZ80FrameLowering
determineCalleeSaves
GBZ80
MPU
LLVM
46
31
1
[]
[ "<s>", "void", "JVMPassConfig", "::", "addIRPasses", "(", ")", "{", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "addPass", "(", "createJVMLowerMemoryIntrinsics", "(", ")", ")", ";", "addPass", "(", "createAggressiveDCEPass", "(", ")", ")", ";", "if", "(", "JvmAggOpt", ")", "addPass", "(", "createInstructionCombiningPass", "(", ")", ")", ";", "addPass", "(", "createJVMIRDecorator", "(", ")", ")", ";", "addPass", "(", "createAggressiveDCEPass", "(", ")", ")", ";", "if", "(", "JvmAggOpt", ")", "addPass", "(", "createInstructionCombiningPass", "(", ")", ")", ";", "if", "(", "JvmClient", ")", "addPass", "(", "createX2JavaPass", "(", ")", ")", ";", "}", "</s>" ]
[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]
[ "JVM", "JVM", "JVM", "JVM" ]
JVMTargetMachine
addIRPasses
JVM
Virtual ISA
LLVM
47
75
1
[]
[ "<s>", "static", "void", "aarch64_parse_cpu", "(", "void", ")", "{", "char", "*", "ext", ";", "const", "struct", "processor", "*", "cpu", ";", "char", "*", "str", "=", "(", "char", "*", ")", "alloca", "(", "strlen", "(", "aarch64_cpu_string", ")", "+", "1", ")", ";", "size_t", "len", ";", "strcpy", "(", "str", ",", "aarch64_cpu_string", ")", ";", "ext", "=", "strchr", "(", "str", ",", "'+'", ")", ";", "if", "(", "ext", "!=", "NULL", ")", "len", "=", "ext", "-", "str", ";", "else", "len", "=", "strlen", "(", "str", ")", ";", "if", "(", "len", "==", "0", ")", "{", "error", "(", "\"missing cpu name in -mcpu=%qs\"", ",", "str", ")", ";", "return", ";", "}", "for", "(", "cpu", "=", "all_cores", ";", "cpu", "->", "name", "!=", "NULL", ";", "cpu", "++", ")", "{", "if", "(", "strlen", "(", "cpu", "->", "name", ")", "==", "len", "&&", "strncmp", "(", "cpu", "->", "name", ",", "str", ",", "len", ")", "==", "0", ")", "{", "selected_cpu", "=", "cpu", ";", "aarch64_isa_flags", "=", "selected_cpu", "->", "flags", ";", "if", "(", "ext", "!=", "NULL", ")", "{", "aarch64_parse_extension", "(", "ext", ")", ";", "}", "return", ";", "}", "}", "error", "(", "\"unknown value %qs for -mcpu\"", ",", "str", ")", ";", "return", ";", "}", "</s>" ]
[ "Parse", "the", "TO_PARSE", "string", "and", "put", "the", "result", "tuning", "in", "RES", "and", "the", "architecture", "flags", "in", "ISA_FLAGS", ".", "Return", "an", "aarch64_parse_opt_result", "describing", "the", "parse", "result", ".", "If", "there", "is", "an", "error", "parsing", ",", "RES", "and", "ISA_FLAGS", "are", "left", "unchanged", "." ]
[ "aarch64", "1", "0", "\"missing cpu name in -mcpu=%qs\"", "0", "\"unknown value %qs for -mcpu\"" ]
aarch642
aarch64_parse_cpu
aarch64
CPU
GCC
48
169
1
[]
[ "<s>", "static", "std", "::", "unique_ptr", "<", "SNESOperand", ">", "CreateReg", "(", "unsigned", "RegNum", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "return", "make_unique", "<", "SNESOperand", ">", "(", "RegNum", ",", "S", ",", "E", ")", ";", "}", "</s>" ]
[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]
[ "SNES", "SNES", "SNES" ]
SNESAsmParser
CreateReg
SNES
DSP
LLVM
49
33
1
[]
[ "<s>", "bool", "XCoreFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "XCoreFunctionInfo", "*", "XFI", "=", "MF", "->", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "bool", "emitFrameMoves", "=", "XCoreRegisterInfo", "::", "needsFrameMoves", "(", "*", "MF", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "it", "=", "CSI", ".", "begin", "(", ")", ";", "it", "!=", "CSI", ".", "end", "(", ")", ";", "++", "it", ")", "{", "unsigned", "Reg", "=", "it", "->", "getReg", "(", ")", ";", "assert", "(", "Reg", "!=", "XCore", "::", "LR", "&&", "!", "(", "Reg", "==", "XCore", "::", "R10", "&&", "hasFP", "(", "*", "MF", ")", ")", "&&", "\"LR & FP are always handled in emitPrologue\"", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "it", "->", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "if", "(", "emitFrameMoves", ")", "{", "auto", "Store", "=", "MI", ";", "--", "Store", ";", "XFI", "->", "getSpillLabels", "(", ")", ".", "push_back", "(", "std", "::", "make_pair", "(", "Store", ",", "*", "it", ")", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]
[ "spillCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "spill", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "store", "instructions", "via", "storeRegToStackSlot", "(", ")", "." ]
[ "XCore", "XCore", "XCore", "XCore", "XCore", "XCore::LR", "XCore::R10", "\"LR & FP are always handled in emitPrologue\"" ]
XCoreFrameLowering24
spillCalleeSavedRegisters
XCore
MPU
LLVM
50
258
1
[]
[ "<s>", "int", "rs6000_trampoline_size", "(", ")", "{", "int", "ret", "=", "0", ";", "switch", "(", "DEFAULT_ABI", ")", "{", "default", ":", "abort", "(", ")", ";", "case", "ABI_AIX", ":", "ret", "=", "(", "TARGET_32BIT", ")", "?", "12", ":", "24", ";", "break", ";", "case", "ABI_DARWIN", ":", "case", "ABI_V4", ":", "case", "ABI_AIX_NODESC", ":", "ret", "=", "(", "TARGET_32BIT", ")", "?", "40", ":", "48", ";", "break", ";", "}", "return", "ret", ";", "}", "</s>" ]
[ "Length", "in", "units", "of", "the", "trampoline", "for", "entering", "a", "nested", "function", "." ]
[ "rs6000", "0", "12", "24", "40", "48" ]
rs60002
rs6000_trampoline_size
rs6000
CPU
GCC
51
62
1
[]
[ "<s>", "static", "bool", "msp430_check_plus_not_high_mem", "(", "rtx", "op", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "PLUS", ")", "return", "false", ";", "rtx", "op0", "=", "XEXP", "(", "op", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "op", ",", "1", ")", ";", "if", "(", "SYMBOL_REF_P", "(", "op0", ")", "&&", "(", "SYMBOL_REF_FLAGS", "(", "op0", ")", "&", "SYMBOL_FLAG_LOW_MEM", ")", "&&", "msp430_check_index_not_high_mem", "(", "op1", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]
[ "If", "this", "returns", "true", ",", "we", "do", "n't", "need", "a", "430X", "insn", "." ]
[ "msp430", "0", "1" ]
msp430
msp430_check_plus_not_high_mem
msp430
MPU
GCC
52
68
1
[]
[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]
[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]
[ "PowerPC" ]
PPCAsmBackend (2)1
mayNeedRelaxation
PowerPC
CPU
LLVM
53
20
1
[]
[ "<s>", "void", "SparcFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "Size", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "SP", "::", "ADJCALLSTACKDOWN", ")", "Size", "=", "-", "Size", ";", "const", "SparcInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SparcInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "Size", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", ".", "get", "(", "SP", "::", "ADDri", ")", ",", "SP", "::", "O6", ")", ".", "addReg", "(", "SP", "::", "O6", ")", ".", "addImm", "(", "Size", ")", ";", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]
[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]
[ "Sparc", "Sparc", "0", "SP::ADJCALLSTACKDOWN", "Sparc", "Sparc", "SP::ADDri", "SP::O6", "SP::O6" ]
SparcFrameLowering3
eliminateCallFramePseudoInstr
Sparc
CPU
LLVM
54
147
1
[]
[ "<s>", "bool", "SystemZShortenInst", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "*", "F", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "SystemZSubtarget", "&", "ST", "=", "F", ".", "getSubtarget", "<", "SystemZSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "LiveRegs", ".", "init", "(", "TRI", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "F", ")", "Changed", "|=", "processBlock", "(", "MBB", ")", ";", "return", "Changed", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "SystemZ", "SystemZ", "SystemZ", "SystemZ" ]
SystemZShortenInst21
runOnMachineFunction
SystemZ
CPU
LLVM
55
86
1
[]
[ "<s>", "bool", "loongarch_split_move_p", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "unsigned", "int", "size", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "dest", ")", ")", ";", "if", "(", "size", "==", "8", "&&", "FP_REG_RTX_P", "(", "src", ")", "&&", "FP_REG_RTX_P", "(", "dest", ")", ")", "return", "false", ";", "if", "(", "size", "==", "8", ")", "{", "if", "(", "FP_REG_RTX_P", "(", "dest", ")", "&&", "MEM_P", "(", "src", ")", ")", "return", "false", ";", "if", "(", "FP_REG_RTX_P", "(", "src", ")", "&&", "MEM_P", "(", "dest", ")", ")", "return", "false", ";", "}", "return", "size", ">", "UNITS_PER_WORD", ";", "}", "</s>" ]
[ "Return", "true", "if", "a", "move", "from", "SRC", "to", "DEST", "should", "be", "split", "into", "two", ".", "SPLIT_TYPE", "describes", "the", "split", "condition", "." ]
[ "loongarch", "8", "8" ]
loongarch
loongarch_split_move_p
loongarch
CPU
GCC
56
85
1
[]
[ "<s>", "XCoreTargetMachine", "::", "XCoreTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ")", ",", "Subtarget", "(", "TT", ",", "FS", ")", ",", "DataLayout", "(", "\"e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-\"", "\"i16:16:32-i32:32:32-i64:32:32-n32\"", ")", ",", "InstrInfo", "(", ")", ",", "FrameInfo", "(", "*", "this", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "TSInfo", "(", "*", "this", ")", "{", "}", "</s>" ]
[ "Create", "an", "ILP32", "architecture", "model", "." ]
[ "XCore", "XCore", "XCore", "\"e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-\"", "\"i16:16:32-i32:32:32-i64:32:32-n32\"" ]
XCoreTargetMachine14
XCoreTargetMachine
XCore
MPU
LLVM
57
67
1
[]
[ "<s>", "unsigned", "HexagonInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Hexagon", "::", "L2_loadri_io", ":", "case", "Hexagon", "::", "L2_loadrd_io", ":", "case", "Hexagon", "::", "L2_loadrh_io", ":", "case", "Hexagon", "::", "L2_loadrb_io", ":", "case", "Hexagon", "::", "L2_loadrub_io", ":", "if", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "0", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]
[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]
[ "Hexagon", "Hexagon", "Hexagon::L2_loadri_io", "Hexagon::L2_loadrd_io", "Hexagon::L2_loadrh_io", "Hexagon::L2_loadrb_io", "Hexagon::L2_loadrub_io", "2", "1", "1", "0", "2", "0", "0" ]
HexagonInstrInfo
isLoadFromStackSlot
Hexagon
DSP
LLVM
58
127
1
[]
[ "<s>", "bool", "NVPTXInferAddressSpaces", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "std", "::", "vector", "<", "Value", "*", ">", "Postorder", "=", "collectGenericAddressExpressions", "(", "F", ")", ";", "ValueToAddrSpaceMapTy", "InferredAddrSpace", ";", "inferAddressSpaces", "(", "Postorder", ",", "&", "InferredAddrSpace", ")", ";", "return", "rewriteWithNewAddressSpaces", "(", "Postorder", ",", "InferredAddrSpace", ",", "&", "F", ")", ";", "}", "</s>" ]
[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]
[ "NVPTX", "NVPTX" ]
NVPTXInferAddressSpaces
runOnFunction
NVPTX
GPU
LLVM
59
57
1
[]
[ "<s>", "const", "MCExpr", "*", "SparcELFTargetObjectFile", "::", "getTTypeGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "unsigned", "Encoding", ",", "Mangler", "&", "Mang", ",", "const", "TargetMachine", "&", "TM", ",", "MachineModuleInfo", "*", "MMI", ",", "MCStreamer", "&", "Streamer", ")", "const", "{", "if", "(", "Encoding", "&", "dwarf", "::", "DW_EH_PE_pcrel", ")", "{", "MachineModuleInfoELF", "&", "ELFMMI", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoELF", ">", "(", ")", ";", "MCSymbol", "*", "SSym", "=", "getSymbolWithGlobalValueBase", "(", "GV", ",", "\".DW.stub\"", ",", "Mang", ",", "TM", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "ELFMMI", ".", "getGVStubEntry", "(", "SSym", ")", ";", "if", "(", "!", "StubSym", ".", "getPointer", "(", ")", ")", "{", "MCSymbol", "*", "Sym", "=", "TM", ".", "getSymbol", "(", "GV", ",", "Mang", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "Sym", ",", "!", "GV", "->", "hasLocalLinkage", "(", ")", ")", ";", "}", "MCContext", "&", "Ctx", "=", "getContext", "(", ")", ";", "return", "SparcMCExpr", "::", "Create", "(", "SparcMCExpr", "::", "VK_Sparc_R_DISP32", ",", "MCSymbolRefExpr", "::", "Create", "(", "SSym", ",", "Ctx", ")", ",", "Ctx", ")", ";", "}", "return", "TargetLoweringObjectFileELF", "::", "getTTypeGlobalReference", "(", "GV", ",", "Encoding", ",", "Mang", ",", "TM", ",", "MMI", ",", "Streamer", ")", ";", "}", "</s>" ]
[ "The", "mach-o", "version", "of", "this", "method", "defaults", "to", "returning", "a", "stub", "reference", "." ]
[ "Sparc", "Sparc", "\".DW.stub\"", "Sparc", "Sparc", "SP" ]
SparcTargetObjectFile15
getTTypeGlobalReference
Sparc
CPU
LLVM
60
173
1
[]
[ "<s>", "int", "ARMAsmParser", "::", "tryParseRegister", "(", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "const", "AsmToken", "&", "Tok", "=", "Parser", ".", "getTok", "(", ")", ";", "if", "(", "Tok", ".", "isNot", "(", "AsmToken", "::", "Identifier", ")", ")", "return", "-", "1", ";", "std", "::", "string", "lowerCase", "=", "Tok", ".", "getString", "(", ")", ".", "lower", "(", ")", ";", "unsigned", "RegNum", "=", "MatchRegisterName", "(", "lowerCase", ")", ";", "if", "(", "!", "RegNum", ")", "{", "RegNum", "=", "StringSwitch", "<", "unsigned", ">", "(", "lowerCase", ")", ".", "Case", "(", "\"r13\"", ",", "ARM", "::", "SP", ")", ".", "Case", "(", "\"r14\"", ",", "ARM", "::", "LR", ")", ".", "Case", "(", "\"r15\"", ",", "ARM", "::", "PC", ")", ".", "Case", "(", "\"ip\"", ",", "ARM", "::", "R12", ")", ".", "Case", "(", "\"a1\"", ",", "ARM", "::", "R0", ")", ".", "Case", "(", "\"a2\"", ",", "ARM", "::", "R1", ")", ".", "Case", "(", "\"a3\"", ",", "ARM", "::", "R2", ")", ".", "Case", "(", "\"a4\"", ",", "ARM", "::", "R3", ")", ".", "Case", "(", "\"v1\"", ",", "ARM", "::", "R4", ")", ".", "Case", "(", "\"v2\"", ",", "ARM", "::", "R5", ")", ".", "Case", "(", "\"v3\"", ",", "ARM", "::", "R6", ")", ".", "Case", "(", "\"v4\"", ",", "ARM", "::", "R7", ")", ".", "Case", "(", "\"v5\"", ",", "ARM", "::", "R8", ")", ".", "Case", "(", "\"v6\"", ",", "ARM", "::", "R9", ")", ".", "Case", "(", "\"v7\"", ",", "ARM", "::", "R10", ")", ".", "Case", "(", "\"v8\"", ",", "ARM", "::", "R11", ")", ".", "Case", "(", "\"sb\"", ",", "ARM", "::", "R9", ")", ".", "Case", "(", "\"sl\"", ",", "ARM", "::", "R10", ")", ".", "Case", "(", "\"fp\"", ",", "ARM", "::", "R11", ")", ".", "Default", "(", "0", ")", ";", "}", "if", "(", "!", "RegNum", ")", "{", "StringMap", "<", "unsigned", ">", "::", "const_iterator", "Entry", "=", "RegisterReqs", ".", "find", "(", "lowerCase", ")", ";", "if", "(", "Entry", "==", "RegisterReqs", ".", "end", "(", ")", ")", "return", "-", "1", ";", "Parser", ".", "Lex", "(", ")", ";", "return", "Entry", "->", "getValue", "(", ")", ";", "}", "if", "(", "hasD16", "(", ")", "&&", "RegNum", ">=", "ARM", "::", "D16", "&&", "RegNum", "<=", "ARM", "::", "D31", ")", "return", "-", "1", ";", "Parser", ".", "Lex", "(", ")", ";", "return", "RegNum", ";", "}", "</s>" ]
[ "tryParseRegister", "-", "parse", "one", "register", "if", "possible" ]
[ "ARM", "ARM", "1", "\"r13\"", "ARM::SP", "\"r14\"", "ARM::LR", "\"r15\"", "ARM::PC", "\"ip\"", "ARM::R12", "\"a1\"", "ARM::R0", "\"a2\"", "ARM::R1", "\"a3\"", "ARM::R2", "\"a4\"", "ARM::R3", "\"v1\"", "ARM::R4", "\"v2\"", "ARM::R5", "\"v3\"", "ARM::R6", "\"v4\"", "ARM::R7", "\"v5\"", "ARM::R8", "\"v6\"", "ARM::R9", "\"v7\"", "ARM::R10", "\"v8\"", "ARM::R11", "\"sb\"", "ARM::R9", "\"sl\"", "ARM::R10", "\"fp\"", "ARM::R11", "0", "1", "ARM::D16", "ARM::D31", "1" ]
ARMAsmParser (2)2
tryParseRegister
ARM
CPU
LLVM
61
338
1
[]
[ "<s>", "void", "NVPTXInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DestReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "DestRC", "=", "MRI", ".", "getRegClass", "(", "DestReg", ")", ";", "const", "TargetRegisterClass", "*", "SrcRC", "=", "MRI", ".", "getRegClass", "(", "SrcReg", ")", ";", "if", "(", "RegInfo", ".", "getRegSizeInBits", "(", "*", "DestRC", ")", "!=", "RegInfo", ".", "getRegSizeInBits", "(", "*", "SrcRC", ")", ")", "report_fatal_error", "(", "\"Copy one register into another with a different width\"", ")", ";", "unsigned", "Op", ";", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Int1RegsRegClass", ")", "{", "Op", "=", "NVPTX", "::", "IMOV1rr", ";", "}", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Int16RegsRegClass", ")", "{", "Op", "=", "NVPTX", "::", "IMOV16rr", ";", "}", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Int32RegsRegClass", ")", "{", "Op", "=", "(", "SrcRC", "==", "&", "NVPTX", "::", "Int32RegsRegClass", "?", "NVPTX", "::", "IMOV32rr", ":", "NVPTX", "::", "BITCONVERT_32_F2I", ")", ";", "}", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Int64RegsRegClass", ")", "{", "Op", "=", "(", "SrcRC", "==", "&", "NVPTX", "::", "Int64RegsRegClass", "?", "NVPTX", "::", "IMOV64rr", ":", "NVPTX", "::", "BITCONVERT_64_F2I", ")", ";", "}", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Float16RegsRegClass", ")", "{", "Op", "=", "(", "SrcRC", "==", "&", "NVPTX", "::", "Float16RegsRegClass", "?", "NVPTX", "::", "FMOV16rr", ":", "NVPTX", "::", "BITCONVERT_16_I2F", ")", ";", "}", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Float16x2RegsRegClass", ")", "{", "Op", "=", "NVPTX", "::", "IMOV32rr", ";", "}", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Float32RegsRegClass", ")", "{", "Op", "=", "(", "SrcRC", "==", "&", "NVPTX", "::", "Float32RegsRegClass", "?", "NVPTX", "::", "FMOV32rr", ":", "NVPTX", "::", "BITCONVERT_32_I2F", ")", ";", "}", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Float64RegsRegClass", ")", "{", "Op", "=", "(", "SrcRC", "==", "&", "NVPTX", "::", "Float64RegsRegClass", "?", "NVPTX", "::", "FMOV64rr", ":", "NVPTX", "::", "BITCONVERT_64_I2F", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Bad register copy\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Op", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]
[ "}", "Branch", "Analysis", "&", "Modification" ]
[ "NVPTX", "NVPTX", "\"Copy one register into another with a different width\"", "NVPTX::Int1RegsRegClass", "NVPTX::IMOV1rr", "NVPTX::Int16RegsRegClass", "NVPTX::IMOV16rr", "NVPTX::Int32RegsRegClass", "NVPTX::Int32RegsRegClass", "NVPTX::IMOV32rr", "NVPTX::BITCONVERT_32_F2I", "NVPTX::Int64RegsRegClass", "NVPTX::Int64RegsRegClass", "NVPTX::IMOV64rr", "NVPTX::BITCONVERT_64_F2I", "NVPTX::Float16RegsRegClass", "NVPTX::Float16RegsRegClass", "NVPTX::FMOV16rr", "NVPTX::BITCONVERT_16_I2F", "NVPTX::Float16x2RegsRegClass", "NVPTX::IMOV32rr", "NVPTX::Float32RegsRegClass", "NVPTX::Float32RegsRegClass", "NVPTX::FMOV32rr", "NVPTX::BITCONVERT_32_I2F", "NVPTX::Float64RegsRegClass", "NVPTX::Float64RegsRegClass", "NVPTX::FMOV64rr", "NVPTX::BITCONVERT_64_I2F", "\"Bad register copy\"" ]
NVPTXInstrInfo17
copyPhysReg
NVPTX
GPU
LLVM
62
338
1
[]
[ "<s>", "static", "bool", "c6x_return_in_msb", "(", "const_tree", "valtype", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "valtype", ")", ";", "return", "TARGET_BIG_ENDIAN", "&&", "AGGREGATE_TYPE_P", "(", "valtype", ")", "&&", "size", "==", "3", ";", "}", "</s>" ]
[ "Values", "which", "must", "be", "returned", "in", "the", "most-significant", "end", "of", "the", "return", "register", "." ]
[ "c6x", "3" ]
c6x
c6x_return_in_msb
c6x
VLIW
GCC
63
29
1
[]
[ "<s>", "bool", "FPS", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "FPIsUsed", "=", "false", ";", "assert", "(", "X86", "::", "FP6", "==", "X86", "::", "FP0", "+", "6", "&&", "\"Register enums aren't sorted right!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<=", "6", ";", "++", "i", ")", "if", "(", "MF", ".", "getRegInfo", "(", ")", ".", "isPhysRegUsed", "(", "X86", "::", "FP0", "+", "i", ")", ")", "{", "FPIsUsed", "=", "true", ";", "break", ";", "}", "if", "(", "!", "FPIsUsed", ")", "return", "false", ";", "TII", "=", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "StackTop", "=", "0", ";", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "8", ">", "Processed", ";", "MachineBasicBlock", "*", "Entry", "=", "MF", ".", "begin", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "df_ext_iterator", "<", "MachineBasicBlock", "*", ",", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "8", ">", ">", "I", "=", "df_ext_begin", "(", "Entry", ",", "Processed", ")", ",", "E", "=", "df_ext_end", "(", "Entry", ",", "Processed", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Changed", "|=", "processBasicBlock", "(", "MF", ",", "*", "*", "I", ")", ";", "return", "Changed", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "X86", "X86::FP6", "X86::FP0", "6", "\"Register enums aren't sorted right!\"", "0", "6", "X86::FP0", "0", "8", "8" ]
X86FloatingPoint23
runOnMachineFunction
X86
CPU
LLVM
64
172
1
[]
[ "<s>", "const", "X86RegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "getInstrInfo", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]
[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]
[ "X86", "X86" ]
X86TargetMachine
getRegisterInfo
X86
CPU
LLVM
65
20
1
[]
[ "<s>", "static", "bool", "c6x_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "if", "(", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "!", "frame_pointer_needed", ";", "return", "true", ";", "}", "</s>" ]
[ "Given", "FROM", "and", "TO", "register", "numbers", ",", "say", "whether", "this", "elimination", "is", "allowed", ".", "Frame", "pointer", "elimination", "is", "automatically", "handled", "." ]
[ "c6x" ]
c6x
c6x_can_eliminate
c6x
VLIW
GCC
66
28
1
[]
[ "<s>", "void", "crx_expand_prologue", "(", "void", ")", "{", "crx_compute_frame", "(", ")", ";", "crx_compute_save_regs", "(", ")", ";", "if", "(", "size_for_adjusting_sp", "+", "sum_regs", "==", "0", ")", "return", ";", "if", "(", "last_reg_to_save", "!=", "-", "1", ")", "emit_insn", "(", "gen_push_for_prologue", "(", "GEN_INT", "(", "sum_regs", ")", ")", ")", ";", "if", "(", "size_for_adjusting_sp", ">", "0", ")", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "size_for_adjusting_sp", ")", ")", ")", ";", "if", "(", "frame_pointer_needed", ")", "emit_move_insn", "(", "frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "}", "</s>" ]
[ "CompactRISC", "CRX", "Architecture", "stack", "layout", ":", "0", "+", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-", "|", ".", ".", "|", "+====================", "Sp", "(", "x", ")", "=Ap", "(", "x+1", ")", "A", "|", "Args", "for", "functions", "|", "|", "called", "by", "X", "and", "Dynamically", "|", "|", "Dynamic", "allocations", "allocated", "and", "|", "|", "(", "alloca", ",", "variable", "deallocated", "Stack", "|", "length", "arrays", ")", ".", "grows", "+", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "Fp", "(", "x", ")", "down|", "|", "Local", "variables", "of", "X", "ward|", "+", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "|", "|", "Regs", "saved", "for", "X-1", "|", "+====================", "Sp", "(", "x-1", ")", "=Ap", "(", "x", ")", "|", "Args", "for", "func", "X", "|", "pushed", "by", "X-1", "+", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "Fp", "(", "x-1", ")", "|", "|", "V" ]
[ "crx", "0", "1", "0" ]
crx
crx_expand_prologue
crx
CPU
GCC
67
76
1
[]
[ "<s>", "void", "GCNScheduleDAGMILive", "::", "finalizeSchedule", "(", ")", "{", "if", "(", "!", "LIS", "||", "StartingOccupancy", "<=", "MinOccupancy", ")", "return", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Retrying function scheduling with lowest recorded occupancy \"", "<<", "MinOccupancy", "<<", "\".\\n\"", ")", ";", "Stage", "++", ";", "GCNMaxOccupancySchedStrategy", "&", "S", "=", "(", "GCNMaxOccupancySchedStrategy", "&", ")", "*", "SchedImpl", ";", "S", ".", "setTargetOccupancy", "(", "MinOccupancy", ")", ";", "MachineBasicBlock", "*", "MBB", "=", "nullptr", ";", "for", "(", "auto", "Region", ":", "Regions", ")", "{", "RegionBegin", "=", "Region", ".", "first", ";", "RegionEnd", "=", "Region", ".", "second", ";", "if", "(", "RegionBegin", "->", "getParent", "(", ")", "!=", "MBB", ")", "{", "if", "(", "MBB", ")", "finishBlock", "(", ")", ";", "MBB", "=", "RegionBegin", "->", "getParent", "(", ")", ";", "startBlock", "(", "MBB", ")", ";", "}", "unsigned", "NumRegionInstrs", "=", "std", "::", "distance", "(", "begin", "(", ")", ",", "end", "(", ")", ")", ";", "enterRegion", "(", "MBB", ",", "begin", "(", ")", ",", "end", "(", ")", ",", "NumRegionInstrs", ")", ";", "if", "(", "begin", "(", ")", "==", "end", "(", ")", "||", "begin", "(", ")", "==", "std", "::", "prev", "(", "end", "(", ")", ")", ")", "{", "exitRegion", "(", ")", ";", "continue", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** MI Scheduling **********\\n\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "MF", ".", "getName", "(", ")", "<<", "\":BB#\"", "<<", "MBB", "->", "getNumber", "(", ")", "<<", "\" \"", "<<", "MBB", "->", "getName", "(", ")", "<<", "\"\\n From: \"", "<<", "*", "begin", "(", ")", "<<", "\" To: \"", ";", "if", "(", "RegionEnd", "!=", "MBB", "->", "end", "(", ")", ")", "dbgs", "(", ")", "<<", "*", "RegionEnd", ";", "else", "dbgs", "(", ")", "<<", "\"End\"", ";", "dbgs", "(", ")", "<<", "\" RegionInstrs: \"", "<<", "NumRegionInstrs", "<<", "'\\n'", ")", ";", "schedule", "(", ")", ";", "exitRegion", "(", ")", ";", "}", "finishBlock", "(", ")", ";", "LiveIns", ".", "shrink_and_clear", "(", ")", ";", "}", "</s>" ]
[ "After", "the", "schedule", "has", "been", "formed", ",", "call", "this", "function", "to", "combine", "the", "instructions", "from", "the", "different", "stages/cycles", "." ]
[ "AMDGPU", "\"Retrying function scheduling with lowest recorded occupancy \"", "\".\\n\"", "\"********** MI Scheduling **********\\n\"", "\":BB#\"", "\" \"", "\"\\n From: \"", "\" To: \"", "\"End\"", "\" RegionInstrs: \"" ]
GCNSchedStrategy21
finalizeSchedule
AMDGPU
GPU
LLVM
68
274
1
[]
[ "<s>", "static", "rtx_insn", "*", "maybe_dead_move", "(", "rtx", "dest", ",", "rtx", "src", ",", "bool", "ATTRIBUTE_UNUSED", "maybe_dead_p", ")", "{", "rtx_insn", "*", "insn", "=", "emit_move_insn", "(", "dest", ",", "src", ")", ";", "if", "(", "maybe_dead_p", ")", "REG_NOTES", "(", "insn", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_MAYBE_DEAD", ",", "const0_rtx", ",", "NULL", ")", ";", "return", "insn", ";", "}", "</s>" ]
[ "Move", "SRC", "to", "DEST", ".", "Mark", "the", "move", "as", "being", "potentially", "dead", "if", "MAYBE_DEAD_P", "." ]
[ "mep" ]
mep
maybe_dead_move
mep
CPU
GCC
69
49
1
[]
[ "<s>", "bool", "AArch64PreLegalizerCombiner", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "FailedISel", ")", ")", "return", "false", ";", "auto", "*", "TPC", "=", "&", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "EnableOpt", "=", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "!", "skipFunction", "(", "F", ")", ";", "GISelKnownBits", "*", "KB", "=", "&", "getAnalysis", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ".", "get", "(", "MF", ")", ";", "MachineDominatorTree", "*", "MDT", "=", "IsOptNone", "?", "nullptr", ":", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "AArch64PreLegalizerCombinerInfo", "PCInfo", "(", "EnableOpt", ",", "F", ".", "hasOptSize", "(", ")", ",", "F", ".", "hasMinSize", "(", ")", ",", "KB", ",", "MDT", ")", ";", "Combiner", "C", "(", "PCInfo", ",", "TPC", ")", ";", "return", "C", ".", "combineMachineInstrs", "(", "MF", ",", "nullptr", ")", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "AArch64", "AArch64", "AArch64" ]
AArch64PreLegalizerCombiner
runOnMachineFunction
AArch64
CPU
LLVM
70
150
1
[]
[ "<s>", "bool", "z8k_mode_dependent_address", "(", "const_rtx", "addr", ",", "addr_space_t", "addr_space", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "GET_CODE", "(", "addr", ")", "==", "POST_INC", "||", "GET_CODE", "(", "addr", ")", "==", "PRE_DEC", ")", ";", "}", "</s>" ]
[ "emit_move_insn", "(", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "tramp", ",", "2", ")", ")", ",", "cxt", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "tramp", ",", "8", ")", ")", ",", "fnaddr", ")", ";", "}", "else", "{", "emit_move_insn", "(", "gen_rtx_MEM", "(", "HImode", ",", "plus_constant", "(", "Pmode", ",", "tramp", ",", "2", ")", ")", ",", "cxt", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "HImode", ",", "plus_constant", "(", "Pmode", ",", "tramp", ",", "6", ")", ")", ",", "fnaddr", ")", ";", "}", "}", "boolz8k_legitimate_constant_p", "(", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "return", "GET_CODE", "(", "x", ")", "!", "=", "CONST_DOUBLE", ";", "}", "boolz8k_can_eliminate", "(", "const", "int", "from", ",", "const", "int", "to", ")", "{", "return", "(", "!", "frame_pointer_needed", "||", "(", "(", "from", ")", "==", "ARG_POINTER_REGNUM", "&", "&", "(", "to", ")", "==", "FRAME_POINTER_REGNUM", ")", "||", "(", "(", "from", ")", "==", "RETURN_ADDRESS_POINTER_REGNUM", "&", "&", "(", "to", ")", "==", "FRAME_POINTER_REGNUM", ")", ")", ";", "}", "Return", "whether", "ADDR", "(", "a", "legitimate", "address", "expression", ")", "has", "an", "effect", "that", "depends", "on", "the", "machine", "mode", "it", "is", "used", "for", ".", "For", "the", "z8k", ",", "pushing", "and", "popping", "needs", "to", "know", "the", "mode" ]
[ "z8k" ]
z8k
z8k_mode_dependent_address
z8k
MPU
GCC
71
29
1
[]
[ "<s>", "void", "pdp10_expand_prologue", "(", ")", "{", "int", "clobbered", "[", "FIRST_PSEUDO_REGISTER", "]", ";", "int", "clobbered_size", ";", "int", "stack_adjust", ";", "int", "single_push", ";", "clobbered_size", "=", "clobbered_regs", "(", "clobbered", ")", ";", "single_push", "=", "clobbered_size", "==", "UNITS_PER_WORD", "&&", "(", "optimize_size", "||", "!", "TARGET_EXTENDED", ")", "&&", "current_function_outgoing_args_size", "==", "0", "&&", "current_function_pretend_args_size", "==", "0", "&&", "get_frame_size", "(", ")", "==", "0", ";", "stack_adjust", "=", "current_function_outgoing_args_size", "+", "get_frame_size", "(", ")", "+", "clobbered_size", "+", "current_function_pretend_args_size", ";", "if", "(", "!", "single_push", "&&", "stack_adjust", ">", "0", ")", "emit_frame_insn", "(", "pdp10_gen_stack_adjust", "(", "GEN_INT", "(", "stack_adjust", "/", "4", ")", ")", ")", ";", "expand_save_or_restore_return_address", "(", "SAVE", ",", "clobbered_size", ")", ";", "expand_save_or_restore_regs", "(", "SAVE", ",", "clobbered", ",", "clobbered_size", ",", "single_push", ")", ";", "expand_set_up_frame_pointer", "(", ")", ";", "}", "</s>" ]
[ "Emit", "function", "prologue", "instructions", "." ]
[ "pdp10", "0", "0", "0", "0", "4" ]
pdp10
pdp10_expand_prologue
pdp10
MPU
GCC
72
111
1
[]
[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "PPCInstrInfo", "::", "getSerializableBitmaskMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "PPCII", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_PLT", ",", "\"ppc-plt\"", "}", ",", "{", "MO_PIC_FLAG", ",", "\"ppc-pic\"", "}", ",", "{", "MO_PCREL_FLAG", ",", "\"ppc-pcrel\"", "}", ",", "{", "MO_GOT_FLAG", ",", "\"ppc-got\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>" ]
[ "Return", "an", "array", "that", "contains", "the", "bitmask", "target", "flag", "values", "and", "their", "names", "." ]
[ "PowerPC", "PPC", "PPC", "\"ppc-plt\"", "\"ppc-pic\"", "\"ppc-pcrel\"", "\"ppc-got\"" ]
PPCInstrInfo128
getSerializableBitmaskMachineOperandTargetFlags
PowerPC
CPU
LLVM
73
72
1
[]
[ "<s>", "void", "s390_expand_vcond", "(", "rtx", "target", ",", "rtx", "then", ",", "rtx", "els", ",", "enum", "rtx_code", "cond", ",", "rtx", "cmp_op1", ",", "rtx", "cmp_op2", ")", "{", "rtx", "tmp", ";", "machine_mode", "result_mode", ";", "rtx", "result_target", ";", "machine_mode", "target_mode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "cmp_mode", "=", "GET_MODE", "(", "cmp_op1", ")", ";", "rtx", "op", "=", "(", "cond", "==", "LT", ")", "?", "els", ":", "then", ";", "if", "(", "(", "cond", "==", "LT", "||", "cond", "==", "GE", ")", "&&", "target_mode", "==", "cmp_mode", "&&", "cmp_op2", "==", "CONST0_RTX", "(", "cmp_mode", ")", "&&", "op", "==", "CONST0_RTX", "(", "target_mode", ")", "&&", "s390_vector_mode_supported_p", "(", "target_mode", ")", "&&", "GET_MODE_CLASS", "(", "target_mode", ")", "==", "MODE_VECTOR_INT", ")", "{", "rtx", "negop", "=", "(", "cond", "==", "LT", ")", "?", "then", ":", "els", ";", "int", "shift", "=", "GET_MODE_BITSIZE", "(", "GET_MODE_INNER", "(", "target_mode", ")", ")", "-", "1", ";", "if", "(", "negop", "==", "CONST1_RTX", "(", "target_mode", ")", ")", "{", "rtx", "res", "=", "expand_simple_binop", "(", "cmp_mode", ",", "LSHIFTRT", ",", "cmp_op1", ",", "GEN_INT", "(", "shift", ")", ",", "target", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "if", "(", "res", "!=", "target", ")", "emit_move_insn", "(", "target", ",", "res", ")", ";", "return", ";", "}", "else", "if", "(", "all_ones_operand", "(", "negop", ",", "target_mode", ")", ")", "{", "rtx", "res", "=", "expand_simple_binop", "(", "cmp_mode", ",", "ASHIFTRT", ",", "cmp_op1", ",", "GEN_INT", "(", "shift", ")", ",", "target", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "if", "(", "res", "!=", "target", ")", "emit_move_insn", "(", "target", ",", "res", ")", ";", "return", ";", "}", "}", "result_mode", "=", "mode_for_int_vector", "(", "cmp_mode", ")", ".", "require", "(", ")", ";", "result_target", "=", "gen_reg_rtx", "(", "result_mode", ")", ";", "if", "(", "!", "REG_P", "(", "cmp_op1", ")", ")", "cmp_op1", "=", "force_reg", "(", "GET_MODE", "(", "cmp_op1", ")", ",", "cmp_op1", ")", ";", "if", "(", "!", "REG_P", "(", "cmp_op2", ")", ")", "cmp_op2", "=", "force_reg", "(", "GET_MODE", "(", "cmp_op2", ")", ",", "cmp_op2", ")", ";", "s390_expand_vec_compare", "(", "result_target", ",", "cond", ",", "cmp_op1", ",", "cmp_op2", ")", ";", "if", "(", "all_ones_operand", "(", "then", ",", "GET_MODE", "(", "then", ")", ")", "&&", "const0_operand", "(", "els", ",", "GET_MODE", "(", "els", ")", ")", ")", "{", "emit_move_insn", "(", "target", ",", "gen_rtx_SUBREG", "(", "target_mode", ",", "result_target", ",", "0", ")", ")", ";", "return", ";", "}", "if", "(", "!", "REG_P", "(", "then", ")", ")", "then", "=", "force_reg", "(", "target_mode", ",", "then", ")", ";", "if", "(", "!", "REG_P", "(", "els", ")", ")", "els", "=", "force_reg", "(", "target_mode", ",", "els", ")", ";", "tmp", "=", "gen_rtx_fmt_ee", "(", "EQ", ",", "VOIDmode", ",", "result_target", ",", "CONST0_RTX", "(", "result_mode", ")", ")", ";", "tmp", "=", "gen_rtx_IF_THEN_ELSE", "(", "target_mode", ",", "tmp", ",", "els", ",", "then", ")", ";", "gcc_assert", "(", "target_mode", "==", "GET_MODE", "(", "then", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "tmp", ")", ")", ";", "}", "</s>" ]
[ "Generate", "a", "vector", "comparison", "expression", "loading", "either", "elements", "of", "THEN", "or", "ELS", "into", "TARGET", "depending", "on", "the", "comparison", "COND", "of", "CMP_OP1", "and", "CMP_OP2", "." ]
[ "s390", "1", "1", "0", "0" ]
s3907
s390_expand_vcond
s390
MPU
GCC
74
423
1
[]
[ "<s>", "virtual", "const", "SPUSubtarget", "*", "getSubtargetImpl", "(", ")", "const", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]
[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]
[ "CellSPU", "SPU" ]
SPUTargetMachine1
getSubtargetImpl
CellSPU
MPU
LLVM
75
14
1
[]
[ "<s>", "const", "AArch64RegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "getInstrInfo", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]
[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]
[ "AArch64", "AArch64" ]
AArch64Subtarget (2)
getRegisterInfo
AArch64
CPU
LLVM
76
20
1
[]
[ "<s>", "int", "rs6000_memory_move_cost", "(", "enum", "machine_mode", "mode", ",", "enum", "reg_class", "class", ",", "int", "in", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "reg_classes_intersect_p", "(", "class", ",", "GENERAL_REGS", ")", ")", "return", "4", "*", "hard_regno_nregs", "[", "0", "]", "[", "mode", "]", ";", "else", "if", "(", "reg_classes_intersect_p", "(", "class", ",", "FLOAT_REGS", ")", ")", "return", "4", "*", "hard_regno_nregs", "[", "32", "]", "[", "mode", "]", ";", "else", "if", "(", "reg_classes_intersect_p", "(", "class", ",", "ALTIVEC_REGS", ")", ")", "return", "4", "*", "hard_regno_nregs", "[", "FIRST_ALTIVEC_REGNO", "]", "[", "mode", "]", ";", "else", "return", "4", "+", "rs6000_register_move_cost", "(", "mode", ",", "class", ",", "GENERAL_REGS", ")", ";", "}", "</s>" ]
[ "A", "C", "expressions", "returning", "the", "cost", "of", "moving", "data", "of", "MODE", "from", "a", "register", "to", "or", "from", "memory", "." ]
[ "rs6000", "4", "0", "4", "32", "4", "4" ]
rs60003
rs6000_memory_move_cost
rs6000
CPU
GCC
77
92
1
[]
[ "<s>", "bool", "JVMTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", ",", "MachineFunction", "&", ",", "bool", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", ")", "const", "{", "return", "Outs", ".", "size", "(", ")", "<=", "1", ";", "}", "</s>" ]
[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]
[ "JVM", "JVM", "ISD::OutputArg", "1" ]
JVMISelLowering
CanLowerReturn
JVM
Virtual ISA
LLVM
78
39
1
[]
[ "<s>", "static", "bool", "dispatch_violation", "(", "void", ")", "{", "if", "(", "dispatch_window_list", "->", "next", ")", "return", "dispatch_window_list", "->", "next", "->", "violation", ";", "return", "dispatch_window_list", "->", "violation", ";", "}", "</s>" ]
[ "Return", "true", "if", "a", "dispatch", "violation", "encountered", "." ]
[ "i386" ]
i3864
dispatch_violation
i386
CPU
GCC
79
26
1
[]
[ "<s>", "static", "int", "eco32_num_arg_regs", "(", "enum", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "int", "size", ";", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "0", ";", "if", "(", "type", "&&", "mode", "==", "BLKmode", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "return", "(", "size", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "}", "</s>" ]
[ "Compute", "the", "number", "of", "word", "sized", "registers", "needed", "to", "hold", "a", "function", "argument", "of", "mode", "INT_MODE", "and", "tree", "type", "TYPE", "." ]
[ "eco32", "0", "1" ]
eco32
eco32_num_arg_regs
eco32
MPU
GCC
80
66
1
[]
[ "<s>", "static", "bool", "aarch64_rtx_arith_op_extract_p", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "SIGN_EXTRACT", "||", "GET_CODE", "(", "x", ")", "==", "ZERO_EXTRACT", ")", "{", "rtx", "op0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "rtx", "op2", "=", "XEXP", "(", "x", ",", "2", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "MULT", "&&", "CONST_INT_P", "(", "op1", ")", "&&", "op2", "==", "const0_rtx", "&&", "CONST_INT_P", "(", "XEXP", "(", "op0", ",", "1", ")", ")", "&&", "aarch64_is_extend_from_extract", "(", "mode", ",", "XEXP", "(", "op0", ",", "1", ")", ",", "op1", ")", ")", "{", "return", "true", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "SIGN_EXTEND", "||", "GET_CODE", "(", "x", ")", "==", "ZERO_EXTEND", ")", "return", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "return", "false", ";", "}", "</s>" ]
[ "Return", "true", "if", "X", "is", "a", "zero", "or", "sign", "extract", "usable", "in", "an", "ADD", "or", "SUB", "(", "extended", "register", ")", "instruction", "." ]
[ "aarch64", "0", "1", "2", "1", "1", "0" ]
aarch643
aarch64_rtx_arith_op_extract_p
aarch64
CPU
GCC
81
138
1
[]
[ "<s>", "void", "ScheduleDAGPostRA", "::", "startBlock", "(", "MachineBasicBlock", "*", "BB", ")", "{", "ScheduleDAGInstrs", "::", "startBlock", "(", "BB", ")", ";", "if", "(", "AntiDepBreak", "!=", "NULL", ")", "AntiDepBreak", "->", "StartBlock", "(", "BB", ")", ";", "}", "</s>" ]
[ "Prepares", "to", "perform", "scheduling", "in", "the", "given", "block", "." ]
[ "Patmos" ]
PatmosPostRAScheduler
startBlock
Patmos
VLIW
LLVM
82
31
1
[]
[ "<s>", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]
[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]
[ "R600" ]
AMDGPUAsmBackend1
fixupNeedsRelaxation
R600
GPU
LLVM
83
28
1
[]
[ "<s>", "InstructionCost", "PPCTTIImpl", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "TTI", "::", "OperandValueKind", "Op1Info", ",", "TTI", "::", "OperandValueKind", "Op2Info", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", ",", "ArrayRef", "<", "const", "Value", "*", ">", "Args", ",", "const", "Instruction", "*", "CxtI", ")", "{", "assert", "(", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", "&&", "\"Invalid opcode\"", ")", ";", "InstructionCost", "CostFactor", "=", "vectorCostAdjustmentFactor", "(", "Opcode", ",", "Ty", ",", "nullptr", ")", ";", "if", "(", "!", "CostFactor", ".", "isValid", "(", ")", ")", "return", "InstructionCost", "::", "getMax", "(", ")", ";", "if", "(", "CostKind", "!=", "TTI", "::", "TCK_RecipThroughput", ")", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "CostKind", ",", "Op1Info", ",", "Op2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ",", "Args", ",", "CxtI", ")", ";", "InstructionCost", "Cost", "=", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "CostKind", ",", "Op1Info", ",", "Op2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "return", "Cost", "*", "CostFactor", ";", "}", "</s>" ]
[ "This", "is", "an", "approximation", "of", "reciprocal", "throughput", "of", "a", "math/logic", "op", "." ]
[ "PowerPC", "PPC", "\"Invalid opcode\"" ]
PPCTargetTransformInfo14
getArithmeticInstrCost
PowerPC
CPU
LLVM
84
151
1
[]
[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "AlphaTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "Alpha", "::", "GPRCRegisterClass", ")", ";", "case", "'f'", ":", "return", "VT", "==", "MVT", "::", "f64", "?", "std", "::", "make_pair", "(", "0U", ",", "Alpha", "::", "F8RCRegisterClass", ")", ":", "std", "::", "make_pair", "(", "0U", ",", "Alpha", "::", "F4RCRegisterClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]
[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]
[ "Alpha", "Alpha", "1", "0", "0U", "Alpha::GPRCRegisterClass", "MVT::f64", "0U", "Alpha::F8RCRegisterClass", "0U", "Alpha::F4RCRegisterClass" ]
AlphaISelLowering2
getRegForInlineAsmConstraint
Alpha
MPU
LLVM
85
105
1
[]
[ "<s>", "void", "print", "(", ")", "{", "if", "(", "numSymbols", "==", "0", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "size", ";", "i", "++", ")", "{", "if", "(", "i", ")", "O", "<<", "\", \"", ";", "O", "<<", "(", "unsigned", "int", ")", "buffer", "[", "i", "]", ";", "}", "}", "else", "{", "unsigned", "int", "pos", "=", "0", ";", "unsigned", "int", "nSym", "=", "0", ";", "unsigned", "int", "nextSymbolPos", "=", "symbolPosInBuffer", "[", "nSym", "]", ";", "unsigned", "int", "nBytes", "=", "4", ";", "if", "(", "static_cast", "<", "const", "NVPTXTargetMachine", "&", ">", "(", "AP", ".", "TM", ")", ".", "is64Bit", "(", ")", ")", "nBytes", "=", "8", ";", "for", "(", "pos", "=", "0", ";", "pos", "<", "size", ";", "pos", "+=", "nBytes", ")", "{", "if", "(", "pos", ")", "O", "<<", "\", \"", ";", "if", "(", "pos", "==", "nextSymbolPos", ")", "{", "const", "Value", "*", "v", "=", "Symbols", "[", "nSym", "]", ";", "const", "Value", "*", "v0", "=", "SymbolsBeforeStripping", "[", "nSym", "]", ";", "if", "(", "const", "GlobalValue", "*", "GVar", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "v", ")", ")", "{", "MCSymbol", "*", "Name", "=", "AP", ".", "getSymbol", "(", "GVar", ")", ";", "PointerType", "*", "PTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "v0", "->", "getType", "(", ")", ")", ";", "bool", "IsNonGenericPointer", "=", "false", ";", "if", "(", "PTy", "&&", "PTy", "->", "getAddressSpace", "(", ")", "!=", "0", ")", "{", "IsNonGenericPointer", "=", "true", ";", "}", "if", "(", "EmitGeneric", "&&", "!", "isa", "<", "Function", ">", "(", "v", ")", "&&", "!", "IsNonGenericPointer", ")", "{", "O", "<<", "\"generic(\"", ";", "Name", "->", "print", "(", "O", ",", "AP", ".", "MAI", ")", ";", "O", "<<", "\")\"", ";", "}", "else", "{", "Name", "->", "print", "(", "O", ",", "AP", ".", "MAI", ")", ";", "}", "}", "else", "if", "(", "const", "ConstantExpr", "*", "CExpr", "=", "dyn_cast", "<", "ConstantExpr", ">", "(", "v0", ")", ")", "{", "const", "MCExpr", "*", "Expr", "=", "AP", ".", "lowerConstantForGV", "(", "cast", "<", "Constant", ">", "(", "CExpr", ")", ",", "false", ")", ";", "AP", ".", "printMCExpr", "(", "*", "Expr", ",", "O", ")", ";", "}", "else", "llvm_unreachable", "(", "\"symbol type unknown\"", ")", ";", "nSym", "++", ";", "if", "(", "nSym", ">=", "numSymbols", ")", "nextSymbolPos", "=", "size", "+", "1", ";", "else", "nextSymbolPos", "=", "symbolPosInBuffer", "[", "nSym", "]", ";", "}", "else", "if", "(", "nBytes", "==", "4", ")", "O", "<<", "*", "(", "unsigned", "int", "*", ")", "(", "&", "buffer", "[", "pos", "]", ")", ";", "else", "O", "<<", "*", "(", "unsigned", "long", "long", "*", ")", "(", "&", "buffer", "[", "pos", "]", ")", ";", "}", "}", "}", "</s>" ]
[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]
[ "NVPTX", "0", "0", "\", \"", "0", "0", "4", "NVPTX", "8", "0", "\", \"", "0", "\"generic(\"", "\")\"", "\"symbol type unknown\"", "1", "4" ]
NVPTXAsmPrinter
print
NVPTX
GPU
LLVM
86
389
1
[]
[ "<s>", "void", "bfin_expand_call", "(", "rtx", "retval", ",", "rtx", "fnaddr", ",", "rtx", "callarg1", ",", "rtx", "cookie", ",", "int", "sibcall", ")", "{", "rtx", "use", "=", "NULL", ",", "call", ";", "rtx", "callee", "=", "XEXP", "(", "fnaddr", ",", "0", ")", ";", "rtx", "pat", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "sibcall", "?", "3", ":", "2", ")", ")", ";", "if", "(", "cookie", "==", "NULL_RTX", ")", "cookie", "=", "const0_rtx", ";", "if", "(", "flag_pic", "&&", "GET_CODE", "(", "callee", ")", "==", "SYMBOL_REF", "&&", "!", "SYMBOL_REF_LOCAL_P", "(", "callee", ")", ")", "use_reg", "(", "&", "use", ",", "pic_offset_table_rtx", ")", ";", "if", "(", "(", "!", "register_no_elim_operand", "(", "callee", ",", "Pmode", ")", "&&", "GET_CODE", "(", "callee", ")", "!=", "SYMBOL_REF", ")", "||", "(", "GET_CODE", "(", "callee", ")", "==", "SYMBOL_REF", "&&", "(", "flag_pic", "||", "bfin_longcall_p", "(", "callee", ",", "INTVAL", "(", "cookie", ")", ")", ")", ")", ")", "{", "callee", "=", "copy_to_mode_reg", "(", "Pmode", ",", "callee", ")", ";", "fnaddr", "=", "gen_rtx_MEM", "(", "Pmode", ",", "callee", ")", ";", "}", "call", "=", "gen_rtx_CALL", "(", "VOIDmode", ",", "fnaddr", ",", "callarg1", ")", ";", "if", "(", "retval", ")", "call", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "retval", ",", "call", ")", ";", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", "=", "call", ";", "XVECEXP", "(", "pat", ",", "0", ",", "1", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "cookie", ")", ";", "if", "(", "sibcall", ")", "XVECEXP", "(", "pat", ",", "0", ",", "2", ")", "=", "gen_rtx_RETURN", "(", "VOIDmode", ")", ";", "call", "=", "emit_call_insn", "(", "pat", ")", ";", "if", "(", "use", ")", "CALL_INSN_FUNCTION_USAGE", "(", "call", ")", "=", "use", ";", "}", "</s>" ]
[ "Expand", "a", "call", "instruction", ".", "FNADDR", "is", "the", "call", "target", ",", "RETVAL", "the", "return", "value", ".", "COOKIE", "is", "a", "CONST_INT", "holding", "the", "call_cookie", "prepared", "init_cumulative_args", ".", "SIBCALL", "is", "nonzero", "if", "this", "is", "a", "sibling", "call", "." ]
[ "bfin", "0", "3", "2", "0", "0", "0", "1", "0", "2" ]
bfin2
bfin_expand_call
bfin
DSP
GCC
87
240
1
[]
[ "<s>", "static", "void", "riscv_expand_mult_with_const_int", "(", "machine_mode", "mode", ",", "rtx", "dest", ",", "rtx", "multiplicand", ",", "int", "multiplier", ")", "{", "if", "(", "multiplier", "==", "0", ")", "{", "riscv_emit_move", "(", "dest", ",", "GEN_INT", "(", "0", ")", ")", ";", "return", ";", "}", "bool", "neg_p", "=", "multiplier", "<", "0", ";", "int", "multiplier_abs", "=", "abs", "(", "multiplier", ")", ";", "if", "(", "multiplier_abs", "==", "1", ")", "{", "if", "(", "neg_p", ")", "riscv_expand_op", "(", "NEG", ",", "mode", ",", "dest", ",", "multiplicand", ",", "NULL_RTX", ")", ";", "else", "riscv_emit_move", "(", "dest", ",", "multiplicand", ")", ";", "}", "else", "{", "if", "(", "pow2p_hwi", "(", "multiplier_abs", ")", ")", "{", "riscv_expand_op", "(", "ASHIFT", ",", "mode", ",", "dest", ",", "multiplicand", ",", "gen_int_mode", "(", "exact_log2", "(", "multiplier_abs", ")", ",", "QImode", ")", ")", ";", "if", "(", "neg_p", ")", "riscv_expand_op", "(", "NEG", ",", "mode", ",", "dest", ",", "dest", ",", "NULL_RTX", ")", ";", "}", "else", "if", "(", "pow2p_hwi", "(", "multiplier_abs", "+", "1", ")", ")", "{", "riscv_expand_op", "(", "ASHIFT", ",", "mode", ",", "dest", ",", "multiplicand", ",", "gen_int_mode", "(", "exact_log2", "(", "multiplier_abs", "+", "1", ")", ",", "QImode", ")", ")", ";", "if", "(", "neg_p", ")", "riscv_expand_op", "(", "MINUS", ",", "mode", ",", "dest", ",", "multiplicand", ",", "dest", ")", ";", "else", "riscv_expand_op", "(", "MINUS", ",", "mode", ",", "dest", ",", "dest", ",", "multiplicand", ")", ";", "}", "else", "if", "(", "pow2p_hwi", "(", "multiplier", "-", "1", ")", ")", "{", "riscv_expand_op", "(", "ASHIFT", ",", "mode", ",", "dest", ",", "multiplicand", ",", "gen_int_mode", "(", "exact_log2", "(", "multiplier_abs", "-", "1", ")", ",", "QImode", ")", ")", ";", "riscv_expand_op", "(", "PLUS", ",", "mode", ",", "dest", ",", "dest", ",", "multiplicand", ")", ";", "if", "(", "neg_p", ")", "riscv_expand_op", "(", "NEG", ",", "mode", ",", "dest", ",", "dest", ",", "NULL_RTX", ")", ";", "}", "else", "{", "gcc_assert", "(", "TARGET_MUL", "&&", "\"M-extension must be enabled to calculate the poly_int \"", "\"size/offset.\"", ")", ";", "riscv_emit_move", "(", "dest", ",", "gen_int_mode", "(", "multiplier", ",", "mode", ")", ")", ";", "riscv_expand_op", "(", "MULT", ",", "mode", ",", "dest", ",", "dest", ",", "multiplicand", ")", ";", "}", "}", "}", "</s>" ]
[ "Expand", "mult", "operation", "with", "constant", "integer", ",", "multiplicand", "also", "used", "as", "a", "*", "temporary", "register", "." ]
[ "riscv", "0", "0", "0", "1", "1", "1", "1", "1", "\"M-extension must be enabled to calculate the poly_int \"", "\"size/offset.\"" ]
riscv1
riscv_expand_mult_with_const_int
riscv
CPU
GCC
88
303
1
[]
[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI Fix VGPR copies\"", ";", "}", "</s>" ]
[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]
[ "AMDGPU", "\"SI Fix VGPR copies\"" ]
SIFixVGPRCopies
getPassName
AMDGPU
GPU
LLVM
89
11
1
[]
[ "<s>", "SDValue", "P2TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "lowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "lowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]
[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]
[ "P2", "P2", "ISD::GlobalAddress", "ISD::VASTART", "ISD::VAARG", "ISD::JumpTable" ]
P2ISelLowering
LowerOperation
P2
MPU
LLVM
90
82
1
[]
[ "<s>", "void", "NVPTXPassConfig", "::", "addMachineSSAOptimization", "(", ")", "{", "if", "(", "addPass", "(", "&", "EarlyTailDuplicateID", ")", ")", "printAndVerify", "(", "\"After Pre-RegAlloc TailDuplicate\"", ")", ";", "addPass", "(", "&", "OptimizePHIsID", ")", ";", "addPass", "(", "&", "StackColoringID", ")", ";", "addPass", "(", "&", "LocalStackSlotAllocationID", ")", ";", "addPass", "(", "&", "DeadMachineInstructionElimID", ")", ";", "printAndVerify", "(", "\"After codegen DCE pass\"", ")", ";", "if", "(", "addILPOpts", "(", ")", ")", "printAndVerify", "(", "\"After ILP optimizations\"", ")", ";", "addPass", "(", "&", "MachineLICMID", ")", ";", "addPass", "(", "&", "MachineCSEID", ")", ";", "addPass", "(", "&", "MachineSinkingID", ")", ";", "printAndVerify", "(", "\"After Machine LICM, CSE and Sinking passes\"", ")", ";", "addPass", "(", "&", "PeepholeOptimizerID", ")", ";", "printAndVerify", "(", "\"After codegen peephole optimization pass\"", ")", ";", "}", "</s>" ]
[ "Methods", "with", "trivial", "inline", "returns", "are", "convenient", "points", "in", "the", "common", "codegen", "pass", "pipeline", "where", "targets", "may", "insert", "passes", "." ]
[ "NVPTX", "NVPTX", "\"After Pre-RegAlloc TailDuplicate\"", "\"After codegen DCE pass\"", "\"After ILP optimizations\"", "\"After Machine LICM, CSE and Sinking passes\"", "\"After codegen peephole optimization pass\"" ]
NVPTXTargetMachine (2)
addMachineSSAOptimization
NVPTX
GPU
LLVM
91
95
1
[]
[ "<s>", "const", "char", "*", "output_a_rotate", "(", "enum", "rtx_code", "code", ",", "rtx", "*", "operands", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "rotate_amount", "=", "operands", "[", "2", "]", ";", "enum", "shift_mode", "rotate_mode", ";", "enum", "shift_type", "rotate_type", ";", "const", "char", "*", "insn_buf", ";", "int", "bits", ";", "int", "amount", ";", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "dst", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "rotate_amount", ")", "==", "CONST_INT", ")", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "rotate_mode", "=", "QIshift", ";", "break", ";", "case", "HImode", ":", "rotate_mode", "=", "HIshift", ";", "break", ";", "case", "SImode", ":", "rotate_mode", "=", "SIshift", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "ROTATERT", ":", "rotate_type", "=", "SHIFT_ASHIFT", ";", "break", ";", "case", "ROTATE", ":", "rotate_type", "=", "SHIFT_LSHIFTRT", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "amount", "=", "INTVAL", "(", "rotate_amount", ")", ";", "if", "(", "amount", "<", "0", ")", "amount", "=", "0", ";", "if", "(", "(", "unsigned", "int", ")", "amount", ">", "GET_MODE_BITSIZE", "(", "mode", ")", ")", "amount", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "if", "(", "(", "unsigned", "int", ")", "amount", ">", "GET_MODE_BITSIZE", "(", "mode", ")", "/", "(", "unsigned", ")", "2", ")", "{", "amount", "=", "GET_MODE_BITSIZE", "(", "mode", ")", "-", "amount", ";", "rotate_type", "=", "(", "rotate_type", "==", "SHIFT_ASHIFT", ")", "?", "SHIFT_LSHIFTRT", ":", "SHIFT_ASHIFT", ";", "}", "if", "(", "(", "mode", "==", "HImode", "&&", "TARGET_H8300", "&&", "amount", ">=", "5", ")", "||", "(", "mode", "==", "HImode", "&&", "TARGET_H8300H", "&&", "amount", ">=", "6", ")", "||", "(", "mode", "==", "HImode", "&&", "TARGET_H8300S", "&&", "amount", "==", "8", ")", "||", "(", "mode", "==", "SImode", "&&", "TARGET_H8300H", "&&", "amount", ">=", "10", ")", "||", "(", "mode", "==", "SImode", "&&", "TARGET_H8300S", "&&", "amount", ">=", "13", ")", ")", "{", "switch", "(", "mode", ")", "{", "case", "HImode", ":", "insn_buf", "=", "\"xor.b\\t%s0,%t0\\n\\txor.b\\t%t0,%s0\\n\\txor.b\\t%s0,%t0\"", ";", "output_asm_insn", "(", "insn_buf", ",", "operands", ")", ";", "break", ";", "case", "SImode", ":", "insn_buf", "=", "\"xor.w\\t%e0,%f0\\n\\txor.w\\t%f0,%e0\\n\\txor.w\\t%e0,%f0\"", ";", "output_asm_insn", "(", "insn_buf", ",", "operands", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "amount", "=", "GET_MODE_BITSIZE", "(", "mode", ")", "/", "2", "-", "amount", ";", "rotate_type", "=", "(", "rotate_type", "==", "SHIFT_ASHIFT", ")", "?", "SHIFT_LSHIFTRT", ":", "SHIFT_ASHIFT", ";", "}", "for", "(", "bits", "=", "TARGET_H8300S", "?", "2", ":", "1", ";", "bits", ">", "0", ";", "bits", "/=", "2", ")", "{", "if", "(", "bits", "==", "2", ")", "insn_buf", "=", "rotate_two", "[", "rotate_type", "]", "[", "rotate_mode", "]", ";", "else", "insn_buf", "=", "rotate_one", "[", "cpu_type", "]", "[", "rotate_type", "]", "[", "rotate_mode", "]", ";", "for", "(", ";", "amount", ">=", "bits", ";", "amount", "-=", "bits", ")", "output_asm_insn", "(", "insn_buf", ",", "operands", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]
[ "Output", "a", "rotate", "insn", "." ]
[ "h8300", "0", "2", "0", "0", "2", "5", "6", "8", "10", "13", "\"xor.b\\t%s0,%t0\\n\\txor.b\\t%t0,%s0\\n\\txor.b\\t%s0,%t0\"", "\"xor.w\\t%e0,%f0\\n\\txor.w\\t%f0,%e0\\n\\txor.w\\t%e0,%f0\"", "2", "2", "1", "0", "2", "2", "\"\"" ]
h83003
output_a_rotate
h8300
MPU
GCC
92
418
1
[]
[ "<s>", "bool", "ARMFrameLowering", "::", "enableShrinkWrapping", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "STI", ".", "hasV8_1MMainlineOps", "(", ")", "&&", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", "->", "isCmseNSEntryFunction", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]
[ "Returns", "true", "if", "the", "target", "will", "correctly", "handle", "shrink", "wrapping", "." ]
[ "ARM", "ARM", "ARM" ]
ARMFrameLowering103
enableShrinkWrapping
ARM
CPU
LLVM
93
40
1
[]
[ "<s>", "bool", "PPCTTIImpl", "::", "canSaveCmp", "(", "Loop", "*", "L", ",", "BranchInst", "*", "*", "BI", ",", "ScalarEvolution", "*", "SE", ",", "LoopInfo", "*", "LI", ",", "DominatorTree", "*", "DT", ",", "AssumptionCache", "*", "AC", ",", "TargetLibraryInfo", "*", "LibInfo", ")", "{", "for", "(", "Loop", "::", "iterator", "I", "=", "L", "->", "begin", "(", ")", ",", "E", "=", "L", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "canSaveCmp", "(", "*", "I", ",", "BI", ",", "SE", ",", "LI", ",", "DT", ",", "AC", ",", "LibInfo", ")", ")", "return", "false", ";", "HardwareLoopInfo", "HWLoopInfo", "(", "L", ")", ";", "if", "(", "!", "HWLoopInfo", ".", "canAnalyze", "(", "*", "LI", ")", ")", "return", "false", ";", "if", "(", "!", "isHardwareLoopProfitable", "(", "L", ",", "*", "SE", ",", "*", "AC", ",", "LibInfo", ",", "HWLoopInfo", ")", ")", "return", "false", ";", "if", "(", "!", "HWLoopInfo", ".", "isHardwareLoopCandidate", "(", "*", "SE", ",", "*", "LI", ",", "*", "DT", ")", ")", "return", "false", ";", "*", "BI", "=", "HWLoopInfo", ".", "ExitBranch", ";", "return", "true", ";", "}", "</s>" ]
[ "Return", "true", "if", "the", "target", "can", "save", "a", "compare", "for", "loop", "count", ",", "for", "example", "hardware", "loop", "saves", "a", "compare", "." ]
[ "PowerPC", "PPC" ]
PPCTargetTransformInfo1
canSaveCmp
PowerPC
CPU
LLVM
94
158
1
[]
[ "<s>", "static", "void", "ix86_emit_mode_set", "(", "int", "entity", ",", "int", "mode", ",", "int", "prev_mode", "ATTRIBUTE_UNUSED", ",", "HARD_REG_SET", "regs_live", ")", "{", "switch", "(", "entity", ")", "{", "case", "X86_DIRFLAG", ":", "if", "(", "mode", "==", "X86_DIRFLAG_RESET", ")", "emit_insn", "(", "gen_cld", "(", ")", ")", ";", "break", ";", "case", "AVX_U128", ":", "if", "(", "mode", "==", "AVX_U128_CLEAN", ")", "ix86_avx_emit_vzeroupper", "(", "regs_live", ")", ";", "break", ";", "case", "I387_TRUNC", ":", "case", "I387_FLOOR", ":", "case", "I387_CEIL", ":", "case", "I387_MASK_PM", ":", "if", "(", "mode", "!=", "I387_CW_ANY", "&&", "mode", "!=", "I387_CW_UNINITIALIZED", ")", "emit_i387_cw_initialization", "(", "mode", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]
[ "Generate", "one", "or", "more", "insns", "to", "set", "ENTITY", "to", "MODE", ".", "HARD_REG_LIVE", "is", "the", "set", "of", "hard", "registers", "live", "at", "the", "point", "where", "the", "insn", "(", "s", ")", "are", "to", "be", "inserted", "." ]
[ "i386" ]
i3866
ix86_emit_mode_set
i386
CPU
GCC
95
94
1
[]
[ "<s>", "bool", "VEPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createVEISelDag", "(", "getVETargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]
[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]
[ "VE", "VE", "VE", "VE" ]
VETargetMachine
addInstSelector
VE
CPU
LLVM
96
21
1
[]
[ "<s>", "static", "bool", "is_costly_group", "(", "rtx", "*", "group_insns", ",", "rtx", "next_insn", ")", "{", "int", "i", ";", "int", "issue_rate", "=", "rs6000_issue_rate", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "issue_rate", ";", "i", "++", ")", "{", "sd_iterator_def", "sd_it", ";", "dep_t", "dep", ";", "rtx", "insn", "=", "group_insns", "[", "i", "]", ";", "if", "(", "!", "insn", ")", "continue", ";", "FOR_EACH_DEP", "(", "insn", ",", "SD_LIST_RES_FORW", ",", "sd_it", ",", "dep", ")", "{", "rtx", "next", "=", "DEP_CON", "(", "dep", ")", ";", "if", "(", "next", "==", "next_insn", "&&", "rs6000_is_costly_dependence", "(", "dep", ",", "dep_cost", "(", "dep", ")", ",", "0", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]
[ "Return", "true", "if", "it", "is", "recommended", "to", "keep", "NEXT_INSN", "``", "far", "''", "(", "in", "a", "separate", "dispatch", "group", ")", "from", "the", "insns", "in", "GROUP_INSNS", ".", "Return", "false", "otherwise", "." ]
[ "rs6000", "0", "0" ]
rs6000
is_costly_group
rs6000
CPU
GCC
97
103
1
[]
[ "<s>", "const", "char", "*", "avr_double_lib", "(", "int", "argc", ",", "const", "char", "*", "*", "argv", ")", "{", "int", "dbl", "=", "64", ";", "int", "dbl", "=", "32", ";", "int", "ldb", "=", "64", ";", "int", "ldb", "=", "32", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "argc", ";", "i", "++", ")", "{", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"mdouble=32\"", ")", "==", "0", ")", "{", "dbl", "=", "32", ";", "ldb", "=", "dbl", ";", "}", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"mdouble=64\"", ")", "==", "0", ")", "{", "ldb", "=", "dbl", "=", "64", ";", "}", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"mlong-double=32\"", ")", "==", "0", ")", "{", "ldb", "=", "dbl", "=", "32", ";", "}", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"mlong-double=64\"", ")", "==", "0", ")", "{", "ldb", "=", "64", ";", "dbl", "=", "ldb", ";", "}", "}", "return", "concat", "(", "\" %<mdouble=* -mdouble=\"", ",", "dbl", "==", "32", "?", "\"32\"", ":", "\"64\"", ",", "\" %<mlong-double=* -mlong-double=\"", ",", "ldb", "==", "32", "?", "\"32\"", ":", "\"64\"", ",", "NULL", ")", ";", "}", "</s>" ]
[ "Re-build", "the", "-mdouble=", "and", "-mlong-double=", "options", ".", "This", "is", "needed", "because", "these", "options", "are", "not", "independent", "of", "each", "other", "." ]
[ "avr", "64", "32", "64", "32", "0", "\"mdouble=32\"", "0", "32", "\"mdouble=64\"", "0", "64", "\"mlong-double=32\"", "0", "32", "\"mlong-double=64\"", "0", "64", "\" %<mdouble=* -mdouble=\"", "32", "\"32\"", "\"64\"", "\" %<mlong-double=* -mlong-double=\"", "32", "\"32\"", "\"64\"" ]
driver-avr
avr_double_lib
avr
MPU
GCC
98
173
1
[]
[ "<s>", "BitVector", "MipsRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "static", "const", "unsigned", "ReservedCPURegs", "[", "]", "=", "{", "Mips", "::", "ZERO", ",", "Mips", "::", "AT", ",", "Mips", "::", "K0", ",", "Mips", "::", "K1", ",", "Mips", "::", "GP", ",", "Mips", "::", "SP", ",", "Mips", "::", "FP", ",", "Mips", "::", "RA", ",", "0", "}", ";", "static", "const", "unsigned", "ReservedCPU64Regs", "[", "]", "=", "{", "Mips", "::", "ZERO_64", ",", "Mips", "::", "AT_64", ",", "Mips", "::", "K0_64", ",", "Mips", "::", "K1_64", ",", "Mips", "::", "GP_64", ",", "Mips", "::", "SP_64", ",", "Mips", "::", "FP_64", ",", "Mips", "::", "RA_64", ",", "0", "}", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "typedef", "TargetRegisterClass", "::", "iterator", "RegIter", ";", "for", "(", "const", "unsigned", "*", "Reg", "=", "ReservedCPURegs", ";", "*", "Reg", ";", "++", "Reg", ")", "Reserved", ".", "set", "(", "*", "Reg", ")", ";", "if", "(", "Subtarget", ".", "hasMips64", "(", ")", ")", "{", "for", "(", "const", "unsigned", "*", "Reg", "=", "ReservedCPU64Regs", ";", "*", "Reg", ";", "++", "Reg", ")", "Reserved", ".", "set", "(", "*", "Reg", ")", ";", "for", "(", "RegIter", "Reg", "=", "Mips", "::", "AFGR64RegisterClass", "->", "begin", "(", ")", ";", "Reg", "!=", "Mips", "::", "AFGR64RegisterClass", "->", "end", "(", ")", ";", "++", "Reg", ")", "Reserved", ".", "set", "(", "*", "Reg", ")", ";", "}", "else", "{", "for", "(", "RegIter", "Reg", "=", "Mips", "::", "CPU64RegsRegisterClass", "->", "begin", "(", ")", ";", "Reg", "!=", "Mips", "::", "CPU64RegsRegisterClass", "->", "end", "(", ")", ";", "++", "Reg", ")", "Reserved", ".", "set", "(", "*", "Reg", ")", ";", "for", "(", "RegIter", "Reg", "=", "Mips", "::", "FGR64RegisterClass", "->", "begin", "(", ")", ";", "Reg", "!=", "Mips", "::", "FGR64RegisterClass", "->", "end", "(", ")", ";", "++", "Reg", ")", "Reserved", ".", "set", "(", "*", "Reg", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]
[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]
[ "Mips", "Mips", "Mips::ZERO", "Mips::AT", "Mips::K0", "Mips::K1", "Mips::GP", "Mips::SP", "Mips::FP", "Mips::RA", "0", "Mips::ZERO_64", "Mips::AT_64", "Mips::K0_64", "Mips::K1_64", "Mips::GP_64", "Mips::SP_64", "Mips::FP_64", "Mips::RA_64", "0", "Mips", "Mips::AFGR64RegisterClass", "Mips::AFGR64RegisterClass", "Mips::CPU64RegsRegisterClass", "Mips::CPU64RegsRegisterClass", "Mips::FGR64RegisterClass", "Mips::FGR64RegisterClass" ]
MipsRegisterInfo60
getReservedRegs
Mips
CPU
LLVM
99
277
1
[]