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>", "EVT", "RISCVTargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "getPointerTy", "(", "DL", ")", ";", "if", "(", "Subtarget", ".", "hasStdExtV", "(", ")", ")", "return", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i1", ",", "VT", ".", "getVectorElementCount", "(", ")", ")", ";", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]
[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]
[ "RI5CY", "RISCV", "MVT::getVectorVT", "MVT::i1" ]
RISCVISelLowering
getSetCCResultType
RI5CY
CPU
LLVM
17,800
65
1
[]
[ "<s>", "static", "section", "*", "loongarch_function_rodata_section", "(", "tree", "decl", ",", "bool", ")", "{", "return", "default_function_rodata_section", "(", "decl", ",", "false", ")", ";", "}", "</s>" ]
[ "Implement", "TARGET_ASM_FUNCTION_RODATA_SECTION", ".", "The", "complication", "here", "is", "that", "jump", "tables", "will", "use", "absolute", "addresses", ",", "and", "should", "therefore", "not", "be", "included", "in", "the", "read-only", "part", "of", "a", "DSO", ".", "Handle", "such", "cases", "by", "selecting", "a", "normal", "data", "section", "instead", "of", "a", "read-only", "one", ".", "The", "logic", "apes", "that", "in", "default_function_rodata_section", "." ]
[ "loongarch" ]
loongarch
loongarch_function_rodata_section
loongarch
CPU
GCC
17,801
20
1
[]
[ "<s>", "static", "void", "mmix_output_shiftvalue_op_from_str", "(", "FILE", "*", "stream", ",", "const", "char", "*", "mainop", ",", "int64_t", "value", ")", "{", "static", "const", "char", "*", "const", "op_part", "[", "]", "=", "{", "\"L\"", ",", "\"ML\"", ",", "\"MH\"", ",", "\"H\"", "}", ";", "int", "i", ";", "if", "(", "!", "mmix_shiftable_wyde_value", "(", "value", ")", ")", "{", "char", "s", "[", "sizeof", "(", "\"0xffffffffffffffff\"", ")", "]", ";", "sprintf", "(", "s", ",", "\"%#\"", "PRIx64", ",", "value", ")", ";", "internal_error", "(", "\"MMIX Internal: %s is not a shiftable int\"", ",", "s", ")", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "{", "if", "(", "value", "&", "0xffff", ")", "{", "fprintf", "(", "stream", ",", "\"%s%s\"", ",", "mainop", ",", "op_part", "[", "i", "]", ")", ";", "return", ";", "}", "value", ">>=", "16", ";", "}", "fprintf", "(", "stream", ",", "\"%sL\"", ",", "mainop", ")", ";", "}", "</s>" ]
[ "Print", "operator", "suitable", "for", "doing", "something", "with", "a", "shiftable", "wyde", ".", "The", "type", "of", "operator", "is", "passed", "as", "an", "asm", "output", "modifier", "." ]
[ "mmix", "\"L\"", "\"ML\"", "\"MH\"", "\"H\"", "\"0xffffffffffffffff\"", "\"%#\"", "\"MMIX Internal: %s is not a shiftable int\"", "0", "4", "0xffff", "\"%s%s\"", "16", "\"%sL\"" ]
mmix4
mmix_output_shiftvalue_op_from_str
mmix
CPU
GCC
17,802
128
1
[]
[ "<s>", "unsigned", "getMaxNumElements", "(", "ElementCount", "VF", ")", "const", "{", "if", "(", "!", "VF", ".", "isScalable", "(", ")", ")", "return", "VF", ".", "getFixedValue", "(", ")", ";", "return", "VF", ".", "getKnownMinValue", "(", ")", "*", "ST", "->", "getVScaleForTuning", "(", ")", ";", "}", "</s>" ]
[ "Try", "to", "return", "an", "estimate", "cost", "factor", "that", "can", "be", "used", "as", "a", "multiplier", "when", "scalarizing", "an", "operation", "for", "a", "vector", "with", "ElementCount", "VF", "." ]
[ "AArch64" ]
AArch64TargetTransformInfo
getMaxNumElements
AArch64
CPU
LLVM
17,803
38
1
[]
[ "<s>", "static", "void", "s390_free_pool", "(", "struct", "constant_pool", "*", "pool", ")", "{", "struct", "constant", "*", "c", ",", "*", "next", ";", "size_t", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NR_C_MODES", ";", "i", "++", ")", "for", "(", "c", "=", "pool", "->", "constants", "[", "i", "]", ";", "c", ";", "c", "=", "next", ")", "{", "next", "=", "c", "->", "next", ";", "free", "(", "c", ")", ";", "}", "for", "(", "c", "=", "pool", "->", "execute", ";", "c", ";", "c", "=", "next", ")", "{", "next", "=", "c", "->", "next", ";", "free", "(", "c", ")", ";", "}", "BITMAP_FREE", "(", "pool", "->", "insns", ")", ";", "free", "(", "pool", ")", ";", "}", "</s>" ]
[ "Free", "all", "memory", "used", "by", "POOL", "." ]
[ "s390", "0" ]
s390
s390_free_pool
s390
MPU
GCC
17,804
104
1
[]
[ "<s>", "bool", "RISCVTargetLowering", "::", "isCheapToSpeculateCttz", "(", ")", "const", "{", "return", "Subtarget", ".", "hasStdExtZbb", "(", ")", ";", "}", "</s>" ]
[ "Return", "true", "if", "it", "is", "cheap", "to", "speculate", "a", "call", "to", "intrinsic", "cttz", "." ]
[ "RI5CY", "RISCV" ]
RISCVISelLowering
isCheapToSpeculateCttz
RI5CY
CPU
LLVM
17,805
16
1
[]
[ "<s>", "enum", "reg_class", "rl78_mode_code_base_reg_class", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "addr_space_t", "address_space", "ATTRIBUTE_UNUSED", ",", "int", "outer_code", "ATTRIBUTE_UNUSED", ",", "int", "index_code", "ATTRIBUTE_UNUSED", ")", "{", "return", "V_REGS", ";", "}", "</s>" ]
[ "Implements", "MODE_CODE_BASE_REG_CLASS", "." ]
[ "rl78" ]
rl78
rl78_mode_code_base_reg_class
rl78
MPU
GCC
17,806
25
1
[]
[ "<s>", "void", "rs6000_final_prescan_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operand", "ATTRIBUTE_UNUSED", ",", "int", "num_operands", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "rs6000_warn_cell_microcode", ")", "{", "const", "char", "*", "temp", ";", "int", "insn_code_number", "=", "recog_memoized", "(", "insn", ")", ";", "location_t", "location", "=", "INSN_LOCATION", "(", "insn", ")", ";", "if", "(", "insn_code_number", "<", "0", ")", "return", ";", "struct", "recog_data_d", "recog_data_save", "=", "recog_data", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "recog_data", ".", "n_operands", ";", "i", "++", ")", "recog_data", ".", "operand", "[", "i", "]", "=", "copy_rtx", "(", "recog_data", ".", "operand", "[", "i", "]", ")", ";", "temp", "=", "get_insn_template", "(", "insn_code_number", ",", "insn", ")", ";", "recog_data", "=", "recog_data_save", ";", "if", "(", "get_attr_cell_micro", "(", "insn", ")", "==", "CELL_MICRO_ALWAYS", ")", "warning_at", "(", "location", ",", "OPT_mwarn_cell_microcode", ",", "\"emitting microcode insn %s\\t[%s] #%d\"", ",", "temp", ",", "insn_data", "[", "INSN_CODE", "(", "insn", ")", "]", ".", "name", ",", "INSN_UID", "(", "insn", ")", ")", ";", "else", "if", "(", "get_attr_cell_micro", "(", "insn", ")", "==", "CELL_MICRO_CONDITIONAL", ")", "warning_at", "(", "location", ",", "OPT_mwarn_cell_microcode", ",", "\"emitting conditional microcode insn %s\\t[%s] #%d\"", ",", "temp", ",", "insn_data", "[", "INSN_CODE", "(", "insn", ")", "]", ".", "name", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "}", "</s>" ]
[ "Define", "FINAL_PRESCAN_INSN", "if", "some", "processing", "needs", "to", "be", "done", "before", "outputting", "the", "assembler", "code", ".", "On", "the", "PowerPC", ",", "we", "remember", "if", "the", "current", "insn", "is", "a", "prefixed", "insn", "where", "we", "need", "to", "emit", "a", "'", "p", "'", "before", "the", "insn", ".", "In", "addition", ",", "if", "the", "insn", "is", "part", "of", "a", "PC-relative", "reference", "to", "an", "external", "label", "optimization", ",", "this", "is", "recorded", "also", "." ]
[ "rs6000", "0", "0", "\"emitting microcode insn %s\\t[%s] #%d\"", "\"emitting conditional microcode insn %s\\t[%s] #%d\"" ]
rs60006
rs6000_final_prescan_insn
rs6000
CPU
GCC
17,807
176
1
[]
[ "<s>", "bool", "SIShrinkInstructions", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "SIRegisterInfo", "&", "TRI", "=", "TII", "->", "getRegisterInfo", "(", ")", ";", "std", "::", "vector", "<", "unsigned", ">", "I1Defs", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "if", "(", "!", "TII", "->", "hasVALU32BitEncoding", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "continue", ";", "if", "(", "!", "canShrink", "(", "MI", ",", "TII", ",", "TRI", ",", "MRI", ")", ")", "{", "if", "(", "!", "MI", ".", "isCommutable", "(", ")", "||", "!", "TII", "->", "commuteInstruction", "(", "&", "MI", ")", "||", "!", "canShrink", "(", "MI", ",", "TII", ",", "TRI", ",", "MRI", ")", ")", "continue", ";", "}", "int", "Op32", "=", "AMDGPU", "::", "getVOPe32", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "Op32", "==", "-", "1", ")", "continue", ";", "if", "(", "TII", "->", "isVOPC", "(", "Op32", ")", ")", "{", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DstReg", ")", ")", "{", "MRI", ".", "setRegAllocationHint", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "0", ",", "AMDGPU", "::", "VCC", ")", ";", "continue", ";", "}", "if", "(", "DstReg", "!=", "AMDGPU", "::", "VCC", ")", "continue", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Shrinking \"", ";", "MI", ".", "dump", "(", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ";", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Op32", ")", ")", ";", "MIB", ".", "addOperand", "(", "MI", ".", "getOperand", "(", "0", ")", ")", ";", "MIB", ".", "addOperand", "(", "*", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ")", ";", "const", "MachineOperand", "*", "Src1", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "if", "(", "Src1", ")", "MIB", ".", "addOperand", "(", "*", "Src1", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "implicit_operands", "(", ")", ")", "MIB", ".", "addOperand", "(", "MO", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"e32 MI = \"", ";", "MI", ".", "dump", "(", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ";", ")", ";", "++", "NumInstructionsShrunk", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "R600", "SI", "SI", "SI", "SI", "1", "0", "0", "0", "\"Shrinking \"", "\"\\n\"", "0", "\"e32 MI = \"", "\"\\n\"" ]
SIShrinkInstructions3
runOnMachineFunction
R600
GPU
LLVM
17,808
464
1
[]
[ "<s>", "SDValue", "SystemZTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "unsigned", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "return", "LowerCCCArguments", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]
[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]
[ "SystemZ", "SystemZ", "ISD::InputArg", "\"Unsupported calling convention\"" ]
SystemZISelLowering42
LowerFormalArguments
SystemZ
CPU
LLVM
17,809
81
1
[]
[ "<s>", "const", "char", "*", "output_jump_label_table", "(", "void", ")", "{", "if", "(", "pool_size", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t.align 2\\n\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "pool_size", ";", "i", "++", ")", "{", "pool_node", "*", "p", "=", "&", "pool_vector", "[", "i", "]", ";", "(", "*", "targetm", ".", "asm_out", ".", "internal_label", ")", "(", "asm_out_file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "p", "->", "label", ")", ")", ";", "output_asm_insn", "(", "\".long\t%O0\"", ",", "&", "p", "->", "value", ")", ";", "}", "pool_size", "=", "0", ";", "}", "return", "\"\"", ";", "}", "</s>" ]
[ "Dump", "out", "any", "constants", "accumulated", "in", "the", "final", "pass", ".", "These", "will", "only", "be", "labels", "." ]
[ "sh", "\"\\t.align 2\\n\"", "0", "\"L\"", "\".long\t%O0\"", "0", "\"\"" ]
sh
output_jump_label_table
sh
CPU
GCC
17,810
86
1
[]
[ "<s>", "void", "SPIRVPassConfig", "::", "addPreLegalizeMachineIR", "(", ")", "{", "addPass", "(", "createSPIRVPreLegalizerPass", "(", ")", ")", ";", "}", "</s>" ]
[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "legalization", "." ]
[ "SPIRV", "SPIRV", "SPIRV" ]
SPIRVTargetMachine
addPreLegalizeMachineIR
SPIRV
Virtual ISA
LLVM
17,811
15
1
[]
[ "<s>", "outliner", "::", "InstrType", "RISCVInstrInfo", "::", "getOutliningType", "(", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "unsigned", "Flags", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "MBBI", ";", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MBB", "->", "getParent", "(", ")", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "MI", ".", "isPosition", "(", ")", ")", "{", "if", "(", "MI", ".", "isCFIInstruction", "(", ")", ")", "return", "MI", ".", "getMF", "(", ")", "->", "getFunction", "(", ")", ".", "needsUnwindTableEntry", "(", ")", "?", "outliner", "::", "InstrType", "::", "Illegal", ":", "outliner", "::", "InstrType", "::", "Invisible", ";", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "}", "if", "(", "MI", ".", "isInlineAsm", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "isTerminator", "(", ")", "&&", "!", "MBB", "->", "succ_empty", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "isReturn", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "modifiesRegister", "(", "RISCV", "::", "X5", ",", "TRI", ")", "||", "MI", ".", "getDesc", "(", ")", ".", "hasImplicitDefOfPhysReg", "(", "RISCV", "::", "X5", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "for", "(", "const", "auto", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "if", "(", "MO", ".", "isMBB", "(", ")", "||", "MO", ".", "isBlockAddress", "(", ")", "||", "MO", ".", "isCPI", "(", ")", "||", "MO", ".", "isJTI", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "isMetaInstruction", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Invisible", ";", "return", "outliner", "::", "InstrType", "::", "Legal", ";", "}", "</s>" ]
[ "Returns", "how", "or", "if", "MIT", "should", "be", "outlined", "." ]
[ "RISCV", "RISCV", "RISCV::X5", "RISCV::X5" ]
RISCVInstrInfo24
getOutliningType
RISCV
CPU
LLVM
17,812
260
1
[]
[ "<s>", "bool", "AArch64MCInstLower", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "const", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "return", "false", ";", "MCOp", "=", "MCOperand", "::", "createReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_RegisterMask", ":", "return", "false", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "Ctx", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "GetGlobalAddressSymbol", "(", "MO", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "GetExternalSymbolSymbol", "(", "MO", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MCSymbol", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "MO", ".", "getMCSymbol", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "MCOp", "=", "LowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ")", ";", "break", ";", "}", "return", "true", ";", "}", "</s>" ]
[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]
[ "AArch64", "AArch64", "\"unknown operand type\"" ]
AArch64MCInstLower1
lowerOperand
AArch64
CPU
LLVM
17,813
260
1
[]
[ "<s>", "bool", "isThumb", "(", ")", "const", "{", "return", "STI", ".", "getFeatureBits", "(", ")", "[", "ARM", "::", "ModeThumb", "]", ";", "}", "</s>" ]
[ "Tests", "whether", "the", "target", "is", "Thumb", "(", "little", "and", "big", "endian", ")", "." ]
[ "ARM", "ARM::ModeThumb" ]
ARMAsmParser108
isThumb
ARM
CPU
LLVM
17,814
19
1
[]
[ "<s>", "void", "MSP430RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "MSP430", "::", "FPW", ":", "MSP430", "::", "SPW", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "Offset", "+=", "2", ";", "if", "(", "!", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "else", "Offset", "+=", "2", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "MSP430", "::", "ADD16ri", ")", "{", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "if", "(", "Offset", "==", "0", ")", "return", ";", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "Offset", "<", "0", ")", "BuildMI", "(", "MBB", ",", "llvm", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "-", "Offset", ")", ";", "else", "BuildMI", "(", "MBB", ",", "llvm", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "Offset", ")", ";", "return", ";", "}", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]
[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]
[ "MSP430", "MSP430", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "MSP430::FPW", "MSP430::SPW", "2", "2", "1", "MSP430::ADD16ri", "MSP430::MOV16rr", "0", "0", "0", "MSP430::SUB16ri", "MSP430::ADD16ri", "1" ]
MSP430RegisterInfo19
eliminateFrameIndex
MSP430
MPU
LLVM
17,815
385
1
[]
[ "<s>", "size_type", "size", "(", ")", "const", "{", "return", "V", ".", "size", "(", ")", ";", "}", "</s>" ]
[ "The", "number", "of", "name/type", "pairs", "is", "returned", "." ]
[ "X86" ]
ImmutableGraph
size
X86
CPU
LLVM
17,816
14
1
[]
[ "<s>", "bool", "arc_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "false", ";", "if", "(", "!", "flag_pic", "&&", "mode", "!=", "Pmode", ")", "return", "true", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "if", "(", "flag_pic", "?", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "CONST_INT", ":", "!", "arc_legitimate_constant_p", "(", "mode", ",", "XEXP", "(", "x", ",", "1", ")", ")", ")", "return", "false", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "ARC_UNSPEC_PLT", ":", "case", "ARC_UNSPEC_GOTOFF", ":", "case", "ARC_UNSPEC_GOTOFFPC", ":", "case", "ARC_UNSPEC_GOT", ":", "case", "UNSPEC_TLS_GD", ":", "case", "UNSPEC_TLS_IE", ":", "case", "UNSPEC_TLS_OFF", ":", "return", "true", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "arc_raw_symbolic_reference_mentioned_p", "(", "x", ",", "false", ")", ")", "return", "false", ";", "break", ";", "case", "SYMBOL_REF", ":", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "false", ";", "case", "LABEL_REF", ":", "if", "(", "flag_pic", ")", "return", "false", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]
[ "Determine", "if", "a", "given", "RTX", "is", "a", "valid", "constant", ".", "We", "already", "know", "this", "satisfies", "CONSTANT_P", "." ]
[ "arc", "0", "1", "1", "0", "1" ]
arc6
arc_legitimate_constant_p
arc
MPU
GCC
17,817
207
1
[]
[ "<s>", "bool", "ARMTargetLowering", "::", "isUsedByReturnOnly", "(", "SDNode", "*", "N", ")", "const", "{", "if", "(", "N", "->", "getNumValues", "(", ")", "!=", "1", ")", "return", "false", ";", "if", "(", "!", "N", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", ")", "return", "false", ";", "unsigned", "NumCopies", "=", "0", ";", "SDNode", "*", "Copies", "[", "2", "]", "=", "{", "0", ",", "0", "}", ";", "SDNode", "*", "Use", "=", "*", "N", "->", "use_begin", "(", ")", ";", "if", "(", "Use", "->", "getOpcode", "(", ")", "==", "ISD", "::", "CopyToReg", ")", "{", "Copies", "[", "NumCopies", "++", "]", "=", "Use", ";", "}", "else", "if", "(", "Use", "->", "getOpcode", "(", ")", "==", "ARMISD", "::", "VMOVRRD", ")", "{", "for", "(", "SDNode", "::", "use_iterator", "UI", "=", "Use", "->", "use_begin", "(", ")", ",", "UE", "=", "Use", "->", "use_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "if", "(", "UI", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "CopyToReg", ")", "return", "false", ";", "Copies", "[", "UI", ".", "getUse", "(", ")", ".", "getResNo", "(", ")", "]", "=", "*", "UI", ";", "++", "NumCopies", ";", "}", "}", "else", "if", "(", "Use", "->", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", ")", "{", "if", "(", "!", "Use", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", ")", "return", "false", ";", "Use", "=", "*", "Use", "->", "use_begin", "(", ")", ";", "if", "(", "Use", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "CopyToReg", "||", "!", "Use", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", ")", "return", "false", ";", "Copies", "[", "NumCopies", "++", "]", "=", "Use", ";", "}", "else", "{", "return", "false", ";", "}", "if", "(", "NumCopies", "!=", "1", "&&", "NumCopies", "!=", "2", ")", "return", "false", ";", "bool", "HasRet", "=", "false", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "NumCopies", ";", "++", "i", ")", "{", "SDNode", "*", "Copy", "=", "Copies", "[", "i", "]", ";", "for", "(", "SDNode", "::", "use_iterator", "UI", "=", "Copy", "->", "use_begin", "(", ")", ",", "UE", "=", "Copy", "->", "use_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "if", "(", "UI", "->", "getOpcode", "(", ")", "==", "ISD", "::", "CopyToReg", ")", "{", "SDNode", "*", "Use", "=", "*", "UI", ";", "if", "(", "Use", "==", "Copies", "[", "0", "]", "||", "(", "(", "NumCopies", "==", "2", ")", "&&", "(", "Use", "==", "Copies", "[", "1", "]", ")", ")", ")", "continue", ";", "return", "false", ";", "}", "if", "(", "UI", "->", "getOpcode", "(", ")", "!=", "ARMISD", "::", "RET_FLAG", ")", "return", "false", ";", "HasRet", "=", "true", ";", "}", "}", "return", "HasRet", ";", "}", "</s>" ]
[ "Return", "true", "if", "result", "of", "the", "specified", "node", "is", "used", "by", "a", "return", "node", "only", "." ]
[ "ARM", "ARM", "1", "1", "0", "0", "2", "0", "0", "ISD::CopyToReg", "ARMISD::VMOVRRD", "ISD::CopyToReg", "ISD::BITCAST", "1", "0", "ISD::CopyToReg", "1", "0", "1", "2", "0", "ISD::CopyToReg", "0", "2", "1", "ARMISD::RET_FLAG" ]
ARMISelLowering16
isUsedByReturnOnly
ARM
CPU
LLVM
17,818
395
1
[]
[ "<s>", "bool", "Thumb2ITBlockPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "TargetMachine", "&", "TM", "=", "Fn", ".", "getTarget", "(", ")", ";", "AFI", "=", "Fn", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "TM", ".", "getRegisterInfo", "(", ")", ";", "hasV8Ops", "=", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "hasV8Ops", "(", ")", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", ")", "return", "false", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "++", "MFI", ";", "Modified", "|=", "InsertITInstructions", "(", "MBB", ")", ";", "}", "if", "(", "Modified", ")", "AFI", "->", "setHasITBlocks", "(", "true", ")", ";", "return", "Modified", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "ARM", "ARM", "ARM" ]
Thumb2ITBlockPass11
runOnMachineFunction
ARM
CPU
LLVM
17,819
148
1
[]
[ "<s>", "void", "Cpu0TargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sbss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "}", "</s>" ]
[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]
[ "Cpu0", "Cpu0", "\".sdata\"", "\".sbss\"" ]
Cpu0TargetObjectFile1
Initialize
Cpu0
CPU
LLVM
17,820
83
1
[]
[ "<s>", "unsigned", "SPUInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "SPU", "::", "STQDv16i8", ":", "case", "SPU", "::", "STQDv8i16", ":", "case", "SPU", "::", "STQDv4i32", ":", "case", "SPU", "::", "STQDv4f32", ":", "case", "SPU", "::", "STQDv2f64", ":", "case", "SPU", "::", "STQDr128", ":", "case", "SPU", "::", "STQDr64", ":", "case", "SPU", "::", "STQDr32", ":", "case", "SPU", "::", "STQDr16", ":", "case", "SPU", "::", "STQDr8", ":", "{", "const", "MachineOperand", "MOp1", "=", "MI", "->", "getOperand", "(", "1", ")", ";", "const", "MachineOperand", "MOp2", "=", "MI", "->", "getOperand", "(", "2", ")", ";", "if", "(", "MOp1", ".", "isImm", "(", ")", "&&", "MOp2", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MOp2", ".", "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", "." ]
[ "CellSPU", "SPU", "SPU::STQDv16i8", "SPU::STQDv8i16", "SPU::STQDv4i32", "SPU::STQDv4f32", "SPU::STQDv2f64", "SPU::STQDr128", "SPU::STQDr64", "SPU::STQDr32", "SPU::STQDr16", "SPU::STQDr8", "1", "2", "0", "0" ]
SPUInstrInfo
isStoreToStackSlot
CellSPU
MPU
LLVM
17,821
146
1
[]
[ "<s>", "static", "avr_map_op_t", "avr_map_decompose", "(", "unsigned", "int", "f", ",", "const", "avr_map_op_t", "*", "g", ",", "bool", "val_const_p", ")", "{", "int", "i", ";", "bool", "val_used_p", "=", "0", "!=", "avr_map_metric", "(", "f", ",", "MAP_MASK_PREIMAGE_F", ")", ";", "avr_map_op_t", "f_ginv", "=", "*", "g", ";", "unsigned", "int", "ginv", "=", "g", "->", "ginv", ";", "f_ginv", ".", "cost", "=", "-", "1", ";", "for", "(", "i", "=", "7", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "int", "x", "=", "avr_map", "(", "f", ",", "i", ")", ";", "if", "(", "x", "<=", "7", ")", "{", "x", "=", "avr_map", "(", "ginv", ",", "x", ")", ";", "if", "(", "x", ">", "7", ")", "return", "f_ginv", ";", "}", "f_ginv", ".", "map", "=", "(", "f_ginv", ".", "map", "<<", "4", ")", "+", "x", ";", "}", "if", "(", "0", "==", "avr_map_metric", "(", "f_ginv", ".", "map", ",", "MAP_NONFIXED_0_7", ")", ")", "{", "f_ginv", ".", "cost", "=", "2", "+", "(", "val_used_p", "&&", "!", "val_const_p", ")", ";", "}", "else", "{", "rtx", "xop", "[", "4", "]", ";", "xop", "[", "0", "]", "=", "all_regs_rtx", "[", "24", "]", ";", "xop", "[", "1", "]", "=", "gen_int_mode", "(", "f_ginv", ".", "map", ",", "SImode", ")", ";", "xop", "[", "2", "]", "=", "all_regs_rtx", "[", "25", "]", ";", "xop", "[", "3", "]", "=", "val_used_p", "?", "xop", "[", "0", "]", ":", "const0_rtx", ";", "avr_out_insert_bits", "(", "xop", ",", "&", "f_ginv", ".", "cost", ")", ";", "f_ginv", ".", "cost", "+=", "val_const_p", "&&", "val_used_p", "?", "1", ":", "0", ";", "}", "f_ginv", ".", "cost", "+=", "g", "->", "cost", ";", "if", "(", "avr_log", ".", "builtin", ")", "avr_edump", "(", "\" %s%d=%d\"", ",", "g", "->", "str", ",", "g", "->", "arg", ",", "f_ginv", ".", "cost", ")", ";", "return", "f_ginv", ";", "}", "</s>" ]
[ "Try", "to", "decompose", "F", "as", "F", "=", "(", "F", "o", "G^-1", ")", "o", "G", "as", "described", "above", ".", "The", "result", "is", "a", "struct", "representing", "F", "o", "G^-1", "and", "G.", "If", "result.cost", "<", "0", "then", "such", "a", "decomposition", "does", "not", "exist", "." ]
[ "avr", "0", "1", "7", "0", "7", "7", "4", "0", "2", "4", "0", "24", "1", "2", "25", "3", "0", "1", "0", "\" %s%d=%d\"" ]
avr4
avr_map_decompose
avr
MPU
GCC
17,822
260
1
[]
[ "<s>", "int", "pa_function_arg_size", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "HOST_WIDE_INT", "size", ";", "size", "=", "mode", "!=", "BLKmode", "?", "GET_MODE_SIZE", "(", "mode", ")", ":", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "size", ">=", "(", "1", "<<", "(", "HOST_BITS_PER_INT", "-", "2", ")", ")", ")", "size", "=", "0", ";", "return", "(", "int", ")", "CEIL", "(", "size", ",", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]
[ "Figure", "out", "the", "size", "in", "words", "of", "the", "function", "argument", "." ]
[ "pa", "1", "2", "0" ]
pa1
pa_function_arg_size
pa
CPU
GCC
17,823
59
1
[]
[ "<s>", "void", "LC3bInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "}", "</s>" ]
[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]
[ "LC3b", "LC3b" ]
LC3bInstPrinter
printInst
LC3b
CPU
LLVM
17,824
19
1
[]
[ "<s>", "static", "void", "mcore_reorg", "(", "void", ")", "{", "current_function_anonymous_args", "=", "0", ";", "if", "(", "saved_warn_return_type", "!=", "-", "1", ")", "{", "if", "(", "--", "saved_warn_return_type_count", "==", "0", ")", "{", "warn_return_type", "=", "saved_warn_return_type", ";", "saved_warn_return_type", "=", "-", "1", ";", "}", "}", "if", "(", "optimize", "==", "0", ")", "return", ";", "conditionalize_optimization", "(", ")", ";", "}", "</s>" ]
[ "This", "is", "to", "handle", "loads", "from", "the", "constant", "pool", "." ]
[ "mcore", "0", "1", "0", "1", "0" ]
mcore3
mcore_reorg
mcore
MPU
GCC
17,825
51
1
[]
[ "<s>", "static", "unsigned", "int", "arc_compute_function_type", "(", "struct", "function", "*", "fun", ")", "{", "tree", "attr", ",", "decl", "=", "fun", "->", "decl", ";", "unsigned", "int", "fn_type", "=", "fun", "->", "machine", "->", "fn_type", ";", "if", "(", "fn_type", "!=", "ARC_FUNCTION_UNKNOWN", ")", "return", "fn_type", ";", "if", "(", "lookup_attribute", "(", "\"naked\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", "!=", "NULL_TREE", ")", "fn_type", "|=", "ARC_FUNCTION_NAKED", ";", "else", "fn_type", "|=", "ARC_FUNCTION_NORMAL", ";", "attr", "=", "lookup_attribute", "(", "\"interrupt\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ";", "if", "(", "attr", "!=", "NULL_TREE", ")", "{", "tree", "value", ",", "args", "=", "TREE_VALUE", "(", "attr", ")", ";", "gcc_assert", "(", "list_length", "(", "args", ")", "==", "1", ")", ";", "value", "=", "TREE_VALUE", "(", "args", ")", ";", "gcc_assert", "(", "TREE_CODE", "(", "value", ")", "==", "STRING_CST", ")", ";", "if", "(", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink1\"", ")", "||", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink\"", ")", ")", "fn_type", "|=", "ARC_FUNCTION_ILINK1", ";", "else", "if", "(", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink2\"", ")", ")", "fn_type", "|=", "ARC_FUNCTION_ILINK2", ";", "else", "if", "(", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"firq\"", ")", ")", "fn_type", "|=", "ARC_FUNCTION_FIRQ", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "return", "fun", "->", "machine", "->", "fn_type", "=", "fn_type", ";", "}", "</s>" ]
[ "Type", "of", "function", "DECL", ".", "The", "result", "is", "cached", ".", "To", "reset", "the", "cache", "at", "the", "end", "of", "a", "function", ",", "call", "with", "DECL", "=", "NULL_TREE", "." ]
[ "arc", "\"naked\"", "\"interrupt\"", "1", "\"ilink1\"", "\"ilink\"", "\"ilink2\"", "\"firq\"" ]
arc
arc_compute_function_type
arc
MPU
GCC
17,826
198
1
[]
[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineBlockFrequencyInfo", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]
[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]
[ "WebAssembly" ]
WebAssemblyExplicitLocals (2)
getAnalysisUsage
WebAssembly
Virtual ISA
LLVM
17,827
33
1
[]
[ "<s>", "void", "RISCVInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DstReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "RISCV", "::", "GPRRegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "RISCV", "::", "ADDI", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "unsigned", "Opc", ";", "if", "(", "RISCV", "::", "FPR32RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "Opc", "=", "RISCV", "::", "FSGNJ_S", ";", "else", "if", "(", "RISCV", "::", "FPR64RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "Opc", "=", "RISCV", "::", "FSGNJ_D", ";", "else", "if", "(", "RISCV", "::", "VRRegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "RISCV", "::", "VMV1R_V", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "else", "if", "(", "RISCV", "::", "VRM2RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", "||", "RISCV", "::", "VRM4RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", "||", "RISCV", "::", "VRM8RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "{", "unsigned", "Opcode", ";", "if", "(", "RISCV", "::", "VRM2RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "Opcode", "=", "RISCV", "::", "VMV2R_V", ";", "else", "if", "(", "RISCV", "::", "VRM4RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "Opcode", "=", "RISCV", "::", "VMV4R_V", ";", "else", "Opcode", "=", "RISCV", "::", "VMV8R_V", ";", "DstReg", "=", "TRI", "->", "getSubReg", "(", "DstReg", ",", "RISCV", "::", "sub_vrm2", ")", ";", "SrcReg", "=", "TRI", "->", "getSubReg", "(", "SrcReg", ",", "RISCV", "::", "sub_vrm2", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]
[ "}", "Branch", "Analysis", "&", "Modification" ]
[ "RISCV", "RISCV", "RISCV::GPRRegClass", "RISCV::ADDI", "0", "RISCV::FPR32RegClass", "RISCV::FSGNJ_S", "RISCV::FPR64RegClass", "RISCV::FSGNJ_D", "RISCV::VRRegClass", "RISCV::VMV1R_V", "RISCV::VRM2RegClass", "RISCV::VRM4RegClass", "RISCV::VRM8RegClass", "RISCV::VRM2RegClass", "RISCV::VMV2R_V", "RISCV::VRM4RegClass", "RISCV::VMV4R_V", "RISCV::VMV8R_V", "RISCV::sub_vrm2", "RISCV::sub_vrm2", "\"Impossible reg-to-reg copy\"" ]
RISCVInstrInfo25
copyPhysReg
RISCV
CPU
LLVM
17,828
379
1
[]
[ "<s>", "unsigned", "HSAILRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "HSAIL", "::", "NoRegister", ";", "}", "</s>" ]
[ "Debug", "information", "queries", "." ]
[ "HSAIL", "HSAIL", "HSAIL::NoRegister" ]
HSAILRegisterInfo
getFrameRegister
HSAIL
Virtual ISA
LLVM
17,829
18
1
[]
[ "<s>", "static", "bool", "swap_top_of_ready_list", "(", "rtx_insn", "*", "*", "ready", ",", "int", "n_ready", ")", "{", "rtx_insn", "*", "top", "=", "ready", "[", "n_ready", "-", "1", "]", ";", "rtx_insn", "*", "next", "=", "ready", "[", "n_ready", "-", "2", "]", ";", "rtx", "set", ";", "sd_iterator_def", "sd_it", ";", "dep_t", "dep", ";", "int", "clock1", "=", "-", "1", ";", "int", "clock2", "=", "-", "1", ";", "if", "(", "!", "TARGET_SILVERMONT", "&&", "!", "TARGET_INTEL", ")", "return", "false", ";", "if", "(", "!", "NONDEBUG_INSN_P", "(", "top", ")", ")", "return", "false", ";", "if", "(", "!", "NONJUMP_INSN_P", "(", "top", ")", ")", "return", "false", ";", "if", "(", "!", "NONDEBUG_INSN_P", "(", "next", ")", ")", "return", "false", ";", "if", "(", "!", "NONJUMP_INSN_P", "(", "next", ")", ")", "return", "false", ";", "set", "=", "single_set", "(", "top", ")", ";", "if", "(", "!", "set", ")", "return", "false", ";", "set", "=", "single_set", "(", "next", ")", ";", "if", "(", "!", "set", ")", "return", "false", ";", "if", "(", "INSN_PRIORITY_KNOWN", "(", "top", ")", "&&", "INSN_PRIORITY_KNOWN", "(", "next", ")", ")", "{", "if", "(", "INSN_PRIORITY", "(", "top", ")", "!=", "INSN_PRIORITY", "(", "next", ")", ")", "return", "false", ";", "FOR_EACH_DEP", "(", "top", ",", "SD_LIST_RES_BACK", ",", "sd_it", ",", "dep", ")", "{", "rtx", "pro", ";", "pro", "=", "DEP_PRO", "(", "dep", ")", ";", "if", "(", "!", "NONDEBUG_INSN_P", "(", "pro", ")", ")", "continue", ";", "if", "(", "INSN_TICK", "(", "pro", ")", ">", "clock1", ")", "clock1", "=", "INSN_TICK", "(", "pro", ")", ";", "}", "FOR_EACH_DEP", "(", "next", ",", "SD_LIST_RES_BACK", ",", "sd_it", ",", "dep", ")", "{", "rtx", "pro", ";", "pro", "=", "DEP_PRO", "(", "dep", ")", ";", "if", "(", "!", "NONDEBUG_INSN_P", "(", "pro", ")", ")", "continue", ";", "if", "(", "INSN_TICK", "(", "pro", ")", ">", "clock2", ")", "clock2", "=", "INSN_TICK", "(", "pro", ")", ";", "}", "if", "(", "clock1", "==", "clock2", ")", "{", "enum", "attr_memory", "memory1", ",", "memory2", ";", "memory1", "=", "get_attr_memory", "(", "top", ")", ";", "memory2", "=", "get_attr_memory", "(", "next", ")", ";", "if", "(", "memory2", "==", "MEMORY_LOAD", "&&", "memory1", "!=", "MEMORY_LOAD", ")", "return", "true", ";", "}", "return", "(", "bool", ")", "(", "clock2", "<", "clock1", ")", ";", "}", "return", "false", ";", "}", "</s>" ]
[ "Try", "to", "find", "the", "best", "candidate", "on", "the", "top", "of", "ready", "list", "if", "two", "insns", "have", "the", "same", "priority", "-", "candidate", "is", "best", "if", "its", "dependees", "were", "scheduled", "earlier", ".", "Applied", "for", "Silvermont", "only", ".", "Return", "true", "if", "top", "2", "insns", "must", "be", "interchanged", "." ]
[ "i386", "1", "2", "1", "1" ]
i3864
swap_top_of_ready_list
i386
CPU
GCC
17,830
321
1
[]
[ "<s>", "SDValue", "MBlazeTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_MBlaze", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]
[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]
[ "MBlaze", "MBlaze", "ISD::InputArg", "16", "MBlaze", "0", "1", "2", "0" ]
MBlazeISelLowering10
LowerCallResult
MBlaze
MPU
LLVM
17,831
170
1
[]
[ "<s>", "static", "void", "reshuffle_units", "(", "basic_block", "loop", ")", "{", "rtx_insn", "*", "head", "=", "BB_HEAD", "(", "loop", ")", ";", "rtx_insn", "*", "tail", "=", "BB_END", "(", "loop", ")", ";", "rtx_insn", "*", "insn", ";", "unit_req_table", "reqs", ";", "edge", "e", ";", "edge_iterator", "ei", ";", "bitmap_head", "bbs", ";", "count_unit_reqs", "(", "reqs", ",", "head", ",", "PREV_INSN", "(", "tail", ")", ")", ";", "merge_unit_reqs", "(", "reqs", ")", ";", "regrename_init", "(", "true", ")", ";", "bitmap_initialize", "(", "&", "bbs", ",", "&", "bitmap_default_obstack", ")", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "loop", "->", "preds", ")", "bitmap_set_bit", "(", "&", "bbs", ",", "e", "->", "src", "->", "index", ")", ";", "bitmap_set_bit", "(", "&", "bbs", ",", "loop", "->", "index", ")", ";", "regrename_analyze", "(", "&", "bbs", ")", ";", "for", "(", "insn", "=", "head", ";", "insn", "!=", "NEXT_INSN", "(", "tail", ")", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "enum", "attr_units", "units", ";", "int", "count", ",", "side1", ",", "side2", ",", "req1", ",", "req2", ";", "unsigned", "int", "mask1", ",", "mask2", ";", "insn_rr_info", "*", "info", ";", "if", "(", "!", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "continue", ";", "count", "=", "get_unit_reqs", "(", "insn", ",", "&", "req1", ",", "&", "side1", ",", "&", "req2", ",", "&", "side2", ")", ";", "if", "(", "count", "==", "0", ")", "continue", ";", "if", "(", "!", "get_unit_operand_masks", "(", "insn", ",", "&", "mask1", ",", "&", "mask2", ")", ")", "continue", ";", "info", "=", "&", "insn_rr", "[", "INSN_UID", "(", "insn", ")", "]", ";", "if", "(", "info", "->", "op_info", "==", "NULL", ")", "continue", ";", "if", "(", "reqs", "[", "side1", "]", "[", "req1", "]", ">", "1", "&&", "reqs", "[", "side1", "]", "[", "req1", "]", ">", "2", "*", "reqs", "[", "side1", "^", "1", "]", "[", "req1", "]", ")", "{", "try_rename_operands", "(", "head", ",", "tail", ",", "reqs", ",", "insn", ",", "info", ",", "mask1", ",", "side1", ")", ";", "}", "units", "=", "get_attr_units", "(", "insn", ")", ";", "if", "(", "units", "==", "UNITS_D_ADDR", ")", "{", "gcc_assert", "(", "count", "==", "2", ")", ";", "if", "(", "reqs", "[", "side2", "]", "[", "req2", "]", ">", "1", "&&", "reqs", "[", "side2", "]", "[", "req2", "]", ">", "2", "*", "reqs", "[", "side2", "^", "1", "]", "[", "req2", "]", ")", "{", "try_rename_operands", "(", "head", ",", "tail", ",", "reqs", ",", "insn", ",", "info", ",", "mask2", ",", "side2", ")", ";", "}", "}", "}", "regrename_finish", "(", ")", ";", "}", "</s>" ]
[ "Find", "insns", "in", "LOOP", "which", "would", ",", "if", "shifted", "to", "the", "other", "side", "of", "the", "machine", ",", "reduce", "an", "imbalance", "in", "the", "unit", "reservations", "." ]
[ "c6x", "0", "1", "2", "1", "2", "1", "2", "1" ]
c6x
reshuffle_units
c6x
VLIW
GCC
17,832
361
1
[]
[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"NVPTX specific alloca hoisting\"", ";", "}", "</s>" ]
[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]
[ "NVPTX", "\"NVPTX specific alloca hoisting\"" ]
NVPTXAllocaHoisting11
getPassName
NVPTX
GPU
LLVM
17,833
11
1
[]
[ "<s>", "bool", "XNCMFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", ")", ";", "}", "</s>" ]
[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]
[ "XNCM", "XNCM" ]
XNCMFrameLowering
hasFP
XNCM
CPU
LLVM
17,834
56
1
[]
[ "<s>", "virtual", "MachineInstr", "*", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "MachineInstr", "*", "LoadMI", ")", "const", "{", "return", "0", ";", "}", "</s>" ]
[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]
[ "MBlaze", "0" ]
MBlazeInstrInfo3
foldMemoryOperandImpl
MBlaze
MPU
LLVM
17,835
31
1
[]
[ "<s>", "bool", "LoongArchAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Operands", ".", "push_back", "(", "LoongArchOperand", "::", "createToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "if", "(", "parseOptionalToken", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "return", "true", ";", "while", "(", "parseOptionalToken", "(", "AsmToken", "::", "Comma", ")", ")", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "return", "true", ";", "if", "(", "parseOptionalToken", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "getParser", "(", ")", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "</s>" ]
[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]
[ "LoongArch", "LoongArch", "LoongArchOperand::createToken", "\"unexpected token\"" ]
LoongArchAsmParser
ParseInstruction
LoongArch
CPU
LLVM
17,836
119
1
[]
[ "<s>", "unsigned", "SIRegisterInfo", "::", "findUnusedRegister", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "for", "(", "unsigned", "Reg", ":", "*", "RC", ")", "if", "(", "!", "MRI", ".", "isPhysRegUsed", "(", "Reg", ")", ")", "return", "Reg", ";", "return", "AMDGPU", "::", "NoRegister", ";", "}", "</s>" ]
[ "Returns", "a", "lowest", "register", "that", "is", "not", "used", "at", "any", "point", "in", "the", "function", "." ]
[ "AMDGPU", "SI", "AMDGPU::NoRegister" ]
SIRegisterInfo (2)
findUnusedRegister
AMDGPU
GPU
LLVM
17,837
44
1
[]
[ "<s>", "static", "tree", "pa_d_handle_target_float_abi", "(", "void", ")", "{", "const", "char", "*", "abi", ";", "if", "(", "TARGET_SOFT_FLOAT", ")", "abi", "=", "\"soft\"", ";", "else", "abi", "=", "\"hard\"", ";", "return", "build_string_literal", "(", "strlen", "(", "abi", ")", "+", "1", ",", "abi", ")", ";", "}", "</s>" ]
[ "Handle", "a", "call", "to", "`", "__traits", "(", "getTargetInfo", ",", "``", "floatAbi", "''", ")", "'", "." ]
[ "pa", "\"soft\"", "\"hard\"", "1" ]
pa-d
pa_d_handle_target_float_abi
pa
CPU
GCC
17,838
39
1
[]
[ "<s>", "void", "WebAssemblyAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"EmitInstruction: \"", "<<", "*", "MI", "<<", "'\\n'", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "ARGUMENT_i32", ":", "case", "WebAssembly", "::", "ARGUMENT_i32_S", ":", "case", "WebAssembly", "::", "ARGUMENT_i64", ":", "case", "WebAssembly", "::", "ARGUMENT_i64_S", ":", "case", "WebAssembly", "::", "ARGUMENT_f32", ":", "case", "WebAssembly", "::", "ARGUMENT_f32_S", ":", "case", "WebAssembly", "::", "ARGUMENT_f64", ":", "case", "WebAssembly", "::", "ARGUMENT_f64_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v16i8", ":", "case", "WebAssembly", "::", "ARGUMENT_v16i8_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v8i16", ":", "case", "WebAssembly", "::", "ARGUMENT_v8i16_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v4i32", ":", "case", "WebAssembly", "::", "ARGUMENT_v4i32_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v2i64", ":", "case", "WebAssembly", "::", "ARGUMENT_v2i64_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v4f32", ":", "case", "WebAssembly", "::", "ARGUMENT_v4f32_S", ":", "case", "WebAssembly", "::", "ARGUMENT_v2f64", ":", "case", "WebAssembly", "::", "ARGUMENT_v2f64_S", ":", "break", ";", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_I32", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_I32_S", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_I64", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_I64_S", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_F32", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_F32_S", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_F64", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_F64_S", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v16i8", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v16i8_S", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v8i16", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v8i16_S", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v4i32", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v4i32_S", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v2i64", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v2i64_S", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v4f32", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v4f32_S", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v2f64", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_v2f64_S", ":", "{", "if", "(", "isVerbose", "(", ")", ")", "{", "OutStreamer", "->", "AddComment", "(", "\"fallthrough-return-value\"", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "break", ";", "}", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_VOID", ":", "case", "WebAssembly", "::", "FALLTHROUGH_RETURN_VOID_S", ":", "if", "(", "isVerbose", "(", ")", ")", "{", "OutStreamer", "->", "AddComment", "(", "\"fallthrough-return-void\"", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "break", ";", "case", "WebAssembly", "::", "COMPILER_FENCE", ":", "break", ";", "case", "WebAssembly", "::", "EXTRACT_EXCEPTION_I32", ":", "case", "WebAssembly", "::", "EXTRACT_EXCEPTION_I32_S", ":", "if", "(", "!", "WasmKeepRegisters", ")", "break", ";", "LLVM_FALLTHROUGH", ";", "default", ":", "{", "WebAssemblyMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "break", ";", "}", "}", "}", "</s>" ]
[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]
[ "WebAssembly", "WebAssembly", "\"EmitInstruction: \"", "WebAssembly::ARGUMENT_i32", "WebAssembly::ARGUMENT_i32_S", "WebAssembly::ARGUMENT_i64", "WebAssembly::ARGUMENT_i64_S", "WebAssembly::ARGUMENT_f32", "WebAssembly::ARGUMENT_f32_S", "WebAssembly::ARGUMENT_f64", "WebAssembly::ARGUMENT_f64_S", "WebAssembly::ARGUMENT_v16i8", "WebAssembly::ARGUMENT_v16i8_S", "WebAssembly::ARGUMENT_v8i16", "WebAssembly::ARGUMENT_v8i16_S", "WebAssembly::ARGUMENT_v4i32", "WebAssembly::ARGUMENT_v4i32_S", "WebAssembly::ARGUMENT_v2i64", "WebAssembly::ARGUMENT_v2i64_S", "WebAssembly::ARGUMENT_v4f32", "WebAssembly::ARGUMENT_v4f32_S", "WebAssembly::ARGUMENT_v2f64", "WebAssembly::ARGUMENT_v2f64_S", "WebAssembly::FALLTHROUGH_RETURN_I32", "WebAssembly::FALLTHROUGH_RETURN_I32_S", "WebAssembly::FALLTHROUGH_RETURN_I64", "WebAssembly::FALLTHROUGH_RETURN_I64_S", "WebAssembly::FALLTHROUGH_RETURN_F32", "WebAssembly::FALLTHROUGH_RETURN_F32_S", "WebAssembly::FALLTHROUGH_RETURN_F64", "WebAssembly::FALLTHROUGH_RETURN_F64_S", "WebAssembly::FALLTHROUGH_RETURN_v16i8", "WebAssembly::FALLTHROUGH_RETURN_v16i8_S", "WebAssembly::FALLTHROUGH_RETURN_v8i16", "WebAssembly::FALLTHROUGH_RETURN_v8i16_S", "WebAssembly::FALLTHROUGH_RETURN_v4i32", "WebAssembly::FALLTHROUGH_RETURN_v4i32_S", "WebAssembly::FALLTHROUGH_RETURN_v2i64", "WebAssembly::FALLTHROUGH_RETURN_v2i64_S", "WebAssembly::FALLTHROUGH_RETURN_v4f32", "WebAssembly::FALLTHROUGH_RETURN_v4f32_S", "WebAssembly::FALLTHROUGH_RETURN_v2f64", "WebAssembly::FALLTHROUGH_RETURN_v2f64_S", "\"fallthrough-return-value\"", "WebAssembly::FALLTHROUGH_RETURN_VOID", "WebAssembly::FALLTHROUGH_RETURN_VOID_S", "\"fallthrough-return-void\"", "WebAssembly::COMPILER_FENCE", "WebAssembly::EXTRACT_EXCEPTION_I32", "WebAssembly::EXTRACT_EXCEPTION_I32_S", "WebAssembly" ]
WebAssemblyAsmPrinter11
EmitInstruction
WebAssembly
Virtual ISA
LLVM
17,839
357
1
[]
[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "MipsTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'d'", ":", "case", "'y'", ":", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "Mips", "::", "CPURegsRegisterClass", ")", ";", "assert", "(", "VT", "==", "MVT", "::", "i64", "&&", "\"Unexpected type.\"", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "Mips", "::", "CPU64RegsRegisterClass", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "Mips", "::", "FGR32RegisterClass", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "f64", ")", "&&", "(", "!", "Subtarget", "->", "isSingleFloat", "(", ")", ")", ")", "{", "if", "(", "Subtarget", "->", "isFP64bit", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "Mips", "::", "FGR64RegisterClass", ")", ";", "else", "return", "std", "::", "make_pair", "(", "0U", ",", "Mips", "::", "AFGR64RegisterClass", ")", ";", "}", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]
[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]
[ "Mips", "Mips", "1", "0", "MVT::i32", "0U", "Mips::CPURegsRegisterClass", "MVT::i64", "\"Unexpected type.\"", "0U", "Mips::CPU64RegsRegisterClass", "MVT::f32", "0U", "Mips::FGR32RegisterClass", "MVT::f64", "0U", "Mips::FGR64RegisterClass", "0U", "Mips::AFGR64RegisterClass" ]
MipsISelLowering (2)3
getRegForInlineAsmConstraint
Mips
CPU
LLVM
17,840
187
1
[]
[ "<s>", "static", "void", "sh_add_function_attribute", "(", "const", "char", "*", "attr", ")", "{", "tree", "id", "=", "get_identifier", "(", "attr", ")", ";", "if", "(", "current_function_decl", ")", "decl_attributes", "(", "&", "current_function_decl", ",", "tree_cons", "(", "id", ",", "NULL_TREE", ",", "NULL_TREE", ")", ",", "0", ")", ";", "else", "{", "*", "sh_deferred_function_attributes_tail", "=", "tree_cons", "(", "id", ",", "NULL_TREE", ",", "*", "sh_deferred_function_attributes_tail", ")", ";", "sh_deferred_function_attributes_tail", "=", "&", "TREE_CHAIN", "(", "*", "sh_deferred_function_attributes_tail", ")", ";", "}", "}", "</s>" ]
[ "Add", "ATTR", "to", "the", "attributes", "of", "the", "current", "function", ".", "If", "there", "is", "no", "such", "function", ",", "save", "it", "to", "be", "added", "to", "the", "attributes", "of", "the", "next", "function", "." ]
[ "sh", "0" ]
sh-c
sh_add_function_attribute
sh
CPU
GCC
17,841
65
1
[]
[ "<s>", "void", "AArch64PassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "if", "(", "EnableSVEIntrinsicOpts", "&&", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", ")", "addPass", "(", "createSVEIntrinsicOptsPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", "SimplifyCFGOptions", "(", ")", ".", "forwardSwitchCondToPhi", "(", "true", ")", ".", "convertSwitchRangeToICmp", "(", "true", ")", ".", "convertSwitchToLookupTable", "(", "true", ")", ".", "needCanonicalLoops", "(", "false", ")", ".", "hoistCommonInsts", "(", "true", ")", ".", "sinkCommonInsts", "(", "true", ")", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableLoopDataPrefetch", ")", "addPass", "(", "createLoopDataPrefetchPass", "(", ")", ")", ";", "if", "(", "EnableFalkorHWPFFix", ")", "addPass", "(", "createFalkorMarkStridedAccessesPass", "(", ")", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "addPass", "(", "createAArch64StackTaggingPass", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createInterleavedLoadCombinePass", "(", ")", ")", ";", "addPass", "(", "createInterleavedAccessPass", "(", ")", ")", ";", "}", "if", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", "&&", "EnableGEPOpt", ")", "{", "addPass", "(", "createSeparateConstOffsetFromGEPPass", "(", "true", ")", ")", ";", "addPass", "(", "createEarlyCSEPass", "(", ")", ")", ";", "addPass", "(", "createLICMPass", "(", ")", ")", ";", "}", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "addPass", "(", "createCFGuardCheckPass", "(", ")", ")", ";", "if", "(", "TM", "->", "Options", ".", "JMCInstrument", ")", "addPass", "(", "createJMCInstrumenterPass", "(", ")", ")", ";", "}", "</s>" ]
[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]
[ "AArch64", "AArch64", "AArch64" ]
AArch64TargetMachine32
addIRPasses
AArch64
CPU
LLVM
17,842
248
1
[]
[ "<s>", "void", "TPCLatencyResolver", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineLoopInfo", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]
[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]
[ "TPC", "TPC" ]
TPCLatencyResolver
getAnalysisUsage
TPC
Virtual ISA
LLVM
17,843
34
1
[]
[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "LiveIntervals", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "VirtRegMap", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LiveRegMatrix", ">", "(", ")", ";", "AU", ".", "setPreservesAll", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]
[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]
[ "AMDGPU" ]
GCNNSAReassign
getAnalysisUsage
AMDGPU
GPU
LLVM
17,844
51
1
[]
[ "<s>", "bool", "HexagonEarlyIfConversion", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "auto", "&", "ST", "=", "MF", ".", "getSubtarget", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MFN", "=", "&", "MF", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MBPI", "=", "EnableHexagonBP", "?", "&", "getAnalysis", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ":", "nullptr", ";", "Deleted", ".", "clear", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineLoopInfo", "::", "iterator", "I", "=", "MLI", "->", "begin", "(", ")", ",", "E", "=", "MLI", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Changed", "|=", "visitLoop", "(", "*", "I", ")", ";", "Changed", "|=", "visitLoop", "(", "0", ")", ";", "return", "Changed", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "Hexagon", "Hexagon", "Hexagon", "0" ]
HexagonEarlyIfConv (2)
runOnMachineFunction
Hexagon
DSP
LLVM
17,845
142
1
[]
[ "<s>", "void", "MSP430AsmPrinter", "::", "PrintSymbolOperand", "(", "const", "MachineOperand", "&", "MO", ",", "raw_ostream", "&", "O", ")", "{", "uint64_t", "Offset", "=", "MO", ".", "getOffset", "(", ")", ";", "if", "(", "Offset", ")", "O", "<<", "'('", "<<", "Offset", "<<", "'+'", ";", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", "->", "print", "(", "O", ",", "MAI", ")", ";", "if", "(", "Offset", ")", "O", "<<", "')'", ";", "}", "</s>" ]
[ "Print", "the", "MachineOperand", "as", "a", "symbol", "." ]
[ "MSP430", "MSP430" ]
MSP430AsmPrinter (2)1
PrintSymbolOperand
MSP430
MPU
LLVM
17,846
61
1
[]
[ "<s>", "bool", "isUnconditionalBranch", "(", "const", "MCInst", "&", "Inst", ")", "const", "override", "{", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "Bcc", "&&", "Inst", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "ARMCC", "::", "AL", ")", "return", "true", ";", "return", "MCInstrAnalysis", "::", "isUnconditionalBranch", "(", "Inst", ")", ";", "}", "</s>" ]
[ "Return", "true", "if", "this", "is", "a", "branch", "which", "always", "transfers", "control", "flow", "to", "some", "other", "block", "." ]
[ "ARM", "ARM::Bcc", "1", "ARMCC::AL" ]
ARMMCTargetDesc (2)
isUnconditionalBranch
ARM
CPU
LLVM
17,847
50
1
[]
[ "<s>", "void", "AArch64RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "AArch64FrameLowering", "*", "TFI", "=", "static_cast", "<", "const", "AArch64FrameLowering", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "FrameReg", ";", "int", "Offset", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", "||", "MI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "STACKMAP", "||", "MI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "PATCHPOINT", ")", "{", "Offset", "=", "TFI", "->", "resolveFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ",", "true", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "Offset", "=", "TFI", "->", "resolveFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ")", ";", "if", "(", "rewriteAArch64FrameIndex", "(", "MI", ",", "FIOperandNum", ",", "FrameReg", ",", "Offset", ",", "TII", ")", ")", "return", ";", "assert", "(", "(", "!", "RS", "||", "!", "RS", "->", "isScavengingFrameIndex", "(", "FrameIndex", ")", ")", "&&", "\"Emergency spill slot is out of reach\"", ")", ";", "unsigned", "ScratchReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "AArch64", "::", "GPR64RegClass", ")", ";", "emitFrameOffset", "(", "MBB", ",", "II", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "ScratchReg", ",", "FrameReg", ",", "Offset", ",", "TII", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "ScratchReg", ",", "false", ",", "false", ",", "true", ")", ";", "}", "</s>" ]
[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]
[ "AArch64", "AArch64", "0", "\"Unexpected\"", "AArch64", "AArch64", "1", "1", "AArch64", "\"Emergency spill slot is out of reach\"", "AArch64::GPR64RegClass" ]
AArch64RegisterInfo1
eliminateFrameIndex
AArch64
CPU
LLVM
17,848
298
1
[]
[ "<s>", "void", "buildLoad", "(", "unsigned", "Val", ",", "const", "CCValAssign", "&", "VA", ")", "{", "MachineMemOperand", "*", "MMO", ";", "unsigned", "Addr", "=", "getStackAddress", "(", "VA", ",", "MMO", ")", ";", "MIRBuilder", ".", "buildLoad", "(", "Val", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]
[ "Build", "and", "insert", "a", "G_LOAD", "instruction", ",", "while", "constructing", "the", "MachineMemOperand", "." ]
[ "Mips" ]
MipsCallLowering1
buildLoad
Mips
CPU
LLVM
17,849
39
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", "::", "STATEPOINT", ":", "MI", ".", "addOperand", "(", "*", "MI", ".", "getMF", "(", ")", ",", "MachineOperand", "::", "CreateReg", "(", "AArch64", "::", "LR", ",", "true", ",", "true", ",", "false", ",", "true", ",", "false", ",", "true", ")", ")", ";", "LLVM_FALLTHROUGH", ";", "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::LR", "AArch64::CATCHRET" ]
AArch64ISelLowering69
EmitInstrWithCustomInserter
AArch64
CPU
LLVM
17,850
124
1
[]
[ "<s>", "void", "Nios2PassConfig", "::", "addIRPasses", "(", ")", "{", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]
[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]
[ "Nios2", "Nios2" ]
Nios2TargetMachine1
addIRPasses
Nios2
MPU
LLVM
17,851
14
1
[]
[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "assert", "(", "Kind", "==", "k_Register", "&&", "\"Invalid access!\"", ")", ";", "return", "Reg", ".", "Num", ";", "}", "</s>" ]
[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]
[ "LC2200", "\"Invalid access!\"" ]
LC2200AsmParser
getReg
LC2200
CPU
LLVM
17,852
22
1
[]
[ "<s>", "int", "HexagonInstrInfo", "::", "getOperandLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MachineInstr", "&", "DefMI", ",", "unsigned", "DefIdx", ",", "const", "MachineInstr", "&", "UseMI", ",", "unsigned", "UseIdx", ")", "const", "{", "const", "HexagonRegisterInfo", "&", "HRI", "=", "*", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "MachineOperand", "&", "DefMO", "=", "DefMI", ".", "getOperand", "(", "DefIdx", ")", ";", "if", "(", "DefMO", ".", "isReg", "(", ")", "&&", "HRI", ".", "isPhysicalRegister", "(", "DefMO", ".", "getReg", "(", ")", ")", ")", "{", "if", "(", "DefMO", ".", "isImplicit", "(", ")", ")", "{", "for", "(", "MCSuperRegIterator", "SR", "(", "DefMO", ".", "getReg", "(", ")", ",", "&", "HRI", ")", ";", "SR", ".", "isValid", "(", ")", ";", "++", "SR", ")", "{", "int", "Idx", "=", "DefMI", ".", "findRegisterDefOperandIdx", "(", "*", "SR", ",", "false", ",", "false", ",", "&", "HRI", ")", ";", "if", "(", "Idx", "!=", "-", "1", ")", "{", "DefIdx", "=", "Idx", ";", "break", ";", "}", "}", "}", "const", "MachineOperand", "&", "UseMO", "=", "UseMI", ".", "getOperand", "(", "UseIdx", ")", ";", "if", "(", "UseMO", ".", "isImplicit", "(", ")", ")", "{", "for", "(", "MCSuperRegIterator", "SR", "(", "UseMO", ".", "getReg", "(", ")", ",", "&", "HRI", ")", ";", "SR", ".", "isValid", "(", ")", ";", "++", "SR", ")", "{", "int", "Idx", "=", "UseMI", ".", "findRegisterUseOperandIdx", "(", "*", "SR", ",", "false", ",", "&", "HRI", ")", ";", "if", "(", "Idx", "!=", "-", "1", ")", "{", "UseIdx", "=", "Idx", ";", "break", ";", "}", "}", "}", "}", "int", "Latency", "=", "TargetInstrInfo", "::", "getOperandLatency", "(", "ItinData", ",", "DefMI", ",", "DefIdx", ",", "UseMI", ",", "UseIdx", ")", ";", "if", "(", "!", "Latency", ")", "Latency", "=", "1", ";", "return", "Latency", ";", "}", "</s>" ]
[ "Compute", "and", "return", "the", "use", "operand", "latency", "of", "a", "given", "pair", "of", "def", "and", "use", "." ]
[ "Hexagon", "Hexagon", "Hexagon", "1", "1", "1" ]
HexagonInstrInfo (2)2
getOperandLatency
Hexagon
DSP
LLVM
17,853
252
1
[]
[ "<s>", "bool", "RISCVInsertVSETVLI", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "RISCVSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "hasVInstructions", "(", ")", ")", "return", "false", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "assert", "(", "BlockInfo", ".", "empty", "(", ")", "&&", "\"Expect empty block infos\"", ")", ";", "BlockInfo", ".", "resize", "(", "MF", ".", "getNumBlockIDs", "(", ")", ")", ";", "bool", "HaveVectorOp", "=", "false", ";", "for", "(", "const", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "HaveVectorOp", "|=", "computeVLVTYPEChanges", "(", "MBB", ")", ";", "if", "(", "HaveVectorOp", ")", "{", "for", "(", "const", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "WorkList", ".", "push", "(", "&", "MBB", ")", ";", "BlockInfo", "[", "MBB", ".", "getNumber", "(", ")", "]", ".", "InQueue", "=", "true", ";", "}", "while", "(", "!", "WorkList", ".", "empty", "(", ")", ")", "{", "const", "MachineBasicBlock", "&", "MBB", "=", "*", "WorkList", ".", "front", "(", ")", ";", "WorkList", ".", "pop", "(", ")", ";", "computeIncomingVLVTYPE", "(", "MBB", ")", ";", "}", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "emitVSETVLIs", "(", "MBB", ")", ";", "}", "BlockInfo", ".", "clear", "(", ")", ";", "return", "HaveVectorOp", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "RISCV", "RISCV", "RISCV", "RISCV", "\"Expect empty block infos\"" ]
RISCVInsertVSETVLI1
runOnMachineFunction
RISCV
CPU
LLVM
17,854
191
1
[]
[ "<s>", "static", "tree", "ix86_canonical_va_list_type", "(", "tree", "type", ")", "{", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "lookup_attribute", "(", "\"ms_abi va_list\"", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", ")", "return", "ms_va_list_type_node", ";", "if", "(", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", "&&", "integer_zerop", "(", "array_type_nelts", "(", "type", ")", ")", ")", "||", "POINTER_TYPE_P", "(", "type", ")", ")", "{", "tree", "elem_type", "=", "TREE_TYPE", "(", "type", ")", ";", "if", "(", "TREE_CODE", "(", "elem_type", ")", "==", "RECORD_TYPE", "&&", "lookup_attribute", "(", "\"sysv_abi va_list\"", ",", "TYPE_ATTRIBUTES", "(", "elem_type", ")", ")", ")", "return", "sysv_va_list_type_node", ";", "}", "return", "NULL_TREE", ";", "}", "return", "std_canonical_va_list_type", "(", "type", ")", ";", "}", "</s>" ]
[ "Returns", "the", "canonical", "va_list", "type", "specified", "by", "TYPE", ".", "If", "there", "is", "no", "valid", "TYPE", "provided", ",", "it", "return", "NULL_TREE", "." ]
[ "i386", "\"ms_abi va_list\"", "\"sysv_abi va_list\"" ]
i386
ix86_canonical_va_list_type
i386
CPU
GCC
17,855
95
1
[]
[ "<s>", "bool", "ARMBaseInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "if", "(", "!", "WidenVMOVS", "||", "!", "MI", "->", "isCopy", "(", ")", ")", "return", "false", ";", "unsigned", "DstRegS", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "SrcRegS", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "ARM", "::", "SPRRegClass", ".", "contains", "(", "DstRegS", ",", "SrcRegS", ")", ")", "return", "false", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "unsigned", "DstRegD", "=", "TRI", "->", "getMatchingSuperReg", "(", "DstRegS", ",", "ARM", "::", "ssub_0", ",", "&", "ARM", "::", "DPRRegClass", ")", ";", "unsigned", "SrcRegD", "=", "TRI", "->", "getMatchingSuperReg", "(", "SrcRegS", ",", "ARM", "::", "ssub_0", ",", "&", "ARM", "::", "DPRRegClass", ")", ";", "if", "(", "!", "DstRegD", "||", "!", "SrcRegD", ")", "return", "false", ";", "if", "(", "!", "MI", "->", "definesRegister", "(", "DstRegD", ",", "TRI", ")", "||", "MI", "->", "readsRegister", "(", "DstRegD", ",", "TRI", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ")", "return", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"widening: \"", "<<", "*", "MI", ")", ";", "int", "ImpDefIdx", "=", "MI", "->", "findRegisterDefOperandIdx", "(", "DstRegD", ")", ";", "if", "(", "ImpDefIdx", "!=", "-", "1", ")", "MI", "->", "RemoveOperand", "(", "ImpDefIdx", ")", ";", "MI", "->", "setDesc", "(", "get", "(", "ARM", "::", "VMOVD", ")", ")", ";", "MI", "->", "getOperand", "(", "0", ")", ".", "setReg", "(", "DstRegD", ")", ";", "MI", "->", "getOperand", "(", "1", ")", ".", "setReg", "(", "SrcRegD", ")", ";", "AddDefaultPred", "(", "MachineInstrBuilder", "(", "MI", ")", ")", ";", "MI", "->", "getOperand", "(", "1", ")", ".", "setIsUndef", "(", ")", ";", "MachineInstrBuilder", "(", "MI", ")", ".", "addReg", "(", "SrcRegS", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isKill", "(", ")", ")", "{", "MI", "->", "getOperand", "(", "1", ")", ".", "setIsKill", "(", "false", ")", ";", "MI", "->", "addRegisterKilled", "(", "SrcRegS", ",", "TRI", ",", "true", ")", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"replaced by: \"", "<<", "*", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]
[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]
[ "ARM", "ARM", "0", "1", "ARM::SPRRegClass", "ARM::ssub_0", "ARM::DPRRegClass", "ARM::ssub_0", "ARM::DPRRegClass", "0", "\"widening: \"", "1", "ARM::VMOVD", "0", "1", "1", "1", "1", "\"replaced by: \"" ]
ARMBaseInstrInfo (2)4
expandPostRAPseudo
ARM
CPU
LLVM
17,856
330
1
[]
[ "<s>", "const", "AArch64Subtarget", "*", "AArch64TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "AArch64Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "isLittle", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]
[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]
[ "AArch64", "AArch64", "AArch64", "\"target-cpu\"", "\"target-features\"", "AArch64" ]
AArch64TargetMachine14
getSubtargetImpl
AArch64
CPU
LLVM
17,857
140
1
[]
[ "<s>", "static", "void", "replace_mov_pcrel_step1", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "unspec", ";", "rtx", "opnds", "[", "2", "]", ";", "rtx_insn", "*", "new_insns", ";", "gcc_assert", "(", "GET_CODE", "(", "pattern", ")", "==", "SET", ")", ";", "opnds", "[", "0", "]", "=", "SET_DEST", "(", "pattern", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_SRC", "(", "pattern", ")", ")", "==", "CONST", ")", ";", "unspec", "=", "XEXP", "(", "SET_SRC", "(", "pattern", ")", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "unspec", ")", "==", "UNSPEC", ")", ";", "gcc_assert", "(", "XINT", "(", "unspec", ",", "1", ")", "==", "UNSPEC_HW1_LAST_PCREL", ")", ";", "opnds", "[", "1", "]", "=", "XVECEXP", "(", "unspec", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "opnds", "[", "1", "]", ")", "!=", "SYMBOL_REF", ")", "return", ";", "start_sequence", "(", ")", ";", "if", "(", "flag_pic", "!=", "1", ")", "{", "if", "(", "TARGET_32BIT", ")", "emit_insn", "(", "gen_mov_got32_step1_32bit", "(", "opnds", "[", "0", "]", ",", "opnds", "[", "1", "]", ")", ")", ";", "else", "emit_insn", "(", "gen_mov_got32_step1", "(", "opnds", "[", "0", "]", ",", "opnds", "[", "1", "]", ")", ")", ";", "}", "new_insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "replace_insns", "(", "insn", ",", "new_insns", ")", ";", "}", "</s>" ]
[ "Do", "the", "first", "replacement", "step", "in", "tilegx_fixup_pcrel_references", "." ]
[ "tilegx", "2", "0", "0", "1", "1", "0", "0", "1", "1", "0", "1", "0", "1" ]
tilegx
replace_mov_pcrel_step1
tilegx
VLIW
GCC
17,858
192
1
[]
[ "<s>", "bool", "function_checker", "::", "require_immediate_enum", "(", "unsigned", "int", "rel_argno", ",", "tree", "type", ")", "{", "unsigned", "int", "argno", "=", "m_base_arg", "+", "rel_argno", ";", "if", "(", "!", "argument_exists_p", "(", "argno", ")", ")", "return", "true", ";", "HOST_WIDE_INT", "actual", ";", "if", "(", "!", "require_immediate", "(", "argno", ",", "actual", ")", ")", "return", "false", ";", "for", "(", "tree", "entry", "=", "TYPE_VALUES", "(", "type", ")", ";", "entry", ";", "entry", "=", "TREE_CHAIN", "(", "entry", ")", ")", "{", "tree", "value", "=", "TREE_VALUE", "(", "entry", ")", ";", "if", "(", "TREE_CODE", "(", "value", ")", "==", "CONST_DECL", ")", "value", "=", "DECL_INITIAL", "(", "value", ")", ";", "if", "(", "wi", "::", "to_widest", "(", "value", ")", "==", "actual", ")", "return", "true", ";", "}", "report_not_enum", "(", "location", ",", "fndecl", ",", "argno", ",", "actual", ",", "type", ")", ";", "return", "false", ";", "}", "</s>" ]
[ "Check", "that", "argument", "REL_ARGNO", "is", "an", "integer", "constant", "expression", "that", "has", "a", "valid", "value", "for", "enumeration", "type", "TYPE", ".", "REL_ARGNO", "counts", "from", "the", "end", "of", "the", "predication", "arguments", "." ]
[ "aarch64" ]
aarch64-sve-builtins
require_immediate_enum
aarch64
CPU
GCC
17,859
124
1
[]
[ "<s>", "TargetLoweringBase", "::", "LegalizeTypeAction", "HexagonTargetLowering", "::", "getPreferredVectorAction", "(", "MVT", "VT", ")", "const", "{", "unsigned", "VecLen", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "MVT", "ElemTy", "=", "VT", ".", "getVectorElementType", "(", ")", ";", "if", "(", "VecLen", "==", "1", "||", "VT", ".", "isScalableVector", "(", ")", ")", "return", "TargetLoweringBase", "::", "TypeScalarizeVector", ";", "if", "(", "Subtarget", ".", "useHVXOps", "(", ")", ")", "{", "unsigned", "Action", "=", "getPreferredHvxVectorAction", "(", "VT", ")", ";", "if", "(", "Action", "!=", "~", "0u", ")", "return", "static_cast", "<", "TargetLoweringBase", "::", "LegalizeTypeAction", ">", "(", "Action", ")", ";", "}", "if", "(", "ElemTy", "==", "MVT", "::", "i1", ")", "return", "TargetLoweringBase", "::", "TypeWidenVector", ";", "return", "TargetLoweringBase", "::", "TypeSplitVector", ";", "}", "</s>" ]
[ "Customize", "the", "preferred", "legalization", "strategy", "for", "certain", "types", "." ]
[ "Hexagon", "Hexagon", "1", "0u", "MVT::i1" ]
HexagonISelLowering100
getPreferredVectorAction
Hexagon
DSP
LLVM
17,860
102
1
[]
[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "AArch64TargetLowering", "::", "shouldExpandAtomicCmpXchgInIR", "(", "AtomicCmpXchgInst", "*", "AI", ")", "const", "{", "if", "(", "Subtarget", "->", "hasLSE", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", "==", "0", ")", "return", "AtomicExpansionKind", "::", "None", ";", "return", "AtomicExpansionKind", "::", "LLSC", ";", "}", "</s>" ]
[ "Returns", "how", "the", "given", "atomic", "cmpxchg", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "." ]
[ "AArch64", "AArch64", "0" ]
AArch64ISelLowering (2)3
shouldExpandAtomicCmpXchgInIR
AArch64
CPU
LLVM
17,861
49
1
[]
[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "LiveIntervals", ">", "(", ")", ";", "AU", ".", "addPreservedID", "(", "LiveVariablesID", ")", ";", "AU", ".", "addRequired", "<", "MachineLoopInfo", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineLoopInfo", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "AAResultsWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]
[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]
[ "TVM" ]
TVMMoveMaterializable
getAnalysisUsage
TVM
Virtual ISA
LLVM
17,862
70
1
[]
[ "<s>", "const", "int", "*", "SIRegisterInfo", "::", "getRegUnitPressureSets", "(", "unsigned", "RegUnit", ")", "const", "{", "static", "const", "int", "Empty", "[", "]", "=", "{", "-", "1", "}", ";", "if", "(", "hasRegUnit", "(", "AMDGPU", "::", "M0", ",", "RegUnit", ")", ")", "return", "Empty", ";", "return", "AMDGPUGenRegisterInfo", "::", "getRegUnitPressureSets", "(", "RegUnit", ")", ";", "}", "</s>" ]
[ "Get", "the", "dimensions", "of", "register", "pressure", "impacted", "by", "this", "register", "unit", "." ]
[ "AMDGPU", "SI", "1", "AMDGPU::M0", "AMDGPU" ]
SIRegisterInfo114
getRegUnitPressureSets
AMDGPU
GPU
LLVM
17,863
47
1
[]
[ "<s>", "bool", "isReg", "(", ")", "const", "override", "{", "if", "(", "isGPRAsmReg", "(", ")", "&&", "RegIdx", ".", "Index", "==", "0", ")", "return", "true", ";", "return", "Kind", "==", "k_PhysRegister", ";", "}", "</s>" ]
[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]
[ "Mips", "0" ]
MipsAsmParser
isReg
Mips
CPU
LLVM
17,864
28
1
[]
[ "<s>", "unsigned", "LEGRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "LEG", "::", "SP", ";", "}", "</s>" ]
[ "Debug", "information", "queries", "." ]
[ "LEG", "LEG", "LEG::SP" ]
LEGRegisterInfo
getFrameRegister
LEG
CPU
LLVM
17,865
18
1
[]
[ "<s>", "MCELFStreamer", "&", "Comet2TargetELFStreamer", "::", "getStreamer", "(", ")", "{", "return", "static_cast", "<", "MCELFStreamer", "&", ">", "(", "Streamer", ")", ";", "}", "</s>" ]
[ "Return", "the", "output", "streamer", "for", "the", "assembler", "." ]
[ "Comet2", "Comet2" ]
Comet2ELFStreamer
getStreamer
Comet2
CPU
LLVM
17,866
19
1
[]
[ "<s>", "bool", "BlackfinFrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]
[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]
[ "Blackfin" ]
BlackfinFrameLowering1
hasReservedCallFrame
Blackfin
DSP
LLVM
17,867
16
1
[]
[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "}", "</s>" ]
[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]
[ "AMDGPU" ]
AMDGPUAsmParser61
print
AMDGPU
GPU
LLVM
17,868
11
1
[]
[ "<s>", "void", "ix86_expand_rounddf_32", "(", "rtx", "operand0", ",", "rtx", "operand1", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operand0", ")", ";", "rtx", "xa", ",", "xa2", ",", "dxa", ",", "TWO52", ",", "tmp", ",", "half", ",", "mhalf", ",", "one", ",", "res", ",", "mask", ";", "rtx_code_label", "*", "label", ";", "TWO52", "=", "ix86_gen_TWO52", "(", "mode", ")", ";", "res", "=", "copy_to_reg", "(", "operand1", ")", ";", "xa", "=", "ix86_expand_sse_fabs", "(", "res", ",", "&", "mask", ")", ";", "label", "=", "ix86_expand_sse_compare_and_jump", "(", "UNLE", ",", "TWO52", ",", "xa", ",", "false", ")", ";", "xa2", "=", "expand_simple_binop", "(", "mode", ",", "PLUS", ",", "xa", ",", "TWO52", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "xa2", "=", "expand_simple_binop", "(", "mode", ",", "MINUS", ",", "xa2", ",", "TWO52", ",", "xa2", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "dxa", "=", "expand_simple_binop", "(", "mode", ",", "MINUS", ",", "xa2", ",", "xa", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "half", "=", "force_reg", "(", "mode", ",", "const_double_from_real_value", "(", "dconsthalf", ",", "mode", ")", ")", ";", "one", "=", "expand_simple_binop", "(", "mode", ",", "PLUS", ",", "half", ",", "half", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "mhalf", "=", "expand_simple_binop", "(", "mode", ",", "MINUS", ",", "half", ",", "one", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "tmp", "=", "ix86_expand_sse_compare_mask", "(", "UNGT", ",", "dxa", ",", "half", ",", "false", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmp", ",", "gen_rtx_AND", "(", "mode", ",", "tmp", ",", "one", ")", ")", ")", ";", "xa2", "=", "expand_simple_binop", "(", "mode", ",", "MINUS", ",", "xa2", ",", "tmp", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "tmp", "=", "ix86_expand_sse_compare_mask", "(", "UNGE", ",", "mhalf", ",", "dxa", ",", "false", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmp", ",", "gen_rtx_AND", "(", "mode", ",", "tmp", ",", "one", ")", ")", ")", ";", "xa2", "=", "expand_simple_binop", "(", "mode", ",", "PLUS", ",", "xa2", ",", "tmp", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "ix86_sse_copysign_to_positive", "(", "res", ",", "xa2", ",", "res", ",", "mask", ")", ";", "emit_label", "(", "label", ")", ";", "LABEL_NUSES", "(", "label", ")", "=", "1", ";", "emit_move_insn", "(", "operand0", ",", "res", ")", ";", "}", "</s>" ]
[ "Expand", "SSE", "sequence", "for", "computing", "round", "from", "OPERAND1", "storing", "into", "OPERAND0", ".", "Sequence", "that", "works", "without", "relying", "on", "DImode", "truncation", "via", "cvttsd2siq", "that", "is", "only", "available", "on", "64bit", "targets", "." ]
[ "i386", "0", "0", "0", "0", "0", "0", "0", "1" ]
i386-expand
ix86_expand_rounddf_32
i386
CPU
GCC
17,869
318
1
[]
[ "<s>", "Instruction", "*", "VETargetLowering", "::", "emitLeadingFence", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Instruction", "*", "Inst", ",", "AtomicOrdering", "Ord", ")", "const", "{", "switch", "(", "Ord", ")", "{", "case", "AtomicOrdering", "::", "NotAtomic", ":", "case", "AtomicOrdering", "::", "Unordered", ":", "llvm_unreachable", "(", "\"Invalid fence: unordered/non-atomic\"", ")", ";", "case", "AtomicOrdering", "::", "Monotonic", ":", "case", "AtomicOrdering", "::", "Acquire", ":", "return", "nullptr", ";", "case", "AtomicOrdering", "::", "Release", ":", "case", "AtomicOrdering", "::", "AcquireRelease", ":", "return", "Builder", ".", "CreateFence", "(", "AtomicOrdering", "::", "Release", ")", ";", "case", "AtomicOrdering", "::", "SequentiallyConsistent", ":", "if", "(", "!", "Inst", "->", "hasAtomicStore", "(", ")", ")", "return", "nullptr", ";", "return", "Builder", ".", "CreateFence", "(", "AtomicOrdering", "::", "SequentiallyConsistent", ")", ";", "}", "llvm_unreachable", "(", "\"Unknown fence ordering in emitLeadingFence\"", ")", ";", "}", "</s>" ]
[ "Custom", "Lower", "{", "." ]
[ "VE", "VE", "\"Invalid fence: unordered/non-atomic\"", "\"Unknown fence ordering in emitLeadingFence\"" ]
VEISelLowering1
emitLeadingFence
VE
CPU
LLVM
17,870
108
1
[]
[ "<s>", "static", "bool", "isAllOnes", "(", "SDValue", "V", ")", "{", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "V", ")", ";", "return", "C", "&&", "C", "->", "isAllOnesValue", "(", ")", ";", "}", "</s>" ]
[ "Returns", "true", "if", "value", "is", "all", "one", "bits", "." ]
[ "X86" ]
X86ISelLowering (2)
isAllOnes
X86
CPU
LLVM
17,871
30
1
[]
[ "<s>", "void", "ARMPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "Options", ".", "ThreadModel", "==", "ThreadModel", "::", "Single", ")", "addPass", "(", "createLowerAtomicPass", "(", ")", ")", ";", "else", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", "1", ",", "false", ",", "false", ",", "true", ",", "true", ",", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "const", "auto", "&", "ST", "=", "this", "->", "TM", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ";", "return", "ST", ".", "hasAnyDataBarrier", "(", ")", "&&", "!", "ST", ".", "isThumb1Only", "(", ")", ";", "}", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", ")", "addPass", "(", "createARMParallelDSPPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createInterleavedAccessPass", "(", ")", ")", ";", "}", "</s>" ]
[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]
[ "ARM", "ARM", "1", "ARM", "ARM" ]
ARMTargetMachine101
addIRPasses
ARM
CPU
LLVM
17,872
150
1
[]
[ "<s>", "MachineBasicBlock", "::", "iterator", "XCoreInstrInfo", "::", "loadImmediate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "Reg", ",", "uint64_t", "Value", ")", "const", "{", "DebugLoc", "dl", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "MI", "->", "isDebugValue", "(", ")", ")", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "isImmMskBitp", "(", "Value", ")", ")", "{", "int", "N", "=", "Log2_32", "(", "Value", ")", "+", "1", ";", "return", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "XCore", "::", "MKMSK_rus", ")", ",", "Reg", ")", ".", "addImm", "(", "N", ")", ";", "}", "if", "(", "isImmU16", "(", "Value", ")", ")", "{", "int", "Opcode", "=", "isImmU6", "(", "Value", ")", "?", "XCore", "::", "LDC_ru6", ":", "XCore", "::", "LDC_lru6", ";", "return", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "Opcode", ")", ",", "Reg", ")", ".", "addImm", "(", "Value", ")", ";", "}", "MachineConstantPool", "*", "ConstantPool", "=", "MBB", ".", "getParent", "(", ")", "->", "getConstantPool", "(", ")", ";", "const", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ",", "Value", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "4", ")", ";", "return", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "XCore", "::", "LDWCP_lru6", ")", ",", "Reg", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ";", "}", "</s>" ]
[ "Emit", "a", "series", "of", "instructions", "to", "load", "an", "immediate", "." ]
[ "XCore", "XCore", "1", "XCore::MKMSK_rus", "XCore::LDC_ru6", "XCore::LDC_lru6", "4", "XCore::LDWCP_lru6" ]
XCoreInstrInfo
loadImmediate
XCore
MPU
LLVM
17,873
224
1
[]
[ "<s>", "bool", "ARMLegalizerInfo", "::", "legalizeCustom", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "MIRBuilder", ")", "const", "{", "using", "namespace", "TargetOpcode", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "G_SDIV", ":", "case", "G_UDIV", ":", "{", "LLT", "Ty", "=", "MRI", ".", "getType", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ";", "if", "(", "Ty", "!=", "LLT", "::", "scalar", "(", "16", ")", "&&", "Ty", "!=", "LLT", "::", "scalar", "(", "8", ")", ")", "return", "false", ";", "LegalizerHelper", "Helper", "(", "MIRBuilder", ".", "getMF", "(", ")", ")", ";", "MachineInstr", "*", "NewMI", "=", "nullptr", ";", "Helper", ".", "MIRBuilder", ".", "recordInsertions", "(", "[", "&", "]", "(", "MachineInstr", "*", "MI", ")", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "G_SDIV", "||", "MI", "->", "getOpcode", "(", ")", "==", "G_UDIV", ")", "NewMI", "=", "MI", ";", "}", ")", ";", "auto", "Result", "=", "Helper", ".", "widenScalar", "(", "MI", ",", "0", ",", "LLT", "::", "scalar", "(", "32", ")", ")", ";", "Helper", ".", "MIRBuilder", ".", "stopRecordingInsertions", "(", ")", ";", "if", "(", "Result", "==", "LegalizerHelper", "::", "UnableToLegalize", ")", "{", "return", "false", ";", "}", "assert", "(", "NewMI", "&&", "\"Couldn't find widened instruction\"", ")", ";", "assert", "(", "(", "NewMI", "->", "getOpcode", "(", ")", "==", "G_SDIV", "||", "NewMI", "->", "getOpcode", "(", ")", "==", "G_UDIV", ")", "&&", "\"Unexpected widened instruction\"", ")", ";", "assert", "(", "MRI", ".", "getType", "(", "NewMI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "getSizeInBits", "(", ")", "==", "32", "&&", "\"Unexpected type for the widened instruction\"", ")", ";", "Result", "=", "Helper", ".", "legalizeInstrStep", "(", "*", "NewMI", ")", ";", "if", "(", "Result", "==", "LegalizerHelper", "::", "UnableToLegalize", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}", "}", "}", "</s>" ]
[ "Called", "for", "instructions", "with", "the", "Custom", "LegalizationAction", "." ]
[ "ARM", "ARM", "0", "16", "8", "0", "32", "\"Couldn't find widened instruction\"", "\"Unexpected widened instruction\"", "0", "32", "\"Unexpected type for the widened instruction\"" ]
ARMLegalizerInfo27
legalizeCustom
ARM
CPU
LLVM
17,874
268
1
[]
[ "<s>", "const", "char", "*", "avr_out_insert_bits", "(", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "unsigned", "int", "map", "=", "UINTVAL", "(", "op", "[", "1", "]", ")", "&", "GET_MODE_MASK", "(", "SImode", ")", ";", "unsigned", "mask_fixed", ";", "bool", "fixp_p", "=", "true", ";", "rtx", "xop", "[", "4", "]", ";", "xop", "[", "0", "]", "=", "op", "[", "0", "]", ";", "xop", "[", "1", "]", "=", "op", "[", "2", "]", ";", "xop", "[", "2", "]", "=", "op", "[", "3", "]", ";", "gcc_assert", "(", "REG_P", "(", "xop", "[", "2", "]", ")", "||", "CONST_INT_P", "(", "xop", "[", "2", "]", ")", ")", ";", "if", "(", "plen", ")", "*", "plen", "=", "0", ";", "else", "if", "(", "flag_print_asm_name", ")", "fprintf", "(", "asm_out_file", ",", "ASM_COMMENT_START", "\"map = 0x%08x\\n\"", ",", "map", ")", ";", "mask_fixed", "=", "avr_map_metric", "(", "map", ",", "MAP_MASK_FIXED_0_7", ")", ";", "if", "(", "REGNO", "(", "xop", "[", "0", "]", ")", "==", "REGNO", "(", "xop", "[", "1", "]", ")", ")", "{", "avr_asm_len", "(", "\"mov __tmp_reg__,%1\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "xop", "[", "1", "]", "=", "tmp_reg_rtx", ";", "fixp_p", "=", "false", ";", "}", "if", "(", "avr_map_metric", "(", "map", ",", "MAP_MASK_PREIMAGE_F", ")", ")", "{", "int", "n_fix", "=", "0", ",", "n_nofix", "=", "0", ";", "gcc_assert", "(", "REG_P", "(", "xop", "[", "2", "]", ")", ")", ";", "avr_move_bits", "(", "xop", ",", "map", ",", "true", ",", "&", "n_fix", ")", ";", "avr_move_bits", "(", "xop", ",", "map", ",", "false", ",", "&", "n_nofix", ")", ";", "if", "(", "fixp_p", "&&", "n_fix", "-", "n_nofix", ">", "3", ")", "{", "xop", "[", "3", "]", "=", "gen_int_mode", "(", "~", "mask_fixed", ",", "QImode", ")", ";", "avr_asm_len", "(", "\"eor %0,%1\"", "CR_TAB", "\"andi %0,%3\"", "CR_TAB", "\"eor %0,%1\"", ",", "xop", ",", "plen", ",", "3", ")", ";", "fixp_p", "=", "false", ";", "}", "}", "else", "{", "if", "(", "fixp_p", "&&", "mask_fixed", ")", "{", "avr_asm_len", "(", "\"mov %0,%1\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "fixp_p", "=", "false", ";", "}", "}", "avr_move_bits", "(", "xop", ",", "map", ",", "fixp_p", ",", "plen", ")", ";", "return", "\"\"", ";", "}", "</s>" ]
[ "PLEN", "==", "0", ":", "Print", "assembler", "code", "for", "`", "insert_bits", "'", ".", "PLEN", "!", "=", "0", ":", "Compute", "code", "length", "in", "bytes", ".", "OP", "[", "0", "]", ":", "Result", "OP", "[", "1", "]", ":", "The", "mapping", "composed", "of", "nibbles", ".", "If", "nibble", "no", ".", "N", "is", "0", ":", "Bit", "N", "of", "result", "is", "copied", "from", "bit", "OP", "[", "2", "]", ".0", "...", "...", "7", ":", "Bit", "N", "of", "result", "is", "copied", "from", "bit", "OP", "[", "2", "]", ".7", "0xf", ":", "Bit", "N", "of", "result", "is", "copied", "from", "bit", "OP", "[", "3", "]", ".N", "OP", "[", "2", "]", ":", "Bits", "to", "be", "inserted", "OP", "[", "3", "]", ":", "Target", "value" ]
[ "avr", "1", "4", "0", "0", "1", "2", "2", "3", "2", "2", "0", "\"map = 0x%08x\\n\"", "0", "1", "\"mov __tmp_reg__,%1\"", "1", "1", "0", "0", "2", "3", "3", "\"eor %0,%1\"", "\"andi %0,%3\"", "\"eor %0,%1\"", "3", "\"mov %0,%1\"", "1", "\"\"" ]
avr
avr_out_insert_bits
avr
MPU
GCC
17,875
309
1
[]
[ "<s>", "type_suffix_index", "function_resolver", "::", "infer_integer_vector_type", "(", "unsigned", "int", "argno", ")", "{", "type_suffix_index", "type", "=", "infer_vector_type", "(", "argno", ")", ";", "if", "(", "type", "==", "NUM_TYPE_SUFFIXES", ")", "return", "type", ";", "if", "(", "!", "type_suffixes", "[", "type", "]", ".", "integer_p", ")", "{", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, which\"", "\" expects a vector of integers\"", ",", "get_argument_type", "(", "argno", ")", ",", "argno", "+", "1", ",", "fndecl", ")", ";", "return", "NUM_TYPE_SUFFIXES", ";", "}", "return", "type", ";", "}", "</s>" ]
[ "Like", "infer_vector_type", ",", "but", "also", "require", "the", "type", "to", "be", "integral", "." ]
[ "aarch64", "\"passing %qT to argument %d of %qE, which\"", "\" expects a vector of integers\"", "1" ]
aarch64-sve-builtins
infer_integer_vector_type
aarch64
CPU
GCC
17,876
65
1
[]
[ "<s>", "static", "void", "mips_promote_ready", "(", "rtx", "*", "ready", ",", "int", "lower", ",", "int", "higher", ")", "{", "rtx", "new_head", ";", "int", "i", ";", "new_head", "=", "ready", "[", "lower", "]", ";", "for", "(", "i", "=", "lower", ";", "i", "<", "higher", ";", "i", "++", ")", "ready", "[", "i", "]", "=", "ready", "[", "i", "+", "1", "]", ";", "ready", "[", "i", "]", "=", "new_head", ";", "}", "</s>" ]
[ "Remove", "the", "instruction", "at", "index", "LOWER", "from", "ready", "queue", "READY", "and", "reinsert", "it", "in", "front", "of", "the", "instruction", "at", "index", "HIGHER", ".", "LOWER", "must", "be", "<", "=", "HIGHER", "." ]
[ "mips", "1" ]
mips3
mips_promote_ready
mips
CPU
GCC
17,877
61
1
[]
[ "<s>", "BitVector", "ARMBaseRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "PC", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "FPSCR", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "FramePtr", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "BasePtr", ")", ";", "if", "(", "STI", ".", "isR9Reserved", "(", ")", ")", "Reserved", ".", "set", "(", "ARM", "::", "R9", ")", ";", "return", "Reserved", ";", "}", "</s>" ]
[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]
[ "ARM", "ARM", "ARM::SP", "ARM::PC", "ARM::FPSCR", "ARM::R9" ]
ARMBaseRegisterInfo29
getReservedRegs
ARM
CPU
LLVM
17,878
96
1
[]
[ "<s>", "const", "char", "*", "host_detect_local_cpu", "(", "int", "argc", ",", "const", "char", "*", "*", "argv", ")", "{", "const", "char", "*", "val", "=", "NULL", ";", "char", "buf", "[", "128", "]", ";", "FILE", "*", "f", "=", "NULL", ";", "bool", "arch", ";", "const", "struct", "vendor_cpu", "*", "cpu_table", "=", "NULL", ";", "char", "*", "fcpu_info", "=", "NULL", ";", "if", "(", "argc", "<", "1", ")", "goto", "not_found", ";", "arch", "=", "strcmp", "(", "argv", "[", "0", "]", ",", "\"arch\"", ")", "==", "0", ";", "if", "(", "!", "arch", "&&", "strcmp", "(", "argv", "[", "0", "]", ",", "\"cpu\"", ")", "!=", "0", "&&", "strcmp", "(", "argv", "[", "0", "]", ",", "\"tune\"", ")", ")", "goto", "not_found", ";", "fcpu_info", "=", "getenv", "(", "\"GCC_CPUINFO\"", ")", ";", "if", "(", "fcpu_info", ")", "f", "=", "fopen", "(", "fcpu_info", ",", "\"r\"", ")", ";", "else", "f", "=", "fopen", "(", "\"/proc/cpuinfo\"", ",", "\"r\"", ")", ";", "if", "(", "f", "==", "NULL", ")", "goto", "not_found", ";", "while", "(", "fgets", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "f", ")", "!=", "NULL", ")", "{", "if", "(", "startswith", "(", "buf", ",", "\"CPU implementer\"", ")", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "vendors_table", "[", "i", "]", ".", "vendor_no", "!=", "NULL", ";", "i", "++", ")", "if", "(", "strstr", "(", "buf", ",", "vendors_table", "[", "i", "]", ".", "vendor_no", ")", "!=", "NULL", ")", "{", "cpu_table", "=", "vendors_table", "[", "i", "]", ".", "vendor_parts", ";", "break", ";", "}", "}", "if", "(", "startswith", "(", "buf", ",", "\"CPU part\"", ")", ")", "{", "int", "i", ";", "if", "(", "cpu_table", "==", "NULL", ")", "goto", "not_found", ";", "for", "(", "i", "=", "0", ";", "cpu_table", "[", "i", "]", ".", "part_no", "!=", "NULL", ";", "i", "++", ")", "if", "(", "strstr", "(", "buf", ",", "cpu_table", "[", "i", "]", ".", "part_no", ")", "!=", "NULL", ")", "{", "val", "=", "arch", "?", "cpu_table", "[", "i", "]", ".", "arch_name", ":", "cpu_table", "[", "i", "]", ".", "cpu_name", ";", "break", ";", "}", "break", ";", "}", "}", "if", "(", "val", ")", "{", "fclose", "(", "f", ")", ";", "return", "concat", "(", "\"-m\"", ",", "argv", "[", "0", "]", ",", "\"=\"", ",", "val", ",", "NULL", ")", ";", "}", "not_found", ":", "{", "unsigned", "int", "i", ";", "unsigned", "int", "opt", ";", "const", "char", "*", "search", "[", "]", "=", "{", "NULL", ",", "\"arch\"", "}", ";", "if", "(", "f", ")", "fclose", "(", "f", ")", ";", "search", "[", "0", "]", "=", "argv", "[", "0", "]", ";", "for", "(", "opt", "=", "0", ";", "opt", "<", "ARRAY_SIZE", "(", "search", ")", ";", "opt", "++", ")", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "configure_default_options", ")", ";", "i", "++", ")", "if", "(", "strcmp", "(", "configure_default_options", "[", "i", "]", ".", "name", ",", "search", "[", "opt", "]", ")", "==", "0", ")", "return", "concat", "(", "\"-m\"", ",", "search", "[", "opt", "]", ",", "\"=\"", ",", "configure_default_options", "[", "i", "]", ".", "value", ",", "NULL", ")", ";", "return", "NULL", ";", "}", "}", "</s>" ]
[ "This", "will", "be", "called", "by", "the", "spec", "parser", "in", "gcc.cc", "when", "it", "sees", "a", "%", ":", "local_cpu_detect", "(", "args", ")", "construct", ".", "Currently", "it", "will", "be", "called", "with", "either", "``", "cpu", "''", "or", "``", "tune", "''", "as", "argument", "depending", "on", "if", "-mcpu=native", "or", "-mtune=native", "is", "to", "be", "substituted", ".", "It", "returns", "a", "string", "containing", "new", "command", "line", "parameters", "to", "be", "put", "at", "the", "place", "of", "the", "above", "two", "options", ",", "depending", "on", "what", "CPU", "this", "is", "executed", ".", "E.g", ".", "``", "-mcpu=ultrasparc3", "''", "on", "an", "UltraSPARC", "III", "for", "-mcpu=native", ".", "If", "the", "routine", "ca", "n't", "detect", "a", "known", "processor", ",", "the", "-mcpu", "or", "-mtune", "option", "is", "discarded", ".", "ARGC", "and", "ARGV", "are", "set", "depending", "on", "the", "actual", "arguments", "given", "in", "the", "spec", "." ]
[ "arm", "128", "1", "0", "\"arch\"", "0", "0", "\"cpu\"", "0", "0", "\"tune\"", "\"GCC_CPUINFO\"", "\"r\"", "\"/proc/cpuinfo\"", "\"r\"", "\"CPU implementer\"", "0", "\"CPU part\"", "0", "\"-m\"", "0", "\"=\"", "\"arch\"", "0", "0", "0", "0", "0", "\"-m\"", "\"=\"" ]
driver-arm
host_detect_local_cpu
arm
CPU
GCC
17,879
452
1
[]
[ "<s>", "bool", "AArch64InstrInfo", "::", "isLdStPairSuppressed", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "return", "llvm", "::", "any_of", "(", "MI", ".", "memoperands", "(", ")", ",", "[", "]", "(", "MachineMemOperand", "*", "MMO", ")", "{", "return", "MMO", "->", "getFlags", "(", ")", "&", "MOSuppressPair", ";", "}", ")", ";", "}", "</s>" ]
[ "Return", "true", "if", "pairing", "the", "given", "load", "or", "store", "is", "hinted", "to", "be", "unprofitable", "." ]
[ "AArch64", "AArch64" ]
AArch64InstrInfo (2)
isLdStPairSuppressed
AArch64
CPU
LLVM
17,880
44
1
[]
[ "<s>", "bool", "rl78_virt_insns_ok", "(", "void", ")", "{", "if", "(", "cfun", ")", "return", "cfun", "->", "machine", "->", "virt_insns_ok", ";", "return", "true", ";", "}", "</s>" ]
[ "Predicates", "used", "in", "the", "MD", "patterns", ".", "This", "one", "is", "true", "when", "virtual", "insns", "may", "be", "matched", ",", "which", "typically", "means", "before", "(", "or", "during", ")", "the", "devirt", "pass", "." ]
[ "rl78" ]
rl78
rl78_virt_insns_ok
rl78
MPU
GCC
17,881
21
1
[]
[ "<s>", "static", "tree", "ix86_md_asm_clobbers", "(", "tree", "outputs", "ATTRIBUTE_UNUSED", ",", "tree", "inputs", "ATTRIBUTE_UNUSED", ",", "tree", "clobbers", ")", "{", "clobbers", "=", "tree_cons", "(", "NULL_TREE", ",", "build_string", "(", "5", ",", "\"flags\"", ")", ",", "clobbers", ")", ";", "clobbers", "=", "tree_cons", "(", "NULL_TREE", ",", "build_string", "(", "4", ",", "\"fpsr\"", ")", ",", "clobbers", ")", ";", "clobbers", "=", "tree_cons", "(", "NULL_TREE", ",", "build_string", "(", "7", ",", "\"dirflag\"", ")", ",", "clobbers", ")", ";", "return", "clobbers", ";", "}", "</s>" ]
[ "Worker", "function", "for", "TARGET_MD_ASM_CLOBBERS", ".", "We", "do", "this", "in", "the", "new", "i386", "backend", "to", "maintain", "source", "compatibility", "with", "the", "old", "cc0-based", "compiler", "." ]
[ "i386", "5", "\"flags\"", "4", "\"fpsr\"", "7", "\"dirflag\"" ]
i3863
ix86_md_asm_clobbers
i386
CPU
GCC
17,882
68
1
[]
[ "<s>", "bool", "X86AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", "==", "\".word\"", ")", "return", "ParseDirectiveWord", "(", "2", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".code\"", ")", ")", "return", "ParseDirectiveCode", "(", "IDVal", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".att_syntax\"", ")", ")", "{", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"prefix\"", ")", "Parser", ".", "Lex", "(", ")", ";", "else", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"noprefix\"", ")", "return", "Error", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "\"'.att_syntax noprefix' is not \"", "\"supported: registers must have a \"", "\"'%' prefix in .att_syntax\"", ")", ";", "}", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "0", ")", ";", "return", "false", ";", "}", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".intel_syntax\"", ")", ")", "{", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "1", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"noprefix\"", ")", "Parser", ".", "Lex", "(", ")", ";", "else", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"prefix\"", ")", "return", "Error", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "\"'.intel_syntax prefix' is not \"", "\"supported: registers must not have \"", "\"a '%' prefix in .intel_syntax\"", ")", ";", "}", "return", "false", ";", "}", "else", "if", "(", "IDVal", "==", "\".even\"", ")", "return", "parseDirectiveEven", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]
[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]
[ "X86", "X86", "\".word\"", "2", "\".code\"", "\".att_syntax\"", "\"prefix\"", "\"noprefix\"", "\"'.att_syntax noprefix' is not \"", "\"supported: registers must have a \"", "\"'%' prefix in .att_syntax\"", "0", "\".intel_syntax\"", "1", "\"noprefix\"", "\"prefix\"", "\"'.intel_syntax prefix' is not \"", "\"supported: registers must not have \"", "\"a '%' prefix in .intel_syntax\"", "\".even\"" ]
X86AsmParser (2)3
ParseDirective
X86
CPU
LLVM
17,883
263
1
[]
[ "<s>", "virtual", "const", "OpenRISCSubtarget", "*", "getSubtargetImpl", "(", ")", "const", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]
[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]
[ "OpenRISC", "OpenRISC" ]
OpenRISCTargetMachine
getSubtargetImpl
OpenRISC
CPU
LLVM
17,884
14
1
[]
[ "<s>", "AVRSubtarget", "&", "AVRSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetMachine", "&", "TM", ")", "{", "ParseSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]
[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]
[ "AVR", "AVR", "AVR" ]
AVRSubtarget (2)
initializeSubtargetDependencies
AVR
MPU
LLVM
17,885
30
1
[]
[ "<s>", "static", "void", "register_builtin_types", "(", ")", "{", "scalar_types", "[", "VECTOR_TYPE_", "##", "ACLE_NAME", "]", "=", "SCALAR_TYPE", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "NUM_VECTOR_TYPES", ";", "++", "i", ")", "{", "tree", "eltype", "=", "scalar_types", "[", "i", "]", ";", "tree", "vectype", ";", "unsigned", "int", "num_zr", "=", "0", ",", "num_pr", "=", "0", ";", "if", "(", "eltype", "==", "boolean_type_node", ")", "{", "vectype", "=", "build_truth_vector_type_for_mode", "(", "BYTES_PER_SVE_VECTOR", ",", "VNx16BImode", ")", ";", "gcc_assert", "(", "TYPE_MODE", "(", "vectype", ")", "==", "VNx16BImode", "&&", "TYPE_MODE", "(", "vectype", ")", "==", "TYPE_MODE_RAW", "(", "vectype", ")", "&&", "TYPE_ALIGN", "(", "vectype", ")", "==", "16", "&&", "known_eq", "(", "wi", "::", "to_poly_offset", "(", "TYPE_SIZE", "(", "vectype", ")", ")", ",", "BYTES_PER_SVE_VECTOR", ")", ")", ";", "num_pr", "=", "1", ";", "}", "else", "{", "scalar_mode", "elmode", "=", "SCALAR_TYPE_MODE", "(", "eltype", ")", ";", "unsigned", "int", "elbytes", "=", "GET_MODE_SIZE", "(", "elmode", ")", ";", "poly_uint64", "nunits", "=", "exact_div", "(", "BYTES_PER_SVE_VECTOR", ",", "elbytes", ")", ";", "machine_mode", "mode", "=", "aarch64_sve_data_mode", "(", "elmode", ",", "nunits", ")", ".", "require", "(", ")", ";", "vectype", "=", "build_vector_type_for_mode", "(", "eltype", ",", "mode", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "TYPE_MODE", "(", "vectype", ")", ")", "&&", "TYPE_MODE", "(", "vectype", ")", "==", "mode", "&&", "TYPE_MODE_RAW", "(", "vectype", ")", "==", "mode", "&&", "TYPE_ALIGN", "(", "vectype", ")", "==", "128", "&&", "known_eq", "(", "wi", "::", "to_poly_offset", "(", "TYPE_SIZE", "(", "vectype", ")", ")", ",", "BITS_PER_SVE_VECTOR", ")", ")", ";", "num_zr", "=", "1", ";", "}", "vectype", "=", "build_distinct_type_copy", "(", "vectype", ")", ";", "gcc_assert", "(", "vectype", "==", "TYPE_MAIN_VARIANT", "(", "vectype", ")", ")", ";", "SET_TYPE_STRUCTURAL_EQUALITY", "(", "vectype", ")", ";", "TYPE_ARTIFICIAL", "(", "vectype", ")", "=", "1", ";", "TYPE_INDIVISIBLE_P", "(", "vectype", ")", "=", "1", ";", "add_sve_type_attribute", "(", "vectype", ",", "num_zr", ",", "num_pr", ",", "vector_types", "[", "i", "]", ".", "mangled_name", ",", "vector_types", "[", "i", "]", ".", "acle_name", ")", ";", "make_type_sizeless", "(", "vectype", ")", ";", "abi_vector_types", "[", "i", "]", "=", "vectype", ";", "lang_hooks", ".", "types", ".", "register_builtin_type", "(", "vectype", ",", "vector_types", "[", "i", "]", ".", "abi_name", ")", ";", "}", "}", "</s>" ]
[ "Register", "the", "built-in", "RVV", "ABI", "types", ",", "such", "as", "__rvv_int32m1_t", "." ]
[ "aarch64", "0", "0", "0", "16", "1", "128", "1", "1", "1" ]
aarch64-sve-builtins1
register_builtin_types
aarch64
CPU
GCC
17,886
308
1
[]
[ "<s>", "bool", "mep_epilogue_uses", "(", "int", "regno", ")", "{", "if", "(", "regno", "==", "LP_REGNO", "&&", "(", "profile_arc_flag", ">", "0", "||", "profile_flag", ">", "0", ")", ")", "return", "true", ";", "return", "(", "reload_completed", "&&", "mep_interrupt_saved_reg", "(", "regno", ")", ")", ";", "}", "</s>" ]
[ "Return", "true", "if", "epilogue", "uses", "register", "REGNO", "." ]
[ "mep", "0", "0" ]
mep
mep_epilogue_uses
mep
CPU
GCC
17,887
37
1
[]
[ "<s>", "static", "void", "nds32_asm_function_begin_epilogue", "(", "FILE", "*", "file", ")", "{", "fprintf", "(", "file", ",", "\"\\t! BEGIN EPILOGUE\\n\"", ")", ";", "}", "</s>" ]
[ "Before", "rtl", "epilogue", "has", "been", "expanded", ",", "this", "function", "is", "used", "." ]
[ "nds32", "\"\\t! BEGIN EPILOGUE\\n\"" ]
nds32
nds32_asm_function_begin_epilogue
nds32
CPU
GCC
17,888
17
1
[]
[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"R600 Vector Registers Merge Pass\"", ";", "}", "</s>" ]
[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]
[ "AMDGPU", "\"R600 Vector Registers Merge Pass\"" ]
R600OptimizeVectorRegisters (2)
getPassName
AMDGPU
GPU
LLVM
17,889
13
1
[]
[ "<s>", "int", "reg_unused_after", "(", "rtx", "reg", ",", "rtx", "insn", ")", "{", "enum", "rtx_code", "code", ",", "prev_code", "=", "UNKNOWN", ";", "while", "(", "(", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", ")", "{", "if", "(", "prev_code", "==", "CALL_INSN", "&&", "call_used_regs", "[", "REGNO", "(", "reg", ")", "]", ")", "return", "1", ";", "code", "=", "GET_CODE", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "CODE_LABEL", ")", "return", "1", ";", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "int", "in_src", "=", "set", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "SET_SRC", "(", "set", ")", ")", ";", "if", "(", "set", "&&", "in_src", ")", "return", "0", ";", "if", "(", "set", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "SET_DEST", "(", "set", ")", ")", ")", "return", "1", ";", "if", "(", "set", "==", "0", "&&", "reg_overlap_mentioned_p", "(", "reg", ",", "PATTERN", "(", "insn", ")", ")", ")", "return", "0", ";", "}", "prev_code", "=", "code", ";", "}", "return", "1", ";", "}", "</s>" ]
[ "Return", "nonzero", "if", "REG", "is", "not", "used", "after", "INSN", ".", "We", "assume", "REG", "is", "a", "reload", "reg", ",", "and", "therefore", "does", "not", "live", "past", "labels", "or", "calls", "or", "jumps", "." ]
[ "sparc", "1", "1", "0", "1", "0", "0", "1" ]
sparc3
reg_unused_after
sparc
CPU
GCC
17,890
152
1
[]
[ "<s>", "static", "tree", "s390_handle_vectorbool_attribute", "(", "tree", "*", "node", ",", "tree", "name", "ATTRIBUTE_UNUSED", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "tree", "type", "=", "*", "node", ",", "result", "=", "NULL_TREE", ";", "machine_mode", "mode", ";", "while", "(", "POINTER_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "type", ")", "==", "FUNCTION_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "METHOD_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_DImode", ":", "case", "E_V2DImode", ":", "result", "=", "s390_builtin_types", "[", "BT_BV2DI", "]", ";", "break", ";", "case", "E_SImode", ":", "case", "E_V4SImode", ":", "result", "=", "s390_builtin_types", "[", "BT_BV4SI", "]", ";", "break", ";", "case", "E_HImode", ":", "case", "E_V8HImode", ":", "result", "=", "s390_builtin_types", "[", "BT_BV8HI", "]", ";", "break", ";", "case", "E_QImode", ":", "case", "E_V16QImode", ":", "result", "=", "s390_builtin_types", "[", "BT_BV16QI", "]", ";", "break", ";", "default", ":", "break", ";", "}", "*", "no_add_attrs", "=", "true", ";", "if", "(", "result", ")", "*", "node", "=", "lang_hooks", ".", "types", ".", "reconstruct_complex_type", "(", "*", "node", ",", "result", ")", ";", "return", "NULL_TREE", ";", "}", "</s>" ]
[ "Expand", "the", "s390_vector_bool", "type", "attribute", "." ]
[ "s390" ]
s390
s390_handle_vectorbool_attribute
s390
MPU
GCC
17,891
178
1
[]
[ "<s>", "void", "SNESMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "assert", "(", "Size", ">", "0", "&&", "\"Instruction size cannot be zero\"", ")", ";", "uint64_t", "BinaryOpCode", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "emitInstruction", "(", "BinaryOpCode", ",", "Size", ",", "STI", ",", "OS", ")", ";", "}", "</s>" ]
[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]
[ "SNES", "SNES", "0", "\"Instruction size cannot be zero\"" ]
SNESMCCodeEmitter
encodeInstruction
SNES
DSP
LLVM
17,892
86
1
[]
[ "<s>", "bool", "X86DynAllocaExpander", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "hasDynAlloca", "(", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "StackPtr", "=", "TRI", "->", "getStackRegister", "(", ")", ";", "SlotSize", "=", "TRI", "->", "getSlotSize", "(", ")", ";", "StackProbeSize", "=", "4096", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"stack-probe-size\"", ")", ")", "{", "MF", ".", "getFunction", "(", ")", ".", "getFnAttribute", "(", "\"stack-probe-size\"", ")", ".", "getValueAsString", "(", ")", ".", "getAsInteger", "(", "0", ",", "StackProbeSize", ")", ";", "}", "NoStackArgProbe", "=", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"no-stack-arg-probe\"", ")", ";", "if", "(", "NoStackArgProbe", ")", "StackProbeSize", "=", "INT64_MAX", ";", "LoweringMap", "Lowerings", ";", "computeLowerings", "(", "MF", ",", "Lowerings", ")", ";", "for", "(", "auto", "&", "P", ":", "Lowerings", ")", "lower", "(", "P", ".", "first", ",", "P", ".", "second", ")", ";", "return", "true", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "X86", "X86", "X86", "X86", "4096", "\"stack-probe-size\"", "\"stack-probe-size\"", "0", "\"no-stack-arg-probe\"" ]
X86DynAllocaExpander
runOnMachineFunction
X86
CPU
LLVM
17,893
177
1
[]
[ "<s>", "MipsSubtarget", "&", "MipsSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetMachine", "&", "TM", ")", "{", "std", "::", "string", "CPUName", "=", "MIPS_MC", "::", "selectMipsCPU", "(", "TM", ".", "getTargetTriple", "(", ")", ",", "CPU", ")", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "InMips16Mode", "&&", "!", "IsSoftFloat", ")", "InMips16HardFloat", "=", "true", ";", "if", "(", "StackAlignOverride", ")", "stackAlignment", "=", "*", "StackAlignOverride", ";", "else", "if", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", "stackAlignment", "=", "Align", "(", "16", ")", ";", "else", "{", "assert", "(", "isABI_O32", "(", ")", "&&", "\"Unknown ABI for stack alignment!\"", ")", ";", "stackAlignment", "=", "Align", "(", "8", ")", ";", "}", "if", "(", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", "&&", "!", "isGP64bit", "(", ")", ")", "report_fatal_error", "(", "\"64-bit code requested on a subtarget that doesn't \"", "\"support it!\"", ")", ";", "return", "*", "this", ";", "}", "</s>" ]
[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]
[ "Mips", "Mips", "Mips", "MIPS_MC::selectMipsCPU", "Mips", "Mips", "16", "\"Unknown ABI for stack alignment!\"", "8", "\"64-bit code requested on a subtarget that doesn't \"", "\"support it!\"" ]
MipsSubtarget74
initializeSubtargetDependencies
Mips
CPU
LLVM
17,894
135
1
[]
[ "<s>", "SDValue", "AArch64SelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "ConstantSDNode", "*", "V", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Src", ")", ";", "ConstantSDNode", "*", "SizeValue", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ";", "const", "AArch64Subtarget", "&", "STI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "const", "char", "*", "bzeroEntry", "=", "(", "V", "&&", "V", "->", "isNullValue", "(", ")", ")", "?", "STI", ".", "getBZeroEntry", "(", ")", ":", "nullptr", ";", "if", "(", "bzeroEntry", "&&", "(", "!", "SizeValue", "||", "SizeValue", "->", "getZExtValue", "(", ")", ">", "256", ")", ")", "{", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "STI", ".", "getTargetLowering", "(", ")", ";", "EVT", "IntPtr", "=", "TLI", ".", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "Type", "*", "IntPtrTy", "=", "DAG", ".", "getDataLayout", "(", ")", ".", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Entry", ".", "Node", "=", "Dst", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";", "CLI", ".", "setDebugLoc", "(", "dl", ")", ".", "setChain", "(", "Chain", ")", ".", "setLibCallee", "(", "CallingConv", "::", "C", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "DAG", ".", "getExternalSymbol", "(", "bzeroEntry", ",", "IntPtr", ")", ",", "std", "::", "move", "(", "Args", ")", ")", ".", "setDiscardResult", "(", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]
[ "Emit", "target-specific", "code", "that", "performs", "a", "memset", "." ]
[ "AArch64", "AArch64", "AArch64", "AArch64", "256", "AArch64" ]
AArch64SelectionDAGInfo6
EmitTargetCodeForMemset
AArch64
CPU
LLVM
17,895
296
1
[]
[ "<s>", "static", "bool", "isNot", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "MachineInstr", "&", "MI", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "!=", "TargetOpcode", "::", "G_XOR", ")", "return", "false", ";", "auto", "ConstVal", "=", "getConstantVRegSExtVal", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ";", "return", "ConstVal", "&&", "*", "ConstVal", "==", "-", "1", ";", "}", "</s>" ]
[ "Check", "if", "the", "current", "token", "has", "kind", "K", "." ]
[ "AMDGPU", "2", "1" ]
AMDGPULegalizerInfo26
isNot
AMDGPU
GPU
LLVM
17,896
59
1
[]
[ "<s>", "bool", "PPCTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "CallConv", "==", "CallingConv", "::", "Cold", ")", "?", "RetCC_PPC_Cold", ":", "RetCC_PPC", ")", ";", "}", "</s>" ]
[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]
[ "PowerPC", "PPC", "ISD::OutputArg", "16", "PPC", "PPC" ]
PPCISelLowering (2)7
CanLowerReturn
PowerPC
CPU
LLVM
17,897
82
1
[]
[ "<s>", "unsigned", "NyuziMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "if", "(", "const", "NyuziMCExpr", "*", "McExpr", "=", "dyn_cast", "<", "NyuziMCExpr", ">", "(", "Expr", ")", ")", "{", "switch", "(", "McExpr", "->", "getKind", "(", ")", ")", "{", "case", "NyuziMCExpr", "::", "VK_Nyuzi_ABS_HI", ":", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "MO", ".", "getExpr", "(", ")", ",", "MCFixupKind", "(", "Nyuzi", "::", "fixup_Nyuzi_HI19", ")", ")", ")", ";", "break", ";", "case", "NyuziMCExpr", "::", "VK_Nyuzi_ABS_LO", ":", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "MO", ".", "getExpr", "(", ")", ",", "MCFixupKind", "(", "Nyuzi", "::", "fixup_Nyuzi_IMM_LO13", ")", ")", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unknown fixup type\"", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]
[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]
[ "Nyuzi", "Nyuzi", "Nyuzi", "Nyuzi", "Nyuzi", "Nyuzi", "0", "Nyuzi::fixup_Nyuzi_HI19", "Nyuzi", "Nyuzi", "0", "Nyuzi::fixup_Nyuzi_IMM_LO13", "\"Unknown fixup type\"", "0" ]
NyuziMCCodeEmitter
getMachineOpValue
Nyuzi
GPU
LLVM
17,898
196
1
[]
[ "<s>", "bool", "Thumb2SizeReduce", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "PredicateFtor", "&&", "!", "PredicateFtor", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "STI", "->", "isThumb1Only", "(", ")", "||", "STI", "->", "prefers32BitThumb", "(", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "STI", "->", "getInstrInfo", "(", ")", ")", ";", "OptimizeSize", "=", "MF", ".", "getFunction", "(", ")", ".", "hasOptSize", "(", ")", ";", "MinimizeSize", "=", "STI", "->", "hasMinSize", "(", ")", ";", "BlockInfo", ".", "clear", "(", ")", ";", "BlockInfo", ".", "resize", "(", "MF", ".", "getNumBlockIDs", "(", ")", ")", ";", "ReversePostOrderTraversal", "<", "MachineFunction", "*", ">", "RPOT", "(", "&", "MF", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "*", "MBB", ":", "RPOT", ")", "Modified", "|=", "ReduceMBB", "(", "*", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]
[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]
[ "ARM", "ARM" ]
Thumb2SizeReduction30
runOnMachineFunction
ARM
CPU
LLVM
17,899
145
1
[]