ground_truth
sequencelengths 8
512
| natrual_language
sequencelengths 1
243
| TS_V_token
sequencelengths 1
182
| File
stringlengths 2
45
| Func
stringlengths 1
56
| Target
stringclasses 175
values | Target_Clf
stringclasses 6
values | Compiler_Type
stringclasses 2
values | Idx
int64 0
36.2k
| Length
int64 6
510
| Cover_Rate
float64 1
1
| Template_token
sequencelengths 0
0
|
|---|---|---|---|---|---|---|---|---|---|---|---|
[
"<s>",
"void",
"ARMBaseRegisterInfo",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
")",
"const",
"{",
"const",
"TargetFrameLowering",
"*",
"TFI",
"=",
"MF",
".",
"getTarget",
"(",
")",
".",
"getFrameLowering",
"(",
")",
";",
"if",
"(",
"!",
"TFI",
"->",
"hasReservedCallFrame",
"(",
"MF",
")",
")",
"{",
"MachineInstr",
"*",
"Old",
"=",
"I",
";",
"DebugLoc",
"dl",
"=",
"Old",
"->",
"getDebugLoc",
"(",
")",
";",
"unsigned",
"Amount",
"=",
"Old",
"->",
"getOperand",
"(",
"0",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"Amount",
"!=",
"0",
")",
"{",
"unsigned",
"Align",
"=",
"TFI",
"->",
"getStackAlignment",
"(",
")",
";",
"Amount",
"=",
"(",
"Amount",
"+",
"Align",
"-",
"1",
")",
"/",
"Align",
"*",
"Align",
";",
"ARMFunctionInfo",
"*",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"assert",
"(",
"!",
"AFI",
"->",
"isThumb1OnlyFunction",
"(",
")",
"&&",
"\"This eliminateCallFramePseudoInstr does not support Thumb1!\"",
")",
";",
"bool",
"isARM",
"=",
"!",
"AFI",
"->",
"isThumbFunction",
"(",
")",
";",
"unsigned",
"Opc",
"=",
"Old",
"->",
"getOpcode",
"(",
")",
";",
"int",
"PIdx",
"=",
"Old",
"->",
"findFirstPredOperandIdx",
"(",
")",
";",
"ARMCC",
"::",
"CondCodes",
"Pred",
"=",
"(",
"PIdx",
"==",
"-",
"1",
")",
"?",
"ARMCC",
"::",
"AL",
":",
"(",
"ARMCC",
"::",
"CondCodes",
")",
"Old",
"->",
"getOperand",
"(",
"PIdx",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"Opc",
"==",
"ARM",
"::",
"ADJCALLSTACKDOWN",
"||",
"Opc",
"==",
"ARM",
"::",
"tADJCALLSTACKDOWN",
")",
"{",
"unsigned",
"PredReg",
"=",
"Old",
"->",
"getOperand",
"(",
"2",
")",
".",
"getReg",
"(",
")",
";",
"emitSPUpdate",
"(",
"isARM",
",",
"MBB",
",",
"I",
",",
"dl",
",",
"TII",
",",
"-",
"Amount",
",",
"Pred",
",",
"PredReg",
")",
";",
"}",
"else",
"{",
"unsigned",
"PredReg",
"=",
"Old",
"->",
"getOperand",
"(",
"3",
")",
".",
"getReg",
"(",
")",
";",
"assert",
"(",
"Opc",
"==",
"ARM",
"::",
"ADJCALLSTACKUP",
"||",
"Opc",
"==",
"ARM",
"::",
"tADJCALLSTACKUP",
")",
";",
"emitSPUpdate",
"(",
"isARM",
",",
"MBB",
",",
"I",
",",
"dl",
",",
"TII",
",",
"Amount",
",",
"Pred",
",",
"PredReg",
")",
";",
"}",
"}",
"}",
"MBB",
".",
"erase",
"(",
"I",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"is",
"called",
"during",
"prolog/epilog",
"code",
"insertion",
"to",
"eliminate",
"call",
"frame",
"setup",
"and",
"destroy",
"pseudo",
"instructions",
"(",
"but",
"only",
"if",
"the",
"Target",
"is",
"using",
"them",
")",
"."
] | [
"ARM",
"ARM",
"0",
"0",
"1",
"ARM",
"ARM",
"\"This eliminateCallFramePseudoInstr does not support Thumb1!\"",
"ARM",
"ARMCC::CondCodes",
"1",
"ARMCC::AL",
"ARMCC::CondCodes",
"ARM::ADJCALLSTACKDOWN",
"ARM::tADJCALLSTACKDOWN",
"2",
"ARM",
"3",
"ARM::ADJCALLSTACKUP",
"ARM::tADJCALLSTACKUP",
"ARM"
] | ARMBaseRegisterInfo1 | eliminateCallFramePseudoInstr | ARM | CPU | LLVM | 8,800 | 301 | 1 | [] |
[
"<s>",
"static",
"bool",
"microblaze_legitimate_constant_p",
"(",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
",",
"rtx",
"x",
")",
"{",
"if",
"(",
"microblaze_cannot_force_const_mem",
"(",
"mode",
",",
"x",
")",
")",
"return",
"false",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"CONST_DOUBLE",
")",
"{",
"return",
"microblaze_const_double_ok",
"(",
"x",
",",
"GET_MODE",
"(",
"x",
")",
")",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"CONST",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
"==",
"PLUS",
")",
"{",
"rtx",
"p0",
",",
"p1",
";",
"p0",
"=",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"0",
")",
";",
"p1",
"=",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"1",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"p1",
")",
"==",
"CONST_INT",
")",
"{",
"if",
"(",
"(",
"GET_CODE",
"(",
"p0",
")",
"==",
"UNSPEC",
")",
")",
"return",
"false",
";",
"if",
"(",
"(",
"GET_CODE",
"(",
"p0",
")",
"==",
"SYMBOL_REF",
"||",
"GET_CODE",
"(",
"p0",
")",
"==",
"LABEL_REF",
")",
"&&",
"(",
"microblaze_tls_symbol_p",
"(",
"p0",
")",
"||",
"!",
"SMALL_INT",
"(",
"p1",
")",
")",
")",
"return",
"false",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_LEGITIMATE_CONSTANT_P",
".",
"At",
"present",
",",
"GAS",
"does",
"n't",
"understand",
"li",
".",
"[",
"sd",
"]",
",",
"so",
"do",
"n't",
"allow",
"it",
"to",
"be",
"generated",
"at",
"present",
"."
] | [
"microblaze",
"0",
"0",
"0",
"0",
"1"
] | microblaze | microblaze_legitimate_constant_p | microblaze | MPU | GCC | 8,801 | 165 | 1 | [] |
[
"<s>",
"const",
"PPCMCExpr",
"*",
"PPCMCExpr",
"::",
"Create",
"(",
"VariantKind",
"Kind",
",",
"const",
"MCExpr",
"*",
"Expr",
",",
"bool",
"isDarwin",
",",
"MCContext",
"&",
"Ctx",
")",
"{",
"return",
"new",
"(",
"Ctx",
")",
"PPCMCExpr",
"(",
"Kind",
",",
"Expr",
",",
"isDarwin",
")",
";",
"}",
"</s>"
] | [
"Construct",
"a",
"unary",
"instruction",
",",
"given",
"the",
"opcode",
"and",
"an",
"operand",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"PPC"
] | PPCMCExpr (2) | Create | PowerPC | CPU | LLVM | 8,802 | 38 | 1 | [] |
[
"<s>",
"MCSymbol",
"*",
"OR1KMCInstLower",
"::",
"GetBlockAddressSymbol",
"(",
"const",
"MachineOperand",
"&",
"MO",
")",
"const",
"{",
"return",
"Printer",
".",
"GetBlockAddressSymbol",
"(",
"MO",
".",
"getBlockAddress",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"MCSymbol",
"used",
"to",
"satisfy",
"BlockAddress",
"uses",
"of",
"the",
"specified",
"basic",
"block",
"."
] | [
"OR1K",
"OR1K"
] | OR1KMCInstLower | GetBlockAddressSymbol | OR1K | CPU | LLVM | 8,803 | 26 | 1 | [] |
[
"<s>",
"bool",
"isLegalMaskedStore",
"(",
"Type",
"*",
"DataTy",
",",
"Align",
"Alignment",
")",
"{",
"return",
"isLegalMaskedLoad",
"(",
"DataTy",
",",
"Alignment",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"target",
"supports",
"masked",
"store",
"."
] | [
"ARM"
] | ARMTargetTransformInfo (2)1 | isLegalMaskedStore | ARM | CPU | LLVM | 8,804 | 20 | 1 | [] |
[
"<s>",
"void",
"MipsTargetELFStreamer",
"::",
"emitAssignment",
"(",
"MCSymbol",
"*",
"Symbol",
",",
"const",
"MCExpr",
"*",
"Value",
")",
"{",
"if",
"(",
"Value",
"->",
"getKind",
"(",
")",
"!=",
"MCExpr",
"::",
"SymbolRef",
")",
"return",
";",
"const",
"MCSymbol",
"&",
"RhsSym",
"=",
"static_cast",
"<",
"const",
"MCSymbolRefExpr",
"*",
">",
"(",
"Value",
")",
"->",
"getSymbol",
"(",
")",
";",
"MCSymbolData",
"&",
"Data",
"=",
"getStreamer",
"(",
")",
".",
"getOrCreateSymbolData",
"(",
"&",
"RhsSym",
")",
";",
"uint8_t",
"Type",
"=",
"MCELF",
"::",
"GetType",
"(",
"Data",
")",
";",
"if",
"(",
"(",
"Type",
"!=",
"ELF",
"::",
"STT_FUNC",
")",
"||",
"!",
"(",
"MCELF",
"::",
"getOther",
"(",
"Data",
")",
"&",
"(",
"ELF",
"::",
"STO_MIPS_MICROMIPS",
">>",
"2",
")",
")",
")",
"return",
";",
"MCSymbolData",
"&",
"SymbolData",
"=",
"getStreamer",
"(",
")",
".",
"getOrCreateSymbolData",
"(",
"Symbol",
")",
";",
"MCELF",
"::",
"setOther",
"(",
"SymbolData",
",",
"ELF",
"::",
"STO_MIPS_MICROMIPS",
">>",
"2",
")",
";",
"}",
"</s>"
] | [
"Emit",
"an",
"assignment",
"of",
"Value",
"to",
"Symbol",
"."
] | [
"Mips",
"Mips",
"2",
"2"
] | MipsTargetStreamer11 | emitAssignment | Mips | CPU | LLVM | 8,805 | 129 | 1 | [] |
[
"<s>",
"bool",
"MOSCallLowering",
"::",
"lowerFormalArguments",
"(",
"MachineIRBuilder",
"&",
"MIRBuilder",
",",
"const",
"Function",
"&",
"F",
",",
"ArrayRef",
"<",
"ArrayRef",
"<",
"Register",
">>",
"VRegs",
",",
"FunctionLoweringInfo",
"&",
"FLI",
")",
"const",
"{",
"MachineFunction",
"&",
"MF",
"=",
"MIRBuilder",
".",
"getMF",
"(",
")",
";",
"const",
"DataLayout",
"&",
"DL",
"=",
"MF",
".",
"getDataLayout",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"const",
"auto",
"&",
"TFI",
"=",
"static_cast",
"<",
"const",
"MOSFrameLowering",
"&",
">",
"(",
"*",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getFrameLowering",
"(",
")",
")",
";",
"if",
"(",
"TFI",
".",
"isISR",
"(",
"MF",
")",
")",
"MIRBuilder",
".",
"buildInstr",
"(",
"MOS",
"::",
"CLD_Implied",
")",
";",
"SmallVector",
"<",
"ArgInfo",
">",
"SplitArgs",
";",
"unsigned",
"Idx",
"=",
"0",
";",
"for",
"(",
"auto",
"&",
"Arg",
":",
"F",
".",
"args",
"(",
")",
")",
"{",
"if",
"(",
"DL",
".",
"getTypeStoreSize",
"(",
"Arg",
".",
"getType",
"(",
")",
")",
".",
"isZero",
"(",
")",
")",
"continue",
";",
"ArgInfo",
"OrigArg",
"{",
"VRegs",
"[",
"Idx",
"]",
",",
"Arg",
".",
"getType",
"(",
")",
",",
"Idx",
"}",
";",
"setArgFlags",
"(",
"OrigArg",
",",
"Idx",
"+",
"AttributeList",
"::",
"FirstArgIndex",
",",
"DL",
",",
"F",
")",
";",
"splitToValueTypes",
"(",
"OrigArg",
",",
"SplitArgs",
",",
"DL",
")",
";",
"++",
"Idx",
";",
"}",
"MOSIncomingArgsHandler",
"Handler",
"(",
"MIRBuilder",
",",
"MRI",
")",
";",
"MOSValueAssigner",
"Assigner",
"(",
"true",
",",
"MRI",
",",
"MF",
")",
";",
"if",
"(",
"!",
"determineAndHandleAssignments",
"(",
"Handler",
",",
"Assigner",
",",
"SplitArgs",
",",
"MIRBuilder",
",",
"F",
".",
"getCallingConv",
"(",
")",
",",
"F",
".",
"isVarArg",
"(",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"F",
".",
"isVarArg",
"(",
")",
")",
"{",
"auto",
"*",
"FuncInfo",
"=",
"MF",
".",
"getInfo",
"<",
"MOSFunctionInfo",
">",
"(",
")",
";",
"FuncInfo",
"->",
"setVarArgsStackIndex",
"(",
"MF",
".",
"getFrameInfo",
"(",
")",
".",
"CreateFixedObject",
"(",
"1",
",",
"Assigner",
".",
"StackOffset",
",",
"true",
")",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"the",
"incoming",
"(",
"formal",
")",
"arguments",
",",
"described",
"by",
"VRegs",
",",
"for",
"GlobalISel",
"."
] | [
"MOS",
"MOS",
"MOS",
"MOS::CLD_Implied",
"0",
"MOS",
"MOS",
"MOS",
"1"
] | MOSCallLowering | lowerFormalArguments | MOS | MPU | LLVM | 8,806 | 285 | 1 | [] |
[
"<s>",
"bool",
"isMem",
"(",
")",
"const",
"override",
"{",
"return",
"Kind",
"==",
"k_Memory",
";",
"}",
"</s>"
] | [
"isMem",
"-",
"Is",
"this",
"a",
"memory",
"operand",
"?"
] | [
"P2"
] | P2AsmParser | isMem | P2 | MPU | LLVM | 8,807 | 13 | 1 | [] |
[
"<s>",
"unsigned",
"TeakInstrInfo",
"::",
"getInstSizeInBytes",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"return",
"get",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
".",
"getSize",
"(",
")",
">>",
"1",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"size",
"in",
"bytes",
"of",
"the",
"specified",
"MachineInstr",
",",
"or",
"~0U",
"when",
"this",
"function",
"is",
"not",
"implemented",
"by",
"a",
"target",
"."
] | [
"Teak",
"Teak",
"1"
] | TeakInstrInfo | getInstSizeInBytes | Teak | DSP | LLVM | 8,808 | 29 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"estimateStackSize",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"const",
"MachineFrameInfo",
"*",
"FFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"int",
"Offset",
"=",
"0",
";",
"for",
"(",
"int",
"i",
"=",
"FFI",
"->",
"getObjectIndexBegin",
"(",
")",
";",
"i",
"!=",
"0",
";",
"++",
"i",
")",
"{",
"int",
"FixedOff",
"=",
"-",
"FFI",
"->",
"getObjectOffset",
"(",
"i",
")",
";",
"if",
"(",
"FixedOff",
">",
"Offset",
")",
"Offset",
"=",
"FixedOff",
";",
"}",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"FFI",
"->",
"getObjectIndexEnd",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"if",
"(",
"FFI",
"->",
"isDeadObjectIndex",
"(",
"i",
")",
")",
"continue",
";",
"Offset",
"+=",
"FFI",
"->",
"getObjectSize",
"(",
"i",
")",
";",
"unsigned",
"Align",
"=",
"FFI",
"->",
"getObjectAlignment",
"(",
"i",
")",
";",
"Offset",
"=",
"(",
"Offset",
"+",
"Align",
"-",
"1",
")",
"/",
"Align",
"*",
"Align",
";",
"}",
"return",
"(",
"unsigned",
")",
"Offset",
";",
"}",
"</s>"
] | [
"Estimate",
"and",
"return",
"the",
"size",
"of",
"the",
"stack",
"frame",
"."
] | [
"ARM",
"0",
"0",
"0",
"1"
] | ARMBaseRegisterInfo12 | estimateStackSize | ARM | CPU | LLVM | 8,809 | 141 | 1 | [] |
[
"<s>",
"DecodeStatus",
"AVRDisassembler",
"::",
"getInstruction",
"(",
"MCInst",
"&",
"Instr",
",",
"uint64_t",
"&",
"Size",
",",
"ArrayRef",
"<",
"uint8_t",
">",
"Bytes",
",",
"uint64_t",
"Address",
",",
"raw_ostream",
"&",
"CStream",
")",
"const",
"{",
"uint32_t",
"Insn",
";",
"DecodeStatus",
"Result",
";",
"{",
"Result",
"=",
"readInstruction16",
"(",
"Bytes",
",",
"Address",
",",
"Size",
",",
"Insn",
")",
";",
"if",
"(",
"Result",
"==",
"MCDisassembler",
"::",
"Fail",
")",
"return",
"MCDisassembler",
"::",
"Fail",
";",
"Result",
"=",
"decodeInstruction",
"(",
"getDecoderTable",
"(",
"Size",
")",
",",
"Instr",
",",
"Insn",
",",
"Address",
",",
"this",
",",
"STI",
")",
";",
"if",
"(",
"Result",
"!=",
"MCDisassembler",
"::",
"Fail",
")",
"return",
"Result",
";",
"}",
"{",
"Result",
"=",
"readInstruction32",
"(",
"Bytes",
",",
"Address",
",",
"Size",
",",
"Insn",
")",
";",
"if",
"(",
"Result",
"==",
"MCDisassembler",
"::",
"Fail",
")",
"return",
"MCDisassembler",
"::",
"Fail",
";",
"Result",
"=",
"decodeInstruction",
"(",
"getDecoderTable",
"(",
"Size",
")",
",",
"Instr",
",",
"Insn",
",",
"Address",
",",
"this",
",",
"STI",
")",
";",
"if",
"(",
"Result",
"!=",
"MCDisassembler",
"::",
"Fail",
")",
"{",
"return",
"Result",
";",
"}",
"return",
"MCDisassembler",
"::",
"Fail",
";",
"}",
"}",
"</s>"
] | [
"Returns",
"the",
"disassembly",
"of",
"a",
"single",
"instruction",
"."
] | [
"AVR",
"AVR"
] | AVRDisassembler | getInstruction | AVR | MPU | LLVM | 8,810 | 160 | 1 | [] |
[
"<s>",
"bool",
"sh_loads_bankedreg_p",
"(",
"rtx",
"insn",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"SET",
")",
"{",
"rtx",
"op",
"=",
"SET_DEST",
"(",
"PATTERN",
"(",
"insn",
")",
")",
";",
"if",
"(",
"REG_P",
"(",
"op",
")",
"&&",
"BANKED_REGISTER_P",
"(",
"REGNO",
"(",
"op",
")",
")",
")",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"iff",
"INSN",
"loads",
"a",
"banked",
"register",
"."
] | [
"sh"
] | sh | sh_loads_bankedreg_p | sh | CPU | GCC | 8,811 | 54 | 1 | [] |
[
"<s>",
"static",
"SDValue",
"getTargetNode",
"(",
"ConstantPoolSDNode",
"*",
"N",
",",
"SDLoc",
"DL",
",",
"EVT",
"Ty",
",",
"SelectionDAG",
"&",
"DAG",
",",
"unsigned",
"Flags",
")",
"{",
"return",
"DAG",
".",
"getTargetConstantPool",
"(",
"N",
"->",
"getConstVal",
"(",
")",
",",
"Ty",
",",
"N",
"->",
"getAlignment",
"(",
")",
",",
"N",
"->",
"getOffset",
"(",
")",
",",
"Flags",
")",
";",
"}",
"</s>"
] | [
"Retrieve",
"the",
"target",
"node",
"this",
"edge",
"connects",
"to",
"."
] | [
"TL45"
] | TL45ISelLowering | getTargetNode | TL45 | MPU | LLVM | 8,812 | 51 | 1 | [] |
[
"<s>",
"MachineBasicBlock",
"::",
"iterator",
"AVRFrameLowering",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
")",
"const",
"{",
"const",
"AVRSubtarget",
"&",
"STI",
"=",
"MF",
".",
"getSubtarget",
"<",
"AVRSubtarget",
">",
"(",
")",
";",
"const",
"TargetFrameLowering",
"&",
"TFI",
"=",
"*",
"STI",
".",
"getFrameLowering",
"(",
")",
";",
"const",
"AVRInstrInfo",
"&",
"TII",
"=",
"*",
"STI",
".",
"getInstrInfo",
"(",
")",
";",
"if",
"(",
"TFI",
".",
"hasReservedCallFrame",
"(",
"MF",
")",
")",
"{",
"fixStackStores",
"(",
"MBB",
",",
"MI",
",",
"TII",
",",
"false",
")",
";",
"return",
"MBB",
".",
"erase",
"(",
"MI",
")",
";",
"}",
"DebugLoc",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"unsigned",
"int",
"Opcode",
"=",
"MI",
"->",
"getOpcode",
"(",
")",
";",
"int",
"Amount",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"Amount",
"!=",
"0",
")",
"{",
"assert",
"(",
"TFI",
".",
"getStackAlignment",
"(",
")",
"==",
"1",
"&&",
"\"Unsupported stack alignment\"",
")",
";",
"if",
"(",
"Opcode",
"==",
"TII",
".",
"getCallFrameSetupOpcode",
"(",
")",
")",
"{",
"fixStackStores",
"(",
"MBB",
",",
"MI",
",",
"TII",
",",
"true",
")",
";",
"}",
"else",
"{",
"assert",
"(",
"Opcode",
"==",
"TII",
".",
"getCallFrameDestroyOpcode",
"(",
")",
")",
";",
"unsigned",
"addOpcode",
";",
"if",
"(",
"isUInt",
"<",
"6",
">",
"(",
"Amount",
")",
")",
"{",
"addOpcode",
"=",
"AVR",
"::",
"ADIWRdK",
";",
"}",
"else",
"{",
"addOpcode",
"=",
"AVR",
"::",
"SUBIWRdK",
";",
"Amount",
"=",
"-",
"Amount",
";",
"}",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"AVR",
"::",
"SPREAD",
")",
",",
"AVR",
"::",
"R31R30",
")",
".",
"addReg",
"(",
"AVR",
"::",
"SP",
")",
";",
"MachineInstr",
"*",
"New",
"=",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"addOpcode",
")",
",",
"AVR",
"::",
"R31R30",
")",
".",
"addReg",
"(",
"AVR",
"::",
"R31R30",
",",
"RegState",
"::",
"Kill",
")",
".",
"addImm",
"(",
"Amount",
")",
";",
"New",
"->",
"getOperand",
"(",
"3",
")",
".",
"setIsDead",
"(",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"AVR",
"::",
"SPWRITE",
")",
",",
"AVR",
"::",
"SP",
")",
".",
"addReg",
"(",
"AVR",
"::",
"R31R30",
",",
"RegState",
"::",
"Kill",
")",
";",
"}",
"}",
"return",
"MBB",
".",
"erase",
"(",
"MI",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"is",
"called",
"during",
"prolog/epilog",
"code",
"insertion",
"to",
"eliminate",
"call",
"frame",
"setup",
"and",
"destroy",
"pseudo",
"instructions",
"(",
"but",
"only",
"if",
"the",
"Target",
"is",
"using",
"them",
")",
"."
] | [
"AVR",
"AVR",
"AVR",
"AVR",
"AVR",
"0",
"0",
"1",
"\"Unsupported stack alignment\"",
"6",
"AVR::ADIWRdK",
"AVR::SUBIWRdK",
"AVR::SPREAD",
"AVR::R31R30",
"AVR::SP",
"AVR::R31R30",
"AVR::R31R30",
"3",
"AVR::SPWRITE",
"AVR::SP",
"AVR::R31R30"
] | AVRFrameLowering12 | eliminateCallFramePseudoInstr | AVR | MPU | LLVM | 8,813 | 338 | 1 | [] |
[
"<s>",
"virtual",
"const",
"DataLayout",
"*",
"getDataLayout",
"(",
")",
"const",
"{",
"return",
"&",
"Layout",
";",
"}",
"</s>"
] | [
"Return",
"the",
"DataLayout",
"associated",
"with",
"the",
"module",
"this",
"SCEV",
"instance",
"is",
"operating",
"on",
"."
] | [
"R600"
] | AMDGPUTargetMachine20 | getDataLayout | R600 | GPU | LLVM | 8,814 | 14 | 1 | [] |
[
"<s>",
"MCSection",
"*",
"LanaiTargetObjectFile",
"::",
"getSectionForConstant",
"(",
"const",
"DataLayout",
"&",
"DL",
",",
"SectionKind",
"Kind",
",",
"const",
"Constant",
"*",
"C",
",",
"unsigned",
"&",
"Align",
")",
"const",
"{",
"if",
"(",
"isConstantInSmallSection",
"(",
"DL",
",",
"C",
")",
")",
"return",
"SmallDataSection",
";",
"return",
"TargetLoweringObjectFileELF",
"::",
"getSectionForConstant",
"(",
"DL",
",",
"Kind",
",",
"C",
",",
"Align",
")",
";",
"}",
"</s>"
] | [
"Given",
"a",
"constant",
"with",
"the",
"SectionKind",
",",
"return",
"a",
"section",
"that",
"it",
"should",
"be",
"placed",
"in",
"."
] | [
"Lanai",
"Lanai"
] | LanaiTargetObjectFile | getSectionForConstant | Lanai | CPU | LLVM | 8,815 | 52 | 1 | [] |
[
"<s>",
"static",
"bool",
"v850_legitimate_address_p",
"(",
"machine_mode",
"mode",
",",
"rtx",
"x",
",",
"bool",
"strict_p",
",",
"addr_space_t",
"as",
"ATTRIBUTE_UNUSED",
")",
"{",
"gcc_assert",
"(",
"ADDR_SPACE_GENERIC_P",
"(",
"as",
")",
")",
";",
"if",
"(",
"v850_rtx_ok_for_base_p",
"(",
"x",
",",
"strict_p",
")",
")",
"return",
"true",
";",
"if",
"(",
"CONSTANT_ADDRESS_P",
"(",
"x",
")",
"&&",
"(",
"mode",
"==",
"QImode",
"||",
"INTVAL",
"(",
"x",
")",
"%",
"2",
"==",
"0",
")",
"&&",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
"<=",
"4",
"||",
"INTVAL",
"(",
"x",
")",
"%",
"4",
"==",
"0",
")",
")",
"return",
"true",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"LO_SUM",
"&&",
"REG_P",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
"&&",
"v850_reg_ok_for_base_p",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"strict_p",
")",
"&&",
"CONSTANT_P",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
"&&",
"(",
"!",
"CONST_INT_P",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
"||",
"(",
"(",
"mode",
"==",
"QImode",
"||",
"INTVAL",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
"%",
"2",
"==",
"0",
")",
"&&",
"constraint_satisfied_p",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
",",
"CONSTRAINT_K",
")",
")",
")",
"&&",
"GET_MODE_SIZE",
"(",
"mode",
")",
"<=",
"GET_MODE_SIZE",
"(",
"word_mode",
")",
")",
"return",
"true",
";",
"if",
"(",
"special_symbolref_operand",
"(",
"x",
",",
"mode",
")",
"&&",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
"<=",
"GET_MODE_SIZE",
"(",
"word_mode",
")",
")",
")",
"return",
"true",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"PLUS",
"&&",
"v850_rtx_ok_for_base_p",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"strict_p",
")",
"&&",
"constraint_satisfied_p",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
",",
"CONSTRAINT_K",
")",
"&&",
"(",
"(",
"mode",
"==",
"QImode",
"||",
"INTVAL",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
"%",
"2",
"==",
"0",
")",
"&&",
"CONST_OK_FOR_K",
"(",
"INTVAL",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
"+",
"(",
"GET_MODE_NUNITS",
"(",
"mode",
")",
"*",
"UNITS_PER_WORD",
")",
")",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_LEGITIMATE_ADDRESS_P",
"."
] | [
"v850",
"2",
"0",
"4",
"4",
"0",
"0",
"0",
"1",
"1",
"1",
"2",
"0",
"1",
"0",
"1",
"1",
"2",
"0",
"1"
] | v8505 | v850_legitimate_address_p | v850 | MPU | GCC | 8,816 | 290 | 1 | [] |
[
"<s>",
"bool",
"ARMAsmPrinter",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"MCP",
"=",
"MF",
".",
"getConstantPool",
"(",
")",
";",
"Subtarget",
"=",
"&",
"MF",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
";",
"SetupMachineFunction",
"(",
"MF",
")",
";",
"const",
"Function",
"*",
"F",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"const",
"TargetMachine",
"&",
"TM",
"=",
"MF",
".",
"getTarget",
"(",
")",
";",
"unsigned",
"OptimizationGoal",
";",
"if",
"(",
"F",
"->",
"hasFnAttribute",
"(",
"Attribute",
"::",
"OptimizeNone",
")",
")",
"OptimizationGoal",
"=",
"6",
";",
"else",
"if",
"(",
"F",
"->",
"optForMinSize",
"(",
")",
")",
"OptimizationGoal",
"=",
"4",
";",
"else",
"if",
"(",
"F",
"->",
"optForSize",
"(",
")",
")",
"OptimizationGoal",
"=",
"3",
";",
"else",
"if",
"(",
"TM",
".",
"getOptLevel",
"(",
")",
"==",
"CodeGenOpt",
"::",
"Aggressive",
")",
"OptimizationGoal",
"=",
"2",
";",
"else",
"if",
"(",
"TM",
".",
"getOptLevel",
"(",
")",
">",
"CodeGenOpt",
"::",
"None",
")",
"OptimizationGoal",
"=",
"1",
";",
"else",
"OptimizationGoal",
"=",
"5",
";",
"if",
"(",
"OptimizationGoals",
"==",
"-",
"1",
")",
"OptimizationGoals",
"=",
"OptimizationGoal",
";",
"else",
"if",
"(",
"OptimizationGoals",
"!=",
"(",
"int",
")",
"OptimizationGoal",
")",
"OptimizationGoals",
"=",
"0",
";",
"if",
"(",
"Subtarget",
"->",
"isTargetCOFF",
"(",
")",
")",
"{",
"bool",
"Internal",
"=",
"F",
"->",
"hasInternalLinkage",
"(",
")",
";",
"COFF",
"::",
"SymbolStorageClass",
"Scl",
"=",
"Internal",
"?",
"COFF",
"::",
"IMAGE_SYM_CLASS_STATIC",
":",
"COFF",
"::",
"IMAGE_SYM_CLASS_EXTERNAL",
";",
"int",
"Type",
"=",
"COFF",
"::",
"IMAGE_SYM_DTYPE_FUNCTION",
"<<",
"COFF",
"::",
"SCT_COMPLEX_TYPE_SHIFT",
";",
"OutStreamer",
"->",
"BeginCOFFSymbolDef",
"(",
"CurrentFnSym",
")",
";",
"OutStreamer",
"->",
"EmitCOFFSymbolStorageClass",
"(",
"Scl",
")",
";",
"OutStreamer",
"->",
"EmitCOFFSymbolType",
"(",
"Type",
")",
";",
"OutStreamer",
"->",
"EndCOFFSymbolDef",
"(",
")",
";",
"}",
"EmitFunctionBody",
"(",
")",
";",
"if",
"(",
"!",
"ThumbIndirectPads",
".",
"empty",
"(",
")",
")",
"{",
"OutStreamer",
"->",
"EmitAssemblerFlag",
"(",
"MCAF_Code16",
")",
";",
"EmitAlignment",
"(",
"1",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"ThumbIndirectPads",
".",
"size",
"(",
")",
";",
"i",
"<",
"e",
";",
"i",
"++",
")",
"{",
"OutStreamer",
"->",
"EmitLabel",
"(",
"ThumbIndirectPads",
"[",
"i",
"]",
".",
"second",
")",
";",
"EmitToStreamer",
"(",
"*",
"OutStreamer",
",",
"MCInstBuilder",
"(",
"ARM",
"::",
"tBX",
")",
".",
"addReg",
"(",
"ThumbIndirectPads",
"[",
"i",
"]",
".",
"first",
")",
".",
"addImm",
"(",
"ARMCC",
"::",
"AL",
")",
".",
"addReg",
"(",
"0",
")",
")",
";",
"}",
"ThumbIndirectPads",
".",
"clear",
"(",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"6",
"4",
"3",
"2",
"1",
"5",
"1",
"0",
"1",
"0",
"ARM::tBX",
"ARMCC::AL",
"0"
] | ARMAsmPrinter102 | runOnMachineFunction | ARM | CPU | LLVM | 8,817 | 356 | 1 | [] |
[
"<s>",
"void",
"aarch64_gen_atomic_ldop",
"(",
"enum",
"rtx_code",
"code",
",",
"rtx",
"out_data",
",",
"rtx",
"out_result",
",",
"rtx",
"mem",
",",
"rtx",
"value",
",",
"rtx",
"model_rtx",
")",
"{",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"mem",
")",
";",
"machine_mode",
"wmode",
"=",
"(",
"mode",
"==",
"DImode",
"?",
"DImode",
":",
"SImode",
")",
";",
"const",
"bool",
"short_mode",
"=",
"(",
"mode",
"<",
"SImode",
")",
";",
"aarch64_atomic_load_op_code",
"ldop_code",
";",
"rtx",
"src",
";",
"rtx",
"x",
";",
"if",
"(",
"out_data",
")",
"out_data",
"=",
"gen_lowpart",
"(",
"mode",
",",
"out_data",
")",
";",
"if",
"(",
"out_result",
")",
"out_result",
"=",
"gen_lowpart",
"(",
"mode",
",",
"out_result",
")",
";",
"if",
"(",
"!",
"register_operand",
"(",
"value",
",",
"mode",
")",
"||",
"code",
"==",
"AND",
"||",
"code",
"==",
"MINUS",
")",
"{",
"src",
"=",
"out_result",
"?",
"out_result",
":",
"out_data",
";",
"emit_move_insn",
"(",
"src",
",",
"gen_lowpart",
"(",
"mode",
",",
"value",
")",
")",
";",
"}",
"else",
"src",
"=",
"value",
";",
"gcc_assert",
"(",
"register_operand",
"(",
"src",
",",
"mode",
")",
")",
";",
"switch",
"(",
"code",
")",
"{",
"case",
"SET",
":",
"aarch64_emit_atomic_swap",
"(",
"mode",
",",
"out_data",
",",
"src",
",",
"mem",
",",
"model_rtx",
")",
";",
"return",
";",
"case",
"MINUS",
":",
"{",
"rtx",
"neg_src",
";",
"if",
"(",
"short_mode",
")",
"src",
"=",
"gen_lowpart",
"(",
"wmode",
",",
"src",
")",
";",
"neg_src",
"=",
"gen_rtx_NEG",
"(",
"wmode",
",",
"src",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"src",
",",
"neg_src",
")",
")",
";",
"if",
"(",
"short_mode",
")",
"src",
"=",
"gen_lowpart",
"(",
"mode",
",",
"src",
")",
";",
"}",
"case",
"PLUS",
":",
"ldop_code",
"=",
"AARCH64_LDOP_PLUS",
";",
"break",
";",
"case",
"IOR",
":",
"ldop_code",
"=",
"AARCH64_LDOP_OR",
";",
"break",
";",
"case",
"XOR",
":",
"ldop_code",
"=",
"AARCH64_LDOP_XOR",
";",
"break",
";",
"case",
"AND",
":",
"{",
"rtx",
"not_src",
";",
"if",
"(",
"short_mode",
")",
"src",
"=",
"gen_lowpart",
"(",
"wmode",
",",
"src",
")",
";",
"not_src",
"=",
"gen_rtx_NOT",
"(",
"wmode",
",",
"src",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"src",
",",
"not_src",
")",
")",
";",
"if",
"(",
"short_mode",
")",
"src",
"=",
"gen_lowpart",
"(",
"mode",
",",
"src",
")",
";",
"}",
"ldop_code",
"=",
"AARCH64_LDOP_BIC",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"aarch64_emit_atomic_load_op",
"(",
"ldop_code",
",",
"mode",
",",
"out_data",
",",
"src",
",",
"mem",
",",
"model_rtx",
")",
";",
"if",
"(",
"!",
"out_result",
")",
"return",
";",
"if",
"(",
"short_mode",
")",
"{",
"src",
"=",
"gen_lowpart",
"(",
"wmode",
",",
"src",
")",
";",
"out_data",
"=",
"gen_lowpart",
"(",
"wmode",
",",
"out_data",
")",
";",
"out_result",
"=",
"gen_lowpart",
"(",
"wmode",
",",
"out_result",
")",
";",
"}",
"x",
"=",
"NULL_RTX",
";",
"switch",
"(",
"code",
")",
"{",
"case",
"MINUS",
":",
"case",
"PLUS",
":",
"x",
"=",
"gen_rtx_PLUS",
"(",
"wmode",
",",
"out_data",
",",
"src",
")",
";",
"break",
";",
"case",
"IOR",
":",
"x",
"=",
"gen_rtx_IOR",
"(",
"wmode",
",",
"out_data",
",",
"src",
")",
";",
"break",
";",
"case",
"XOR",
":",
"x",
"=",
"gen_rtx_XOR",
"(",
"wmode",
",",
"out_data",
",",
"src",
")",
";",
"break",
";",
"case",
"AND",
":",
"aarch64_emit_bic",
"(",
"wmode",
",",
"out_result",
",",
"out_data",
",",
"src",
",",
"0",
")",
";",
"return",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"emit_set_insn",
"(",
"out_result",
",",
"x",
")",
";",
"return",
";",
"}",
"</s>"
] | [
"Emit",
"an",
"atomic",
"load+operate",
".",
"CODE",
"is",
"the",
"operation",
".",
"OUT_DATA",
"is",
"the",
"location",
"to",
"store",
"the",
"data",
"read",
"from",
"memory",
".",
"OUT_RESULT",
"is",
"the",
"location",
"to",
"store",
"the",
"result",
"of",
"the",
"operation",
".",
"MEM",
"is",
"the",
"memory",
"location",
"to",
"read",
"and",
"modify",
".",
"MODEL_RTX",
"is",
"the",
"memory",
"ordering",
"to",
"use",
".",
"VALUE",
"is",
"the",
"second",
"operand",
"for",
"the",
"operation",
".",
"Either",
"OUT_DATA",
"or",
"OUT_RESULT",
",",
"but",
"not",
"both",
",",
"can",
"be",
"NULL",
"."
] | [
"aarch64",
"0"
] | aarch643 | aarch64_gen_atomic_ldop | aarch64 | CPU | GCC | 8,818 | 463 | 1 | [] |
[
"<s>",
"bool",
"MipsSEInstrInfo",
"::",
"isReallyTriviallyReMaterializable",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"AAResults",
"*",
"AA",
")",
"const",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"Mips",
"::",
"CheriBoundedStackPseudoImm",
":",
"assert",
"(",
"MI",
".",
"getOperand",
"(",
"3",
")",
".",
"isImm",
"(",
")",
")",
";",
"return",
"true",
";",
"case",
"Mips",
"::",
"CIncOffsetImm",
":",
"case",
"Mips",
"::",
"CMove",
":",
"case",
"Mips",
"::",
"COPY",
":",
"return",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"isReg",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
"==",
"Mips",
"::",
"CNULL",
";",
"case",
"Mips",
"::",
"LUi64",
":",
"{",
"auto",
"Flags",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getTargetFlags",
"(",
")",
";",
"if",
"(",
"Flags",
"==",
"MipsII",
"::",
"MO_CAPTABLE_OFF_HI",
")",
"{",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"default",
":",
"return",
"false",
";",
"}",
"}",
"</s>"
] | [
"For",
"instructions",
"with",
"opcodes",
"for",
"which",
"the",
"M_REMATERIALIZABLE",
"flag",
"is",
"set",
",",
"this",
"hook",
"lets",
"the",
"target",
"specify",
"whether",
"the",
"instruction",
"is",
"actually",
"trivially",
"rematerializable",
",",
"taking",
"into",
"consideration",
"its",
"operands",
"."
] | [
"Mips",
"Mips",
"Mips::CheriBoundedStackPseudoImm",
"3",
"Mips::CIncOffsetImm",
"Mips::CMove",
"Mips::COPY",
"1",
"1",
"Mips::CNULL",
"Mips::LUi64",
"1",
"MipsII::MO_CAPTABLE_OFF_HI"
] | MipsSEInstrInfo30 | isReallyTriviallyReMaterializable | Mips | CPU | LLVM | 8,819 | 133 | 1 | [] |
[
"<s>",
"StringRef",
"SIRegisterInfo",
"::",
"getRegAsmName",
"(",
"unsigned",
"Reg",
")",
"const",
"{",
"switch",
"(",
"Reg",
")",
"{",
"case",
"AMDGPU",
"::",
"FLAT_SCR",
":",
"return",
"\"flat_scratch\"",
";",
"case",
"AMDGPU",
"::",
"FLAT_SCR_LO",
":",
"return",
"\"flat_scratch_lo\"",
";",
"case",
"AMDGPU",
"::",
"FLAT_SCR_HI",
":",
"return",
"\"flat_scratch_hi\"",
";",
"default",
":",
"break",
";",
"}",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"getMinimalPhysRegClass",
"(",
"Reg",
")",
";",
"unsigned",
"Size",
"=",
"getRegSizeInBits",
"(",
"*",
"RC",
")",
";",
"unsigned",
"AltName",
"=",
"AMDGPU",
"::",
"NoRegAltName",
";",
"switch",
"(",
"Size",
")",
"{",
"case",
"32",
":",
"AltName",
"=",
"AMDGPU",
"::",
"Reg32",
";",
"break",
";",
"case",
"64",
":",
"AltName",
"=",
"AMDGPU",
"::",
"Reg64",
";",
"break",
";",
"case",
"96",
":",
"AltName",
"=",
"AMDGPU",
"::",
"Reg96",
";",
"break",
";",
"case",
"128",
":",
"AltName",
"=",
"AMDGPU",
"::",
"Reg128",
";",
"break",
";",
"case",
"160",
":",
"AltName",
"=",
"AMDGPU",
"::",
"Reg160",
";",
"break",
";",
"case",
"256",
":",
"AltName",
"=",
"AMDGPU",
"::",
"Reg256",
";",
"break",
";",
"case",
"512",
":",
"AltName",
"=",
"AMDGPU",
"::",
"Reg512",
";",
"break",
";",
"case",
"1024",
":",
"AltName",
"=",
"AMDGPU",
"::",
"Reg1024",
";",
"break",
";",
"}",
"return",
"AMDGPUInstPrinter",
"::",
"getRegisterName",
"(",
"Reg",
",",
"AltName",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"assembly",
"name",
"for",
"Reg",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU::FLAT_SCR",
"\"flat_scratch\"",
"AMDGPU::FLAT_SCR_LO",
"\"flat_scratch_lo\"",
"AMDGPU::FLAT_SCR_HI",
"\"flat_scratch_hi\"",
"AMDGPU::NoRegAltName",
"32",
"AMDGPU::Reg32",
"64",
"AMDGPU::Reg64",
"96",
"AMDGPU::Reg96",
"128",
"AMDGPU::Reg128",
"160",
"AMDGPU::Reg160",
"256",
"AMDGPU::Reg256",
"512",
"AMDGPU::Reg512",
"1024",
"AMDGPU::Reg1024",
"AMDGPU"
] | SIRegisterInfo89 | getRegAsmName | AMDGPU | GPU | LLVM | 8,820 | 175 | 1 | [] |
[
"<s>",
"bool",
"X86CallLowering",
"::",
"lowerFormalArguments",
"(",
"MachineIRBuilder",
"&",
"MIRBuilder",
",",
"const",
"Function",
"&",
"F",
",",
"ArrayRef",
"<",
"unsigned",
">",
"VRegs",
")",
"const",
"{",
"if",
"(",
"F",
".",
"arg_empty",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"F",
".",
"isVarArg",
"(",
")",
")",
"return",
"false",
";",
"MachineFunction",
"&",
"MF",
"=",
"MIRBuilder",
".",
"getMF",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"auto",
"DL",
"=",
"MF",
".",
"getDataLayout",
"(",
")",
";",
"SmallVector",
"<",
"ArgInfo",
",",
"8",
">",
"SplitArgs",
";",
"unsigned",
"Idx",
"=",
"0",
";",
"for",
"(",
"auto",
"&",
"Arg",
":",
"F",
".",
"args",
"(",
")",
")",
"{",
"if",
"(",
"Arg",
".",
"hasAttribute",
"(",
"Attribute",
"::",
"ByVal",
")",
"||",
"Arg",
".",
"hasAttribute",
"(",
"Attribute",
"::",
"InReg",
")",
"||",
"Arg",
".",
"hasAttribute",
"(",
"Attribute",
"::",
"StructRet",
")",
"||",
"Arg",
".",
"hasAttribute",
"(",
"Attribute",
"::",
"SwiftSelf",
")",
"||",
"Arg",
".",
"hasAttribute",
"(",
"Attribute",
"::",
"SwiftError",
")",
"||",
"Arg",
".",
"hasAttribute",
"(",
"Attribute",
"::",
"Nest",
")",
")",
"return",
"false",
";",
"ArgInfo",
"OrigArg",
"(",
"VRegs",
"[",
"Idx",
"]",
",",
"Arg",
".",
"getType",
"(",
")",
")",
";",
"setArgFlags",
"(",
"OrigArg",
",",
"Idx",
"+",
"AttributeList",
"::",
"FirstArgIndex",
",",
"DL",
",",
"F",
")",
";",
"if",
"(",
"!",
"splitToValueTypes",
"(",
"OrigArg",
",",
"SplitArgs",
",",
"DL",
",",
"MRI",
",",
"[",
"&",
"]",
"(",
"ArrayRef",
"<",
"unsigned",
">",
"Regs",
")",
"{",
"MIRBuilder",
".",
"buildMerge",
"(",
"VRegs",
"[",
"Idx",
"]",
",",
"Regs",
")",
";",
"}",
")",
")",
"return",
"false",
";",
"Idx",
"++",
";",
"}",
"MachineBasicBlock",
"&",
"MBB",
"=",
"MIRBuilder",
".",
"getMBB",
"(",
")",
";",
"if",
"(",
"!",
"MBB",
".",
"empty",
"(",
")",
")",
"MIRBuilder",
".",
"setInstr",
"(",
"*",
"MBB",
".",
"begin",
"(",
")",
")",
";",
"FormalArgHandler",
"Handler",
"(",
"MIRBuilder",
",",
"MRI",
",",
"CC_X86",
")",
";",
"if",
"(",
"!",
"handleAssignments",
"(",
"MIRBuilder",
",",
"SplitArgs",
",",
"Handler",
")",
")",
"return",
"false",
";",
"MIRBuilder",
".",
"setMBB",
"(",
"MBB",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"the",
"incoming",
"(",
"formal",
")",
"arguments",
",",
"described",
"by",
"VRegs",
",",
"for",
"GlobalISel",
"."
] | [
"X86",
"X86",
"8",
"0",
"X86"
] | X86CallLowering | lowerFormalArguments | X86 | CPU | LLVM | 8,821 | 301 | 1 | [] |
[
"<s>",
"const",
"MipsMCExpr",
"*",
"MipsMCExpr",
"::",
"Create",
"(",
"VariantKind",
"Kind",
",",
"const",
"MCExpr",
"*",
"Expr",
",",
"MCContext",
"&",
"Ctx",
")",
"{",
"return",
"new",
"(",
"Ctx",
")",
"MipsMCExpr",
"(",
"Kind",
",",
"Expr",
")",
";",
"}",
"</s>"
] | [
"Construct",
"a",
"unary",
"instruction",
",",
"given",
"the",
"opcode",
"and",
"an",
"operand",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips"
] | MipsMCExpr2 | Create | Mips | CPU | LLVM | 8,822 | 33 | 1 | [] |
[
"<s>",
"const",
"MCS51InstrInfo",
"*",
"getInstrInfo",
"(",
")",
"const",
"override",
"{",
"return",
"&",
"InstrInfo",
";",
"}",
"</s>"
] | [
"TargetInstrInfo",
"getter",
"."
] | [
"MCS51",
"MCS51"
] | MCS51Subtarget | getInstrInfo | MCS51 | MPU | LLVM | 8,823 | 14 | 1 | [] |
[
"<s>",
"bool",
"GCNPassConfig",
"::",
"addPreISel",
"(",
")",
"{",
"AMDGPUPassConfig",
"::",
"addPreISel",
"(",
")",
";",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
">",
"CodeGenOpt",
"::",
"None",
")",
"addPass",
"(",
"createAMDGPULateCodeGenPreparePass",
"(",
")",
")",
";",
"if",
"(",
"isPassEnabled",
"(",
"EnableAtomicOptimizations",
",",
"CodeGenOpt",
"::",
"Less",
")",
")",
"{",
"addPass",
"(",
"createAMDGPUAtomicOptimizerPass",
"(",
")",
")",
";",
"}",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
">",
"CodeGenOpt",
"::",
"None",
")",
"addPass",
"(",
"createSinkingPass",
"(",
")",
")",
";",
"addPass",
"(",
"&",
"AMDGPUUnifyDivergentExitNodesID",
")",
";",
"if",
"(",
"!",
"LateCFGStructurize",
")",
"{",
"if",
"(",
"EnableStructurizerWorkarounds",
")",
"{",
"addPass",
"(",
"createFixIrreduciblePass",
"(",
")",
")",
";",
"addPass",
"(",
"createUnifyLoopExitsPass",
"(",
")",
")",
";",
"}",
"addPass",
"(",
"createStructurizeCFGPass",
"(",
"false",
")",
")",
";",
"}",
"addPass",
"(",
"createAMDGPUAnnotateUniformValues",
"(",
")",
")",
";",
"if",
"(",
"!",
"LateCFGStructurize",
")",
"{",
"addPass",
"(",
"createSIAnnotateControlFlowPass",
"(",
")",
")",
";",
"}",
"addPass",
"(",
"createLCSSAPass",
"(",
")",
")",
";",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
">",
"CodeGenOpt",
"::",
"Less",
")",
"addPass",
"(",
"&",
"AMDGPUPerfHintAnalysisID",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"{",
"{",
"@",
"For",
"GlobalISel"
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"SI",
"AMDGPU"
] | AMDGPUTargetMachine (2)1 | addPreISel | AMDGPU | GPU | LLVM | 8,824 | 162 | 1 | [] |
[
"<s>",
"const",
"AAPTargetMachine",
"&",
"getTargetMachine",
"(",
")",
"{",
"return",
"static_cast",
"<",
"const",
"AAPTargetMachine",
"&",
">",
"(",
"TM",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"target",
"machine",
"(",
"if",
"available",
")",
"."
] | [
"AAP",
"AAP",
"AAP"
] | AAPISelDAGToDAG | getTargetMachine | AAP | MPU | LLVM | 8,825 | 19 | 1 | [] |
[
"<s>",
"void",
"MipsMCCodeEmitter",
"::",
"encodeInstruction",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"raw_ostream",
"&",
"OS",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"MCInst",
"TmpInst",
"=",
"MI",
";",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"Mips",
"::",
"DSLL",
":",
"case",
"Mips",
"::",
"DSRL",
":",
"case",
"Mips",
"::",
"DSRA",
":",
"case",
"Mips",
"::",
"DROTR",
":",
"LowerLargeShift",
"(",
"TmpInst",
")",
";",
"break",
";",
"case",
"Mips",
"::",
"DEXT",
":",
"case",
"Mips",
"::",
"DINS",
":",
"LowerDextDins",
"(",
"TmpInst",
")",
";",
"}",
"unsigned",
"long",
"N",
"=",
"Fixups",
".",
"size",
"(",
")",
";",
"uint32_t",
"Binary",
"=",
"getBinaryCodeForInstr",
"(",
"TmpInst",
",",
"Fixups",
",",
"STI",
")",
";",
"unsigned",
"Opcode",
"=",
"TmpInst",
".",
"getOpcode",
"(",
")",
";",
"if",
"(",
"(",
"Opcode",
"!=",
"Mips",
"::",
"NOP",
")",
"&&",
"(",
"Opcode",
"!=",
"Mips",
"::",
"SLL",
")",
"&&",
"(",
"Opcode",
"!=",
"Mips",
"::",
"SLL_MM",
")",
"&&",
"!",
"Binary",
")",
"llvm_unreachable",
"(",
"\"unimplemented opcode in encodeInstruction()\"",
")",
";",
"int",
"NewOpcode",
"=",
"-",
"1",
";",
"if",
"(",
"isMicroMips",
"(",
"STI",
")",
")",
"{",
"if",
"(",
"isMips32r6",
"(",
"STI",
")",
")",
"{",
"NewOpcode",
"=",
"Mips",
"::",
"MipsR62MicroMipsR6",
"(",
"Opcode",
",",
"Mips",
"::",
"Arch_micromipsr6",
")",
";",
"if",
"(",
"NewOpcode",
"==",
"-",
"1",
")",
"NewOpcode",
"=",
"Mips",
"::",
"Std2MicroMipsR6",
"(",
"Opcode",
",",
"Mips",
"::",
"Arch_micromipsr6",
")",
";",
"}",
"else",
"NewOpcode",
"=",
"Mips",
"::",
"Std2MicroMips",
"(",
"Opcode",
",",
"Mips",
"::",
"Arch_micromips",
")",
";",
"if",
"(",
"NewOpcode",
"==",
"-",
"1",
")",
"NewOpcode",
"=",
"Mips",
"::",
"Dsp2MicroMips",
"(",
"Opcode",
",",
"Mips",
"::",
"Arch_mmdsp",
")",
";",
"if",
"(",
"NewOpcode",
"!=",
"-",
"1",
")",
"{",
"if",
"(",
"Fixups",
".",
"size",
"(",
")",
">",
"N",
")",
"Fixups",
".",
"pop_back",
"(",
")",
";",
"Opcode",
"=",
"NewOpcode",
";",
"TmpInst",
".",
"setOpcode",
"(",
"NewOpcode",
")",
";",
"Binary",
"=",
"getBinaryCodeForInstr",
"(",
"TmpInst",
",",
"Fixups",
",",
"STI",
")",
";",
"}",
"}",
"const",
"MCInstrDesc",
"&",
"Desc",
"=",
"MCII",
".",
"get",
"(",
"TmpInst",
".",
"getOpcode",
"(",
")",
")",
";",
"unsigned",
"Size",
"=",
"Desc",
".",
"getSize",
"(",
")",
";",
"if",
"(",
"!",
"Size",
")",
"llvm_unreachable",
"(",
"\"Desc.getSize() returns 0\"",
")",
";",
"EmitInstruction",
"(",
"Binary",
",",
"Size",
",",
"STI",
",",
"OS",
")",
";",
"}",
"</s>"
] | [
"Encode",
"the",
"given",
"Inst",
"to",
"bytes",
"and",
"append",
"to",
"CB",
"."
] | [
"Mips",
"Mips",
"Mips::DSLL",
"Mips::DSRL",
"Mips::DSRA",
"Mips::DROTR",
"Mips::DEXT",
"Mips::DINS",
"Mips::NOP",
"Mips::SLL",
"Mips::SLL_MM",
"\"unimplemented opcode in encodeInstruction()\"",
"1",
"Mips",
"Mips",
"Mips::MipsR62MicroMipsR6",
"Mips::Arch_micromipsr6",
"1",
"Mips::Std2MicroMipsR6",
"Mips::Arch_micromipsr6",
"Mips::Std2MicroMips",
"Mips::Arch_micromips",
"1",
"Mips::Dsp2MicroMips",
"Mips::Arch_mmdsp",
"1",
"\"Desc.getSize() returns 0\""
] | MipsMCCodeEmitter (2)1 | encodeInstruction | Mips | CPU | LLVM | 8,826 | 335 | 1 | [] |
[
"<s>",
"bool",
"HexagonTargetLowering",
"::",
"getPostIndexedAddressParts",
"(",
"SDNode",
"*",
"N",
",",
"SDNode",
"*",
"Op",
",",
"SDValue",
"&",
"Base",
",",
"SDValue",
"&",
"Offset",
",",
"ISD",
"::",
"MemIndexedMode",
"&",
"AM",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"LSBaseSDNode",
"*",
"LSN",
"=",
"dyn_cast",
"<",
"LSBaseSDNode",
">",
"(",
"N",
")",
";",
"if",
"(",
"!",
"LSN",
")",
"return",
"false",
";",
"EVT",
"VT",
"=",
"LSN",
"->",
"getMemoryVT",
"(",
")",
";",
"if",
"(",
"!",
"VT",
".",
"isSimple",
"(",
")",
")",
"return",
"false",
";",
"bool",
"IsLegalType",
"=",
"VT",
"==",
"MVT",
"::",
"i8",
"||",
"VT",
"==",
"MVT",
"::",
"i16",
"||",
"VT",
"==",
"MVT",
"::",
"i32",
"||",
"VT",
"==",
"MVT",
"::",
"i64",
"||",
"VT",
"==",
"MVT",
"::",
"f32",
"||",
"VT",
"==",
"MVT",
"::",
"f64",
"||",
"VT",
"==",
"MVT",
"::",
"v2i16",
"||",
"VT",
"==",
"MVT",
"::",
"v2i32",
"||",
"VT",
"==",
"MVT",
"::",
"v4i8",
"||",
"VT",
"==",
"MVT",
"::",
"v4i16",
"||",
"VT",
"==",
"MVT",
"::",
"v8i8",
"||",
"Subtarget",
".",
"isHVXVectorType",
"(",
"VT",
".",
"getSimpleVT",
"(",
")",
")",
";",
"if",
"(",
"!",
"IsLegalType",
")",
"return",
"false",
";",
"if",
"(",
"Op",
"->",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"ADD",
")",
"return",
"false",
";",
"Base",
"=",
"Op",
"->",
"getOperand",
"(",
"0",
")",
";",
"Offset",
"=",
"Op",
"->",
"getOperand",
"(",
"1",
")",
";",
"if",
"(",
"!",
"isa",
"<",
"ConstantSDNode",
">",
"(",
"Offset",
".",
"getNode",
"(",
")",
")",
")",
"return",
"false",
";",
"AM",
"=",
"ISD",
"::",
"POST_INC",
";",
"int32_t",
"V",
"=",
"cast",
"<",
"ConstantSDNode",
">",
"(",
"Offset",
".",
"getNode",
"(",
")",
")",
"->",
"getSExtValue",
"(",
")",
";",
"return",
"Subtarget",
".",
"getInstrInfo",
"(",
")",
"->",
"isValidAutoIncImm",
"(",
"VT",
",",
"V",
")",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"by",
"value",
",",
"base",
"pointer",
"and",
"offset",
"pointer",
"and",
"addressing",
"mode",
"by",
"reference",
"if",
"this",
"node",
"can",
"be",
"combined",
"with",
"a",
"load",
"/",
"store",
"to",
"form",
"a",
"post-indexed",
"load",
"/",
"store",
"."
] | [
"Hexagon",
"Hexagon",
"ISD::MemIndexedMode",
"MVT::i8",
"MVT::i16",
"MVT::i32",
"MVT::i64",
"MVT::f32",
"MVT::f64",
"MVT::v2i16",
"MVT::v2i32",
"MVT::v4i8",
"MVT::v4i16",
"MVT::v8i8",
"ISD::ADD",
"0",
"1",
"ISD::POST_INC"
] | HexagonISelLowering1 | getPostIndexedAddressParts | Hexagon | DSP | LLVM | 8,827 | 253 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"const",
"TargetRegisterClass",
"*",
">",
"RV16KTargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"const",
"TargetRegisterInfo",
"*",
"TRI",
",",
"StringRef",
"Constraint",
",",
"MVT",
"VT",
")",
"const",
"{",
"if",
"(",
"Constraint",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"case",
"'r'",
":",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"RV16K",
"::",
"GPRRegClass",
")",
";",
"default",
":",
"break",
";",
"}",
"}",
"return",
"TargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"TRI",
",",
"Constraint",
",",
"VT",
")",
";",
"}",
"</s>"
] | [
"Given",
"a",
"physical",
"register",
"constraint",
"(",
"e.g",
"."
] | [
"RV16K",
"RV16K",
"1",
"0",
"0U",
"RV16K::GPRRegClass"
] | RV16KISelLowering | getRegForInlineAsmConstraint | RV16K | Virtual ISA | LLVM | 8,828 | 81 | 1 | [] |
[
"<s>",
"Liveness",
"(",
"MachineRegisterInfo",
"&",
"mri",
",",
"const",
"DataFlowGraph",
"&",
"g",
")",
":",
"DFG",
"(",
"g",
")",
",",
"TRI",
"(",
"g",
".",
"getTRI",
"(",
")",
")",
",",
"PRI",
"(",
"g",
".",
"getPRI",
"(",
")",
")",
",",
"MDT",
"(",
"g",
".",
"getDT",
"(",
")",
")",
",",
"MDF",
"(",
"g",
".",
"getDF",
"(",
")",
")",
",",
"MRI",
"(",
"mri",
")",
",",
"LiveMap",
"(",
"g",
".",
"getPRI",
"(",
")",
")",
",",
"Empty",
"(",
")",
",",
"NoRegs",
"(",
"g",
".",
"getPRI",
"(",
")",
")",
",",
"Trace",
"(",
"false",
")",
"{",
"}",
"</s>"
] | [
"During",
"our",
"initial",
"pass",
"over",
"the",
"program",
",",
"we",
"determine",
"that",
"things",
"are",
"either",
"alive",
"or",
"maybe",
"alive",
".",
"More",
"..."
] | [
"Hexagon"
] | RDFLiveness5 | Liveness | Hexagon | DSP | LLVM | 8,829 | 86 | 1 | [] |
[
"<s>",
"inline",
"bool",
"isAdd",
"(",
"const",
"MCInstrDesc",
"&",
"MCInstD",
")",
"{",
"if",
"(",
"isSPUInst",
"(",
"MCInstD",
")",
")",
"return",
"getSlotOpCode",
"(",
"MCInstD",
")",
"==",
"spuADD",
";",
"if",
"(",
"isVPUInst",
"(",
"MCInstD",
")",
")",
"return",
"getSlotOpCode",
"(",
"MCInstD",
")",
"==",
"vpuADD",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"instruction",
"is",
"an",
"add",
"instruction",
"."
] | [
"TPC"
] | TPCMCInstrInfo | isAdd | TPC | Virtual ISA | LLVM | 8,830 | 44 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"HexagonTargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"(",
"HexagonISD",
"::",
"NodeType",
")",
"Opcode",
")",
"{",
"case",
"HexagonISD",
"::",
"ALLOCA",
":",
"return",
"\"HexagonISD::ALLOCA\"",
";",
"case",
"HexagonISD",
"::",
"AT_GOT",
":",
"return",
"\"HexagonISD::AT_GOT\"",
";",
"case",
"HexagonISD",
"::",
"AT_PCREL",
":",
"return",
"\"HexagonISD::AT_PCREL\"",
";",
"case",
"HexagonISD",
"::",
"BARRIER",
":",
"return",
"\"HexagonISD::BARRIER\"",
";",
"case",
"HexagonISD",
"::",
"CALL",
":",
"return",
"\"HexagonISD::CALL\"",
";",
"case",
"HexagonISD",
"::",
"CALLnr",
":",
"return",
"\"HexagonISD::CALLnr\"",
";",
"case",
"HexagonISD",
"::",
"CALLR",
":",
"return",
"\"HexagonISD::CALLR\"",
";",
"case",
"HexagonISD",
"::",
"COMBINE",
":",
"return",
"\"HexagonISD::COMBINE\"",
";",
"case",
"HexagonISD",
"::",
"CONST32_GP",
":",
"return",
"\"HexagonISD::CONST32_GP\"",
";",
"case",
"HexagonISD",
"::",
"CONST32",
":",
"return",
"\"HexagonISD::CONST32\"",
";",
"case",
"HexagonISD",
"::",
"CP",
":",
"return",
"\"HexagonISD::CP\"",
";",
"case",
"HexagonISD",
"::",
"DCFETCH",
":",
"return",
"\"HexagonISD::DCFETCH\"",
";",
"case",
"HexagonISD",
"::",
"EH_RETURN",
":",
"return",
"\"HexagonISD::EH_RETURN\"",
";",
"case",
"HexagonISD",
"::",
"EXTRACTU",
":",
"return",
"\"HexagonISD::EXTRACTU\"",
";",
"case",
"HexagonISD",
"::",
"EXTRACTURP",
":",
"return",
"\"HexagonISD::EXTRACTURP\"",
";",
"case",
"HexagonISD",
"::",
"INSERT",
":",
"return",
"\"HexagonISD::INSERT\"",
";",
"case",
"HexagonISD",
"::",
"INSERTRP",
":",
"return",
"\"HexagonISD::INSERTRP\"",
";",
"case",
"HexagonISD",
"::",
"JT",
":",
"return",
"\"HexagonISD::JT\"",
";",
"case",
"HexagonISD",
"::",
"PACKHL",
":",
"return",
"\"HexagonISD::PACKHL\"",
";",
"case",
"HexagonISD",
"::",
"RET_FLAG",
":",
"return",
"\"HexagonISD::RET_FLAG\"",
";",
"case",
"HexagonISD",
"::",
"SHUFFEB",
":",
"return",
"\"HexagonISD::SHUFFEB\"",
";",
"case",
"HexagonISD",
"::",
"SHUFFEH",
":",
"return",
"\"HexagonISD::SHUFFEH\"",
";",
"case",
"HexagonISD",
"::",
"SHUFFOB",
":",
"return",
"\"HexagonISD::SHUFFOB\"",
";",
"case",
"HexagonISD",
"::",
"SHUFFOH",
":",
"return",
"\"HexagonISD::SHUFFOH\"",
";",
"case",
"HexagonISD",
"::",
"TC_RETURN",
":",
"return",
"\"HexagonISD::TC_RETURN\"",
";",
"case",
"HexagonISD",
"::",
"VCMPBEQ",
":",
"return",
"\"HexagonISD::VCMPBEQ\"",
";",
"case",
"HexagonISD",
"::",
"VCMPBGT",
":",
"return",
"\"HexagonISD::VCMPBGT\"",
";",
"case",
"HexagonISD",
"::",
"VCMPBGTU",
":",
"return",
"\"HexagonISD::VCMPBGTU\"",
";",
"case",
"HexagonISD",
"::",
"VCMPHEQ",
":",
"return",
"\"HexagonISD::VCMPHEQ\"",
";",
"case",
"HexagonISD",
"::",
"VCMPHGT",
":",
"return",
"\"HexagonISD::VCMPHGT\"",
";",
"case",
"HexagonISD",
"::",
"VCMPHGTU",
":",
"return",
"\"HexagonISD::VCMPHGTU\"",
";",
"case",
"HexagonISD",
"::",
"VCMPWEQ",
":",
"return",
"\"HexagonISD::VCMPWEQ\"",
";",
"case",
"HexagonISD",
"::",
"VCMPWGT",
":",
"return",
"\"HexagonISD::VCMPWGT\"",
";",
"case",
"HexagonISD",
"::",
"VCMPWGTU",
":",
"return",
"\"HexagonISD::VCMPWGTU\"",
";",
"case",
"HexagonISD",
"::",
"VCOMBINE",
":",
"return",
"\"HexagonISD::VCOMBINE\"",
";",
"case",
"HexagonISD",
"::",
"VPACK",
":",
"return",
"\"HexagonISD::VPACK\"",
";",
"case",
"HexagonISD",
"::",
"VSHLH",
":",
"return",
"\"HexagonISD::VSHLH\"",
";",
"case",
"HexagonISD",
"::",
"VSHLW",
":",
"return",
"\"HexagonISD::VSHLW\"",
";",
"case",
"HexagonISD",
"::",
"VSPLATB",
":",
"return",
"\"HexagonISD::VSPLTB\"",
";",
"case",
"HexagonISD",
"::",
"VSPLATH",
":",
"return",
"\"HexagonISD::VSPLATH\"",
";",
"case",
"HexagonISD",
"::",
"VSRAH",
":",
"return",
"\"HexagonISD::VSRAH\"",
";",
"case",
"HexagonISD",
"::",
"VSRAW",
":",
"return",
"\"HexagonISD::VSRAW\"",
";",
"case",
"HexagonISD",
"::",
"VSRLH",
":",
"return",
"\"HexagonISD::VSRLH\"",
";",
"case",
"HexagonISD",
"::",
"VSRLW",
":",
"return",
"\"HexagonISD::VSRLW\"",
";",
"case",
"HexagonISD",
"::",
"VSXTBH",
":",
"return",
"\"HexagonISD::VSXTBH\"",
";",
"case",
"HexagonISD",
"::",
"VSXTBW",
":",
"return",
"\"HexagonISD::VSXTBW\"",
";",
"case",
"HexagonISD",
"::",
"READCYCLE",
":",
"return",
"\"HexagonISD::READCYCLE\"",
";",
"case",
"HexagonISD",
"::",
"OP_END",
":",
"break",
";",
"}",
"return",
"nullptr",
";",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"Hexagon",
"Hexagon",
"HexagonISD::NodeType",
"HexagonISD::ALLOCA",
"\"HexagonISD::ALLOCA\"",
"HexagonISD::AT_GOT",
"\"HexagonISD::AT_GOT\"",
"HexagonISD::AT_PCREL",
"\"HexagonISD::AT_PCREL\"",
"HexagonISD::BARRIER",
"\"HexagonISD::BARRIER\"",
"HexagonISD::CALL",
"\"HexagonISD::CALL\"",
"HexagonISD::CALLnr",
"\"HexagonISD::CALLnr\"",
"HexagonISD::CALLR",
"\"HexagonISD::CALLR\"",
"HexagonISD::COMBINE",
"\"HexagonISD::COMBINE\"",
"HexagonISD::CONST32_GP",
"\"HexagonISD::CONST32_GP\"",
"HexagonISD::CONST32",
"\"HexagonISD::CONST32\"",
"HexagonISD::CP",
"\"HexagonISD::CP\"",
"HexagonISD::DCFETCH",
"\"HexagonISD::DCFETCH\"",
"HexagonISD::EH_RETURN",
"\"HexagonISD::EH_RETURN\"",
"HexagonISD::EXTRACTU",
"\"HexagonISD::EXTRACTU\"",
"HexagonISD::EXTRACTURP",
"\"HexagonISD::EXTRACTURP\"",
"HexagonISD::INSERT",
"\"HexagonISD::INSERT\"",
"HexagonISD::INSERTRP",
"\"HexagonISD::INSERTRP\"",
"HexagonISD::JT",
"\"HexagonISD::JT\"",
"HexagonISD::PACKHL",
"\"HexagonISD::PACKHL\"",
"HexagonISD::RET_FLAG",
"\"HexagonISD::RET_FLAG\"",
"HexagonISD::SHUFFEB",
"\"HexagonISD::SHUFFEB\"",
"HexagonISD::SHUFFEH",
"\"HexagonISD::SHUFFEH\"",
"HexagonISD::SHUFFOB",
"\"HexagonISD::SHUFFOB\"",
"HexagonISD::SHUFFOH",
"\"HexagonISD::SHUFFOH\"",
"HexagonISD::TC_RETURN",
"\"HexagonISD::TC_RETURN\"",
"HexagonISD::VCMPBEQ",
"\"HexagonISD::VCMPBEQ\"",
"HexagonISD::VCMPBGT",
"\"HexagonISD::VCMPBGT\"",
"HexagonISD::VCMPBGTU",
"\"HexagonISD::VCMPBGTU\"",
"HexagonISD::VCMPHEQ",
"\"HexagonISD::VCMPHEQ\"",
"HexagonISD::VCMPHGT",
"\"HexagonISD::VCMPHGT\"",
"HexagonISD::VCMPHGTU",
"\"HexagonISD::VCMPHGTU\"",
"HexagonISD::VCMPWEQ",
"\"HexagonISD::VCMPWEQ\"",
"HexagonISD::VCMPWGT",
"\"HexagonISD::VCMPWGT\"",
"HexagonISD::VCMPWGTU",
"\"HexagonISD::VCMPWGTU\"",
"HexagonISD::VCOMBINE",
"\"HexagonISD::VCOMBINE\"",
"HexagonISD::VPACK",
"\"HexagonISD::VPACK\"",
"HexagonISD::VSHLH",
"\"HexagonISD::VSHLH\"",
"HexagonISD::VSHLW",
"\"HexagonISD::VSHLW\"",
"HexagonISD::VSPLATB",
"\"HexagonISD::VSPLTB\"",
"HexagonISD::VSPLATH",
"\"HexagonISD::VSPLATH\"",
"HexagonISD::VSRAH",
"\"HexagonISD::VSRAH\"",
"HexagonISD::VSRAW",
"\"HexagonISD::VSRAW\"",
"HexagonISD::VSRLH",
"\"HexagonISD::VSRLH\"",
"HexagonISD::VSRLW",
"\"HexagonISD::VSRLW\"",
"HexagonISD::VSXTBH",
"\"HexagonISD::VSXTBH\"",
"HexagonISD::VSXTBW",
"\"HexagonISD::VSXTBW\"",
"HexagonISD::READCYCLE",
"\"HexagonISD::READCYCLE\"",
"HexagonISD::OP_END"
] | HexagonISelLowering19 | getTargetNodeName | Hexagon | DSP | LLVM | 8,831 | 410 | 1 | [] |
[
"<s>",
"bool",
"doFinalization",
"(",
"Module",
"&",
"M",
")",
"override",
"{",
"Result",
".",
"reset",
"(",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"doFinalization",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"any",
"necessary",
"clean",
"up",
"after",
"all",
"passes",
"have",
"run",
"."
] | [
"AMDGPU"
] | AMDGPUAliasAnalysis (2) | doFinalization | AMDGPU | GPU | LLVM | 8,832 | 19 | 1 | [] |
[
"<s>",
"void",
"Thumb2InstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"unsigned",
"DestReg",
",",
"int",
"FI",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"MF",
",",
"FI",
")",
",",
"MachineMemOperand",
"::",
"MOLoad",
",",
"MFI",
".",
"getObjectSize",
"(",
"FI",
")",
",",
"MFI",
".",
"getObjectAlignment",
"(",
"FI",
")",
")",
";",
"DebugLoc",
"DL",
";",
"if",
"(",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"I",
"->",
"getDebugLoc",
"(",
")",
";",
"if",
"(",
"RC",
"==",
"&",
"ARM",
"::",
"GPRRegClass",
"||",
"RC",
"==",
"&",
"ARM",
"::",
"tGPRRegClass",
"||",
"RC",
"==",
"&",
"ARM",
"::",
"tcGPRRegClass",
"||",
"RC",
"==",
"&",
"ARM",
"::",
"rGPRRegClass",
"||",
"RC",
"==",
"&",
"ARM",
"::",
"GPRnopcRegClass",
")",
"{",
"AddDefaultPred",
"(",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"ARM",
"::",
"t2LDRi12",
")",
",",
"DestReg",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
")",
";",
"return",
";",
"}",
"if",
"(",
"ARM",
"::",
"GPRPairRegClass",
".",
"hasSubClassEq",
"(",
"RC",
")",
")",
"{",
"if",
"(",
"TargetRegisterInfo",
"::",
"isVirtualRegister",
"(",
"DestReg",
")",
")",
"{",
"MachineRegisterInfo",
"*",
"MRI",
"=",
"&",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"MRI",
"->",
"constrainRegClass",
"(",
"DestReg",
",",
"&",
"ARM",
"::",
"GPRPair_with_gsub_1_in_rGPRRegClass",
")",
";",
"}",
"MachineInstrBuilder",
"MIB",
"=",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"ARM",
"::",
"t2LDRDi8",
")",
")",
";",
"AddDReg",
"(",
"MIB",
",",
"DestReg",
",",
"ARM",
"::",
"gsub_0",
",",
"RegState",
"::",
"DefineNoRead",
",",
"TRI",
")",
";",
"AddDReg",
"(",
"MIB",
",",
"DestReg",
",",
"ARM",
"::",
"gsub_1",
",",
"RegState",
"::",
"DefineNoRead",
",",
"TRI",
")",
";",
"MIB",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"AddDefaultPred",
"(",
"MIB",
")",
";",
"if",
"(",
"TargetRegisterInfo",
"::",
"isPhysicalRegister",
"(",
"DestReg",
")",
")",
"MIB",
".",
"addReg",
"(",
"DestReg",
",",
"RegState",
"::",
"ImplicitDefine",
")",
";",
"return",
";",
"}",
"ARMBaseInstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MBB",
",",
"I",
",",
"DestReg",
",",
"FI",
",",
"RC",
",",
"TRI",
")",
";",
"}",
"</s>"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"ARM",
"ARM::GPRRegClass",
"ARM::tGPRRegClass",
"ARM::tcGPRRegClass",
"ARM::rGPRRegClass",
"ARM::GPRnopcRegClass",
"ARM::t2LDRi12",
"0",
"ARM::GPRPairRegClass",
"ARM::GPRPair_with_gsub_1_in_rGPRRegClass",
"ARM::t2LDRDi8",
"ARM::gsub_0",
"ARM::gsub_1",
"0",
"ARM"
] | Thumb2InstrInfo18 | loadRegFromStackSlot | ARM | CPU | LLVM | 8,833 | 349 | 1 | [] |
[
"<s>",
"void",
"UnwindOpcodeAssembler",
"::",
"Finalize",
"(",
"unsigned",
"&",
"PersonalityIndex",
",",
"SmallVectorImpl",
"<",
"uint8_t",
">",
"&",
"Result",
")",
"{",
"UnwindOpcodeStreamer",
"OpStreamer",
"(",
"Result",
")",
";",
"if",
"(",
"HasPersonality",
")",
"{",
"PersonalityIndex",
"=",
"ARM",
"::",
"EHABI",
"::",
"NUM_PERSONALITY_INDEX",
";",
"size_t",
"TotalSize",
"=",
"Ops",
".",
"size",
"(",
")",
"+",
"1",
";",
"size_t",
"RoundUpSize",
"=",
"(",
"TotalSize",
"+",
"3",
")",
"/",
"4",
"*",
"4",
";",
"Result",
".",
"resize",
"(",
"RoundUpSize",
")",
";",
"OpStreamer",
".",
"EmitSize",
"(",
"RoundUpSize",
")",
";",
"}",
"else",
"{",
"if",
"(",
"PersonalityIndex",
"==",
"ARM",
"::",
"EHABI",
"::",
"NUM_PERSONALITY_INDEX",
")",
"PersonalityIndex",
"=",
"(",
"Ops",
".",
"size",
"(",
")",
"<=",
"3",
")",
"?",
"ARM",
"::",
"EHABI",
"::",
"AEABI_UNWIND_CPP_PR0",
":",
"ARM",
"::",
"EHABI",
"::",
"AEABI_UNWIND_CPP_PR1",
";",
"if",
"(",
"PersonalityIndex",
"==",
"ARM",
"::",
"EHABI",
"::",
"AEABI_UNWIND_CPP_PR0",
")",
"{",
"assert",
"(",
"Ops",
".",
"size",
"(",
")",
"<=",
"3",
"&&",
"\"too many opcodes for __aeabi_unwind_cpp_pr0\"",
")",
";",
"Result",
".",
"resize",
"(",
"4",
")",
";",
"OpStreamer",
".",
"EmitPersonalityIndex",
"(",
"PersonalityIndex",
")",
";",
"}",
"else",
"{",
"size_t",
"TotalSize",
"=",
"Ops",
".",
"size",
"(",
")",
"+",
"2",
";",
"size_t",
"RoundUpSize",
"=",
"(",
"TotalSize",
"+",
"3",
")",
"/",
"4",
"*",
"4",
";",
"Result",
".",
"resize",
"(",
"RoundUpSize",
")",
";",
"OpStreamer",
".",
"EmitPersonalityIndex",
"(",
"PersonalityIndex",
")",
";",
"OpStreamer",
".",
"EmitSize",
"(",
"RoundUpSize",
")",
";",
"}",
"}",
"for",
"(",
"size_t",
"i",
"=",
"OpBegins",
".",
"size",
"(",
")",
"-",
"1",
";",
"i",
">",
"0",
";",
"--",
"i",
")",
"for",
"(",
"size_t",
"j",
"=",
"OpBegins",
"[",
"i",
"-",
"1",
"]",
",",
"end",
"=",
"OpBegins",
"[",
"i",
"]",
";",
"j",
"<",
"end",
";",
"++",
"j",
")",
"OpStreamer",
".",
"EmitByte",
"(",
"Ops",
"[",
"j",
"]",
")",
";",
"OpStreamer",
".",
"FillFinishOpcode",
"(",
")",
";",
"Reset",
"(",
")",
";",
"}",
"</s>"
] | [
"Finalize",
"the",
"unwind",
"opcode",
"sequence",
"for",
"emitBytes",
"(",
")"
] | [
"ARM",
"ARM::EHABI",
"1",
"3",
"4",
"4",
"ARM::EHABI",
"3",
"ARM::EHABI",
"ARM::EHABI",
"ARM::EHABI",
"3",
"\"too many opcodes for __aeabi_unwind_cpp_pr0\"",
"4",
"2",
"3",
"4",
"4",
"1",
"0",
"1"
] | ARMUnwindOpAsm (2) | Finalize | ARM | CPU | LLVM | 8,834 | 266 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUResourceUsageAnalysis",
"::",
"runOnSCC",
"(",
"CallGraphSCC",
"&",
"SCC",
")",
"{",
"auto",
"*",
"TPC",
"=",
"getAnalysisIfAvailable",
"<",
"TargetPassConfig",
">",
"(",
")",
";",
"if",
"(",
"!",
"TPC",
")",
"return",
"false",
";",
"const",
"TargetMachine",
"&",
"TM",
"=",
"TPC",
"->",
"getTM",
"<",
"TargetMachine",
">",
"(",
")",
";",
"bool",
"HasIndirectCall",
"=",
"false",
";",
"for",
"(",
"CallGraphNode",
"*",
"I",
":",
"SCC",
")",
"{",
"Function",
"*",
"F",
"=",
"I",
"->",
"getFunction",
"(",
")",
";",
"if",
"(",
"!",
"F",
"||",
"F",
"->",
"isDeclaration",
"(",
")",
")",
"continue",
";",
"MachineModuleInfo",
"&",
"MMI",
"=",
"getAnalysis",
"<",
"MachineModuleInfoWrapperPass",
">",
"(",
")",
".",
"getMMI",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"MMI",
".",
"getOrCreateMachineFunction",
"(",
"*",
"F",
")",
";",
"auto",
"CI",
"=",
"CallGraphResourceInfo",
".",
"insert",
"(",
"std",
"::",
"make_pair",
"(",
"&",
"MF",
".",
"getFunction",
"(",
")",
",",
"SIFunctionResourceInfo",
"(",
")",
")",
")",
";",
"SIFunctionResourceInfo",
"&",
"Info",
"=",
"CI",
".",
"first",
"->",
"second",
";",
"assert",
"(",
"CI",
".",
"second",
"&&",
"\"should only be called once per function\"",
")",
";",
"Info",
"=",
"analyzeResourceUsage",
"(",
"MF",
",",
"TM",
")",
";",
"HasIndirectCall",
"|=",
"Info",
".",
"HasIndirectCall",
";",
"}",
"if",
"(",
"HasIndirectCall",
")",
"propagateIndirectCallRegisterUsage",
"(",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnSCC",
"-",
"This",
"method",
"should",
"be",
"implemented",
"by",
"the",
"subclass",
"to",
"perform",
"whatever",
"action",
"is",
"necessary",
"for",
"the",
"specified",
"SCC",
"."
] | [
"AMDGPU",
"AMDGPU",
"SI",
"SI",
"\"should only be called once per function\""
] | AMDGPUResourceUsageAnalysis | runOnSCC | AMDGPU | GPU | LLVM | 8,835 | 178 | 1 | [] |
[
"<s>",
"SDValue",
"MSP430TargetLowering",
"::",
"LowerReturn",
"(",
"SDValue",
"Chain",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"isVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
",",
"const",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"OutVals",
",",
"DebugLoc",
"dl",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"if",
"(",
"CallConv",
"==",
"CallingConv",
"::",
"MSP430_INTR",
"&&",
"!",
"Outs",
".",
"empty",
"(",
")",
")",
"report_fatal_error",
"(",
"\"ISRs cannot return any value\"",
")",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"isVarArg",
",",
"DAG",
".",
"getMachineFunction",
"(",
")",
",",
"getTargetMachine",
"(",
")",
",",
"RVLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"CCInfo",
".",
"AnalyzeReturn",
"(",
"Outs",
",",
"RetCC_MSP430",
")",
";",
"if",
"(",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"liveout_empty",
"(",
")",
")",
"{",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"RVLocs",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"if",
"(",
"RVLocs",
"[",
"i",
"]",
".",
"isRegLoc",
"(",
")",
")",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"addLiveOut",
"(",
"RVLocs",
"[",
"i",
"]",
".",
"getLocReg",
"(",
")",
")",
";",
"}",
"SDValue",
"Flag",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"RVLocs",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"{",
"CCValAssign",
"&",
"VA",
"=",
"RVLocs",
"[",
"i",
"]",
";",
"assert",
"(",
"VA",
".",
"isRegLoc",
"(",
")",
"&&",
"\"Can only return in registers!\"",
")",
";",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"dl",
",",
"VA",
".",
"getLocReg",
"(",
")",
",",
"OutVals",
"[",
"i",
"]",
",",
"Flag",
")",
";",
"Flag",
"=",
"Chain",
".",
"getValue",
"(",
"1",
")",
";",
"}",
"unsigned",
"Opc",
"=",
"(",
"CallConv",
"==",
"CallingConv",
"::",
"MSP430_INTR",
"?",
"MSP430ISD",
"::",
"RETI_FLAG",
":",
"MSP430ISD",
"::",
"RET_FLAG",
")",
";",
"if",
"(",
"Flag",
".",
"getNode",
"(",
")",
")",
"return",
"DAG",
".",
"getNode",
"(",
"Opc",
",",
"dl",
",",
"MVT",
"::",
"Other",
",",
"Chain",
",",
"Flag",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"Opc",
",",
"dl",
",",
"MVT",
"::",
"Other",
",",
"Chain",
")",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"outgoing",
"return",
"values",
",",
"described",
"by",
"the",
"Outs",
"array",
",",
"into",
"the",
"specified",
"DAG",
"."
] | [
"MSP430",
"MSP430",
"ISD::OutputArg",
"16",
"MSP430",
"\"ISRs cannot return any value\"",
"MSP430",
"0",
"0",
"\"Can only return in registers!\"",
"1",
"MSP430",
"MSP430ISD::RETI_FLAG",
"MSP430ISD::RET_FLAG",
"MVT::Other",
"MVT::Other"
] | MSP430ISelLowering14 | LowerReturn | MSP430 | MPU | LLVM | 8,836 | 314 | 1 | [] |
[
"<s>",
"void",
"mn10300_split_cbranch",
"(",
"machine_mode",
"cmp_mode",
",",
"rtx",
"cmp_op",
",",
"rtx",
"label_ref",
")",
"{",
"rtx",
"flags",
",",
"x",
";",
"flags",
"=",
"gen_rtx_REG",
"(",
"cmp_mode",
",",
"CC_REG",
")",
";",
"x",
"=",
"gen_rtx_COMPARE",
"(",
"cmp_mode",
",",
"XEXP",
"(",
"cmp_op",
",",
"0",
")",
",",
"XEXP",
"(",
"cmp_op",
",",
"1",
")",
")",
";",
"x",
"=",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"flags",
",",
"x",
")",
";",
"emit_insn",
"(",
"x",
")",
";",
"x",
"=",
"gen_rtx_fmt_ee",
"(",
"GET_CODE",
"(",
"cmp_op",
")",
",",
"VOIDmode",
",",
"flags",
",",
"const0_rtx",
")",
";",
"x",
"=",
"gen_rtx_IF_THEN_ELSE",
"(",
"VOIDmode",
",",
"x",
",",
"label_ref",
",",
"pc_rtx",
")",
";",
"x",
"=",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"pc_rtx",
",",
"x",
")",
";",
"emit_jump_insn",
"(",
"x",
")",
";",
"}",
"</s>"
] | [
"A",
"helper",
"function",
"for",
"splitting",
"cbranch",
"patterns",
"after",
"reload",
"."
] | [
"mn10300",
"0",
"1"
] | mn103004 | mn10300_split_cbranch | mn10300 | MPU | GCC | 8,837 | 110 | 1 | [] |
[
"<s>",
"static",
"MCAsmInfo",
"*",
"createMCAsmInfo",
"(",
"const",
"Target",
"&",
"T",
",",
"StringRef",
"TT",
")",
"{",
"Triple",
"TheTriple",
"(",
"TT",
")",
";",
"switch",
"(",
"TheTriple",
".",
"getOS",
"(",
")",
")",
"{",
"case",
"Triple",
"::",
"Darwin",
":",
"return",
"new",
"X86MCAsmInfoDarwin",
"(",
"TheTriple",
")",
";",
"case",
"Triple",
"::",
"MinGW32",
":",
"case",
"Triple",
"::",
"MinGW64",
":",
"case",
"Triple",
"::",
"Cygwin",
":",
"case",
"Triple",
"::",
"Win32",
":",
"return",
"new",
"X86MCAsmInfoCOFF",
"(",
"TheTriple",
")",
";",
"default",
":",
"return",
"new",
"X86ELFMCAsmInfo",
"(",
"TheTriple",
")",
";",
"}",
"}",
"</s>"
] | [
"createMCAsmInfo",
"-",
"Create",
"a",
"MCAsmInfo",
"implementation",
"for",
"the",
"specified",
"target",
"triple",
"."
] | [
"X86",
"X86",
"X86",
"X86"
] | X86TargetMachine37 | createMCAsmInfo | X86 | CPU | LLVM | 8,838 | 79 | 1 | [] |
[
"<s>",
"static",
"const",
"char",
"*",
"cond_string",
"(",
"enum",
"rtx_code",
"code",
")",
"{",
"switch",
"(",
"code",
")",
"{",
"case",
"NE",
":",
"return",
"\"ne\"",
";",
"case",
"EQ",
":",
"return",
"\"eq\"",
";",
"case",
"GE",
":",
"if",
"(",
"cc_prev_status",
".",
"flags",
"&",
"CC_OVERFLOW_UNUSABLE",
")",
"return",
"\"pl\"",
";",
"else",
"return",
"\"ge\"",
";",
"case",
"LT",
":",
"if",
"(",
"cc_prev_status",
".",
"flags",
"&",
"CC_OVERFLOW_UNUSABLE",
")",
"return",
"\"mi\"",
";",
"else",
"return",
"\"lt\"",
";",
"case",
"GEU",
":",
"return",
"\"sh\"",
";",
"case",
"LTU",
":",
"return",
"\"lo\"",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Return",
"assembly",
"language",
"string",
"which",
"identifies",
"a",
"comparison",
"type",
"."
] | [
"avr",
"\"ne\"",
"\"eq\"",
"\"pl\"",
"\"ge\"",
"\"mi\"",
"\"lt\"",
"\"sh\"",
"\"lo\""
] | avr3 | cond_string | avr | MPU | GCC | 8,839 | 84 | 1 | [] |
[
"<s>",
"bool",
"ARCOptAddrMode",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"if",
"(",
"skipFunction",
"(",
"MF",
".",
"getFunction",
"(",
")",
")",
"||",
"KILL_PASS",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"DUMP_BEFORE",
"(",
")",
")",
"MF",
".",
"dump",
"(",
")",
";",
"if",
"(",
"VIEW_BEFORE",
"(",
")",
")",
"MF",
".",
"viewCFG",
"(",
")",
";",
"AST",
"=",
"&",
"MF",
".",
"getSubtarget",
"<",
"ARCSubtarget",
">",
"(",
")",
";",
"AII",
"=",
"AST",
"->",
"getInstrInfo",
"(",
")",
";",
"MRI",
"=",
"&",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"MDT",
"=",
"&",
"getAnalysis",
"<",
"MachineDominatorTree",
">",
"(",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"auto",
"&",
"MBB",
":",
"MF",
")",
"Changed",
"|=",
"processBasicBlock",
"(",
"MBB",
")",
";",
"if",
"(",
"DUMP_AFTER",
"(",
")",
")",
"MF",
".",
"dump",
"(",
")",
";",
"if",
"(",
"VIEW_AFTER",
"(",
")",
")",
"MF",
".",
"viewCFG",
"(",
")",
";",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARC",
"ARC",
"ARC"
] | ARCOptAddrMode1 | runOnMachineFunction | ARC | MPU | LLVM | 8,840 | 139 | 1 | [] |
[
"<s>",
"static",
"char",
"*",
"to_host_file_spec",
"(",
"char",
"*",
"filespec",
")",
"{",
"if",
"(",
"strchr",
"(",
"filespec",
",",
"']'",
")",
"||",
"strchr",
"(",
"filespec",
",",
"':'",
")",
")",
"return",
"filespec",
";",
"else",
"{",
"strcpy",
"(",
"filename_buff",
",",
"filespec",
")",
";",
"decc$to_vms",
"(",
"filespec",
",",
"translate_unix",
",",
"1",
",",
"1",
")",
";",
"strcpy",
"(",
"new_host_filespec",
",",
"filename_buff",
")",
";",
"return",
"new_host_filespec",
";",
"}",
"return",
"filespec",
";",
"}",
"</s>"
] | [
"Translate",
"a",
"Unix",
"syntax",
"file",
"specification",
"FILESPEC",
"into",
"VMS",
"syntax",
".",
"If",
"indicators",
"of",
"VMS",
"syntax",
"found",
",",
"return",
"input",
"string",
".",
"Return",
"a",
"pointer",
"to",
"a",
"static",
"buffer",
"."
] | [
"vms",
"1",
"1"
] | vms-ar | to_host_file_spec | vms | Virtual ISA | GCC | 8,841 | 64 | 1 | [] |
[
"<s>",
"static",
"bool",
"arm_const_not_ok_for_debug_p",
"(",
"rtx",
"p",
")",
"{",
"tree",
"decl_op0",
"=",
"NULL",
";",
"tree",
"decl_op1",
"=",
"NULL",
";",
"if",
"(",
"GET_CODE",
"(",
"p",
")",
"==",
"UNSPEC",
")",
"return",
"true",
";",
"if",
"(",
"GET_CODE",
"(",
"p",
")",
"==",
"MINUS",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"p",
",",
"1",
")",
")",
"==",
"SYMBOL_REF",
")",
"{",
"decl_op1",
"=",
"SYMBOL_REF_DECL",
"(",
"XEXP",
"(",
"p",
",",
"1",
")",
")",
";",
"if",
"(",
"decl_op1",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"p",
",",
"0",
")",
")",
"==",
"SYMBOL_REF",
"&&",
"(",
"decl_op0",
"=",
"SYMBOL_REF_DECL",
"(",
"XEXP",
"(",
"p",
",",
"0",
")",
")",
")",
")",
"{",
"if",
"(",
"(",
"VAR_P",
"(",
"decl_op1",
")",
"||",
"TREE_CODE",
"(",
"decl_op1",
")",
"==",
"CONST_DECL",
")",
"&&",
"(",
"VAR_P",
"(",
"decl_op0",
")",
"||",
"TREE_CODE",
"(",
"decl_op0",
")",
"==",
"CONST_DECL",
")",
")",
"return",
"(",
"get_variable_section",
"(",
"decl_op1",
",",
"false",
")",
"!=",
"get_variable_section",
"(",
"decl_op0",
",",
"false",
")",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"decl_op1",
")",
"==",
"LABEL_DECL",
"&&",
"TREE_CODE",
"(",
"decl_op0",
")",
"==",
"LABEL_DECL",
")",
"return",
"(",
"DECL_CONTEXT",
"(",
"decl_op1",
")",
"!=",
"DECL_CONTEXT",
"(",
"decl_op0",
")",
")",
";",
"}",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"This",
"is",
"a",
"temporary",
"fix",
"for",
"PR60655",
".",
"Ideally",
"we",
"need",
"to",
"handle",
"most",
"of",
"these",
"cases",
"in",
"the",
"generic",
"part",
"but",
"currently",
"we",
"reject",
"minus",
"(",
"..",
")",
"(",
"sym_ref",
")",
".",
"We",
"try",
"to",
"ameliorate",
"the",
"case",
"with",
"minus",
"(",
"sym_ref1",
")",
"(",
"sym_ref2",
")",
"where",
"they",
"are",
"in",
"the",
"same",
"section",
"."
] | [
"arm",
"1",
"1",
"0",
"0"
] | arm | arm_const_not_ok_for_debug_p | arm | CPU | GCC | 8,842 | 184 | 1 | [] |
[
"<s>",
"bool",
"AMDGPULowerIntrinsics",
"::",
"makeLIDRangeMetadata",
"(",
"Function",
"&",
"F",
")",
"const",
"{",
"auto",
"*",
"TPC",
"=",
"getAnalysisIfAvailable",
"<",
"TargetPassConfig",
">",
"(",
")",
";",
"if",
"(",
"!",
"TPC",
")",
"return",
"false",
";",
"const",
"TargetMachine",
"&",
"TM",
"=",
"TPC",
"->",
"getTM",
"<",
"TargetMachine",
">",
"(",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"auto",
"*",
"U",
":",
"F",
".",
"users",
"(",
")",
")",
"{",
"auto",
"*",
"CI",
"=",
"dyn_cast",
"<",
"CallInst",
">",
"(",
"U",
")",
";",
"if",
"(",
"!",
"CI",
")",
"continue",
";",
"Changed",
"|=",
"AMDGPUCommonSubtarget",
"::",
"get",
"(",
"TM",
",",
"F",
")",
".",
"makeLIDRangeMetadata",
"(",
"CI",
")",
";",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"Creates",
"value",
"range",
"metadata",
"on",
"an",
"workitemid",
".",
"*",
"intrinsic",
"call",
"or",
"load",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU"
] | AMDGPULowerIntrinsics11 | makeLIDRangeMetadata | AMDGPU | GPU | LLVM | 8,843 | 102 | 1 | [] |
[
"<s>",
"void",
"clear",
"(",
")",
"{",
"memset",
"(",
"ScoreLBs",
",",
"0",
",",
"sizeof",
"(",
"ScoreLBs",
")",
")",
";",
"memset",
"(",
"ScoreUBs",
",",
"0",
",",
"sizeof",
"(",
"ScoreUBs",
")",
")",
";",
"PendingEvents",
"=",
"0",
";",
"memset",
"(",
"MixedPendingEvents",
",",
"0",
",",
"sizeof",
"(",
"MixedPendingEvents",
")",
")",
";",
"for",
"(",
"auto",
"T",
":",
"inst_counter_types",
"(",
")",
")",
"memset",
"(",
"VgprScores",
"[",
"T",
"]",
",",
"0",
",",
"sizeof",
"(",
"VgprScores",
"[",
"T",
"]",
")",
")",
";",
"memset",
"(",
"SgprScores",
",",
"0",
",",
"sizeof",
"(",
"SgprScores",
")",
")",
";",
"}",
"</s>"
] | [
"Clear",
"all",
"timers",
"in",
"this",
"group",
"."
] | [
"AMDGPU",
"0",
"0",
"0",
"0",
"0",
"0"
] | SIInsertWaitcnts | clear | AMDGPU | GPU | LLVM | 8,844 | 85 | 1 | [] |
[
"<s>",
"static",
"bool",
"msp430_var_in_low_mem",
"(",
"tree",
"decl",
")",
"{",
"gcc_assert",
"(",
"VAR_P",
"(",
"decl",
")",
")",
";",
"if",
"(",
"has_attr",
"(",
"ATTR_UPPER",
",",
"decl",
")",
"||",
"has_attr",
"(",
"ATTR_EITHER",
",",
"decl",
")",
"||",
"has_attr",
"(",
"ATTR_PERSIST",
",",
"decl",
")",
"||",
"(",
"!",
"has_attr",
"(",
"ATTR_LOWER",
",",
"decl",
")",
"&&",
"!",
"has_attr",
"(",
"ATTR_NOINIT",
",",
"decl",
")",
"&&",
"(",
"has_attr",
"(",
"\"section\"",
",",
"decl",
")",
"||",
"msp430_data_region",
"==",
"MSP430_REGION_UPPER",
"||",
"msp430_data_region",
"==",
"MSP430_REGION_EITHER",
"||",
"msp430_data_region",
"==",
"MSP430_REGION_ANY",
")",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Given",
"a",
"non-automatic",
"VAR_DECL",
"which",
"can",
"possibly",
"have",
"a",
"section",
",",
"return",
"true",
"if",
"the",
"variable",
"will",
"definitely",
"be",
"placed",
"in",
"the",
"lower",
"memory",
"region",
"(",
"below",
"address",
"0x10000",
")",
"."
] | [
"msp430",
"\"section\""
] | msp430 | msp430_var_in_low_mem | msp430 | MPU | GCC | 8,845 | 85 | 1 | [] |
[
"<s>",
"const",
"uint32_t",
"*",
"SIRegisterInfo",
"::",
"getCallPreservedMask",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"CallingConv",
"::",
"ID",
"CC",
")",
"const",
"{",
"switch",
"(",
"CC",
")",
"{",
"case",
"CallingConv",
"::",
"C",
":",
"case",
"CallingConv",
"::",
"Fast",
":",
"case",
"CallingConv",
"::",
"Cold",
":",
"return",
"ST",
".",
"hasGFX90AInsts",
"(",
")",
"?",
"CSR_AMDGPU_GFX90AInsts_RegMask",
":",
"CSR_AMDGPU_RegMask",
";",
"case",
"CallingConv",
"::",
"AMDGPU_Gfx",
":",
"return",
"ST",
".",
"hasGFX90AInsts",
"(",
")",
"?",
"CSR_AMDGPU_SI_Gfx_GFX90AInsts_RegMask",
":",
"CSR_AMDGPU_SI_Gfx_RegMask",
";",
"default",
":",
"return",
"nullptr",
";",
"}",
"}",
"</s>"
] | [
"Return",
"a",
"mask",
"of",
"call-preserved",
"registers",
"for",
"the",
"given",
"calling",
"convention",
"on",
"the",
"current",
"function",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"SI",
"SI"
] | SIRegisterInfo (3) | getCallPreservedMask | AMDGPU | GPU | LLVM | 8,846 | 73 | 1 | [] |
[
"<s>",
"bool",
"expand_move",
"(",
"rtx",
"*",
"operands",
",",
"machine_mode",
"mode",
")",
"{",
"rtx",
"op",
"=",
"operands",
"[",
"1",
"]",
";",
"if",
"(",
"(",
"TARGET_ID_SHARED_LIBRARY",
"||",
"TARGET_FDPIC",
")",
"&&",
"SYMBOLIC_CONST",
"(",
"op",
")",
")",
"emit_pic_move",
"(",
"operands",
",",
"mode",
")",
";",
"else",
"if",
"(",
"mode",
"==",
"SImode",
"&&",
"GET_CODE",
"(",
"op",
")",
"==",
"CONST",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
")",
"==",
"PLUS",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
",",
"0",
")",
")",
"==",
"SYMBOL_REF",
"&&",
"!",
"targetm",
".",
"legitimate_constant_p",
"(",
"mode",
",",
"op",
")",
")",
"{",
"rtx",
"dest",
"=",
"operands",
"[",
"0",
"]",
";",
"rtx",
"op0",
",",
"op1",
";",
"gcc_assert",
"(",
"!",
"reload_in_progress",
"&&",
"!",
"reload_completed",
")",
";",
"op",
"=",
"XEXP",
"(",
"op",
",",
"0",
")",
";",
"op0",
"=",
"force_reg",
"(",
"mode",
",",
"XEXP",
"(",
"op",
",",
"0",
")",
")",
";",
"op1",
"=",
"XEXP",
"(",
"op",
",",
"1",
")",
";",
"if",
"(",
"!",
"insn_data",
"[",
"CODE_FOR_addsi3",
"]",
".",
"operand",
"[",
"2",
"]",
".",
"predicate",
"(",
"op1",
",",
"mode",
")",
")",
"op1",
"=",
"force_reg",
"(",
"mode",
",",
"op1",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"dest",
")",
"==",
"MEM",
")",
"dest",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"emit_insn",
"(",
"gen_addsi3",
"(",
"dest",
",",
"op0",
",",
"op1",
")",
")",
";",
"if",
"(",
"dest",
"==",
"operands",
"[",
"0",
"]",
")",
"return",
"true",
";",
"operands",
"[",
"1",
"]",
"=",
"dest",
";",
"}",
"else",
"if",
"(",
"(",
"reload_in_progress",
"|",
"reload_completed",
")",
"==",
"0",
"&&",
"GET_CODE",
"(",
"operands",
"[",
"0",
"]",
")",
"==",
"MEM",
"&&",
"GET_CODE",
"(",
"operands",
"[",
"1",
"]",
")",
"!=",
"REG",
")",
"operands",
"[",
"1",
"]",
"=",
"force_reg",
"(",
"mode",
",",
"operands",
"[",
"1",
"]",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Expand",
"a",
"move",
"operation",
"in",
"mode",
"MODE",
".",
"The",
"operands",
"are",
"in",
"OPERANDS",
"."
] | [
"bfin",
"1",
"0",
"0",
"0",
"0",
"0",
"0",
"1",
"2",
"0",
"1",
"0",
"0",
"1",
"1",
"1"
] | bfin | expand_move | bfin | DSP | GCC | 8,847 | 274 | 1 | [] |
[
"<s>",
"string",
"str",
"(",
"void",
")",
"const",
"{",
"stringbuf",
"buf",
";",
"char",
"kind",
"[",
"]",
"=",
"{",
"'-'",
",",
"'u'",
",",
"'d'",
",",
"'x'",
"}",
";",
"for",
"(",
"unsigned",
"long",
"i",
"=",
"0",
";",
"i",
"<",
"uses",
".",
"size",
"(",
")",
";",
"i",
"++",
")",
"{",
"int",
"x",
"=",
"0",
";",
"if",
"(",
"uses",
".",
"test",
"(",
"i",
")",
")",
"x",
"+=",
"1",
";",
"if",
"(",
"defs",
".",
"test",
"(",
"i",
")",
")",
"x",
"+=",
"2",
";",
"buf",
".",
"sputc",
"(",
"kind",
"[",
"x",
"]",
")",
";",
"}",
"return",
"buf",
".",
"str",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"twine",
"contents",
"as",
"a",
"std",
":",
":string",
"."
] | [
"Patmos",
"0",
"0",
"1",
"2"
] | RAInfo | str | Patmos | VLIW | LLVM | 8,848 | 95 | 1 | [] |
[
"<s>",
"static",
"bool",
"timode_scalar_to_vector_candidate_p",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"rtx",
"def_set",
"=",
"pseudo_reg_set",
"(",
"insn",
")",
";",
"if",
"(",
"!",
"def_set",
")",
"return",
"false",
";",
"rtx",
"src",
"=",
"SET_SRC",
"(",
"def_set",
")",
";",
"rtx",
"dst",
"=",
"SET_DEST",
"(",
"def_set",
")",
";",
"if",
"(",
"GET_MODE",
"(",
"dst",
")",
"!=",
"TImode",
")",
"return",
"false",
";",
"if",
"(",
"MEM_P",
"(",
"dst",
")",
")",
"{",
"if",
"(",
"misaligned_operand",
"(",
"dst",
",",
"TImode",
")",
"&&",
"!",
"TARGET_SSE_UNALIGNED_STORE_OPTIMAL",
")",
"return",
"false",
";",
"switch",
"(",
"GET_CODE",
"(",
"src",
")",
")",
"{",
"default",
":",
"return",
"false",
";",
"case",
"REG",
":",
"case",
"CONST_WIDE_INT",
":",
"return",
"true",
";",
"case",
"CONST_INT",
":",
"return",
"standard_sse_constant_p",
"(",
"src",
",",
"TImode",
")",
";",
"}",
"}",
"else",
"if",
"(",
"MEM_P",
"(",
"src",
")",
")",
"{",
"return",
"(",
"REG_P",
"(",
"dst",
")",
"&&",
"(",
"!",
"misaligned_operand",
"(",
"src",
",",
"TImode",
")",
"||",
"TARGET_SSE_UNALIGNED_LOAD_OPTIMAL",
")",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"The",
"TImode",
"version",
"of",
"scalar_to_vector_candidate_p",
"."
] | [
"i386"
] | i386-features | timode_scalar_to_vector_candidate_p | i386 | CPU | GCC | 8,849 | 145 | 1 | [] |
[
"<s>",
"static",
"int",
"loongarch_zero_extend_cost",
"(",
"rtx",
"op",
")",
"{",
"if",
"(",
"MEM_P",
"(",
"op",
")",
")",
"return",
"0",
";",
"return",
"COSTS_N_INSNS",
"(",
"1",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"cost",
"of",
"zero-extending",
"OP",
"to",
"mode",
"MODE",
",",
"not",
"including",
"the",
"cost",
"of",
"OP",
"itself",
"."
] | [
"loongarch",
"0",
"1"
] | loongarch | loongarch_zero_extend_cost | loongarch | CPU | GCC | 8,850 | 25 | 1 | [] |
[
"<s>",
"static",
"rtx",
"get_branch_target",
"(",
"rtx_insn",
"*",
"branch",
")",
"{",
"if",
"(",
"JUMP_P",
"(",
"branch",
")",
")",
"{",
"rtx",
"set",
",",
"src",
";",
"if",
"(",
"GET_CODE",
"(",
"PATTERN",
"(",
"branch",
")",
")",
"==",
"RETURN",
")",
"return",
"gen_rtx_REG",
"(",
"SImode",
",",
"LINK_REGISTER_REGNUM",
")",
";",
"if",
"(",
"extract_asm_operands",
"(",
"PATTERN",
"(",
"branch",
")",
")",
"!=",
"NULL",
")",
"return",
"NULL",
";",
"set",
"=",
"single_set",
"(",
"branch",
")",
";",
"src",
"=",
"SET_SRC",
"(",
"set",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"SET_DEST",
"(",
"set",
")",
")",
"!=",
"PC",
")",
"abort",
"(",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"src",
")",
"==",
"IF_THEN_ELSE",
")",
"{",
"rtx",
"lab",
"=",
"0",
";",
"rtx",
"note",
"=",
"find_reg_note",
"(",
"branch",
",",
"REG_BR_PROB",
",",
"0",
")",
";",
"if",
"(",
"note",
")",
"{",
"int",
"prob",
"=",
"profile_probability",
"::",
"from_reg_br_prob_note",
"(",
"XINT",
"(",
"note",
",",
"0",
")",
")",
".",
"to_reg_br_prob_base",
"(",
")",
";",
"if",
"(",
"prob",
">",
"(",
"REG_BR_PROB_BASE",
"*",
"6",
"/",
"10",
")",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"src",
",",
"1",
")",
")",
"!=",
"PC",
")",
"lab",
"=",
"XEXP",
"(",
"src",
",",
"1",
")",
";",
"else",
"if",
"(",
"prob",
"<",
"(",
"REG_BR_PROB_BASE",
"*",
"4",
"/",
"10",
")",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"src",
",",
"2",
")",
")",
"!=",
"PC",
")",
"lab",
"=",
"XEXP",
"(",
"src",
",",
"2",
")",
";",
"}",
"if",
"(",
"lab",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"lab",
")",
"==",
"RETURN",
")",
"return",
"gen_rtx_REG",
"(",
"SImode",
",",
"LINK_REGISTER_REGNUM",
")",
";",
"return",
"lab",
";",
"}",
"return",
"0",
";",
"}",
"return",
"src",
";",
"}",
"else",
"if",
"(",
"CALL_P",
"(",
"branch",
")",
")",
"{",
"rtx",
"call",
";",
"if",
"(",
"GET_CODE",
"(",
"PATTERN",
"(",
"branch",
")",
")",
"!=",
"PARALLEL",
")",
"abort",
"(",
")",
";",
"call",
"=",
"XVECEXP",
"(",
"PATTERN",
"(",
"branch",
")",
",",
"0",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"call",
")",
"==",
"SET",
")",
"call",
"=",
"SET_SRC",
"(",
"call",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"call",
")",
"!=",
"CALL",
")",
"abort",
"(",
")",
";",
"return",
"XEXP",
"(",
"XEXP",
"(",
"call",
",",
"0",
")",
",",
"0",
")",
";",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"Returns",
"0",
"if",
"we",
"do",
"n't",
"want",
"a",
"hint",
"for",
"this",
"branch",
".",
"Otherwise",
"return",
"the",
"rtx",
"for",
"the",
"branch",
"target",
"."
] | [
"spu",
"0",
"0",
"0",
"6",
"10",
"1",
"1",
"4",
"10",
"2",
"2",
"0",
"0",
"0",
"0",
"0",
"0"
] | spu3 | get_branch_target | spu | MPU | GCC | 8,851 | 329 | 1 | [] |
[
"<s>",
"void",
"init_cumulative_args",
"(",
"CUMULATIVE_ARGS",
"*",
"cum",
",",
"tree",
"fntype",
",",
"rtx",
"libname",
"ATTRIBUTE_UNUSED",
",",
"int",
"incoming",
",",
"int",
"libcall",
",",
"int",
"n_named_args",
")",
"{",
"static",
"CUMULATIVE_ARGS",
"zero_cumulative",
";",
"*",
"cum",
"=",
"zero_cumulative",
";",
"cum",
"->",
"words",
"=",
"0",
";",
"cum",
"->",
"fregno",
"=",
"FP_ARG_MIN_REG",
";",
"cum",
"->",
"vregno",
"=",
"ALTIVEC_ARG_MIN_REG",
";",
"cum",
"->",
"prototype",
"=",
"(",
"fntype",
"&&",
"TYPE_ARG_TYPES",
"(",
"fntype",
")",
")",
";",
"cum",
"->",
"call_cookie",
"=",
"(",
"(",
"DEFAULT_ABI",
"==",
"ABI_V4",
"&&",
"libcall",
")",
"?",
"CALL_LIBCALL",
":",
"CALL_NORMAL",
")",
";",
"cum",
"->",
"sysv_gregno",
"=",
"GP_ARG_MIN_REG",
";",
"cum",
"->",
"stdarg",
"=",
"fntype",
"&&",
"(",
"TYPE_ARG_TYPES",
"(",
"fntype",
")",
"!=",
"0",
"&&",
"(",
"TREE_VALUE",
"(",
"tree_last",
"(",
"TYPE_ARG_TYPES",
"(",
"fntype",
")",
")",
")",
"!=",
"void_type_node",
")",
")",
";",
"cum",
"->",
"nargs_prototype",
"=",
"0",
";",
"if",
"(",
"incoming",
"||",
"cum",
"->",
"prototype",
")",
"cum",
"->",
"nargs_prototype",
"=",
"n_named_args",
";",
"if",
"(",
"(",
"!",
"fntype",
"&&",
"rs6000_default_long_calls",
")",
"||",
"(",
"fntype",
"&&",
"lookup_attribute",
"(",
"\"longcall\"",
",",
"TYPE_ATTRIBUTES",
"(",
"fntype",
")",
")",
"&&",
"!",
"lookup_attribute",
"(",
"\"shortcall\"",
",",
"TYPE_ATTRIBUTES",
"(",
"fntype",
")",
")",
")",
")",
"cum",
"->",
"call_cookie",
"|=",
"CALL_LONG",
";",
"if",
"(",
"TARGET_DEBUG_ARG",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\"\\ninit_cumulative_args:\"",
")",
";",
"if",
"(",
"fntype",
")",
"{",
"tree",
"ret_type",
"=",
"TREE_TYPE",
"(",
"fntype",
")",
";",
"fprintf",
"(",
"stderr",
",",
"\" ret code = %s,\"",
",",
"tree_code_name",
"[",
"(",
"int",
")",
"TREE_CODE",
"(",
"ret_type",
")",
"]",
")",
";",
"}",
"if",
"(",
"cum",
"->",
"call_cookie",
"&",
"CALL_LONG",
")",
"fprintf",
"(",
"stderr",
",",
"\" longcall,\"",
")",
";",
"fprintf",
"(",
"stderr",
",",
"\" proto = %d, nargs = %d\\n\"",
",",
"cum",
"->",
"prototype",
",",
"cum",
"->",
"nargs_prototype",
")",
";",
"}",
"if",
"(",
"fntype",
"&&",
"!",
"TARGET_ALTIVEC",
"&&",
"TARGET_ALTIVEC_ABI",
"&&",
"ALTIVEC_VECTOR_MODE",
"(",
"TYPE_MODE",
"(",
"TREE_TYPE",
"(",
"fntype",
")",
")",
")",
")",
"{",
"error",
"(",
"\"cannot return value in vector register because\"",
"\" altivec instructions are disabled, use -maltivec\"",
"\" to enable them\"",
")",
";",
"}",
"}",
"</s>"
] | [
"Handle",
"the",
"INIT_CUMULATIVE_ARGS",
"macro",
".",
"Initialize",
"a",
"variable",
"CUM",
"of",
"type",
"CUMULATIVE_ARGS",
"for",
"a",
"call",
"to",
"a",
"function",
"whose",
"data",
"type",
"is",
"FNTYPE",
".",
"For",
"a",
"library",
"call",
",",
"FNTYPE",
"is",
"0",
"."
] | [
"rs6000",
"0",
"0",
"0",
"\"longcall\"",
"\"shortcall\"",
"\"\\ninit_cumulative_args:\"",
"\" ret code = %s,\"",
"\" longcall,\"",
"\" proto = %d, nargs = %d\\n\"",
"\"cannot return value in vector register because\"",
"\" altivec instructions are disabled, use -maltivec\"",
"\" to enable them\""
] | rs60003 | init_cumulative_args | rs6000 | CPU | GCC | 8,852 | 283 | 1 | [] |
[
"<s>",
"char",
"*",
"mcore_output_call",
"(",
"rtx",
"operands",
"[",
"]",
",",
"int",
"index",
")",
"{",
"static",
"char",
"buffer",
"[",
"20",
"]",
";",
"rtx",
"addr",
"=",
"operands",
"[",
"index",
"]",
";",
"if",
"(",
"REG_P",
"(",
"addr",
")",
")",
"{",
"if",
"(",
"TARGET_CG_DATA",
")",
"{",
"gcc_assert",
"(",
"mcore_current_function_name",
")",
";",
"ASM_OUTPUT_CG_EDGE",
"(",
"asm_out_file",
",",
"mcore_current_function_name",
",",
"\"unknown\"",
",",
"1",
")",
";",
"}",
"sprintf",
"(",
"buffer",
",",
"\"jsr\\t%%%d\"",
",",
"index",
")",
";",
"}",
"else",
"{",
"if",
"(",
"TARGET_CG_DATA",
")",
"{",
"gcc_assert",
"(",
"mcore_current_function_name",
")",
";",
"gcc_assert",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"SYMBOL_REF",
")",
";",
"ASM_OUTPUT_CG_EDGE",
"(",
"asm_out_file",
",",
"mcore_current_function_name",
",",
"XSTR",
"(",
"addr",
",",
"0",
")",
",",
"0",
")",
";",
"}",
"sprintf",
"(",
"buffer",
",",
"\"jbsr\\t%%%d\"",
",",
"index",
")",
";",
"}",
"return",
"buffer",
";",
"}",
"</s>"
] | [
"Functions",
"to",
"output",
"assembly",
"code",
"for",
"a",
"function",
"call",
"."
] | [
"mcore",
"20",
"\"unknown\"",
"1",
"\"jsr\\t%%%d\"",
"0",
"0",
"\"jbsr\\t%%%d\""
] | mcore | mcore_output_call | mcore | MPU | GCC | 8,853 | 121 | 1 | [] |
[
"<s>",
"static",
"void",
"nvptx_goacc_reduction_teardown",
"(",
"gcall",
"*",
"call",
",",
"offload_attrs",
"*",
"oa",
")",
"{",
"gimple_stmt_iterator",
"gsi",
"=",
"gsi_for_stmt",
"(",
"call",
")",
";",
"tree",
"lhs",
"=",
"gimple_call_lhs",
"(",
"call",
")",
";",
"tree",
"var",
"=",
"gimple_call_arg",
"(",
"call",
",",
"2",
")",
";",
"int",
"level",
"=",
"TREE_INT_CST_LOW",
"(",
"gimple_call_arg",
"(",
"call",
",",
"3",
")",
")",
";",
"gimple_seq",
"seq",
"=",
"NULL",
";",
"push_gimplify_context",
"(",
"true",
")",
";",
"if",
"(",
"level",
"==",
"GOMP_DIM_WORKER",
"||",
"(",
"level",
"==",
"GOMP_DIM_VECTOR",
"&&",
"oa",
"->",
"vector_length",
">",
"PTX_WARP_SIZE",
")",
")",
"{",
"tree",
"offset",
"=",
"gimple_call_arg",
"(",
"call",
",",
"5",
")",
";",
"tree",
"call",
"=",
"nvptx_get_shared_red_addr",
"(",
"TREE_TYPE",
"(",
"var",
")",
",",
"offset",
",",
"level",
"==",
"GOMP_DIM_VECTOR",
")",
";",
"tree",
"ptr",
"=",
"make_ssa_name",
"(",
"TREE_TYPE",
"(",
"call",
")",
")",
";",
"gimplify_assign",
"(",
"ptr",
",",
"call",
",",
"&",
"seq",
")",
";",
"var",
"=",
"build_simple_mem_ref",
"(",
"ptr",
")",
";",
"TREE_THIS_VOLATILE",
"(",
"var",
")",
"=",
"1",
";",
"}",
"if",
"(",
"level",
"!=",
"GOMP_DIM_GANG",
")",
"{",
"tree",
"ref_to_res",
"=",
"gimple_call_arg",
"(",
"call",
",",
"1",
")",
";",
"if",
"(",
"!",
"integer_zerop",
"(",
"ref_to_res",
")",
")",
"gimplify_assign",
"(",
"build_simple_mem_ref",
"(",
"ref_to_res",
")",
",",
"var",
",",
"&",
"seq",
")",
";",
"}",
"if",
"(",
"lhs",
")",
"gimplify_assign",
"(",
"lhs",
",",
"var",
",",
"&",
"seq",
")",
";",
"pop_gimplify_context",
"(",
"NULL",
")",
";",
"gsi_replace_with_seq",
"(",
"&",
"gsi",
",",
"seq",
",",
"true",
")",
";",
"}",
"</s>"
] | [
"NVPTX",
"implementation",
"of",
"GOACC_REDUCTION_TEARDOWN",
"."
] | [
"nvptx",
"2",
"3",
"5",
"1",
"1"
] | nvptx | nvptx_goacc_reduction_teardown | nvptx | GPU | GCC | 8,854 | 213 | 1 | [] |
[
"<s>",
"bool",
"isImm",
"(",
")",
"const",
"override",
"{",
"return",
"Kind",
"==",
"IMMEDIATE",
";",
"}",
"</s>"
] | [
"isImm",
"-",
"Is",
"this",
"an",
"immediate",
"operand",
"?"
] | [
"DLX"
] | DLXAsmParser | isImm | DLX | CPU | LLVM | 8,855 | 13 | 1 | [] |
[
"<s>",
"void",
"XtensaMCCodeEmitter",
"::",
"encodeInstruction",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"raw_ostream",
"&",
"OS",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"uint64_t",
"Hex",
"=",
"getBinaryCodeForInstr",
"(",
"MI",
",",
"Fixups",
",",
"STI",
")",
";",
"support",
"::",
"endian",
"::",
"write",
"<",
"uint8_t",
">",
"(",
"OS",
",",
"(",
"Hex",
">>",
"0",
")",
"&",
"0xff",
",",
"llvm",
"::",
"support",
"::",
"little",
")",
";",
"support",
"::",
"endian",
"::",
"write",
"<",
"uint8_t",
">",
"(",
"OS",
",",
"(",
"Hex",
">>",
"8",
")",
"&",
"0xff",
",",
"llvm",
"::",
"support",
"::",
"little",
")",
";",
"if",
"(",
"!",
"(",
"Hex",
"&",
"8",
")",
")",
"support",
"::",
"endian",
"::",
"write",
"<",
"uint8_t",
">",
"(",
"OS",
",",
"(",
"Hex",
">>",
"16",
")",
"&",
"0xff",
",",
"llvm",
"::",
"support",
"::",
"little",
")",
";",
"}",
"</s>"
] | [
"Encode",
"the",
"given",
"Inst",
"to",
"bytes",
"and",
"append",
"to",
"CB",
"."
] | [
"Xtensa",
"Xtensa",
"support::endian",
"0",
"0xff",
"support::little",
"support::endian",
"8",
"0xff",
"support::little",
"8",
"support::endian",
"16",
"0xff",
"support::little"
] | XtensaMCCodeEmitter | encodeInstruction | Xtensa | MPU | LLVM | 8,856 | 128 | 1 | [] |
[
"<s>",
"const",
"Cpu0RegisterInfo",
"&",
"Cpu0SEInstrInfo",
"::",
"getRegisterInfo",
"(",
")",
"const",
"{",
"return",
"RI",
";",
"}",
"</s>"
] | [
"getRegisterInfo",
"-",
"TargetInstrInfo",
"is",
"a",
"superset",
"of",
"MRegister",
"info",
"."
] | [
"Cpu0",
"Cpu0",
"Cpu0"
] | Cpu0SEInstrInfo | getRegisterInfo | Cpu0 | CPU | LLVM | 8,857 | 14 | 1 | [] |
[
"<s>",
"bool",
"aarch64_expand_movmem",
"(",
"rtx",
"*",
"operands",
")",
"{",
"int",
"n",
",",
"mode_bits",
";",
"rtx",
"dst",
"=",
"operands",
"[",
"0",
"]",
";",
"rtx",
"src",
"=",
"operands",
"[",
"1",
"]",
";",
"rtx",
"base",
";",
"machine_mode",
"cur_mode",
"=",
"BLKmode",
",",
"next_mode",
";",
"bool",
"speed_p",
"=",
"!",
"optimize_function_for_size_p",
"(",
"cfun",
")",
";",
"int",
"max_num_moves",
"=",
"(",
"speed_p",
"?",
"16",
":",
"AARCH64_CALL_RATIO",
")",
"/",
"2",
";",
"if",
"(",
"!",
"CONST_INT_P",
"(",
"operands",
"[",
"2",
"]",
")",
")",
"return",
"false",
";",
"n",
"=",
"INTVAL",
"(",
"operands",
"[",
"2",
"]",
")",
";",
"if",
"(",
"(",
"(",
"n",
"/",
"16",
")",
"+",
"(",
"n",
"%",
"16",
"?",
"2",
":",
"0",
")",
")",
">",
"max_num_moves",
")",
"return",
"false",
";",
"base",
"=",
"copy_to_mode_reg",
"(",
"Pmode",
",",
"XEXP",
"(",
"dst",
",",
"0",
")",
")",
";",
"dst",
"=",
"adjust_automodify_address",
"(",
"dst",
",",
"VOIDmode",
",",
"base",
",",
"0",
")",
";",
"base",
"=",
"copy_to_mode_reg",
"(",
"Pmode",
",",
"XEXP",
"(",
"src",
",",
"0",
")",
")",
";",
"src",
"=",
"adjust_automodify_address",
"(",
"src",
",",
"VOIDmode",
",",
"base",
",",
"0",
")",
";",
"n",
"=",
"n",
"*",
"BITS_PER_UNIT",
";",
"const",
"int",
"copy_limit",
"=",
"GET_MODE_BITSIZE",
"(",
"TImode",
")",
";",
"while",
"(",
"n",
">",
"0",
")",
"{",
"opt_scalar_int_mode",
"mode_iter",
";",
"FOR_EACH_MODE_IN_CLASS",
"(",
"mode_iter",
",",
"MODE_INT",
")",
"if",
"(",
"GET_MODE_BITSIZE",
"(",
"mode_iter",
".",
"require",
"(",
")",
")",
"<=",
"MIN",
"(",
"n",
",",
"copy_limit",
")",
")",
"cur_mode",
"=",
"mode_iter",
".",
"require",
"(",
")",
";",
"gcc_assert",
"(",
"cur_mode",
"!=",
"BLKmode",
")",
";",
"mode_bits",
"=",
"GET_MODE_BITSIZE",
"(",
"cur_mode",
")",
".",
"to_constant",
"(",
")",
";",
"aarch64_copy_one_block_and_progress_pointers",
"(",
"&",
"src",
",",
"&",
"dst",
",",
"cur_mode",
")",
";",
"n",
"-=",
"mode_bits",
";",
"if",
"(",
"n",
">",
"0",
"&&",
"n",
"<=",
"8",
"*",
"BITS_PER_UNIT",
")",
"{",
"next_mode",
"=",
"smallest_mode_for_size",
"(",
"n",
",",
"MODE_INT",
")",
";",
"int",
"n_bits",
"=",
"GET_MODE_BITSIZE",
"(",
"next_mode",
")",
".",
"to_constant",
"(",
")",
";",
"src",
"=",
"aarch64_move_pointer",
"(",
"src",
",",
"(",
"n",
"-",
"n_bits",
")",
"/",
"BITS_PER_UNIT",
")",
";",
"dst",
"=",
"aarch64_move_pointer",
"(",
"dst",
",",
"(",
"n",
"-",
"n_bits",
")",
"/",
"BITS_PER_UNIT",
")",
";",
"n",
"=",
"n_bits",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Expand",
"movmem",
",",
"as",
"if",
"from",
"a",
"__builtin_memcpy",
".",
"Return",
"true",
"if",
"we",
"succeed",
",",
"otherwise",
"return",
"false",
"."
] | [
"aarch64",
"0",
"1",
"16",
"2",
"2",
"2",
"16",
"16",
"2",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"8"
] | aarch646 | aarch64_expand_movmem | aarch64 | CPU | GCC | 8,858 | 328 | 1 | [] |
[
"<s>",
"void",
"NVPTXTargetMachine",
"::",
"registerPassBuilderCallbacks",
"(",
"PassBuilder",
"&",
"PB",
")",
"{",
"PB",
".",
"registerPipelineParsingCallback",
"(",
"[",
"]",
"(",
"StringRef",
"PassName",
",",
"FunctionPassManager",
"&",
"PM",
",",
"ArrayRef",
"<",
"PassBuilder",
"::",
"PipelineElement",
">",
")",
"{",
"if",
"(",
"PassName",
"==",
"\"nvvm-reflect\"",
")",
"{",
"PM",
".",
"addPass",
"(",
"NVVMReflectPass",
"(",
")",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"PassName",
"==",
"\"nvvm-intr-range\"",
")",
"{",
"PM",
".",
"addPass",
"(",
"NVVMIntrRangePass",
"(",
")",
")",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
")",
";",
"PB",
".",
"registerPipelineStartEPCallback",
"(",
"[",
"this",
"]",
"(",
"ModulePassManager",
"&",
"PM",
",",
"OptimizationLevel",
"Level",
")",
"{",
"FunctionPassManager",
"FPM",
";",
"FPM",
".",
"addPass",
"(",
"NVVMReflectPass",
"(",
"Subtarget",
".",
"getSmVersion",
"(",
")",
")",
")",
";",
"PM",
".",
"addPass",
"(",
"createModuleToFunctionPassAdaptor",
"(",
"std",
"::",
"move",
"(",
"FPM",
")",
")",
")",
";",
"}",
")",
";",
"}",
"</s>"
] | [
"Invoke",
"the",
"PassBuilder",
"callback",
"registration",
"."
] | [
"NVPTX",
"NVPTX",
"\"nvvm-reflect\"",
"\"nvvm-intr-range\""
] | NVPTXTargetMachine (2)1 | registerPassBuilderCallbacks | NVPTX | GPU | LLVM | 8,859 | 130 | 1 | [] |
[
"<s>",
"StackOffset",
"(",
"const",
"StackOffset",
"&",
"Other",
")",
":",
"Bytes",
"(",
"Other",
".",
"Bytes",
")",
"{",
"}",
"</s>"
] | [
"Offset",
"from",
"the",
"stack",
"pointer",
"."
] | [
"AArch64"
] | AArch64StackOffset1 | StackOffset | AArch64 | CPU | LLVM | 8,860 | 16 | 1 | [] |
[
"<s>",
"bool",
"ARMBaseRegisterInfo",
"::",
"canRealignStack",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"MachineRegisterInfo",
"*",
"MRI",
"=",
"&",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"const",
"ARMFunctionInfo",
"*",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"const",
"ARMFrameLowering",
"*",
"TFI",
"=",
"getFrameLowering",
"(",
"MF",
")",
";",
"if",
"(",
"!",
"TargetRegisterInfo",
"::",
"canRealignStack",
"(",
"MF",
")",
")",
"return",
"false",
";",
"if",
"(",
"AFI",
"->",
"isThumb1OnlyFunction",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"MRI",
"->",
"canReserveReg",
"(",
"getFramePointerReg",
"(",
"MF",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"TFI",
"->",
"hasReservedCallFrame",
"(",
"MF",
")",
")",
"return",
"true",
";",
"return",
"MRI",
"->",
"canReserveReg",
"(",
"BasePtr",
")",
";",
"}",
"</s>"
] | [
"True",
"if",
"the",
"stack",
"can",
"be",
"realigned",
"for",
"the",
"target",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM"
] | ARMBaseRegisterInfo10 | canRealignStack | ARM | CPU | LLVM | 8,861 | 116 | 1 | [] |
[
"<s>",
"void",
"sparc_emit_floatunsdi",
"(",
"rtx",
"*",
"operands",
",",
"machine_mode",
"mode",
")",
"{",
"rtx",
"i0",
",",
"i1",
",",
"f0",
",",
"in",
",",
"out",
";",
"out",
"=",
"operands",
"[",
"0",
"]",
";",
"in",
"=",
"force_reg",
"(",
"DImode",
",",
"operands",
"[",
"1",
"]",
")",
";",
"rtx_code_label",
"*",
"neglab",
"=",
"gen_label_rtx",
"(",
")",
";",
"rtx_code_label",
"*",
"donelab",
"=",
"gen_label_rtx",
"(",
")",
";",
"i0",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"i1",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"f0",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"emit_cmp_and_jump_insns",
"(",
"in",
",",
"const0_rtx",
",",
"LT",
",",
"const0_rtx",
",",
"DImode",
",",
"0",
",",
"neglab",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"out",
",",
"gen_rtx_FLOAT",
"(",
"mode",
",",
"in",
")",
")",
")",
";",
"emit_jump_insn",
"(",
"gen_jump",
"(",
"donelab",
")",
")",
";",
"emit_barrier",
"(",
")",
";",
"emit_label",
"(",
"neglab",
")",
";",
"emit_insn",
"(",
"gen_lshrdi3",
"(",
"i0",
",",
"in",
",",
"const1_rtx",
")",
")",
";",
"emit_insn",
"(",
"gen_anddi3",
"(",
"i1",
",",
"in",
",",
"const1_rtx",
")",
")",
";",
"emit_insn",
"(",
"gen_iordi3",
"(",
"i0",
",",
"i0",
",",
"i1",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"f0",
",",
"gen_rtx_FLOAT",
"(",
"mode",
",",
"i0",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"out",
",",
"gen_rtx_PLUS",
"(",
"mode",
",",
"f0",
",",
"f0",
")",
")",
")",
";",
"emit_label",
"(",
"donelab",
")",
";",
"}",
"</s>"
] | [
"Generate",
"an",
"unsigned",
"DImode",
"to",
"FP",
"conversion",
".",
"This",
"is",
"the",
"same",
"code",
"optabs",
"would",
"emit",
"if",
"we",
"did",
"n't",
"have",
"TFmode",
"patterns",
"."
] | [
"sparc",
"0",
"1",
"0"
] | sparc4 | sparc_emit_floatunsdi | sparc | CPU | GCC | 8,862 | 207 | 1 | [] |
[
"<s>",
"static",
"int",
"arc_memory_move_cost",
"(",
"machine_mode",
"mode",
",",
"reg_class_t",
"rclass",
"ATTRIBUTE_UNUSED",
",",
"bool",
"in",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
"<=",
"UNITS_PER_WORD",
")",
"||",
"(",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
"<=",
"UNITS_PER_WORD",
"*",
"2",
")",
"&&",
"TARGET_LL64",
")",
")",
"return",
"6",
";",
"return",
"(",
"2",
"*",
"GET_MODE_SIZE",
"(",
"mode",
")",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_MEMORY_MOVE_COST",
"."
] | [
"arc",
"2",
"6",
"2"
] | arc | arc_memory_move_cost | arc | MPU | GCC | 8,863 | 56 | 1 | [] |
[
"<s>",
"DecodeStatus",
"SparcDisassembler",
"::",
"getInstruction",
"(",
"MCInst",
"&",
"Instr",
",",
"uint64_t",
"&",
"Size",
",",
"ArrayRef",
"<",
"uint8_t",
">",
"Bytes",
",",
"uint64_t",
"Address",
",",
"raw_ostream",
"&",
"VStream",
",",
"raw_ostream",
"&",
"CStream",
")",
"const",
"{",
"uint32_t",
"Insn",
";",
"bool",
"isLittleEndian",
"=",
"getContext",
"(",
")",
".",
"getAsmInfo",
"(",
")",
"->",
"isLittleEndian",
"(",
")",
";",
"DecodeStatus",
"Result",
"=",
"readInstruction32",
"(",
"Bytes",
",",
"Address",
",",
"Size",
",",
"Insn",
",",
"isLittleEndian",
")",
";",
"if",
"(",
"Result",
"==",
"MCDisassembler",
"::",
"Fail",
")",
"return",
"MCDisassembler",
"::",
"Fail",
";",
"if",
"(",
"STI",
".",
"getFeatureBits",
"(",
")",
"[",
"Sparc",
"::",
"FeatureV9",
"]",
")",
"{",
"Result",
"=",
"decodeInstruction",
"(",
"DecoderTableSparcV932",
",",
"Instr",
",",
"Insn",
",",
"Address",
",",
"this",
",",
"STI",
")",
";",
"}",
"else",
"{",
"Result",
"=",
"decodeInstruction",
"(",
"DecoderTableSparcV832",
",",
"Instr",
",",
"Insn",
",",
"Address",
",",
"this",
",",
"STI",
")",
";",
"}",
"if",
"(",
"Result",
"!=",
"MCDisassembler",
"::",
"Fail",
")",
"return",
"Result",
";",
"Result",
"=",
"decodeInstruction",
"(",
"DecoderTableSparc32",
",",
"Instr",
",",
"Insn",
",",
"Address",
",",
"this",
",",
"STI",
")",
";",
"if",
"(",
"Result",
"!=",
"MCDisassembler",
"::",
"Fail",
")",
"{",
"Size",
"=",
"4",
";",
"return",
"Result",
";",
"}",
"return",
"MCDisassembler",
"::",
"Fail",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"disassembly",
"of",
"a",
"single",
"instruction",
"."
] | [
"Sparc",
"Sparc",
"Sparc::FeatureV9",
"Sparc",
"Sparc",
"Sparc",
"4"
] | SparcDisassembler13 | getInstruction | Sparc | CPU | LLVM | 8,864 | 182 | 1 | [] |
[
"<s>",
"static",
"inline",
"tree",
"def_builtin",
"(",
"HOST_WIDE_INT",
"mask",
",",
"HOST_WIDE_INT",
"mask2",
",",
"const",
"char",
"*",
"name",
",",
"enum",
"ix86_builtin_func_type",
"tcode",
",",
"enum",
"ix86_builtins",
"code",
")",
"{",
"tree",
"decl",
"=",
"NULL_TREE",
";",
"if",
"(",
"!",
"(",
"mask",
"&",
"OPTION_MASK_ISA_64BIT",
")",
"||",
"TARGET_64BIT",
")",
"{",
"ix86_builtins_isa",
"[",
"(",
"int",
")",
"code",
"]",
".",
"isa",
"=",
"mask",
";",
"ix86_builtins_isa",
"[",
"(",
"int",
")",
"code",
"]",
".",
"isa2",
"=",
"mask2",
";",
"mask",
"&=",
"~",
"OPTION_MASK_ISA_64BIT",
";",
"if",
"(",
"(",
"mask",
"&",
"ix86_isa_flags",
"&",
"OPTION_MASK_ISA_AVX512VL",
")",
"&&",
"mask",
"!=",
"OPTION_MASK_ISA_AVX512VL",
")",
"mask",
"&=",
"~",
"OPTION_MASK_ISA_AVX512VL",
";",
"if",
"(",
"(",
"mask",
"&",
"ix86_isa_flags",
"&",
"OPTION_MASK_ISA_AVX512BW",
")",
"&&",
"mask",
"!=",
"OPTION_MASK_ISA_AVX512BW",
")",
"mask",
"&=",
"~",
"OPTION_MASK_ISA_AVX512BW",
";",
"if",
"(",
"(",
"(",
"mask2",
"==",
"0",
"||",
"(",
"mask2",
"&",
"ix86_isa_flags2",
")",
"!=",
"0",
")",
"&&",
"(",
"mask",
"==",
"0",
"||",
"(",
"mask",
"&",
"ix86_isa_flags",
")",
"!=",
"0",
")",
")",
"||",
"(",
"(",
"mask",
"&",
"OPTION_MASK_ISA_MMX",
")",
"!=",
"0",
"&&",
"TARGET_MMX_WITH_SSE",
")",
"||",
"(",
"mask2",
"==",
"OPTION_MASK_ISA2_AVXVNNI",
")",
"||",
"(",
"lang_hooks",
".",
"builtin_function",
"==",
"lang_hooks",
".",
"builtin_function_ext_scope",
")",
")",
"{",
"tree",
"type",
"=",
"ix86_get_builtin_func_type",
"(",
"tcode",
")",
";",
"decl",
"=",
"add_builtin_function",
"(",
"name",
",",
"type",
",",
"code",
",",
"BUILT_IN_MD",
",",
"NULL",
",",
"NULL_TREE",
")",
";",
"ix86_builtins",
"[",
"(",
"int",
")",
"code",
"]",
"=",
"decl",
";",
"ix86_builtins_isa",
"[",
"(",
"int",
")",
"code",
"]",
".",
"set_and_not_built_p",
"=",
"false",
";",
"}",
"else",
"{",
"deferred_isa_values",
"|=",
"mask",
";",
"deferred_isa_values2",
"|=",
"mask2",
";",
"ix86_builtins",
"[",
"(",
"int",
")",
"code",
"]",
"=",
"NULL_TREE",
";",
"ix86_builtins_isa",
"[",
"(",
"int",
")",
"code",
"]",
".",
"tcode",
"=",
"tcode",
";",
"ix86_builtins_isa",
"[",
"(",
"int",
")",
"code",
"]",
".",
"name",
"=",
"name",
";",
"ix86_builtins_isa",
"[",
"(",
"int",
")",
"code",
"]",
".",
"const_p",
"=",
"false",
";",
"ix86_builtins_isa",
"[",
"(",
"int",
")",
"code",
"]",
".",
"pure_p",
"=",
"false",
";",
"ix86_builtins_isa",
"[",
"(",
"int",
")",
"code",
"]",
".",
"set_and_not_built_p",
"=",
"true",
";",
"}",
"}",
"return",
"decl",
";",
"}",
"</s>"
] | [
"Add",
"a",
"SPARC",
"builtin",
"function",
"with",
"NAME",
",",
"ICODE",
",",
"CODE",
"and",
"TYPE",
".",
"Return",
"the",
"function",
"decl",
"or",
"NULL_TREE",
"if",
"the",
"builtin",
"was",
"not",
"added",
"."
] | [
"i386",
"0",
"0",
"0",
"0",
"0"
] | i386-builtins | def_builtin | i386 | CPU | GCC | 8,865 | 304 | 1 | [] |
[
"<s>",
"static",
"int",
"signal_function_p",
"(",
"tree",
"func",
")",
"{",
"tree",
"a",
";",
"if",
"(",
"TREE_CODE",
"(",
"func",
")",
"!=",
"FUNCTION_DECL",
")",
"return",
"0",
";",
"a",
"=",
"lookup_attribute",
"(",
"\"signal\"",
",",
"DECL_ATTRIBUTES",
"(",
"func",
")",
")",
";",
"return",
"a",
"!=",
"NULL_TREE",
";",
"}",
"</s>"
] | [
"Return",
"nonzero",
"if",
"FUNC",
"is",
"a",
"signal",
"function",
"as",
"specified",
"by",
"the",
"``",
"signal",
"''",
"attribute",
"."
] | [
"avr",
"0",
"\"signal\""
] | avr3 | signal_function_p | avr | MPU | GCC | 8,866 | 41 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"output_fp_compare",
"(",
"rtx",
"insn",
",",
"rtx",
"*",
"operands",
",",
"bool",
"eflags_p",
",",
"bool",
"unordered_p",
")",
"{",
"int",
"stack_top_dies",
";",
"rtx",
"cmp_op0",
",",
"cmp_op1",
";",
"int",
"is_sse",
"=",
"SSE_REG_P",
"(",
"operands",
"[",
"0",
"]",
")",
"||",
"SSE_REG_P",
"(",
"operands",
"[",
"1",
"]",
")",
";",
"if",
"(",
"eflags_p",
")",
"{",
"cmp_op0",
"=",
"operands",
"[",
"0",
"]",
";",
"cmp_op1",
"=",
"operands",
"[",
"1",
"]",
";",
"}",
"else",
"{",
"cmp_op0",
"=",
"operands",
"[",
"1",
"]",
";",
"cmp_op1",
"=",
"operands",
"[",
"2",
"]",
";",
"}",
"if",
"(",
"is_sse",
")",
"{",
"if",
"(",
"GET_MODE",
"(",
"operands",
"[",
"0",
"]",
")",
"==",
"SFmode",
")",
"if",
"(",
"unordered_p",
")",
"return",
"\"%vucomiss\\t{%1, %0|%0, %1}\"",
";",
"else",
"return",
"\"%vcomiss\\t{%1, %0|%0, %1}\"",
";",
"else",
"if",
"(",
"unordered_p",
")",
"return",
"\"%vucomisd\\t{%1, %0|%0, %1}\"",
";",
"else",
"return",
"\"%vcomisd\\t{%1, %0|%0, %1}\"",
";",
"}",
"gcc_assert",
"(",
"STACK_TOP_P",
"(",
"cmp_op0",
")",
")",
";",
"stack_top_dies",
"=",
"find_regno_note",
"(",
"insn",
",",
"REG_DEAD",
",",
"FIRST_STACK_REG",
")",
"!=",
"0",
";",
"if",
"(",
"cmp_op1",
"==",
"CONST0_RTX",
"(",
"GET_MODE",
"(",
"cmp_op1",
")",
")",
")",
"{",
"if",
"(",
"stack_top_dies",
")",
"{",
"output_asm_insn",
"(",
"\"ftst\\n\\tfnstsw\\t%0\"",
",",
"operands",
")",
";",
"return",
"output_387_ffreep",
"(",
"operands",
",",
"1",
")",
";",
"}",
"else",
"return",
"\"ftst\\n\\tfnstsw\\t%0\"",
";",
"}",
"if",
"(",
"STACK_REG_P",
"(",
"cmp_op1",
")",
"&&",
"stack_top_dies",
"&&",
"find_regno_note",
"(",
"insn",
",",
"REG_DEAD",
",",
"REGNO",
"(",
"cmp_op1",
")",
")",
"&&",
"REGNO",
"(",
"cmp_op1",
")",
"!=",
"FIRST_STACK_REG",
")",
"{",
"if",
"(",
"eflags_p",
")",
"{",
"if",
"(",
"unordered_p",
")",
"output_asm_insn",
"(",
"\"fucomip\\t{%y1, %0|%0, %y1}\"",
",",
"operands",
")",
";",
"else",
"output_asm_insn",
"(",
"\"fcomip\\t{%y1, %0|%0, %y1}\"",
",",
"operands",
")",
";",
"return",
"output_387_ffreep",
"(",
"operands",
",",
"0",
")",
";",
"}",
"else",
"{",
"if",
"(",
"unordered_p",
")",
"return",
"\"fucompp\\n\\tfnstsw\\t%0\"",
";",
"else",
"return",
"\"fcompp\\n\\tfnstsw\\t%0\"",
";",
"}",
"}",
"else",
"{",
"static",
"const",
"char",
"*",
"const",
"alt",
"[",
"16",
"]",
"=",
"{",
"\"fcom%Z2\\t%y2\\n\\tfnstsw\\t%0\"",
",",
"\"fcomp%Z2\\t%y2\\n\\tfnstsw\\t%0\"",
",",
"\"fucom%Z2\\t%y2\\n\\tfnstsw\\t%0\"",
",",
"\"fucomp%Z2\\t%y2\\n\\tfnstsw\\t%0\"",
",",
"\"ficom%Z2\\t%y2\\n\\tfnstsw\\t%0\"",
",",
"\"ficomp%Z2\\t%y2\\n\\tfnstsw\\t%0\"",
",",
"NULL",
",",
"NULL",
",",
"\"fcomi\\t{%y1, %0|%0, %y1}\"",
",",
"\"fcomip\\t{%y1, %0|%0, %y1}\"",
",",
"\"fucomi\\t{%y1, %0|%0, %y1}\"",
",",
"\"fucomip\\t{%y1, %0|%0, %y1}\"",
",",
"NULL",
",",
"NULL",
",",
"NULL",
",",
"NULL",
"}",
";",
"int",
"mask",
";",
"const",
"char",
"*",
"ret",
";",
"mask",
"=",
"eflags_p",
"<<",
"3",
";",
"mask",
"|=",
"(",
"GET_MODE_CLASS",
"(",
"GET_MODE",
"(",
"cmp_op1",
")",
")",
"==",
"MODE_INT",
")",
"<<",
"2",
";",
"mask",
"|=",
"unordered_p",
"<<",
"1",
";",
"mask",
"|=",
"stack_top_dies",
";",
"gcc_assert",
"(",
"mask",
"<",
"16",
")",
";",
"ret",
"=",
"alt",
"[",
"mask",
"]",
";",
"gcc_assert",
"(",
"ret",
")",
";",
"return",
"ret",
";",
"}",
"}",
"</s>"
] | [
"Output",
"code",
"for",
"INSN",
"to",
"compare",
"OPERANDS",
".",
"EFLAGS_P",
"is",
"1",
"when",
"fcomi",
"should",
"be",
"used",
"and",
"2",
"when",
"fnstsw",
"should",
"be",
"used",
".",
"UNORDERED_P",
"is",
"true",
"when",
"fucom",
"should",
"be",
"used",
"."
] | [
"i386",
"0",
"1",
"0",
"1",
"1",
"2",
"0",
"\"%vucomiss\\t{%1, %0|%0, %1}\"",
"\"%vcomiss\\t{%1, %0|%0, %1}\"",
"\"%vucomisd\\t{%1, %0|%0, %1}\"",
"\"%vcomisd\\t{%1, %0|%0, %1}\"",
"0",
"\"ftst\\n\\tfnstsw\\t%0\"",
"1",
"\"ftst\\n\\tfnstsw\\t%0\"",
"\"fucomip\\t{%y1, %0|%0, %y1}\"",
"\"fcomip\\t{%y1, %0|%0, %y1}\"",
"0",
"\"fucompp\\n\\tfnstsw\\t%0\"",
"\"fcompp\\n\\tfnstsw\\t%0\"",
"16",
"\"fcom%Z2\\t%y2\\n\\tfnstsw\\t%0\"",
"\"fcomp%Z2\\t%y2\\n\\tfnstsw\\t%0\"",
"\"fucom%Z2\\t%y2\\n\\tfnstsw\\t%0\"",
"\"fucomp%Z2\\t%y2\\n\\tfnstsw\\t%0\"",
"\"ficom%Z2\\t%y2\\n\\tfnstsw\\t%0\"",
"\"ficomp%Z2\\t%y2\\n\\tfnstsw\\t%0\"",
"\"fcomi\\t{%y1, %0|%0, %y1}\"",
"\"fcomip\\t{%y1, %0|%0, %y1}\"",
"\"fucomi\\t{%y1, %0|%0, %y1}\"",
"\"fucomip\\t{%y1, %0|%0, %y1}\"",
"3",
"2",
"1",
"16"
] | i3864 | output_fp_compare | i386 | CPU | GCC | 8,867 | 371 | 1 | [] |
[
"<s>",
"bool",
"MVEGatherScatterLowering",
"::",
"runOnFunction",
"(",
"Function",
"&",
"F",
")",
"{",
"if",
"(",
"!",
"EnableMaskedGatherScatters",
")",
"return",
"false",
";",
"auto",
"&",
"TPC",
"=",
"getAnalysis",
"<",
"TargetPassConfig",
">",
"(",
")",
";",
"auto",
"&",
"TM",
"=",
"TPC",
".",
"getTM",
"<",
"TargetMachine",
">",
"(",
")",
";",
"auto",
"*",
"ST",
"=",
"&",
"TM",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
"F",
")",
";",
"if",
"(",
"!",
"ST",
"->",
"hasMVEIntegerOps",
"(",
")",
")",
"return",
"false",
";",
"LI",
"=",
"&",
"getAnalysis",
"<",
"LoopInfoWrapperPass",
">",
"(",
")",
".",
"getLoopInfo",
"(",
")",
";",
"DL",
"=",
"&",
"F",
".",
"getParent",
"(",
")",
"->",
"getDataLayout",
"(",
")",
";",
"SmallVector",
"<",
"IntrinsicInst",
"*",
",",
"4",
">",
"Gathers",
";",
"SmallVector",
"<",
"IntrinsicInst",
"*",
",",
"4",
">",
"Scatters",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"BasicBlock",
"&",
"BB",
":",
"F",
")",
"{",
"Changed",
"|=",
"SimplifyInstructionsInBlock",
"(",
"&",
"BB",
")",
";",
"for",
"(",
"Instruction",
"&",
"I",
":",
"BB",
")",
"{",
"IntrinsicInst",
"*",
"II",
"=",
"dyn_cast",
"<",
"IntrinsicInst",
">",
"(",
"&",
"I",
")",
";",
"if",
"(",
"II",
"&&",
"II",
"->",
"getIntrinsicID",
"(",
")",
"==",
"Intrinsic",
"::",
"masked_gather",
"&&",
"isa",
"<",
"FixedVectorType",
">",
"(",
"II",
"->",
"getType",
"(",
")",
")",
")",
"{",
"Gathers",
".",
"push_back",
"(",
"II",
")",
";",
"Changed",
"|=",
"optimiseAddress",
"(",
"II",
"->",
"getArgOperand",
"(",
"0",
")",
",",
"II",
"->",
"getParent",
"(",
")",
",",
"LI",
")",
";",
"}",
"else",
"if",
"(",
"II",
"&&",
"II",
"->",
"getIntrinsicID",
"(",
")",
"==",
"Intrinsic",
"::",
"masked_scatter",
"&&",
"isa",
"<",
"FixedVectorType",
">",
"(",
"II",
"->",
"getArgOperand",
"(",
"0",
")",
"->",
"getType",
"(",
")",
")",
")",
"{",
"Scatters",
".",
"push_back",
"(",
"II",
")",
";",
"Changed",
"|=",
"optimiseAddress",
"(",
"II",
"->",
"getArgOperand",
"(",
"1",
")",
",",
"II",
"->",
"getParent",
"(",
")",
",",
"LI",
")",
";",
"}",
"}",
"}",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"Gathers",
".",
"size",
"(",
")",
";",
"i",
"++",
")",
"{",
"IntrinsicInst",
"*",
"I",
"=",
"Gathers",
"[",
"i",
"]",
";",
"Instruction",
"*",
"L",
"=",
"lowerGather",
"(",
"I",
")",
";",
"if",
"(",
"L",
"==",
"nullptr",
")",
"continue",
";",
"SimplifyInstructionsInBlock",
"(",
"L",
"->",
"getParent",
"(",
")",
")",
";",
"Changed",
"=",
"true",
";",
"}",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"Scatters",
".",
"size",
"(",
")",
";",
"i",
"++",
")",
"{",
"IntrinsicInst",
"*",
"I",
"=",
"Scatters",
"[",
"i",
"]",
";",
"Instruction",
"*",
"S",
"=",
"lowerScatter",
"(",
"I",
")",
";",
"if",
"(",
"S",
"==",
"nullptr",
")",
"continue",
";",
"SimplifyInstructionsInBlock",
"(",
"S",
"->",
"getParent",
"(",
")",
")",
";",
"Changed",
"=",
"true",
";",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnFunction",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"the",
"per-function",
"processing",
"of",
"the",
"pass",
"."
] | [
"ARM",
"ARM",
"4",
"4",
"Intrinsic::masked_gather",
"0",
"Intrinsic::masked_scatter",
"0",
"1",
"0",
"0"
] | MVEGatherScatterLowering (2) | runOnFunction | ARM | CPU | LLVM | 8,868 | 398 | 1 | [] |
[
"<s>",
"static",
"bool",
"arm_vectorize_vec_perm_const_ok",
"(",
"machine_mode",
"vmode",
",",
"const",
"unsigned",
"char",
"*",
"sel",
")",
"{",
"struct",
"expand_vec_perm_d",
"d",
";",
"unsigned",
"int",
"i",
",",
"nelt",
",",
"which",
";",
"bool",
"ret",
";",
"d",
".",
"vmode",
"=",
"vmode",
";",
"d",
".",
"nelt",
"=",
"nelt",
"=",
"GET_MODE_NUNITS",
"(",
"d",
".",
"vmode",
")",
";",
"d",
".",
"testing_p",
"=",
"true",
";",
"memcpy",
"(",
"d",
".",
"perm",
",",
"sel",
",",
"nelt",
")",
";",
"for",
"(",
"i",
"=",
"which",
"=",
"0",
";",
"i",
"<",
"nelt",
";",
"++",
"i",
")",
"{",
"unsigned",
"char",
"e",
"=",
"d",
".",
"perm",
"[",
"i",
"]",
";",
"gcc_assert",
"(",
"e",
"<",
"2",
"*",
"nelt",
")",
";",
"which",
"|=",
"(",
"e",
"<",
"nelt",
"?",
"1",
":",
"2",
")",
";",
"}",
"if",
"(",
"which",
"==",
"2",
")",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"nelt",
";",
"++",
"i",
")",
"d",
".",
"perm",
"[",
"i",
"]",
"-=",
"nelt",
";",
"d",
".",
"one_vector_p",
"=",
"(",
"which",
"!=",
"3",
")",
";",
"d",
".",
"target",
"=",
"gen_raw_REG",
"(",
"d",
".",
"vmode",
",",
"LAST_VIRTUAL_REGISTER",
"+",
"1",
")",
";",
"d",
".",
"op1",
"=",
"d",
".",
"op0",
"=",
"gen_raw_REG",
"(",
"d",
".",
"vmode",
",",
"LAST_VIRTUAL_REGISTER",
"+",
"2",
")",
";",
"if",
"(",
"!",
"d",
".",
"one_vector_p",
")",
"d",
".",
"op1",
"=",
"gen_raw_REG",
"(",
"d",
".",
"vmode",
",",
"LAST_VIRTUAL_REGISTER",
"+",
"3",
")",
";",
"start_sequence",
"(",
")",
";",
"ret",
"=",
"arm_expand_vec_perm_const_1",
"(",
"&",
"d",
")",
";",
"end_sequence",
"(",
")",
";",
"return",
"ret",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_VECTORIZE_VEC_PERM_CONST_OK",
"."
] | [
"arm",
"0",
"2",
"1",
"2",
"2",
"0",
"3",
"1",
"2",
"3"
] | arm4 | arm_vectorize_vec_perm_const_ok | arm | CPU | GCC | 8,869 | 228 | 1 | [] |
[
"<s>",
"VariantKind",
"getKind",
"(",
")",
"const",
"{",
"return",
"Kind",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"Kind",
"of",
"lane",
"offset",
"."
] | [
"AArch64"
] | AArch64MCExpr (2) | getKind | AArch64 | CPU | LLVM | 8,870 | 10 | 1 | [] |
[
"<s>",
"bool",
"AArch64CallLowering",
"::",
"lowerFormalArguments",
"(",
"MachineIRBuilder",
"&",
"MIRBuilder",
",",
"const",
"Function",
"&",
"F",
",",
"ArrayRef",
"<",
"unsigned",
">",
"VRegs",
")",
"const",
"{",
"auto",
"&",
"Args",
"=",
"F",
".",
"getArgumentList",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"MIRBuilder",
".",
"getMF",
"(",
")",
";",
"MachineBasicBlock",
"&",
"MBB",
"=",
"MIRBuilder",
".",
"getMBB",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"auto",
"&",
"DL",
"=",
"F",
".",
"getParent",
"(",
")",
"->",
"getDataLayout",
"(",
")",
";",
"SmallVector",
"<",
"ArgInfo",
",",
"8",
">",
"SplitArgs",
";",
"unsigned",
"i",
"=",
"0",
";",
"for",
"(",
"auto",
"&",
"Arg",
":",
"Args",
")",
"{",
"ArgInfo",
"OrigArg",
"{",
"VRegs",
"[",
"i",
"]",
",",
"Arg",
".",
"getType",
"(",
")",
"}",
";",
"setArgFlags",
"(",
"OrigArg",
",",
"i",
"+",
"1",
",",
"DL",
",",
"F",
")",
";",
"splitToValueTypes",
"(",
"OrigArg",
",",
"SplitArgs",
",",
"DL",
",",
"MRI",
",",
"[",
"&",
"]",
"(",
"ArrayRef",
"<",
"unsigned",
">",
"Regs",
",",
"ArrayRef",
"<",
"uint64_t",
">",
"Offsets",
")",
"{",
"MIRBuilder",
".",
"buildSequence",
"(",
"VRegs",
"[",
"i",
"]",
",",
"Regs",
",",
"Offsets",
")",
";",
"}",
")",
";",
"++",
"i",
";",
"}",
"if",
"(",
"!",
"MBB",
".",
"empty",
"(",
")",
")",
"MIRBuilder",
".",
"setInstr",
"(",
"*",
"MBB",
".",
"begin",
"(",
")",
")",
";",
"const",
"AArch64TargetLowering",
"&",
"TLI",
"=",
"*",
"getTLI",
"<",
"AArch64TargetLowering",
">",
"(",
")",
";",
"CCAssignFn",
"*",
"AssignFn",
"=",
"TLI",
".",
"CCAssignFnForCall",
"(",
"F",
".",
"getCallingConv",
"(",
")",
",",
"false",
")",
";",
"FormalArgHandler",
"Handler",
"(",
"MIRBuilder",
",",
"MRI",
",",
"AssignFn",
")",
";",
"if",
"(",
"!",
"handleAssignments",
"(",
"MIRBuilder",
",",
"SplitArgs",
",",
"Handler",
")",
")",
"return",
"false",
";",
"if",
"(",
"F",
".",
"isVarArg",
"(",
")",
")",
"{",
"if",
"(",
"!",
"MF",
".",
"getSubtarget",
"<",
"AArch64Subtarget",
">",
"(",
")",
".",
"isTargetDarwin",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"uint64_t",
"StackOffset",
"=",
"alignTo",
"(",
"Handler",
".",
"StackUsed",
",",
"8",
")",
";",
"auto",
"&",
"MFI",
"=",
"MIRBuilder",
".",
"getMF",
"(",
")",
".",
"getFrameInfo",
"(",
")",
";",
"AArch64FunctionInfo",
"*",
"FuncInfo",
"=",
"MF",
".",
"getInfo",
"<",
"AArch64FunctionInfo",
">",
"(",
")",
";",
"FuncInfo",
"->",
"setVarArgsStackIndex",
"(",
"MFI",
".",
"CreateFixedObject",
"(",
"4",
",",
"StackOffset",
",",
"true",
")",
")",
";",
"}",
"MIRBuilder",
".",
"setMBB",
"(",
"MBB",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"the",
"incoming",
"(",
"formal",
")",
"arguments",
",",
"described",
"by",
"VRegs",
",",
"for",
"GlobalISel",
"."
] | [
"AArch64",
"AArch64",
"8",
"0",
"1",
"AArch64",
"AArch64",
"AArch64",
"8",
"AArch64",
"AArch64",
"4"
] | AArch64CallLowering33 | lowerFormalArguments | AArch64 | CPU | LLVM | 8,871 | 347 | 1 | [] |
[
"<s>",
"void",
"AArch64PassConfig",
"::",
"addPostRegAlloc",
"(",
")",
"{",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"EnableDeadRegisterElimination",
")",
"addPass",
"(",
"createAArch64DeadRegisterDefinitions",
"(",
")",
")",
";",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"usingDefaultRegAlloc",
"(",
")",
")",
"addPass",
"(",
"createAArch64A57FPLoadBalancing",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"after",
"register",
"allocation",
"pass",
"pipeline",
"but",
"before",
"prolog-epilog",
"insertion",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64"
] | AArch64TargetMachine2 | addPostRegAlloc | AArch64 | CPU | LLVM | 8,872 | 52 | 1 | [] |
[
"<s>",
"void",
"SPURegisterInfo",
"::",
"emitEpilogue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"prior",
"(",
"MBB",
".",
"end",
"(",
")",
")",
";",
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"int",
"FrameSize",
"=",
"MFI",
"->",
"getStackSize",
"(",
")",
";",
"int",
"LinkSlotOffset",
"=",
"SPUFrameInfo",
"::",
"stackSlotSize",
"(",
")",
";",
"DebugLoc",
"dl",
"=",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
";",
"assert",
"(",
"MBBI",
"->",
"getOpcode",
"(",
")",
"==",
"SPU",
"::",
"RET",
"&&",
"\"Can only insert epilog into returning blocks\"",
")",
";",
"assert",
"(",
"(",
"FrameSize",
"&",
"0xf",
")",
"==",
"0",
"&&",
"\"SPURegisterInfo::emitEpilogue: FrameSize not aligned\"",
")",
";",
"if",
"(",
"FrameSize",
">",
"0",
"||",
"MFI",
"->",
"hasCalls",
"(",
")",
")",
"{",
"FrameSize",
"=",
"FrameSize",
"+",
"SPUFrameInfo",
"::",
"minStackSize",
"(",
")",
";",
"if",
"(",
"isS10Constant",
"(",
"FrameSize",
"+",
"LinkSlotOffset",
")",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"SPU",
"::",
"LQDr128",
")",
",",
"SPU",
"::",
"R0",
")",
".",
"addImm",
"(",
"FrameSize",
"+",
"LinkSlotOffset",
")",
".",
"addReg",
"(",
"SPU",
"::",
"R1",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"SPU",
"::",
"AIr32",
")",
",",
"SPU",
"::",
"R1",
")",
".",
"addReg",
"(",
"SPU",
"::",
"R1",
")",
".",
"addImm",
"(",
"FrameSize",
")",
";",
"}",
"else",
"if",
"(",
"FrameSize",
"<=",
"(",
"1",
"<<",
"16",
")",
"-",
"1",
"&&",
"FrameSize",
">=",
"-",
"(",
"1",
"<<",
"16",
")",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"SPU",
"::",
"STQDr128",
")",
",",
"SPU",
"::",
"R2",
")",
".",
"addImm",
"(",
"16",
")",
".",
"addReg",
"(",
"SPU",
"::",
"R1",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"SPU",
"::",
"ILr32",
")",
",",
"SPU",
"::",
"R2",
")",
".",
"addImm",
"(",
"FrameSize",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"SPU",
"::",
"Ar32",
")",
",",
"SPU",
"::",
"R1",
")",
".",
"addReg",
"(",
"SPU",
"::",
"R1",
")",
".",
"addReg",
"(",
"SPU",
"::",
"R2",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"SPU",
"::",
"LQDr128",
")",
",",
"SPU",
"::",
"R0",
")",
".",
"addImm",
"(",
"16",
")",
".",
"addReg",
"(",
"SPU",
"::",
"R2",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"SPU",
"::",
"SFIr32",
")",
",",
"SPU",
"::",
"R2",
")",
".",
"addReg",
"(",
"SPU",
"::",
"R2",
")",
".",
"addImm",
"(",
"16",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"SPU",
"::",
"LQXr128",
")",
",",
"SPU",
"::",
"R2",
")",
".",
"addReg",
"(",
"SPU",
"::",
"R2",
")",
".",
"addReg",
"(",
"SPU",
"::",
"R1",
")",
";",
"}",
"else",
"{",
"cerr",
"<<",
"\"Unhandled frame size: \"",
"<<",
"FrameSize",
"<<",
"\"\\n\"",
";",
"abort",
"(",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Insert",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"CellSPU",
"SPU",
"SPU",
"SPU::RET",
"\"Can only insert epilog into returning blocks\"",
"0xf",
"0",
"\"SPURegisterInfo::emitEpilogue: FrameSize not aligned\"",
"0",
"SPU",
"SPU::LQDr128",
"SPU::R0",
"SPU::R1",
"SPU::AIr32",
"SPU::R1",
"SPU::R1",
"1",
"16",
"1",
"1",
"16",
"SPU::STQDr128",
"SPU::R2",
"16",
"SPU::R1",
"SPU::ILr32",
"SPU::R2",
"SPU::Ar32",
"SPU::R1",
"SPU::R1",
"SPU::R2",
"SPU::LQDr128",
"SPU::R0",
"16",
"SPU::R2",
"SPU::SFIr32",
"SPU::R2",
"SPU::R2",
"16",
"SPU::LQXr128",
"SPU::R2",
"SPU::R2",
"SPU::R1",
"\"Unhandled frame size: \"",
"\"\\n\""
] | SPURegisterInfo8 | emitEpilogue | CellSPU | MPU | LLVM | 8,873 | 441 | 1 | [] |
[
"<s>",
"rtx",
"extract_nth_lmsw_access_reg",
"(",
"rtx_insn",
"*",
"insn",
",",
"int",
"n",
")",
"{",
"rtx",
"nth_rtx",
"=",
"extract_nth_access_rtx",
"(",
"insn",
",",
"n",
")",
";",
"if",
"(",
"nth_rtx",
"==",
"NULL_RTX",
")",
"return",
"NULL_RTX",
";",
"switch",
"(",
"get_attr_type",
"(",
"insn",
")",
")",
"{",
"case",
"TYPE_LOAD_MULTIPLE",
":",
"return",
"SET_DEST",
"(",
"nth_rtx",
")",
";",
"case",
"TYPE_STORE_MULTIPLE",
":",
"return",
"SET_SRC",
"(",
"nth_rtx",
")",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Returns",
"the",
"register",
"operated",
"by",
"the",
"nth",
"load/store",
"operation",
"in",
"the",
"real",
"micro-operation",
"accessing",
"order",
".",
"This",
"function",
"assumes",
"INSN",
"must",
"be",
"a",
"multiple-word",
"load/store",
"insn",
"."
] | [
"nds32"
] | nds32-pipelines-auxiliary | extract_nth_lmsw_access_reg | nds32 | CPU | GCC | 8,874 | 64 | 1 | [] |
[
"<s>",
"unsigned",
"PPCFastISel",
"::",
"fastMaterializeConstant",
"(",
"const",
"Constant",
"*",
"C",
")",
"{",
"EVT",
"CEVT",
"=",
"TLI",
".",
"getValueType",
"(",
"C",
"->",
"getType",
"(",
")",
",",
"true",
")",
";",
"if",
"(",
"!",
"CEVT",
".",
"isSimple",
"(",
")",
")",
"return",
"0",
";",
"MVT",
"VT",
"=",
"CEVT",
".",
"getSimpleVT",
"(",
")",
";",
"if",
"(",
"const",
"ConstantFP",
"*",
"CFP",
"=",
"dyn_cast",
"<",
"ConstantFP",
">",
"(",
"C",
")",
")",
"return",
"PPCMaterializeFP",
"(",
"CFP",
",",
"VT",
")",
";",
"else",
"if",
"(",
"const",
"GlobalValue",
"*",
"GV",
"=",
"dyn_cast",
"<",
"GlobalValue",
">",
"(",
"C",
")",
")",
"return",
"PPCMaterializeGV",
"(",
"GV",
",",
"VT",
")",
";",
"else",
"if",
"(",
"isa",
"<",
"ConstantInt",
">",
"(",
"C",
")",
")",
"return",
"PPCMaterializeInt",
"(",
"C",
",",
"VT",
",",
"VT",
"!=",
"MVT",
"::",
"i1",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"Emit",
"a",
"constant",
"in",
"a",
"register",
"using",
"target-specific",
"logic",
",",
"such",
"as",
"constant",
"pool",
"loads",
"."
] | [
"PowerPC",
"PPC",
"0",
"PPC",
"PPC",
"PPC",
"MVT::i1",
"0"
] | PPCFastISel17 | fastMaterializeConstant | PowerPC | CPU | LLVM | 8,875 | 124 | 1 | [] |
[
"<s>",
"unsigned",
"getElementSize",
"(",
")",
"{",
"return",
"CurType",
".",
"ElementSize",
";",
"}",
"</s>"
] | [
"Return",
"the",
"size",
"of",
"an",
"element",
"read",
"or",
"written",
"by",
"Inst",
"."
] | [
"X86"
] | X86AsmParser16 | getElementSize | X86 | CPU | LLVM | 8,876 | 11 | 1 | [] |
[
"<s>",
"bool",
"isCall",
"(",
"unsigned",
"Opcode",
",",
"bool",
"*",
"IsIndirectCall",
")",
"{",
"*",
"IsIndirectCall",
"=",
"false",
";",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"return",
"false",
";",
"case",
"Mips",
"::",
"JAL",
":",
"case",
"Mips",
"::",
"BAL_BR",
":",
"case",
"Mips",
"::",
"BLTZAL",
":",
"case",
"Mips",
"::",
"BGEZAL",
":",
"return",
"true",
";",
"case",
"Mips",
"::",
"JALR",
":",
"*",
"IsIndirectCall",
"=",
"true",
";",
"return",
"true",
";",
"}",
"}",
"</s>"
] | [
"Is",
"a",
"function",
"call",
"."
] | [
"Mips",
"Mips::JAL",
"Mips::BAL_BR",
"Mips::BLTZAL",
"Mips::BGEZAL",
"Mips::JALR"
] | MipsNaClELFStreamer11 | isCall | Mips | CPU | LLVM | 8,877 | 64 | 1 | [] |
[
"<s>",
"unsigned",
"MipsRegisterInfo",
"::",
"eliminateFrameIndex",
"(",
"MachineBasicBlock",
"::",
"iterator",
"II",
",",
"int",
"SPAdj",
",",
"int",
"*",
"Value",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"MachineInstr",
"&",
"MI",
"=",
"*",
"II",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"unsigned",
"i",
"=",
"0",
";",
"while",
"(",
"!",
"MI",
".",
"getOperand",
"(",
"i",
")",
".",
"isFI",
"(",
")",
")",
"{",
"++",
"i",
";",
"assert",
"(",
"i",
"<",
"MI",
".",
"getNumOperands",
"(",
")",
"&&",
"\"Instr doesn't have FrameIndex operand!\"",
")",
";",
"}",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"\\nFunction : \"",
"<<",
"MF",
".",
"getFunction",
"(",
")",
"->",
"getName",
"(",
")",
"<<",
"\"\\n\"",
";",
"errs",
"(",
")",
"<<",
"\"<--------->\\n\"",
"<<",
"MI",
")",
";",
"int",
"FrameIndex",
"=",
"MI",
".",
"getOperand",
"(",
"i",
")",
".",
"getIndex",
"(",
")",
";",
"int",
"stackSize",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
"->",
"getStackSize",
"(",
")",
";",
"int",
"spOffset",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
"->",
"getObjectOffset",
"(",
"FrameIndex",
")",
";",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"FrameIndex : \"",
"<<",
"FrameIndex",
"<<",
"\"\\n\"",
"<<",
"\"spOffset : \"",
"<<",
"spOffset",
"<<",
"\"\\n\"",
"<<",
"\"stackSize : \"",
"<<",
"stackSize",
"<<",
"\"\\n\"",
")",
";",
"int",
"Offset",
"=",
"(",
"(",
"spOffset",
"<",
"0",
")",
"?",
"(",
"stackSize",
"+",
"(",
"-",
"(",
"spOffset",
"+",
"4",
")",
")",
")",
":",
"(",
"spOffset",
")",
")",
";",
"Offset",
"+=",
"MI",
".",
"getOperand",
"(",
"i",
"-",
"1",
")",
".",
"getImm",
"(",
")",
";",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"Offset : \"",
"<<",
"Offset",
"<<",
"\"\\n\"",
"<<",
"\"<--------->\\n\"",
")",
";",
"MI",
".",
"getOperand",
"(",
"i",
"-",
"1",
")",
".",
"ChangeToImmediate",
"(",
"Offset",
")",
";",
"MI",
".",
"getOperand",
"(",
"i",
")",
".",
"ChangeToRegister",
"(",
"getFrameRegister",
"(",
"MF",
")",
",",
"false",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"overriden",
"to",
"eliminate",
"abstract",
"frame",
"indices",
"from",
"instructions",
"which",
"may",
"use",
"them",
"."
] | [
"Mips",
"Mips",
"0",
"\"Instr doesn't have FrameIndex operand!\"",
"\"\\nFunction : \"",
"\"\\n\"",
"\"<--------->\\n\"",
"\"FrameIndex : \"",
"\"\\n\"",
"\"spOffset : \"",
"\"\\n\"",
"\"stackSize : \"",
"\"\\n\"",
"0",
"4",
"1",
"\"Offset : \"",
"\"\\n\"",
"\"<--------->\\n\"",
"1",
"0"
] | MipsRegisterInfo38 | eliminateFrameIndex | Mips | CPU | LLVM | 8,878 | 270 | 1 | [] |
[
"<s>",
"bool",
"RISCVTargetLowering",
"::",
"isDesirableToCommuteWithShift",
"(",
"const",
"SDNode",
"*",
"N",
",",
"CombineLevel",
"Level",
")",
"const",
"{",
"SDValue",
"N0",
"=",
"N",
"->",
"getOperand",
"(",
"0",
")",
";",
"EVT",
"Ty",
"=",
"N0",
".",
"getValueType",
"(",
")",
";",
"if",
"(",
"Ty",
".",
"isScalarInteger",
"(",
")",
"&&",
"(",
"N0",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"ADD",
"||",
"N0",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"OR",
")",
")",
"{",
"auto",
"*",
"C1",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"N0",
"->",
"getOperand",
"(",
"1",
")",
")",
";",
"auto",
"*",
"C2",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"N",
"->",
"getOperand",
"(",
"1",
")",
")",
";",
"if",
"(",
"C1",
"&&",
"C2",
")",
"{",
"APInt",
"C1Int",
"=",
"C1",
"->",
"getAPIntValue",
"(",
")",
";",
"APInt",
"ShiftedC1Int",
"=",
"C1Int",
"<<",
"C2",
"->",
"getAPIntValue",
"(",
")",
";",
"if",
"(",
"isLegalAddImmediate",
"(",
"ShiftedC1Int",
".",
"getSExtValue",
"(",
")",
")",
")",
"return",
"true",
";",
"if",
"(",
"isLegalAddImmediate",
"(",
"C1Int",
".",
"getSExtValue",
"(",
")",
")",
")",
"return",
"false",
";",
"int",
"C1Cost",
"=",
"RISCVMatInt",
"::",
"getIntMatCost",
"(",
"C1Int",
",",
"Ty",
".",
"getSizeInBits",
"(",
")",
",",
"Subtarget",
".",
"is64Bit",
"(",
")",
")",
";",
"int",
"ShiftedC1Cost",
"=",
"RISCVMatInt",
"::",
"getIntMatCost",
"(",
"ShiftedC1Int",
",",
"Ty",
".",
"getSizeInBits",
"(",
")",
",",
"Subtarget",
".",
"is64Bit",
"(",
")",
")",
";",
"if",
"(",
"C1Cost",
"<",
"ShiftedC1Cost",
")",
"return",
"false",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"it",
"is",
"profitable",
"to",
"move",
"this",
"shift",
"by",
"a",
"constant",
"amount",
"through",
"its",
"operand",
",",
"adjusting",
"any",
"immediate",
"operands",
"as",
"necessary",
"to",
"preserve",
"semantics",
"."
] | [
"RISCV",
"RISCV",
"0",
"ISD::ADD",
"ISD::OR",
"1",
"1",
"RISCVMatInt::getIntMatCost",
"RISCVMatInt::getIntMatCost"
] | RISCVISelLowering16 | isDesirableToCommuteWithShift | RISCV | CPU | LLVM | 8,879 | 213 | 1 | [] |
[
"<s>",
"unsigned",
"int",
"mn10300_get_live_callee_saved_regs",
"(",
"unsigned",
"int",
"*",
"bytes_saved",
")",
"{",
"int",
"mask",
";",
"int",
"i",
";",
"unsigned",
"int",
"count",
";",
"count",
"=",
"mask",
"=",
"0",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<=",
"LAST_EXTENDED_REGNUM",
";",
"i",
"++",
")",
"if",
"(",
"df_regs_ever_live_p",
"(",
"i",
")",
"&&",
"!",
"call_used_regs",
"[",
"i",
"]",
")",
"{",
"mask",
"|=",
"(",
"1",
"<<",
"i",
")",
";",
"++",
"count",
";",
"}",
"if",
"(",
"(",
"mask",
"&",
"0x3c000",
")",
"!=",
"0",
")",
"{",
"for",
"(",
"i",
"=",
"0x04000",
";",
"i",
"<",
"0x40000",
";",
"i",
"<<=",
"1",
")",
"if",
"(",
"(",
"mask",
"&",
"i",
")",
"==",
"0",
")",
"++",
"count",
";",
"mask",
"|=",
"0x3c000",
";",
"}",
"if",
"(",
"bytes_saved",
")",
"*",
"bytes_saved",
"=",
"count",
"*",
"UNITS_PER_WORD",
";",
"return",
"mask",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"set",
"of",
"live",
",",
"callee-saved",
"registers",
"as",
"a",
"bitmask",
".",
"The",
"callee-saved",
"extended",
"registers",
"can",
"not",
"be",
"stored",
"individually",
",",
"so",
"all",
"of",
"them",
"will",
"be",
"included",
"in",
"the",
"mask",
"if",
"any",
"one",
"of",
"them",
"is",
"used",
"."
] | [
"mn10300",
"0",
"0",
"1",
"0x3c000",
"0",
"0x04000",
"0x40000",
"1",
"0",
"0x3c000"
] | mn10300 | mn10300_get_live_callee_saved_regs | mn10300 | MPU | GCC | 8,880 | 123 | 1 | [] |
[
"<s>",
"bool",
"isNoopAddrSpaceCast",
"(",
"unsigned",
"SrcAS",
",",
"unsigned",
"DestAS",
")",
"const",
"override",
"{",
"const",
"bool",
"SrcIsCheri",
"=",
"isCheriPointer",
"(",
"SrcAS",
",",
"nullptr",
")",
";",
"const",
"bool",
"DestIsCheri",
"=",
"isCheriPointer",
"(",
"DestAS",
",",
"nullptr",
")",
";",
"if",
"(",
"(",
"SrcIsCheri",
"||",
"DestIsCheri",
")",
"&&",
"(",
"SrcIsCheri",
"!=",
"DestIsCheri",
")",
")",
"return",
"false",
";",
"return",
"SrcAS",
"<",
"256",
"&&",
"DestAS",
"<",
"256",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"a",
"cast",
"between",
"SrcAS",
"and",
"DestAS",
"is",
"a",
"noop",
"."
] | [
"Mips",
"256",
"256"
] | MipsTargetMachine29 | isNoopAddrSpaceCast | Mips | CPU | LLVM | 8,881 | 61 | 1 | [] |
[
"<s>",
"void",
"function_expander",
"::",
"add_address_operand",
"(",
"rtx",
"x",
")",
"{",
"m_ops",
".",
"safe_grow",
"(",
"m_ops",
".",
"length",
"(",
")",
"+",
"1",
",",
"true",
")",
";",
"create_address_operand",
"(",
"&",
"m_ops",
".",
"last",
"(",
")",
",",
"x",
")",
";",
"}",
"</s>"
] | [
"Add",
"an",
"address",
"operand",
"with",
"value",
"X",
".",
"The",
"static",
"operand",
"data",
"says",
"what",
"mode",
"and",
"form",
"the",
"address",
"must",
"have",
"."
] | [
"aarch64",
"1"
] | aarch64-sve-builtins1 | add_address_operand | aarch64 | CPU | GCC | 8,882 | 37 | 1 | [] |
[
"<s>",
"bool",
"R600InstrInfo",
"::",
"isLegalToSplitMBBAt",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
")",
"const",
"{",
"for",
"(",
"MachineInstr",
"::",
"const_mop_iterator",
"I",
"=",
"MBBI",
"->",
"operands_begin",
"(",
")",
",",
"E",
"=",
"MBBI",
"->",
"operands_end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"if",
"(",
"I",
"->",
"isReg",
"(",
")",
"&&",
"!",
"TargetRegisterInfo",
"::",
"isVirtualRegister",
"(",
"I",
"->",
"getReg",
"(",
")",
")",
"&&",
"I",
"->",
"isUse",
"(",
")",
"&&",
"RI",
".",
"isPhysRegLiveAcrossClauses",
"(",
"I",
"->",
"getReg",
"(",
")",
")",
")",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"it",
"'s",
"legal",
"to",
"split",
"the",
"given",
"basic",
"block",
"at",
"the",
"specified",
"instruction",
"(",
"i.e",
"."
] | [
"AMDGPU",
"R600"
] | R600InstrInfo (2) | isLegalToSplitMBBAt | AMDGPU | GPU | LLVM | 8,883 | 90 | 1 | [] |
[
"<s>",
"bool",
"X86CallFrameOptimization",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"STI",
"=",
"&",
"MF",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"TII",
"=",
"STI",
"->",
"getInstrInfo",
"(",
")",
";",
"TFL",
"=",
"STI",
"->",
"getFrameLowering",
"(",
")",
";",
"MRI",
"=",
"&",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"const",
"X86RegisterInfo",
"&",
"RegInfo",
"=",
"*",
"static_cast",
"<",
"const",
"X86RegisterInfo",
"*",
">",
"(",
"STI",
"->",
"getRegisterInfo",
"(",
")",
")",
";",
"SlotSize",
"=",
"RegInfo",
".",
"getSlotSize",
"(",
")",
";",
"assert",
"(",
"isPowerOf2_32",
"(",
"SlotSize",
")",
"&&",
"\"Expect power of 2 stack slot size\"",
")",
";",
"Log2SlotSize",
"=",
"Log2_32",
"(",
"SlotSize",
")",
";",
"if",
"(",
"!",
"isLegal",
"(",
"MF",
")",
")",
"return",
"false",
";",
"unsigned",
"FrameSetupOpcode",
"=",
"TII",
"->",
"getCallFrameSetupOpcode",
"(",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"ContextVector",
"CallSeqVector",
";",
"for",
"(",
"auto",
"&",
"MBB",
":",
"MF",
")",
"for",
"(",
"auto",
"&",
"MI",
":",
"MBB",
")",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"FrameSetupOpcode",
")",
"{",
"CallContext",
"Context",
";",
"collectCallInfo",
"(",
"MF",
",",
"MBB",
",",
"MI",
",",
"Context",
")",
";",
"CallSeqVector",
".",
"push_back",
"(",
"Context",
")",
";",
"}",
"if",
"(",
"!",
"isProfitable",
"(",
"MF",
",",
"CallSeqVector",
")",
")",
"return",
"false",
";",
"for",
"(",
"auto",
"CC",
":",
"CallSeqVector",
")",
"{",
"if",
"(",
"CC",
".",
"UsePush",
")",
"{",
"adjustCallSequence",
"(",
"MF",
",",
"CC",
")",
";",
"Changed",
"=",
"true",
";",
"}",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86",
"\"Expect power of 2 stack slot size\""
] | X86CallFrameOptimization17 | runOnMachineFunction | X86 | CPU | LLVM | 8,884 | 214 | 1 | [] |
[
"<s>",
"bool",
"Cpu0DAGToDAGISel",
"::",
"SelectInlineAsmMemoryOperand",
"(",
"const",
"SDValue",
"&",
"Op",
",",
"unsigned",
"ConstraintID",
",",
"std",
"::",
"vector",
"<",
"SDValue",
">",
"&",
"OutOps",
")",
"{",
"switch",
"(",
"ConstraintID",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unexpected asm memory constraint\"",
")",
";",
"case",
"InlineAsm",
"::",
"Constraint_m",
":",
"OutOps",
".",
"push_back",
"(",
"Op",
")",
";",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"SelectInlineAsmMemoryOperand",
"-",
"Select",
"the",
"specified",
"address",
"as",
"a",
"target",
"addressing",
"mode",
",",
"according",
"to",
"the",
"specified",
"constraint",
"."
] | [
"Cpu0",
"Cpu0",
"\"Unexpected asm memory constraint\""
] | Cpu0ISelDAGToDAG4 | SelectInlineAsmMemoryOperand | Cpu0 | CPU | LLVM | 8,885 | 55 | 1 | [] |
[
"<s>",
"rtx",
"rs6000_find_base_term",
"(",
"rtx",
"op",
")",
"{",
"rtx",
"base",
";",
"base",
"=",
"op",
";",
"if",
"(",
"GET_CODE",
"(",
"base",
")",
"==",
"CONST",
")",
"base",
"=",
"XEXP",
"(",
"base",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"base",
")",
"==",
"PLUS",
")",
"base",
"=",
"XEXP",
"(",
"base",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"base",
")",
"==",
"UNSPEC",
")",
"switch",
"(",
"XINT",
"(",
"base",
",",
"1",
")",
")",
"{",
"case",
"UNSPEC_TOCREL",
":",
"case",
"UNSPEC_MACHOPIC_OFFSET",
":",
"return",
"XVECEXP",
"(",
"base",
",",
"0",
",",
"0",
")",
";",
"}",
"return",
"op",
";",
"}",
"</s>"
] | [
"Implement",
"FIND_BASE_TERM",
"."
] | [
"powerpcspe",
"0",
"0",
"1",
"0",
"0"
] | powerpcspe | rs6000_find_base_term | powerpcspe | CPU | GCC | 8,886 | 90 | 1 | [] |
[
"<s>",
"void",
"emitEpilogue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"override",
"{",
"}",
"</s>"
] | [
"Insert",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"HSAIL"
] | HSAILFrameLowering | emitEpilogue | HSAIL | Virtual ISA | LLVM | 8,887 | 15 | 1 | [] |
[
"<s>",
"void",
"MipsPassConfig",
"::",
"addIRPasses",
"(",
")",
"{",
"TargetPassConfig",
"::",
"addIRPasses",
"(",
")",
";",
"if",
"(",
"getMipsSubtarget",
"(",
")",
".",
"os16",
"(",
")",
")",
"addPass",
"(",
"createMipsOs16",
"(",
"getMipsTargetMachine",
"(",
")",
")",
")",
";",
"if",
"(",
"getMipsSubtarget",
"(",
")",
".",
"inMips16HardFloat",
"(",
")",
")",
"addPass",
"(",
"createMips16HardFloat",
"(",
"getMipsTargetMachine",
"(",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Add",
"common",
"target",
"configurable",
"passes",
"that",
"perform",
"LLVM",
"IR",
"to",
"IR",
"transforms",
"following",
"machine",
"independent",
"optimization",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips"
] | MipsTargetMachine35 | addIRPasses | Mips | CPU | LLVM | 8,888 | 54 | 1 | [] |
[
"<s>",
"bool",
"ExpandPseudo",
"::",
"expand",
"(",
")",
"{",
"bool",
"Expanded",
"=",
"false",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"BB",
"=",
"MF",
".",
"begin",
"(",
")",
",",
"BBEnd",
"=",
"MF",
".",
"end",
"(",
")",
";",
"BB",
"!=",
"BBEnd",
";",
"++",
"BB",
")",
"for",
"(",
"Iter",
"I",
"=",
"BB",
"->",
"begin",
"(",
")",
",",
"End",
"=",
"BB",
"->",
"end",
"(",
")",
";",
"I",
"!=",
"End",
";",
")",
"Expanded",
"|=",
"expandInstr",
"(",
"*",
"BB",
",",
"I",
"++",
")",
";",
"return",
"Expanded",
";",
"}",
"</s>"
] | [
"expand",
"-",
"Expand",
"a",
"record",
"into",
"a",
"set",
"of",
"elements",
"if",
"possible",
"."
] | [
"Mips"
] | MipsSEFrameLowering | expand | Mips | CPU | LLVM | 8,889 | 79 | 1 | [] |
[
"<s>",
"bool",
"AArch64InstrInfo",
"::",
"isCandidateToMergeOrPair",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"bool",
"IsPreLdSt",
"=",
"isPreLdSt",
"(",
"MI",
")",
";",
"if",
"(",
"MI",
".",
"hasOrderedMemoryRef",
"(",
")",
")",
"return",
"false",
";",
"assert",
"(",
"(",
"MI",
".",
"getOperand",
"(",
"IsPreLdSt",
"?",
"2",
":",
"1",
")",
".",
"isReg",
"(",
")",
"||",
"MI",
".",
"getOperand",
"(",
"IsPreLdSt",
"?",
"2",
":",
"1",
")",
".",
"isFI",
"(",
")",
")",
"&&",
"\"Expected a reg or frame index operand.\"",
")",
";",
"bool",
"IsImmPreLdSt",
"=",
"IsPreLdSt",
"&&",
"MI",
".",
"getOperand",
"(",
"3",
")",
".",
"isImm",
"(",
")",
";",
"if",
"(",
"!",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"isImm",
"(",
")",
"&&",
"!",
"IsImmPreLdSt",
")",
"return",
"false",
";",
"if",
"(",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"isReg",
"(",
")",
"&&",
"!",
"IsPreLdSt",
")",
"{",
"Register",
"BaseReg",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
";",
"const",
"TargetRegisterInfo",
"*",
"TRI",
"=",
"&",
"getRegisterInfo",
"(",
")",
";",
"if",
"(",
"MI",
".",
"modifiesRegister",
"(",
"BaseReg",
",",
"TRI",
")",
")",
"return",
"false",
";",
"}",
"if",
"(",
"isLdStPairSuppressed",
"(",
"MI",
")",
")",
"return",
"false",
";",
"const",
"MCAsmInfo",
"*",
"MAI",
"=",
"MI",
".",
"getMF",
"(",
")",
"->",
"getTarget",
"(",
")",
".",
"getMCAsmInfo",
"(",
")",
";",
"bool",
"NeedsWinCFI",
"=",
"MAI",
"->",
"usesWindowsCFI",
"(",
")",
"&&",
"MI",
".",
"getMF",
"(",
")",
"->",
"getFunction",
"(",
")",
".",
"needsUnwindTableEntry",
"(",
")",
";",
"if",
"(",
"NeedsWinCFI",
"&&",
"(",
"MI",
".",
"getFlag",
"(",
"MachineInstr",
"::",
"FrameSetup",
")",
"||",
"MI",
".",
"getFlag",
"(",
"MachineInstr",
"::",
"FrameDestroy",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"Subtarget",
".",
"isPaired128Slow",
"(",
")",
")",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"AArch64",
"::",
"LDURQi",
":",
"case",
"AArch64",
"::",
"STURQi",
":",
"case",
"AArch64",
"::",
"LDRQui",
":",
"case",
"AArch64",
"::",
"STRQui",
":",
"return",
"false",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"this",
"is",
"a",
"load/store",
"that",
"can",
"be",
"potentially",
"paired/merged",
"."
] | [
"AArch64",
"AArch64",
"2",
"1",
"2",
"1",
"\"Expected a reg or frame index operand.\"",
"3",
"2",
"1",
"1",
"AArch64::LDURQi",
"AArch64::STURQi",
"AArch64::LDRQui",
"AArch64::STRQui"
] | AArch64InstrInfo105 | isCandidateToMergeOrPair | AArch64 | CPU | LLVM | 8,890 | 290 | 1 | [] |
[
"<s>",
"const",
"uint16_t",
"*",
"LC3RegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"static",
"const",
"uint16_t",
"CalleeSavedRegs",
"[",
"]",
"=",
"{",
"LC3",
"::",
"R4",
",",
"LC3",
"::",
"R5",
",",
"LC3",
"::",
"R6",
",",
"LC3",
"::",
"R7",
",",
"LC3",
"::",
"R8",
",",
"LC3",
"::",
"R9",
",",
"0",
"}",
";",
"return",
"CalleeSavedRegs",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"LC3",
"LC3",
"LC3::R4",
"LC3::R5",
"LC3::R6",
"LC3::R7",
"LC3::R8",
"LC3::R9",
"0"
] | LC3RegisterInfo | getCalleeSavedRegs | LC3 | CPU | LLVM | 8,891 | 53 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"M68k DAG->DAG Pattern Instruction Selection\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"M68k",
"\"M68k DAG->DAG Pattern Instruction Selection\""
] | M68kISelDAGToDAG | getPassName | M68k | MPU | LLVM | 8,892 | 11 | 1 | [] |
[
"<s>",
"void",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
")",
"const",
"{",
"MBB",
".",
"erase",
"(",
"MI",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"is",
"called",
"during",
"prolog/epilog",
"code",
"insertion",
"to",
"eliminate",
"call",
"frame",
"setup",
"and",
"destroy",
"pseudo",
"instructions",
"(",
"but",
"only",
"if",
"the",
"Target",
"is",
"using",
"them",
")",
"."
] | [
"BPF"
] | BPFFrameLowering11 | eliminateCallFramePseudoInstr | BPF | Virtual ISA | LLVM | 8,893 | 26 | 1 | [] |
[
"<s>",
"bool",
"X86InstrInfo",
"::",
"getMachineCombinerPatterns",
"(",
"MachineInstr",
"&",
"Root",
",",
"SmallVectorImpl",
"<",
"MachineCombinerPattern",
"::",
"MC_PATTERN",
">",
"&",
"Patterns",
")",
"const",
"{",
"bool",
"Commute",
";",
"if",
"(",
"isReassociationCandidate",
"(",
"Root",
",",
"Commute",
")",
")",
"{",
"if",
"(",
"Commute",
")",
"{",
"Patterns",
".",
"push_back",
"(",
"MachineCombinerPattern",
"::",
"MC_REASSOC_AX_YB",
")",
";",
"Patterns",
".",
"push_back",
"(",
"MachineCombinerPattern",
"::",
"MC_REASSOC_XA_YB",
")",
";",
"}",
"else",
"{",
"Patterns",
".",
"push_back",
"(",
"MachineCombinerPattern",
"::",
"MC_REASSOC_AX_BY",
")",
";",
"Patterns",
".",
"push_back",
"(",
"MachineCombinerPattern",
"::",
"MC_REASSOC_XA_BY",
")",
";",
"}",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"when",
"there",
"is",
"potentially",
"a",
"faster",
"code",
"sequence",
"for",
"an",
"instruction",
"chain",
"ending",
"in",
"Root",
"."
] | [
"X86",
"X86"
] | X86InstrInfo123 | getMachineCombinerPatterns | X86 | CPU | LLVM | 8,894 | 86 | 1 | [] |
[
"<s>",
"const",
"uint32_t",
"*",
"RISCVRegisterInfo",
"::",
"getCallPreservedMask",
"(",
"const",
"MachineFunction",
"&",
",",
"CallingConv",
"::",
"ID",
")",
"const",
"{",
"return",
"CSR_RegMask",
";",
"}",
"</s>"
] | [
"Return",
"a",
"mask",
"of",
"call-preserved",
"registers",
"for",
"the",
"given",
"calling",
"convention",
"on",
"the",
"current",
"function",
"."
] | [
"RISCV",
"RISCV"
] | RISCVRegisterInfo22 | getCallPreservedMask | RISCV | CPU | LLVM | 8,895 | 21 | 1 | [] |
[
"<s>",
"void",
"markGlobalAsPromotedToConstantPool",
"(",
"const",
"GlobalVariable",
"*",
"GV",
")",
"{",
"PromotedGlobals",
".",
"insert",
"(",
"GV",
")",
";",
"}",
"</s>"
] | [
"Indicate",
"to",
"the",
"backend",
"that",
"GV",
"has",
"had",
"its",
"storage",
"changed",
"to",
"inside",
"a",
"constant",
"pool",
"."
] | [
"ARM"
] | ARMMachineFunctionInfo (2)1 | markGlobalAsPromotedToConstantPool | ARM | CPU | LLVM | 8,896 | 17 | 1 | [] |
[
"<s>",
"void",
"arm_emit_fp16_const",
"(",
"rtx",
"c",
")",
"{",
"REAL_VALUE_TYPE",
"r",
";",
"long",
"bits",
";",
"REAL_VALUE_FROM_CONST_DOUBLE",
"(",
"r",
",",
"c",
")",
";",
"bits",
"=",
"real_to_target",
"(",
"NULL",
",",
"&",
"r",
",",
"HFmode",
")",
";",
"if",
"(",
"WORDS_BIG_ENDIAN",
")",
"assemble_zeros",
"(",
"2",
")",
";",
"assemble_integer",
"(",
"GEN_INT",
"(",
"bits",
")",
",",
"2",
",",
"BITS_PER_WORD",
",",
"1",
")",
";",
"if",
"(",
"!",
"WORDS_BIG_ENDIAN",
")",
"assemble_zeros",
"(",
"2",
")",
";",
"}",
"</s>"
] | [
"Emit",
"a",
"fp16",
"constant",
"appropriately",
"padded",
"to",
"occupy",
"a",
"4-byte",
"word",
".",
"HFmode",
"constant",
"pool",
"entries",
"are",
"actually",
"loaded",
"with",
"ldr",
"."
] | [
"arm",
"2",
"2",
"1",
"2"
] | arm4 | arm_emit_fp16_const | arm | CPU | GCC | 8,897 | 66 | 1 | [] |
[
"<s>",
"void",
"crx_print_operand_address",
"(",
"FILE",
"*",
"file",
",",
"rtx",
"addr",
")",
"{",
"enum",
"crx_addrtype",
"addrtype",
";",
"struct",
"crx_address",
"address",
";",
"int",
"offset",
";",
"addrtype",
"=",
"crx_decompose_address",
"(",
"addr",
",",
"&",
"address",
")",
";",
"if",
"(",
"address",
".",
"disp",
")",
"offset",
"=",
"INTVAL",
"(",
"address",
".",
"disp",
")",
";",
"else",
"offset",
"=",
"0",
";",
"switch",
"(",
"addrtype",
")",
"{",
"case",
"CRX_REG_REL",
":",
"fprintf",
"(",
"file",
",",
"\"%d(%s)\"",
",",
"offset",
",",
"reg_names",
"[",
"REGNO",
"(",
"address",
".",
"base",
")",
"]",
")",
";",
"return",
";",
"case",
"CRX_POST_INC",
":",
"switch",
"(",
"GET_CODE",
"(",
"address",
".",
"side_effect",
")",
")",
"{",
"case",
"PLUS",
":",
"break",
";",
"case",
"MINUS",
":",
"offset",
"=",
"-",
"offset",
";",
"break",
";",
"case",
"POST_INC",
":",
"offset",
"=",
"GET_MODE_SIZE",
"(",
"output_memory_reference_mode",
")",
";",
"break",
";",
"case",
"POST_DEC",
":",
"offset",
"=",
"-",
"GET_MODE_SIZE",
"(",
"output_memory_reference_mode",
")",
";",
"break",
";",
"default",
":",
"abort",
"(",
")",
";",
"}",
"fprintf",
"(",
"file",
",",
"\"%d(%s)+\"",
",",
"offset",
",",
"reg_names",
"[",
"REGNO",
"(",
"address",
".",
"base",
")",
"]",
")",
";",
"return",
";",
"case",
"CRX_SCALED_INDX",
":",
"fprintf",
"(",
"file",
",",
"\"%d(%s, %s, %d)\"",
",",
"offset",
",",
"reg_names",
"[",
"REGNO",
"(",
"address",
".",
"base",
")",
"]",
",",
"reg_names",
"[",
"REGNO",
"(",
"address",
".",
"index",
")",
"]",
",",
"address",
".",
"scale",
")",
";",
"return",
";",
"case",
"CRX_ABSOLUTE",
":",
"output_addr_const",
"(",
"file",
",",
"address",
".",
"disp",
")",
";",
"return",
";",
"default",
":",
"abort",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Implements",
"the",
"macro",
"PRINT_OPERAND_ADDRESS",
"defined",
"in",
"crx.h",
"."
] | [
"crx",
"0",
"\"%d(%s)\"",
"\"%d(%s)+\"",
"\"%d(%s, %s, %d)\""
] | crx | crx_print_operand_address | crx | CPU | GCC | 8,898 | 222 | 1 | [] |
[
"<s>",
"void",
"AArch64FrameLowering",
"::",
"processFunctionBeforeFrameFinalized",
"(",
"MachineFunction",
"&",
"MF",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"if",
"(",
"!",
"MF",
".",
"hasEHFunclets",
"(",
")",
")",
"return",
";",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"WinEHFuncInfo",
"&",
"EHInfo",
"=",
"*",
"MF",
".",
"getWinEHFuncInfo",
"(",
")",
";",
"MachineBasicBlock",
"&",
"MBB",
"=",
"MF",
".",
"front",
"(",
")",
";",
"auto",
"MBBI",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"while",
"(",
"MBBI",
"!=",
"MBB",
".",
"end",
"(",
")",
"&&",
"MBBI",
"->",
"getFlag",
"(",
"MachineInstr",
"::",
"FrameSetup",
")",
")",
"++",
"MBBI",
";",
"int",
"UnwindHelpFI",
"=",
"MFI",
".",
"CreateStackObject",
"(",
"8",
",",
"16",
",",
"false",
")",
";",
"EHInfo",
".",
"UnwindHelpFrameIdx",
"=",
"UnwindHelpFI",
";",
"DebugLoc",
"DL",
";",
"RS",
"->",
"enterBasicBlockEnd",
"(",
"MBB",
")",
";",
"RS",
"->",
"backward",
"(",
"std",
"::",
"prev",
"(",
"MBBI",
")",
")",
";",
"unsigned",
"DstReg",
"=",
"RS",
"->",
"FindUnusedReg",
"(",
"&",
"AArch64",
"::",
"GPR64commonRegClass",
")",
";",
"assert",
"(",
"DstReg",
"&&",
"\"There must be a free register after frame setup\"",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"AArch64",
"::",
"MOVi64imm",
")",
",",
"DstReg",
")",
".",
"addImm",
"(",
"-",
"2",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"AArch64",
"::",
"STURXi",
")",
")",
".",
"addReg",
"(",
"DstReg",
",",
"getKillRegState",
"(",
"true",
")",
")",
".",
"addFrameIndex",
"(",
"UnwindHelpFI",
")",
".",
"addImm",
"(",
"0",
")",
";",
"}",
"</s>"
] | [
"processFunctionBeforeFrameFinalized",
"-",
"This",
"method",
"is",
"called",
"immediately",
"before",
"the",
"specified",
"function",
"'s",
"frame",
"layout",
"(",
"MF.getFrameInfo",
"(",
")",
")",
"is",
"finalized",
"."
] | [
"AArch64",
"AArch64",
"8",
"16",
"AArch64::GPR64commonRegClass",
"\"There must be a free register after frame setup\"",
"AArch64::MOVi64imm",
"2",
"AArch64::STURXi",
"0"
] | AArch64FrameLowering31 | processFunctionBeforeFrameFinalized | AArch64 | CPU | LLVM | 8,899 | 231 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.