Datasets:
docz1105
/
ComBack

Dataset card Data Studio Files
ground_truth
sequencelengths
8
512
natrual_language
sequencelengths
1
243
TS_V_token
sequencelengths
1
182
File
stringlengths
2
45
Func
stringlengths
1
56
Target
stringclasses
175 values
Target_Clf
stringclasses
6 values
Compiler_Type
stringclasses
2 values
Idx
int64
0
36.2k
Length
int64
6
510
Cover_Rate
float64
1
1
Template_token
sequencelengths
0
0
[ "<s>", "bool", "nonpic_symbol_mentioned_p", "(", "rtx", "x", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "x", ")", "==", "PC", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_PIC", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOT", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOTOFF", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOTPLT", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOTTPOFF", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_DTPOFF", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_TPOFF", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_PLT", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_SYMOFF", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_PCREL_SYMOFF", ")", ")", "return", "false", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "x", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "x", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "x", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "nonpic_symbol_mentioned_p", "(", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ")", ")", "return", "true", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "nonpic_symbol_mentioned_p", "(", "XEXP", "(", "x", ",", "i", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]
[ "Return", "TRUE", "if", "X", "references", "a", "SYMBOL_REF", "or", "LABEL_REF", "whose", "symbol", "is", "n't", "protected", "by", "a", "PIC", "unspec", "." ]
[ "sh", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "0", "1", "0" ]
sh4
nonpic_symbol_mentioned_p
sh
CPU
GCC
4,500
268
1
[]
[ "<s>", "bool", "isKZeroMasked", "(", ")", "const", "{", "return", "(", "Attributes", "&", "KZeroMasked", ")", "!=", "0", ";", "}", "</s>" ]
[ "Returns", "true", "iff", "the", "group", "of", "FMA", "opcodes", "holds", "k-zero-masked", "opcodes", "." ]
[ "X86", "0" ]
X86InstrFMA3Info11
isKZeroMasked
X86
CPU
LLVM
4,501
16
1
[]
[ "<s>", "int", "mips_ldst_scaled_shift", "(", "machine_mode", "mode", ")", "{", "int", "shift", "=", "exact_log2", "(", "GET_MODE_UNIT_SIZE", "(", "mode", ")", ")", ";", "if", "(", "shift", "<", "0", "||", "shift", ">", "8", ")", "gcc_unreachable", "(", ")", ";", "return", "shift", ";", "}", "</s>" ]
[ "Return", "the", "scale", "shift", "that", "applied", "to", "MSA", "LD/ST", "address", "offset", "." ]
[ "mips", "0", "8" ]
mips
mips_ldst_scaled_shift
mips
CPU
GCC
4,502
36
1
[]
[ "<s>", "SDValue", "BPFTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "break", ";", "}", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_BPF64", ")", ";", "for", "(", "auto", "&", "VA", ":", "ArgLocs", ")", "{", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "switch", "(", "RegVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "{", "errs", "(", ")", "<<", "\"LowerFormalArguments Unhandled argument type: \"", "<<", "RegVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", "<<", "'\\n'", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "case", "MVT", "::", "i64", ":", "unsigned", "VReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "BPF", "::", "GPRRegClass", ")", ";", "RegInfo", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "SDValue", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VReg", ",", "RegVT", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "DL", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "DL", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "ArgValue", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "}", "}", "else", "{", "fail", "(", "DL", ",", "DAG", ",", "\"defined with too many args\"", ")", ";", "}", "}", "if", "(", "IsVarArg", "||", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "fail", "(", "DL", ",", "DAG", ",", "\"functions with VarArgs or StructRet are not supported\"", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]
[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]
[ "BPF", "BPF", "ISD::InputArg", "\"Unsupported calling convention\"", "16", "BPF", "\"LowerFormalArguments Unhandled argument type: \"", "0", "MVT::i64", "BPF::GPRRegClass", "ISD::AssertSext", "ISD::AssertZext", "ISD::TRUNCATE", "\"defined with too many args\"", "\"functions with VarArgs or StructRet are not supported\"" ]
BPFISelLowering6
LowerFormalArguments
BPF
Virtual ISA
LLVM
4,503
398
1
[]
[ "<s>", "void", "SITargetLowering", "::", "AdjustInstrPostInstrSelection", "(", "MachineInstr", "&", "MI", ",", "SDNode", "*", "Node", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "if", "(", "TII", "->", "isVOP3", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "TII", "->", "legalizeOperandsVOP3", "(", "MRI", ",", "MI", ")", ";", "return", ";", "}", "int", "NoRetAtomicOp", "=", "AMDGPU", "::", "getAtomicNoRetOp", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "NoRetAtomicOp", "!=", "-", "1", ")", "{", "if", "(", "!", "Node", "->", "hasAnyUseOfValue", "(", "0", ")", ")", "{", "MI", ".", "setDesc", "(", "TII", "->", "get", "(", "NoRetAtomicOp", ")", ")", ";", "MI", ".", "RemoveOperand", "(", "0", ")", ";", "return", ";", "}", "if", "(", "(", "Node", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", "&&", "Node", "->", "use_begin", "(", ")", "->", "isMachineOpcode", "(", ")", "&&", "Node", "->", "use_begin", "(", ")", "->", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "EXTRACT_SUBREG", "&&", "!", "Node", "->", "use_begin", "(", ")", "->", "hasAnyUseOfValue", "(", "0", ")", ")", ")", "{", "unsigned", "Def", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "MI", ".", "setDesc", "(", "TII", "->", "get", "(", "NoRetAtomicOp", ")", ")", ";", "MI", ".", "RemoveOperand", "(", "0", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "IMPLICIT_DEF", ")", ",", "Def", ")", ";", "}", "return", ";", "}", "}", "</s>" ]
[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'hasPostISelHook", "'", "flag", "." ]
[ "AMDGPU", "SI", "SI", "AMDGPU::getAtomicNoRetOp", "1", "0", "0", "1", "0", "AMDGPU::EXTRACT_SUBREG", "0", "0", "0", "AMDGPU::IMPLICIT_DEF" ]
SIISelLowering (2)3
AdjustInstrPostInstrSelection
AMDGPU
GPU
LLVM
4,504
244
1
[]
[ "<s>", "void", "SIFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "FuncInfo", "->", "isEntryFunction", "(", ")", ")", "return", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "for", "(", "const", "SIMachineFunctionInfo", "::", "SGPRSpillVGPRCSR", "&", "Reg", ":", "FuncInfo", "->", "getSGPRSpillVGPRs", "(", ")", ")", "{", "if", "(", "!", "Reg", ".", "FI", ".", "hasValue", "(", ")", ")", "continue", ";", "TII", "->", "loadRegFromStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ".", "VGPR", ",", "Reg", ".", "FI", ".", "getValue", "(", ")", ",", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "&", "TII", "->", "getRegisterInfo", "(", ")", ")", ";", "}", "unsigned", "StackPtrReg", "=", "FuncInfo", "->", "getStackPtrOffsetReg", "(", ")", ";", "if", "(", "StackPtrReg", "==", "AMDGPU", "::", "NoRegister", ")", "return", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "uint32_t", "NumBytes", "=", "MFI", ".", "getStackSize", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "NumBytes", "!=", "0", "&&", "hasSP", "(", "MF", ")", ")", "{", "uint32_t", "RoundedSize", "=", "FuncInfo", "->", "isStackRealigned", "(", ")", "?", "NumBytes", "+", "MFI", ".", "getMaxAlignment", "(", ")", ":", "NumBytes", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_SUB_U32", ")", ",", "StackPtrReg", ")", ".", "addReg", "(", "StackPtrReg", ")", ".", "addImm", "(", "RoundedSize", "*", "ST", ".", "getWavefrontSize", "(", ")", ")", ";", "}", "}", "</s>" ]
[ "Insert", "epilog", "code", "into", "the", "function", "." ]
[ "AMDGPU", "SI", "SI", "SI", "SI", "SI", "AMDGPU::VGPR_32RegClass", "AMDGPU::NoRegister", "0", "AMDGPU::S_SUB_U32" ]
SIFrameLowering16
emitEpilogue
AMDGPU
GPU
LLVM
4,505
249
1
[]
[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"AGC pseudo instruction expansion pass\"", ";", "}", "</s>" ]
[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]
[ "AGC", "\"AGC pseudo instruction expansion pass\"" ]
AGCExpandPseudos
getPassName
AGC
MPU
LLVM
4,506
11
1
[]
[ "<s>", "void", "msp430_split_movsi", "(", "rtx", "*", "operands", ")", "{", "rtx", "op00", ",", "op02", ",", "op10", ",", "op12", ";", "op00", "=", "msp430_subreg", "(", "HImode", ",", "operands", "[", "0", "]", ",", "SImode", ",", "0", ")", ";", "op02", "=", "msp430_subreg", "(", "HImode", ",", "operands", "[", "0", "]", ",", "SImode", ",", "2", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST", "||", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "SYMBOL_REF", ")", "{", "op10", "=", "gen_rtx_ZERO_EXTRACT", "(", "HImode", ",", "operands", "[", "1", "]", ",", "GEN_INT", "(", "16", ")", ",", "GEN_INT", "(", "0", ")", ")", ";", "op10", "=", "gen_rtx_CONST", "(", "HImode", ",", "op10", ")", ";", "op12", "=", "gen_rtx_ZERO_EXTRACT", "(", "HImode", ",", "operands", "[", "1", "]", ",", "GEN_INT", "(", "16", ")", ",", "GEN_INT", "(", "16", ")", ")", ";", "op12", "=", "gen_rtx_CONST", "(", "HImode", ",", "op12", ")", ";", "}", "else", "{", "op10", "=", "msp430_subreg", "(", "HImode", ",", "operands", "[", "1", "]", ",", "SImode", ",", "0", ")", ";", "op12", "=", "msp430_subreg", "(", "HImode", ",", "operands", "[", "1", "]", ",", "SImode", ",", "2", ")", ";", "}", "if", "(", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", "{", "operands", "[", "2", "]", "=", "op02", ";", "operands", "[", "4", "]", "=", "op12", ";", "operands", "[", "3", "]", "=", "op00", ";", "operands", "[", "5", "]", "=", "op10", ";", "}", "else", "if", "(", "rtx_equal_p", "(", "op00", ",", "op12", ")", "||", "(", "REG_P", "(", "op00", ")", "&&", "reg_mentioned_p", "(", "op00", ",", "op10", ")", ")", "||", "(", "REG_P", "(", "op10", ")", "&&", "reg_mentioned_p", "(", "op10", ",", "op00", ")", ")", ")", "{", "operands", "[", "2", "]", "=", "op02", ";", "operands", "[", "4", "]", "=", "op12", ";", "operands", "[", "3", "]", "=", "op00", ";", "operands", "[", "5", "]", "=", "op10", ";", "}", "else", "{", "operands", "[", "2", "]", "=", "op00", ";", "operands", "[", "4", "]", "=", "op10", ";", "operands", "[", "3", "]", "=", "op02", ";", "operands", "[", "5", "]", "=", "op12", ";", "}", "}", "</s>" ]
[ "Called", "by", "movsi_x", "to", "generate", "the", "HImode", "operands", "." ]
[ "msp430", "0", "0", "0", "2", "1", "1", "1", "16", "0", "1", "16", "16", "1", "0", "1", "2", "0", "1", "2", "4", "3", "5", "2", "4", "3", "5", "2", "4", "3", "5" ]
msp4302
msp430_split_movsi
msp430
MPU
GCC
4,507
315
1
[]
[ "<s>", "bool", "TeakRegisterInfo", "::", "requiresRegisterScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]
[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]
[ "Teak", "Teak" ]
TeakRegisterInfo
requiresRegisterScavenging
Teak
DSP
LLVM
4,508
16
1
[]
[ "<s>", "int", "avr_jump_mode", "(", "rtx", "x", ",", "rtx_insn", "*", "insn", ")", "{", "int", "dest_addr", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", "?", "XEXP", "(", "x", ",", "0", ")", ":", "x", ")", ")", ";", "int", "cur_addr", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ";", "int", "jump_distance", "=", "cur_addr", "-", "dest_addr", ";", "if", "(", "IN_RANGE", "(", "jump_distance", ",", "-", "63", ",", "62", ")", ")", "return", "1", ";", "else", "if", "(", "IN_RANGE", "(", "jump_distance", ",", "-", "2046", ",", "2045", ")", ")", "return", "2", ";", "else", "if", "(", "AVR_HAVE_JMP_CALL", ")", "return", "3", ";", "return", "2", ";", "}", "</s>" ]
[ "Choose", "mode", "for", "jump", "insn", ":", "1", "-", "relative", "jump", "in", "range", "-63", "<", "=", "x", "<", "=", "62", ";", "2", "-", "relative", "jump", "in", "range", "-2046", "<", "=", "x", "<", "=", "2045", ";", "3", "-", "absolute", "jump", "(", "only", "for", "ATmega", "[", "16", "]", "03", ")", "." ]
[ "avr", "0", "63", "62", "1", "2046", "2045", "2", "3", "2" ]
avr
avr_jump_mode
avr
MPU
GCC
4,509
97
1
[]
[ "<s>", "static", "rtx", "mn10300_delegitimize_address", "(", "rtx", "orig_x", ")", "{", "rtx", "x", "=", "orig_x", ",", "ret", ",", "addend", "=", "NULL", ";", "bool", "need_mem", ";", "if", "(", "MEM_P", "(", "x", ")", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "PLUS", "||", "GET_MODE", "(", "x", ")", "!=", "Pmode", ")", "return", "orig_x", ";", "if", "(", "XEXP", "(", "x", ",", "0", ")", "==", "pic_offset_table_rtx", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", ")", "{", "rtx", "x0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "x00", "=", "XEXP", "(", "x0", ",", "0", ")", ";", "rtx", "x01", "=", "XEXP", "(", "x0", ",", "1", ")", ";", "if", "(", "x00", "==", "pic_offset_table_rtx", ")", "addend", "=", "x01", ";", "else", "if", "(", "x01", "==", "pic_offset_table_rtx", ")", "addend", "=", "x00", ";", "else", "return", "orig_x", ";", "}", "else", "return", "orig_x", ";", "x", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "CONST", ")", "return", "orig_x", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "UNSPEC", ")", "return", "orig_x", ";", "ret", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "if", "(", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOTOFF", ")", "need_mem", "=", "false", ";", "else", "if", "(", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOT", ")", "need_mem", "=", "true", ";", "else", "return", "orig_x", ";", "gcc_assert", "(", "GET_CODE", "(", "ret", ")", "==", "SYMBOL_REF", ")", ";", "if", "(", "need_mem", "!=", "MEM_P", "(", "orig_x", ")", ")", "return", "orig_x", ";", "if", "(", "need_mem", "&&", "addend", ")", "return", "orig_x", ";", "if", "(", "addend", ")", "ret", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "addend", ",", "ret", ")", ";", "return", "ret", ";", "}", "</s>" ]
[ "Undo", "pic", "address", "legitimization", "for", "the", "benefit", "of", "debug", "info", "." ]
[ "mn10300", "0", "0", "0", "0", "0", "1", "1", "0", "0", "0", "1", "1" ]
mn10300
mn10300_delegitimize_address
mn10300
MPU
GCC
4,510
283
1
[]
[ "<s>", "DecodeStatus", "AMDGPUDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes_", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "WS", ",", "raw_ostream", "&", "CS", ")", "const", "{", "CommentStream", "=", "&", "CS", ";", "if", "(", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "AMDGPU", "::", "FeatureGCN3Encoding", "]", ")", "report_fatal_error", "(", "\"Disassembly not yet supported for subtarget\"", ")", ";", "const", "unsigned", "MaxInstBytesNum", "=", "(", "std", "::", "min", ")", "(", "(", "size_t", ")", "8", ",", "Bytes_", ".", "size", "(", ")", ")", ";", "Bytes", "=", "Bytes_", ".", "slice", "(", "0", ",", "MaxInstBytesNum", ")", ";", "DecodeStatus", "Res", "=", "MCDisassembler", "::", "Fail", ";", "do", "{", "if", "(", "Bytes", ".", "size", "(", ")", ">=", "8", ")", "{", "const", "uint64_t", "QW", "=", "eatBytes", "<", "uint64_t", ">", "(", "Bytes", ")", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableDPP64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableSDWA64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "}", "Bytes", "=", "Bytes_", ".", "slice", "(", "0", ",", "MaxInstBytesNum", ")", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "break", ";", "const", "uint32_t", "DW", "=", "eatBytes", "<", "uint32_t", ">", "(", "Bytes", ")", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableVI32", ",", "MI", ",", "DW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableAMDGPU32", ",", "MI", ",", "DW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "break", ";", "const", "uint64_t", "QW", "=", "(", "(", "uint64_t", ")", "eatBytes", "<", "uint32_t", ">", "(", "Bytes", ")", "<<", "32", ")", "|", "DW", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableVI64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableAMDGPU64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "}", "while", "(", "false", ")", ";", "if", "(", "Res", "&&", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F32_e64_vi", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F32_e64_si", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F16_e64_vi", ")", ")", "{", "int", "Src2ModIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", ".", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "src2_modifiers", ")", ";", "auto", "I", "=", "MI", ".", "begin", "(", ")", ";", "std", "::", "advance", "(", "I", ",", "Src2ModIdx", ")", ";", "MI", ".", "insert", "(", "I", ",", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "}", "Size", "=", "Res", "?", "(", "MaxInstBytesNum", "-", "Bytes", ".", "size", "(", ")", ")", ":", "0", ";", "return", "Res", ";", "}", "</s>" ]
[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]
[ "AMDGPU", "AMDGPU", "AMDGPU::FeatureGCN3Encoding", "\"Disassembly not yet supported for subtarget\"", "8", "0", "8", "0", "4", "AMDGPU", "4", "32", "AMDGPU", "AMDGPU::V_MAC_F32_e64_vi", "AMDGPU::V_MAC_F32_e64_si", "AMDGPU::V_MAC_F16_e64_vi", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "0", "0" ]
AMDGPUDisassembler37
getInstruction
AMDGPU
GPU
LLVM
4,511
414
1
[]
[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"ReplaceFMULS: Erratum Fix LBR32: replace FMULS instruction with a \"", "\"routine using conversions/double precision operations to replace \"", "\"FMULS\"", ";", "}", "</s>" ]
[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]
[ "Sparc", "\"ReplaceFMULS: Erratum Fix LBR32: replace FMULS instruction with a \"", "\"routine using conversions/double precision operations to replace \"", "\"FMULS\"" ]
LeonPasses5
getPassName
Sparc
CPU
LLVM
4,512
13
1
[]
[ "<s>", "static", "void", "rs6000_debug_reg_print", "(", "int", "first_regno", ",", "int", "last_regno", ",", "const", "char", "*", "reg_name", ")", "{", "int", "r", ",", "m", ";", "for", "(", "r", "=", "first_regno", ";", "r", "<=", "last_regno", ";", "++", "r", ")", "{", "const", "char", "*", "comma", "=", "\"\"", ";", "int", "len", ";", "if", "(", "first_regno", "==", "last_regno", ")", "fprintf", "(", "stderr", ",", "\"%s:\\t\"", ",", "reg_name", ")", ";", "else", "fprintf", "(", "stderr", ",", "\"%s%d:\\t\"", ",", "reg_name", ",", "r", "-", "first_regno", ")", ";", "len", "=", "8", ";", "for", "(", "m", "=", "0", ";", "m", "<", "NUM_MACHINE_MODES", ";", "++", "m", ")", "if", "(", "rs6000_hard_regno_mode_ok_p", "[", "m", "]", "[", "r", "]", "&&", "rs6000_hard_regno_nregs", "[", "m", "]", "[", "r", "]", ")", "{", "if", "(", "len", ">", "70", ")", "{", "fprintf", "(", "stderr", ",", "\",\\n\\t\"", ")", ";", "len", "=", "8", ";", "comma", "=", "\"\"", ";", "}", "if", "(", "rs6000_hard_regno_nregs", "[", "m", "]", "[", "r", "]", ">", "1", ")", "len", "+=", "fprintf", "(", "stderr", ",", "\"%s%s/%d\"", ",", "comma", ",", "GET_MODE_NAME", "(", "m", ")", ",", "rs6000_hard_regno_nregs", "[", "m", "]", "[", "r", "]", ")", ";", "else", "len", "+=", "fprintf", "(", "stderr", ",", "\"%s%s\"", ",", "comma", ",", "GET_MODE_NAME", "(", "m", ")", ")", ";", "comma", "=", "\", \"", ";", "}", "if", "(", "call_used_regs", "[", "r", "]", ")", "{", "if", "(", "len", ">", "70", ")", "{", "fprintf", "(", "stderr", ",", "\",\\n\\t\"", ")", ";", "len", "=", "8", ";", "comma", "=", "\"\"", ";", "}", "len", "+=", "fprintf", "(", "stderr", ",", "\"%s%s\"", ",", "comma", ",", "\"call-used\"", ")", ";", "comma", "=", "\", \"", ";", "}", "if", "(", "fixed_regs", "[", "r", "]", ")", "{", "if", "(", "len", ">", "70", ")", "{", "fprintf", "(", "stderr", ",", "\",\\n\\t\"", ")", ";", "len", "=", "8", ";", "comma", "=", "\"\"", ";", "}", "len", "+=", "fprintf", "(", "stderr", ",", "\"%s%s\"", ",", "comma", ",", "\"fixed\"", ")", ";", "comma", "=", "\", \"", ";", "}", "if", "(", "len", ">", "70", ")", "{", "fprintf", "(", "stderr", ",", "\",\\n\\t\"", ")", ";", "comma", "=", "\"\"", ";", "}", "len", "+=", "fprintf", "(", "stderr", ",", "\"%sreg-class = %s\"", ",", "comma", ",", "reg_class_names", "[", "(", "int", ")", "rs6000_regno_regclass", "[", "r", "]", "]", ")", ";", "comma", "=", "\", \"", ";", "if", "(", "len", ">", "70", ")", "{", "fprintf", "(", "stderr", ",", "\",\\n\\t\"", ")", ";", "comma", "=", "\"\"", ";", "}", "fprintf", "(", "stderr", ",", "\"%sregno = %d\\n\"", ",", "comma", ",", "r", ")", ";", "}", "}", "</s>" ]
[ "Print", "interesting", "facts", "about", "registers", "." ]
[ "powerpcspe", "\"\"", "\"%s:\\t\"", "\"%s%d:\\t\"", "8", "0", "70", "\",\\n\\t\"", "8", "\"\"", "1", "\"%s%s/%d\"", "\"%s%s\"", "\", \"", "70", "\",\\n\\t\"", "8", "\"\"", "\"%s%s\"", "\"call-used\"", "\", \"", "70", "\",\\n\\t\"", "8", "\"\"", "\"%s%s\"", "\"fixed\"", "\", \"", "70", "\",\\n\\t\"", "\"\"", "\"%sreg-class = %s\"", "\", \"", "70", "\",\\n\\t\"", "\"\"", "\"%sregno = %d\\n\"" ]
powerpcspe
rs6000_debug_reg_print
powerpcspe
CPU
GCC
4,513
366
1
[]
[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "report_fatal_error", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "return", "LowerCCCArguments", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "case", "CallingConv", "::", "MSP430_INTR", ":", "if", "(", "Ins", ".", "empty", "(", ")", ")", "return", "Chain", ";", "report_fatal_error", "(", "\"ISRs cannot have arguments\"", ")", ";", "}", "}", "</s>" ]
[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]
[ "MSP430", "MSP430", "ISD::InputArg", "\"Unsupported calling convention\"", "MSP430", "\"ISRs cannot have arguments\"" ]
MSP430ISelLowering (2)1
LowerFormalArguments
MSP430
MPU
LLVM
4,514
107
1
[]
[ "<s>", "MachineBasicBlock", "*", "WebAssemblyTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "case", "WebAssembly", "::", "FP_TO_SINT_I32_F32", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "false", ",", "false", ",", "false", ",", "WebAssembly", "::", "I32_TRUNC_S_F32", ")", ";", "case", "WebAssembly", "::", "FP_TO_UINT_I32_F32", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "true", ",", "false", ",", "false", ",", "WebAssembly", "::", "I32_TRUNC_U_F32", ")", ";", "case", "WebAssembly", "::", "FP_TO_SINT_I64_F32", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "false", ",", "true", ",", "false", ",", "WebAssembly", "::", "I64_TRUNC_S_F32", ")", ";", "case", "WebAssembly", "::", "FP_TO_UINT_I64_F32", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "true", ",", "true", ",", "false", ",", "WebAssembly", "::", "I64_TRUNC_U_F32", ")", ";", "case", "WebAssembly", "::", "FP_TO_SINT_I32_F64", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "false", ",", "false", ",", "true", ",", "WebAssembly", "::", "I32_TRUNC_S_F64", ")", ";", "case", "WebAssembly", "::", "FP_TO_UINT_I32_F64", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "true", ",", "false", ",", "true", ",", "WebAssembly", "::", "I32_TRUNC_U_F64", ")", ";", "case", "WebAssembly", "::", "FP_TO_SINT_I64_F64", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "false", ",", "true", ",", "true", ",", "WebAssembly", "::", "I64_TRUNC_S_F64", ")", ";", "case", "WebAssembly", "::", "FP_TO_UINT_I64_F64", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "true", ",", "true", ",", "true", ",", "WebAssembly", "::", "I64_TRUNC_U_F64", ")", ";", "llvm_unreachable", "(", "\"Unexpected instruction to emit with custom inserter\"", ")", ";", "}", "}", "</s>" ]
[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]
[ "WebAssembly", "WebAssembly", "\"Unexpected instr type to insert\"", "WebAssembly::FP_TO_SINT_I32_F32", "WebAssembly::I32_TRUNC_S_F32", "WebAssembly::FP_TO_UINT_I32_F32", "WebAssembly::I32_TRUNC_U_F32", "WebAssembly::FP_TO_SINT_I64_F32", "WebAssembly::I64_TRUNC_S_F32", "WebAssembly::FP_TO_UINT_I64_F32", "WebAssembly::I64_TRUNC_U_F32", "WebAssembly::FP_TO_SINT_I32_F64", "WebAssembly::I32_TRUNC_S_F64", "WebAssembly::FP_TO_UINT_I32_F64", "WebAssembly::I32_TRUNC_U_F64", "WebAssembly::FP_TO_SINT_I64_F64", "WebAssembly::I64_TRUNC_S_F64", "WebAssembly::FP_TO_UINT_I64_F64", "WebAssembly::I64_TRUNC_U_F64", "\"Unexpected instruction to emit with custom inserter\"" ]
WebAssemblyISelLowering
EmitInstrWithCustomInserter
WebAssembly
Virtual ISA
LLVM
4,515
276
1
[]
[ "<s>", "bool", "sparc_expand_conditional_move", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "enum", "rtx_code", "rc", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "machine_mode", "cmp_mode", ";", "rtx", "cc_reg", ",", "dst", ",", "cmp", ";", "cmp", "=", "operands", "[", "1", "]", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "cmp", ",", "0", ")", ")", "==", "DImode", "&&", "!", "TARGET_ARCH64", ")", "return", "false", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "cmp", ",", "0", ")", ")", "==", "TFmode", "&&", "!", "TARGET_HARD_QUAD", ")", "cmp", "=", "sparc_emit_float_lib_cmp", "(", "XEXP", "(", "cmp", ",", "0", ")", ",", "XEXP", "(", "cmp", ",", "1", ")", ",", "rc", ")", ";", "cmp_mode", "=", "GET_MODE", "(", "XEXP", "(", "cmp", ",", "0", ")", ")", ";", "rc", "=", "GET_CODE", "(", "cmp", ")", ";", "dst", "=", "operands", "[", "0", "]", ";", "if", "(", "!", "rtx_equal_p", "(", "operands", "[", "2", "]", ",", "dst", ")", "&&", "!", "rtx_equal_p", "(", "operands", "[", "3", "]", ",", "dst", ")", ")", "{", "if", "(", "reg_overlap_mentioned_p", "(", "dst", ",", "cmp", ")", ")", "dst", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_move_insn", "(", "dst", ",", "operands", "[", "3", "]", ")", ";", "}", "else", "if", "(", "operands", "[", "2", "]", "==", "dst", ")", "{", "operands", "[", "2", "]", "=", "operands", "[", "3", "]", ";", "if", "(", "GET_MODE_CLASS", "(", "cmp_mode", ")", "==", "MODE_FLOAT", ")", "rc", "=", "reverse_condition_maybe_unordered", "(", "rc", ")", ";", "else", "rc", "=", "reverse_condition", "(", "rc", ")", ";", "}", "if", "(", "XEXP", "(", "cmp", ",", "1", ")", "==", "const0_rtx", "&&", "GET_CODE", "(", "XEXP", "(", "cmp", ",", "0", ")", ")", "==", "REG", "&&", "cmp_mode", "==", "DImode", "&&", "v9_regcmp_p", "(", "rc", ")", ")", "cc_reg", "=", "XEXP", "(", "cmp", ",", "0", ")", ";", "else", "cc_reg", "=", "gen_compare_reg_1", "(", "rc", ",", "XEXP", "(", "cmp", ",", "0", ")", ",", "XEXP", "(", "cmp", ",", "1", ")", ")", ";", "cmp", "=", "gen_rtx_fmt_ee", "(", "rc", ",", "GET_MODE", "(", "cc_reg", ")", ",", "cc_reg", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dst", ",", "gen_rtx_IF_THEN_ELSE", "(", "mode", ",", "cmp", ",", "operands", "[", "2", "]", ",", "dst", ")", ")", ")", ";", "if", "(", "dst", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "dst", ")", ";", "return", "true", ";", "}", "</s>" ]
[ "Emit", "code", "to", "conditionally", "move", "either", "OPERANDS", "[", "2", "]", "or", "OPERANDS", "[", "3", "]", "into", "OPERANDS", "[", "0", "]", "in", "MODE", ".", "OPERANDS", "[", "1", "]", "is", "the", "operator", "of", "the", "condition", "." ]
[ "sparc", "1", "1", "0", "0", "0", "1", "0", "0", "2", "3", "3", "2", "2", "3", "1", "0", "0", "0", "1", "2", "0", "0" ]
sparc4
sparc_expand_conditional_move
sparc
CPU
GCC
4,516
348
1
[]
[ "<s>", "bool", "OR1KFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "return", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", "||", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ")", ";", "}", "</s>" ]
[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]
[ "OR1K", "OR1K" ]
OR1KFrameLowering
hasFP
OR1K
CPU
LLVM
4,517
78
1
[]
[ "<s>", "void", "AMDGPUFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "</s>" ]
[ "Insert", "epilog", "code", "into", "the", "function", "." ]
[ "R600" ]
AMDGPUFrameLowering
emitEpilogue
R600
GPU
LLVM
4,518
16
1
[]
[ "<s>", "bool", "isZero", "(", ")", "{", "if", "(", "!", "isImm", "(", ")", ")", "return", "false", ";", "if", "(", "const", "auto", "*", "ConstExpr", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Imm", ".", "Val", ")", ")", "{", "int64_t", "Value", "=", "ConstExpr", "->", "getValue", "(", ")", ";", "return", "Value", "==", "0", ";", "}", "return", "false", ";", "}", "</s>" ]
[ "Return", "true", "if", "the", "expression", "is", "a", "constant", "zero", "." ]
[ "VE", "0" ]
VEAsmParser (2)
isZero
VE
CPU
LLVM
4,519
52
1
[]
[ "<s>", "static", "void", "pa_output_function_epilogue", "(", "FILE", "*", "file", ")", "{", "rtx_insn", "*", "insn", "=", "get_last_insn", "(", ")", ";", "bool", "extra_nop", ";", "if", "(", "NOTE_P", "(", "insn", ")", ")", "insn", "=", "prev_real_insn", "(", "insn", ")", ";", "if", "(", "insn", "&&", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SEQUENCE", ")", "insn", "=", "as_a", "<", "rtx_sequence", "*", ">", "(", "PATTERN", "(", "insn", ")", ")", "->", "insn", "(", "0", ")", ";", "if", "(", "insn", "&&", "CALL_P", "(", "insn", ")", ")", "{", "fputs", "(", "\"\\tnop\\n\"", ",", "file", ")", ";", "extra_nop", "=", "true", ";", "}", "else", "extra_nop", "=", "false", ";", "fputs", "(", "\"\\t.EXIT\\n\\t.PROCEND\\n\"", ",", "file", ")", ";", "if", "(", "TARGET_SOM", "&&", "TARGET_GAS", ")", "{", "in_section", "=", "NULL", ";", "cfun", "->", "machine", "->", "in_nsubspa", "=", "2", ";", "}", "if", "(", "cfun", "->", "is_thunk", ")", "return", ";", "if", "(", "INSN_ADDRESSES_SET_P", "(", ")", ")", "{", "last_address", "=", "extra_nop", "?", "4", ":", "0", ";", "insn", "=", "get_last_nonnote_insn", "(", ")", ";", "if", "(", "insn", ")", "{", "last_address", "+=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ";", "if", "(", "INSN_P", "(", "insn", ")", ")", "last_address", "+=", "insn_default_length", "(", "insn", ")", ";", "}", "last_address", "=", "(", "(", "last_address", "+", "FUNCTION_BOUNDARY", "/", "BITS_PER_UNIT", "-", "1", ")", "&", "~", "(", "FUNCTION_BOUNDARY", "/", "BITS_PER_UNIT", "-", "1", ")", ")", ";", "}", "else", "last_address", "=", "UINT_MAX", ";", "update_total_code_bytes", "(", "last_address", ")", ";", "}", "</s>" ]
[ "This", "function", "generates", "the", "assembly", "code", "for", "function", "exit", ".", "Args", "are", "as", "for", "output_function_prologue", "(", ")", ".", "The", "function", "epilogue", "should", "not", "depend", "on", "the", "current", "stack", "pointer", "!", "It", "should", "use", "the", "frame", "pointer", "only", ".", "This", "is", "mandatory", "because", "of", "alloca", ";", "we", "also", "take", "advantage", "of", "it", "to", "omit", "stack", "adjustments", "before", "returning", "." ]
[ "pa", "0", "\"\\tnop\\n\"", "\"\\t.EXIT\\n\\t.PROCEND\\n\"", "2", "4", "0", "1", "1" ]
pa
pa_output_function_epilogue
pa
CPU
GCC
4,520
220
1
[]
[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerFREM", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "SL", "(", "Op", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "auto", "Flags", "=", "Op", "->", "getFlags", "(", ")", ";", "SDValue", "X", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "SDValue", "Y", "=", "Op", ".", "getOperand", "(", "1", ")", ";", "SDValue", "Div", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FDIV", ",", "SL", ",", "VT", ",", "X", ",", "Y", ",", "Flags", ")", ";", "SDValue", "Trunc", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FTRUNC", ",", "SL", ",", "VT", ",", "Div", ",", "Flags", ")", ";", "SDValue", "Neg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FNEG", ",", "SL", ",", "VT", ",", "Trunc", ",", "Flags", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "FMA", ",", "SL", ",", "VT", ",", "Neg", ",", "Y", ",", "X", ",", "Flags", ")", ";", "}", "</s>" ]
[ "Split", "a", "vector", "store", "into", "multiple", "scalar", "stores", "." ]
[ "AMDGPU", "AMDGPU", "0", "1", "ISD::FDIV", "ISD::FTRUNC", "ISD::FNEG", "ISD::FMA" ]
AMDGPUISelLowering (2)1
LowerFREM
AMDGPU
GPU
LLVM
4,521
143
1
[]
[ "<s>", "uint64_t", "MipsFrameLowering", "::", "estimateStackSize", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "int64_t", "Offset", "=", "0", ";", "for", "(", "int", "I", "=", "MFI", "->", "getObjectIndexBegin", "(", ")", ";", "I", "!=", "0", ";", "++", "I", ")", "Offset", "=", "std", "::", "max", "(", "Offset", ",", "-", "MFI", "->", "getObjectOffset", "(", "I", ")", ")", ";", "for", "(", "const", "MCPhysReg", "*", "R", "=", "TRI", ".", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "*", "R", ";", "++", "R", ")", "{", "unsigned", "Size", "=", "TRI", ".", "getMinimalPhysRegClass", "(", "*", "R", ")", "->", "getSize", "(", ")", ";", "Offset", "=", "alignTo", "(", "Offset", "+", "Size", ",", "Size", ")", ";", "}", "unsigned", "MaxAlign", "=", "MFI", "->", "getMaxAlignment", "(", ")", ";", "assert", "(", "!", "MFI", "->", "getObjectIndexEnd", "(", ")", "||", "MaxAlign", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MFI", "->", "getObjectIndexEnd", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Offset", "=", "alignTo", "(", "Offset", "+", "MFI", "->", "getObjectSize", "(", "I", ")", ",", "MaxAlign", ")", ";", "if", "(", "MFI", "->", "adjustsStack", "(", ")", "&&", "hasReservedCallFrame", "(", "MF", ")", ")", "Offset", "=", "alignTo", "(", "Offset", "+", "MFI", "->", "getMaxCallFrameSize", "(", ")", ",", "std", "::", "max", "(", "MaxAlign", ",", "getStackAlignment", "(", ")", ")", ")", ";", "return", "alignTo", "(", "Offset", ",", "getStackAlignment", "(", ")", ")", ";", "}", "</s>" ]
[ "Estimate", "and", "return", "the", "size", "of", "the", "stack", "frame", "." ]
[ "Mips", "Mips", "0", "0", "0" ]
MipsFrameLowering24
estimateStackSize
Mips
CPU
LLVM
4,522
231
1
[]
[ "<s>", "bool", "tilegx_bitfield_operand_p", "(", "HOST_WIDE_INT", "n", ",", "int", "*", "first_bit", ",", "int", "*", "last_bit", ")", "{", "int", "i", ";", "if", "(", "n", "==", "0", ")", "return", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "64", ";", "i", "++", ")", "{", "unsigned", "HOST_WIDE_INT", "x", "=", "rotate_right", "(", "n", ",", "i", ")", ";", "if", "(", "!", "(", "x", "&", "1", ")", ")", "continue", ";", "if", "(", "(", "x", "&", "(", "x", "+", "1", ")", ")", "==", "0", ")", "{", "if", "(", "first_bit", "!=", "NULL", ")", "*", "first_bit", "=", "i", ";", "if", "(", "last_bit", "!=", "NULL", ")", "*", "last_bit", "=", "(", "i", "+", "exact_log2", "(", "x", "^", "(", "x", ">>", "1", ")", ")", ")", "&", "63", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]
[ "Return", "true", "iff", "n", "contains", "exactly", "one", "contiguous", "sequence", "of", "1", "bits", ",", "possibly", "wrapping", "around", "from", "high", "bits", "to", "low", "bits", "." ]
[ "tilegx", "0", "0", "64", "1", "1", "0", "1", "63" ]
tilegx
tilegx_bitfield_operand_p
tilegx
VLIW
GCC
4,523
124
1
[]
[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"NVPTX optimize redundant cvta.to.local instruction\"", ";", "}", "</s>" ]
[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]
[ "NVPTX", "\"NVPTX optimize redundant cvta.to.local instruction\"" ]
NVPTXPeephole
getPassName
NVPTX
GPU
LLVM
4,524
11
1
[]
[ "<s>", "bool", "supportSplitCSR", "(", "MachineFunction", "*", "MF", ")", "const", "override", "{", "return", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CXX_FAST_TLS", "&&", "MF", "->", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", ";", "}", "</s>" ]
[ "Return", "true", "if", "the", "target", "supports", "that", "a", "subset", "of", "CSRs", "for", "the", "given", "machine", "function", "is", "handled", "explicitly", "via", "copies", "." ]
[ "AArch64" ]
AArch64ISelLowering (2)1
supportSplitCSR
AArch64
CPU
LLVM
4,525
39
1
[]
[ "<s>", "const", "LegalizerInfo", "*", "getLegalizerInfo", "(", ")", "const", "override", "{", "return", "Legalizer", ".", "get", "(", ")", ";", "}", "</s>" ]
[ "Expose", "LegalizerInfo", "so", "the", "clients", "can", "re-use", "." ]
[ "X86" ]
X86Subtarget24
getLegalizerInfo
X86
CPU
LLVM
4,526
17
1
[]
[ "<s>", "void", "WebAssemblyFrameLowering", "::", "writeSPToGlobal", "(", "unsigned", "SrcReg", ",", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "InsertStore", ",", "const", "DebugLoc", "&", "DL", ")", "const", "{", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "char", "*", "ES", "=", "\"__stack_pointer\"", ";", "auto", "*", "SPSymbol", "=", "MF", ".", "createExternalSymbolName", "(", "ES", ")", ";", "BuildMI", "(", "MBB", ",", "InsertStore", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "SET_GLOBAL_I32", ")", ")", ".", "addExternalSymbol", "(", "SPSymbol", ",", "WebAssemblyII", "::", "MO_SYMBOL_GLOBAL", ")", ".", "addReg", "(", "SrcReg", ")", ";", "}", "</s>" ]
[ "Write", "SP", "back", "to", "__stack_pointer", "global", "." ]
[ "WebAssembly", "WebAssembly", "WebAssembly", "\"__stack_pointer\"", "WebAssembly::SET_GLOBAL_I32", "WebAssemblyII::MO_SYMBOL_GLOBAL" ]
WebAssemblyFrameLowering10
writeSPToGlobal
WebAssembly
Virtual ISA
LLVM
4,527
98
1
[]
[ "<s>", "bool", "SPIRVBasicBlockDominance", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "DominatorTree", "&", "DT", "=", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "SmallVector", "<", "BasicBlock", "*", ",", "16", ">", "newBBOrder", ";", "bool", "changedOrder", "=", "false", ";", "for", "(", "auto", "&", "BB", ":", "F", ")", "{", "bool", "inserted", "=", "false", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "newBBOrder", ".", "size", "(", ")", ";", "++", "i", ")", "{", "if", "(", "DT", ".", "dominates", "(", "&", "BB", ",", "newBBOrder", "[", "i", "]", ")", ")", "{", "newBBOrder", ".", "insert", "(", "newBBOrder", ".", "begin", "(", ")", "+", "i", ",", "&", "BB", ")", ";", "inserted", "=", "true", ";", "changedOrder", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "inserted", ")", "{", "newBBOrder", ".", "push_back", "(", "&", "BB", ")", ";", "}", "}", "if", "(", "changedOrder", ")", "{", "for", "(", "auto", "BB", ":", "newBBOrder", ")", "{", "BB", "->", "removeFromParent", "(", ")", ";", "F", ".", "getBasicBlockList", "(", ")", ".", "push_back", "(", "BB", ")", ";", "}", "}", "return", "changedOrder", ";", "}", "</s>" ]
[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]
[ "SPIRV", "SPIRV", "16", "0" ]
SPIRVBasicBlockDominance
runOnFunction
SPIRV
Virtual ISA
LLVM
4,528
168
1
[]
[ "<s>", "void", "TOYInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]
[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]
[ "TOY", "TOY" ]
TOYInstPrinter1
printInst
TOY
CPU
LLVM
4,529
38
1
[]
[ "<s>", "const", "MCPhysReg", "*", "CSKYRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "CSKYSubtarget", "&", "STI", "=", "MF", "->", "getSubtarget", "<", "CSKYSubtarget", ">", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "if", "(", "STI", ".", "hasFPUv3DoubleFloat", "(", ")", ")", "return", "CSR_GPR_FPR64v3_ISR_SaveList", ";", "if", "(", "STI", ".", "hasFPUv3SingleFloat", "(", ")", ")", "return", "CSR_GPR_FPR32v3_ISR_SaveList", ";", "if", "(", "STI", ".", "hasFPUv2DoubleFloat", "(", ")", ")", "return", "CSR_GPR_FPR64_ISR_SaveList", ";", "if", "(", "STI", ".", "hasFPUv2SingleFloat", "(", ")", ")", "return", "CSR_GPR_FPR32_ISR_SaveList", ";", "return", "CSR_GPR_ISR_SaveList", ";", "}", "if", "(", "STI", ".", "hasFPUv2DoubleFloat", "(", ")", "||", "STI", ".", "hasFPUv3DoubleFloat", "(", ")", ")", "return", "CSR_GPR_FPR64_SaveList", ";", "if", "(", "STI", ".", "hasFPUv2SingleFloat", "(", ")", "||", "STI", ".", "hasFPUv3SingleFloat", "(", ")", ")", "return", "CSR_GPR_FPR32_SaveList", ";", "return", "CSR_I32_SaveList", ";", "}", "</s>" ]
[ "Code", "Generation", "virtual", "methods", "..." ]
[ "CSKY", "CSKY", "CSKY", "CSKY", "\"interrupt\"" ]
CSKYRegisterInfo1
getCalleeSavedRegs
CSKY
CPU
LLVM
4,530
128
1
[]
[ "<s>", "const", "TargetRegisterClass", "*", "getPointerRegClass", "(", "unsigned", "Kind", "=", "0", ")", "const", "{", "return", "&", "BF", "::", "PRegClass", ";", "}", "</s>" ]
[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]
[ "Blackfin", "0", "BF::PRegClass" ]
BlackfinRegisterInfo1
getPointerRegClass
Blackfin
DSP
LLVM
4,531
19
1
[]
[ "<s>", "bool", "isMachineVerifierClean", "(", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]
[ "Returns", "true", "if", "the", "target", "is", "expected", "to", "pass", "all", "machine", "verifier", "checks", "." ]
[ "DLX" ]
DLXTargetMachine
isMachineVerifierClean
DLX
CPU
LLVM
4,532
11
1
[]
[ "<s>", "void", "riscv_split_doubleword_move", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "if", "(", "!", "TARGET_64BIT", "&&", "TARGET_XTHEADFMV", ")", "{", "if", "(", "FP_REG_RTX_P", "(", "dest", ")", ")", "{", "rtx", "low_src", "=", "riscv_subword", "(", "src", ",", "false", ")", ";", "rtx", "high_src", "=", "riscv_subword", "(", "src", ",", "true", ")", ";", "emit_insn", "(", "gen_th_fmv_hw_w_x", "(", "dest", ",", "high_src", ",", "low_src", ")", ")", ";", "return", ";", "}", "if", "(", "FP_REG_RTX_P", "(", "src", ")", ")", "{", "rtx", "low_dest", "=", "riscv_subword", "(", "dest", ",", "false", ")", ";", "rtx", "high_dest", "=", "riscv_subword", "(", "dest", ",", "true", ")", ";", "emit_insn", "(", "gen_th_fmv_x_w", "(", "low_dest", ",", "src", ")", ")", ";", "emit_insn", "(", "gen_th_fmv_x_hw", "(", "high_dest", ",", "src", ")", ")", ";", "return", ";", "}", "}", "rtx", "low_dest", "=", "riscv_subword", "(", "dest", ",", "false", ")", ";", "if", "(", "REG_P", "(", "low_dest", ")", "&&", "reg_overlap_mentioned_p", "(", "low_dest", ",", "src", ")", ")", "{", "riscv_emit_move", "(", "riscv_subword", "(", "dest", ",", "true", ")", ",", "riscv_subword", "(", "src", ",", "true", ")", ")", ";", "riscv_emit_move", "(", "low_dest", ",", "riscv_subword", "(", "src", ",", "false", ")", ")", ";", "}", "else", "{", "riscv_emit_move", "(", "low_dest", ",", "riscv_subword", "(", "src", ",", "false", ")", ")", ";", "riscv_emit_move", "(", "riscv_subword", "(", "dest", ",", "true", ")", ",", "riscv_subword", "(", "src", ",", "true", ")", ")", ";", "}", "}", "</s>" ]
[ "Split", "a", "doubleword", "move", "from", "SRC", "to", "DEST", ".", "On", "32-bit", "targets", ",", "this", "function", "handles", "64-bit", "moves", "for", "which", "riscv_split_64bit_move_p", "holds", ".", "For", "64-bit", "targets", ",", "this", "function", "handles", "128-bit", "moves", "." ]
[ "riscv" ]
riscv1
riscv_split_doubleword_move
riscv
CPU
GCC
4,533
201
1
[]
[ "<s>", "SparcSubtarget", "&", "SparcSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "IsV9", "=", "false", ";", "IsLeon", "=", "false", ";", "V8DeprecatedInsts", "=", "false", ";", "IsVIS", "=", "false", ";", "HasHardQuad", "=", "false", ";", "UsePopc", "=", "false", ";", "UseSoftFloat", "=", "false", ";", "HasLeonCasa", "=", "false", ";", "HasUmacSmac", "=", "false", ";", "InsertNOPLoad", "=", "false", ";", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "(", "Is64Bit", ")", "?", "\"v9\"", ":", "\"v8\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "if", "(", "!", "IsV9", ")", "UsePopc", "=", "false", ";", "return", "*", "this", ";", "}", "</s>" ]
[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]
[ "Sparc", "Sparc", "Sparc", "\"v9\"", "\"v8\"" ]
SparcSubtarget24
initializeSubtargetDependencies
Sparc
CPU
LLVM
4,534
99
1
[]
[ "<s>", "void", "AMDGPUPerfHint", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "FIM", ".", "find", "(", "&", "F", ")", "!=", "FIM", ".", "end", "(", ")", ")", "return", ";", "const", "Module", "&", "M", "=", "*", "F", ".", "getParent", "(", ")", ";", "DL", "=", "&", "M", ".", "getDataLayout", "(", ")", ";", "visit", "(", "F", ")", ";", "auto", "Loc", "=", "FIM", ".", "find", "(", "&", "F", ")", ";", "assert", "(", "Loc", "!=", "FIM", ".", "end", "(", ")", "&&", "\"No func info\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "F", ".", "getName", "(", ")", "<<", "\" MemInst: \"", "<<", "Loc", "->", "second", ".", "MemInstCount", "<<", "'\\n'", "<<", "\" IAMInst: \"", "<<", "Loc", "->", "second", ".", "IAMInstCount", "<<", "'\\n'", "<<", "\" LSMInst: \"", "<<", "Loc", "->", "second", ".", "LSMInstCount", "<<", "'\\n'", "<<", "\" TotalInst: \"", "<<", "Loc", "->", "second", ".", "InstCount", "<<", "'\\n'", ")", ";", "auto", "&", "FI", "=", "Loc", "->", "second", ";", "if", "(", "isMemBound", "(", "FI", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "F", ".", "getName", "(", ")", "<<", "\" is memory bound\\n\"", ")", ";", "NumMemBound", "++", ";", "}", "if", "(", "AMDGPU", "::", "isEntryFunctionCC", "(", "F", ".", "getCallingConv", "(", ")", ")", "&&", "needLimitWave", "(", "FI", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "F", ".", "getName", "(", ")", "<<", "\" needs limit wave\\n\"", ")", ";", "NumLimitWave", "++", ";", "}", "}", "</s>" ]
[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]
[ "AMDGPU", "AMDGPU", "\"No func info\"", "\" MemInst: \"", "\" IAMInst: \"", "\" LSMInst: \"", "\" TotalInst: \"", "\" is memory bound\\n\"", "AMDGPU::isEntryFunctionCC", "\" needs limit wave\\n\"" ]
AMDGPUPerfHintAnalysis14
runOnFunction
AMDGPU
GPU
LLVM
4,535
205
1
[]
[ "<s>", "static", "bool", "avr_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "regno", "==", "REG_CC", ")", "return", "mode", "==", "CCmode", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "1", ")", "return", "true", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">=", "4", "&&", "regno", ">=", "REG_X", ")", "return", "false", ";", "return", "!", "(", "regno", "&", "1", ")", ";", "}", "</s>" ]
[ "Returns", "1", "if", "a", "value", "of", "mode", "MODE", "can", "be", "stored", "starting", "with", "hard", "register", "number", "REGNO", ".", "On", "the", "enhanced", "core", ",", "anything", "larger", "than", "1", "byte", "must", "start", "in", "even", "numbered", "register", "for", "``", "movw", "''", "to", "work", "(", "this", "way", "we", "do", "n't", "have", "to", "check", "for", "odd", "registers", "everywhere", ")", "." ]
[ "avr", "1", "4", "1" ]
avr
avr_hard_regno_mode_ok
avr
MPU
GCC
4,536
60
1
[]
[ "<s>", "bool", "LEGPassConfig", "::", "addPreISel", "(", ")", "{", "return", "false", ";", "}", "</s>" ]
[ "{", "{", "@", "For", "GlobalISel" ]
[ "LEG", "LEG" ]
LEGTargetMachine
addPreISel
LEG
CPU
LLVM
4,537
11
1
[]
[ "<s>", "static", "unsigned", "int", "loongarch_build_integer", "(", "struct", "loongarch_integer_op", "*", "codes", ",", "HOST_WIDE_INT", "value", ")", "{", "unsigned", "int", "cost", "=", "0", ";", "HOST_WIDE_INT", "low_part", "=", "TARGET_64BIT", "?", "value", "<<", "32", ">>", "32", ":", "value", ";", "if", "(", "IMM12_OPERAND", "(", "low_part", ")", "||", "IMM12_OPERAND_UNSIGNED", "(", "low_part", ")", ")", "{", "codes", "[", "0", "]", ".", "code", "=", "UNKNOWN", ";", "codes", "[", "0", "]", ".", "method", "=", "METHOD_NORMAL", ";", "codes", "[", "0", "]", ".", "value", "=", "low_part", ";", "cost", "++", ";", "}", "else", "{", "codes", "[", "0", "]", ".", "code", "=", "UNKNOWN", ";", "codes", "[", "0", "]", ".", "method", "=", "METHOD_NORMAL", ";", "codes", "[", "0", "]", ".", "value", "=", "low_part", "&", "~", "(", "IMM_REACH", "-", "1", ")", ";", "cost", "++", ";", "HOST_WIDE_INT", "iorv", "=", "low_part", "&", "(", "IMM_REACH", "-", "1", ")", ";", "if", "(", "iorv", "!=", "0", ")", "{", "codes", "[", "1", "]", ".", "code", "=", "IOR", ";", "codes", "[", "1", "]", ".", "method", "=", "METHOD_NORMAL", ";", "codes", "[", "1", "]", ".", "value", "=", "iorv", ";", "cost", "++", ";", "}", "}", "if", "(", "TARGET_64BIT", ")", "{", "bool", "lu32i", "[", "2", "]", "=", "{", "(", "value", "&", "LU32I_B", ")", "==", "0", ",", "(", "value", "&", "LU32I_B", ")", "==", "LU32I_B", "}", ";", "bool", "lu52i", "[", "2", "]", "=", "{", "(", "value", "&", "LU52I_B", ")", "==", "0", ",", "(", "value", "&", "LU52I_B", ")", "==", "LU52I_B", "}", ";", "int", "sign31", "=", "(", "value", "&", "(", "1UL", "<<", "31", ")", ")", ">>", "31", ";", "if", "(", "lu32i", "[", "sign31", "]", "&&", "lu52i", "[", "sign31", "]", ")", "return", "cost", ";", "else", "if", "(", "lu32i", "[", "sign31", "]", ")", "{", "codes", "[", "cost", "]", ".", "method", "=", "METHOD_LU52I", ";", "codes", "[", "cost", "]", ".", "value", "=", "(", "value", ">>", "52", ")", "<<", "52", ";", "return", "cost", "+", "1", ";", "}", "codes", "[", "cost", "]", ".", "method", "=", "METHOD_LU32I", ";", "codes", "[", "cost", "]", ".", "value", "=", "(", "(", "value", "<<", "12", ")", ">>", "44", ")", "<<", "32", ";", "cost", "++", ";", "if", "(", "!", "lu52i", "[", "(", "value", "&", "(", "1ULL", "<<", "51", ")", ")", ">>", "51", "]", ")", "{", "codes", "[", "cost", "]", ".", "method", "=", "METHOD_LU52I", ";", "codes", "[", "cost", "]", ".", "value", "=", "(", "value", ">>", "52", ")", "<<", "52", ";", "cost", "++", ";", "}", "}", "gcc_assert", "(", "cost", "<=", "LARCH_MAX_INTEGER_OPS", ")", ";", "return", "cost", ";", "}", "</s>" ]
[ "Fill", "CODES", "with", "a", "sequence", "of", "rtl", "operations", "to", "load", "VALUE", ".", "Return", "the", "number", "of", "operations", "needed", "." ]
[ "loongarch", "0", "32", "32", "0", "0", "0", "0", "0", "0", "1", "1", "0", "1", "1", "1", "2", "0", "2", "0", "1UL", "31", "31", "52", "52", "1", "12", "44", "32", "1ULL", "51", "51", "52", "52" ]
loongarch
loongarch_build_integer
loongarch
CPU
GCC
4,538
378
1
[]
[ "<s>", "void", "tilepro_expand_set_const32", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "op0", ")", ";", "rtx", "temp", ";", "if", "(", "CONST_INT_P", "(", "op1", ")", ")", "{", "expand_set_cint32", "(", "op0", ",", "op1", ")", ";", "}", "else", "{", "temp", "=", "create_temp_reg_if_possible", "(", "mode", ",", "op0", ")", ";", "emit_move_insn", "(", "temp", ",", "gen_rtx_HIGH", "(", "mode", ",", "op1", ")", ")", ";", "emit_move_insn", "(", "op0", ",", "gen_rtx_LO_SUM", "(", "mode", ",", "temp", ",", "op1", ")", ")", ";", "}", "}", "</s>" ]
[ "Load", "OP1", ",", "a", "32-bit", "constant", ",", "into", "OP0", ",", "a", "register", ".", "We", "know", "it", "ca", "n't", "be", "done", "in", "one", "insn", "when", "we", "get", "here", ",", "the", "move", "expander", "guarantees", "this", "." ]
[ "tilepro" ]
tilepro
tilepro_expand_set_const32
tilepro
VLIW
GCC
4,539
76
1
[]
[ "<s>", "SDValue", "AArch64TargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ",", "bool", "isThisReturn", ",", "SDValue", "ThisVal", ")", "const", "{", "CCAssignFn", "*", "RetCC", "=", "CallConv", "==", "CallingConv", "::", "WebKit_JS", "?", "RetCC_AArch64_WebKit_JS", ":", "RetCC_AArch64_AAPCS", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "DenseMap", "<", "unsigned", ",", "SDValue", ">", "CopiedRegs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "i", "==", "0", "&&", "isThisReturn", ")", "{", "assert", "(", "!", "VA", ".", "needsCustom", "(", ")", "&&", "VA", ".", "getLocVT", "(", ")", "==", "MVT", "::", "i64", "&&", "\"unexpected return calling convention register assignment\"", ")", ";", "InVals", ".", "push_back", "(", "ThisVal", ")", ";", "continue", ";", "}", "SDValue", "Val", "=", "CopiedRegs", ".", "lookup", "(", "VA", ".", "getLocReg", "(", ")", ")", ";", "if", "(", "!", "Val", ")", "{", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ";", "Chain", "=", "Val", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Val", ".", "getValue", "(", "2", ")", ";", "CopiedRegs", "[", "VA", ".", "getLocReg", "(", ")", "]", "=", "Val", ";", "}", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "AExtUpper", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Val", ",", "DAG", ".", "getConstant", "(", "32", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "LLVM_FALLTHROUGH", ";", "case", "CCValAssign", "::", "AExt", ":", "LLVM_FALLTHROUGH", ";", "case", "CCValAssign", "::", "ZExt", ":", "Val", "=", "DAG", ".", "getZExtOrTrunc", "(", "Val", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ")", ";", "break", ";", "}", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]
[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]
[ "AArch64", "AArch64", "ISD::InputArg", "AArch64", "AArch64", "16", "0", "0", "MVT::i64", "\"unexpected return calling convention register assignment\"", "1", "2", "\"Unknown loc info!\"", "ISD::BITCAST", "ISD::SRL", "32" ]
AArch64ISelLowering (2)3
LowerCallResult
AArch64
CPU
LLVM
4,540
396
1
[]
[ "<s>", "static", "bool", "ix86_fixed_condition_code_regs", "(", "unsigned", "int", "*", "p1", ",", "unsigned", "int", "*", "p2", ")", "{", "*", "p1", "=", "FLAGS_REG", ";", "*", "p2", "=", "FPSR_REG", ";", "return", "true", ";", "}", "</s>" ]
[ "Return", "the", "fixed", "registers", "used", "for", "condition", "codes", "." ]
[ "i386" ]
i3863
ix86_fixed_condition_code_regs
i386
CPU
GCC
4,541
29
1
[]
[ "<s>", "bool", "RISCVInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "const", "MachineInstr", "&", "MIa", ",", "const", "MachineInstr", "&", "MIb", ")", "const", "{", "assert", "(", "MIa", ".", "mayLoadOrStore", "(", ")", "&&", "\"MIa must be a load or store.\"", ")", ";", "assert", "(", "MIb", ".", "mayLoadOrStore", "(", ")", "&&", "\"MIb must be a load or store.\"", ")", ";", "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "const", "MachineOperand", "*", "BaseOpA", "=", "nullptr", ",", "*", "BaseOpB", "=", "nullptr", ";", "int64_t", "OffsetA", "=", "0", ",", "OffsetB", "=", "0", ";", "unsigned", "int", "WidthA", "=", "0", ",", "WidthB", "=", "0", ";", "if", "(", "getMemOperandWithOffsetWidth", "(", "MIa", ",", "BaseOpA", ",", "OffsetA", ",", "WidthA", ",", "TRI", ")", "&&", "getMemOperandWithOffsetWidth", "(", "MIb", ",", "BaseOpB", ",", "OffsetB", ",", "WidthB", ",", "TRI", ")", ")", "{", "if", "(", "BaseOpA", "->", "isIdenticalTo", "(", "*", "BaseOpB", ")", ")", "{", "int", "LowOffset", "=", "std", "::", "min", "(", "OffsetA", ",", "OffsetB", ")", ";", "int", "HighOffset", "=", "std", "::", "max", "(", "OffsetA", ",", "OffsetB", ")", ";", "int", "LowWidth", "=", "(", "LowOffset", "==", "OffsetA", ")", "?", "WidthA", ":", "WidthB", ";", "if", "(", "LowOffset", "+", "LowWidth", "<=", "HighOffset", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]
[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]
[ "RI5CY", "RISCV", "\"MIa must be a load or store.\"", "\"MIb must be a load or store.\"", "0", "0", "0", "0" ]
RISCVInstrInfo
areMemAccessesTriviallyDisjoint
RI5CY
CPU
LLVM
4,542
204
1
[]
[ "<s>", "Register", "AVRTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "LLT", "VT", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "Register", "Reg", ";", "if", "(", "VT", "==", "LLT", "::", "scalar", "(", "8", ")", ")", "{", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"r0\"", ",", "AVR", "::", "R0", ")", ".", "Case", "(", "\"r1\"", ",", "AVR", "::", "R1", ")", ".", "Default", "(", "0", ")", ";", "}", "else", "{", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"r0\"", ",", "AVR", "::", "R1R0", ")", ".", "Case", "(", "\"sp\"", ",", "AVR", "::", "SP", ")", ".", "Default", "(", "0", ")", ";", "}", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "Twine", "(", "\"Invalid register name \\\"\"", "+", "StringRef", "(", "RegName", ")", "+", "\"\\\".\"", ")", ")", ";", "}", "</s>" ]
[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]
[ "AVR", "AVR", "8", "\"r0\"", "AVR::R0", "\"r1\"", "AVR::R1", "0", "\"r0\"", "AVR::R1R0", "\"sp\"", "AVR::SP", "0", "\"Invalid register name \\\"\"", "\"\\\".\"" ]
AVRISelLowering11
getRegisterByName
AVR
MPU
LLVM
4,543
128
1
[]
[ "<s>", "unsigned", "ARM64InstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM64", "::", "STRWui", ":", "case", "ARM64", "::", "STRXui", ":", "case", "ARM64", "::", "STRBui", ":", "case", "ARM64", "::", "STRHui", ":", "case", "ARM64", "::", "STRSui", ":", "case", "ARM64", "::", "STRDui", ":", "case", "ARM64", "::", "STRQui", ":", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]
[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]
[ "ARM64", "ARM64", "ARM64::STRWui", "ARM64::STRXui", "ARM64::STRBui", "ARM64::STRHui", "ARM64::STRSui", "ARM64::STRDui", "ARM64::STRQui", "0", "0", "1", "2", "2", "0", "1", "0", "0" ]
ARM64InstrInfo
isStoreToStackSlot
ARM64
CPU
LLVM
4,544
148
1
[]
[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"X86 Machine Code Emitter\"", ";", "}", "</s>" ]
[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]
[ "X86", "\"X86 Machine Code Emitter\"" ]
X86CodeEmitter
getPassName
X86
CPU
LLVM
4,545
13
1
[]
[ "<s>", "void", "MandarinFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "MandarinInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MandarinInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "int", "Size", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Size", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "MD", "::", "ADJCALLSTACKDOWN", ")", "{", "BuildMI", "(", "MF", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MD", "::", "SUBri", ")", ",", "MD", "::", "R30", ")", ".", "addReg", "(", "MD", "::", "R30", ")", ".", "addImm", "(", "Size", ")", ";", "}", "else", "{", "BuildMI", "(", "MF", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MD", "::", "ADDri", ")", ",", "MD", "::", "R30", ")", ".", "addReg", "(", "MD", "::", "R30", ")", ".", "addImm", "(", "Size", ")", ";", "}", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]
[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]
[ "Mandarin", "0", "MD::ADJCALLSTACKDOWN", "MD::SUBri", "MD::R30", "MD::R30", "MD::ADDri", "MD::R30", "MD::R30" ]
MandarinFrameLowering
eliminateCallFramePseudoInstr
Mandarin
CPU
LLVM
4,546
178
1
[]
[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "}", "</s>" ]
[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]
[ "LC3" ]
LC3AsmBackend
relaxInstruction
LC3
CPU
LLVM
4,547
16
1
[]
[ "<s>", "void", "ARMPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "Options", ".", "ThreadModel", "==", "ThreadModel", "::", "Single", ")", "addPass", "(", "createLowerAtomicPass", "(", ")", ")", ";", "else", "addPass", "(", "createAtomicExpandPass", "(", "TM", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", "-", "1", ",", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "const", "auto", "&", "ST", "=", "this", "->", "TM", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ";", "return", "ST", ".", "hasAnyDataBarrier", "(", ")", "&&", "!", "ST", ".", "isThumb1Only", "(", ")", ";", "}", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createInterleavedAccessPass", "(", "TM", ")", ")", ";", "}", "</s>" ]
[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]
[ "ARM", "ARM", "1", "ARM" ]
ARMTargetMachine (2)1
addIRPasses
ARM
CPU
LLVM
4,548
128
1
[]
[ "<s>", "unsigned", "BlackfinInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "BF", "::", "LOAD32fi", ":", "case", "BF", "::", "LOAD16fi", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]
[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]
[ "Blackfin", "BF::LOAD32fi", "BF::LOAD16fi", "1", "2", "2", "0", "1", "0", "0" ]
BlackfinInstrInfo
isLoadFromStackSlot
Blackfin
DSP
LLVM
4,549
110
1
[]
[ "<s>", "rtx", "mips_expand_thread_pointer", "(", "rtx", "tp", ")", "{", "rtx", "fn", ";", "if", "(", "TARGET_MIPS16", ")", "{", "if", "(", "!", "mips16_rdhwr_stub", ")", "mips16_rdhwr_stub", "=", "new", "mips16_rdhwr_one_only_stub", "(", ")", ";", "fn", "=", "mips16_stub_call_address", "(", "mips16_rdhwr_stub", ")", ";", "emit_insn", "(", "PMODE_INSN", "(", "gen_tls_get_tp_mips16", ",", "(", "tp", ",", "fn", ")", ")", ")", ";", "}", "else", "emit_insn", "(", "PMODE_INSN", "(", "gen_tls_get_tp", ",", "(", "tp", ")", ")", ")", ";", "return", "tp", ";", "}", "</s>" ]
[ "Return", "a", "pseudo", "register", "that", "contains", "the", "current", "thread", "pointer", "." ]
[ "mips" ]
mips
mips_expand_thread_pointer
mips
CPU
GCC
4,550
66
1
[]
[ "<s>", "MachineBasicBlock", "*", "MipsTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "assert", "(", "false", "&&", "\"Unexpected instr type to insert\"", ")", ";", "return", "NULL", ";", "case", "Mips", "::", "ATOMIC_LOAD_ADD_I8", ":", "return", "EmitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "1", ",", "Mips", "::", "ADDu", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_ADD_I16", ":", "return", "EmitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "2", ",", "Mips", "::", "ADDu", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_ADD_I32", ":", "return", "EmitAtomicBinary", "(", "MI", ",", "BB", ",", "4", ",", "Mips", "::", "ADDu", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_AND_I8", ":", "return", "EmitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "1", ",", "Mips", "::", "AND", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_AND_I16", ":", "return", "EmitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "2", ",", "Mips", "::", "AND", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_AND_I32", ":", "return", "EmitAtomicBinary", "(", "MI", ",", "BB", ",", "4", ",", "Mips", "::", "AND", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_OR_I8", ":", "return", "EmitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "1", ",", "Mips", "::", "OR", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_OR_I16", ":", "return", "EmitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "2", ",", "Mips", "::", "OR", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_OR_I32", ":", "return", "EmitAtomicBinary", "(", "MI", ",", "BB", ",", "4", ",", "Mips", "::", "OR", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_XOR_I8", ":", "return", "EmitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "1", ",", "Mips", "::", "XOR", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_XOR_I16", ":", "return", "EmitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "2", ",", "Mips", "::", "XOR", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_XOR_I32", ":", "return", "EmitAtomicBinary", "(", "MI", ",", "BB", ",", "4", ",", "Mips", "::", "XOR", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_NAND_I8", ":", "return", "EmitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "1", ",", "0", ",", "true", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_NAND_I16", ":", "return", "EmitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "2", ",", "0", ",", "true", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_NAND_I32", ":", "return", "EmitAtomicBinary", "(", "MI", ",", "BB", ",", "4", ",", "0", ",", "true", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_SUB_I8", ":", "return", "EmitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "1", ",", "Mips", "::", "SUBu", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_SUB_I16", ":", "return", "EmitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "2", ",", "Mips", "::", "SUBu", ")", ";", "case", "Mips", "::", "ATOMIC_LOAD_SUB_I32", ":", "return", "EmitAtomicBinary", "(", "MI", ",", "BB", ",", "4", ",", "Mips", "::", "SUBu", ")", ";", "case", "Mips", "::", "ATOMIC_SWAP_I8", ":", "return", "EmitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "1", ",", "0", ")", ";", "case", "Mips", "::", "ATOMIC_SWAP_I16", ":", "return", "EmitAtomicBinaryPartword", "(", "MI", ",", "BB", ",", "2", ",", "0", ")", ";", "case", "Mips", "::", "ATOMIC_SWAP_I32", ":", "return", "EmitAtomicBinary", "(", "MI", ",", "BB", ",", "4", ",", "0", ")", ";", "case", "Mips", "::", "ATOMIC_CMP_SWAP_I8", ":", "return", "EmitAtomicCmpSwapPartword", "(", "MI", ",", "BB", ",", "1", ")", ";", "case", "Mips", "::", "ATOMIC_CMP_SWAP_I16", ":", "return", "EmitAtomicCmpSwapPartword", "(", "MI", ",", "BB", ",", "2", ")", ";", "case", "Mips", "::", "ATOMIC_CMP_SWAP_I32", ":", "return", "EmitAtomicCmpSwap", "(", "MI", ",", "BB", ",", "4", ")", ";", "}", "}", "</s>" ]
[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]
[ "Mips", "Mips", "\"Unexpected instr type to insert\"", "Mips::ATOMIC_LOAD_ADD_I8", "1", "Mips::ADDu", "Mips::ATOMIC_LOAD_ADD_I16", "2", "Mips::ADDu", "Mips::ATOMIC_LOAD_ADD_I32", "4", "Mips::ADDu", "Mips::ATOMIC_LOAD_AND_I8", "1", "Mips::AND", "Mips::ATOMIC_LOAD_AND_I16", "2", "Mips::AND", "Mips::ATOMIC_LOAD_AND_I32", "4", "Mips::AND", "Mips::ATOMIC_LOAD_OR_I8", "1", "Mips::OR", "Mips::ATOMIC_LOAD_OR_I16", "2", "Mips::OR", "Mips::ATOMIC_LOAD_OR_I32", "4", "Mips::OR", "Mips::ATOMIC_LOAD_XOR_I8", "1", "Mips::XOR", "Mips::ATOMIC_LOAD_XOR_I16", "2", "Mips::XOR", "Mips::ATOMIC_LOAD_XOR_I32", "4", "Mips::XOR", "Mips::ATOMIC_LOAD_NAND_I8", "1", "0", "Mips::ATOMIC_LOAD_NAND_I16", "2", "0", "Mips::ATOMIC_LOAD_NAND_I32", "4", "0", "Mips::ATOMIC_LOAD_SUB_I8", "1", "Mips::SUBu", "Mips::ATOMIC_LOAD_SUB_I16", "2", "Mips::SUBu", "Mips::ATOMIC_LOAD_SUB_I32", "4", "Mips::SUBu", "Mips::ATOMIC_SWAP_I8", "1", "0", "Mips::ATOMIC_SWAP_I16", "2", "0", "Mips::ATOMIC_SWAP_I32", "4", "0", "Mips::ATOMIC_CMP_SWAP_I8", "1", "Mips::ATOMIC_CMP_SWAP_I16", "2", "Mips::ATOMIC_CMP_SWAP_I32", "4" ]
MipsISelLowering117
EmitInstrWithCustomInserter
Mips
CPU
LLVM
4,551
477
1
[]
[ "<s>", "static", "constexpr", "ArgDescriptor", "createArg", "(", "const", "ArgDescriptor", "&", "Arg", ",", "unsigned", "Mask", ")", "{", "return", "ArgDescriptor", "(", "Arg", ".", "Reg", ",", "Mask", ",", "Arg", ".", "IsStack", ",", "Arg", ".", "IsSet", ")", ";", "}", "</s>" ]
[ "Convenience", "wrapper", "." ]
[ "AMDGPU" ]
AMDGPUArgumentUsageInfo
createArg
AMDGPU
GPU
LLVM
4,552
33
1
[]
[ "<s>", "void", "WebAssemblyPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "disablePass", "(", "&", "PrologEpilogCodeInserterID", ")", ";", "disablePass", "(", "&", "MachineCopyPropagationID", ")", ";", "}", "</s>" ]
[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "register", "allocation", "pass", "pipeline", "but", "before", "prolog-epilog", "insertion", "." ]
[ "WebAssembly", "WebAssembly" ]
WebAssemblyTargetMachine47
addPostRegAlloc
WebAssembly
Virtual ISA
LLVM
4,553
20
1
[]
[ "<s>", "static", "bool", "mips_hard_regno_mode_ok_uncached", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "unsigned", "int", "size", ";", "enum", "mode_class", "mclass", ";", "if", "(", "mode", "==", "CCV2mode", ")", "return", "(", "ISA_HAS_8CC", "&&", "ST_REG_P", "(", "regno", ")", "&&", "(", "regno", "-", "ST_REG_FIRST", ")", "%", "2", "==", "0", ")", ";", "if", "(", "mode", "==", "CCV4mode", ")", "return", "(", "ISA_HAS_8CC", "&&", "ST_REG_P", "(", "regno", ")", "&&", "(", "regno", "-", "ST_REG_FIRST", ")", "%", "4", "==", "0", ")", ";", "if", "(", "mode", "==", "CCmode", ")", "return", "ISA_HAS_8CC", "?", "ST_REG_P", "(", "regno", ")", ":", "regno", "==", "FPSW_REGNUM", ";", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "mclass", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "if", "(", "GP_REG_P", "(", "regno", ")", "&&", "mode", "!=", "CCFmode", "&&", "!", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", ")", "return", "(", "(", "regno", "-", "GP_REG_FIRST", ")", "&", "1", ")", "==", "0", "||", "size", "<=", "UNITS_PER_WORD", ";", "if", "(", "FP_REG_P", "(", "regno", ")", "&&", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "FP_REG_P", "(", "regno", ")", "&&", "(", "(", "(", "regno", "-", "FP_REG_FIRST", ")", "%", "MAX_FPRS_PER_FMT", ")", "==", "0", "||", "(", "MIN_FPRS_PER_FMT", "==", "1", "&&", "size", "<=", "UNITS_PER_FPREG", ")", ")", ")", "{", "if", "(", "TARGET_O32_FP64A_ABI", "&&", "size", "<=", "4", "&&", "(", "regno", "&", "1", ")", "!=", "0", ")", "return", "false", ";", "if", "(", "mode", "==", "CCFmode", ")", "return", "!", "(", "TARGET_FLOATXX", "&&", "(", "regno", "&", "1", ")", "!=", "0", ")", ";", "if", "(", "TARGET_LOONGSON_MMI", "&&", "(", "mode", "==", "V2SImode", "||", "mode", "==", "V4HImode", "||", "mode", "==", "V8QImode", "||", "mode", "==", "DImode", ")", ")", "return", "true", ";", "if", "(", "mclass", "==", "MODE_FLOAT", "||", "mclass", "==", "MODE_COMPLEX_FLOAT", "||", "mclass", "==", "MODE_VECTOR_FLOAT", ")", "return", "size", "<=", "UNITS_PER_FPVALUE", ";", "if", "(", "mclass", "==", "MODE_INT", ")", "return", "size", ">=", "MIN_UNITS_PER_WORD", "&&", "size", "<=", "UNITS_PER_FPREG", ";", "}", "if", "(", "ACC_REG_P", "(", "regno", ")", "&&", "!", "VECTOR_MODE_P", "(", "mode", ")", "&&", "(", "INTEGRAL_MODE_P", "(", "mode", ")", "||", "ALL_FIXED_POINT_MODE_P", "(", "mode", ")", ")", ")", "{", "if", "(", "MD_REG_P", "(", "regno", ")", ")", "{", "if", "(", "size", "<=", "UNITS_PER_WORD", "*", "2", ")", "return", "regno", "==", "(", "size", "<=", "UNITS_PER_WORD", "?", "LO_REGNUM", ":", "MD_REG_FIRST", ")", ";", "}", "else", "{", "if", "(", "size", "<=", "UNITS_PER_WORD", ")", "return", "true", ";", "if", "(", "size", "<=", "UNITS_PER_WORD", "*", "2", "&&", "(", "(", "regno", "-", "DSP_ACC_REG_FIRST", ")", "&", "1", ")", "==", "0", ")", "return", "true", ";", "}", "}", "if", "(", "ALL_COP_REG_P", "(", "regno", ")", ")", "return", "mclass", "==", "MODE_INT", "&&", "size", "<=", "UNITS_PER_WORD", ";", "if", "(", "regno", "==", "GOT_VERSION_REGNUM", ")", "return", "mode", "==", "SImode", ";", "return", "false", ";", "}", "</s>" ]
[ "Return", "true", "if", "register", "REGNO", "can", "store", "a", "value", "of", "mode", "MODE", ".", "The", "result", "of", "this", "function", "is", "cached", "in", "mips_hard_regno_mode_ok", "." ]
[ "mips", "2", "0", "4", "0", "1", "0", "0", "1", "4", "1", "0", "1", "0", "2", "2", "1", "0" ]
mips
mips_hard_regno_mode_ok_uncached
mips
CPU
GCC
4,554
407
1
[]
[ "<s>", "static", "bool", "hasCopyImplyingStackAdjustment", "(", "const", "MachineFunction", "&", "MF", ")", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "return", "any_of", "(", "MRI", ".", "reg_instructions", "(", "X86", "::", "EFLAGS", ")", ",", "[", "]", "(", "const", "MachineInstr", "&", "RI", ")", "{", "return", "RI", ".", "isCopy", "(", ")", ";", "}", ")", ";", "}", "</s>" ]
[ "Returns", "true", "if", "the", "function", "contains", "operations", "which", "will", "lower", "down", "to", "instructions", "which", "manipulate", "the", "stack", "pointer", "." ]
[ "X86", "X86::EFLAGS" ]
X86ISelLowering102
hasCopyImplyingStackAdjustment
X86
CPU
LLVM
4,555
53
1
[]
[ "<s>", "inline", "static", "MCDisassembler", "::", "DecodeStatus", "addOperand", "(", "MCInst", "&", "Inst", ",", "const", "MCOperand", "&", "Opnd", ")", "{", "Inst", ".", "addOperand", "(", "Opnd", ")", ";", "return", "Opnd", ".", "isValid", "(", ")", "?", "MCDisassembler", "::", "Success", ":", "MCDisassembler", "::", "Fail", ";", "}", "</s>" ]
[ "Add", "an", "operand", "." ]
[ "AMDGPU" ]
AMDGPUDisassembler1
addOperand
AMDGPU
GPU
LLVM
4,556
40
1
[]
[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"XCore FRAME_TO_ARGS_OFFSET Elimination\"", ";", "}", "</s>" ]
[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]
[ "XCore", "\"XCore FRAME_TO_ARGS_OFFSET Elimination\"" ]
XCoreFrameToArgsOffsetElim
getPassName
XCore
MPU
LLVM
4,557
13
1
[]
[ "<s>", "void", "ARMBaseInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "0", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "Align", ")", ";", "if", "(", "RC", "==", "ARM", "::", "tGPRRegisterClass", ")", "RC", "=", "ARM", "::", "GPRRegisterClass", ";", "if", "(", "RC", "==", "ARM", "::", "GPRRegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "STR", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addReg", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "}", "else", "if", "(", "RC", "==", "ARM", "::", "DPRRegisterClass", "||", "RC", "==", "ARM", "::", "DPR_VFP2RegisterClass", "||", "RC", "==", "ARM", "::", "DPR_8RegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "VSTRD", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "}", "else", "if", "(", "RC", "==", "ARM", "::", "SPRRegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "VSTRS", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "}", "else", "{", "assert", "(", "(", "RC", "==", "ARM", "::", "QPRRegisterClass", "||", "RC", "==", "ARM", "::", "QPR_VFP2RegisterClass", ")", "&&", "\"Unknown regclass!\"", ")", ";", "if", "(", "Align", ">=", "16", "&&", "(", "getRegisterInfo", "(", ")", ".", "canRealignStack", "(", "MF", ")", ")", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "VST1q", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "128", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ")", ";", "}", "else", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "VSTMQ", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "ARM_AM", "::", "getAM5Opc", "(", "ARM_AM", "::", "ia", ",", "4", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "}", "}", "}", "</s>" ]
[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]
[ "ARM", "ARM", "0", "ARM::tGPRRegisterClass", "ARM::GPRRegisterClass", "ARM::GPRRegisterClass", "ARM::STR", "0", "0", "ARM::DPRRegisterClass", "ARM::DPR_VFP2RegisterClass", "ARM::DPR_8RegisterClass", "ARM::VSTRD", "0", "ARM::SPRRegisterClass", "ARM::VSTRS", "0", "ARM::QPRRegisterClass", "ARM::QPR_VFP2RegisterClass", "\"Unknown regclass!\"", "16", "ARM::VST1q", "128", "ARM::VSTMQ", "ARM_AM::getAM5Opc", "ARM_AM::ia", "4" ]
ARMBaseInstrInfo16
storeRegToStackSlot
ARM
CPU
LLVM
4,558
451
1
[]
[ "<s>", "bool", "HexagonAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "if", "(", "!", "InBrackets", ")", "{", "MCB", ".", "clear", "(", ")", ";", "MCB", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "}", "HexagonOperand", "&", "FirstOperand", "=", "static_cast", "<", "HexagonOperand", "&", ">", "(", "*", "Operands", "[", "0", "]", ")", ";", "if", "(", "FirstOperand", ".", "isToken", "(", ")", "&&", "FirstOperand", ".", "getToken", "(", ")", "==", "\"{\"", ")", "{", "assert", "(", "Operands", ".", "size", "(", ")", "==", "1", "&&", "\"Brackets should be by themselves\"", ")", ";", "if", "(", "InBrackets", ")", "{", "getParser", "(", ")", ".", "Error", "(", "IDLoc", ",", "\"Already in a packet\"", ")", ";", "return", "true", ";", "}", "InBrackets", "=", "true", ";", "return", "false", ";", "}", "if", "(", "FirstOperand", ".", "isToken", "(", ")", "&&", "FirstOperand", ".", "getToken", "(", ")", "==", "\"}\"", ")", "{", "assert", "(", "Operands", ".", "size", "(", ")", "==", "1", "&&", "\"Brackets should be by themselves\"", ")", ";", "if", "(", "!", "InBrackets", ")", "{", "getParser", "(", ")", ".", "Error", "(", "IDLoc", ",", "\"Not in a packet\"", ")", ";", "return", "true", ";", "}", "InBrackets", "=", "false", ";", "if", "(", "matchBundleOptions", "(", ")", ")", "return", "true", ";", "return", "finishBundle", "(", "IDLoc", ",", "Out", ")", ";", "}", "MCInst", "*", "SubInst", "=", "new", "(", "getParser", "(", ")", ".", "getContext", "(", ")", ")", "MCInst", ";", "if", "(", "matchOneInstruction", "(", "*", "SubInst", ",", "IDLoc", ",", "Operands", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ")", "return", "true", ";", "HexagonMCInstrInfo", "::", "extendIfNeeded", "(", "getParser", "(", ")", ".", "getContext", "(", ")", ",", "MCII", ",", "MCB", ",", "*", "SubInst", ")", ";", "MCB", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "SubInst", ")", ")", ";", "if", "(", "!", "InBrackets", ")", "return", "finishBundle", "(", "IDLoc", ",", "Out", ")", ";", "return", "false", ";", "}", "</s>" ]
[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]
[ "Hexagon", "Hexagon", "0", "Hexagon", "Hexagon", "0", "\"{\"", "1", "\"Brackets should be by themselves\"", "\"Already in a packet\"", "\"}\"", "1", "\"Brackets should be by themselves\"", "\"Not in a packet\"", "Hexagon" ]
HexagonAsmParser1
MatchAndEmitInstruction
Hexagon
DSP
LLVM
4,559
285
1
[]
[ "<s>", "unsigned", "SITargetLowering", "::", "getVectorTypeBreakdownForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ",", "EVT", "&", "IntermediateVT", ",", "unsigned", "&", "NumIntermediates", ",", "MVT", "&", "RegisterVT", ")", "const", "{", "if", "(", "CC", "!=", "CallingConv", "::", "AMDGPU_KERNEL", "&&", "VT", ".", "isVector", "(", ")", ")", "{", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "EVT", "ScalarVT", "=", "VT", ".", "getScalarType", "(", ")", ";", "unsigned", "Size", "=", "ScalarVT", ".", "getSizeInBits", "(", ")", ";", "if", "(", "Size", "==", "32", ")", "{", "RegisterVT", "=", "ScalarVT", ".", "getSimpleVT", "(", ")", ";", "IntermediateVT", "=", "RegisterVT", ";", "NumIntermediates", "=", "NumElts", ";", "return", "NumIntermediates", ";", "}", "if", "(", "Size", "==", "64", ")", "{", "RegisterVT", "=", "MVT", "::", "i32", ";", "IntermediateVT", "=", "RegisterVT", ";", "NumIntermediates", "=", "2", "*", "NumElts", ";", "return", "NumIntermediates", ";", "}", "if", "(", "Size", "==", "16", "&&", "Subtarget", "->", "has16BitInsts", "(", ")", ")", "{", "RegisterVT", "=", "VT", ".", "isInteger", "(", ")", "?", "MVT", "::", "v2i16", ":", "MVT", "::", "v2f16", ";", "IntermediateVT", "=", "RegisterVT", ";", "NumIntermediates", "=", "(", "NumElts", "+", "1", ")", "/", "2", ";", "return", "NumIntermediates", ";", "}", "}", "return", "TargetLowering", "::", "getVectorTypeBreakdownForCallingConv", "(", "Context", ",", "CC", ",", "VT", ",", "IntermediateVT", ",", "NumIntermediates", ",", "RegisterVT", ")", ";", "}", "</s>" ]
[ "Certain", "targets", "such", "as", "MIPS", "require", "that", "some", "types", "such", "as", "vectors", "are", "always", "broken", "down", "into", "scalars", "in", "some", "contexts", "." ]
[ "AMDGPU", "SI", "AMDGPU", "32", "64", "MVT::i32", "2", "16", "MVT::v2i16", "MVT::v2f16", "1", "2" ]
SIISelLowering (2)3
getVectorTypeBreakdownForCallingConv
AMDGPU
GPU
LLVM
4,560
194
1
[]
[ "<s>", "static", "bool", "arc_enter_leave_p", "(", "uint64_t", "gmask", ")", "{", "int", "regno", ";", "unsigned", "int", "rmask", "=", "0", ";", "if", "(", "!", "gmask", ")", "return", "false", ";", "for", "(", "regno", "=", "ENTER_LEAVE_START_REG", ";", "regno", "<=", "ENTER_LEAVE_END_REG", "&&", "(", "gmask", "&", "(", "1ULL", "<<", "regno", ")", ")", ";", "regno", "++", ")", "rmask", "|=", "1ULL", "<<", "regno", ";", "if", "(", "rmask", "^", "gmask", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]
[ "Check", "if", "we", "have", "a", "continous", "range", "to", "be", "save/restored", "with", "the", "help", "of", "enter/leave", "instructions", ".", "A", "vaild", "register", "range", "starts", "from", "$", "r13", "and", "is", "up", "to", "(", "including", ")", "$", "r26", "." ]
[ "arc", "0", "1ULL", "1ULL" ]
arc
arc_enter_leave_p
arc
MPU
GCC
4,561
67
1
[]
[ "<s>", "void", "AMDGPUPassConfig", "::", "addIRPasses", "(", ")", "{", "const", "AMDGPUTargetMachine", "&", "TM", "=", "getAMDGPUTargetMachine", "(", ")", ";", "disablePass", "(", "&", "StackMapLivenessID", ")", ";", "disablePass", "(", "&", "FuncletLayoutID", ")", ";", "disablePass", "(", "&", "PatchableFunctionID", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUFixFunctionBitcastsPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPULowerIntrinsicsPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUAlwaysInlinePass", "(", ")", ")", ";", "addPass", "(", "createAlwaysInlinerLegacyPass", "(", ")", ")", ";", "addPass", "(", "createBarrierNoopPass", "(", ")", ")", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "{", "addPass", "(", "createAMDGPUCodeGenPreparePass", "(", ")", ")", ";", "}", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "r600", ")", "addPass", "(", "createR600OpenCLImageTypeLoweringPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUOpenCLEnqueuedBlockLoweringPass", "(", ")", ")", ";", "if", "(", "TM", ".", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createInferAddressSpacesPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUPromoteAlloca", "(", ")", ")", ";", "if", "(", "EnableSROA", ")", "addPass", "(", "createSROAPass", "(", ")", ")", ";", "addStraightLineScalarOptimizationPasses", "(", ")", ";", "if", "(", "EnableAMDGPUAliasAnalysis", ")", "{", "addPass", "(", "createAMDGPUAAWrapperPass", "(", ")", ")", ";", "addPass", "(", "createExternalAAWrapperPass", "(", "[", "]", "(", "Pass", "&", "P", ",", "Function", "&", ",", "AAResults", "&", "AAR", ")", "{", "if", "(", "auto", "*", "WrapperPass", "=", "P", ".", "getAnalysisIfAvailable", "<", "AMDGPUAAWrapperPass", ">", "(", ")", ")", "AAR", ".", "addAAResult", "(", "WrapperPass", "->", "getResult", "(", ")", ")", ";", "}", ")", ")", ";", "}", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addEarlyCSEOrGVNPass", "(", ")", ";", "}", "</s>" ]
[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]
[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "R600", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU" ]
AMDGPUTargetMachine102
addIRPasses
AMDGPU
GPU
LLVM
4,562
257
1
[]
[ "<s>", "bool", "PPCTargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isSimple", "(", ")", "||", "!", "Subtarget", ".", "hasVSX", "(", ")", ")", "return", "false", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "return", "false", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "case", "MVT", "::", "ppcf128", ":", "return", "Imm", ".", "isPosZero", "(", ")", ";", "}", "}", "</s>" ]
[ "Returns", "true", "if", "the", "target", "can", "instruction", "select", "the", "specified", "FP", "immediate", "natively", "." ]
[ "PowerPC", "PPC", "MVT::f32", "MVT::f64", "MVT::ppcf128" ]
PPCISelLowering (2)7
isFPImmLegal
PowerPC
CPU
LLVM
4,563
74
1
[]
[ "<s>", "bool", "RISCVTargetLowering", "::", "splitValueIntoRegisterParts", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "SDValue", "Val", ",", "SDValue", "*", "Parts", ",", "unsigned", "NumParts", ",", "MVT", "PartVT", ",", "Optional", "<", "CallingConv", "::", "ID", ">", "CC", ")", "const", "{", "bool", "IsABIRegCopy", "=", "CC", ".", "hasValue", "(", ")", ";", "EVT", "ValueVT", "=", "Val", ".", "getValueType", "(", ")", ";", "if", "(", "IsABIRegCopy", "&&", "ValueVT", "==", "MVT", "::", "f16", "&&", "PartVT", "==", "MVT", "::", "f32", ")", "{", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "i16", ",", "Val", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "DL", ",", "MVT", "::", "i32", ",", "Val", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "OR", ",", "DL", ",", "MVT", "::", "i32", ",", "Val", ",", "DAG", ".", "getConstant", "(", "0xFFFF0000", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "f32", ",", "Val", ")", ";", "Parts", "[", "0", "]", "=", "Val", ";", "return", "true", ";", "}", "if", "(", "ValueVT", ".", "isScalableVector", "(", ")", "&&", "PartVT", ".", "isScalableVector", "(", ")", ")", "{", "LLVMContext", "&", "Context", "=", "*", "DAG", ".", "getContext", "(", ")", ";", "EVT", "ValueEltVT", "=", "ValueVT", ".", "getVectorElementType", "(", ")", ";", "EVT", "PartEltVT", "=", "PartVT", ".", "getVectorElementType", "(", ")", ";", "unsigned", "ValueVTBitSize", "=", "ValueVT", ".", "getSizeInBits", "(", ")", ".", "getKnownMinSize", "(", ")", ";", "unsigned", "PartVTBitSize", "=", "PartVT", ".", "getSizeInBits", "(", ")", ".", "getKnownMinSize", "(", ")", ";", "if", "(", "PartVTBitSize", "%", "ValueVTBitSize", "==", "0", ")", "{", "if", "(", "ValueEltVT", "!=", "PartEltVT", ")", "{", "unsigned", "Count", "=", "ValueVTBitSize", "/", "PartEltVT", ".", "getSizeInBits", "(", ")", ";", "assert", "(", "Count", "!=", "0", "&&", "\"The number of element should not be zero.\"", ")", ";", "EVT", "SameEltTypeVT", "=", "EVT", "::", "getVectorVT", "(", "Context", ",", "PartEltVT", ",", "Count", ",", "true", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "SameEltTypeVT", ",", "Val", ")", ";", "}", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_SUBVECTOR", ",", "DL", ",", "PartVT", ",", "DAG", ".", "getUNDEF", "(", "PartVT", ")", ",", "Val", ",", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "Subtarget", ".", "getXLenVT", "(", ")", ")", ")", ";", "Parts", "[", "0", "]", "=", "Val", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]
[ "Target-specific", "splitting", "of", "values", "into", "parts", "that", "fit", "a", "register", "storing", "a", "legal", "type", "." ]
[ "RISCV", "RISCV", "MVT::f16", "MVT::f32", "ISD::BITCAST", "MVT::i16", "ISD::ANY_EXTEND", "MVT::i32", "ISD::OR", "MVT::i32", "0xFFFF0000", "MVT::i32", "ISD::BITCAST", "MVT::f32", "0", "0", "0", "\"The number of element should not be zero.\"", "ISD::BITCAST", "ISD::INSERT_SUBVECTOR", "0", "0" ]
RISCVISelLowering1
splitValueIntoRegisterParts
RISCV
CPU
LLVM
4,564
367
1
[]
[ "<s>", "bool", "X86TTIImpl", "::", "canMacroFuseCmp", "(", ")", "{", "return", "ST", "->", "hasMacroFusion", "(", ")", "||", "ST", "->", "hasBranchFusion", "(", ")", ";", "}", "</s>" ]
[ "Return", "true", "if", "the", "target", "can", "fuse", "a", "compare", "and", "branch", "." ]
[ "X86", "X86" ]
X86TargetTransformInfo (2)1
canMacroFuseCmp
X86
CPU
LLVM
4,565
21
1
[]
[ "<s>", "const", "char", "*", "M68kTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "M68kISD", "::", "CALL", ":", "return", "\"M68kISD::CALL\"", ";", "case", "M68kISD", "::", "TAIL_CALL", ":", "return", "\"M68kISD::TAIL_CALL\"", ";", "case", "M68kISD", "::", "RET", ":", "return", "\"M68kISD::RET\"", ";", "case", "M68kISD", "::", "TC_RETURN", ":", "return", "\"M68kISD::TC_RETURN\"", ";", "case", "M68kISD", "::", "ADD", ":", "return", "\"M68kISD::ADD\"", ";", "case", "M68kISD", "::", "SUB", ":", "return", "\"M68kISD::SUB\"", ";", "case", "M68kISD", "::", "ADDX", ":", "return", "\"M68kISD::ADDX\"", ";", "case", "M68kISD", "::", "SUBX", ":", "return", "\"M68kISD::SUBX\"", ";", "case", "M68kISD", "::", "SMUL", ":", "return", "\"M68kISD::SMUL\"", ";", "case", "M68kISD", "::", "UMUL", ":", "return", "\"M68kISD::UMUL\"", ";", "case", "M68kISD", "::", "OR", ":", "return", "\"M68kISD::OR\"", ";", "case", "M68kISD", "::", "XOR", ":", "return", "\"M68kISD::XOR\"", ";", "case", "M68kISD", "::", "AND", ":", "return", "\"M68kISD::AND\"", ";", "case", "M68kISD", "::", "CMP", ":", "return", "\"M68kISD::CMP\"", ";", "case", "M68kISD", "::", "BTST", ":", "return", "\"M68kISD::BTST\"", ";", "case", "M68kISD", "::", "SELECT", ":", "return", "\"M68kISD::SELECT\"", ";", "case", "M68kISD", "::", "CMOV", ":", "return", "\"M68kISD::CMOV\"", ";", "case", "M68kISD", "::", "BRCOND", ":", "return", "\"M68kISD::BRCOND\"", ";", "case", "M68kISD", "::", "SETCC", ":", "return", "\"M68kISD::SETCC\"", ";", "case", "M68kISD", "::", "SETCC_CARRY", ":", "return", "\"M68kISD::SETCC_CARRY\"", ";", "case", "M68kISD", "::", "GLOBAL_BASE_REG", ":", "return", "\"M68kISD::GLOBAL_BASE_REG\"", ";", "case", "M68kISD", "::", "Wrapper", ":", "return", "\"M68kISD::Wrapper\"", ";", "case", "M68kISD", "::", "WrapperPC", ":", "return", "\"M68kISD::WrapperPC\"", ";", "case", "M68kISD", "::", "SEG_ALLOCA", ":", "return", "\"M68kISD::SEG_ALLOCA\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]
[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]
[ "M68k", "M68k", "M68kISD::CALL", "\"M68kISD::CALL\"", "M68kISD::TAIL_CALL", "\"M68kISD::TAIL_CALL\"", "M68kISD::RET", "\"M68kISD::RET\"", "M68kISD::TC_RETURN", "\"M68kISD::TC_RETURN\"", "M68kISD::ADD", "\"M68kISD::ADD\"", "M68kISD::SUB", "\"M68kISD::SUB\"", "M68kISD::ADDX", "\"M68kISD::ADDX\"", "M68kISD::SUBX", "\"M68kISD::SUBX\"", "M68kISD::SMUL", "\"M68kISD::SMUL\"", "M68kISD::UMUL", "\"M68kISD::UMUL\"", "M68kISD::OR", "\"M68kISD::OR\"", "M68kISD::XOR", "\"M68kISD::XOR\"", "M68kISD::AND", "\"M68kISD::AND\"", "M68kISD::CMP", "\"M68kISD::CMP\"", "M68kISD::BTST", "\"M68kISD::BTST\"", "M68kISD::SELECT", "\"M68kISD::SELECT\"", "M68kISD::CMOV", "\"M68kISD::CMOV\"", "M68kISD::BRCOND", "\"M68kISD::BRCOND\"", "M68kISD::SETCC", "\"M68kISD::SETCC\"", "M68kISD::SETCC_CARRY", "\"M68kISD::SETCC_CARRY\"", "M68kISD::GLOBAL_BASE_REG", "\"M68kISD::GLOBAL_BASE_REG\"", "M68kISD::Wrapper", "\"M68kISD::Wrapper\"", "M68kISD::WrapperPC", "\"M68kISD::WrapperPC\"", "M68kISD::SEG_ALLOCA", "\"M68kISD::SEG_ALLOCA\"" ]
M68kISelLowering
getTargetNodeName
M68k
MPU
LLVM
4,566
216
1
[]
[ "<s>", "static", "rtx", "arc_process_double_reg_moves", "(", "rtx", "*", "operands", ")", "{", "rtx", "dest", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "rtx", "val", ";", "enum", "usesDxState", "{", "none", ",", "srcDx", ",", "destDx", ",", "maxDx", "}", ";", "enum", "usesDxState", "state", "=", "none", ";", "if", "(", "refers_to_regno_p", "(", "40", ",", "44", ",", "src", ",", "0", ")", ")", "state", "=", "srcDx", ";", "if", "(", "refers_to_regno_p", "(", "40", ",", "44", ",", "dest", ",", "0", ")", ")", "{", "gcc_assert", "(", "state", "==", "none", ")", ";", "state", "=", "destDx", ";", "}", "if", "(", "state", "==", "none", ")", "return", "NULL_RTX", ";", "start_sequence", "(", ")", ";", "if", "(", "state", "==", "srcDx", ")", "{", "if", "(", "TARGET_DPFP_DISABLE_LRSR", ")", "{", "rtx", "set", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "src", ")", ";", "rtx", "use1", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "const1_rtx", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set", ",", "use1", ")", ")", ")", ";", "}", "else", "{", "rtx", "destHigh", "=", "simplify_gen_subreg", "(", "SImode", ",", "dest", ",", "DFmode", ",", "4", ")", ";", "rtx", "destLow", "=", "simplify_gen_subreg", "(", "SImode", ",", "dest", ",", "DFmode", ",", "0", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "destHigh", ",", "gen_rtx_UNSPEC_VOLATILE", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "src", ")", ",", "VUNSPEC_LR_HIGH", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "destLow", ",", "gen_rtx_UNSPEC_VOLATILE", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "src", ")", ",", "VUNSPEC_LR", ")", ")", ")", ";", "}", "}", "else", "if", "(", "state", "==", "destDx", ")", "{", "rtx", "srcHigh", "=", "simplify_gen_subreg", "(", "SImode", ",", "src", ",", "DFmode", ",", "4", ")", ";", "rtx", "srcLow", "=", "simplify_gen_subreg", "(", "SImode", ",", "src", ",", "DFmode", ",", "0", ")", ";", "emit_insn", "(", "gen_rtx_UNSPEC_VOLATILE", "(", "Pmode", ",", "gen_rtvec", "(", "3", ",", "dest", ",", "srcHigh", ",", "srcLow", ")", ",", "VUNSPEC_DEXCL_NORES", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "val", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "val", ";", "}", "</s>" ]
[ "Handle", "DOUBLE_REGS", "uses", ".", "Operand", "0", ":", "destination", "register", "Operand", "1", ":", "source", "register" ]
[ "arc", "0", "1", "40", "44", "0", "40", "44", "0", "2", "4", "0", "1", "1", "4", "0", "3" ]
arc4
arc_process_double_reg_moves
arc
MPU
GCC
4,567
311
1
[]
[ "<s>", "void", "AArch64MCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "verifyInstructionPredicates", "(", "MI", ",", "computeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "TLSDESCCALL", ")", "{", "auto", "Reloc", "=", "STI", ".", "getTargetTriple", "(", ")", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUILP32", "?", "ELF", "::", "R_AARCH64_P32_TLSDESC_CALL", ":", "ELF", "::", "R_AARCH64_TLSDESC_CALL", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "MI", ".", "getOperand", "(", "0", ")", ".", "getExpr", "(", ")", ",", "MCFixupKind", "(", "FirstLiteralRelocationKind", "+", "Reloc", ")", ")", ")", ";", "return", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "CompilerBarrier", "||", "MI", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "SPACE", ")", "{", "return", ";", "}", "uint64_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "OS", ",", "Binary", ",", "support", "::", "little", ")", ";", "++", "MCNumEmitted", ";", "}", "</s>" ]
[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]
[ "AArch64", "AArch64", "AArch64::TLSDESCCALL", "0", "0", "AArch64::CompilerBarrier", "AArch64::SPACE", "support::endian", "support::little" ]
AArch64MCCodeEmitter15
encodeInstruction
AArch64
CPU
LLVM
4,568
173
1
[]
[ "<s>", "int", "iq2000_can_use_return_insn", "(", "void", ")", "{", "if", "(", "!", "reload_completed", ")", "return", "0", ";", "if", "(", "regs_ever_live", "[", "31", "]", "||", "profile_flag", ")", "return", "0", ";", "if", "(", "cfun", "->", "machine", "->", "initialized", ")", "return", "cfun", "->", "machine", "->", "total_size", "==", "0", ";", "return", "compute_frame_size", "(", "get_frame_size", "(", ")", ")", "==", "0", ";", "}", "</s>" ]
[ "Return", "nonzero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", ".", "This", "allows", "the", "optimizer", "to", "omit", "jumps", "to", "jumps", "if", "no", "stack", "was", "created", "." ]
[ "iq2000", "0", "31", "0", "0", "0" ]
iq20002
iq2000_can_use_return_insn
iq2000
CPU
GCC
4,569
54
1
[]
[ "<s>", "void", "NVPTXTargetLowering", "::", "LowerAsmOperandForConstraint", "(", "SDValue", "Op", ",", "std", "::", "string", "&", "Constraint", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "Constraint", ".", "length", "(", ")", ">", "1", ")", "return", ";", "else", "TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "Op", ",", "Constraint", ",", "Ops", ",", "DAG", ")", ";", "}", "</s>" ]
[ "Lower", "the", "specified", "operand", "into", "the", "Ops", "vector", "." ]
[ "NVPTX", "NVPTX", "1" ]
NVPTXISelLowering (2)
LowerAsmOperandForConstraint
NVPTX
GPU
LLVM
4,570
56
1
[]
[ "<s>", "const", "uint16_t", "*", "HexagonRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "uint16_t", "CalleeSavedRegsV2", "[", "]", "=", "{", "Hexagon", "::", "R24", ",", "Hexagon", "::", "R25", ",", "Hexagon", "::", "R26", ",", "Hexagon", "::", "R27", ",", "0", "}", ";", "static", "const", "uint16_t", "CalleeSavedRegsV3", "[", "]", "=", "{", "Hexagon", "::", "R16", ",", "Hexagon", "::", "R17", ",", "Hexagon", "::", "R18", ",", "Hexagon", "::", "R19", ",", "Hexagon", "::", "R20", ",", "Hexagon", "::", "R21", ",", "Hexagon", "::", "R22", ",", "Hexagon", "::", "R23", ",", "Hexagon", "::", "R24", ",", "Hexagon", "::", "R25", ",", "Hexagon", "::", "R26", ",", "Hexagon", "::", "R27", ",", "0", "}", ";", "switch", "(", "Subtarget", ".", "getHexagonArchVersion", "(", ")", ")", "{", "case", "HexagonSubtarget", "::", "V1", ":", "break", ";", "case", "HexagonSubtarget", "::", "V2", ":", "return", "CalleeSavedRegsV2", ";", "case", "HexagonSubtarget", "::", "V3", ":", "case", "HexagonSubtarget", "::", "V4", ":", "case", "HexagonSubtarget", "::", "V5", ":", "return", "CalleeSavedRegsV3", ";", "}", "llvm_unreachable", "(", "\"Callee saved registers requested for unknown architecture \"", "\"version\"", ")", ";", "}", "</s>" ]
[ "Code", "Generation", "virtual", "methods", "..." ]
[ "Hexagon", "Hexagon", "Hexagon::R24", "Hexagon::R25", "Hexagon::R26", "Hexagon::R27", "0", "Hexagon::R16", "Hexagon::R17", "Hexagon::R18", "Hexagon::R19", "Hexagon::R20", "Hexagon::R21", "Hexagon::R22", "Hexagon::R23", "Hexagon::R24", "Hexagon::R25", "Hexagon::R26", "Hexagon::R27", "0", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"Callee saved registers requested for unknown architecture \"", "\"version\"" ]
HexagonRegisterInfo10
getCalleeSavedRegs
Hexagon
DSP
LLVM
4,571
150
1
[]
[ "<s>", "int", "cris_cfun_uses_pic_table", "(", "void", ")", "{", "return", "current_function_uses_pic_offset_table", ";", "}", "</s>" ]
[ "Return", "current_function_uses_pic_offset_table", ".", "For", "use", "in", "cris.md", ",", "since", "some", "generated", "files", "do", "not", "include", "function.h", "." ]
[ "cris" ]
cris3
cris_cfun_uses_pic_table
cris
MPU
GCC
4,572
10
1
[]
[ "<s>", "bool", "NVPTXPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "addPass", "(", "createNVPTXPrologEpilogPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]
[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "register", "allocation", "pass", "pipeline", "but", "before", "prolog-epilog", "insertion", "." ]
[ "NVPTX", "NVPTX", "NVPTX" ]
NVPTXTargetMachine1
addPostRegAlloc
NVPTX
GPU
LLVM
4,573
18
1
[]
[ "<s>", "bool", "FalkorMarkStridedAccesses", "::", "run", "(", ")", "{", "bool", "MadeChange", "=", "false", ";", "for", "(", "Loop", "*", "L", ":", "LI", ")", "for", "(", "auto", "LIt", "=", "df_begin", "(", "L", ")", ",", "LE", "=", "df_end", "(", "L", ")", ";", "LIt", "!=", "LE", ";", "++", "LIt", ")", "MadeChange", "|=", "runOnLoop", "(", "*", "*", "LIt", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]
[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]
[ "AArch64" ]
AArch64FalkorHWPFFix
run
AArch64
CPU
LLVM
4,574
57
1
[]
[ "<s>", "static", "bool", "aarch64_evpc_ins", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "machine_mode", "mode", "=", "d", "->", "vmode", ";", "unsigned", "HOST_WIDE_INT", "nelt", ";", "if", "(", "d", "->", "vec_flags", "!=", "VEC_ADVSIMD", ")", "return", "false", ";", "nelt", "=", "d", "->", "perm", ".", "length", "(", ")", ".", "to_constant", "(", ")", ";", "rtx", "insv", "=", "d", "->", "op0", ";", "HOST_WIDE_INT", "idx", "=", "-", "1", ";", "for", "(", "unsigned", "HOST_WIDE_INT", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "++", ")", "{", "HOST_WIDE_INT", "elt", ";", "if", "(", "!", "d", "->", "perm", "[", "i", "]", ".", "is_constant", "(", "&", "elt", ")", ")", "return", "false", ";", "if", "(", "elt", "==", "(", "HOST_WIDE_INT", ")", "i", ")", "continue", ";", "if", "(", "idx", "!=", "-", "1", ")", "{", "idx", "=", "-", "1", ";", "break", ";", "}", "idx", "=", "i", ";", "}", "if", "(", "idx", "==", "-", "1", ")", "{", "insv", "=", "d", "->", "op1", ";", "for", "(", "unsigned", "HOST_WIDE_INT", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "++", ")", "{", "if", "(", "d", "->", "perm", "[", "i", "]", ".", "to_constant", "(", ")", "==", "(", "HOST_WIDE_INT", ")", "(", "i", "+", "nelt", ")", ")", "continue", ";", "if", "(", "idx", "!=", "-", "1", ")", "return", "false", ";", "idx", "=", "i", ";", "}", "if", "(", "idx", "==", "-", "1", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "gcc_assert", "(", "idx", "!=", "-", "1", ")", ";", "unsigned", "extractindex", "=", "d", "->", "perm", "[", "idx", "]", ".", "to_constant", "(", ")", ";", "rtx", "extractv", "=", "d", "->", "op0", ";", "if", "(", "extractindex", ">=", "nelt", ")", "{", "extractv", "=", "d", "->", "op1", ";", "extractindex", "-=", "nelt", ";", "}", "gcc_assert", "(", "extractindex", "<", "nelt", ")", ";", "emit_move_insn", "(", "d", "->", "target", ",", "insv", ")", ";", "insn_code", "icode", "=", "code_for_aarch64_simd_vec_copy_lane", "(", "mode", ")", ";", "expand_operand", "ops", "[", "5", "]", ";", "create_output_operand", "(", "&", "ops", "[", "0", "]", ",", "d", "->", "target", ",", "mode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "1", "]", ",", "d", "->", "target", ",", "mode", ")", ";", "create_integer_operand", "(", "&", "ops", "[", "2", "]", ",", "1", "<<", "idx", ")", ";", "create_input_operand", "(", "&", "ops", "[", "3", "]", ",", "extractv", ",", "mode", ")", ";", "create_integer_operand", "(", "&", "ops", "[", "4", "]", ",", "extractindex", ")", ";", "expand_insn", "(", "icode", ",", "5", ",", "ops", ")", ";", "return", "true", ";", "}", "</s>" ]
[ "Recognize", "patterns", "suitable", "for", "the", "INS", "instructions", "." ]
[ "aarch64", "1", "0", "1", "1", "1", "0", "1", "1", "1", "5", "0", "1", "2", "1", "3", "4", "5" ]
aarch641
aarch64_evpc_ins
aarch64
CPU
GCC
4,575
375
1
[]
[ "<s>", "static", "void", "mmix_file_start", "(", "void", ")", "{", "default_file_start", "(", ")", ";", "fputs", "(", "\"! mmixal:= 8H LOC Data_Section\\n\"", ",", "asm_out_file", ")", ";", "text_section", "(", ")", ";", "}", "</s>" ]
[ "TARGET_ASM_FILE_START", ".", "We", "just", "emit", "a", "little", "comment", "for", "the", "time", "being", "." ]
[ "mmix", "\"! mmixal:= 8H LOC Data_Section\\n\"" ]
mmix3
mmix_file_start
mmix
CPU
GCC
4,576
23
1
[]
[ "<s>", "bool", "PPCRegisterInfo", "::", "requiresFrameIndexScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "const", "PPCInstrInfo", "*", "InstrInfo", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "Info", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "if", "(", "!", "MFI", ".", "isCalleeSavedInfoValid", "(", ")", ")", "return", "true", ";", "unsigned", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "FrameSize", "&", "~", "0x7FFF", ")", "return", "true", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Info", ".", "size", "(", ")", ";", "i", "++", ")", "{", "int", "FrIdx", "=", "Info", "[", "i", "]", ".", "getFrameIdx", "(", ")", ";", "unsigned", "Reg", "=", "Info", "[", "i", "]", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "unsigned", "Opcode", "=", "InstrInfo", "->", "getStoreOpcodeForSpill", "(", "RC", ")", ";", "if", "(", "!", "MFI", ".", "isFixedObjectIndex", "(", "FrIdx", ")", ")", "{", "if", "(", "offsetMinAlignForOpcode", "(", "Opcode", ")", ">", "1", ")", "return", "true", ";", "}", "if", "(", "InstrInfo", "->", "isXFormMemOp", "(", "Opcode", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]
[ "Returns", "true", "if", "the", "target", "requires", "post", "PEI", "scavenging", "of", "registers", "for", "materializing", "frame", "index", "constants", "." ]
[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "0x7FFF", "0", "1" ]
PPCRegisterInfo3
requiresFrameIndexScavenging
PowerPC
CPU
LLVM
4,577
199
1
[]
[ "<s>", "static", "void", "ix86_sse_copysign_to_positive", "(", "rtx", "result", ",", "rtx", "abs_value", ",", "rtx", "sign", ",", "rtx", "mask", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "sign", ")", ";", "rtx", "sgn", "=", "gen_reg_rtx", "(", "mode", ")", ";", "if", "(", "mask", "==", "NULL_RTX", ")", "{", "machine_mode", "vmode", ";", "if", "(", "mode", "==", "SFmode", ")", "vmode", "=", "V4SFmode", ";", "else", "if", "(", "mode", "==", "DFmode", ")", "vmode", "=", "V2DFmode", ";", "else", "vmode", "=", "mode", ";", "mask", "=", "ix86_build_signbit_mask", "(", "vmode", ",", "VECTOR_MODE_P", "(", "mode", ")", ",", "false", ")", ";", "if", "(", "!", "VECTOR_MODE_P", "(", "mode", ")", ")", "{", "rtx", "tmp", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "1", ",", "const0_rtx", ")", ")", ";", "tmp", "=", "gen_rtx_VEC_SELECT", "(", "mode", ",", "mask", ",", "tmp", ")", ";", "mask", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "mask", ",", "tmp", ")", ")", ";", "}", "}", "else", "mask", "=", "gen_rtx_NOT", "(", "mode", ",", "mask", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "sgn", ",", "gen_rtx_AND", "(", "mode", ",", "mask", ",", "sign", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "result", ",", "gen_rtx_IOR", "(", "mode", ",", "abs_value", ",", "sgn", ")", ")", ")", ";", "}", "</s>" ]
[ "Expand", "copysign", "from", "SIGN", "to", "the", "positive", "value", "ABS_VALUE", "storing", "in", "RESULT", ".", "If", "MASK", "is", "non-null", ",", "it", "shall", "be", "a", "mask", "to", "mask", "out", "the", "sign-bit", "." ]
[ "i386", "1" ]
i3864
ix86_sse_copysign_to_positive
i386
CPU
GCC
4,578
188
1
[]
[ "<s>", "static", "arm_stack_offsets", "*", "arm_get_frame_offsets", "(", "void", ")", "{", "struct", "arm_stack_offsets", "*", "offsets", ";", "unsigned", "long", "func_type", ";", "int", "leaf", ";", "int", "saved", ";", "HOST_WIDE_INT", "frame_size", ";", "offsets", "=", "&", "cfun", "->", "machine", "->", "stack_offsets", ";", "if", "(", "reload_completed", ")", "return", "offsets", ";", "frame_size", "=", "ROUND_UP_WORD", "(", "get_frame_size", "(", ")", ")", ";", "leaf", "=", "leaf_function_p", "(", ")", ";", "offsets", "->", "saved_args", "=", "current_function_pretend_args_size", ";", "offsets", "->", "frame", "=", "offsets", "->", "saved_args", "+", "(", "frame_pointer_needed", "?", "4", ":", "0", ")", ";", "if", "(", "TARGET_ARM", ")", "{", "unsigned", "int", "regno", ";", "saved", "=", "bit_count", "(", "arm_compute_save_reg_mask", "(", ")", ")", "*", "4", ";", "if", "(", "TARGET_REALLY_IWMMXT", ")", "{", "for", "(", "regno", "=", "FIRST_IWMMXT_REGNUM", ";", "regno", "<=", "LAST_IWMMXT_REGNUM", ";", "regno", "++", ")", "if", "(", "regs_ever_live", "[", "regno", "]", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "saved", "+=", "8", ";", "}", "func_type", "=", "arm_current_func_type", "(", ")", ";", "if", "(", "!", "IS_VOLATILE", "(", "func_type", ")", ")", "{", "for", "(", "regno", "=", "FIRST_FPA_REGNUM", ";", "regno", "<=", "LAST_FPA_REGNUM", ";", "regno", "++", ")", "if", "(", "regs_ever_live", "[", "regno", "]", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "saved", "+=", "12", ";", "if", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_VFP", ")", "saved", "+=", "arm_get_vfp_saved_size", "(", ")", ";", "}", "}", "else", "{", "saved", "=", "bit_count", "(", "thumb_compute_save_reg_mask", "(", ")", ")", "*", "4", ";", "if", "(", "TARGET_BACKTRACE", ")", "saved", "+=", "16", ";", "}", "offsets", "->", "saved_regs", "=", "offsets", "->", "saved_args", "+", "saved", ";", "offsets", "->", "soft_frame", "=", "offsets", "->", "saved_regs", "+", "CALLER_INTERWORKING_SLOT_SIZE", ";", "if", "(", "leaf", "&&", "frame_size", "==", "0", ")", "{", "offsets", "->", "outgoing_args", "=", "offsets", "->", "soft_frame", ";", "return", "offsets", ";", "}", "if", "(", "ARM_DOUBLEWORD_ALIGN", "&&", "(", "offsets", "->", "soft_frame", "&", "7", ")", ")", "offsets", "->", "soft_frame", "+=", "4", ";", "offsets", "->", "locals_base", "=", "offsets", "->", "soft_frame", "+", "frame_size", ";", "offsets", "->", "outgoing_args", "=", "(", "offsets", "->", "locals_base", "+", "current_function_outgoing_args_size", ")", ";", "if", "(", "ARM_DOUBLEWORD_ALIGN", ")", "{", "if", "(", "offsets", "->", "outgoing_args", "&", "7", ")", "offsets", "->", "outgoing_args", "+=", "4", ";", "gcc_assert", "(", "!", "(", "offsets", "->", "outgoing_args", "&", "7", ")", ")", ";", "}", "return", "offsets", ";", "}", "</s>" ]
[ "Calculate", "stack", "offsets", ".", "These", "are", "used", "to", "calculate", "register", "elimination", "offsets", "and", "in", "prologue/epilogue", "code", ".", "Also", "calculates", "which", "registers", "should", "be", "saved", "." ]
[ "arm", "4", "0", "4", "8", "12", "4", "16", "0", "7", "4", "7", "4", "7" ]
arm3
arm_get_frame_offsets
arm
CPU
GCC
4,579
333
1
[]
[ "<s>", "RISCVTargetLowering", "::", "ConstraintType", "RISCVTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'f'", ":", "return", "C_RegisterClass", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]
[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]
[ "RISCV", "RISCV", "RISCV", "1", "0" ]
RISCVISelLowering4
getConstraintType
RISCV
CPU
LLVM
4,580
52
1
[]
[ "<s>", "void", "X86TargetLowering", "::", "LowerOperationWrapper", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", "=", "LowerOperation", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ";", "if", "(", "!", "Res", ".", "getNode", "(", ")", ")", "return", ";", "assert", "(", "(", "N", "->", "getNumValues", "(", ")", "<=", "Res", "->", "getNumValues", "(", ")", ")", "&&", "\"Lowering returned the wrong number of results!\"", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "N", "->", "getNumValues", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "I", ")", ")", ";", "}", "</s>" ]
[ "This", "callback", "is", "invoked", "by", "the", "type", "legalizer", "to", "legalize", "nodes", "with", "an", "illegal", "operand", "type", "but", "legal", "result", "types", "." ]
[ "X86", "X86", "0", "\"Lowering returned the wrong number of results!\"", "0" ]
X86ISelLowering (2)8
LowerOperationWrapper
X86
CPU
LLVM
4,581
102
1
[]
[ "<s>", "inline", "const", "AMDGPUInstrInfo", "*", "AMDGPUSubtarget", "::", "getInstrInfo", "(", ")", "const", "{", "if", "(", "getGeneration", "(", ")", ">=", "SOUTHERN_ISLANDS", ")", "return", "static_cast", "<", "const", "SISubtarget", "*", ">", "(", "this", ")", "->", "getInstrInfo", "(", ")", ";", "return", "static_cast", "<", "const", "R600Subtarget", "*", ">", "(", "this", ")", "->", "getInstrInfo", "(", ")", ";", "}", "</s>" ]
[ "TargetInstrInfo", "getter", "." ]
[ "AMDGPU", "AMDGPU", "AMDGPU", "SI", "R600" ]
AMDGPUSubtarget100
getInstrInfo
AMDGPU
GPU
LLVM
4,582
50
1
[]
[ "<s>", "bool", "PPCInstrInfo", "::", "SubsumesPredicate", "(", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Pred1", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Pred2", ")", "const", "{", "assert", "(", "Pred1", ".", "size", "(", ")", "==", "2", "&&", "\"Invalid PPC first predicate\"", ")", ";", "assert", "(", "Pred2", ".", "size", "(", ")", "==", "2", "&&", "\"Invalid PPC second predicate\"", ")", ";", "if", "(", "Pred1", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR8", "||", "Pred1", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR", ")", "return", "false", ";", "if", "(", "Pred2", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR8", "||", "Pred2", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR", ")", "return", "false", ";", "PPC", "::", "Predicate", "P1", "=", "(", "PPC", "::", "Predicate", ")", "Pred1", "[", "0", "]", ".", "getImm", "(", ")", ";", "PPC", "::", "Predicate", "P2", "=", "(", "PPC", "::", "Predicate", ")", "Pred2", "[", "0", "]", ".", "getImm", "(", ")", ";", "if", "(", "P1", "==", "P2", ")", "return", "true", ";", "if", "(", "P1", "==", "PPC", "::", "PRED_LE", "&&", "(", "P2", "==", "PPC", "::", "PRED_LT", "||", "P2", "==", "PPC", "::", "PRED_EQ", ")", ")", "return", "true", ";", "if", "(", "P1", "==", "PPC", "::", "PRED_GE", "&&", "(", "P2", "==", "PPC", "::", "PRED_GT", "||", "P2", "==", "PPC", "::", "PRED_EQ", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]
[ "Returns", "true", "if", "the", "first", "specified", "predicate", "subsumes", "the", "second", ",", "e.g", "." ]
[ "PowerPC", "PPC", "2", "\"Invalid PPC first predicate\"", "2", "\"Invalid PPC second predicate\"", "1", "PPC::CTR8", "1", "PPC::CTR", "1", "PPC::CTR8", "1", "PPC::CTR", "PPC::Predicate", "PPC::Predicate", "0", "PPC::Predicate", "PPC::Predicate", "0", "PPC::PRED_LE", "PPC::PRED_LT", "PPC::PRED_EQ", "PPC::PRED_GE", "PPC::PRED_GT", "PPC::PRED_EQ" ]
PPCInstrInfo108
SubsumesPredicate
PowerPC
CPU
LLVM
4,583
212
1
[]
[ "<s>", "MachineBasicBlock", "*", "AArch64TargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "MI", ".", "dump", "(", ")", ";", "llvm_unreachable", "(", "\"Unexpected instruction for custom inserter!\"", ")", ";", "case", "AArch64", "::", "F128CSEL", ":", "return", "EmitF128CSEL", "(", "MI", ",", "BB", ")", ";", "case", "TargetOpcode", "::", "STACKMAP", ":", "case", "TargetOpcode", "::", "PATCHPOINT", ":", "return", "emitPatchPoint", "(", "MI", ",", "BB", ")", ";", "case", "AArch64", "::", "CATCHRET", ":", "return", "EmitLoweredCatchRet", "(", "MI", ",", "BB", ")", ";", "}", "}", "</s>" ]
[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]
[ "AArch64", "AArch64", "\"Unexpected instruction for custom inserter!\"", "AArch64::F128CSEL", "AArch64::CATCHRET" ]
AArch64ISelLowering135
EmitInstrWithCustomInserter
AArch64
CPU
LLVM
4,584
84
1
[]
[ "<s>", "bool", "AArch64InstrInfo", "::", "optimizeCompareInstr", "(", "MachineInstr", "&", "CmpInstr", ",", "unsigned", "SrcReg", ",", "unsigned", "SrcReg2", ",", "int", "CmpMask", ",", "int", "CmpValue", ",", "const", "MachineRegisterInfo", "*", "MRI", ")", "const", "{", "assert", "(", "CmpInstr", ".", "getParent", "(", ")", ")", ";", "assert", "(", "MRI", ")", ";", "int", "DeadNZCVIdx", "=", "CmpInstr", ".", "findRegisterDefOperandIdx", "(", "AArch64", "::", "NZCV", ",", "true", ")", ";", "if", "(", "DeadNZCVIdx", "!=", "-", "1", ")", "{", "if", "(", "CmpInstr", ".", "definesRegister", "(", "AArch64", "::", "WZR", ")", "||", "CmpInstr", ".", "definesRegister", "(", "AArch64", "::", "XZR", ")", ")", "{", "CmpInstr", ".", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "unsigned", "Opc", "=", "CmpInstr", ".", "getOpcode", "(", ")", ";", "unsigned", "NewOpc", "=", "convertToNonFlagSettingOpc", "(", "CmpInstr", ")", ";", "if", "(", "NewOpc", "==", "Opc", ")", "return", "false", ";", "const", "MCInstrDesc", "&", "MCID", "=", "get", "(", "NewOpc", ")", ";", "CmpInstr", ".", "setDesc", "(", "MCID", ")", ";", "CmpInstr", ".", "RemoveOperand", "(", "DeadNZCVIdx", ")", ";", "bool", "succeeded", "=", "UpdateOperandRegClass", "(", "CmpInstr", ")", ";", "(", "void", ")", "succeeded", ";", "assert", "(", "succeeded", "&&", "\"Some operands reg class are incompatible!\"", ")", ";", "return", "true", ";", "}", "assert", "(", "(", "CmpValue", "==", "0", "||", "CmpValue", "==", "1", ")", "&&", "\"CmpValue must be 0 or 1!\"", ")", ";", "if", "(", "CmpValue", "!=", "0", "||", "SrcReg2", "!=", "0", ")", "return", "false", ";", "if", "(", "!", "MRI", "->", "use_nodbg_empty", "(", "CmpInstr", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "return", "false", ";", "return", "substituteCmpToZero", "(", "CmpInstr", ",", "SrcReg", ",", "MRI", ")", ";", "}", "</s>" ]
[ "optimizeCompareInstr", "-", "Check", "if", "there", "exists", "an", "earlier", "instruction", "that", "operates", "on", "the", "same", "source", "operands", "and", "sets", "flags", "in", "the", "same", "way", "as", "Compare", ";", "remove", "Compare", "if", "possible", "." ]
[ "AArch64", "AArch64", "AArch64::NZCV", "1", "AArch64::WZR", "AArch64::XZR", "\"Some operands reg class are incompatible!\"", "0", "1", "\"CmpValue must be 0 or 1!\"", "0", "0", "0" ]
AArch64InstrInfo (2)
optimizeCompareInstr
AArch64
CPU
LLVM
4,585
230
1
[]
[ "<s>", "void", "sparc_expand_compare_and_swap", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "bval", ",", "retval", ",", "mem", ",", "oldval", ",", "newval", ";", "machine_mode", "mode", ";", "enum", "memmodel", "model", ";", "bval", "=", "operands", "[", "0", "]", ";", "retval", "=", "operands", "[", "1", "]", ";", "mem", "=", "operands", "[", "2", "]", ";", "oldval", "=", "operands", "[", "3", "]", ";", "newval", "=", "operands", "[", "4", "]", ";", "model", "=", "(", "enum", "memmodel", ")", "INTVAL", "(", "operands", "[", "6", "]", ")", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "sparc_emit_membar_for_model", "(", "model", ",", "3", ",", "1", ")", ";", "if", "(", "reg_overlap_mentioned_p", "(", "retval", ",", "oldval", ")", ")", "oldval", "=", "copy_to_reg", "(", "oldval", ")", ";", "if", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", "sparc_expand_compare_and_swap_12", "(", "bval", ",", "retval", ",", "mem", ",", "oldval", ",", "newval", ")", ";", "else", "{", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "x", ";", "if", "(", "mode", "==", "SImode", ")", "gen", "=", "gen_atomic_compare_and_swapsi_1", ";", "else", "gen", "=", "gen_atomic_compare_and_swapdi_1", ";", "emit_insn", "(", "gen", "(", "retval", ",", "mem", ",", "oldval", ",", "newval", ")", ")", ";", "x", "=", "emit_store_flag", "(", "bval", ",", "EQ", ",", "retval", ",", "oldval", ",", "mode", ",", "1", ",", "1", ")", ";", "if", "(", "x", "!=", "bval", ")", "convert_move", "(", "bval", ",", "x", ",", "1", ")", ";", "}", "sparc_emit_membar_for_model", "(", "model", ",", "3", ",", "2", ")", ";", "}", "</s>" ]
[ "Expand", "code", "to", "perform", "a", "compare-and-swap", "." ]
[ "sparc", "0", "1", "2", "3", "4", "6", "3", "1", "1", "1", "1", "3", "2" ]
sparc
sparc_expand_compare_and_swap
sparc
CPU
GCC
4,586
225
1
[]
[ "<s>", "static", "void", "arc_external_libcall", "(", "rtx", "fun", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_MANGLE_CPU_LIBGCC", ")", "{", "fprintf", "(", "FILE", ",", "\"\\t.rename\\t_%s, _%s%s\\n\"", ",", "XSTR", "(", "SYMREF", ",", "0", ")", ",", "XSTR", "(", "SYMREF", ",", "0", ")", ",", "arc_mangle_suffix", ")", ";", "}", "}", "</s>" ]
[ "Worker", "function", "for", "TARGET_ASM_EXTERNAL_LIBCALL", "." ]
[ "arc", "\"\\t.rename\\t_%s, _%s%s\\n\"", "0", "0" ]
arc3
arc_external_libcall
arc
MPU
GCC
4,587
39
1
[]
[ "<s>", "bool", "OR1KAsmParser", "::", "ParseInstruction", "(", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "size_t", "dotLoc", "=", "Name", ".", "find", "(", "'.'", ")", ";", "Operands", ".", "push_back", "(", "OR1KOperand", "::", "CreateToken", "(", "Name", ".", "substr", "(", "0", ",", "dotLoc", ")", ",", "NameLoc", ")", ")", ";", "if", "(", "dotLoc", "<", "Name", ".", "size", "(", ")", ")", "{", "size_t", "dotLoc2", "=", "Name", ".", "rfind", "(", "'.'", ")", ";", "if", "(", "dotLoc", "==", "dotLoc2", ")", "Operands", ".", "push_back", "(", "OR1KOperand", "::", "CreateToken", "(", "Name", ".", "substr", "(", "dotLoc", ")", ",", "NameLoc", ")", ")", ";", "else", "{", "Operands", ".", "push_back", "(", "OR1KOperand", "::", "CreateToken", "(", "Name", ".", "substr", "(", "dotLoc", ",", "dotLoc2", "-", "dotLoc", ")", ",", "NameLoc", ")", ")", ";", "Operands", ".", "push_back", "(", "OR1KOperand", "::", "CreateToken", "(", "Name", ".", "substr", "(", "dotLoc2", ")", ",", "NameLoc", ")", ")", ";", "}", "}", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "ParseOperand", "(", "Operands", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "if", "(", "ParseOperand", "(", "Operands", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]
[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]
[ "OR1K", "OR1K", "OR1KOperand::CreateToken", "0", "OR1KOperand::CreateToken", "OR1KOperand::CreateToken", "OR1KOperand::CreateToken" ]
OR1KAsmParser
ParseInstruction
OR1K
CPU
LLVM
4,588
217
1
[]
[ "<s>", "rtx", "gen_pop", "(", "rtx", "arg", ")", "{", "if", "(", "REG_P", "(", "arg", ")", "&&", "GET_MODE", "(", "arg", ")", "!=", "word_mode", ")", "arg", "=", "gen_rtx_REG", "(", "word_mode", ",", "REGNO", "(", "arg", ")", ")", ";", "return", "gen_rtx_SET", "(", "arg", ",", "gen_rtx_MEM", "(", "word_mode", ",", "gen_rtx_POST_INC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ")", ")", ";", "}", "</s>" ]
[ "Generate", "an", "``", "pop", "''", "pattern", "for", "input", "ARG", "." ]
[ "i386" ]
i386
gen_pop
i386
CPU
GCC
4,589
52
1
[]
[ "<s>", "const", "MCExpr", "*", "getSubExpr", "(", ")", "const", "{", "return", "Expr", ";", "}", "</s>" ]
[ "getSubExpr", "-", "Get", "the", "child", "of", "this", "expression", "." ]
[ "Sparc" ]
SparcMCExpr
getSubExpr
Sparc
CPU
LLVM
4,590
12
1
[]
[ "<s>", "DecodeStatus", "PPCDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CS", ")", "const", "{", "auto", "*", "ReadFunc", "=", "IsLittleEndian", "?", "support", "::", "endian", "::", "read32le", ":", "support", "::", "endian", "::", "read32be", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "PPC", "::", "FeaturePrefixInstrs", "]", "&&", "Bytes", ".", "size", "(", ")", ">=", "8", ")", "{", "uint32_t", "Prefix", "=", "ReadFunc", "(", "Bytes", ".", "data", "(", ")", ")", ";", "uint32_t", "BaseInst", "=", "ReadFunc", "(", "Bytes", ".", "data", "(", ")", "+", "4", ")", ";", "uint64_t", "Inst", "=", "BaseInst", "|", "(", "uint64_t", ")", "Prefix", "<<", "32", ";", "DecodeStatus", "result", "=", "decodeInstruction", "(", "DecoderTable64", ",", "MI", ",", "Inst", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "8", ";", "return", "result", ";", "}", "}", "Size", "=", "4", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "uint64_t", "Inst", "=", "ReadFunc", "(", "Bytes", ".", "data", "(", ")", ")", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "PPC", "::", "FeatureQPX", "]", ")", "{", "DecodeStatus", "result", "=", "decodeInstruction", "(", "DecoderTableQPX32", ",", "MI", ",", "Inst", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", "!=", "MCDisassembler", "::", "Fail", ")", "return", "result", ";", "}", "else", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "PPC", "::", "FeatureSPE", "]", ")", "{", "DecodeStatus", "result", "=", "decodeInstruction", "(", "DecoderTableSPE32", ",", "MI", ",", "Inst", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", "!=", "MCDisassembler", "::", "Fail", ")", "return", "result", ";", "}", "return", "decodeInstruction", "(", "DecoderTable32", ",", "MI", ",", "Inst", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "</s>" ]
[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]
[ "PowerPC", "PPC", "support::endian", "support::endian", "PPC::FeaturePrefixInstrs", "8", "4", "32", "8", "4", "4", "0", "PPC::FeatureQPX", "PPC::FeatureSPE" ]
PPCDisassembler11
getInstruction
PowerPC
CPU
LLVM
4,591
285
1
[]
[ "<s>", "int", "getIntImmCostInst", "(", "unsigned", "Opc", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "return", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ";", "}", "</s>" ]
[ "Return", "the", "expected", "cost", "of", "materialization", "for", "the", "given", "integer", "immediate", "of", "the", "specified", "type", "for", "a", "given", "instruction", "." ]
[ "Lanai" ]
LanaiTargetTransformInfo10
getIntImmCostInst
Lanai
CPU
LLVM
4,592
35
1
[]
[ "<s>", "align_flags", "rs6000_loop_align", "(", "rtx", "label", ")", "{", "basic_block", "bb", ";", "int", "ninsns", ";", "if", "(", "!", "can_override_loop_align", ")", "return", "align_loops", ";", "bb", "=", "BLOCK_FOR_INSN", "(", "label", ")", ";", "ninsns", "=", "num_loop_insns", "(", "bb", "->", "loop_father", ")", ";", "if", "(", "ninsns", ">", "4", "&&", "ninsns", "<=", "8", "&&", "(", "rs6000_tune", "==", "PROCESSOR_POWER4", "||", "rs6000_tune", "==", "PROCESSOR_POWER5", "||", "rs6000_tune", "==", "PROCESSOR_POWER6", "||", "rs6000_tune", "==", "PROCESSOR_POWER7", "||", "rs6000_tune", "==", "PROCESSOR_POWER8", ")", ")", "return", "align_flags", "(", "5", ")", ";", "else", "return", "align_loops", ";", "}", "</s>" ]
[ "Implement", "LOOP_ALIGN", "." ]
[ "rs6000", "4", "8", "5" ]
rs6000
rs6000_loop_align
rs6000
CPU
GCC
4,593
80
1
[]
[ "<s>", "virtual", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "LLVM_OVERRIDE", "{", "return", "createSystemZObjectWriter", "(", "OS", ",", "OSABI", ")", ";", "}", "</s>" ]
[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]
[ "SystemZ", "SystemZ" ]
SystemZMCAsmBackend29
createObjectWriter
SystemZ
CPU
LLVM
4,594
21
1
[]
[ "<s>", "static", "AMDGPUOperand", "::", "Ptr", "CreateReg", "(", "const", "AMDGPUAsmParser", "*", "AsmParser", ",", "unsigned", "RegNo", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "auto", "Op", "=", "llvm", "::", "make_unique", "<", "AMDGPUOperand", ">", "(", "Register", ",", "AsmParser", ")", ";", "Op", "->", "Reg", ".", "RegNo", "=", "RegNo", ";", "Op", "->", "Reg", ".", "Mods", "=", "Modifiers", "(", ")", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]
[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]
[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU" ]
AMDGPUAsmParser15
CreateReg
AMDGPU
GPU
LLVM
4,595
70
1
[]
[ "<s>", "static", "reg_class_t", "arm_preferred_reload_class", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "reg_class_t", "rclass", ")", "{", "if", "(", "TARGET_32BIT", ")", "return", "rclass", ";", "else", "{", "if", "(", "rclass", "==", "GENERAL_REGS", ")", "return", "LO_REGS", ";", "else", "return", "rclass", ";", "}", "}", "</s>" ]
[ "Worker", "function", "for", "TARGET_PREFERRED_RELOAD_CLASS", ".", "Given", "an", "rtx", "X", "being", "reloaded", "into", "a", "reg", "required", "to", "be", "in", "class", "CLASS", ",", "return", "the", "class", "of", "reg", "to", "actually", "use", ".", "In", "general", "this", "is", "just", "CLASS", ",", "but", "for", "the", "Thumb", "core", "registers", "and", "immediate", "constants", "we", "prefer", "a", "LO_REGS", "class", "or", "a", "subset", "." ]
[ "arm" ]
arm
arm_preferred_reload_class
arm
CPU
GCC
4,596
36
1
[]
[ "<s>", "virtual", "const", "InstrItineraryData", "*", "getInstrItineraryData", "(", ")", "const", "{", "return", "&", "InstrItins", ";", "}", "</s>" ]
[ "getInstrItineraryData", "-", "Returns", "instruction", "itinerary", "data", "for", "the", "target", "or", "specific", "subtarget", "." ]
[ "TMS320C64X" ]
TMS320C64XTargetMachine
getInstrItineraryData
TMS320C64X
VLIW
LLVM
4,597
14
1
[]
[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "TargetTransformInfo", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]
[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]
[ "NVPTX" ]
NVPTXTargetTransformInfo21
getAnalysisUsage
NVPTX
GPU
LLVM
4,598
18
1
[]
[ "<s>", "SMLoc", "getStartLoc", "(", ")", "const", "override", "{", "return", "Start", ";", "}", "</s>" ]
[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]
[ "MSP430" ]
MSP430AsmParser11
getStartLoc
MSP430
MPU
LLVM
4,599
11
1
[]