ground_truth
sequencelengths 8
512
| natrual_language
sequencelengths 1
243
| TS_V_token
sequencelengths 1
182
| File
stringlengths 2
45
| Func
stringlengths 1
56
| Target
stringclasses 175
values | Target_Clf
stringclasses 6
values | Compiler_Type
stringclasses 2
values | Idx
int64 0
36.2k
| Length
int64 6
510
| Cover_Rate
float64 1
1
| Template_token
sequencelengths 0
0
|
|---|---|---|---|---|---|---|---|---|---|---|---|
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"IsEligibleForTailCallOptimization",
"(",
"CallSDNode",
"*",
"TheCall",
",",
"SDValue",
"Ret",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"if",
"(",
"!",
"PerformTailCallOpt",
")",
"return",
"false",
";",
"if",
"(",
"CheckTailCallReturnConstraints",
"(",
"TheCall",
",",
"Ret",
")",
")",
"{",
"MachineFunction",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"unsigned",
"CallerCC",
"=",
"MF",
".",
"getFunction",
"(",
")",
"->",
"getCallingConv",
"(",
")",
";",
"unsigned",
"CalleeCC",
"=",
"TheCall",
"->",
"getCallingConv",
"(",
")",
";",
"if",
"(",
"CalleeCC",
"==",
"CallingConv",
"::",
"Fast",
"&&",
"CallerCC",
"==",
"CalleeCC",
")",
"{",
"SDValue",
"Callee",
"=",
"TheCall",
"->",
"getCallee",
"(",
")",
";",
"if",
"(",
"getTargetMachine",
"(",
")",
".",
"getRelocationModel",
"(",
")",
"!=",
"Reloc",
"::",
"PIC_",
"||",
"!",
"Subtarget",
"->",
"isPICStyleGOT",
"(",
")",
"||",
"!",
"Subtarget",
"->",
"is64Bit",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"GlobalAddressSDNode",
"*",
"G",
"=",
"dyn_cast",
"<",
"GlobalAddressSDNode",
">",
"(",
"Callee",
")",
")",
"return",
"G",
"->",
"getGlobal",
"(",
")",
"->",
"hasHiddenVisibility",
"(",
")",
"||",
"G",
"->",
"getGlobal",
"(",
")",
"->",
"hasProtectedVisibility",
"(",
")",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"IsEligibleForTailCallOptimization",
"-",
"Check",
"whether",
"the",
"call",
"is",
"eligible",
"for",
"tail",
"call",
"optimization",
"."
] | [
"X86",
"X86"
] | X86ISelLowering160 | IsEligibleForTailCallOptimization | X86 | CPU | LLVM | 19,900 | 162 | 1 | [] |
[
"<s>",
"ARMSubtarget",
"::",
"ARMSubtarget",
"(",
"const",
"std",
"::",
"string",
"&",
"TT",
",",
"const",
"std",
"::",
"string",
"&",
"CPU",
",",
"const",
"std",
"::",
"string",
"&",
"FS",
")",
":",
"ARMGenSubtargetInfo",
"(",
"TT",
",",
"CPU",
",",
"FS",
")",
",",
"ARMProcFamily",
"(",
"Others",
")",
",",
"stackAlignment",
"(",
"4",
")",
",",
"CPUString",
"(",
"CPU",
")",
",",
"TargetTriple",
"(",
"TT",
")",
",",
"TargetABI",
"(",
"ARM_ABI_APCS",
")",
"{",
"initializeEnvironment",
"(",
")",
";",
"resetSubtargetFeatures",
"(",
"CPU",
",",
"FS",
")",
";",
"}",
"</s>"
] | [
"This",
"constructor",
"initializes",
"the",
"data",
"members",
"to",
"match",
"that",
"of",
"the",
"specified",
"triple",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"4",
"ARM"
] | ARMSubtarget1 | ARMSubtarget | ARM | CPU | LLVM | 19,901 | 72 | 1 | [] |
[
"<s>",
"bool",
"ARMBaseTargetMachine",
"::",
"addPreISel",
"(",
"PassManagerBase",
"&",
"PM",
",",
"CodeGenOpt",
"::",
"Level",
"OptLevel",
")",
"{",
"if",
"(",
"OptLevel",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"EnableGlobalMerge",
")",
"PM",
".",
"add",
"(",
"createARMGlobalMergePass",
"(",
"getTargetLowering",
"(",
")",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"{",
"{",
"@",
"For",
"GlobalISel"
] | [
"ARM",
"ARM",
"ARM"
] | ARMTargetMachine87 | addPreISel | ARM | CPU | LLVM | 19,902 | 41 | 1 | [] |
[
"<s>",
"void",
"ARMBaseInstrInfo",
"::",
"buildOutlinedFrame",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineFunction",
"&",
"MF",
",",
"const",
"outliner",
"::",
"OutlinedFunction",
"&",
"OF",
")",
"const",
"{",
"if",
"(",
"OF",
".",
"FrameConstructionID",
"==",
"MachineOutlinerThunk",
")",
"{",
"MachineInstr",
"*",
"Call",
"=",
"&",
"*",
"--",
"MBB",
".",
"instr_end",
"(",
")",
";",
"bool",
"isThumb",
"=",
"Subtarget",
".",
"isThumb",
"(",
")",
";",
"unsigned",
"FuncOp",
"=",
"isThumb",
"?",
"2",
":",
"0",
";",
"unsigned",
"Opc",
"=",
"Call",
"->",
"getOperand",
"(",
"FuncOp",
")",
".",
"isReg",
"(",
")",
"?",
"isThumb",
"?",
"ARM",
"::",
"tTAILJMPr",
":",
"ARM",
"::",
"TAILJMPr",
":",
"isThumb",
"?",
"Subtarget",
".",
"isTargetMachO",
"(",
")",
"?",
"ARM",
"::",
"tTAILJMPd",
":",
"ARM",
"::",
"tTAILJMPdND",
":",
"ARM",
"::",
"TAILJMPd",
";",
"MachineInstrBuilder",
"MIB",
"=",
"BuildMI",
"(",
"MBB",
",",
"MBB",
".",
"end",
"(",
")",
",",
"DebugLoc",
"(",
")",
",",
"get",
"(",
"Opc",
")",
")",
".",
"add",
"(",
"Call",
"->",
"getOperand",
"(",
"FuncOp",
")",
")",
";",
"if",
"(",
"isThumb",
"&&",
"!",
"Call",
"->",
"getOperand",
"(",
"FuncOp",
")",
".",
"isReg",
"(",
")",
")",
"MIB",
".",
"add",
"(",
"predOps",
"(",
"ARMCC",
"::",
"AL",
")",
")",
";",
"Call",
"->",
"eraseFromParent",
"(",
")",
";",
"}",
"auto",
"IsNonTailCall",
"=",
"[",
"]",
"(",
"MachineInstr",
"&",
"MI",
")",
"{",
"return",
"MI",
".",
"isCall",
"(",
")",
"&&",
"!",
"MI",
".",
"isReturn",
"(",
")",
";",
"}",
";",
"if",
"(",
"std",
"::",
"any_of",
"(",
"MBB",
".",
"instr_begin",
"(",
")",
",",
"MBB",
".",
"instr_end",
"(",
")",
",",
"IsNonTailCall",
")",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"It",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"Et",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"if",
"(",
"OF",
".",
"FrameConstructionID",
"==",
"MachineOutlinerTailCall",
"||",
"OF",
".",
"FrameConstructionID",
"==",
"MachineOutlinerThunk",
")",
"Et",
"=",
"std",
"::",
"prev",
"(",
"MBB",
".",
"end",
"(",
")",
")",
";",
"if",
"(",
"!",
"MBB",
".",
"isLiveIn",
"(",
"ARM",
"::",
"LR",
")",
")",
"MBB",
".",
"addLiveIn",
"(",
"ARM",
"::",
"LR",
")",
";",
"saveLROnStack",
"(",
"MBB",
",",
"It",
")",
";",
"emitCFIForLRSaveOnStack",
"(",
"MBB",
",",
"It",
")",
";",
"restoreLRFromStack",
"(",
"MBB",
",",
"Et",
")",
";",
"emitCFIForLRRestoreFromStack",
"(",
"MBB",
",",
"Et",
")",
";",
"}",
"if",
"(",
"OF",
".",
"FrameConstructionID",
"==",
"MachineOutlinerTailCall",
"||",
"OF",
".",
"FrameConstructionID",
"==",
"MachineOutlinerThunk",
")",
"return",
";",
"BuildMI",
"(",
"MBB",
",",
"MBB",
".",
"end",
"(",
")",
",",
"DebugLoc",
"(",
")",
",",
"get",
"(",
"Subtarget",
".",
"getReturnOpcode",
"(",
")",
")",
")",
".",
"add",
"(",
"predOps",
"(",
"ARMCC",
"::",
"AL",
")",
")",
";",
"}",
"</s>"
] | [
"Insert",
"a",
"custom",
"frame",
"for",
"outlined",
"functions",
"."
] | [
"ARM",
"ARM",
"2",
"0",
"ARM::tTAILJMPr",
"ARM::TAILJMPr",
"ARM::tTAILJMPd",
"ARM::tTAILJMPdND",
"ARM::TAILJMPd",
"ARMCC::AL",
"ARM::LR",
"ARM::LR",
"ARMCC::AL"
] | ARMBaseInstrInfo65 | buildOutlinedFrame | ARM | CPU | LLVM | 19,903 | 373 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"Hexagon VectorPrint pass\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"Hexagon",
"\"Hexagon VectorPrint pass\""
] | HexagonVectorPrint | getPassName | Hexagon | DSP | LLVM | 19,904 | 13 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"output_ubranch",
"(",
"rtx",
"dest",
",",
"rtx_insn",
"*",
"insn",
")",
"{",
"static",
"char",
"string",
"[",
"64",
"]",
";",
"bool",
"v9_form",
"=",
"false",
";",
"int",
"delta",
";",
"char",
"*",
"p",
";",
"delta",
"=",
"5000000",
";",
"if",
"(",
"INSN_ADDRESSES_SET_P",
"(",
")",
")",
"delta",
"=",
"(",
"INSN_ADDRESSES",
"(",
"INSN_UID",
"(",
"dest",
")",
")",
"-",
"INSN_ADDRESSES",
"(",
"INSN_UID",
"(",
"insn",
")",
")",
")",
";",
"if",
"(",
"TARGET_V9",
"&&",
"delta",
">=",
"-",
"260000",
"&&",
"delta",
"<",
"260000",
")",
"v9_form",
"=",
"true",
";",
"if",
"(",
"TARGET_CBCOND",
")",
"{",
"bool",
"emit_nop",
"=",
"emit_cbcond_nop",
"(",
"insn",
")",
";",
"bool",
"far",
"=",
"false",
";",
"const",
"char",
"*",
"rval",
";",
"if",
"(",
"delta",
"<",
"-",
"500",
"||",
"delta",
">",
"500",
")",
"far",
"=",
"true",
";",
"if",
"(",
"far",
")",
"{",
"if",
"(",
"v9_form",
")",
"rval",
"=",
"\"ba,a,pt\\t%%xcc, %l0\"",
";",
"else",
"rval",
"=",
"\"b,a\\t%l0\"",
";",
"}",
"else",
"{",
"if",
"(",
"emit_nop",
")",
"rval",
"=",
"\"cwbe\\t%%g0, %%g0, %l0\\n\\tnop\"",
";",
"else",
"rval",
"=",
"\"cwbe\\t%%g0, %%g0, %l0\"",
";",
"}",
"return",
"rval",
";",
"}",
"if",
"(",
"v9_form",
")",
"strcpy",
"(",
"string",
",",
"\"ba%*,pt\\t%%xcc, \"",
")",
";",
"else",
"strcpy",
"(",
"string",
",",
"\"b%*\\t\"",
")",
";",
"p",
"=",
"strchr",
"(",
"string",
",",
"'\\0'",
")",
";",
"*",
"p",
"++",
"=",
"'%'",
";",
"*",
"p",
"++",
"=",
"'l'",
";",
"*",
"p",
"++",
"=",
"'0'",
";",
"*",
"p",
"++",
"=",
"'%'",
";",
"*",
"p",
"++",
"=",
"'('",
";",
"*",
"p",
"=",
"'\\0'",
";",
"return",
"string",
";",
"}",
"</s>"
] | [
"Output",
"an",
"unconditional",
"branch",
"to",
"LABEL",
".",
"INSN",
"is",
"the",
"instruction",
"."
] | [
"sparc",
"64",
"5000000",
"260000",
"260000",
"500",
"500",
"\"ba,a,pt\\t%%xcc, %l0\"",
"\"b,a\\t%l0\"",
"\"cwbe\\t%%g0, %%g0, %l0\\n\\tnop\"",
"\"cwbe\\t%%g0, %%g0, %l0\"",
"\"ba%*,pt\\t%%xcc, \"",
"\"b%*\\t\""
] | sparc4 | output_ubranch | sparc | CPU | GCC | 19,905 | 223 | 1 | [] |
[
"<s>",
"enum",
"reg_class",
"m32c_regno_reg_class",
"(",
"int",
"regno",
")",
"{",
"switch",
"(",
"regno",
")",
"{",
"case",
"R0_REGNO",
":",
"return",
"R0_REGS",
";",
"case",
"R1_REGNO",
":",
"return",
"R1_REGS",
";",
"case",
"R2_REGNO",
":",
"return",
"R2_REGS",
";",
"case",
"R3_REGNO",
":",
"return",
"R3_REGS",
";",
"case",
"A0_REGNO",
":",
"return",
"A0_REGS",
";",
"case",
"A1_REGNO",
":",
"return",
"A1_REGS",
";",
"case",
"SB_REGNO",
":",
"return",
"SB_REGS",
";",
"case",
"FB_REGNO",
":",
"return",
"FB_REGS",
";",
"case",
"SP_REGNO",
":",
"return",
"SP_REGS",
";",
"case",
"FLG_REGNO",
":",
"return",
"FLG_REGS",
";",
"default",
":",
"if",
"(",
"IS_MEM_REGNO",
"(",
"regno",
")",
")",
"return",
"MEM_REGS",
";",
"return",
"ALL_REGS",
";",
"}",
"}",
"</s>"
] | [
"Implements",
"REGNO_REG_CLASS",
"."
] | [
"m32c"
] | m32c | m32c_regno_reg_class | m32c | MPU | GCC | 19,906 | 90 | 1 | [] |
[
"<s>",
"unsigned",
"R600InstrInfo",
"::",
"calculateIndirectAddress",
"(",
"unsigned",
"RegIndex",
",",
"unsigned",
"Channel",
")",
"const",
"{",
"assert",
"(",
"Channel",
"==",
"0",
")",
";",
"return",
"RegIndex",
";",
"}",
"</s>"
] | [
"Calculate",
"the",
"``",
"Indirect",
"Address",
"''",
"for",
"the",
"given",
"RegIndex",
"and",
"Channel",
"."
] | [
"R600",
"0"
] | R600InstrInfo | calculateIndirectAddress | R600 | GPU | LLVM | 19,907 | 24 | 1 | [] |
[
"<s>",
"SDValue",
"JVMTargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"SDLoc",
"DL",
"(",
"Op",
")",
";",
"auto",
"PtrVT",
"=",
"getPointerTy",
"(",
"DAG",
".",
"getDataLayout",
"(",
")",
")",
";",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"unimplemented operation lowering\"",
")",
";",
"return",
"SDValue",
"(",
")",
";",
"case",
"ISD",
"::",
"ARRAY_REF",
":",
"return",
"LowerARRAY_REF",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"STRUCT_REF",
":",
"return",
"LowerSTRUCT_REF",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BRCOND",
":",
"return",
"LowerBRCOND",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BR_CC",
":",
"return",
"LowerBR_CC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"DYNAMIC_STACKALLOC",
":",
"return",
"LowerDYNAMIC_STACKALLOC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SHL",
":",
"case",
"ISD",
"::",
"SRA",
":",
"case",
"ISD",
"::",
"SRL",
":",
"case",
"ISD",
"::",
"OR",
":",
"case",
"ISD",
"::",
"AND",
":",
"case",
"ISD",
"::",
"XOR",
":",
"case",
"ISD",
"::",
"ADD",
":",
"case",
"ISD",
"::",
"SUB",
":",
"case",
"ISD",
"::",
"MUL",
":",
"case",
"ISD",
"::",
"UDIV",
":",
"case",
"ISD",
"::",
"SDIV",
":",
"case",
"ISD",
"::",
"UREM",
":",
"case",
"ISD",
"::",
"SREM",
":",
"return",
"LowerBinaryOp",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"LOAD",
":",
"return",
"LowerLOAD",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"STORE",
":",
"return",
"LowerSTORE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalAddress",
":",
"return",
"LowerGlobalAddress",
"(",
"Op",
",",
"DAG",
",",
"PtrVT",
")",
";",
"case",
"ISD",
"::",
"ZERO_EXTEND",
":",
"case",
"ISD",
"::",
"SIGN_EXTEND",
":",
"case",
"ISD",
"::",
"ANY_EXTEND",
":",
"case",
"ISD",
"::",
"SIGN_EXTEND_INREG",
":",
"return",
"LowerEXTEND",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"TRUNCATE",
":",
"return",
"LowerTRUNCATE",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"JVM",
"JVM",
"\"unimplemented operation lowering\"",
"ISD::ARRAY_REF",
"ISD::STRUCT_REF",
"ISD::BRCOND",
"ISD::BR_CC",
"ISD::DYNAMIC_STACKALLOC",
"ISD::SHL",
"ISD::SRA",
"ISD::SRL",
"ISD::OR",
"ISD::AND",
"ISD::XOR",
"ISD::ADD",
"ISD::SUB",
"ISD::MUL",
"ISD::UDIV",
"ISD::SDIV",
"ISD::UREM",
"ISD::SREM",
"ISD::LOAD",
"ISD::STORE",
"ISD::GlobalAddress",
"ISD::ZERO_EXTEND",
"ISD::SIGN_EXTEND",
"ISD::ANY_EXTEND",
"ISD::SIGN_EXTEND_INREG",
"ISD::TRUNCATE"
] | JVMISelLowering | LowerOperation | JVM | Virtual ISA | LLVM | 19,908 | 275 | 1 | [] |
[
"<s>",
"static",
"void",
"rx_get_stack_layout",
"(",
"unsigned",
"int",
"*",
"lowest",
",",
"unsigned",
"int",
"*",
"highest",
",",
"unsigned",
"int",
"*",
"register_mask",
",",
"unsigned",
"int",
"*",
"frame_size",
",",
"unsigned",
"int",
"*",
"stack_size",
")",
"{",
"unsigned",
"int",
"reg",
";",
"unsigned",
"int",
"low",
";",
"unsigned",
"int",
"high",
";",
"unsigned",
"int",
"fixed_reg",
"=",
"0",
";",
"unsigned",
"int",
"save_mask",
";",
"unsigned",
"int",
"pushed_mask",
";",
"unsigned",
"int",
"unneeded_pushes",
";",
"if",
"(",
"is_naked_func",
"(",
"NULL_TREE",
")",
")",
"{",
"*",
"lowest",
"=",
"0",
";",
"*",
"highest",
"=",
"0",
";",
"*",
"register_mask",
"=",
"0",
";",
"*",
"frame_size",
"=",
"0",
";",
"*",
"stack_size",
"=",
"0",
";",
"return",
";",
"}",
"for",
"(",
"save_mask",
"=",
"high",
"=",
"low",
"=",
"0",
",",
"reg",
"=",
"1",
";",
"reg",
"<",
"CC_REGNUM",
";",
"reg",
"++",
")",
"{",
"if",
"(",
"(",
"df_regs_ever_live_p",
"(",
"reg",
")",
"||",
"(",
"call_used_regs",
"[",
"reg",
"]",
"&&",
"is_interrupt_func",
"(",
"NULL_TREE",
")",
"&&",
"!",
"crtl",
"->",
"is_leaf",
")",
")",
"&&",
"(",
"!",
"call_used_regs",
"[",
"reg",
"]",
"||",
"is_interrupt_func",
"(",
"NULL_TREE",
")",
"||",
"(",
"is_fast_interrupt_func",
"(",
"NULL_TREE",
")",
"&&",
"!",
"IN_RANGE",
"(",
"reg",
",",
"10",
",",
"13",
")",
")",
")",
")",
"{",
"if",
"(",
"low",
"==",
"0",
")",
"low",
"=",
"reg",
";",
"high",
"=",
"reg",
";",
"save_mask",
"|=",
"1",
"<<",
"reg",
";",
"}",
"if",
"(",
"low",
"!=",
"0",
"&&",
"fixed_reg",
"==",
"0",
"&&",
"fixed_regs",
"[",
"reg",
"]",
")",
"fixed_reg",
"=",
"reg",
";",
"}",
"if",
"(",
"MUST_SAVE_ACC_REGISTER",
"&&",
"bit_count",
"(",
"save_mask",
")",
"<",
"2",
")",
"{",
"save_mask",
"|=",
"(",
"1",
"<<",
"13",
")",
"|",
"(",
"1",
"<<",
"14",
")",
";",
"if",
"(",
"low",
"==",
"0",
")",
"low",
"=",
"13",
";",
"if",
"(",
"high",
"==",
"0",
"||",
"low",
"==",
"high",
")",
"high",
"=",
"low",
"+",
"1",
";",
"}",
"pushed_mask",
"=",
"(",
"-",
"1",
"<<",
"low",
")",
"&",
"~",
"(",
"-",
"1",
"<<",
"(",
"high",
"+",
"1",
")",
")",
";",
"unneeded_pushes",
"=",
"(",
"pushed_mask",
"&",
"(",
"~",
"save_mask",
")",
")",
"&",
"pushed_mask",
";",
"if",
"(",
"(",
"fixed_reg",
"&&",
"fixed_reg",
"<=",
"high",
")",
"||",
"(",
"optimize_function_for_speed_p",
"(",
"cfun",
")",
"&&",
"bit_count",
"(",
"save_mask",
")",
"<",
"bit_count",
"(",
"unneeded_pushes",
")",
")",
")",
"{",
"*",
"lowest",
"=",
"0",
";",
"*",
"highest",
"=",
"0",
";",
"*",
"register_mask",
"=",
"save_mask",
";",
"}",
"else",
"{",
"*",
"lowest",
"=",
"low",
";",
"*",
"highest",
"=",
"high",
";",
"*",
"register_mask",
"=",
"0",
";",
"}",
"*",
"frame_size",
"=",
"rx_round_up",
"(",
"get_frame_size",
"(",
")",
",",
"STACK_BOUNDARY",
"/",
"BITS_PER_UNIT",
")",
";",
"if",
"(",
"crtl",
"->",
"args",
".",
"size",
">",
"0",
")",
"*",
"frame_size",
"+=",
"rx_round_up",
"(",
"crtl",
"->",
"args",
".",
"size",
",",
"STACK_BOUNDARY",
"/",
"BITS_PER_UNIT",
")",
";",
"*",
"stack_size",
"=",
"rx_round_up",
"(",
"crtl",
"->",
"outgoing_args_size",
",",
"STACK_BOUNDARY",
"/",
"BITS_PER_UNIT",
")",
";",
"}",
"</s>"
] | [
"Returns",
"either",
"the",
"lowest",
"numbered",
"and",
"highest",
"numbered",
"registers",
"that",
"occupy",
"the",
"call-saved",
"area",
"of",
"the",
"stack",
"frame",
",",
"if",
"the",
"registers",
"are",
"stored",
"as",
"a",
"contiguous",
"block",
",",
"or",
"else",
"a",
"bitmask",
"of",
"the",
"individual",
"registers",
"if",
"they",
"are",
"stored",
"piecemeal",
".",
"Also",
"computes",
"the",
"size",
"of",
"the",
"frame",
"and",
"the",
"size",
"of",
"the",
"outgoing",
"arguments",
"block",
"(",
"in",
"bytes",
")",
"."
] | [
"rx",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"1",
"10",
"13",
"0",
"1",
"0",
"0",
"2",
"1",
"13",
"1",
"14",
"0",
"13",
"0",
"1",
"1",
"1",
"1",
"0",
"0",
"0",
"0"
] | rx2 | rx_get_stack_layout | rx | CPU | GCC | 19,909 | 420 | 1 | [] |
[
"<s>",
"bool",
"SystemZTargetLowering",
"::",
"isLegalAddressingMode",
"(",
"const",
"DataLayout",
"&",
"DL",
",",
"const",
"AddrMode",
"&",
"AM",
",",
"Type",
"*",
"Ty",
",",
"unsigned",
"AS",
",",
"Instruction",
"*",
"I",
")",
"const",
"{",
"if",
"(",
"AM",
".",
"BaseGV",
")",
"return",
"false",
";",
"if",
"(",
"!",
"isInt",
"<",
"20",
">",
"(",
"AM",
".",
"BaseOffs",
")",
")",
"return",
"false",
";",
"bool",
"RequireD12",
"=",
"Subtarget",
".",
"hasVector",
"(",
")",
"&&",
"Ty",
"->",
"isVectorTy",
"(",
")",
";",
"AddressingMode",
"SupportedAM",
"(",
"!",
"RequireD12",
",",
"true",
")",
";",
"if",
"(",
"I",
"!=",
"nullptr",
")",
"SupportedAM",
"=",
"supportedAddressingMode",
"(",
"I",
",",
"Subtarget",
".",
"hasVector",
"(",
")",
")",
";",
"if",
"(",
"!",
"SupportedAM",
".",
"LongDisplacement",
"&&",
"!",
"isUInt",
"<",
"12",
">",
"(",
"AM",
".",
"BaseOffs",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"SupportedAM",
".",
"IndexReg",
")",
"return",
"AM",
".",
"Scale",
"==",
"0",
";",
"else",
"return",
"AM",
".",
"Scale",
"==",
"0",
"||",
"AM",
".",
"Scale",
"==",
"1",
";",
"}",
"</s>"
] | [
"isLegalAddressingMode",
"-",
"Return",
"true",
"if",
"the",
"addressing",
"mode",
"represented",
"by",
"AM",
"is",
"legal",
"for",
"this",
"target",
",",
"for",
"a",
"load/store",
"of",
"the",
"specified",
"type",
"."
] | [
"SystemZ",
"SystemZ",
"20",
"12",
"0",
"0",
"1"
] | SystemZISelLowering57 | isLegalAddressingMode | SystemZ | CPU | LLVM | 19,910 | 146 | 1 | [] |
[
"<s>",
"ARMBaseTargetMachine",
"::",
"ARMBaseTargetMachine",
"(",
"const",
"Target",
"&",
"T",
",",
"const",
"Triple",
"&",
"TT",
",",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
",",
"const",
"TargetOptions",
"&",
"Options",
",",
"Optional",
"<",
"Reloc",
"::",
"Model",
">",
"RM",
",",
"Optional",
"<",
"CodeModel",
"::",
"Model",
">",
"CM",
",",
"CodeGenOpt",
"::",
"Level",
"OL",
",",
"bool",
"isLittle",
")",
":",
"LLVMTargetMachine",
"(",
"T",
",",
"computeDataLayout",
"(",
"TT",
",",
"CPU",
",",
"Options",
",",
"isLittle",
")",
",",
"TT",
",",
"CPU",
",",
"FS",
",",
"Options",
",",
"getEffectiveRelocModel",
"(",
"TT",
",",
"RM",
")",
",",
"getEffectiveCodeModel",
"(",
"CM",
")",
",",
"OL",
")",
",",
"TargetABI",
"(",
"computeTargetABI",
"(",
"TT",
",",
"CPU",
",",
"Options",
")",
")",
",",
"TLOF",
"(",
"createTLOF",
"(",
"getTargetTriple",
"(",
")",
")",
")",
",",
"isLittle",
"(",
"isLittle",
")",
"{",
"if",
"(",
"Options",
".",
"FloatABIType",
"==",
"FloatABI",
"::",
"Default",
")",
"{",
"if",
"(",
"isTargetHardFloat",
"(",
")",
")",
"this",
"->",
"Options",
".",
"FloatABIType",
"=",
"FloatABI",
"::",
"Hard",
";",
"else",
"this",
"->",
"Options",
".",
"FloatABIType",
"=",
"FloatABI",
"::",
"Soft",
";",
"}",
"if",
"(",
"Options",
".",
"EABIVersion",
"==",
"EABI",
"::",
"Default",
"||",
"Options",
".",
"EABIVersion",
"==",
"EABI",
"::",
"Unknown",
")",
"{",
"if",
"(",
"(",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"GNUEABI",
"||",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"GNUEABIHF",
"||",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"MuslEABI",
"||",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"MuslEABIHF",
")",
"&&",
"!",
"(",
"TargetTriple",
".",
"isOSWindows",
"(",
")",
"||",
"TargetTriple",
".",
"isOSDarwin",
"(",
")",
")",
")",
"this",
"->",
"Options",
".",
"EABIVersion",
"=",
"EABI",
"::",
"GNU",
";",
"else",
"this",
"->",
"Options",
".",
"EABIVersion",
"=",
"EABI",
"::",
"EABI5",
";",
"}",
"if",
"(",
"TT",
".",
"isOSBinFormatMachO",
"(",
")",
")",
"{",
"this",
"->",
"Options",
".",
"TrapUnreachable",
"=",
"true",
";",
"this",
"->",
"Options",
".",
"NoTrapAfterNoreturn",
"=",
"true",
";",
"}",
"initAsmInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"Create",
"an",
"ARM",
"architecture",
"model",
"."
] | [
"ARM",
"ARM",
"ARM"
] | ARMTargetMachine42 | ARMBaseTargetMachine | ARM | CPU | LLVM | 19,911 | 285 | 1 | [] |
[
"<s>",
"const",
"MCFixupKindInfo",
"&",
"getFixupKindInfo",
"(",
"MCFixupKind",
"Kind",
")",
"const",
"override",
"{",
"const",
"static",
"MCFixupKindInfo",
"Infos",
"[",
"Teak",
"::",
"NumTargetFixupKinds",
"]",
"=",
"{",
"{",
"\"fixup_teak_call_imm18\"",
",",
"0",
",",
"18",
",",
"0",
"}",
",",
"{",
"\"fixup_teak_rel7\"",
",",
"0",
",",
"7",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"\"fixup_teak_ptr_imm16\"",
",",
"0",
",",
"16",
",",
"0",
"}",
",",
"{",
"\"fixup_teak_bkrep_reg\"",
",",
"0",
",",
"18",
",",
"0",
"}",
",",
"{",
"\"fixup_teak_bkrep_r6\"",
",",
"0",
",",
"18",
",",
"0",
"}",
",",
"}",
";",
"if",
"(",
"Kind",
"<",
"FirstTargetFixupKind",
")",
"return",
"MCAsmBackend",
"::",
"getFixupKindInfo",
"(",
"Kind",
")",
";",
"assert",
"(",
"unsigned",
"(",
"Kind",
"-",
"FirstTargetFixupKind",
")",
"<",
"getNumFixupKinds",
"(",
")",
"&&",
"\"Invalid kind!\"",
")",
";",
"return",
"Infos",
"[",
"Kind",
"-",
"FirstTargetFixupKind",
"]",
";",
"}",
"</s>"
] | [
"Get",
"information",
"on",
"a",
"fixup",
"kind",
"."
] | [
"Teak",
"Teak::NumTargetFixupKinds",
"\"fixup_teak_call_imm18\"",
"0",
"18",
"0",
"\"fixup_teak_rel7\"",
"0",
"7",
"\"fixup_teak_ptr_imm16\"",
"0",
"16",
"0",
"\"fixup_teak_bkrep_reg\"",
"0",
"18",
"0",
"\"fixup_teak_bkrep_r6\"",
"0",
"18",
"0",
"\"Invalid kind!\""
] | TeakAsmBackend | getFixupKindInfo | Teak | DSP | LLVM | 19,912 | 115 | 1 | [] |
[
"<s>",
"void",
"AVRAsmPrinter",
"::",
"EmitInstruction",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"{",
"AVRMCInstLower",
"MCInstLowering",
"(",
"OutContext",
",",
"*",
"this",
")",
";",
"MCInst",
"I",
";",
"MCInstLowering",
".",
"lowerInstruction",
"(",
"*",
"MI",
",",
"I",
")",
";",
"EmitToStreamer",
"(",
"*",
"OutStreamer",
",",
"I",
")",
";",
"}",
"</s>"
] | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"AVR",
"AVR",
"AVR"
] | AVRAsmPrinter1 | EmitInstruction | AVR | MPU | LLVM | 19,913 | 42 | 1 | [] |
[
"<s>",
"void",
"RISCVFrameLowering",
"::",
"emitEpilogue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"MBB",
".",
"getLastNonDebugInstr",
"(",
")",
";",
"const",
"RISCVRegisterInfo",
"*",
"RI",
"=",
"STI",
".",
"getRegisterInfo",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"auto",
"*",
"RVFI",
"=",
"MF",
".",
"getInfo",
"<",
"RISCVMachineFunctionInfo",
">",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
";",
"unsigned",
"FPReg",
"=",
"getFPReg",
"(",
"STI",
")",
";",
"unsigned",
"SPReg",
"=",
"getSPReg",
"(",
"STI",
")",
";",
"auto",
"LastFrameDestroy",
"=",
"std",
"::",
"prev",
"(",
"MBBI",
",",
"MFI",
".",
"getCalleeSavedInfo",
"(",
")",
".",
"size",
"(",
")",
")",
";",
"uint64_t",
"StackSize",
"=",
"MFI",
".",
"getStackSize",
"(",
")",
";",
"if",
"(",
"RI",
"->",
"needsStackRealignment",
"(",
"MF",
")",
"||",
"MFI",
".",
"hasVarSizedObjects",
"(",
")",
")",
"{",
"assert",
"(",
"hasFP",
"(",
"MF",
")",
"&&",
"\"frame pointer should not have been eliminated\"",
")",
";",
"adjustReg",
"(",
"MBB",
",",
"LastFrameDestroy",
",",
"DL",
",",
"SPReg",
",",
"FPReg",
",",
"-",
"StackSize",
"+",
"RVFI",
"->",
"getVarArgsSaveSize",
"(",
")",
",",
"MachineInstr",
"::",
"FrameDestroy",
")",
";",
"}",
"adjustReg",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"SPReg",
",",
"SPReg",
",",
"StackSize",
",",
"MachineInstr",
"::",
"FrameDestroy",
")",
";",
"}",
"</s>"
] | [
"Insert",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"RISCV",
"RISCV",
"RISCV",
"RISCV",
"\"frame pointer should not have been eliminated\""
] | RISCVFrameLowering10 | emitEpilogue | RISCV | CPU | LLVM | 19,914 | 187 | 1 | [] |
[
"<s>",
"bool",
"Warning",
"(",
"SMLoc",
"L",
",",
"const",
"Twine",
"&",
"Msg",
",",
"ArrayRef",
"<",
"SMRange",
">",
"Ranges",
"=",
"None",
")",
"{",
"return",
"getParser",
"(",
")",
".",
"Warning",
"(",
"L",
",",
"Msg",
",",
"Ranges",
")",
";",
"}",
"</s>"
] | [
"Emit",
"a",
"warning",
"at",
"the",
"location",
"L",
",",
"with",
"the",
"message",
"Msg",
"."
] | [
"ARM"
] | ARMAsmParser (2)5 | Warning | ARM | CPU | LLVM | 19,915 | 35 | 1 | [] |
[
"<s>",
"bool",
"ARMBaseInstrInfo",
"::",
"expandPostRAPseudo",
"(",
"MachineBasicBlock",
"::",
"iterator",
"MI",
")",
"const",
"{",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MI",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"Reloc",
"::",
"Model",
"RM",
"=",
"MF",
".",
"getTarget",
"(",
")",
".",
"getRelocationModel",
"(",
")",
";",
"if",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
"==",
"TargetOpcode",
"::",
"LOAD_STACK_GUARD",
")",
"{",
"assert",
"(",
"getSubtarget",
"(",
")",
".",
"getTargetTriple",
"(",
")",
".",
"isOSBinFormatMachO",
"(",
")",
"&&",
"\"LOAD_STACK_GUARD currently supported only for MachO.\"",
")",
";",
"expandLoadStackGuard",
"(",
"MI",
",",
"RM",
")",
";",
"MI",
"->",
"getParent",
"(",
")",
"->",
"erase",
"(",
"MI",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
"==",
"ARM",
"::",
"MEMCPY",
")",
"{",
"expandMEMCPY",
"(",
"MI",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"!",
"WidenVMOVS",
"||",
"!",
"MI",
"->",
"isCopy",
"(",
")",
"||",
"Subtarget",
".",
"isCortexA15",
"(",
")",
"||",
"Subtarget",
".",
"isFPOnlySP",
"(",
")",
")",
"return",
"false",
";",
"unsigned",
"DstRegS",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"unsigned",
"SrcRegS",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"!",
"ARM",
"::",
"SPRRegClass",
".",
"contains",
"(",
"DstRegS",
",",
"SrcRegS",
")",
")",
"return",
"false",
";",
"const",
"TargetRegisterInfo",
"*",
"TRI",
"=",
"&",
"getRegisterInfo",
"(",
")",
";",
"unsigned",
"DstRegD",
"=",
"TRI",
"->",
"getMatchingSuperReg",
"(",
"DstRegS",
",",
"ARM",
"::",
"ssub_0",
",",
"&",
"ARM",
"::",
"DPRRegClass",
")",
";",
"unsigned",
"SrcRegD",
"=",
"TRI",
"->",
"getMatchingSuperReg",
"(",
"SrcRegS",
",",
"ARM",
"::",
"ssub_0",
",",
"&",
"ARM",
"::",
"DPRRegClass",
")",
";",
"if",
"(",
"!",
"DstRegD",
"||",
"!",
"SrcRegD",
")",
"return",
"false",
";",
"if",
"(",
"!",
"MI",
"->",
"definesRegister",
"(",
"DstRegD",
",",
"TRI",
")",
"||",
"MI",
"->",
"readsRegister",
"(",
"DstRegD",
",",
"TRI",
")",
")",
"return",
"false",
";",
"if",
"(",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"isDead",
"(",
")",
")",
"return",
"false",
";",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"widening: \"",
"<<",
"*",
"MI",
")",
";",
"MachineInstrBuilder",
"MIB",
"(",
"*",
"MI",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
",",
"MI",
")",
";",
"int",
"ImpDefIdx",
"=",
"MI",
"->",
"findRegisterDefOperandIdx",
"(",
"DstRegD",
")",
";",
"if",
"(",
"ImpDefIdx",
"!=",
"-",
"1",
")",
"MI",
"->",
"RemoveOperand",
"(",
"ImpDefIdx",
")",
";",
"MI",
"->",
"setDesc",
"(",
"get",
"(",
"ARM",
"::",
"VMOVD",
")",
")",
";",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"setReg",
"(",
"DstRegD",
")",
";",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"setReg",
"(",
"SrcRegD",
")",
";",
"AddDefaultPred",
"(",
"MIB",
")",
";",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"setIsUndef",
"(",
")",
";",
"MIB",
".",
"addReg",
"(",
"SrcRegS",
",",
"RegState",
"::",
"Implicit",
")",
";",
"if",
"(",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"isKill",
"(",
")",
")",
"{",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"setIsKill",
"(",
"false",
")",
";",
"MI",
"->",
"addRegisterKilled",
"(",
"SrcRegS",
",",
"TRI",
",",
"true",
")",
";",
"}",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"replaced by: \"",
"<<",
"*",
"MI",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"function",
"is",
"called",
"for",
"all",
"pseudo",
"instructions",
"that",
"remain",
"after",
"register",
"allocation",
"."
] | [
"ARM",
"ARM",
"\"LOAD_STACK_GUARD currently supported only for MachO.\"",
"ARM::MEMCPY",
"0",
"1",
"ARM::SPRRegClass",
"ARM::ssub_0",
"ARM::DPRRegClass",
"ARM::ssub_0",
"ARM::DPRRegClass",
"0",
"\"widening: \"",
"1",
"ARM::VMOVD",
"0",
"1",
"1",
"1",
"1",
"\"replaced by: \""
] | ARMBaseInstrInfo (2)3 | expandPostRAPseudo | ARM | CPU | LLVM | 19,916 | 457 | 1 | [] |
[
"<s>",
"void",
"X86AsmPrinter",
"::",
"emitStartOfAsmFile",
"(",
"Module",
"&",
"M",
")",
"{",
"const",
"Triple",
"&",
"TT",
"=",
"TM",
".",
"getTargetTriple",
"(",
")",
";",
"if",
"(",
"TT",
".",
"isOSBinFormatELF",
"(",
")",
")",
"{",
"unsigned",
"FeatureFlagsAnd",
"=",
"0",
";",
"if",
"(",
"M",
".",
"getModuleFlag",
"(",
"\"cf-protection-branch\"",
")",
")",
"{",
"FeatureFlagsAnd",
"|=",
"ELF",
"::",
"GNU_PROPERTY_X86_FEATURE_1_IBT",
";",
"if",
"(",
"M",
".",
"getModuleFlag",
"(",
"\"cf-protection-fine\"",
")",
")",
"{",
"FeatureFlagsAnd",
"|=",
"ELF",
"::",
"GNU_PROPERTY_X86_FEATURE_1_FINEIBT",
";",
"}",
"}",
"if",
"(",
"M",
".",
"getModuleFlag",
"(",
"\"cf-protection-return\"",
")",
")",
"FeatureFlagsAnd",
"|=",
"ELF",
"::",
"GNU_PROPERTY_X86_FEATURE_1_SHSTK",
";",
"if",
"(",
"FeatureFlagsAnd",
")",
"{",
"if",
"(",
"!",
"TT",
".",
"isArch32Bit",
"(",
")",
"&&",
"!",
"TT",
".",
"isArch64Bit",
"(",
")",
")",
"llvm_unreachable",
"(",
"\"CFProtection used on invalid architecture!\"",
")",
";",
"MCSection",
"*",
"Cur",
"=",
"OutStreamer",
"->",
"getCurrentSectionOnly",
"(",
")",
";",
"MCSection",
"*",
"Nt",
"=",
"MMI",
"->",
"getContext",
"(",
")",
".",
"getELFSection",
"(",
"\".note.gnu.property\"",
",",
"ELF",
"::",
"SHT_NOTE",
",",
"ELF",
"::",
"SHF_ALLOC",
")",
";",
"OutStreamer",
"->",
"SwitchSection",
"(",
"Nt",
")",
";",
"int",
"WordSize",
"=",
"TT",
".",
"isArch64Bit",
"(",
")",
"?",
"8",
":",
"4",
";",
"emitAlignment",
"(",
"WordSize",
"==",
"4",
"?",
"Align",
"(",
"4",
")",
":",
"Align",
"(",
"8",
")",
")",
";",
"OutStreamer",
"->",
"emitIntValue",
"(",
"4",
",",
"4",
")",
";",
"OutStreamer",
"->",
"emitIntValue",
"(",
"8",
"+",
"WordSize",
",",
"4",
")",
";",
"OutStreamer",
"->",
"emitIntValue",
"(",
"ELF",
"::",
"NT_GNU_PROPERTY_TYPE_0",
",",
"4",
")",
";",
"OutStreamer",
"->",
"emitBytes",
"(",
"StringRef",
"(",
"\"GNU\"",
",",
"4",
")",
")",
";",
"OutStreamer",
"->",
"emitInt32",
"(",
"ELF",
"::",
"GNU_PROPERTY_X86_FEATURE_1_AND",
")",
";",
"OutStreamer",
"->",
"emitInt32",
"(",
"4",
")",
";",
"OutStreamer",
"->",
"emitInt32",
"(",
"FeatureFlagsAnd",
")",
";",
"emitAlignment",
"(",
"WordSize",
"==",
"4",
"?",
"Align",
"(",
"4",
")",
":",
"Align",
"(",
"8",
")",
")",
";",
"OutStreamer",
"->",
"endSection",
"(",
"Nt",
")",
";",
"OutStreamer",
"->",
"SwitchSection",
"(",
"Cur",
")",
";",
"}",
"}",
"if",
"(",
"TT",
".",
"isOSBinFormatMachO",
"(",
")",
")",
"OutStreamer",
"->",
"SwitchSection",
"(",
"getObjFileLowering",
"(",
")",
".",
"getTextSection",
"(",
")",
")",
";",
"if",
"(",
"TT",
".",
"isOSBinFormatCOFF",
"(",
")",
")",
"{",
"MCSymbol",
"*",
"S",
"=",
"MMI",
"->",
"getContext",
"(",
")",
".",
"getOrCreateSymbol",
"(",
"StringRef",
"(",
"\"@feat.00\"",
")",
")",
";",
"OutStreamer",
"->",
"BeginCOFFSymbolDef",
"(",
"S",
")",
";",
"OutStreamer",
"->",
"EmitCOFFSymbolStorageClass",
"(",
"COFF",
"::",
"IMAGE_SYM_CLASS_STATIC",
")",
";",
"OutStreamer",
"->",
"EmitCOFFSymbolType",
"(",
"COFF",
"::",
"IMAGE_SYM_DTYPE_NULL",
")",
";",
"OutStreamer",
"->",
"EndCOFFSymbolDef",
"(",
")",
";",
"int64_t",
"Feat00Flags",
"=",
"0",
";",
"if",
"(",
"TT",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"x86",
")",
"{",
"Feat00Flags",
"|=",
"1",
";",
"}",
"if",
"(",
"M",
".",
"getModuleFlag",
"(",
"\"cfguard\"",
")",
")",
"Feat00Flags",
"|=",
"0x800",
";",
"OutStreamer",
"->",
"emitSymbolAttribute",
"(",
"S",
",",
"MCSA_Global",
")",
";",
"OutStreamer",
"->",
"emitAssignment",
"(",
"S",
",",
"MCConstantExpr",
"::",
"create",
"(",
"Feat00Flags",
",",
"MMI",
"->",
"getContext",
"(",
")",
")",
")",
";",
"}",
"OutStreamer",
"->",
"emitSyntaxDirective",
"(",
")",
";",
"bool",
"is16",
"=",
"TT",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"CODE16",
";",
"if",
"(",
"M",
".",
"getModuleInlineAsm",
"(",
")",
".",
"empty",
"(",
")",
"&&",
"is16",
")",
"OutStreamer",
"->",
"emitAssemblerFlag",
"(",
"MCAF_Code16",
")",
";",
"}",
"</s>"
] | [
"This",
"virtual",
"method",
"can",
"be",
"overridden",
"by",
"targets",
"that",
"want",
"to",
"emit",
"something",
"at",
"the",
"start",
"of",
"their",
"file",
"."
] | [
"X86",
"X86",
"0",
"\"cf-protection-branch\"",
"X86",
"\"cf-protection-fine\"",
"X86",
"\"cf-protection-return\"",
"X86",
"\"CFProtection used on invalid architecture!\"",
"\".note.gnu.property\"",
"8",
"4",
"4",
"4",
"8",
"4",
"4",
"8",
"4",
"4",
"\"GNU\"",
"4",
"X86",
"4",
"4",
"4",
"8",
"\"@feat.00\"",
"0",
"1",
"\"cfguard\"",
"0x800"
] | X86AsmPrinter9 | emitStartOfAsmFile | X86 | CPU | LLVM | 19,917 | 465 | 1 | [] |
[
"<s>",
"void",
"arc_print_operand_address",
"(",
"FILE",
"*",
"file",
",",
"rtx",
"addr",
")",
"{",
"register",
"rtx",
"base",
",",
"index",
"=",
"0",
";",
"int",
"offset",
"=",
"0",
";",
"switch",
"(",
"GET_CODE",
"(",
"addr",
")",
")",
"{",
"case",
"REG",
":",
"fputs",
"(",
"reg_names",
"[",
"REGNO",
"(",
"addr",
")",
"]",
",",
"file",
")",
";",
"break",
";",
"case",
"SYMBOL_REF",
":",
"if",
"(",
"0",
"&&",
"SYMBOL_REF_FUNCTION_P",
"(",
"addr",
")",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"%%st(\"",
")",
";",
"output_addr_const",
"(",
"file",
",",
"addr",
")",
";",
"fprintf",
"(",
"file",
",",
"\")\"",
")",
";",
"}",
"else",
"output_addr_const",
"(",
"file",
",",
"addr",
")",
";",
"break",
";",
"case",
"PLUS",
":",
"if",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
")",
"==",
"CONST_INT",
")",
"offset",
"=",
"INTVAL",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
")",
",",
"base",
"=",
"XEXP",
"(",
"addr",
",",
"1",
")",
";",
"else",
"if",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"addr",
",",
"1",
")",
")",
"==",
"CONST_INT",
")",
"offset",
"=",
"INTVAL",
"(",
"XEXP",
"(",
"addr",
",",
"1",
")",
")",
",",
"base",
"=",
"XEXP",
"(",
"addr",
",",
"0",
")",
";",
"else",
"base",
"=",
"XEXP",
"(",
"addr",
",",
"0",
")",
",",
"index",
"=",
"XEXP",
"(",
"addr",
",",
"1",
")",
";",
"gcc_assert",
"(",
"GET_CODE",
"(",
"base",
")",
"==",
"REG",
")",
";",
"fputs",
"(",
"reg_names",
"[",
"REGNO",
"(",
"base",
")",
"]",
",",
"file",
")",
";",
"if",
"(",
"index",
"==",
"0",
")",
"{",
"if",
"(",
"offset",
"!=",
"0",
")",
"fprintf",
"(",
"file",
",",
"\",%d\"",
",",
"offset",
")",
";",
"}",
"else",
"{",
"switch",
"(",
"GET_CODE",
"(",
"index",
")",
")",
"{",
"case",
"REG",
":",
"fprintf",
"(",
"file",
",",
"\",%s\"",
",",
"reg_names",
"[",
"REGNO",
"(",
"index",
")",
"]",
")",
";",
"break",
";",
"case",
"SYMBOL_REF",
":",
"fputc",
"(",
"','",
",",
"file",
")",
",",
"output_addr_const",
"(",
"file",
",",
"index",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"break",
";",
"case",
"PRE_INC",
":",
"case",
"PRE_DEC",
":",
"gcc_unreachable",
"(",
")",
";",
"break",
";",
"default",
":",
"output_addr_const",
"(",
"file",
",",
"addr",
")",
";",
"break",
";",
"}",
"}",
"</s>"
] | [
"Print",
"a",
"memory",
"address",
"as",
"an",
"operand",
"to",
"reference",
"that",
"memory",
"location",
"."
] | [
"arc",
"0",
"0",
"0",
"\"%%st(\"",
"\")\"",
"0",
"0",
"1",
"1",
"1",
"0",
"0",
"1",
"0",
"0",
"\",%d\"",
"\",%s\""
] | arc3 | arc_print_operand_address | arc | MPU | GCC | 19,918 | 318 | 1 | [] |
[
"<s>",
"bool",
"SIInstrInfo",
"::",
"isInlineConstant",
"(",
"const",
"MachineOperand",
"&",
"MO",
",",
"uint8_t",
"OperandType",
")",
"const",
"{",
"if",
"(",
"!",
"MO",
".",
"isImm",
"(",
")",
"||",
"OperandType",
"<",
"AMDGPU",
"::",
"OPERAND_SRC_FIRST",
"||",
"OperandType",
">",
"AMDGPU",
"::",
"OPERAND_SRC_LAST",
")",
"return",
"false",
";",
"int64_t",
"Imm",
"=",
"MO",
".",
"getImm",
"(",
")",
";",
"switch",
"(",
"OperandType",
")",
"{",
"case",
"AMDGPU",
"::",
"OPERAND_REG_IMM_INT32",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_IMM_FP32",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_C_INT32",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_C_FP32",
":",
"{",
"int32_t",
"Trunc",
"=",
"static_cast",
"<",
"int32_t",
">",
"(",
"Imm",
")",
";",
"return",
"AMDGPU",
"::",
"isInlinableLiteral32",
"(",
"Trunc",
",",
"ST",
".",
"hasInv2PiInlineImm",
"(",
")",
")",
";",
"}",
"case",
"AMDGPU",
"::",
"OPERAND_REG_IMM_INT64",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_IMM_FP64",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_C_INT64",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_C_FP64",
":",
"return",
"AMDGPU",
"::",
"isInlinableLiteral64",
"(",
"MO",
".",
"getImm",
"(",
")",
",",
"ST",
".",
"hasInv2PiInlineImm",
"(",
")",
")",
";",
"case",
"AMDGPU",
"::",
"OPERAND_REG_IMM_INT16",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_IMM_FP16",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_C_INT16",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_C_FP16",
":",
"{",
"if",
"(",
"isInt",
"<",
"16",
">",
"(",
"Imm",
")",
"||",
"isUInt",
"<",
"16",
">",
"(",
"Imm",
")",
")",
"{",
"int16_t",
"Trunc",
"=",
"static_cast",
"<",
"int16_t",
">",
"(",
"Imm",
")",
";",
"return",
"ST",
".",
"has16BitInsts",
"(",
")",
"&&",
"AMDGPU",
"::",
"isInlinableLiteral16",
"(",
"Trunc",
",",
"ST",
".",
"hasInv2PiInlineImm",
"(",
")",
")",
";",
"}",
"return",
"false",
";",
"}",
"case",
"AMDGPU",
"::",
"OPERAND_REG_IMM_V2INT16",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_IMM_V2FP16",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_C_V2INT16",
":",
"case",
"AMDGPU",
"::",
"OPERAND_REG_INLINE_C_V2FP16",
":",
"{",
"uint32_t",
"Trunc",
"=",
"static_cast",
"<",
"uint32_t",
">",
"(",
"Imm",
")",
";",
"return",
"AMDGPU",
"::",
"isInlinableLiteralV216",
"(",
"Trunc",
",",
"ST",
".",
"hasInv2PiInlineImm",
"(",
")",
")",
";",
"}",
"default",
":",
"llvm_unreachable",
"(",
"\"invalid bitwidth\"",
")",
";",
"}",
"}",
"</s>"
] | [
"returns",
"true",
"if",
"the",
"operand",
"OpIdx",
"in",
"MI",
"is",
"a",
"valid",
"inline",
"immediate",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU::OPERAND_SRC_FIRST",
"AMDGPU::OPERAND_SRC_LAST",
"AMDGPU::OPERAND_REG_IMM_INT32",
"AMDGPU::OPERAND_REG_IMM_FP32",
"AMDGPU::OPERAND_REG_INLINE_C_INT32",
"AMDGPU::OPERAND_REG_INLINE_C_FP32",
"AMDGPU::isInlinableLiteral32",
"AMDGPU::OPERAND_REG_IMM_INT64",
"AMDGPU::OPERAND_REG_IMM_FP64",
"AMDGPU::OPERAND_REG_INLINE_C_INT64",
"AMDGPU::OPERAND_REG_INLINE_C_FP64",
"AMDGPU::isInlinableLiteral64",
"AMDGPU::OPERAND_REG_IMM_INT16",
"AMDGPU::OPERAND_REG_IMM_FP16",
"AMDGPU::OPERAND_REG_INLINE_C_INT16",
"AMDGPU::OPERAND_REG_INLINE_C_FP16",
"16",
"16",
"AMDGPU::isInlinableLiteral16",
"AMDGPU::OPERAND_REG_IMM_V2INT16",
"AMDGPU::OPERAND_REG_IMM_V2FP16",
"AMDGPU::OPERAND_REG_INLINE_C_V2INT16",
"AMDGPU::OPERAND_REG_INLINE_C_V2FP16",
"AMDGPU::isInlinableLiteralV216",
"\"invalid bitwidth\""
] | SIInstrInfo110 | isInlineConstant | AMDGPU | GPU | LLVM | 19,919 | 270 | 1 | [] |
[
"<s>",
"const",
"DataLayout",
"*",
"getDataLayout",
"(",
")",
"const",
"override",
"{",
"return",
"&",
"DL",
";",
"}",
"</s>"
] | [
"Return",
"the",
"DataLayout",
"associated",
"with",
"the",
"module",
"this",
"SCEV",
"instance",
"is",
"operating",
"on",
"."
] | [
"MSP430"
] | MSP430TargetMachine19 | getDataLayout | MSP430 | MPU | LLVM | 19,920 | 14 | 1 | [] |
[
"<s>",
"static",
"int",
"h8300_rtx_ok_for_base_p",
"(",
"rtx",
"x",
",",
"int",
"strict",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"SUBREG",
")",
"x",
"=",
"SUBREG_REG",
"(",
"x",
")",
";",
"return",
"(",
"REG_P",
"(",
"x",
")",
"&&",
"(",
"strict",
"?",
"REG_OK_FOR_BASE_STRICT_P",
"(",
"x",
")",
":",
"REG_OK_FOR_BASE_NONSTRICT_P",
"(",
"x",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"nonzero",
"if",
"X",
"is",
"a",
"REG",
"or",
"SUBREG",
"suitable",
"as",
"a",
"base",
"register",
"."
] | [
"h8300"
] | h8300 | h8300_rtx_ok_for_base_p | h8300 | MPU | GCC | 19,921 | 50 | 1 | [] |
[
"<s>",
"void",
"arc_clear_unalign",
"(",
"void",
")",
"{",
"if",
"(",
"cfun",
")",
"cfun",
"->",
"machine",
"->",
"unalign",
"=",
"0",
";",
"}",
"</s>"
] | [
"Accessor",
"functions",
"for",
"cfun-",
">",
"machine-",
">",
"unalign",
"."
] | [
"arc",
"0"
] | arc | arc_clear_unalign | arc | MPU | GCC | 19,922 | 19 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"isShuffleMaskLegal",
"(",
"const",
"SmallVectorImpl",
"<",
"int",
">",
"&",
"M",
",",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"VT",
".",
"getSizeInBits",
"(",
")",
"==",
"64",
")",
"return",
"false",
";",
"return",
"(",
"VT",
".",
"getVectorNumElements",
"(",
")",
"==",
"2",
"||",
"ShuffleVectorSDNode",
"::",
"isSplatMask",
"(",
"&",
"M",
"[",
"0",
"]",
",",
"VT",
")",
"||",
"isMOVLMask",
"(",
"M",
",",
"VT",
")",
"||",
"isSHUFPMask",
"(",
"M",
",",
"VT",
",",
"Subtarget",
"->",
"hasFp256",
"(",
")",
")",
"||",
"isPSHUFDMask",
"(",
"M",
",",
"VT",
")",
"||",
"isPSHUFHWMask",
"(",
"M",
",",
"VT",
",",
"Subtarget",
"->",
"hasInt256",
"(",
")",
")",
"||",
"isPSHUFLWMask",
"(",
"M",
",",
"VT",
",",
"Subtarget",
"->",
"hasInt256",
"(",
")",
")",
"||",
"isPALIGNRMask",
"(",
"M",
",",
"VT",
",",
"Subtarget",
")",
"||",
"isUNPCKLMask",
"(",
"M",
",",
"VT",
",",
"Subtarget",
"->",
"hasInt256",
"(",
")",
")",
"||",
"isUNPCKHMask",
"(",
"M",
",",
"VT",
",",
"Subtarget",
"->",
"hasInt256",
"(",
")",
")",
"||",
"isUNPCKL_v_undef_Mask",
"(",
"M",
",",
"VT",
",",
"Subtarget",
"->",
"hasInt256",
"(",
")",
")",
"||",
"isUNPCKH_v_undef_Mask",
"(",
"M",
",",
"VT",
",",
"Subtarget",
"->",
"hasInt256",
"(",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Targets",
"can",
"use",
"this",
"to",
"indicate",
"that",
"they",
"only",
"support",
"some",
"VECTOR_SHUFFLE",
"operations",
",",
"those",
"with",
"specific",
"masks",
"."
] | [
"X86",
"X86",
"64",
"2",
"0"
] | X86ISelLowering (2)2 | isShuffleMaskLegal | X86 | CPU | LLVM | 19,923 | 170 | 1 | [] |
[
"<s>",
"static",
"rtx",
"ix86_expand_sse_fabs",
"(",
"rtx",
"op0",
",",
"rtx",
"*",
"smask",
")",
"{",
"machine_mode",
"vmode",
",",
"mode",
"=",
"GET_MODE",
"(",
"op0",
")",
";",
"rtx",
"xa",
",",
"mask",
";",
"xa",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"if",
"(",
"mode",
"==",
"SFmode",
")",
"vmode",
"=",
"V4SFmode",
";",
"else",
"if",
"(",
"mode",
"==",
"DFmode",
")",
"vmode",
"=",
"V2DFmode",
";",
"else",
"vmode",
"=",
"mode",
";",
"mask",
"=",
"ix86_build_signbit_mask",
"(",
"vmode",
",",
"VECTOR_MODE_P",
"(",
"mode",
")",
",",
"true",
")",
";",
"if",
"(",
"!",
"VECTOR_MODE_P",
"(",
"mode",
")",
")",
"{",
"rtx",
"tmp",
"=",
"gen_rtx_PARALLEL",
"(",
"VOIDmode",
",",
"gen_rtvec",
"(",
"1",
",",
"const0_rtx",
")",
")",
";",
"tmp",
"=",
"gen_rtx_VEC_SELECT",
"(",
"mode",
",",
"mask",
",",
"tmp",
")",
";",
"mask",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"mask",
",",
"tmp",
")",
")",
";",
"}",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"xa",
",",
"gen_rtx_AND",
"(",
"mode",
",",
"op0",
",",
"mask",
")",
")",
")",
";",
"if",
"(",
"smask",
")",
"*",
"smask",
"=",
"mask",
";",
"return",
"xa",
";",
"}",
"</s>"
] | [
"Expand",
"fabs",
"(",
"OP0",
")",
"and",
"return",
"a",
"new",
"rtx",
"that",
"holds",
"the",
"result",
".",
"The",
"mask",
"for",
"masking",
"out",
"the",
"sign-bit",
"is",
"stored",
"in",
"*",
"SMASK",
",",
"if",
"that",
"is",
"non-null",
"."
] | [
"i386",
"1"
] | i3864 | ix86_expand_sse_fabs | i386 | CPU | GCC | 19,924 | 161 | 1 | [] |
[
"<s>",
"const",
"SystemZSubtarget",
"*",
"SystemZTargetMachine",
"::",
"getSubtargetImpl",
"(",
"const",
"Function",
"&",
"F",
")",
"const",
"{",
"Attribute",
"CPUAttr",
"=",
"F",
".",
"getFnAttribute",
"(",
"\"target-cpu\"",
")",
";",
"Attribute",
"FSAttr",
"=",
"F",
".",
"getFnAttribute",
"(",
"\"target-features\"",
")",
";",
"std",
"::",
"string",
"CPU",
"=",
"CPUAttr",
".",
"isValid",
"(",
")",
"?",
"CPUAttr",
".",
"getValueAsString",
"(",
")",
".",
"str",
"(",
")",
":",
"TargetCPU",
";",
"std",
"::",
"string",
"FS",
"=",
"FSAttr",
".",
"isValid",
"(",
")",
"?",
"FSAttr",
".",
"getValueAsString",
"(",
")",
".",
"str",
"(",
")",
":",
"TargetFS",
";",
"bool",
"softFloat",
"=",
"F",
".",
"hasFnAttribute",
"(",
"\"use-soft-float\"",
")",
"&&",
"F",
".",
"getFnAttribute",
"(",
"\"use-soft-float\"",
")",
".",
"getValueAsString",
"(",
")",
"==",
"\"true\"",
";",
"if",
"(",
"softFloat",
")",
"FS",
"+=",
"FS",
".",
"empty",
"(",
")",
"?",
"\"+soft-float\"",
":",
"\",+soft-float\"",
";",
"auto",
"&",
"I",
"=",
"SubtargetMap",
"[",
"CPU",
"+",
"FS",
"]",
";",
"if",
"(",
"!",
"I",
")",
"{",
"resetTargetOptions",
"(",
"F",
")",
";",
"I",
"=",
"std",
"::",
"make_unique",
"<",
"SystemZSubtarget",
">",
"(",
"TargetTriple",
",",
"CPU",
",",
"FS",
",",
"*",
"this",
")",
";",
"}",
"return",
"I",
".",
"get",
"(",
")",
";",
"}",
"</s>"
] | [
"Virtual",
"method",
"implemented",
"by",
"subclasses",
"that",
"returns",
"a",
"reference",
"to",
"that",
"target",
"'s",
"TargetSubtargetInfo-derived",
"member",
"variable",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ",
"\"target-cpu\"",
"\"target-features\"",
"\"use-soft-float\"",
"\"use-soft-float\"",
"\"true\"",
"\"+soft-float\"",
"\",+soft-float\"",
"SystemZ"
] | SystemZTargetMachine19 | getSubtargetImpl | SystemZ | CPU | LLVM | 19,925 | 169 | 1 | [] |
[
"<s>",
"unsigned",
"xlogue_layout",
"::",
"count_stub_managed_regs",
"(",
")",
"{",
"bool",
"hfp",
"=",
"frame_pointer_needed",
"||",
"stack_realign_fp",
";",
"unsigned",
"i",
",",
"count",
";",
"unsigned",
"regno",
";",
"for",
"(",
"count",
"=",
"i",
"=",
"MIN_REGS",
";",
"i",
"<",
"MAX_REGS",
";",
"++",
"i",
")",
"{",
"regno",
"=",
"REG_ORDER",
"[",
"i",
"]",
";",
"if",
"(",
"regno",
"==",
"BP_REG",
"&&",
"hfp",
")",
"continue",
";",
"if",
"(",
"!",
"ix86_save_reg",
"(",
"regno",
",",
"false",
",",
"false",
")",
")",
"break",
";",
"++",
"count",
";",
"}",
"return",
"count",
";",
"}",
"</s>"
] | [
"Determine",
"how",
"many",
"clobbered",
"registers",
"can",
"be",
"saved",
"by",
"the",
"stub",
".",
"Returns",
"the",
"count",
"of",
"registers",
"the",
"stub",
"will",
"save",
"and",
"restore",
"."
] | [
"i386"
] | i386-features | count_stub_managed_regs | i386 | CPU | GCC | 19,926 | 77 | 1 | [] |
[
"<s>",
"SDValue",
"AArch64SelectionDAGInfo",
"::",
"EmitTargetCodeForMemset",
"(",
"SelectionDAG",
"&",
"DAG",
",",
"const",
"SDLoc",
"&",
"dl",
",",
"SDValue",
"Chain",
",",
"SDValue",
"Dst",
",",
"SDValue",
"Src",
",",
"SDValue",
"Size",
",",
"Align",
"Alignment",
",",
"bool",
"isVolatile",
",",
"MachinePointerInfo",
"DstPtrInfo",
")",
"const",
"{",
"ConstantSDNode",
"*",
"V",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Src",
")",
";",
"ConstantSDNode",
"*",
"SizeValue",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Size",
")",
";",
"const",
"AArch64Subtarget",
"&",
"STI",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getSubtarget",
"<",
"AArch64Subtarget",
">",
"(",
")",
";",
"const",
"char",
"*",
"bzeroName",
"=",
"(",
"V",
"&&",
"V",
"->",
"isNullValue",
"(",
")",
")",
"?",
"DAG",
".",
"getTargetLoweringInfo",
"(",
")",
".",
"getLibcallName",
"(",
"RTLIB",
"::",
"BZERO",
")",
":",
"nullptr",
";",
"if",
"(",
"bzeroName",
"&&",
"(",
"!",
"SizeValue",
"||",
"SizeValue",
"->",
"getZExtValue",
"(",
")",
">",
"256",
")",
")",
"{",
"const",
"AArch64TargetLowering",
"&",
"TLI",
"=",
"*",
"STI",
".",
"getTargetLowering",
"(",
")",
";",
"Type",
"*",
"IntPtrTy",
"=",
"Type",
"::",
"getInt8PtrTy",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"TargetLowering",
"::",
"ArgListTy",
"Args",
";",
"TargetLowering",
"::",
"ArgListEntry",
"Entry",
";",
"Entry",
".",
"Node",
"=",
"Dst",
";",
"Entry",
".",
"Ty",
"=",
"IntPtrTy",
";",
"Args",
".",
"push_back",
"(",
"Entry",
")",
";",
"Entry",
".",
"Node",
"=",
"Size",
";",
"Args",
".",
"push_back",
"(",
"Entry",
")",
";",
"TargetLowering",
"::",
"CallLoweringInfo",
"CLI",
"(",
"DAG",
")",
";",
"CLI",
".",
"setDebugLoc",
"(",
"dl",
")",
".",
"setChain",
"(",
"Chain",
")",
".",
"setLibCallee",
"(",
"CallingConv",
"::",
"C",
",",
"Type",
"::",
"getVoidTy",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
",",
"DAG",
".",
"getExternalFunctionSymbol",
"(",
"bzeroName",
")",
",",
"std",
"::",
"move",
"(",
"Args",
")",
")",
".",
"setDiscardResult",
"(",
")",
";",
"std",
"::",
"pair",
"<",
"SDValue",
",",
"SDValue",
">",
"CallResult",
"=",
"TLI",
".",
"LowerCallTo",
"(",
"CLI",
")",
";",
"return",
"CallResult",
".",
"second",
";",
"}",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] | [
"Emit",
"target-specific",
"code",
"that",
"performs",
"a",
"memset",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"256",
"AArch64"
] | AArch64SelectionDAGInfo16 | EmitTargetCodeForMemset | AArch64 | CPU | LLVM | 19,927 | 283 | 1 | [] |
[
"<s>",
"avr_regno_mode_code_ok_for_base_p",
"(",
"num",
",",
"mode",
",",
"as",
",",
"outer_code",
",",
"index_code",
")",
"{",
"ARG_POINTER_REGNUM",
",",
"STACK_POINTER_REGNUM",
"}",
",",
"\\",
"{",
"ARG_POINTER_REGNUM",
",",
"FRAME_POINTER_REGNUM",
"}",
",",
"\\",
"{",
"FRAME_POINTER_REGNUM",
",",
"STACK_POINTER_REGNUM",
"}",
",",
"\\",
"{",
"FRAME_POINTER_REGNUM",
"+",
"1",
",",
"STACK_POINTER_REGNUM",
"+",
"1",
"}",
"</s>"
] | [
"Implement",
"`",
"REGNO_MODE_CODE_OK_FOR_BASE_P",
"'",
"."
] | [
"avr",
"1",
"1"
] | avr2 | avr_regno_mode_code_ok_for_base_p | avr | MPU | GCC | 19,928 | 42 | 1 | [] |
[
"<s>",
"unsigned",
"HexagonTTIImpl",
"::",
"getGatherScatterOpCost",
"(",
"unsigned",
"Opcode",
",",
"Type",
"*",
"DataTy",
",",
"Value",
"*",
"Ptr",
",",
"bool",
"VariableMask",
",",
"unsigned",
"Alignment",
",",
"TTI",
"::",
"TargetCostKind",
"CostKind",
",",
"const",
"Instruction",
"*",
"I",
")",
"{",
"return",
"BaseT",
"::",
"getGatherScatterOpCost",
"(",
"Opcode",
",",
"DataTy",
",",
"Ptr",
",",
"VariableMask",
",",
"Alignment",
",",
"CostKind",
",",
"I",
")",
";",
"}",
"</s>"
] | [
"Calculate",
"the",
"cost",
"of",
"Gather",
"/",
"Scatter",
"operation",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonTargetTransformInfo | getGatherScatterOpCost | Hexagon | DSP | LLVM | 19,929 | 54 | 1 | [] |
[
"<s>",
"void",
"addExpr",
"(",
"MCInst",
"&",
"Inst",
",",
"const",
"MCExpr",
"*",
"Expr",
")",
"const",
"{",
"if",
"(",
"const",
"MCConstantExpr",
"*",
"CE",
"=",
"dyn_cast",
"<",
"MCConstantExpr",
">",
"(",
"Expr",
")",
")",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"CE",
"->",
"getValue",
"(",
")",
")",
")",
";",
"else",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createExpr",
"(",
"Expr",
")",
")",
";",
"}",
"</s>"
] | [
"Add",
"a",
"new",
"MCExpr",
"operand",
"."
] | [
"X86"
] | X86Operand (2) | addExpr | X86 | CPU | LLVM | 19,930 | 59 | 1 | [] |
[
"<s>",
"void",
"Mips16TargetLowering",
"::",
"getOpndList",
"(",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"Ops",
",",
"std",
"::",
"deque",
"<",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"SDValue",
">",
">",
"&",
"RegsToPass",
",",
"bool",
"IsPICCall",
",",
"bool",
"GlobalOrExternal",
",",
"bool",
"InternalLinkage",
",",
"CallLoweringInfo",
"&",
"CLI",
",",
"SDValue",
"Callee",
",",
"SDValue",
"Chain",
")",
"const",
"{",
"SelectionDAG",
"&",
"DAG",
"=",
"CLI",
".",
"DAG",
";",
"MachineFunction",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"MipsFunctionInfo",
"*",
"FuncInfo",
"=",
"MF",
".",
"getInfo",
"<",
"MipsFunctionInfo",
">",
"(",
")",
";",
"const",
"char",
"*",
"Mips16HelperFunction",
"=",
"0",
";",
"bool",
"NeedMips16Helper",
"=",
"false",
";",
"if",
"(",
"getTargetMachine",
"(",
")",
".",
"Options",
".",
"UseSoftFloat",
"&&",
"Subtarget",
"->",
"inMips16HardFloat",
"(",
")",
")",
"{",
"bool",
"LookupHelper",
"=",
"true",
";",
"if",
"(",
"ExternalSymbolSDNode",
"*",
"S",
"=",
"dyn_cast",
"<",
"ExternalSymbolSDNode",
">",
"(",
"CLI",
".",
"Callee",
")",
")",
"{",
"Mips16Libcall",
"Find",
"=",
"{",
"RTLIB",
"::",
"UNKNOWN_LIBCALL",
",",
"S",
"->",
"getSymbol",
"(",
")",
"}",
";",
"if",
"(",
"std",
"::",
"binary_search",
"(",
"HardFloatLibCalls",
",",
"array_endof",
"(",
"HardFloatLibCalls",
")",
",",
"Find",
")",
")",
"LookupHelper",
"=",
"false",
";",
"else",
"{",
"Mips16IntrinsicHelperType",
"IntrinsicFind",
"=",
"{",
"S",
"->",
"getSymbol",
"(",
")",
",",
"\"\"",
"}",
";",
"if",
"(",
"std",
"::",
"binary_search",
"(",
"Mips16IntrinsicHelper",
",",
"array_endof",
"(",
"Mips16IntrinsicHelper",
")",
",",
"IntrinsicFind",
")",
")",
"{",
"const",
"Mips16IntrinsicHelperType",
"*",
"h",
"=",
"(",
"std",
"::",
"find",
"(",
"Mips16IntrinsicHelper",
",",
"array_endof",
"(",
"Mips16IntrinsicHelper",
")",
",",
"IntrinsicFind",
")",
")",
";",
"Mips16HelperFunction",
"=",
"h",
"->",
"Helper",
";",
"NeedMips16Helper",
"=",
"true",
";",
"LookupHelper",
"=",
"false",
";",
"}",
"}",
"}",
"else",
"if",
"(",
"GlobalAddressSDNode",
"*",
"G",
"=",
"dyn_cast",
"<",
"GlobalAddressSDNode",
">",
"(",
"CLI",
".",
"Callee",
")",
")",
"{",
"Mips16Libcall",
"Find",
"=",
"{",
"RTLIB",
"::",
"UNKNOWN_LIBCALL",
",",
"G",
"->",
"getGlobal",
"(",
")",
"->",
"getName",
"(",
")",
".",
"data",
"(",
")",
"}",
";",
"if",
"(",
"std",
"::",
"binary_search",
"(",
"HardFloatLibCalls",
",",
"array_endof",
"(",
"HardFloatLibCalls",
")",
",",
"Find",
")",
")",
"LookupHelper",
"=",
"false",
";",
"}",
"if",
"(",
"LookupHelper",
")",
"Mips16HelperFunction",
"=",
"getMips16HelperFunction",
"(",
"CLI",
".",
"RetTy",
",",
"CLI",
".",
"Args",
",",
"NeedMips16Helper",
")",
";",
"}",
"SDValue",
"JumpTarget",
"=",
"Callee",
";",
"if",
"(",
"IsPICCall",
"||",
"!",
"GlobalOrExternal",
")",
"{",
"unsigned",
"V0Reg",
"=",
"Mips",
"::",
"V0",
";",
"if",
"(",
"NeedMips16Helper",
")",
"{",
"RegsToPass",
".",
"push_front",
"(",
"std",
"::",
"make_pair",
"(",
"V0Reg",
",",
"Callee",
")",
")",
";",
"JumpTarget",
"=",
"DAG",
".",
"getExternalSymbol",
"(",
"Mips16HelperFunction",
",",
"getPointerTy",
"(",
")",
")",
";",
"ExternalSymbolSDNode",
"*",
"S",
"=",
"cast",
"<",
"ExternalSymbolSDNode",
">",
"(",
"JumpTarget",
")",
";",
"JumpTarget",
"=",
"getAddrGlobal",
"(",
"S",
",",
"JumpTarget",
".",
"getValueType",
"(",
")",
",",
"DAG",
",",
"MipsII",
"::",
"MO_GOT",
",",
"Chain",
",",
"FuncInfo",
"->",
"callPtrInfo",
"(",
"S",
"->",
"getSymbol",
"(",
")",
")",
")",
";",
"}",
"else",
"RegsToPass",
".",
"push_front",
"(",
"std",
"::",
"make_pair",
"(",
"(",
"unsigned",
")",
"Mips",
"::",
"T9",
",",
"Callee",
")",
")",
";",
"}",
"Ops",
".",
"push_back",
"(",
"JumpTarget",
")",
";",
"MipsTargetLowering",
"::",
"getOpndList",
"(",
"Ops",
",",
"RegsToPass",
",",
"IsPICCall",
",",
"GlobalOrExternal",
",",
"InternalLinkage",
",",
"CLI",
",",
"Callee",
",",
"Chain",
")",
";",
"}",
"</s>"
] | [
"This",
"function",
"fills",
"Ops",
",",
"which",
"is",
"the",
"list",
"of",
"operands",
"that",
"will",
"later",
"be",
"used",
"when",
"a",
"function",
"call",
"node",
"is",
"created",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"0",
"Mips",
"Mips",
"Mips",
"Mips",
"\"\"",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips::V0",
"Mips",
"Mips",
"MipsII::MO_GOT",
"Mips::T9",
"Mips"
] | Mips16ISelLowering29 | getOpndList | Mips | CPU | LLVM | 19,931 | 465 | 1 | [] |
[
"<s>",
"swap",
"(",
")",
":",
"xchgTop",
"(",
"1",
")",
"{",
"}",
"</s>"
] | [
"Provide",
"a",
"fast",
"substitute",
"to",
"std",
":",
":swap",
"<",
"Use",
">",
"that",
"also",
"works",
"with",
"less",
"standard-compliant",
"compilers",
"."
] | [
"TVM",
"1"
] | TVMStackFixup | swap | TVM | Virtual ISA | LLVM | 19,932 | 10 | 1 | [] |
[
"<s>",
"virtual",
"void",
"initializePass",
"(",
")",
"override",
"{",
"pushTTIStack",
"(",
"this",
")",
";",
"}",
"</s>"
] | [
"initializePass",
"-",
"This",
"method",
"may",
"be",
"overriden",
"by",
"immutable",
"passes",
"to",
"allow",
"them",
"to",
"perform",
"various",
"initialization",
"actions",
"they",
"require",
"."
] | [
"XCore"
] | XCoreTargetTransformInfo | initializePass | XCore | MPU | LLVM | 19,933 | 13 | 1 | [] |
[
"<s>",
"static",
"void",
"nios2_set_current_function",
"(",
"tree",
"fndecl",
")",
"{",
"tree",
"old_tree",
"=",
"(",
"nios2_previous_fndecl",
"?",
"DECL_FUNCTION_SPECIFIC_TARGET",
"(",
"nios2_previous_fndecl",
")",
":",
"NULL_TREE",
")",
";",
"tree",
"new_tree",
"=",
"(",
"fndecl",
"?",
"DECL_FUNCTION_SPECIFIC_TARGET",
"(",
"fndecl",
")",
":",
"NULL_TREE",
")",
";",
"if",
"(",
"fndecl",
"&&",
"fndecl",
"!=",
"nios2_previous_fndecl",
")",
"{",
"nios2_previous_fndecl",
"=",
"fndecl",
";",
"if",
"(",
"old_tree",
"==",
"new_tree",
")",
";",
"else",
"if",
"(",
"new_tree",
")",
"{",
"cl_target_option_restore",
"(",
"&",
"global_options",
",",
"&",
"global_options_set",
",",
"TREE_TARGET_OPTION",
"(",
"new_tree",
")",
")",
";",
"target_reinit",
"(",
")",
";",
"}",
"else",
"if",
"(",
"old_tree",
")",
"{",
"struct",
"cl_target_option",
"*",
"def",
"=",
"TREE_TARGET_OPTION",
"(",
"target_option_current_node",
")",
";",
"cl_target_option_restore",
"(",
"&",
"global_options",
",",
"&",
"global_options_set",
",",
"def",
")",
";",
"target_reinit",
"(",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Establish",
"appropriate",
"back-end",
"context",
"for",
"processing",
"the",
"function",
"FNDECL",
".",
"The",
"argument",
"might",
"be",
"NULL",
"to",
"indicate",
"processing",
"at",
"top",
"level",
",",
"outside",
"of",
"any",
"function",
"scope",
"."
] | [
"nios2"
] | nios2 | nios2_set_current_function | nios2 | MPU | GCC | 19,934 | 115 | 1 | [] |
[
"<s>",
"void",
"SIFrameLowering",
"::",
"processFunctionBeforeFrameFinalized",
"(",
"MachineFunction",
"&",
"MF",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"GCNSubtarget",
"&",
"ST",
"=",
"MF",
".",
"getSubtarget",
"<",
"GCNSubtarget",
">",
"(",
")",
";",
"const",
"SIRegisterInfo",
"*",
"TRI",
"=",
"ST",
".",
"getRegisterInfo",
"(",
")",
";",
"SIMachineFunctionInfo",
"*",
"FuncInfo",
"=",
"MF",
".",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"FuncInfo",
"->",
"removeDeadFrameIndices",
"(",
"MFI",
")",
";",
"assert",
"(",
"allSGPRSpillsAreDead",
"(",
"MF",
")",
"&&",
"\"SGPR spill should have been removed in SILowerSGPRSpills\"",
")",
";",
"if",
"(",
"!",
"allStackObjectsAreDead",
"(",
"MFI",
")",
")",
"{",
"assert",
"(",
"RS",
"&&",
"\"RegScavenger required if spilling\"",
")",
";",
"if",
"(",
"FuncInfo",
"->",
"isEntryFunction",
"(",
")",
")",
"{",
"int",
"ScavengeFI",
"=",
"MFI",
".",
"CreateFixedObject",
"(",
"TRI",
"->",
"getSpillSize",
"(",
"AMDGPU",
"::",
"SGPR_32RegClass",
")",
",",
"0",
",",
"false",
")",
";",
"RS",
"->",
"addScavengingFrameIndex",
"(",
"ScavengeFI",
")",
";",
"}",
"else",
"{",
"int",
"ScavengeFI",
"=",
"MFI",
".",
"CreateStackObject",
"(",
"TRI",
"->",
"getSpillSize",
"(",
"AMDGPU",
"::",
"SGPR_32RegClass",
")",
",",
"TRI",
"->",
"getSpillAlign",
"(",
"AMDGPU",
"::",
"SGPR_32RegClass",
")",
",",
"false",
")",
";",
"RS",
"->",
"addScavengingFrameIndex",
"(",
"ScavengeFI",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"processFunctionBeforeFrameFinalized",
"-",
"This",
"method",
"is",
"called",
"immediately",
"before",
"the",
"specified",
"function",
"'s",
"frame",
"layout",
"(",
"MF.getFrameInfo",
"(",
")",
")",
"is",
"finalized",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"SI",
"\"SGPR spill should have been removed in SILowerSGPRSpills\"",
"\"RegScavenger required if spilling\"",
"AMDGPU::SGPR_32RegClass",
"0",
"AMDGPU::SGPR_32RegClass",
"AMDGPU::SGPR_32RegClass"
] | SIFrameLowering2 | processFunctionBeforeFrameFinalized | AMDGPU | GPU | LLVM | 19,935 | 174 | 1 | [] |
[
"<s>",
"static",
"rtx",
"rs6000_emit_stack_reset",
"(",
"rtx",
"frame_reg_rtx",
",",
"HOST_WIDE_INT",
"frame_off",
",",
"unsigned",
"updt_regno",
")",
"{",
"if",
"(",
"frame_off",
"==",
"0",
"&&",
"REGNO",
"(",
"frame_reg_rtx",
")",
"==",
"updt_regno",
")",
"return",
"NULL_RTX",
";",
"rtx",
"updt_reg_rtx",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"updt_regno",
")",
";",
"if",
"(",
"DEFAULT_ABI",
"==",
"ABI_V4",
")",
"return",
"emit_insn",
"(",
"gen_stack_restore_tie",
"(",
"updt_reg_rtx",
",",
"frame_reg_rtx",
",",
"GEN_INT",
"(",
"frame_off",
")",
")",
")",
";",
"if",
"(",
"frame_off",
"!=",
"0",
")",
"return",
"emit_insn",
"(",
"gen_add3_insn",
"(",
"updt_reg_rtx",
",",
"frame_reg_rtx",
",",
"GEN_INT",
"(",
"frame_off",
")",
")",
")",
";",
"else",
"return",
"emit_move_insn",
"(",
"updt_reg_rtx",
",",
"frame_reg_rtx",
")",
";",
"return",
"NULL_RTX",
";",
"}",
"</s>"
] | [
"Emit",
"a",
"sequence",
"of",
"insns",
",",
"including",
"a",
"stack",
"tie",
"if",
"needed",
",",
"for",
"resetting",
"the",
"stack",
"pointer",
".",
"If",
"UPDT_REGNO",
"is",
"not",
"1",
",",
"then",
"do",
"n't",
"reset",
"the",
"stack",
"pointer",
",",
"but",
"move",
"the",
"base",
"of",
"the",
"frame",
"into",
"reg",
"UPDT_REGNO",
"for",
"use",
"by",
"out-of-line",
"register",
"restore",
"routines",
"."
] | [
"rs6000",
"0",
"0"
] | rs6000-logue | rs6000_emit_stack_reset | rs6000 | CPU | GCC | 19,936 | 97 | 1 | [] |
[
"<s>",
"static",
"void",
"s390_atomic_assign_expand_fenv",
"(",
"tree",
"*",
"hold",
",",
"tree",
"*",
"clear",
",",
"tree",
"*",
"update",
")",
"{",
"tree",
"sfpc",
"=",
"s390_builtin_decls",
"[",
"S390_BUILTIN_s390_sfpc",
"]",
";",
"tree",
"efpc",
"=",
"s390_builtin_decls",
"[",
"S390_BUILTIN_s390_efpc",
"]",
";",
"tree",
"call_efpc",
"=",
"build_call_expr",
"(",
"efpc",
",",
"0",
")",
";",
"tree",
"fenv_var",
"=",
"create_tmp_var_raw",
"(",
"unsigned_type_node",
")",
";",
"tree",
"old_fpc",
"=",
"build4",
"(",
"TARGET_EXPR",
",",
"unsigned_type_node",
",",
"fenv_var",
",",
"call_efpc",
",",
"NULL_TREE",
",",
"NULL_TREE",
")",
";",
"tree",
"new_fpc",
"=",
"build2",
"(",
"BIT_AND_EXPR",
",",
"unsigned_type_node",
",",
"fenv_var",
",",
"build_int_cst",
"(",
"unsigned_type_node",
",",
"~",
"(",
"FPC_DXC_MASK",
"|",
"FPC_FLAGS_MASK",
"|",
"FPC_EXCEPTION_MASK",
")",
")",
")",
";",
"tree",
"set_new_fpc",
"=",
"build_call_expr",
"(",
"sfpc",
",",
"1",
",",
"new_fpc",
")",
";",
"*",
"hold",
"=",
"build2",
"(",
"COMPOUND_EXPR",
",",
"void_type_node",
",",
"old_fpc",
",",
"set_new_fpc",
")",
";",
"new_fpc",
"=",
"build2",
"(",
"BIT_AND_EXPR",
",",
"unsigned_type_node",
",",
"call_efpc",
",",
"build_int_cst",
"(",
"unsigned_type_node",
",",
"~",
"(",
"FPC_DXC_MASK",
"|",
"FPC_FLAGS_MASK",
")",
")",
")",
";",
"*",
"clear",
"=",
"build_call_expr",
"(",
"sfpc",
",",
"1",
",",
"new_fpc",
")",
";",
"old_fpc",
"=",
"create_tmp_var_raw",
"(",
"unsigned_type_node",
")",
";",
"tree",
"store_old_fpc",
"=",
"build4",
"(",
"TARGET_EXPR",
",",
"void_type_node",
",",
"old_fpc",
",",
"call_efpc",
",",
"NULL_TREE",
",",
"NULL_TREE",
")",
";",
"set_new_fpc",
"=",
"build_call_expr",
"(",
"sfpc",
",",
"1",
",",
"fenv_var",
")",
";",
"tree",
"raise_old_except",
"=",
"build2",
"(",
"BIT_AND_EXPR",
",",
"unsigned_type_node",
",",
"old_fpc",
",",
"build_int_cst",
"(",
"unsigned_type_node",
",",
"FPC_FLAGS_MASK",
")",
")",
";",
"raise_old_except",
"=",
"build2",
"(",
"RSHIFT_EXPR",
",",
"unsigned_type_node",
",",
"raise_old_except",
",",
"build_int_cst",
"(",
"unsigned_type_node",
",",
"FPC_FLAGS_SHIFT",
")",
")",
";",
"tree",
"atomic_feraiseexcept",
"=",
"builtin_decl_implicit",
"(",
"BUILT_IN_ATOMIC_FERAISEEXCEPT",
")",
";",
"raise_old_except",
"=",
"build_call_expr",
"(",
"atomic_feraiseexcept",
",",
"1",
",",
"raise_old_except",
")",
";",
"*",
"update",
"=",
"build2",
"(",
"COMPOUND_EXPR",
",",
"void_type_node",
",",
"build2",
"(",
"COMPOUND_EXPR",
",",
"void_type_node",
",",
"store_old_fpc",
",",
"set_new_fpc",
")",
",",
"raise_old_except",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_ATOMIC_ASSIGN_EXPAND_FENV",
"hook",
"."
] | [
"s390",
"0",
"1",
"1",
"1",
"1"
] | s390 | s390_atomic_assign_expand_fenv | s390 | MPU | GCC | 19,937 | 272 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"AU",
".",
"addRequired",
"<",
"MachineFunctionAnalysis",
">",
"(",
")",
";",
"AU",
".",
"addPreserved",
"<",
"MachineFunctionAnalysis",
">",
"(",
")",
";",
"AU",
".",
"addPreserved",
"<",
"StackProtector",
">",
"(",
")",
";",
"FunctionPass",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"Hexagon"
] | HexagonOptimizeSZextends5 | getAnalysisUsage | Hexagon | DSP | LLVM | 19,938 | 45 | 1 | [] |
[
"<s>",
"rtx",
"rs6000_allocate_stack_temp",
"(",
"machine_mode",
"mode",
",",
"bool",
"offsettable_p",
",",
"bool",
"reg_reg_p",
")",
"{",
"rtx",
"stack",
"=",
"assign_stack_temp",
"(",
"mode",
",",
"GET_MODE_SIZE",
"(",
"mode",
")",
")",
";",
"rtx",
"addr",
"=",
"XEXP",
"(",
"stack",
",",
"0",
")",
";",
"int",
"strict_p",
"=",
"reload_completed",
";",
"if",
"(",
"!",
"legitimate_indirect_address_p",
"(",
"addr",
",",
"strict_p",
")",
")",
"{",
"if",
"(",
"offsettable_p",
"&&",
"!",
"rs6000_legitimate_offset_address_p",
"(",
"mode",
",",
"addr",
",",
"strict_p",
",",
"true",
")",
")",
"stack",
"=",
"replace_equiv_address",
"(",
"stack",
",",
"copy_addr_to_reg",
"(",
"addr",
")",
")",
";",
"else",
"if",
"(",
"reg_reg_p",
"&&",
"!",
"legitimate_indexed_address_p",
"(",
"addr",
",",
"strict_p",
")",
")",
"stack",
"=",
"replace_equiv_address",
"(",
"stack",
",",
"copy_addr_to_reg",
"(",
"addr",
")",
")",
";",
"}",
"return",
"stack",
";",
"}",
"</s>"
] | [
"Allocate",
"a",
"stack",
"temp",
"and",
"fixup",
"the",
"address",
"so",
"it",
"meets",
"the",
"particular",
"memory",
"requirements",
"(",
"either",
"offetable",
"or",
"REG+REG",
"addressing",
")",
"."
] | [
"rs6000",
"0"
] | rs6000 | rs6000_allocate_stack_temp | rs6000 | CPU | GCC | 19,939 | 110 | 1 | [] |
[
"<s>",
"void",
"tilegx_expand_builtin_vector_binop",
"(",
"rtx",
"(",
"*",
"gen",
")",
"(",
"rtx",
",",
"rtx",
",",
"rtx",
")",
",",
"machine_mode",
"dest_mode",
",",
"rtx",
"dest",
",",
"machine_mode",
"src_mode",
",",
"rtx",
"src0",
",",
"rtx",
"src1",
",",
"bool",
"do_src1",
")",
"{",
"dest",
"=",
"gen_lowpart",
"(",
"dest_mode",
",",
"dest",
")",
";",
"if",
"(",
"src0",
"==",
"const0_rtx",
")",
"src0",
"=",
"CONST0_RTX",
"(",
"src_mode",
")",
";",
"else",
"src0",
"=",
"gen_lowpart",
"(",
"src_mode",
",",
"src0",
")",
";",
"if",
"(",
"do_src1",
")",
"{",
"if",
"(",
"src1",
"==",
"const0_rtx",
")",
"src1",
"=",
"CONST0_RTX",
"(",
"src_mode",
")",
";",
"else",
"src1",
"=",
"gen_lowpart",
"(",
"src_mode",
",",
"src1",
")",
";",
"}",
"emit_insn",
"(",
"(",
"*",
"gen",
")",
"(",
"dest",
",",
"src0",
",",
"src1",
")",
")",
";",
"}",
"</s>"
] | [
"Expand",
"a",
"builtin",
"vector",
"binary",
"op",
",",
"by",
"calling",
"gen",
"function",
"GEN",
"with",
"operands",
"in",
"the",
"proper",
"modes",
".",
"DEST",
"is",
"converted",
"to",
"DEST_MODE",
",",
"and",
"src0",
"and",
"src1",
"(",
"if",
"DO_SRC1",
"is",
"true",
")",
"is",
"converted",
"to",
"SRC_MODE",
"."
] | [
"tilegx"
] | tilegx | tilegx_expand_builtin_vector_binop | tilegx | VLIW | GCC | 19,940 | 112 | 1 | [] |
[
"<s>",
"bool",
"ARMTargetLowering",
"::",
"isLegalAddressingMode",
"(",
"const",
"AddrMode",
"&",
"AM",
",",
"Type",
"*",
"Ty",
")",
"const",
"{",
"EVT",
"VT",
"=",
"getValueType",
"(",
"Ty",
",",
"true",
")",
";",
"if",
"(",
"!",
"isLegalAddressImmediate",
"(",
"AM",
".",
"BaseOffs",
",",
"VT",
",",
"Subtarget",
")",
")",
"return",
"false",
";",
"if",
"(",
"AM",
".",
"BaseGV",
")",
"return",
"false",
";",
"switch",
"(",
"AM",
".",
"Scale",
")",
"{",
"case",
"0",
":",
"break",
";",
"case",
"1",
":",
"if",
"(",
"Subtarget",
"->",
"isThumb1Only",
"(",
")",
")",
"return",
"false",
";",
"default",
":",
"if",
"(",
"AM",
".",
"BaseOffs",
")",
"return",
"false",
";",
"if",
"(",
"!",
"VT",
".",
"isSimple",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"Subtarget",
"->",
"isThumb2",
"(",
")",
")",
"return",
"isLegalT2ScaledAddressingMode",
"(",
"AM",
",",
"VT",
")",
";",
"int",
"Scale",
"=",
"AM",
".",
"Scale",
";",
"switch",
"(",
"VT",
".",
"getSimpleVT",
"(",
")",
".",
"SimpleTy",
")",
"{",
"default",
":",
"return",
"false",
";",
"case",
"MVT",
"::",
"i1",
":",
"case",
"MVT",
"::",
"i8",
":",
"case",
"MVT",
"::",
"i32",
":",
"if",
"(",
"Scale",
"<",
"0",
")",
"Scale",
"=",
"-",
"Scale",
";",
"if",
"(",
"Scale",
"==",
"1",
")",
"return",
"true",
";",
"return",
"isPowerOf2_32",
"(",
"Scale",
"&",
"~",
"1",
")",
";",
"case",
"MVT",
"::",
"i16",
":",
"case",
"MVT",
"::",
"i64",
":",
"if",
"(",
"(",
"(",
"unsigned",
")",
"AM",
".",
"HasBaseReg",
"+",
"Scale",
")",
"<=",
"2",
")",
"return",
"true",
";",
"return",
"false",
";",
"case",
"MVT",
"::",
"isVoid",
":",
"if",
"(",
"Scale",
"&",
"1",
")",
"return",
"false",
";",
"return",
"isPowerOf2_32",
"(",
"Scale",
")",
";",
"}",
"break",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"isLegalAddressingMode",
"-",
"Return",
"true",
"if",
"the",
"addressing",
"mode",
"represented",
"by",
"AM",
"is",
"legal",
"for",
"this",
"target",
",",
"for",
"a",
"load/store",
"of",
"the",
"specified",
"type",
"."
] | [
"ARM",
"ARM",
"0",
"1",
"MVT::i1",
"MVT::i8",
"MVT::i32",
"0",
"1",
"1",
"MVT::i16",
"MVT::i64",
"2",
"MVT::isVoid",
"1"
] | ARMISelLowering152 | isLegalAddressingMode | ARM | CPU | LLVM | 19,941 | 243 | 1 | [] |
[
"<s>",
"bool",
"RISCVInstrInfo",
"::",
"getMemOperandWithOffsetWidth",
"(",
"const",
"MachineInstr",
"&",
"LdSt",
",",
"const",
"MachineOperand",
"*",
"&",
"BaseReg",
",",
"int64_t",
"&",
"Offset",
",",
"unsigned",
"&",
"Width",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"if",
"(",
"!",
"LdSt",
".",
"mayLoadOrStore",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"LdSt",
".",
"getNumExplicitOperands",
"(",
")",
"!=",
"3",
")",
"return",
"false",
";",
"if",
"(",
"!",
"LdSt",
".",
"getOperand",
"(",
"1",
")",
".",
"isReg",
"(",
")",
"||",
"!",
"LdSt",
".",
"getOperand",
"(",
"2",
")",
".",
"isImm",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"LdSt",
".",
"hasOneMemOperand",
"(",
")",
")",
"return",
"false",
";",
"Width",
"=",
"(",
"*",
"LdSt",
".",
"memoperands_begin",
"(",
")",
")",
"->",
"getSize",
"(",
")",
";",
"BaseReg",
"=",
"&",
"LdSt",
".",
"getOperand",
"(",
"1",
")",
";",
"Offset",
"=",
"LdSt",
".",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"get",
"the",
"base",
"operand",
",",
"byte",
"offset",
"of",
"an",
"instruction",
"and",
"the",
"memory",
"width",
"."
] | [
"RI5CY",
"RISCV",
"3",
"1",
"2",
"1",
"2"
] | RISCVInstrInfo | getMemOperandWithOffsetWidth | RI5CY | CPU | LLVM | 19,942 | 139 | 1 | [] |
[
"<s>",
"void",
"SIInstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"SrcReg",
",",
"bool",
"isKill",
",",
"int",
"FrameIndex",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
".",
"getParent",
"(",
")",
";",
"SIMachineFunctionInfo",
"*",
"MFI",
"=",
"MF",
"->",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"MachineFrameInfo",
"&",
"FrameInfo",
"=",
"MF",
"->",
"getFrameInfo",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"MBB",
".",
"findDebugLoc",
"(",
"MI",
")",
";",
"unsigned",
"Size",
"=",
"FrameInfo",
".",
"getObjectSize",
"(",
"FrameIndex",
")",
";",
"unsigned",
"Align",
"=",
"FrameInfo",
".",
"getObjectAlignment",
"(",
"FrameIndex",
")",
";",
"MachinePointerInfo",
"PtrInfo",
"=",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"*",
"MF",
",",
"FrameIndex",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
"->",
"getMachineMemOperand",
"(",
"PtrInfo",
",",
"MachineMemOperand",
"::",
"MOStore",
",",
"Size",
",",
"Align",
")",
";",
"unsigned",
"SpillSize",
"=",
"TRI",
"->",
"getSpillSize",
"(",
"*",
"RC",
")",
";",
"if",
"(",
"RI",
".",
"isSGPRClass",
"(",
"RC",
")",
")",
"{",
"MFI",
"->",
"setHasSpilledSGPRs",
"(",
")",
";",
"const",
"MCInstrDesc",
"&",
"OpDesc",
"=",
"get",
"(",
"getSGPRSpillSaveOpcode",
"(",
"SpillSize",
")",
")",
";",
"if",
"(",
"TargetRegisterInfo",
"::",
"isVirtualRegister",
"(",
"SrcReg",
")",
"&&",
"SpillSize",
"==",
"4",
")",
"{",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"MRI",
".",
"constrainRegClass",
"(",
"SrcReg",
",",
"&",
"AMDGPU",
"::",
"SReg_32_XM0RegClass",
")",
";",
"}",
"MachineInstrBuilder",
"Spill",
"=",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"OpDesc",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIndex",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getScratchRSrcReg",
"(",
")",
",",
"RegState",
"::",
"Implicit",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getFrameOffsetReg",
"(",
")",
",",
"RegState",
"::",
"Implicit",
")",
";",
"FrameInfo",
".",
"setStackID",
"(",
"FrameIndex",
",",
"1",
")",
";",
"if",
"(",
"ST",
".",
"hasScalarStores",
"(",
")",
")",
"{",
"Spill",
".",
"addReg",
"(",
"AMDGPU",
"::",
"M0",
",",
"RegState",
"::",
"ImplicitDefine",
"|",
"RegState",
"::",
"Dead",
")",
";",
"}",
"return",
";",
"}",
"if",
"(",
"!",
"ST",
".",
"isVGPRSpillingEnabled",
"(",
"*",
"MF",
"->",
"getFunction",
"(",
")",
")",
")",
"{",
"LLVMContext",
"&",
"Ctx",
"=",
"MF",
"->",
"getFunction",
"(",
")",
"->",
"getContext",
"(",
")",
";",
"Ctx",
".",
"emitError",
"(",
"\"SIInstrInfo::storeRegToStackSlot - Do not know how to\"",
"\" spill register\"",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"AMDGPU",
"::",
"KILL",
")",
")",
".",
"addReg",
"(",
"SrcReg",
")",
";",
"return",
";",
"}",
"assert",
"(",
"RI",
".",
"hasVGPRs",
"(",
"RC",
")",
"&&",
"\"Only VGPR spilling expected\"",
")",
";",
"unsigned",
"Opcode",
"=",
"getVGPRSpillSaveOpcode",
"(",
"SpillSize",
")",
";",
"MFI",
"->",
"setHasSpilledVGPRs",
"(",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Opcode",
")",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIndex",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getScratchRSrcReg",
"(",
")",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getFrameOffsetReg",
"(",
")",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"}",
"</s>"
] | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"4",
"AMDGPU::SReg_32_XM0RegClass",
"1",
"AMDGPU::M0",
"\"SIInstrInfo::storeRegToStackSlot - Do not know how to\"",
"\" spill register\"",
"AMDGPU::KILL",
"\"Only VGPR spilling expected\"",
"0"
] | SIInstrInfo122 | storeRegToStackSlot | AMDGPU | GPU | LLVM | 19,943 | 452 | 1 | [] |
[
"<s>",
"unsigned",
"HexagonInstrInfo",
"::",
"isStoreToStackSlot",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"Hexagon",
"::",
"S2_storerb_io",
":",
"case",
"Hexagon",
"::",
"S2_storerh_io",
":",
"case",
"Hexagon",
"::",
"S2_storeri_io",
":",
"case",
"Hexagon",
"::",
"S2_storerd_io",
":",
"case",
"Hexagon",
"::",
"V6_vS32b_ai",
":",
"case",
"Hexagon",
"::",
"V6_vS32b_ai_128B",
":",
"case",
"Hexagon",
"::",
"V6_vS32Ub_ai",
":",
"case",
"Hexagon",
"::",
"V6_vS32Ub_ai_128B",
":",
"case",
"Hexagon",
"::",
"STriw_pred",
":",
"case",
"Hexagon",
"::",
"STriw_mod",
":",
"case",
"Hexagon",
"::",
"PS_vstorerq_ai",
":",
"case",
"Hexagon",
"::",
"PS_vstorerw_ai",
":",
"case",
"Hexagon",
"::",
"PS_vstorerq_ai_128B",
":",
"case",
"Hexagon",
"::",
"PS_vstorerw_ai_128B",
":",
"{",
"const",
"MachineOperand",
"&",
"OpFI",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
";",
"if",
"(",
"!",
"OpFI",
".",
"isFI",
"(",
")",
")",
"return",
"0",
";",
"const",
"MachineOperand",
"&",
"OpOff",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
";",
"if",
"(",
"!",
"OpOff",
".",
"isImm",
"(",
")",
"||",
"OpOff",
".",
"getImm",
"(",
")",
"!=",
"0",
")",
"return",
"0",
";",
"FrameIndex",
"=",
"OpFI",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"getReg",
"(",
")",
";",
"}",
"case",
"Hexagon",
"::",
"S2_pstorerbt_io",
":",
"case",
"Hexagon",
"::",
"S2_pstorerbf_io",
":",
"case",
"Hexagon",
"::",
"S2_pstorerht_io",
":",
"case",
"Hexagon",
"::",
"S2_pstorerhf_io",
":",
"case",
"Hexagon",
"::",
"S2_pstorerit_io",
":",
"case",
"Hexagon",
"::",
"S2_pstorerif_io",
":",
"case",
"Hexagon",
"::",
"S2_pstorerdt_io",
":",
"case",
"Hexagon",
"::",
"S2_pstorerdf_io",
":",
"{",
"const",
"MachineOperand",
"&",
"OpFI",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
";",
"if",
"(",
"!",
"OpFI",
".",
"isFI",
"(",
")",
")",
"return",
"0",
";",
"const",
"MachineOperand",
"&",
"OpOff",
"=",
"MI",
".",
"getOperand",
"(",
"2",
")",
";",
"if",
"(",
"!",
"OpOff",
".",
"isImm",
"(",
")",
"||",
"OpOff",
".",
"getImm",
"(",
")",
"!=",
"0",
")",
"return",
"0",
";",
"FrameIndex",
"=",
"OpFI",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
".",
"getOperand",
"(",
"3",
")",
".",
"getReg",
"(",
")",
";",
"}",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"isStoreToStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"store",
"to",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"source",
"reg",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon::S2_storerb_io",
"Hexagon::S2_storerh_io",
"Hexagon::S2_storeri_io",
"Hexagon::S2_storerd_io",
"Hexagon::V6_vS32b_ai",
"Hexagon::V6_vS32b_ai_128B",
"Hexagon::V6_vS32Ub_ai",
"Hexagon::V6_vS32Ub_ai_128B",
"Hexagon::STriw_pred",
"Hexagon::STriw_mod",
"Hexagon::PS_vstorerq_ai",
"Hexagon::PS_vstorerw_ai",
"Hexagon::PS_vstorerq_ai_128B",
"Hexagon::PS_vstorerw_ai_128B",
"0",
"0",
"1",
"0",
"0",
"2",
"Hexagon::S2_pstorerbt_io",
"Hexagon::S2_pstorerbf_io",
"Hexagon::S2_pstorerht_io",
"Hexagon::S2_pstorerhf_io",
"Hexagon::S2_pstorerit_io",
"Hexagon::S2_pstorerif_io",
"Hexagon::S2_pstorerdt_io",
"Hexagon::S2_pstorerdf_io",
"1",
"0",
"2",
"0",
"0",
"3",
"0"
] | HexagonInstrInfo10 | isStoreToStackSlot | Hexagon | DSP | LLVM | 19,944 | 300 | 1 | [] |
[
"<s>",
"BPFSubtarget",
"&",
"BPFSubtarget",
"::",
"initializeSubtargetDependencies",
"(",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
")",
"{",
"initializeEnvironment",
"(",
")",
";",
"initSubtargetFeatures",
"(",
"CPU",
",",
"FS",
")",
";",
"return",
"*",
"this",
";",
"}",
"</s>"
] | [
"initializeSubtargetDependencies",
"-",
"Initializes",
"using",
"a",
"CPU",
",",
"a",
"TuneCPU",
",",
"and",
"feature",
"string",
"so",
"that",
"we",
"can",
"use",
"initializer",
"lists",
"for",
"subtarget",
"initialization",
"."
] | [
"BPF",
"BPF",
"BPF"
] | BPFSubtarget4 | initializeSubtargetDependencies | BPF | Virtual ISA | LLVM | 19,945 | 29 | 1 | [] |
[
"<s>",
"static",
"Register",
"buildLoad",
"(",
"SPIRVType",
"*",
"BaseType",
",",
"Register",
"PtrVReg",
",",
"MachineIRBuilder",
"&",
"MIRBuilder",
",",
"SPIRVGlobalRegistry",
"*",
"GR",
",",
"LLT",
"llt",
",",
"Register",
"dstReg",
"=",
"Register",
"(",
"0",
")",
")",
"{",
"const",
"auto",
"MRI",
"=",
"MIRBuilder",
".",
"getMRI",
"(",
")",
";",
"if",
"(",
"!",
"dstReg",
".",
"isValid",
"(",
")",
")",
"{",
"dstReg",
"=",
"MRI",
"->",
"createVirtualRegister",
"(",
"&",
"SPIRV",
"::",
"IDRegClass",
")",
";",
"MRI",
"->",
"setType",
"(",
"dstReg",
",",
"LLT",
"::",
"scalar",
"(",
"32",
")",
")",
";",
"GR",
"->",
"assignSPIRVTypeToVReg",
"(",
"BaseType",
",",
"dstReg",
",",
"MIRBuilder",
".",
"getMF",
"(",
")",
")",
";",
"}",
"auto",
"PtrInfo",
"=",
"MachinePointerInfo",
"(",
")",
";",
"MIRBuilder",
".",
"buildLoad",
"(",
"dstReg",
",",
"PtrVReg",
",",
"PtrInfo",
",",
"Align",
"(",
")",
")",
";",
"return",
"dstReg",
";",
"}",
"</s>"
] | [
"Build",
"and",
"insert",
"a",
"G_LOAD",
"instruction",
",",
"while",
"constructing",
"the",
"MachineMemOperand",
"."
] | [
"SPIRV",
"SPIRV",
"SPIRV",
"0",
"SPIRV::IDRegClass",
"32",
"SPIRV"
] | SPIRVOpenCLBIFs | buildLoad | SPIRV | Virtual ISA | LLVM | 19,946 | 119 | 1 | [] |
[
"<s>",
"ScheduleHazardRecognizer",
"::",
"HazardType",
"PPCHazardRecognizer970",
"::",
"getHazardType",
"(",
"SUnit",
"*",
"SU",
")",
"{",
"const",
"SDNode",
"*",
"Node",
"=",
"SU",
"->",
"getNode",
"(",
")",
"->",
"getFlaggedMachineNode",
"(",
")",
";",
"bool",
"isFirst",
",",
"isSingle",
",",
"isCracked",
",",
"isLoad",
",",
"isStore",
";",
"PPCII",
"::",
"PPC970_Unit",
"InstrType",
"=",
"GetInstrType",
"(",
"Node",
"->",
"getOpcode",
"(",
")",
",",
"isFirst",
",",
"isSingle",
",",
"isCracked",
",",
"isLoad",
",",
"isStore",
")",
";",
"if",
"(",
"InstrType",
"==",
"PPCII",
"::",
"PPC970_Pseudo",
")",
"return",
"NoHazard",
";",
"unsigned",
"Opcode",
"=",
"Node",
"->",
"getMachineOpcode",
"(",
")",
";",
"if",
"(",
"NumIssued",
"!=",
"0",
"&&",
"(",
"isFirst",
"||",
"isSingle",
")",
")",
"return",
"Hazard",
";",
"if",
"(",
"isCracked",
"&&",
"NumIssued",
">",
"2",
")",
"return",
"Hazard",
";",
"switch",
"(",
"InstrType",
")",
"{",
"default",
":",
"assert",
"(",
"0",
"&&",
"\"Unknown instruction type!\"",
")",
";",
"case",
"PPCII",
"::",
"PPC970_FXU",
":",
"case",
"PPCII",
"::",
"PPC970_LSU",
":",
"case",
"PPCII",
"::",
"PPC970_FPU",
":",
"case",
"PPCII",
"::",
"PPC970_VALU",
":",
"case",
"PPCII",
"::",
"PPC970_VPERM",
":",
"if",
"(",
"NumIssued",
"==",
"4",
")",
"return",
"Hazard",
";",
"break",
";",
"case",
"PPCII",
"::",
"PPC970_CRU",
":",
"if",
"(",
"NumIssued",
">=",
"2",
")",
"return",
"Hazard",
";",
"break",
";",
"case",
"PPCII",
"::",
"PPC970_BRU",
":",
"break",
";",
"}",
"if",
"(",
"HasCTRSet",
"&&",
"(",
"Opcode",
"==",
"PPC",
"::",
"BCTRL_Macho",
"||",
"Opcode",
"==",
"PPC",
"::",
"BCTRL_ELF",
")",
")",
"return",
"NoopHazard",
";",
"if",
"(",
"isLoad",
"&&",
"NumStores",
")",
"{",
"unsigned",
"LoadSize",
";",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"assert",
"(",
"0",
"&&",
"\"Unknown load!\"",
")",
";",
"case",
"PPC",
"::",
"LBZ",
":",
"case",
"PPC",
"::",
"LBZU",
":",
"case",
"PPC",
"::",
"LBZX",
":",
"case",
"PPC",
"::",
"LBZ8",
":",
"case",
"PPC",
"::",
"LBZU8",
":",
"case",
"PPC",
"::",
"LBZX8",
":",
"case",
"PPC",
"::",
"LVEBX",
":",
"LoadSize",
"=",
"1",
";",
"break",
";",
"case",
"PPC",
"::",
"LHA",
":",
"case",
"PPC",
"::",
"LHAU",
":",
"case",
"PPC",
"::",
"LHAX",
":",
"case",
"PPC",
"::",
"LHZ",
":",
"case",
"PPC",
"::",
"LHZU",
":",
"case",
"PPC",
"::",
"LHZX",
":",
"case",
"PPC",
"::",
"LVEHX",
":",
"case",
"PPC",
"::",
"LHBRX",
":",
"case",
"PPC",
"::",
"LHA8",
":",
"case",
"PPC",
"::",
"LHAU8",
":",
"case",
"PPC",
"::",
"LHAX8",
":",
"case",
"PPC",
"::",
"LHZ8",
":",
"case",
"PPC",
"::",
"LHZU8",
":",
"case",
"PPC",
"::",
"LHZX8",
":",
"LoadSize",
"=",
"2",
";",
"break",
";",
"case",
"PPC",
"::",
"LFS",
":",
"case",
"PPC",
"::",
"LFSU",
":",
"case",
"PPC",
"::",
"LFSX",
":",
"case",
"PPC",
"::",
"LWZ",
":",
"case",
"PPC",
"::",
"LWZU",
":",
"case",
"PPC",
"::",
"LWZX",
":",
"case",
"PPC",
"::",
"LWA",
":",
"case",
"PPC",
"::",
"LWAX",
":",
"case",
"PPC",
"::",
"LVEWX",
":",
"case",
"PPC",
"::",
"LWBRX",
":",
"case",
"PPC",
"::",
"LWZ8",
":",
"case",
"PPC",
"::",
"LWZX8",
":",
"LoadSize",
"=",
"4",
";",
"break",
";",
"case",
"PPC",
"::",
"LFD",
":",
"case",
"PPC",
"::",
"LFDU",
":",
"case",
"PPC",
"::",
"LFDX",
":",
"case",
"PPC",
"::",
"LD",
":",
"case",
"PPC",
"::",
"LDU",
":",
"case",
"PPC",
"::",
"LDX",
":",
"LoadSize",
"=",
"8",
";",
"break",
";",
"case",
"PPC",
"::",
"LVX",
":",
"case",
"PPC",
"::",
"LVXL",
":",
"LoadSize",
"=",
"16",
";",
"break",
";",
"}",
"if",
"(",
"isLoadOfStoredAddress",
"(",
"LoadSize",
",",
"Node",
"->",
"getOperand",
"(",
"0",
")",
",",
"Node",
"->",
"getOperand",
"(",
"1",
")",
")",
")",
"return",
"NoopHazard",
";",
"}",
"return",
"NoHazard",
";",
"}",
"</s>"
] | [
"getHazardType",
"-",
"Return",
"the",
"hazard",
"type",
"of",
"emitting",
"this",
"node",
"."
] | [
"PowerPC",
"PPC",
"PPCII::PPC970_Unit",
"PPCII::PPC970_Pseudo",
"0",
"2",
"0",
"\"Unknown instruction type!\"",
"PPCII::PPC970_FXU",
"PPCII::PPC970_LSU",
"PPCII::PPC970_FPU",
"PPCII::PPC970_VALU",
"PPCII::PPC970_VPERM",
"4",
"PPCII::PPC970_CRU",
"2",
"PPCII::PPC970_BRU",
"PPC::BCTRL_Macho",
"PPC::BCTRL_ELF",
"0",
"\"Unknown load!\"",
"PPC::LBZ",
"PPC::LBZU",
"PPC::LBZX",
"PPC::LBZ8",
"PPC::LBZU8",
"PPC::LBZX8",
"PPC::LVEBX",
"1",
"PPC::LHA",
"PPC::LHAU",
"PPC::LHAX",
"PPC::LHZ",
"PPC::LHZU",
"PPC::LHZX",
"PPC::LVEHX",
"PPC::LHBRX",
"PPC::LHA8",
"PPC::LHAU8",
"PPC::LHAX8",
"PPC::LHZ8",
"PPC::LHZU8",
"PPC::LHZX8",
"2",
"PPC::LFS",
"PPC::LFSU",
"PPC::LFSX",
"PPC::LWZ",
"PPC::LWZU",
"PPC::LWZX",
"PPC::LWA",
"PPC::LWAX",
"PPC::LVEWX",
"PPC::LWBRX",
"PPC::LWZ8",
"PPC::LWZX8",
"4",
"PPC::LFD",
"PPC::LFDU",
"PPC::LFDX",
"PPC::LD",
"PPC::LDU",
"PPC::LDX",
"8",
"PPC::LVX",
"PPC::LVXL",
"16",
"0",
"1"
] | PPCHazardRecognizers19 | getHazardType | PowerPC | CPU | LLVM | 19,947 | 492 | 1 | [] |
[
"<s>",
"bool",
"RISCVMCExpr",
"::",
"evaluateAsConstant",
"(",
"int64_t",
"&",
"Res",
")",
"const",
"{",
"MCValue",
"Value",
";",
"if",
"(",
"Kind",
"==",
"VK_RISCV_PCREL_HI",
"||",
"Kind",
"==",
"VK_RISCV_PCREL_LO",
"||",
"Kind",
"==",
"VK_RISCV_CALL",
")",
"return",
"false",
";",
"if",
"(",
"!",
"getSubExpr",
"(",
")",
"->",
"evaluateAsRelocatable",
"(",
"Value",
",",
"nullptr",
",",
"nullptr",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"Value",
".",
"isAbsolute",
"(",
")",
")",
"return",
"false",
";",
"Res",
"=",
"evaluateAsInt64",
"(",
"Value",
".",
"getConstant",
"(",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Evaluates",
"the",
"fixup",
"as",
"a",
"constant",
"value",
"."
] | [
"RISCV",
"RISCV",
"RISCV",
"RISCV",
"RISCV"
] | RISCVMCExpr (2) | evaluateAsConstant | RISCV | CPU | LLVM | 19,948 | 77 | 1 | [] |
[
"<s>",
"bool",
"SIInstrInfo",
"::",
"isLegalRegOperand",
"(",
"const",
"MachineRegisterInfo",
"&",
"MRI",
",",
"const",
"MCOperandInfo",
"&",
"OpInfo",
",",
"const",
"MachineOperand",
"&",
"MO",
")",
"const",
"{",
"if",
"(",
"!",
"MO",
".",
"isReg",
"(",
")",
")",
"return",
"false",
";",
"Register",
"Reg",
"=",
"MO",
".",
"getReg",
"(",
")",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"Register",
"::",
"isVirtualRegister",
"(",
"Reg",
")",
"?",
"MRI",
".",
"getRegClass",
"(",
"Reg",
")",
":",
"RI",
".",
"getPhysRegClass",
"(",
"Reg",
")",
";",
"const",
"SIRegisterInfo",
"*",
"TRI",
"=",
"static_cast",
"<",
"const",
"SIRegisterInfo",
"*",
">",
"(",
"MRI",
".",
"getTargetRegisterInfo",
"(",
")",
")",
";",
"RC",
"=",
"TRI",
"->",
"getSubRegClass",
"(",
"RC",
",",
"MO",
".",
"getSubReg",
"(",
")",
")",
";",
"return",
"RI",
".",
"getCommonSubClass",
"(",
"RC",
",",
"RI",
".",
"getRegClass",
"(",
"OpInfo",
".",
"RegClass",
")",
")",
"==",
"RC",
";",
"}",
"</s>"
] | [
"Check",
"if",
"MO",
"(",
"a",
"register",
"operand",
")",
"is",
"a",
"legal",
"register",
"for",
"the",
"given",
"operand",
"description",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI"
] | SIInstrInfo131 | isLegalRegOperand | AMDGPU | GPU | LLVM | 19,949 | 123 | 1 | [] |
[
"<s>",
"void",
"ELFAArch64AsmBackend",
"::",
"applyFixup",
"(",
"const",
"MCFixup",
"&",
"Fixup",
",",
"char",
"*",
"Data",
",",
"unsigned",
"DataSize",
",",
"uint64_t",
"Value",
",",
"bool",
"IsPCRel",
")",
"const",
"{",
"if",
"(",
"!",
"IsLittleEndian",
"&&",
"Fixup",
".",
"getKind",
"(",
")",
"==",
"FK_Data_4",
")",
"{",
"const",
"MCSection",
"*",
"Sec",
"=",
"Fixup",
".",
"getValue",
"(",
")",
"->",
"FindAssociatedSection",
"(",
")",
";",
"const",
"MCSectionELF",
"*",
"SecELF",
"=",
"dyn_cast_or_null",
"<",
"const",
"MCSectionELF",
">",
"(",
"Sec",
")",
";",
"if",
"(",
"SecELF",
"&&",
"SecELF",
"->",
"getSectionName",
"(",
")",
"==",
"\".eh_frame\"",
")",
"Value",
"=",
"ByteSwap_32",
"(",
"unsigned",
"(",
"Value",
")",
")",
";",
"}",
"AArch64AsmBackend",
"::",
"applyFixup",
"(",
"Fixup",
",",
"Data",
",",
"DataSize",
",",
"Value",
",",
"IsPCRel",
")",
";",
"}",
"</s>"
] | [
"Apply",
"the",
"Value",
"for",
"given",
"Fixup",
"into",
"the",
"provided",
"data",
"fragment",
",",
"at",
"the",
"offset",
"specified",
"by",
"the",
"fixup",
"and",
"following",
"the",
"fixup",
"kind",
"as",
"appropriate",
"."
] | [
"AArch64",
"AArch64",
"\".eh_frame\"",
"AArch64"
] | AArch64AsmBackend14 | applyFixup | AArch64 | CPU | LLVM | 19,950 | 107 | 1 | [] |
[
"<s>",
"int",
"mcore_expand_insv",
"(",
"rtx",
"operands",
"[",
"]",
")",
"{",
"int",
"width",
"=",
"INTVAL",
"(",
"operands",
"[",
"1",
"]",
")",
";",
"int",
"posn",
"=",
"INTVAL",
"(",
"operands",
"[",
"2",
"]",
")",
";",
"int",
"mask",
";",
"rtx",
"mreg",
",",
"sreg",
",",
"ereg",
";",
"if",
"(",
"width",
"==",
"1",
"&&",
"GET_CODE",
"(",
"operands",
"[",
"3",
"]",
")",
"==",
"CONST_INT",
")",
"{",
"if",
"(",
"(",
"INTVAL",
"(",
"operands",
"[",
"3",
"]",
")",
"&",
"1",
")",
"==",
"0",
")",
"{",
"mask",
"=",
"~",
"(",
"1",
"<<",
"posn",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"SImode",
",",
"operands",
"[",
"0",
"]",
",",
"gen_rtx_AND",
"(",
"SImode",
",",
"operands",
"[",
"0",
"]",
",",
"GEN_INT",
"(",
"mask",
")",
")",
")",
")",
";",
"}",
"else",
"{",
"mask",
"=",
"1",
"<<",
"posn",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"SImode",
",",
"operands",
"[",
"0",
"]",
",",
"gen_rtx_IOR",
"(",
"SImode",
",",
"operands",
"[",
"0",
"]",
",",
"GEN_INT",
"(",
"mask",
")",
")",
")",
")",
";",
"}",
"return",
"1",
";",
"}",
"if",
"(",
"!",
"TARGET_W_FIELD",
")",
"return",
"0",
";",
"if",
"(",
"width",
"==",
"8",
"&&",
"posn",
"%",
"8",
"==",
"0",
")",
"return",
"0",
";",
"if",
"(",
"width",
"==",
"16",
"&&",
"posn",
"%",
"16",
"==",
"0",
")",
"return",
"0",
";",
"if",
"(",
"GET_CODE",
"(",
"operands",
"[",
"3",
"]",
")",
"==",
"CONST_INT",
"&&",
"INTVAL",
"(",
"operands",
"[",
"3",
"]",
")",
"==",
"(",
"(",
"1",
"<<",
"width",
")",
"-",
"1",
")",
")",
"{",
"mreg",
"=",
"force_reg",
"(",
"SImode",
",",
"GEN_INT",
"(",
"INTVAL",
"(",
"operands",
"[",
"3",
"]",
")",
"<<",
"posn",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"SImode",
",",
"operands",
"[",
"0",
"]",
",",
"gen_rtx_IOR",
"(",
"SImode",
",",
"operands",
"[",
"0",
"]",
",",
"mreg",
")",
")",
")",
";",
"return",
"1",
";",
"}",
"mreg",
"=",
"force_reg",
"(",
"SImode",
",",
"GEN_INT",
"(",
"~",
"(",
"(",
"(",
"1",
"<<",
"width",
")",
"-",
"1",
")",
"<<",
"posn",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"SImode",
",",
"operands",
"[",
"0",
"]",
",",
"gen_rtx_AND",
"(",
"SImode",
",",
"operands",
"[",
"0",
"]",
",",
"mreg",
")",
")",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"operands",
"[",
"3",
"]",
")",
"==",
"CONST_INT",
"&&",
"INTVAL",
"(",
"operands",
"[",
"3",
"]",
")",
"==",
"0",
")",
"return",
"1",
";",
"sreg",
"=",
"copy_to_mode_reg",
"(",
"SImode",
",",
"operands",
"[",
"3",
"]",
")",
";",
"if",
"(",
"width",
"+",
"posn",
"!=",
"(",
"int",
")",
"GET_MODE_SIZE",
"(",
"SImode",
")",
")",
"{",
"ereg",
"=",
"force_reg",
"(",
"SImode",
",",
"GEN_INT",
"(",
"(",
"1",
"<<",
"width",
")",
"-",
"1",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"SImode",
",",
"sreg",
",",
"gen_rtx_AND",
"(",
"SImode",
",",
"sreg",
",",
"ereg",
")",
")",
")",
";",
"}",
"if",
"(",
"posn",
"!=",
"0",
")",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"SImode",
",",
"sreg",
",",
"gen_rtx_ASHIFT",
"(",
"SImode",
",",
"sreg",
",",
"GEN_INT",
"(",
"posn",
")",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"SImode",
",",
"operands",
"[",
"0",
"]",
",",
"gen_rtx_IOR",
"(",
"SImode",
",",
"operands",
"[",
"0",
"]",
",",
"sreg",
")",
")",
")",
";",
"return",
"1",
";",
"}",
"</s>"
] | [
"Expand",
"insert",
"bit",
"field",
".",
"BRC"
] | [
"mcore",
"1",
"2",
"1",
"3",
"3",
"1",
"0",
"1",
"0",
"0",
"1",
"0",
"0",
"1",
"0",
"8",
"8",
"0",
"0",
"16",
"16",
"0",
"0",
"3",
"3",
"1",
"1",
"3",
"0",
"0",
"1",
"1",
"1",
"0",
"0",
"3",
"3",
"0",
"1",
"3",
"1",
"1",
"0",
"0",
"0",
"1"
] | mcore4 | mcore_expand_insv | mcore | MPU | GCC | 19,951 | 469 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"AMDGPU Promote Alloca\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"AMDGPU",
"\"AMDGPU Promote Alloca\""
] | AMDGPUPromoteAlloca (2) | getPassName | AMDGPU | GPU | LLVM | 19,952 | 13 | 1 | [] |
[
"<s>",
"bool",
"MSP430AsmPrinter",
"::",
"PrintAsmOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNo",
",",
"const",
"char",
"*",
"ExtraCode",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"if",
"(",
"ExtraCode",
"&&",
"ExtraCode",
"[",
"0",
"]",
")",
"return",
"AsmPrinter",
"::",
"PrintAsmOperand",
"(",
"MI",
",",
"OpNo",
",",
"ExtraCode",
",",
"O",
")",
";",
"printOperand",
"(",
"MI",
",",
"OpNo",
",",
"O",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"PrintAsmOperand",
"-",
"Print",
"out",
"an",
"operand",
"for",
"an",
"inline",
"asm",
"expression",
"."
] | [
"MSP430",
"MSP430",
"0"
] | MSP430AsmPrinter (2)1 | PrintAsmOperand | MSP430 | MPU | LLVM | 19,953 | 59 | 1 | [] |
[
"<s>",
"const",
"MCPhysReg",
"*",
"X86RegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"assert",
"(",
"MF",
"&&",
"\"MachineFunction required\"",
")",
";",
"const",
"X86Subtarget",
"&",
"Subtarget",
"=",
"MF",
"->",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"const",
"Function",
"&",
"F",
"=",
"MF",
"->",
"getFunction",
"(",
")",
";",
"bool",
"HasSSE",
"=",
"Subtarget",
".",
"hasSSE1",
"(",
")",
";",
"bool",
"HasAVX",
"=",
"Subtarget",
".",
"hasAVX",
"(",
")",
";",
"bool",
"HasAVX512",
"=",
"Subtarget",
".",
"hasAVX512",
"(",
")",
";",
"bool",
"CallsEHReturn",
"=",
"MF",
"->",
"callsEHReturn",
"(",
")",
";",
"CallingConv",
"::",
"ID",
"CC",
"=",
"F",
".",
"getCallingConv",
"(",
")",
";",
"if",
"(",
"MF",
"->",
"getFunction",
"(",
")",
".",
"hasFnAttribute",
"(",
"\"no_caller_saved_registers\"",
")",
")",
"CC",
"=",
"CallingConv",
"::",
"X86_INTR",
";",
"switch",
"(",
"CC",
")",
"{",
"case",
"CallingConv",
"::",
"GHC",
":",
"case",
"CallingConv",
"::",
"HiPE",
":",
"return",
"CSR_NoRegs_SaveList",
";",
"case",
"CallingConv",
"::",
"AnyReg",
":",
"if",
"(",
"HasAVX",
")",
"return",
"CSR_64_AllRegs_AVX_SaveList",
";",
"return",
"CSR_64_AllRegs_SaveList",
";",
"case",
"CallingConv",
"::",
"PreserveMost",
":",
"return",
"CSR_64_RT_MostRegs_SaveList",
";",
"case",
"CallingConv",
"::",
"PreserveAll",
":",
"if",
"(",
"HasAVX",
")",
"return",
"CSR_64_RT_AllRegs_AVX_SaveList",
";",
"return",
"CSR_64_RT_AllRegs_SaveList",
";",
"case",
"CallingConv",
"::",
"CXX_FAST_TLS",
":",
"if",
"(",
"Is64Bit",
")",
"return",
"MF",
"->",
"getInfo",
"<",
"X86MachineFunctionInfo",
">",
"(",
")",
"->",
"isSplitCSR",
"(",
")",
"?",
"CSR_64_CXX_TLS_Darwin_PE_SaveList",
":",
"CSR_64_TLS_Darwin_SaveList",
";",
"break",
";",
"case",
"CallingConv",
"::",
"Intel_OCL_BI",
":",
"{",
"if",
"(",
"HasAVX512",
"&&",
"IsWin64",
")",
"return",
"CSR_Win64_Intel_OCL_BI_AVX512_SaveList",
";",
"if",
"(",
"HasAVX512",
"&&",
"Is64Bit",
")",
"return",
"CSR_64_Intel_OCL_BI_AVX512_SaveList",
";",
"if",
"(",
"HasAVX",
"&&",
"IsWin64",
")",
"return",
"CSR_Win64_Intel_OCL_BI_AVX_SaveList",
";",
"if",
"(",
"HasAVX",
"&&",
"Is64Bit",
")",
"return",
"CSR_64_Intel_OCL_BI_AVX_SaveList",
";",
"if",
"(",
"!",
"HasAVX",
"&&",
"!",
"IsWin64",
"&&",
"Is64Bit",
")",
"return",
"CSR_64_Intel_OCL_BI_SaveList",
";",
"break",
";",
"}",
"case",
"CallingConv",
"::",
"HHVM",
":",
"return",
"CSR_64_HHVM_SaveList",
";",
"case",
"CallingConv",
"::",
"X86_RegCall",
":",
"if",
"(",
"Is64Bit",
")",
"{",
"if",
"(",
"IsWin64",
")",
"{",
"return",
"(",
"HasSSE",
"?",
"CSR_Win64_RegCall_SaveList",
":",
"CSR_Win64_RegCall_NoSSE_SaveList",
")",
";",
"}",
"else",
"{",
"return",
"(",
"HasSSE",
"?",
"CSR_SysV64_RegCall_SaveList",
":",
"CSR_SysV64_RegCall_NoSSE_SaveList",
")",
";",
"}",
"}",
"else",
"{",
"return",
"(",
"HasSSE",
"?",
"CSR_32_RegCall_SaveList",
":",
"CSR_32_RegCall_NoSSE_SaveList",
")",
";",
"}",
"case",
"CallingConv",
"::",
"Cold",
":",
"if",
"(",
"Is64Bit",
")",
"return",
"CSR_64_MostRegs_SaveList",
";",
"break",
";",
"case",
"CallingConv",
"::",
"Win64",
":",
"if",
"(",
"!",
"HasSSE",
")",
"return",
"CSR_Win64_NoSSE_SaveList",
";",
"return",
"CSR_Win64_SaveList",
";",
"case",
"CallingConv",
"::",
"X86_64_SysV",
":",
"if",
"(",
"CallsEHReturn",
")",
"return",
"CSR_64EHRet_SaveList",
";",
"return",
"CSR_64_SaveList",
";",
"case",
"CallingConv",
"::",
"X86_INTR",
":",
"if",
"(",
"Is64Bit",
")",
"{",
"if",
"(",
"HasAVX512",
")",
"return",
"CSR_64_AllRegs_AVX512_SaveList",
";",
"if",
"(",
"HasAVX",
")",
"return",
"CSR_64_AllRegs_AVX_SaveList",
";",
"if",
"(",
"HasSSE",
")",
"return",
"CSR_64_AllRegs_SaveList",
";",
"return",
"CSR_64_AllRegs_NoSSE_SaveList",
";",
"}",
"else",
"{",
"if",
"(",
"HasAVX512",
")",
"return",
"CSR_32_AllRegs_AVX512_SaveList",
";",
"if",
"(",
"HasAVX",
")",
"return",
"CSR_32_AllRegs_AVX_SaveList",
";",
"if",
"(",
"HasSSE",
")",
"return",
"CSR_32_AllRegs_SSE_SaveList",
";",
"return",
"CSR_32_AllRegs_SaveList",
";",
"}",
"default",
":",
"break",
";",
"}",
"if",
"(",
"Is64Bit",
")",
"{",
"bool",
"IsSwiftCC",
"=",
"Subtarget",
".",
"getTargetLowering",
"(",
")",
"->",
"supportSwiftError",
"(",
")",
"&&",
"F",
".",
"getAttributes",
"(",
")",
".",
"hasAttrSomewhere",
"(",
"Attribute",
"::",
"SwiftError",
")",
";",
"if",
"(",
"IsSwiftCC",
")",
"return",
"IsWin64",
"?",
"CSR_Win64_SwiftError_SaveList",
":",
"CSR_64_SwiftError_SaveList",
";",
"if",
"(",
"IsWin64",
")",
"return",
"HasSSE",
"?",
"CSR_Win64_SaveList",
":",
"CSR_Win64_NoSSE_SaveList",
";",
"if",
"(",
"CallsEHReturn",
")",
"return",
"CSR_64EHRet_SaveList",
";",
"return",
"CSR_64_SaveList",
";",
"}",
"return",
"CallsEHReturn",
"?",
"CSR_32EHRet_SaveList",
":",
"CSR_32_SaveList",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"X86",
"X86",
"\"MachineFunction required\"",
"X86",
"X86",
"\"no_caller_saved_registers\"",
"X86",
"X86",
"X86",
"X86",
"X86"
] | X86RegisterInfo (2)2 | getCalleeSavedRegs | X86 | CPU | LLVM | 19,954 | 497 | 1 | [] |
[
"<s>",
"static",
"void",
"c6x_mark_reg_written",
"(",
"rtx",
"reg",
",",
"int",
"cycles",
")",
"{",
"unsigned",
"regno",
"=",
"REGNO",
"(",
"reg",
")",
";",
"unsigned",
"nregs",
"=",
"hard_regno_nregs",
"[",
"regno",
"]",
"[",
"GET_MODE",
"(",
"reg",
")",
"]",
";",
"while",
"(",
"nregs",
"--",
">",
"0",
")",
"ss",
".",
"reg_set_in_cycle",
"[",
"regno",
"+",
"nregs",
"]",
"=",
"cycles",
";",
"}",
"</s>"
] | [
"Note",
"that",
"register",
"REG",
"is",
"written",
"in",
"cycle",
"CYCLES",
"."
] | [
"c6x",
"0"
] | c6x2 | c6x_mark_reg_written | c6x | VLIW | GCC | 19,955 | 52 | 1 | [] |
[
"<s>",
"bool",
"NVPTXPrologEpilogPass",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"const",
"TargetSubtargetInfo",
"&",
"STI",
"=",
"MF",
".",
"getSubtarget",
"(",
")",
";",
"const",
"TargetFrameLowering",
"&",
"TFI",
"=",
"*",
"STI",
".",
"getFrameLowering",
"(",
")",
";",
"const",
"TargetRegisterInfo",
"&",
"TRI",
"=",
"*",
"STI",
".",
"getRegisterInfo",
"(",
")",
";",
"bool",
"Modified",
"=",
"false",
";",
"calculateFrameObjectOffsets",
"(",
"MF",
")",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"MBB",
":",
"MF",
")",
"{",
"for",
"(",
"MachineInstr",
"&",
"MI",
":",
"MBB",
")",
"{",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"MI",
".",
"getNumOperands",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"if",
"(",
"!",
"MI",
".",
"getOperand",
"(",
"i",
")",
".",
"isFI",
"(",
")",
")",
"continue",
";",
"if",
"(",
"MI",
".",
"isDebugValue",
"(",
")",
")",
"{",
"assert",
"(",
"i",
"==",
"0",
"&&",
"\"Frame indices can only appear as the first \"",
"\"operand of a DBG_VALUE machine instruction\"",
")",
";",
"Register",
"Reg",
";",
"int64_t",
"Offset",
"=",
"TFI",
".",
"getFrameIndexReference",
"(",
"MF",
",",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getIndex",
"(",
")",
",",
"Reg",
")",
".",
"getFixed",
"(",
")",
";",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"ChangeToRegister",
"(",
"Reg",
",",
"false",
")",
";",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"setIsDebug",
"(",
")",
";",
"auto",
"*",
"DIExpr",
"=",
"DIExpression",
"::",
"prepend",
"(",
"MI",
".",
"getDebugExpression",
"(",
")",
",",
"DIExpression",
"::",
"ApplyOffset",
",",
"Offset",
")",
";",
"MI",
".",
"getDebugExpressionOp",
"(",
")",
".",
"setMetadata",
"(",
"DIExpr",
")",
";",
"continue",
";",
"}",
"TRI",
".",
"eliminateFrameIndex",
"(",
"MI",
",",
"0",
",",
"i",
",",
"nullptr",
")",
";",
"Modified",
"=",
"true",
";",
"}",
"}",
"}",
"TFI",
".",
"emitPrologue",
"(",
"MF",
",",
"MF",
".",
"front",
"(",
")",
")",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"I",
"=",
"MF",
".",
"begin",
"(",
")",
",",
"E",
"=",
"MF",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"if",
"(",
"I",
"->",
"isReturnBlock",
"(",
")",
")",
"TFI",
".",
"emitEpilogue",
"(",
"MF",
",",
"*",
"I",
")",
";",
"}",
"return",
"Modified",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"NVPTX",
"NVPTX",
"0",
"0",
"\"Frame indices can only appear as the first \"",
"\"operand of a DBG_VALUE machine instruction\"",
"0",
"0",
"0",
"0"
] | NVPTXPrologEpilogPass14 | runOnMachineFunction | NVPTX | GPU | LLVM | 19,956 | 306 | 1 | [] |
[
"<s>",
"const",
"RegisterBank",
"&",
"MipsRegisterBankInfo",
"::",
"getRegBankFromRegClass",
"(",
"const",
"TargetRegisterClass",
"&",
"RC",
")",
"const",
"{",
"using",
"namespace",
"Mips",
";",
"switch",
"(",
"RC",
".",
"getID",
"(",
")",
")",
"{",
"case",
"Mips",
"::",
"GPR32RegClassID",
":",
"case",
"Mips",
"::",
"CPU16Regs_and_GPRMM16ZeroRegClassID",
":",
"case",
"Mips",
"::",
"GPRMM16MovePPairFirstRegClassID",
":",
"case",
"Mips",
"::",
"CPU16Regs_and_GPRMM16MovePPairSecondRegClassID",
":",
"case",
"Mips",
"::",
"GPRMM16MoveP_and_CPU16Regs_and_GPRMM16ZeroRegClassID",
":",
"case",
"Mips",
"::",
"GPRMM16MovePPairFirst_and_GPRMM16MovePPairSecondRegClassID",
":",
"case",
"Mips",
"::",
"SP32RegClassID",
":",
"case",
"Mips",
"::",
"GP32RegClassID",
":",
"return",
"getRegBank",
"(",
"Mips",
"::",
"GPRBRegBankID",
")",
";",
"case",
"Mips",
"::",
"FGRCCRegClassID",
":",
"case",
"Mips",
"::",
"FGR32RegClassID",
":",
"case",
"Mips",
"::",
"FGR64RegClassID",
":",
"case",
"Mips",
"::",
"AFGR64RegClassID",
":",
"case",
"Mips",
"::",
"MSA128BRegClassID",
":",
"case",
"Mips",
"::",
"MSA128HRegClassID",
":",
"case",
"Mips",
"::",
"MSA128WRegClassID",
":",
"case",
"Mips",
"::",
"MSA128DRegClassID",
":",
"return",
"getRegBank",
"(",
"Mips",
"::",
"FPRBRegBankID",
")",
";",
"default",
":",
"llvm_unreachable",
"(",
"\"Register class not supported\"",
")",
";",
"}",
"}",
"</s>"
] | [
"Get",
"a",
"register",
"bank",
"that",
"covers",
"RC",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips::GPR32RegClassID",
"Mips::CPU16Regs_and_GPRMM16ZeroRegClassID",
"Mips::GPRMM16MovePPairFirstRegClassID",
"Mips::CPU16Regs_and_GPRMM16MovePPairSecondRegClassID",
"Mips::GPRMM16MoveP_and_CPU16Regs_and_GPRMM16ZeroRegClassID",
"Mips::GPRMM16MovePPairFirst_and_GPRMM16MovePPairSecondRegClassID",
"Mips::SP32RegClassID",
"Mips::GP32RegClassID",
"Mips::GPRBRegBankID",
"Mips::FGRCCRegClassID",
"Mips::FGR32RegClassID",
"Mips::FGR64RegClassID",
"Mips::AFGR64RegClassID",
"Mips::MSA128BRegClassID",
"Mips::MSA128HRegClassID",
"Mips::MSA128WRegClassID",
"Mips::MSA128DRegClassID",
"Mips::FPRBRegBankID",
"\"Register class not supported\""
] | MipsRegisterBankInfo16 | getRegBankFromRegClass | Mips | CPU | LLVM | 19,957 | 132 | 1 | [] |
[
"<s>",
"bool",
"evaluateBranch",
"(",
"MCInst",
"const",
"&",
"Inst",
",",
"uint64_t",
"Addr",
",",
"uint64_t",
"Size",
",",
"uint64_t",
"&",
"Target",
")",
"const",
"override",
"{",
"if",
"(",
"!",
"(",
"isCall",
"(",
"Inst",
")",
"||",
"isUnconditionalBranch",
"(",
"Inst",
")",
"||",
"isConditionalBranch",
"(",
"Inst",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"HexagonMCInstrInfo",
"::",
"isExtendable",
"(",
"*",
"Info",
",",
"Inst",
")",
")",
"return",
"false",
";",
"auto",
"const",
"&",
"Extended",
"(",
"HexagonMCInstrInfo",
"::",
"getExtendableOperand",
"(",
"*",
"Info",
",",
"Inst",
")",
")",
";",
"assert",
"(",
"Extended",
".",
"isExpr",
"(",
")",
")",
";",
"int64_t",
"Value",
";",
"if",
"(",
"!",
"Extended",
".",
"getExpr",
"(",
")",
"->",
"evaluateAsAbsolute",
"(",
"Value",
")",
")",
"return",
"false",
";",
"Target",
"=",
"Value",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Given",
"a",
"branch",
"instruction",
"try",
"to",
"get",
"the",
"address",
"the",
"branch",
"targets",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon"
] | HexagonMCTargetDesc | evaluateBranch | Hexagon | DSP | LLVM | 19,958 | 113 | 1 | [] |
[
"<s>",
"bool",
"MipsCodeEmitter",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"MipsTargetMachine",
"&",
"Target",
"=",
"static_cast",
"<",
"MipsTargetMachine",
"&",
">",
"(",
"const_cast",
"<",
"TargetMachine",
"&",
">",
"(",
"MF",
".",
"getTarget",
"(",
")",
")",
")",
";",
"JTI",
"=",
"Target",
".",
"getJITInfo",
"(",
")",
";",
"II",
"=",
"Target",
".",
"getInstrInfo",
"(",
")",
";",
"TD",
"=",
"Target",
".",
"getDataLayout",
"(",
")",
";",
"Subtarget",
"=",
"&",
"TM",
".",
"getSubtarget",
"<",
"MipsSubtarget",
">",
"(",
")",
";",
"MCPEs",
"=",
"&",
"MF",
".",
"getConstantPool",
"(",
")",
"->",
"getConstants",
"(",
")",
";",
"MJTEs",
"=",
"0",
";",
"if",
"(",
"MF",
".",
"getJumpTableInfo",
"(",
")",
")",
"MJTEs",
"=",
"&",
"MF",
".",
"getJumpTableInfo",
"(",
")",
"->",
"getJumpTables",
"(",
")",
";",
"JTI",
"->",
"Initialize",
"(",
"MF",
",",
"IsPIC",
",",
"Subtarget",
"->",
"isLittle",
"(",
")",
")",
";",
"MCE",
".",
"setModuleInfo",
"(",
"&",
"getAnalysis",
"<",
"MachineModuleInfo",
">",
"(",
")",
")",
";",
"do",
"{",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"JITTing function '\"",
"<<",
"MF",
".",
"getName",
"(",
")",
"<<",
"\"'\\n\"",
")",
";",
"MCE",
".",
"startFunction",
"(",
"MF",
")",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"MBB",
"=",
"MF",
".",
"begin",
"(",
")",
",",
"E",
"=",
"MF",
".",
"end",
"(",
")",
";",
"MBB",
"!=",
"E",
";",
"++",
"MBB",
")",
"{",
"MCE",
".",
"StartMachineBasicBlock",
"(",
"MBB",
")",
";",
"for",
"(",
"MachineBasicBlock",
"::",
"instr_iterator",
"I",
"=",
"MBB",
"->",
"instr_begin",
"(",
")",
",",
"E",
"=",
"MBB",
"->",
"instr_end",
"(",
")",
";",
"I",
"!=",
"E",
";",
")",
"emitInstruction",
"(",
"*",
"I",
"++",
",",
"*",
"MBB",
")",
";",
"}",
"}",
"while",
"(",
"MCE",
".",
"finishFunction",
"(",
"MF",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"0",
"\"JITTing function '\"",
"\"'\\n\""
] | MipsCodeEmitter | runOnMachineFunction | Mips | CPU | LLVM | 19,959 | 250 | 1 | [] |
[
"<s>",
"void",
"PPCTargetLowering",
"::",
"LowerAsmOperandForConstraint",
"(",
"SDValue",
"Op",
",",
"std",
"::",
"string",
"&",
"Constraint",
",",
"std",
"::",
"vector",
"<",
"SDValue",
">",
"&",
"Ops",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"SDValue",
"Result",
";",
"if",
"(",
"Constraint",
".",
"length",
"(",
")",
">",
"1",
")",
"return",
";",
"char",
"Letter",
"=",
"Constraint",
"[",
"0",
"]",
";",
"switch",
"(",
"Letter",
")",
"{",
"default",
":",
"break",
";",
"case",
"'I'",
":",
"case",
"'J'",
":",
"case",
"'K'",
":",
"case",
"'L'",
":",
"case",
"'M'",
":",
"case",
"'N'",
":",
"case",
"'O'",
":",
"case",
"'P'",
":",
"{",
"ConstantSDNode",
"*",
"CST",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
")",
";",
"if",
"(",
"!",
"CST",
")",
"return",
";",
"int64_t",
"Value",
"=",
"CST",
"->",
"getSExtValue",
"(",
")",
";",
"EVT",
"TCVT",
"=",
"MVT",
"::",
"i64",
";",
"switch",
"(",
"Letter",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unknown constraint letter!\"",
")",
";",
"case",
"'I'",
":",
"if",
"(",
"isInt",
"<",
"16",
">",
"(",
"Value",
")",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"TCVT",
")",
";",
"break",
";",
"case",
"'J'",
":",
"if",
"(",
"isShiftedUInt",
"<",
"16",
",",
"16",
">",
"(",
"Value",
")",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"TCVT",
")",
";",
"break",
";",
"case",
"'L'",
":",
"if",
"(",
"isShiftedInt",
"<",
"16",
",",
"16",
">",
"(",
"Value",
")",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"TCVT",
")",
";",
"break",
";",
"case",
"'K'",
":",
"if",
"(",
"isUInt",
"<",
"16",
">",
"(",
"Value",
")",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"TCVT",
")",
";",
"break",
";",
"case",
"'M'",
":",
"if",
"(",
"Value",
">",
"31",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"TCVT",
")",
";",
"break",
";",
"case",
"'N'",
":",
"if",
"(",
"Value",
">",
"0",
"&&",
"isPowerOf2_64",
"(",
"Value",
")",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"TCVT",
")",
";",
"break",
";",
"case",
"'O'",
":",
"if",
"(",
"Value",
"==",
"0",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"TCVT",
")",
";",
"break",
";",
"case",
"'P'",
":",
"if",
"(",
"isInt",
"<",
"16",
">",
"(",
"-",
"Value",
")",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"TCVT",
")",
";",
"break",
";",
"}",
"break",
";",
"}",
"}",
"if",
"(",
"Result",
".",
"getNode",
"(",
")",
")",
"{",
"Ops",
".",
"push_back",
"(",
"Result",
")",
";",
"return",
";",
"}",
"TargetLowering",
"::",
"LowerAsmOperandForConstraint",
"(",
"Op",
",",
"Constraint",
",",
"Ops",
",",
"DAG",
")",
";",
"}",
"</s>"
] | [
"Lower",
"the",
"specified",
"operand",
"into",
"the",
"Ops",
"vector",
"."
] | [
"PowerPC",
"PPC",
"1",
"0",
"MVT::i64",
"\"Unknown constraint letter!\"",
"16",
"16",
"16",
"16",
"16",
"16",
"31",
"0",
"0",
"16"
] | PPCISelLowering8 | LowerAsmOperandForConstraint | PowerPC | CPU | LLVM | 19,960 | 377 | 1 | [] |
[
"<s>",
"void",
"XtensaPassConfig",
"::",
"addIRPasses",
"(",
")",
"{",
"TargetPassConfig",
"::",
"addIRPasses",
"(",
")",
";",
"}",
"</s>"
] | [
"Add",
"common",
"target",
"configurable",
"passes",
"that",
"perform",
"LLVM",
"IR",
"to",
"IR",
"transforms",
"following",
"machine",
"independent",
"optimization",
"."
] | [
"Xtensa",
"Xtensa"
] | XtensaTargetMachine1 | addIRPasses | Xtensa | MPU | LLVM | 19,961 | 14 | 1 | [] |
[
"<s>",
"const",
"MipsRegisterInfo",
"*",
"getRegisterInfo",
"(",
")",
"const",
"{",
"return",
"&",
"InstrInfo",
"->",
"getRegisterInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"getRegisterInfo",
"-",
"TargetInstrInfo",
"is",
"a",
"superset",
"of",
"MRegister",
"info",
"."
] | [
"Mips",
"Mips"
] | MipsSubtarget (2) | getRegisterInfo | Mips | CPU | LLVM | 19,962 | 17 | 1 | [] |
[
"<s>",
"std",
"::",
"string",
"MCGNode",
"::",
"getLabel",
"(",
")",
"const",
"{",
"std",
"::",
"string",
"tmps",
";",
"raw_string_ostream",
"tmp",
"(",
"tmps",
")",
";",
"if",
"(",
"isUnknown",
"(",
")",
")",
"tmp",
"<<",
"\"<UNKNOWN-\"",
"<<",
"*",
"T",
"<<",
"\">\"",
";",
"else",
"tmp",
"<<",
"MF",
"->",
"getFunction",
"(",
")",
".",
"getName",
"(",
")",
";",
"return",
"tmps",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"MDNode",
"pointer",
"for",
"the",
"label",
"."
] | [
"Patmos",
"\"<UNKNOWN-\"",
"\">\""
] | PatmosCallGraphBuilder1 | getLabel | Patmos | VLIW | LLVM | 19,963 | 53 | 1 | [] |
[
"<s>",
"bool",
"X86InstrInfo",
"::",
"canInsertSelect",
"(",
"const",
"MachineBasicBlock",
"&",
"MBB",
",",
"ArrayRef",
"<",
"MachineOperand",
">",
"Cond",
",",
"unsigned",
"TrueReg",
",",
"unsigned",
"FalseReg",
",",
"int",
"&",
"CondCycles",
",",
"int",
"&",
"TrueCycles",
",",
"int",
"&",
"FalseCycles",
")",
"const",
"{",
"if",
"(",
"!",
"Subtarget",
".",
"hasCMov",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"Cond",
".",
"size",
"(",
")",
"!=",
"1",
")",
"return",
"false",
";",
"if",
"(",
"(",
"X86",
"::",
"CondCode",
")",
"Cond",
"[",
"0",
"]",
".",
"getImm",
"(",
")",
">",
"X86",
"::",
"COND_S",
")",
"return",
"false",
";",
"const",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MBB",
".",
"getParent",
"(",
")",
"->",
"getRegInfo",
"(",
")",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"RI",
".",
"getCommonSubClass",
"(",
"MRI",
".",
"getRegClass",
"(",
"TrueReg",
")",
",",
"MRI",
".",
"getRegClass",
"(",
"FalseReg",
")",
")",
";",
"if",
"(",
"!",
"RC",
")",
"return",
"false",
";",
"if",
"(",
"X86",
"::",
"GR16RegClass",
".",
"hasSubClassEq",
"(",
"RC",
")",
"||",
"X86",
"::",
"GR32RegClass",
".",
"hasSubClassEq",
"(",
"RC",
")",
"||",
"X86",
"::",
"GR64RegClass",
".",
"hasSubClassEq",
"(",
"RC",
")",
")",
"{",
"CondCycles",
"=",
"2",
";",
"TrueCycles",
"=",
"2",
";",
"FalseCycles",
"=",
"2",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"it",
"is",
"possible",
"to",
"insert",
"a",
"select",
"instruction",
"that",
"chooses",
"between",
"TrueReg",
"and",
"FalseReg",
"based",
"on",
"the",
"condition",
"code",
"in",
"Cond",
"."
] | [
"X86",
"X86",
"1",
"X86::CondCode",
"0",
"X86::COND_S",
"X86::GR16RegClass",
"X86::GR32RegClass",
"X86::GR64RegClass",
"2",
"2",
"2"
] | X86InstrInfo (2)1 | canInsertSelect | X86 | CPU | LLVM | 19,964 | 181 | 1 | [] |
[
"<s>",
"static",
"int",
"ix86_mode_exit",
"(",
"int",
"entity",
")",
"{",
"switch",
"(",
"entity",
")",
"{",
"case",
"AVX_U128",
":",
"return",
"ix86_avx_u128_mode_exit",
"(",
")",
";",
"case",
"I387_TRUNC",
":",
"case",
"I387_FLOOR",
":",
"case",
"I387_CEIL",
":",
"case",
"I387_MASK_PM",
":",
"return",
"I387_CW_ANY",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Return",
"a",
"mode",
"that",
"ENTITY",
"is",
"assumed",
"to",
"be",
"switched",
"to",
"at",
"function",
"exit",
"."
] | [
"i386"
] | i3864 | ix86_mode_exit | i386 | CPU | GCC | 19,965 | 44 | 1 | [] |
[
"<s>",
"bool",
"MicroMipsSizeReduce",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"Subtarget",
"=",
"&",
"MF",
".",
"getSubtarget",
"<",
"MipsSubtarget",
">",
"(",
")",
";",
"if",
"(",
"!",
"Subtarget",
"->",
"inMicroMipsMode",
"(",
")",
"||",
"!",
"Subtarget",
"->",
"hasMips32r2",
"(",
")",
"||",
"Subtarget",
"->",
"hasMips32r6",
"(",
")",
")",
"return",
"false",
";",
"MipsII",
"=",
"static_cast",
"<",
"const",
"MipsInstrInfo",
"*",
">",
"(",
"Subtarget",
"->",
"getInstrInfo",
"(",
")",
")",
";",
"bool",
"Modified",
"=",
"false",
";",
"MachineFunction",
"::",
"iterator",
"I",
"=",
"MF",
".",
"begin",
"(",
")",
",",
"E",
"=",
"MF",
".",
"end",
"(",
")",
";",
"for",
"(",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"Modified",
"|=",
"ReduceMBB",
"(",
"*",
"I",
")",
";",
"return",
"Modified",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips"
] | MicroMipsSizeReduction8 | runOnMachineFunction | Mips | CPU | LLVM | 19,966 | 109 | 1 | [] |
[
"<s>",
"bool",
"MOSPassConfig",
"::",
"addPreISel",
"(",
")",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"{",
"{",
"@",
"For",
"GlobalISel"
] | [
"MOS",
"MOS"
] | MOSTargetMachine | addPreISel | MOS | MPU | LLVM | 19,967 | 11 | 1 | [] |
[
"<s>",
"void",
"SIMachineFunctionInfo",
"::",
"removeDeadFrameIndices",
"(",
"MachineFrameInfo",
"&",
"MFI",
")",
"{",
"for",
"(",
"auto",
"&",
"R",
":",
"make_early_inc_range",
"(",
"SGPRToVGPRSpills",
")",
")",
"{",
"if",
"(",
"R",
".",
"first",
"!=",
"FramePointerSaveIndex",
"&&",
"R",
".",
"first",
"!=",
"BasePointerSaveIndex",
")",
"{",
"MFI",
".",
"RemoveStackObject",
"(",
"R",
".",
"first",
")",
";",
"SGPRToVGPRSpills",
".",
"erase",
"(",
"R",
".",
"first",
")",
";",
"}",
"}",
"for",
"(",
"int",
"i",
"=",
"MFI",
".",
"getObjectIndexBegin",
"(",
")",
",",
"e",
"=",
"MFI",
".",
"getObjectIndexEnd",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"if",
"(",
"i",
"!=",
"FramePointerSaveIndex",
"&&",
"i",
"!=",
"BasePointerSaveIndex",
")",
"MFI",
".",
"setStackID",
"(",
"i",
",",
"TargetStackID",
"::",
"Default",
")",
";",
"for",
"(",
"auto",
"&",
"R",
":",
"VGPRToAGPRSpills",
")",
"{",
"if",
"(",
"R",
".",
"second",
".",
"IsDead",
")",
"MFI",
".",
"RemoveStackObject",
"(",
"R",
".",
"first",
")",
";",
"}",
"}",
"</s>"
] | [
"If",
"ResetSGPRSpillStackIDs",
"is",
"true",
",",
"reset",
"the",
"stack",
"ID",
"from",
"sgpr-spill",
"to",
"the",
"default",
"stack",
"."
] | [
"AMDGPU",
"SI"
] | SIMachineFunctionInfo15 | removeDeadFrameIndices | AMDGPU | GPU | LLVM | 19,968 | 132 | 1 | [] |
[
"<s>",
"void",
"SIInstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"Register",
"SrcReg",
",",
"bool",
"isKill",
",",
"int",
"FrameIndex",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
".",
"getParent",
"(",
")",
";",
"SIMachineFunctionInfo",
"*",
"MFI",
"=",
"MF",
"->",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"MachineFrameInfo",
"&",
"FrameInfo",
"=",
"MF",
"->",
"getFrameInfo",
"(",
")",
";",
"const",
"DebugLoc",
"&",
"DL",
"=",
"MBB",
".",
"findDebugLoc",
"(",
"MI",
")",
";",
"MachinePointerInfo",
"PtrInfo",
"=",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"*",
"MF",
",",
"FrameIndex",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
"->",
"getMachineMemOperand",
"(",
"PtrInfo",
",",
"MachineMemOperand",
"::",
"MOStore",
",",
"FrameInfo",
".",
"getObjectSize",
"(",
"FrameIndex",
")",
",",
"FrameInfo",
".",
"getObjectAlign",
"(",
"FrameIndex",
")",
")",
";",
"unsigned",
"SpillSize",
"=",
"TRI",
"->",
"getSpillSize",
"(",
"*",
"RC",
")",
";",
"if",
"(",
"RI",
".",
"isSGPRClass",
"(",
"RC",
")",
")",
"{",
"MFI",
"->",
"setHasSpilledSGPRs",
"(",
")",
";",
"assert",
"(",
"SrcReg",
"!=",
"AMDGPU",
"::",
"M0",
"&&",
"\"m0 should not be spilled\"",
")",
";",
"assert",
"(",
"SrcReg",
"!=",
"AMDGPU",
"::",
"EXEC_LO",
"&&",
"SrcReg",
"!=",
"AMDGPU",
"::",
"EXEC_HI",
"&&",
"SrcReg",
"!=",
"AMDGPU",
"::",
"EXEC",
"&&",
"\"exec should not be spilled\"",
")",
";",
"const",
"MCInstrDesc",
"&",
"OpDesc",
"=",
"get",
"(",
"getSGPRSpillSaveOpcode",
"(",
"SpillSize",
")",
")",
";",
"if",
"(",
"Register",
"::",
"isVirtualRegister",
"(",
"SrcReg",
")",
"&&",
"SpillSize",
"==",
"4",
")",
"{",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"MRI",
".",
"constrainRegClass",
"(",
"SrcReg",
",",
"&",
"AMDGPU",
"::",
"SReg_32_XM0_XEXECRegClass",
")",
";",
"}",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"OpDesc",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIndex",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getScratchRSrcReg",
"(",
")",
",",
"RegState",
"::",
"Implicit",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getStackPtrOffsetReg",
"(",
")",
",",
"RegState",
"::",
"Implicit",
")",
";",
"if",
"(",
"RI",
".",
"spillSGPRToVGPR",
"(",
")",
")",
"FrameInfo",
".",
"setStackID",
"(",
"FrameIndex",
",",
"TargetStackID",
"::",
"SGPRSpill",
")",
";",
"return",
";",
"}",
"unsigned",
"Opcode",
"=",
"RI",
".",
"hasAGPRs",
"(",
"RC",
")",
"?",
"getAGPRSpillSaveOpcode",
"(",
"SpillSize",
")",
":",
"getVGPRSpillSaveOpcode",
"(",
"SpillSize",
")",
";",
"MFI",
"->",
"setHasSpilledVGPRs",
"(",
")",
";",
"auto",
"MIB",
"=",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Opcode",
")",
")",
";",
"if",
"(",
"RI",
".",
"hasAGPRs",
"(",
"RC",
")",
")",
"{",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"Register",
"Tmp",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"AMDGPU",
"::",
"VGPR_32RegClass",
")",
";",
"MIB",
".",
"addReg",
"(",
"Tmp",
",",
"RegState",
"::",
"Define",
")",
";",
"}",
"MIB",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIndex",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getScratchRSrcReg",
"(",
")",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getStackPtrOffsetReg",
"(",
")",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"}",
"</s>"
] | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"AMDGPU::M0",
"\"m0 should not be spilled\"",
"AMDGPU::EXEC_LO",
"AMDGPU::EXEC_HI",
"AMDGPU::EXEC",
"\"exec should not be spilled\"",
"4",
"AMDGPU::SReg_32_XM0_XEXECRegClass",
"AMDGPU::VGPR_32RegClass",
"0"
] | SIInstrInfo118 | storeRegToStackSlot | AMDGPU | GPU | LLVM | 19,969 | 446 | 1 | [] |
[
"<s>",
"static",
"int",
"loongarch_sign_extend_cost",
"(",
"rtx",
"op",
")",
"{",
"if",
"(",
"MEM_P",
"(",
"op",
")",
")",
"return",
"0",
";",
"return",
"COSTS_N_INSNS",
"(",
"1",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"cost",
"of",
"sign-extending",
"OP",
"to",
"mode",
"MODE",
",",
"not",
"including",
"the",
"cost",
"of",
"OP",
"itself",
"."
] | [
"loongarch",
"0",
"1"
] | loongarch | loongarch_sign_extend_cost | loongarch | CPU | GCC | 19,970 | 25 | 1 | [] |
[
"<s>",
"void",
"Thumb1InstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"unsigned",
"DestReg",
",",
"int",
"FI",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"assert",
"(",
"(",
"RC",
"==",
"&",
"ARM",
"::",
"tGPRRegClass",
"||",
"(",
"TargetRegisterInfo",
"::",
"isPhysicalRegister",
"(",
"DestReg",
")",
"&&",
"isARMLowRegister",
"(",
"DestReg",
")",
")",
")",
"&&",
"\"Unknown regclass!\"",
")",
";",
"if",
"(",
"RC",
"==",
"&",
"ARM",
"::",
"tGPRRegClass",
"||",
"(",
"TargetRegisterInfo",
"::",
"isPhysicalRegister",
"(",
"DestReg",
")",
"&&",
"isARMLowRegister",
"(",
"DestReg",
")",
")",
")",
"{",
"DebugLoc",
"DL",
";",
"if",
"(",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"I",
"->",
"getDebugLoc",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"*",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"MF",
",",
"FI",
")",
",",
"MachineMemOperand",
"::",
"MOLoad",
",",
"MFI",
".",
"getObjectSize",
"(",
"FI",
")",
",",
"MFI",
".",
"getObjectAlignment",
"(",
"FI",
")",
")",
";",
"AddDefaultPred",
"(",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"ARM",
"::",
"tLDRspi",
")",
",",
"DestReg",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"ARM",
"ARM::tGPRRegClass",
"ARM",
"\"Unknown regclass!\"",
"ARM::tGPRRegClass",
"ARM",
"ARM::tLDRspi",
"0"
] | Thumb1InstrInfo21 | loadRegFromStackSlot | ARM | CPU | LLVM | 19,971 | 201 | 1 | [] |
[
"<s>",
"bool",
"writeNopData",
"(",
"raw_ostream",
"&",
"OS",
",",
"uint64_t",
"Count",
")",
"const",
"override",
"{",
"if",
"(",
"(",
"Count",
"%",
"8",
")",
"!=",
"0",
")",
"return",
"false",
";",
"for",
"(",
"uint64_t",
"i",
"=",
"0",
";",
"i",
"<",
"Count",
";",
"i",
"+=",
"8",
")",
"support",
"::",
"endian",
"::",
"write",
"<",
"uint64_t",
">",
"(",
"OS",
",",
"0x7900000000000000ULL",
",",
"support",
"::",
"little",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Write",
"an",
"(",
"optimal",
")",
"nop",
"sequence",
"of",
"Count",
"bytes",
"to",
"the",
"given",
"output",
"."
] | [
"VE",
"8",
"0",
"0",
"8",
"support::endian",
"0x7900000000000000ULL",
"support::little"
] | VEAsmBackend1 | writeNopData | VE | CPU | LLVM | 19,972 | 63 | 1 | [] |
[
"<s>",
"bool",
"AArch64TargetLowering",
"::",
"isFMAFasterThanFMulAndFAdd",
"(",
"EVT",
"VT",
")",
"const",
"{",
"VT",
"=",
"VT",
".",
"getScalarType",
"(",
")",
";",
"if",
"(",
"!",
"VT",
".",
"isSimple",
"(",
")",
")",
"return",
"false",
";",
"switch",
"(",
"VT",
".",
"getSimpleVT",
"(",
")",
".",
"SimpleTy",
")",
"{",
"case",
"MVT",
"::",
"f16",
":",
"case",
"MVT",
"::",
"f32",
":",
"case",
"MVT",
"::",
"f64",
":",
"return",
"true",
";",
"case",
"MVT",
"::",
"f128",
":",
"return",
"false",
";",
"default",
":",
"break",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"an",
"FMA",
"operation",
"is",
"faster",
"than",
"a",
"pair",
"of",
"fmul",
"and",
"fadd",
"instructions",
"."
] | [
"AArch64",
"AArch64",
"MVT::f16",
"MVT::f32",
"MVT::f64",
"MVT::f128"
] | AArch64ISelLowering109 | isFMAFasterThanFMulAndFAdd | AArch64 | CPU | LLVM | 19,973 | 76 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"SNES DAG->DAG Instruction Selection\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"SNES",
"\"SNES DAG->DAG Instruction Selection\""
] | SNESISelDAGToDAG | getPassName | SNES | DSP | LLVM | 19,974 | 11 | 1 | [] |
[
"<s>",
"void",
"SIInstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"SrcReg",
",",
"bool",
"isKill",
",",
"int",
"FrameIndex",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
".",
"getParent",
"(",
")",
";",
"SIMachineFunctionInfo",
"*",
"MFI",
"=",
"MF",
"->",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"MachineFrameInfo",
"&",
"FrameInfo",
"=",
"MF",
"->",
"getFrameInfo",
"(",
")",
";",
"const",
"DebugLoc",
"&",
"DL",
"=",
"MBB",
".",
"findDebugLoc",
"(",
"MI",
")",
";",
"unsigned",
"Size",
"=",
"FrameInfo",
".",
"getObjectSize",
"(",
"FrameIndex",
")",
";",
"unsigned",
"Align",
"=",
"FrameInfo",
".",
"getObjectAlignment",
"(",
"FrameIndex",
")",
";",
"MachinePointerInfo",
"PtrInfo",
"=",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"*",
"MF",
",",
"FrameIndex",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
"->",
"getMachineMemOperand",
"(",
"PtrInfo",
",",
"MachineMemOperand",
"::",
"MOStore",
",",
"Size",
",",
"Align",
")",
";",
"unsigned",
"SpillSize",
"=",
"TRI",
"->",
"getSpillSize",
"(",
"*",
"RC",
")",
";",
"if",
"(",
"RI",
".",
"isSGPRClass",
"(",
"RC",
")",
")",
"{",
"MFI",
"->",
"setHasSpilledSGPRs",
"(",
")",
";",
"const",
"MCInstrDesc",
"&",
"OpDesc",
"=",
"get",
"(",
"getSGPRSpillSaveOpcode",
"(",
"SpillSize",
")",
")",
";",
"if",
"(",
"TargetRegisterInfo",
"::",
"isVirtualRegister",
"(",
"SrcReg",
")",
"&&",
"SpillSize",
"==",
"4",
")",
"{",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"MRI",
".",
"constrainRegClass",
"(",
"SrcReg",
",",
"&",
"AMDGPU",
"::",
"SReg_32_XM0RegClass",
")",
";",
"}",
"MachineInstrBuilder",
"Spill",
"=",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"OpDesc",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIndex",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getScratchRSrcReg",
"(",
")",
",",
"RegState",
"::",
"Implicit",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getFrameOffsetReg",
"(",
")",
",",
"RegState",
"::",
"Implicit",
")",
";",
"FrameInfo",
".",
"setStackID",
"(",
"FrameIndex",
",",
"SIStackID",
"::",
"SGPR_SPILL",
")",
";",
"if",
"(",
"ST",
".",
"hasScalarStores",
"(",
")",
")",
"{",
"Spill",
".",
"addReg",
"(",
"AMDGPU",
"::",
"M0",
",",
"RegState",
"::",
"ImplicitDefine",
"|",
"RegState",
"::",
"Dead",
")",
";",
"}",
"return",
";",
"}",
"assert",
"(",
"RI",
".",
"hasVGPRs",
"(",
"RC",
")",
"&&",
"\"Only VGPR spilling expected\"",
")",
";",
"unsigned",
"Opcode",
"=",
"getVGPRSpillSaveOpcode",
"(",
"SpillSize",
")",
";",
"MFI",
"->",
"setHasSpilledVGPRs",
"(",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Opcode",
")",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIndex",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getScratchRSrcReg",
"(",
")",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getFrameOffsetReg",
"(",
")",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"}",
"</s>"
] | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"4",
"AMDGPU::SReg_32_XM0RegClass",
"SIStackID::SGPR_SPILL",
"AMDGPU::M0",
"\"Only VGPR spilling expected\"",
"0"
] | SIInstrInfo1 | storeRegToStackSlot | AMDGPU | GPU | LLVM | 19,975 | 394 | 1 | [] |
[
"<s>",
"void",
"AArch64MacroFusion",
"::",
"apply",
"(",
"ScheduleDAGInstrs",
"*",
"DAGInstrs",
")",
"{",
"ScheduleDAGMI",
"*",
"DAG",
"=",
"static_cast",
"<",
"ScheduleDAGMI",
"*",
">",
"(",
"DAGInstrs",
")",
";",
"for",
"(",
"SUnit",
"&",
"ISU",
":",
"DAG",
"->",
"SUnits",
")",
"scheduleAdjacentImpl",
"(",
"DAG",
",",
"ISU",
")",
";",
"scheduleAdjacentImpl",
"(",
"DAG",
",",
"DAG",
"->",
"ExitSU",
")",
";",
"}",
"</s>"
] | [
"Apply",
"the",
"profile",
"inference",
"algorithm",
"for",
"a",
"given",
"function",
"."
] | [
"AArch64",
"AArch64"
] | AArch64MacroFusion | apply | AArch64 | CPU | LLVM | 19,976 | 50 | 1 | [] |
[
"<s>",
"void",
"finishImpl",
"(",
")",
"override",
"{",
"}",
"</s>"
] | [
"Streamer",
"specific",
"finalization",
"."
] | [
"Patmos"
] | PatmosInstrInfo1 | finishImpl | Patmos | VLIW | LLVM | 19,977 | 7 | 1 | [] |
[
"<s>",
"MachineBasicBlock",
"::",
"iterator",
"TPCFrameLowering",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
")",
"const",
"{",
"llvm_unreachable",
"(",
"\"No stack frame pseudos\"",
")",
";",
"}",
"</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",
")",
"."
] | [
"TPC",
"TPC",
"\"No stack frame pseudos\""
] | TPCFrameLowering | eliminateCallFramePseudoInstr | TPC | Virtual ISA | LLVM | 19,978 | 28 | 1 | [] |
[
"<s>",
"bool",
"HexagonTargetLowering",
"::",
"isFPImmLegal",
"(",
"const",
"APFloat",
"&",
"Imm",
",",
"EVT",
"VT",
",",
"bool",
"ForCodeSize",
")",
"const",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"can",
"instruction",
"select",
"the",
"specified",
"FP",
"immediate",
"natively",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonISelLowering100 | isFPImmLegal | Hexagon | DSP | LLVM | 19,979 | 22 | 1 | [] |
[
"<s>",
"bool",
"AArch64FastISel",
"::",
"optimizeSelect",
"(",
"const",
"SelectInst",
"*",
"SI",
")",
"{",
"if",
"(",
"!",
"SI",
"->",
"getType",
"(",
")",
"->",
"isIntegerTy",
"(",
"1",
")",
")",
"return",
"false",
";",
"const",
"Value",
"*",
"Src1Val",
",",
"*",
"Src2Val",
";",
"unsigned",
"Opc",
"=",
"0",
";",
"bool",
"NeedExtraOp",
"=",
"false",
";",
"if",
"(",
"auto",
"*",
"CI",
"=",
"dyn_cast",
"<",
"ConstantInt",
">",
"(",
"SI",
"->",
"getTrueValue",
"(",
")",
")",
")",
"{",
"if",
"(",
"CI",
"->",
"isOne",
"(",
")",
")",
"{",
"Src1Val",
"=",
"SI",
"->",
"getCondition",
"(",
")",
";",
"Src2Val",
"=",
"SI",
"->",
"getFalseValue",
"(",
")",
";",
"Opc",
"=",
"AArch64",
"::",
"ORRWrr",
";",
"}",
"else",
"{",
"assert",
"(",
"CI",
"->",
"isZero",
"(",
")",
")",
";",
"Src1Val",
"=",
"SI",
"->",
"getFalseValue",
"(",
")",
";",
"Src2Val",
"=",
"SI",
"->",
"getCondition",
"(",
")",
";",
"Opc",
"=",
"AArch64",
"::",
"BICWrr",
";",
"}",
"}",
"else",
"if",
"(",
"auto",
"*",
"CI",
"=",
"dyn_cast",
"<",
"ConstantInt",
">",
"(",
"SI",
"->",
"getFalseValue",
"(",
")",
")",
")",
"{",
"if",
"(",
"CI",
"->",
"isOne",
"(",
")",
")",
"{",
"Src1Val",
"=",
"SI",
"->",
"getCondition",
"(",
")",
";",
"Src2Val",
"=",
"SI",
"->",
"getTrueValue",
"(",
")",
";",
"Opc",
"=",
"AArch64",
"::",
"ORRWrr",
";",
"NeedExtraOp",
"=",
"true",
";",
"}",
"else",
"{",
"assert",
"(",
"CI",
"->",
"isZero",
"(",
")",
")",
";",
"Src1Val",
"=",
"SI",
"->",
"getCondition",
"(",
")",
";",
"Src2Val",
"=",
"SI",
"->",
"getTrueValue",
"(",
")",
";",
"Opc",
"=",
"AArch64",
"::",
"ANDWrr",
";",
"}",
"}",
"if",
"(",
"!",
"Opc",
")",
"return",
"false",
";",
"unsigned",
"Src1Reg",
"=",
"getRegForValue",
"(",
"Src1Val",
")",
";",
"if",
"(",
"!",
"Src1Reg",
")",
"return",
"false",
";",
"unsigned",
"Src2Reg",
"=",
"getRegForValue",
"(",
"Src2Val",
")",
";",
"if",
"(",
"!",
"Src2Reg",
")",
"return",
"false",
";",
"if",
"(",
"NeedExtraOp",
")",
"Src1Reg",
"=",
"emitLogicalOp_ri",
"(",
"ISD",
"::",
"XOR",
",",
"MVT",
"::",
"i32",
",",
"Src1Reg",
",",
"1",
")",
";",
"unsigned",
"ResultReg",
"=",
"fastEmitInst_rr",
"(",
"Opc",
",",
"&",
"AArch64",
"::",
"GPR32RegClass",
",",
"Src1Reg",
",",
"Src2Reg",
")",
";",
"updateValueMap",
"(",
"SI",
",",
"ResultReg",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Given",
"a",
"select",
"instruction",
"that",
"was",
"understood",
"by",
"analyzeSelect",
"and",
"returned",
"Optimizable",
"=",
"true",
",",
"attempt",
"to",
"optimize",
"MI",
"by",
"merging",
"it",
"with",
"one",
"of",
"its",
"operands",
"."
] | [
"AArch64",
"AArch64",
"1",
"0",
"AArch64::ORRWrr",
"AArch64::BICWrr",
"AArch64::ORRWrr",
"AArch64::ANDWrr",
"ISD::XOR",
"MVT::i32",
"1",
"AArch64::GPR32RegClass"
] | AArch64FastISel21 | optimizeSelect | AArch64 | CPU | LLVM | 19,980 | 312 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUDAGToDAGISel",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"Subtarget",
"=",
"&",
"static_cast",
"<",
"const",
"AMDGPUSubtarget",
"&",
">",
"(",
"MF",
".",
"getSubtarget",
"(",
")",
")",
";",
"return",
"SelectionDAGISel",
"::",
"runOnMachineFunction",
"(",
"MF",
")",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"R600"
] | AMDGPUISelDAGToDAG24 | runOnMachineFunction | R600 | GPU | LLVM | 19,981 | 36 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"output_adjust_stack_and_probe",
"(",
"rtx",
"reg",
")",
"{",
"static",
"int",
"labelno",
"=",
"0",
";",
"char",
"loop_lab",
"[",
"32",
"]",
";",
"rtx",
"xops",
"[",
"2",
"]",
";",
"ASM_GENERATE_INTERNAL_LABEL",
"(",
"loop_lab",
",",
"\"LPSRL\"",
",",
"labelno",
"++",
")",
";",
"ASM_OUTPUT_INTERNAL_LABEL",
"(",
"asm_out_file",
",",
"loop_lab",
")",
";",
"xops",
"[",
"0",
"]",
"=",
"stack_pointer_rtx",
";",
"xops",
"[",
"1",
"]",
"=",
"GEN_INT",
"(",
"get_probe_interval",
"(",
")",
")",
";",
"output_asm_insn",
"(",
"\"sub%z0\\t{%1, %0|%0, %1}\"",
",",
"xops",
")",
";",
"xops",
"[",
"1",
"]",
"=",
"const0_rtx",
";",
"output_asm_insn",
"(",
"\"or%z0\\t{%1, (%0)|DWORD PTR [%0], %1}\"",
",",
"xops",
")",
";",
"xops",
"[",
"0",
"]",
"=",
"stack_pointer_rtx",
";",
"xops",
"[",
"1",
"]",
"=",
"reg",
";",
"output_asm_insn",
"(",
"\"cmp%z0\\t{%1, %0|%0, %1}\"",
",",
"xops",
")",
";",
"fputs",
"(",
"\"\\tjne\\t\"",
",",
"asm_out_file",
")",
";",
"assemble_name_raw",
"(",
"asm_out_file",
",",
"loop_lab",
")",
";",
"fputc",
"(",
"'\\n'",
",",
"asm_out_file",
")",
";",
"return",
"\"\"",
";",
"}",
"</s>"
] | [
"Adjust",
"the",
"stack",
"pointer",
"up",
"to",
"REG",
"while",
"probing",
"it",
"."
] | [
"i386",
"0",
"32",
"2",
"\"LPSRL\"",
"0",
"1",
"\"sub%z0\\t{%1, %0|%0, %1}\"",
"1",
"\"or%z0\\t{%1, (%0)|DWORD PTR [%0], %1}\"",
"0",
"1",
"\"cmp%z0\\t{%1, %0|%0, %1}\"",
"\"\\tjne\\t\"",
"\"\""
] | i386 | output_adjust_stack_and_probe | i386 | CPU | GCC | 19,982 | 130 | 1 | [] |
[
"<s>",
"void",
"ScheduleDAGPostRA",
"::",
"viewGraph",
"(",
")",
"{",
"viewGraph",
"(",
"getDAGName",
"(",
")",
",",
"\"Scheduling-Units Graph for \"",
"+",
"getDAGName",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Pop",
"up",
"a",
"GraphViz/gv",
"window",
"with",
"the",
"DAG",
"rendered",
"using",
"'dot",
"'",
"."
] | [
"Patmos",
"\"Scheduling-Units Graph for \""
] | PatmosPostRAScheduler | viewGraph | Patmos | VLIW | LLVM | 19,983 | 21 | 1 | [] |
[
"<s>",
"void",
"SystemZTTIImpl",
"::",
"getUnrollingPreferences",
"(",
"Loop",
"*",
"L",
",",
"ScalarEvolution",
"&",
"SE",
",",
"TTI",
"::",
"UnrollingPreferences",
"&",
"UP",
")",
"{",
"bool",
"HasCall",
"=",
"false",
";",
"unsigned",
"NumStores",
"=",
"0",
";",
"for",
"(",
"auto",
"&",
"BB",
":",
"L",
"->",
"blocks",
"(",
")",
")",
"for",
"(",
"auto",
"&",
"I",
":",
"*",
"BB",
")",
"{",
"if",
"(",
"isa",
"<",
"CallInst",
">",
"(",
"&",
"I",
")",
"||",
"isa",
"<",
"InvokeInst",
">",
"(",
"&",
"I",
")",
")",
"{",
"ImmutableCallSite",
"CS",
"(",
"&",
"I",
")",
";",
"if",
"(",
"const",
"Function",
"*",
"F",
"=",
"CS",
".",
"getCalledFunction",
"(",
")",
")",
"{",
"if",
"(",
"isLoweredToCall",
"(",
"F",
")",
")",
"HasCall",
"=",
"true",
";",
"if",
"(",
"F",
"->",
"getIntrinsicID",
"(",
")",
"==",
"Intrinsic",
"::",
"memcpy",
"||",
"F",
"->",
"getIntrinsicID",
"(",
")",
"==",
"Intrinsic",
"::",
"memset",
")",
"NumStores",
"++",
";",
"}",
"else",
"{",
"HasCall",
"=",
"true",
";",
"}",
"}",
"if",
"(",
"isa",
"<",
"StoreInst",
">",
"(",
"&",
"I",
")",
")",
"{",
"Type",
"*",
"MemAccessTy",
"=",
"I",
".",
"getOperand",
"(",
"0",
")",
"->",
"getType",
"(",
")",
";",
"NumStores",
"+=",
"getMemoryOpCost",
"(",
"Instruction",
"::",
"Store",
",",
"MemAccessTy",
",",
"None",
",",
"0",
")",
";",
"}",
"}",
"unsigned",
"const",
"Max",
"=",
"(",
"NumStores",
"?",
"(",
"12",
"/",
"NumStores",
")",
":",
"UINT_MAX",
")",
";",
"if",
"(",
"HasCall",
")",
"{",
"UP",
".",
"FullUnrollMaxCount",
"=",
"Max",
";",
"UP",
".",
"MaxCount",
"=",
"1",
";",
"return",
";",
"}",
"UP",
".",
"MaxCount",
"=",
"Max",
";",
"if",
"(",
"UP",
".",
"MaxCount",
"<=",
"1",
")",
"return",
";",
"UP",
".",
"Partial",
"=",
"UP",
".",
"Runtime",
"=",
"true",
";",
"UP",
".",
"PartialThreshold",
"=",
"75",
";",
"UP",
".",
"DefaultUnrollRuntimeCount",
"=",
"4",
";",
"UP",
".",
"AllowExpensiveTripCount",
"=",
"true",
";",
"UP",
".",
"Force",
"=",
"true",
";",
"}",
"</s>"
] | [
"Get",
"target-customized",
"preferences",
"for",
"the",
"generic",
"loop",
"unrolling",
"transformation",
"."
] | [
"SystemZ",
"SystemZ",
"0",
"Intrinsic::memcpy",
"Intrinsic::memset",
"0",
"0",
"12",
"1",
"1",
"75",
"4"
] | SystemZTargetTransformInfo25 | getUnrollingPreferences | SystemZ | CPU | LLVM | 19,984 | 270 | 1 | [] |
[
"<s>",
"static",
"MCSymbol",
"*",
"GetSymbolFromOperand",
"(",
"const",
"MachineOperand",
"&",
"MO",
",",
"AsmPrinter",
"&",
"AP",
")",
"{",
"const",
"TargetMachine",
"&",
"TM",
"=",
"AP",
".",
"TM",
";",
"Mangler",
"*",
"Mang",
"=",
"AP",
".",
"Mang",
";",
"const",
"DataLayout",
"*",
"DL",
"=",
"TM",
".",
"getDataLayout",
"(",
")",
";",
"MCContext",
"&",
"Ctx",
"=",
"AP",
".",
"OutContext",
";",
"bool",
"isDarwin",
"=",
"Triple",
"(",
"TM",
".",
"getTargetTriple",
"(",
")",
")",
".",
"isOSDarwin",
"(",
")",
";",
"SmallString",
"<",
"128",
">",
"Name",
";",
"StringRef",
"Suffix",
";",
"if",
"(",
"MO",
".",
"getTargetFlags",
"(",
")",
"==",
"PPCII",
"::",
"MO_PLT_OR_STUB",
")",
"{",
"if",
"(",
"isDarwin",
")",
"Suffix",
"=",
"\"$stub\"",
";",
"}",
"else",
"if",
"(",
"MO",
".",
"getTargetFlags",
"(",
")",
"&",
"PPCII",
"::",
"MO_NLP_FLAG",
")",
"Suffix",
"=",
"\"$non_lazy_ptr\"",
";",
"if",
"(",
"!",
"Suffix",
".",
"empty",
"(",
")",
")",
"Name",
"+=",
"DL",
"->",
"getPrivateGlobalPrefix",
"(",
")",
";",
"unsigned",
"PrefixLen",
"=",
"Name",
".",
"size",
"(",
")",
";",
"if",
"(",
"!",
"MO",
".",
"isGlobal",
"(",
")",
")",
"{",
"assert",
"(",
"MO",
".",
"isSymbol",
"(",
")",
"&&",
"\"Isn't a symbol reference\"",
")",
";",
"Mang",
"->",
"getNameWithPrefix",
"(",
"Name",
",",
"MO",
".",
"getSymbolName",
"(",
")",
")",
";",
"}",
"else",
"{",
"const",
"GlobalValue",
"*",
"GV",
"=",
"MO",
".",
"getGlobal",
"(",
")",
";",
"TM",
".",
"getNameWithPrefix",
"(",
"Name",
",",
"GV",
",",
"*",
"Mang",
")",
";",
"}",
"unsigned",
"OrigLen",
"=",
"Name",
".",
"size",
"(",
")",
"-",
"PrefixLen",
";",
"Name",
"+=",
"Suffix",
";",
"MCSymbol",
"*",
"Sym",
"=",
"Ctx",
".",
"GetOrCreateSymbol",
"(",
"Name",
".",
"str",
"(",
")",
")",
";",
"StringRef",
"OrigName",
"=",
"StringRef",
"(",
"Name",
")",
".",
"substr",
"(",
"PrefixLen",
",",
"OrigLen",
")",
";",
"if",
"(",
"MO",
".",
"getTargetFlags",
"(",
")",
"==",
"PPCII",
"::",
"MO_PLT_OR_STUB",
"&&",
"isDarwin",
")",
"{",
"MachineModuleInfoImpl",
"::",
"StubValueTy",
"&",
"StubSym",
"=",
"getMachOMMI",
"(",
"AP",
")",
".",
"getFnStubEntry",
"(",
"Sym",
")",
";",
"if",
"(",
"StubSym",
".",
"getPointer",
"(",
")",
")",
"return",
"Sym",
";",
"if",
"(",
"MO",
".",
"isGlobal",
"(",
")",
")",
"{",
"StubSym",
"=",
"MachineModuleInfoImpl",
"::",
"StubValueTy",
"(",
"AP",
".",
"getSymbol",
"(",
"MO",
".",
"getGlobal",
"(",
")",
")",
",",
"!",
"MO",
".",
"getGlobal",
"(",
")",
"->",
"hasInternalLinkage",
"(",
")",
")",
";",
"}",
"else",
"{",
"StubSym",
"=",
"MachineModuleInfoImpl",
"::",
"StubValueTy",
"(",
"Ctx",
".",
"GetOrCreateSymbol",
"(",
"OrigName",
")",
",",
"false",
")",
";",
"}",
"return",
"Sym",
";",
"}",
"if",
"(",
"MO",
".",
"getTargetFlags",
"(",
")",
"&",
"PPCII",
"::",
"MO_NLP_FLAG",
")",
"{",
"MachineModuleInfoMachO",
"&",
"MachO",
"=",
"getMachOMMI",
"(",
"AP",
")",
";",
"MachineModuleInfoImpl",
"::",
"StubValueTy",
"&",
"StubSym",
"=",
"(",
"MO",
".",
"getTargetFlags",
"(",
")",
"&",
"PPCII",
"::",
"MO_NLP_HIDDEN_FLAG",
")",
"?",
"MachO",
".",
"getHiddenGVStubEntry",
"(",
"Sym",
")",
":",
"MachO",
".",
"getGVStubEntry",
"(",
"Sym",
")",
";",
"if",
"(",
"!",
"StubSym",
".",
"getPointer",
"(",
")",
")",
"{",
"assert",
"(",
"MO",
".",
"isGlobal",
"(",
")",
"&&",
"\"Extern symbol not handled yet\"",
")",
";",
"StubSym",
"=",
"MachineModuleInfoImpl",
"::",
"StubValueTy",
"(",
"AP",
".",
"getSymbol",
"(",
"MO",
".",
"getGlobal",
"(",
")",
")",
",",
"!",
"MO",
".",
"getGlobal",
"(",
")",
"->",
"hasInternalLinkage",
"(",
")",
")",
";",
"}",
"return",
"Sym",
";",
"}",
"return",
"Sym",
";",
"}",
"</s>"
] | [
"Lower",
"an",
"MO_GlobalAddress",
"or",
"MO_ExternalSymbol",
"operand",
"to",
"an",
"MCSymbol",
"."
] | [
"PowerPC",
"128",
"PPCII::MO_PLT_OR_STUB",
"\"$stub\"",
"PPCII::MO_NLP_FLAG",
"\"$non_lazy_ptr\"",
"\"Isn't a symbol reference\"",
"PPCII::MO_PLT_OR_STUB",
"PPCII::MO_NLP_FLAG",
"PPCII::MO_NLP_HIDDEN_FLAG",
"\"Extern symbol not handled yet\""
] | PPCMCInstLower21 | GetSymbolFromOperand | PowerPC | CPU | LLVM | 19,985 | 464 | 1 | [] |
[
"<s>",
"GCNSubtarget",
"&",
"GCNSubtarget",
"::",
"initializeSubtargetDependencies",
"(",
"const",
"Triple",
"&",
"TT",
",",
"StringRef",
"GPU",
",",
"StringRef",
"FS",
")",
"{",
"SmallString",
"<",
"256",
">",
"FullFS",
"(",
"\"+promote-alloca,+load-store-opt,+enable-ds128,+sram-ecc,+xnack,\"",
")",
";",
"if",
"(",
"isAmdHsaOS",
"(",
")",
")",
"FullFS",
"+=",
"\"+flat-for-global,+unaligned-buffer-access,+trap-handler,\"",
";",
"FullFS",
"+=",
"\"+enable-prt-strict-null,\"",
";",
"if",
"(",
"FS",
".",
"find_lower",
"(",
"\"+wavefrontsize\"",
")",
"!=",
"StringRef",
"::",
"npos",
")",
"{",
"if",
"(",
"FS",
".",
"find_lower",
"(",
"\"wavefrontsize16\"",
")",
"==",
"StringRef",
"::",
"npos",
")",
"FullFS",
"+=",
"\"-wavefrontsize16,\"",
";",
"if",
"(",
"FS",
".",
"find_lower",
"(",
"\"wavefrontsize32\"",
")",
"==",
"StringRef",
"::",
"npos",
")",
"FullFS",
"+=",
"\"-wavefrontsize32,\"",
";",
"if",
"(",
"FS",
".",
"find_lower",
"(",
"\"wavefrontsize64\"",
")",
"==",
"StringRef",
"::",
"npos",
")",
"FullFS",
"+=",
"\"-wavefrontsize64,\"",
";",
"}",
"FullFS",
"+=",
"FS",
";",
"ParseSubtargetFeatures",
"(",
"GPU",
",",
"FullFS",
")",
";",
"assert",
"(",
"!",
"hasFP64",
"(",
")",
"||",
"(",
"getGeneration",
"(",
")",
">=",
"AMDGPUSubtarget",
"::",
"SOUTHERN_ISLANDS",
")",
")",
";",
"if",
"(",
"!",
"hasAddr64",
"(",
")",
"&&",
"!",
"FS",
".",
"contains",
"(",
"\"flat-for-global\"",
")",
")",
"{",
"FlatForGlobal",
"=",
"true",
";",
"}",
"if",
"(",
"MaxPrivateElementSize",
"==",
"0",
")",
"MaxPrivateElementSize",
"=",
"4",
";",
"if",
"(",
"LDSBankCount",
"==",
"0",
")",
"LDSBankCount",
"=",
"32",
";",
"if",
"(",
"TT",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"amdgcn",
")",
"{",
"if",
"(",
"LocalMemorySize",
"==",
"0",
")",
"LocalMemorySize",
"=",
"32768",
";",
"if",
"(",
"!",
"HasMovrel",
"&&",
"!",
"HasVGPRIndexMode",
")",
"HasMovrel",
"=",
"true",
";",
"}",
"if",
"(",
"WavefrontSizeLog2",
"==",
"0",
")",
"WavefrontSizeLog2",
"=",
"5",
";",
"HasFminFmaxLegacy",
"=",
"getGeneration",
"(",
")",
"<",
"AMDGPUSubtarget",
"::",
"VOLCANIC_ISLANDS",
";",
"if",
"(",
"!",
"FS",
".",
"contains",
"(",
"\"+xnack\"",
")",
"&&",
"DoesNotSupportXNACK",
"&&",
"EnableXNACK",
")",
"{",
"ToggleFeature",
"(",
"AMDGPU",
"::",
"FeatureXNACK",
")",
";",
"EnableXNACK",
"=",
"false",
";",
"}",
"if",
"(",
"DoesNotSupportSRAMECC",
"&&",
"EnableSRAMECC",
")",
"{",
"ToggleFeature",
"(",
"AMDGPU",
"::",
"FeatureSRAMECC",
")",
";",
"EnableSRAMECC",
"=",
"false",
";",
"}",
"return",
"*",
"this",
";",
"}",
"</s>"
] | [
"initializeSubtargetDependencies",
"-",
"Initializes",
"using",
"a",
"CPU",
",",
"a",
"TuneCPU",
",",
"and",
"feature",
"string",
"so",
"that",
"we",
"can",
"use",
"initializer",
"lists",
"for",
"subtarget",
"initialization",
"."
] | [
"AMDGPU",
"256",
"\"+promote-alloca,+load-store-opt,+enable-ds128,+sram-ecc,+xnack,\"",
"\"+flat-for-global,+unaligned-buffer-access,+trap-handler,\"",
"\"+enable-prt-strict-null,\"",
"\"+wavefrontsize\"",
"\"wavefrontsize16\"",
"\"-wavefrontsize16,\"",
"\"wavefrontsize32\"",
"\"-wavefrontsize32,\"",
"\"wavefrontsize64\"",
"\"-wavefrontsize64,\"",
"AMDGPU",
"\"flat-for-global\"",
"0",
"4",
"0",
"32",
"0",
"32768",
"0",
"5",
"AMDGPU",
"\"+xnack\"",
"AMDGPU::FeatureXNACK",
"AMDGPU::FeatureSRAMECC"
] | AMDGPUSubtarget29 | initializeSubtargetDependencies | AMDGPU | GPU | LLVM | 19,986 | 284 | 1 | [] |
[
"<s>",
"void",
"AArch64PassConfig",
"::",
"addIRPasses",
"(",
")",
"{",
"addPass",
"(",
"createAtomicExpandLoadLinkedPass",
"(",
"TM",
")",
")",
";",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"EnableAtomicTidy",
")",
"addPass",
"(",
"createCFGSimplificationPass",
"(",
")",
")",
";",
"TargetPassConfig",
"::",
"addIRPasses",
"(",
")",
";",
"}",
"</s>"
] | [
"Add",
"common",
"target",
"configurable",
"passes",
"that",
"perform",
"LLVM",
"IR",
"to",
"IR",
"transforms",
"following",
"machine",
"independent",
"optimization",
"."
] | [
"AArch64",
"AArch64"
] | AArch64TargetMachine3 | addIRPasses | AArch64 | CPU | LLVM | 19,987 | 43 | 1 | [] |
[
"<s>",
"static",
"void",
"mips_avoid_hazards",
"(",
"void",
")",
"{",
"rtx",
"insn",
",",
"last_insn",
",",
"lo_reg",
",",
"delayed_reg",
";",
"int",
"hilo_delay",
",",
"i",
";",
"split_all_insns_noflow",
"(",
")",
";",
"cfun",
"->",
"machine",
"->",
"ignore_hazard_length_p",
"=",
"true",
";",
"shorten_branches",
"(",
"get_insns",
"(",
")",
")",
";",
"cfun",
"->",
"machine",
"->",
"all_noreorder_p",
"=",
"true",
";",
"if",
"(",
"current_function_profile",
")",
"cfun",
"->",
"machine",
"->",
"all_noreorder_p",
"=",
"false",
";",
"if",
"(",
"TARGET_FIX_VR4120",
")",
"cfun",
"->",
"machine",
"->",
"all_noreorder_p",
"=",
"false",
";",
"if",
"(",
"TARGET_FIX_VR4130",
"&&",
"!",
"ISA_HAS_MACCHI",
")",
"cfun",
"->",
"machine",
"->",
"all_noreorder_p",
"=",
"false",
";",
"last_insn",
"=",
"0",
";",
"hilo_delay",
"=",
"2",
";",
"delayed_reg",
"=",
"0",
";",
"lo_reg",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"LO_REGNUM",
")",
";",
"for",
"(",
"insn",
"=",
"get_insns",
"(",
")",
";",
"insn",
"!=",
"0",
";",
"insn",
"=",
"NEXT_INSN",
"(",
"insn",
")",
")",
"if",
"(",
"INSN_P",
"(",
"insn",
")",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"SEQUENCE",
")",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"XVECLEN",
"(",
"PATTERN",
"(",
"insn",
")",
",",
"0",
")",
";",
"i",
"++",
")",
"mips_avoid_hazard",
"(",
"last_insn",
",",
"XVECEXP",
"(",
"PATTERN",
"(",
"insn",
")",
",",
"0",
",",
"i",
")",
",",
"&",
"hilo_delay",
",",
"&",
"delayed_reg",
",",
"lo_reg",
")",
";",
"else",
"mips_avoid_hazard",
"(",
"last_insn",
",",
"insn",
",",
"&",
"hilo_delay",
",",
"&",
"delayed_reg",
",",
"lo_reg",
")",
";",
"last_insn",
"=",
"insn",
";",
"}",
"}",
"</s>"
] | [
"Go",
"through",
"the",
"instruction",
"stream",
"and",
"insert",
"nops",
"where",
"necessary",
".",
"See",
"if",
"the",
"whole",
"function",
"can",
"then",
"be",
"put",
"into",
".set",
"noreorder",
"&",
".set",
"nomacro",
"."
] | [
"mips",
"0",
"2",
"0",
"0",
"0",
"0",
"0"
] | mips3 | mips_avoid_hazards | mips | CPU | GCC | 19,988 | 215 | 1 | [] |
[
"<s>",
"void",
"final_prescan_insn",
"(",
"rtx_insn",
"*",
"insn",
",",
"rtx",
"opvec",
"[",
"]",
"ATTRIBUTE_UNUSED",
",",
"int",
"noperands",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"dslots_number_nops",
">",
"0",
")",
"{",
"rtx",
"pattern",
"=",
"PATTERN",
"(",
"insn",
")",
";",
"int",
"length",
"=",
"get_attr_length",
"(",
"insn",
")",
";",
"if",
"(",
"length",
"==",
"0",
"||",
"(",
"iq2000_load_reg",
"!=",
"0",
"&&",
"reg_mentioned_p",
"(",
"iq2000_load_reg",
",",
"pattern",
")",
")",
"||",
"(",
"iq2000_load_reg2",
"!=",
"0",
"&&",
"reg_mentioned_p",
"(",
"iq2000_load_reg2",
",",
"pattern",
")",
")",
"||",
"(",
"iq2000_load_reg3",
"!=",
"0",
"&&",
"reg_mentioned_p",
"(",
"iq2000_load_reg3",
",",
"pattern",
")",
")",
"||",
"(",
"iq2000_load_reg4",
"!=",
"0",
"&&",
"reg_mentioned_p",
"(",
"iq2000_load_reg4",
",",
"pattern",
")",
")",
")",
"fputs",
"(",
"\"\\tnop\\n\"",
",",
"asm_out_file",
")",
";",
"else",
"dslots_load_filled",
"++",
";",
"while",
"(",
"--",
"dslots_number_nops",
">",
"0",
")",
"fputs",
"(",
"\"\\tnop\\n\"",
",",
"asm_out_file",
")",
";",
"iq2000_load_reg",
"=",
"0",
";",
"iq2000_load_reg2",
"=",
"0",
";",
"iq2000_load_reg3",
"=",
"0",
";",
"iq2000_load_reg4",
"=",
"0",
";",
"}",
"if",
"(",
"(",
"JUMP_P",
"(",
"insn",
")",
"||",
"CALL_P",
"(",
"insn",
")",
"||",
"(",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"RETURN",
")",
")",
"&&",
"NEXT_INSN",
"(",
"PREV_INSN",
"(",
"insn",
")",
")",
"==",
"insn",
")",
"{",
"rtx_insn",
"*",
"nop_insn",
"=",
"emit_insn_after",
"(",
"gen_nop",
"(",
")",
",",
"insn",
")",
";",
"INSN_ADDRESSES_NEW",
"(",
"nop_insn",
",",
"-",
"1",
")",
";",
"}",
"if",
"(",
"TARGET_STATS",
"&&",
"(",
"JUMP_P",
"(",
"insn",
")",
"||",
"CALL_P",
"(",
"insn",
")",
")",
")",
"dslots_jump_total",
"++",
";",
"}",
"</s>"
] | [
"If",
"defined",
",",
"a",
"C",
"statement",
"to",
"be",
"executed",
"just",
"prior",
"to",
"the",
"output",
"of",
"assembler",
"code",
"for",
"INSN",
",",
"to",
"modify",
"the",
"extracted",
"operands",
"so",
"they",
"will",
"be",
"output",
"differently",
".",
"Here",
"the",
"argument",
"OPVEC",
"is",
"the",
"vector",
"containing",
"the",
"operands",
"extracted",
"from",
"INSN",
",",
"and",
"NOPERANDS",
"is",
"the",
"number",
"of",
"elements",
"of",
"the",
"vector",
"which",
"contain",
"meaningful",
"data",
"for",
"this",
"insn",
".",
"The",
"contents",
"of",
"this",
"vector",
"are",
"what",
"will",
"be",
"used",
"to",
"convert",
"the",
"insn",
"template",
"into",
"assembler",
"code",
",",
"so",
"you",
"can",
"change",
"the",
"assembler",
"output",
"by",
"changing",
"the",
"contents",
"of",
"the",
"vector",
".",
"We",
"use",
"it",
"to",
"check",
"if",
"the",
"current",
"insn",
"needs",
"a",
"nop",
"in",
"front",
"of",
"it",
"because",
"of",
"load",
"delays",
",",
"and",
"also",
"to",
"update",
"the",
"delay",
"slot",
"statistics",
"."
] | [
"iq2000",
"0",
"0",
"0",
"0",
"0",
"0",
"\"\\tnop\\n\"",
"0",
"\"\\tnop\\n\"",
"0",
"0",
"0",
"0",
"1"
] | iq2000 | final_prescan_insn | iq2000 | CPU | GCC | 19,989 | 220 | 1 | [] |
[
"<s>",
"int",
"AMDGPUTTIImpl",
"::",
"getArithmeticReductionCost",
"(",
"unsigned",
"Opcode",
",",
"Type",
"*",
"Ty",
",",
"bool",
"IsPairwise",
")",
"{",
"EVT",
"OrigTy",
"=",
"TLI",
"->",
"getValueType",
"(",
"DL",
",",
"Ty",
")",
";",
"if",
"(",
"IsPairwise",
"||",
"!",
"ST",
"->",
"hasVOP3PInsts",
"(",
")",
"||",
"OrigTy",
".",
"getScalarSizeInBits",
"(",
")",
"!=",
"16",
")",
"return",
"BaseT",
"::",
"getArithmeticReductionCost",
"(",
"Opcode",
",",
"Ty",
",",
"IsPairwise",
")",
";",
"std",
"::",
"pair",
"<",
"int",
",",
"MVT",
">",
"LT",
"=",
"TLI",
"->",
"getTypeLegalizationCost",
"(",
"DL",
",",
"Ty",
")",
";",
"return",
"LT",
".",
"first",
"*",
"getFullRateInstrCost",
"(",
")",
";",
"}",
"</s>"
] | [
"Calculate",
"the",
"cost",
"of",
"vector",
"reduction",
"intrinsics",
"."
] | [
"AMDGPU",
"AMDGPU",
"16"
] | AMDGPUTargetTransformInfo15 | getArithmeticReductionCost | AMDGPU | GPU | LLVM | 19,990 | 88 | 1 | [] |
[
"<s>",
"bool",
"X86RegisterInfo",
"::",
"canRealignStack",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"if",
"(",
"!",
"TargetRegisterInfo",
"::",
"canRealignStack",
"(",
"MF",
")",
")",
"return",
"false",
";",
"const",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"MachineRegisterInfo",
"*",
"MRI",
"=",
"&",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"if",
"(",
"!",
"MRI",
"->",
"canReserveReg",
"(",
"FramePtr",
")",
")",
"return",
"false",
";",
"if",
"(",
"CantUseSP",
"(",
"MFI",
")",
")",
"return",
"MRI",
"->",
"canReserveReg",
"(",
"BasePtr",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"True",
"if",
"the",
"stack",
"can",
"be",
"realigned",
"for",
"the",
"target",
"."
] | [
"X86",
"X86"
] | X86RegisterInfo (2)1 | canRealignStack | X86 | CPU | LLVM | 19,991 | 80 | 1 | [] |
[
"<s>",
"void",
"LC2200AsmBackend",
"::",
"relaxInstruction",
"(",
"const",
"MCInst",
"&",
"Inst",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
",",
"MCInst",
"&",
"Res",
")",
"const",
"{",
"}",
"</s>"
] | [
"Relax",
"the",
"instruction",
"in",
"the",
"given",
"fragment",
"to",
"the",
"next",
"wider",
"instruction",
"."
] | [
"LC2200",
"LC2200"
] | LC2200AsmBackend | relaxInstruction | LC2200 | CPU | LLVM | 19,992 | 22 | 1 | [] |
[
"<s>",
"bool",
"AArch64LowerHomogeneousPE",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"TII",
"=",
"static_cast",
"<",
"const",
"AArch64InstrInfo",
"*",
">",
"(",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";",
"bool",
"Modified",
"=",
"false",
";",
"for",
"(",
"auto",
"&",
"MBB",
":",
"MF",
")",
"Modified",
"|=",
"runOnMBB",
"(",
"MBB",
")",
";",
"return",
"Modified",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"AArch64",
"AArch64",
"AArch64"
] | AArch64LowerHomogeneousPrologEpilog | runOnMachineFunction | AArch64 | CPU | LLVM | 19,993 | 54 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUAsmParser",
"::",
"ParseInstruction",
"(",
"ParseInstructionInfo",
"&",
"Info",
",",
"StringRef",
"Name",
",",
"SMLoc",
"NameLoc",
",",
"OperandVector",
"&",
"Operands",
")",
"{",
"Name",
"=",
"parseMnemonicSuffix",
"(",
"Name",
")",
";",
"Operands",
".",
"push_back",
"(",
"AMDGPUOperand",
"::",
"CreateToken",
"(",
"this",
",",
"Name",
",",
"NameLoc",
")",
")",
";",
"bool",
"IsMIMG",
"=",
"Name",
".",
"startswith",
"(",
"\"image_\"",
")",
";",
"while",
"(",
"!",
"trySkipToken",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"OperandMode",
"Mode",
"=",
"OperandMode_Default",
";",
"if",
"(",
"IsMIMG",
"&&",
"isGFX10Plus",
"(",
")",
"&&",
"Operands",
".",
"size",
"(",
")",
"==",
"2",
")",
"Mode",
"=",
"OperandMode_NSA",
";",
"CPolSeen",
"=",
"0",
";",
"OperandMatchResultTy",
"Res",
"=",
"parseOperand",
"(",
"Operands",
",",
"Name",
",",
"Mode",
")",
";",
"if",
"(",
"Res",
"!=",
"MatchOperand_Success",
")",
"{",
"checkUnsupportedInstruction",
"(",
"Name",
",",
"NameLoc",
")",
";",
"if",
"(",
"!",
"Parser",
".",
"hasPendingError",
"(",
")",
")",
"{",
"StringRef",
"Msg",
"=",
"(",
"Res",
"==",
"MatchOperand_ParseFail",
")",
"?",
"\"failed parsing operand.\"",
":",
"\"not a valid operand.\"",
";",
"Error",
"(",
"getLoc",
"(",
")",
",",
"Msg",
")",
";",
"}",
"while",
"(",
"!",
"trySkipToken",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"lex",
"(",
")",
";",
"}",
"return",
"true",
";",
"}",
"trySkipToken",
"(",
"AsmToken",
"::",
"Comma",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"ParseInstruction",
"-",
"Parse",
"one",
"assembly",
"instruction",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU",
"\"image_\"",
"2",
"0",
"\"failed parsing operand.\"",
"\"not a valid operand.\""
] | AMDGPUAsmParser1 | ParseInstruction | AMDGPU | GPU | LLVM | 19,994 | 184 | 1 | [] |
[
"<s>",
"static",
"int",
"index_term_p",
"(",
"rtx",
"prod",
",",
"enum",
"machine_mode",
"mode",
",",
"int",
"strict",
")",
"{",
"rtx",
"xfoo0",
",",
"xfoo1",
";",
"if",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
"==",
"1",
")",
"return",
"BASE_REGISTER_P",
"(",
"prod",
",",
"strict",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"prod",
")",
"!=",
"MULT",
"||",
"GET_MODE_SIZE",
"(",
"mode",
")",
">",
"8",
")",
"return",
"0",
";",
"xfoo0",
"=",
"XEXP",
"(",
"prod",
",",
"0",
")",
";",
"xfoo1",
"=",
"XEXP",
"(",
"prod",
",",
"1",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"xfoo0",
")",
"==",
"CONST_INT",
"&&",
"INTVAL",
"(",
"xfoo0",
")",
"==",
"(",
"int",
")",
"GET_MODE_SIZE",
"(",
"mode",
")",
"&&",
"INDEX_REGISTER_P",
"(",
"xfoo1",
",",
"strict",
")",
")",
"return",
"1",
";",
"if",
"(",
"GET_CODE",
"(",
"xfoo1",
")",
"==",
"CONST_INT",
"&&",
"INTVAL",
"(",
"xfoo1",
")",
"==",
"(",
"int",
")",
"GET_MODE_SIZE",
"(",
"mode",
")",
"&&",
"INDEX_REGISTER_P",
"(",
"xfoo0",
",",
"strict",
")",
")",
"return",
"1",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"1",
"if",
"PROD",
"is",
"either",
"a",
"reg",
"times",
"size",
"of",
"mode",
"MODE",
"and",
"MODE",
"is",
"less",
"than",
"or",
"equal",
"8",
"bytes",
",",
"or",
"just",
"a",
"reg",
"if",
"MODE",
"is",
"one",
"byte",
"."
] | [
"vax",
"1",
"8",
"0",
"0",
"1",
"1",
"1",
"0"
] | vax3 | index_term_p | vax | CPU | GCC | 19,995 | 142 | 1 | [] |
[
"<s>",
"void",
"c6x_init_cumulative_args",
"(",
"CUMULATIVE_ARGS",
"*",
"cum",
",",
"const_tree",
"fntype",
",",
"rtx",
"libname",
",",
"int",
"n_named_args",
"ATTRIBUTE_UNUSED",
")",
"{",
"cum",
"->",
"count",
"=",
"0",
";",
"cum",
"->",
"nregs",
"=",
"10",
";",
"if",
"(",
"!",
"libname",
"&&",
"fntype",
")",
"{",
"if",
"(",
"stdarg_p",
"(",
"fntype",
")",
")",
"cum",
"->",
"nregs",
"=",
"type_num_arguments",
"(",
"fntype",
")",
"-",
"1",
";",
"if",
"(",
"cum",
"->",
"nregs",
">",
"10",
")",
"cum",
"->",
"nregs",
"=",
"10",
";",
"}",
"}",
"</s>"
] | [
"Implements",
"the",
"macro",
"INIT_CUMULATIVE_ARGS",
"defined",
"in",
"c6x.h",
"."
] | [
"c6x",
"0",
"10",
"1",
"10",
"10"
] | c6x | c6x_init_cumulative_args | c6x | VLIW | GCC | 19,996 | 72 | 1 | [] |
[
"<s>",
"char",
"*",
"get_name",
"(",
"function_builder",
"&",
"b",
",",
"const",
"function_instance",
"&",
"instance",
",",
"bool",
"overloaded_p",
")",
"const",
"override",
"{",
"if",
"(",
"overloaded_p",
")",
"if",
"(",
"instance",
".",
"pred",
"==",
"PRED_TYPE_none",
"||",
"instance",
".",
"pred",
"==",
"PRED_TYPE_mu",
")",
"return",
"nullptr",
";",
"tree",
"type",
"=",
"builtin_types",
"[",
"instance",
".",
"type",
".",
"index",
"]",
".",
"vector",
";",
"machine_mode",
"mode",
"=",
"TYPE_MODE",
"(",
"type",
")",
";",
"int",
"sew",
"=",
"GET_MODE_BITSIZE",
"(",
"GET_MODE_INNER",
"(",
"mode",
")",
")",
";",
"b",
".",
"append_name",
"(",
"\"__riscv_\"",
")",
";",
"b",
".",
"append_name",
"(",
"\"vle\"",
")",
";",
"b",
".",
"append_sew",
"(",
"sew",
")",
";",
"b",
".",
"append_name",
"(",
"\"ff\"",
")",
";",
"if",
"(",
"!",
"overloaded_p",
")",
"{",
"b",
".",
"append_name",
"(",
"operand_suffixes",
"[",
"instance",
".",
"op_info",
"->",
"op",
"]",
")",
";",
"b",
".",
"append_name",
"(",
"type_suffixes",
"[",
"instance",
".",
"type",
".",
"index",
"]",
".",
"vector",
")",
";",
"}",
"if",
"(",
"overloaded_p",
"&&",
"instance",
".",
"pred",
"==",
"PRED_TYPE_m",
")",
"return",
"b",
".",
"finish_name",
"(",
")",
";",
"b",
".",
"append_name",
"(",
"predication_suffixes",
"[",
"instance",
".",
"pred",
"]",
")",
";",
"return",
"b",
".",
"finish_name",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"overloaded",
"or",
"full",
"function",
"name",
"for",
"INSTANCE",
";",
"OVERLOADED_P",
"selects",
"which",
".",
"Allocate",
"the",
"string",
"on",
"m_string_obstack",
";",
"the",
"caller",
"must",
"use",
"obstack_free",
"to",
"free",
"it",
"after",
"use",
"."
] | [
"riscv",
"\"__riscv_\"",
"\"vle\"",
"\"ff\""
] | riscv-vector-builtins-shapes | get_name | riscv | CPU | GCC | 19,997 | 175 | 1 | [] |
[
"<s>",
"bool",
"ARMSubtarget",
"::",
"enablePostRAScheduler",
"(",
"CodeGenOpt",
"::",
"Level",
"OptLevel",
",",
"TargetSubtarget",
"::",
"AntiDepBreakMode",
"&",
"Mode",
",",
"RegClassVector",
"&",
"CriticalPathRCs",
")",
"const",
"{",
"Mode",
"=",
"TargetSubtarget",
"::",
"ANTIDEP_CRITICAL",
";",
"CriticalPathRCs",
".",
"clear",
"(",
")",
";",
"CriticalPathRCs",
".",
"push_back",
"(",
"&",
"ARM",
"::",
"GPRRegClass",
")",
";",
"return",
"PostRAScheduler",
"&&",
"OptLevel",
">=",
"CodeGenOpt",
"::",
"Default",
";",
"}",
"</s>"
] | [
"True",
"if",
"the",
"subtarget",
"should",
"run",
"a",
"scheduler",
"after",
"register",
"allocation",
"."
] | [
"ARM",
"ARM",
"ARM::GPRRegClass"
] | ARMSubtarget10 | enablePostRAScheduler | ARM | CPU | LLVM | 19,998 | 54 | 1 | [] |
[
"<s>",
"bool",
"ARMSubtarget",
"::",
"isGVInGOT",
"(",
"const",
"GlobalValue",
"*",
"GV",
")",
"const",
"{",
"return",
"isTargetELF",
"(",
")",
"&&",
"TM",
".",
"isPositionIndependent",
"(",
")",
"&&",
"!",
"TM",
".",
"shouldAssumeDSOLocal",
"(",
"*",
"GV",
"->",
"getParent",
"(",
")",
",",
"GV",
")",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"constant",
"pool",
"modifier",
"needed",
"to",
"access",
"the",
"GV",
"."
] | [
"ARM",
"ARM"
] | ARMSubtarget | isGVInGOT | ARM | CPU | LLVM | 19,999 | 39 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.