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>", "static", "void", "pop", "(", "int", "rn", ")", "{", "rtx", "x", ",", "sp_reg", ",", "reg", ";", "if", "(", "rn", "==", "FPUL_REG", ")", "x", "=", "gen_pop_fpul", "(", ")", ";", "else", "if", "(", "rn", "==", "FPSCR_REG", ")", "x", "=", "gen_pop_fpscr", "(", ")", ";", "else", "if", "(", "(", "TARGET_SH4", "||", "TARGET_SH2A_DOUBLE", ")", "&&", "TARGET_FMOVD", "&&", "!", "TARGET_FPU_SINGLE", "&&", "FP_OR_XD_REGISTER_P", "(", "rn", ")", ")", "{", "if", "(", "FP_REGISTER_P", "(", "rn", ")", "&&", "(", "rn", "-", "FIRST_FP_REG", ")", "&", "1", ")", "return", ";", "x", "=", "gen_pop_4", "(", "gen_rtx_REG", "(", "DFmode", ",", "rn", ")", ")", ";", "}", "else", "if", "(", "TARGET_SH2E", "&&", "FP_REGISTER_P", "(", "rn", ")", ")", "x", "=", "gen_pop_e", "(", "gen_rtx_REG", "(", "SFmode", ",", "rn", ")", ")", ";", "else", "x", "=", "gen_pop", "(", "gen_rtx_REG", "(", "SImode", ",", "rn", ")", ")", ";", "x", "=", "emit_insn", "(", "x", ")", ";", "sp_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "STACK_POINTER_REGNUM", ")", ";", "reg", "=", "copy_rtx", "(", "GET_CODE", "(", "PATTERN", "(", "x", ")", ")", "==", "PARALLEL", "?", "SET_DEST", "(", "XVECEXP", "(", "PATTERN", "(", "x", ")", ",", "0", ",", "0", ")", ")", ":", "SET_DEST", "(", "PATTERN", "(", "x", ")", ")", ")", ";", "add_reg_note", "(", "x", ",", "REG_CFA_RESTORE", ",", "reg", ")", ";", "add_reg_note", "(", "x", ",", "REG_CFA_ADJUST_CFA", ",", "gen_rtx_SET", "(", "SImode", ",", "sp_reg", ",", "plus_constant", "(", "SImode", ",", "sp_reg", ",", "GET_MODE_SIZE", "(", "GET_MODE", "(", "reg", ")", ")", ")", ")", ")", ";", "add_reg_note", "(", "x", ",", "REG_INC", ",", "gen_rtx_REG", "(", "SImode", ",", "STACK_POINTER_REGNUM", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "x", ")", "=", "1", ";", "}", "</s>" ]
[ "Output", "RTL", "to", "pop", "register", "RN", "from", "the", "stack", "." ]
[ "sh", "1", "0", "0", "1" ]
sh4
pop
sh
CPU
GCC
19,000
239
1
[]
[ "<s>", "static", "void", "c6x_asm_init_sections", "(", "void", ")", "{", "exception_section", "=", "get_unnamed_section", "(", "0", ",", "output_section_asm_op", ",", "\"\\t.handlerdata\"", ")", ";", "}", "</s>" ]
[ "Use", "a", "special", "assembly", "directive", "rather", "than", "a", "regular", "setion", "for", "unwind", "table", "data", "." ]
[ "c6x", "0", "\"\\t.handlerdata\"" ]
c6x
c6x_asm_init_sections
c6x
VLIW
GCC
19,001
19
1
[]
[ "<s>", "bool", "HexagonInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "SrcReg2", ",", "int", "&", "Mask", ",", "int", "&", "Value", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "C2_cmpeq", ":", "case", "Hexagon", "::", "C2_cmpeqp", ":", "case", "Hexagon", "::", "C2_cmpgt", ":", "case", "Hexagon", "::", "C2_cmpgtp", ":", "case", "Hexagon", "::", "C2_cmpgtu", ":", "case", "Hexagon", "::", "C2_cmpgtup", ":", "case", "Hexagon", "::", "C4_cmpneq", ":", "case", "Hexagon", "::", "C4_cmplte", ":", "case", "Hexagon", "::", "C4_cmplteu", ":", "case", "Hexagon", "::", "C2_cmpeqi", ":", "case", "Hexagon", "::", "C2_cmpgti", ":", "case", "Hexagon", "::", "C2_cmpgtui", ":", "case", "Hexagon", "::", "C4_cmpneqi", ":", "case", "Hexagon", "::", "C4_cmplteui", ":", "case", "Hexagon", "::", "C4_cmpltei", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "~", "0", ";", "break", ";", "case", "Hexagon", "::", "A4_cmpbeq", ":", "case", "Hexagon", "::", "A4_cmpbgt", ":", "case", "Hexagon", "::", "A4_cmpbgtu", ":", "case", "Hexagon", "::", "A4_cmpbeqi", ":", "case", "Hexagon", "::", "A4_cmpbgti", ":", "case", "Hexagon", "::", "A4_cmpbgtui", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "0xFF", ";", "break", ";", "case", "Hexagon", "::", "A4_cmpheq", ":", "case", "Hexagon", "::", "A4_cmphgt", ":", "case", "Hexagon", "::", "A4_cmphgtu", ":", "case", "Hexagon", "::", "A4_cmpheqi", ":", "case", "Hexagon", "::", "A4_cmphgti", ":", "case", "Hexagon", "::", "A4_cmphgtui", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "0xFFFF", ";", "break", ";", "}", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "C2_cmpeq", ":", "case", "Hexagon", "::", "C2_cmpeqp", ":", "case", "Hexagon", "::", "C2_cmpgt", ":", "case", "Hexagon", "::", "C2_cmpgtp", ":", "case", "Hexagon", "::", "C2_cmpgtu", ":", "case", "Hexagon", "::", "C2_cmpgtup", ":", "case", "Hexagon", "::", "A4_cmpbeq", ":", "case", "Hexagon", "::", "A4_cmpbgt", ":", "case", "Hexagon", "::", "A4_cmpbgtu", ":", "case", "Hexagon", "::", "A4_cmpheq", ":", "case", "Hexagon", "::", "A4_cmphgt", ":", "case", "Hexagon", "::", "A4_cmphgtu", ":", "case", "Hexagon", "::", "C4_cmpneq", ":", "case", "Hexagon", "::", "C4_cmplte", ":", "case", "Hexagon", "::", "C4_cmplteu", ":", "SrcReg2", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "return", "true", ";", "case", "Hexagon", "::", "C2_cmpeqi", ":", "case", "Hexagon", "::", "C2_cmpgtui", ":", "case", "Hexagon", "::", "C2_cmpgti", ":", "case", "Hexagon", "::", "C4_cmpneqi", ":", "case", "Hexagon", "::", "C4_cmplteui", ":", "case", "Hexagon", "::", "C4_cmpltei", ":", "case", "Hexagon", "::", "A4_cmpbeqi", ":", "case", "Hexagon", "::", "A4_cmpbgti", ":", "case", "Hexagon", "::", "A4_cmpbgtui", ":", "case", "Hexagon", "::", "A4_cmpheqi", ":", "case", "Hexagon", "::", "A4_cmphgti", ":", "case", "Hexagon", "::", "A4_cmphgtui", ":", "{", "SrcReg2", "=", "0", ";", "const", "MachineOperand", "&", "Op2", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "if", "(", "!", "Op2", ".", "isImm", "(", ")", ")", "return", "false", ";", "Value", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "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", "." ]
[ "Hexagon", "Hexagon", "Hexagon::C2_cmpeq", "Hexagon::C2_cmpeqp", "Hexagon::C2_cmpgt", "Hexagon::C2_cmpgtp", "Hexagon::C2_cmpgtu", "Hexagon::C2_cmpgtup", "Hexagon::C4_cmpneq", "Hexagon::C4_cmplte", "Hexagon::C4_cmplteu", "Hexagon::C2_cmpeqi", "Hexagon::C2_cmpgti", "Hexagon::C2_cmpgtui", "Hexagon::C4_cmpneqi", "Hexagon::C4_cmplteui", "Hexagon::C4_cmpltei", "1", "0", "Hexagon::A4_cmpbeq", "Hexagon::A4_cmpbgt", "Hexagon::A4_cmpbgtu", "Hexagon::A4_cmpbeqi", "Hexagon::A4_cmpbgti", "Hexagon::A4_cmpbgtui", "1", "0xFF", "Hexagon::A4_cmpheq", "Hexagon::A4_cmphgt", "Hexagon::A4_cmphgtu", "Hexagon::A4_cmpheqi", "Hexagon::A4_cmphgti", "Hexagon::A4_cmphgtui", "1", "0xFFFF", "Hexagon::C2_cmpeq", "Hexagon::C2_cmpeqp", "Hexagon::C2_cmpgt", "Hexagon::C2_cmpgtp", "Hexagon::C2_cmpgtu", "Hexagon::C2_cmpgtup", "Hexagon::A4_cmpbeq", "Hexagon::A4_cmpbgt", "Hexagon::A4_cmpbgtu", "Hexagon::A4_cmpheq", "Hexagon::A4_cmphgt", "Hexagon::A4_cmphgtu", "Hexagon::C4_cmpneq", "Hexagon::C4_cmplte", "Hexagon::C4_cmplteu", "2", "Hexagon::C2_cmpeqi", "Hexagon::C2_cmpgtui", "Hexagon::C2_cmpgti", "Hexagon::C4_cmpneqi", "Hexagon::C4_cmplteui", "Hexagon::C4_cmpltei", "Hexagon::A4_cmpbeqi", "Hexagon::A4_cmpbgti", "Hexagon::A4_cmpbgtui", "Hexagon::A4_cmpheqi", "Hexagon::A4_cmphgti", "Hexagon::A4_cmphgtui", "0", "2", "2" ]
HexagonInstrInfo (2)2
analyzeCompare
Hexagon
DSP
LLVM
19,002
443
1
[]
[ "<s>", "virtual", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineLoopInfo", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]
[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]
[ "Hexagon" ]
HexagonHardwareLoops11
getAnalysisUsage
Hexagon
DSP
LLVM
19,003
36
1
[]
[ "<s>", "const", "char", "*", "nios2_fpu_insn_asm", "(", "enum", "n2fpu_code", "code", ")", "{", "static", "char", "buf", "[", "256", "]", ";", "const", "char", "*", "op1", ",", "*", "op2", ",", "*", "op3", ";", "int", "ln", "=", "256", ",", "n", "=", "0", ";", "int", "N", "=", "N2FPU_N", "(", "code", ")", ";", "int", "num_operands", "=", "N2FPU", "(", "code", ")", ".", "num_operands", ";", "const", "char", "*", "insn_name", "=", "N2FPU_NAME", "(", "code", ")", ";", "tree", "ftype", "=", "nios2_ftype", "(", "N2FPU_FTCODE", "(", "code", ")", ")", ";", "machine_mode", "dst_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "ftype", ")", ")", ";", "machine_mode", "src_mode", "=", "TYPE_MODE", "(", "TREE_VALUE", "(", "TYPE_ARG_TYPES", "(", "ftype", ")", ")", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "src_mode", ")", "==", "8", "&&", "num_operands", "==", "3", ")", "n", "=", "snprintf", "(", "buf", ",", "ln", ",", "\"custom\\t%d, zero, %%1, %%D1 # fwrx %%1\\n\\t\"", ",", "N2FPU_N", "(", "n2fpu_fwrx", ")", ")", ";", "if", "(", "src_mode", "==", "SFmode", ")", "{", "if", "(", "dst_mode", "==", "VOIDmode", ")", "{", "op1", "=", "op3", "=", "\"zero\"", ";", "op2", "=", "\"%0\"", ";", "num_operands", "-=", "1", ";", "}", "else", "{", "op1", "=", "(", "dst_mode", "==", "DFmode", "?", "\"%D0\"", ":", "\"%0\"", ")", ";", "op2", "=", "\"%1\"", ";", "op3", "=", "(", "num_operands", "==", "2", "?", "\"zero\"", ":", "\"%2\"", ")", ";", "}", "}", "else", "if", "(", "src_mode", "==", "DFmode", ")", "{", "if", "(", "dst_mode", "==", "VOIDmode", ")", "{", "op1", "=", "\"zero\"", ";", "op2", "=", "\"%0\"", ";", "op3", "=", "\"%D0\"", ";", "num_operands", "-=", "1", ";", "}", "else", "{", "op1", "=", "(", "dst_mode", "==", "DFmode", "?", "\"%D0\"", ":", "\"%0\"", ")", ";", "op2", "=", "(", "num_operands", "==", "2", "?", "\"%1\"", ":", "\"%2\"", ")", ";", "op3", "=", "(", "num_operands", "==", "2", "?", "\"%D1\"", ":", "\"%D2\"", ")", ";", "}", "}", "else", "if", "(", "src_mode", "==", "VOIDmode", ")", "{", "gcc_assert", "(", "dst_mode", "==", "SFmode", ")", ";", "op1", "=", "\"%0\"", ";", "op2", "=", "op3", "=", "\"zero\"", ";", "}", "else", "if", "(", "src_mode", "==", "SImode", ")", "{", "gcc_assert", "(", "num_operands", "==", "2", ")", ";", "op1", "=", "(", "dst_mode", "==", "DFmode", "?", "\"%D0\"", ":", "\"%0\"", ")", ";", "op2", "=", "\"%1\"", ";", "op3", "=", "\"zero\"", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "n", "+=", "snprintf", "(", "buf", "+", "n", ",", "ln", "-", "n", ",", "\"custom\\t%d, %s, %s, %s # %s %%0%s%s\"", ",", "N", ",", "op1", ",", "op2", ",", "op3", ",", "insn_name", ",", "(", "num_operands", ">=", "2", "?", "\", %1\"", ":", "\"\"", ")", ",", "(", "num_operands", "==", "3", "?", "\", %2\"", ":", "\"\"", ")", ")", ";", "if", "(", "dst_mode", "==", "DFmode", ")", "snprintf", "(", "buf", "+", "n", ",", "ln", "-", "n", ",", "\"\\n\\tcustom\\t%d, %%0, zero, zero # frdy %%0\"", ",", "N2FPU_N", "(", "n2fpu_frdy", ")", ")", ";", "return", "buf", ";", "}", "</s>" ]
[ "Emit", "assembly", "of", "custom", "FPU", "instructions", "." ]
[ "nios2", "256", "256", "0", "8", "3", "\"custom\\t%d, zero, %%1, %%D1 # fwrx %%1\\n\\t\"", "\"zero\"", "\"%0\"", "1", "\"%D0\"", "\"%0\"", "\"%1\"", "2", "\"zero\"", "\"%2\"", "\"zero\"", "\"%0\"", "\"%D0\"", "1", "\"%D0\"", "\"%0\"", "2", "\"%1\"", "\"%2\"", "2", "\"%D1\"", "\"%D2\"", "\"%0\"", "\"zero\"", "2", "\"%D0\"", "\"%0\"", "\"%1\"", "\"zero\"", "\"custom\\t%d, %s, %s, %s # %s %%0%s%s\"", "2", "\", %1\"", "\"\"", "3", "\", %2\"", "\"\"", "\"\\n\\tcustom\\t%d, %%0, zero, zero # frdy %%0\"" ]
nios2
nios2_fpu_insn_asm
nios2
MPU
GCC
19,004
403
1
[]
[ "<s>", "ARMSubtarget", "::", "ARMSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ")", ":", "ARMGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ARMProcFamily", "(", "Others", ")", ",", "HasV4TOps", "(", "false", ")", ",", "HasV5TOps", "(", "false", ")", ",", "HasV5TEOps", "(", "false", ")", ",", "HasV6Ops", "(", "false", ")", ",", "HasV6T2Ops", "(", "false", ")", ",", "HasV7Ops", "(", "false", ")", ",", "HasVFPv2", "(", "false", ")", ",", "HasVFPv3", "(", "false", ")", ",", "HasVFPv4", "(", "false", ")", ",", "HasNEON", "(", "false", ")", ",", "UseNEONForSinglePrecisionFP", "(", "false", ")", ",", "SlowFPVMLx", "(", "false", ")", ",", "HasVMLxForwarding", "(", "false", ")", ",", "SlowFPBrcc", "(", "false", ")", ",", "InThumbMode", "(", "false", ")", ",", "HasThumb2", "(", "false", ")", ",", "IsMClass", "(", "false", ")", ",", "NoARM", "(", "false", ")", ",", "PostRAScheduler", "(", "false", ")", ",", "IsR9Reserved", "(", "ReserveR9", ")", ",", "UseMovt", "(", "false", ")", ",", "SupportsTailCall", "(", "false", ")", ",", "HasFP16", "(", "false", ")", ",", "HasD16", "(", "false", ")", ",", "HasHardwareDivide", "(", "false", ")", ",", "HasT2ExtractPack", "(", "false", ")", ",", "HasDataBarrier", "(", "false", ")", ",", "Pref32BitThumb", "(", "false", ")", ",", "AvoidCPSRPartialUpdate", "(", "false", ")", ",", "HasRAS", "(", "false", ")", ",", "HasMPExtension", "(", "false", ")", ",", "FPOnlySP", "(", "false", ")", ",", "AllowsUnalignedMem", "(", "false", ")", ",", "Thumb2DSP", "(", "false", ")", ",", "stackAlignment", "(", "4", ")", ",", "CPUString", "(", "CPU", ")", ",", "TargetTriple", "(", "TT", ")", ",", "TargetABI", "(", "ARM_ABI_APCS", ")", "{", "if", "(", "CPUString", ".", "empty", "(", ")", ")", "CPUString", "=", "\"generic\"", ";", "std", "::", "string", "ArchFS", "=", "ARM_MC", "::", "ParseARMTriple", "(", "TT", ",", "CPUString", ")", ";", "if", "(", "!", "FS", ".", "empty", "(", ")", ")", "{", "if", "(", "!", "ArchFS", ".", "empty", "(", ")", ")", "ArchFS", "=", "ArchFS", "+", "\",\"", "+", "FS", ";", "else", "ArchFS", "=", "FS", ";", "}", "ParseSubtargetFeatures", "(", "CPUString", ",", "ArchFS", ")", ";", "if", "(", "!", "HasV6T2Ops", "&&", "hasThumb2", "(", ")", ")", "HasV4TOps", "=", "HasV5TOps", "=", "HasV5TEOps", "=", "HasV6Ops", "=", "HasV6T2Ops", "=", "true", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUString", ")", ";", "if", "(", "(", "TT", ".", "find", "(", "\"eabi\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "||", "(", "isTargetIOS", "(", ")", "&&", "isMClass", "(", ")", ")", ")", "TargetABI", "=", "ARM_ABI_AAPCS", ";", "if", "(", "isAAPCS_ABI", "(", ")", ")", "stackAlignment", "=", "8", ";", "if", "(", "!", "isTargetIOS", "(", ")", ")", "UseMovt", "=", "hasV6T2Ops", "(", ")", ";", "else", "{", "IsR9Reserved", "=", "ReserveR9", "|", "!", "HasV6Ops", ";", "UseMovt", "=", "DarwinUseMOVT", "&&", "hasV6T2Ops", "(", ")", ";", "SupportsTailCall", "=", "!", "getTargetTriple", "(", ")", ".", "isOSVersionLT", "(", "5", ",", "0", ")", ";", "}", "if", "(", "!", "isThumb", "(", ")", "||", "hasThumb2", "(", ")", ")", "PostRAScheduler", "=", "true", ";", "if", "(", "!", "StrictAlign", "&&", "hasV6Ops", "(", ")", "&&", "isTargetDarwin", "(", ")", ")", "AllowsUnalignedMem", "=", "true", ";", "}", "</s>" ]
[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]
[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "4", "ARM", "\"generic\"", "ARM", "ARM", "\",\"", "\"eabi\"", "ARM", "8", "5", "0" ]
ARMSubtarget29
ARMSubtarget
ARM
CPU
LLVM
19,005
443
1
[]
[ "<s>", "const", "char", "*", "MBlazeTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "MBlazeISD", "::", "JmpLink", ":", "return", "\"MBlazeISD::JmpLink\"", ";", "case", "MBlazeISD", "::", "GPRel", ":", "return", "\"MBlazeISD::GPRel\"", ";", "case", "MBlazeISD", "::", "Wrap", ":", "return", "\"MBlazeISD::Wrap\"", ";", "case", "MBlazeISD", "::", "ICmp", ":", "return", "\"MBlazeISD::ICmp\"", ";", "case", "MBlazeISD", "::", "Ret", ":", "return", "\"MBlazeISD::Ret\"", ";", "case", "MBlazeISD", "::", "Select_CC", ":", "return", "\"MBlazeISD::Select_CC\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]
[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]
[ "MBlaze", "MBlaze", "MBlazeISD::JmpLink", "\"MBlazeISD::JmpLink\"", "MBlazeISD::GPRel", "\"MBlazeISD::GPRel\"", "MBlazeISD::Wrap", "\"MBlazeISD::Wrap\"", "MBlazeISD::ICmp", "\"MBlazeISD::ICmp\"", "MBlazeISD::Ret", "\"MBlazeISD::Ret\"", "MBlazeISD::Select_CC", "\"MBlazeISD::Select_CC\"" ]
MBlazeISelLowering
getTargetNodeName
MBlaze
MPU
LLVM
19,006
72
1
[]
[ "<s>", "void", "AArch64ConditionalCompares", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineLoopInfo", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineLoopInfo", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineTraceMetrics", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineTraceMetrics", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]
[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]
[ "AArch64", "AArch64" ]
AArch64ConditionalCompares (2)
getAnalysisUsage
AArch64
CPU
LLVM
19,007
82
1
[]
[ "<s>", "void", "SPIRVMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "auto", "Features", "=", "computeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ";", "verifyInstructionPredicates", "(", "MI", ",", "Features", ")", ";", "EndianWriter", "OSE", "(", "OS", ",", "support", "::", "little", ")", ";", "const", "uint64_t", "OpCode", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "const", "uint32_t", "NumWords", "=", "MI", ".", "getNumOperands", "(", ")", "+", "1", ";", "const", "uint32_t", "FirstWord", "=", "(", "NumWords", "<<", "16", ")", "|", "OpCode", ";", "OSE", ".", "write", "<", "uint32_t", ">", "(", "FirstWord", ")", ";", "if", "(", "hasType", "(", "MI", ",", "MCII", ")", ")", "emitTypedInstrOperands", "(", "MI", ",", "OSE", ")", ";", "else", "emitUntypedInstrOperands", "(", "MI", ",", "OSE", ")", ";", "}", "</s>" ]
[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]
[ "SPIRV", "SPIRV", "support::little", "1", "16" ]
SPIRVMCCodeEmitter
encodeInstruction
SPIRV
Virtual ISA
LLVM
19,008
129
1
[]
[ "<s>", "void", "aarch64_split_atomic_op", "(", "enum", "rtx_code", "code", ",", "rtx", "old_out", ",", "rtx", "new_out", ",", "rtx", "mem", ",", "rtx", "value", ",", "rtx", "model_rtx", ",", "rtx", "cond", ")", "{", "gcc_assert", "(", "epilogue_completed", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "machine_mode", "wmode", "=", "(", "mode", "==", "DImode", "?", "DImode", ":", "SImode", ")", ";", "const", "enum", "memmodel", "model", "=", "memmodel_from_int", "(", "INTVAL", "(", "model_rtx", ")", ")", ";", "const", "bool", "is_sync", "=", "is_mm_sync", "(", "model", ")", ";", "rtx_code_label", "*", "label", ";", "rtx", "x", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "if", "(", "new_out", ")", "new_out", "=", "gen_lowpart", "(", "wmode", ",", "new_out", ")", ";", "if", "(", "old_out", ")", "old_out", "=", "gen_lowpart", "(", "wmode", ",", "old_out", ")", ";", "else", "old_out", "=", "new_out", ";", "value", "=", "simplify_gen_subreg", "(", "wmode", ",", "value", ",", "mode", ",", "0", ")", ";", "if", "(", "is_sync", ")", "aarch64_emit_load_exclusive", "(", "mode", ",", "old_out", ",", "mem", ",", "GEN_INT", "(", "MEMMODEL_RELAXED", ")", ")", ";", "else", "aarch64_emit_load_exclusive", "(", "mode", ",", "old_out", ",", "mem", ",", "model_rtx", ")", ";", "switch", "(", "code", ")", "{", "case", "SET", ":", "new_out", "=", "value", ";", "break", ";", "case", "NOT", ":", "x", "=", "gen_rtx_AND", "(", "wmode", ",", "old_out", ",", "value", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "new_out", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_NOT", "(", "wmode", ",", "new_out", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "new_out", ",", "x", ")", ")", ";", "break", ";", "case", "MINUS", ":", "if", "(", "CONST_INT_P", "(", "value", ")", ")", "{", "value", "=", "GEN_INT", "(", "-", "INTVAL", "(", "value", ")", ")", ";", "code", "=", "PLUS", ";", "}", "default", ":", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "wmode", ",", "old_out", ",", "value", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "new_out", ",", "x", ")", ")", ";", "break", ";", "}", "aarch64_emit_store_exclusive", "(", "mode", ",", "cond", ",", "mem", ",", "gen_lowpart", "(", "mode", ",", "new_out", ")", ",", "model_rtx", ")", ";", "if", "(", "aarch64_track_speculation", ")", "{", "rtx", "cc_reg", "=", "aarch64_gen_compare_reg", "(", "NE", ",", "cond", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_NE", "(", "GET_MODE", "(", "cc_reg", ")", ",", "cc_reg", ",", "const0_rtx", ")", ";", "}", "else", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label", ")", ",", "pc_rtx", ")", ";", "aarch64_emit_unlikely_jump", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "if", "(", "is_sync", ")", "aarch64_emit_post_barrier", "(", "model", ")", ";", "}", "</s>" ]
[ "Split", "an", "atomic", "operation", "." ]
[ "aarch64", "0" ]
aarch64
aarch64_split_atomic_op
aarch64
CPU
GCC
19,009
380
1
[]
[ "<s>", "Register", "getGlobalBaseReg", "(", ")", "const", "{", "return", "GlobalBaseReg", ";", "}", "</s>" ]
[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]
[ "CSKY" ]
CSKYMachineFunctionInfo
getGlobalBaseReg
CSKY
CPU
LLVM
19,010
10
1
[]
[ "<s>", "const", "TargetRegisterClass", "*", "SystemZRegisterInfo", "::", "getCrossCopyRegClass", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "if", "(", "RC", "==", "&", "SystemZ", "::", "CCRRegClass", ")", "return", "&", "SystemZ", "::", "GR32BitRegClass", ";", "return", "RC", ";", "}", "</s>" ]
[ "getCrossCopyRegClass", "-", "Returns", "a", "legal", "register", "class", "to", "copy", "a", "register", "in", "the", "specified", "class", "to", "or", "from", "." ]
[ "SystemZ", "SystemZ", "SystemZ::CCRRegClass", "SystemZ::GR32BitRegClass" ]
SystemZRegisterInfo10
getCrossCopyRegClass
SystemZ
CPU
LLVM
19,011
33
1
[]
[ "<s>", "bool", "AMDGPUPassConfig", "::", "addPreISel", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "addPass", "(", "createFlattenCFGPass", "(", ")", ")", ";", "if", "(", "ST", ".", "IsIRStructurizerEnabled", "(", ")", "||", "ST", ".", "getGeneration", "(", ")", ">", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "addPass", "(", "createStructurizeCFGPass", "(", ")", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", ">", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "addPass", "(", "createSinkingPass", "(", ")", ")", ";", "addPass", "(", "createSITypeRewriter", "(", ")", ")", ";", "addPass", "(", "createSIAnnotateControlFlowPass", "(", ")", ")", ";", "}", "else", "{", "addPass", "(", "createR600TextureIntrinsicsReplacer", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]
[ "{", "{", "@", "For", "GlobalISel" ]
[ "R600", "SI", "SI" ]
AMDGPUTargetMachine76
addPreISel
R600
GPU
LLVM
19,012
102
1
[]
[ "<s>", "DFAPacketizer", "*", "Tile64InstrInfo", "::", "CreateTargetScheduleState", "(", "const", "TargetMachine", "*", "TM", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "const", "InstrItineraryData", "*", "II", "=", "TM", "->", "getInstrItineraryData", "(", ")", ";", "return", "TM", "->", "getSubtarget", "<", "Tile64GenSubtargetInfo", ">", "(", ")", ".", "createDFAPacketizer", "(", "II", ")", ";", "}", "</s>" ]
[ "Create", "machine", "specific", "model", "for", "scheduling", "." ]
[ "Tile64" ]
Tile64InstrInfo
CreateTargetScheduleState
Tile64
VLIW
LLVM
19,013
45
1
[]
[ "<s>", "bool", "NyuziAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"unexpected inline asm memory operand\"", ")", ";", "O", "<<", "\"(\"", "<<", "NyuziInstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "\")\"", ";", "return", "false", ";", "}", "</s>" ]
[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]
[ "Nyuzi", "Nyuzi", "\"unexpected inline asm memory operand\"", "\"(\"", "Nyuzi", "\")\"" ]
NyuziAsmPrinter
PrintAsmMemoryOperand
Nyuzi
GPU
LLVM
19,014
70
1
[]
[ "<s>", "bool", "HexagonInstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "if", "(", "Cond", ".", "empty", "(", ")", "||", "isEndLoopN", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nCannot predicate:\"", ";", "MI", "->", "dump", "(", ")", ";", ")", ";", "return", "false", ";", "}", "int", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "assert", "(", "isPredicable", "(", "MI", ")", "&&", "\"Expected predicable instruction\"", ")", ";", "bool", "invertJump", "=", "predOpcodeHasNot", "(", "Cond", ")", ";", "MachineBasicBlock", "&", "B", "=", "*", "MI", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "PredOpc", "=", "getCondOpcode", "(", "Opc", ",", "invertJump", ")", ";", "MachineInstrBuilder", "T", "=", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "get", "(", "PredOpc", ")", ")", ";", "unsigned", "NOp", "=", "0", ",", "NumOps", "=", "MI", "->", "getNumOperands", "(", ")", ";", "while", "(", "NOp", "<", "NumOps", ")", "{", "MachineOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "NOp", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", "||", "!", "Op", ".", "isDef", "(", ")", "||", "Op", ".", "isImplicit", "(", ")", ")", "break", ";", "T", ".", "addOperand", "(", "Op", ")", ";", "NOp", "++", ";", "}", "unsigned", "PredReg", ",", "PredRegPos", ",", "PredRegFlags", ";", "bool", "GotPredReg", "=", "getPredReg", "(", "Cond", ",", "PredReg", ",", "PredRegPos", ",", "PredRegFlags", ")", ";", "(", "void", ")", "GotPredReg", ";", "assert", "(", "GotPredReg", ")", ";", "T", ".", "addReg", "(", "PredReg", ",", "PredRegFlags", ")", ";", "while", "(", "NOp", "<", "NumOps", ")", "T", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "NOp", "++", ")", ")", ";", "MI", "->", "setDesc", "(", "get", "(", "PredOpc", ")", ")", ";", "while", "(", "unsigned", "n", "=", "MI", "->", "getNumOperands", "(", ")", ")", "MI", "->", "RemoveOperand", "(", "n", "-", "1", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "n", "=", "T", "->", "getNumOperands", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "MI", "->", "addOperand", "(", "T", "->", "getOperand", "(", "i", ")", ")", ";", "MachineBasicBlock", "::", "instr_iterator", "TI", "=", "&", "*", "T", ";", "B", ".", "erase", "(", "TI", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "B", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "clearKillFlags", "(", "PredReg", ")", ";", "return", "true", ";", "}", "</s>" ]
[ "Convert", "the", "instruction", "into", "a", "predicated", "instruction", "." ]
[ "Hexagon", "Hexagon", "0", "\"\\nCannot predicate:\"", "\"Expected predicable instruction\"", "0", "1", "0" ]
HexagonInstrInfo64
PredicateInstruction
Hexagon
DSP
LLVM
19,015
364
1
[]
[ "<s>", "const", "SparcSubtarget", "*", "SparcTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "bool", "softFloat", "=", "F", ".", "hasFnAttribute", "(", "\"use-soft-float\"", ")", "&&", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ";", "if", "(", "softFloat", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\",+soft-float\"", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "SparcSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "this", "->", "is64Bit", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]
[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]
[ "Sparc", "Sparc", "Sparc", "\"target-cpu\"", "\"target-features\"", "\"use-soft-float\"", "\"use-soft-float\"", "\"true\"", "\"+soft-float\"", "\",+soft-float\"", "Sparc" ]
SparcTargetMachine16
getSubtargetImpl
Sparc
CPU
LLVM
19,016
181
1
[]
[ "<s>", "bool", "X86InsertPrefetch", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "if", "(", "Filename", ".", "empty", "(", ")", ")", "return", "false", ";", "LLVMContext", "&", "Ctx", "=", "M", ".", "getContext", "(", ")", ";", "ErrorOr", "<", "std", "::", "unique_ptr", "<", "SampleProfileReader", ">>", "ReaderOrErr", "=", "SampleProfileReader", "::", "create", "(", "Filename", ",", "Ctx", ")", ";", "if", "(", "std", "::", "error_code", "EC", "=", "ReaderOrErr", ".", "getError", "(", ")", ")", "{", "std", "::", "string", "Msg", "=", "\"Could not open profile: \"", "+", "EC", ".", "message", "(", ")", ";", "Ctx", ".", "diagnose", "(", "DiagnosticInfoSampleProfile", "(", "Filename", ",", "Msg", ",", "DiagnosticSeverity", "::", "DS_Warning", ")", ")", ";", "return", "false", ";", "}", "Reader", "=", "std", "::", "move", "(", "ReaderOrErr", ".", "get", "(", ")", ")", ";", "Reader", "->", "read", "(", ")", ";", "return", "true", ";", "}", "</s>" ]
[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]
[ "X86", "X86", "\"Could not open profile: \"" ]
X86InsertPrefetch (2)
doInitialization
X86
CPU
LLVM
19,017
120
1
[]
[ "<s>", "MachineBasicBlock", "::", "iterator", "X86InstrInfo", "::", "insertOutlinedCall", "(", "Module", "&", "M", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "It", ",", "MachineFunction", "&", "MF", ",", "const", "outliner", "::", "Candidate", "&", "C", ")", "const", "{", "if", "(", "C", ".", "CallConstructionID", "==", "MachineOutlinerTailCall", ")", "{", "It", "=", "MBB", ".", "insert", "(", "It", ",", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "X86", "::", "TAILJMPd64", ")", ")", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ")", ")", ";", "}", "else", "{", "It", "=", "MBB", ".", "insert", "(", "It", ",", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "X86", "::", "CALL64pcrel32", ")", ")", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ")", ")", ";", "}", "return", "It", ";", "}", "</s>" ]
[ "Insert", "a", "call", "to", "an", "outlined", "function", "into", "the", "program", "." ]
[ "X86", "X86", "X86::TAILJMPd64", "X86::CALL64pcrel32" ]
X86InstrInfo (2)3
insertOutlinedCall
X86
CPU
LLVM
19,018
129
1
[]
[ "<s>", "const", "AArch64GNULDBackend", "&", "getTarget", "(", ")", "const", "{", "return", "m_Target", ";", "}", "</s>" ]
[ "getTarget", "-", "Return", "the", "target", "machine", "this", "machine", "code", "is", "compiled", "with" ]
[ "AArch64", "AArch64" ]
AArch64Relocator
getTarget
AArch64
CPU
LLVM
19,019
12
1
[]
[ "<s>", "static", "void", "core2i7_dfa_post_advance_cycle", "(", "void", ")", "{", "ix86_first_cycle_multipass_data_t", "data", "=", "ix86_first_cycle_multipass_data", ";", "gcc_assert", "(", "data", "->", "ifetch_block_n_insns", "<=", "core2i7_ifetch_block_max_insns", ")", ";", "data", "->", "ifetch_block_len", "=", "0", ";", "data", "->", "ifetch_block_n_insns", "=", "0", ";", "}", "</s>" ]
[ "Advancing", "the", "cycle", ";", "reset", "ifetch", "block", "counts", "." ]
[ "i386", "0", "0" ]
i3864
core2i7_dfa_post_advance_cycle
i386
CPU
GCC
19,020
34
1
[]
[ "<s>", "static", "std", "::", "unique_ptr", "<", "FISCOperand", ">", "CreateReg", "(", "unsigned", "RegNum", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "auto", "Op", "=", "make_unique", "<", "FISCOperand", ">", "(", "k_Register", ")", ";", "Op", "->", "Reg", ".", "RegNum", "=", "RegNum", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]
[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]
[ "FISC", "FISC", "FISC" ]
FISCAsmParser
CreateReg
FISC
CPU
LLVM
19,021
54
1
[]
[ "<s>", "SDValue", "AArch64TargetLowering", "::", "getRecipEstimate", "(", "SDValue", "Operand", ",", "SelectionDAG", "&", "DAG", ",", "int", "Enabled", ",", "int", "&", "ExtraSteps", ")", "const", "{", "if", "(", "Enabled", "==", "ReciprocalEstimate", "::", "Enabled", ")", "if", "(", "SDValue", "Estimate", "=", "getEstimate", "(", "Subtarget", ",", "AArch64ISD", "::", "FRECPE", ",", "Operand", ",", "DAG", ",", "ExtraSteps", ")", ")", "{", "SDLoc", "DL", "(", "Operand", ")", ";", "EVT", "VT", "=", "Operand", ".", "getValueType", "(", ")", ";", "SDNodeFlags", "Flags", ";", "Flags", ".", "setAllowReassociation", "(", "true", ")", ";", "for", "(", "int", "i", "=", "ExtraSteps", ";", "i", ">", "0", ";", "--", "i", ")", "{", "SDValue", "Step", "=", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "FRECPS", ",", "DL", ",", "VT", ",", "Operand", ",", "Estimate", ",", "Flags", ")", ";", "Estimate", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "DL", ",", "VT", ",", "Estimate", ",", "Step", ",", "Flags", ")", ";", "}", "ExtraSteps", "=", "0", ";", "return", "Estimate", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]
[ "Return", "a", "reciprocal", "estimate", "value", "for", "the", "input", "operand", "." ]
[ "AArch64", "AArch64", "AArch64ISD::FRECPE", "0", "AArch64ISD::FRECPS", "ISD::FMUL", "0" ]
AArch64ISelLowering (2)2
getRecipEstimate
AArch64
CPU
LLVM
19,022
148
1
[]
[ "<s>", "static", "void", "cris_operand_lossage", "(", "const", "char", "*", "msgid", ",", "rtx", "op", ")", "{", "debug_rtx", "(", "op", ")", ";", "output_operand_lossage", "(", "\"%s\"", ",", "msgid", ")", ";", "}", "</s>" ]
[ "Emit", "an", "error", "message", "when", "we", "'re", "in", "an", "asm", ",", "and", "a", "fatal", "error", "for", "``", "normal", "''", "insns", ".", "Formatted", "output", "is", "n't", "easily", "implemented", ",", "since", "we", "use", "output_operand_lossage", "to", "output", "the", "actual", "message", "and", "handle", "the", "categorization", "of", "the", "error", "." ]
[ "cris", "\"%s\"" ]
cris
cris_operand_lossage
cris
MPU
GCC
19,023
26
1
[]
[ "<s>", "SDValue", "AArch64SelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "ConstantSDNode", "*", "V", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Src", ")", ";", "ConstantSDNode", "*", "SizeValue", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ";", "const", "AArch64Subtarget", "&", "STI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "const", "char", "*", "bzeroName", "=", "(", "V", "&&", "V", "->", "isNullValue", "(", ")", ")", "?", "DAG", ".", "getTargetLoweringInfo", "(", ")", ".", "getLibcallName", "(", "RTLIB", "::", "BZERO", ")", ":", "nullptr", ";", "if", "(", "bzeroName", "&&", "(", "!", "SizeValue", "||", "SizeValue", "->", "getZExtValue", "(", ")", ">", "256", ")", ")", "{", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "STI", ".", "getTargetLowering", "(", ")", ";", "EVT", "IntPtr", "=", "TLI", ".", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "Type", "*", "IntPtrTy", "=", "DAG", ".", "getDataLayout", "(", ")", ".", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Entry", ".", "Node", "=", "Dst", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";", "CLI", ".", "setDebugLoc", "(", "dl", ")", ".", "setChain", "(", "Chain", ")", ".", "setLibCallee", "(", "CallingConv", "::", "C", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "DAG", ".", "getExternalSymbol", "(", "bzeroName", ",", "IntPtr", ")", ",", "std", "::", "move", "(", "Args", ")", ")", ".", "setDiscardResult", "(", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]
[ "Emit", "target-specific", "code", "that", "performs", "a", "memset", "." ]
[ "AArch64", "AArch64", "AArch64", "AArch64", "256", "AArch64" ]
AArch64SelectionDAGInfo
EmitTargetCodeForMemset
AArch64
CPU
LLVM
19,024
303
1
[]
[ "<s>", "virtual", "void", "print", "(", "raw_ostream", "&", "O", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "k_Token", ":", "O", "<<", "\"Token: \\\"\"", "<<", "getToken", "(", ")", "<<", "\"\\\"\"", ";", "break", ";", "case", "k_Register", ":", "O", "<<", "\"Register: \"", "<<", "getReg", "(", ")", ";", "break", ";", "case", "k_Immediate", ":", "O", "<<", "\"Immediate: \\\"\"", "<<", "*", "getImm", "(", ")", "<<", "\"\\\"\"", ";", "break", ";", "case", "k_Memri", ":", "{", "O", "<<", "\"Memri: \\\"\"", "<<", "getReg", "(", ")", "<<", "'+'", "<<", "*", "getImm", "(", ")", "<<", "\"\\\"\"", ";", "break", ";", "}", "}", "O", "<<", "\"\\n\"", ";", "}", "</s>" ]
[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]
[ "AVR", "\"Token: \\\"\"", "\"\\\"\"", "\"Register: \"", "\"Immediate: \\\"\"", "\"\\\"\"", "\"Memri: \\\"\"", "\"\\\"\"", "\"\\n\"" ]
AVRAsmParser
print
AVR
MPU
LLVM
19,025
89
1
[]
[ "<s>", "rtx", "ix86_build_const_vector", "(", "machine_mode", "mode", ",", "bool", "vect", ",", "rtx", "value", ")", "{", "int", "i", ",", "n_elt", ";", "rtvec", "v", ";", "machine_mode", "scalar_mode", ";", "switch", "(", "mode", ")", "{", "case", "V64QImode", ":", "case", "V32QImode", ":", "case", "V16QImode", ":", "case", "V32HImode", ":", "case", "V16HImode", ":", "case", "V8HImode", ":", "case", "V16SImode", ":", "case", "V8SImode", ":", "case", "V4SImode", ":", "case", "V8DImode", ":", "case", "V4DImode", ":", "case", "V2DImode", ":", "gcc_assert", "(", "vect", ")", ";", "case", "V16SFmode", ":", "case", "V8SFmode", ":", "case", "V4SFmode", ":", "case", "V8DFmode", ":", "case", "V4DFmode", ":", "case", "V2DFmode", ":", "n_elt", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "v", "=", "rtvec_alloc", "(", "n_elt", ")", ";", "scalar_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "RTVEC_ELT", "(", "v", ",", "0", ")", "=", "value", ";", "for", "(", "i", "=", "1", ";", "i", "<", "n_elt", ";", "++", "i", ")", "RTVEC_ELT", "(", "v", ",", "i", ")", "=", "vect", "?", "value", ":", "CONST0_RTX", "(", "scalar_mode", ")", ";", "return", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "v", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]
[ "A", "subroutine", "of", "ix86_build_signbit_mask", ".", "If", "VECT", "is", "true", ",", "then", "replicate", "the", "value", "for", "all", "elements", "of", "the", "vector", "register", "." ]
[ "i386", "0", "1" ]
i3864
ix86_build_const_vector
i386
CPU
GCC
19,026
163
1
[]
[ "<s>", "static", "void", "epiphany_print_operand_address", "(", "FILE", "*", "file", ",", "machine_mode", ",", "rtx", "addr", ")", "{", "rtx", "base", ",", "index", "=", "0", ";", "int", "offset", "=", "0", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fputs", "(", "reg_names", "[", "REGNO", "(", "addr", ")", "]", ",", "file", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "if", "(", "0", "&&", "SYMBOL_REF_FUNCTION_P", "(", "addr", ")", ")", "{", "output_addr_const", "(", "file", ",", "addr", ")", ";", "}", "else", "{", "output_addr_const", "(", "file", ",", "addr", ")", ";", "}", "break", ";", "case", "PLUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "CONST_INT", ")", "offset", "=", "INTVAL", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ",", "base", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "CONST_INT", ")", "offset", "=", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ",", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "else", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ",", "index", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "base", ")", "==", "REG", ")", ";", "fputs", "(", "reg_names", "[", "REGNO", "(", "base", ")", "]", ",", "file", ")", ";", "if", "(", "index", "==", "0", ")", "{", "fprintf", "(", "file", ",", "\",%s%d\"", ",", "IMMEDIATE_PREFIX", ",", "offset", "/", "current_frame_info", ".", "stld_sz", ")", ";", "}", "else", "{", "switch", "(", "GET_CODE", "(", "index", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "\",%s\"", ",", "reg_names", "[", "REGNO", "(", "index", ")", "]", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "fputc", "(", "','", ",", "file", ")", ",", "output_addr_const", "(", "file", ",", "index", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "break", ";", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "case", "POST_INC", ":", "case", "POST_DEC", ":", "case", "POST_MODIFY", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "default", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>" ]
[ "Print", "a", "memory", "address", "as", "an", "operand", "to", "reference", "that", "memory", "location", "." ]
[ "epiphany", "0", "0", "0", "0", "0", "1", "1", "1", "0", "0", "1", "0", "\",%s%d\"", "\",%s\"" ]
epiphany
epiphany_print_operand_address
epiphany
MPU
GCC
19,027
317
1
[]
[ "<s>", "bool", "PPCFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "PPCInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "PPCFunctionInfo", "*", "FI", "=", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "bool", "MustSaveTOC", "=", "FI", "->", "mustSaveTOC", "(", ")", ";", "DebugLoc", "DL", ";", "bool", "CRSpilled", "=", "false", ";", "MachineInstrBuilder", "CRMIB", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "PPC", "::", "VRSAVE", ")", "continue", ";", "bool", "IsCRField", "=", "PPC", "::", "CR2", "<=", "Reg", "&&", "Reg", "<=", "PPC", "::", "CR4", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "bool", "IsLiveIn", "=", "MRI", ".", "isLiveIn", "(", "Reg", ")", ";", "if", "(", "!", "IsLiveIn", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "CRSpilled", "&&", "IsCRField", ")", "{", "CRMIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitKill", ")", ";", "continue", ";", "}", "if", "(", "(", "Reg", "==", "PPC", "::", "X2", "||", "Reg", "==", "PPC", "::", "R2", ")", "&&", "MustSaveTOC", ")", "continue", ";", "if", "(", "IsCRField", ")", "{", "PPCFunctionInfo", "*", "FuncInfo", "=", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "is32BitELFABI", "(", ")", ")", "{", "FuncInfo", "->", "addMustSaveCR", "(", "Reg", ")", ";", "}", "else", "{", "CRSpilled", "=", "true", ";", "FuncInfo", "->", "setSpillsCR", "(", ")", ";", "CRMIB", "=", "BuildMI", "(", "*", "MF", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "MFCR", ")", ",", "PPC", "::", "R12", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitKill", ")", ";", "MBB", ".", "insert", "(", "MI", ",", "CRMIB", ")", ";", "MBB", ".", "insert", "(", "MI", ",", "addFrameReference", "(", "BuildMI", "(", "*", "MF", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "STW", ")", ")", ".", "addReg", "(", "PPC", "::", "R12", ",", "getKillRegState", "(", "true", ")", ")", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ")", ")", ";", "}", "}", "else", "{", "if", "(", "CSI", "[", "i", "]", ".", "isSpilledToReg", "(", ")", ")", "{", "NumPESpillVSR", "++", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "MTVSRD", ")", ",", "CSI", "[", "i", "]", ".", "getDstReg", "(", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "true", ")", ")", ";", "}", "else", "{", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "if", "(", "Subtarget", ".", "needsSwapsForVSXMemOps", "(", ")", "&&", "!", "MF", "->", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", ")", "TII", ".", "storeRegToStackSlotNoUpd", "(", "MBB", ",", "MI", ",", "Reg", ",", "!", "IsLiveIn", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "else", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "!", "IsLiveIn", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "}", "}", "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", "(", ")", "." ]
[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "0", "PPC::VRSAVE", "PPC::CR2", "PPC::CR4", "PPC::X2", "PPC::R2", "PPC", "PPC", "PPC::MFCR", "PPC::R12", "PPC::STW", "PPC::R12", "PPC::MTVSRD" ]
PPCFrameLowering3
spillCalleeSavedRegisters
PowerPC
CPU
LLVM
19,028
508
1
[]
[ "<s>", "MachineRegisterInfo", "&", "getRegInfo", "(", "Block", "&", "MBB", ")", "{", "return", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "}", "</s>" ]
[ "getRegInfo", "-", "Return", "information", "about", "the", "registers", "currently", "in", "use", "." ]
[ "SNES" ]
SNESExpandPseudoInsts
getRegInfo
SNES
DSP
LLVM
19,029
21
1
[]
[ "<s>", "DecodeStatus", "OR1KDisassembler", "::", "getInstruction", "(", "MCInst", "&", "instr", ",", "uint64_t", "&", "Size", ",", "const", "MemoryObject", "&", "Region", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "vStream", ",", "raw_ostream", "&", "cStream", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", "=", "readInstruction32", "(", "Region", ",", "Address", ",", "Size", ",", "Insn", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableOR1K32", ",", "instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "</s>" ]
[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]
[ "OR1K", "OR1K", "OR1K", "4" ]
OR1KDisassembler
getInstruction
OR1K
CPU
LLVM
19,030
101
1
[]
[ "<s>", "bool", "X86FrameLowering", "::", "canUseAsEpilogue", "(", "const", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "MBB", ".", "getParent", "(", ")", "&&", "\"Block is not attached to a function!\"", ")", ";", "if", "(", "MBB", ".", "getParent", "(", ")", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "isTargetWin64", "(", ")", "&&", "!", "MBB", ".", "succ_empty", "(", ")", "&&", "!", "MBB", ".", "isReturnBlock", "(", ")", ")", "return", "false", ";", "if", "(", "canUseLEAForSPInEpilogue", "(", "*", "MBB", ".", "getParent", "(", ")", ")", ")", "return", "true", ";", "return", "!", "terminatorsNeedFlagsAsInput", "(", "MBB", ")", ";", "}", "</s>" ]
[ "Check", "whether", "or", "not", "the", "given", "MBB", "can", "be", "used", "as", "a", "epilogue", "for", "the", "target", "." ]
[ "X86", "X86", "\"Block is not attached to a function!\"", "X86" ]
X86FrameLowering81
canUseAsEpilogue
X86
CPU
LLVM
19,031
82
1
[]
[ "<s>", "void", "ARMPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createThumb2SizeReductionPass", "(", ")", ")", ";", "addPass", "(", "createUnpackMachineBundles", "(", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "return", "this", "->", "TM", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ".", "isThumb2", "(", ")", ";", "}", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createARMOptimizeBarriersPass", "(", ")", ")", ";", "addPass", "(", "createARMConstantIslandPass", "(", ")", ")", ";", "}", "</s>" ]
[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]
[ "ARM", "ARM", "ARM", "ARM", "ARM" ]
ARMTargetMachine (2)1
addPreEmitPass
ARM
CPU
LLVM
19,032
74
1
[]
[ "<s>", "unsigned", "CFStack", "::", "getLoopDepth", "(", ")", "{", "return", "LoopStack", ".", "size", "(", ")", ";", "}", "</s>" ]
[ "Return", "the", "loop", "nesting", "level", "of", "the", "specified", "block", "." ]
[ "R600" ]
R600ControlFlowFinalizer
getLoopDepth
R600
GPU
LLVM
19,033
15
1
[]
[ "<s>", "ARCTargetMachine", "::", "ARCTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ")", ":", "LLVMTargetMachine", "(", "T", ",", "\"e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-\"", "\"f32:32:32-i64:32-f64:32-a:0:32-n32\"", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getRelocModel", "(", "RM", ")", ",", "getEffectiveCodeModel", "(", "CM", ",", "CodeModel", "::", "Small", ")", ",", "OL", ")", ",", "TLOF", "(", "std", "::", "make_unique", "<", "TargetLoweringObjectFileELF", ">", "(", ")", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ")", "{", "initAsmInfo", "(", ")", ";", "}", "</s>" ]
[ "ARCTargetMachine", "ctor", "-", "Create", "an", "ILP32", "architecture", "model", "." ]
[ "ARC", "ARC", "ARC", "\"e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-\"", "\"f32:32:32-i64:32-f64:32-a:0:32-n32\"" ]
ARCTargetMachine
ARCTargetMachine
ARC
MPU
LLVM
19,034
111
1
[]
[ "<s>", "int", "m32c_hard_regno_ok", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "return", "m32c_hard_regno_nregs_1", "(", "regno", ",", "mode", ")", "!=", "0", ";", "}", "</s>" ]
[ "Implements", "HARD_REGNO_MODE_OK", ".", "The", "above", "function", "does", "the", "work", "already", ";", "just", "test", "its", "return", "value", "." ]
[ "m32c", "0" ]
m32c3
m32c_hard_regno_ok
m32c
MPU
GCC
19,035
21
1
[]
[ "<s>", "void", "AMDGPUPassConfig", "::", "addPreSched2", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "addPass", "(", "createR600EmitClauseMarkers", "(", ")", ",", "false", ")", ";", "if", "(", "ST", ".", "isIfCvtEnabled", "(", ")", ")", "addPass", "(", "&", "IfConverterID", ",", "false", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "addPass", "(", "createR600ClauseMergePass", "(", "*", "TM", ")", ",", "false", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "addPass", "(", "createSIInsertWaits", "(", "*", "TM", ")", ",", "false", ")", ";", "}", "}", "</s>" ]
[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]
[ "R600", "SI" ]
AMDGPUTargetMachine35
addPreSched2
R600
GPU
LLVM
19,036
107
1
[]
[ "<s>", "SDValue", "LanaiTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Lanai32", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ".", "hasStructRetAttr", "(", ")", ")", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "LanaiMachineFunctionInfo", "*", "LanaiMFI", "=", "MF", ".", "getInfo", "<", "LanaiMachineFunctionInfo", ">", "(", ")", ";", "Register", "Reg", "=", "LanaiMFI", "->", "getSRetReturnReg", "(", ")", ";", "assert", "(", "Reg", "&&", "\"SRetReturnReg should have been set in LowerFormalArguments().\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "Lanai", "::", "RV", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "Lanai", "::", "RV", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "unsigned", "Opc", "=", "LanaiISD", "::", "RET_FLAG", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "DL", ",", "MVT", "::", "Other", ",", "ArrayRef", "<", "SDValue", ">", "(", "&", "RetOps", "[", "0", "]", ",", "RetOps", ".", "size", "(", ")", ")", ")", ";", "}", "</s>" ]
[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]
[ "Lanai", "Lanai", "ISD::OutputArg", "16", "Lanai", "4", "1", "0", "\"Can only return in registers!\"", "1", "Lanai", "Lanai", "Lanai", "Lanai", "\"SRetReturnReg should have been set in LowerFormalArguments().\"", "Lanai::RV", "1", "Lanai::RV", "0", "LanaiISD::RET_FLAG", "MVT::Other", "0" ]
LanaiISelLowering12
LowerReturn
Lanai
CPU
LLVM
19,037
389
1
[]
[ "<s>", "BitVector", "LC2200RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "static", "const", "MCPhysReg", "ReservedGPR32", "[", "]", "=", "{", "LC2200", "::", "zero", ",", "LC2200", "::", "sp", ",", "LC2200", "::", "fp", ",", "LC2200", "::", "pc", "}", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "for", "(", "unsigned", "short", "I", ":", "ReservedGPR32", ")", "{", "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", "." ]
[ "LC2200", "LC2200", "LC2200::zero", "LC2200::sp", "LC2200::fp", "LC2200::pc" ]
LC2200RegisterInfo
getReservedRegs
LC2200
CPU
LLVM
19,038
66
1
[]
[ "<s>", "static", "void", "tilepro_asm_trampoline_template", "(", "FILE", "*", "file", ")", "{", "fprintf", "(", "file", ",", "\"\\tlnk r10\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\taddi r10, r10, 32\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\tlwadd r11, r10, %d\\n\"", ",", "GET_MODE_SIZE", "(", "ptr_mode", ")", ")", ";", "fprintf", "(", "file", ",", "\"\\tlw r10, r10\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\tjr r11\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t.word 0 # <function address>\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t.word 0 # <static chain value>\\n\"", ")", ";", "}", "</s>" ]
[ "Implement", "TARGET_ASM_TRAMPOLINE_TEMPLATE", "." ]
[ "tilepro", "\"\\tlnk r10\\n\"", "\"\\taddi r10, r10, 32\\n\"", "\"\\tlwadd r11, r10, %d\\n\"", "\"\\tlw r10, r10\\n\"", "\"\\tjr r11\\n\"", "\"\\t.word 0 # <function address>\\n\"", "\"\\t.word 0 # <static chain value>\\n\"" ]
tilepro
tilepro_asm_trampoline_template
tilepro
VLIW
GCC
19,039
64
1
[]
[ "<s>", "const", "Cpu0InstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]
[ "TargetInstrInfo", "getter", "." ]
[ "Cpu0", "Cpu0" ]
Cpu0Subtarget3
getInstrInfo
Cpu0
CPU
LLVM
19,040
14
1
[]
[ "<s>", "void", "AMDGPUAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "switch", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", ")", "{", "case", "AMDGPU", "::", "fixup_si_sopp_br", ":", "{", "uint16_t", "*", "Dst", "=", "(", "uint16_t", "*", ")", "(", "Data", "+", "Fixup", ".", "getOffset", "(", ")", ")", ";", "*", "Dst", "=", "(", "Value", "-", "4", ")", "/", "4", ";", "break", ";", "}", "case", "AMDGPU", "::", "fixup_si_rodata", ":", "{", "uint32_t", "*", "Dst", "=", "(", "uint32_t", "*", ")", "(", "Data", "+", "Fixup", ".", "getOffset", "(", ")", ")", ";", "*", "Dst", "=", "Value", ";", "break", ";", "}", "case", "AMDGPU", "::", "fixup_si_end_of_text", ":", "{", "uint32_t", "*", "Dst", "=", "(", "uint32_t", "*", ")", "(", "Data", "+", "Fixup", ".", "getOffset", "(", ")", ")", ";", "*", "Dst", "=", "Value", "+", "4", ";", "break", ";", "}", "default", ":", "{", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "}", "</s>" ]
[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]
[ "AMDGPU", "AMDGPU", "AMDGPU::fixup_si_sopp_br", "4", "4", "AMDGPU::fixup_si_rodata", "AMDGPU::fixup_si_end_of_text", "4", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]
AMDGPUAsmBackend
applyFixup
AMDGPU
GPU
LLVM
19,041
240
1
[]
[ "<s>", "unsigned", "HOST_WIDE_INT", "aarch64_and_split_imm1", "(", "HOST_WIDE_INT", "val_in", ")", "{", "int", "lowest_bit_set", "=", "ctz_hwi", "(", "val_in", ")", ";", "int", "highest_bit_set", "=", "floor_log2", "(", "val_in", ")", ";", "gcc_assert", "(", "val_in", "!=", "0", ")", ";", "return", "(", "(", "HOST_WIDE_INT_UC", "(", "2", ")", "<<", "highest_bit_set", ")", "-", "(", "HOST_WIDE_INT_1U", "<<", "lowest_bit_set", ")", ")", ";", "}", "</s>" ]
[ "Create", "mask", "of", "ones", ",", "covering", "the", "lowest", "to", "highest", "bits", "set", "in", "VAL_IN", ".", "Assumed", "precondition", ":", "VAL_IN", "Is", "not", "zero", "." ]
[ "aarch64", "0", "2" ]
aarch64
aarch64_and_split_imm1
aarch64
CPU
GCC
19,042
50
1
[]
[ "<s>", "void", "CSKYFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "CSKYMachineFunctionInfo", "*", "CFI", "=", "MF", ".", "getInfo", "<", "CSKYMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "Register", "FPReg", "=", "getFPReg", "(", "STI", ")", ";", "Register", "SPReg", "=", "CSKY", "::", "R14", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "end", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "{", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "if", "(", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "!", "MBBI", "->", "isTerminator", "(", ")", ")", "MBBI", "=", "std", "::", "next", "(", "MBBI", ")", ";", "}", "const", "auto", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "uint64_t", "ActualSize", "=", "CFI", "->", "getCalleeSaveAreaSize", "(", ")", "+", "CFI", "->", "getVarArgsSaveSize", "(", ")", ";", "auto", "LastFrameDestroy", "=", "MBBI", ";", "if", "(", "!", "CSI", ".", "empty", "(", ")", ")", "LastFrameDestroy", "=", "std", "::", "prev", "(", "MBBI", ",", "CSI", ".", "size", "(", ")", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "const", "CSKYInstrInfo", "*", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "BuildMI", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "SPReg", ")", ".", "addReg", "(", "FPReg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "NoFlags", ")", ";", "}", "else", "{", "adjustReg", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "(", "StackSize", "-", "ActualSize", ")", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "ActualSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "</s>" ]
[ "Insert", "epilog", "code", "into", "the", "function", "." ]
[ "CSKY", "CSKY", "CSKY", "CSKY", "CSKY::R14", "CSKY" ]
CSKYFrameLowering1
emitEpilogue
CSKY
CPU
LLVM
19,043
292
1
[]
[ "<s>", "static", "void", "rs6000_eliminate_indexed_memrefs", "(", "rtx", "operands", "[", "2", "]", ")", "{", "if", "(", "reload_in_progress", ")", "return", ";", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", "!=", "REG", "&&", "!", "legitimate_constant_pool_address_p", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ",", "GET_MODE", "(", "operands", "[", "0", "]", ")", ",", "false", ")", ")", "operands", "[", "0", "]", "=", "replace_equiv_address", "(", "operands", "[", "0", "]", ",", "copy_addr_to_reg", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ")", "!=", "REG", "&&", "!", "legitimate_constant_pool_address_p", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ",", "GET_MODE", "(", "operands", "[", "1", "]", ")", ",", "false", ")", ")", "operands", "[", "1", "]", "=", "replace_equiv_address", "(", "operands", "[", "1", "]", ",", "copy_addr_to_reg", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ")", ")", ";", "}", "</s>" ]
[ "Helper", "for", "the", "following", ".", "Get", "rid", "of", "[", "r+r", "]", "memory", "refs", "in", "cases", "where", "it", "wo", "n't", "work", "(", "TImode", ",", "TFmode", ")", "." ]
[ "rs6000", "2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "1", "0", "1", "0", "1", "1", "1", "1", "0" ]
rs60004
rs6000_eliminate_indexed_memrefs
rs6000
CPU
GCC
19,044
172
1
[]
[ "<s>", "static", "HOST_WIDE_INT", "aarch64_simd_vector_alignment", "(", "const_tree", "type", ")", "{", "if", "(", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "!=", "INTEGER_CST", ")", "return", "GET_MODE_CLASS", "(", "TYPE_MODE", "(", "type", ")", ")", "==", "MODE_VECTOR_BOOL", "?", "16", ":", "128", ";", "return", "wi", "::", "umin", "(", "wi", "::", "to_wide", "(", "TYPE_SIZE", "(", "type", ")", ")", ",", "128", ")", ".", "to_uhwi", "(", ")", ";", "}", "</s>" ]
[ "Implement", "target", "hook", "TARGET_VECTOR_ALIGNMENT", ".", "The", "AAPCS64", "sets", "the", "maximum", "alignment", "of", "a", "vector", "to", "128", "bits", "." ]
[ "aarch64", "16", "128", "128" ]
aarch646
aarch64_simd_vector_alignment
aarch64
CPU
GCC
19,045
58
1
[]
[ "<s>", "bool", "aarch64_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode1", ")", "==", "GET_MODE_CLASS", "(", "mode2", ")", ")", "return", "true", ";", "if", "(", "TARGET_SIMD", "&&", "aarch64_vector_mode_p", "(", "mode1", ")", "&&", "aarch64_vector_mode_p", "(", "mode2", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]
[ "Implement", "MODES_TIEABLE_P", ".", "In", "principle", "we", "should", "always", "return", "true", ".", "However", "due", "to", "issues", "with", "register", "allocation", "it", "is", "preferable", "to", "avoid", "tieing", "integer", "scalar", "and", "FP", "scalar", "modes", ".", "Executing", "integer", "operations", "in", "general", "registers", "is", "better", "than", "treating", "them", "as", "scalar", "vector", "operations", ".", "This", "reduces", "latency", "and", "avoids", "redundant", "int", "<", "-", ">", "FP", "moves", ".", "So", "tie", "modes", "if", "they", "are", "either", "the", "same", "class", ",", "or", "vector", "modes", "with", "other", "vector", "modes", ",", "vector", "structs", "or", "any", "scalar", "mode", "." ]
[ "aarch64" ]
aarch642
aarch64_modes_tieable_p
aarch64
CPU
GCC
19,046
46
1
[]
[ "<s>", "const", "char", "*", "ix86_output_indirect_function_return", "(", "rtx", "ret_op", ")", "{", "if", "(", "cfun", "->", "machine", "->", "function_return_type", "!=", "indirect_branch_keep", ")", "{", "char", "thunk_name", "[", "32", "]", ";", "enum", "indirect_thunk_prefix", "need_prefix", "=", "indirect_thunk_need_prefix", "(", "current_output_insn", ")", ";", "unsigned", "int", "regno", "=", "REGNO", "(", "ret_op", ")", ";", "gcc_assert", "(", "regno", "==", "CX_REG", ")", ";", "if", "(", "cfun", "->", "machine", "->", "function_return_type", "!=", "indirect_branch_thunk_inline", ")", "{", "bool", "need_thunk", "=", "(", "cfun", "->", "machine", "->", "function_return_type", "==", "indirect_branch_thunk", ")", ";", "indirect_thunk_name", "(", "thunk_name", ",", "regno", ",", "need_prefix", ",", "true", ")", ";", "if", "(", "need_thunk", ")", "{", "indirect_return_via_cx", "=", "true", ";", "SET_HARD_REG_BIT", "(", "indirect_thunks_used", ",", "CX_REG", ")", ";", "}", "fprintf", "(", "asm_out_file", ",", "\"\\tjmp\\t\"", ")", ";", "assemble_name", "(", "asm_out_file", ",", "thunk_name", ")", ";", "putc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "}", "else", "output_indirect_thunk", "(", "regno", ")", ";", "}", "else", "{", "output_asm_insn", "(", "\"%!jmp\\t%A0\"", ",", "&", "ret_op", ")", ";", "if", "(", "ix86_harden_sls", "&", "harden_sls_indirect_jmp", ")", "fputs", "(", "\"\\tint3\\n\"", ",", "asm_out_file", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]
[ "Output", "indirect", "function", "return", ".", "RET_OP", "is", "the", "function", "return", "target", "." ]
[ "i386", "32", "\"\\tjmp\\t\"", "\"%!jmp\\t%A0\"", "\"\\tint3\\n\"", "\"\"" ]
i386
ix86_output_indirect_function_return
i386
CPU
GCC
19,047
160
1
[]
[ "<s>", "bool", "aarch64_sve_ldnf1_operand_p", "(", "rtx", "op", ")", "{", "struct", "aarch64_address_info", "addr", ";", "return", "(", "MEM_P", "(", "op", ")", "&&", "aarch64_classify_address", "(", "&", "addr", ",", "XEXP", "(", "op", ",", "0", ")", ",", "GET_MODE", "(", "op", ")", ",", "false", ")", "&&", "addr", ".", "type", "==", "ADDRESS_REG_IMM", ")", ";", "}", "</s>" ]
[ "Return", "true", "if", "OP", "is", "a", "valid", "MEM", "operand", "for", "an", "SVE", "LDNF1", "instruction", "." ]
[ "aarch64", "0" ]
aarch64
aarch64_sve_ldnf1_operand_p
aarch64
CPU
GCC
19,048
46
1
[]
[ "<s>", "unsigned", "X86TargetLowering", "::", "getByValTypeAlignment", "(", "Type", "*", "Ty", ")", "const", "{", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", ")", "{", "unsigned", "TyAlign", "=", "TD", "->", "getABITypeAlignment", "(", "Ty", ")", ";", "if", "(", "TyAlign", ">", "8", ")", "return", "TyAlign", ";", "return", "8", ";", "}", "unsigned", "Align", "=", "4", ";", "if", "(", "Subtarget", "->", "hasSSE1", "(", ")", ")", "getMaxByValAlign", "(", "Ty", ",", "Align", ")", ";", "return", "Align", ";", "}", "</s>" ]
[ "Return", "the", "desired", "alignment", "for", "ByVal", "aggregate", "function", "arguments", "in", "the", "caller", "parameter", "area", "." ]
[ "X86", "X86", "8", "8", "4" ]
X86ISelLowering (2)
getByValTypeAlignment
X86
CPU
LLVM
19,049
67
1
[]
[ "<s>", "void", "AArch64RegisterInfo", "::", "materializeFrameBaseRegister", "(", "MachineBasicBlock", "*", "MBB", ",", "unsigned", "BaseReg", ",", "int", "FrameIdx", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "Ins", "=", "MBB", "->", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "Ins", "!=", "MBB", "->", "end", "(", ")", ")", "DL", "=", "Ins", "->", "getDebugLoc", "(", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", "->", "getParent", "(", ")", ";", "const", "AArch64InstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "TII", "->", "get", "(", "AArch64", "::", "ADDXri", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "BaseReg", ",", "TII", "->", "getRegClass", "(", "MCID", ",", "0", ",", "this", ",", "MF", ")", ")", ";", "unsigned", "Shifter", "=", "AArch64_AM", "::", "getShifterImm", "(", "AArch64_AM", "::", "LSL", ",", "0", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "MCID", ",", "BaseReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "Offset", ")", ".", "addImm", "(", "Shifter", ")", ";", "}", "</s>" ]
[ "Insert", "defining", "instruction", "(", "s", ")", "for", "a", "pointer", "to", "FrameIdx", "before", "insertion", "point", "I", "." ]
[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64::ADDXri", "0", "AArch64_AM::getShifterImm", "AArch64_AM::LSL", "0" ]
AArch64RegisterInfo (2)
materializeFrameBaseRegister
AArch64
CPU
LLVM
19,050
174
1
[]
[ "<s>", "static", "rtx", "rs6000_finish_function_arg", "(", "machine_mode", "mode", ",", "rtx", "*", "rvec", ",", "int", "k", ")", "{", "gcc_assert", "(", "k", ">=", "1", ")", ";", "if", "(", "k", "==", "1", ")", "{", "if", "(", "XEXP", "(", "rvec", "[", "0", "]", ",", "0", ")", "==", "NULL_RTX", ")", "return", "NULL_RTX", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "rvec", "[", "0", "]", ",", "0", ")", ")", "==", "mode", ")", "return", "XEXP", "(", "rvec", "[", "0", "]", ",", "0", ")", ";", "}", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec_v", "(", "k", ",", "rvec", ")", ")", ";", "}", "</s>" ]
[ "RVEC", "is", "a", "vector", "of", "K", "components", "of", "an", "argument", "of", "mode", "MODE", ".", "Construct", "the", "final", "function_arg", "return", "value", "from", "it", "." ]
[ "powerpcspe", "1", "1", "0", "0", "0", "0", "0", "0" ]
powerpcspe
rs6000_finish_function_arg
powerpcspe
CPU
GCC
19,051
89
1
[]
[ "<s>", "bool", "JVMLoadStoreEliminationOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MFN", ")", "{", "MF", "=", "&", "MFN", ";", "TII", "=", "static_cast", "<", "const", "JVMInstrInfo", "*", ">", "(", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "static_cast", "<", "const", "JVMRegisterInfo", "*", ">", "(", "MF", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "MRI", "=", "&", "MF", "->", "getRegInfo", "(", ")", ";", "DT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n******** JVM Load/Store Elimination Optimization ********\\n\"", ")", ";", "PerformOptimization", "(", "DT", "->", "getRootNode", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "JVM", "JVM", "JVM", "JVM", "\"\\n******** JVM Load/Store Elimination Optimization ********\\n\"" ]
JVMLoadStoreEliminationOpt
runOnMachineFunction
JVM
Virtual ISA
LLVM
19,052
96
1
[]
[ "<s>", "int", "alpha_split_conditional_move", "(", "enum", "rtx_code", "code", ",", "rtx", "dest", ",", "rtx", "cond", ",", "rtx", "t_rtx", ",", "rtx", "f_rtx", ")", "{", "HOST_WIDE_INT", "t", ",", "f", ",", "diff", ";", "enum", "machine_mode", "mode", ";", "rtx", "target", ",", "subtarget", ",", "tmp", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "t", "=", "INTVAL", "(", "t_rtx", ")", ";", "f", "=", "INTVAL", "(", "f_rtx", ")", ";", "diff", "=", "t", "-", "f", ";", "if", "(", "(", "(", "code", "==", "NE", "||", "code", "==", "EQ", ")", "&&", "diff", "<", "0", ")", "||", "(", "code", "==", "GE", "||", "code", "==", "GT", ")", ")", "{", "code", "=", "reverse_condition", "(", "code", ")", ";", "diff", "=", "t", ",", "t", "=", "f", ",", "f", "=", "diff", ";", "diff", "=", "t", "-", "f", ";", "}", "subtarget", "=", "target", "=", "dest", ";", "if", "(", "mode", "!=", "DImode", ")", "{", "target", "=", "gen_lowpart", "(", "DImode", ",", "dest", ")", ";", "if", "(", "!", "no_new_pseudos", ")", "subtarget", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "else", "subtarget", "=", "target", ";", "}", "if", "(", "f", "==", "0", "&&", "exact_log2", "(", "diff", ")", ">", "0", "&&", "(", "diff", "<=", "8", "||", "alpha_tune", "==", "PROCESSOR_EV6", ")", ")", "{", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "tmp", "=", "gen_rtx_ASHIFT", "(", "DImode", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "exact_log2", "(", "t", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "tmp", ")", ")", ";", "}", "else", "if", "(", "f", "==", "0", "&&", "t", "==", "-", "1", ")", "{", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "emit_insn", "(", "gen_negdi2", "(", "target", ",", "copy_rtx", "(", "subtarget", ")", ")", ")", ";", "}", "else", "if", "(", "diff", "==", "1", "||", "diff", "==", "4", "||", "diff", "==", "8", ")", "{", "rtx", "add_op", ";", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "if", "(", "diff", "==", "1", ")", "emit_insn", "(", "gen_adddi3", "(", "target", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "f", ")", ")", ")", ";", "else", "{", "add_op", "=", "GEN_INT", "(", "f", ")", ";", "if", "(", "sext_add_operand", "(", "add_op", ",", "mode", ")", ")", "{", "tmp", "=", "gen_rtx_MULT", "(", "DImode", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "diff", ")", ")", ";", "tmp", "=", "gen_rtx_PLUS", "(", "DImode", ",", "tmp", ",", "add_op", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "tmp", ")", ")", ";", "}", "else", "return", "0", ";", "}", "}", "else", "return", "0", ";", "return", "1", ";", "}", "</s>" ]
[ "Simplify", "a", "conditional", "move", "of", "two", "constants", "into", "a", "setcc", "with", "arithmetic", ".", "This", "is", "done", "with", "a", "splitter", "since", "combine", "would", "just", "undo", "the", "work", "if", "done", "during", "code", "generation", ".", "It", "also", "catches", "cases", "we", "would", "n't", "have", "before", "cse", "." ]
[ "alpha", "0", "0", "0", "8", "0", "1", "1", "4", "8", "1", "0", "0", "1" ]
alpha3
alpha_split_conditional_move
alpha
MPU
GCC
19,053
445
1
[]
[ "<s>", "bool", "SystemZAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "Operands", ".", "push_back", "(", "SystemZOperand", "::", "createToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "true", ";", "}", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "true", ";", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "}", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]
[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]
[ "SystemZ", "SystemZ", "SystemZ", "\"unexpected token in argument list\"" ]
SystemZAsmParser10
ParseInstruction
SystemZ
CPU
LLVM
19,054
164
1
[]
[ "<s>", "static", "int", "get_vsel_insn", "(", "enum", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "V4SImode", ":", "return", "UNSPEC_VSEL4SI", ";", "break", ";", "case", "V4SFmode", ":", "return", "UNSPEC_VSEL4SF", ";", "break", ";", "case", "V8HImode", ":", "return", "UNSPEC_VSEL8HI", ";", "break", ";", "case", "V16QImode", ":", "return", "UNSPEC_VSEL16QI", ";", "break", ";", "default", ":", "return", "INSN_NOT_AVAILABLE", ";", "break", ";", "}", "return", "INSN_NOT_AVAILABLE", ";", "}", "</s>" ]
[ "Return", "vector", "select", "instruction", "for", "MODE", ".", "Return", "INSN_NOT_AVAILABLE", ",", "if", "valid", "insn", "doesn", "exist", "for", "given", "mode", "." ]
[ "rs6000" ]
rs60003
get_vsel_insn
rs6000
CPU
GCC
19,055
58
1
[]
[ "<s>", "struct", "xstormy16_stack_layout", "xstormy16_compute_stack_layout", "(", "void", ")", "{", "struct", "xstormy16_stack_layout", "layout", ";", "int", "regno", ";", "const", "int", "ifun", "=", "xstormy16_interrupt_function_p", "(", ")", ";", "layout", ".", "locals_size", "=", "get_frame_size", "(", ")", ";", "layout", ".", "register_save_size", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "REG_NEEDS_SAVE", "(", "regno", ",", "ifun", ")", ")", "layout", ".", "register_save_size", "+=", "UNITS_PER_WORD", ";", "if", "(", "current_function_stdarg", ")", "layout", ".", "stdarg_save_size", "=", "NUM_ARGUMENT_REGISTERS", "*", "UNITS_PER_WORD", ";", "else", "layout", ".", "stdarg_save_size", "=", "0", ";", "layout", ".", "frame_size", "=", "(", "layout", ".", "locals_size", "+", "layout", ".", "register_save_size", "+", "layout", ".", "stdarg_save_size", ")", ";", "if", "(", "current_function_args_size", "<=", "2048", "&&", "current_function_args_size", "!=", "-", "1", ")", "{", "if", "(", "layout", ".", "frame_size", "+", "INCOMING_FRAME_SP_OFFSET", "+", "current_function_args_size", "<=", "2048", ")", "layout", ".", "fp_minus_ap", "=", "layout", ".", "frame_size", "+", "INCOMING_FRAME_SP_OFFSET", ";", "else", "layout", ".", "fp_minus_ap", "=", "2048", "-", "current_function_args_size", ";", "}", "else", "layout", ".", "fp_minus_ap", "=", "(", "layout", ".", "stdarg_save_size", "+", "layout", ".", "register_save_size", "+", "INCOMING_FRAME_SP_OFFSET", ")", ";", "layout", ".", "sp_minus_fp", "=", "(", "layout", ".", "frame_size", "+", "INCOMING_FRAME_SP_OFFSET", "-", "layout", ".", "fp_minus_ap", ")", ";", "layout", ".", "first_local_minus_ap", "=", "layout", ".", "sp_minus_fp", "-", "layout", ".", "locals_size", ";", "return", "layout", ";", "}", "</s>" ]
[ "Compute", "the", "stack", "layout", "." ]
[ "stormy16", "0", "0", "0", "2048", "1", "2048", "2048" ]
stormy163
xstormy16_compute_stack_layout
stormy16
CPU
GCC
19,056
194
1
[]
[ "<s>", "bool", "X86TargetLowering", "::", "shouldReduceLoadWidth", "(", "SDNode", "*", "Load", ",", "ISD", "::", "LoadExtType", "ExtTy", ",", "EVT", "NewVT", ")", "const", "{", "SDValue", "BasePtr", "=", "cast", "<", "LoadSDNode", ">", "(", "Load", ")", "->", "getBasePtr", "(", ")", ";", "if", "(", "BasePtr", ".", "getOpcode", "(", ")", "==", "X86ISD", "::", "WrapperRIP", ")", "if", "(", "const", "auto", "*", "GA", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "BasePtr", ".", "getOperand", "(", "0", ")", ")", ")", "return", "GA", "->", "getTargetFlags", "(", ")", "!=", "X86II", "::", "MO_GOTTPOFF", ";", "EVT", "VT", "=", "Load", "->", "getValueType", "(", "0", ")", ";", "if", "(", "(", "VT", ".", "is256BitVector", "(", ")", "||", "VT", ".", "is512BitVector", "(", ")", ")", "&&", "!", "Load", "->", "hasOneUse", "(", ")", ")", "{", "for", "(", "auto", "UI", "=", "Load", "->", "use_begin", "(", ")", ",", "UE", "=", "Load", "->", "use_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "if", "(", "UI", ".", "getUse", "(", ")", ".", "getResNo", "(", ")", "!=", "0", ")", "continue", ";", "if", "(", "UI", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "EXTRACT_SUBVECTOR", "||", "!", "UI", "->", "hasOneUse", "(", ")", "||", "UI", "->", "use_begin", "(", ")", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "STORE", ")", "return", "true", ";", "}", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]
[ "Return", "true", "if", "we", "believe", "it", "is", "correct", "and", "profitable", "to", "reduce", "the", "load", "node", "to", "a", "smaller", "type", "." ]
[ "X86", "X86", "ISD::LoadExtType", "X86ISD::WrapperRIP", "0", "X86II::MO_GOTTPOFF", "0", "0", "ISD::EXTRACT_SUBVECTOR", "ISD::STORE" ]
X86ISelLowering108
shouldReduceLoadWidth
X86
CPU
LLVM
19,057
199
1
[]
[ "<s>", "void", "rs6000_secondary_reload_gpr", "(", "rtx", "reg", ",", "rtx", "mem", ",", "rtx", "scratch", ",", "bool", "store_p", ")", "{", "int", "regno", "=", "true_regnum", "(", "reg", ")", ";", "enum", "reg_class", "rclass", ";", "rtx", "addr", ";", "rtx", "scratch_or_premodify", "=", "scratch", ";", "if", "(", "TARGET_DEBUG_ADDR", ")", "{", "fprintf", "(", "stderr", ",", "\"\\nrs6000_secondary_reload_gpr, type = %s\\n\"", ",", "store_p", "?", "\"store\"", ":", "\"load\"", ")", ";", "fprintf", "(", "stderr", ",", "\"reg:\\n\"", ")", ";", "debug_rtx", "(", "reg", ")", ";", "fprintf", "(", "stderr", ",", "\"mem:\\n\"", ")", ";", "debug_rtx", "(", "mem", ")", ";", "fprintf", "(", "stderr", ",", "\"scratch:\\n\"", ")", ";", "debug_rtx", "(", "scratch", ")", ";", "}", "gcc_assert", "(", "regno", ">=", "0", "&&", "regno", "<", "FIRST_PSEUDO_REGISTER", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "mem", ")", "==", "MEM", ")", ";", "rclass", "=", "REGNO_REG_CLASS", "(", "regno", ")", ";", "gcc_assert", "(", "rclass", "==", "GENERAL_REGS", "||", "rclass", "==", "BASE_REGS", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PRE_MODIFY", ")", "{", "gcc_assert", "(", "REG_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "PLUS", "&&", "XEXP", "(", "XEXP", "(", "addr", ",", "1", ")", ",", "0", ")", "==", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "scratch_or_premodify", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "!", "HARD_REGISTER_P", "(", "scratch_or_premodify", ")", ")", "scratch_or_premodify", "=", "find_replacement", "(", "&", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "||", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", ")", ";", "rs6000_emit_move", "(", "scratch_or_premodify", ",", "addr", ",", "Pmode", ")", ";", "mem", "=", "replace_equiv_address_nv", "(", "mem", ",", "scratch_or_premodify", ")", ";", "if", "(", "store_p", ")", "emit_insn", "(", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "else", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ")", ";", "return", ";", "}", "</s>" ]
[ "Convert", "reloads", "involving", "64-bit", "gprs", "and", "misaligned", "offset", "addressing", ",", "or", "multiple", "32-bit", "gprs", "and", "offsets", "that", "are", "too", "large", ",", "to", "use", "indirect", "addressing", "." ]
[ "rs6000", "\"\\nrs6000_secondary_reload_gpr, type = %s\\n\"", "\"store\"", "\"load\"", "\"reg:\\n\"", "\"mem:\\n\"", "\"scratch:\\n\"", "0", "0", "0", "1", "1", "0", "0", "0", "0", "1" ]
rs60005
rs6000_secondary_reload_gpr
rs6000
CPU
GCC
19,058
296
1
[]
[ "<s>", "bool", "AArch64LoadStoreOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "skipFunction", "(", "*", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "Subtarget", "=", "&", "static_cast", "<", "const", "AArch64Subtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "Subtarget", "->", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "ModifiedRegs", ".", "resize", "(", "TRI", "->", "getNumRegs", "(", ")", ")", ";", "UsedRegs", ".", "resize", "(", "TRI", "->", "getNumRegs", "(", ")", ")", ";", "bool", "Modified", "=", "false", ";", "bool", "enableNarrowZeroStOpt", "=", "!", "Subtarget", "->", "requiresStrictAlign", "(", ")", ";", "for", "(", "auto", "&", "MBB", ":", "Fn", ")", "Modified", "|=", "optimizeBlock", "(", "MBB", ",", "enableNarrowZeroStOpt", ")", ";", "return", "Modified", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "AArch64", "AArch64", "AArch64", "AArch64" ]
AArch64LoadStoreOptimizer17
runOnMachineFunction
AArch64
CPU
LLVM
19,059
124
1
[]
[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]
[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]
[ "OR1K" ]
OR1KAsmBackend1
mayNeedRelaxation
OR1K
CPU
LLVM
19,060
15
1
[]
[ "<s>", "void", "function_arg_advance", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", ")", "{", "struct", "mips_arg_info", "info", ";", "mips_arg_info", "(", "cum", ",", "mode", ",", "type", ",", "named", ",", "&", "info", ")", ";", "if", "(", "!", "info", ".", "fpr_p", ")", "cum", "->", "gp_reg_found", "=", "true", ";", "if", "(", "cum", "->", "arg_number", "<", "2", "&&", "info", ".", "fpr_p", ")", "cum", "->", "fp_code", "+=", "(", "mode", "==", "SFmode", "?", "1", ":", "2", ")", "<<", "(", "(", "cum", "->", "arg_number", "-", "1", ")", "*", "2", ")", ";", "if", "(", "mips_abi", "!=", "ABI_EABI", "||", "!", "info", ".", "fpr_p", ")", "cum", "->", "num_gprs", "=", "info", ".", "reg_offset", "+", "info", ".", "reg_words", ";", "else", "if", "(", "info", ".", "reg_words", ">", "0", ")", "cum", "->", "num_fprs", "+=", "FP_INC", ";", "if", "(", "info", ".", "stack_words", ">", "0", ")", "cum", "->", "stack_words", "=", "info", ".", "stack_offset", "+", "info", ".", "stack_words", ";", "cum", "->", "arg_number", "++", ";", "}", "</s>" ]
[ "Handle", "the", "FUNCTION_ARG_ADVANCE", "macro", ".", "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", "." ]
[ "mips", "2", "1", "2", "1", "2", "0", "0" ]
mips3
function_arg_advance
mips
CPU
GCC
19,061
151
1
[]
[ "<s>", "AlphaTargetLowering", "::", "ConstraintType", "AlphaTargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'f'", ":", "case", "'r'", ":", "return", "C_RegisterClass", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]
[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]
[ "Alpha", "Alpha", "Alpha", "1", "0" ]
AlphaISelLowering1
getConstraintType
Alpha
MPU
LLVM
19,062
59
1
[]
[ "<s>", "static", "std", "::", "string", "toString", "(", "const", "APFloat", "&", "FP", ")", "{", "if", "(", "FP", ".", "isNaN", "(", ")", "&&", "!", "FP", ".", "bitwiseIsEqual", "(", "APFloat", "::", "getQNaN", "(", "FP", ".", "getSemantics", "(", ")", ")", ")", "&&", "!", "FP", ".", "bitwiseIsEqual", "(", "APFloat", "::", "getQNaN", "(", "FP", ".", "getSemantics", "(", ")", ",", "true", ")", ")", ")", "{", "APInt", "AI", "=", "FP", ".", "bitcastToAPInt", "(", ")", ";", "return", "std", "::", "string", "(", "AI", ".", "isNegative", "(", ")", "?", "\"-\"", ":", "\"\"", ")", "+", "\"nan:0x\"", "+", "utohexstr", "(", "AI", ".", "getZExtValue", "(", ")", "&", "(", "AI", ".", "getBitWidth", "(", ")", "==", "32", "?", "INT64_C", "(", "0x007fffff", ")", ":", "INT64_C", "(", "0x000fffffffffffff", ")", ")", ",", "true", ")", ";", "}", "static", "const", "size_t", "BufBytes", "=", "128", ";", "char", "buf", "[", "BufBytes", "]", ";", "auto", "Written", "=", "FP", ".", "convertToHexString", "(", "buf", ",", "0", ",", "false", ",", "APFloat", "::", "rmNearestTiesToEven", ")", ";", "(", "void", ")", "Written", ";", "assert", "(", "Written", "!=", "0", ")", ";", "assert", "(", "Written", "<", "BufBytes", ")", ";", "return", "buf", ";", "}", "</s>" ]
[ "Convert", "to", "a", "decimal", "representation", "in", "a", "string", "." ]
[ "WebAssembly", "\"-\"", "\"\"", "\"nan:0x\"", "32", "0x007fffff", "0x000fffffffffffff", "128", "0", "0" ]
WebAssemblyInstPrinter1
toString
WebAssembly
Virtual ISA
LLVM
19,063
170
1
[]
[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unimplemented operation lowering\"", ")", ";", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]
[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]
[ "WebAssembly", "WebAssembly", "\"unimplemented operation lowering\"", "ISD::GlobalAddress" ]
WebAssemblyISelLowering57
LowerOperation
WebAssembly
Virtual ISA
LLVM
19,064
50
1
[]
[ "<s>", "static", "int", "ia64_arg_partial_bytes", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "words", "=", "ia64_function_arg_words", "(", "type", ",", "mode", ")", ";", "int", "offset", "=", "ia64_function_arg_offset", "(", "cum", ",", "type", ",", "words", ")", ";", "if", "(", "cum", "->", "words", "+", "offset", ">=", "MAX_ARGUMENT_SLOTS", ")", "return", "0", ";", "if", "(", "words", "+", "cum", "->", "words", "+", "offset", "<=", "MAX_ARGUMENT_SLOTS", ")", "return", "0", ";", "return", "(", "MAX_ARGUMENT_SLOTS", "-", "cum", "->", "words", "-", "offset", ")", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]
[ "Return", "number", "of", "bytes", ",", "at", "the", "beginning", "of", "the", "argument", ",", "that", "must", "be", "put", "in", "registers", ".", "0", "is", "the", "argument", "is", "entirely", "in", "registers", "or", "entirely", "in", "memory", "." ]
[ "ia64", "0", "0" ]
ia644
ia64_arg_partial_bytes
ia64
CPU
GCC
19,065
91
1
[]
[ "<s>", "static", "tree", "aarch64_build_builtin_va_list", "(", "void", ")", "{", "tree", "va_list_name", ";", "tree", "f_stack", ",", "f_grtop", ",", "f_vrtop", ",", "f_groff", ",", "f_vroff", ";", "va_list_type", "=", "lang_hooks", ".", "types", ".", "make_type", "(", "RECORD_TYPE", ")", ";", "va_list_name", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "TYPE_DECL", ",", "get_identifier", "(", "\"__va_list\"", ")", ",", "va_list_type", ")", ";", "DECL_ARTIFICIAL", "(", "va_list_name", ")", "=", "1", ";", "TYPE_NAME", "(", "va_list_type", ")", "=", "va_list_name", ";", "TYPE_STUB_DECL", "(", "va_list_type", ")", "=", "va_list_name", ";", "f_stack", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__stack\"", ")", ",", "ptr_type_node", ")", ";", "f_grtop", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__gr_top\"", ")", ",", "ptr_type_node", ")", ";", "f_vrtop", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__vr_top\"", ")", ",", "ptr_type_node", ")", ";", "f_groff", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__gr_offs\"", ")", ",", "integer_type_node", ")", ";", "f_vroff", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__vr_offs\"", ")", ",", "integer_type_node", ")", ";", "va_list_gpr_counter_field", "=", "f_groff", ";", "va_list_fpr_counter_field", "=", "f_vroff", ";", "DECL_ARTIFICIAL", "(", "f_stack", ")", "=", "1", ";", "DECL_ARTIFICIAL", "(", "f_grtop", ")", "=", "1", ";", "DECL_ARTIFICIAL", "(", "f_vrtop", ")", "=", "1", ";", "DECL_ARTIFICIAL", "(", "f_groff", ")", "=", "1", ";", "DECL_ARTIFICIAL", "(", "f_vroff", ")", "=", "1", ";", "DECL_FIELD_CONTEXT", "(", "f_stack", ")", "=", "va_list_type", ";", "DECL_FIELD_CONTEXT", "(", "f_grtop", ")", "=", "va_list_type", ";", "DECL_FIELD_CONTEXT", "(", "f_vrtop", ")", "=", "va_list_type", ";", "DECL_FIELD_CONTEXT", "(", "f_groff", ")", "=", "va_list_type", ";", "DECL_FIELD_CONTEXT", "(", "f_vroff", ")", "=", "va_list_type", ";", "TYPE_FIELDS", "(", "va_list_type", ")", "=", "f_stack", ";", "DECL_CHAIN", "(", "f_stack", ")", "=", "f_grtop", ";", "DECL_CHAIN", "(", "f_grtop", ")", "=", "f_vrtop", ";", "DECL_CHAIN", "(", "f_vrtop", ")", "=", "f_groff", ";", "DECL_CHAIN", "(", "f_groff", ")", "=", "f_vroff", ";", "layout_type", "(", "va_list_type", ")", ";", "return", "va_list_type", ";", "}", "</s>" ]
[ "Implement", "TARGET_BUILD_BUILTIN_VA_LIST", ".", "Return", "the", "type", "to", "use", "as", "__builtin_va_list", ".", "AAPCS64", "\\S", "7.1.4", "requires", "that", "va_list", "be", "a", "typedef", "for", "a", "type", "defined", "as", ":", "struct", "__va_list", "{", "void", "*", "__stack", ";", "void", "*", "__gr_top", ";", "void", "*", "__vr_top", ";", "int", "__gr_offs", ";", "int", "__vr_offs", ";", "}", ";" ]
[ "aarch64", "\"__va_list\"", "1", "\"__stack\"", "\"__gr_top\"", "\"__vr_top\"", "\"__gr_offs\"", "\"__vr_offs\"", "1", "1", "1", "1", "1" ]
aarch64
aarch64_build_builtin_va_list
aarch64
CPU
GCC
19,066
271
1
[]
[ "<s>", "virtual", "bool", "addPreSched2", "(", ")", "{", "addPass", "(", "createPatmosPMLProfileImport", "(", "getPatmosTargetMachine", "(", ")", ")", ")", ";", "if", "(", "PatmosSinglePathInfo", "::", "isEnabled", "(", ")", ")", "{", "addPass", "(", "createPatmosSinglePathInfoPass", "(", "getPatmosTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createPatmosSPBundlingPass", "(", "getPatmosTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createPatmosSPReducePass", "(", "getPatmosTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createSPSchedulerPass", "(", "getPatmosTargetMachine", "(", ")", ")", ")", ";", "}", "else", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "!", "DisableIfConverter", ")", "{", "addPass", "(", "&", "IfConverterID", ")", ";", "addPass", "(", "&", "UnreachableMachineBlockElimID", ")", ";", "}", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "TargetPassConfig", "::", "addBlockPlacement", "(", ")", ";", "}", "}", "addPass", "(", "createPatmosStackCacheAnalysisInfo", "(", "getPatmosTargetMachine", "(", ")", ")", ")", ";", "if", "(", "EnableStackCacheAnalysis", ")", "{", "addPass", "(", "createPatmosStackCacheAnalysis", "(", "getPatmosTargetMachine", "(", ")", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]
[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]
[ "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos" ]
PatmosTargetMachine
addPreSched2
Patmos
VLIW
LLVM
19,067
144
1
[]
[ "<s>", "static", "int", "sh_pr_n_sets", "(", "void", ")", "{", "return", "DF_REG_DEF_COUNT", "(", "PR_REG", ")", ";", "}", "</s>" ]
[ "For", "use", "by", "ALLOCATE_INITIAL_VALUE", ".", "Note", "that", "sh.md", "contains", "some", "'special", "function", "'", "patterns", "(", "type", "sfunc", ")", "that", "clobber", "pr", ",", "but", "that", "do", "not", "look", "like", "function", "calls", "to", "leaf_function_p", ".", "Hence", "we", "must", "do", "this", "extra", "check", "." ]
[ "sh" ]
sh
sh_pr_n_sets
sh
CPU
GCC
19,068
14
1
[]
[ "<s>", "bool", "RISCVGatherScatterLowering", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "auto", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "auto", "&", "TM", "=", "TPC", ".", "getTM", "<", "RISCVTargetMachine", ">", "(", ")", ";", "ST", "=", "&", "TM", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", "F", ")", ";", "if", "(", "!", "ST", "->", "hasStdExtV", "(", ")", "||", "!", "ST", "->", "useRVVForFixedLengthVectors", "(", ")", ")", "return", "false", ";", "TLI", "=", "ST", "->", "getTargetLowering", "(", ")", ";", "DL", "=", "&", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "SmallVector", "<", "IntrinsicInst", "*", ",", "4", ">", "Gathers", ";", "SmallVector", "<", "IntrinsicInst", "*", ",", "4", ">", "Scatters", ";", "bool", "Changed", "=", "false", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "for", "(", "Instruction", "&", "I", ":", "BB", ")", "{", "IntrinsicInst", "*", "II", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "&", "I", ")", ";", "if", "(", "II", "&&", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "masked_gather", "&&", "isa", "<", "FixedVectorType", ">", "(", "II", "->", "getType", "(", ")", ")", ")", "{", "Gathers", ".", "push_back", "(", "II", ")", ";", "}", "else", "if", "(", "II", "&&", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "masked_scatter", "&&", "isa", "<", "FixedVectorType", ">", "(", "II", "->", "getArgOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ")", "{", "Scatters", ".", "push_back", "(", "II", ")", ";", "}", "}", "}", "for", "(", "auto", "*", "II", ":", "Gathers", ")", "Changed", "|=", "tryCreateStridedLoadStore", "(", "II", ",", "II", "->", "getType", "(", ")", ",", "II", "->", "getArgOperand", "(", "0", ")", ",", "II", "->", "getArgOperand", "(", "1", ")", ")", ";", "for", "(", "auto", "*", "II", ":", "Scatters", ")", "Changed", "|=", "tryCreateStridedLoadStore", "(", "II", ",", "II", "->", "getArgOperand", "(", "0", ")", "->", "getType", "(", ")", ",", "II", "->", "getArgOperand", "(", "1", ")", ",", "II", "->", "getArgOperand", "(", "2", ")", ")", ";", "while", "(", "!", "MaybeDeadPHIs", ".", "empty", "(", ")", ")", "{", "if", "(", "auto", "*", "Phi", "=", "dyn_cast_or_null", "<", "PHINode", ">", "(", "MaybeDeadPHIs", ".", "pop_back_val", "(", ")", ")", ")", "RecursivelyDeleteDeadPHINode", "(", "Phi", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]
[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]
[ "RISCV", "RISCV", "RISCV", "RISCV", "4", "4", "Intrinsic::masked_gather", "Intrinsic::masked_scatter", "0", "0", "1", "0", "1", "2" ]
RISCVGatherScatterLowering3
runOnFunction
RISCV
CPU
LLVM
19,069
356
1
[]
[ "<s>", "UPTSubtarget", "&", "UPTSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"generic-upt\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]
[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]
[ "UPT", "UPT", "UPT", "\"generic-upt\"" ]
UPTSubtarget
initializeSubtargetDependencies
UPT
CPU
LLVM
19,070
44
1
[]
[ "<s>", "void", "PPCInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "PPC", "::", "RLWINM", ")", "{", "unsigned", "char", "SH", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "unsigned", "char", "MB", "=", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "unsigned", "char", "ME", "=", "MI", "->", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", ";", "bool", "useSubstituteMnemonic", "=", "false", ";", "if", "(", "SH", "<=", "31", "&&", "MB", "==", "0", "&&", "ME", "==", "(", "31", "-", "SH", ")", ")", "{", "O", "<<", "\"\\tslwi \"", ";", "useSubstituteMnemonic", "=", "true", ";", "}", "if", "(", "SH", "<=", "31", "&&", "MB", "==", "(", "32", "-", "SH", ")", "&&", "ME", "==", "31", ")", "{", "O", "<<", "\"\\tsrwi \"", ";", "useSubstituteMnemonic", "=", "true", ";", "SH", "=", "32", "-", "SH", ";", "}", "if", "(", "useSubstituteMnemonic", ")", "{", "printOperand", "(", "MI", ",", "0", ",", "O", ")", ";", "O", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "1", ",", "O", ")", ";", "O", "<<", "\", \"", "<<", "(", "unsigned", "int", ")", "SH", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "return", ";", "}", "}", "if", "(", "(", "MI", "->", "getOpcode", "(", ")", "==", "PPC", "::", "OR", "||", "MI", "->", "getOpcode", "(", ")", "==", "PPC", "::", "OR8", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", "{", "O", "<<", "\"\\tmr \"", ";", "printOperand", "(", "MI", ",", "0", ",", "O", ")", ";", "O", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "1", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "return", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "PPC", "::", "RLDICR", ")", "{", "unsigned", "char", "SH", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "unsigned", "char", "ME", "=", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "if", "(", "63", "-", "SH", "==", "ME", ")", "{", "O", "<<", "\"\\tsldi \"", ";", "printOperand", "(", "MI", ",", "0", ",", "O", ")", ";", "O", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "1", ",", "O", ")", ";", "O", "<<", "\", \"", "<<", "(", "unsigned", "int", ")", "SH", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "return", ";", "}", "}", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]
[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]
[ "PowerPC", "PPC", "PPC::RLWINM", "2", "3", "4", "31", "0", "31", "\"\\tslwi \"", "31", "32", "31", "\"\\tsrwi \"", "32", "0", "\", \"", "1", "\", \"", "PPC::OR", "PPC::OR8", "1", "2", "\"\\tmr \"", "0", "\", \"", "1", "PPC::RLDICR", "2", "3", "63", "\"\\tsldi \"", "0", "\", \"", "1", "\", \"" ]
PPCInstPrinter1
printInst
PowerPC
CPU
LLVM
19,071
388
1
[]
[ "<s>", "unsigned", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "override", "{", "return", "AArch64", "::", "X1", ";", "}", "</s>" ]
[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "typeid", "on", "entry", "to", "a", "landing", "pad", "." ]
[ "AArch64", "AArch64::X1" ]
AArch64ISelLowering (2)
getExceptionSelectorRegister
AArch64
CPU
LLVM
19,072
17
1
[]
[ "<s>", "void", "WebAssemblyTargetAsmStreamer", "::", "emitImportName", "(", "const", "MCSymbolWasm", "*", "Sym", ",", "StringRef", "ImportName", ")", "{", "OS", "<<", "\"\\t.import_name\\t\"", "<<", "Sym", "->", "getName", "(", ")", "<<", "\", \"", "<<", "ImportName", "<<", "'\\n'", ";", "}", "</s>" ]
[ ".import_name" ]
[ "WebAssembly", "WebAssembly", "\"\\t.import_name\\t\"", "\", \"" ]
WebAssemblyTargetStreamer12
emitImportName
WebAssembly
Virtual ISA
LLVM
19,073
31
1
[]
[ "<s>", "bool", "BlackfinTargetLowering", "::", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "{", "return", "false", ";", "}", "</s>" ]
[ "Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "." ]
[ "Blackfin" ]
BlackfinISelLowering
isOffsetFoldingLegal
Blackfin
DSP
LLVM
19,074
16
1
[]
[ "<s>", "Value", "*", "AArch64TargetLowering", "::", "getIRStackGuard", "(", "IRBuilder", "<", ">", "&", "IRB", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "isTargetAndroid", "(", ")", ")", "return", "TargetLowering", "::", "getIRStackGuard", "(", "IRB", ")", ";", "const", "unsigned", "TlsOffset", "=", "0x28", ";", "Module", "*", "M", "=", "IRB", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Function", "*", "ThreadPointerFunc", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Intrinsic", "::", "thread_pointer", ")", ";", "return", "IRB", ".", "CreatePointerCast", "(", "IRB", ".", "CreateConstGEP1_32", "(", "IRB", ".", "CreateCall", "(", "ThreadPointerFunc", ")", ",", "TlsOffset", ")", ",", "Type", "::", "getInt8PtrTy", "(", "IRB", ".", "getContext", "(", ")", ")", "->", "getPointerTo", "(", "0", ")", ")", ";", "}", "</s>" ]
[ "If", "the", "target", "has", "a", "standard", "location", "for", "the", "stack", "protector", "cookie", ",", "returns", "the", "address", "of", "that", "location", "." ]
[ "AArch64", "AArch64", "0x28", "Intrinsic::getDeclaration", "Intrinsic::thread_pointer", "0" ]
AArch64ISelLowering (2)
getIRStackGuard
AArch64
CPU
LLVM
19,075
107
1
[]
[ "<s>", "void", "LC2200AsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "exit", "(", "-", "1", ")", ";", "}", "</s>" ]
[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]
[ "LC2200", "LC2200", "1" ]
LC2200AsmBackend
applyFixup
LC2200
CPU
LLVM
19,076
46
1
[]
[ "<s>", "static", "bool", "rs6000_reg_live_or_pic_offset_p", "(", "int", "reg", ")", "{", "return", "(", "(", "(", "crtl", "->", "calls_eh_return", "||", "df_regs_ever_live_p", "(", "reg", ")", ")", "&&", "(", "!", "call_used_regs", "[", "reg", "]", "||", "(", "reg", "==", "RS6000_PIC_OFFSET_TABLE_REGNUM", "&&", "!", "TARGET_SINGLE_PIC_BASE", "&&", "TARGET_TOC", "&&", "TARGET_MINIMAL_TOC", ")", ")", ")", "||", "(", "reg", "==", "RS6000_PIC_OFFSET_TABLE_REGNUM", "&&", "!", "TARGET_SINGLE_PIC_BASE", "&&", "(", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "flag_pic", "!=", "0", ")", "||", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "flag_pic", ")", ")", ")", ")", ";", "}", "</s>" ]
[ "Determine", "whether", "the", "gp", "REG", "is", "really", "used", "." ]
[ "rs6000", "0" ]
rs60004
rs6000_reg_live_or_pic_offset_p
rs6000
CPU
GCC
19,077
75
1
[]
[ "<s>", "TargetPassConfig", "*", "LC3bTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "LC3bPassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]
[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]
[ "LC3b", "LC3b", "LC3b" ]
LC3bTargetMachine
createPassConfig
LC3b
CPU
LLVM
19,078
21
1
[]
[ "<s>", "unsigned", "X86InstrInfo", "::", "isLoadFromStackSlotPostFE", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "unsigned", "Dummy", ";", "if", "(", "isFrameLoadOpcode", "(", "MI", ".", "getOpcode", "(", ")", ",", "Dummy", ")", ")", "{", "unsigned", "Reg", ";", "if", "(", "(", "Reg", "=", "isLoadFromStackSlot", "(", "MI", ",", "FrameIndex", ")", ")", ")", "return", "Reg", ";", "const", "MachineMemOperand", "*", "Dummy", ";", "return", "hasLoadFromStackSlot", "(", "MI", ",", "Dummy", ",", "FrameIndex", ")", ";", "}", "return", "0", ";", "}", "</s>" ]
[ "isLoadFromStackSlotPostFE", "-", "Check", "for", "post-frame", "ptr", "elimination", "stack", "locations", "as", "well", "." ]
[ "X86", "X86", "0" ]
X86InstrInfo
isLoadFromStackSlotPostFE
X86
CPU
LLVM
19,079
72
1
[]
[ "<s>", "static", "rtx", "m68k_call_tls_get_addr", "(", "rtx", "x", ",", "rtx", "eqv", ",", "enum", "m68k_reloc", "reloc", ")", "{", "rtx", "a0", ";", "rtx_insn", "*", "insns", ";", "rtx", "dest", ";", "start_sequence", "(", ")", ";", "x", "=", "m68k_wrap_symbol", "(", "x", ",", "reloc", ",", "m68k_get_gp", "(", ")", ",", "NULL_RTX", ")", ";", "m68k_libcall_value_in_a0_p", "=", "true", ";", "a0", "=", "emit_library_call_value", "(", "m68k_get_tls_get_addr", "(", ")", ",", "NULL_RTX", ",", "LCT_PURE", ",", "Pmode", ",", "1", ",", "x", ",", "Pmode", ")", ";", "m68k_libcall_value_in_a0_p", "=", "false", ";", "insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_libcall_block", "(", "insns", ",", "dest", ",", "a0", ",", "eqv", ")", ";", "return", "dest", ";", "}", "</s>" ]
[ "Emit", "instruction", "sequence", "that", "calls", "__tls_get_addr", ".", "X", "is", "the", "TLS", "symbol", "we", "are", "referencing", "and", "RELOC", "is", "the", "symbol", "type", "to", "use", "(", "either", "TLSGD", "or", "TLSLDM", ")", ".", "EQV", "is", "the", "REG_EQUAL", "note", "for", "the", "sequence", "emitted", ".", "A", "pseudo", "register", "with", "result", "of", "__tls_get_addr", "call", "is", "returned", "." ]
[ "m68k", "1" ]
m68k4
m68k_call_tls_get_addr
m68k
MPU
GCC
19,080
112
1
[]
[ "<s>", "bool", "SITargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AddrSpace", ",", "unsigned", "Align", ",", "bool", "*", "IsFast", ")", "const", "{", "if", "(", "IsFast", ")", "*", "IsFast", "=", "false", ";", "if", "(", "VT", "==", "MVT", "::", "Other", "||", "(", "VT", "!=", "MVT", "::", "Other", "&&", "VT", ".", "getSizeInBits", "(", ")", ">", "1024", "&&", "VT", ".", "getStoreSize", "(", ")", ">", "16", ")", ")", "{", "return", "false", ";", "}", "if", "(", "AddrSpace", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", "||", "AddrSpace", "==", "AMDGPUAS", "::", "REGION_ADDRESS", ")", "{", "bool", "AlignedBy4", "=", "(", "Align", "%", "4", "==", "0", ")", ";", "if", "(", "IsFast", ")", "*", "IsFast", "=", "AlignedBy4", ";", "return", "AlignedBy4", ";", "}", "if", "(", "!", "Subtarget", "->", "hasUnalignedScratchAccess", "(", ")", "&&", "(", "AddrSpace", "==", "AMDGPUAS", "::", "PRIVATE_ADDRESS", "||", "AddrSpace", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", ")", "{", "return", "false", ";", "}", "if", "(", "Subtarget", "->", "hasUnalignedBufferAccess", "(", ")", ")", "{", "if", "(", "IsFast", ")", "{", "*", "IsFast", "=", "(", "AddrSpace", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS", "||", "AddrSpace", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS_32BIT", ")", "?", "(", "Align", "%", "4", "==", "0", ")", ":", "true", ";", "}", "return", "true", ";", "}", "if", "(", "VT", ".", "bitsLT", "(", "MVT", "::", "i32", ")", ")", "return", "false", ";", "if", "(", "IsFast", ")", "*", "IsFast", "=", "true", ";", "return", "VT", ".", "bitsGT", "(", "MVT", "::", "i32", ")", "&&", "Align", "%", "4", "==", "0", ";", "}", "</s>" ]
[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]
[ "AMDGPU", "SI", "MVT::Other", "MVT::Other", "1024", "16", "AMDGPU", "AMDGPU", "4", "0", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "4", "0", "MVT::i32", "MVT::i32", "4", "0" ]
SIISelLowering17
allowsMisalignedMemoryAccesses
AMDGPU
GPU
LLVM
19,081
219
1
[]
[ "<s>", "SDValue", "SPUTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "unsigned", "Opc", "=", "(", "unsigned", ")", "Op", ".", "getOpcode", "(", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "{", "cerr", "<<", "\"SPUTargetLowering::LowerOperation(): need to lower this!\\n\"", ";", "cerr", "<<", "\"Op.getOpcode() = \"", "<<", "Opc", "<<", "\"\\n\"", ";", "cerr", "<<", "\"*Op.getNode():\\n\"", ";", "Op", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "case", "ISD", "::", "LOAD", ":", "case", "ISD", "::", "EXTLOAD", ":", "case", "ISD", "::", "SEXTLOAD", ":", "case", "ISD", "::", "ZEXTLOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ",", "SPUTM", ".", "getSubtargetImpl", "(", ")", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ",", "SPUTM", ".", "getSubtargetImpl", "(", ")", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ",", "SPUTM", ".", "getSubtargetImpl", "(", ")", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ",", "SPUTM", ".", "getSubtargetImpl", "(", ")", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ",", "SPUTM", ".", "getSubtargetImpl", "(", ")", ")", ";", "case", "ISD", "::", "ConstantFP", ":", "return", "LowerConstantFP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "case", "ISD", "::", "ROTR", ":", "case", "ISD", "::", "ROTL", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "{", "if", "(", "VT", "==", "MVT", "::", "i8", ")", "return", "LowerI8Math", "(", "Op", ",", "DAG", ",", "Opc", ",", "*", "this", ")", ";", "break", ";", "}", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerINT_TO_FP", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SCALAR_TO_VECTOR", ":", "return", "LowerSCALAR_TO_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "LowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "LowerINSERT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "AND", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "return", "LowerByteImmed", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "MUL", ":", "if", "(", "VT", "==", "MVT", "::", "i8", ")", "return", "LowerI8Math", "(", "Op", ",", "DAG", ",", "Opc", ",", "*", "this", ")", ";", "case", "ISD", "::", "CTPOP", ":", "return", "LowerCTPOP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "TRUNCATE", ":", "return", "LowerTRUNCATE", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]
[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]
[ "CellSPU", "SPU", "\"SPUTargetLowering::LowerOperation(): need to lower this!\\n\"", "\"Op.getOpcode() = \"", "\"\\n\"", "\"*Op.getNode():\\n\"", "0", "ISD::LOAD", "ISD::EXTLOAD", "ISD::SEXTLOAD", "ISD::ZEXTLOAD", "SPU", "ISD::STORE", "SPU", "ISD::ConstantPool", "SPU", "ISD::GlobalAddress", "SPU", "ISD::JumpTable", "SPU", "ISD::ConstantFP", "ISD::ADD", "ISD::SUB", "ISD::ROTR", "ISD::ROTL", "ISD::SRL", "ISD::SHL", "ISD::SRA", "MVT::i8", "ISD::FP_TO_SINT", "ISD::FP_TO_UINT", "ISD::SINT_TO_FP", "ISD::UINT_TO_FP", "ISD::BUILD_VECTOR", "ISD::SCALAR_TO_VECTOR", "ISD::VECTOR_SHUFFLE", "ISD::EXTRACT_VECTOR_ELT", "ISD::INSERT_VECTOR_ELT", "ISD::AND", "ISD::OR", "ISD::XOR", "ISD::MUL", "MVT::i8", "ISD::CTPOP", "ISD::SELECT_CC", "ISD::SETCC", "ISD::TRUNCATE" ]
SPUISelLowering8
LowerOperation
CellSPU
MPU
LLVM
19,082
478
1
[]
[ "<s>", "static", "void", "ix86_emit_restore_regs_using_mov", "(", "rtx", "pointer", ",", "HOST_WIDE_INT", "offset", ",", "int", "maybe_eh_return", ")", "{", "int", "regno", ";", "rtx", "base_address", "=", "gen_rtx_MEM", "(", "Pmode", ",", "pointer", ")", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "ix86_save_reg", "(", "regno", ",", "maybe_eh_return", ")", ")", "{", "if", "(", "TARGET_64BIT", "&&", "offset", "!=", "trunc_int_for_mode", "(", "offset", ",", "SImode", ")", ")", "{", "rtx", "r11", ";", "r11", "=", "gen_rtx_REG", "(", "DImode", ",", "FIRST_REX_INT_REG", "+", "3", ")", ";", "emit_move_insn", "(", "r11", ",", "GEN_INT", "(", "offset", ")", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "r11", ",", "r11", ",", "pointer", ")", ")", ";", "base_address", "=", "gen_rtx_MEM", "(", "Pmode", ",", "r11", ")", ";", "offset", "=", "0", ";", "}", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ",", "adjust_address", "(", "base_address", ",", "Pmode", ",", "offset", ")", ")", ";", "offset", "+=", "UNITS_PER_WORD", ";", "}", "}", "</s>" ]
[ "Emit", "code", "to", "restore", "saved", "registers", "using", "MOV", "insns", ".", "First", "register", "is", "restored", "from", "POINTER", "+", "OFFSET", "." ]
[ "i386", "0", "3", "0" ]
i3863
ix86_emit_restore_regs_using_mov
i386
CPU
GCC
19,083
139
1
[]
[ "<s>", "void", "AMDGPUDAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "MachineFrameInfo", "&", "MFI", "=", "CurDAG", "->", "getMachineFunction", "(", ")", ".", "getFrameInfo", "(", ")", ";", "for", "(", "int", "I", "=", "MFI", ".", "getObjectIndexBegin", "(", ")", ",", "E", "=", "MFI", ".", "getObjectIndexEnd", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "SDValue", "FI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "I", ",", "MVT", "::", "i32", ")", ";", "if", "(", "FI", ".", "use_empty", "(", ")", ")", "continue", ";", "SDValue", "EffectiveFI", "=", "FI", ";", "auto", "It", "=", "FI", "->", "use_begin", "(", ")", ";", "if", "(", "It", "->", "getOpcode", "(", ")", "==", "ISD", "::", "AssertZext", "&&", "FI", "->", "hasOneUse", "(", ")", ")", "{", "EffectiveFI", "=", "SDValue", "(", "*", "It", ",", "0", ")", ";", "It", "=", "EffectiveFI", "->", "use_begin", "(", ")", ";", "}", "for", "(", "auto", "It", "=", "EffectiveFI", "->", "use_begin", "(", ")", ";", "!", "It", ".", "atEnd", "(", ")", ";", ")", "{", "SDUse", "&", "Use", "=", "It", ".", "getUse", "(", ")", ";", "SDNode", "*", "User", "=", "Use", ".", "getUser", "(", ")", ";", "unsigned", "OpIdx", "=", "It", ".", "getOperandNo", "(", ")", ";", "++", "It", ";", "if", "(", "MemSDNode", "*", "M", "=", "dyn_cast", "<", "MemSDNode", ">", "(", "User", ")", ")", "{", "unsigned", "PtrIdx", "=", "M", "->", "getOpcode", "(", ")", "==", "ISD", "::", "STORE", "?", "2", ":", "1", ";", "if", "(", "OpIdx", "==", "PtrIdx", ")", "continue", ";", "unsigned", "OpN", "=", "M", "->", "getNumOperands", "(", ")", ";", "SDValue", "NewOps", "[", "8", "]", ";", "assert", "(", "OpN", "<", "array_lengthof", "(", "NewOps", ")", ")", ";", "for", "(", "unsigned", "Op", "=", "0", ";", "Op", "!=", "OpN", ";", "++", "Op", ")", "{", "if", "(", "Op", "!=", "OpIdx", ")", "{", "NewOps", "[", "Op", "]", "=", "M", "->", "getOperand", "(", "Op", ")", ";", "continue", ";", "}", "MachineSDNode", "*", "Mov", "=", "CurDAG", "->", "getMachineNode", "(", "AMDGPU", "::", "V_MOV_B32_e32", ",", "SDLoc", "(", "M", ")", ",", "MVT", "::", "i32", ",", "FI", ")", ";", "NewOps", "[", "Op", "]", "=", "SDValue", "(", "Mov", ",", "0", ")", ";", "}", "CurDAG", "->", "UpdateNodeOperands", "(", "M", ",", "makeArrayRef", "(", "NewOps", ",", "OpN", ")", ")", ";", "}", "}", "}", "}", "</s>" ]
[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]
[ "AMDGPU", "AMDGPU", "MVT::i32", "ISD::AssertZext", "0", "ISD::STORE", "2", "1", "8", "0", "AMDGPU::V_MOV_B32_e32", "MVT::i32", "0" ]
AMDGPUISelDAGToDAG82
PreprocessISelDAG
AMDGPU
GPU
LLVM
19,084
333
1
[]
[ "<s>", "static", "int", "rename_dest", "(", "tag_insn_info", "*", "insn_info", ",", "tag_map_t", "&", "tag_map", ")", "{", "struct", "du_chain", "*", "chain", "=", "NULL", ";", "du_head_p", "head", "=", "NULL", ";", "int", "i", ";", "unsigned", "dest_regno", "=", "REGNO", "(", "insn_info", "->", "dest", ")", ";", "if", "(", "unsafe_rename_p", "(", "dest_regno", ")", ")", "return", "-", "1", ";", "rtx_insn", "*", "insn", "=", "insn_info", "->", "insn", ";", "operand_rr_info", "*", "dest_op_info", "=", "insn_rr", "[", "INSN_UID", "(", "insn", ")", "]", ".", "op_info", ";", "for", "(", "i", "=", "0", ";", "i", "<", "dest_op_info", "->", "n_chains", ";", "i", "++", ")", "{", "if", "(", "dest_op_info", "->", "heads", "[", "i", "]", "->", "regno", "!=", "dest_regno", ")", "continue", ";", "head", "=", "dest_op_info", "->", "heads", "[", "i", "]", ";", "if", "(", "!", "head", "->", "first", ")", "head", "=", "regrename_chain_from_id", "(", "head", "->", "id", ")", ";", "for", "(", "chain", "=", "head", "->", "first", ";", "chain", ";", "chain", "=", "chain", "->", "next_use", ")", "if", "(", "chain", "->", "insn", "==", "insn", ")", "return", "rename_chain", "(", "insn_info", ",", "tag_map", ",", "head", ")", ";", "}", "return", "-", "1", ";", "}", "</s>" ]
[ "Go", "through", "the", "def/use", "chains", "for", "the", "register", "and", "find", "the", "chain", "for", "this", "insn", "to", "rename", ".", "The", "function", "returns", "the", "hard", "register", "number", "in", "case", "of", "a", "successful", "rename", "and", "-1", "otherwise", "." ]
[ "aarch64", "1", "0", "1" ]
falkor-tag-collision-avoidance
rename_dest
aarch64
CPU
GCC
19,085
167
1
[]
[ "<s>", "static", "bool", "avr_return_in_memory", "(", "tree", "type", ",", "tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "BLKmode", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "return", "(", "size", "==", "-", "1", "||", "size", ">", "8", ")", ";", "}", "else", "return", "false", ";", "}", "</s>" ]
[ "Worker", "function", "for", "TARGET_RETURN_IN_MEMORY", "." ]
[ "avr", "1", "8" ]
avr3
avr_return_in_memory
avr
MPU
GCC
19,086
48
1
[]
[ "<s>", "bool", "MipsAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "assert", "(", "OpNum", "+", "1", "<", "MI", "->", "getNumOperands", "(", ")", "&&", "\"Insufficient operands\"", ")", ";", "const", "MachineOperand", "&", "BaseMO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "const", "MachineOperand", "&", "OffsetMO", "=", "MI", "->", "getOperand", "(", "OpNum", "+", "1", ")", ";", "assert", "(", "BaseMO", ".", "isReg", "(", ")", "&&", "\"Unexpected base pointer for inline asm memory operand.\"", ")", ";", "assert", "(", "OffsetMO", ".", "isImm", "(", ")", "&&", "\"Unexpected offset for inline asm memory operand.\"", ")", ";", "int", "Offset", "=", "OffsetMO", ".", "getImm", "(", ")", ";", "if", "(", "ExtraCode", ")", "{", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "case", "'D'", ":", "Offset", "+=", "4", ";", "break", ";", "case", "'M'", ":", "if", "(", "Subtarget", "->", "isLittle", "(", ")", ")", "Offset", "+=", "4", ";", "break", ";", "case", "'L'", ":", "if", "(", "!", "Subtarget", "->", "isLittle", "(", ")", ")", "Offset", "+=", "4", ";", "break", ";", "default", ":", "return", "true", ";", "}", "}", "O", "<<", "Offset", "<<", "\"($\"", "<<", "MipsInstPrinter", "::", "getRegisterName", "(", "BaseMO", ".", "getReg", "(", ")", ")", "<<", "\")\"", ";", "return", "false", ";", "}", "</s>" ]
[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]
[ "Mips", "Mips", "1", "\"Insufficient operands\"", "1", "\"Unexpected base pointer for inline asm memory operand.\"", "\"Unexpected offset for inline asm memory operand.\"", "0", "4", "4", "4", "\"($\"", "Mips", "\")\"" ]
MipsAsmPrinter25
PrintAsmMemoryOperand
Mips
CPU
LLVM
19,087
185
1
[]
[ "<s>", "void", "Thumb1InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "assert", "(", "(", "RC", "==", "ARM", "::", "tGPRRegisterClass", "||", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "DestReg", ")", "&&", "isARMLowRegister", "(", "DestReg", ")", ")", ")", "&&", "\"Unknown regclass!\"", ")", ";", "if", "(", "RC", "==", "ARM", "::", "tGPRRegisterClass", "||", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "DestReg", ")", "&&", "isARMLowRegister", "(", "DestReg", ")", ")", ")", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tLDRspi", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "}", "}", "</s>" ]
[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]
[ "ARM", "ARM::tGPRRegisterClass", "ARM", "\"Unknown regclass!\"", "ARM::tGPRRegisterClass", "ARM", "ARM::tLDRspi", "0" ]
Thumb1InstrInfo4
loadRegFromStackSlot
ARM
CPU
LLVM
19,088
197
1
[]
[ "<s>", "void", "rvexTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sbss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "}", "</s>" ]
[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]
[ "rvex", "rvex", "\".sdata\"", "\".sbss\"" ]
rvexTargetObjectFile
Initialize
rvex
VLIW
LLVM
19,089
83
1
[]
[ "<s>", "bool", "MipsAsmParser", "::", "processInstruction", "(", "MCInst", "&", "Inst", ",", "SMLoc", "IDLoc", ",", "SmallVectorImpl", "<", "MCInst", ">", "&", "Instructions", ")", "{", "const", "MCInstrDesc", "&", "MCID", "=", "getInstDesc", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "if", "(", "MCID", ".", "hasDelaySlot", "(", ")", "&&", "Options", ".", "isReorder", "(", ")", ")", "{", "Instructions", ".", "push_back", "(", "Inst", ")", ";", "MCInst", "NopInst", ";", "NopInst", ".", "setOpcode", "(", "Mips", "::", "SLL", ")", ";", "NopInst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "Mips", "::", "ZERO", ")", ")", ";", "NopInst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "Mips", "::", "ZERO", ")", ")", ";", "NopInst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "0", ")", ")", ";", "Instructions", ".", "push_back", "(", "NopInst", ")", ";", "return", "false", ";", "}", "if", "(", "MCID", ".", "mayLoad", "(", ")", "||", "MCID", ".", "mayStore", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MCID", ".", "getNumOperands", "(", ")", ";", "i", "++", ")", "{", "const", "MCOperandInfo", "&", "OpInfo", "=", "MCID", ".", "OpInfo", "[", "i", "]", ";", "if", "(", "(", "OpInfo", ".", "OperandType", "==", "MCOI", "::", "OPERAND_MEMORY", ")", "||", "(", "OpInfo", ".", "OperandType", "==", "MCOI", "::", "OPERAND_UNKNOWN", ")", ")", "{", "MCOperand", "&", "Op", "=", "Inst", ".", "getOperand", "(", "i", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "int", "MemOffset", "=", "Op", ".", "getImm", "(", ")", ";", "if", "(", "MemOffset", "<", "-", "32768", "||", "MemOffset", ">", "32767", ")", "{", "expandMemInst", "(", "Inst", ",", "IDLoc", ",", "Instructions", ",", "MCID", ".", "mayLoad", "(", ")", ",", "true", ")", ";", "return", "false", ";", "}", "}", "else", "if", "(", "Op", ".", "isExpr", "(", ")", ")", "{", "const", "MCExpr", "*", "Expr", "=", "Op", ".", "getExpr", "(", ")", ";", "if", "(", "Expr", "->", "getKind", "(", ")", "==", "MCExpr", "::", "SymbolRef", ")", "{", "const", "MCSymbolRefExpr", "*", "SR", "=", "static_cast", "<", "const", "MCSymbolRefExpr", "*", ">", "(", "Expr", ")", ";", "if", "(", "SR", "->", "getKind", "(", ")", "==", "MCSymbolRefExpr", "::", "VK_None", ")", "{", "expandMemInst", "(", "Inst", ",", "IDLoc", ",", "Instructions", ",", "MCID", ".", "mayLoad", "(", ")", ",", "false", ")", ";", "return", "false", ";", "}", "}", "else", "if", "(", "!", "isEvaluated", "(", "Expr", ")", ")", "{", "expandMemInst", "(", "Inst", ",", "IDLoc", ",", "Instructions", ",", "MCID", ".", "mayLoad", "(", ")", ",", "false", ")", ";", "return", "false", ";", "}", "}", "}", "}", "}", "if", "(", "needsExpansion", "(", "Inst", ")", ")", "expandInstruction", "(", "Inst", ",", "IDLoc", ",", "Instructions", ")", ";", "else", "Instructions", ".", "push_back", "(", "Inst", ")", ";", "return", "false", ";", "}", "</s>" ]
[ "Process", "a", "single", "instruction", "and", "collect", "debug", "info", "anchors", "." ]
[ "Mips", "Mips", "Mips::SLL", "Mips::ZERO", "Mips::ZERO", "0", "0", "32768", "32767" ]
MipsAsmParser64
processInstruction
Mips
CPU
LLVM
19,090
405
1
[]
[ "<s>", "void", "fr30_expand_epilogue", "(", "void", ")", "{", "int", "regno", ";", "gcc_assert", "(", "current_frame_info", ".", "initialised", ")", ";", "if", "(", "current_frame_info", ".", "frame_size", ">", "0", ")", "{", "if", "(", "current_frame_info", ".", "save_fp", "&&", "frame_pointer_needed", ")", "{", "emit_insn", "(", "gen_leave_func", "(", ")", ")", ";", "current_frame_info", ".", "save_fp", "=", "0", ";", "}", "else", "if", "(", "current_frame_info", ".", "frame_size", "<=", "508", ")", "emit_insn", "(", "gen_add_to_stack", "(", "GEN_INT", "(", "current_frame_info", ".", "frame_size", ")", ")", ")", ";", "else", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "PROLOGUE_TMP_REGNUM", ")", ";", "emit_insn", "(", "gen_movsi", "(", "tmp", ",", "GEN_INT", "(", "current_frame_info", ".", "frame_size", ")", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "tmp", ")", ")", ";", "}", "}", "if", "(", "current_frame_info", ".", "save_fp", ")", "emit_insn", "(", "gen_movsi_pop", "(", "frame_pointer_rtx", ")", ")", ";", "if", "(", "current_frame_info", ".", "save_rp", ")", "emit_insn", "(", "gen_movsi_pop", "(", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_POINTER_REGNUM", ")", ")", ")", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "STACK_POINTER_REGNUM", ";", "regno", "++", ")", "if", "(", "current_frame_info", ".", "gmask", "&", "(", "1", "<<", "regno", ")", ")", "emit_insn", "(", "gen_movsi_pop", "(", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ")", ")", ";", "if", "(", "current_frame_info", ".", "pretend_size", ")", "emit_insn", "(", "gen_add_to_stack", "(", "GEN_INT", "(", "current_frame_info", ".", "pretend_size", ")", ")", ")", ";", "current_frame_info", "=", "zero_frame_info", ";", "emit_jump_insn", "(", "gen_return_from_func", "(", ")", ")", ";", "}", "</s>" ]
[ "Called", "after", "register", "allocation", "to", "add", "any", "instructions", "needed", "for", "the", "epilogue", ".", "Using", "an", "epilogue", "insn", "is", "favored", "compared", "to", "putting", "all", "of", "the", "instructions", "in", "output_function_epilogue", "(", ")", ",", "since", "it", "allows", "the", "scheduler", "to", "intermix", "instructions", "with", "the", "restores", "of", "the", "caller", "saved", "registers", ".", "In", "some", "cases", ",", "it", "might", "be", "necessary", "to", "emit", "a", "barrier", "instruction", "as", "the", "first", "insn", "to", "prevent", "such", "scheduling", "." ]
[ "fr30", "0", "0", "508", "0", "1" ]
fr30
fr30_expand_epilogue
fr30
DSP
GCC
19,091
213
1
[]
[ "<s>", "static", "parallel", "*", "nvptx_discover_pars", "(", "bb_insn_map_t", "*", "map", ")", "{", "basic_block", "block", ";", "block", "=", "EXIT_BLOCK_PTR_FOR_FN", "(", "cfun", ")", ";", "block", "->", "flags", "|=", "BB_VISITED", ";", "block", "=", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", ";", "block", "->", "flags", "&=", "~", "BB_VISITED", ";", "parallel", "*", "par", "=", "nvptx_find_par", "(", "map", ",", "0", ",", "block", ")", ";", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\"\\nLoops\\n\"", ")", ";", "nvptx_dump_pars", "(", "par", ",", "0", ")", ";", "fprintf", "(", "dump_file", ",", "\"\\n\"", ")", ";", "}", "return", "par", ";", "}", "</s>" ]
[ "See", "also", "'gcc/omp-oacc-neuter-broadcast.cc", ":", "omp_sese_discover_pars", "'", "." ]
[ "nvptx", "0", "\"\\nLoops\\n\"", "0", "\"\\n\"" ]
nvptx
nvptx_discover_pars
nvptx
GPU
GCC
19,092
84
1
[]
[ "<s>", "static", "bool", "dep_between_memop_and_curr", "(", "rtx", "memop", ")", "{", "rtx", "load_reg", ";", "int", "opno", ";", "gcc_assert", "(", "GET_CODE", "(", "memop", ")", "==", "SET", ")", ";", "if", "(", "!", "REG_P", "(", "SET_DEST", "(", "memop", ")", ")", ")", "return", "false", ";", "load_reg", "=", "SET_DEST", "(", "memop", ")", ";", "for", "(", "opno", "=", "1", ";", "opno", "<", "recog_data", ".", "n_operands", ";", "opno", "++", ")", "{", "rtx", "operand", "=", "recog_data", ".", "operand", "[", "opno", "]", ";", "if", "(", "REG_P", "(", "operand", ")", "&&", "reg_overlap_mentioned_p", "(", "load_reg", ",", "operand", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]
[ "Check", "if", "there", "is", "a", "register", "dependency", "between", "a", "load", "and", "the", "insn", "for", "which", "we", "hold", "recog_data", "." ]
[ "aarch64", "1" ]
aarch64
dep_between_memop_and_curr
aarch64
CPU
GCC
19,093
93
1
[]
[ "<s>", "int", "hard_regno_mode_ok", "(", "int", "regno", ",", "enum", "machine_mode", "mode", ")", "{", "enum", "reg_class", "class", "=", "REGNO_REG_CLASS", "(", "regno", ")", ";", "if", "(", "mode", "==", "CCmode", ")", "return", "0", ";", "if", "(", "mode", "==", "V2HImode", ")", "return", "D_REGNO_P", "(", "regno", ")", ";", "if", "(", "class", "==", "CCREGS", ")", "return", "mode", "==", "BImode", ";", "if", "(", "mode", "==", "PDImode", ")", "return", "regno", "==", "REG_A0", "||", "regno", "==", "REG_A1", ";", "if", "(", "mode", "==", "SImode", "&&", "TEST_HARD_REG_BIT", "(", "reg_class_contents", "[", "PROLOGUE_REGS", "]", ",", "regno", ")", ")", "return", "1", ";", "return", "TEST_HARD_REG_BIT", "(", "reg_class_contents", "[", "MOST_REGS", "]", ",", "regno", ")", ";", "}", "</s>" ]
[ "Value", "is", "1", "if", "hard", "register", "REGNO", "can", "hold", "a", "value", "of", "machine-mode", "MODE", "." ]
[ "bfin", "0", "1" ]
bfin2
hard_regno_mode_ok
bfin
DSP
GCC
19,094
98
1
[]
[ "<s>", "bool", "ARM64CollectLOH", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "TM", ".", "getRegisterInfo", "(", ")", ";", "const", "MachineDominatorTree", "*", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MapRegToId", "RegToId", ";", "MapIdToReg", "IdToReg", ";", "ARM64FunctionInfo", "*", "ARM64FI", "=", "MF", ".", "getInfo", "<", "ARM64FunctionInfo", ">", "(", ")", ";", "assert", "(", "ARM64FI", "&&", "\"No MachineFunctionInfo for this function!\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Looking for LOH in \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "collectInvolvedReg", "(", "MF", ",", "RegToId", ",", "IdToReg", ",", "TRI", ")", ";", "if", "(", "RegToId", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineInstr", "*", "DummyOp", "=", "nullptr", ";", "if", "(", "BasicBlockScopeOnly", ")", "{", "const", "ARM64InstrInfo", "*", "TII", "=", "static_cast", "<", "const", "ARM64InstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "DummyOp", "=", "MF", ".", "CreateMachineInstr", "(", "TII", "->", "get", "(", "ARM64", "::", "COPY", ")", ",", "DebugLoc", "(", ")", ")", ";", "}", "unsigned", "NbReg", "=", "RegToId", ".", "size", "(", ")", ";", "bool", "Modified", "=", "false", ";", "InstrToInstrs", "*", "ColorOpToReachedUses", "=", "new", "InstrToInstrs", "[", "NbReg", "]", ";", "reachingDef", "(", "MF", ",", "ColorOpToReachedUses", ",", "RegToId", ",", "true", ",", "DummyOp", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"ADRP reaching defs\\n\"", ")", ";", "DEBUG", "(", "printReachingDef", "(", "ColorOpToReachedUses", ",", "NbReg", ",", "TRI", ",", "IdToReg", ")", ")", ";", "InstrToInstrs", "ADRPToReachingDefs", ";", "reachedUsesToDefs", "(", "ADRPToReachingDefs", ",", "ColorOpToReachedUses", ",", "RegToId", ",", "true", ")", ";", "computeADRP", "(", "ADRPToReachingDefs", ",", "*", "ARM64FI", ",", "MDT", ")", ";", "delete", "[", "]", "ColorOpToReachedUses", ";", "ColorOpToReachedUses", "=", "new", "InstrToInstrs", "[", "NbReg", "]", ";", "reachingDef", "(", "MF", ",", "ColorOpToReachedUses", ",", "RegToId", ",", "false", ",", "DummyOp", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"All reaching defs\\n\"", ")", ";", "DEBUG", "(", "printReachingDef", "(", "ColorOpToReachedUses", ",", "NbReg", ",", "TRI", ",", "IdToReg", ")", ")", ";", "InstrToInstrs", "UsesToReachingDefs", ";", "reachedUsesToDefs", "(", "UsesToReachingDefs", ",", "ColorOpToReachedUses", ",", "RegToId", ",", "false", ")", ";", "computeOthers", "(", "UsesToReachingDefs", ",", "ColorOpToReachedUses", ",", "*", "ARM64FI", ",", "RegToId", ",", "MDT", ")", ";", "delete", "[", "]", "ColorOpToReachedUses", ";", "if", "(", "BasicBlockScopeOnly", ")", "MF", ".", "DeleteMachineInstr", "(", "DummyOp", ")", ";", "return", "Modified", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "ARM64", "ARM64", "ARM64", "ARM64", "ARM64", "ARM64", "\"No MachineFunctionInfo for this function!\"", "\"Looking for LOH in \"", "ARM64", "ARM64", "ARM64::COPY", "\"ADRP reaching defs\\n\"", "ARM64", "\"All reaching defs\\n\"", "ARM64" ]
ARM64CollectLOH
runOnMachineFunction
ARM64
CPU
LLVM
19,095
342
1
[]
[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Remove sign extends\"", ";", "}", "</s>" ]
[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]
[ "Hexagon", "\"Remove sign extends\"" ]
HexagonOptimizeSZextends (2)
getPassName
Hexagon
DSP
LLVM
19,096
11
1
[]
[ "<s>", "void", "ARMConstantIslands", "::", "verify", "(", ")", "{", "assert", "(", "std", "::", "is_sorted", "(", "MF", "->", "begin", "(", ")", ",", "MF", "->", "end", "(", ")", ",", "[", "this", "]", "(", "const", "MachineBasicBlock", "&", "LHS", ",", "const", "MachineBasicBlock", "&", "RHS", ")", "{", "return", "BBInfo", "[", "LHS", ".", "getNumber", "(", ")", "]", ".", "postOffset", "(", ")", "<", "BBInfo", "[", "RHS", ".", "getNumber", "(", ")", "]", ".", "postOffset", "(", ")", ";", "}", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Verifying \"", "<<", "CPUsers", ".", "size", "(", ")", "<<", "\" CP users.\\n\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CPUsers", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CPUser", "&", "U", "=", "CPUsers", "[", "i", "]", ";", "unsigned", "UserOffset", "=", "getUserOffset", "(", "U", ")", ";", "if", "(", "isCPEntryInRange", "(", "U", ".", "MI", ",", "UserOffset", ",", "U", ".", "CPEMI", ",", "U", ".", "getMaxDisp", "(", ")", "+", "2", ",", "U", ".", "NegOk", ",", "true", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"OK\\n\"", ")", ";", "continue", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Out of range.\\n\"", ")", ";", "dumpBBs", "(", ")", ";", "LLVM_DEBUG", "(", "MF", "->", "dump", "(", ")", ")", ";", "llvm_unreachable", "(", "\"Constant pool entry out of range!\"", ")", ";", "}", "}", "</s>" ]
[ "Check", "if", "this", "register", "bank", "is", "valid", "." ]
[ "ARM", "ARM", "\"Verifying \"", "\" CP users.\\n\"", "0", "2", "\"OK\\n\"", "\"Out of range.\\n\"", "\"Constant pool entry out of range!\"" ]
ARMConstantIslandPass
verify
ARM
CPU
LLVM
19,097
199
1
[]
[ "<s>", "static", "bool", "reg_used_in_mem_p", "(", "int", "regno", ",", "rtx", "x", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "int", "i", ",", "j", ";", "const", "char", "*", "fmt", ";", "if", "(", "code", "==", "MEM", ")", "{", "if", "(", "refers_to_regno_p", "(", "regno", ",", "regno", "+", "1", ",", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "return", "true", ";", "}", "else", "if", "(", "code", "==", "SET", "&&", "GET_CODE", "(", "SET_DEST", "(", "x", ")", ")", "==", "PC", ")", "{", "if", "(", "refers_to_regno_p", "(", "regno", ",", "regno", "+", "1", ",", "SET_SRC", "(", "x", ")", ",", "0", ")", ")", "return", "true", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "code", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "code", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "reg_used_in_mem_p", "(", "regno", ",", "XEXP", "(", "x", ",", "i", ")", ")", ")", "return", "true", ";", "else", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "for", "(", "j", "=", "0", ";", "j", "<", "XVECLEN", "(", "x", ",", "i", ")", ";", "j", "++", ")", "if", "(", "reg_used_in_mem_p", "(", "regno", ",", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]
[ "Returns", "true", "if", "register", "REGNO", "is", "used", "for", "forming", "a", "memory", "address", "in", "expression", "X", "." ]
[ "s390", "1", "0", "0", "1", "0", "1", "0", "0" ]
s3903
reg_used_in_mem_p
s390
MPU
GCC
19,098
203
1
[]
[ "<s>", "bool", "RISCVMergeBaseOffsetOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "skipFunction", "(", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "ST", "=", "&", "Fn", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "DeadInstrs", ".", "clear", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "Fn", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"MBB: \"", "<<", "MBB", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "for", "(", "MachineInstr", "&", "HiLUI", ":", "MBB", ")", "{", "MachineInstr", "*", "LoADDI", "=", "nullptr", ";", "if", "(", "!", "detectLuiAddiGlobal", "(", "HiLUI", ",", "LoADDI", ")", ")", "continue", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" Found lowered global address with one use: \"", "<<", "*", "LoADDI", "->", "getOperand", "(", "2", ")", ".", "getGlobal", "(", ")", "<<", "\"\\n\"", ")", ";", "MadeChange", "|=", "detectAndFoldOffset", "(", "HiLUI", ",", "*", "LoADDI", ")", ";", "}", "}", "for", "(", "auto", "*", "MI", ":", "DeadInstrs", ")", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "RISCV", "RISCV", "RISCV", "\"MBB: \"", "\"\\n\"", "\" Found lowered global address with one use: \"", "2", "\"\\n\"" ]
RISCVMergeBaseOffset4
runOnMachineFunction
RISCV
CPU
LLVM
19,099
162
1
[]