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>",
"static",
"ChildIteratorType",
"child_begin",
"(",
"const",
"NodeRef",
"N",
")",
"{",
"return",
"N",
"->",
"child_begin",
"(",
")",
";",
"}",
"</s>"
] | [
"nodes_iterator/begin/end",
"-",
"Allow",
"iteration",
"over",
"all",
"nodes",
"in",
"the",
"graph"
] | [
"Patmos"
] | SPScope1 | child_begin | Patmos | VLIW | LLVM | 19,300 | 17 | 1 | [] |
[
"<s>",
"void",
"neon_lane_bounds",
"(",
"rtx",
"operand",
",",
"HOST_WIDE_INT",
"low",
",",
"HOST_WIDE_INT",
"high",
",",
"const_tree",
"exp",
")",
"{",
"bounds_check",
"(",
"operand",
",",
"low",
",",
"high",
",",
"exp",
",",
"\"lane\"",
")",
";",
"}",
"</s>"
] | [
"Bounds-check",
"lanes",
"."
] | [
"arm",
"\"lane\""
] | arm | neon_lane_bounds | arm | CPU | GCC | 19,301 | 30 | 1 | [] |
[
"<s>",
"static",
"HOST_WIDE_INT",
"round_frame_size",
"(",
"HOST_WIDE_INT",
"size",
")",
"{",
"return",
"(",
"(",
"size",
"+",
"STACK_BOUNDARY",
"/",
"BITS_PER_UNIT",
"-",
"1",
")",
"&",
"-",
"STACK_BOUNDARY",
"/",
"BITS_PER_UNIT",
")",
";",
"}",
"</s>"
] | [
"Round",
"up",
"frame",
"size",
"SIZE",
"."
] | [
"h8300",
"1"
] | h8300 | round_frame_size | h8300 | MPU | GCC | 19,302 | 27 | 1 | [] |
[
"<s>",
"static",
"int",
"tilepro_pic_address_needs_scratch",
"(",
"rtx",
"x",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"CONST",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
"==",
"PLUS",
"&&",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"0",
")",
")",
"==",
"SYMBOL_REF",
"||",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"0",
")",
")",
"==",
"LABEL_REF",
")",
"&&",
"CONST_INT_P",
"(",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"1",
")",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"X",
"requires",
"a",
"scratch",
"register",
".",
"It",
"is",
"given",
"that",
"flag_pic",
"is",
"on",
"and",
"that",
"X",
"satisfies",
"CONSTANT_P",
"."
] | [
"tilepro",
"0",
"0",
"0",
"0",
"0",
"0",
"1"
] | tilepro | tilepro_pic_address_needs_scratch | tilepro | VLIW | GCC | 19,303 | 87 | 1 | [] |
[
"<s>",
"static",
"enum",
"tls_model",
"tls_symbolic_operand_type",
"(",
"rtx",
"addr",
")",
"{",
"enum",
"tls_model",
"tls_kind",
"=",
"TLS_MODEL_NONE",
";",
"rtx",
"sym",
",",
"addend",
";",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"CONST",
")",
"{",
"split_const",
"(",
"addr",
",",
"&",
"sym",
",",
"&",
"addend",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"sym",
")",
"==",
"SYMBOL_REF",
")",
"tls_kind",
"=",
"SYMBOL_REF_TLS_MODEL",
"(",
"sym",
")",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"SYMBOL_REF",
")",
"tls_kind",
"=",
"SYMBOL_REF_TLS_MODEL",
"(",
"addr",
")",
";",
"return",
"tls_kind",
";",
"}",
"</s>"
] | [
"Return",
"the",
"TLS",
"model",
"to",
"use",
"for",
"SYMBOL",
"."
] | [
"aarch64"
] | aarch642 | tls_symbolic_operand_type | aarch64 | CPU | GCC | 19,304 | 79 | 1 | [] |
[
"<s>",
"bool",
"RISCVAsmParser",
"::",
"ParseDirective",
"(",
"AsmToken",
"DirectiveID",
")",
"{",
"StringRef",
"IDVal",
"=",
"DirectiveID",
".",
"getString",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".option\"",
")",
"return",
"parseDirectiveOption",
"(",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"ParseDirective",
"-",
"Parse",
"a",
"target",
"specific",
"assembler",
"directive",
"This",
"method",
"is",
"deprecated",
",",
"use",
"'parseDirective",
"'",
"instead",
"."
] | [
"RISCV",
"RISCV",
"\".option\""
] | RISCVAsmParser | ParseDirective | RISCV | CPU | LLVM | 19,305 | 33 | 1 | [] |
[
"<s>",
"unsigned",
"getNumFixupKinds",
"(",
")",
"const",
"override",
"{",
"return",
"UPT",
"::",
"NumTargetFixupKinds",
";",
"}",
"</s>"
] | [
"Get",
"the",
"number",
"of",
"target",
"specific",
"fixup",
"kinds",
"."
] | [
"UPT",
"UPT::NumTargetFixupKinds"
] | UPTAsmBackend | getNumFixupKinds | UPT | CPU | LLVM | 19,306 | 13 | 1 | [] |
[
"<s>",
"bool",
"PPCInstrInfo",
"::",
"canInsertSelect",
"(",
"const",
"MachineBasicBlock",
"&",
"MBB",
",",
"const",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"Cond",
",",
"unsigned",
"TrueReg",
",",
"unsigned",
"FalseReg",
",",
"int",
"&",
"CondCycles",
",",
"int",
"&",
"TrueCycles",
",",
"int",
"&",
"FalseCycles",
")",
"const",
"{",
"if",
"(",
"!",
"TM",
".",
"getSubtargetImpl",
"(",
")",
"->",
"hasISEL",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"Cond",
".",
"size",
"(",
")",
"!=",
"2",
")",
"return",
"false",
";",
"if",
"(",
"Cond",
"[",
"1",
"]",
".",
"getReg",
"(",
")",
"==",
"PPC",
"::",
"CTR",
"||",
"Cond",
"[",
"1",
"]",
".",
"getReg",
"(",
")",
"==",
"PPC",
"::",
"CTR8",
")",
"return",
"false",
";",
"const",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MBB",
".",
"getParent",
"(",
")",
"->",
"getRegInfo",
"(",
")",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"RI",
".",
"getCommonSubClass",
"(",
"MRI",
".",
"getRegClass",
"(",
"TrueReg",
")",
",",
"MRI",
".",
"getRegClass",
"(",
"FalseReg",
")",
")",
";",
"if",
"(",
"!",
"RC",
")",
"return",
"false",
";",
"if",
"(",
"!",
"PPC",
"::",
"GPRCRegClass",
".",
"hasSubClassEq",
"(",
"RC",
")",
"&&",
"!",
"PPC",
"::",
"GPRC_NOR0RegClass",
".",
"hasSubClassEq",
"(",
"RC",
")",
"&&",
"!",
"PPC",
"::",
"G8RCRegClass",
".",
"hasSubClassEq",
"(",
"RC",
")",
"&&",
"!",
"PPC",
"::",
"G8RC_NOX0RegClass",
".",
"hasSubClassEq",
"(",
"RC",
")",
")",
"return",
"false",
";",
"CondCycles",
"=",
"1",
";",
"TrueCycles",
"=",
"1",
";",
"FalseCycles",
"=",
"1",
";",
"return",
"true",
";",
"}",
"</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",
"."
] | [
"PowerPC",
"PPC",
"2",
"1",
"PPC::CTR",
"1",
"PPC::CTR8",
"PPC::GPRCRegClass",
"PPC::GPRC_NOR0RegClass",
"PPC::G8RCRegClass",
"PPC::G8RC_NOX0RegClass",
"1",
"1",
"1"
] | PPCInstrInfo (2) | canInsertSelect | PowerPC | CPU | LLVM | 19,307 | 206 | 1 | [] |
[
"<s>",
"RegisterAggr",
"&",
"RegisterAggr",
"::",
"clear",
"(",
"const",
"RegisterAggr",
"&",
"RG",
")",
"{",
"for",
"(",
"std",
"::",
"pair",
"<",
"RegisterId",
",",
"LaneBitmask",
">",
"P",
":",
"RG",
".",
"Masks",
")",
"clear",
"(",
"RegisterRef",
"(",
"P",
".",
"first",
",",
"P",
".",
"second",
")",
")",
";",
"return",
"*",
"this",
";",
"}",
"</s>"
] | [
"Clear",
"all",
"timers",
"in",
"this",
"group",
"."
] | [
"Hexagon"
] | RDFGraph7 | clear | Hexagon | DSP | LLVM | 19,308 | 47 | 1 | [] |
[
"<s>",
"const",
"TargetRegisterClass",
"*",
"SITargetLowering",
"::",
"getRegClassFor",
"(",
"MVT",
"VT",
",",
"bool",
"isDivergent",
")",
"const",
"{",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"TargetLoweringBase",
"::",
"getRegClassFor",
"(",
"VT",
",",
"false",
")",
";",
"const",
"SIRegisterInfo",
"*",
"TRI",
"=",
"Subtarget",
"->",
"getRegisterInfo",
"(",
")",
";",
"if",
"(",
"RC",
"==",
"&",
"AMDGPU",
"::",
"VReg_1RegClass",
"&&",
"!",
"isDivergent",
")",
"return",
"&",
"AMDGPU",
"::",
"SReg_64RegClass",
";",
"if",
"(",
"!",
"TRI",
"->",
"isSGPRClass",
"(",
"RC",
")",
"&&",
"!",
"isDivergent",
")",
"return",
"TRI",
"->",
"getEquivalentSGPRClass",
"(",
"RC",
")",
";",
"else",
"if",
"(",
"TRI",
"->",
"isSGPRClass",
"(",
"RC",
")",
"&&",
"isDivergent",
")",
"return",
"TRI",
"->",
"getEquivalentVGPRClass",
"(",
"RC",
")",
";",
"return",
"RC",
";",
"}",
"</s>"
] | [
"Return",
"the",
"register",
"class",
"that",
"should",
"be",
"used",
"for",
"the",
"specified",
"value",
"type",
"."
] | [
"AMDGPU",
"SI",
"SI",
"AMDGPU::VReg_1RegClass",
"AMDGPU::SReg_64RegClass"
] | SIISelLowering103 | getRegClassFor | AMDGPU | GPU | LLVM | 19,309 | 103 | 1 | [] |
[
"<s>",
"static",
"rtx",
"frv_expand_store_builtin",
"(",
"enum",
"insn_code",
"icode",
",",
"tree",
"call",
")",
"{",
"rtx",
"op0",
"=",
"frv_read_argument",
"(",
"call",
",",
"0",
")",
";",
"rtx",
"op1",
"=",
"frv_read_argument",
"(",
"call",
",",
"1",
")",
";",
"rtx",
"cookie",
"=",
"frv_io_address_cookie",
"(",
"op0",
")",
";",
"op0",
"=",
"frv_volatile_memref",
"(",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"0",
"]",
".",
"mode",
",",
"op0",
")",
";",
"convert_move",
"(",
"op0",
",",
"force_reg",
"(",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"0",
"]",
".",
"mode",
",",
"op1",
")",
",",
"1",
")",
";",
"emit_insn",
"(",
"GEN_FCN",
"(",
"icode",
")",
"(",
"copy_rtx",
"(",
"op0",
")",
",",
"cookie",
",",
"GEN_INT",
"(",
"FRV_IO_WRITE",
")",
")",
")",
";",
"cfun",
"->",
"machine",
"->",
"has_membar_p",
"=",
"1",
";",
"return",
"NULL_RTX",
";",
"}",
"</s>"
] | [
"Likewise",
"__builtin_write",
"*",
"functions",
"."
] | [
"frv",
"0",
"1",
"0",
"0",
"1",
"1"
] | frv | frv_expand_store_builtin | frv | VLIW | GCC | 19,310 | 116 | 1 | [] |
[
"<s>",
"void",
"aarch64_swap_ldrstr_operands",
"(",
"rtx",
"*",
"operands",
",",
"bool",
"load",
")",
"{",
"rtx",
"mem_1",
",",
"mem_2",
",",
"base_1",
",",
"base_2",
",",
"offset_1",
",",
"offset_2",
";",
"HOST_WIDE_INT",
"offval_1",
",",
"offval_2",
";",
"if",
"(",
"load",
")",
"{",
"mem_1",
"=",
"operands",
"[",
"1",
"]",
";",
"mem_2",
"=",
"operands",
"[",
"3",
"]",
";",
"}",
"else",
"{",
"mem_1",
"=",
"operands",
"[",
"0",
"]",
";",
"mem_2",
"=",
"operands",
"[",
"2",
"]",
";",
"}",
"extract_base_offset_in_addr",
"(",
"mem_1",
",",
"&",
"base_1",
",",
"&",
"offset_1",
")",
";",
"extract_base_offset_in_addr",
"(",
"mem_2",
",",
"&",
"base_2",
",",
"&",
"offset_2",
")",
";",
"offval_1",
"=",
"INTVAL",
"(",
"offset_1",
")",
";",
"offval_2",
"=",
"INTVAL",
"(",
"offset_2",
")",
";",
"if",
"(",
"offval_1",
">",
"offval_2",
")",
"{",
"std",
"::",
"swap",
"(",
"operands",
"[",
"0",
"]",
",",
"operands",
"[",
"2",
"]",
")",
";",
"std",
"::",
"swap",
"(",
"operands",
"[",
"1",
"]",
",",
"operands",
"[",
"3",
"]",
")",
";",
"}",
"}",
"</s>"
] | [
"Given",
"OPERANDS",
"of",
"consecutive",
"load/store",
"that",
"can",
"be",
"merged",
",",
"swap",
"them",
"if",
"they",
"are",
"not",
"in",
"ascending",
"order",
"."
] | [
"aarch64",
"1",
"3",
"0",
"2",
"0",
"2",
"1",
"3"
] | aarch64 | aarch64_swap_ldrstr_operands | aarch64 | CPU | GCC | 19,311 | 141 | 1 | [] |
[
"<s>",
"void",
"SIInstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"DestReg",
",",
"int",
"FrameIndex",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"SIMachineFunctionInfo",
"*",
"MFI",
"=",
"MF",
"->",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"MachineFrameInfo",
"&",
"FrameInfo",
"=",
"MF",
"->",
"getFrameInfo",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"MBB",
".",
"findDebugLoc",
"(",
"MI",
")",
";",
"unsigned",
"Align",
"=",
"FrameInfo",
".",
"getObjectAlignment",
"(",
"FrameIndex",
")",
";",
"unsigned",
"Size",
"=",
"FrameInfo",
".",
"getObjectSize",
"(",
"FrameIndex",
")",
";",
"unsigned",
"SpillSize",
"=",
"TRI",
"->",
"getSpillSize",
"(",
"*",
"RC",
")",
";",
"MachinePointerInfo",
"PtrInfo",
"=",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"*",
"MF",
",",
"FrameIndex",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
"->",
"getMachineMemOperand",
"(",
"PtrInfo",
",",
"MachineMemOperand",
"::",
"MOLoad",
",",
"Size",
",",
"Align",
")",
";",
"if",
"(",
"RI",
".",
"isSGPRClass",
"(",
"RC",
")",
")",
"{",
"const",
"MCInstrDesc",
"&",
"OpDesc",
"=",
"get",
"(",
"getSGPRSpillRestoreOpcode",
"(",
"SpillSize",
")",
")",
";",
"if",
"(",
"TargetRegisterInfo",
"::",
"isVirtualRegister",
"(",
"DestReg",
")",
"&&",
"SpillSize",
"==",
"4",
")",
"{",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"MRI",
".",
"constrainRegClass",
"(",
"DestReg",
",",
"&",
"AMDGPU",
"::",
"SReg_32_XM0RegClass",
")",
";",
"}",
"MachineInstrBuilder",
"Spill",
"=",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"OpDesc",
",",
"DestReg",
")",
".",
"addFrameIndex",
"(",
"FrameIndex",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getScratchRSrcReg",
"(",
")",
",",
"RegState",
"::",
"Implicit",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getScratchWaveOffsetReg",
"(",
")",
",",
"RegState",
"::",
"Implicit",
")",
";",
"if",
"(",
"ST",
".",
"hasScalarStores",
"(",
")",
")",
"{",
"Spill",
".",
"addReg",
"(",
"AMDGPU",
"::",
"M0",
",",
"RegState",
"::",
"ImplicitDefine",
")",
";",
"}",
"return",
";",
"}",
"if",
"(",
"!",
"ST",
".",
"isVGPRSpillingEnabled",
"(",
"*",
"MF",
"->",
"getFunction",
"(",
")",
")",
")",
"{",
"LLVMContext",
"&",
"Ctx",
"=",
"MF",
"->",
"getFunction",
"(",
")",
"->",
"getContext",
"(",
")",
";",
"Ctx",
".",
"emitError",
"(",
"\"SIInstrInfo::loadRegFromStackSlot - Do not know how to\"",
"\" restore register\"",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"AMDGPU",
"::",
"IMPLICIT_DEF",
")",
",",
"DestReg",
")",
";",
"return",
";",
"}",
"assert",
"(",
"RI",
".",
"hasVGPRs",
"(",
"RC",
")",
"&&",
"\"Only VGPR spilling expected\"",
")",
";",
"unsigned",
"Opcode",
"=",
"getVGPRSpillRestoreOpcode",
"(",
"SpillSize",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Opcode",
")",
",",
"DestReg",
")",
".",
"addFrameIndex",
"(",
"FrameIndex",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getScratchRSrcReg",
"(",
")",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getScratchWaveOffsetReg",
"(",
")",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"}",
"</s>"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"4",
"AMDGPU::SReg_32_XM0RegClass",
"AMDGPU::M0",
"\"SIInstrInfo::loadRegFromStackSlot - Do not know how to\"",
"\" restore register\"",
"AMDGPU::IMPLICIT_DEF",
"\"Only VGPR spilling expected\"",
"0"
] | SIInstrInfo39 | loadRegFromStackSlot | AMDGPU | GPU | LLVM | 19,312 | 406 | 1 | [] |
[
"<s>",
"static",
"void",
"cris_option_override",
"(",
"void",
")",
"{",
"if",
"(",
"cris_max_stackframe_str",
")",
"{",
"cris_max_stackframe",
"=",
"atoi",
"(",
"cris_max_stackframe_str",
")",
";",
"if",
"(",
"cris_max_stackframe",
"<",
"0",
"||",
"cris_max_stackframe",
">",
"0x20000000",
")",
"internal_error",
"(",
"\"-max-stackframe=%d is not usable, not between 0 and %d\"",
",",
"cris_max_stackframe",
",",
"0x20000000",
")",
";",
"}",
"if",
"(",
"TARGET_SVINTO",
"&&",
"cris_cpu_version",
"<",
"CRIS_CPU_SVINTO",
")",
"cris_cpu_version",
"=",
"CRIS_CPU_SVINTO",
";",
"else",
"if",
"(",
"TARGET_ETRAX4_ADD",
"&&",
"cris_cpu_version",
"<",
"CRIS_CPU_ETRAX4",
")",
"cris_cpu_version",
"=",
"CRIS_CPU_ETRAX4",
";",
"if",
"(",
"cris_cpu_str",
")",
"{",
"cris_cpu_version",
"=",
"(",
"*",
"cris_cpu_str",
"==",
"'v'",
"?",
"atoi",
"(",
"cris_cpu_str",
"+",
"1",
")",
":",
"-",
"1",
")",
";",
"if",
"(",
"strcmp",
"(",
"\"etrax4\"",
",",
"cris_cpu_str",
")",
"==",
"0",
")",
"cris_cpu_version",
"=",
"3",
";",
"if",
"(",
"strcmp",
"(",
"\"svinto\"",
",",
"cris_cpu_str",
")",
"==",
"0",
"||",
"strcmp",
"(",
"\"etrax100\"",
",",
"cris_cpu_str",
")",
"==",
"0",
")",
"cris_cpu_version",
"=",
"8",
";",
"if",
"(",
"strcmp",
"(",
"\"ng\"",
",",
"cris_cpu_str",
")",
"==",
"0",
"||",
"strcmp",
"(",
"\"etrax100lx\"",
",",
"cris_cpu_str",
")",
"==",
"0",
")",
"cris_cpu_version",
"=",
"10",
";",
"if",
"(",
"cris_cpu_version",
"<",
"0",
"||",
"cris_cpu_version",
">",
"32",
")",
"error",
"(",
"\"unknown CRIS version specification in -march= or -mcpu= : %s\"",
",",
"cris_cpu_str",
")",
";",
"if",
"(",
"cris_cpu_version",
">=",
"CRIS_CPU_ETRAX4",
")",
"target_flags",
"|=",
"MASK_ETRAX4_ADD",
";",
"if",
"(",
"cris_cpu_version",
">=",
"CRIS_CPU_SVINTO",
")",
"target_flags",
"|=",
"(",
"MASK_SVINTO",
"|",
"MASK_ALIGN_BY_32",
"|",
"MASK_STACK_ALIGN",
"|",
"MASK_CONST_ALIGN",
"|",
"MASK_DATA_ALIGN",
")",
";",
"}",
"if",
"(",
"cris_tune_str",
")",
"{",
"int",
"cris_tune",
"=",
"(",
"*",
"cris_tune_str",
"==",
"'v'",
"?",
"atoi",
"(",
"cris_tune_str",
"+",
"1",
")",
":",
"-",
"1",
")",
";",
"if",
"(",
"strcmp",
"(",
"\"etrax4\"",
",",
"cris_tune_str",
")",
"==",
"0",
")",
"cris_tune",
"=",
"3",
";",
"if",
"(",
"strcmp",
"(",
"\"svinto\"",
",",
"cris_tune_str",
")",
"==",
"0",
"||",
"strcmp",
"(",
"\"etrax100\"",
",",
"cris_tune_str",
")",
"==",
"0",
")",
"cris_tune",
"=",
"8",
";",
"if",
"(",
"strcmp",
"(",
"\"ng\"",
",",
"cris_tune_str",
")",
"==",
"0",
"||",
"strcmp",
"(",
"\"etrax100lx\"",
",",
"cris_tune_str",
")",
"==",
"0",
")",
"cris_tune",
"=",
"10",
";",
"if",
"(",
"cris_tune",
"<",
"0",
"||",
"cris_tune",
">",
"32",
")",
"error",
"(",
"\"unknown CRIS cpu version specification in -mtune= : %s\"",
",",
"cris_tune_str",
")",
";",
"if",
"(",
"cris_tune",
">=",
"CRIS_CPU_SVINTO",
")",
"target_flags",
"|=",
"(",
"MASK_STACK_ALIGN",
"|",
"MASK_CONST_ALIGN",
"|",
"MASK_DATA_ALIGN",
"|",
"MASK_ALIGN_BY_32",
")",
";",
"}",
"if",
"(",
"cris_cpu_version",
">=",
"CRIS_CPU_V32",
")",
"target_flags",
"&=",
"~",
"(",
"MASK_SIDE_EFFECT_PREFIXES",
"|",
"MASK_MUL_BUG",
")",
";",
"if",
"(",
"flag_pic",
")",
"{",
"if",
"(",
"!",
"TARGET_LINUX",
")",
"{",
"error",
"(",
"\"-fPIC and -fpic are not supported in this configuration\"",
")",
";",
"flag_pic",
"=",
"0",
";",
"}",
"flag_no_function_cse",
"=",
"1",
";",
"}",
"init_machine_status",
"=",
"cris_init_machine_status",
";",
"}",
"</s>"
] | [
"The",
"TARGET_OPTION_OVERRIDE",
"worker",
".",
"As",
"is",
"the",
"norm",
",",
"this",
"also",
"parses",
"-mfoo=bar",
"type",
"parameters",
"."
] | [
"cris",
"0",
"0x20000000",
"\"-max-stackframe=%d is not usable, not between 0 and %d\"",
"0x20000000",
"1",
"1",
"\"etrax4\"",
"0",
"3",
"\"svinto\"",
"0",
"\"etrax100\"",
"0",
"8",
"\"ng\"",
"0",
"\"etrax100lx\"",
"0",
"10",
"0",
"32",
"\"unknown CRIS version specification in -march= or -mcpu= : %s\"",
"1",
"1",
"\"etrax4\"",
"0",
"3",
"\"svinto\"",
"0",
"\"etrax100\"",
"0",
"8",
"\"ng\"",
"0",
"\"etrax100lx\"",
"0",
"10",
"0",
"32",
"\"unknown CRIS cpu version specification in -mtune= : %s\"",
"\"-fPIC and -fpic are not supported in this configuration\"",
"0",
"1"
] | cris4 | cris_option_override | cris | MPU | GCC | 19,313 | 369 | 1 | [] |
[
"<s>",
"static",
"void",
"vax_init_libfuncs",
"(",
"void",
")",
"{",
"set_optab_libfunc",
"(",
"udiv_optab",
",",
"SImode",
",",
"TARGET_ELF",
"?",
"\"*__udiv\"",
":",
"\"*udiv\"",
")",
";",
"set_optab_libfunc",
"(",
"umod_optab",
",",
"SImode",
",",
"TARGET_ELF",
"?",
"\"*__urem\"",
":",
"\"*urem\"",
")",
";",
"}",
"</s>"
] | [
"We",
"can",
"use",
"the",
"BSD",
"C",
"library",
"routines",
"for",
"the",
"libgcc",
"calls",
"that",
"are",
"still",
"generated",
",",
"since",
"that",
"'s",
"what",
"they",
"boil",
"down",
"to",
"anyways",
".",
"When",
"ELF",
",",
"avoid",
"the",
"user",
"'s",
"namespace",
"."
] | [
"vax",
"\"*__udiv\"",
"\"*udiv\"",
"\"*__urem\"",
"\"*urem\""
] | vax3 | vax_init_libfuncs | vax | CPU | GCC | 19,314 | 34 | 1 | [] |
[
"<s>",
"static",
"void",
"pa_function_arg_advance",
"(",
"cumulative_args_t",
"cum_v",
",",
"machine_mode",
"mode",
",",
"const_tree",
"type",
",",
"bool",
"named",
"ATTRIBUTE_UNUSED",
")",
"{",
"CUMULATIVE_ARGS",
"*",
"cum",
"=",
"get_cumulative_args",
"(",
"cum_v",
")",
";",
"int",
"arg_size",
"=",
"FUNCTION_ARG_SIZE",
"(",
"mode",
",",
"type",
")",
";",
"cum",
"->",
"nargs_prototype",
"--",
";",
"cum",
"->",
"words",
"+=",
"(",
"arg_size",
"+",
"(",
"(",
"cum",
"->",
"words",
"&",
"01",
")",
"&&",
"type",
"!=",
"NULL_TREE",
"&&",
"arg_size",
">",
"1",
")",
")",
";",
"}",
"</s>"
] | [
"Update",
"the",
"data",
"in",
"CUM",
"to",
"advance",
"over",
"an",
"argument",
"of",
"mode",
"MODE",
"and",
"data",
"type",
"TYPE",
".",
"(",
"TYPE",
"is",
"null",
"for",
"libcalls",
"where",
"that",
"information",
"may",
"not",
"be",
"available",
".",
")"
] | [
"pa",
"01",
"1"
] | pa4 | pa_function_arg_advance | pa | CPU | GCC | 19,315 | 69 | 1 | [] |
[
"<s>",
"void",
"ARMDAGToDAGISel",
"::",
"PreprocessISelDAG",
"(",
")",
"{",
"if",
"(",
"!",
"Subtarget",
"->",
"hasV6T2Ops",
"(",
")",
")",
"return",
";",
"bool",
"isThumb2",
"=",
"Subtarget",
"->",
"isThumb",
"(",
")",
";",
"for",
"(",
"SelectionDAG",
"::",
"allnodes_iterator",
"I",
"=",
"CurDAG",
"->",
"allnodes_begin",
"(",
")",
",",
"E",
"=",
"CurDAG",
"->",
"allnodes_end",
"(",
")",
";",
"I",
"!=",
"E",
";",
")",
"{",
"SDNode",
"*",
"N",
"=",
"I",
"++",
";",
"if",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"ADD",
")",
"continue",
";",
"SDValue",
"N0",
"=",
"N",
"->",
"getOperand",
"(",
"0",
")",
";",
"SDValue",
"N1",
"=",
"N",
"->",
"getOperand",
"(",
"1",
")",
";",
"unsigned",
"And_imm",
"=",
"0",
";",
"if",
"(",
"!",
"isOpcWithIntImmediate",
"(",
"N1",
".",
"getNode",
"(",
")",
",",
"ISD",
"::",
"AND",
",",
"And_imm",
")",
")",
"{",
"if",
"(",
"isOpcWithIntImmediate",
"(",
"N0",
".",
"getNode",
"(",
")",
",",
"ISD",
"::",
"AND",
",",
"And_imm",
")",
")",
"std",
"::",
"swap",
"(",
"N0",
",",
"N1",
")",
";",
"}",
"if",
"(",
"!",
"And_imm",
")",
"continue",
";",
"unsigned",
"TZ",
"=",
"countTrailingZeros",
"(",
"And_imm",
")",
";",
"if",
"(",
"TZ",
"!=",
"1",
"&&",
"TZ",
"!=",
"2",
")",
"continue",
";",
"And_imm",
">>=",
"TZ",
";",
"if",
"(",
"And_imm",
"&",
"(",
"And_imm",
"+",
"1",
")",
")",
"continue",
";",
"SDValue",
"Srl",
"=",
"N1",
".",
"getOperand",
"(",
"0",
")",
";",
"unsigned",
"Srl_imm",
"=",
"0",
";",
"if",
"(",
"!",
"isOpcWithIntImmediate",
"(",
"Srl",
".",
"getNode",
"(",
")",
",",
"ISD",
"::",
"SRL",
",",
"Srl_imm",
")",
"||",
"(",
"Srl_imm",
"<=",
"2",
")",
")",
"continue",
";",
"SDValue",
"CPTmp0",
";",
"SDValue",
"CPTmp1",
";",
"SDValue",
"CPTmp2",
";",
"if",
"(",
"isThumb2",
")",
"{",
"if",
"(",
"SelectT2ShifterOperandReg",
"(",
"N0",
",",
"CPTmp0",
",",
"CPTmp1",
")",
")",
"continue",
";",
"}",
"else",
"{",
"if",
"(",
"SelectImmShifterOperand",
"(",
"N0",
",",
"CPTmp0",
",",
"CPTmp1",
")",
"||",
"SelectRegShifterOperand",
"(",
"N0",
",",
"CPTmp0",
",",
"CPTmp1",
",",
"CPTmp2",
")",
")",
"continue",
";",
"}",
"Srl",
"=",
"CurDAG",
"->",
"getNode",
"(",
"ISD",
"::",
"SRL",
",",
"SDLoc",
"(",
"Srl",
")",
",",
"MVT",
"::",
"i32",
",",
"Srl",
".",
"getOperand",
"(",
"0",
")",
",",
"CurDAG",
"->",
"getConstant",
"(",
"Srl_imm",
"+",
"TZ",
",",
"SDLoc",
"(",
"Srl",
")",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"N1",
"=",
"CurDAG",
"->",
"getNode",
"(",
"ISD",
"::",
"AND",
",",
"SDLoc",
"(",
"N1",
")",
",",
"MVT",
"::",
"i32",
",",
"Srl",
",",
"CurDAG",
"->",
"getConstant",
"(",
"And_imm",
",",
"SDLoc",
"(",
"Srl",
")",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"N1",
"=",
"CurDAG",
"->",
"getNode",
"(",
"ISD",
"::",
"SHL",
",",
"SDLoc",
"(",
"N1",
")",
",",
"MVT",
"::",
"i32",
",",
"N1",
",",
"CurDAG",
"->",
"getConstant",
"(",
"TZ",
",",
"SDLoc",
"(",
"Srl",
")",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"CurDAG",
"->",
"UpdateNodeOperands",
"(",
"N",
",",
"N0",
",",
"N1",
")",
";",
"}",
"}",
"</s>"
] | [
"PreprocessISelDAG",
"-",
"This",
"hook",
"allows",
"targets",
"to",
"hack",
"on",
"the",
"graph",
"before",
"instruction",
"selection",
"starts",
"."
] | [
"ARM",
"ARM",
"ISD::ADD",
"0",
"1",
"0",
"ISD::AND",
"ISD::AND",
"1",
"2",
"1",
"0",
"0",
"ISD::SRL",
"2",
"ISD::SRL",
"MVT::i32",
"0",
"MVT::i32",
"ISD::AND",
"MVT::i32",
"MVT::i32",
"ISD::SHL",
"MVT::i32",
"MVT::i32"
] | ARMISelDAGToDAG5 | PreprocessISelDAG | ARM | CPU | LLVM | 19,316 | 419 | 1 | [] |
[
"<s>",
"void",
"TGSIAsmPrinter",
"::",
"EmitInstruction",
"(",
"const",
"MachineInstr",
"*",
"mi",
")",
"{",
"MCInst",
"mci",
";",
"LowerMachineInstrToMCInst",
"(",
"mi",
",",
"mci",
",",
"*",
"this",
")",
";",
"EmitMCInstruction",
"(",
"mci",
")",
";",
"}",
"</s>"
] | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"TGSI",
"TGSI"
] | TGSIAsmPrinter | EmitInstruction | TGSI | Virtual ISA | LLVM | 19,317 | 30 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"WebAssembly Register Stackify\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"WebAssembly",
"\"WebAssembly Register Stackify\""
] | WebAssemblyRegStackify (2) | getPassName | WebAssembly | Virtual ISA | LLVM | 19,318 | 13 | 1 | [] |
[
"<s>",
"const",
"TargetRegisterClass",
"*",
"MCS51RegisterInfo",
"::",
"getPointerRegClass",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"unsigned",
"Kind",
")",
"const",
"{",
"return",
"&",
"MCS51",
"::",
"PTRDISPREGSRegClass",
";",
"}",
"</s>"
] | [
"getPointerRegClass",
"-",
"Returns",
"a",
"TargetRegisterClass",
"used",
"for",
"pointer",
"values",
"."
] | [
"MCS51",
"MCS51",
"MCS51::PTRDISPREGSRegClass"
] | MCS51RegisterInfo | getPointerRegClass | MCS51 | MPU | LLVM | 19,319 | 24 | 1 | [] |
[
"<s>",
"void",
"rs6000_expand_vector_extract",
"(",
"rtx",
"target",
",",
"rtx",
"vec",
",",
"int",
"elt",
")",
"{",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"vec",
")",
";",
"machine_mode",
"inner_mode",
"=",
"GET_MODE_INNER",
"(",
"mode",
")",
";",
"rtx",
"mem",
";",
"if",
"(",
"VECTOR_MEM_VSX_P",
"(",
"mode",
")",
")",
"{",
"switch",
"(",
"mode",
")",
"{",
"default",
":",
"break",
";",
"case",
"V1TImode",
":",
"gcc_assert",
"(",
"elt",
"==",
"0",
"&&",
"inner_mode",
"==",
"TImode",
")",
";",
"emit_move_insn",
"(",
"target",
",",
"gen_lowpart",
"(",
"TImode",
",",
"vec",
")",
")",
";",
"break",
";",
"case",
"V2DFmode",
":",
"emit_insn",
"(",
"gen_vsx_extract_v2df",
"(",
"target",
",",
"vec",
",",
"GEN_INT",
"(",
"elt",
")",
")",
")",
";",
"return",
";",
"case",
"V2DImode",
":",
"emit_insn",
"(",
"gen_vsx_extract_v2di",
"(",
"target",
",",
"vec",
",",
"GEN_INT",
"(",
"elt",
")",
")",
")",
";",
"return",
";",
"case",
"V4SFmode",
":",
"emit_insn",
"(",
"gen_vsx_extract_v4sf",
"(",
"target",
",",
"vec",
",",
"GEN_INT",
"(",
"elt",
")",
")",
")",
";",
"return",
";",
"}",
"}",
"mem",
"=",
"assign_stack_temp",
"(",
"mode",
",",
"GET_MODE_SIZE",
"(",
"mode",
")",
")",
";",
"emit_move_insn",
"(",
"mem",
",",
"vec",
")",
";",
"mem",
"=",
"adjust_address_nv",
"(",
"mem",
",",
"inner_mode",
",",
"elt",
"*",
"GET_MODE_SIZE",
"(",
"inner_mode",
")",
")",
";",
"emit_move_insn",
"(",
"target",
",",
"adjust_address_nv",
"(",
"mem",
",",
"inner_mode",
",",
"0",
")",
")",
";",
"}",
"</s>"
] | [
"Extract",
"field",
"ELT",
"from",
"VEC",
"into",
"TARGET",
"."
] | [
"rs6000",
"0",
"0"
] | rs60004 | rs6000_expand_vector_extract | rs6000 | CPU | GCC | 19,320 | 189 | 1 | [] |
[
"<s>",
"Register",
"getExceptionPointerRegister",
"(",
"const",
"Constant",
"*",
"PersonalityFn",
")",
"const",
"override",
"{",
"return",
"SystemZ",
"::",
"R6D",
";",
"}",
"</s>"
] | [
"If",
"a",
"physical",
"register",
",",
"this",
"returns",
"the",
"register",
"that",
"receives",
"the",
"exception",
"address",
"on",
"entry",
"to",
"an",
"EH",
"pad",
"."
] | [
"SystemZ",
"SystemZ::R6D"
] | SystemZISelLowering18 | getExceptionPointerRegister | SystemZ | CPU | LLVM | 19,321 | 17 | 1 | [] |
[
"<s>",
"void",
"rs6000_xcoff_declare_function_name",
"(",
"FILE",
"*",
"file",
",",
"const",
"char",
"*",
"name",
",",
"tree",
"decl",
")",
"{",
"char",
"*",
"buffer",
"=",
"(",
"char",
"*",
")",
"alloca",
"(",
"strlen",
"(",
"name",
")",
"+",
"1",
")",
";",
"char",
"*",
"p",
";",
"int",
"dollar_inside",
"=",
"0",
";",
"struct",
"declare_alias_data",
"data",
"=",
"{",
"file",
",",
"false",
"}",
";",
"strcpy",
"(",
"buffer",
",",
"name",
")",
";",
"p",
"=",
"strchr",
"(",
"buffer",
",",
"'$'",
")",
";",
"while",
"(",
"p",
")",
"{",
"*",
"p",
"=",
"'_'",
";",
"dollar_inside",
"++",
";",
"p",
"=",
"strchr",
"(",
"p",
"+",
"1",
",",
"'$'",
")",
";",
"}",
"if",
"(",
"TREE_PUBLIC",
"(",
"decl",
")",
")",
"{",
"if",
"(",
"!",
"RS6000_WEAK",
"||",
"!",
"DECL_WEAK",
"(",
"decl",
")",
")",
"{",
"if",
"(",
"dollar_inside",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"\\t.rename .%s,\\\".%s\\\"\\n\"",
",",
"buffer",
",",
"name",
")",
";",
"fprintf",
"(",
"file",
",",
"\"\\t.rename %s,\\\"%s\\\"\\n\"",
",",
"buffer",
",",
"name",
")",
";",
"}",
"fputs",
"(",
"\"\\t.globl .\"",
",",
"file",
")",
";",
"RS6000_OUTPUT_BASENAME",
"(",
"file",
",",
"buffer",
")",
";",
"fputs",
"(",
"rs6000_xcoff_visibility",
"(",
"decl",
")",
",",
"file",
")",
";",
"putc",
"(",
"'\\n'",
",",
"file",
")",
";",
"}",
"}",
"else",
"{",
"if",
"(",
"dollar_inside",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"\\t.rename .%s,\\\".%s\\\"\\n\"",
",",
"buffer",
",",
"name",
")",
";",
"fprintf",
"(",
"file",
",",
"\"\\t.rename %s,\\\"%s\\\"\\n\"",
",",
"buffer",
",",
"name",
")",
";",
"}",
"fputs",
"(",
"\"\\t.lglobl .\"",
",",
"file",
")",
";",
"RS6000_OUTPUT_BASENAME",
"(",
"file",
",",
"buffer",
")",
";",
"putc",
"(",
"'\\n'",
",",
"file",
")",
";",
"}",
"fputs",
"(",
"\"\\t.csect \"",
",",
"file",
")",
";",
"RS6000_OUTPUT_BASENAME",
"(",
"file",
",",
"buffer",
")",
";",
"fputs",
"(",
"TARGET_32BIT",
"?",
"\"[DS]\\n\"",
":",
"\"[DS],3\\n\"",
",",
"file",
")",
";",
"RS6000_OUTPUT_BASENAME",
"(",
"file",
",",
"buffer",
")",
";",
"fputs",
"(",
"\":\\n\"",
",",
"file",
")",
";",
"symtab_node",
"::",
"get",
"(",
"decl",
")",
"->",
"call_for_symbol_and_aliases",
"(",
"rs6000_declare_alias",
",",
"&",
"data",
",",
"true",
")",
";",
"fputs",
"(",
"TARGET_32BIT",
"?",
"\"\\t.long .\"",
":",
"\"\\t.llong .\"",
",",
"file",
")",
";",
"RS6000_OUTPUT_BASENAME",
"(",
"file",
",",
"buffer",
")",
";",
"fputs",
"(",
"\", TOC[tc0], 0\\n\"",
",",
"file",
")",
";",
"in_section",
"=",
"NULL",
";",
"switch_to_section",
"(",
"function_section",
"(",
"decl",
")",
")",
";",
"putc",
"(",
"'.'",
",",
"file",
")",
";",
"RS6000_OUTPUT_BASENAME",
"(",
"file",
",",
"buffer",
")",
";",
"fputs",
"(",
"\":\\n\"",
",",
"file",
")",
";",
"data",
".",
"function_descriptor",
"=",
"true",
";",
"symtab_node",
"::",
"get",
"(",
"decl",
")",
"->",
"call_for_symbol_and_aliases",
"(",
"rs6000_declare_alias",
",",
"&",
"data",
",",
"true",
")",
";",
"if",
"(",
"!",
"DECL_IGNORED_P",
"(",
"decl",
")",
")",
"{",
"if",
"(",
"write_symbols",
"==",
"DBX_DEBUG",
"||",
"write_symbols",
"==",
"XCOFF_DEBUG",
")",
"xcoffout_declare_function",
"(",
"file",
",",
"decl",
",",
"buffer",
")",
";",
"else",
"if",
"(",
"write_symbols",
"==",
"DWARF2_DEBUG",
")",
"{",
"name",
"=",
"(",
"*",
"targetm",
".",
"strip_name_encoding",
")",
"(",
"name",
")",
";",
"fprintf",
"(",
"file",
",",
"\"\\t.function .%s,.%s,2,0\\n\"",
",",
"name",
",",
"name",
")",
";",
"}",
"}",
"return",
";",
"}",
"</s>"
] | [
"This",
"macro",
"produces",
"the",
"initial",
"definition",
"of",
"a",
"function",
"name",
".",
"On",
"the",
"RS/6000",
",",
"we",
"need",
"to",
"place",
"an",
"extra",
"'",
".",
"'",
"in",
"the",
"function",
"name",
"and",
"output",
"the",
"function",
"descriptor",
".",
"Dollar",
"signs",
"are",
"converted",
"to",
"underscores",
".",
"The",
"csect",
"for",
"the",
"function",
"will",
"have",
"already",
"been",
"created",
"when",
"text_section",
"was",
"selected",
".",
"We",
"do",
"have",
"to",
"go",
"back",
"to",
"that",
"csect",
",",
"however",
".",
"The",
"third",
"and",
"fourth",
"parameters",
"to",
"the",
".function",
"pseudo-op",
"(",
"16",
"and",
"044",
")",
"are",
"placeholders",
"which",
"no",
"longer",
"have",
"any",
"use",
".",
"Because",
"AIX",
"assembler",
"'s",
".set",
"command",
"has",
"unexpected",
"semantics",
",",
"we",
"output",
"all",
"aliases",
"as",
"alternative",
"labels",
"in",
"front",
"of",
"the",
"definition",
"."
] | [
"powerpcspe",
"1",
"0",
"1",
"\"\\t.rename .%s,\\\".%s\\\"\\n\"",
"\"\\t.rename %s,\\\"%s\\\"\\n\"",
"\"\\t.globl .\"",
"\"\\t.rename .%s,\\\".%s\\\"\\n\"",
"\"\\t.rename %s,\\\"%s\\\"\\n\"",
"\"\\t.lglobl .\"",
"\"\\t.csect \"",
"\"[DS]\\n\"",
"\"[DS],3\\n\"",
"\":\\n\"",
"\"\\t.long .\"",
"\"\\t.llong .\"",
"\", TOC[tc0], 0\\n\"",
"\":\\n\"",
"\"\\t.function .%s,.%s,2,0\\n\""
] | powerpcspe | rs6000_xcoff_declare_function_name | powerpcspe | CPU | GCC | 19,322 | 428 | 1 | [] |
[
"<s>",
"void",
"X86IntelInstPrinter",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"raw_ostream",
"&",
"OS",
",",
"StringRef",
"Annot",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"{",
"const",
"MCInstrDesc",
"&",
"Desc",
"=",
"MII",
".",
"get",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
";",
"uint64_t",
"TSFlags",
"=",
"Desc",
".",
"TSFlags",
";",
"unsigned",
"Flags",
"=",
"MI",
"->",
"getFlags",
"(",
")",
";",
"if",
"(",
"(",
"TSFlags",
"&",
"X86II",
"::",
"LOCK",
")",
"||",
"(",
"Flags",
"&",
"X86",
"::",
"IP_HAS_LOCK",
")",
")",
"OS",
"<<",
"\"\\tlock\\t\"",
";",
"if",
"(",
"Flags",
"&",
"X86",
"::",
"IP_HAS_REPEAT_NE",
")",
"OS",
"<<",
"\"\\trepne\\t\"",
";",
"else",
"if",
"(",
"Flags",
"&",
"X86",
"::",
"IP_HAS_REPEAT",
")",
"OS",
"<<",
"\"\\trep\\t\"",
";",
"if",
"(",
"(",
"TSFlags",
"&",
"X86II",
"::",
"NOTRACK",
")",
"||",
"(",
"Flags",
"&",
"X86",
"::",
"IP_HAS_NOTRACK",
")",
")",
"OS",
"<<",
"\"\\tnotrack\\t\"",
";",
"printInstruction",
"(",
"MI",
",",
"OS",
")",
";",
"printAnnotation",
"(",
"OS",
",",
"Annot",
")",
";",
"if",
"(",
"CommentStream",
")",
"EmitAnyX86InstComments",
"(",
"MI",
",",
"*",
"CommentStream",
",",
"MII",
",",
"getRegisterName",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] | [
"X86",
"X86",
"X86II::LOCK",
"X86::IP_HAS_LOCK",
"\"\\tlock\\t\"",
"X86::IP_HAS_REPEAT_NE",
"\"\\trepne\\t\"",
"X86::IP_HAS_REPEAT",
"\"\\trep\\t\"",
"X86II::NOTRACK",
"X86::IP_HAS_NOTRACK",
"\"\\tnotrack\\t\"",
"X86"
] | X86IntelInstPrinter15 | printInst | X86 | CPU | LLVM | 19,323 | 155 | 1 | [] |
[
"<s>",
"static",
"bool",
"callee_saved_regno_p",
"(",
"int",
"regno",
")",
"{",
"if",
"(",
"!",
"call_used_regs",
"[",
"regno",
"]",
"&&",
"df_regs_ever_live_p",
"(",
"regno",
")",
")",
"return",
"true",
";",
"switch",
"(",
"regno",
")",
"{",
"case",
"HARD_FRAME_POINTER_REGNUM",
":",
"return",
"frame_pointer_needed",
";",
"case",
"LR_REGNUM",
":",
"return",
"(",
"frame_pointer_needed",
"||",
"!",
"crtl",
"->",
"is_leaf",
"||",
"crtl",
"->",
"uses_pic_offset_table",
"||",
"df_regs_ever_live_p",
"(",
"regno",
")",
")",
";",
"case",
"HW_TO_GCC_REGNO",
"(",
"25",
")",
":",
"case",
"HW_TO_GCC_REGNO",
"(",
"27",
")",
":",
"case",
"HW_TO_GCC_REGNO",
"(",
"29",
")",
":",
"case",
"HW_TO_GCC_REGNO",
"(",
"31",
")",
":",
"return",
"crtl",
"->",
"calls_eh_return",
";",
"default",
":",
"return",
"false",
";",
"}",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"REGNO",
"must",
"be",
"saved",
"for",
"the",
"current",
"function",
"."
] | [
"or1k",
"25",
"27",
"29",
"31"
] | or1k2 | callee_saved_regno_p | or1k | CPU | GCC | 19,324 | 93 | 1 | [] |
[
"<s>",
"const",
"std",
"::",
"string",
"getAsStr",
"(",
")",
"const",
"override",
"{",
"return",
"\"AMDInfo[\"",
"+",
"std",
"::",
"to_string",
"(",
"Attributes",
".",
"size",
"(",
")",
")",
"+",
"\"]\"",
";",
"}",
"</s>"
] | [
"See",
"AbstractState",
":",
":getAsStr",
"(",
"Attributor",
")",
"."
] | [
"AMDGPU",
"\"AMDInfo[\"",
"\"]\""
] | AMDGPUAttributor5 | getAsStr | AMDGPU | GPU | LLVM | 19,325 | 27 | 1 | [] |
[
"<s>",
"static",
"scalar_int_mode",
"pru_unwind_word_mode",
"(",
"void",
")",
"{",
"return",
"SImode",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_UNWIND_WORD_MODE",
".",
"Since",
"PRU",
"is",
"really",
"a",
"32-bit",
"CPU",
",",
"the",
"default",
"word_mode",
"is",
"not",
"suitable",
"."
] | [
"pru"
] | pru | pru_unwind_word_mode | pru | CPU | GCC | 19,326 | 11 | 1 | [] |
[
"<s>",
"bool",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"F",
")",
"override",
"{",
"TM",
"=",
"&",
"F",
".",
"getTarget",
"(",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"FI",
"=",
"F",
".",
"begin",
"(",
")",
",",
"FE",
"=",
"F",
".",
"end",
"(",
")",
";",
"FI",
"!=",
"FE",
";",
"++",
"FI",
")",
"Changed",
"|=",
"runOnMachineBasicBlock",
"(",
"*",
"FI",
")",
";",
"if",
"(",
"Changed",
")",
"F",
".",
"getRegInfo",
"(",
")",
".",
"invalidateLiveness",
"(",
")",
";",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"Mips"
] | MipsDelaySlotFiller12 | runOnMachineFunction | Mips | CPU | LLVM | 19,327 | 77 | 1 | [] |
[
"<s>",
"SDNode",
"*",
"BlackfinDAGToDAGISel",
"::",
"Select",
"(",
"SDNode",
"*",
"N",
")",
"{",
"if",
"(",
"N",
"->",
"isMachineOpcode",
"(",
")",
")",
"return",
"NULL",
";",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"FrameIndex",
":",
"{",
"int",
"FI",
"=",
"cast",
"<",
"FrameIndexSDNode",
">",
"(",
"N",
")",
"->",
"getIndex",
"(",
")",
";",
"SDValue",
"TFI",
"=",
"CurDAG",
"->",
"getTargetFrameIndex",
"(",
"FI",
",",
"MVT",
"::",
"i32",
")",
";",
"return",
"CurDAG",
"->",
"SelectNodeTo",
"(",
"N",
",",
"BF",
"::",
"ADDpp",
",",
"MVT",
"::",
"i32",
",",
"TFI",
",",
"CurDAG",
"->",
"getTargetConstant",
"(",
"0",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"}",
"}",
"return",
"SelectCode",
"(",
"N",
")",
";",
"}",
"</s>"
] | [
"Main",
"hook",
"for",
"targets",
"to",
"transform",
"nodes",
"into",
"machine",
"nodes",
"."
] | [
"Blackfin",
"ISD::FrameIndex",
"MVT::i32",
"BF::ADDpp",
"MVT::i32",
"0",
"MVT::i32"
] | BlackfinISelDAGToDAG | Select | Blackfin | DSP | LLVM | 19,328 | 108 | 1 | [] |
[
"<s>",
"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",
"."
] | [
"AArch64"
] | AArch64TargetTransformInfo1 | initializePass | AArch64 | CPU | LLVM | 19,329 | 12 | 1 | [] |
[
"<s>",
"void",
"GCNPassConfig",
"::",
"addFastRegAlloc",
"(",
")",
"{",
"insertPass",
"(",
"&",
"PHIEliminationID",
",",
"&",
"SILowerControlFlowID",
",",
"false",
")",
";",
"insertPass",
"(",
"&",
"TwoAddressInstructionPassID",
",",
"&",
"SIWholeQuadModeID",
")",
";",
"insertPass",
"(",
"&",
"TwoAddressInstructionPassID",
",",
"&",
"SIPreAllocateWWMRegsID",
")",
";",
"TargetPassConfig",
"::",
"addFastRegAlloc",
"(",
")",
";",
"}",
"</s>"
] | [
"addFastRegAlloc",
"-",
"Add",
"the",
"minimum",
"set",
"of",
"target-independent",
"passes",
"that",
"are",
"required",
"for",
"fast",
"register",
"allocation",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI"
] | AMDGPUTargetMachine10 | addFastRegAlloc | AMDGPU | GPU | LLVM | 19,330 | 43 | 1 | [] |
[
"<s>",
"enum",
"calling_abi",
"ix86_function_type_abi",
"(",
"const_tree",
"fntype",
")",
"{",
"enum",
"calling_abi",
"abi",
"=",
"ix86_abi",
";",
"if",
"(",
"fntype",
"==",
"NULL_TREE",
"||",
"TYPE_ATTRIBUTES",
"(",
"fntype",
")",
"==",
"NULL_TREE",
")",
"return",
"abi",
";",
"if",
"(",
"abi",
"==",
"SYSV_ABI",
"&&",
"lookup_attribute",
"(",
"\"ms_abi\"",
",",
"TYPE_ATTRIBUTES",
"(",
"fntype",
")",
")",
")",
"{",
"if",
"(",
"TARGET_X32",
")",
"error",
"(",
"\"X32 does not support ms_abi attribute\"",
")",
";",
"abi",
"=",
"MS_ABI",
";",
"}",
"else",
"if",
"(",
"abi",
"==",
"MS_ABI",
"&&",
"lookup_attribute",
"(",
"\"sysv_abi\"",
",",
"TYPE_ATTRIBUTES",
"(",
"fntype",
")",
")",
")",
"abi",
"=",
"SYSV_ABI",
";",
"return",
"abi",
";",
"}",
"</s>"
] | [
"Returns",
"value",
"SYSV_ABI",
",",
"MS_ABI",
"dependent",
"on",
"fntype",
",",
"specifying",
"the",
"call",
"abi",
"used",
"."
] | [
"i386",
"\"ms_abi\"",
"\"X32 does not support ms_abi attribute\"",
"\"sysv_abi\""
] | i3865 | ix86_function_type_abi | i386 | CPU | GCC | 19,331 | 86 | 1 | [] |
[
"<s>",
"static",
"const",
"predefined_function_abi",
"&",
"aarch64_sve_abi",
"(",
"void",
")",
"{",
"predefined_function_abi",
"&",
"sve_abi",
"=",
"function_abis",
"[",
"ARM_PCS_SVE",
"]",
";",
"if",
"(",
"!",
"sve_abi",
".",
"initialized_p",
"(",
")",
")",
"{",
"HARD_REG_SET",
"full_reg_clobbers",
"=",
"default_function_abi",
".",
"full_reg_clobbers",
"(",
")",
";",
"for",
"(",
"int",
"regno",
"=",
"V8_REGNUM",
";",
"regno",
"<=",
"V23_REGNUM",
";",
"++",
"regno",
")",
"CLEAR_HARD_REG_BIT",
"(",
"full_reg_clobbers",
",",
"regno",
")",
";",
"for",
"(",
"int",
"regno",
"=",
"P4_REGNUM",
";",
"regno",
"<=",
"P15_REGNUM",
";",
"++",
"regno",
")",
"CLEAR_HARD_REG_BIT",
"(",
"full_reg_clobbers",
",",
"regno",
")",
";",
"sve_abi",
".",
"initialize",
"(",
"ARM_PCS_SVE",
",",
"full_reg_clobbers",
")",
";",
"}",
"return",
"sve_abi",
";",
"}",
"</s>"
] | [
"Return",
"the",
"descriptor",
"of",
"the",
"SVE",
"PCS",
"."
] | [
"aarch64"
] | aarch64 | aarch64_sve_abi | aarch64 | CPU | GCC | 19,332 | 93 | 1 | [] |
[
"<s>",
"bool",
"SparcAsmParser",
"::",
"MatchAndEmitInstruction",
"(",
"SMLoc",
"IDLoc",
",",
"unsigned",
"&",
"Opcode",
",",
"OperandVector",
"&",
"Operands",
",",
"MCStreamer",
"&",
"Out",
",",
"uint64_t",
"&",
"ErrorInfo",
",",
"bool",
"MatchingInlineAsm",
")",
"{",
"MCInst",
"Inst",
";",
"SmallVector",
"<",
"MCInst",
",",
"8",
">",
"Instructions",
";",
"unsigned",
"MatchResult",
"=",
"MatchInstructionImpl",
"(",
"Operands",
",",
"Inst",
",",
"ErrorInfo",
",",
"MatchingInlineAsm",
")",
";",
"switch",
"(",
"MatchResult",
")",
"{",
"case",
"Match_Success",
":",
"{",
"switch",
"(",
"Inst",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"Inst",
".",
"setLoc",
"(",
"IDLoc",
")",
";",
"Instructions",
".",
"push_back",
"(",
"Inst",
")",
";",
"break",
";",
"case",
"SP",
"::",
"SET",
":",
"if",
"(",
"expandSET",
"(",
"Inst",
",",
"IDLoc",
",",
"Instructions",
")",
")",
"return",
"true",
";",
"break",
";",
"}",
"for",
"(",
"const",
"MCInst",
"&",
"I",
":",
"Instructions",
")",
"{",
"Out",
".",
"emitInstruction",
"(",
"I",
",",
"getSTI",
"(",
")",
")",
";",
"}",
"return",
"false",
";",
"}",
"case",
"Match_MissingFeature",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"instruction requires a CPU feature not currently enabled\"",
")",
";",
"case",
"Match_InvalidOperand",
":",
"{",
"SMLoc",
"ErrorLoc",
"=",
"IDLoc",
";",
"if",
"(",
"ErrorInfo",
"!=",
"~",
"0ULL",
")",
"{",
"if",
"(",
"ErrorInfo",
">=",
"Operands",
".",
"size",
"(",
")",
")",
"return",
"Error",
"(",
"IDLoc",
",",
"\"too few operands for instruction\"",
")",
";",
"ErrorLoc",
"=",
"(",
"(",
"SparcOperand",
"&",
")",
"*",
"Operands",
"[",
"ErrorInfo",
"]",
")",
".",
"getStartLoc",
"(",
")",
";",
"if",
"(",
"ErrorLoc",
"==",
"SMLoc",
"(",
")",
")",
"ErrorLoc",
"=",
"IDLoc",
";",
"}",
"return",
"Error",
"(",
"ErrorLoc",
",",
"\"invalid operand for instruction\"",
")",
";",
"}",
"case",
"Match_MnemonicFail",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"invalid instruction mnemonic\"",
")",
";",
"}",
"llvm_unreachable",
"(",
"\"Implement any new match types added!\"",
")",
";",
"}",
"</s>"
] | [
"MatchAndEmitInstruction",
"-",
"Recognize",
"a",
"series",
"of",
"operands",
"of",
"a",
"parsed",
"instruction",
"as",
"an",
"actual",
"MCInst",
"and",
"emit",
"it",
"to",
"the",
"specified",
"MCStreamer",
"."
] | [
"Sparc",
"Sparc",
"8",
"SP::SET",
"\"instruction requires a CPU feature not currently enabled\"",
"0ULL",
"\"too few operands for instruction\"",
"Sparc",
"\"invalid operand for instruction\"",
"\"invalid instruction mnemonic\"",
"\"Implement any new match types added!\""
] | SparcAsmParser1 | MatchAndEmitInstruction | Sparc | CPU | LLVM | 19,333 | 241 | 1 | [] |
[
"<s>",
"bool",
"DeadCodeElimination",
"::",
"isDead",
"(",
"unsigned",
"R",
")",
"const",
"{",
"for",
"(",
"auto",
"I",
"=",
"MRI",
".",
"use_begin",
"(",
"R",
")",
",",
"E",
"=",
"MRI",
".",
"use_end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"MachineInstr",
"*",
"UseI",
"=",
"I",
"->",
"getParent",
"(",
")",
";",
"if",
"(",
"UseI",
"->",
"isDebugValue",
"(",
")",
")",
"continue",
";",
"if",
"(",
"UseI",
"->",
"isPHI",
"(",
")",
")",
"{",
"assert",
"(",
"!",
"UseI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getSubReg",
"(",
")",
")",
";",
"Register",
"DR",
"=",
"UseI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"DR",
"==",
"R",
")",
"continue",
";",
"}",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"isDead",
"-",
"Returns",
"true",
"if",
"this",
"is",
"a",
"dead",
"def",
"kill",
"slot",
"."
] | [
"Hexagon",
"0",
"0"
] | HexagonBitSimplify | isDead | Hexagon | DSP | LLVM | 19,334 | 113 | 1 | [] |
[
"<s>",
"uint64_t",
"SIMCCodeEmitter",
"::",
"getMachineOpValue",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"const",
"MCOperand",
"&",
"MO",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"return",
"MRI",
".",
"getEncodingValue",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"if",
"(",
"MO",
".",
"isExpr",
"(",
")",
")",
"{",
"const",
"MCSymbolRefExpr",
"*",
"Expr",
"=",
"cast",
"<",
"MCSymbolRefExpr",
">",
"(",
"MO",
".",
"getExpr",
"(",
")",
")",
";",
"MCFixupKind",
"Kind",
"=",
"(",
"MCFixupKind",
")",
"AMDGPU",
"::",
"fixup_si_rodata",
";",
"Fixups",
".",
"push_back",
"(",
"MCFixup",
"::",
"create",
"(",
"4",
",",
"Expr",
",",
"Kind",
",",
"MI",
".",
"getLoc",
"(",
")",
")",
")",
";",
"}",
"unsigned",
"OpNo",
"=",
"0",
";",
"for",
"(",
"unsigned",
"e",
"=",
"MI",
".",
"getNumOperands",
"(",
")",
";",
"OpNo",
"<",
"e",
";",
"++",
"OpNo",
")",
"{",
"if",
"(",
"&",
"MO",
"==",
"&",
"MI",
".",
"getOperand",
"(",
"OpNo",
")",
")",
"break",
";",
"}",
"const",
"MCInstrDesc",
"&",
"Desc",
"=",
"MCII",
".",
"get",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
";",
"if",
"(",
"isSrcOperand",
"(",
"Desc",
",",
"OpNo",
")",
")",
"{",
"int",
"RCID",
"=",
"Desc",
".",
"OpInfo",
"[",
"OpNo",
"]",
".",
"RegClass",
";",
"const",
"MCRegisterClass",
"&",
"RC",
"=",
"MRI",
".",
"getRegClass",
"(",
"RCID",
")",
";",
"uint32_t",
"Enc",
"=",
"getLitEncoding",
"(",
"MO",
",",
"RC",
".",
"getSize",
"(",
")",
")",
";",
"if",
"(",
"Enc",
"!=",
"~",
"0U",
"&&",
"(",
"Enc",
"!=",
"255",
"||",
"Desc",
".",
"getSize",
"(",
")",
"==",
"4",
")",
")",
"return",
"Enc",
";",
"}",
"else",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"return",
"MO",
".",
"getImm",
"(",
")",
";",
"llvm_unreachable",
"(",
"\"Encoding of this operand type is not supported yet.\"",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"getMachineOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"operand",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU::fixup_si_rodata",
"4",
"0",
"0U",
"255",
"4",
"\"Encoding of this operand type is not supported yet.\"",
"0"
] | SIMCCodeEmitter (2) | getMachineOpValue | AMDGPU | GPU | LLVM | 19,335 | 262 | 1 | [] |
[
"<s>",
"bool",
"PPCInstrInfo",
"::",
"FoldImmediate",
"(",
"MachineInstr",
"&",
"UseMI",
",",
"MachineInstr",
"&",
"DefMI",
",",
"Register",
"Reg",
",",
"MachineRegisterInfo",
"*",
"MRI",
")",
"const",
"{",
"unsigned",
"DefOpc",
"=",
"DefMI",
".",
"getOpcode",
"(",
")",
";",
"if",
"(",
"DefOpc",
"!=",
"PPC",
"::",
"LI",
"&&",
"DefOpc",
"!=",
"PPC",
"::",
"LI8",
")",
"return",
"false",
";",
"if",
"(",
"!",
"DefMI",
".",
"getOperand",
"(",
"1",
")",
".",
"isImm",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"DefMI",
".",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
"!=",
"0",
")",
"return",
"false",
";",
"const",
"MCInstrDesc",
"&",
"UseMCID",
"=",
"UseMI",
".",
"getDesc",
"(",
")",
";",
"if",
"(",
"UseMCID",
".",
"isPseudo",
"(",
")",
")",
"return",
"false",
";",
"unsigned",
"UseIdx",
";",
"for",
"(",
"UseIdx",
"=",
"0",
";",
"UseIdx",
"<",
"UseMI",
".",
"getNumOperands",
"(",
")",
";",
"++",
"UseIdx",
")",
"if",
"(",
"UseMI",
".",
"getOperand",
"(",
"UseIdx",
")",
".",
"isReg",
"(",
")",
"&&",
"UseMI",
".",
"getOperand",
"(",
"UseIdx",
")",
".",
"getReg",
"(",
")",
"==",
"Reg",
")",
"break",
";",
"assert",
"(",
"UseIdx",
"<",
"UseMI",
".",
"getNumOperands",
"(",
")",
"&&",
"\"Cannot find Reg in UseMI\"",
")",
";",
"assert",
"(",
"UseIdx",
"<",
"UseMCID",
".",
"getNumOperands",
"(",
")",
"&&",
"\"No operand description for Reg\"",
")",
";",
"const",
"MCOperandInfo",
"*",
"UseInfo",
"=",
"&",
"UseMCID",
".",
"OpInfo",
"[",
"UseIdx",
"]",
";",
"if",
"(",
"UseInfo",
"->",
"isLookupPtrRegClass",
"(",
")",
")",
"{",
"if",
"(",
"UseInfo",
"->",
"RegClass",
"!=",
"1",
")",
"return",
"false",
";",
"}",
"else",
"{",
"if",
"(",
"UseInfo",
"->",
"RegClass",
"!=",
"PPC",
"::",
"GPRC_NOR0RegClassID",
"&&",
"UseInfo",
"->",
"RegClass",
"!=",
"PPC",
"::",
"G8RC_NOX0RegClassID",
")",
"return",
"false",
";",
"}",
"if",
"(",
"UseInfo",
"->",
"Constraints",
"!=",
"0",
")",
"return",
"false",
";",
"MCRegister",
"ZeroReg",
";",
"if",
"(",
"UseInfo",
"->",
"isLookupPtrRegClass",
"(",
")",
")",
"{",
"bool",
"isPPC64",
"=",
"Subtarget",
".",
"isPPC64",
"(",
")",
";",
"ZeroReg",
"=",
"isPPC64",
"?",
"PPC",
"::",
"ZERO8",
":",
"PPC",
"::",
"ZERO",
";",
"}",
"else",
"{",
"ZeroReg",
"=",
"UseInfo",
"->",
"RegClass",
"==",
"PPC",
"::",
"G8RC_NOX0RegClassID",
"?",
"PPC",
"::",
"ZERO8",
":",
"PPC",
"::",
"ZERO",
";",
"}",
"bool",
"DeleteDef",
"=",
"MRI",
"->",
"hasOneNonDBGUse",
"(",
"Reg",
")",
";",
"UseMI",
".",
"getOperand",
"(",
"UseIdx",
")",
".",
"setReg",
"(",
"ZeroReg",
")",
";",
"if",
"(",
"DeleteDef",
")",
"DefMI",
".",
"eraseFromParent",
"(",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Reg",
"is",
"known",
"to",
"be",
"defined",
"by",
"a",
"move",
"immediate",
"instruction",
",",
"try",
"to",
"fold",
"the",
"immediate",
"into",
"the",
"use",
"instruction",
"."
] | [
"PowerPC",
"PPC",
"PPC::LI",
"PPC::LI8",
"1",
"1",
"0",
"0",
"\"Cannot find Reg in UseMI\"",
"\"No operand description for Reg\"",
"1",
"PPC::GPRC_NOR0RegClassID",
"PPC::G8RC_NOX0RegClassID",
"0",
"PPC",
"PPC",
"PPC",
"PPC::ZERO8",
"PPC::ZERO",
"PPC::G8RC_NOX0RegClassID",
"PPC::ZERO8",
"PPC::ZERO"
] | PPCInstrInfo17 | FoldImmediate | PowerPC | CPU | LLVM | 19,336 | 339 | 1 | [] |
[
"<s>",
"void",
"relaxInstruction",
"(",
"const",
"MCInst",
"&",
"Inst",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
",",
"MCInst",
"&",
"Res",
")",
"const",
"override",
"{",
"assert",
"(",
"HexagonMCInstrInfo",
"::",
"isBundle",
"(",
"Inst",
")",
"&&",
"\"Hexagon relaxInstruction only works on bundles\"",
")",
";",
"Res",
"=",
"HexagonMCInstrInfo",
"::",
"createBundle",
"(",
")",
";",
"bool",
"Update",
"=",
"false",
";",
"for",
"(",
"auto",
"&",
"I",
":",
"HexagonMCInstrInfo",
"::",
"bundleInstructions",
"(",
"Inst",
")",
")",
"{",
"MCInst",
"&",
"CrntHMI",
"=",
"const_cast",
"<",
"MCInst",
"&",
">",
"(",
"*",
"I",
".",
"getInst",
"(",
")",
")",
";",
"if",
"(",
"*",
"RelaxTarget",
"==",
"&",
"CrntHMI",
")",
"{",
"Update",
"=",
"true",
";",
"assert",
"(",
"(",
"HexagonMCInstrInfo",
"::",
"bundleSize",
"(",
"Res",
")",
"<",
"HEXAGON_PACKET_SIZE",
")",
"&&",
"\"No room to insert extender for relaxation\"",
")",
";",
"MCInst",
"*",
"HMIx",
"=",
"takeExtender",
"(",
")",
";",
"*",
"HMIx",
"=",
"HexagonMCInstrInfo",
"::",
"deriveExtender",
"(",
"*",
"MCII",
",",
"CrntHMI",
",",
"HexagonMCInstrInfo",
"::",
"getExtendableOperand",
"(",
"*",
"MCII",
",",
"CrntHMI",
")",
")",
";",
"Res",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createInst",
"(",
"HMIx",
")",
")",
";",
"*",
"RelaxTarget",
"=",
"nullptr",
";",
"}",
"Res",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createInst",
"(",
"I",
".",
"getInst",
"(",
")",
")",
")",
";",
"}",
"(",
"void",
")",
"Update",
";",
"assert",
"(",
"Update",
"&&",
"\"Didn't find relaxation target\"",
")",
";",
"}",
"</s>"
] | [
"Relax",
"the",
"instruction",
"in",
"the",
"given",
"fragment",
"to",
"the",
"next",
"wider",
"instruction",
"."
] | [
"Hexagon",
"Hexagon",
"\"Hexagon relaxInstruction only works on bundles\"",
"Hexagon",
"Hexagon",
"Hexagon",
"\"No room to insert extender for relaxation\"",
"Hexagon",
"Hexagon",
"\"Didn't find relaxation target\""
] | HexagonAsmBackend (2)1 | relaxInstruction | Hexagon | DSP | LLVM | 19,337 | 185 | 1 | [] |
[
"<s>",
"SDValue",
"XCoreTargetLowering",
"::",
"LowerReturn",
"(",
"SDValue",
"Chain",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"isVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
",",
"DebugLoc",
"dl",
",",
"SelectionDAG",
"&",
"DAG",
")",
"{",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"isVarArg",
",",
"getTargetMachine",
"(",
")",
",",
"RVLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"CCInfo",
".",
"AnalyzeReturn",
"(",
"Outs",
",",
"RetCC_XCore",
")",
";",
"if",
"(",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"liveout_empty",
"(",
")",
")",
"{",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"RVLocs",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"if",
"(",
"RVLocs",
"[",
"i",
"]",
".",
"isRegLoc",
"(",
")",
")",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"addLiveOut",
"(",
"RVLocs",
"[",
"i",
"]",
".",
"getLocReg",
"(",
")",
")",
";",
"}",
"SDValue",
"Flag",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"RVLocs",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"{",
"CCValAssign",
"&",
"VA",
"=",
"RVLocs",
"[",
"i",
"]",
";",
"assert",
"(",
"VA",
".",
"isRegLoc",
"(",
")",
"&&",
"\"Can only return in registers!\"",
")",
";",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"dl",
",",
"VA",
".",
"getLocReg",
"(",
")",
",",
"Outs",
"[",
"i",
"]",
".",
"Val",
",",
"Flag",
")",
";",
"Flag",
"=",
"Chain",
".",
"getValue",
"(",
"1",
")",
";",
"}",
"if",
"(",
"Flag",
".",
"getNode",
"(",
")",
")",
"return",
"DAG",
".",
"getNode",
"(",
"XCoreISD",
"::",
"RETSP",
",",
"dl",
",",
"MVT",
"::",
"Other",
",",
"Chain",
",",
"DAG",
".",
"getConstant",
"(",
"0",
",",
"MVT",
"::",
"i32",
")",
",",
"Flag",
")",
";",
"else",
"return",
"DAG",
".",
"getNode",
"(",
"XCoreISD",
"::",
"RETSP",
",",
"dl",
",",
"MVT",
"::",
"Other",
",",
"Chain",
",",
"DAG",
".",
"getConstant",
"(",
"0",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"outgoing",
"return",
"values",
",",
"described",
"by",
"the",
"Outs",
"array",
",",
"into",
"the",
"specified",
"DAG",
"."
] | [
"XCore",
"XCore",
"ISD::OutputArg",
"16",
"XCore",
"0",
"0",
"\"Can only return in registers!\"",
"1",
"XCoreISD::RETSP",
"MVT::Other",
"0",
"MVT::i32",
"XCoreISD::RETSP",
"MVT::Other",
"0",
"MVT::i32"
] | XCoreISelLowering43 | LowerReturn | XCore | MPU | LLVM | 19,338 | 289 | 1 | [] |
[
"<s>",
"virtual",
"const",
"DCPU16InstrInfo",
"*",
"getInstrInfo",
"(",
")",
"const",
"{",
"return",
"&",
"InstrInfo",
";",
"}",
"</s>"
] | [
"TargetInstrInfo",
"getter",
"."
] | [
"Dcpu16",
"DCPU16"
] | Dcpu16TargetMachine | getInstrInfo | Dcpu16 | CPU | LLVM | 19,339 | 14 | 1 | [] |
[
"<s>",
"bool",
"XCoreAsmPrinter",
"::",
"PrintAsmOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNo",
",",
"unsigned",
"AsmVariant",
",",
"const",
"char",
"*",
"ExtraCode",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"if",
"(",
"ExtraCode",
"&&",
"ExtraCode",
"[",
"0",
"]",
")",
"if",
"(",
"ExtraCode",
"[",
"1",
"]",
"!=",
"0",
")",
"return",
"true",
";",
"switch",
"(",
"ExtraCode",
"[",
"0",
"]",
")",
"{",
"default",
":",
"return",
"AsmPrinter",
"::",
"PrintAsmOperand",
"(",
"MI",
",",
"OpNo",
",",
"AsmVariant",
",",
"ExtraCode",
",",
"O",
")",
";",
"}",
"printOperand",
"(",
"MI",
",",
"OpNo",
",",
"O",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"PrintAsmOperand",
"-",
"Print",
"out",
"an",
"operand",
"for",
"an",
"inline",
"asm",
"expression",
"."
] | [
"XCore",
"XCore",
"0",
"1",
"0",
"0"
] | XCoreAsmPrinter12 | PrintAsmOperand | XCore | MPU | LLVM | 19,340 | 87 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"uint16_t",
",",
"uint16_t",
">",
"X86InstrInfo",
"::",
"getExecutionDomain",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"uint16_t",
"domain",
"=",
"(",
"MI",
".",
"getDesc",
"(",
")",
".",
"TSFlags",
">>",
"X86II",
"::",
"SSEDomainShift",
")",
"&",
"3",
";",
"unsigned",
"opcode",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"uint16_t",
"validDomains",
"=",
"0",
";",
"if",
"(",
"domain",
")",
"{",
"if",
"(",
"lookup",
"(",
"MI",
".",
"getOpcode",
"(",
")",
",",
"domain",
",",
"ReplaceableInstrs",
")",
")",
"{",
"validDomains",
"=",
"0xe",
";",
"}",
"else",
"if",
"(",
"lookup",
"(",
"opcode",
",",
"domain",
",",
"ReplaceableInstrsAVX2",
")",
")",
"{",
"validDomains",
"=",
"Subtarget",
".",
"hasAVX2",
"(",
")",
"?",
"0xe",
":",
"0x6",
";",
"}",
"else",
"if",
"(",
"lookupAVX512",
"(",
"opcode",
",",
"domain",
",",
"ReplaceableInstrsAVX512",
")",
")",
"{",
"validDomains",
"=",
"0xe",
";",
"}",
"else",
"if",
"(",
"lookupAVX512",
"(",
"opcode",
",",
"domain",
",",
"ReplaceableInstrsAVX512DQ",
")",
")",
"{",
"validDomains",
"=",
"Subtarget",
".",
"hasDQI",
"(",
")",
"?",
"0xe",
":",
"0x8",
";",
"}",
"else",
"if",
"(",
"const",
"uint16_t",
"*",
"table",
"=",
"lookupAVX512",
"(",
"opcode",
",",
"domain",
",",
"ReplaceableInstrsAVX512DQMasked",
")",
")",
"{",
"if",
"(",
"domain",
"==",
"1",
"||",
"(",
"domain",
"==",
"3",
"&&",
"table",
"[",
"3",
"]",
"==",
"opcode",
")",
")",
"validDomains",
"=",
"Subtarget",
".",
"hasDQI",
"(",
")",
"?",
"0xa",
":",
"0x8",
";",
"else",
"validDomains",
"=",
"Subtarget",
".",
"hasDQI",
"(",
")",
"?",
"0xc",
":",
"0x8",
";",
"}",
"}",
"return",
"std",
"::",
"make_pair",
"(",
"domain",
",",
"validDomains",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"current",
"execution",
"domain",
"and",
"bit",
"mask",
"of",
"possible",
"domains",
"for",
"instruction",
"."
] | [
"X86",
"X86",
"X86II::SSEDomainShift",
"3",
"0",
"0xe",
"0xe",
"0x6",
"0xe",
"0xe",
"0x8",
"1",
"3",
"3",
"0xa",
"0x8",
"0xc",
"0x8"
] | X86InstrInfo112 | getExecutionDomain | X86 | CPU | LLVM | 19,341 | 223 | 1 | [] |
[
"<s>",
"unsigned",
"LEGInstrInfo",
"::",
"isLoadFromStackSlot",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"assert",
"(",
"0",
"&&",
"\"Unimplemented\"",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"isLoadFromStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"load",
"from",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"destination",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
] | [
"LEG",
"LEG",
"0",
"\"Unimplemented\"",
"0"
] | LEGInstrInfo | isLoadFromStackSlot | LEG | CPU | LLVM | 19,342 | 27 | 1 | [] |
[
"<s>",
"static",
"bool",
"symbol_p",
"(",
"rtx",
"x",
")",
"{",
"int",
"c",
"=",
"GET_CODE",
"(",
"x",
")",
";",
"return",
"(",
"c",
"==",
"CONST_INT",
"||",
"c",
"==",
"CONST",
"||",
"c",
"==",
"SYMBOL_REF",
")",
";",
"}",
"</s>"
] | [
"MEP",
"has",
"very",
"few",
"instructions",
"that",
"can",
"refer",
"to",
"the",
"span",
"of",
"addresses",
"used",
"by",
"symbols",
",",
"so",
"it",
"'s",
"common",
"to",
"check",
"for",
"them",
"."
] | [
"mep"
] | mep | symbol_p | mep | CPU | GCC | 19,343 | 32 | 1 | [] |
[
"<s>",
"static",
"bool",
"rs6000_secondary_reload_simple_move",
"(",
"enum",
"rs6000_reg_type",
"to_type",
",",
"enum",
"rs6000_reg_type",
"from_type",
",",
"machine_mode",
"mode",
")",
"{",
"int",
"size",
"=",
"GET_MODE_SIZE",
"(",
"mode",
")",
";",
"if",
"(",
"TARGET_DIRECT_MOVE",
"&&",
"(",
"(",
"to_type",
"==",
"GPR_REG_TYPE",
"&&",
"from_type",
"==",
"VSX_REG_TYPE",
")",
"||",
"(",
"to_type",
"==",
"VSX_REG_TYPE",
"&&",
"from_type",
"==",
"GPR_REG_TYPE",
")",
")",
")",
"{",
"if",
"(",
"TARGET_POWERPC64",
")",
"{",
"if",
"(",
"size",
"==",
"8",
")",
"return",
"true",
";",
"if",
"(",
"size",
"==",
"16",
"&&",
"TARGET_P9_VECTOR",
"&&",
"mode",
"!=",
"TDmode",
")",
"return",
"true",
";",
"}",
"if",
"(",
"TARGET_VSX_SMALL_INTEGER",
")",
"{",
"if",
"(",
"mode",
"==",
"SImode",
")",
"return",
"true",
";",
"if",
"(",
"TARGET_P9_VECTOR",
"&&",
"(",
"mode",
"==",
"HImode",
"||",
"mode",
"==",
"QImode",
")",
")",
"return",
"true",
";",
"}",
"if",
"(",
"mode",
"==",
"SDmode",
")",
"return",
"true",
";",
"}",
"else",
"if",
"(",
"TARGET_MFPGPR",
"&&",
"TARGET_POWERPC64",
"&&",
"size",
"==",
"8",
"&&",
"(",
"(",
"to_type",
"==",
"GPR_REG_TYPE",
"&&",
"from_type",
"==",
"FPR_REG_TYPE",
")",
"||",
"(",
"to_type",
"==",
"FPR_REG_TYPE",
"&&",
"from_type",
"==",
"GPR_REG_TYPE",
")",
")",
")",
"return",
"true",
";",
"else",
"if",
"(",
"(",
"size",
"==",
"4",
"||",
"(",
"TARGET_POWERPC64",
"&&",
"size",
"==",
"8",
")",
")",
"&&",
"(",
"(",
"to_type",
"==",
"GPR_REG_TYPE",
"&&",
"from_type",
"==",
"SPR_REG_TYPE",
")",
"||",
"(",
"to_type",
"==",
"SPR_REG_TYPE",
"&&",
"from_type",
"==",
"GPR_REG_TYPE",
")",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Helper",
"function",
"for",
"rs6000_secondary_reload",
"to",
"return",
"true",
"if",
"a",
"move",
"to",
"a",
"different",
"register",
"classe",
"is",
"really",
"a",
"simple",
"move",
"."
] | [
"powerpcspe",
"8",
"16",
"8",
"4",
"8"
] | powerpcspe | rs6000_secondary_reload_simple_move | powerpcspe | CPU | GCC | 19,344 | 205 | 1 | [] |
[
"<s>",
"static",
"inline",
"int",
"shiftcosts",
"(",
"rtx",
"x",
")",
"{",
"if",
"(",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"x",
")",
")",
">",
"UNITS_PER_WORD",
")",
"{",
"if",
"(",
"GET_MODE",
"(",
"x",
")",
"==",
"DImode",
"&&",
"CONST_INT_P",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
"&&",
"INTVAL",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
"==",
"1",
")",
"return",
"2",
";",
"return",
"-",
"1",
";",
"}",
"if",
"(",
"!",
"CONST_INT_P",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
")",
"return",
"SH_DYNAMIC_SHIFT_COST",
";",
"int",
"value",
"=",
"INTVAL",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
"&",
"31",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"ASHIFTRT",
")",
"{",
"int",
"cost",
"=",
"ashiftrt_insns",
"[",
"value",
"]",
";",
"if",
"(",
"cost",
">",
"1",
"+",
"SH_DYNAMIC_SHIFT_COST",
")",
"cost",
"=",
"1",
"+",
"SH_DYNAMIC_SHIFT_COST",
";",
"return",
"cost",
";",
"}",
"else",
"return",
"ashl_lshr_seq",
"[",
"value",
"]",
".",
"insn_count",
";",
"}",
"</s>"
] | [
"Return",
"the",
"cost",
"of",
"a",
"shift",
"."
] | [
"sh",
"1",
"1",
"1",
"2",
"1",
"1",
"1",
"31",
"1",
"1"
] | sh | shiftcosts | sh | CPU | GCC | 19,345 | 138 | 1 | [] |
[
"<s>",
"bool",
"NVPTXPassConfig",
"::",
"addInstSelector",
"(",
")",
"{",
"addPass",
"(",
"createLowerAggrCopies",
"(",
")",
")",
";",
"addPass",
"(",
"createSplitBBatBarPass",
"(",
")",
")",
";",
"addPass",
"(",
"createAllocaHoisting",
"(",
")",
")",
";",
"addPass",
"(",
"createNVPTXISelDag",
"(",
"getNVPTXTargetMachine",
"(",
")",
",",
"getOptLevel",
"(",
")",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"addInstSelector",
"-",
"This",
"method",
"should",
"install",
"an",
"instruction",
"selector",
"pass",
",",
"which",
"converts",
"from",
"LLVM",
"code",
"to",
"machine",
"instructions",
"."
] | [
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX"
] | NVPTXTargetMachine12 | addInstSelector | NVPTX | GPU | LLVM | 19,346 | 46 | 1 | [] |
[
"<s>",
"static",
"bool",
"aarch64_returns_value_in_sve_regs_p",
"(",
"const_tree",
"fntype",
")",
"{",
"tree",
"return_type",
"=",
"TREE_TYPE",
"(",
"fntype",
")",
";",
"pure_scalable_type_info",
"pst_info",
";",
"switch",
"(",
"pst_info",
".",
"analyze",
"(",
"return_type",
")",
")",
"{",
"case",
"pure_scalable_type_info",
"::",
"IS_PST",
":",
"return",
"(",
"pst_info",
".",
"num_zr",
"(",
")",
"<=",
"NUM_FP_ARG_REGS",
"&&",
"pst_info",
".",
"num_pr",
"(",
")",
"<=",
"NUM_PR_ARG_REGS",
")",
";",
"case",
"pure_scalable_type_info",
"::",
"DOESNT_MATTER",
":",
"gcc_assert",
"(",
"aarch64_return_in_memory_1",
"(",
"return_type",
")",
")",
";",
"return",
"false",
";",
"case",
"pure_scalable_type_info",
"::",
"NO_ABI_IDENTITY",
":",
"case",
"pure_scalable_type_info",
"::",
"ISNT_PST",
":",
"return",
"false",
";",
"}",
"gcc_unreachable",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"a",
"function",
"with",
"type",
"FNTYPE",
"returns",
"its",
"value",
"in",
"SVE",
"vector",
"or",
"predicate",
"registers",
"."
] | [
"aarch64"
] | aarch64 | aarch64_returns_value_in_sve_regs_p | aarch64 | CPU | GCC | 19,347 | 88 | 1 | [] |
[
"<s>",
"XCoreTargetMachine",
"::",
"XCoreTargetMachine",
"(",
"const",
"Target",
"&",
"T",
",",
"const",
"std",
"::",
"string",
"&",
"TT",
",",
"const",
"std",
"::",
"string",
"&",
"FS",
")",
":",
"LLVMTargetMachine",
"(",
"T",
",",
"TT",
")",
",",
"Subtarget",
"(",
"TT",
",",
"FS",
")",
",",
"DataLayout",
"(",
"\"e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-\"",
"\"i16:16:32-i32:32:32-i64:32:32\"",
")",
",",
"InstrInfo",
"(",
")",
",",
"FrameInfo",
"(",
"*",
"this",
")",
",",
"TLInfo",
"(",
"*",
"this",
")",
"{",
"}",
"</s>"
] | [
"Create",
"an",
"ILP32",
"architecture",
"model",
"."
] | [
"XCore",
"XCore",
"XCore",
"\"e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-\"",
"\"i16:16:32-i32:32:32-i64:32:32\""
] | XCoreTargetMachine8 | XCoreTargetMachine | XCore | MPU | LLVM | 19,348 | 61 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"AMDGPUTargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"(",
"AMDGPUISD",
"::",
"NodeType",
")",
"Opcode",
")",
"{",
"case",
"AMDGPUISD",
"::",
"FIRST_NUMBER",
":",
"break",
";",
"NODE_NAME_CASE",
"(",
"CALL",
")",
";",
"NODE_NAME_CASE",
"(",
"UMUL",
")",
";",
"NODE_NAME_CASE",
"(",
"BRANCH_COND",
")",
";",
"NODE_NAME_CASE",
"(",
"ENDPGM",
")",
"NODE_NAME_CASE",
"(",
"RETURN",
")",
"NODE_NAME_CASE",
"(",
"DWORDADDR",
")",
"NODE_NAME_CASE",
"(",
"FRACT",
")",
"NODE_NAME_CASE",
"(",
"CLAMP",
")",
"NODE_NAME_CASE",
"(",
"COS_HW",
")",
"NODE_NAME_CASE",
"(",
"SIN_HW",
")",
"NODE_NAME_CASE",
"(",
"FMAX_LEGACY",
")",
"NODE_NAME_CASE",
"(",
"FMIN_LEGACY",
")",
"NODE_NAME_CASE",
"(",
"FMAX3",
")",
"NODE_NAME_CASE",
"(",
"SMAX3",
")",
"NODE_NAME_CASE",
"(",
"UMAX3",
")",
"NODE_NAME_CASE",
"(",
"FMIN3",
")",
"NODE_NAME_CASE",
"(",
"SMIN3",
")",
"NODE_NAME_CASE",
"(",
"UMIN3",
")",
"NODE_NAME_CASE",
"(",
"FMED3",
")",
"NODE_NAME_CASE",
"(",
"SMED3",
")",
"NODE_NAME_CASE",
"(",
"UMED3",
")",
"NODE_NAME_CASE",
"(",
"URECIP",
")",
"NODE_NAME_CASE",
"(",
"DIV_SCALE",
")",
"NODE_NAME_CASE",
"(",
"DIV_FMAS",
")",
"NODE_NAME_CASE",
"(",
"DIV_FIXUP",
")",
"NODE_NAME_CASE",
"(",
"TRIG_PREOP",
")",
"NODE_NAME_CASE",
"(",
"RCP",
")",
"NODE_NAME_CASE",
"(",
"RSQ",
")",
"NODE_NAME_CASE",
"(",
"RSQ_LEGACY",
")",
"NODE_NAME_CASE",
"(",
"RSQ_CLAMP",
")",
"NODE_NAME_CASE",
"(",
"LDEXP",
")",
"NODE_NAME_CASE",
"(",
"FP_CLASS",
")",
"NODE_NAME_CASE",
"(",
"DOT4",
")",
"NODE_NAME_CASE",
"(",
"CARRY",
")",
"NODE_NAME_CASE",
"(",
"BORROW",
")",
"NODE_NAME_CASE",
"(",
"BFE_U32",
")",
"NODE_NAME_CASE",
"(",
"BFE_I32",
")",
"NODE_NAME_CASE",
"(",
"BFI",
")",
"NODE_NAME_CASE",
"(",
"BFM",
")",
"NODE_NAME_CASE",
"(",
"FFBH_U32",
")",
"NODE_NAME_CASE",
"(",
"FFBH_I32",
")",
"NODE_NAME_CASE",
"(",
"MUL_U24",
")",
"NODE_NAME_CASE",
"(",
"MUL_I24",
")",
"NODE_NAME_CASE",
"(",
"MAD_U24",
")",
"NODE_NAME_CASE",
"(",
"MAD_I24",
")",
"NODE_NAME_CASE",
"(",
"TEXTURE_FETCH",
")",
"NODE_NAME_CASE",
"(",
"EXPORT",
")",
"NODE_NAME_CASE",
"(",
"CONST_ADDRESS",
")",
"NODE_NAME_CASE",
"(",
"REGISTER_LOAD",
")",
"NODE_NAME_CASE",
"(",
"REGISTER_STORE",
")",
"NODE_NAME_CASE",
"(",
"LOAD_INPUT",
")",
"NODE_NAME_CASE",
"(",
"SAMPLE",
")",
"NODE_NAME_CASE",
"(",
"SAMPLEB",
")",
"NODE_NAME_CASE",
"(",
"SAMPLED",
")",
"NODE_NAME_CASE",
"(",
"SAMPLEL",
")",
"NODE_NAME_CASE",
"(",
"CVT_F32_UBYTE0",
")",
"NODE_NAME_CASE",
"(",
"CVT_F32_UBYTE1",
")",
"NODE_NAME_CASE",
"(",
"CVT_F32_UBYTE2",
")",
"NODE_NAME_CASE",
"(",
"CVT_F32_UBYTE3",
")",
"NODE_NAME_CASE",
"(",
"BUILD_VERTICAL_VECTOR",
")",
"NODE_NAME_CASE",
"(",
"CONST_DATA_PTR",
")",
"NODE_NAME_CASE",
"(",
"PC_ADD_REL_OFFSET",
")",
"NODE_NAME_CASE",
"(",
"KILL",
")",
"case",
"AMDGPUISD",
"::",
"FIRST_MEM_OPCODE_NUMBER",
":",
"break",
";",
"NODE_NAME_CASE",
"(",
"SENDMSG",
")",
"NODE_NAME_CASE",
"(",
"INTERP_MOV",
")",
"NODE_NAME_CASE",
"(",
"INTERP_P1",
")",
"NODE_NAME_CASE",
"(",
"INTERP_P2",
")",
"NODE_NAME_CASE",
"(",
"STORE_MSKOR",
")",
"NODE_NAME_CASE",
"(",
"LOAD_CONSTANT",
")",
"NODE_NAME_CASE",
"(",
"TBUFFER_STORE_FORMAT",
")",
"NODE_NAME_CASE",
"(",
"ATOMIC_CMP_SWAP",
")",
"NODE_NAME_CASE",
"(",
"ATOMIC_INC",
")",
"NODE_NAME_CASE",
"(",
"ATOMIC_DEC",
")",
"case",
"AMDGPUISD",
"::",
"LAST_AMDGPU_ISD_NUMBER",
":",
"break",
";",
"}",
"return",
"nullptr",
";",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"AMDGPU",
"AMDGPU",
"AMDGPUISD::NodeType",
"AMDGPUISD::FIRST_NUMBER",
"SI",
"AMDGPUISD::FIRST_MEM_OPCODE_NUMBER",
"AMDGPUISD::LAST_AMDGPU_ISD_NUMBER"
] | AMDGPUISelLowering87 | getTargetNodeName | AMDGPU | GPU | LLVM | 19,349 | 343 | 1 | [] |
[
"<s>",
"bool",
"SystemZAsmParser",
"::",
"MatchAndEmitInstruction",
"(",
"SMLoc",
"IDLoc",
",",
"unsigned",
"&",
"Opcode",
",",
"OperandVector",
"&",
"Operands",
",",
"MCStreamer",
"&",
"Out",
",",
"uint64_t",
"&",
"ErrorInfo",
",",
"bool",
"MatchingInlineAsm",
")",
"{",
"MCInst",
"Inst",
";",
"unsigned",
"MatchResult",
";",
"MatchResult",
"=",
"MatchInstructionImpl",
"(",
"Operands",
",",
"Inst",
",",
"ErrorInfo",
",",
"MatchingInlineAsm",
")",
";",
"switch",
"(",
"MatchResult",
")",
"{",
"default",
":",
"break",
";",
"case",
"Match_Success",
":",
"Inst",
".",
"setLoc",
"(",
"IDLoc",
")",
";",
"Out",
".",
"EmitInstruction",
"(",
"Inst",
",",
"STI",
")",
";",
"return",
"false",
";",
"case",
"Match_MissingFeature",
":",
"{",
"assert",
"(",
"ErrorInfo",
"&&",
"\"Unknown missing feature!\"",
")",
";",
"std",
"::",
"string",
"Msg",
"=",
"\"instruction requires:\"",
";",
"uint64_t",
"Mask",
"=",
"1",
";",
"for",
"(",
"unsigned",
"I",
"=",
"0",
";",
"I",
"<",
"sizeof",
"(",
"ErrorInfo",
")",
"*",
"8",
"-",
"1",
";",
"++",
"I",
")",
"{",
"if",
"(",
"ErrorInfo",
"&",
"Mask",
")",
"{",
"Msg",
"+=",
"\" \"",
";",
"Msg",
"+=",
"getSubtargetFeatureName",
"(",
"ErrorInfo",
"&",
"Mask",
")",
";",
"}",
"Mask",
"<<=",
"1",
";",
"}",
"return",
"Error",
"(",
"IDLoc",
",",
"Msg",
")",
";",
"}",
"case",
"Match_InvalidOperand",
":",
"{",
"SMLoc",
"ErrorLoc",
"=",
"IDLoc",
";",
"if",
"(",
"ErrorInfo",
"!=",
"~",
"0ULL",
")",
"{",
"if",
"(",
"ErrorInfo",
">=",
"Operands",
".",
"size",
"(",
")",
")",
"return",
"Error",
"(",
"IDLoc",
",",
"\"too few operands for instruction\"",
")",
";",
"ErrorLoc",
"=",
"(",
"(",
"SystemZOperand",
"&",
")",
"*",
"Operands",
"[",
"ErrorInfo",
"]",
")",
".",
"getStartLoc",
"(",
")",
";",
"if",
"(",
"ErrorLoc",
"==",
"SMLoc",
"(",
")",
")",
"ErrorLoc",
"=",
"IDLoc",
";",
"}",
"return",
"Error",
"(",
"ErrorLoc",
",",
"\"invalid operand for instruction\"",
")",
";",
"}",
"case",
"Match_MnemonicFail",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"invalid instruction\"",
")",
";",
"}",
"llvm_unreachable",
"(",
"\"Unexpected match type\"",
")",
";",
"}",
"</s>"
] | [
"MatchAndEmitInstruction",
"-",
"Recognize",
"a",
"series",
"of",
"operands",
"of",
"a",
"parsed",
"instruction",
"as",
"an",
"actual",
"MCInst",
"and",
"emit",
"it",
"to",
"the",
"specified",
"MCStreamer",
"."
] | [
"SystemZ",
"SystemZ",
"\"Unknown missing feature!\"",
"\"instruction requires:\"",
"1",
"0",
"8",
"1",
"\" \"",
"1",
"0ULL",
"\"too few operands for instruction\"",
"SystemZ",
"\"invalid operand for instruction\"",
"\"invalid instruction\"",
"\"Unexpected match type\""
] | SystemZAsmParser40 | MatchAndEmitInstruction | SystemZ | CPU | LLVM | 19,350 | 251 | 1 | [] |
[
"<s>",
"static",
"tree",
"rs6000_builtin_vectorized_libmass",
"(",
"combined_fn",
"fn",
",",
"tree",
"type_out",
",",
"tree",
"type_in",
")",
"{",
"char",
"name",
"[",
"32",
"]",
";",
"const",
"char",
"*",
"suffix",
"=",
"NULL",
";",
"tree",
"fntype",
",",
"new_fndecl",
",",
"bdecl",
"=",
"NULL_TREE",
";",
"int",
"n_args",
"=",
"1",
";",
"const",
"char",
"*",
"bname",
";",
"machine_mode",
"el_mode",
",",
"in_mode",
";",
"int",
"n",
",",
"in_n",
";",
"if",
"(",
"!",
"flag_unsafe_math_optimizations",
"||",
"!",
"TARGET_VSX",
")",
"return",
"NULL_TREE",
";",
"el_mode",
"=",
"TYPE_MODE",
"(",
"TREE_TYPE",
"(",
"type_out",
")",
")",
";",
"n",
"=",
"TYPE_VECTOR_SUBPARTS",
"(",
"type_out",
")",
";",
"in_mode",
"=",
"TYPE_MODE",
"(",
"TREE_TYPE",
"(",
"type_in",
")",
")",
";",
"in_n",
"=",
"TYPE_VECTOR_SUBPARTS",
"(",
"type_in",
")",
";",
"if",
"(",
"el_mode",
"!=",
"in_mode",
"||",
"n",
"!=",
"in_n",
")",
"return",
"NULL_TREE",
";",
"switch",
"(",
"fn",
")",
"{",
"CASE_CFN_ATAN2",
":",
"CASE_CFN_HYPOT",
":",
"CASE_CFN_POW",
":",
"n_args",
"=",
"2",
";",
"gcc_fallthrough",
"(",
")",
";",
"CASE_CFN_ACOS",
":",
"CASE_CFN_ACOSH",
":",
"CASE_CFN_ASIN",
":",
"CASE_CFN_ASINH",
":",
"CASE_CFN_ATAN",
":",
"CASE_CFN_ATANH",
":",
"CASE_CFN_CBRT",
":",
"CASE_CFN_COS",
":",
"CASE_CFN_COSH",
":",
"CASE_CFN_ERF",
":",
"CASE_CFN_ERFC",
":",
"CASE_CFN_EXP2",
":",
"CASE_CFN_EXP",
":",
"CASE_CFN_EXPM1",
":",
"CASE_CFN_LGAMMA",
":",
"CASE_CFN_LOG10",
":",
"CASE_CFN_LOG1P",
":",
"CASE_CFN_LOG2",
":",
"CASE_CFN_LOG",
":",
"CASE_CFN_SIN",
":",
"CASE_CFN_SINH",
":",
"CASE_CFN_SQRT",
":",
"CASE_CFN_TAN",
":",
"CASE_CFN_TANH",
":",
"if",
"(",
"el_mode",
"==",
"DFmode",
"&&",
"n",
"==",
"2",
")",
"{",
"bdecl",
"=",
"mathfn_built_in",
"(",
"double_type_node",
",",
"fn",
")",
";",
"suffix",
"=",
"\"d2\"",
";",
"}",
"else",
"if",
"(",
"el_mode",
"==",
"SFmode",
"&&",
"n",
"==",
"4",
")",
"{",
"bdecl",
"=",
"mathfn_built_in",
"(",
"float_type_node",
",",
"fn",
")",
";",
"suffix",
"=",
"\"4\"",
";",
"}",
"else",
"return",
"NULL_TREE",
";",
"if",
"(",
"!",
"bdecl",
")",
"return",
"NULL_TREE",
";",
"break",
";",
"default",
":",
"return",
"NULL_TREE",
";",
"}",
"gcc_assert",
"(",
"suffix",
"!=",
"NULL",
")",
";",
"bname",
"=",
"IDENTIFIER_POINTER",
"(",
"DECL_NAME",
"(",
"bdecl",
")",
")",
";",
"if",
"(",
"!",
"bname",
")",
"return",
"NULL_TREE",
";",
"strcpy",
"(",
"name",
",",
"bname",
"+",
"sizeof",
"(",
"\"__builtin_\"",
")",
"-",
"1",
")",
";",
"strcat",
"(",
"name",
",",
"suffix",
")",
";",
"if",
"(",
"n_args",
"==",
"1",
")",
"fntype",
"=",
"build_function_type_list",
"(",
"type_out",
",",
"type_in",
",",
"NULL",
")",
";",
"else",
"if",
"(",
"n_args",
"==",
"2",
")",
"fntype",
"=",
"build_function_type_list",
"(",
"type_out",
",",
"type_in",
",",
"type_in",
",",
"NULL",
")",
";",
"else",
"gcc_unreachable",
"(",
")",
";",
"new_fndecl",
"=",
"build_decl",
"(",
"BUILTINS_LOCATION",
",",
"FUNCTION_DECL",
",",
"get_identifier",
"(",
"name",
")",
",",
"fntype",
")",
";",
"TREE_PUBLIC",
"(",
"new_fndecl",
")",
"=",
"1",
";",
"DECL_EXTERNAL",
"(",
"new_fndecl",
")",
"=",
"1",
";",
"DECL_IS_NOVOPS",
"(",
"new_fndecl",
")",
"=",
"1",
";",
"TREE_READONLY",
"(",
"new_fndecl",
")",
"=",
"1",
";",
"return",
"new_fndecl",
";",
"}",
"</s>"
] | [
"Handler",
"for",
"the",
"Mathematical",
"Acceleration",
"Subsystem",
"(",
"mass",
")",
"interface",
"to",
"a",
"library",
"with",
"vectorized",
"intrinsics",
"."
] | [
"rs6000",
"32",
"1",
"2",
"2",
"\"d2\"",
"4",
"\"4\"",
"\"__builtin_\"",
"1",
"1",
"2",
"1",
"1",
"1",
"1"
] | rs60006 | rs6000_builtin_vectorized_libmass | rs6000 | CPU | GCC | 19,351 | 388 | 1 | [] |
[
"<s>",
"void",
"sparc_expand_epilogue",
"(",
"bool",
"for_eh",
")",
"{",
"HOST_WIDE_INT",
"size",
"=",
"sparc_frame_size",
";",
"if",
"(",
"cfun",
"->",
"calls_alloca",
")",
"emit_insn",
"(",
"gen_frame_blockage",
"(",
")",
")",
";",
"if",
"(",
"sparc_n_global_fp_regs",
">",
"0",
")",
"emit_save_or_restore_global_fp_regs",
"(",
"sparc_frame_base_reg",
",",
"sparc_frame_base_offset",
"-",
"sparc_apparent_frame_size",
",",
"SORR_RESTORE",
")",
";",
"if",
"(",
"size",
"==",
"0",
"||",
"for_eh",
")",
";",
"else",
"if",
"(",
"sparc_leaf_function_p",
")",
"{",
"if",
"(",
"size",
"<=",
"4096",
")",
"emit_insn",
"(",
"gen_stack_pointer_inc",
"(",
"GEN_INT",
"(",
"size",
")",
")",
")",
";",
"else",
"if",
"(",
"size",
"<=",
"8192",
")",
"{",
"emit_insn",
"(",
"gen_stack_pointer_inc",
"(",
"GEN_INT",
"(",
"4096",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_stack_pointer_inc",
"(",
"GEN_INT",
"(",
"size",
"-",
"4096",
")",
")",
")",
";",
"}",
"else",
"{",
"rtx",
"reg",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"1",
")",
";",
"emit_move_insn",
"(",
"reg",
",",
"GEN_INT",
"(",
"size",
")",
")",
";",
"emit_insn",
"(",
"gen_stack_pointer_inc",
"(",
"reg",
")",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Expand",
"the",
"function",
"epilogue",
",",
"either",
"normal",
"or",
"part",
"of",
"a",
"sibcall",
".",
"We",
"emit",
"all",
"the",
"instructions",
"except",
"the",
"return",
"or",
"the",
"call",
"."
] | [
"sparc",
"0",
"0",
"4096",
"8192",
"4096",
"4096",
"1"
] | sparc | sparc_expand_epilogue | sparc | CPU | GCC | 19,352 | 140 | 1 | [] |
[
"<s>",
"void",
"SystemZAsmPrinter",
"::",
"EmitInstruction",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"{",
"SystemZMCInstLower",
"Lower",
"(",
"Mang",
",",
"MF",
"->",
"getContext",
"(",
")",
",",
"*",
"this",
")",
";",
"MCInst",
"LoweredMI",
";",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"SystemZ",
"::",
"Return",
":",
"LoweredMI",
"=",
"MCInstBuilder",
"(",
"SystemZ",
"::",
"BR",
")",
".",
"addReg",
"(",
"SystemZ",
"::",
"R14D",
")",
";",
"break",
";",
"case",
"SystemZ",
"::",
"CallBRASL",
":",
"LoweredMI",
"=",
"MCInstBuilder",
"(",
"SystemZ",
"::",
"BRASL",
")",
".",
"addReg",
"(",
"SystemZ",
"::",
"R14D",
")",
".",
"addExpr",
"(",
"Lower",
".",
"getExpr",
"(",
"MI",
"->",
"getOperand",
"(",
"0",
")",
",",
"MCSymbolRefExpr",
"::",
"VK_PLT",
")",
")",
";",
"break",
";",
"case",
"SystemZ",
"::",
"CallBASR",
":",
"LoweredMI",
"=",
"MCInstBuilder",
"(",
"SystemZ",
"::",
"BASR",
")",
".",
"addReg",
"(",
"SystemZ",
"::",
"R14D",
")",
".",
"addReg",
"(",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
")",
";",
"break",
";",
"case",
"SystemZ",
"::",
"CallJG",
":",
"LoweredMI",
"=",
"MCInstBuilder",
"(",
"SystemZ",
"::",
"JG",
")",
".",
"addExpr",
"(",
"Lower",
".",
"getExpr",
"(",
"MI",
"->",
"getOperand",
"(",
"0",
")",
",",
"MCSymbolRefExpr",
"::",
"VK_PLT",
")",
")",
";",
"break",
";",
"case",
"SystemZ",
"::",
"CallBR",
":",
"LoweredMI",
"=",
"MCInstBuilder",
"(",
"SystemZ",
"::",
"BR",
")",
".",
"addReg",
"(",
"SystemZ",
"::",
"R1D",
")",
";",
"break",
";",
"case",
"SystemZ",
"::",
"IILF64",
":",
"LoweredMI",
"=",
"MCInstBuilder",
"(",
"SystemZ",
"::",
"IILF",
")",
".",
"addReg",
"(",
"SystemZMC",
"::",
"getRegAsGR32",
"(",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
")",
")",
".",
"addImm",
"(",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
")",
";",
"break",
";",
"case",
"SystemZ",
"::",
"IIHF64",
":",
"LoweredMI",
"=",
"MCInstBuilder",
"(",
"SystemZ",
"::",
"IIHF",
")",
".",
"addReg",
"(",
"SystemZMC",
"::",
"getRegAsGRH32",
"(",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
")",
")",
".",
"addImm",
"(",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
")",
";",
"break",
";",
"case",
"SystemZ",
"::",
"RISBHH",
":",
"case",
"SystemZ",
"::",
"RISBHL",
":",
"LoweredMI",
"=",
"lowerRIEfLow",
"(",
"MI",
",",
"SystemZ",
"::",
"RISBHG",
")",
";",
"break",
";",
"case",
"SystemZ",
"::",
"RISBLH",
":",
"case",
"SystemZ",
"::",
"RISBLL",
":",
"LoweredMI",
"=",
"lowerRIEfLow",
"(",
"MI",
",",
"SystemZ",
"::",
"RISBLG",
")",
";",
"break",
";",
"case",
"SystemZ",
"::",
"NAME",
"##",
"64",
":",
"LoweredMI",
"=",
"lowerRILow",
"(",
"MI",
",",
"SystemZ",
"::",
"NAME",
")",
";",
"break",
"LOWER_LOW",
"(",
"IILL",
")",
";",
"LOWER_LOW",
"(",
"IILH",
")",
";",
"LOWER_LOW",
"(",
"NILL",
")",
";",
"LOWER_LOW",
"(",
"NILH",
")",
";",
"LOWER_LOW",
"(",
"NILF",
")",
";",
"LOWER_LOW",
"(",
"OILL",
")",
";",
"LOWER_LOW",
"(",
"OILH",
")",
";",
"LOWER_LOW",
"(",
"OILF",
")",
";",
"LOWER_LOW",
"(",
"XILF",
")",
";",
"case",
"SystemZ",
"::",
"NAME",
"##",
"64",
":",
"LoweredMI",
"=",
"lowerRIHigh",
"(",
"MI",
",",
"SystemZ",
"::",
"NAME",
")",
";",
"break",
"LOWER_HIGH",
"(",
"IIHL",
")",
";",
"LOWER_HIGH",
"(",
"IIHH",
")",
";",
"LOWER_HIGH",
"(",
"NIHL",
")",
";",
"LOWER_HIGH",
"(",
"NIHH",
")",
";",
"LOWER_HIGH",
"(",
"NIHF",
")",
";",
"LOWER_HIGH",
"(",
"OIHL",
")",
";",
"LOWER_HIGH",
"(",
"OIHH",
")",
";",
"LOWER_HIGH",
"(",
"OIHF",
")",
";",
"LOWER_HIGH",
"(",
"XIHF",
")",
";",
"default",
":",
"Lower",
".",
"lower",
"(",
"MI",
",",
"LoweredMI",
")",
";",
"break",
";",
"}",
"OutStreamer",
".",
"EmitInstruction",
"(",
"LoweredMI",
")",
";",
"}",
"</s>"
] | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ::Return",
"SystemZ::BR",
"SystemZ::R14D",
"SystemZ::CallBRASL",
"SystemZ::BRASL",
"SystemZ::R14D",
"0",
"SystemZ::CallBASR",
"SystemZ::BASR",
"SystemZ::R14D",
"0",
"SystemZ::CallJG",
"SystemZ::JG",
"0",
"SystemZ::CallBR",
"SystemZ::BR",
"SystemZ::R1D",
"SystemZ::IILF64",
"SystemZ::IILF",
"SystemZMC::getRegAsGR32",
"0",
"2",
"SystemZ::IIHF64",
"SystemZ::IIHF",
"SystemZMC::getRegAsGRH32",
"0",
"2",
"SystemZ::RISBHH",
"SystemZ::RISBHL",
"SystemZ::RISBHG",
"SystemZ::RISBLH",
"SystemZ::RISBLL",
"SystemZ::RISBLG",
"SystemZ::NAME",
"64",
"SystemZ::NAME",
"SystemZ::NAME",
"64",
"SystemZ::NAME"
] | SystemZAsmPrinter36 | EmitInstruction | SystemZ | CPU | LLVM | 19,353 | 492 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"TargetTransformInfo",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"ARM"
] | ARMTargetTransformInfo21 | getAnalysisUsage | ARM | CPU | LLVM | 19,354 | 18 | 1 | [] |
[
"<s>",
"MCELFStreamer",
"&",
"getStreamer",
"(",
")",
"{",
"return",
"static_cast",
"<",
"MCELFStreamer",
"&",
">",
"(",
"Streamer",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"output",
"streamer",
"for",
"the",
"assembler",
"."
] | [
"Hexagon"
] | HexagonMCTargetDesc | getStreamer | Hexagon | DSP | LLVM | 19,355 | 17 | 1 | [] |
[
"<s>",
"static",
"void",
"ix86_adjust_counter",
"(",
"rtx",
"countreg",
",",
"HOST_WIDE_INT",
"value",
")",
"{",
"rtx",
"(",
"*",
"gen_add",
")",
"(",
"rtx",
",",
"rtx",
",",
"rtx",
")",
"=",
"GET_MODE",
"(",
"countreg",
")",
"==",
"DImode",
"?",
"gen_adddi3",
":",
"gen_addsi3",
";",
"emit_insn",
"(",
"gen_add",
"(",
"countreg",
",",
"countreg",
",",
"GEN_INT",
"(",
"-",
"value",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Adjust",
"COUNTER",
"by",
"the",
"VALUE",
"."
] | [
"i386"
] | i3864 | ix86_adjust_counter | i386 | CPU | GCC | 19,356 | 52 | 1 | [] |
[
"<s>",
"void",
"MipsDAGToDAGISel",
"::",
"Select",
"(",
"SDNode",
"*",
"Node",
")",
"{",
"unsigned",
"Opcode",
"=",
"Node",
"->",
"getOpcode",
"(",
")",
";",
"if",
"(",
"Node",
"->",
"isMachineOpcode",
"(",
")",
")",
"{",
"LLVM_DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"== \"",
";",
"Node",
"->",
"dump",
"(",
"CurDAG",
")",
";",
"errs",
"(",
")",
"<<",
"\"\\n\"",
")",
";",
"Node",
"->",
"setNodeId",
"(",
"-",
"1",
")",
";",
"return",
";",
"}",
"if",
"(",
"trySelect",
"(",
"Node",
")",
")",
"return",
";",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"ADD",
":",
"if",
"(",
"Node",
"->",
"getSimpleValueType",
"(",
"0",
")",
".",
"isVector",
"(",
")",
"&&",
"selectVecAddAsVecSubIfProfitable",
"(",
"Node",
")",
")",
"return",
";",
"break",
";",
"case",
"ISD",
"::",
"GLOBAL_OFFSET_TABLE",
":",
"ReplaceNode",
"(",
"Node",
",",
"getGlobalBaseReg",
"(",
")",
")",
";",
"return",
";",
"case",
"ISD",
"::",
"LOAD",
":",
"case",
"ISD",
"::",
"STORE",
":",
"assert",
"(",
"(",
"Subtarget",
"->",
"systemSupportsUnalignedAccess",
"(",
")",
"||",
"cast",
"<",
"MemSDNode",
">",
"(",
"Node",
")",
"->",
"getMemoryVT",
"(",
")",
".",
"getSizeInBits",
"(",
")",
"/",
"8",
"<=",
"cast",
"<",
"MemSDNode",
">",
"(",
"Node",
")",
"->",
"getAlignment",
"(",
")",
")",
"&&",
"\"Unexpected unaligned loads/stores.\"",
")",
";",
"break",
";",
"}",
"SelectCode",
"(",
"Node",
")",
";",
"}",
"</s>"
] | [
"Main",
"hook",
"for",
"targets",
"to",
"transform",
"nodes",
"into",
"machine",
"nodes",
"."
] | [
"Mips",
"Mips",
"\"== \"",
"\"\\n\"",
"1",
"ISD::ADD",
"0",
"ISD::GLOBAL_OFFSET_TABLE",
"ISD::LOAD",
"ISD::STORE",
"8",
"\"Unexpected unaligned loads/stores.\""
] | MipsISelDAGToDAG27 | Select | Mips | CPU | LLVM | 19,357 | 184 | 1 | [] |
[
"<s>",
"void",
"ATTRIBUTE_UNUSED",
"ix86_debug_options",
"(",
"void",
")",
"{",
"char",
"*",
"opts",
"=",
"ix86_target_string",
"(",
"ix86_isa_flags",
",",
"ix86_isa_flags2",
",",
"target_flags",
",",
"ix86_target_flags",
",",
"ix86_arch_string",
",",
"ix86_tune_string",
",",
"ix86_fpmath",
",",
"true",
")",
";",
"if",
"(",
"opts",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\"%s\\n\\n\"",
",",
"opts",
")",
";",
"free",
"(",
"opts",
")",
";",
"}",
"else",
"fputs",
"(",
"\"<no options>\\n\\n\"",
",",
"stderr",
")",
";",
"return",
";",
"}",
"</s>"
] | [
"Function",
"that",
"is",
"callable",
"from",
"the",
"debugger",
"to",
"print",
"the",
"current",
"options",
"."
] | [
"i386",
"\"%s\\n\\n\"",
"\"<no options>\\n\\n\""
] | i3866 | ix86_debug_options | i386 | CPU | GCC | 19,358 | 61 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"emit_fusion_gpr_load",
"(",
"rtx",
"target",
",",
"rtx",
"mem",
")",
"{",
"rtx",
"addis_value",
";",
"rtx",
"addr",
";",
"rtx",
"load_offset",
";",
"const",
"char",
"*",
"load_str",
"=",
"NULL",
";",
"machine_mode",
"mode",
";",
"if",
"(",
"GET_CODE",
"(",
"mem",
")",
"==",
"ZERO_EXTEND",
")",
"mem",
"=",
"XEXP",
"(",
"mem",
",",
"0",
")",
";",
"gcc_assert",
"(",
"REG_P",
"(",
"target",
")",
"&&",
"MEM_P",
"(",
"mem",
")",
")",
";",
"addr",
"=",
"XEXP",
"(",
"mem",
",",
"0",
")",
";",
"fusion_split_address",
"(",
"addr",
",",
"&",
"addis_value",
",",
"&",
"load_offset",
")",
";",
"mode",
"=",
"GET_MODE",
"(",
"mem",
")",
";",
"switch",
"(",
"mode",
")",
"{",
"case",
"E_QImode",
":",
"load_str",
"=",
"\"lbz\"",
";",
"break",
";",
"case",
"E_HImode",
":",
"load_str",
"=",
"\"lhz\"",
";",
"break",
";",
"case",
"E_SImode",
":",
"case",
"E_SFmode",
":",
"load_str",
"=",
"\"lwz\"",
";",
"break",
";",
"case",
"E_DImode",
":",
"case",
"E_DFmode",
":",
"gcc_assert",
"(",
"TARGET_POWERPC64",
")",
";",
"load_str",
"=",
"\"ld\"",
";",
"break",
";",
"default",
":",
"fatal_insn",
"(",
"\"Bad GPR fusion\"",
",",
"gen_rtx_SET",
"(",
"target",
",",
"mem",
")",
")",
";",
"}",
"emit_fusion_addis",
"(",
"target",
",",
"addis_value",
")",
";",
"emit_fusion_load_store",
"(",
"target",
",",
"target",
",",
"load_offset",
",",
"load_str",
")",
";",
"return",
"\"\"",
";",
"}",
"</s>"
] | [
"Return",
"a",
"string",
"to",
"fuse",
"an",
"addis",
"instruction",
"with",
"a",
"gpr",
"load",
"to",
"the",
"same",
"register",
"that",
"we",
"loaded",
"up",
"the",
"addis",
"instruction",
".",
"The",
"address",
"that",
"is",
"used",
"is",
"the",
"logical",
"address",
"that",
"was",
"formed",
"during",
"peephole2",
":",
"(",
"lo_sum",
"(",
"high",
")",
"(",
"low-part",
")",
")",
"The",
"code",
"is",
"complicated",
",",
"so",
"we",
"call",
"output_asm_insn",
"directly",
",",
"and",
"just",
"return",
"``",
"''",
"."
] | [
"rs6000",
"0",
"0",
"\"lbz\"",
"\"lhz\"",
"\"lwz\"",
"\"ld\"",
"\"Bad GPR fusion\"",
"\"\""
] | rs60007 | emit_fusion_gpr_load | rs6000 | CPU | GCC | 19,359 | 178 | 1 | [] |
[
"<s>",
"bool",
"MipsLegalizerInfo",
"::",
"legalizeCustom",
"(",
"MachineInstr",
"&",
"MI",
",",
"MachineRegisterInfo",
"&",
"MRI",
",",
"MachineIRBuilder",
"&",
"MIRBuilder",
",",
"GISelChangeObserver",
"&",
"Observer",
")",
"const",
"{",
"using",
"namespace",
"TargetOpcode",
";",
"MIRBuilder",
".",
"setInstr",
"(",
"MI",
")",
";",
"const",
"MipsSubtarget",
"&",
"STI",
"=",
"static_cast",
"<",
"const",
"MipsSubtarget",
"&",
">",
"(",
"MIRBuilder",
".",
"getMF",
"(",
")",
".",
"getSubtarget",
"(",
")",
")",
";",
"const",
"LLT",
"s32",
"=",
"LLT",
"::",
"scalar",
"(",
"32",
")",
";",
"const",
"LLT",
"s64",
"=",
"LLT",
"::",
"scalar",
"(",
"64",
")",
";",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"G_UITOFP",
":",
"{",
"Register",
"Dst",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"Register",
"Src",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
";",
"LLT",
"DstTy",
"=",
"MRI",
".",
"getType",
"(",
"Dst",
")",
";",
"LLT",
"SrcTy",
"=",
"MRI",
".",
"getType",
"(",
"Src",
")",
";",
"if",
"(",
"SrcTy",
"!=",
"s32",
")",
"return",
"false",
";",
"if",
"(",
"DstTy",
"!=",
"s32",
"&&",
"DstTy",
"!=",
"s64",
")",
"return",
"false",
";",
"MachineInstrBuilder",
"Bitcast",
"=",
"MIRBuilder",
".",
"buildInstr",
"(",
"STI",
".",
"isFP64bit",
"(",
")",
"?",
"Mips",
"::",
"BuildPairF64_64",
":",
"Mips",
"::",
"BuildPairF64",
",",
"{",
"s64",
"}",
",",
"{",
"Src",
",",
"MIRBuilder",
".",
"buildConstant",
"(",
"s32",
",",
"UINT32_C",
"(",
"0x43300000",
")",
")",
"}",
")",
";",
"Bitcast",
".",
"constrainAllUses",
"(",
"MIRBuilder",
".",
"getTII",
"(",
")",
",",
"*",
"STI",
".",
"getRegisterInfo",
"(",
")",
",",
"*",
"STI",
".",
"getRegBankInfo",
"(",
")",
")",
";",
"MachineInstrBuilder",
"TwoP52FP",
"=",
"MIRBuilder",
".",
"buildFConstant",
"(",
"s64",
",",
"BitsToDouble",
"(",
"UINT64_C",
"(",
"0x4330000000000000",
")",
")",
")",
";",
"if",
"(",
"DstTy",
"==",
"s64",
")",
"MIRBuilder",
".",
"buildFSub",
"(",
"Dst",
",",
"Bitcast",
",",
"TwoP52FP",
")",
";",
"else",
"{",
"MachineInstrBuilder",
"ResF64",
"=",
"MIRBuilder",
".",
"buildFSub",
"(",
"s64",
",",
"Bitcast",
",",
"TwoP52FP",
")",
";",
"MIRBuilder",
".",
"buildFPTrunc",
"(",
"Dst",
",",
"ResF64",
")",
";",
"}",
"MI",
".",
"eraseFromParent",
"(",
")",
";",
"break",
";",
"}",
"default",
":",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Called",
"for",
"instructions",
"with",
"the",
"Custom",
"LegalizationAction",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips",
"32",
"64",
"0",
"1",
"Mips::BuildPairF64_64",
"Mips::BuildPairF64",
"0x43300000",
"0x4330000000000000"
] | MipsLegalizerInfo18 | legalizeCustom | Mips | CPU | LLVM | 19,360 | 309 | 1 | [] |
[
"<s>",
"static",
"rtx",
"bfin_struct_value_rtx",
"(",
"tree",
"fntype",
"ATTRIBUTE_UNUSED",
",",
"int",
"incoming",
"ATTRIBUTE_UNUSED",
")",
"{",
"return",
"gen_rtx_REG",
"(",
"Pmode",
",",
"REG_P0",
")",
";",
"}",
"</s>"
] | [
"Register",
"in",
"which",
"address",
"to",
"store",
"a",
"structure",
"value",
"is",
"passed",
"to",
"a",
"function",
"."
] | [
"bfin"
] | bfin | bfin_struct_value_rtx | bfin | DSP | GCC | 19,361 | 22 | 1 | [] |
[
"<s>",
"bool",
"sh_can_use_simple_return_p",
"(",
"void",
")",
"{",
"if",
"(",
"!",
"reload_completed",
"||",
"frame_pointer_needed",
")",
"return",
"false",
";",
"if",
"(",
"optimize_function_for_size_p",
"(",
"cfun",
")",
")",
"return",
"false",
";",
"HARD_REG_SET",
"live_regs_mask",
";",
"int",
"d",
"=",
"calc_live_regs",
"(",
"&",
"live_regs_mask",
")",
";",
"if",
"(",
"rounded_frame_size",
"(",
"d",
")",
">",
"4",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"it",
"is",
"appropriate",
"to",
"emit",
"`",
"ret",
"'",
"instructions",
"in",
"the",
"body",
"of",
"a",
"function",
"."
] | [
"sh",
"4"
] | sh | sh_can_use_simple_return_p | sh | CPU | GCC | 19,362 | 54 | 1 | [] |
[
"<s>",
"static",
"bool",
"chain_contains_only_swaps",
"(",
"swap_web_entry",
"*",
"insn_entry",
",",
"struct",
"df_link",
"*",
"link",
",",
"enum",
"chain_purpose",
"purpose",
")",
"{",
"if",
"(",
"!",
"link",
")",
"return",
"false",
";",
"for",
"(",
";",
"link",
";",
"link",
"=",
"link",
"->",
"next",
")",
"{",
"if",
"(",
"!",
"ALTIVEC_OR_VSX_VECTOR_MODE",
"(",
"GET_MODE",
"(",
"DF_REF_REG",
"(",
"link",
"->",
"ref",
")",
")",
")",
")",
"continue",
";",
"if",
"(",
"DF_REF_IS_ARTIFICIAL",
"(",
"link",
"->",
"ref",
")",
")",
"return",
"false",
";",
"rtx",
"reached_insn",
"=",
"DF_REF_INSN",
"(",
"link",
"->",
"ref",
")",
";",
"unsigned",
"uid",
"=",
"INSN_UID",
"(",
"reached_insn",
")",
";",
"struct",
"df_insn_info",
"*",
"insn_info",
"=",
"DF_INSN_INFO_GET",
"(",
"reached_insn",
")",
";",
"if",
"(",
"!",
"insn_entry",
"[",
"uid",
"]",
".",
"is_swap",
"||",
"insn_entry",
"[",
"uid",
"]",
".",
"is_load",
"||",
"insn_entry",
"[",
"uid",
"]",
".",
"is_store",
")",
"return",
"false",
";",
"if",
"(",
"purpose",
"==",
"FOR_LOADS",
")",
"{",
"df_ref",
"use",
";",
"FOR_EACH_INSN_INFO_USE",
"(",
"use",
",",
"insn_info",
")",
"{",
"struct",
"df_link",
"*",
"swap_link",
"=",
"DF_REF_CHAIN",
"(",
"use",
")",
";",
"while",
"(",
"swap_link",
")",
"{",
"if",
"(",
"DF_REF_IS_ARTIFICIAL",
"(",
"link",
"->",
"ref",
")",
")",
"return",
"false",
";",
"rtx",
"swap_def_insn",
"=",
"DF_REF_INSN",
"(",
"swap_link",
"->",
"ref",
")",
";",
"unsigned",
"uid2",
"=",
"INSN_UID",
"(",
"swap_def_insn",
")",
";",
"if",
"(",
"!",
"insn_entry",
"[",
"uid2",
"]",
".",
"is_swap",
"||",
"!",
"insn_entry",
"[",
"uid2",
"]",
".",
"is_load",
")",
"return",
"false",
";",
"swap_link",
"=",
"swap_link",
"->",
"next",
";",
"}",
"}",
"}",
"else",
"if",
"(",
"purpose",
"==",
"FOR_STORES",
")",
"{",
"df_ref",
"def",
";",
"FOR_EACH_INSN_INFO_DEF",
"(",
"def",
",",
"insn_info",
")",
"{",
"struct",
"df_link",
"*",
"swap_link",
"=",
"DF_REF_CHAIN",
"(",
"def",
")",
";",
"while",
"(",
"swap_link",
")",
"{",
"if",
"(",
"DF_REF_IS_ARTIFICIAL",
"(",
"link",
"->",
"ref",
")",
")",
"return",
"false",
";",
"rtx",
"swap_use_insn",
"=",
"DF_REF_INSN",
"(",
"swap_link",
"->",
"ref",
")",
";",
"unsigned",
"uid2",
"=",
"INSN_UID",
"(",
"swap_use_insn",
")",
";",
"if",
"(",
"!",
"insn_entry",
"[",
"uid2",
"]",
".",
"is_swap",
"||",
"insn_entry",
"[",
"uid2",
"]",
".",
"is_load",
")",
"return",
"false",
";",
"swap_link",
"=",
"swap_link",
"->",
"next",
";",
"}",
"}",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"UD",
"or",
"DU",
"chain",
"headed",
"by",
"LINK",
"is",
"non-empty",
",",
"and",
"every",
"entry",
"on",
"the",
"chain",
"references",
"an",
"insn",
"that",
"is",
"a",
"register",
"swap",
".",
"Furthermore",
",",
"if",
"PURPOSE",
"is",
"FOR_LOADS",
",",
"each",
"such",
"register",
"swap",
"must",
"have",
"only",
"permuting",
"loads",
"as",
"reaching",
"defs",
".",
"If",
"PURPOSE",
"is",
"FOR_STORES",
",",
"each",
"such",
"register",
"swap",
"must",
"have",
"only",
"register",
"swaps",
"or",
"permuting",
"stores",
"as",
"reached",
"uses",
"."
] | [
"powerpcspe"
] | powerpcspe | chain_contains_only_swaps | powerpcspe | CPU | GCC | 19,363 | 312 | 1 | [] |
[
"<s>",
"static",
"machine_mode",
"mips_preferred_simd_mode",
"(",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"TARGET_PAIRED_SINGLE_FLOAT",
"&&",
"mode",
"==",
"SFmode",
")",
"return",
"V2SFmode",
";",
"return",
"word_mode",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_VECTORIZE_PREFERRED_SIMD_MODE",
"."
] | [
"mips"
] | mips4 | mips_preferred_simd_mode | mips | CPU | GCC | 19,364 | 24 | 1 | [] |
[
"<s>",
"static",
"void",
"gen_int_relational",
"(",
"enum",
"rtx_code",
"code",
",",
"rtx",
"result",
",",
"rtx",
"cmp0",
",",
"rtx",
"cmp1",
",",
"rtx",
"destination",
")",
"{",
"machine_mode",
"mode",
";",
"int",
"branch_p",
";",
"mode",
"=",
"GET_MODE",
"(",
"cmp0",
")",
";",
"if",
"(",
"mode",
"==",
"VOIDmode",
")",
"mode",
"=",
"GET_MODE",
"(",
"cmp1",
")",
";",
"branch_p",
"=",
"(",
"destination",
"!=",
"0",
")",
";",
"switch",
"(",
"code",
")",
"{",
"case",
"LE",
":",
"case",
"LT",
":",
"case",
"LEU",
":",
"case",
"LTU",
":",
"{",
"rtx",
"temp",
";",
"code",
"=",
"swap_condition",
"(",
"code",
")",
";",
"temp",
"=",
"cmp0",
";",
"cmp0",
"=",
"cmp1",
";",
"cmp1",
"=",
"temp",
";",
"break",
";",
"}",
"default",
":",
"break",
";",
"}",
"if",
"(",
"branch_p",
")",
"{",
"rtx",
"insn",
",",
"cond",
",",
"label",
";",
"if",
"(",
"!",
"register_operand",
"(",
"cmp0",
",",
"mode",
")",
")",
"cmp0",
"=",
"force_reg",
"(",
"mode",
",",
"cmp0",
")",
";",
"if",
"(",
"!",
"register_operand",
"(",
"cmp1",
",",
"mode",
")",
")",
"cmp1",
"=",
"force_reg",
"(",
"mode",
",",
"cmp1",
")",
";",
"cond",
"=",
"gen_rtx_fmt_ee",
"(",
"code",
",",
"mode",
",",
"cmp0",
",",
"cmp1",
")",
";",
"label",
"=",
"gen_rtx_LABEL_REF",
"(",
"VOIDmode",
",",
"destination",
")",
";",
"insn",
"=",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"pc_rtx",
",",
"gen_rtx_IF_THEN_ELSE",
"(",
"VOIDmode",
",",
"cond",
",",
"label",
",",
"pc_rtx",
")",
")",
";",
"emit_jump_insn",
"(",
"insn",
")",
";",
"}",
"else",
"{",
"if",
"(",
"(",
"GET_CODE",
"(",
"cmp0",
")",
"==",
"CONST_INT",
")",
"&&",
"(",
"INTVAL",
"(",
"cmp0",
")",
"!=",
"0",
")",
")",
"cmp0",
"=",
"force_reg",
"(",
"mode",
",",
"cmp0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"cmp1",
")",
"==",
"CONST_INT",
")",
"{",
"switch",
"(",
"code",
")",
"{",
"case",
"EQ",
":",
"case",
"NE",
":",
"case",
"LE",
":",
"case",
"LT",
":",
"case",
"GE",
":",
"case",
"GT",
":",
"if",
"(",
"!",
"satisfies_constraint_K",
"(",
"cmp1",
")",
")",
"cmp1",
"=",
"force_reg",
"(",
"mode",
",",
"cmp1",
")",
";",
"break",
";",
"case",
"LEU",
":",
"case",
"LTU",
":",
"case",
"GEU",
":",
"case",
"GTU",
":",
"if",
"(",
"!",
"satisfies_constraint_L",
"(",
"cmp1",
")",
")",
"cmp1",
"=",
"force_reg",
"(",
"mode",
",",
"cmp1",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"emit_move_insn",
"(",
"result",
",",
"gen_rtx_fmt_ee",
"(",
"code",
",",
"mode",
",",
"cmp0",
",",
"cmp1",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Generate",
"the",
"code",
"to",
"compare",
"two",
"integer",
"values",
".",
"The",
"return",
"value",
"is",
"the",
"comparison",
"expression",
"."
] | [
"lm32",
"0",
"0"
] | lm322 | gen_int_relational | lm32 | MPU | GCC | 19,365 | 341 | 1 | [] |
[
"<s>",
"param_iterator",
"arg_end",
"(",
")",
"const",
"{",
"return",
"ArgumentParams",
".",
"end",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"iterator",
"pointing",
"to",
"the",
"end",
"of",
"the",
"argument",
"list",
"."
] | [
"HSAIL"
] | HSAILParamManager | arg_end | HSAIL | Virtual ISA | LLVM | 19,366 | 14 | 1 | [] |
[
"<s>",
"bool",
"SICDAGToDAGISel",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"Subtarget",
"=",
"&",
"static_cast",
"<",
"const",
"SICSubtarget",
"&",
">",
"(",
"MF",
".",
"getSubtarget",
"(",
")",
")",
";",
"bool",
"Ret",
"=",
"SelectionDAGISel",
"::",
"runOnMachineFunction",
"(",
"MF",
")",
";",
"return",
"Ret",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"SIC",
"SIC",
"SIC"
] | SICISelDAGToDAG | runOnMachineFunction | SIC | CPU | LLVM | 19,367 | 41 | 1 | [] |
[
"<s>",
"void",
"rs6000_emit_eh_reg_restore",
"(",
"rtx",
"source",
",",
"rtx",
"scratch",
")",
"{",
"rs6000_stack_t",
"*",
"info",
"=",
"rs6000_stack_info",
"(",
")",
";",
"rtx",
"operands",
"[",
"2",
"]",
";",
"operands",
"[",
"0",
"]",
"=",
"source",
";",
"operands",
"[",
"1",
"]",
"=",
"scratch",
";",
"if",
"(",
"info",
"->",
"lr_save_p",
")",
"{",
"rtx",
"frame_rtx",
"=",
"stack_pointer_rtx",
";",
"HOST_WIDE_INT",
"sp_offset",
"=",
"0",
";",
"rtx",
"tmp",
";",
"if",
"(",
"frame_pointer_needed",
"||",
"cfun",
"->",
"calls_alloca",
"||",
"info",
"->",
"total_size",
">",
"32767",
")",
"{",
"tmp",
"=",
"gen_frame_mem",
"(",
"Pmode",
",",
"frame_rtx",
")",
";",
"emit_move_insn",
"(",
"operands",
"[",
"1",
"]",
",",
"tmp",
")",
";",
"frame_rtx",
"=",
"operands",
"[",
"1",
"]",
";",
"}",
"else",
"if",
"(",
"info",
"->",
"push_p",
")",
"sp_offset",
"=",
"info",
"->",
"total_size",
";",
"tmp",
"=",
"plus_constant",
"(",
"Pmode",
",",
"frame_rtx",
",",
"info",
"->",
"lr_save_offset",
"+",
"sp_offset",
")",
";",
"tmp",
"=",
"gen_frame_mem",
"(",
"Pmode",
",",
"tmp",
")",
";",
"emit_move_insn",
"(",
"tmp",
",",
"operands",
"[",
"0",
"]",
")",
";",
"}",
"else",
"emit_move_insn",
"(",
"gen_rtx_REG",
"(",
"Pmode",
",",
"LR_REGNO",
")",
",",
"operands",
"[",
"0",
"]",
")",
";",
"cfun",
"->",
"machine",
"->",
"lr_save_state",
"=",
"info",
"->",
"lr_save_p",
"+",
"1",
";",
"}",
"</s>"
] | [
"Emit",
"instructions",
"to",
"restore",
"the",
"link",
"register",
"after",
"determining",
"where",
"its",
"value",
"has",
"been",
"stored",
"."
] | [
"rs6000",
"2",
"0",
"1",
"0",
"32767",
"1",
"1",
"0",
"0",
"1"
] | rs6000-logue | rs6000_emit_eh_reg_restore | rs6000 | CPU | GCC | 19,368 | 177 | 1 | [] |
[
"<s>",
"TargetLoweringObjectFile",
"*",
"getObjFileLowering",
"(",
")",
"const",
"override",
"{",
"return",
"TLOF",
".",
"get",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"information",
"about",
"object",
"file",
"lowering",
"."
] | [
"AMDGPU"
] | AMDGPUTargetMachine (2)1 | getObjFileLowering | AMDGPU | GPU | LLVM | 19,369 | 16 | 1 | [] |
[
"<s>",
"const",
"CJGRegisterInfo",
"&",
"getRegisterInfo",
"(",
")",
"const",
"{",
"return",
"RI",
";",
"}",
"</s>"
] | [
"getRegisterInfo",
"-",
"TargetInstrInfo",
"is",
"a",
"superset",
"of",
"MRegister",
"info",
"."
] | [
"CJG",
"CJG"
] | CJGInstrInfo | getRegisterInfo | CJG | CPU | LLVM | 19,370 | 12 | 1 | [] |
[
"<s>",
"bool",
"SPIRVEmitIntrinsics",
"::",
"runOnFunction",
"(",
"Function",
"&",
"Func",
")",
"{",
"if",
"(",
"Func",
".",
"isDeclaration",
"(",
")",
")",
"return",
"false",
";",
"F",
"=",
"&",
"Func",
";",
"IRB",
"=",
"new",
"IRBuilder",
"<",
">",
"(",
"Func",
".",
"getContext",
"(",
")",
")",
";",
"AggrConsts",
".",
"clear",
"(",
")",
";",
"AggrStores",
".",
"clear",
"(",
")",
";",
"IRB",
"->",
"SetInsertPoint",
"(",
"&",
"Func",
".",
"getEntryBlock",
"(",
")",
".",
"front",
"(",
")",
")",
";",
"for",
"(",
"auto",
"&",
"GV",
":",
"Func",
".",
"getParent",
"(",
")",
"->",
"globals",
"(",
")",
")",
"processGlobalValue",
"(",
"GV",
")",
";",
"preprocessCompositeConstants",
"(",
")",
";",
"SmallVector",
"<",
"Instruction",
"*",
">",
"Worklist",
";",
"for",
"(",
"auto",
"&",
"I",
":",
"instructions",
"(",
"Func",
")",
")",
"Worklist",
".",
"push_back",
"(",
"&",
"I",
")",
";",
"for",
"(",
"auto",
"&",
"I",
":",
"Worklist",
")",
"insertAssignTypeIntrs",
"(",
"I",
")",
";",
"for",
"(",
"auto",
"*",
"I",
":",
"Worklist",
")",
"{",
"TrackConstants",
"=",
"true",
";",
"if",
"(",
"!",
"I",
"->",
"getType",
"(",
")",
"->",
"isVoidTy",
"(",
")",
"||",
"isa",
"<",
"StoreInst",
">",
"(",
"I",
")",
")",
"IRB",
"->",
"SetInsertPoint",
"(",
"I",
"->",
"getNextNode",
"(",
")",
")",
";",
"I",
"=",
"visit",
"(",
"*",
"I",
")",
";",
"processInstrAfterVisit",
"(",
"I",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnFunction",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"the",
"per-function",
"processing",
"of",
"the",
"pass",
"."
] | [
"SPIRV",
"SPIRV"
] | SPIRVEmitIntrinsics | runOnFunction | SPIRV | Virtual ISA | LLVM | 19,371 | 195 | 1 | [] |
[
"<s>",
"rtx",
"gen_push",
"(",
"rtx",
"operand0",
",",
"enum",
"machine_mode",
"mode",
")",
"{",
"return",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"gen_rtx_MEM",
"(",
"mode",
",",
"gen_rtx_PRE_DEC",
"(",
"mode",
",",
"gen_rtx_REG",
"(",
"Pmode",
",",
"STACK_POINTER_REGNUM",
")",
")",
")",
",",
"operand0",
")",
";",
"}",
"</s>"
] | [
"Code",
"to",
"generate",
"prologue",
"and",
"epilogue",
"sequences"
] | [
"z8k"
] | z8k | gen_push | z8k | MPU | GCC | 19,372 | 37 | 1 | [] |
[
"<s>",
"size_type",
"empty",
"(",
")",
"const",
"{",
"return",
"V",
".",
"none",
"(",
")",
";",
"}",
"</s>"
] | [
"Determine",
"whether",
"this",
"version",
"information",
"is",
"empty",
"(",
"e.g.",
",",
"all",
"version",
"components",
"are",
"zero",
")",
"."
] | [
"X86"
] | ImmutableGraph | empty | X86 | CPU | LLVM | 19,373 | 14 | 1 | [] |
[
"<s>",
"bool",
"AlphaAsmPrinter",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"this",
"->",
"MF",
"=",
"&",
"MF",
";",
"SetupMachineFunction",
"(",
"MF",
")",
";",
"O",
"<<",
"\"\\n\\n\"",
";",
"EmitConstantPool",
"(",
"MF",
".",
"getConstantPool",
"(",
")",
")",
";",
"EmitJumpTableInfo",
"(",
"MF",
".",
"getJumpTableInfo",
"(",
")",
",",
"MF",
")",
";",
"const",
"Function",
"*",
"F",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"SwitchToSection",
"(",
"TAI",
"->",
"SectionForGlobal",
"(",
"F",
")",
")",
";",
"EmitAlignment",
"(",
"4",
",",
"F",
")",
";",
"switch",
"(",
"F",
"->",
"getLinkage",
"(",
")",
")",
"{",
"default",
":",
"assert",
"(",
"0",
"&&",
"\"Unknown linkage type!\"",
")",
";",
"case",
"Function",
"::",
"InternalLinkage",
":",
"case",
"Function",
"::",
"PrivateLinkage",
":",
"break",
";",
"case",
"Function",
"::",
"ExternalLinkage",
":",
"O",
"<<",
"\"\\t.globl \"",
"<<",
"CurrentFnName",
"<<",
"\"\\n\"",
";",
"break",
";",
"case",
"Function",
"::",
"WeakAnyLinkage",
":",
"case",
"Function",
"::",
"WeakODRLinkage",
":",
"case",
"Function",
"::",
"LinkOnceAnyLinkage",
":",
"case",
"Function",
"::",
"LinkOnceODRLinkage",
":",
"O",
"<<",
"TAI",
"->",
"getWeakRefDirective",
"(",
")",
"<<",
"CurrentFnName",
"<<",
"\"\\n\"",
";",
"break",
";",
"}",
"printVisibility",
"(",
"CurrentFnName",
",",
"F",
"->",
"getVisibility",
"(",
")",
")",
";",
"O",
"<<",
"\"\\t.ent \"",
"<<",
"CurrentFnName",
"<<",
"\"\\n\"",
";",
"O",
"<<",
"CurrentFnName",
"<<",
"\":\\n\"",
";",
"for",
"(",
"MachineFunction",
"::",
"const_iterator",
"I",
"=",
"MF",
".",
"begin",
"(",
")",
",",
"E",
"=",
"MF",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"if",
"(",
"I",
"!=",
"MF",
".",
"begin",
"(",
")",
")",
"{",
"printBasicBlockLabel",
"(",
"I",
",",
"true",
",",
"true",
")",
";",
"O",
"<<",
"'\\n'",
";",
"}",
"for",
"(",
"MachineBasicBlock",
"::",
"const_iterator",
"II",
"=",
"I",
"->",
"begin",
"(",
")",
",",
"E",
"=",
"I",
"->",
"end",
"(",
")",
";",
"II",
"!=",
"E",
";",
"++",
"II",
")",
"{",
"++",
"EmittedInsts",
";",
"if",
"(",
"!",
"printInstruction",
"(",
"II",
")",
")",
"{",
"assert",
"(",
"0",
"&&",
"\"Unhandled instruction in asm writer!\"",
")",
";",
"abort",
"(",
")",
";",
"}",
"}",
"}",
"O",
"<<",
"\"\\t.end \"",
"<<",
"CurrentFnName",
"<<",
"\"\\n\"",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"Alpha",
"Alpha",
"\"\\n\\n\"",
"4",
"0",
"\"Unknown linkage type!\"",
"\"\\t.globl \"",
"\"\\n\"",
"\"\\n\"",
"\"\\t.ent \"",
"\"\\n\"",
"\":\\n\"",
"0",
"\"Unhandled instruction in asm writer!\"",
"\"\\t.end \"",
"\"\\n\""
] | AlphaAsmPrinter3 | runOnMachineFunction | Alpha | MPU | LLVM | 19,374 | 300 | 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",
";",
"unsigned",
"Value",
"=",
"CST",
"->",
"getZExtValue",
"(",
")",
";",
"switch",
"(",
"Letter",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unknown constraint letter!\"",
")",
";",
"case",
"'I'",
":",
"if",
"(",
"(",
"short",
")",
"Value",
"==",
"(",
"int",
")",
"Value",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
";",
"break",
";",
"case",
"'J'",
":",
"case",
"'L'",
":",
"if",
"(",
"(",
"short",
")",
"Value",
"==",
"0",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
";",
"break",
";",
"case",
"'K'",
":",
"if",
"(",
"(",
"Value",
">>",
"16",
")",
"==",
"0",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
";",
"break",
";",
"case",
"'M'",
":",
"if",
"(",
"Value",
">",
"31",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
";",
"break",
";",
"case",
"'N'",
":",
"if",
"(",
"(",
"int",
")",
"Value",
">",
"0",
"&&",
"isPowerOf2_32",
"(",
"Value",
")",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
";",
"break",
";",
"case",
"'O'",
":",
"if",
"(",
"Value",
"==",
"0",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
";",
"break",
";",
"case",
"'P'",
":",
"if",
"(",
"(",
"short",
")",
"-",
"Value",
"==",
"(",
"int",
")",
"-",
"Value",
")",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Value",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
";",
"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",
"\"Unknown constraint letter!\"",
"0",
"16",
"0",
"31",
"0",
"0"
] | PPCISelLowering120 | LowerAsmOperandForConstraint | PowerPC | CPU | LLVM | 19,375 | 378 | 1 | [] |
[
"<s>",
"unsigned",
"MipsTargetLowering",
"::",
"getJumpTableEncoding",
"(",
")",
"const",
"{",
"if",
"(",
"IsN64",
")",
"return",
"MachineJumpTableInfo",
"::",
"EK_GPRel64BlockAddress",
";",
"return",
"TargetLowering",
"::",
"getJumpTableEncoding",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"entry",
"encoding",
"for",
"a",
"jump",
"table",
"in",
"the",
"current",
"function",
"."
] | [
"Mips",
"Mips"
] | MipsISelLowering (2) | getJumpTableEncoding | Mips | CPU | LLVM | 19,376 | 25 | 1 | [] |
[
"<s>",
"bool",
"evaluateBranch",
"(",
"const",
"MCInst",
"&",
"Inst",
",",
"uint64_t",
"Addr",
",",
"uint64_t",
"Size",
",",
"uint64_t",
"&",
"Target",
")",
"const",
"override",
"{",
"unsigned",
"NumOps",
"=",
"Inst",
".",
"getNumOperands",
"(",
")",
";",
"if",
"(",
"NumOps",
"==",
"0",
"||",
"Info",
"->",
"get",
"(",
"Inst",
".",
"getOpcode",
"(",
")",
")",
".",
"OpInfo",
"[",
"NumOps",
"-",
"1",
"]",
".",
"OperandType",
"!=",
"MCOI",
"::",
"OPERAND_PCREL",
")",
"return",
"false",
";",
"Target",
"=",
"Addr",
"+",
"Inst",
".",
"getOperand",
"(",
"NumOps",
"-",
"1",
")",
".",
"getImm",
"(",
")",
"*",
"Size",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Given",
"a",
"branch",
"instruction",
"try",
"to",
"get",
"the",
"address",
"the",
"branch",
"targets",
"."
] | [
"PowerPC",
"0",
"1",
"1"
] | PPCMCTargetDesc25 | evaluateBranch | PowerPC | CPU | LLVM | 19,377 | 86 | 1 | [] |
[
"<s>",
"static",
"rtx",
"gen_and_emit_move",
"(",
"rtx",
"to",
",",
"rtx",
"from",
",",
"rtx_insn",
"*",
"where",
",",
"bool",
"before",
")",
"{",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"to",
")",
";",
"if",
"(",
"optimize",
"&&",
"before",
"&&",
"already_contains",
"(",
"to",
",",
"from",
")",
")",
"{",
"display_content_memory",
"(",
"stderr",
")",
";",
"if",
"(",
"dump_file",
")",
"{",
"fprintf",
"(",
"dump_file",
",",
"\" Omit move of %s into \"",
",",
"get_content_name",
"(",
"get_content_index",
"(",
"from",
")",
",",
"mode",
")",
")",
";",
"fprintf",
"(",
"dump_file",
",",
"\"%s as it already contains this value\\n\"",
",",
"get_content_name",
"(",
"get_content_index",
"(",
"to",
")",
",",
"mode",
")",
")",
";",
"}",
"}",
"else",
"{",
"rtx",
"move",
"=",
"mode",
"==",
"QImode",
"?",
"gen_movqi",
"(",
"to",
",",
"from",
")",
":",
"gen_movhi",
"(",
"to",
",",
"from",
")",
";",
"EM",
"(",
"move",
")",
";",
"if",
"(",
"where",
"==",
"NULL_RTX",
")",
"emit_insn",
"(",
"move",
")",
";",
"else",
"if",
"(",
"before",
")",
"emit_insn_before",
"(",
"move",
",",
"where",
")",
";",
"else",
"{",
"rtx",
"note",
"=",
"find_reg_note",
"(",
"where",
",",
"REG_EH_REGION",
",",
"NULL_RTX",
")",
";",
"if",
"(",
"note",
"!=",
"NULL_RTX",
")",
"{",
"add_reg_note",
"(",
"move",
",",
"REG_EH_REGION",
",",
"XEXP",
"(",
"note",
",",
"0",
")",
")",
";",
"remove_note",
"(",
"where",
",",
"note",
")",
";",
"}",
"emit_insn_after",
"(",
"move",
",",
"where",
")",
";",
"}",
"if",
"(",
"before",
")",
"record_content",
"(",
"to",
",",
"from",
")",
";",
"else",
"add_postponed_content_update",
"(",
"to",
",",
"from",
")",
";",
"}",
"return",
"before",
"?",
"to",
":",
"from",
";",
"}",
"</s>"
] | [
"Generate",
"and",
"emit",
"a",
"move",
"of",
"(",
"register",
")",
"FROM",
"into",
"TO",
".",
"if",
"WHERE",
"is",
"not",
"NULL",
"then",
"if",
"BEFORE",
"is",
"true",
"then",
"emit",
"the",
"insn",
"before",
"WHERE",
",",
"otherwise",
"emit",
"it",
"after",
"WHERE",
".",
"If",
"TO",
"already",
"contains",
"FROM",
"then",
"do",
"nothing",
".",
"Returns",
"TO",
"if",
"BEFORE",
"is",
"true",
",",
"FROM",
"otherwise",
"."
] | [
"rl78",
"\" Omit move of %s into \"",
"\"%s as it already contains this value\\n\"",
"0"
] | rl78 | gen_and_emit_move | rl78 | MPU | GCC | 19,378 | 216 | 1 | [] |
[
"<s>",
"static",
"rtx",
"h8300_get_index",
"(",
"rtx",
"x",
",",
"machine_mode",
"mode",
",",
"int",
"*",
"size",
")",
"{",
"int",
"dummy",
",",
"factor",
";",
"if",
"(",
"size",
"==",
"0",
")",
"size",
"=",
"&",
"dummy",
";",
"factor",
"=",
"(",
"mode",
"==",
"VOIDmode",
"?",
"0",
":",
"GET_MODE_SIZE",
"(",
"mode",
")",
")",
";",
"if",
"(",
"TARGET_H8300SX",
"&&",
"factor",
"<=",
"4",
"&&",
"(",
"mode",
"==",
"VOIDmode",
"||",
"GET_MODE_CLASS",
"(",
"mode",
")",
"==",
"MODE_INT",
"||",
"GET_MODE_CLASS",
"(",
"mode",
")",
"==",
"MODE_FLOAT",
")",
")",
"{",
"if",
"(",
"factor",
"<=",
"1",
"&&",
"GET_CODE",
"(",
"x",
")",
"==",
"ZERO_EXTEND",
")",
"{",
"*",
"size",
"=",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
")",
";",
"return",
"XEXP",
"(",
"x",
",",
"0",
")",
";",
"}",
"else",
"{",
"rtx",
"index",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"AND",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
"==",
"CONST_INT",
"&&",
"(",
"factor",
"==",
"0",
"||",
"INTVAL",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
"==",
"0xff",
"*",
"factor",
"||",
"INTVAL",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
"==",
"0xffff",
"*",
"factor",
")",
")",
"{",
"index",
"=",
"XEXP",
"(",
"x",
",",
"0",
")",
";",
"*",
"size",
"=",
"(",
"INTVAL",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
">=",
"0xffff",
"?",
"2",
":",
"1",
")",
";",
"}",
"else",
"{",
"index",
"=",
"x",
";",
"*",
"size",
"=",
"4",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"index",
")",
"==",
"MULT",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"index",
",",
"1",
")",
")",
"==",
"CONST_INT",
"&&",
"(",
"factor",
"==",
"0",
"||",
"factor",
"==",
"INTVAL",
"(",
"XEXP",
"(",
"index",
",",
"1",
")",
")",
")",
")",
"return",
"XEXP",
"(",
"index",
",",
"0",
")",
";",
"}",
"}",
"*",
"size",
"=",
"0",
";",
"return",
"x",
";",
"}",
"</s>"
] | [
"Given",
"that",
"X",
"occurs",
"in",
"an",
"address",
"of",
"the",
"form",
"(",
"plus",
"X",
"constant",
")",
",",
"return",
"the",
"part",
"of",
"X",
"that",
"is",
"expected",
"to",
"be",
"a",
"register",
".",
"There",
"are",
"four",
"kinds",
"of",
"addressing",
"mode",
"to",
"recognize",
":",
"@",
"(",
"dd",
",",
"Rn",
")",
"@",
"(",
"dd",
",",
"RnL.b",
")",
"@",
"(",
"dd",
",",
"Rn.w",
")",
"@",
"(",
"dd",
",",
"ERn.l",
")",
"If",
"SIZE",
"is",
"nonnull",
",",
"and",
"the",
"address",
"is",
"one",
"of",
"the",
"last",
"three",
"forms",
",",
"set",
"*",
"SIZE",
"to",
"the",
"index",
"multiplication",
"factor",
".",
"Set",
"it",
"to",
"0",
"for",
"plain",
"@",
"(",
"dd",
",",
"Rn",
")",
"addresses",
".",
"MODE",
"is",
"the",
"mode",
"of",
"the",
"value",
"being",
"accessed",
".",
"It",
"can",
"be",
"VOIDmode",
"if",
"the",
"address",
"is",
"known",
"to",
"be",
"valid",
",",
"but",
"its",
"mode",
"is",
"unknown",
"."
] | [
"h8300",
"0",
"0",
"4",
"1",
"0",
"0",
"1",
"0",
"1",
"0xff",
"1",
"0xffff",
"0",
"1",
"0xffff",
"2",
"1",
"4",
"1",
"0",
"1",
"0",
"0"
] | h8300 | h8300_get_index | h8300 | MPU | GCC | 19,379 | 276 | 1 | [] |
[
"<s>",
"int",
"sh_pr_n_sets",
"(",
")",
"{",
"return",
"REG_N_SETS",
"(",
"PR_REG",
")",
";",
"}",
"</s>"
] | [
"For",
"use",
"by",
"ALLOCATE_INITIAL_VALUE",
".",
"Note",
"that",
"sh.md",
"contains",
"some",
"'special",
"function",
"'",
"patterns",
"(",
"type",
"sfunc",
")",
"that",
"clobber",
"pr",
",",
"but",
"that",
"do",
"not",
"look",
"like",
"function",
"calls",
"to",
"leaf_function_p",
".",
"Hence",
"we",
"must",
"do",
"this",
"extra",
"check",
"."
] | [
"sh"
] | sh2 | sh_pr_n_sets | sh | CPU | GCC | 19,380 | 12 | 1 | [] |
[
"<s>",
"TargetTransformInfo",
"::",
"PopcntSupportKind",
"PPCTTIImpl",
"::",
"getPopcntSupport",
"(",
"unsigned",
"TyWidth",
")",
"{",
"assert",
"(",
"isPowerOf2_32",
"(",
"TyWidth",
")",
"&&",
"\"Ty width must be power of 2\"",
")",
";",
"if",
"(",
"ST",
"->",
"hasPOPCNTD",
"(",
")",
"&&",
"TyWidth",
"<=",
"64",
")",
"return",
"TTI",
"::",
"PSK_FastHardware",
";",
"return",
"TTI",
"::",
"PSK_Software",
";",
"}",
"</s>"
] | [
"Return",
"hardware",
"support",
"for",
"population",
"count",
"."
] | [
"PowerPC",
"PPC",
"\"Ty width must be power of 2\"",
"64"
] | PPCTargetTransformInfo19 | getPopcntSupport | PowerPC | CPU | LLVM | 19,381 | 44 | 1 | [] |
[
"<s>",
"bool",
"HexagonEvaluator",
"::",
"evaluate",
"(",
"const",
"MachineInstr",
"&",
"BI",
",",
"const",
"CellMapType",
"&",
"Inputs",
",",
"BranchTargetList",
"&",
"Targets",
",",
"bool",
"&",
"FallsThru",
")",
"const",
"{",
"unsigned",
"Opc",
"=",
"BI",
".",
"getOpcode",
"(",
")",
";",
"bool",
"SimpleBranch",
"=",
"false",
";",
"bool",
"Negated",
"=",
"false",
";",
"switch",
"(",
"Opc",
")",
"{",
"case",
"Hexagon",
"::",
"J2_jumpf",
":",
"case",
"Hexagon",
"::",
"J2_jumpfpt",
":",
"case",
"Hexagon",
"::",
"J2_jumpfnew",
":",
"case",
"Hexagon",
"::",
"J2_jumpfnewpt",
":",
"Negated",
"=",
"true",
";",
"LLVM_FALLTHROUGH",
";",
"case",
"Hexagon",
"::",
"J2_jumpt",
":",
"case",
"Hexagon",
"::",
"J2_jumptpt",
":",
"case",
"Hexagon",
"::",
"J2_jumptnew",
":",
"case",
"Hexagon",
"::",
"J2_jumptnewpt",
":",
"SimpleBranch",
"=",
"true",
";",
"break",
";",
"case",
"Hexagon",
"::",
"J2_jump",
":",
"Targets",
".",
"insert",
"(",
"BI",
".",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
")",
";",
"FallsThru",
"=",
"false",
";",
"return",
"true",
";",
"default",
":",
"return",
"false",
";",
"}",
"if",
"(",
"!",
"SimpleBranch",
")",
"return",
"false",
";",
"RegisterRef",
"PR",
"=",
"BI",
".",
"getOperand",
"(",
"0",
")",
";",
"RegisterCell",
"PC",
"=",
"getCell",
"(",
"PR",
",",
"Inputs",
")",
";",
"const",
"BT",
"::",
"BitValue",
"&",
"Test",
"=",
"PC",
"[",
"0",
"]",
";",
"if",
"(",
"!",
"Test",
".",
"is",
"(",
"0",
")",
"&&",
"!",
"Test",
".",
"is",
"(",
"1",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"Test",
".",
"is",
"(",
"!",
"Negated",
")",
")",
"{",
"FallsThru",
"=",
"true",
";",
"return",
"true",
";",
"}",
"Targets",
".",
"insert",
"(",
"BI",
".",
"getOperand",
"(",
"1",
")",
".",
"getMBB",
"(",
")",
")",
";",
"FallsThru",
"=",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"evaluate",
"-",
"Evaluate",
"Expr",
"and",
"append",
"the",
"resulting",
"set",
"to",
"Elts",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon::J2_jumpf",
"Hexagon::J2_jumpfpt",
"Hexagon::J2_jumpfnew",
"Hexagon::J2_jumpfnewpt",
"Hexagon::J2_jumpt",
"Hexagon::J2_jumptpt",
"Hexagon::J2_jumptnew",
"Hexagon::J2_jumptnewpt",
"Hexagon::J2_jump",
"0",
"0",
"0",
"0",
"1",
"1"
] | HexagonBitTracker10 | evaluate | Hexagon | DSP | LLVM | 19,382 | 240 | 1 | [] |
[
"<s>",
"Optional",
"<",
"MCFixupKind",
">",
"ARMAsmBackend",
"::",
"getFixupKind",
"(",
"StringRef",
"Name",
")",
"const",
"{",
"if",
"(",
"STI",
".",
"getTargetTriple",
"(",
")",
".",
"isOSBinFormatELF",
"(",
")",
"&&",
"Name",
"==",
"\"R_ARM_NONE\"",
")",
"return",
"FK_NONE",
";",
"return",
"MCAsmBackend",
"::",
"getFixupKind",
"(",
"Name",
")",
";",
"}",
"</s>"
] | [
"getFixupKind",
"-",
"Get",
"the",
"fixup",
"kind",
"of",
"this",
"expression",
"."
] | [
"ARM",
"ARM",
"\"R_ARM_NONE\""
] | ARMAsmBackend27 | getFixupKind | ARM | CPU | LLVM | 19,383 | 41 | 1 | [] |
[
"<s>",
"unsigned",
"assignCustomValue",
"(",
"ARMCallLowering",
"::",
"ArgInfo",
"&",
"Arg",
",",
"ArrayRef",
"<",
"CCValAssign",
">",
"VAs",
")",
"override",
"{",
"assert",
"(",
"Arg",
".",
"Regs",
".",
"size",
"(",
")",
"==",
"1",
"&&",
"\"Can't handle multple regs yet\"",
")",
";",
"CCValAssign",
"VA",
"=",
"VAs",
"[",
"0",
"]",
";",
"assert",
"(",
"VA",
".",
"needsCustom",
"(",
")",
"&&",
"\"Value doesn't need custom handling\"",
")",
";",
"if",
"(",
"VA",
".",
"getValVT",
"(",
")",
"!=",
"MVT",
"::",
"f64",
")",
"return",
"0",
";",
"CCValAssign",
"NextVA",
"=",
"VAs",
"[",
"1",
"]",
";",
"assert",
"(",
"NextVA",
".",
"needsCustom",
"(",
")",
"&&",
"\"Value doesn't need custom handling\"",
")",
";",
"assert",
"(",
"NextVA",
".",
"getValVT",
"(",
")",
"==",
"MVT",
"::",
"f64",
"&&",
"\"Unsupported type\"",
")",
";",
"assert",
"(",
"VA",
".",
"getValNo",
"(",
")",
"==",
"NextVA",
".",
"getValNo",
"(",
")",
"&&",
"\"Values belong to different arguments\"",
")",
";",
"assert",
"(",
"VA",
".",
"isRegLoc",
"(",
")",
"&&",
"\"Value should be in reg\"",
")",
";",
"assert",
"(",
"NextVA",
".",
"isRegLoc",
"(",
")",
"&&",
"\"Value should be in reg\"",
")",
";",
"Register",
"NewRegs",
"[",
"]",
"=",
"{",
"MRI",
".",
"createGenericVirtualRegister",
"(",
"LLT",
"::",
"scalar",
"(",
"32",
")",
")",
",",
"MRI",
".",
"createGenericVirtualRegister",
"(",
"LLT",
"::",
"scalar",
"(",
"32",
")",
")",
"}",
";",
"assignValueToReg",
"(",
"NewRegs",
"[",
"0",
"]",
",",
"VA",
".",
"getLocReg",
"(",
")",
",",
"VA",
")",
";",
"assignValueToReg",
"(",
"NewRegs",
"[",
"1",
"]",
",",
"NextVA",
".",
"getLocReg",
"(",
")",
",",
"NextVA",
")",
";",
"bool",
"IsLittle",
"=",
"MIRBuilder",
".",
"getMF",
"(",
")",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
".",
"isLittle",
"(",
")",
";",
"if",
"(",
"!",
"IsLittle",
")",
"std",
"::",
"swap",
"(",
"NewRegs",
"[",
"0",
"]",
",",
"NewRegs",
"[",
"1",
"]",
")",
";",
"MIRBuilder",
".",
"buildMerge",
"(",
"Arg",
".",
"Regs",
"[",
"0",
"]",
",",
"NewRegs",
")",
";",
"return",
"1",
";",
"}",
"</s>"
] | [
"Handle",
"custom",
"values",
",",
"which",
"may",
"be",
"passed",
"into",
"one",
"or",
"more",
"of",
"VAs",
"."
] | [
"ARM",
"ARM",
"1",
"\"Can't handle multple regs yet\"",
"0",
"\"Value doesn't need custom handling\"",
"MVT::f64",
"0",
"1",
"\"Value doesn't need custom handling\"",
"MVT::f64",
"\"Unsupported type\"",
"\"Values belong to different arguments\"",
"\"Value should be in reg\"",
"\"Value should be in reg\"",
"32",
"32",
"0",
"1",
"ARM",
"0",
"1",
"0",
"1"
] | ARMCallLowering15 | assignCustomValue | ARM | CPU | LLVM | 19,384 | 260 | 1 | [] |
[
"<s>",
"void",
"MipsTargetELFStreamer",
"::",
"finish",
"(",
")",
"{",
"MCAssembler",
"&",
"MCA",
"=",
"getStreamer",
"(",
")",
".",
"getAssembler",
"(",
")",
";",
"const",
"MCObjectFileInfo",
"&",
"OFI",
"=",
"*",
"MCA",
".",
"getContext",
"(",
")",
".",
"getObjectFileInfo",
"(",
")",
";",
"MCSection",
"&",
"TextSection",
"=",
"*",
"OFI",
".",
"getTextSection",
"(",
")",
";",
"MCA",
".",
"registerSection",
"(",
"TextSection",
")",
";",
"MCSection",
"&",
"DataSection",
"=",
"*",
"OFI",
".",
"getDataSection",
"(",
")",
";",
"MCA",
".",
"registerSection",
"(",
"DataSection",
")",
";",
"MCSection",
"&",
"BSSSection",
"=",
"*",
"OFI",
".",
"getBSSSection",
"(",
")",
";",
"MCA",
".",
"registerSection",
"(",
"BSSSection",
")",
";",
"TextSection",
".",
"setAlignment",
"(",
"Align",
"(",
"std",
"::",
"max",
"(",
"16u",
",",
"TextSection",
".",
"getAlignment",
"(",
")",
")",
")",
")",
";",
"DataSection",
".",
"setAlignment",
"(",
"Align",
"(",
"std",
"::",
"max",
"(",
"16u",
",",
"DataSection",
".",
"getAlignment",
"(",
")",
")",
")",
")",
";",
"BSSSection",
".",
"setAlignment",
"(",
"Align",
"(",
"std",
"::",
"max",
"(",
"16u",
",",
"BSSSection",
".",
"getAlignment",
"(",
")",
")",
")",
")",
";",
"if",
"(",
"RoundSectionSizes",
")",
"{",
"MCStreamer",
"&",
"OS",
"=",
"getStreamer",
"(",
")",
";",
"for",
"(",
"MCSection",
"&",
"S",
":",
"MCA",
")",
"{",
"MCSectionELF",
"&",
"Section",
"=",
"static_cast",
"<",
"MCSectionELF",
"&",
">",
"(",
"S",
")",
";",
"unsigned",
"Alignment",
"=",
"Section",
".",
"getAlignment",
"(",
")",
";",
"if",
"(",
"Alignment",
")",
"{",
"OS",
".",
"SwitchSection",
"(",
"&",
"Section",
")",
";",
"if",
"(",
"Section",
".",
"useCodeAlign",
"(",
")",
")",
"OS",
".",
"emitCodeAlignment",
"(",
"Alignment",
",",
"&",
"STI",
",",
"Alignment",
")",
";",
"else",
"OS",
".",
"emitValueToAlignment",
"(",
"Alignment",
",",
"0",
",",
"1",
",",
"Alignment",
")",
";",
"}",
"}",
"}",
"const",
"FeatureBitset",
"&",
"Features",
"=",
"STI",
".",
"getFeatureBits",
"(",
")",
";",
"unsigned",
"EFlags",
"=",
"MCA",
".",
"getELFHeaderEFlags",
"(",
")",
";",
"if",
"(",
"getABI",
"(",
")",
".",
"IsO32",
"(",
")",
")",
"EFlags",
"|=",
"ELF",
"::",
"EF_MIPS_ABI_O32",
";",
"else",
"if",
"(",
"getABI",
"(",
")",
".",
"IsN32",
"(",
")",
")",
"EFlags",
"|=",
"ELF",
"::",
"EF_MIPS_ABI2",
";",
"if",
"(",
"Features",
"[",
"Mips",
"::",
"FeatureGP64Bit",
"]",
")",
"{",
"if",
"(",
"getABI",
"(",
")",
".",
"IsO32",
"(",
")",
")",
"EFlags",
"|=",
"ELF",
"::",
"EF_MIPS_32BITMODE",
";",
"}",
"else",
"if",
"(",
"Features",
"[",
"Mips",
"::",
"FeatureMips64r2",
"]",
"||",
"Features",
"[",
"Mips",
"::",
"FeatureMips64",
"]",
")",
"EFlags",
"|=",
"ELF",
"::",
"EF_MIPS_32BITMODE",
";",
"if",
"(",
"!",
"Features",
"[",
"Mips",
"::",
"FeatureNoABICalls",
"]",
")",
"EFlags",
"|=",
"ELF",
"::",
"EF_MIPS_CPIC",
";",
"if",
"(",
"Pic",
")",
"EFlags",
"|=",
"ELF",
"::",
"EF_MIPS_PIC",
"|",
"ELF",
"::",
"EF_MIPS_CPIC",
";",
"MCA",
".",
"setELFHeaderEFlags",
"(",
"EFlags",
")",
";",
"MipsELFStreamer",
"&",
"MEF",
"=",
"static_cast",
"<",
"MipsELFStreamer",
"&",
">",
"(",
"Streamer",
")",
";",
"MEF",
".",
"EmitMipsOptionRecords",
"(",
")",
";",
"emitMipsAbiFlags",
"(",
")",
";",
"}",
"</s>"
] | [
"finish",
"-",
"after",
"all",
"the",
"new",
"live",
"ranges",
"have",
"been",
"created",
",",
"compute",
"the",
"remaining",
"live",
"range",
",",
"and",
"rewrite",
"instructions",
"to",
"use",
"the",
"new",
"registers",
"."
] | [
"Mips",
"Mips",
"16u",
"16u",
"16u",
"0",
"1",
"Mips::FeatureGP64Bit",
"Mips::FeatureMips64r2",
"Mips::FeatureMips64",
"Mips::FeatureNoABICalls",
"Mips",
"Mips",
"Mips",
"Mips"
] | MipsTargetStreamer (2)1 | finish | Mips | CPU | LLVM | 19,385 | 410 | 1 | [] |
[
"<s>",
"virtual",
"const",
"mprocSubtarget",
"*",
"getSubtargetImpl",
"(",
")",
"const",
"{",
"return",
"&",
"Subtarget",
";",
"}",
"</s>"
] | [
"Virtual",
"method",
"implemented",
"by",
"subclasses",
"that",
"returns",
"a",
"reference",
"to",
"that",
"target",
"'s",
"TargetSubtargetInfo-derived",
"member",
"variable",
"."
] | [
"mproc",
"mproc"
] | mprocTargetMachine | getSubtargetImpl | mproc | Virtual ISA | LLVM | 19,386 | 14 | 1 | [] |
[
"<s>",
"unsigned",
"getGlobalBaseReg",
"(",
")",
"const",
"{",
"WDC_LOG",
"(",
"\"Returning \"",
"<<",
"GlobalBaseReg",
")",
";",
"return",
"GlobalBaseReg",
";",
"}",
"</s>"
] | [
"getGlobalBaseReg",
"-",
"Return",
"a",
"virtual",
"register",
"initialized",
"with",
"the",
"the",
"global",
"base",
"register",
"value",
"."
] | [
"WDC65816",
"WDC",
"\"Returning \""
] | WDC65816MachineFunctionInfo | getGlobalBaseReg | WDC65816 | MPU | LLVM | 19,387 | 17 | 1 | [] |
[
"<s>",
"static",
"int",
"unicosmk_need_dex",
"(",
"rtx",
"x",
"ATTRIBUTE_UNUSED",
")",
"{",
"return",
"0",
";",
"}",
"</s>"
] | [
"Return",
"the",
"DEX",
"number",
"if",
"X",
"must",
"be",
"replaced",
"by",
"a",
"DEX",
"expression",
"and",
"0",
"otherwise",
"."
] | [
"alpha",
"0"
] | alpha3 | unicosmk_need_dex | alpha | MPU | GCC | 19,388 | 13 | 1 | [] |
[
"<s>",
"bool",
"SystemZInstrInfo",
"::",
"isUnpredicatedTerminator",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"const",
"{",
"const",
"MCInstrDesc",
"&",
"MCID",
"=",
"MI",
"->",
"getDesc",
"(",
")",
";",
"if",
"(",
"!",
"MCID",
".",
"isTerminator",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"MCID",
".",
"isBranch",
"(",
")",
"&&",
"!",
"MCID",
".",
"isBarrier",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"!",
"MCID",
".",
"isPredicable",
"(",
")",
")",
"return",
"true",
";",
"return",
"!",
"isPredicated",
"(",
"MI",
")",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"instruction",
"is",
"a",
"terminator",
"instruction",
"that",
"has",
"not",
"been",
"predicated",
"."
] | [
"SystemZ",
"SystemZ"
] | SystemZInstrInfo7 | isUnpredicatedTerminator | SystemZ | CPU | LLVM | 19,389 | 73 | 1 | [] |
[
"<s>",
"EVT",
"ARMTargetLowering",
"::",
"getOptimalMemOpType",
"(",
"const",
"MemOp",
"&",
"Op",
",",
"const",
"AttributeList",
"&",
"FuncAttributes",
")",
"const",
"{",
"if",
"(",
"(",
"Op",
".",
"isMemcpy",
"(",
")",
"||",
"Op",
".",
"isZeroMemset",
"(",
")",
")",
"&&",
"Subtarget",
"->",
"hasNEON",
"(",
")",
"&&",
"!",
"FuncAttributes",
".",
"hasFnAttr",
"(",
"Attribute",
"::",
"NoImplicitFloat",
")",
")",
"{",
"bool",
"Fast",
";",
"if",
"(",
"Op",
".",
"size",
"(",
")",
">=",
"16",
"&&",
"(",
"Op",
".",
"isAligned",
"(",
"Align",
"(",
"16",
")",
")",
"||",
"(",
"allowsMisalignedMemoryAccesses",
"(",
"MVT",
"::",
"v2f64",
",",
"0",
",",
"Align",
"(",
"1",
")",
",",
"MachineMemOperand",
"::",
"MONone",
",",
"&",
"Fast",
")",
"&&",
"Fast",
")",
")",
")",
"{",
"return",
"MVT",
"::",
"v2f64",
";",
"}",
"else",
"if",
"(",
"Op",
".",
"size",
"(",
")",
">=",
"8",
"&&",
"(",
"Op",
".",
"isAligned",
"(",
"Align",
"(",
"8",
")",
")",
"||",
"(",
"allowsMisalignedMemoryAccesses",
"(",
"MVT",
"::",
"f64",
",",
"0",
",",
"Align",
"(",
"1",
")",
",",
"MachineMemOperand",
"::",
"MONone",
",",
"&",
"Fast",
")",
"&&",
"Fast",
")",
")",
")",
"{",
"return",
"MVT",
"::",
"f64",
";",
"}",
"}",
"return",
"MVT",
"::",
"Other",
";",
"}",
"</s>"
] | [
"It",
"returns",
"EVT",
":",
":Other",
"if",
"the",
"type",
"should",
"be",
"determined",
"using",
"generic",
"target-independent",
"logic",
"."
] | [
"ARM",
"ARM",
"16",
"16",
"MVT::v2f64",
"0",
"1",
"MVT::v2f64",
"8",
"8",
"MVT::f64",
"0",
"1",
"MVT::f64",
"MVT::Other"
] | ARMISelLowering (2)5 | getOptimalMemOpType | ARM | CPU | LLVM | 19,390 | 169 | 1 | [] |
[
"<s>",
"DecodeStatus",
"M68kDisassembler",
"::",
"getInstruction",
"(",
"MCInst",
"&",
"Instr",
",",
"uint64_t",
"&",
"Size",
",",
"ArrayRef",
"<",
"uint8_t",
">",
"Bytes",
",",
"uint64_t",
"Address",
",",
"raw_ostream",
"&",
"CStream",
")",
"const",
"{",
"DecodeStatus",
"Result",
";",
"auto",
"MakeUp",
"=",
"[",
"&",
"]",
"(",
"APInt",
"&",
"Insn",
",",
"unsigned",
"InstrBits",
")",
"{",
"unsigned",
"Idx",
"=",
"Insn",
".",
"getBitWidth",
"(",
")",
">>",
"3",
";",
"unsigned",
"RoundUp",
"=",
"alignTo",
"(",
"InstrBits",
",",
"Align",
"(",
"16",
")",
")",
";",
"if",
"(",
"RoundUp",
">",
"Insn",
".",
"getBitWidth",
"(",
")",
")",
"Insn",
"=",
"Insn",
".",
"zext",
"(",
"RoundUp",
")",
";",
"RoundUp",
"=",
"RoundUp",
">>",
"3",
";",
"for",
"(",
";",
"Idx",
"<",
"RoundUp",
";",
"Idx",
"+=",
"2",
")",
"{",
"Insn",
".",
"insertBits",
"(",
"support",
"::",
"endian",
"::",
"read16be",
"(",
"&",
"Bytes",
"[",
"Idx",
"]",
")",
",",
"Idx",
"*",
"8",
",",
"16",
")",
";",
"}",
"}",
";",
"APInt",
"Insn",
"(",
"16",
",",
"support",
"::",
"endian",
"::",
"read16be",
"(",
"Bytes",
".",
"data",
"(",
")",
")",
")",
";",
"Size",
"=",
"2",
";",
"Result",
"=",
"decodeInstruction",
"(",
"DecoderTable80",
",",
"Instr",
",",
"Insn",
",",
"Address",
",",
"this",
",",
"STI",
",",
"MakeUp",
")",
";",
"if",
"(",
"Result",
"==",
"DecodeStatus",
"::",
"Success",
")",
"Size",
"=",
"InstrLenTable",
"[",
"Instr",
".",
"getOpcode",
"(",
")",
"]",
">>",
"3",
";",
"return",
"Result",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"disassembly",
"of",
"a",
"single",
"instruction",
"."
] | [
"M68k",
"M68k",
"3",
"16",
"3",
"2",
"support::endian",
"8",
"16",
"16",
"support::endian",
"2",
"3"
] | M68kDisassembler (2) | getInstruction | M68k | MPU | LLVM | 19,391 | 201 | 1 | [] |
[
"<s>",
"SDValue",
"VETargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"::LowerOperation\"",
";",
"Op",
"->",
"print",
"(",
"dbgs",
"(",
")",
")",
";",
")",
";",
"unsigned",
"Opcode",
"=",
"Op",
".",
"getOpcode",
"(",
")",
";",
"switch",
"(",
"Opcode",
")",
"{",
"case",
"ISD",
"::",
"ATOMIC_FENCE",
":",
"return",
"lowerATOMIC_FENCE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"ATOMIC_SWAP",
":",
"return",
"lowerATOMIC_SWAP",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BlockAddress",
":",
"return",
"lowerBlockAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"ConstantPool",
":",
"return",
"lowerConstantPool",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"DYNAMIC_STACKALLOC",
":",
"return",
"lowerDYNAMIC_STACKALLOC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"EH_SJLJ_LONGJMP",
":",
"return",
"lowerEH_SJLJ_LONGJMP",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"EH_SJLJ_SETJMP",
":",
"return",
"lowerEH_SJLJ_SETJMP",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"EH_SJLJ_SETUP_DISPATCH",
":",
"return",
"lowerEH_SJLJ_SETUP_DISPATCH",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FRAMEADDR",
":",
"return",
"lowerFRAMEADDR",
"(",
"Op",
",",
"DAG",
",",
"*",
"this",
",",
"Subtarget",
")",
";",
"case",
"ISD",
"::",
"GlobalAddress",
":",
"return",
"lowerGlobalAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalTLSAddress",
":",
"return",
"lowerGlobalTLSAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
":",
"return",
"lowerINTRINSIC_WO_CHAIN",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"JumpTable",
":",
"return",
"lowerJumpTable",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"LOAD",
":",
"return",
"lowerLOAD",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"RETURNADDR",
":",
"return",
"lowerRETURNADDR",
"(",
"Op",
",",
"DAG",
",",
"*",
"this",
",",
"Subtarget",
")",
";",
"case",
"ISD",
"::",
"BUILD_VECTOR",
":",
"return",
"lowerBUILD_VECTOR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"STORE",
":",
"return",
"lowerSTORE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"VASTART",
":",
"return",
"lowerVASTART",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"VAARG",
":",
"return",
"lowerVAARG",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INSERT_VECTOR_ELT",
":",
"return",
"lowerINSERT_VECTOR_ELT",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"EXTRACT_VECTOR_ELT",
":",
"return",
"lowerEXTRACT_VECTOR_ELT",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"::LowerOperation_VVP\"",
";",
"Op",
"->",
"print",
"(",
"dbgs",
"(",
")",
")",
";",
")",
";",
"if",
"(",
"ISD",
"::",
"isVPOpcode",
"(",
"Opcode",
")",
")",
"return",
"lowerToVVP",
"(",
"Op",
",",
"DAG",
")",
";",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Should not custom lower this!\"",
")",
";",
"case",
"VEISD",
"::",
"VEC_BROADCAST",
":",
"if",
"(",
"getAnnotatedNodeAVL",
"(",
"Op",
")",
".",
"second",
")",
"return",
"Op",
";",
"return",
"legalizeInternalVectorOp",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"MLOAD",
":",
"case",
"ISD",
"::",
"MSTORE",
":",
"if",
"(",
"isMaskArithmetic",
"(",
"Op",
")",
"&&",
"isPackedVectorType",
"(",
"Op",
".",
"getValueType",
"(",
")",
")",
")",
"return",
"splitMaskArithmetic",
"(",
"Op",
",",
"DAG",
")",
";",
"return",
"lowerToVVP",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"VE",
"VE",
"\"::LowerOperation\"",
"ISD::ATOMIC_FENCE",
"ISD::ATOMIC_SWAP",
"ISD::BlockAddress",
"ISD::ConstantPool",
"ISD::DYNAMIC_STACKALLOC",
"ISD::EH_SJLJ_LONGJMP",
"ISD::EH_SJLJ_SETJMP",
"ISD::EH_SJLJ_SETUP_DISPATCH",
"ISD::FRAMEADDR",
"ISD::GlobalAddress",
"ISD::GlobalTLSAddress",
"ISD::INTRINSIC_WO_CHAIN",
"ISD::JumpTable",
"ISD::LOAD",
"ISD::RETURNADDR",
"ISD::BUILD_VECTOR",
"VE",
"ISD::STORE",
"ISD::VASTART",
"ISD::VAARG",
"ISD::INSERT_VECTOR_ELT",
"VE",
"ISD::EXTRACT_VECTOR_ELT",
"VE",
"\"::LowerOperation_VVP\"",
"ISD::isVPOpcode",
"\"Should not custom lower this!\"",
"VEISD::VEC_BROADCAST",
"ISD::MLOAD",
"ISD::MSTORE"
] | VEISelLowering8 | LowerOperation | VE | CPU | LLVM | 19,392 | 448 | 1 | [] |
[
"<s>",
"const",
"InstrItineraryData",
"*",
"getInstrItineraryData",
"(",
")",
"const",
"override",
"{",
"return",
"&",
"InstrItins",
";",
"}",
"</s>"
] | [
"getInstrItineraryData",
"-",
"Returns",
"instruction",
"itinerary",
"data",
"for",
"the",
"target",
"or",
"specific",
"subtarget",
"."
] | [
"ARM"
] | ARMSubtarget (2)1 | getInstrItineraryData | ARM | CPU | LLVM | 19,393 | 14 | 1 | [] |
[
"<s>",
"unsigned",
"getReg",
"(",
"unsigned",
"RC",
",",
"unsigned",
"RegNo",
")",
"const",
"{",
"return",
"*",
"(",
"RegInfo",
"->",
"getRegClass",
"(",
"RC",
")",
".",
"begin",
"(",
")",
"+",
"RegNo",
")",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"register",
"associated",
"with",
"this",
"edge",
"."
] | [
"Videocore"
] | VideocoreDisassembler | getReg | Videocore | DSP | LLVM | 19,394 | 29 | 1 | [] |
[
"<s>",
"bool",
"isImm",
"(",
")",
"const",
"{",
"return",
"Kind",
"==",
"Immediate",
";",
"}",
"</s>"
] | [
"isImm",
"-",
"Is",
"this",
"an",
"immediate",
"operand",
"?"
] | [
"MBlaze"
] | MBlazeAsmParser1 | isImm | MBlaze | MPU | LLVM | 19,395 | 12 | 1 | [] |
[
"<s>",
"bool",
"SystemZRegisterInfo",
"::",
"saveScavengerRegister",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"SaveMBBI",
",",
"MachineBasicBlock",
"::",
"iterator",
"&",
"UseMBBI",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"unsigned",
"Reg",
")",
"const",
"{",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"SystemZFrameLowering",
"*",
"TFI",
"=",
"static_cast",
"<",
"const",
"SystemZFrameLowering",
"*",
">",
"(",
"TM",
".",
"getFrameLowering",
"(",
")",
")",
";",
"unsigned",
"Base",
"=",
"getFrameRegister",
"(",
"MF",
")",
";",
"uint64_t",
"Offset",
"=",
"TFI",
"->",
"getEmergencySpillSlotOffset",
"(",
"MF",
")",
";",
"DebugLoc",
"DL",
";",
"unsigned",
"LoadOpcode",
",",
"StoreOpcode",
";",
"TII",
".",
"getLoadStoreOpcodes",
"(",
"RC",
",",
"LoadOpcode",
",",
"StoreOpcode",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"SaveMBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"StoreOpcode",
")",
")",
".",
"addReg",
"(",
"Reg",
",",
"RegState",
"::",
"Kill",
")",
".",
"addReg",
"(",
"Base",
")",
".",
"addImm",
"(",
"Offset",
")",
".",
"addReg",
"(",
"0",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"UseMBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"LoadOpcode",
")",
",",
"Reg",
")",
".",
"addReg",
"(",
"Base",
")",
".",
"addImm",
"(",
"Offset",
")",
".",
"addReg",
"(",
"0",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Spill",
"the",
"register",
"so",
"it",
"can",
"be",
"used",
"by",
"the",
"register",
"scavenger",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ",
"0",
"0"
] | SystemZRegisterInfo24 | saveScavengerRegister | SystemZ | CPU | LLVM | 19,396 | 174 | 1 | [] |
[
"<s>",
"bool",
"X86FastISel",
"::",
"isTypeLegal",
"(",
"const",
"Type",
"*",
"Ty",
",",
"MVT",
"&",
"VT",
",",
"bool",
"AllowI1",
")",
"{",
"VT",
"=",
"TLI",
".",
"getValueType",
"(",
"Ty",
",",
"true",
")",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"Other",
"||",
"!",
"VT",
".",
"isSimple",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f64",
"&&",
"!",
"X86ScalarSSEf64",
")",
"return",
"false",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f32",
"&&",
"!",
"X86ScalarSSEf32",
")",
"return",
"false",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f80",
")",
"return",
"false",
";",
"return",
"(",
"AllowI1",
"&&",
"VT",
"==",
"MVT",
"::",
"i1",
")",
"||",
"TLI",
".",
"isTypeLegal",
"(",
"VT",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"this",
"type",
"is",
"legal",
"."
] | [
"X86",
"X86",
"MVT::Other",
"MVT::f64",
"X86",
"MVT::f32",
"X86",
"MVT::f80",
"MVT::i1"
] | X86FastISel41 | isTypeLegal | X86 | CPU | LLVM | 19,397 | 105 | 1 | [] |
[
"<s>",
"static",
"bool",
"aarch64_reads_global_state_p",
"(",
"aarch64_simd_builtin_datum",
"*",
"d",
")",
"{",
"unsigned",
"int",
"flags",
"=",
"aarch64_call_properties",
"(",
"d",
")",
";",
"if",
"(",
"flags",
"&",
"FLAG_READ_FPCR",
")",
"return",
"true",
";",
"return",
"flags",
"&",
"FLAG_READ_MEMORY",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"calls",
"to",
"the",
"function",
"could",
"read",
"some",
"form",
"of",
"global",
"state",
"."
] | [
"aarch64"
] | aarch64-builtins1 | aarch64_reads_global_state_p | aarch64 | CPU | GCC | 19,398 | 33 | 1 | [] |
[
"<s>",
"bool",
"RISCVTargetLowering",
"::",
"isFPImmLegal",
"(",
"const",
"APFloat",
"&",
"Imm",
",",
"EVT",
"VT",
",",
"bool",
"ForCodeSize",
")",
"const",
"{",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f16",
"&&",
"!",
"Subtarget",
".",
"hasStdExtZfhmin",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f32",
"&&",
"!",
"Subtarget",
".",
"hasStdExtF",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f64",
"&&",
"!",
"Subtarget",
".",
"hasStdExtD",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"Imm",
".",
"isNegZero",
"(",
")",
")",
"return",
"false",
";",
"return",
"Imm",
".",
"isZero",
"(",
")",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"can",
"instruction",
"select",
"the",
"specified",
"FP",
"immediate",
"natively",
"."
] | [
"RISCV",
"RISCV",
"MVT::f16",
"MVT::f32",
"MVT::f64"
] | RISCVISelLowering18 | isFPImmLegal | RISCV | CPU | LLVM | 19,399 | 91 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.