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>", "void", "ARMPassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "getARMSubtarget", "(", ")", ".", "isThumb2", "(", ")", ")", "{", "if", "(", "!", "getARMSubtarget", "(", ")", ".", "prefers32BitThumb", "(", ")", ")", "addPass", "(", "createThumb2SizeReductionPass", "(", ")", ")", ";", "addPass", "(", "&", "UnpackMachineBundlesID", ")", ";", "}", "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", "ARM" ]
ARMTargetMachine25
addPreEmitPass
ARM
CPU
LLVM
12,600
58
1
[]
[ "<s>", "static", "std", "::", "unique_ptr", "<", "AArch64Operand", ">", "CreateReg", "(", "unsigned", "RegNum", ",", "bool", "isVector", ",", "SMLoc", "S", ",", "SMLoc", "E", ",", "MCContext", "&", "Ctx", ")", "{", "auto", "Op", "=", "make_unique", "<", "AArch64Operand", ">", "(", "k_Register", ",", "Ctx", ")", ";", "Op", "->", "Reg", ".", "RegNum", "=", "RegNum", ";", "Op", "->", "Reg", ".", "isVector", "=", "isVector", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]
[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]
[ "AArch64", "AArch64", "AArch64" ]
AArch64AsmParser (2)1
CreateReg
AArch64
CPU
LLVM
12,601
71
1
[]
[ "<s>", "bool", "aarch64_emit_approx_div", "(", "rtx", "quo", ",", "rtx", "num", ",", "rtx", "den", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "quo", ")", ";", "if", "(", "GET_MODE_INNER", "(", "mode", ")", "==", "HFmode", ")", "return", "false", ";", "bool", "use_approx_division_p", "=", "(", "flag_mlow_precision_div", "||", "(", "aarch64_tune_params", ".", "approx_modes", "->", "division", "&", "AARCH64_APPROX_MODE", "(", "mode", ")", ")", ")", ";", "if", "(", "!", "flag_finite_math_only", "||", "flag_trapping_math", "||", "!", "flag_unsafe_math_optimizations", "||", "optimize_function_for_size_p", "(", "cfun", ")", "||", "!", "use_approx_division_p", ")", "return", "false", ";", "rtx", "xrcp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "(", "*", "get_recpe_type", "(", "mode", ")", ")", "(", "xrcp", ",", "den", ")", ")", ";", "int", "iterations", "=", "(", "GET_MODE_INNER", "(", "mode", ")", "==", "DFmode", ")", "?", "3", ":", "2", ";", "if", "(", "flag_mlow_precision_div", ")", "iterations", "--", ";", "rtx", "xtmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "while", "(", "iterations", "--", ")", "{", "emit_insn", "(", "(", "*", "get_recps_type", "(", "mode", ")", ")", "(", "xtmp", ",", "xrcp", ",", "den", ")", ")", ";", "if", "(", "iterations", ">", "0", ")", "emit_set_insn", "(", "xrcp", ",", "gen_rtx_MULT", "(", "mode", ",", "xrcp", ",", "xtmp", ")", ")", ";", "}", "if", "(", "num", "!=", "CONST1_RTX", "(", "mode", ")", ")", "{", "rtx", "xnum", "=", "force_reg", "(", "mode", ",", "num", ")", ";", "emit_set_insn", "(", "xrcp", ",", "gen_rtx_MULT", "(", "mode", ",", "xrcp", ",", "xnum", ")", ")", ";", "}", "emit_set_insn", "(", "quo", ",", "gen_rtx_MULT", "(", "mode", ",", "xrcp", ",", "xtmp", ")", ")", ";", "return", "true", ";", "}", "</s>" ]
[ "Emit", "the", "instruction", "sequence", "to", "compute", "the", "approximation", "for", "the", "division", "of", "NUM", "by", "DEN", "in", "QUO", "and", "return", "whether", "the", "sequence", "was", "emitted", "or", "not", "." ]
[ "aarch64", "3", "2", "0" ]
aarch644
aarch64_emit_approx_div
aarch64
CPU
GCC
12,602
227
1
[]
[ "<s>", "bool", "PPCFastISel", "::", "tryToFoldLoadIntoMI", "(", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "LoadInst", "*", "LI", ")", "{", "MVT", "VT", ";", "if", "(", "!", "isLoadTypeLegal", "(", "LI", "->", "getType", "(", ")", ",", "VT", ")", ")", "return", "false", ";", "bool", "IsZExt", "=", "false", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "PPC", "::", "RLDICL", ":", "case", "PPC", "::", "RLDICL_32_64", ":", "{", "IsZExt", "=", "true", ";", "unsigned", "MB", "=", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "i8", "&&", "MB", "<=", "56", ")", "||", "(", "VT", "==", "MVT", "::", "i16", "&&", "MB", "<=", "48", ")", "||", "(", "VT", "==", "MVT", "::", "i32", "&&", "MB", "<=", "32", ")", ")", "break", ";", "return", "false", ";", "}", "case", "PPC", "::", "RLWINM", ":", "case", "PPC", "::", "RLWINM8", ":", "{", "IsZExt", "=", "true", ";", "unsigned", "MB", "=", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "i8", "&&", "MB", "<=", "24", ")", "||", "(", "VT", "==", "MVT", "::", "i16", "&&", "MB", "<=", "16", ")", ")", "break", ";", "return", "false", ";", "}", "case", "PPC", "::", "EXTSB", ":", "case", "PPC", "::", "EXTSB8", ":", "case", "PPC", "::", "EXTSB8_32_64", ":", "return", "false", ";", "case", "PPC", "::", "EXTSH", ":", "case", "PPC", "::", "EXTSH8", ":", "case", "PPC", "::", "EXTSH8_32_64", ":", "{", "if", "(", "VT", "!=", "MVT", "::", "i16", "&&", "VT", "!=", "MVT", "::", "i8", ")", "return", "false", ";", "break", ";", "}", "case", "PPC", "::", "EXTSW", ":", "case", "PPC", "::", "EXTSW_32", ":", "case", "PPC", "::", "EXTSW_32_64", ":", "{", "if", "(", "VT", "!=", "MVT", "::", "i32", "&&", "VT", "!=", "MVT", "::", "i16", "&&", "VT", "!=", "MVT", "::", "i8", ")", "return", "false", ";", "break", ";", "}", "}", "Address", "Addr", ";", "if", "(", "!", "PPCComputeAddress", "(", "LI", "->", "getOperand", "(", "0", ")", ",", "Addr", ")", ")", "return", "false", ";", "unsigned", "ResultReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "PPCEmitLoad", "(", "VT", ",", "ResultReg", ",", "Addr", ",", "nullptr", ",", "IsZExt", ",", "PPCSubTarget", "->", "hasSPE", "(", ")", "?", "PPC", "::", "EVLDD", ":", "PPC", "::", "LFD", ")", ")", "return", "false", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]
[ "The", "specified", "machine", "instr", "operand", "is", "a", "vreg", ",", "and", "that", "vreg", "is", "being", "provided", "by", "the", "specified", "load", "instruction", "." ]
[ "PowerPC", "PPC", "PPC::RLDICL", "PPC::RLDICL_32_64", "3", "MVT::i8", "56", "MVT::i16", "48", "MVT::i32", "32", "PPC::RLWINM", "PPC::RLWINM8", "3", "MVT::i8", "24", "MVT::i16", "16", "PPC::EXTSB", "PPC::EXTSB8", "PPC::EXTSB8_32_64", "PPC::EXTSH", "PPC::EXTSH8", "PPC::EXTSH8_32_64", "MVT::i16", "MVT::i8", "PPC::EXTSW", "PPC::EXTSW_32", "PPC::EXTSW_32_64", "MVT::i32", "MVT::i16", "MVT::i8", "PPC", "0", "0", "PPC", "PPC", "PPC::EVLDD", "PPC::LFD" ]
PPCFastISel46
tryToFoldLoadIntoMI
PowerPC
CPU
LLVM
12,603
366
1
[]
[ "<s>", "VESubtarget", "&", "VESubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "std", "::", "string", "CPUName", "=", "std", "::", "string", "(", "CPU", ")", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"ve\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "CPU", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]
[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]
[ "VE", "VE", "VE", "\"ve\"" ]
VESubtarget1
initializeSubtargetDependencies
VE
CPU
LLVM
12,604
51
1
[]
[ "<s>", "void", "M680x0FrameLowering", "::", "BuildCFI", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "const", "MCCFIInstruction", "&", "CFIInst", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "CFIInst", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "</s>" ]
[ "Wraps", "up", "getting", "a", "CFI", "index", "and", "building", "a", "MachineInstr", "for", "it", "." ]
[ "M680x0", "M680x0" ]
M680x0FrameLowering
BuildCFI
M680x0
MPU
LLVM
12,605
71
1
[]
[ "<s>", "void", "ConvergingVLIWScheduler", "::", "schedNode", "(", "SUnit", "*", "SU", ",", "bool", "IsTopNode", ")", "{", "if", "(", "IsTopNode", ")", "{", "Top", ".", "bumpNode", "(", "SU", ")", ";", "SU", "->", "TopReadyCycle", "=", "Top", ".", "CurrCycle", ";", "}", "else", "{", "Bot", ".", "bumpNode", "(", "SU", ")", ";", "SU", "->", "BotReadyCycle", "=", "Bot", ".", "CurrCycle", ";", "}", "}", "</s>" ]
[ "ScheduleDAGMI", "has", "scheduled", "an", "instruction", "-", "tell", "HazardRec", "about", "it", "." ]
[ "Hexagon" ]
HexagonMachineScheduler11
schedNode
Hexagon
DSP
LLVM
12,606
53
1
[]
[ "<s>", "poly_int64", "riscv_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "poly_int64", "src", ",", "dest", ";", "riscv_compute_frame_info", "(", ")", ";", "if", "(", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "dest", "=", "cfun", "->", "machine", "->", "frame", ".", "hard_frame_pointer_offset", ";", "else", "if", "(", "to", "==", "STACK_POINTER_REGNUM", ")", "dest", "=", "0", ";", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", ")", "src", "=", "cfun", "->", "machine", "->", "frame", ".", "frame_pointer_offset", ";", "else", "if", "(", "from", "==", "ARG_POINTER_REGNUM", ")", "src", "=", "cfun", "->", "machine", "->", "frame", ".", "arg_pointer_offset", ";", "else", "gcc_unreachable", "(", ")", ";", "return", "src", "-", "dest", ";", "}", "</s>" ]
[ "Implement", "INITIAL_ELIMINATION_OFFSET", ".", "FROM", "is", "either", "the", "frame", "pointer", "or", "argument", "pointer", ".", "TO", "is", "either", "the", "stack", "pointer", "or", "hard", "frame", "pointer", "." ]
[ "riscv", "0" ]
riscv1
riscv_initial_elimination_offset
riscv
CPU
GCC
12,607
95
1
[]
[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "if", "(", "Expr", "==", "0", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "0", ")", ")", ";", "else", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]
[ "Add", "a", "new", "MCExpr", "operand", "." ]
[ "SystemZ", "0", "0" ]
SystemZAsmParser10
addExpr
SystemZ
CPU
LLVM
12,608
78
1
[]
[ "<s>", "bool", "NVPTXDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ";", "switch", "(", "ConstraintID", ")", "{", "default", ":", "return", "true", ";", "case", "InlineAsm", "::", "Constraint_m", ":", "if", "(", "SelectDirectAddr", "(", "Op", ",", "Op0", ")", ")", "{", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "MVT", "::", "i32", ")", ")", ";", "return", "false", ";", "}", "if", "(", "SelectADDRri", "(", "Op", ".", "getNode", "(", ")", ",", "Op", ",", "Op0", ",", "Op1", ")", ")", "{", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "return", "false", ";", "}", "break", ";", "}", "return", "true", ";", "}", "</s>" ]
[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]
[ "NVPTX", "NVPTX", "0", "MVT::i32" ]
NVPTXISelDAGToDAG15
SelectInlineAsmMemoryOperand
NVPTX
GPU
LLVM
12,609
123
1
[]
[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "switch", "(", "Kind", ")", "{", "case", "Immediate", ":", "OS", "<<", "*", "getImm", "(", ")", ";", "break", ";", "case", "Register", ":", "OS", "<<", "\"<register x\"", ";", "OS", "<<", "getReg", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "}", "}", "</s>" ]
[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]
[ "RV16K", "\"<register x\"", "\">\"", "\"'\"", "\"'\"" ]
RV16KAsmParser
print
RV16K
Virtual ISA
LLVM
12,610
61
1
[]
[ "<s>", "int", "aarch64_branch_cost", "(", "bool", "speed_p", ",", "bool", "predictable_p", ")", "{", "const", "struct", "cpu_branch_cost", "*", "branch_costs", "=", "aarch64_tune_params", ".", "branch_costs", ";", "if", "(", "!", "speed_p", "||", "predictable_p", ")", "return", "branch_costs", "->", "predictable", ";", "else", "return", "branch_costs", "->", "unpredictable", ";", "}", "</s>" ]
[ "Return", "the", "cost", "of", "a", "branch", ".", "If", "SPEED_P", "is", "true", "then", "the", "compiler", "is", "optimizing", "for", "speed", ".", "If", "PREDICTABLE_P", "is", "true", "then", "the", "branch", "is", "predicted", "to", "be", "taken", "." ]
[ "aarch64" ]
aarch64
aarch64_branch_cost
aarch64
CPU
GCC
12,611
39
1
[]
[ "<s>", "static", "void", "ix86_pad_returns", "(", "void", ")", "{", "edge", "e", ";", "edge_iterator", "ei", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "EXIT_BLOCK_PTR", "->", "preds", ")", "{", "basic_block", "bb", "=", "e", "->", "src", ";", "rtx", "ret", "=", "BB_END", "(", "bb", ")", ";", "rtx", "prev", ";", "bool", "replace", "=", "false", ";", "if", "(", "GET_CODE", "(", "ret", ")", "!=", "JUMP_INSN", "||", "GET_CODE", "(", "PATTERN", "(", "ret", ")", ")", "!=", "RETURN", "||", "!", "maybe_hot_bb_p", "(", "bb", ")", ")", "continue", ";", "for", "(", "prev", "=", "PREV_INSN", "(", "ret", ")", ";", "prev", ";", "prev", "=", "PREV_INSN", "(", "prev", ")", ")", "if", "(", "active_insn_p", "(", "prev", ")", "||", "GET_CODE", "(", "prev", ")", "==", "CODE_LABEL", ")", "break", ";", "if", "(", "prev", "&&", "GET_CODE", "(", "prev", ")", "==", "CODE_LABEL", ")", "{", "edge", "e", ";", "edge_iterator", "ei", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "bb", "->", "preds", ")", "if", "(", "EDGE_FREQUENCY", "(", "e", ")", "&&", "e", "->", "src", "->", "index", ">=", "0", "&&", "!", "(", "e", "->", "flags", "&", "EDGE_FALLTHRU", ")", ")", "replace", "=", "true", ";", "}", "if", "(", "!", "replace", ")", "{", "prev", "=", "prev_active_insn", "(", "ret", ")", ";", "if", "(", "prev", "&&", "(", "(", "GET_CODE", "(", "prev", ")", "==", "JUMP_INSN", "&&", "any_condjump_p", "(", "prev", ")", ")", "||", "GET_CODE", "(", "prev", ")", "==", "CALL_INSN", ")", ")", "replace", "=", "true", ";", "if", "(", "!", "prev", "&&", "cfun", "->", "function_frequency", ">", "FUNCTION_FREQUENCY_UNLIKELY_EXECUTED", ")", "replace", "=", "true", ";", "}", "if", "(", "replace", ")", "{", "emit_insn_before", "(", "gen_return_internal_long", "(", ")", ",", "ret", ")", ";", "delete_insn", "(", "ret", ")", ";", "}", "}", "}", "</s>" ]
[ "AMD", "Athlon", "works", "faster", "when", "RET", "is", "not", "destination", "of", "conditional", "jump", "or", "directly", "preceded", "by", "other", "jump", "instruction", ".", "We", "avoid", "the", "penalty", "by", "inserting", "NOP", "just", "before", "the", "RET", "instructions", "in", "such", "cases", "." ]
[ "i386", "0" ]
i3863
ix86_pad_returns
i386
CPU
GCC
12,612
247
1
[]
[ "<s>", "Triple", "::", "ObjectFormatType", "getFormat", "(", ")", "const", "override", "{", "return", "Triple", "::", "Hex", ";", "}", "</s>" ]
[ "Return", "the", "DWARF", "format", "of", "this", "table", "." ]
[ "LC2200" ]
LC2200HexObjectWriter
getFormat
LC2200
CPU
LLVM
12,613
15
1
[]
[ "<s>", "bool", "R600InstrInfo", "::", "fitsConstReadLimitations", "(", "const", "std", "::", "vector", "<", "MachineInstr", "*", ">", "&", "MIs", ")", "const", "{", "std", "::", "vector", "<", "unsigned", ">", "Consts", ";", "SmallSet", "<", "int64_t", ",", "4", ">", "Literals", ";", "for", "(", "MachineInstr", "*", "MI", ":", "MIs", ")", "{", "if", "(", "!", "isALUInstr", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "continue", ";", "for", "(", "const", "auto", "&", "Src", ":", "getSrcs", "(", "*", "MI", ")", ")", "{", "if", "(", "Src", ".", "first", "->", "getReg", "(", ")", "==", "R600", "::", "ALU_LITERAL_X", ")", "Literals", ".", "insert", "(", "Src", ".", "second", ")", ";", "if", "(", "Literals", ".", "size", "(", ")", ">", "4", ")", "return", "false", ";", "if", "(", "Src", ".", "first", "->", "getReg", "(", ")", "==", "R600", "::", "ALU_CONST", ")", "Consts", ".", "push_back", "(", "Src", ".", "second", ")", ";", "if", "(", "R600", "::", "R600_KC0RegClass", ".", "contains", "(", "Src", ".", "first", "->", "getReg", "(", ")", ")", "||", "R600", "::", "R600_KC1RegClass", ".", "contains", "(", "Src", ".", "first", "->", "getReg", "(", ")", ")", ")", "{", "unsigned", "Index", "=", "RI", ".", "getEncodingValue", "(", "Src", ".", "first", "->", "getReg", "(", ")", ")", "&", "0xff", ";", "unsigned", "Chan", "=", "RI", ".", "getHWRegChan", "(", "Src", ".", "first", "->", "getReg", "(", ")", ")", ";", "Consts", ".", "push_back", "(", "(", "Index", "<<", "2", ")", "|", "Chan", ")", ";", "}", "}", "}", "return", "fitsConstReadLimitations", "(", "Consts", ")", ";", "}", "</s>" ]
[ "Same", "but", "using", "const", "index", "set", "instead", "of", "MI", "set", "." ]
[ "AMDGPU", "R600", "4", "R600::ALU_LITERAL_X", "4", "R600::ALU_CONST", "R600::R600_KC0RegClass", "R600::R600_KC1RegClass", "0xff", "2" ]
R600InstrInfo17
fitsConstReadLimitations
AMDGPU
GPU
LLVM
12,614
220
1
[]
[ "<s>", "bool", "SystemZFrameInfo", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "SystemZ", "::", "FP64RegClass", ".", "contains", "(", "Reg", ")", ")", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "FP64RegClass", ",", "TRI", ")", ";", "}", "unsigned", "LowReg", "=", "MFI", "->", "getLowReg", "(", ")", ",", "HighReg", "=", "MFI", "->", "getHighReg", "(", ")", ";", "unsigned", "StartOffset", "=", "RegSpillOffsets", "[", "LowReg", "]", ";", "if", "(", "StartOffset", ")", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "(", "LowReg", "==", "HighReg", "?", "SystemZ", "::", "MOV64rm", ":", "SystemZ", "::", "MOV64rmm", ")", ")", ")", ";", "MIB", ".", "addReg", "(", "LowReg", ",", "RegState", "::", "Define", ")", ";", "if", "(", "LowReg", "!=", "HighReg", ")", "MIB", ".", "addReg", "(", "HighReg", ",", "RegState", "::", "Define", ")", ";", "MIB", ".", "addReg", "(", "hasFP", "(", "MF", ")", "?", "SystemZ", "::", "R11D", ":", "SystemZ", "::", "R15D", ")", ";", "MIB", ".", "addImm", "(", "StartOffset", ")", ";", "if", "(", "LowReg", "==", "HighReg", ")", "MIB", ".", "addReg", "(", "0", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "!=", "LowReg", "&&", "Reg", "!=", "HighReg", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]
[ "restoreCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "restore", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "load", "instructions", "via", "loadRegToStackSlot", "(", ")", "." ]
[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "0", "SystemZ::FP64RegClass", "SystemZ::FP64RegClass", "SystemZ::MOV64rm", "SystemZ::MOV64rmm", "SystemZ::R11D", "SystemZ::R15D", "0", "0" ]
SystemZFrameInfo
restoreCalleeSavedRegisters
SystemZ
CPU
LLVM
12,615
366
1
[]
[ "<s>", "const", "char", "*", "nds32_output_16bit_store", "(", "rtx", "*", "operands", ",", "int", "byte", ")", "{", "char", "pattern", "[", "100", "]", ";", "char", "size", ";", "rtx", "code", "=", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ";", "size", "=", "nds32_byte_to_size", "(", "byte", ")", ";", "switch", "(", "nds32_mem_format", "(", "operands", "[", "0", "]", ")", ")", "{", "case", "ADDRESS_REG", ":", "operands", "[", "0", "]", "=", "code", ";", "output_asm_insn", "(", "\"swi450\\t%1, [%0]\"", ",", "operands", ")", ";", "break", ";", "case", "ADDRESS_LO_REG_IMM3U", ":", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"s%ci333\\t%%1, %%0\"", ",", "size", ")", ";", "output_asm_insn", "(", "pattern", ",", "operands", ")", ";", "break", ";", "case", "ADDRESS_POST_INC_LO_REG_IMM3U", ":", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"swi333.bi\\t%%1, %%0, 4\"", ")", ";", "output_asm_insn", "(", "pattern", ",", "operands", ")", ";", "break", ";", "case", "ADDRESS_POST_MODIFY_LO_REG_IMM3U", ":", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"swi333.bi\\t%%1, %%0\"", ")", ";", "output_asm_insn", "(", "pattern", ",", "operands", ")", ";", "break", ";", "case", "ADDRESS_FP_IMM7U", ":", "output_asm_insn", "(", "\"swi37\\t%1, %0\"", ",", "operands", ")", ";", "break", ";", "case", "ADDRESS_SP_IMM7U", ":", "operands", "[", "0", "]", "=", "XEXP", "(", "code", ",", "1", ")", ";", "output_asm_insn", "(", "\"swi37.sp\\t%1, [ + (%0)]\"", ",", "operands", ")", ";", "break", ";", "default", ":", "break", ";", "}", "return", "\"\"", ";", "}", "</s>" ]
[ "Output", "16-bit", "store", "." ]
[ "nds32", "100", "0", "0", "0", "0", "\"swi450\\t%1, [%0]\"", "\"s%ci333\\t%%1, %%0\"", "\"swi333.bi\\t%%1, %%0, 4\"", "\"swi333.bi\\t%%1, %%0\"", "\"swi37\\t%1, %0\"", "0", "1", "\"swi37.sp\\t%1, [ + (%0)]\"", "\"\"" ]
nds32-md-auxiliary
nds32_output_16bit_store
nds32
CPU
GCC
12,616
191
1
[]
[ "<s>", "static", "Scope", "::", "Scope", "getScope", "(", "SyncScope", "::", "ID", "Ord", ")", "{", "switch", "(", "Ord", ")", "{", "case", "SyncScope", "::", "SingleThread", ":", "return", "Scope", "::", "Invocation", ";", "case", "SyncScope", "::", "System", ":", "return", "Scope", "::", "Device", ";", "default", ":", "llvm_unreachable", "(", "\"Unsupported synchronization Scope ID.\"", ")", ";", "}", "}", "</s>" ]
[ "Get", "the", "local", "scope", "for", "this", "variable", "." ]
[ "SPIRV", "\"Unsupported synchronization Scope ID.\"" ]
SPIRVInstructionSelector1
getScope
SPIRV
Virtual ISA
LLVM
12,617
46
1
[]
[ "<s>", "unsigned", "PPCInstrInfo", "::", "lookThruCopyLike", "(", "unsigned", "SrcReg", ",", "const", "MachineRegisterInfo", "*", "MRI", ")", "{", "while", "(", "true", ")", "{", "MachineInstr", "*", "MI", "=", "MRI", "->", "getVRegDef", "(", "SrcReg", ")", ";", "if", "(", "!", "MI", "->", "isCopyLike", "(", ")", ")", "return", "SrcReg", ";", "unsigned", "CopySrcReg", ";", "if", "(", "MI", "->", "isCopy", "(", ")", ")", "CopySrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "else", "{", "assert", "(", "MI", "->", "isSubregToReg", "(", ")", "&&", "\"Bad opcode for lookThruCopyLike\"", ")", ";", "CopySrcReg", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "if", "(", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "CopySrcReg", ")", ")", "return", "CopySrcReg", ";", "SrcReg", "=", "CopySrcReg", ";", "}", "}", "</s>" ]
[ "Returns", "the", "original", "SrcReg", "unless", "it", "is", "the", "target", "of", "a", "copy-like", "operation", ",", "in", "which", "case", "we", "chain", "backwards", "through", "all", "such", "operations", "to", "the", "ultimate", "source", "register", "." ]
[ "PowerPC", "PPC", "1", "\"Bad opcode for lookThruCopyLike\"", "2" ]
PPCInstrInfo102
lookThruCopyLike
PowerPC
CPU
LLVM
12,618
112
1
[]
[ "<s>", "unsigned", "BPFMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "MRI", ".", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "assert", "(", "Expr", "->", "getKind", "(", ")", "==", "MCExpr", "::", "SymbolRef", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "BPF", "::", "JAL", ")", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "Expr", ",", "FK_PCRel_4", ")", ")", ";", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "BPF", "::", "LD_imm64", ")", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "Expr", ",", "FK_SecRel_8", ")", ")", ";", "else", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "Expr", ",", "FK_PCRel_2", ")", ")", ";", "return", "0", ";", "}", "</s>" ]
[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]
[ "BPF", "BPF", "BPF::JAL", "0", "BPF::LD_imm64", "0", "0", "0" ]
BPFMCCodeEmitter (2)1
getMachineOpValue
BPF
Virtual ISA
LLVM
12,619
181
1
[]
[ "<s>", "const", "char", "*", "loongarch_output_probe_stack_range", "(", "rtx", "reg1", ",", "rtx", "reg2", ",", "rtx", "reg3", ")", "{", "static", "int", "labelno", "=", "0", ";", "char", "loop_lab", "[", "32", "]", ",", "tmp", "[", "64", "]", ";", "rtx", "xops", "[", "3", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "loop_lab", ",", "\"LPSRL\"", ",", "labelno", "++", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "loop_lab", ")", ";", "xops", "[", "0", "]", "=", "reg1", ";", "xops", "[", "1", "]", "=", "GEN_INT", "(", "-", "PROBE_INTERVAL", ")", ";", "xops", "[", "2", "]", "=", "reg3", ";", "if", "(", "TARGET_64BIT", ")", "output_asm_insn", "(", "\"sub.d\\t%0,%0,%2\"", ",", "xops", ")", ";", "else", "output_asm_insn", "(", "\"sub.w\\t%0,%0,%2\"", ",", "xops", ")", ";", "xops", "[", "1", "]", "=", "reg2", ";", "strcpy", "(", "tmp", ",", "\"bne\\t%0,%1,\"", ")", ";", "if", "(", "TARGET_64BIT", ")", "output_asm_insn", "(", "\"st.d\\t$r0,%0,0\"", ",", "xops", ")", ";", "else", "output_asm_insn", "(", "\"st.w\\t$r0,%0,0\"", ",", "xops", ")", ";", "output_asm_insn", "(", "strcat", "(", "tmp", ",", "&", "loop_lab", "[", "1", "]", ")", ",", "xops", ")", ";", "return", "\"\"", ";", "}", "</s>" ]
[ "Probe", "a", "range", "of", "stack", "addresses", "from", "REG1", "to", "REG2", "inclusive", ".", "These", "are", "absolute", "addresses", "." ]
[ "loongarch", "0", "32", "64", "3", "\"LPSRL\"", "0", "1", "2", "\"sub.d\\t%0,%0,%2\"", "\"sub.w\\t%0,%0,%2\"", "1", "\"bne\\t%0,%1,\"", "\"st.d\\t$r0,%0,0\"", "\"st.w\\t$r0,%0,0\"", "1", "\"\"" ]
loongarch
loongarch_output_probe_stack_range
loongarch
CPU
GCC
12,620
152
1
[]
[ "<s>", "void", "MipsFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MipsInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "SP", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "SP_64", ":", "Mips", "::", "SP", ";", "unsigned", "FP", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "FP_64", ":", "Mips", "::", "FP", ";", "unsigned", "ZERO", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "ZERO_64", ":", "Mips", "::", "ZERO", ";", "unsigned", "ADDu", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "DADDu", ":", "Mips", "::", "ADDu", ";", "unsigned", "ADDiu", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "DADDiu", ":", "Mips", "::", "ADDiu", ";", "unsigned", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "NewReg", "=", "0", ";", "int", "NewImm", "=", "0", ";", "bool", "ATUsed", "=", "false", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBBI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MFI", "->", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ";", "++", "i", ")", "--", "I", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "ADDu", ")", ",", "SP", ")", ".", "addReg", "(", "FP", ")", ".", "addReg", "(", "ZERO", ")", ";", "}", "if", "(", "StackSize", ")", "{", "ATUsed", "=", "expandRegLargeImmPair", "(", "SP", ",", "StackSize", ",", "NewReg", ",", "NewImm", ",", "MBB", ",", "MBBI", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ADDiu", ")", ",", "SP", ")", ".", "addReg", "(", "NewReg", ")", ".", "addImm", "(", "NewImm", ")", ";", "if", "(", "ATUsed", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ATMACRO", ")", ")", ";", "}", "}", "</s>" ]
[ "Insert", "epilog", "code", "into", "the", "function", "." ]
[ "Mips", "Mips", "Mips", "Mips", "Mips::SP_64", "Mips::SP", "Mips::FP_64", "Mips::FP", "Mips::ZERO_64", "Mips::ZERO", "Mips::DADDu", "Mips::ADDu", "Mips::DADDiu", "Mips::ADDiu", "0", "0", "0", "Mips::ATMACRO" ]
MipsFrameLowering4
emitEpilogue
Mips
CPU
LLVM
12,621
321
1
[]
[ "<s>", "static", "int", "rs6000_debug_address_cost", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "addr_space_t", "as", ",", "bool", "speed", ")", "{", "int", "ret", "=", "TARGET_ADDRESS_COST", "(", "x", ",", "mode", ",", "as", ",", "speed", ")", ";", "fprintf", "(", "stderr", ",", "\"\\nrs6000_address_cost, return = %d, speed = %s, x:\\n\"", ",", "ret", ",", "speed", "?", "\"true\"", ":", "\"false\"", ")", ";", "debug_rtx", "(", "x", ")", ";", "return", "ret", ";", "}", "</s>" ]
[ "Debug", "form", "of", "ADDRESS_COST", "that", "is", "selected", "if", "-mdebug=cost", "." ]
[ "rs6000", "\"\\nrs6000_address_cost, return = %d, speed = %s, x:\\n\"", "\"true\"", "\"false\"" ]
rs6000
rs6000_debug_address_cost
rs6000
CPU
GCC
12,622
55
1
[]
[ "<s>", "static", "void", "nvptx_file_end", "(", "void", ")", "{", "hash_table", "<", "tree_hasher", ">", "::", "iterator", "iter", ";", "tree", "decl", ";", "FOR_EACH_HASH_TABLE_ELEMENT", "(", "*", "needed_fndecls_htab", ",", "decl", ",", "tree", ",", "iter", ")", "nvptx_record_fndecl", "(", "decl", ")", ";", "fputs", "(", "func_decls", ".", "str", "(", ")", ".", "c_str", "(", ")", ",", "asm_out_file", ")", ";", "if", "(", "worker_bcast_size", ")", "write_worker_buffer", "(", "asm_out_file", ",", "worker_bcast_sym", ",", "worker_bcast_align", ",", "worker_bcast_size", ")", ";", "if", "(", "worker_red_size", ")", "write_worker_buffer", "(", "asm_out_file", ",", "worker_red_sym", ",", "worker_red_align", ",", "worker_red_size", ")", ";", "}", "</s>" ]
[ "Write", "out", "the", "function", "declarations", "we", "'ve", "collected", "." ]
[ "nvptx" ]
nvptx3
nvptx_file_end
nvptx
GPU
GCC
12,623
80
1
[]
[ "<s>", "static", "const", "char", "*", "output_move_simode_const", "(", "rtx", "*", "operands", ")", "{", "rtx", "dest", ";", "HOST_WIDE_INT", "src", ";", "dest", "=", "operands", "[", "0", "]", ";", "src", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "src", "==", "0", "&&", "(", "DATA_REG_P", "(", "dest", ")", "||", "MEM_P", "(", "dest", ")", ")", "&&", "(", "(", "TARGET_68010", "||", "TARGET_COLDFIRE", ")", "||", "!", "(", "MEM_P", "(", "dest", ")", "&&", "MEM_VOLATILE_P", "(", "dest", ")", ")", ")", ")", "return", "\"clr%.l %0\"", ";", "else", "if", "(", "GET_MODE", "(", "dest", ")", "==", "SImode", "&&", "valid_mov3q_const", "(", "src", ")", ")", "return", "\"mov3q%.l %1,%0\"", ";", "else", "if", "(", "src", "==", "0", "&&", "ADDRESS_REG_P", "(", "dest", ")", ")", "return", "\"sub%.l %0,%0\"", ";", "else", "if", "(", "DATA_REG_P", "(", "dest", ")", ")", "return", "output_move_const_into_data_reg", "(", "operands", ")", ";", "else", "if", "(", "ADDRESS_REG_P", "(", "dest", ")", "&&", "IN_RANGE", "(", "src", ",", "-", "0x8000", ",", "0x7fff", ")", ")", "{", "if", "(", "valid_mov3q_const", "(", "src", ")", ")", "return", "\"mov3q%.l %1,%0\"", ";", "return", "\"move%.w %1,%0\"", ";", "}", "else", "if", "(", "MEM_P", "(", "dest", ")", "&&", "GET_CODE", "(", "XEXP", "(", "dest", ",", "0", ")", ")", "==", "PRE_DEC", "&&", "REGNO", "(", "XEXP", "(", "XEXP", "(", "dest", ",", "0", ")", ",", "0", ")", ")", "==", "STACK_POINTER_REGNUM", "&&", "IN_RANGE", "(", "src", ",", "-", "0x8000", ",", "0x7fff", ")", ")", "{", "if", "(", "valid_mov3q_const", "(", "src", ")", ")", "return", "\"mov3q%.l %1,%-\"", ";", "return", "\"pea %a1\"", ";", "}", "return", "\"move%.l %1,%0\"", ";", "}", "</s>" ]
[ "Return", "an", "instruction", "to", "move", "CONST_INT", "OPERANDS", "[", "1", "]", "into", "OPERANDS", "[", "0", "]", ".", "I", "is", "the", "value", "of", "OPERANDS", "[", "1", "]", "." ]
[ "m68k", "0", "1", "0", "\"clr%.l %0\"", "\"mov3q%.l %1,%0\"", "0", "\"sub%.l %0,%0\"", "0x8000", "0x7fff", "\"mov3q%.l %1,%0\"", "\"move%.w %1,%0\"", "0", "0", "0", "0x8000", "0x7fff", "\"mov3q%.l %1,%-\"", "\"pea %a1\"", "\"move%.l %1,%0\"" ]
m68k
output_move_simode_const
m68k
MPU
GCC
12,624
222
1
[]
[ "<s>", "void", "mmix_asm_output_aligned_common", "(", "FILE", "*", "stream", ",", "const", "char", "*", "name", ",", "int", "size", ",", "int", "align", ")", "{", "fprintf", "(", "stream", ",", "\"\\t.comm\\t\"", ")", ";", "assemble_name", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\",%u,%u ! mmixal-incompatible COMMON\\n\"", ",", "size", ",", "align", "/", "BITS_PER_UNIT", ")", ";", "}", "</s>" ]
[ "ASM_OUTPUT_ALIGNED_COMMON", "." ]
[ "mmix", "\"\\t.comm\\t\"", "\",%u,%u ! mmixal-incompatible COMMON\\n\"" ]
mmix
mmix_asm_output_aligned_common
mmix
CPU
GCC
12,625
47
1
[]
[ "<s>", "bool", "ARMAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", ";", "bool", "PendConditionalInstruction", "=", "false", ";", "SmallVector", "<", "NearMissInfo", ",", "4", ">", "NearMisses", ";", "MatchResult", "=", "MatchInstruction", "(", "Operands", ",", "Inst", ",", "NearMisses", ",", "MatchingInlineAsm", ",", "PendConditionalInstruction", ",", "Out", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Parsed as: \"", ";", "Inst", ".", "dump_pretty", "(", "dbgs", "(", ")", ",", "MII", ".", "getName", "(", "Inst", ".", "getOpcode", "(", ")", ")", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "validateInstruction", "(", "Inst", ",", "Operands", ")", ")", "{", "forwardITPosition", "(", ")", ";", "return", "true", ";", "}", "{", "bool", "wasInITBlock", "=", "inITBlock", "(", ")", ";", "while", "(", "processInstruction", "(", "Inst", ",", "Operands", ",", "Out", ")", ")", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Changed to: \"", ";", "Inst", ".", "dump_pretty", "(", "dbgs", "(", ")", ",", "MII", ".", "getName", "(", "Inst", ".", "getOpcode", "(", ")", ")", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "wasInITBlock", "&&", "hasV8Ops", "(", ")", "&&", "isThumb", "(", ")", "&&", "!", "isV8EligibleForIT", "(", "&", "Inst", ")", ")", "{", "Warning", "(", "IDLoc", ",", "\"deprecated instruction in IT block\"", ")", ";", "}", "}", "forwardITPosition", "(", ")", ";", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "ITasm", ")", "return", "false", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "if", "(", "PendConditionalInstruction", ")", "{", "PendingConditionalInsts", ".", "push_back", "(", "Inst", ")", ";", "if", "(", "isITBlockFull", "(", ")", "||", "isITBlockTerminator", "(", "Inst", ")", ")", "flushPendingInstructions", "(", "Out", ")", ";", "}", "else", "{", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "}", "return", "false", ";", "case", "Match_NearMisses", ":", "ReportNearMisses", "(", "NearMisses", ",", "IDLoc", ",", "Operands", ")", ";", "return", "true", ";", "case", "Match_MnemonicFail", ":", "{", "FeatureBitset", "FBS", "=", "ComputeAvailableFeatures", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", ")", ";", "std", "::", "string", "Suggestion", "=", "ARMMnemonicSpellCheck", "(", "(", "(", "ARMOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getToken", "(", ")", ",", "FBS", ")", ";", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", "+", "Suggestion", ",", "(", "(", "ARMOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getLocRange", "(", ")", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]
[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]
[ "ARM", "ARM", "4", "\"Parsed as: \"", "\"\\n\"", "\"Changed to: \"", "\"\\n\"", "\"deprecated instruction in IT block\"", "ARM::ITasm", "ARM", "ARM", "0", "\"invalid instruction\"", "ARM", "0", "\"Implement any new match types added!\"" ]
ARMAsmParser116
MatchAndEmitInstruction
ARM
CPU
LLVM
12,626
373
1
[]
[ "<s>", "void", "R600TTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "CommonTTI", ".", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ")", ";", "}", "</s>" ]
[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]
[ "AMDGPU", "R600" ]
AMDGPUTargetTransformInfo1
getUnrollingPreferences
AMDGPU
GPU
LLVM
12,627
32
1
[]
[ "<s>", "bool", "SIPreEmitPeephole", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "MF", ".", "RenumberBlocks", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "::", "iterator", "TermI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "if", "(", "TermI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "MachineInstr", "&", "MI", "=", "*", "TermI", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "S_CBRANCH_VCCZ", ":", "case", "AMDGPU", "::", "S_CBRANCH_VCCNZ", ":", "Changed", "|=", "optimizeVccBranch", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "S_CBRANCH_EXECZ", ":", "Changed", "|=", "removeExeczBranch", "(", "MI", ",", "MBB", ")", ";", "break", ";", "}", "}", "if", "(", "!", "ST", ".", "hasVGPRIndexMode", "(", ")", ")", "continue", ";", "MachineInstr", "*", "SetGPRMI", "=", "nullptr", ";", "const", "unsigned", "Threshold", "=", "20", ";", "unsigned", "Count", "=", "0", ";", "for", "(", "auto", "&", "MI", ":", "make_early_inc_range", "(", "make_range", "(", "MBB", ".", "instr_begin", "(", ")", ",", "MBB", ".", "instr_end", "(", ")", ")", ")", ")", "{", "if", "(", "Count", "==", "Threshold", ")", "SetGPRMI", "=", "nullptr", ";", "else", "++", "Count", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "S_SET_GPR_IDX_ON", ")", "continue", ";", "Count", "=", "0", ";", "if", "(", "!", "SetGPRMI", ")", "{", "SetGPRMI", "=", "&", "MI", ";", "continue", ";", "}", "if", "(", "optimizeSetGPR", "(", "*", "SetGPRMI", ",", "MI", ")", ")", "Changed", "=", "true", ";", "else", "SetGPRMI", "=", "&", "MI", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "AMDGPU", "SI", "AMDGPU::S_CBRANCH_VCCZ", "AMDGPU::S_CBRANCH_VCCNZ", "AMDGPU::S_CBRANCH_EXECZ", "20", "0", "AMDGPU::S_SET_GPR_IDX_ON", "0" ]
SIPreEmitPeephole
runOnMachineFunction
AMDGPU
GPU
LLVM
12,628
261
1
[]
[ "<s>", "enum", "reg_class", "ix86_preferred_reload_class", "(", "rtx", "x", ",", "enum", "reg_class", "class", ")", "{", "if", "(", "class", "==", "NO_REGS", ")", "return", "NO_REGS", ";", "if", "(", "x", "==", "CONST0_RTX", "(", "GET_MODE", "(", "x", ")", ")", ")", "return", "class", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", "&&", "GET_MODE", "(", "x", ")", "!=", "VOIDmode", ")", "{", "if", "(", "reg_class_subset_p", "(", "class", ",", "GENERAL_REGS", ")", ")", "return", "class", ";", "if", "(", "TARGET_80387", "&&", "(", "TARGET_MIX_SSE_I387", "||", "!", "(", "TARGET_SSE_MATH", "&&", "SSE_FLOAT_MODE_P", "(", "GET_MODE", "(", "x", ")", ")", ")", ")", "&&", "standard_80387_constant_p", "(", "x", ")", ")", "{", "if", "(", "class", "==", "FLOAT_SSE_REGS", ")", "return", "FLOAT_REGS", ";", "if", "(", "class", "==", "FP_TOP_SSE_REGS", ")", "return", "FP_TOP_REG", ";", "if", "(", "class", "==", "FP_SECOND_SSE_REGS", ")", "return", "FP_SECOND_REG", ";", "if", "(", "class", "==", "FLOAT_INT_REGS", "||", "class", "==", "FLOAT_REGS", ")", "return", "class", ";", "}", "return", "NO_REGS", ";", "}", "if", "(", "MAYBE_MMX_CLASS_P", "(", "class", ")", "&&", "CONSTANT_P", "(", "x", ")", ")", "return", "NO_REGS", ";", "if", "(", "MAYBE_SSE_CLASS_P", "(", "class", ")", "&&", "CONSTANT_P", "(", "x", ")", ")", "return", "NO_REGS", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "return", "reg_class_subset_p", "(", "class", ",", "GENERAL_REGS", ")", "?", "class", ":", "NO_REGS", ";", "if", "(", "GET_MODE", "(", "x", ")", "==", "QImode", "&&", "!", "CONSTANT_P", "(", "x", ")", ")", "{", "if", "(", "reg_class_subset_p", "(", "class", ",", "Q_REGS", ")", ")", "return", "class", ";", "if", "(", "reg_class_subset_p", "(", "Q_REGS", ",", "class", ")", ")", "return", "Q_REGS", ";", "return", "NO_REGS", ";", "}", "return", "class", ";", "}", "</s>" ]
[ "Put", "float", "CONST_DOUBLE", "in", "the", "constant", "pool", "instead", "of", "fp", "regs", ".", "QImode", "must", "go", "into", "class", "Q_REGS", ".", "Narrow", "ALL_REGS", "to", "GENERAL_REGS", ".", "This", "supports", "allowing", "movsf", "and", "movdf", "to", "do", "mem-to-mem", "moves", "through", "integer", "regs", "." ]
[ "i386" ]
i3863
ix86_preferred_reload_class
i386
CPU
GCC
12,629
236
1
[]
[ "<s>", "MCELFStreamer", "&", "getStreamer", "(", ")", "{", "return", "static_cast", "<", "MCELFStreamer", "&", ">", "(", "Streamer", ")", ";", "}", "</s>" ]
[ "Return", "the", "output", "streamer", "for", "the", "assembler", "." ]
[ "MCS51" ]
MCS51ELFStreamer
getStreamer
MCS51
MPU
LLVM
12,630
17
1
[]
[ "<s>", "static", "reg_class_t", "xtensa_preferred_reload_class", "(", "rtx", "x", ",", "reg_class_t", "rclass", ")", "{", "if", "(", "CONSTANT_P", "(", "x", ")", "&&", "CONST_DOUBLE_P", "(", "x", ")", ")", "return", "NO_REGS", ";", "if", "(", "rclass", "==", "AR_REGS", "||", "rclass", "==", "GR_REGS", ")", "return", "RL_REGS", ";", "return", "rclass", ";", "}", "</s>" ]
[ "Worker", "function", "for", "TARGET_PREFERRED_RELOAD_CLASS", "." ]
[ "xtensa" ]
xtensa
xtensa_preferred_reload_class
xtensa
MPU
GCC
12,631
43
1
[]
[ "<s>", "bool", "RISCVAsmBackend", "::", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "{", "if", "(", "Fixup", ".", "getKind", "(", ")", ">=", "FirstLiteralRelocationKind", ")", "return", "true", ";", "switch", "(", "Fixup", ".", "getTargetKind", "(", ")", ")", "{", "default", ":", "break", ";", "case", "FK_Data_1", ":", "case", "FK_Data_2", ":", "case", "FK_Data_4", ":", "case", "FK_Data_8", ":", "if", "(", "Target", ".", "isAbsolute", "(", ")", ")", "return", "false", ";", "break", ";", "case", "RISCV", "::", "fixup_riscv_got_hi20", ":", "case", "RISCV", "::", "fixup_riscv_tls_got_hi20", ":", "case", "RISCV", "::", "fixup_riscv_tls_gd_hi20", ":", "return", "true", ";", "case", "RISCV", "::", "fixup_pulpv2_loop_setup", ":", "case", "RISCV", "::", "fixup_pulpv2_loop_setupi", ":", "return", "false", ";", "}", "return", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureRelax", "]", "||", "ForceRelocs", ";", "}", "</s>" ]
[ "Hook", "to", "check", "if", "a", "relocation", "is", "needed", "for", "some", "target", "specific", "reason", "." ]
[ "RI5CY", "RISCV", "RISCV::fixup_riscv_got_hi20", "RISCV::fixup_riscv_tls_got_hi20", "RISCV::fixup_riscv_tls_gd_hi20", "RISCV::fixup_pulpv2_loop_setup", "RISCV::fixup_pulpv2_loop_setupi", "RISCV::FeatureRelax" ]
RISCVAsmBackend
shouldForceRelocation
RI5CY
CPU
LLVM
12,632
119
1
[]
[ "<s>", "bool", "HexagonGenPredicate", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "PredGPRs", ".", "clear", "(", ")", ";", "PUsers", ".", "clear", "(", ")", ";", "G2P", ".", "clear", "(", ")", ";", "bool", "Changed", "=", "false", ";", "collectPredicateGPR", "(", "MF", ")", ";", "for", "(", "SetOfReg", "::", "iterator", "I", "=", "PredGPRs", ".", "begin", "(", ")", ",", "E", "=", "PredGPRs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "processPredicateGPR", "(", "*", "I", ")", ";", "bool", "Again", ";", "do", "{", "Again", "=", "false", ";", "VectOfInst", "Processed", ",", "Copy", ";", "Copy", "=", "PUsers", ";", "for", "(", "MachineInstr", "*", "MI", ":", "Copy", ")", "{", "bool", "Done", "=", "convertToPredForm", "(", "MI", ")", ";", "if", "(", "Done", ")", "{", "Processed", ".", "insert", "(", "MI", ")", ";", "Again", "=", "true", ";", "}", "}", "Changed", "|=", "Again", ";", "auto", "Done", "=", "[", "Processed", "]", "(", "MachineInstr", "*", "MI", ")", "->", "bool", "{", "return", "Processed", ".", "count", "(", "MI", ")", ";", "}", ";", "PUsers", ".", "remove_if", "(", "Done", ")", ";", "}", "while", "(", "Again", ")", ";", "Changed", "|=", "eliminatePredCopies", "(", "MF", ")", ";", "return", "Changed", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "Hexagon", "Hexagon", "Hexagon", "Hexagon" ]
HexagonGenPredicate3
runOnMachineFunction
Hexagon
DSP
LLVM
12,633
230
1
[]
[ "<s>", "static", "bool", "mips_return_in_memory", "(", "tree", "type", ",", "tree", "fndecl", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_OLDABI", ")", "return", "(", "TYPE_MODE", "(", "type", ")", "==", "BLKmode", ")", ";", "else", "return", "(", "(", "int_size_in_bytes", "(", "type", ")", ">", "(", "2", "*", "UNITS_PER_WORD", ")", ")", "||", "(", "int_size_in_bytes", "(", "type", ")", "==", "-", "1", ")", ")", ";", "}", "</s>" ]
[ "Implement", "TARGET_RETURN_IN_MEMORY", ".", "Under", "the", "old", "(", "i.e.", ",", "32", "and", "O64", "ABIs", ")", "all", "BLKmode", "objects", "are", "returned", "in", "memory", ".", "Under", "the", "new", "(", "N32", "and", "64-bit", "MIPS", "ABIs", ")", "small", "structures", "are", "returned", "in", "a", "register", ".", "Objects", "with", "varying", "size", "must", "still", "be", "returned", "in", "memory", ",", "of", "course", "." ]
[ "mips", "2", "1" ]
mips3
mips_return_in_memory
mips
CPU
GCC
12,634
54
1
[]
[ "<s>", "bool", "MCS51InstrInfo", "::", "isBranchOffsetInRange", "(", "unsigned", "BranchOp", ",", "int64_t", "BrOffset", ")", "const", "{", "switch", "(", "BranchOp", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unexpected opcode!\"", ")", ";", "case", "MCS51", "::", "JMPk", ":", "case", "MCS51", "::", "CALLk", ":", "return", "true", ";", "case", "MCS51", "::", "RCALLk", ":", "case", "MCS51", "::", "RJMPk", ":", "return", "isIntN", "(", "13", ",", "BrOffset", ")", ";", "case", "MCS51", "::", "BRBSsk", ":", "case", "MCS51", "::", "BRBCsk", ":", "case", "MCS51", "::", "BREQk", ":", "case", "MCS51", "::", "BRNEk", ":", "case", "MCS51", "::", "BRSHk", ":", "case", "MCS51", "::", "BRLOk", ":", "case", "MCS51", "::", "BRMIk", ":", "case", "MCS51", "::", "BRPLk", ":", "case", "MCS51", "::", "BRGEk", ":", "case", "MCS51", "::", "BRLTk", ":", "return", "isIntN", "(", "7", ",", "BrOffset", ")", ";", "}", "}", "</s>" ]
[ "Determine", "if", "the", "branch", "target", "is", "in", "range", "." ]
[ "MCS51", "MCS51", "\"unexpected opcode!\"", "MCS51::JMPk", "MCS51::CALLk", "MCS51::RCALLk", "MCS51::RJMPk", "13", "MCS51::BRBSsk", "MCS51::BRBCsk", "MCS51::BREQk", "MCS51::BRNEk", "MCS51::BRSHk", "MCS51::BRLOk", "MCS51::BRMIk", "MCS51::BRPLk", "MCS51::BRGEk", "MCS51::BRLTk", "7" ]
MCS51InstrInfo
isBranchOffsetInRange
MCS51
MPU
LLVM
12,635
116
1
[]
[ "<s>", "const", "char", "*", "NVPTXTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "NVPTXISD", "::", "CALL", ":", "return", "\"NVPTXISD::CALL\"", ";", "case", "NVPTXISD", "::", "RET_FLAG", ":", "return", "\"NVPTXISD::RET_FLAG\"", ";", "case", "NVPTXISD", "::", "Wrapper", ":", "return", "\"NVPTXISD::Wrapper\"", ";", "case", "NVPTXISD", "::", "NVBuiltin", ":", "return", "\"NVPTXISD::NVBuiltin\"", ";", "case", "NVPTXISD", "::", "DeclareParam", ":", "return", "\"NVPTXISD::DeclareParam\"", ";", "case", "NVPTXISD", "::", "DeclareScalarParam", ":", "return", "\"NVPTXISD::DeclareScalarParam\"", ";", "case", "NVPTXISD", "::", "DeclareRet", ":", "return", "\"NVPTXISD::DeclareRet\"", ";", "case", "NVPTXISD", "::", "DeclareRetParam", ":", "return", "\"NVPTXISD::DeclareRetParam\"", ";", "case", "NVPTXISD", "::", "PrintCall", ":", "return", "\"NVPTXISD::PrintCall\"", ";", "case", "NVPTXISD", "::", "LoadParam", ":", "return", "\"NVPTXISD::LoadParam\"", ";", "case", "NVPTXISD", "::", "StoreParam", ":", "return", "\"NVPTXISD::StoreParam\"", ";", "case", "NVPTXISD", "::", "StoreParamS32", ":", "return", "\"NVPTXISD::StoreParamS32\"", ";", "case", "NVPTXISD", "::", "StoreParamU32", ":", "return", "\"NVPTXISD::StoreParamU32\"", ";", "case", "NVPTXISD", "::", "MoveToParam", ":", "return", "\"NVPTXISD::MoveToParam\"", ";", "case", "NVPTXISD", "::", "CallArgBegin", ":", "return", "\"NVPTXISD::CallArgBegin\"", ";", "case", "NVPTXISD", "::", "CallArg", ":", "return", "\"NVPTXISD::CallArg\"", ";", "case", "NVPTXISD", "::", "LastCallArg", ":", "return", "\"NVPTXISD::LastCallArg\"", ";", "case", "NVPTXISD", "::", "CallArgEnd", ":", "return", "\"NVPTXISD::CallArgEnd\"", ";", "case", "NVPTXISD", "::", "CallVoid", ":", "return", "\"NVPTXISD::CallVoid\"", ";", "case", "NVPTXISD", "::", "CallVal", ":", "return", "\"NVPTXISD::CallVal\"", ";", "case", "NVPTXISD", "::", "CallSymbol", ":", "return", "\"NVPTXISD::CallSymbol\"", ";", "case", "NVPTXISD", "::", "Prototype", ":", "return", "\"NVPTXISD::Prototype\"", ";", "case", "NVPTXISD", "::", "MoveParam", ":", "return", "\"NVPTXISD::MoveParam\"", ";", "case", "NVPTXISD", "::", "MoveRetval", ":", "return", "\"NVPTXISD::MoveRetval\"", ";", "case", "NVPTXISD", "::", "MoveToRetval", ":", "return", "\"NVPTXISD::MoveToRetval\"", ";", "case", "NVPTXISD", "::", "StoreRetval", ":", "return", "\"NVPTXISD::StoreRetval\"", ";", "case", "NVPTXISD", "::", "PseudoUseParam", ":", "return", "\"NVPTXISD::PseudoUseParam\"", ";", "case", "NVPTXISD", "::", "RETURN", ":", "return", "\"NVPTXISD::RETURN\"", ";", "case", "NVPTXISD", "::", "CallSeqBegin", ":", "return", "\"NVPTXISD::CallSeqBegin\"", ";", "case", "NVPTXISD", "::", "CallSeqEnd", ":", "return", "\"NVPTXISD::CallSeqEnd\"", ";", "}", "}", "</s>" ]
[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]
[ "NVPTX", "NVPTX", "0", "NVPTXISD::CALL", "\"NVPTXISD::CALL\"", "NVPTXISD::RET_FLAG", "\"NVPTXISD::RET_FLAG\"", "NVPTXISD::Wrapper", "\"NVPTXISD::Wrapper\"", "NVPTXISD::NVBuiltin", "\"NVPTXISD::NVBuiltin\"", "NVPTXISD::DeclareParam", "\"NVPTXISD::DeclareParam\"", "NVPTXISD::DeclareScalarParam", "\"NVPTXISD::DeclareScalarParam\"", "NVPTXISD::DeclareRet", "\"NVPTXISD::DeclareRet\"", "NVPTXISD::DeclareRetParam", "\"NVPTXISD::DeclareRetParam\"", "NVPTXISD::PrintCall", "\"NVPTXISD::PrintCall\"", "NVPTXISD::LoadParam", "\"NVPTXISD::LoadParam\"", "NVPTXISD::StoreParam", "\"NVPTXISD::StoreParam\"", "NVPTXISD::StoreParamS32", "\"NVPTXISD::StoreParamS32\"", "NVPTXISD::StoreParamU32", "\"NVPTXISD::StoreParamU32\"", "NVPTXISD::MoveToParam", "\"NVPTXISD::MoveToParam\"", "NVPTXISD::CallArgBegin", "\"NVPTXISD::CallArgBegin\"", "NVPTXISD::CallArg", "\"NVPTXISD::CallArg\"", "NVPTXISD::LastCallArg", "\"NVPTXISD::LastCallArg\"", "NVPTXISD::CallArgEnd", "\"NVPTXISD::CallArgEnd\"", "NVPTXISD::CallVoid", "\"NVPTXISD::CallVoid\"", "NVPTXISD::CallVal", "\"NVPTXISD::CallVal\"", "NVPTXISD::CallSymbol", "\"NVPTXISD::CallSymbol\"", "NVPTXISD::Prototype", "\"NVPTXISD::Prototype\"", "NVPTXISD::MoveParam", "\"NVPTXISD::MoveParam\"", "NVPTXISD::MoveRetval", "\"NVPTXISD::MoveRetval\"", "NVPTXISD::MoveToRetval", "\"NVPTXISD::MoveToRetval\"", "NVPTXISD::StoreRetval", "\"NVPTXISD::StoreRetval\"", "NVPTXISD::PseudoUseParam", "\"NVPTXISD::PseudoUseParam\"", "NVPTXISD::RETURN", "\"NVPTXISD::RETURN\"", "NVPTXISD::CallSeqBegin", "\"NVPTXISD::CallSeqBegin\"", "NVPTXISD::CallSeqEnd", "\"NVPTXISD::CallSeqEnd\"" ]
NVPTXISelLowering15
getTargetNodeName
NVPTX
GPU
LLVM
12,636
264
1
[]
[ "<s>", "MVT", "getVectorIdxTy", "(", "const", "DataLayout", "&", "DL", ")", "const", "override", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]
[ "Returns", "the", "type", "to", "be", "used", "for", "the", "index", "operand", "of", ":", "ISD", ":", ":INSERT_VECTOR_ELT", ",", "ISD", ":", ":EXTRACT_VECTOR_ELT", ",", "ISD", ":", ":INSERT_SUBVECTOR", ",", "and", "ISD", ":", ":EXTRACT_SUBVECTOR", "." ]
[ "SystemZ", "MVT::i32" ]
SystemZISelLowering (2)
getVectorIdxTy
SystemZ
CPU
LLVM
12,637
17
1
[]
[ "<s>", "rtx", "arm_gen_load_multiple", "(", "int", "*", "regs", ",", "int", "count", ",", "rtx", "basereg", ",", "int", "write_back", ",", "rtx", "basemem", ",", "HOST_WIDE_INT", "*", "offsetp", ")", "{", "return", "arm_gen_multiple_op", "(", "TRUE", ",", "regs", ",", "count", ",", "basereg", ",", "write_back", ",", "basemem", ",", "offsetp", ")", ";", "}", "</s>" ]
[ "Routines", "for", "use", "in", "generating", "RTL", "." ]
[ "arm" ]
arm
arm_gen_load_multiple
arm
CPU
GCC
12,638
43
1
[]
[ "<s>", "std", "::", "pair", "<", "const", "Value", "*", ",", "unsigned", ">", "NVPTXTargetMachine", "::", "getPredicatedAddrSpace", "(", "const", "Value", "*", "V", ")", "const", "{", "if", "(", "auto", "*", "II", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "V", ")", ")", "{", "switch", "(", "II", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "nvvm_isspacep_const", ":", "return", "std", "::", "make_pair", "(", "II", "->", "getArgOperand", "(", "0", ")", ",", "llvm", "::", "ADDRESS_SPACE_CONST", ")", ";", "case", "Intrinsic", "::", "nvvm_isspacep_global", ":", "return", "std", "::", "make_pair", "(", "II", "->", "getArgOperand", "(", "0", ")", ",", "llvm", "::", "ADDRESS_SPACE_GLOBAL", ")", ";", "case", "Intrinsic", "::", "nvvm_isspacep_local", ":", "return", "std", "::", "make_pair", "(", "II", "->", "getArgOperand", "(", "0", ")", ",", "llvm", "::", "ADDRESS_SPACE_LOCAL", ")", ";", "case", "Intrinsic", "::", "nvvm_isspacep_shared", ":", "return", "std", "::", "make_pair", "(", "II", "->", "getArgOperand", "(", "0", ")", ",", "llvm", "::", "ADDRESS_SPACE_SHARED", ")", ";", "default", ":", "break", ";", "}", "}", "return", "std", "::", "make_pair", "(", "nullptr", ",", "-", "1", ")", ";", "}", "</s>" ]
[ "If", "the", "specified", "predicate", "checks", "whether", "a", "generic", "pointer", "falls", "within", "a", "specified", "address", "space", ",", "return", "that", "generic", "pointer", "and", "the", "address", "space", "being", "queried", "." ]
[ "NVPTX", "NVPTX", "Intrinsic::nvvm_isspacep_const", "0", "Intrinsic::nvvm_isspacep_global", "0", "Intrinsic::nvvm_isspacep_local", "0", "Intrinsic::nvvm_isspacep_shared", "0", "1" ]
NVPTXTargetMachine13
getPredicatedAddrSpace
NVPTX
GPU
LLVM
12,639
151
1
[]
[ "<s>", "static", "int", "rs6000_hard_regno_nregs_internal", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "unsigned", "HOST_WIDE_INT", "reg_size", ";", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "reg_size", "=", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "?", "UNITS_PER_VSX_WORD", ":", "UNITS_PER_FP_WORD", ")", ";", "else", "if", "(", "SPE_SIMD_REGNO_P", "(", "regno", ")", "&&", "TARGET_SPE", "&&", "SPE_VECTOR_MODE", "(", "mode", ")", ")", "reg_size", "=", "UNITS_PER_SPE_WORD", ";", "else", "if", "(", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "reg_size", "=", "UNITS_PER_ALTIVEC_WORD", ";", "else", "if", "(", "TARGET_E500_DOUBLE", "&&", "FLOAT_MODE_P", "(", "mode", ")", "&&", "mode", "!=", "SCmode", "&&", "!", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", "&&", "SPE_SIMD_REGNO_P", "(", "regno", ")", ")", "reg_size", "=", "UNITS_PER_FP_WORD", ";", "else", "reg_size", "=", "UNITS_PER_WORD", ";", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "reg_size", "-", "1", ")", "/", "reg_size", ";", "}", "</s>" ]
[ "Return", "number", "of", "consecutive", "hard", "regs", "needed", "starting", "at", "reg", "REGNO", "to", "hold", "something", "of", "mode", "MODE", ".", "This", "is", "ordinarily", "the", "length", "in", "words", "of", "a", "value", "of", "mode", "MODE", "but", "can", "be", "less", "for", "certain", "modes", "in", "special", "long", "registers", ".", "POWER", "and", "PowerPC", "GPRs", "hold", "32", "bits", "worth", ";", "PowerPC64", "GPRs", "and", "FPRs", "point", "register", "holds", "64", "bits", "worth", "." ]
[ "rs6000", "1" ]
rs60005
rs6000_hard_regno_nregs_internal
rs6000
CPU
GCC
12,640
115
1
[]
[ "<s>", "void", "SIInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "*", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "Align", "=", "FrameInfo", "->", "getObjectAlignment", "(", "FrameIndex", ")", ";", "unsigned", "Size", "=", "FrameInfo", "->", "getObjectSize", "(", "FrameIndex", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOLoad", ",", "Size", ",", "Align", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "unsigned", "Opcode", "=", "getSGPRSpillRestoreOpcode", "(", "RC", "->", "getSize", "(", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "return", ";", "}", "if", "(", "!", "ST", ".", "isVGPRSpillingEnabled", "(", "MFI", ")", ")", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "\"SIInstrInfo::loadRegFromStackSlot - Do not know how to\"", "\" restore register\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "IMPLICIT_DEF", ")", ",", "DestReg", ")", ";", "return", ";", "}", "assert", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "\"Only VGPR spilling expected\"", ")", ";", "unsigned", "Opcode", "=", "getVGPRSpillRestoreOpcode", "(", "RC", "->", "getSize", "(", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "AMDGPU", "::", "SGPR0_SGPR1_SGPR2_SGPR3", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "AMDGPU", "::", "SGPR0", ",", "RegState", "::", "Undef", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]
[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]
[ "AMDGPU", "SI", "SI", "SI", "\"SIInstrInfo::loadRegFromStackSlot - Do not know how to\"", "\" restore register\"", "AMDGPU::IMPLICIT_DEF", "\"Only VGPR spilling expected\"", "AMDGPU::SGPR0_SGPR1_SGPR2_SGPR3", "AMDGPU::SGPR0" ]
SIInstrInfo88
loadRegFromStackSlot
AMDGPU
GPU
LLVM
12,641
306
1
[]
[ "<s>", "bool", "ARM64AsmBackend", "::", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "{", "return", "false", ";", "}", "</s>" ]
[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]
[ "ARM64", "ARM64" ]
ARM64AsmBackend
mayNeedRelaxation
ARM64
CPU
LLVM
12,642
16
1
[]
[ "<s>", "int", "arm_early_store_addr_dep", "(", "rtx", "producer", ",", "rtx", "consumer", ")", "{", "return", "!", "arm_no_early_store_addr_dep", "(", "producer", ",", "consumer", ")", ";", "}", "</s>" ]
[ "Return", "nonzero", "if", "the", "CONSUMER", "instruction", "(", "a", "store", ")", "does", "need", "PRODUCER", "'s", "value", "to", "calculate", "the", "address", "." ]
[ "arm" ]
aarch-common
arm_early_store_addr_dep
arm
CPU
GCC
12,643
20
1
[]
[ "<s>", "SMLoc", "getEndLoc", "(", ")", "const", "override", "{", "return", "EndLoc", ";", "}", "</s>" ]
[ "getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "." ]
[ "ECLair" ]
ECLairAsmParser
getEndLoc
ECLair
MPU
LLVM
12,644
11
1
[]
[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "ARMTargetLowering", "::", "shouldExpandAtomicLoadInIR", "(", "LoadInst", "*", "LI", ")", "const", "{", "unsigned", "Size", "=", "LI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "return", "(", "(", "Size", "==", "64", ")", "&&", "!", "Subtarget", "->", "isMClass", "(", ")", ")", "?", "AtomicExpansionKind", "::", "LLSC", ":", "AtomicExpansionKind", "::", "None", ";", "}", "</s>" ]
[ "Returns", "how", "the", "given", "(", "atomic", ")", "load", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "." ]
[ "ARM", "ARM", "64" ]
ARMISelLowering
shouldExpandAtomicLoadInIR
ARM
CPU
LLVM
12,645
51
1
[]
[ "<s>", "void", "GCNPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "addPass", "(", "&", "SIFixVGPRCopiesID", ")", ";", "addPass", "(", "&", "SIOptimizeExecMaskingID", ")", ";", "TargetPassConfig", "::", "addPostRegAlloc", "(", ")", ";", "}", "</s>" ]
[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "register", "allocation", "pass", "pipeline", "but", "before", "prolog-epilog", "insertion", "." ]
[ "AMDGPU", "SI", "SI" ]
AMDGPUTargetMachine102
addPostRegAlloc
AMDGPU
GPU
LLVM
12,646
26
1
[]
[ "<s>", "bool", "X86ATTAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "this", "->", "MF", "=", "&", "MF", ";", "unsigned", "CC", "=", "F", "->", "getCallingConv", "(", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "O", "<<", "\"\\n\\n\"", ";", "if", "(", "CC", "==", "CallingConv", "::", "X86_StdCall", "||", "CC", "==", "CallingConv", "::", "X86_FastCall", ")", "FunctionInfoMap", "[", "F", "]", "=", "*", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "EmitConstantPool", "(", "MF", ".", "getConstantPool", "(", ")", ")", ";", "if", "(", "F", "->", "hasDLLExportLinkage", "(", ")", ")", "DLLExportedFns", ".", "insert", "(", "Mang", "->", "getMangledName", "(", "F", ")", ")", ";", "emitFunctionHeader", "(", "MF", ")", ";", "if", "(", "TAI", "->", "doesSupportDebugInformation", "(", ")", "||", "TAI", "->", "doesSupportExceptionHandling", "(", ")", ")", "DW", "->", "BeginFunction", "(", "&", "MF", ")", ";", "bool", "hasAnyRealCode", "=", "false", ";", "for", "(", "MachineFunction", "::", "const_iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "VerboseAsm", "&&", "(", "I", "->", "pred_empty", "(", ")", "||", "I", "->", "isOnlyReachableByFallthrough", "(", ")", ")", ")", "{", "}", "else", "{", "printBasicBlockLabel", "(", "I", ",", "true", ",", "true", ",", "VerboseAsm", ")", ";", "O", "<<", "'\\n'", ";", "}", "for", "(", "MachineBasicBlock", "::", "const_iterator", "II", "=", "I", "->", "begin", "(", ")", ",", "IE", "=", "I", "->", "end", "(", ")", ";", "II", "!=", "IE", ";", "++", "II", ")", "{", "if", "(", "!", "II", "->", "isLabel", "(", ")", ")", "hasAnyRealCode", "=", "true", ";", "printMachineInstruction", "(", "II", ")", ";", "}", "}", "if", "(", "Subtarget", "->", "isTargetDarwin", "(", ")", "&&", "!", "hasAnyRealCode", ")", "{", "O", "<<", "\"\\tnop\\n\"", ";", "}", "if", "(", "TAI", "->", "hasDotTypeDotSizeDirective", "(", ")", ")", "O", "<<", "\"\\t.size\\t\"", "<<", "CurrentFnName", "<<", "\", .-\"", "<<", "CurrentFnName", "<<", "'\\n'", ";", "if", "(", "TAI", "->", "doesSupportDebugInformation", "(", ")", "||", "TAI", "->", "doesSupportExceptionHandling", "(", ")", ")", "DW", "->", "EndFunction", "(", "&", "MF", ")", ";", "EmitJumpTableInfo", "(", "MF", ".", "getJumpTableInfo", "(", ")", ",", "MF", ")", ";", "return", "false", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "X86", "X86", "\"\\n\\n\"", "X86", "X86", "X86", "\"\\tnop\\n\"", "\"\\t.size\\t\"", "\", .-\"" ]
X86ATTAsmPrinter2
runOnMachineFunction
X86
CPU
LLVM
12,647
327
1
[]
[ "<s>", "static", "void", "s390_register_info", "(", ")", "{", "int", "i", ";", "char", "clobbered_regs", "[", "32", "]", ";", "gcc_assert", "(", "!", "epilogue_completed", ")", ";", "if", "(", "reload_completed", ")", "s390_regs_ever_clobbered", "(", "clobbered_regs", ")", ";", "else", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "i", "++", ")", "clobbered_regs", "[", "i", "]", "=", "df_regs_ever_live_p", "(", "i", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "i", "++", ")", "clobbered_regs", "[", "i", "]", "=", "clobbered_regs", "[", "i", "]", "&&", "!", "global_regs", "[", "i", "]", ";", "cfun_frame_layout", ".", "fpr_bitmap", "=", "0", ";", "cfun_frame_layout", ".", "high_fprs", "=", "0", ";", "for", "(", "i", "=", "FPR0_REGNUM", ";", "i", "<=", "FPR15_REGNUM", ";", "i", "++", ")", "if", "(", "clobbered_regs", "[", "i", "]", "&&", "!", "call_used_regs", "[", "i", "]", ")", "{", "cfun_set_fpr_save", "(", "i", ")", ";", "if", "(", "i", ">=", "FPR8_REGNUM", ")", "cfun_frame_layout", ".", "high_fprs", "++", ";", "}", "clobbered_regs", "[", "12", "]", "|=", "(", "(", "flag_pic", "&&", "df_regs_ever_live_p", "(", "PIC_OFFSET_TABLE_REGNUM", ")", ")", "||", "(", "flag_split_stack", "&&", "cfun", "->", "stdarg", "&&", "(", "crtl", "->", "is_leaf", "||", "TARGET_TPF_PROFILING", "||", "has_hard_reg_initial_val", "(", "Pmode", ",", "RETURN_REGNUM", ")", ")", ")", ")", ";", "clobbered_regs", "[", "BASE_REGNUM", "]", "|=", "(", "cfun", "->", "machine", "->", "base_reg", "&&", "REGNO", "(", "cfun", "->", "machine", "->", "base_reg", ")", "==", "BASE_REGNUM", ")", ";", "clobbered_regs", "[", "HARD_FRAME_POINTER_REGNUM", "]", "|=", "!", "!", "frame_pointer_needed", ";", "clobbered_regs", "[", "RETURN_REGNUM", "]", "|=", "(", "!", "crtl", "->", "is_leaf", "||", "TARGET_TPF_PROFILING", "||", "cfun_frame_layout", ".", "save_return_addr_p", "||", "crtl", "->", "calls_eh_return", ")", ";", "clobbered_regs", "[", "STACK_POINTER_REGNUM", "]", "|=", "(", "!", "crtl", "->", "is_leaf", "||", "TARGET_TPF_PROFILING", "||", "cfun_save_high_fprs_p", "||", "get_frame_size", "(", ")", ">", "0", "||", "(", "reload_completed", "&&", "cfun_frame_layout", ".", "frame_size", ">", "0", ")", "||", "cfun", "->", "calls_alloca", ")", ";", "memset", "(", "cfun_frame_layout", ".", "gpr_save_slots", ",", "SAVE_SLOT_NONE", ",", "16", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "16", ";", "i", "++", ")", "if", "(", "clobbered_regs", "[", "i", "]", "&&", "!", "call_used_regs", "[", "i", "]", ")", "cfun_gpr_save_slot", "(", "i", ")", "=", "SAVE_SLOT_STACK", ";", "s390_register_info_arg_fpr", "(", ")", ";", "s390_register_info_gprtofpr", "(", ")", ";", "s390_register_info_set_ranges", "(", ")", ";", "s390_register_info_arg_gpr", "(", ")", ";", "}", "</s>" ]
[ "Fill", "cfun-", ">", "machine", "with", "info", "about", "register", "usage", "of", "current", "function", ".", "Return", "in", "CLOBBERED_REGS", "which", "GPRs", "are", "currently", "considered", "set", "." ]
[ "s390", "32", "0", "32", "0", "32", "0", "0", "12", "0", "0", "16", "0", "16" ]
s3901
s390_register_info
s390
MPU
GCC
12,648
330
1
[]
[ "<s>", "static", "int", "ix86_i387_mode_needed", "(", "int", "entity", ",", "rtx_insn", "*", "insn", ")", "{", "enum", "attr_i387_cw", "mode", ";", "if", "(", "CALL_P", "(", "insn", ")", "||", "(", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "(", "asm_noperands", "(", "PATTERN", "(", "insn", ")", ")", ">=", "0", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ASM_INPUT", ")", ")", ")", "return", "I387_CW_UNINITIALIZED", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "I387_CW_ANY", ";", "mode", "=", "get_attr_i387_cw", "(", "insn", ")", ";", "switch", "(", "entity", ")", "{", "case", "I387_ROUNDEVEN", ":", "if", "(", "mode", "==", "I387_CW_ROUNDEVEN", ")", "return", "mode", ";", "break", ";", "case", "I387_TRUNC", ":", "if", "(", "mode", "==", "I387_CW_TRUNC", ")", "return", "mode", ";", "break", ";", "case", "I387_FLOOR", ":", "if", "(", "mode", "==", "I387_CW_FLOOR", ")", "return", "mode", ";", "break", ";", "case", "I387_CEIL", ":", "if", "(", "mode", "==", "I387_CW_CEIL", ")", "return", "mode", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "I387_CW_ANY", ";", "}", "</s>" ]
[ "Return", "mode", "that", "i387", "must", "be", "switched", "into", "prior", "to", "the", "execution", "of", "insn", "." ]
[ "i386", "0", "0" ]
i386
ix86_i387_mode_needed
i386
CPU
GCC
12,649
146
1
[]
[ "<s>", "bool", "RISCVAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "return", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "RISCV", "RISCV", "RISCV" ]
RISCVAsmPrinter (2)
runOnMachineFunction
RISCV
CPU
LLVM
12,650
31
1
[]
[ "<s>", "void", "gen_ashift", "(", "int", "type", ",", "int", "n", ",", "rtx", "reg", ")", "{", "if", "(", "n", "<", "0", ")", "{", "if", "(", "type", "==", "ASHIFT", ")", "type", "=", "LSHIFTRT", ";", "else", "type", "=", "ASHIFT", ";", "n", "=", "-", "n", ";", "}", "switch", "(", "type", ")", "{", "case", "ASHIFTRT", ":", "emit_insn", "(", "gen_ashrsi3_k", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "n", ")", ")", ")", ";", "break", ";", "case", "LSHIFTRT", ":", "if", "(", "n", "==", "1", ")", "emit_insn", "(", "gen_lshrsi3_m", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "n", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_lshrsi3_k", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "n", ")", ")", ")", ";", "break", ";", "case", "ASHIFT", ":", "emit_insn", "(", "gen_ashlsi3_std", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "n", ")", ")", ")", ";", "break", ";", "}", "}", "</s>" ]
[ "Code", "to", "expand", "a", "shift", "." ]
[ "sh", "0", "1" ]
sh3
gen_ashift
sh
CPU
GCC
12,651
130
1
[]
[ "<s>", "const", "MCSection", "*", "XCoreTargetObjectFile", "::", "getSectionForConstant", "(", "SectionKind", "Kind", ",", "const", "Constant", "*", "C", ")", "const", "{", "if", "(", "Kind", ".", "isMergeableConst4", "(", ")", ")", "return", "MergeableConst4Section", ";", "if", "(", "Kind", ".", "isMergeableConst8", "(", ")", ")", "return", "MergeableConst8Section", ";", "if", "(", "Kind", ".", "isMergeableConst16", "(", ")", ")", "return", "MergeableConst16Section", ";", "assert", "(", "(", "Kind", ".", "isReadOnly", "(", ")", "||", "Kind", ".", "isReadOnlyWithRel", "(", ")", ")", "&&", "\"Unknown section kind\"", ")", ";", "return", "ReadOnlySection", ";", "}", "</s>" ]
[ "Given", "a", "constant", "with", "the", "SectionKind", ",", "return", "a", "section", "that", "it", "should", "be", "placed", "in", "." ]
[ "XCore", "XCore", "\"Unknown section kind\"" ]
XCoreTargetObjectFile1
getSectionForConstant
XCore
MPU
LLVM
12,652
73
1
[]
[ "<s>", "static", "bool", "mips16_stub_function_p", "(", "const_rtx", "x", ")", "{", "return", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "startswith", "(", "XSTR", "(", "x", ",", "0", ")", ",", "\"__mips16_\"", ")", ")", ";", "}", "</s>" ]
[ "Return", "true", "if", "function", "X", "is", "a", "libgcc", "MIPS16", "stub", "function", "." ]
[ "mips", "0", "\"__mips16_\"" ]
mips
mips16_stub_function_p
mips
CPU
GCC
12,653
31
1
[]
[ "<s>", "void", "LanaiInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "StringRef", "(", "getRegisterName", "(", "RegNo", ")", ")", ".", "lower", "(", ")", ";", "}", "</s>" ]
[ "Print", "the", "assembler", "register", "name", "." ]
[ "Lanai", "Lanai" ]
LanaiInstPrinter
printRegName
Lanai
CPU
LLVM
12,654
29
1
[]
[ "<s>", "MVT", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", ",", "EVT", ")", "const", "override", "{", "return", "MVT", "::", "i257", ";", "}", "</s>" ]
[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]
[ "TVM", "MVT::i257" ]
TVMISelLowering
getScalarShiftAmountTy
TVM
Virtual ISA
LLVM
12,655
18
1
[]
[ "<s>", "bool", "vax_acceptable_pic_operand_p", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "bool", "local_p", "ATTRIBUTE_UNUSED", ",", "bool", "symbol_p", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", ")", "{", "x", "=", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ";", "local_p", "=", "true", ";", "}", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "SYMBOL_REF", ":", "return", "symbol_p", "&&", "!", "(", "local_p", "&&", "!", "SYMBOL_REF_LOCAL_P", "(", "x", ")", ")", ";", "case", "LABEL_REF", ":", "return", "symbol_p", "&&", "!", "(", "local_p", "&&", "LABEL_REF_NONLOCAL_P", "(", "x", ")", ")", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]
[ "With", "ELF", "we", "do", "not", "support", "GOT", "entries", "for", "external", "`", "symbol+offset", "'", "references", ",", "so", "do", "not", "accept", "external", "symbol", "references", "if", "an", "offset", "is", "to", "be", "added", ".", "Do", "not", "accept", "external", "symbol", "references", "at", "all", "if", "LOCAL_P", "is", "set", ".", "This", "is", "for", "cases", "where", "making", "a", "reference", "indirect", "would", "make", "it", "invalid", ".", "Do", "not", "accept", "any", "kind", "of", "symbols", "if", "SYMBOL_P", "is", "clear", ".", "This", "is", "for", "situations", "where", "the", "a", "reference", "is", "used", "as", "an", "immediate", "value", "for", "operations", "other", "than", "address", "loads", "(", "MOVA/PUSHA", ")", ",", "as", "those", "operations", "do", "not", "support", "PC-relative", "immediates", "." ]
[ "vax", "0", "0", "0" ]
vax
vax_acceptable_pic_operand_p
vax
CPU
GCC
12,656
107
1
[]
[ "<s>", "std", "::", "pair", "<", "const", "TargetRegisterClass", "*", ",", "uint8_t", ">", "X86TargetLowering", "::", "findRepresentativeClass", "(", "EVT", "VT", ")", "const", "{", "const", "TargetRegisterClass", "*", "RRC", "=", "0", ";", "uint8_t", "Cost", "=", "1", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "return", "TargetLowering", "::", "findRepresentativeClass", "(", "VT", ")", ";", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "i64", ":", "RRC", "=", "Subtarget", "->", "is64Bit", "(", ")", "?", "(", "const", "TargetRegisterClass", "*", ")", "&", "X86", "::", "GR64RegClass", ":", "(", "const", "TargetRegisterClass", "*", ")", "&", "X86", "::", "GR32RegClass", ";", "break", ";", "case", "MVT", "::", "x86mmx", ":", "RRC", "=", "&", "X86", "::", "VR64RegClass", ";", "break", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "case", "MVT", "::", "v16i8", ":", "case", "MVT", "::", "v8i16", ":", "case", "MVT", "::", "v4i32", ":", "case", "MVT", "::", "v2i64", ":", "case", "MVT", "::", "v4f32", ":", "case", "MVT", "::", "v2f64", ":", "case", "MVT", "::", "v32i8", ":", "case", "MVT", "::", "v8i32", ":", "case", "MVT", "::", "v4i64", ":", "case", "MVT", "::", "v8f32", ":", "case", "MVT", "::", "v4f64", ":", "RRC", "=", "&", "X86", "::", "VR128RegClass", ";", "break", ";", "}", "return", "std", "::", "make_pair", "(", "RRC", ",", "Cost", ")", ";", "}", "</s>" ]
[ "Return", "the", "largest", "legal", "super-reg", "register", "class", "of", "the", "register", "class", "for", "the", "specified", "type", "and", "its", "associated", "``", "cost", "''", "." ]
[ "X86", "X86", "0", "1", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::i64", "X86::GR64RegClass", "X86::GR32RegClass", "MVT::x86mmx", "X86::VR64RegClass", "MVT::f32", "MVT::f64", "MVT::v16i8", "MVT::v8i16", "MVT::v4i32", "MVT::v2i64", "MVT::v4f32", "MVT::v2f64", "MVT::v32i8", "MVT::v8i32", "MVT::v4i64", "MVT::v8f32", "MVT::v4f64", "X86::VR128RegClass" ]
X86ISelLowering117
findRepresentativeClass
X86
CPU
LLVM
12,657
202
1
[]
[ "<s>", "HOST_WIDE_INT", "compute_frame_size", "(", "HOST_WIDE_INT", "size", ")", "{", "int", "regno", ";", "HOST_WIDE_INT", "total_size", ";", "HOST_WIDE_INT", "var_size", ";", "HOST_WIDE_INT", "args_size", ";", "HOST_WIDE_INT", "extra_size", ";", "HOST_WIDE_INT", "gp_reg_rounded", ";", "HOST_WIDE_INT", "gp_reg_size", ";", "HOST_WIDE_INT", "fp_reg_size", ";", "long", "mask", ";", "int", "fp_inc", ";", "long", "fp_bits", ";", "gp_reg_size", "=", "0", ";", "fp_reg_size", "=", "0", ";", "mask", "=", "0", ";", "extra_size", "=", "IQ2000_STACK_ALIGN", "(", "(", "0", ")", ")", ";", "var_size", "=", "IQ2000_STACK_ALIGN", "(", "size", ")", ";", "args_size", "=", "IQ2000_STACK_ALIGN", "(", "current_function_outgoing_args_size", ")", ";", "if", "(", "args_size", "==", "0", "&&", "current_function_calls_alloca", ")", "args_size", "=", "4", "*", "UNITS_PER_WORD", ";", "total_size", "=", "var_size", "+", "args_size", "+", "extra_size", ";", "for", "(", "regno", "=", "GP_REG_FIRST", ";", "regno", "<=", "GP_REG_LAST", ";", "regno", "++", ")", "{", "if", "(", "MUST_SAVE_REGISTER", "(", "regno", ")", ")", "{", "gp_reg_size", "+=", "GET_MODE_SIZE", "(", "gpr_mode", ")", ";", "mask", "|=", "1L", "<<", "(", "regno", "-", "GP_REG_FIRST", ")", ";", "}", "}", "if", "(", "current_function_calls_eh_return", ")", "{", "unsigned", "int", "i", ";", "for", "(", "i", "=", "0", ";", ";", "++", "i", ")", "{", "regno", "=", "EH_RETURN_DATA_REGNO", "(", "i", ")", ";", "if", "(", "regno", "==", "(", "int", ")", "INVALID_REGNUM", ")", "break", ";", "gp_reg_size", "+=", "GET_MODE_SIZE", "(", "gpr_mode", ")", ";", "mask", "|=", "1L", "<<", "(", "regno", "-", "GP_REG_FIRST", ")", ";", "}", "}", "fp_inc", "=", "2", ";", "fp_bits", "=", "3", ";", "gp_reg_rounded", "=", "IQ2000_STACK_ALIGN", "(", "gp_reg_size", ")", ";", "total_size", "+=", "gp_reg_rounded", "+", "IQ2000_STACK_ALIGN", "(", "fp_reg_size", ")", ";", "if", "(", "total_size", "==", "extra_size", "&&", "!", "profile_flag", ")", "total_size", "=", "extra_size", "=", "0", ";", "total_size", "+=", "IQ2000_STACK_ALIGN", "(", "current_function_pretend_args_size", ")", ";", "cfun", "->", "machine", "->", "total_size", "=", "total_size", ";", "cfun", "->", "machine", "->", "var_size", "=", "var_size", ";", "cfun", "->", "machine", "->", "args_size", "=", "args_size", ";", "cfun", "->", "machine", "->", "extra_size", "=", "extra_size", ";", "cfun", "->", "machine", "->", "gp_reg_size", "=", "gp_reg_size", ";", "cfun", "->", "machine", "->", "fp_reg_size", "=", "fp_reg_size", ";", "cfun", "->", "machine", "->", "mask", "=", "mask", ";", "cfun", "->", "machine", "->", "initialized", "=", "reload_completed", ";", "cfun", "->", "machine", "->", "num_gp", "=", "gp_reg_size", "/", "UNITS_PER_WORD", ";", "if", "(", "mask", ")", "{", "unsigned", "long", "offset", ";", "offset", "=", "(", "args_size", "+", "extra_size", "+", "var_size", "+", "gp_reg_size", "-", "GET_MODE_SIZE", "(", "gpr_mode", ")", ")", ";", "cfun", "->", "machine", "->", "gp_sp_offset", "=", "offset", ";", "cfun", "->", "machine", "->", "gp_save_offset", "=", "offset", "-", "total_size", ";", "}", "else", "{", "cfun", "->", "machine", "->", "gp_sp_offset", "=", "0", ";", "cfun", "->", "machine", "->", "gp_save_offset", "=", "0", ";", "}", "cfun", "->", "machine", "->", "fp_sp_offset", "=", "0", ";", "cfun", "->", "machine", "->", "fp_save_offset", "=", "0", ";", "return", "total_size", ";", "}", "</s>" ]
[ "Typical", "stack", "layout", "should", "looks", "like", "this", "after", "the", "function", "'s", "prologue", ":", "|", "|", "--", "^", "|", "|", "\\", "|", "|", "|", "arguments", "saved", "|", "Increasing", "|", "|", "on", "the", "stack", "|", "addresses", "PARENT", "arg", "pointer", "-", ">", "|", "|", "/", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-", "|", "|", "-", "space", "for", "argument", "split", "between", "regs", "&", "stack", "--", "CHILD", "|", "|", "\\", "<", "--", "(", "return", "address", "here", ")", "|", "|", "other", "call", "|", "|", "saved", "registers", "|", "|", "/", "--", "frame", "pointer", "-", ">", "|", "|", "\\", "___", "|", "|", "local", "|", "|", "|", "variables", "|f", "|", "|", "/", "|r", "--", "|a", "|", "|", "\\", "|m", "|", "|", "outgoing", "|e", "|", "|", "arguments", "|", "|", "Decreasing", "(", "hard", ")", "frame", "pointer", "|", "|", "/", "|", "|", "addresses", "and", "stack", "pointer", "-", ">", "|", "|", "/", "_|_", "|", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "V" ]
[ "iq2000", "0", "0", "0", "0", "0", "4", "1L", "0", "1L", "2", "3", "0", "0", "0", "0", "0" ]
iq20002
compute_frame_size
iq2000
CPU
GCC
12,658
399
1
[]
[ "<s>", "void", "PPCAIXAsmPrinter", "::", "emitEndOfAsmFile", "(", "Module", "&", "M", ")", "{", "if", "(", "M", ".", "empty", "(", ")", ")", "return", ";", "OutStreamer", "->", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getTOCBaseSection", "(", ")", ")", ";", "PPCTargetStreamer", "*", "TS", "=", "static_cast", "<", "PPCTargetStreamer", "*", ">", "(", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", ";", "for", "(", "auto", "&", "I", ":", "TOC", ")", "{", "MCSectionXCOFF", "*", "TCEntry", "=", "cast", "<", "MCSectionXCOFF", ">", "(", "getObjFileLowering", "(", ")", ".", "getSectionForTOCEntry", "(", "I", ".", "first", ",", "TM", ")", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "TCEntry", ")", ";", "OutStreamer", "->", "emitLabel", "(", "I", ".", "second", ")", ";", "if", "(", "TS", "!=", "nullptr", ")", "TS", "->", "emitTCEntry", "(", "*", "I", ".", "first", ")", ";", "}", "}", "</s>" ]
[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "end", "of", "their", "file", "." ]
[ "PowerPC", "PPC", "PPC", "PPC" ]
PPCAsmPrinter10
emitEndOfAsmFile
PowerPC
CPU
LLVM
12,659
116
1
[]
[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getBranchTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getBranchTargetOpValue expects only expressions or immediates\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "MCFixupKind", "(", "Mips", "::", "fixup_Mips_PC16", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]
[ "getBranchTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]
[ "Mips", "Mips", "\"getBranchTargetOpValue expects only expressions or immediates\"", "0", "Mips::fixup_Mips_PC16", "0" ]
MipsMCCodeEmitter13
getBranchTargetOpValue
Mips
CPU
LLVM
12,660
96
1
[]
[ "<s>", "static", "void", "predict_jump", "(", "int", "prob", ")", "{", "rtx_insn", "*", "insn", "=", "get_last_insn", "(", ")", ";", "gcc_assert", "(", "JUMP_P", "(", "insn", ")", ")", ";", "add_int_reg_note", "(", "insn", ",", "REG_BR_PROB", ",", "prob", ")", ";", "}", "</s>" ]
[ "Predict", "just", "emitted", "jump", "instruction", "to", "be", "taken", "with", "probability", "PROB", "." ]
[ "i386" ]
i3866
predict_jump
i386
CPU
GCC
12,661
34
1
[]
[ "<s>", "static", "void", "ia64_asm_unwind_emit", "(", "FILE", "*", "out_file", ",", "rtx_insn", "*", "insn", ")", "{", "bool", "unwind", "=", "ia64_except_unwind_info", "(", "&", "global_options", ")", "==", "UI_TARGET", ";", "bool", "frame", "=", "dwarf2out_do_frame", "(", ")", ";", "rtx", "note", ",", "pat", ";", "bool", "handled_one", ";", "if", "(", "!", "unwind", "&&", "!", "frame", ")", "return", ";", "if", "(", "NOTE_INSN_BASIC_BLOCK_P", "(", "insn", ")", ")", "{", "last_block", "=", "NOTE_BASIC_BLOCK", "(", "insn", ")", "->", "next_bb", "==", "EXIT_BLOCK_PTR_FOR_FN", "(", "cfun", ")", ";", "if", "(", "need_copy_state", ")", "{", "if", "(", "unwind", ")", "{", "fprintf", "(", "out_file", ",", "\"\\t.body\\n\"", ")", ";", "fprintf", "(", "out_file", ",", "\"\\t.copy_state %d\\n\"", ",", "cfun", "->", "machine", "->", "state_num", ")", ";", "}", "need_copy_state", "=", "false", ";", "}", "}", "if", "(", "NOTE_P", "(", "insn", ")", "||", "!", "RTX_FRAME_RELATED_P", "(", "insn", ")", ")", "return", ";", "if", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_alloc", ")", "{", "rtx", "dest", "=", "SET_DEST", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "0", ")", ")", ";", "int", "dest_regno", "=", "REGNO", "(", "dest", ")", ";", "if", "(", "dest_regno", "==", "current_frame_info", ".", "r", "[", "reg_save_ar_pfs", "]", ")", "{", "if", "(", "unwind", ")", "fprintf", "(", "out_file", ",", "\"\\t.save ar.pfs, r%d\\n\"", ",", "ia64_dbx_register_number", "(", "dest_regno", ")", ")", ";", "}", "else", "{", "if", "(", "current_frame_info", ".", "total_size", "==", "0", "&&", "!", "frame_pointer_needed", ")", "process_epilogue", "(", "out_file", ",", "insn", ",", "unwind", ",", "frame", ")", ";", "if", "(", "unwind", ")", "fprintf", "(", "out_file", ",", "\"\\t.prologue\\n\"", ")", ";", "}", "return", ";", "}", "handled_one", "=", "false", ";", "for", "(", "note", "=", "REG_NOTES", "(", "insn", ")", ";", "note", ";", "note", "=", "XEXP", "(", "note", ",", "1", ")", ")", "switch", "(", "REG_NOTE_KIND", "(", "note", ")", ")", "{", "case", "REG_CFA_ADJUST_CFA", ":", "pat", "=", "XEXP", "(", "note", ",", "0", ")", ";", "if", "(", "pat", "==", "NULL", ")", "pat", "=", "PATTERN", "(", "insn", ")", ";", "process_cfa_adjust_cfa", "(", "out_file", ",", "pat", ",", "insn", ",", "unwind", ",", "frame", ")", ";", "handled_one", "=", "true", ";", "break", ";", "case", "REG_CFA_OFFSET", ":", "pat", "=", "XEXP", "(", "note", ",", "0", ")", ";", "if", "(", "pat", "==", "NULL", ")", "pat", "=", "PATTERN", "(", "insn", ")", ";", "process_cfa_offset", "(", "out_file", ",", "pat", ",", "unwind", ")", ";", "handled_one", "=", "true", ";", "break", ";", "case", "REG_CFA_REGISTER", ":", "pat", "=", "XEXP", "(", "note", ",", "0", ")", ";", "if", "(", "pat", "==", "NULL", ")", "pat", "=", "PATTERN", "(", "insn", ")", ";", "process_cfa_register", "(", "out_file", ",", "pat", ",", "unwind", ")", ";", "handled_one", "=", "true", ";", "break", ";", "case", "REG_FRAME_RELATED_EXPR", ":", "case", "REG_CFA_DEF_CFA", ":", "case", "REG_CFA_EXPRESSION", ":", "case", "REG_CFA_RESTORE", ":", "case", "REG_CFA_SET_VDRAP", ":", "gcc_unreachable", "(", ")", ";", "default", ":", "break", ";", "}", "gcc_assert", "(", "handled_one", ")", ";", "}", "</s>" ]
[ "This", "function", "looks", "at", "a", "single", "insn", "and", "emits", "any", "directives", "required", "to", "unwind", "this", "insn", "." ]
[ "ia64", "\"\\t.body\\n\"", "\"\\t.copy_state %d\\n\"", "0", "0", "\"\\t.save ar.pfs, r%d\\n\"", "0", "\"\\t.prologue\\n\"", "1", "0", "0", "0" ]
ia64
ia64_asm_unwind_emit
ia64
CPU
GCC
12,662
413
1
[]
[ "<s>", "bool", "MipsSEFrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "isInt", "<", "16", ">", "(", "MFI", "->", "getMaxCallFrameSize", "(", ")", ")", "&&", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]
[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]
[ "Mips", "Mips", "16" ]
MipsSEFrameLowering14
hasReservedCallFrame
Mips
CPU
LLVM
12,663
44
1
[]
[ "<s>", "DecodeStatus", "AArch64Disassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "OS", ",", "raw_ostream", "&", "CS", ")", "const", "{", "CommentStream", "=", "&", "CS", ";", "Size", "=", "0", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "return", "Fail", ";", "Size", "=", "4", ";", "uint32_t", "Insn", "=", "(", "Bytes", "[", "3", "]", "<<", "24", ")", "|", "(", "Bytes", "[", "2", "]", "<<", "16", ")", "|", "(", "Bytes", "[", "1", "]", "<<", "8", ")", "|", "(", "Bytes", "[", "0", "]", "<<", "0", ")", ";", "return", "decodeInstruction", "(", "DecoderTable32", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "</s>" ]
[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]
[ "AArch64", "AArch64", "0", "4", "4", "3", "24", "2", "16", "1", "8", "0", "0" ]
AArch64Disassembler (2)2
getInstruction
AArch64
CPU
LLVM
12,664
114
1
[]
[ "<s>", "bool", "RV16KFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", ";", "}", "</s>" ]
[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]
[ "RV16K", "RV16K" ]
RV16KFrameLowering
hasFP
RV16K
Virtual ISA
LLVM
12,665
72
1
[]
[ "<s>", "void", "WebAssemblyPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "Options", ".", "ThreadModel", "==", "ThreadModel", "::", "Single", ")", "addPass", "(", "createLowerAtomicPass", "(", ")", ")", ";", "else", "addPass", "(", "createAtomicExpandPass", "(", "TM", ")", ")", ";", "addPass", "(", "createWebAssemblyOptimizeReturned", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]
[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]
[ "WebAssembly", "WebAssembly", "WebAssembly" ]
WebAssemblyTargetMachine (2)
addIRPasses
WebAssembly
Virtual ISA
LLVM
12,666
49
1
[]
[ "<s>", "static", "rtx", "rs6000_legitimize_tls_address_aix", "(", "rtx", "addr", ",", "enum", "tls_model", "model", ")", "{", "rtx", "sym", ",", "mem", ",", "tocref", ",", "tlsreg", ",", "tmpreg", ",", "dest", ",", "tlsaddr", ";", "const", "char", "*", "name", ";", "char", "*", "tlsname", ";", "name", "=", "XSTR", "(", "addr", ",", "0", ")", ";", "if", "(", "name", "[", "strlen", "(", "name", ")", "-", "1", "]", "!=", "']'", "&&", "(", "TREE_PUBLIC", "(", "SYMBOL_REF_DECL", "(", "addr", ")", ")", "||", "bss_initializer_p", "(", "SYMBOL_REF_DECL", "(", "addr", ")", ")", ")", ")", "{", "tlsname", "=", "XALLOCAVEC", "(", "char", ",", "strlen", "(", "name", ")", "+", "4", ")", ";", "strcpy", "(", "tlsname", ",", "name", ")", ";", "strcat", "(", "tlsname", ",", "bss_initializer_p", "(", "SYMBOL_REF_DECL", "(", "addr", ")", ")", "?", "\"[UL]\"", ":", "\"[TL]\"", ")", ";", "tlsaddr", "=", "copy_rtx", "(", "addr", ")", ";", "XSTR", "(", "tlsaddr", ",", "0", ")", "=", "ggc_strdup", "(", "tlsname", ")", ";", "}", "else", "tlsaddr", "=", "addr", ";", "sym", "=", "force_const_mem", "(", "GET_MODE", "(", "tlsaddr", ")", ",", "tlsaddr", ")", ";", "if", "(", "constant_pool_expr_p", "(", "XEXP", "(", "sym", ",", "0", ")", ")", "&&", "ASM_OUTPUT_SPECIAL_POOL_ENTRY_P", "(", "get_pool_constant", "(", "XEXP", "(", "sym", ",", "0", ")", ")", ",", "Pmode", ")", ")", "{", "tocref", "=", "create_TOC_reference", "(", "XEXP", "(", "sym", ",", "0", ")", ",", "NULL_RTX", ")", ";", "mem", "=", "gen_const_mem", "(", "Pmode", ",", "tocref", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_TOC_alias_set", "(", ")", ")", ";", "}", "else", "return", "sym", ";", "if", "(", "model", "==", "TLS_MODEL_GLOBAL_DYNAMIC", "||", "model", "==", "TLS_MODEL_LOCAL_DYNAMIC", ")", "{", "name", "=", "XSTR", "(", "XVECEXP", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "0", ",", "0", ")", ",", "0", ")", ";", "tlsname", "=", "XALLOCAVEC", "(", "char", ",", "strlen", "(", "name", ")", "+", "1", ")", ";", "strcpy", "(", "tlsname", ",", "\"*LCM\"", ")", ";", "strcat", "(", "tlsname", ",", "name", "+", "3", ")", ";", "rtx", "modaddr", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "tlsname", ")", ")", ";", "SYMBOL_REF_FLAGS", "(", "modaddr", ")", "|=", "SYMBOL_FLAG_LOCAL", ";", "tocref", "=", "create_TOC_reference", "(", "modaddr", ",", "NULL_RTX", ")", ";", "rtx", "modmem", "=", "gen_const_mem", "(", "Pmode", ",", "tocref", ")", ";", "set_mem_alias_set", "(", "modmem", ",", "get_TOC_alias_set", "(", ")", ")", ";", "rtx", "modreg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "modreg", ",", "modmem", ")", ")", ";", "tmpreg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "tmpreg", ",", "mem", ")", ")", ";", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "if", "(", "TARGET_32BIT", ")", "emit_insn", "(", "gen_tls_get_addrsi", "(", "dest", ",", "modreg", ",", "tmpreg", ")", ")", ";", "else", "emit_insn", "(", "gen_tls_get_addrdi", "(", "dest", ",", "modreg", ",", "tmpreg", ")", ")", ";", "return", "dest", ";", "}", "else", "if", "(", "TARGET_32BIT", ")", "{", "tlsreg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_tls_get_tpointer", "(", "tlsreg", ")", ")", ";", "}", "else", "tlsreg", "=", "gen_rtx_REG", "(", "DImode", ",", "13", ")", ";", "tmpreg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "tmpreg", ",", "mem", ")", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "gen_rtx_MINUS", "(", "Pmode", ",", "addr", ",", "tlsreg", ")", ")", ";", "dest", "=", "force_reg", "(", "Pmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "tmpreg", ",", "tlsreg", ")", ")", ";", "return", "dest", ";", "}", "</s>" ]
[ "AIX", "Thread-Local", "Address", "support", "." ]
[ "rs6000", "0", "1", "4", "\"[UL]\"", "\"[TL]\"", "0", "0", "0", "0", "0", "0", "0", "0", "1", "\"*LCM\"", "3", "13" ]
rs60004
rs6000_legitimize_tls_address_aix
rs6000
CPU
GCC
12,667
496
1
[]
[ "<s>", "bool", "WebAssemblyTargetLowering", "::", "isVectorLoadExtDesirable", "(", "SDValue", "ExtVal", ")", "const", "{", "EVT", "ExtT", "=", "ExtVal", ".", "getValueType", "(", ")", ";", "EVT", "MemT", "=", "cast", "<", "LoadSDNode", ">", "(", "ExtVal", "->", "getOperand", "(", "0", ")", ")", "->", "getValueType", "(", "0", ")", ";", "return", "(", "ExtT", "==", "MVT", "::", "v8i16", "&&", "MemT", "==", "MVT", "::", "v8i8", ")", "||", "(", "ExtT", "==", "MVT", "::", "v4i32", "&&", "MemT", "==", "MVT", "::", "v4i16", ")", "||", "(", "ExtT", "==", "MVT", "::", "v2i64", "&&", "MemT", "==", "MVT", "::", "v2i32", ")", ";", "}", "</s>" ]
[ "Return", "true", "if", "folding", "a", "vector", "load", "into", "ExtVal", "(", "a", "sign", ",", "zero", ",", "or", "any", "extend", "node", ")", "is", "profitable", "." ]
[ "WebAssembly", "WebAssembly", "0", "0", "MVT::v8i16", "MVT::v8i8", "MVT::v4i32", "MVT::v4i16", "MVT::v2i64", "MVT::v2i32" ]
WebAssemblyISelLowering15
isVectorLoadExtDesirable
WebAssembly
Virtual ISA
LLVM
12,668
84
1
[]
[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "DLXTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]
[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]
[ "DLX", "DLX" ]
DLXISelLowering
getRegForInlineAsmConstraint
DLX
CPU
LLVM
12,669
40
1
[]
[ "<s>", "unsigned", "HexagonInstrInfo", "::", "getUnits", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "InstrItineraryData", "&", "II", "=", "*", "Subtarget", ".", "getInstrItineraryData", "(", ")", ";", "const", "InstrStage", "&", "IS", "=", "*", "II", ".", "beginStage", "(", "MI", ".", "getDesc", "(", ")", ".", "getSchedClass", "(", ")", ")", ";", "return", "IS", ".", "getUnits", "(", ")", ";", "}", "</s>" ]
[ "Returns", "the", "choice", "of", "FUs", "." ]
[ "Hexagon", "Hexagon" ]
HexagonInstrInfo (2)2
getUnits
Hexagon
DSP
LLVM
12,670
53
1
[]
[ "<s>", "static", "void", "emit_pop_byte", "(", "unsigned", "regno", ")", "{", "rtx", "mem", ",", "reg", ";", "mem", "=", "gen_rtx_PRE_INC", "(", "HImode", ",", "stack_pointer_rtx", ")", ";", "mem", "=", "gen_frame_mem", "(", "QImode", ",", "mem", ")", ";", "reg", "=", "gen_rtx_REG", "(", "QImode", ",", "regno", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ")", ";", "}", "</s>" ]
[ "Helper", "for", "avr_expand_epilogue", ".", "Emit", "a", "pop", "of", "a", "byte", "register", "." ]
[ "avr" ]
avr
emit_pop_byte
avr
MPU
GCC
12,671
51
1
[]
[ "<s>", "static", "void", "ix86_simd_clone_adjust", "(", "struct", "cgraph_node", "*", "node", ")", "{", "const", "char", "*", "str", "=", "NULL", ";", "if", "(", "!", "node", "->", "definition", ")", "return", ";", "gcc_assert", "(", "node", "->", "decl", "==", "cfun", "->", "decl", ")", ";", "switch", "(", "node", "->", "simdclone", "->", "vecsize_mangle", ")", "{", "case", "'b'", ":", "if", "(", "!", "TARGET_SSE2", ")", "str", "=", "\"sse2\"", ";", "break", ";", "case", "'c'", ":", "if", "(", "!", "TARGET_AVX", ")", "str", "=", "\"avx\"", ";", "break", ";", "case", "'d'", ":", "if", "(", "!", "TARGET_AVX2", ")", "str", "=", "\"avx2\"", ";", "break", ";", "case", "'e'", ":", "if", "(", "!", "TARGET_AVX512F", ")", "str", "=", "\"avx512f\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "str", "==", "NULL", ")", "return", ";", "push_cfun", "(", "NULL", ")", ";", "tree", "args", "=", "build_tree_list", "(", "NULL_TREE", ",", "build_string", "(", "strlen", "(", "str", ")", ",", "str", ")", ")", ";", "bool", "ok", "=", "ix86_valid_target_attribute_p", "(", "node", "->", "decl", ",", "NULL", ",", "args", ",", "0", ")", ";", "gcc_assert", "(", "ok", ")", ";", "pop_cfun", "(", ")", ";", "ix86_reset_previous_fndecl", "(", ")", ";", "ix86_set_current_function", "(", "node", "->", "decl", ")", ";", "}", "</s>" ]
[ "Add", "target", "attribute", "to", "SIMD", "clone", "NODE", "if", "needed", "." ]
[ "i386", "\"sse2\"", "\"avx\"", "\"avx2\"", "\"avx512f\"", "0" ]
i3868
ix86_simd_clone_adjust
i386
CPU
GCC
12,672
177
1
[]
[ "<s>", "void", "PPCRegisterInfo", "::", "materializeFrameBaseRegister", "(", "MachineBasicBlock", "*", "MBB", ",", "unsigned", "BaseReg", ",", "int", "FrameIdx", ",", "int64_t", "Offset", ")", "const", "{", "unsigned", "ADDriOpc", "=", "Subtarget", ".", "isPPC64", "(", ")", "?", "PPC", "::", "ADDI8", ":", "PPC", "::", "ADDI", ";", "MachineBasicBlock", "::", "iterator", "Ins", "=", "MBB", "->", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "Ins", "!=", "MBB", "->", "end", "(", ")", ")", "DL", "=", "Ins", "->", "getDebugLoc", "(", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", "->", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "TII", ".", "get", "(", "ADDriOpc", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "BaseReg", ",", "TII", ".", "getRegClass", "(", "MCID", ",", "0", ",", "this", ",", "MF", ")", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "MCID", ",", "BaseReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "Offset", ")", ";", "}", "</s>" ]
[ "Insert", "defining", "instruction", "(", "s", ")", "for", "a", "pointer", "to", "FrameIdx", "before", "insertion", "point", "I", "." ]
[ "PowerPC", "PPC", "PPC", "PPC::ADDI8", "PPC::ADDI", "0" ]
PPCRegisterInfo22
materializeFrameBaseRegister
PowerPC
CPU
LLVM
12,673
164
1
[]
[ "<s>", "unsigned", "X86TTI", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ")", "const", "{", "std", "::", "pair", "<", "unsigned", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "Ty", ")", ";", "int", "ISD", "=", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", ";", "assert", "(", "ISD", "&&", "\"Invalid opcode\"", ")", ";", "static", "const", "CostTblEntry", "<", "MVT", ">", "AVX1CostTable", "[", "]", "=", "{", "{", "ISD", "::", "MUL", ",", "MVT", "::", "v8i32", ",", "4", "}", ",", "{", "ISD", "::", "SUB", ",", "MVT", "::", "v8i32", ",", "4", "}", ",", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v8i32", ",", "4", "}", ",", "{", "ISD", "::", "SUB", ",", "MVT", "::", "v4i64", ",", "4", "}", ",", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v4i64", ",", "4", "}", ",", "{", "ISD", "::", "MUL", ",", "MVT", "::", "v4i64", ",", "18", "}", ",", "}", ";", "if", "(", "ST", "->", "hasAVX", "(", ")", "&&", "!", "ST", "->", "hasAVX2", "(", ")", ")", "{", "int", "Idx", "=", "CostTableLookup", "<", "MVT", ">", "(", "AVX1CostTable", ",", "array_lengthof", "(", "AVX1CostTable", ")", ",", "ISD", ",", "LT", ".", "second", ")", ";", "if", "(", "Idx", "!=", "-", "1", ")", "return", "LT", ".", "first", "*", "AVX1CostTable", "[", "Idx", "]", ".", "Cost", ";", "}", "static", "const", "CostTblEntry", "<", "MVT", ">", "CustomLowered", "[", "]", "=", "{", "{", "ISD", "::", "MUL", ",", "MVT", "::", "v2i64", ",", "9", "}", ",", "{", "ISD", "::", "MUL", ",", "MVT", "::", "v4i64", ",", "9", "}", ",", "}", ";", "int", "Idx", "=", "CostTableLookup", "<", "MVT", ">", "(", "CustomLowered", ",", "array_lengthof", "(", "CustomLowered", ")", ",", "ISD", ",", "LT", ".", "second", ")", ";", "if", "(", "Idx", "!=", "-", "1", ")", "return", "LT", ".", "first", "*", "CustomLowered", "[", "Idx", "]", ".", "Cost", ";", "if", "(", "ISD", "==", "ISD", "::", "MUL", "&&", "LT", ".", "second", "==", "MVT", "::", "v4i32", "&&", "ST", "->", "hasSSE2", "(", ")", "&&", "!", "ST", "->", "hasSSE41", "(", ")", ")", "return", "6", ";", "return", "TargetTransformInfo", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ")", ";", "}", "</s>" ]
[ "This", "is", "an", "approximation", "of", "reciprocal", "throughput", "of", "a", "math/logic", "op", "." ]
[ "X86", "X86", "\"Invalid opcode\"", "ISD::MUL", "MVT::v8i32", "4", "ISD::SUB", "MVT::v8i32", "4", "ISD::ADD", "MVT::v8i32", "4", "ISD::SUB", "MVT::v4i64", "4", "ISD::ADD", "MVT::v4i64", "4", "ISD::MUL", "MVT::v4i64", "18", "1", "ISD::MUL", "MVT::v2i64", "9", "ISD::MUL", "MVT::v4i64", "9", "1", "ISD::MUL", "MVT::v4i32", "6" ]
X86TargetTransformInfo113
getArithmeticInstrCost
X86
CPU
LLVM
12,674
312
1
[]
[ "<s>", "PreservedAnalyses", "HexagonLoopIdiomRecognitionPass", "::", "run", "(", "Loop", "&", "L", ",", "LoopAnalysisManager", "&", "AM", ",", "LoopStandardAnalysisResults", "&", "AR", ",", "LPMUpdater", "&", "U", ")", "{", "return", "HexagonLoopIdiomRecognize", "(", "&", "AR", ".", "AA", ",", "&", "AR", ".", "DT", ",", "&", "AR", ".", "LI", ",", "&", "AR", ".", "TLI", ",", "&", "AR", ".", "SE", ")", ".", "run", "(", "&", "L", ")", "?", "getLoopPassPreservedAnalyses", "(", ")", ":", "PreservedAnalyses", "::", "all", "(", ")", ";", "}", "</s>" ]
[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]
[ "Hexagon", "Hexagon", "Hexagon" ]
HexagonLoopIdiomRecognition1
run
Hexagon
DSP
LLVM
12,675
68
1
[]
[ "<s>", "void", "PPCDAGToDAGISel", "::", "PostprocessISelDAG", "(", ")", "{", "if", "(", "TM", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "return", ";", "PeepholePPC64", "(", ")", ";", "PeepholeCROps", "(", ")", ";", "}", "</s>" ]
[ "PostprocessISelDAG", "(", ")", "-", "This", "hook", "allows", "the", "target", "to", "hack", "on", "the", "graph", "right", "after", "selection", "." ]
[ "PowerPC", "PPC", "PPC" ]
PPCISelDAGToDAG102
PostprocessISelDAG
PowerPC
CPU
LLVM
12,676
30
1
[]
[ "<s>", "DEBUG_FUNCTION", "void", "debug_dispatch_window", "(", "int", "window_num", ")", "{", "debug_dispatch_window_file", "(", "stdout", ",", "window_num", ")", ";", "}", "</s>" ]
[ "Print", "to", "stdout", "a", "dispatch", "window", "." ]
[ "i386" ]
i3864
debug_dispatch_window
i386
CPU
GCC
12,677
16
1
[]
[ "<s>", "static", "tree", "arm_stack_protect_guard", "(", "void", ")", "{", "if", "(", "arm_stack_protector_guard", "==", "SSP_GLOBAL", ")", "return", "default_stack_protect_guard", "(", ")", ";", "return", "NULL_TREE", ";", "}", "</s>" ]
[ "Implement", "TARGET_STACK_PROTECT_GUARD", ".", "In", "case", "of", "a", "global", "variable", "based", "guard", "use", "the", "default", "else", "return", "a", "null", "tree", "." ]
[ "arm" ]
arm
arm_stack_protect_guard
arm
CPU
GCC
12,678
22
1
[]
[ "<s>", "bool", "isBlockAddress", "(", ")", "{", "return", "Kind", "==", "ARMCP", "::", "CPBlockAddress", ";", "}", "</s>" ]
[ "isBlockAddress", "-", "Tests", "if", "this", "is", "a", "MO_BlockAddress", "operand", "." ]
[ "ARM", "ARMCP::CPBlockAddress" ]
ARMConstantPoolValue10
isBlockAddress
ARM
CPU
LLVM
12,679
13
1
[]
[ "<s>", "int", "avr_simplify_comparison_p", "(", "machine_mode", "mode", ",", "RTX_CODE", "op", ",", "rtx", "x", ")", "{", "unsigned", "int", "max", "=", "(", "mode", "==", "QImode", "?", "0xff", ":", "mode", "==", "HImode", "?", "0xffff", ":", "mode", "==", "PSImode", "?", "0xffffff", ":", "mode", "==", "SImode", "?", "0xffffffff", ":", "0", ")", ";", "if", "(", "max", "&&", "op", "&&", "CONST_INT_P", "(", "x", ")", ")", "{", "if", "(", "unsigned_condition", "(", "op", ")", "!=", "op", ")", "max", ">>=", "1", ";", "if", "(", "max", "!=", "(", "INTVAL", "(", "x", ")", "&", "max", ")", "&&", "INTVAL", "(", "x", ")", "!=", "0xff", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]
[ "Return", "0", "if", "undefined", ",", "1", "if", "always", "true", "or", "always", "false", "." ]
[ "avr", "0xff", "0xffff", "0xffffff", "0xffffffff", "0", "1", "0xff", "1", "0" ]
avr
avr_simplify_comparison_p
avr
MPU
GCC
12,680
98
1
[]
[ "<s>", "bool", "reg_unused_after", "(", "rtx", "reg", ",", "rtx_insn", "*", "insn", ")", "{", "enum", "rtx_code", "code", ";", "rtx", "set", ";", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", "&&", "!", "MEM_P", "(", "SET_DEST", "(", "set", ")", ")", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "SET_DEST", "(", "set", ")", ")", ")", "return", "true", ";", "while", "(", "(", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", ")", "{", "rtx", "set", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "continue", ";", "code", "=", "GET_CODE", "(", "insn", ")", ";", "if", "(", "code", "==", "CODE_LABEL", ")", "return", "1", ";", "if", "(", "code", "==", "JUMP_INSN", ")", "return", "false", ";", "else", "if", "(", "code", "==", "INSN", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SEQUENCE", ")", "{", "rtx_sequence", "*", "seq", "=", "as_a", "<", "rtx_sequence", "*", ">", "(", "PATTERN", "(", "insn", ")", ")", ";", "int", "i", ";", "int", "retval", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "seq", "->", "len", "(", ")", ";", "i", "++", ")", "{", "rtx_insn", "*", "this_insn", "=", "seq", "->", "insn", "(", "i", ")", ";", "rtx", "set", "=", "single_set", "(", "this_insn", ")", ";", "if", "(", "CALL_P", "(", "this_insn", ")", ")", "code", "=", "CALL_INSN", ";", "else", "if", "(", "JUMP_P", "(", "this_insn", ")", ")", "{", "if", "(", "INSN_ANNULLED_BRANCH_P", "(", "this_insn", ")", ")", "return", "false", ";", "code", "=", "JUMP_INSN", ";", "}", "if", "(", "set", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "SET_SRC", "(", "set", ")", ")", ")", "return", "false", ";", "if", "(", "set", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "SET_DEST", "(", "set", ")", ")", ")", "{", "if", "(", "!", "MEM_P", "(", "SET_DEST", "(", "set", ")", ")", ")", "retval", "=", "true", ";", "else", "return", "false", ";", "}", "if", "(", "set", "==", "NULL_RTX", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "PATTERN", "(", "this_insn", ")", ")", ")", "return", "false", ";", "}", "if", "(", "retval", "==", "1", ")", "return", "true", ";", "else", "if", "(", "code", "==", "JUMP_INSN", ")", "return", "false", ";", "}", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "SET_SRC", "(", "set", ")", ")", ")", "return", "false", ";", "if", "(", "set", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "SET_DEST", "(", "set", ")", ")", ")", "return", "!", "MEM_P", "(", "SET_DEST", "(", "set", ")", ")", ";", "if", "(", "set", "==", "0", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "PATTERN", "(", "insn", ")", ")", ")", "return", "false", ";", "if", "(", "code", "==", "CALL_INSN", "&&", "call_really_used_regs", "[", "REGNO", "(", "reg", ")", "]", ")", "return", "true", ";", "}", "return", "true", ";", "}", "</s>" ]
[ "Return", "nonzero", "if", "REG", "is", "not", "used", "after", "INSN", ".", "We", "assume", "REG", "is", "a", "reload", "reg", ",", "and", "therefore", "does", "not", "live", "past", "labels", "or", "calls", "or", "jumps", "." ]
[ "sh", "1", "0", "0", "1", "0" ]
sh4
reg_unused_after
sh
CPU
GCC
12,681
396
1
[]
[ "<s>", "static", "void", "build_one", "(", "function_builder", "&", "b", ",", "const", "char", "*", "signature", ",", "const", "function_group_info", "&", "group", ",", "mode_suffix_index", "mode_suffix_id", ",", "unsigned", "int", "ti", ",", "unsigned", "int", "pi", ",", "bool", "force_direct_overloads", ")", "{", "auto_vec", "<", "tree", ",", "16", ">", "argument_types", ";", "function_instance", "instance", "(", "group", ".", "base_name", ",", "*", "group", ".", "base", ",", "*", "group", ".", "shape", ",", "mode_suffix_id", ",", "group", ".", "types", "[", "ti", "]", ",", "group", ".", "preds", "[", "pi", "]", ")", ";", "tree", "return_type", "=", "parse_signature", "(", "instance", ",", "signature", ",", "argument_types", ")", ";", "apply_predication", "(", "instance", ",", "return_type", ",", "argument_types", ")", ";", "b", ".", "add_unique_function", "(", "instance", ",", "return_type", ",", "argument_types", ",", "group", ".", "required_extensions", ",", "force_direct_overloads", ")", ";", "}", "</s>" ]
[ "Add", "one", "function", "instance", "for", "GROUP", ",", "using", "operand", "suffix", "at", "index", "OI", ",", "mode", "suffix", "at", "index", "PAIR", "&", "&", "bi", "and", "predication", "suffix", "at", "index", "pred_idx", "." ]
[ "aarch64", "16" ]
aarch64-sve-builtins-shapes
build_one
aarch64
CPU
GCC
12,682
114
1
[]
[ "<s>", "static", "std", "::", "unique_ptr", "<", "MipsOperand", ">", "CreateReg", "(", "unsigned", "Index", ",", "StringRef", "Str", ",", "RegKind", "RegKind", ",", "const", "MCRegisterInfo", "*", "RegInfo", ",", "SMLoc", "S", ",", "SMLoc", "E", ",", "MipsAsmParser", "&", "Parser", ")", "{", "auto", "Op", "=", "make_unique", "<", "MipsOperand", ">", "(", "k_RegisterIndex", ",", "Parser", ")", ";", "Op", "->", "RegIdx", ".", "Index", "=", "Index", ";", "Op", "->", "RegIdx", ".", "RegInfo", "=", "RegInfo", ";", "Op", "->", "RegIdx", ".", "Kind", "=", "RegKind", ";", "Op", "->", "RegIdx", ".", "Tok", ".", "Data", "=", "Str", ".", "data", "(", ")", ";", "Op", "->", "RegIdx", ".", "Tok", ".", "Length", "=", "Str", ".", "size", "(", ")", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]
[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]
[ "Mips", "Mips", "Mips", "Mips" ]
MipsAsmParser37
CreateReg
Mips
CPU
LLVM
12,683
115
1
[]
[ "<s>", "void", "bpf_expand_epilogue", "(", "void", ")", "{", "if", "(", "TARGET_XBPF", ")", "{", "int", "regno", ";", "int", "fp_offset", "=", "-", "cfun", "->", "machine", "->", "local_vars_size", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "{", "if", "(", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", "||", "(", "cfun", "->", "calls_alloca", "&&", "regno", "==", "STACK_POINTER_REGNUM", ")", ")", "{", "rtx", "mem", ";", "if", "(", "!", "IN_RANGE", "(", "fp_offset", ",", "-", "1", "-", "0x7fff", ",", "0x7fff", ")", ")", "break", ";", "else", "{", "mem", "=", "gen_frame_mem", "(", "DImode", ",", "plus_constant", "(", "DImode", ",", "hard_frame_pointer_rtx", ",", "fp_offset", "-", "8", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ",", "mem", ")", ";", "fp_offset", "-=", "8", ";", "}", "}", "}", "}", "emit_jump_insn", "(", "gen_exit", "(", ")", ")", ";", "}", "</s>" ]
[ "Expand", "to", "the", "instructions", "in", "a", "function", "epilogue", ".", "This", "function", "is", "called", "when", "expanding", "the", "'epilogue", "'", "pattern", "in", "bpf.md", "." ]
[ "bpf", "0", "1", "0x7fff", "0x7fff", "8", "8" ]
bpf1
bpf_expand_epilogue
bpf
Virtual ISA
GCC
12,684
132
1
[]
[ "<s>", "ARMBaseTargetMachine", "::", "ARMBaseTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "isLittle", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "CPU", ",", "Options", ",", "isLittle", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "TargetABI", "(", "computeTargetABI", "(", "TT", ",", "CPU", ",", "Options", ")", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ",", "isLittle", ")", ",", "isLittle", "(", "isLittle", ")", "{", "if", "(", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "this", "->", "Options", ".", "FloatABIType", "=", "Subtarget", ".", "isTargetHardFloat", "(", ")", "?", "FloatABI", "::", "Hard", ":", "FloatABI", "::", "Soft", ";", "if", "(", "Options", ".", "EABIVersion", "==", "EABI", "::", "Default", "||", "Options", ".", "EABIVersion", "==", "EABI", "::", "Unknown", ")", "{", "if", "(", "Subtarget", ".", "isTargetGNUAEABI", "(", ")", ")", "this", "->", "Options", ".", "EABIVersion", "=", "EABI", "::", "GNU", ";", "else", "this", "->", "Options", ".", "EABIVersion", "=", "EABI", "::", "EABI5", ";", "}", "}", "</s>" ]
[ "Create", "an", "ARM", "architecture", "model", "." ]
[ "ARM", "ARM", "ARM" ]
ARMTargetMachine (2)1
ARMBaseTargetMachine
ARM
CPU
LLVM
12,685
195
1
[]
[ "<s>", "static", "unsigned", "HOST_WIDE_INT", "sparc_asan_shadow_offset", "(", "void", ")", "{", "return", "TARGET_ARCH64", "?", "(", "HOST_WIDE_INT_1", "<<", "43", ")", ":", "(", "HOST_WIDE_INT_1", "<<", "29", ")", ";", "}", "</s>" ]
[ "Implement", "the", "TARGET_ASAN_SHADOW_OFFSET", "hook", "." ]
[ "sparc", "43", "29" ]
sparc
sparc_asan_shadow_offset
sparc
CPU
GCC
12,686
24
1
[]
[ "<s>", "void", "ARMConstantIslands", "::", "verify", "(", "MachineFunction", "&", "MF", ")", "{", "assert", "(", "BBOffsets", ".", "size", "(", ")", "==", "BBSizes", ".", "size", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "1", ",", "e", "=", "BBOffsets", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "assert", "(", "BBOffsets", "[", "i", "-", "1", "]", "+", "BBSizes", "[", "i", "-", "1", "]", "==", "BBOffsets", "[", "i", "]", ")", ";", "if", "(", "!", "isThumb", ")", "return", ";", "for", "(", "MachineFunction", "::", "iterator", "MBBI", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MBBI", "!=", "E", ";", "++", "MBBI", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "MBBI", ";", "if", "(", "!", "MBB", "->", "empty", "(", ")", "&&", "MBB", "->", "begin", "(", ")", "->", "getOpcode", "(", ")", "==", "ARM", "::", "CONSTPOOL_ENTRY", ")", "{", "unsigned", "MBBId", "=", "MBB", "->", "getNumber", "(", ")", ";", "assert", "(", "HasInlineAsm", "||", "(", "BBOffsets", "[", "MBBId", "]", "%", "4", "==", "0", "&&", "BBSizes", "[", "MBBId", "]", "%", "4", "==", "0", ")", "||", "(", "BBOffsets", "[", "MBBId", "]", "%", "4", "!=", "0", "&&", "BBSizes", "[", "MBBId", "]", "%", "4", "!=", "0", ")", ")", ";", "}", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CPUsers", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CPUser", "&", "U", "=", "CPUsers", "[", "i", "]", ";", "unsigned", "UserOffset", "=", "GetOffsetOf", "(", "U", ".", "MI", ")", "+", "(", "isThumb", "?", "4", ":", "8", ")", ";", "unsigned", "CPEOffset", "=", "GetOffsetOf", "(", "U", ".", "CPEMI", ")", ";", "unsigned", "Disp", "=", "UserOffset", "<", "CPEOffset", "?", "CPEOffset", "-", "UserOffset", ":", "UserOffset", "-", "CPEOffset", ";", "assert", "(", "Disp", "<=", "U", ".", "MaxDisp", "||", "\"Constant pool entry out of range!\"", ")", ";", "}", "}", "</s>" ]
[ "Check", "if", "this", "register", "bank", "is", "valid", "." ]
[ "ARM", "ARM", "1", "1", "1", "ARM::CONSTPOOL_ENTRY", "4", "0", "4", "0", "4", "0", "4", "0", "0", "4", "8", "\"Constant pool entry out of range!\"" ]
ARMConstantIslandPass14
verify
ARM
CPU
LLVM
12,687
279
1
[]
[ "<s>", "unsigned", "MSP430AsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "MSP430Operand", "&", "Op", "=", "static_cast", "<", "MSP430Operand", "&", ">", "(", "AsmOp", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "return", "Match_InvalidOperand", ";", "unsigned", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "bool", "isGR16", "=", "MSP430MCRegisterClasses", "[", "MSP430", "::", "GR16RegClassID", "]", ".", "contains", "(", "Reg", ")", ";", "if", "(", "isGR16", "&&", "(", "Kind", "==", "MCK_GR8", ")", ")", "{", "Op", ".", "setReg", "(", "convertGR16ToGR8", "(", "Reg", ")", ")", ";", "return", "Match_Success", ";", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]
[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]
[ "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430::GR16RegClassID" ]
MSP430AsmParser
validateTargetOperandClass
MSP430
MPU
LLVM
12,688
91
1
[]
[ "<s>", "bool", "SITargetLowering", "::", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "{", "return", "(", "GA", "->", "getAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "GLOBAL_ADDRESS", "||", "GA", "->", "getAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS", "||", "GA", "->", "getAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS_32BIT", ")", "&&", "!", "shouldEmitGOTReloc", "(", "GA", "->", "getGlobal", "(", ")", ")", ";", "}", "</s>" ]
[ "Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "." ]
[ "AMDGPU", "SI", "AMDGPU", "AMDGPU", "AMDGPU" ]
SIISelLowering (2)3
isOffsetFoldingLegal
AMDGPU
GPU
LLVM
12,689
56
1
[]
[ "<s>", "const", "char", "*", "emit_fusion_p9_store", "(", "rtx", "mem", ",", "rtx", "reg", ",", "rtx", "tmp_reg", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "reg", ")", ";", "rtx", "hi", ";", "rtx", "lo", ";", "rtx", "addr", ";", "const", "char", "*", "store_string", ";", "int", "r", ";", "if", "(", "GET_CODE", "(", "reg", ")", "==", "SUBREG", ")", "{", "gcc_assert", "(", "SUBREG_BYTE", "(", "reg", ")", "==", "0", ")", ";", "reg", "=", "SUBREG_REG", "(", "reg", ")", ";", "}", "if", "(", "!", "REG_P", "(", "reg", ")", ")", "fatal_insn", "(", "\"emit_fusion_p9_store, bad reg #1\"", ",", "reg", ")", ";", "r", "=", "REGNO", "(", "reg", ")", ";", "if", "(", "FP_REGNO_P", "(", "r", ")", ")", "{", "if", "(", "mode", "==", "SFmode", ")", "store_string", "=", "\"stfs\"", ";", "else", "if", "(", "mode", "==", "DFmode", ")", "store_string", "=", "\"stfd\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "INT_REGNO_P", "(", "r", ")", ")", "{", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "store_string", "=", "\"stb\"", ";", "break", ";", "case", "HImode", ":", "store_string", "=", "\"sth\"", ";", "break", ";", "case", "SImode", ":", "case", "SFmode", ":", "store_string", "=", "\"stw\"", ";", "break", ";", "case", "DImode", ":", "case", "DFmode", ":", "if", "(", "!", "TARGET_POWERPC64", ")", "gcc_unreachable", "(", ")", ";", "store_string", "=", "\"std\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "fatal_insn", "(", "\"emit_fusion_p9_store, bad reg #2\"", ",", "reg", ")", ";", "if", "(", "!", "MEM_P", "(", "mem", ")", ")", "fatal_insn", "(", "\"emit_fusion_p9_store not MEM\"", ",", "mem", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "fusion_split_address", "(", "addr", ",", "&", "hi", ",", "&", "lo", ")", ";", "emit_fusion_addis", "(", "tmp_reg", ",", "hi", ",", "\"power9 store fusion\"", ",", "GET_MODE_NAME", "(", "mode", ")", ")", ";", "emit_fusion_load_store", "(", "reg", ",", "tmp_reg", ",", "lo", ",", "store_string", ")", ";", "return", "\"\"", ";", "}", "</s>" ]
[ "Return", "a", "string", "to", "fuse", "an", "addis", "instruction", "with", "a", "store", "using", "extended", "fusion", ".", "The", "address", "that", "is", "used", "is", "the", "logical", "address", "that", "was", "formed", "during", "peephole2", ":", "(", "lo_sum", "(", "high", ")", "(", "low-part", ")", ")", "The", "code", "is", "complicated", ",", "so", "we", "call", "output_asm_insn", "directly", ",", "and", "just", "return", "``", "''", "." ]
[ "rs6000", "0", "\"emit_fusion_p9_store, bad reg #1\"", "\"stfs\"", "\"stfd\"", "\"stb\"", "\"sth\"", "\"stw\"", "\"std\"", "\"emit_fusion_p9_store, bad reg #2\"", "\"emit_fusion_p9_store not MEM\"", "0", "\"power9 store fusion\"", "\"\"" ]
rs60005
emit_fusion_p9_store
rs6000
CPU
GCC
12,690
271
1
[]
[ "<s>", "rtx", "function_expander", "::", "expand", "(", ")", "{", "unsigned", "int", "nargs", "=", "call_expr_nargs", "(", "call_expr", ")", ";", "args", ".", "reserve", "(", "nargs", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "nargs", ";", "++", "i", ")", "args", ".", "quick_push", "(", "expand_normal", "(", "CALL_EXPR_ARG", "(", "call_expr", ",", "i", ")", ")", ")", ";", "return", "base", "->", "expand", "(", "*", "this", ")", ";", "}", "</s>" ]
[ "Expand", "the", "call", "and", "return", "its", "lhs", "." ]
[ "aarch64", "0" ]
aarch64-sve-builtins
expand
aarch64
CPU
GCC
12,691
63
1
[]
[ "<s>", "SDNode", "*", "TOYDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "llvm_unreachable", "(", "\"getGlobalBaseReg not implemented yet!\\n\"", ")", ";", "}", "</s>" ]
[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]
[ "TOY", "TOY", "\"getGlobalBaseReg not implemented yet!\\n\"" ]
TOYISelDAGToDAG
getGlobalBaseReg
TOY
CPU
LLVM
12,692
14
1
[]
[ "<s>", "SMLoc", "getStartLoc", "(", ")", "const", "override", "{", "return", "Start", ";", "}", "</s>" ]
[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]
[ "MCS51" ]
MCS51AsmParser
getStartLoc
MCS51
MPU
LLVM
12,693
11
1
[]
[ "<s>", "SDValue", "MBlazeTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_MBlaze", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "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", "(", ")", ",", "Outs", "[", "i", "]", ".", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "MBlazeISD", "::", "Ret", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "DAG", ".", "getRegister", "(", "MBlaze", "::", "R15", ",", "MVT", "::", "i32", ")", ",", "Flag", ")", ";", "else", "return", "DAG", ".", "getNode", "(", "MBlazeISD", "::", "Ret", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "DAG", ".", "getRegister", "(", "MBlaze", "::", "R15", ",", "MVT", "::", "i32", ")", ")", ";", "}", "</s>" ]
[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]
[ "MBlaze", "MBlaze", "ISD::OutputArg", "16", "MBlaze", "0", "0", "\"Can only return in registers!\"", "1", "MBlazeISD::Ret", "MVT::Other", "MBlaze::R15", "MVT::i32", "MBlazeISD::Ret", "MVT::Other", "MBlaze::R15", "MVT::i32" ]
MBlazeISelLowering1
LowerReturn
MBlaze
MPU
LLVM
12,694
293
1
[]
[ "<s>", "const", "DirectXSubtarget", "*", "DirectXTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "{", "return", "Subtarget", ".", "get", "(", ")", ";", "}", "</s>" ]
[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]
[ "DirectX" ]
DirectXTargetMachine
getSubtargetImpl
DirectX
Virtual ISA
LLVM
12,695
21
1
[]
[ "<s>", "bool", "FPGATTIImpl", "::", "isLegalMaskedStore", "(", "Type", "*", "DataType", ")", "{", "return", "true", ";", "}", "</s>" ]
[ "Return", "true", "if", "the", "target", "supports", "masked", "store", "." ]
[ "FPGA", "FPGA" ]
FPGATargetTransformInfo
isLegalMaskedStore
FPGA
CPU
LLVM
12,696
14
1
[]
[ "<s>", "rtx", "msp430_eh_return_stackadj_rtx", "(", "void", ")", "{", "if", "(", "!", "cfun", "->", "machine", "->", "eh_stack_adjust", ")", "{", "rtx", "sa", ";", "sa", "=", "gen_rtx_REG", "(", "Pmode", ",", "15", ")", ";", "cfun", "->", "machine", "->", "eh_stack_adjust", "=", "sa", ";", "}", "return", "cfun", "->", "machine", "->", "eh_stack_adjust", ";", "}", "</s>" ]
[ "Implements", "EH_RETURN_STACKADJ_RTX", ".", "Saved", "and", "used", "later", "in", "m32c_emit_eh_epilogue", "." ]
[ "msp430", "15" ]
msp430
msp430_eh_return_stackadj_rtx
msp430
MPU
GCC
12,697
45
1
[]
[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "RISCV_EXPAND_SDMA_NAME", ";", "}", "</s>" ]
[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]
[ "RI5CY", "RISCV" ]
RISCVExpandSDMAInsts
getPassName
RI5CY
CPU
LLVM
12,698
11
1
[]
[ "<s>", "bool", "HexagonExpandCondsets", "::", "split", "(", "MachineInstr", "&", "MI", ",", "std", "::", "set", "<", "Register", ">", "&", "UpdRegs", ")", "{", "if", "(", "TfrLimitActive", ")", "{", "if", "(", "TfrCounter", ">=", "TfrLimit", ")", "return", "false", ";", "TfrCounter", "++", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nsplitting \"", "<<", "printMBBReference", "(", "*", "MI", ".", "getParent", "(", ")", ")", "<<", "\": \"", "<<", "MI", ")", ";", "MachineOperand", "&", "MD", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "MachineOperand", "&", "MP", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "assert", "(", "MD", ".", "isDef", "(", ")", ")", ";", "Register", "DR", "=", "MD", ".", "getReg", "(", ")", ",", "DSR", "=", "MD", ".", "getSubReg", "(", ")", ";", "bool", "ReadUndef", "=", "MD", ".", "isUndef", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "At", "=", "MI", ";", "auto", "updateRegs", "=", "[", "&", "UpdRegs", "]", "(", "const", "MachineInstr", "&", "MI", ")", "->", "void", "{", "for", "(", "auto", "&", "Op", ":", "MI", ".", "operands", "(", ")", ")", "if", "(", "Op", ".", "isReg", "(", ")", ")", "UpdRegs", ".", "insert", "(", "Op", ".", "getReg", "(", ")", ")", ";", "}", ";", "MachineOperand", "&", "ST", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "MachineOperand", "&", "SF", "=", "MI", ".", "getOperand", "(", "3", ")", ";", "if", "(", "ST", ".", "isReg", "(", ")", "&&", "SF", ".", "isReg", "(", ")", ")", "{", "RegisterRef", "RT", "(", "ST", ")", ";", "if", "(", "RT", "==", "RegisterRef", "(", "SF", ")", ")", "{", "updateRegs", "(", "MI", ")", ";", "MI", ".", "setDesc", "(", "HII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ")", ";", "unsigned", "S", "=", "getRegState", "(", "ST", ")", ";", "while", "(", "MI", ".", "getNumOperands", "(", ")", ">", "1", ")", "MI", ".", "RemoveOperand", "(", "MI", ".", "getNumOperands", "(", ")", "-", "1", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineInstrBuilder", "(", "MF", ",", "MI", ")", ".", "addReg", "(", "RT", ".", "Reg", ",", "S", ",", "RT", ".", "Sub", ")", ";", "return", "true", ";", "}", "}", "MachineInstr", "*", "TfrT", "=", "genCondTfrFor", "(", "ST", ",", "At", ",", "DR", ",", "DSR", ",", "MP", ",", "true", ",", "ReadUndef", ",", "false", ")", ";", "MachineInstr", "*", "TfrF", "=", "genCondTfrFor", "(", "SF", ",", "At", ",", "DR", ",", "DSR", ",", "MP", ",", "false", ",", "ReadUndef", ",", "true", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "TfrT", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "TfrF", ")", ";", "updateRegs", "(", "MI", ")", ";", "removeInstr", "(", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]
[ "Split", "into", "substrings", "around", "the", "occurrences", "of", "a", "separator", "character", "." ]
[ "Hexagon", "Hexagon", "\"\\nsplitting \"", "\": \"", "0", "1", "2", "3", "1", "1" ]
HexagonExpandCondsets20
split
Hexagon
DSP
LLVM
12,699
392
1
[]