Datasets:
docz1105
/
ComBack

Dataset card Data Studio Files
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>", "bool", "LanaiInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "SrcReg2", ",", "int", "&", "CmpMask", ",", "int", "&", "CmpValue", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Lanai", "::", "SFSUB_F_RI_LO", ":", "case", "Lanai", "::", "SFSUB_F_RI_HI", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "case", "Lanai", "::", "SFSUB_F_RR", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]
[ "analyzeCompare", "-", "For", "a", "comparison", "instruction", ",", "return", "the", "source", "registers", "in", "SrcReg", "and", "SrcReg2", "if", "having", "two", "register", "operands", ",", "and", "the", "value", "it", "compares", "against", "in", "CmpValue", "." ]
[ "Lanai", "Lanai", "Lanai::SFSUB_F_RI_LO", "Lanai::SFSUB_F_RI_HI", "0", "0", "0", "1", "Lanai::SFSUB_F_RR", "0", "1", "0", "0" ]
LanaiInstrInfo (2)
analyzeCompare
Lanai
CPU
LLVM
18,300
137
1
[]
[ "<s>", "static", "bool", "isSigned", "(", "Value", "*", "V", ")", "{", "if", "(", "!", "isa", "<", "Instruction", ">", "(", "V", ")", ")", "return", "false", ";", "unsigned", "Opc", "=", "cast", "<", "Instruction", ">", "(", "V", ")", "->", "getOpcode", "(", ")", ";", "return", "Opc", "==", "Instruction", "::", "AShr", "||", "Opc", "==", "Instruction", "::", "SDiv", "||", "Opc", "==", "Instruction", "::", "SRem", ";", "}", "</s>" ]
[ "Returns", "true", "if", "all", "source", "operands", "of", "the", "recurrence", "are", "SExtInsts", "." ]
[ "ARM" ]
ARMCodeGenPrepare1
isSigned
ARM
CPU
LLVM
18,301
58
1
[]
[ "<s>", "static", "bool", "rs6000_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_MACHO", "&&", "rs6000_darwin64_abi", "&&", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">", "0", ")", "{", "CUMULATIVE_ARGS", "valcum", ";", "rtx", "valret", ";", "valcum", ".", "words", "=", "0", ";", "valcum", ".", "fregno", "=", "FP_ARG_MIN_REG", ";", "valcum", ".", "vregno", "=", "ALTIVEC_ARG_MIN_REG", ";", "valret", "=", "rs6000_darwin64_record_arg", "(", "&", "valcum", ",", "type", ",", "true", ",", "true", ")", ";", "if", "(", "valret", ")", "return", "false", ";", "}", "if", "(", "rs6000_discover_homogeneous_aggregate", "(", "TYPE_MODE", "(", "type", ")", ",", "type", ",", "NULL", ",", "NULL", ")", ")", "return", "false", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_ELFv2", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "type", ")", "<=", "16", ")", "return", "false", ";", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "(", "aix_struct_return", "||", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "type", ")", ">", "8", ")", ")", "return", "true", ";", "if", "(", "TARGET_32BIT", "&&", "!", "TARGET_ALTIVEC_ABI", "&&", "ALTIVEC_VECTOR_MODE", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">", "(", "TARGET_ALTIVEC_ABI", "?", "16", ":", "8", ")", ")", "{", "static", "bool", "warned_for_return_big_vectors", "=", "false", ";", "if", "(", "!", "warned_for_return_big_vectors", ")", "{", "warning", "(", "OPT_Wpsabi", ",", "\"GCC vector returned by reference: \"", "\"non-standard ABI extension with no compatibility \"", "\"guarantee\"", ")", ";", "warned_for_return_big_vectors", "=", "true", ";", "}", "return", "true", ";", "}", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "TARGET_IEEEQUAD", "&&", "FLOAT128_IEEE_P", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]
[ "Return", "a", "nonzero", "value", "to", "say", "to", "return", "the", "function", "value", "in", "memory", ",", "just", "as", "large", "structures", "are", "always", "returned", ".", "TYPE", "will", "be", "the", "data", "type", "of", "the", "value", ",", "and", "FNTYPE", "will", "be", "the", "type", "of", "the", "function", "doing", "the", "returning", ",", "or", "@", "code", "{", "NULL", "}", "for", "libcalls", ".", "The", "AIX", "ABI", "for", "the", "RS/6000", "specifies", "that", "all", "structures", "are", "returned", "in", "memory", ".", "The", "Darwin", "ABI", "does", "the", "same", ".", "The", "SVR4", "ABI", "specifies", "that", "structures", "<", "=", "8", "bytes", "are", "returned", "in", "r3/r4", ",", "but", "a", "draft", "put", "them", "in", "memory", ",", "and", "GCC", "used", "to", "implement", "the", "draft", "instead", "of", "the", "final", "standard", ".", "Therefore", ",", "aix_struct_return", "controls", "this", "instead", "of", "DEFAULT_ABI", ";", "V.4", "targets", "needing", "backward", "compatibility", "can", "change", "DRAFT_V4_STRUCT_RET", "to", "override", "the", "default", ",", "and", "-m", "switches", "get", "the", "final", "word", ".", "See", "rs6000_override_options", "for", "more", "details", ".", "The", "PPC32", "SVR4", "ABI", "uses", "IEEE", "double", "extended", "for", "long", "double", ",", "if", "128-bit", "long", "double", "support", "is", "enabled", ".", "These", "values", "are", "returned", "in", "memory", ".", "int_size_in_bytes", "returns", "-1", "for", "variable", "size", "objects", ",", "which", "go", "in", "memory", "always", ".", "The", "cast", "to", "unsigned", "makes", "-1", ">", "8", "." ]
[ "rs6000", "0", "0", "16", "8", "16", "8", "\"GCC vector returned by reference: \"", "\"non-standard ABI extension with no compatibility \"", "\"guarantee\"" ]
rs60007
rs6000_return_in_memory
rs6000
CPU
GCC
18,302
242
1
[]
[ "<s>", "const", "TargetRegisterClass", "*", "SHUXIRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "return", "&", "SHUXI", "::", "GPRegsRegClass", ";", "}", "</s>" ]
[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]
[ "SHUXI", "SHUXI", "SHUXI::GPRegsRegClass" ]
SHUXIRegisterInfo
getPointerRegClass
SHUXI
CPU
LLVM
18,303
24
1
[]
[ "<s>", "int", "pa_mem_shadd_constant_p", "(", "int", "val", ")", "{", "if", "(", "val", "==", "2", "||", "val", "==", "4", "||", "val", "==", "8", ")", "return", "1", ";", "else", "return", "0", ";", "}", "</s>" ]
[ "Return", "1", "if", "the", "given", "constant", "is", "2", ",", "4", ",", "or", "8", ".", "These", "are", "the", "valid", "constants", "for", "a", "MULT", "embedded", "inside", "a", "memory", "address", "." ]
[ "pa", "2", "4", "8", "1", "0" ]
pa
pa_mem_shadd_constant_p
pa
CPU
GCC
18,304
29
1
[]
[ "<s>", "SDValue", "SITargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "{", "SDValue", "Result", "=", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "assert", "(", "(", "!", "Result", ".", "getNode", "(", ")", "||", "Result", ".", "getNode", "(", ")", "->", "getNumValues", "(", ")", "==", "2", ")", "&&", "\"Load should return a value and a chain\"", ")", ";", "return", "Result", ";", "}", "case", "ISD", "::", "FSIN", ":", "case", "ISD", "::", "FCOS", ":", "return", "LowerTrig", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "LowerFDIV", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "return", "LowerATOMIC_CMP_SWAP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "return", "LowerGlobalAddress", "(", "MFI", ",", "Op", ",", "DAG", ")", ";", "}", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "LowerINTRINSIC_W_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "return", "LowerINTRINSIC_VOID", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADDRSPACECAST", ":", "return", "lowerADDRSPACECAST", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "lowerINSERT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "lowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "lowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_ROUND", ":", "return", "lowerFP_ROUND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "TRAP", ":", "return", "lowerTRAP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DEBUGTRAP", ":", "return", "lowerDEBUGTRAP", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]
[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]
[ "AMDGPU", "SI", "AMDGPU", "ISD::BRCOND", "ISD::LOAD", "2", "\"Load should return a value and a chain\"", "ISD::FSIN", "ISD::FCOS", "ISD::SELECT", "ISD::FDIV", "ISD::ATOMIC_CMP_SWAP", "ISD::STORE", "ISD::GlobalAddress", "SI", "SI", "ISD::INTRINSIC_WO_CHAIN", "SI", "ISD::INTRINSIC_W_CHAIN", "SI", "ISD::INTRINSIC_VOID", "SI", "ISD::ADDRSPACECAST", "ISD::INSERT_VECTOR_ELT", "ISD::EXTRACT_VECTOR_ELT", "ISD::BUILD_VECTOR", "ISD::FP_ROUND", "ISD::TRAP", "ISD::DEBUGTRAP" ]
SIISelLowering43
LowerOperation
AMDGPU
GPU
LLVM
18,305
341
1
[]
[ "<s>", "static", "bool", "nios2_in_small_data_p", "(", "const_tree", "exp", ")", "{", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "STRING_CST", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "VAR_DECL", ")", "{", "if", "(", "DECL_SECTION_NAME", "(", "exp", ")", ")", "{", "const", "char", "*", "section", "=", "DECL_SECTION_NAME", "(", "exp", ")", ";", "if", "(", "nios2_small_section_name_p", "(", "section", ")", ")", "return", "true", ";", "}", "else", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "TREE_TYPE", "(", "exp", ")", ")", ";", "if", "(", "size", ">", "0", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "size", "<=", "nios2_section_threshold", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]
[ "Return", "true", "if", "EXP", "should", "be", "placed", "in", "the", "small", "data", "section", "." ]
[ "nios2", "0" ]
nios22
nios2_in_small_data_p
nios2
MPU
GCC
18,306
95
1
[]
[ "<s>", "static", "opt_scalar_float_mode", "rs6000_floatn_mode", "(", "int", "n", ",", "bool", "extended", ")", "{", "if", "(", "extended", ")", "{", "switch", "(", "n", ")", "{", "case", "32", ":", "return", "DFmode", ";", "case", "64", ":", "if", "(", "TARGET_FLOAT128_KEYWORD", ")", "return", "(", "FLOAT128_IEEE_P", "(", "TFmode", ")", ")", "?", "TFmode", ":", "KFmode", ";", "else", "return", "opt_scalar_float_mode", "(", ")", ";", "case", "128", ":", "return", "opt_scalar_float_mode", "(", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "{", "switch", "(", "n", ")", "{", "case", "32", ":", "return", "SFmode", ";", "case", "64", ":", "return", "DFmode", ";", "case", "128", ":", "if", "(", "TARGET_FLOAT128_KEYWORD", ")", "return", "(", "FLOAT128_IEEE_P", "(", "TFmode", ")", ")", "?", "TFmode", ":", "KFmode", ";", "else", "return", "opt_scalar_float_mode", "(", ")", ";", "default", ":", "return", "opt_scalar_float_mode", "(", ")", ";", "}", "}", "}", "</s>" ]
[ "Target", "hook", "for", "floatn_mode", "." ]
[ "powerpcspe", "32", "64", "128", "32", "64", "128" ]
powerpcspe
rs6000_floatn_mode
powerpcspe
CPU
GCC
18,307
122
1
[]
[ "<s>", "unsigned", "get132Opcode", "(", ")", "const", "{", "return", "Opcodes", "[", "Form132", "]", ";", "}", "</s>" ]
[ "Returns", "the", "132", "form", "of", "FMA", "opcode", "." ]
[ "X86" ]
X86InstrFMA3Info11
get132Opcode
X86
CPU
LLVM
18,308
13
1
[]
[ "<s>", "bool", "MSP430FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setCalleeSavedFrameSize", "(", "CSI", ".", "size", "(", ")", "*", "2", ")", ";", "bool", "MSP430X", "=", "MF", ".", "getSubtarget", "<", "MSP430Subtarget", ">", "(", ")", ".", "hasMSP430X", "(", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "!", "MSP430X", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "if", "(", "MSP430X", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "PUSHM16r", ")", ")", ".", "addImm", "(", "CSI", ".", "size", "(", ")", ")", ".", "addReg", "(", "CSI", "[", "CSI", ".", "size", "(", ")", "-", "1", "]", ".", "getReg", "(", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "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", "(", ")", "." ]
[ "MSP430", "MSP430", "MSP430", "MSP430", "2", "MSP430", "MSP430", "MSP430", "0", "1", "MSP430", "MSP430::PUSH16r", "MSP430", "MSP430::PUSHM16r", "1" ]
MSP430FrameLowering31
spillCalleeSavedRegisters
MSP430
MPU
LLVM
18,309
268
1
[]
[ "<s>", "bool", "GeneralShuffle", "::", "add", "(", "SDValue", "Op", ",", "unsigned", "Elem", ")", "{", "unsigned", "BytesPerElement", "=", "VT", ".", "getVectorElementType", "(", ")", ".", "getStoreSize", "(", ")", ";", "EVT", "FromVT", "=", "Op", ".", "getNode", "(", ")", "?", "Op", ".", "getValueType", "(", ")", ":", "VT", ";", "unsigned", "FromBytesPerElement", "=", "FromVT", ".", "getVectorElementType", "(", ")", ".", "getStoreSize", "(", ")", ";", "if", "(", "FromBytesPerElement", "<", "BytesPerElement", ")", "return", "false", ";", "unsigned", "Byte", "=", "(", "(", "Elem", "*", "FromBytesPerElement", ")", "%", "SystemZ", "::", "VectorBytes", "+", "(", "FromBytesPerElement", "-", "BytesPerElement", ")", ")", ";", "while", "(", "Op", ".", "getNode", "(", ")", ")", "{", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", ")", "Op", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "else", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "VECTOR_SHUFFLE", "&&", "Op", ".", "hasOneUse", "(", ")", ")", "{", "SmallVector", "<", "int", ",", "SystemZ", "::", "VectorBytes", ">", "OpBytes", ";", "if", "(", "!", "getVPermMask", "(", "Op", ",", "OpBytes", ")", ")", "break", ";", "int", "NewByte", ";", "if", "(", "!", "getShuffleInput", "(", "OpBytes", ",", "Byte", ",", "BytesPerElement", ",", "NewByte", ")", ")", "break", ";", "if", "(", "NewByte", "<", "0", ")", "{", "addUndef", "(", ")", ";", "return", "true", ";", "}", "Op", "=", "Op", ".", "getOperand", "(", "unsigned", "(", "NewByte", ")", "/", "SystemZ", "::", "VectorBytes", ")", ";", "Byte", "=", "unsigned", "(", "NewByte", ")", "%", "SystemZ", "::", "VectorBytes", ";", "}", "else", "if", "(", "Op", ".", "isUndef", "(", ")", ")", "{", "addUndef", "(", ")", ";", "return", "true", ";", "}", "else", "break", ";", "}", "unsigned", "OpNo", "=", "0", ";", "for", "(", ";", "OpNo", "<", "Ops", ".", "size", "(", ")", ";", "++", "OpNo", ")", "if", "(", "Ops", "[", "OpNo", "]", "==", "Op", ")", "break", ";", "if", "(", "OpNo", "==", "Ops", ".", "size", "(", ")", ")", "Ops", ".", "push_back", "(", "Op", ")", ";", "unsigned", "Base", "=", "OpNo", "*", "SystemZ", "::", "VectorBytes", "+", "Byte", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "BytesPerElement", ";", "++", "I", ")", "Bytes", ".", "push_back", "(", "Base", "+", "I", ")", ";", "return", "true", ";", "}", "</s>" ]
[ "Add", "a", "string", "to", "the", "builder", "." ]
[ "SystemZ", "SystemZ::VectorBytes", "ISD::BITCAST", "0", "ISD::VECTOR_SHUFFLE", "SystemZ::VectorBytes", "0", "SystemZ::VectorBytes", "SystemZ::VectorBytes", "0", "SystemZ::VectorBytes", "0" ]
SystemZISelLowering (2)2
add
SystemZ
CPU
LLVM
18,310
326
1
[]
[ "<s>", "bool", "rs6000_global_entry_point_prologue_needed_p", "(", "void", ")", "{", "if", "(", "DEFAULT_ABI", "!=", "ABI_ELFv2", ")", "return", "false", ";", "if", "(", "TARGET_SINGLE_PIC_BASE", ")", "return", "false", ";", "if", "(", "rs6000_pcrel_p", "(", ")", ")", "return", "false", ";", "if", "(", "cfun", "->", "is_thunk", ")", "return", "true", ";", "return", "cfun", "->", "machine", "->", "r2_setup_needed", ";", "}", "</s>" ]
[ "Return", "whether", "we", "need", "to", "emit", "an", "ELFv2", "global", "entry", "point", "prologue", "." ]
[ "rs6000" ]
rs6000-logue
rs6000_global_entry_point_prologue_needed_p
rs6000
CPU
GCC
18,311
48
1
[]
[ "<s>", "bool", "AMDGPUPromoteAlloca", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "TM", "||", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "FunctionType", "*", "FTy", "=", "F", ".", "getFunctionType", "(", ")", ";", "for", "(", "Type", "*", "ParamTy", ":", "FTy", "->", "params", "(", ")", ")", "{", "PointerType", "*", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "ParamTy", ")", ";", "if", "(", "PtrTy", "&&", "PtrTy", "->", "getAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "{", "LocalMemLimit", "=", "0", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Function has local memory argument. Promoting to \"", "\"local memory disabled.\\n\"", ")", ";", "return", "false", ";", "}", "}", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", "F", ")", ";", "LocalMemLimit", "=", "ST", ".", "getLocalMemorySize", "(", ")", ";", "if", "(", "LocalMemLimit", "==", "0", ")", "return", "false", ";", "const", "DataLayout", "&", "DL", "=", "Mod", "->", "getDataLayout", "(", ")", ";", "CurrentLocalMemUsage", "=", "0", ";", "for", "(", "GlobalVariable", "&", "GV", ":", "Mod", "->", "globals", "(", ")", ")", "{", "if", "(", "GV", ".", "getType", "(", ")", "->", "getAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "continue", ";", "for", "(", "const", "User", "*", "U", ":", "GV", ".", "users", "(", ")", ")", "{", "const", "Instruction", "*", "Use", "=", "dyn_cast", "<", "Instruction", ">", "(", "U", ")", ";", "if", "(", "!", "Use", ")", "continue", ";", "if", "(", "Use", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "==", "&", "F", ")", "{", "unsigned", "Align", "=", "GV", ".", "getAlignment", "(", ")", ";", "if", "(", "Align", "==", "0", ")", "Align", "=", "DL", ".", "getABITypeAlignment", "(", "GV", ".", "getValueType", "(", ")", ")", ";", "uint64_t", "AllocSize", "=", "DL", ".", "getTypeAllocSize", "(", "GV", ".", "getValueType", "(", ")", ")", ";", "CurrentLocalMemUsage", "=", "alignTo", "(", "CurrentLocalMemUsage", ",", "Align", ")", ";", "CurrentLocalMemUsage", "+=", "AllocSize", ";", "break", ";", "}", "}", "}", "unsigned", "MaxOccupancy", "=", "ST", ".", "getOccupancyWithLocalMemSize", "(", "CurrentLocalMemUsage", ")", ";", "unsigned", "OccupancyHint", "=", "AMDGPU", "::", "getIntegerAttribute", "(", "F", ",", "\"amdgpu-max-waves-per-eu\"", ",", "0", ")", ";", "if", "(", "OccupancyHint", "==", "0", ")", "OccupancyHint", "=", "7", ";", "OccupancyHint", "=", "std", "::", "min", "(", "OccupancyHint", ",", "ST", ".", "getMaxWavesPerCU", "(", ")", ")", ";", "MaxOccupancy", "=", "std", "::", "min", "(", "OccupancyHint", ",", "MaxOccupancy", ")", ";", "unsigned", "MaxSizeWithWaveCount", "=", "ST", ".", "getMaxLocalMemSizeWithWaveCount", "(", "MaxOccupancy", ")", ";", "if", "(", "CurrentLocalMemUsage", ">", "MaxSizeWithWaveCount", ")", "return", "false", ";", "LocalMemLimit", "=", "MaxSizeWithWaveCount", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "F", ".", "getName", "(", ")", "<<", "\" uses \"", "<<", "CurrentLocalMemUsage", "<<", "\" bytes of LDS\\n\"", "<<", "\" Rounding size to \"", "<<", "MaxSizeWithWaveCount", "<<", "\" with a maximum occupancy of \"", "<<", "MaxOccupancy", "<<", "'\\n'", "<<", "\" and \"", "<<", "(", "LocalMemLimit", "-", "CurrentLocalMemUsage", ")", "<<", "\" available for promotion\\n\"", ")", ";", "BasicBlock", "&", "EntryBB", "=", "*", "F", ".", "begin", "(", ")", ";", "for", "(", "auto", "I", "=", "EntryBB", ".", "begin", "(", ")", ",", "E", "=", "EntryBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "AllocaInst", "*", "AI", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "I", ")", ";", "++", "I", ";", "if", "(", "AI", ")", "handleAlloca", "(", "*", "AI", ")", ";", "}", "return", "true", ";", "}", "</s>" ]
[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]
[ "AMDGPU", "AMDGPU", "AMDGPU", "0", "\"Function has local memory argument. Promoting to \"", "\"local memory disabled.\\n\"", "AMDGPU", "AMDGPU", "0", "0", "AMDGPU", "0", "AMDGPU::getIntegerAttribute", "\"amdgpu-max-waves-per-eu\"", "0", "0", "7", "\" uses \"", "\" bytes of LDS\\n\"", "\" Rounding size to \"", "\" with a maximum occupancy of \"", "\" and \"", "\" available for promotion\\n\"" ]
AMDGPUPromoteAlloca34
runOnFunction
AMDGPU
GPU
LLVM
18,312
468
1
[]
[ "<s>", "XCoreTargetMachine", "::", "XCoreTargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "DL", "(", "\"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", "(", ")", ",", "FrameLowering", "(", "Subtarget", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "TSInfo", "(", "*", "this", ")", "{", "initAsmInfo", "(", ")", ";", "}", "</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\"" ]
XCoreTargetMachine13
XCoreTargetMachine
XCore
MPU
LLVM
18,313
99
1
[]
[ "<s>", "void", "WebAssemblyRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "FrameOffset", "=", "MFI", ".", "getStackSize", "(", ")", "+", "MFI", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "if", "(", "MI", ".", "mayLoadOrStore", "(", ")", ")", "{", "assert", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "0", "&&", "\"Can't eliminate FI yet if offset is already set\"", ")", ";", "MI", ".", "getOperand", "(", "1", ")", ".", "setImm", "(", "FrameOffset", ")", ";", "MI", ".", "getOperand", "(", "2", ")", ".", "ChangeToRegister", "(", "WebAssembly", "::", "SP32", ",", "false", ")", ";", "}", "else", "{", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "unsigned", "OffsetReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "WebAssembly", "::", "I32RegClass", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "WebAssembly", "::", "CONST_I32", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "FrameOffset", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "WebAssembly", "::", "ADD_I32", ")", ",", "OffsetReg", ")", ".", "addReg", "(", "WebAssembly", "::", "SP32", ")", ".", "addReg", "(", "OffsetReg", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "OffsetReg", ",", "false", ")", ";", "}", "}", "</s>" ]
[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]
[ "WebAssembly", "WebAssembly", "0", "1", "0", "\"Can't eliminate FI yet if offset is already set\"", "1", "2", "WebAssembly::SP32", "WebAssembly::I32RegClass", "WebAssembly::CONST_I32", "WebAssembly::ADD_I32", "WebAssembly::SP32" ]
WebAssemblyRegisterInfo (2)
eliminateFrameIndex
WebAssembly
Virtual ISA
LLVM
18,314
276
1
[]
[ "<s>", "static", "unsigned", "getOppositeBranchOpc", "(", "unsigned", "Opcode", ")", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown conditional branch!\"", ")", ";", "case", "CSKY", "::", "BT32", ":", "return", "CSKY", "::", "BF32", ";", "case", "CSKY", "::", "BT16", ":", "return", "CSKY", "::", "BF16", ";", "case", "CSKY", "::", "BF32", ":", "return", "CSKY", "::", "BT32", ";", "case", "CSKY", "::", "BF16", ":", "return", "CSKY", "::", "BT16", ";", "case", "CSKY", "::", "BHZ32", ":", "return", "CSKY", "::", "BLSZ32", ";", "case", "CSKY", "::", "BHSZ32", ":", "return", "CSKY", "::", "BLZ32", ";", "case", "CSKY", "::", "BLZ32", ":", "return", "CSKY", "::", "BHSZ32", ";", "case", "CSKY", "::", "BLSZ32", ":", "return", "CSKY", "::", "BHZ32", ";", "case", "CSKY", "::", "BNEZ32", ":", "return", "CSKY", "::", "BEZ32", ";", "case", "CSKY", "::", "BEZ32", ":", "return", "CSKY", "::", "BNEZ32", ";", "}", "}", "</s>" ]
[ "getOppositeBranchOpc", "-", "Return", "the", "inverse", "of", "the", "specified", "opcode", ",", "e.g", "." ]
[ "CSKY", "\"Unknown conditional branch!\"", "CSKY::BT32", "CSKY::BF32", "CSKY::BT16", "CSKY::BF16", "CSKY::BF32", "CSKY::BT32", "CSKY::BF16", "CSKY::BT16", "CSKY::BHZ32", "CSKY::BLSZ32", "CSKY::BHSZ32", "CSKY::BLZ32", "CSKY::BLZ32", "CSKY::BHSZ32", "CSKY::BLSZ32", "CSKY::BHZ32", "CSKY::BNEZ32", "CSKY::BEZ32", "CSKY::BEZ32", "CSKY::BNEZ32" ]
CSKYInstrInfo1
getOppositeBranchOpc
CSKY
CPU
LLVM
18,315
122
1
[]
[ "<s>", "void", "RISCVDAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "SDNode", "*", "N", "=", "&", "*", "I", "++", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "RISCVISD", "::", "SPLAT_VECTOR_SPLIT_I64_VL", ")", "continue", ";", "assert", "(", "N", "->", "getNumOperands", "(", ")", "==", "3", "&&", "\"Unexpected number of operands\"", ")", ";", "MVT", "VT", "=", "N", "->", "getSimpleValueType", "(", "0", ")", ";", "SDValue", "Lo", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Hi", "=", "N", "->", "getOperand", "(", "1", ")", ";", "SDValue", "VL", "=", "N", "->", "getOperand", "(", "2", ")", ";", "assert", "(", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i64", "&&", "VT", ".", "isScalableVector", "(", ")", "&&", "Lo", ".", "getValueType", "(", ")", "==", "MVT", "::", "i32", "&&", "Hi", ".", "getValueType", "(", ")", "==", "MVT", "::", "i32", "&&", "\"Unexpected VTs!\"", ")", ";", "MachineFunction", "&", "MF", "=", "CurDAG", "->", "getMachineFunction", "(", ")", ";", "RISCVMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "int", "FI", "=", "FuncInfo", "->", "getMoveF64FrameIndex", "(", "MF", ")", ";", "MachinePointerInfo", "MPI", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ";", "const", "TargetLowering", "&", "TLI", "=", "CurDAG", "->", "getTargetLoweringInfo", "(", ")", ";", "SDValue", "StackSlot", "=", "CurDAG", "->", "getFrameIndex", "(", "FI", ",", "TLI", ".", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", ")", ";", "SDValue", "Chain", "=", "CurDAG", "->", "getEntryNode", "(", ")", ";", "Lo", "=", "CurDAG", "->", "getStore", "(", "Chain", ",", "DL", ",", "Lo", ",", "StackSlot", ",", "MPI", ",", "Align", "(", "8", ")", ")", ";", "SDValue", "OffsetSlot", "=", "CurDAG", "->", "getMemBasePlusOffset", "(", "StackSlot", ",", "TypeSize", "::", "Fixed", "(", "4", ")", ",", "DL", ")", ";", "Hi", "=", "CurDAG", "->", "getStore", "(", "Chain", ",", "DL", ",", "Hi", ",", "OffsetSlot", ",", "MPI", ".", "getWithOffset", "(", "4", ")", ",", "Align", "(", "8", ")", ")", ";", "Chain", "=", "CurDAG", "->", "getNode", "(", "ISD", "::", "TokenFactor", ",", "DL", ",", "MVT", "::", "Other", ",", "Lo", ",", "Hi", ")", ";", "SDVTList", "VTs", "=", "CurDAG", "->", "getVTList", "(", "{", "VT", ",", "MVT", "::", "Other", "}", ")", ";", "SDValue", "IntID", "=", "CurDAG", "->", "getTargetConstant", "(", "Intrinsic", "::", "riscv_vlse", ",", "DL", ",", "MVT", "::", "i64", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Chain", ",", "IntID", ",", "CurDAG", "->", "getUNDEF", "(", "VT", ")", ",", "StackSlot", ",", "CurDAG", "->", "getRegister", "(", "RISCV", "::", "X0", ",", "MVT", "::", "i64", ")", ",", "VL", "}", ";", "SDValue", "Result", "=", "CurDAG", "->", "getMemIntrinsicNode", "(", "ISD", "::", "INTRINSIC_W_CHAIN", ",", "DL", ",", "VTs", ",", "Ops", ",", "MVT", "::", "i64", ",", "MPI", ",", "Align", "(", "8", ")", ",", "MachineMemOperand", "::", "MOLoad", ")", ";", "--", "I", ";", "CurDAG", "->", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "0", ")", ",", "Result", ")", ";", "++", "I", ";", "CurDAG", "->", "DeleteNode", "(", "N", ")", ";", "}", "}", "</s>" ]
[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]
[ "RISCV", "RISCV", "RISCVISD::SPLAT_VECTOR_SPLIT_I64_VL", "3", "\"Unexpected number of operands\"", "0", "0", "1", "2", "MVT::i64", "MVT::i32", "MVT::i32", "\"Unexpected VTs!\"", "RISCV", "RISCV", "8", "4", "4", "8", "ISD::TokenFactor", "MVT::Other", "MVT::Other", "Intrinsic::riscv_vlse", "MVT::i64", "RISCV::X0", "MVT::i64", "ISD::INTRINSIC_W_CHAIN", "MVT::i64", "8", "0" ]
RISCVISelDAGToDAG35
PreprocessISelDAG
RISCV
CPU
LLVM
18,316
463
1
[]
[ "<s>", "int", "spu_saved_regs_size", "(", "void", ")", "{", "int", "reg_save_size", "=", "0", ";", "int", "regno", ";", "for", "(", "regno", "=", "FIRST_PSEUDO_REGISTER", "-", "1", ";", "regno", ">=", "0", ";", "--", "regno", ")", "if", "(", "need_to_save_reg", "(", "regno", ",", "0", ")", ")", "reg_save_size", "+=", "0x10", ";", "return", "reg_save_size", ";", "}", "</s>" ]
[ "This", "function", "is", "only", "correct", "starting", "with", "local", "register", "allocation" ]
[ "spu", "0", "1", "0", "0", "0x10" ]
spu
spu_saved_regs_size
spu
MPU
GCC
18,317
46
1
[]
[ "<s>", "void", "MINA32InstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "'$'", "<<", "StringRef", "(", "getRegisterName", "(", "RegNo", ")", ")", ".", "lower", "(", ")", ";", "}", "</s>" ]
[ "Print", "the", "assembler", "register", "name", "." ]
[ "MINA32", "MINA32" ]
MINA32InstPrinter
printRegName
MINA32
CPU
LLVM
18,318
31
1
[]
[ "<s>", "static", "Cpu0ABIInfo", "Unknown", "(", ")", "{", "return", "Cpu0ABIInfo", "(", "ABI", "::", "Unknown", ")", ";", "}", "</s>" ]
[ "The", "kind", "of", "location", "description", "being", "produced", ".", "More", "..." ]
[ "Cpu0", "Cpu0", "Cpu0", "ABI::Unknown" ]
Cpu0ABIInfo
Unknown
Cpu0
CPU
LLVM
18,319
15
1
[]
[ "<s>", "static", "bool", "frv_local_funcdesc_p", "(", "rtx", "fnx", ")", "{", "tree", "fn", ";", "enum", "symbol_visibility", "vis", ";", "bool", "ret", ";", "if", "(", "!", "SYMBOL_REF_LOCAL_P", "(", "fnx", ")", ")", "return", "FALSE", ";", "fn", "=", "SYMBOL_REF_DECL", "(", "fnx", ")", ";", "if", "(", "!", "fn", ")", "return", "FALSE", ";", "vis", "=", "DECL_VISIBILITY", "(", "fn", ")", ";", "if", "(", "vis", "==", "VISIBILITY_PROTECTED", ")", "vis", "=", "VISIBILITY_DEFAULT", ";", "else", "if", "(", "flag_shlib", ")", "return", "TRUE", ";", "ret", "=", "default_binds_local_p_1", "(", "fn", ",", "flag_pic", ")", ";", "DECL_VISIBILITY", "(", "fn", ")", "=", "vis", ";", "return", "ret", ";", "}", "</s>" ]
[ "Test", "whether", "a", "local", "function", "descriptor", "is", "canonical", ",", "i.e.", ",", "whether", "we", "can", "use", "FUNCDESC_GOTOFF", "to", "compute", "the", "address", "of", "the", "function", "." ]
[ "frv" ]
frv
frv_local_funcdesc_p
frv
VLIW
GCC
18,320
89
1
[]
[ "<s>", "bool", "X86TargetLowering", "::", "isBinOp", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "X86ISD", "::", "ANDNP", ":", "case", "X86ISD", "::", "PCMPGT", ":", "case", "X86ISD", "::", "FMAX", ":", "case", "X86ISD", "::", "FMIN", ":", "case", "X86ISD", "::", "FANDN", ":", "case", "X86ISD", "::", "VPSHA", ":", "case", "X86ISD", "::", "VPSHL", ":", "case", "X86ISD", "::", "VSHLV", ":", "case", "X86ISD", "::", "VSRLV", ":", "case", "X86ISD", "::", "VSRAV", ":", "return", "true", ";", "}", "return", "TargetLoweringBase", "::", "isBinOp", "(", "Opcode", ")", ";", "}", "</s>" ]
[ "Add", "x86-specific", "opcodes", "to", "the", "default", "list", "." ]
[ "X86", "X86", "X86ISD::ANDNP", "X86ISD::PCMPGT", "X86ISD::FMAX", "X86ISD::FMIN", "X86ISD::FANDN", "X86ISD::VPSHA", "X86ISD::VPSHL", "X86ISD::VSHLV", "X86ISD::VSRLV", "X86ISD::VSRAV" ]
X86ISelLowering100
isBinOp
X86
CPU
LLVM
18,321
78
1
[]
[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 WinAlloca Expander\"", ";", "}", "</s>" ]
[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]
[ "X86", "\"X86 WinAlloca Expander\"" ]
X86WinAllocaExpander1
getPassName
X86
CPU
LLVM
18,322
13
1
[]
[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "assert", "(", "(", "Kind", "==", "k_Register", ")", "&&", "\"Invalid access!\"", ")", ";", "return", "Reg", ".", "RegNum", ";", "}", "</s>" ]
[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]
[ "VE", "\"Invalid access!\"" ]
VEAsmParser (2)
getReg
VE
CPU
LLVM
18,323
24
1
[]
[ "<s>", "AArch64Subtarget", "::", "AArch64Subtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ",", "bool", "LittleEndian", ")", ":", "AArch64GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ReserveX18", "(", "TT", ".", "isOSDarwin", "(", ")", "||", "TT", ".", "isOSWindows", "(", ")", ")", ",", "IsLittle", "(", "LittleEndian", ")", ",", "TargetTriple", "(", "TT", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "FS", ",", "CPU", ")", ")", ",", "TSInfo", "(", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "CallLoweringInfo", ".", "reset", "(", "new", "AArch64CallLowering", "(", "*", "getTargetLowering", "(", ")", ")", ")", ";", "Legalizer", ".", "reset", "(", "new", "AArch64LegalizerInfo", "(", ")", ")", ";", "auto", "*", "RBI", "=", "new", "AArch64RegisterBankInfo", "(", "*", "getRegisterInfo", "(", ")", ")", ";", "InstSelector", ".", "reset", "(", "createAArch64InstructionSelector", "(", "*", "static_cast", "<", "const", "AArch64TargetMachine", "*", ">", "(", "&", "TM", ")", ",", "*", "this", ",", "*", "RBI", ")", ")", ";", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "}", "</s>" ]
[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]
[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]
AArch64Subtarget24
AArch64Subtarget
AArch64
CPU
LLVM
18,324
163
1
[]
[ "<s>", "void", "SystemZInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]
[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]
[ "SystemZ", "SystemZ" ]
SystemZInstPrinter
printInst
SystemZ
CPU
LLVM
18,325
33
1
[]
[ "<s>", "void", "aarch64_split_128bit_move", "(", "rtx", "dst", ",", "rtx", "src", ")", "{", "rtx", "dst_lo", ",", "dst_hi", ";", "rtx", "src_lo", ",", "src_hi", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "dst", ")", ";", "gcc_assert", "(", "mode", "==", "TImode", "||", "mode", "==", "TFmode", ")", ";", "gcc_assert", "(", "!", "(", "side_effects_p", "(", "src", ")", "||", "side_effects_p", "(", "dst", ")", ")", ")", ";", "gcc_assert", "(", "mode", "==", "GET_MODE", "(", "src", ")", "||", "GET_MODE", "(", "src", ")", "==", "VOIDmode", ")", ";", "if", "(", "REG_P", "(", "dst", ")", "&&", "REG_P", "(", "src", ")", ")", "{", "int", "src_regno", "=", "REGNO", "(", "src", ")", ";", "int", "dst_regno", "=", "REGNO", "(", "dst", ")", ";", "if", "(", "FP_REGNUM_P", "(", "dst_regno", ")", "&&", "GP_REGNUM_P", "(", "src_regno", ")", ")", "{", "src_lo", "=", "gen_lowpart", "(", "word_mode", ",", "src", ")", ";", "src_hi", "=", "gen_highpart", "(", "word_mode", ",", "src", ")", ";", "if", "(", "mode", "==", "TImode", ")", "{", "emit_insn", "(", "gen_aarch64_movtilow_di", "(", "dst", ",", "src_lo", ")", ")", ";", "emit_insn", "(", "gen_aarch64_movtihigh_di", "(", "dst", ",", "src_hi", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_aarch64_movtflow_di", "(", "dst", ",", "src_lo", ")", ")", ";", "emit_insn", "(", "gen_aarch64_movtfhigh_di", "(", "dst", ",", "src_hi", ")", ")", ";", "}", "return", ";", "}", "else", "if", "(", "GP_REGNUM_P", "(", "dst_regno", ")", "&&", "FP_REGNUM_P", "(", "src_regno", ")", ")", "{", "dst_lo", "=", "gen_lowpart", "(", "word_mode", ",", "dst", ")", ";", "dst_hi", "=", "gen_highpart", "(", "word_mode", ",", "dst", ")", ";", "if", "(", "mode", "==", "TImode", ")", "{", "emit_insn", "(", "gen_aarch64_movdi_tilow", "(", "dst_lo", ",", "src", ")", ")", ";", "emit_insn", "(", "gen_aarch64_movdi_tihigh", "(", "dst_hi", ",", "src", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_aarch64_movdi_tflow", "(", "dst_lo", ",", "src", ")", ")", ";", "emit_insn", "(", "gen_aarch64_movdi_tfhigh", "(", "dst_hi", ",", "src", ")", ")", ";", "}", "return", ";", "}", "}", "dst_lo", "=", "gen_lowpart", "(", "word_mode", ",", "dst", ")", ";", "dst_hi", "=", "gen_highpart", "(", "word_mode", ",", "dst", ")", ";", "src_lo", "=", "gen_lowpart", "(", "word_mode", ",", "src", ")", ";", "src_hi", "=", "gen_highpart_mode", "(", "word_mode", ",", "mode", ",", "src", ")", ";", "if", "(", "reg_overlap_mentioned_p", "(", "dst_lo", ",", "src_hi", ")", ")", "{", "aarch64_emit_move", "(", "dst_hi", ",", "src_hi", ")", ";", "aarch64_emit_move", "(", "dst_lo", ",", "src_lo", ")", ";", "}", "else", "{", "aarch64_emit_move", "(", "dst_lo", ",", "src_lo", ")", ";", "aarch64_emit_move", "(", "dst_hi", ",", "src_hi", ")", ";", "}", "}", "</s>" ]
[ "Split", "a", "128-bit", "move", "operation", "into", "two", "64-bit", "move", "operations", ",", "taking", "care", "to", "handle", "partial", "overlap", "of", "register", "to", "register", "copies", ".", "Special", "cases", "are", "needed", "when", "moving", "between", "GP", "regs", "and", "FP", "regs", ".", "SRC", "can", "be", "a", "register", ",", "constant", "or", "memory", ";", "DST", "a", "register", "or", "memory", ".", "If", "either", "operand", "is", "memory", "it", "must", "not", "have", "any", "side", "effects", "." ]
[ "aarch64" ]
aarch642
aarch64_split_128bit_move
aarch64
CPU
GCC
18,326
354
1
[]
[ "<s>", "type_suffix_index", "function_resolver", "::", "infer_pointer_type", "(", "unsigned", "int", "argno", ",", "bool", "gather_scatter_p", ")", "{", "tree", "actual", "=", "get_argument_type", "(", "argno", ")", ";", "if", "(", "actual", "==", "error_mark_node", ")", "return", "NUM_TYPE_SUFFIXES", ";", "if", "(", "TREE_CODE", "(", "actual", ")", "!=", "POINTER_TYPE", ")", "{", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, which\"", "\" expects a pointer type\"", ",", "actual", ",", "argno", "+", "1", ",", "fndecl", ")", ";", "if", "(", "VECTOR_TYPE_P", "(", "actual", ")", "&&", "gather_scatter_p", ")", "inform", "(", "location", ",", "\"an explicit type suffix is needed\"", "\" when using a vector of base addresses\"", ")", ";", "return", "NUM_TYPE_SUFFIXES", ";", "}", "tree", "target", "=", "TREE_TYPE", "(", "actual", ")", ";", "type_suffix_index", "type", "=", "find_type_suffix_for_scalar_type", "(", "target", ")", ";", "if", "(", "type", "==", "NUM_TYPE_SUFFIXES", ")", "{", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, but %qT is not\"", "\" a valid SVE element type\"", ",", "actual", ",", "argno", "+", "1", ",", "fndecl", ",", "build_qualified_type", "(", "target", ",", "0", ")", ")", ";", "return", "NUM_TYPE_SUFFIXES", ";", "}", "unsigned", "int", "bits", "=", "type_suffixes", "[", "type", "]", ".", "element_bits", ";", "if", "(", "gather_scatter_p", "&&", "bits", "!=", "32", "&&", "bits", "!=", "64", ")", "{", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, which\"", "\" expects a pointer to 32-bit or 64-bit elements\"", ",", "actual", ",", "argno", "+", "1", ",", "fndecl", ")", ";", "return", "NUM_TYPE_SUFFIXES", ";", "}", "return", "type", ";", "}", "</s>" ]
[ "Require", "argument", "ARGNO", "to", "be", "a", "pointer", "to", "a", "scalar", "type", "that", "has", "a", "corresponding", "type", "suffix", ".", "Return", "that", "type", "suffix", "on", "success", ",", "otherwise", "report", "an", "error", "and", "return", "NUM_TYPE_SUFFIXES", ".", "GATHER_SCATTER_P", "is", "true", "if", "the", "function", "is", "a", "gather/scatter", "operation", ",", "and", "so", "requires", "a", "pointer", "to", "32-bit", "or", "64-bit", "data", "." ]
[ "aarch64", "\"passing %qT to argument %d of %qE, which\"", "\" expects a pointer type\"", "1", "\"an explicit type suffix is needed\"", "\" when using a vector of base addresses\"", "\"passing %qT to argument %d of %qE, but %qT is not\"", "\" a valid SVE element type\"", "1", "0", "32", "64", "\"passing %qT to argument %d of %qE, which\"", "\" expects a pointer to 32-bit or 64-bit elements\"", "1" ]
aarch64-sve-builtins
infer_pointer_type
aarch64
CPU
GCC
18,327
175
1
[]
[ "<s>", "void", "ix86_function_specific_print", "(", "FILE", "*", "file", ",", "int", "indent", ",", "struct", "cl_target_option", "*", "ptr", ")", "{", "char", "*", "target_string", "=", "ix86_target_string", "(", "ptr", "->", "x_ix86_isa_flags", ",", "ptr", "->", "x_ix86_isa_flags2", ",", "ptr", "->", "x_target_flags", ",", "ptr", "->", "x_ix86_target_flags", ",", "NULL", ",", "NULL", ",", "ptr", "->", "x_ix86_fpmath", ",", "ptr", "->", "x_prefer_vector_width_type", ",", "ptr", "->", "x_ix86_move_max", ",", "ptr", "->", "x_ix86_store_max", ",", "false", ",", "true", ")", ";", "gcc_assert", "(", "ptr", "->", "arch", "<", "PROCESSOR_max", ")", ";", "fprintf", "(", "file", ",", "\"%*sarch = %d (%s)\\n\"", ",", "indent", ",", "\"\"", ",", "ptr", "->", "arch", ",", "processor_names", "[", "ptr", "->", "arch", "]", ")", ";", "gcc_assert", "(", "ptr", "->", "tune", "<", "PROCESSOR_max", ")", ";", "fprintf", "(", "file", ",", "\"%*stune = %d (%s)\\n\"", ",", "indent", ",", "\"\"", ",", "ptr", "->", "tune", ",", "processor_names", "[", "ptr", "->", "tune", "]", ")", ";", "fprintf", "(", "file", ",", "\"%*sbranch_cost = %d\\n\"", ",", "indent", ",", "\"\"", ",", "ptr", "->", "branch_cost", ")", ";", "if", "(", "target_string", ")", "{", "fprintf", "(", "file", ",", "\"%*s%s\\n\"", ",", "indent", ",", "\"\"", ",", "target_string", ")", ";", "free", "(", "target_string", ")", ";", "}", "}", "</s>" ]
[ "Print", "the", "current", "options" ]
[ "i386", "\"%*sarch = %d (%s)\\n\"", "\"\"", "\"%*stune = %d (%s)\\n\"", "\"\"", "\"%*sbranch_cost = %d\\n\"", "\"\"", "\"%*s%s\\n\"", "\"\"" ]
i386-options
ix86_function_specific_print
i386
CPU
GCC
18,328
165
1
[]
[ "<s>", "SUnit", "*", "TPCSchedStrategy", "::", "pickNode", "(", "bool", "&", "IsTopNode", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n*** pickNode\\n\"", ")", ";", "SUnit", "*", "SU", "=", "nullptr", ";", "if", "(", "DAG", "->", "top", "(", ")", "==", "DAG", "->", "bottom", "(", ")", ")", "{", "assert", "(", "Top", ".", "Available", ".", "empty", "(", ")", "&&", "\"ReadyQ garbage\"", ")", ";", "return", "nullptr", ";", "}", "if", "(", "llvm", "::", "ForceTopDown", ")", "{", "SU", "=", "Top", ".", "pickOnlyChoice", "(", ")", ";", "if", "(", "!", "SU", ")", "{", "SchedCandidate", "TopCand", ";", "CandResult", "TopResult", "=", "pickNodeFromQueue", "(", "Top", ".", "Available", ",", "DAG", "->", "getTopRPTracker", "(", ")", ",", "TopCand", ")", ";", "assert", "(", "TopResult", "!=", "NoCand", "&&", "\"failed to find the first candidate\"", ")", ";", "(", "void", ")", "TopResult", ";", "SU", "=", "TopCand", ".", "SU", ";", "}", "IsTopNode", "=", "true", ";", "}", "else", "if", "(", "llvm", "::", "ForceBottomUp", ")", "{", "SU", "=", "Bot", ".", "pickOnlyChoice", "(", ")", ";", "if", "(", "!", "SU", ")", "{", "SchedCandidate", "BotCand", ";", "CandResult", "BotResult", "=", "pickNodeFromQueue", "(", "Bot", ".", "Available", ",", "DAG", "->", "getBotRPTracker", "(", ")", ",", "BotCand", ")", ";", "assert", "(", "BotResult", "!=", "NoCand", "&&", "\"failed to find the first candidate\"", ")", ";", "(", "void", ")", "BotResult", ";", "SU", "=", "BotCand", ".", "SU", ";", "}", "IsTopNode", "=", "false", ";", "}", "else", "{", "SU", "=", "pickNodeBidrectional", "(", "IsTopNode", ")", ";", "}", "if", "(", "SU", "->", "isTopReady", "(", ")", ")", "Top", ".", "removeReady", "(", "SU", ")", ";", "if", "(", "SU", "->", "isBottomReady", "(", ")", ")", "Bot", ".", "removeReady", "(", "SU", ")", ";", "LLVM_DEBUG", "(", "if", "(", "SU", ")", "{", "dbgs", "(", ")", "<<", "\"*** Pick node \"", "<<", "(", "IsTopNode", "?", "\"Top\"", ":", "\"Bottom\"", ")", "<<", "\" at cycle \"", "<<", "(", "IsTopNode", "?", "Top", ".", "CurrCycle", ":", "Bot", ".", "CurrCycle", ")", "<<", "'\\n'", ";", "dbgs", "(", ")", "<<", "\" \"", ";", "DAG", "->", "dumpNode", "(", "*", "SU", ")", ";", "}", "else", "{", "dbgs", "(", ")", "<<", "\" ** NO NODE \\n\"", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "DAG", "->", "SUnits", ".", "size", "(", ")", ";", "i", "++", ")", "{", "const", "SUnit", "&", "S", "=", "DAG", "->", "SUnits", "[", "i", "]", ";", "if", "(", "!", "S", ".", "isScheduled", ")", "DAG", "->", "dumpNode", "(", "S", ")", ";", "}", "}", "</s>" ]
[ "Pick", "the", "next", "node", "to", "schedule", ",", "or", "return", "NULL", "." ]
[ "TPC", "TPC", "\"\\n*** pickNode\\n\"", "\"ReadyQ garbage\"", "\"failed to find the first candidate\"", "\"failed to find the first candidate\"", "\"*** Pick node \"", "\"Top\"", "\"Bottom\"", "\" at cycle \"", "\" \"", "\" ** NO NODE \\n\"", "0" ]
TPCMachineScheduler
pickNode
TPC
Virtual ISA
LLVM
18,329
344
1
[]
[ "<s>", "static", "void", "s390_reorg", "(", "void", ")", "{", "bool", "pool_overflow", "=", "false", ";", "int", "hw_before", ",", "hw_after", ";", "split_all_insns_noflow", "(", ")", ";", "for", "(", ";", ";", ")", "{", "struct", "constant_pool", "*", "pool", "=", "NULL", ";", "if", "(", "!", "pool_overflow", ")", "{", "pool", "=", "s390_mainpool_start", "(", ")", ";", "if", "(", "!", "pool", ")", "pool_overflow", "=", "true", ";", "}", "if", "(", "pool_overflow", ")", "pool", "=", "s390_chunkify_start", "(", ")", ";", "if", "(", "!", "TARGET_CPU_ZARCH", "&&", "s390_split_branches", "(", ")", ")", "{", "if", "(", "pool_overflow", ")", "s390_chunkify_cancel", "(", "pool", ")", ";", "else", "s390_mainpool_cancel", "(", "pool", ")", ";", "continue", ";", "}", "if", "(", "pool_overflow", ")", "s390_chunkify_finish", "(", "pool", ")", ";", "else", "s390_mainpool_finish", "(", "pool", ")", ";", "cfun", "->", "machine", "->", "split_branches_pending_p", "=", "false", ";", "break", ";", "}", "if", "(", "TARGET_CPU_ZARCH", ")", "{", "rtx_insn", "*", "insn", ",", "*", "target", ";", "rtx", "label", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "label", "=", "s390_execute_label", "(", "insn", ")", ";", "if", "(", "!", "label", ")", "continue", ";", "gcc_assert", "(", "label", "!=", "const0_rtx", ")", ";", "target", "=", "emit_label", "(", "XEXP", "(", "label", ",", "0", ")", ")", ";", "INSN_ADDRESSES_NEW", "(", "target", ",", "-", "1", ")", ";", "target", "=", "emit_insn", "(", "s390_execute_target", "(", "insn", ")", ")", ";", "INSN_ADDRESSES_NEW", "(", "target", ",", "-", "1", ")", ";", "}", "}", "s390_optimize_prologue", "(", ")", ";", "if", "(", "s390_tune", ">=", "PROCESSOR_2097_Z10", ")", "{", "rtx_insn", "*", "insn", ";", "bool", "insn_added_p", "=", "false", ";", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "INSN_CODE", "(", "insn", ")", "<=", "0", ")", "continue", ";", "if", "(", "JUMP_P", "(", "insn", ")", ")", "insn_added_p", "|=", "s390_fix_long_loop_prediction", "(", "insn", ")", ";", "if", "(", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "PARALLEL", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", ")", "&&", "s390_tune", "==", "PROCESSOR_2097_Z10", ")", "insn_added_p", "|=", "s390_z10_optimize_cmp", "(", "insn", ")", ";", "}", "if", "(", "insn_added_p", ")", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "}", "s390_function_num_hotpatch_hw", "(", "current_function_decl", ",", "&", "hw_before", ",", "&", "hw_after", ")", ";", "if", "(", "hw_after", ">", "0", ")", "{", "rtx_insn", "*", "insn", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "active_insn_p", "(", "insn", ")", "||", "BARRIER_P", "(", "insn", ")", "||", "LABEL_P", "(", "insn", ")", ")", "break", ";", "while", "(", "insn", "&&", "hw_after", ">", "0", ")", "{", "if", "(", "hw_after", ">=", "3", "&&", "TARGET_CPU_ZARCH", ")", "{", "emit_insn_before", "(", "gen_nop_6_byte", "(", ")", ",", "insn", ")", ";", "hw_after", "-=", "3", ";", "}", "else", "if", "(", "hw_after", ">=", "2", ")", "{", "emit_insn_before", "(", "gen_nop_4_byte", "(", ")", ",", "insn", ")", ";", "hw_after", "-=", "2", ";", "}", "else", "{", "emit_insn_before", "(", "gen_nop_2_byte", "(", ")", ",", "insn", ")", ";", "hw_after", "-=", "1", ";", "}", "}", "}", "}", "</s>" ]
[ "Perform", "machine-dependent", "processing", "." ]
[ "s390", "0", "1", "1", "0", "0", "0", "3", "3", "2", "2", "1" ]
s3905
s390_reorg
s390
MPU
GCC
18,330
469
1
[]
[ "<s>", "unsigned", "int", "LC2200AsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "Op", ",", "unsigned", "Kind", ")", "{", "return", "MCTargetAsmParser", "::", "validateTargetOperandClass", "(", "Op", ",", "Kind", ")", ";", "}", "</s>" ]
[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]
[ "LC2200", "LC2200" ]
LC2200AsmParser
validateTargetOperandClass
LC2200
CPU
LLVM
18,331
25
1
[]
[ "<s>", "static", "unsigned", "int", "aarch64_parse_boolean_options", "(", "const", "char", "*", "option", ",", "const", "struct", "aarch64_flag_desc", "*", "flags", ",", "unsigned", "int", "initial_state", ",", "const", "char", "*", "option_name", ")", "{", "const", "char", "separator", "=", "'.'", ";", "const", "char", "*", "specs", "=", "option", ";", "const", "char", "*", "ntoken", "=", "option", ";", "unsigned", "int", "found_flags", "=", "initial_state", ";", "while", "(", "(", "ntoken", "=", "strchr", "(", "specs", ",", "separator", ")", ")", ")", "{", "size_t", "token_length", "=", "ntoken", "-", "specs", ";", "unsigned", "token_ops", "=", "aarch64_parse_one_option_token", "(", "specs", ",", "token_length", ",", "flags", ",", "option_name", ")", ";", "if", "(", "!", "token_ops", ")", "found_flags", "=", "0", ";", "found_flags", "|=", "token_ops", ";", "specs", "=", "++", "ntoken", ";", "}", "if", "(", "!", "(", "*", "specs", ")", ")", "{", "error", "(", "\"%s string ill-formed\\n\"", ",", "option_name", ")", ";", "return", "0", ";", "}", "size_t", "token_length", "=", "strlen", "(", "specs", ")", ";", "unsigned", "token_ops", "=", "aarch64_parse_one_option_token", "(", "specs", ",", "token_length", ",", "flags", ",", "option_name", ")", ";", "if", "(", "!", "token_ops", ")", "found_flags", "=", "0", ";", "found_flags", "|=", "token_ops", ";", "return", "found_flags", ";", "}", "</s>" ]
[ "Parse", "OPTION", "which", "is", "a", "comma-separated", "list", "of", "flags", "to", "enable", ".", "FLAGS", "gives", "the", "list", "of", "flags", "we", "understand", ",", "INITIAL_STATE", "gives", "any", "default", "state", "we", "inherit", "from", "the", "CPU", "tuning", "structures", ".", "OPTION_NAME", "gives", "the", "top-level", "option", "we", "are", "parsing", "in", "the", "-moverride", "string", ",", "for", "use", "in", "error", "messages", "." ]
[ "aarch64", "0", "\"%s string ill-formed\\n\"", "0", "0" ]
aarch64
aarch64_parse_boolean_options
aarch64
CPU
GCC
18,332
165
1
[]
[ "<s>", "void", "c4x_global_label", "(", "const", "char", "*", "name", ")", "{", "struct", "name_list", "*", "p", ",", "*", "last", ";", "p", "=", "global_head", ";", "while", "(", "p", ")", "{", "if", "(", "strcmp", "(", "p", "->", "name", ",", "name", ")", "==", "0", ")", "return", ";", "p", "=", "p", "->", "next", ";", "}", "p", "=", "(", "struct", "name_list", "*", ")", "xmalloc", "(", "sizeof", "*", "p", ")", ";", "p", "->", "next", "=", "global_head", ";", "p", "->", "name", "=", "name", ";", "global_head", "=", "p", ";", "last", "=", "NULL", ";", "p", "=", "extern_head", ";", "while", "(", "p", ")", "{", "if", "(", "strcmp", "(", "p", "->", "name", ",", "name", ")", "==", "0", ")", "{", "if", "(", "last", ")", "last", "->", "next", "=", "p", "->", "next", ";", "else", "extern_head", "=", "p", "->", "next", ";", "break", ";", "}", "last", "=", "p", ";", "p", "=", "p", "->", "next", ";", "}", "}", "</s>" ]
[ "Add", "NAME", "to", "list", "of", "global", "symbols", "and", "remove", "from", "external", "list", "if", "present", "on", "external", "list", "." ]
[ "c4x", "0", "0" ]
c4x1
c4x_global_label
c4x
DSP
GCC
18,333
139
1
[]
[ "<s>", "MachineInstr", "*", "Z80InstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "&", "MI", ",", "ArrayRef", "<", "unsigned", ">", "Ops", ",", "MachineBasicBlock", "::", "iterator", "InsertPt", ",", "MachineInstr", "&", "LoadMI", ",", "LiveIntervals", "*", "LIS", ")", "const", "{", "return", "nullptr", ";", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "}", "</s>" ]
[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]
[ "Z80", "Z80", "\"Unimplemented\"" ]
Z80InstrInfo2
foldMemoryOperandImpl
Z80
MPU
LLVM
18,334
44
1
[]
[ "<s>", "void", "setReg", "(", "unsigned", "Val", ")", "{", "Contents", ".", "RegNum", "=", "Val", ";", "}", "</s>" ]
[ "Assigns", "the", "associated", "register", "for", "this", "edge", "." ]
[ "PowerPC" ]
PPCCTRLoops2
setReg
PowerPC
CPU
LLVM
18,335
14
1
[]
[ "<s>", "static", "int", "ia64_first_cycle_multipass_dfa_lookahead_guard", "(", "rtx_insn", "*", "insn", ",", "int", "ready_index", ")", "{", "gcc_assert", "(", "insn", "&&", "INSN_P", "(", "insn", ")", ")", ";", "if", "(", "pending_data_specs", ">=", "16", "&&", "(", "TODO_SPEC", "(", "insn", ")", "&", "BEGIN_DATA", ")", ")", "return", "ready_index", "==", "0", "?", "-", "1", ":", "1", ";", "if", "(", "ready_index", "==", "0", ")", "return", "0", ";", "if", "(", "(", "!", "reload_completed", "||", "!", "safe_group_barrier_needed", "(", "insn", ")", ")", "&&", "(", "!", "mflag_sched_mem_insns_hard_limit", "||", "!", "is_load_p", "(", "insn", ")", "||", "mem_ops_in_group", "[", "current_cycle", "%", "4", "]", "<", "ia64_max_memory_insns", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]
[ "We", "are", "choosing", "insn", "from", "the", "ready", "queue", ".", "Return", "nonzero", "if", "INSN", "can", "be", "chosen", "." ]
[ "ia64", "16", "0", "1", "1", "0", "0", "4", "0", "1" ]
ia64
ia64_first_cycle_multipass_dfa_lookahead_guard
ia64
CPU
GCC
18,336
96
1
[]
[ "<s>", "bool", "SIFixSGPRCopies", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "PHI", ")", "{", "continue", ";", "}", "unsigned", "Reg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "inferRegClass", "(", "TRI", ",", "MRI", ",", "Reg", ")", ";", "if", "(", "RC", "==", "&", "AMDGPU", "::", "VSrc_32RegClass", ")", "{", "MRI", ".", "constrainRegClass", "(", "Reg", ",", "&", "AMDGPU", "::", "VReg_32RegClass", ")", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "R600", "SI", "0" ]
SIFixSGPRCopies7
runOnMachineFunction
R600
GPU
LLVM
18,337
180
1
[]
[ "<s>", "static", "rtx_insn", "*", "rs6000_emit_allocate_stack", "(", "HOST_WIDE_INT", "size", ",", "rtx", "copy_reg", ",", "int", "copy_off", ")", "{", "rtx_insn", "*", "insn", ";", "rtx", "stack_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ";", "rtx", "tmp_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ";", "rtx", "todec", "=", "gen_int_mode", "(", "-", "size", ",", "Pmode", ")", ";", "if", "(", "INTVAL", "(", "todec", ")", "!=", "-", "size", ")", "{", "warning", "(", "0", ",", "\"stack frame too large\"", ")", ";", "emit_insn", "(", "gen_trap", "(", ")", ")", ";", "return", "0", ";", "}", "if", "(", "crtl", "->", "limit_stack", ")", "{", "if", "(", "REG_P", "(", "stack_limit_rtx", ")", "&&", "REGNO", "(", "stack_limit_rtx", ")", ">", "1", "&&", "REGNO", "(", "stack_limit_rtx", ")", "<=", "31", ")", "{", "rtx_insn", "*", "insn", "=", "gen_add3_insn", "(", "tmp_reg", ",", "stack_limit_rtx", ",", "GEN_INT", "(", "size", ")", ")", ";", "gcc_assert", "(", "insn", ")", ";", "emit_insn", "(", "insn", ")", ";", "emit_insn", "(", "gen_cond_trap", "(", "LTU", ",", "stack_reg", ",", "tmp_reg", ",", "const0_rtx", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "stack_limit_rtx", ")", "==", "SYMBOL_REF", "&&", "TARGET_32BIT", "&&", "DEFAULT_ABI", "==", "ABI_V4", "&&", "!", "flag_pic", ")", "{", "rtx", "toload", "=", "gen_rtx_CONST", "(", "VOIDmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_limit_rtx", ",", "GEN_INT", "(", "size", ")", ")", ")", ";", "emit_insn", "(", "gen_elf_high", "(", "tmp_reg", ",", "toload", ")", ")", ";", "emit_insn", "(", "gen_elf_low", "(", "tmp_reg", ",", "tmp_reg", ",", "toload", ")", ")", ";", "emit_insn", "(", "gen_cond_trap", "(", "LTU", ",", "stack_reg", ",", "tmp_reg", ",", "const0_rtx", ")", ")", ";", "}", "else", "warning", "(", "0", ",", "\"stack limit expression is not supported\"", ")", ";", "}", "if", "(", "flag_stack_clash_protection", ")", "{", "if", "(", "size", "<", "get_stack_clash_protection_guard_size", "(", ")", ")", "dump_stack_clash_frame_info", "(", "NO_PROBE_SMALL_FRAME", ",", "true", ")", ";", "else", "{", "rtx_insn", "*", "insn", "=", "rs6000_emit_probe_stack_range_stack_clash", "(", "size", ",", "copy_reg", ")", ";", "if", "(", "copy_reg", "&&", "copy_off", ")", "emit_insn", "(", "gen_add3_insn", "(", "copy_reg", ",", "copy_reg", ",", "GEN_INT", "(", "copy_off", ")", ")", ")", ";", "return", "insn", ";", "}", "}", "if", "(", "copy_reg", ")", "{", "if", "(", "copy_off", "!=", "0", ")", "emit_insn", "(", "gen_add3_insn", "(", "copy_reg", ",", "stack_reg", ",", "GEN_INT", "(", "copy_off", ")", ")", ")", ";", "else", "emit_move_insn", "(", "copy_reg", ",", "stack_reg", ")", ";", "}", "insn", "=", "rs6000_emit_allocate_stack_1", "(", "size", ",", "stack_reg", ")", ";", "return", "insn", ";", "}", "</s>" ]
[ "Emit", "the", "correct", "code", "for", "allocating", "stack", "space", ",", "as", "insns", ".", "If", "COPY_R12", ",", "make", "sure", "a", "copy", "of", "the", "old", "frame", "is", "left", "in", "r12", ".", "The", "generated", "code", "may", "use", "hard", "register", "0", "as", "a", "temporary", "." ]
[ "rs6000", "0", "0", "\"stack frame too large\"", "0", "1", "31", "0", "\"stack limit expression is not supported\"", "0" ]
rs60007
rs6000_emit_allocate_stack
rs6000
CPU
GCC
18,338
342
1
[]
[ "<s>", "void", "BPFRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "unsigned", "FrameReg", "=", "getFrameRegister", "(", "MF", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "BPF", "::", "MOV_rr", ")", "{", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "unsigned", "reg", "=", "MI", ".", "getOperand", "(", "i", "-", "1", ")", ".", "getReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "++", "II", ",", "DL", ",", "TII", ".", "get", "(", "BPF", "::", "ADD_ri", ")", ",", "reg", ")", ".", "addReg", "(", "reg", ")", ".", "addImm", "(", "Offset", ")", ";", "return", ";", "}", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", "+", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "!", "isInt", "<", "32", ">", "(", "Offset", ")", ")", "llvm_unreachable", "(", "\"bug in frame offset\"", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "BPF", "::", "FI_ri", ")", "{", "unsigned", "reg", "=", "MI", ".", "getOperand", "(", "i", "-", "1", ")", ".", "getReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "++", "II", ",", "DL", ",", "TII", ".", "get", "(", "BPF", "::", "MOV_rr", ")", ",", "reg", ")", ".", "addReg", "(", "FrameReg", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", ".", "get", "(", "BPF", "::", "ADD_ri", ")", ",", "reg", ")", ".", "addReg", "(", "reg", ")", ".", "addImm", "(", "Offset", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "}", "else", "{", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "}", "</s>" ]
[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]
[ "BPF", "BPF", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "BPF::MOV_rr", "1", "BPF::ADD_ri", "1", "32", "\"bug in frame offset\"", "BPF::FI_ri", "1", "BPF::MOV_rr", "BPF::ADD_ri", "1" ]
BPFRegisterInfo1
eliminateFrameIndex
BPF
Virtual ISA
LLVM
18,339
406
1
[]
[ "<s>", "bool", "isScheduled", "(", "const", "SUnit", "*", "SU", ")", "const", "{", "assert", "(", "!", "SU", "->", "isBoundaryNode", "(", ")", ")", ";", "return", "NumPreds", "[", "SU", "->", "NodeNum", "]", "==", "std", "::", "numeric_limits", "<", "unsigned", ">", "::", "max", "(", ")", ";", "}", "</s>" ]
[ "True", "once", "scheduled", "." ]
[ "AMDGPU" ]
GCNMinRegStrategy
isScheduled
AMDGPU
GPU
LLVM
18,340
40
1
[]
[ "<s>", "static", "int", "msp430_memory_move_cost", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "reg_class_t", "rclass", "ATTRIBUTE_UNUSED", ",", "bool", "in", ")", "{", "int", "cost", ";", "const", "struct", "double_op_cost", "*", "cost_p", ";", "bool", "speed", "=", "(", "!", "optimize_size", "&&", "optimize", ">=", "2", ")", ";", "cost_p", "=", "(", "speed", "?", "&", "cycle_cost_double_op_mov", ":", "&", "size_cost_double_op", ")", ";", "if", "(", "in", ")", "cost", "=", "cost_p", "->", "ind2r", ";", "else", "cost", "=", "cost_p", "->", "r2m", ";", "return", "2", "*", "cost", ";", "}", "</s>" ]
[ "Return", "the", "cost", "of", "moving", "data", "between", "registers", "and", "memory", ".", "The", "returned", "cost", "must", "be", "relative", "to", "the", "default", "TARGET_REGISTER_MOVE_COST", "of", "2", ".", "IN", "is", "false", "if", "the", "value", "is", "to", "be", "written", "to", "memory", "." ]
[ "msp430", "2", "2" ]
msp430
msp430_memory_move_cost
msp430
MPU
GCC
18,341
72
1
[]
[ "<s>", "bool", "ARMAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "const", "uint16_t", "Thumb1_16bitNopEncoding", "=", "0x46c0", ";", "const", "uint16_t", "Thumb2_16bitNopEncoding", "=", "0xbf00", ";", "const", "uint32_t", "ARMv4_NopEncoding", "=", "0xe1a00000", ";", "const", "uint32_t", "ARMv6T2_NopEncoding", "=", "0xe320f000", ";", "if", "(", "isThumb", "(", ")", ")", "{", "const", "uint16_t", "nopEncoding", "=", "hasNOP", "(", ")", "?", "Thumb2_16bitNopEncoding", ":", "Thumb1_16bitNopEncoding", ";", "uint64_t", "NumNops", "=", "Count", "/", "2", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "NumNops", ";", "++", "i", ")", "support", "::", "endian", "::", "write", "(", "OS", ",", "nopEncoding", ",", "Endian", ")", ";", "if", "(", "Count", "&", "1", ")", "OS", "<<", "'\\0'", ";", "return", "true", ";", "}", "const", "uint32_t", "nopEncoding", "=", "hasNOP", "(", ")", "?", "ARMv6T2_NopEncoding", ":", "ARMv4_NopEncoding", ";", "uint64_t", "NumNops", "=", "Count", "/", "4", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "NumNops", ";", "++", "i", ")", "support", "::", "endian", "::", "write", "(", "OS", ",", "nopEncoding", ",", "Endian", ")", ";", "switch", "(", "Count", "%", "4", ")", "{", "default", ":", "break", ";", "case", "1", ":", "OS", "<<", "'\\0'", ";", "break", ";", "case", "2", ":", "OS", ".", "write", "(", "\"\\0\\0\"", ",", "2", ")", ";", "break", ";", "case", "3", ":", "OS", ".", "write", "(", "\"\\0\\0\\xa0\"", ",", "3", ")", ";", "break", ";", "}", "return", "true", ";", "}", "</s>" ]
[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]
[ "ARM", "ARM", "0x46c0", "0xbf00", "ARM", "0xe1a00000", "ARM", "0xe320f000", "2", "0", "support::endian", "1", "ARM", "ARM", "4", "0", "support::endian", "4", "1", "2", "\"\\0\\0\"", "2", "3", "\"\\0\\0\\xa0\"", "3" ]
ARMAsmBackend (2)2
writeNopData
ARM
CPU
LLVM
18,342
204
1
[]
[ "<s>", "static", "rtx_insn", "*", "nvptx_discover_pre", "(", "basic_block", "block", ",", "int", "expected", ")", "{", "gcc_assert", "(", "block", "->", "preds", "->", "length", "(", ")", "==", "1", ")", ";", "basic_block", "pre_block", "=", "(", "*", "block", "->", "preds", ")", "[", "0", "]", "->", "src", ";", "rtx_insn", "*", "pre_insn", ";", "for", "(", "pre_insn", "=", "BB_END", "(", "pre_block", ")", ";", "!", "INSN_P", "(", "pre_insn", ")", ";", "pre_insn", "=", "PREV_INSN", "(", "pre_insn", ")", ")", "gcc_assert", "(", "pre_insn", "!=", "BB_HEAD", "(", "pre_block", ")", ")", ";", "gcc_assert", "(", "recog_memoized", "(", "pre_insn", ")", "==", "expected", ")", ";", "return", "pre_insn", ";", "}", "</s>" ]
[ "BLOCK", "is", "a", "basic", "block", "containing", "a", "head", "or", "tail", "instruction", ".", "Locate", "the", "associated", "prehead", "or", "pretail", "instruction", ",", "which", "must", "be", "in", "the", "single", "predecessor", "block", "." ]
[ "nvptx", "1", "0" ]
nvptx
nvptx_discover_pre
nvptx
GPU
GCC
18,343
90
1
[]
[ "<s>", "const", "uint32_t", "*", "Z80RegisterInfo", "::", "getNoPreservedMask", "(", ")", "const", "{", "return", "CSR_NoRegs_RegMask", ";", "}", "</s>" ]
[ "Return", "a", "register", "mask", "that", "clobbers", "everything", "." ]
[ "Z80", "Z80" ]
Z80RegisterInfo2
getNoPreservedMask
Z80
MPU
LLVM
18,344
14
1
[]
[ "<s>", "void", "SIInstrInfo", "::", "moveToVALU", "(", "MachineInstr", "&", "TopInst", ")", "const", "{", "SmallVector", "<", "MachineInstr", "*", ",", "128", ">", "Worklist", ";", "Worklist", ".", "push_back", "(", "&", "TopInst", ")", ";", "while", "(", "!", "Worklist", ".", "empty", "(", ")", ")", "{", "MachineInstr", "*", "Inst", "=", "Worklist", ".", "pop_back_val", "(", ")", ";", "unsigned", "NewOpcode", "=", "getVALUOp", "(", "*", "Inst", ")", ";", "if", "(", "NewOpcode", "==", "AMDGPU", "::", "INSTRUCTION_LIST_END", ")", "continue", ";", "MachineRegisterInfo", "&", "MRI", "=", "Inst", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "NewDesc", "=", "get", "(", "NewOpcode", ")", ";", "Inst", "->", "setDesc", "(", "NewDesc", ")", ";", "for", "(", "unsigned", "i", "=", "Inst", "->", "getNumOperands", "(", ")", "-", "1", ";", "i", ">", "0", ";", "--", "i", ")", "{", "MachineOperand", "&", "Op", "=", "Inst", "->", "getOperand", "(", "i", ")", ";", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "SCC", ")", "Inst", "->", "RemoveOperand", "(", "i", ")", ";", "}", "if", "(", "NewDesc", ".", "ImplicitUses", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "NewDesc", ".", "ImplicitUses", "[", "i", "]", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "NewDesc", ".", "ImplicitUses", "[", "i", "]", ";", "Inst", "->", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "Reg", ",", "false", ",", "true", ")", ")", ";", "}", "}", "if", "(", "NewDesc", ".", "ImplicitDefs", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "NewDesc", ".", "ImplicitDefs", "[", "i", "]", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "NewDesc", ".", "ImplicitDefs", "[", "i", "]", ";", "Inst", "->", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "Reg", ",", "true", ",", "true", ")", ")", ";", "}", "}", "legalizeOperands", "(", "Inst", ")", ";", "const", "TargetRegisterClass", "*", "NewDstRC", "=", "getOpRegClass", "(", "*", "Inst", ",", "0", ")", ";", "switch", "(", "Inst", "->", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "COPY", ":", "case", "AMDGPU", "::", "PHI", ":", "case", "AMDGPU", "::", "REG_SEQUENCE", ":", "if", "(", "RI", ".", "hasVGPRs", "(", "NewDstRC", ")", ")", "continue", ";", "NewDstRC", "=", "RI", ".", "getEquivalentVGPRClass", "(", "NewDstRC", ")", ";", "if", "(", "!", "NewDstRC", ")", "continue", ";", "break", ";", "default", ":", "break", ";", "}", "unsigned", "DstReg", "=", "Inst", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "NewDstReg", "=", "MRI", ".", "createVirtualRegister", "(", "NewDstRC", ")", ";", "MRI", ".", "replaceRegWith", "(", "DstReg", ",", "NewDstReg", ")", ";", "for", "(", "MachineRegisterInfo", "::", "use_iterator", "I", "=", "MRI", ".", "use_begin", "(", "NewDstReg", ")", ",", "E", "=", "MRI", ".", "use_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "&", "UseMI", "=", "*", "I", "->", "getParent", "(", ")", ";", "if", "(", "!", "canReadVGPR", "(", "UseMI", ",", "I", ".", "getOperandNo", "(", ")", ")", ")", "{", "Worklist", ".", "push_back", "(", "&", "UseMI", ")", ";", "}", "}", "}", "}", "</s>" ]
[ "Replace", "the", "instructions", "opcode", "with", "the", "equivalent", "VALU", "opcode", "." ]
[ "R600", "SI", "128", "1", "0", "0", "0", "0", "0" ]
SIInstrInfo43
moveToVALU
R600
GPU
LLVM
18,345
443
1
[]
[ "<s>", "bool", "F2003fTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC_F2003f", ")", ";", "}", "</s>" ]
[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]
[ "F2003f", "F2003f", "ISD::OutputArg", "16", "F2003f" ]
F2003fISelLowering
CanLowerReturn
F2003f
CPU
LLVM
18,346
66
1
[]
[ "<s>", "RISCVSubtarget", "&", "RISCVSubtarget", "::", "initializeSubtargetDependencies", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "TuneCPU", ",", "StringRef", "FS", ",", "StringRef", "ABIName", ")", "{", "bool", "Is64Bit", "=", "TT", ".", "isArch64Bit", "(", ")", ";", "std", "::", "string", "CPUName", "=", "std", "::", "string", "(", "CPU", ")", ";", "std", "::", "string", "TuneCPUName", "=", "std", "::", "string", "(", "TuneCPU", ")", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "Is64Bit", "?", "\"generic-rv64\"", ":", "\"generic-rv32\"", ";", "if", "(", "TuneCPUName", ".", "empty", "(", ")", ")", "TuneCPUName", "=", "CPUName", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "TuneCPUName", ",", "FS", ")", ";", "if", "(", "Is64Bit", ")", "{", "XLenVT", "=", "MVT", "::", "i64", ";", "XLen", "=", "64", ";", "}", "TargetABI", "=", "RISCVABI", "::", "computeTargetABI", "(", "TT", ",", "getFeatureBits", "(", ")", ",", "ABIName", ")", ";", "RISCVFeatures", "::", "validate", "(", "TT", ",", "getFeatureBits", "(", ")", ")", ";", "if", "(", "TT", ".", "getVendor", "(", ")", "==", "Triple", "::", "HERO", ")", "{", "IsPULP", "=", "true", ";", "}", "return", "*", "this", ";", "}", "</s>" ]
[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]
[ "RI5CY", "RISCV", "RISCV", "\"generic-rv64\"", "\"generic-rv32\"", "MVT::i64", "64", "RISCVABI::computeTargetABI", "RISCVFeatures::validate" ]
RISCVSubtarget
initializeSubtargetDependencies
RI5CY
CPU
LLVM
18,347
159
1
[]
[ "<s>", "TargetPassConfig", "*", "RISCVTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "RISCVPassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]
[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]
[ "RISCV", "RISCV", "RISCV" ]
RISCVTargetMachine (2)1
createPassConfig
RISCV
CPU
LLVM
18,348
21
1
[]
[ "<s>", "bool", "VLIWResourceModel", "::", "reserveResources", "(", "SUnit", "*", "SU", ")", "{", "bool", "startNewCycle", "=", "false", ";", "if", "(", "!", "SU", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "return", "false", ";", "}", "if", "(", "!", "isResourceAvailable", "(", "SU", ")", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "startNewCycle", "=", "true", ";", "}", "switch", "(", "SU", "->", "getInstr", "(", ")", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "ResourcesModel", "->", "reserveResources", "(", "SU", "->", "getInstr", "(", ")", ")", ";", "break", ";", "case", "TargetOpcode", "::", "EXTRACT_SUBREG", ":", "case", "TargetOpcode", "::", "INSERT_SUBREG", ":", "case", "TargetOpcode", "::", "SUBREG_TO_REG", ":", "case", "TargetOpcode", "::", "REG_SEQUENCE", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "CFI_INSTRUCTION", ":", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "COPY", ":", "case", "TargetOpcode", "::", "INLINEASM", ":", "break", ";", "}", "Packet", ".", "push_back", "(", "SU", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Packet[\"", "<<", "TotalPackets", "<<", "\"]:\\n\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Packet", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\t[\"", "<<", "i", "<<", "\"] SU(\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "Packet", "[", "i", "]", "->", "NodeNum", "<<", "\")\\t\"", ")", ";", "DEBUG", "(", "Packet", "[", "i", "]", "->", "getInstr", "(", ")", "->", "dump", "(", ")", ")", ";", "}", "if", "(", "Packet", ".", "size", "(", ")", ">=", "SchedModel", "->", "getIssueWidth", "(", ")", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "startNewCycle", "=", "true", ";", "}", "return", "startNewCycle", ";", "}", "</s>" ]
[ "Keep", "track", "of", "available", "resources", "." ]
[ "Hexagon", "\"Packet[\"", "\"]:\\n\"", "0", "\"\\t[\"", "\"] SU(\"", "\")\\t\"" ]
HexagonMachineScheduler (2)2
reserveResources
Hexagon
DSP
LLVM
18,349
278
1
[]
[ "<s>", "bool", "X86InstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "MachineInstrBuilder", "MIB", "(", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "MOV32r0", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "XOR32rr", ")", ")", ";", "case", "X86", "::", "SETB_C8r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB8rr", ")", ")", ";", "case", "X86", "::", "SETB_C16r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB16rr", ")", ")", ";", "case", "X86", "::", "SETB_C32r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB32rr", ")", ")", ";", "case", "X86", "::", "SETB_C64r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB64rr", ")", ")", ";", "case", "X86", "::", "V_SET0", ":", "case", "X86", "::", "FsFLD0SS", ":", "case", "X86", "::", "FsFLD0SD", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "HasAVX", "?", "X86", "::", "VXORPSrr", ":", "X86", "::", "XORPSrr", ")", ")", ";", "case", "X86", "::", "AVX_SET0", ":", "assert", "(", "HasAVX", "&&", "\"AVX not supported\"", ")", ";", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VXORPSYrr", ")", ")", ";", "case", "X86", "::", "AVX512_512_SET0", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VPXORDZrr", ")", ")", ";", "case", "X86", "::", "V_SETALLONES", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "HasAVX", "?", "X86", "::", "VPCMPEQDrr", ":", "X86", "::", "PCMPEQDrr", ")", ")", ";", "case", "X86", "::", "AVX2_SETALLONES", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VPCMPEQDYrr", ")", ")", ";", "case", "X86", "::", "TEST8ri_NOREX", ":", "MI", "->", "setDesc", "(", "get", "(", "X86", "::", "TEST8ri", ")", ")", ";", "return", "true", ";", "case", "X86", "::", "KSET0B", ":", "case", "X86", "::", "KSET0W", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "KXORWrr", ")", ")", ";", "case", "X86", "::", "KSET1B", ":", "case", "X86", "::", "KSET1W", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "KXNORWrr", ")", ")", ";", "case", "TargetOpcode", "::", "LOAD_STACK_GUARD", ":", "expandLoadStackGuard", "(", "MIB", ",", "*", "this", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]
[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]
[ "X86", "X86", "X86::MOV32r0", "X86::XOR32rr", "X86::SETB_C8r", "X86::SBB8rr", "X86::SETB_C16r", "X86::SBB16rr", "X86::SETB_C32r", "X86::SBB32rr", "X86::SETB_C64r", "X86::SBB64rr", "X86::V_SET0", "X86::FsFLD0SS", "X86::FsFLD0SD", "X86::VXORPSrr", "X86::XORPSrr", "X86::AVX_SET0", "\"AVX not supported\"", "X86::VXORPSYrr", "X86::AVX512_512_SET0", "X86::VPXORDZrr", "X86::V_SETALLONES", "X86::VPCMPEQDrr", "X86::PCMPEQDrr", "X86::AVX2_SETALLONES", "X86::VPCMPEQDYrr", "X86::TEST8ri_NOREX", "X86::TEST8ri", "X86::KSET0B", "X86::KSET0W", "X86::KXORWrr", "X86::KSET1B", "X86::KSET1W", "X86::KXNORWrr" ]
X86InstrInfo109
expandPostRAPseudo
X86
CPU
LLVM
18,350
343
1
[]
[ "<s>", "void", "print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "int", "basereg", "=", "31", ";", "HOST_WIDE_INT", "offset", "=", "0", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "AND", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "{", "offset", "=", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", ")", "{", "const", "char", "*", "reloc16", ",", "*", "reloclo", ";", "rtx", "op1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "op1", ",", "0", ")", ")", "==", "UNSPEC", ")", "{", "op1", "=", "XEXP", "(", "op1", ",", "0", ")", ";", "switch", "(", "XINT", "(", "op1", ",", "1", ")", ")", "{", "case", "UNSPEC_DTPREL", ":", "reloc16", "=", "NULL", ";", "reloclo", "=", "(", "alpha_tls_size", "==", "16", "?", "\"dtprel\"", ":", "\"dtprello\"", ")", ";", "break", ";", "case", "UNSPEC_TPREL", ":", "reloc16", "=", "NULL", ";", "reloclo", "=", "(", "alpha_tls_size", "==", "16", "?", "\"tprel\"", ":", "\"tprello\"", ")", ";", "break", ";", "default", ":", "output_operand_lossage", "(", "\"unknown relocation unspec\"", ")", ";", "return", ";", "}", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "op1", ",", "0", ",", "0", ")", ")", ";", "}", "else", "{", "reloc16", "=", "\"gprel\"", ";", "reloclo", "=", "\"gprellow\"", ";", "output_addr_const", "(", "file", ",", "op1", ")", ";", "}", "if", "(", "offset", ")", "fprintf", "(", "file", ",", "\"+\"", "HOST_WIDE_INT_PRINT_DEC", ",", "offset", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "basereg", "=", "REGNO", "(", "addr", ")", ";", "break", ";", "case", "SUBREG", ":", "basereg", "=", "subreg_regno", "(", "addr", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "fprintf", "(", "file", ",", "\"($%d)\\t\\t!%s\"", ",", "basereg", ",", "(", "basereg", "==", "29", "?", "reloc16", ":", "reloclo", ")", ")", ";", "return", ";", "}", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "basereg", "=", "REGNO", "(", "addr", ")", ";", "break", ";", "case", "SUBREG", ":", "basereg", "=", "subreg_regno", "(", "addr", ")", ";", "break", ";", "case", "CONST_INT", ":", "offset", "=", "INTVAL", "(", "addr", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "gcc_assert", "(", "TARGET_ABI_OPEN_VMS", "||", "this_is_asm_operands", ")", ";", "fprintf", "(", "file", ",", "\"%s\"", ",", "XSTR", "(", "addr", ",", "0", ")", ")", ";", "return", ";", "case", "CONST", ":", "gcc_assert", "(", "TARGET_ABI_OPEN_VMS", "||", "this_is_asm_operands", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ";", "fprintf", "(", "file", ",", "\"%s+\"", "HOST_WIDE_INT_PRINT_DEC", ",", "XSTR", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ",", "0", ")", ",", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "1", ")", ")", ")", ";", "return", ";", "default", ":", "output_operand_lossage", "(", "\"invalid operand address\"", ")", ";", "return", ";", "}", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", "\"($%d)\"", ",", "offset", ",", "basereg", ")", ";", "}", "</s>" ]
[ "Print", "the", "operand", "address", "represented", "by", "the", "rtx", "addr" ]
[ "alpha", "31", "0", "0", "1", "1", "0", "1", "0", "0", "1", "16", "\"dtprel\"", "\"dtprello\"", "16", "\"tprel\"", "\"tprello\"", "\"unknown relocation unspec\"", "0", "0", "\"gprel\"", "\"gprellow\"", "\"+\"", "0", "\"($%d)\\t\\t!%s\"", "29", "\"%s\"", "0", "0", "0", "0", "\"%s+\"", "0", "0", "0", "0", "1", "\"invalid operand address\"", "\"($%d)\"" ]
alpha4
print_operand_address
alpha
MPU
GCC
18,351
496
1
[]
[ "<s>", "static", "void", "loongarch_emit_int_order_test", "(", "enum", "rtx_code", "code", ",", "bool", "*", "invert_ptr", ",", "rtx", "target", ",", "rtx", "cmp0", ",", "rtx", "cmp1", ")", "{", "machine_mode", "mode", ";", "mode", "=", "GET_MODE", "(", "cmp0", ")", ";", "if", "(", "loongarch_canonicalize_int_order_test", "(", "&", "code", ",", "&", "cmp1", ",", "mode", ")", ")", "loongarch_emit_binary", "(", "code", ",", "target", ",", "cmp0", ",", "cmp1", ")", ";", "else", "{", "enum", "rtx_code", "inv_code", "=", "reverse_condition", "(", "code", ")", ";", "if", "(", "!", "loongarch_canonicalize_int_order_test", "(", "&", "inv_code", ",", "&", "cmp1", ",", "mode", ")", ")", "{", "cmp1", "=", "force_reg", "(", "mode", ",", "cmp1", ")", ";", "loongarch_emit_int_order_test", "(", "code", ",", "invert_ptr", ",", "target", ",", "cmp0", ",", "cmp1", ")", ";", "}", "else", "if", "(", "invert_ptr", "==", "0", ")", "{", "rtx", "inv_target", ";", "inv_target", "=", "loongarch_force_binary", "(", "GET_MODE", "(", "target", ")", ",", "inv_code", ",", "cmp0", ",", "cmp1", ")", ";", "loongarch_emit_binary", "(", "XOR", ",", "target", ",", "inv_target", ",", "const1_rtx", ")", ";", "}", "else", "{", "*", "invert_ptr", "=", "!", "*", "invert_ptr", ";", "loongarch_emit_binary", "(", "inv_code", ",", "target", ",", "cmp0", ",", "cmp1", ")", ";", "}", "}", "}", "</s>" ]
[ "Compare", "CMP0", "and", "CMP1", "using", "ordering", "test", "CODE", "and", "store", "the", "result", "in", "TARGET", ".", "CMP0", "and", "TARGET", "are", "register_operands", ".", "If", "INVERT_PTR", "is", "nonnull", ",", "it", "'s", "OK", "to", "set", "TARGET", "to", "the", "inverse", "of", "the", "result", "and", "flip", "*", "INVERT_PTR", "instead", "." ]
[ "loongarch", "0" ]
loongarch
loongarch_emit_int_order_test
loongarch
CPU
GCC
18,352
167
1
[]
[ "<s>", "void", "HexagonTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "isHvxOperation", "(", "N", ",", "DAG", ")", ")", "{", "ReplaceHvxNodeResults", "(", "N", ",", "Results", ",", "DAG", ")", ";", "if", "(", "!", "Results", ".", "empty", "(", ")", ")", "return", ";", "}", "const", "SDLoc", "&", "dl", "(", "N", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SHL", ":", "return", ";", "case", "ISD", "::", "BITCAST", ":", "if", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i8", ")", "{", "SDValue", "P", "=", "getInstr", "(", "Hexagon", "::", "C2_tfrpr", ",", "dl", ",", "MVT", "::", "i32", ",", "N", "->", "getOperand", "(", "0", ")", ",", "DAG", ")", ";", "SDValue", "T", "=", "DAG", ".", "getAnyExtOrTrunc", "(", "P", ",", "dl", ",", "MVT", "::", "i8", ")", ";", "Results", ".", "push_back", "(", "T", ")", ";", "}", "break", ";", "}", "}", "</s>" ]
[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]
[ "Hexagon", "Hexagon", "ISD::SRL", "ISD::SRA", "ISD::SHL", "ISD::BITCAST", "0", "MVT::i8", "Hexagon::C2_tfrpr", "MVT::i32", "0", "MVT::i8" ]
HexagonISelLowering9
ReplaceNodeResults
Hexagon
DSP
LLVM
18,353
159
1
[]
[ "<s>", "bool", "SystemZMCAsmBackend", "::", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "{", "return", "getRelaxedOpcode", "(", "Inst", ".", "getOpcode", "(", ")", ")", "!=", "0", ";", "}", "</s>" ]
[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]
[ "SystemZ", "SystemZ", "0" ]
SystemZMCAsmBackend28
mayNeedRelaxation
SystemZ
CPU
LLVM
18,354
25
1
[]
[ "<s>", "int", "m32c_legitimate_address_p", "(", "enum", "machine_mode", "mode", ",", "rtx", "x", ",", "int", "strict", ")", "{", "int", "mode_adjust", ";", "if", "(", "CONSTANT_P", "(", "x", ")", ")", "return", "1", ";", "mode_adjust", "=", "GET_MODE_SIZE", "(", "mode", ")", "-", "1", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PRE_DEC", "||", "GET_CODE", "(", "x", ")", "==", "POST_INC", "||", "GET_CODE", "(", "x", ")", "==", "PRE_MODIFY", ")", "{", "return", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "SP_REGNO", ")", ";", "}", "if", "(", "TARGET_A24", "&&", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "!=", "PLUS", ")", "{", "fprintf", "(", "stderr", ",", "\"double indirect\\n\"", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "encode_pattern", "(", "x", ")", ";", "if", "(", "RTX_IS", "(", "\"r\"", ")", ")", "{", "switch", "(", "REGNO", "(", "patternr", "[", "0", "]", ")", ")", "{", "case", "A0_REGNO", ":", "case", "A1_REGNO", ":", "case", "SB_REGNO", ":", "case", "FB_REGNO", ":", "case", "SP_REGNO", ":", "return", "1", ";", "default", ":", "if", "(", "IS_PSEUDO", "(", "patternr", "[", "0", "]", ",", "strict", ")", ")", "return", "1", ";", "return", "0", ";", "}", "}", "if", "(", "RTX_IS", "(", "\"+ri\"", ")", ")", "{", "int", "rn", "=", "REGNO", "(", "patternr", "[", "1", "]", ")", ";", "HOST_WIDE_INT", "offs", "=", "INTVAL", "(", "patternr", "[", "2", "]", ")", ";", "switch", "(", "rn", ")", "{", "case", "A0_REGNO", ":", "case", "A1_REGNO", ":", "case", "SB_REGNO", ":", "if", "(", "TARGET_A16", ")", "return", "(", "offs", ">=", "-", "65536", "&&", "offs", "<=", "65535", "-", "mode_adjust", ")", ";", "if", "(", "rn", "==", "SB_REGNO", ")", "return", "(", "offs", ">=", "0", "&&", "offs", "<=", "65535", "-", "mode_adjust", ")", ";", "return", "(", "offs", ">=", "-", "16777216", "&&", "offs", "<=", "16777215", ")", ";", "case", "FB_REGNO", ":", "if", "(", "TARGET_A16", ")", "return", "(", "offs", ">=", "-", "128", "&&", "offs", "<=", "127", "-", "mode_adjust", ")", ";", "return", "(", "offs", ">=", "-", "65536", "&&", "offs", "<=", "65535", "-", "mode_adjust", ")", ";", "case", "SP_REGNO", ":", "return", "(", "offs", ">=", "-", "128", "&&", "offs", "<=", "127", "-", "mode_adjust", ")", ";", "default", ":", "if", "(", "IS_PSEUDO", "(", "patternr", "[", "1", "]", ",", "strict", ")", ")", "return", "1", ";", "return", "0", ";", "}", "}", "if", "(", "RTX_IS", "(", "\"+rs\"", ")", "||", "RTX_IS", "(", "\"+r+si\"", ")", ")", "{", "rtx", "reg", "=", "patternr", "[", "1", "]", ";", "switch", "(", "REGNO", "(", "reg", ")", ")", "{", "case", "A0_REGNO", ":", "case", "A1_REGNO", ":", "return", "1", ";", "default", ":", "if", "(", "IS_PSEUDO", "(", "reg", ",", "strict", ")", ")", "return", "1", ";", "return", "0", ";", "}", "}", "return", "0", ";", "}", "</s>" ]
[ "Used", "by", "GO_IF_LEGITIMATE_ADDRESS", ".", "The", "r8c/m32c", "family", "supports", "a", "wide", "range", "of", "non-orthogonal", "addressing", "modes", ",", "including", "the", "ability", "to", "double-indirect", "on", "*", "some", "*", "of", "them", ".", "Not", "all", "insns", "support", "all", "modes", ",", "either", ",", "but", "we", "rely", "on", "predicates", "and", "constraints", "to", "deal", "with", "that", "." ]
[ "m32c", "1", "1", "0", "0", "0", "\"double indirect\\n\"", "0", "\"r\"", "0", "1", "0", "1", "0", "\"+ri\"", "1", "2", "65536", "65535", "0", "65535", "16777216", "16777215", "128", "127", "65536", "65535", "128", "127", "1", "1", "0", "\"+rs\"", "\"+r+si\"", "1", "1", "1", "0", "0" ]
m32c2
m32c_legitimate_address_p
m32c
MPU
GCC
18,355
421
1
[]
[ "<s>", "bool", "ARMAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "printAddrMode2Operand", "(", "MI", ",", "OpNum", ")", ";", "return", "false", ";", "}", "</s>" ]
[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]
[ "ARM", "ARM", "0" ]
ARMAsmPrinter20
PrintAsmMemoryOperand
ARM
CPU
LLVM
18,356
45
1
[]
[ "<s>", "void", "MipsTargetMachine", "::", "resetSubtarget", "(", "MachineFunction", "*", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"resetSubtarget\\n\"", ")", ";", "AttributeSet", "FnAttrs", "=", "MF", "->", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ";", "bool", "Mips16Attr", "=", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "\"mips16\"", ")", ";", "bool", "NoMips16Attr", "=", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "\"nomips16\"", ")", ";", "assert", "(", "!", "(", "Mips16Attr", "&&", "NoMips16Attr", ")", "&&", "\"mips16 and nomips16 specified on the same function\"", ")", ";", "if", "(", "Mips16Attr", ")", "Subtarget", "=", "&", "Mips16Subtarget", ";", "else", "if", "(", "NoMips16Attr", ")", "Subtarget", "=", "&", "NoMips16Subtarget", ";", "else", "Subtarget", "=", "&", "DefaultSubtarget", ";", "MF", "->", "setSubtarget", "(", "Subtarget", ")", ";", "return", ";", "}", "</s>" ]
[ "Reset", "the", "subtarget", "for", "the", "Mips", "target", "." ]
[ "Mips", "Mips", "\"resetSubtarget\\n\"", "Mips", "\"mips16\"", "Mips", "\"nomips16\"", "Mips", "Mips", "\"mips16 and nomips16 specified on the same function\"", "Mips", "Mips", "Mips", "Mips" ]
MipsTargetMachine79
resetSubtarget
Mips
CPU
LLVM
18,357
107
1
[]
[ "<s>", "SDValue", "BPFTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "report_fatal_error", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "break", ";", "}", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "getHasAlu32", "(", ")", "?", "CC_BPF32", ":", "CC_BPF64", ")", ";", "for", "(", "auto", "&", "VA", ":", "ArgLocs", ")", "{", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "MVT", "::", "SimpleValueType", "SimpleTy", "=", "RegVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ";", "switch", "(", "SimpleTy", ")", "{", "default", ":", "{", "errs", "(", ")", "<<", "\"LowerFormalArguments Unhandled argument type: \"", "<<", "RegVT", ".", "getEVTString", "(", ")", "<<", "'\\n'", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "i64", ":", "Register", "VReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "SimpleTy", "==", "MVT", "::", "i64", "?", "&", "BPF", "::", "GPRRegClass", ":", "&", "BPF", "::", "GPR32RegClass", ")", ";", "RegInfo", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "SDValue", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VReg", ",", "RegVT", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "DL", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "DL", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "ArgValue", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "break", ";", "}", "}", "else", "{", "fail", "(", "DL", ",", "DAG", ",", "\"defined with too many args\"", ")", ";", "InVals", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "}", "if", "(", "IsVarArg", "||", "MF", ".", "getFunction", "(", ")", ".", "hasStructRetAttr", "(", ")", ")", "{", "fail", "(", "DL", ",", "DAG", ",", "\"functions with VarArgs or StructRet are not supported\"", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]
[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]
[ "BPF", "BPF", "ISD::InputArg", "\"Unsupported calling convention\"", "16", "BPF", "BPF", "MVT::SimpleValueType", "\"LowerFormalArguments Unhandled argument type: \"", "0", "MVT::i32", "MVT::i64", "MVT::i64", "BPF::GPRRegClass", "BPF::GPR32RegClass", "ISD::AssertSext", "ISD::AssertZext", "ISD::TRUNCATE", "\"defined with too many args\"", "0", "\"functions with VarArgs or StructRet are not supported\"" ]
BPFISelLowering1
LowerFormalArguments
BPF
Virtual ISA
LLVM
18,358
449
1
[]
[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getJumpOffset16OpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getJumpOffset16OpValue expects only expressions or an immediate\"", ")", ";", "return", "0", ";", "}", "</s>" ]
[ "getJumpOffset16OpValue", "-", "Return", "binary", "encoding", "of", "the", "jump", "target", "operand", "." ]
[ "Mips", "Mips", "\"getJumpOffset16OpValue expects only expressions or an immediate\"", "0" ]
MipsMCCodeEmitter (2)
getJumpOffset16OpValue
Mips
CPU
LLVM
18,359
69
1
[]
[ "<s>", "static", "void", "*", "rs6000_init_cost", "(", "struct", "loop", "*", "loop_info", ")", "{", "rs6000_cost_data", "*", "data", "=", "XNEW", "(", "struct", "_rs6000_cost_data", ")", ";", "data", "->", "loop_info", "=", "loop_info", ";", "data", "->", "cost", "[", "vect_prologue", "]", "=", "0", ";", "data", "->", "cost", "[", "vect_body", "]", "=", "0", ";", "data", "->", "cost", "[", "vect_epilogue", "]", "=", "0", ";", "rs6000_vect_nonmem", "=", "false", ";", "return", "data", ";", "}", "</s>" ]
[ "Implement", "targetm.vectorize.init_cost", "." ]
[ "powerpcspe", "0", "0", "0" ]
powerpcspe
rs6000_init_cost
powerpcspe
CPU
GCC
18,360
62
1
[]
[ "<s>", "Register", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ",", "ISD", "::", "ArgFlagsTy", "Flags", ")", "override", "{", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "Size", ",", "Offset", ",", "true", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "FI", ")", ";", "auto", "AddrReg", "=", "MIRBuilder", ".", "buildFrameIndex", "(", "LLT", "::", "pointer", "(", "0", ",", "16", ")", ",", "FI", ")", ";", "return", "AddrReg", ".", "getReg", "(", "0", ")", ";", "}", "</s>" ]
[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]
[ "MOS", "ISD::ArgFlagsTy", "0", "16", "0" ]
MOSCallLowering
getStackAddress
MOS
MPU
LLVM
18,361
91
1
[]
[ "<s>", "void", "PatmosPostRASchedStrategy", "::", "scheduleTree", "(", "unsigned", "SubtreeID", ")", "{", "ReadyQ", ".", "scheduledTree", "(", "SubtreeID", ")", ";", "}", "</s>" ]
[ "Scheduler", "callback", "to", "update", "SubtreeConnectLevels", "when", "a", "tree", "is", "initially", "scheduled", "." ]
[ "Patmos", "Patmos" ]
PatmosSchedStrategy
scheduleTree
Patmos
VLIW
LLVM
18,362
17
1
[]
[ "<s>", "int", "sh_media_register_for_return", "(", "void", ")", "{", "int", "regno", ";", "int", "tr0_used", ";", "if", "(", "!", "current_function_is_leaf", ")", "return", "-", "1", ";", "if", "(", "lookup_attribute", "(", "\"interrupt_handler\"", ",", "DECL_ATTRIBUTES", "(", "current_function_decl", ")", ")", ")", "return", "-", "1", ";", "if", "(", "sh_cfun_interrupt_handler_p", "(", ")", ")", "return", "-", "1", ";", "tr0_used", "=", "flag_pic", "&&", "regs_ever_live", "[", "PIC_OFFSET_TABLE_REGNUM", "]", ";", "for", "(", "regno", "=", "FIRST_TARGET_REG", "+", "tr0_used", ";", "regno", "<=", "LAST_TARGET_REG", ";", "regno", "++", ")", "if", "(", "call_really_used_regs", "[", "regno", "]", "&&", "!", "regs_ever_live", "[", "regno", "]", ")", "return", "regno", ";", "return", "-", "1", ";", "}", "</s>" ]
[ "Choose", "a", "call-clobbered", "target-branch", "register", "that", "remains", "unchanged", "along", "the", "whole", "function", ".", "We", "set", "it", "up", "as", "the", "return", "value", "in", "the", "prologue", "." ]
[ "sh", "1", "\"interrupt_handler\"", "1", "1", "1" ]
sh3
sh_media_register_for_return
sh
CPU
GCC
18,363
92
1
[]
[ "<s>", "static", "bool", "h8300_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "return", "regno", "==", "MAC_REG", "?", "mode", "==", "SImode", ":", "1", ";", "}", "</s>" ]
[ "Worker", "function", "for", "HARD_REGNO_MODE_OK", "." ]
[ "h8300", "1" ]
h8300
h8300_hard_regno_mode_ok
h8300
MPU
GCC
18,364
24
1
[]
[ "<s>", "bool", "XtensaAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "llvm_unreachable", "(", "\"XXX:\"", ")", ";", "}", "</s>" ]
[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]
[ "Xtensa", "Xtensa", "\"XXX:\"" ]
XtensaAsmPrinter
PrintAsmOperand
Xtensa
MPU
LLVM
18,365
31
1
[]
[ "<s>", "static", "unsigned", "findDeadCallerSavedReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "const", "X86RegisterInfo", "*", "TRI", ",", "bool", "Is64Bit", ")", "{", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "if", "(", "!", "F", "||", "MF", "->", "callsEHReturn", "(", ")", ")", "return", "0", ";", "const", "TargetRegisterClass", "&", "AvailableRegs", "=", "*", "TRI", "->", "getGPRsForTailCall", "(", "*", "MF", ")", ";", "if", "(", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", "return", "0", ";", "switch", "(", "MBBI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "TargetOpcode", "::", "PATCHABLE_RET", ":", "case", "X86", "::", "RET", ":", "case", "X86", "::", "RETL", ":", "case", "X86", "::", "RETQ", ":", "case", "X86", "::", "RETIL", ":", "case", "X86", "::", "RETIQ", ":", "case", "X86", "::", "TCRETURNdi", ":", "case", "X86", "::", "TCRETURNri", ":", "case", "X86", "::", "TCRETURNmi", ":", "case", "X86", "::", "TCRETURNdi64", ":", "case", "X86", "::", "TCRETURNri64", ":", "case", "X86", "::", "TCRETURNmi64", ":", "case", "X86", "::", "EH_RETURN", ":", "case", "X86", "::", "EH_RETURN64", ":", "{", "SmallSet", "<", "uint16_t", ",", "8", ">", "Uses", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MBBI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MBBI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "continue", ";", "for", "(", "MCRegAliasIterator", "AI", "(", "Reg", ",", "TRI", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Uses", ".", "insert", "(", "*", "AI", ")", ";", "}", "for", "(", "auto", "CS", ":", "AvailableRegs", ")", "if", "(", "!", "Uses", ".", "count", "(", "CS", ")", "&&", "CS", "!=", "X86", "::", "RIP", ")", "return", "CS", ";", "}", "}", "return", "0", ";", "}", "</s>" ]
[ "findDeadCallerSavedReg", "-", "Return", "a", "caller-saved", "register", "that", "is", "n't", "live", "when", "it", "reaches", "the", "``", "return", "''", "instruction", "." ]
[ "X86", "X86", "0", "0", "0", "X86::RET", "X86::RETL", "X86::RETQ", "X86::RETIL", "X86::RETIQ", "X86::TCRETURNdi", "X86::TCRETURNri", "X86::TCRETURNmi", "X86::TCRETURNdi64", "X86::TCRETURNri64", "X86::TCRETURNmi64", "X86::EH_RETURN", "X86::EH_RETURN64", "8", "0", "X86::RIP", "0" ]
X86FrameLowering11
findDeadCallerSavedReg
X86
CPU
LLVM
18,366
308
1
[]
[ "<s>", "static", "void", "aarch64_override_options_after_change", "(", "void", ")", "{", "aarch64_override_options_after_change_1", "(", "&", "global_options", ")", ";", "}", "</s>" ]
[ "Implement", "targetm.override_options_after_change", "." ]
[ "aarch64" ]
aarch64
aarch64_override_options_after_change
aarch64
CPU
GCC
18,367
14
1
[]
[ "<s>", "bool", "function_arg_regno_p", "(", "int", "n", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "arg_regs", "[", "i", "]", "!=", "-", "1", ";", "i", "++", ")", "if", "(", "n", "==", "arg_regs", "[", "i", "]", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]
[ "Return", "true", "when", "register", "may", "be", "used", "to", "pass", "function", "parameters", "." ]
[ "bfin", "0", "1" ]
bfin
function_arg_regno_p
bfin
DSP
GCC
18,368
43
1
[]
[ "<s>", "static", "bool", "pa_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_PORTABLE_RUNTIME", ")", "return", "false", ";", "if", "(", "TARGET_ELF32", ")", "return", "(", "decl", "!=", "NULL_TREE", ")", ";", "if", "(", "TARGET_64BIT", ")", "return", "false", ";", "return", "(", "decl", "&&", "!", "TREE_PUBLIC", "(", "decl", ")", ")", ";", "}", "</s>" ]
[ "Only", "direct", "calls", "to", "static", "functions", "are", "allowed", "to", "be", "sibling", "(", "tail", ")", "call", "optimized", ".", "This", "restriction", "is", "necessary", "because", "some", "linker", "generated", "stubs", "will", "store", "return", "pointers", "into", "rp", "'", "in", "some", "cases", "which", "might", "clobber", "a", "live", "value", "already", "in", "rp", "'", ".", "In", "a", "sibcall", "the", "current", "function", "and", "the", "target", "function", "share", "stack", "space", ".", "Thus", "if", "the", "path", "to", "the", "current", "function", "and", "the", "path", "to", "the", "target", "function", "save", "a", "value", "in", "rp", "'", ",", "they", "save", "the", "value", "into", "the", "same", "stack", "slot", ",", "which", "has", "undesirable", "consequences", ".", "Because", "of", "the", "deferred", "binding", "nature", "of", "shared", "libraries", "any", "function", "with", "external", "scope", "could", "be", "in", "a", "different", "load", "module", "and", "thus", "require", "rp", "'", "to", "be", "saved", "when", "calling", "that", "function", ".", "So", "sibcall", "optimizations", "can", "only", "be", "safe", "for", "static", "function", ".", "Note", "that", "GCC", "never", "needs", "return", "value", "relocations", ",", "so", "we", "do", "n't", "have", "to", "worry", "about", "static", "calls", "with", "return", "value", "relocations", "(", "which", "require", "saving", "rp", "'", ")", ".", "It", "is", "safe", "to", "perform", "a", "sibcall", "optimization", "when", "the", "target", "function", "will", "never", "return", "." ]
[ "pa" ]
pa3
pa_function_ok_for_sibcall
pa
CPU
GCC
18,369
49
1
[]
[ "<s>", "bool", "VZeroUpperInserter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "hasAVX", "(", ")", "||", "ST", ".", "hasAVX512", "(", ")", ")", "return", "false", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "EverMadeChange", "=", "false", ";", "bool", "FnHasLiveInYmm", "=", "checkFnHasLiveInYmm", "(", "MRI", ")", ";", "bool", "YMMUsed", "=", "FnHasLiveInYmm", ";", "if", "(", "!", "YMMUsed", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "&", "X86", "::", "VR256RegClass", ";", "for", "(", "TargetRegisterClass", "::", "iterator", "i", "=", "RC", "->", "begin", "(", ")", ",", "e", "=", "RC", "->", "end", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "if", "(", "!", "MRI", ".", "reg_nodbg_empty", "(", "*", "i", ")", ")", "{", "YMMUsed", "=", "true", ";", "break", ";", "}", "}", "}", "if", "(", "!", "YMMUsed", ")", "{", "return", "false", ";", "}", "assert", "(", "BlockStates", ".", "empty", "(", ")", "&&", "DirtySuccessors", ".", "empty", "(", ")", "&&", "\"X86VZeroUpper state should be clear\"", ")", ";", "BlockStates", ".", "resize", "(", "MF", ".", "getNumBlockIDs", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "processBasicBlock", "(", "*", "I", ")", ";", "if", "(", "FnHasLiveInYmm", ")", "addDirtySuccessor", "(", "MF", ".", "front", "(", ")", ")", ";", "while", "(", "!", "DirtySuccessors", ".", "empty", "(", ")", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "DirtySuccessors", ".", "back", "(", ")", ";", "DirtySuccessors", ".", "pop_back", "(", ")", ";", "BlockState", "&", "BBState", "=", "BlockStates", "[", "MBB", ".", "getNumber", "(", ")", "]", ";", "if", "(", "BBState", ".", "FirstUnguardedCall", "!=", "MBB", ".", "end", "(", ")", ")", "insertVZeroUpper", "(", "BBState", ".", "FirstUnguardedCall", ",", "MBB", ")", ";", "if", "(", "BBState", ".", "ExitState", "==", "PASS_THROUGH", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"MBB #\"", "<<", "MBB", ".", "getNumber", "(", ")", "<<", "\" was Pass-through, is now Dirty-out.\\n\"", ")", ";", "for", "(", "MachineBasicBlock", "::", "succ_iterator", "SI", "=", "MBB", ".", "succ_begin", "(", ")", ",", "SE", "=", "MBB", ".", "succ_end", "(", ")", ";", "SI", "!=", "SE", ";", "++", "SI", ")", "addDirtySuccessor", "(", "*", "*", "SI", ")", ";", "}", "}", "BlockStates", ".", "clear", "(", ")", ";", "return", "EverMadeChange", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "X86", "X86", "X86", "X86::VR256RegClass", "\"X86VZeroUpper state should be clear\"", "\"MBB #\"", "\" was Pass-through, is now Dirty-out.\\n\"" ]
X86VZeroUpper12
runOnMachineFunction
X86
CPU
LLVM
18,370
362
1
[]
[ "<s>", "bool", "hasFP", "(", "const", "MachineFunction", "&", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]
[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]
[ "Cpu0" ]
Cpu0FrameLowering3
hasFP
Cpu0
CPU
LLVM
18,371
14
1
[]
[ "<s>", "bool", "ARMTargetLowering", "::", "getPostIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDNode", "*", "Op", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "VT", ";", "SDValue", "Ptr", ";", "bool", "isSEXTLoad", "=", "false", ",", "isNonExt", ";", "if", "(", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "Ptr", "=", "LD", "->", "getBasePtr", "(", ")", ";", "isSEXTLoad", "=", "LD", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "SEXTLOAD", ";", "isNonExt", "=", "LD", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "NON_EXTLOAD", ";", "}", "else", "if", "(", "StoreSDNode", "*", "ST", "=", "dyn_cast", "<", "StoreSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "Ptr", "=", "ST", "->", "getBasePtr", "(", ")", ";", "isNonExt", "=", "!", "ST", "->", "isTruncatingStore", "(", ")", ";", "}", "else", "return", "false", ";", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "{", "assert", "(", "Op", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", "&&", "\"Non-i32 post-inc op?!\"", ")", ";", "if", "(", "Op", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "ADD", "||", "!", "isNonExt", ")", "return", "false", ";", "auto", "*", "RHS", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "1", ")", ")", ";", "if", "(", "!", "RHS", "||", "RHS", "->", "getZExtValue", "(", ")", "!=", "4", ")", "return", "false", ";", "Offset", "=", "Op", "->", "getOperand", "(", "1", ")", ";", "Base", "=", "Op", "->", "getOperand", "(", "0", ")", ";", "AM", "=", "ISD", "::", "POST_INC", ";", "return", "true", ";", "}", "bool", "isInc", ";", "bool", "isLegal", "=", "false", ";", "if", "(", "Subtarget", "->", "isThumb2", "(", ")", ")", "isLegal", "=", "getT2IndexedAddressParts", "(", "Op", ",", "VT", ",", "isSEXTLoad", ",", "Base", ",", "Offset", ",", "isInc", ",", "DAG", ")", ";", "else", "isLegal", "=", "getARMIndexedAddressParts", "(", "Op", ",", "VT", ",", "isSEXTLoad", ",", "Base", ",", "Offset", ",", "isInc", ",", "DAG", ")", ";", "if", "(", "!", "isLegal", ")", "return", "false", ";", "if", "(", "Ptr", "!=", "Base", ")", "{", "if", "(", "Ptr", "==", "Offset", "&&", "Op", "->", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", "&&", "!", "Subtarget", "->", "isThumb2", "(", ")", ")", "std", "::", "swap", "(", "Base", ",", "Offset", ")", ";", "if", "(", "Ptr", "!=", "Base", ")", "return", "false", ";", "}", "AM", "=", "isInc", "?", "ISD", "::", "POST_INC", ":", "ISD", "::", "POST_DEC", ";", "return", "true", ";", "}", "</s>" ]
[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "this", "node", "can", "be", "combined", "with", "a", "load", "/", "store", "to", "form", "a", "post-indexed", "load", "/", "store", "." ]
[ "ARM", "ARM", "ISD::MemIndexedMode", "ISD::SEXTLOAD", "ISD::NON_EXTLOAD", "0", "MVT::i32", "\"Non-i32 post-inc op?!\"", "ISD::ADD", "1", "4", "1", "0", "ISD::POST_INC", "ARM", "ISD::ADD", "ISD::POST_INC", "ISD::POST_DEC" ]
ARMISelLowering (3)
getPostIndexedAddressParts
ARM
CPU
LLVM
18,372
380
1
[]
[ "<s>", "bool", "PPCLoopPreIncPrep", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "SE", "=", "&", "getAnalysis", "<", "ScalarEvolution", ">", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "LoopInfo", "::", "iterator", "I", "=", "LI", "->", "begin", "(", ")", ",", "E", "=", "LI", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Loop", "*", "L", "=", "*", "I", ";", "MadeChange", "|=", "runOnLoop", "(", "L", ")", ";", "}", "return", "MadeChange", ";", "}", "</s>" ]
[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]
[ "PowerPC", "PPC" ]
PPCLoopPreIncPrep7
runOnFunction
PowerPC
CPU
LLVM
18,373
87
1
[]
[ "<s>", "bool", "PPCAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "O", ")", ";", "case", "'L'", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", "||", "OpNo", "+", "1", "==", "MI", "->", "getNumOperands", "(", ")", "||", "!", "MI", "->", "getOperand", "(", "OpNo", "+", "1", ")", ".", "isReg", "(", ")", ")", "return", "true", ";", "++", "OpNo", ";", "break", ";", "case", "'I'", ":", "if", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isImm", "(", ")", ")", "O", "<<", "\"i\"", ";", "return", "false", ";", "case", "'x'", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", ")", "return", "true", ";", "Register", "Reg", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", ";", "if", "(", "PPCInstrInfo", "::", "isVRRegister", "(", "Reg", ")", ")", "Reg", "=", "PPC", "::", "VSX32", "+", "(", "Reg", "-", "PPC", "::", "V0", ")", ";", "else", "if", "(", "PPCInstrInfo", "::", "isVFRegister", "(", "Reg", ")", ")", "Reg", "=", "PPC", "::", "VSX32", "+", "(", "Reg", "-", "PPC", "::", "VF0", ")", ";", "const", "char", "*", "RegName", ";", "RegName", "=", "PPCInstPrinter", "::", "getRegisterName", "(", "Reg", ")", ";", "RegName", "=", "PPCRegisterInfo", "::", "stripRegisterPrefix", "(", "RegName", ")", ";", "O", "<<", "RegName", ";", "return", "false", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]
[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]
[ "PowerPC", "PPC", "0", "1", "0", "0", "1", "1", "\"i\"", "PPC", "PPC::VSX32", "PPC::V0", "PPC", "PPC::VSX32", "PPC::VF0", "PPC", "PPC" ]
PPCAsmPrinter (2)3
PrintAsmOperand
PowerPC
CPU
LLVM
18,374
267
1
[]
[ "<s>", "bool", "isValid", "(", ")", "const", "{", "return", "Block", ";", "}", "</s>" ]
[ "Returns", "true", "if", "this", "iterator", "is", "still", "pointing", "at", "a", "valid", "entry", "." ]
[ "AMDGPU" ]
SIMachineScheduler
isValid
AMDGPU
GPU
LLVM
18,375
10
1
[]
[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addPreserved", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ";", "getLoopAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]
[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]
[ "TPC" ]
TPCoptimization
getAnalysisUsage
TPC
Virtual ISA
LLVM
18,376
25
1
[]
[ "<s>", "int", "M680x0FrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "TRI", "->", "hasBasePointer", "(", "MF", ")", ")", "FrameReg", "=", "TRI", "->", "getBaseRegister", "(", ")", ";", "else", "if", "(", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ")", "FrameReg", "=", "TRI", "->", "getStackRegister", "(", ")", ";", "else", "FrameReg", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", "-", "getOffsetOfLocalArea", "(", ")", ";", "const", "M680x0MachineFunctionInfo", "*", "MMFI", "=", "MF", ".", "getInfo", "<", "M680x0MachineFunctionInfo", ">", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "if", "(", "TRI", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "assert", "(", "HasFP", "&&", "\"VLAs and dynamic stack realign, but no FP?!\"", ")", ";", "if", "(", "FI", "<", "0", ")", "{", "return", "Offset", "+", "SlotSize", ";", "}", "else", "{", "assert", "(", "(", "-", "(", "Offset", "+", "StackSize", ")", ")", "%", "MFI", ".", "getObjectAlignment", "(", "FI", ")", "==", "0", ")", ";", "return", "Offset", "+", "StackSize", ";", "}", "}", "else", "if", "(", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "if", "(", "FI", "<", "0", ")", "{", "return", "Offset", "+", "SlotSize", ";", "}", "else", "{", "assert", "(", "(", "-", "(", "Offset", "+", "StackSize", ")", ")", "%", "MFI", ".", "getObjectAlignment", "(", "FI", ")", "==", "0", ")", ";", "return", "Offset", "+", "StackSize", ";", "}", "}", "else", "{", "if", "(", "!", "HasFP", ")", "return", "Offset", "+", "StackSize", ";", "Offset", "+=", "SlotSize", ";", "int", "TailCallReturnAddrDelta", "=", "MMFI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "TailCallReturnAddrDelta", "<", "0", ")", "Offset", "-=", "TailCallReturnAddrDelta", ";", "}", "return", "Offset", ";", "}", "</s>" ]
[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]
[ "M680x0", "M680x0", "M680x0", "M680x0", "\"VLAs and dynamic stack realign, but no FP?!\"", "0", "0", "0", "0", "0" ]
M680x0FrameLowering
getFrameIndexReference
M680x0
MPU
LLVM
18,377
274
1
[]
[ "<s>", "bool", "SystemZInstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Pred", ")", "const", "{", "assert", "(", "Pred", ".", "size", "(", ")", "==", "2", "&&", "\"Invalid condition\"", ")", ";", "unsigned", "CCValid", "=", "Pred", "[", "0", "]", ".", "getImm", "(", ")", ";", "unsigned", "CCMask", "=", "Pred", "[", "1", "]", ".", "getImm", "(", ")", ";", "assert", "(", "CCMask", ">", "0", "&&", "CCMask", "<", "15", "&&", "\"Invalid predicate\"", ")", ";", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "TM", ".", "getSubtargetImpl", "(", ")", "->", "hasLoadStoreOnCond", "(", ")", ")", "{", "if", "(", "unsigned", "CondOpcode", "=", "getConditionalMove", "(", "Opcode", ")", ")", "{", "MI", "->", "setDesc", "(", "get", "(", "CondOpcode", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "addReg", "(", "SystemZ", "::", "CC", ",", "RegState", "::", "Implicit", ")", ";", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]
[ "Convert", "the", "instruction", "into", "a", "predicated", "instruction", "." ]
[ "SystemZ", "SystemZ", "2", "\"Invalid condition\"", "0", "1", "0", "15", "\"Invalid predicate\"", "SystemZ::CC" ]
SystemZInstrInfo (2)
PredicateInstruction
SystemZ
CPU
LLVM
18,378
159
1
[]
[ "<s>", "int", "mmix_initial_elimination_offset", "(", "int", "fromreg", ",", "int", "toreg", ")", "{", "int", "regno", ";", "int", "fp_sp_offset", "=", "(", "get_frame_size", "(", ")", "+", "crtl", "->", "outgoing_args_size", "+", "7", ")", "&", "~", "7", ";", "if", "(", "fromreg", "==", "MMIX_ARG_POINTER_REGNUM", "&&", "toreg", "==", "MMIX_FRAME_POINTER_REGNUM", ")", "return", "0", ";", "for", "(", "regno", "=", "MMIX_FIRST_GLOBAL_REGNUM", ";", "regno", "<=", "255", ";", "regno", "++", ")", "if", "(", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", "||", "IS_MMIX_EH_RETURN_DATA_REG", "(", "regno", ")", ")", "fp_sp_offset", "+=", "8", ";", "return", "fp_sp_offset", "+", "(", "MMIX_CFUN_HAS_LANDING_PAD", "?", "16", ":", "(", "MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS", "?", "8", ":", "0", ")", ")", "+", "(", "fromreg", "==", "MMIX_ARG_POINTER_REGNUM", "?", "0", ":", "8", ")", ";", "}", "</s>" ]
[ "The", "difference", "between", "the", "(", "imaginary", ")", "frame", "pointer", "and", "the", "stack", "pointer", ".", "Used", "to", "eliminate", "the", "frame", "pointer", "." ]
[ "mmix", "7", "7", "0", "255", "8", "16", "8", "0", "0", "8" ]
mmix
mmix_initial_elimination_offset
mmix
CPU
GCC
18,379
109
1
[]
[ "<s>", "Register", "VETargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "LLT", "VT", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "Register", "Reg", "=", "StringSwitch", "<", "Register", ">", "(", "RegName", ")", ".", "Case", "(", "\"sp\"", ",", "VE", "::", "SX11", ")", ".", "Case", "(", "\"fp\"", ",", "VE", "::", "SX9", ")", ".", "Case", "(", "\"sl\"", ",", "VE", "::", "SX8", ")", ".", "Case", "(", "\"lr\"", ",", "VE", "::", "SX10", ")", ".", "Case", "(", "\"tp\"", ",", "VE", "::", "SX14", ")", ".", "Case", "(", "\"outer\"", ",", "VE", "::", "SX12", ")", ".", "Case", "(", "\"info\"", ",", "VE", "::", "SX17", ")", ".", "Case", "(", "\"got\"", ",", "VE", "::", "SX15", ")", ".", "Case", "(", "\"plt\"", ",", "VE", "::", "SX16", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]
[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]
[ "VE", "VE", "\"sp\"", "VE::SX11", "\"fp\"", "VE::SX9", "\"sl\"", "VE::SX8", "\"lr\"", "VE::SX10", "\"tp\"", "VE::SX14", "\"outer\"", "VE::SX12", "\"info\"", "VE::SX17", "\"got\"", "VE::SX15", "\"plt\"", "VE::SX16", "0", "\"Invalid register name global variable\"" ]
VEISelLowering
getRegisterByName
VE
CPU
LLVM
18,380
130
1
[]
[ "<s>", "unsigned", "TOYInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "TOY", "::", "STORErr", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]
[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]
[ "TOY", "TOY", "TOY::STORErr", "1", "1", "0", "0" ]
TOYInstrInfo
isStoreToStackSlot
TOY
CPU
LLVM
18,381
81
1
[]
[ "<s>", "void", "RISCVFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "RISCVRegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "const", "RISCVInstrInfo", "*", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "unsigned", "FPReg", "=", "getFPReg", "(", "STI", ")", ";", "unsigned", "SPReg", "=", "getSPReg", "(", "STI", ")", ";", "auto", "LastFrameDestroy", "=", "std", "::", "prev", "(", "MBBI", ",", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "uint64_t", "FPOffset", "=", "StackSize", "-", "RVFI", "->", "getVarArgsSaveSize", "(", ")", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "assert", "(", "hasFP", "(", "MF", ")", "&&", "\"frame pointer should not have been eliminated\"", ")", ";", "adjustReg", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "SPReg", ",", "FPReg", ",", "-", "FPOffset", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "for", "(", "auto", "&", "I", "=", "LastFrameDestroy", ";", "I", "!=", "MBBI", ";", "++", "I", ")", "{", "if", "(", "I", "->", "mayLoad", "(", ")", "&&", "I", "->", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", ")", "{", "unsigned", "DestReg", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "DestReg", "==", "FPReg", ")", "{", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfa", "(", "nullptr", ",", "RI", "->", "getDwarfRegNum", "(", "SPReg", ",", "true", ")", ",", "-", "FPOffset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "I", ")", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "break", ";", "}", "}", "}", "}", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "for", "(", "const", "auto", "&", "Entry", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "Entry", ".", "getReg", "(", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createRestore", "(", "nullptr", ",", "RI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "StackSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaOffset", "(", "nullptr", ",", "0", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "</s>" ]
[ "Insert", "epilog", "code", "into", "the", "function", "." ]
[ "RISCV", "RISCV", "RISCV", "RISCV", "RISCV", "\"frame pointer should not have been eliminated\"", "0", "0", "0" ]
RISCVFrameLowering32
emitEpilogue
RISCV
CPU
LLVM
18,382
452
1
[]
[ "<s>", "static", "void", "assign_fp_registers", "(", "const_tree", "field", ",", "int", "bitpos", ",", "assign_data_t", "*", "data", ")", "{", "int", "nregs", ";", "machine_mode", "mode", ";", "if", "(", "!", "compute_fp_layout", "(", "field", ",", "bitpos", ",", "data", ",", "&", "nregs", ",", "&", "mode", ")", ")", "return", ";", "const", "int", "this_slotno", "=", "data", "->", "slotno", "+", "bitpos", "/", "BITS_PER_WORD", ";", "int", "regno", "=", "SPARC_FP_ARG_FIRST", "+", "this_slotno", "*", "2", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", "&&", "(", "bitpos", "&", "32", ")", "!=", "0", ")", "regno", "++", ";", "int", "pos", "=", "bitpos", "/", "BITS_PER_UNIT", ";", "do", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "XVECEXP", "(", "data", "->", "ret", ",", "0", ",", "data", "->", "stack", "+", "data", "->", "nregs", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "GEN_INT", "(", "pos", ")", ")", ";", "data", "->", "nregs", "+=", "1", ";", "regno", "+=", "GET_MODE_SIZE", "(", "mode", ")", "/", "4", ";", "pos", "+=", "GET_MODE_SIZE", "(", "mode", ")", ";", "}", "while", "(", "--", "nregs", ">", "0", ")", ";", "}", "</s>" ]
[ "A", "subroutine", "of", "function_arg_record_value", ".", "Assign", "FIELD", "at", "position", "BITPOS", "to", "FP", "registers", "." ]
[ "sparc", "2", "4", "32", "0", "0", "1", "4", "0" ]
sparc
assign_fp_registers
sparc
CPU
GCC
18,383
162
1
[]
[ "<s>", "bool", "isImm", "(", ")", "const", "override", "{", "return", "is", "(", "k_Immediate", ")", ";", "}", "</s>" ]
[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]
[ "MOS" ]
MOSAsmParser
isImm
MOS
MPU
LLVM
18,384
14
1
[]
[ "<s>", "int", "standard_sse_constant_p", "(", "rtx", "x", ")", "{", "if", "(", "x", "==", "const0_rtx", ")", "return", "1", ";", "return", "(", "x", "==", "CONST0_RTX", "(", "GET_MODE", "(", "x", ")", ")", ")", ";", "}", "</s>" ]
[ "Return", "1", "if", "X", "is", "all", "0s", "and", "2", "if", "x", "is", "all", "1s", "in", "supported", "SSE/AVX", "vector", "mode", "." ]
[ "i386", "1" ]
i3863
standard_sse_constant_p
i386
CPU
GCC
18,385
30
1
[]
[ "<s>", "void", "VEInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "if", "(", "RC", "==", "&", "VE", "::", "I64RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "LDrii", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "VE", "::", "I32RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "LDLSXrii", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "VE", "::", "F32RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "LDUrii", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "report_fatal_error", "(", "\"Can't load this register from stack slot\"", ")", ";", "}", "</s>" ]
[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]
[ "VE", "VE", "VE::I64RegClass", "VE::LDrii", "0", "0", "VE::I32RegClass", "VE::LDLSXrii", "0", "0", "VE::F32RegClass", "VE::LDUrii", "0", "0", "\"Can't load this register from stack slot\"" ]
VEInstrInfo1
loadRegFromStackSlot
VE
CPU
LLVM
18,386
267
1
[]
[ "<s>", "bool", "ARMCodeEmitter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "assert", "(", "(", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Default", "||", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Static", ")", "&&", "\"JIT relocation model must be set to static or default!\"", ")", ";", "JTI", "=", "(", "(", "ARMBaseTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getJITInfo", "(", ")", ";", "II", "=", "(", "const", "ARMBaseInstrInfo", "*", ")", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TD", "=", "MF", ".", "getTarget", "(", ")", ".", "getDataLayout", "(", ")", ";", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "MCPEs", "=", "&", "MF", ".", "getConstantPool", "(", ")", "->", "getConstants", "(", ")", ";", "MJTEs", "=", "0", ";", "if", "(", "MF", ".", "getJumpTableInfo", "(", ")", ")", "MJTEs", "=", "&", "MF", ".", "getJumpTableInfo", "(", ")", "->", "getJumpTables", "(", ")", ";", "IsPIC", "=", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ";", "IsThumb", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", "->", "isThumbFunction", "(", ")", ";", "JTI", "->", "Initialize", "(", "MF", ",", "IsPIC", ")", ";", "MMI", "=", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ";", "MCE", ".", "setModuleInfo", "(", "MMI", ")", ";", "do", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"JITTing function '\"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"'\\n\"", ")", ";", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MBB", "!=", "E", ";", "++", "MBB", ")", "{", "MCE", ".", "StartMachineBasicBlock", "(", "MBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", "->", "begin", "(", ")", ",", "E", "=", "MBB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "emitInstruction", "(", "*", "I", ")", ";", "}", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "ARM", "ARM", "\"JIT relocation model must be set to static or default!\"", "ARM", "ARM", "ARM", "0", "ARM", "\"JITTing function '\"", "\"'\\n\"" ]
ARMCodeEmitter15
runOnMachineFunction
ARM
CPU
LLVM
18,387
307
1
[]
[ "<s>", "bool", "hasUsableDSOffset", "(", ")", "const", "{", "return", "getGeneration", "(", ")", ">=", "SEA_ISLANDS", ";", "}", "</s>" ]
[ "True", "if", "the", "offset", "field", "of", "DS", "instructions", "works", "as", "expected", "." ]
[ "AMDGPU" ]
AMDGPUSubtarget107
hasUsableDSOffset
AMDGPU
GPU
LLVM
18,388
14
1
[]
[ "<s>", "bool", "MipsLongBranch", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "if", "(", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "&&", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "isABI_O32", "(", ")", "&&", "F", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "globalBaseRegSet", "(", ")", ")", "emitGPDisp", "(", "F", ",", "TII", ")", ";", "if", "(", "SkipLongBranch", ")", "return", "true", ";", "MF", "=", "&", "F", ";", "initMBBInfo", "(", ")", ";", "SmallVector", "<", "MBBInfo", ",", "16", ">", "::", "iterator", "I", ",", "E", "=", "MBBInfos", ".", "end", "(", ")", ";", "bool", "EverMadeChange", "=", "false", ",", "MadeChange", "=", "true", ";", "while", "(", "MadeChange", ")", "{", "MadeChange", "=", "false", ";", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "I", "->", "Br", "||", "I", "->", "HasLongBranch", ")", "continue", ";", "if", "(", "!", "ForceLongBranch", "&&", "isInt", "<", "16", ">", "(", "computeOffset", "(", "I", "->", "Br", ")", "/", "4", ")", ")", "continue", ";", "I", "->", "HasLongBranch", "=", "true", ";", "I", "->", "Size", "+=", "LongBranchSeqSize", "*", "4", ";", "++", "LongBranches", ";", "EverMadeChange", "=", "MadeChange", "=", "true", ";", "}", "}", "if", "(", "!", "EverMadeChange", ")", "return", "true", ";", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "{", "MF", "->", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "setEmitNOAT", "(", ")", ";", "uint64_t", "Address", "=", "0", ";", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "Address", "+=", "I", "->", "Size", ",", "++", "I", ")", "I", "->", "Address", "=", "Address", ";", "}", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "I", "->", "HasLongBranch", ")", "expandToLongBranch", "(", "*", "I", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "return", "true", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "Mips", "Mips", "Mips", "Mips", "16", "16", "4", "4", "Mips", "0" ]
MipsLongBranch16
runOnMachineFunction
Mips
CPU
LLVM
18,389
295
1
[]
[ "<s>", "static", "bool", "frv_registers_conflict_p", "(", "rtx", "x", ")", "{", "regstate_t", "flags", ";", "flags", "=", "0", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "COND_EXEC", ")", "{", "if", "(", "frv_registers_conflict_p_1", "(", "XEXP", "(", "x", ",", "0", ")", ",", "flags", ")", ")", "return", "true", ";", "flags", "|=", "frv_cond_flags", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "x", "=", "XEXP", "(", "x", ",", "1", ")", ";", "}", "return", "frv_registers_conflict_p_1", "(", "x", ",", "flags", ")", ";", "}", "</s>" ]
[ "Return", "true", "if", "something", "in", "X", "might", "depend", "on", "an", "instruction", "in", "the", "current", "packet", "." ]
[ "frv", "0", "0", "0", "1" ]
frv
frv_registers_conflict_p
frv
VLIW
GCC
18,390
73
1
[]
[ "<s>", "std", "::", "string", "getDataLayout", "(", ")", "const", "{", "const", "char", "*", "p", ";", "if", "(", "is64Bit", "(", ")", ")", "p", "=", "\"e-p:64:64-s:64-f64:64:64-i64:64:64-f80:128:128\"", ";", "else", "if", "(", "isTargetDarwin", "(", ")", ")", "p", "=", "\"e-p:32:32-f64:32:64-i64:32:64-f80:128:128\"", ";", "else", "p", "=", "\"e-p:32:32-f64:32:64-i64:32:64-f80:32:32\"", ";", "return", "std", "::", "string", "(", "p", ")", ";", "}", "</s>" ]
[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]
[ "X86", "\"e-p:64:64-s:64-f64:64:64-i64:64:64-f80:128:128\"", "\"e-p:32:32-f64:32:64-i64:32:64-f80:128:128\"", "\"e-p:32:32-f64:32:64-i64:32:64-f80:32:32\"" ]
X86Subtarget46
getDataLayout
X86
CPU
LLVM
18,391
48
1
[]
[ "<s>", "static", "unsigned", "long", "rs6000_arg_size", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "unsigned", "long", "size", ";", "if", "(", "mode", "!=", "BLKmode", ")", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "else", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "TARGET_32BIT", ")", "return", "(", "size", "+", "3", ")", ">>", "2", ";", "else", "return", "(", "size", "+", "7", ")", ">>", "3", ";", "}", "</s>" ]
[ "Compute", "the", "size", "(", "in", "words", ")", "of", "a", "function", "argument", "." ]
[ "rs6000", "3", "2", "7", "3" ]
rs6000-call
rs6000_arg_size
rs6000
CPU
GCC
18,392
61
1
[]
[ "<s>", "void", "AArch64PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", ">=", "CodeGenOpt", "::", "Aggressive", "&&", "EnableLoadStoreOpt", ")", "addPass", "(", "createAArch64LoadStoreOptimizationPass", "(", ")", ")", ";", "if", "(", "EnableA53Fix835769", ")", "addPass", "(", "createAArch64A53Fix835769", "(", ")", ")", ";", "if", "(", "BranchRelaxation", ")", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "if", "(", "EnableBranchTargets", ")", "addPass", "(", "createAArch64BranchTargetsPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "addPass", "(", "createCFGuardLongjmpPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCompressJumpTables", ")", "addPass", "(", "createAArch64CompressJumpTablesPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCollectLOH", "&&", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSBinFormatMachO", "(", ")", ")", "addPass", "(", "createAArch64CollectLOHPass", "(", ")", ")", ";", "}", "</s>" ]
[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]
[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]
AArch64TargetMachine15
addPreEmitPass
AArch64
CPU
LLVM
18,393
132
1
[]
[ "<s>", "unsigned", "ARMFastISel", "::", "fastEmitInst_i", "(", "unsigned", "MachineInstOpcode", ",", "const", "TargetRegisterClass", "*", "RC", ",", "uint64_t", "Imm", ")", "{", "Register", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "const", "MCInstrDesc", "&", "II", "=", "TII", ".", "get", "(", "MachineInstOpcode", ")", ";", "if", "(", "II", ".", "getNumDefs", "(", ")", ">=", "1", ")", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ",", "ResultReg", ")", ".", "addImm", "(", "Imm", ")", ")", ";", "}", "else", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ")", ".", "addImm", "(", "Imm", ")", ")", ";", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "II", ".", "ImplicitDefs", "[", "0", "]", ")", ")", ";", "}", "return", "ResultReg", ";", "}", "</s>" ]
[ "Emit", "a", "MachineInstr", "with", "a", "single", "immediate", "operand", ",", "and", "a", "result", "register", "in", "the", "given", "register", "class", "." ]
[ "ARM", "ARM", "1", "0" ]
ARMFastISel36
fastEmitInst_i
ARM
CPU
LLVM
18,394
144
1
[]
[ "<s>", "const", "char", "*", "SparcTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "SPISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "SPISD", "::", "FIRST_NUMBER", ":", "break", ";", "case", "SPISD", "::", "CMPICC", ":", "return", "\"SPISD::CMPICC\"", ";", "case", "SPISD", "::", "CMPFCC", ":", "return", "\"SPISD::CMPFCC\"", ";", "case", "SPISD", "::", "BRICC", ":", "return", "\"SPISD::BRICC\"", ";", "case", "SPISD", "::", "BRXCC", ":", "return", "\"SPISD::BRXCC\"", ";", "case", "SPISD", "::", "BRFCC", ":", "return", "\"SPISD::BRFCC\"", ";", "case", "SPISD", "::", "SELECT_ICC", ":", "return", "\"SPISD::SELECT_ICC\"", ";", "case", "SPISD", "::", "SELECT_XCC", ":", "return", "\"SPISD::SELECT_XCC\"", ";", "case", "SPISD", "::", "SELECT_FCC", ":", "return", "\"SPISD::SELECT_FCC\"", ";", "case", "SPISD", "::", "EH_SJLJ_SETJMP", ":", "return", "\"SPISD::EH_SJLJ_SETJMP\"", ";", "case", "SPISD", "::", "EH_SJLJ_LONGJMP", ":", "return", "\"SPISD::EH_SJLJ_LONGJMP\"", ";", "case", "SPISD", "::", "Hi", ":", "return", "\"SPISD::Hi\"", ";", "case", "SPISD", "::", "Lo", ":", "return", "\"SPISD::Lo\"", ";", "case", "SPISD", "::", "FTOI", ":", "return", "\"SPISD::FTOI\"", ";", "case", "SPISD", "::", "ITOF", ":", "return", "\"SPISD::ITOF\"", ";", "case", "SPISD", "::", "FTOX", ":", "return", "\"SPISD::FTOX\"", ";", "case", "SPISD", "::", "XTOF", ":", "return", "\"SPISD::XTOF\"", ";", "case", "SPISD", "::", "CALL", ":", "return", "\"SPISD::CALL\"", ";", "case", "SPISD", "::", "RET_FLAG", ":", "return", "\"SPISD::RET_FLAG\"", ";", "case", "SPISD", "::", "GLOBAL_BASE_REG", ":", "return", "\"SPISD::GLOBAL_BASE_REG\"", ";", "case", "SPISD", "::", "FLUSHW", ":", "return", "\"SPISD::FLUSHW\"", ";", "case", "SPISD", "::", "TLS_ADD", ":", "return", "\"SPISD::TLS_ADD\"", ";", "case", "SPISD", "::", "TLS_LD", ":", "return", "\"SPISD::TLS_LD\"", ";", "case", "SPISD", "::", "TLS_CALL", ":", "return", "\"SPISD::TLS_CALL\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]
[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]
[ "Sparc", "Sparc", "SPISD::NodeType", "SPISD::FIRST_NUMBER", "SPISD::CMPICC", "\"SPISD::CMPICC\"", "SPISD::CMPFCC", "\"SPISD::CMPFCC\"", "SPISD::BRICC", "\"SPISD::BRICC\"", "SPISD::BRXCC", "\"SPISD::BRXCC\"", "SPISD::BRFCC", "\"SPISD::BRFCC\"", "SPISD::SELECT_ICC", "\"SPISD::SELECT_ICC\"", "SPISD::SELECT_XCC", "\"SPISD::SELECT_XCC\"", "SPISD::SELECT_FCC", "\"SPISD::SELECT_FCC\"", "SPISD::EH_SJLJ_SETJMP", "\"SPISD::EH_SJLJ_SETJMP\"", "SPISD::EH_SJLJ_LONGJMP", "\"SPISD::EH_SJLJ_LONGJMP\"", "SPISD::Hi", "\"SPISD::Hi\"", "SPISD::Lo", "\"SPISD::Lo\"", "SPISD::FTOI", "\"SPISD::FTOI\"", "SPISD::ITOF", "\"SPISD::ITOF\"", "SPISD::FTOX", "\"SPISD::FTOX\"", "SPISD::XTOF", "\"SPISD::XTOF\"", "SPISD::CALL", "\"SPISD::CALL\"", "SPISD::RET_FLAG", "\"SPISD::RET_FLAG\"", "SPISD::GLOBAL_BASE_REG", "\"SPISD::GLOBAL_BASE_REG\"", "SPISD::FLUSHW", "\"SPISD::FLUSHW\"", "SPISD::TLS_ADD", "\"SPISD::TLS_ADD\"", "SPISD::TLS_LD", "\"SPISD::TLS_LD\"", "SPISD::TLS_CALL", "\"SPISD::TLS_CALL\"" ]
SparcISelLowering14
getTargetNodeName
Sparc
CPU
LLVM
18,395
218
1
[]
[ "<s>", "bool", "strict_low_part_peephole_ok", "(", "machine_mode", "mode", ",", "rtx_insn", "*", "first_insn", ",", "rtx", "target", ")", "{", "rtx_insn", "*", "p", "=", "first_insn", ";", "while", "(", "(", "p", "=", "PREV_INSN", "(", "p", ")", ")", ")", "{", "if", "(", "NOTE_INSN_BASIC_BLOCK_P", "(", "p", ")", ")", "return", "false", ";", "if", "(", "NOTE_P", "(", "p", ")", ")", "continue", ";", "if", "(", "!", "INSN_P", "(", "p", ")", ")", "return", "false", ";", "if", "(", "reg_set_p", "(", "target", ",", "p", ")", ")", "{", "rtx", "set", "=", "single_set", "(", "p", ")", ";", "rtx", "dest", ";", "if", "(", "!", "set", ")", "return", "false", ";", "dest", "=", "SET_DEST", "(", "set", ")", ";", "if", "(", "rtx_equal_p", "(", "dest", ",", "target", ")", "&&", "SET_SRC", "(", "set", ")", "==", "const0_rtx", ")", "return", "true", ";", "else", "if", "(", "GET_CODE", "(", "dest", ")", "==", "STRICT_LOW_PART", "&&", "GET_CODE", "(", "XEXP", "(", "dest", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "dest", ",", "0", ")", ")", "==", "REGNO", "(", "target", ")", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "XEXP", "(", "dest", ",", "0", ")", ")", ")", "<=", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ";", "else", "return", "false", ";", "}", "}", "return", "false", ";", "}", "</s>" ]
[ "Check", "for", "cases", "where", "a", "clr", "insns", "can", "be", "omitted", "from", "code", "using", "strict_low_part", "sets", ".", "For", "example", ",", "the", "second", "clrl", "here", "is", "not", "needed", ":", "clrl", "d0", ";", "movw", "a0", "@", "+", ",", "d0", ";", "use", "d0", ";", "clrl", "d0", ";", "movw", "a0", "@", "+", ";", "use", "d0", ";", "...", "MODE", "is", "the", "mode", "of", "this", "STRICT_LOW_PART", "set", ".", "FIRST_INSN", "is", "the", "clear", "insn", "we", "are", "checking", "for", "redundancy", ".", "TARGET", "is", "the", "register", "set", "by", "the", "clear", "insn", "." ]
[ "m68k", "0", "0", "0" ]
m68k
strict_low_part_peephole_ok
m68k
MPU
GCC
18,396
185
1
[]
[ "<s>", "bool", "XCoreAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "!", "ExtraCode", "||", "!", "ExtraCode", "[", "0", "]", ")", "{", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ";", "}", "</s>" ]
[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]
[ "XCore", "XCore", "0" ]
XCoreAsmPrinter (2)
PrintAsmOperand
XCore
MPU
LLVM
18,397
68
1
[]
[ "<s>", "BitVector", "ARMBaseRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "PC", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "FPSCR", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "FramePtr", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "BasePtr", ")", ";", "if", "(", "STI", ".", "isR9Reserved", "(", ")", ")", "Reserved", ".", "set", "(", "ARM", "::", "R9", ")", ";", "if", "(", "!", "STI", ".", "hasVFP3", "(", ")", "||", "STI", ".", "hasD16", "(", ")", ")", "{", "assert", "(", "ARM", "::", "D31", "==", "ARM", "::", "D16", "+", "15", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "16", ";", "++", "i", ")", "Reserved", ".", "set", "(", "ARM", "::", "D16", "+", "i", ")", ";", "}", "const", "TargetRegisterClass", "*", "RC", "=", "&", "ARM", "::", "GPRPairRegClass", ";", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "RC", "->", "begin", "(", ")", ",", "E", "=", "RC", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "for", "(", "MCSubRegIterator", "SI", "(", "*", "I", ",", "this", ")", ";", "SI", ".", "isValid", "(", ")", ";", "++", "SI", ")", "if", "(", "Reserved", ".", "test", "(", "*", "SI", ")", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "return", "Reserved", ";", "}", "</s>" ]
[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]
[ "ARM", "ARM", "ARM::SP", "ARM::PC", "ARM::FPSCR", "ARM::R9", "ARM::D31", "ARM::D16", "15", "0", "16", "ARM::D16", "ARM::GPRPairRegClass" ]
ARMBaseRegisterInfo21
getReservedRegs
ARM
CPU
LLVM
18,398
244
1
[]
[ "<s>", "void", "alpha_set_memflags", "(", "rtx", "insn", ",", "rtx", "ref", ")", "{", "rtx", "*", "base_ptr", ";", "if", "(", "GET_CODE", "(", "ref", ")", "!=", "MEM", ")", "return", ";", "if", "(", "!", "MEM_VOLATILE_P", "(", "ref", ")", "&&", "!", "MEM_IN_STRUCT_P", "(", "ref", ")", "&&", "!", "MEM_SCALAR_P", "(", "ref", ")", "&&", "!", "MEM_NOTRAP_P", "(", "ref", ")", "&&", "!", "MEM_READONLY_P", "(", "ref", ")", ")", "return", ";", "if", "(", "INSN_P", "(", "insn", ")", ")", "base_ptr", "=", "&", "PATTERN", "(", "insn", ")", ";", "else", "base_ptr", "=", "&", "insn", ";", "for_each_rtx", "(", "base_ptr", ",", "alpha_set_memflags_1", ",", "(", "void", "*", ")", "ref", ")", ";", "}", "</s>" ]
[ "Given", "INSN", ",", "which", "is", "an", "INSN", "list", "or", "the", "PATTERN", "of", "a", "single", "insn", "generated", "to", "perform", "a", "memory", "operation", ",", "look", "for", "any", "MEMs", "in", "either", "a", "SET_DEST", "or", "a", "SET_SRC", "and", "copy", "the", "in-struct", ",", "unchanging", ",", "and", "volatile", "flags", "from", "REF", "into", "each", "of", "the", "MEMs", "found", ".", "If", "REF", "is", "not", "a", "MEM", ",", "do", "n't", "do", "anything", "." ]
[ "alpha" ]
alpha3
alpha_set_memflags
alpha
MPU
GCC
18,399
94
1
[]