Compiler_Type
stringclasses 2
values | Target
stringclasses 176
values | Programming Language
stringclasses 3
values | Task
stringclasses 4
values | Target_Type
stringclasses 7
values | Idx
int64 0
636k
| Ground_Truth
sequencelengths 0
2.32k
| Input
sequencelengths 1
1.02k
|
---|---|---|---|---|---|---|---|
LLVM | WebAssembly | CPP | next_suggestion | Virtual ISA | 0 | [
"}"
] | [
"void",
"Block",
"::",
"AddBranchTo",
"(",
"Block",
"*",
"Target",
",",
"const",
"char",
"*",
"Condition",
",",
"const",
"char",
"*",
"Code",
")",
"{",
"assert",
"(",
"!",
"contains",
"(",
"BranchesOut",
",",
"Target",
")",
"&&",
"<STR_LIT>",
"cannot add more than one branch to the same target",
"<STR_LIT>",
")",
";",
"BranchesOut",
"[",
"Target",
"]",
"=",
"make_unique",
"<",
"Branch",
">",
"(",
"Condition",
",",
"Code",
")",
";"
] |
GCC | i386 | CPP | stmt_completion | CPU | 1 | [
"_",
"_",
"mmask16",
")",
"_",
"_",
"U",
")",
";"
] | [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m512i",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm512_maskz_cvtepi8_epi32",
"(",
"_",
"_",
"mmask16",
"_",
"_",
"U",
",",
"_",
"_",
"m128i",
"_",
"_",
"A",
")",
"{",
"return",
"(",
"_",
"_",
"m512i",
")",
"_",
"_",
"builtin_ia32_pmovsxbd512_mask",
"(",
"(",
"_",
"_",
"v16qi",
")",
"_",
"_",
"A",
",",
"(",
"_",
"_",
"v16si",
")",
"_",
"mm512_setzero_si512",
"(",
")",
",",
"("
] |
LLVM | PowerPC | TD | stmt_completion | CPU | 2 | [
"(",
"PPCvecinsert",
"v4i32",
":",
"$",
"XTi",
",",
"v4i32",
":",
"$",
"XB",
",",
"imm32SExt16",
":",
"$",
"UIM",
")",
")",
"]",
">",
",",
"RegConstraint",
"<",
"<STR_LIT>",
">",
",",
"NoEncode",
"<",
"<STR_LIT>",
">",
";"
] | [
"def",
"XXINSERTW",
":",
"XX2_RD6_UIM5_RS6",
"<",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"(",
"outs",
"vsrc",
":",
"$",
"XT",
")",
",",
"(",
"ins",
"vsrc",
":",
"$",
"XTi",
",",
"vsrc",
":",
"$",
"XB",
",",
"u4imm",
":",
"$",
"UIM",
")",
",",
"<STR_LIT>",
",",
"IIC_VecFP",
",",
"[",
"(",
"set",
"v4i32",
":",
"$",
"XT",
","
] |
LLVM | AArch64 | CPP | next_suggestion | CPU | 3 | [
"assert",
"(",
"NumBytes",
"<=",
"FulleSizeInBytes",
"&&",
"<STR_LIT>",
"Invalid fixup size!",
"<STR_LIT>",
")",
";"
] | [
"Value",
"=",
"adjustFixupValue",
"(",
"Fixup",
",",
"Target",
",",
"Value",
",",
"Ctx",
",",
"TheTriple",
",",
"IsResolved",
")",
";",
"Value",
"<<=",
"Info",
".",
"TargetOffset",
";",
"unsigned",
"Offset",
"=",
"Fixup",
".",
"getOffset",
"(",
")",
";",
"assert",
"(",
"Offset",
"+",
"NumBytes",
"<=",
"Data",
".",
"size",
"(",
")",
"&&",
"<STR_LIT>",
"Invalid fixup offset!",
"<STR_LIT>",
")",
";",
"unsigned",
"FulleSizeInBytes",
"=",
"getFixupKindContainereSizeInBytes",
"(",
"Fixup",
".",
"getKind",
"(",
")",
")",
";",
"if",
"(",
"FulleSizeInBytes",
"==",
"<NUM_LIT>",
")",
"{",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"!=",
"NumBytes",
";",
"++",
"i",
")",
"{",
"Data",
"[",
"Offset",
"+",
"i",
"]",
"|=",
"uint8_t",
"(",
"(",
"Value",
">>",
"(",
"i",
"*",
"<NUM_LIT>",
")",
")",
"&",
"<NUM_LIT>",
")",
";",
"}",
"}",
"else",
"{",
"assert",
"(",
"(",
"Offset",
"+",
"FulleSizeInBytes",
")",
"<=",
"Data",
".",
"size",
"(",
")",
"&&",
"<STR_LIT>",
"Invalid fixup size!",
"<STR_LIT>",
")",
";"
] |
LLVM | AArch64 | TD | next_suggestion | CPU | 4 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"target",
";"
] | [
"let",
"isBranch",
"=",
"<NUM_LIT>",
";",
"let",
"isTerminator",
"=",
"<NUM_LIT>",
";",
"let",
"Uses",
"=",
"[",
"NZCV",
"]",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"cond",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"target",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] |
LLVM | AMDGPU | CPP | next_suggestion | GPU | 5 | [
"if",
"(",
"!",
"Info",
"->",
"isEntryFunction",
"(",
")",
"&&",
"FI",
".",
"hasValue",
"(",
")",
")",
"MIB",
".",
"addReg",
"(",
"Info",
"->",
"getStackPtrOffsetReg",
"(",
")",
")",
";"
] | [
"const",
"MachineInstr",
"*",
"LHSDef",
"=",
"MRI",
"->",
"getVRegDef",
"(",
"LHS",
".",
"getReg",
"(",
")",
")",
";",
"const",
"MachineInstr",
"*",
"RHSDef",
"=",
"MRI",
"->",
"getVRegDef",
"(",
"RHS",
".",
"getReg",
"(",
")",
")",
";",
"if",
"(",
"LHSDef",
"&&",
"RHSDef",
")",
"{",
"int64_t",
"PossibleOffset",
"=",
"RHSDef",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getCImm",
"(",
")",
"->",
"getSExtValue",
"(",
")",
";",
"if",
"(",
"SIInstrInfo",
"::",
"isLegalMUBUFImmOffset",
"(",
"PossibleOffset",
")",
"&&",
"(",
"!",
"STI",
".",
"privateMemoryResourceIsRangeChecked",
"(",
")",
"||",
"KnownBits",
"->",
"signBitIsZero",
"(",
"LHS",
".",
"getReg",
"(",
")",
")",
")",
")",
"{",
"if",
"(",
"LHSDef",
"->",
"getOpcode",
"(",
")",
"==",
"AMDGPU",
"::",
"G_FRAME_INDEX",
")",
"FI",
"=",
"LHSDef",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getIndex",
"(",
")",
";",
"else",
"VAddr",
"=",
"LHS",
".",
"getReg",
"(",
")",
";",
"Offset",
"=",
"PossibleOffset",
";",
"}",
"}",
"}",
"else",
"if",
"(",
"RootDef",
"->",
"getOpcode",
"(",
")",
"==",
"AMDGPU",
"::",
"G_FRAME_INDEX",
")",
"{",
"FI",
"=",
"RootDef",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getIndex",
"(",
")",
";",
"}",
"}",
"return",
"{",
"{",
"[",
"=",
"]",
"(",
"MachineInstrBuilder",
"&",
"MIB",
")",
"{",
"MIB",
".",
"addReg",
"(",
"Info",
"->",
"getScratchRSrcReg",
"(",
")",
")",
";",
"}",
",",
"[",
"=",
"]",
"(",
"MachineInstrBuilder",
"&",
"MIB",
")",
"{",
"if",
"(",
"FI",
".",
"hasValue",
"(",
")",
")",
"MIB",
".",
"addFrameIndex",
"(",
"FI",
".",
"getValue",
"(",
")",
")",
";",
"else",
"MIB",
".",
"addReg",
"(",
"VAddr",
")",
";",
"}",
",",
"[",
"=",
"]",
"(",
"MachineInstrBuilder",
"&",
"MIB",
")",
"{"
] |
GCC | iq2000 | CPP | code_generation | CPU | 6 | [
"static",
"section",
"*",
"iq2000_select_rtx_section",
"(",
"machine_mode",
"mode",
",",
"rtx",
"x",
"ATTRIBUTE_UNUSED",
",",
"unsigned",
"HOST_WIDE_INT",
"align",
")",
"{",
"return",
"mergeable_constant_section",
"(",
"mode",
",",
"align",
",",
"<NUM_LIT>",
")",
";",
"}"
] | [
"Choose",
"the",
"section",
"to",
"use",
"for",
"the",
"constant",
"rtx",
"expression",
"X",
"that",
"has",
"mode",
"MODE",
"."
] |
GCC | aarch64 | CPP | next_suggestion | CPU | 7 | [
"}"
] | [
"static",
"tree",
"add_attribute",
"(",
"const",
"char",
"*",
"name",
",",
"tree",
"attrs",
")",
"{",
"return",
"tree_cons",
"(",
"get_identifier",
"(",
"name",
")",
",",
"NULL_TREE",
",",
"attrs",
")",
";"
] |
LLVM | SystemZ | TD | next_suggestion | CPU | 8 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"V2",
"{",
"<NUM_LIT>",
"}",
";"
] | [
"field",
"bits",
"<",
"<NUM_LIT>",
">",
"Inst",
";",
"field",
"bits",
"<",
"<NUM_LIT>",
">",
"SoftFail",
"=",
"<NUM_LIT>",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"V1",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"V2",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"M3",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"M4",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"M5",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"op",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"V1",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"V2",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"M5",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"!",
"if",
"(",
"!",
"eq",
"(",
"m4or",
"{",
"<NUM_LIT>",
"}",
",",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
",",
"M4",
"{",
"<NUM_LIT>",
"}",
")",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"!",
"if",
"(",
"!",
"eq",
"(",
"m4or",
"{",
"<NUM_LIT>",
"}",
",",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
",",
"M4",
"{",
"<NUM_LIT>",
"}",
")",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"!",
"if",
"(",
"!",
"eq",
"(",
"m4or",
"{",
"<NUM_LIT>",
"}",
",",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
",",
"M4",
"{",
"<NUM_LIT>",
"}",
")",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"!",
"if",
"(",
"!",
"eq",
"(",
"m4or",
"{",
"<NUM_LIT>",
"}",
",",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
",",
"M4",
"{",
"<NUM_LIT>",
"}",
")",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"M3",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"V1",
"{",
"<NUM_LIT>",
"}",
";"
] |
GCC | sh | MD | program_repair | CPU | 9 | [
"<FIXS>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"<FIXE>",
"<FIXS>",
"(",
"use",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"use",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"<FIXE>",
"<FIXS>",
"<STR_LIT>",
"<FIXE>",
"<FIXS>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"<FIXE>",
"<FIXS>",
"(",
"use",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"use",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"]",
"<FIXE>",
"<FIXS>",
"<STR_LIT>",
"<FIXE>"
] | [
"}",
")",
"(",
"define_insn",
"<STR_LIT>",
"<BUGS>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"<BUGE>",
"(",
"div",
":",
"SI",
"(",
"reg",
":",
"SI",
"R4_REG",
")",
"(",
"reg",
":",
"SI",
"R5_REG",
")",
")",
")",
"(",
"clobber",
"(",
"reg",
":",
"SI",
"PR_REG",
")",
")",
"(",
"clobber",
"(",
"reg",
":",
"DF",
"DR0_REG",
")",
")",
"(",
"clobber",
"(",
"reg",
":",
"DF",
"DR2_REG",
")",
")",
"(",
"clobber",
"(",
"reg",
":",
"SI",
"FPSCR_STAT_REG",
")",
")",
"<BUGS>",
"(",
"use",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"<BUGE>",
"(",
"use",
"(",
"reg",
":",
"SI",
"FPSCR_MODES_REG",
")",
")",
"]",
"<STR_LIT>",
"<BUGS>",
"<STR_LIT>",
"<BUGE>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"(",
"define_insn",
"<STR_LIT>",
"<BUGS>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"<BUGE>",
"(",
"div",
":",
"SI",
"(",
"reg",
":",
"SI",
"R4_REG",
")",
"(",
"reg",
":",
"SI",
"R5_REG",
")",
")",
")",
"(",
"clobber",
"(",
"reg",
":",
"SI",
"PR_REG",
")",
")",
"(",
"clobber",
"(",
"reg",
":",
"DF",
"DR0_REG",
")",
")",
"(",
"clobber",
"(",
"reg",
":",
"DF",
"DR2_REG",
")",
")",
"(",
"clobber",
"(",
"reg",
":",
"SI",
"R2_REG",
")",
")",
"<BUGS>",
"(",
"use",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"]",
"<BUGE>",
"<STR_LIT>",
"<BUGS>",
"<STR_LIT>",
"<BUGE>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")"
] |
LLVM | X86 | TD | stmt_completion | CPU | 10 | [
":",
"$",
"ptr",
")",
")",
">",
";"
] | [
"def",
"extloadi64i32",
":",
"PatFrag",
"<",
"(",
"ops",
"node",
":",
"$",
"ptr",
")",
",",
"(",
"i64",
"(",
"extloadi32",
"node"
] |
LLVM | AMDGPU | CPP | stmt_completion | GPU | 11 | [
":",
"<NUM_LIT>",
";"
] | [
"auto",
"Arg",
"=",
"ArgInfo",
".",
"getPreloadedValue",
"(",
"Value",
")",
".",
"first",
";",
"return",
"Arg",
"?",
"Arg",
"->",
"getRegister",
"(",
")"
] |
GCC | i386 | MD | next_suggestion | CPU | 12 | [
"<STR_LIT>",
")"
] | [
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
")"
] |
LLVM | AArch64 | TD | next_suggestion | CPU | 13 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Zd",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"sz8_64",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Zm",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Zn",
";"
] |
GCC | i386 | MD | program_repair | CPU | 14 | [
"<FIXS>",
"(",
"V2DI",
"<STR_LIT>",
")",
"(",
"V4DI",
"<STR_LIT>",
")",
"(",
"V8DI",
"<STR_LIT>",
")",
"]",
")",
"<FIXE>"
] | [
"[",
"(",
"V16QI",
"<STR_LIT>",
")",
"(",
"V32QI",
"<STR_LIT>",
")",
"(",
"V8HI",
"<STR_LIT>",
")",
"(",
"V16HI",
"<STR_LIT>",
")",
"(",
"V4SI",
"<STR_LIT>",
")",
"(",
"V8SI",
"<STR_LIT>",
")",
"(",
"V16SI",
"<STR_LIT>",
")",
"<BUGS>",
"(",
"V2DI",
"<STR_LIT>",
")",
"(",
"V4DI",
"<STR_LIT>",
")",
"]",
")",
"<BUGE>",
"(",
"define_mode_attr",
"avx_avx2",
"[",
"(",
"V4SF",
"<STR_LIT>",
")",
"(",
"V2DF",
"<STR_LIT>",
")"
] |
LLVM | AArch64 | CPP | stmt_completion | CPU | 15 | [
")",
";"
] | [
"if",
"(",
"Value",
"&",
"<NUM_LIT>",
")",
"Ctx",
".",
"reportError",
"(",
"Fixup",
".",
"getLoc",
"(",
")",
",",
"<STR_LIT>",
"fixup must be 16-byte aligned",
"<STR_LIT>",
")",
";",
"return",
"Value",
">>",
"<NUM_LIT>",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"{",
"AArch64MCExpr",
"::",
"VariantKind",
"RefKind",
"=",
"static_cast",
"<",
"AArch64MCExpr",
"::",
"VariantKind",
">",
"(",
"Target",
".",
"getRefKind",
"(",
")",
")",
";",
"if",
"(",
"AArch64MCExpr",
"::",
"getSymbolLoc",
"(",
"RefKind",
")",
"!=",
"AArch64MCExpr",
"::",
"VK_ABS",
"&&",
"AArch64MCExpr",
"::",
"getSymbolLoc",
"(",
"RefKind",
")",
"!=",
"AArch64MCExpr",
"::",
"VK_SABS",
")",
"{",
"Ctx",
".",
"reportError",
"(",
"Fixup",
".",
"getLoc",
"(",
")",
",",
"<STR_LIT>",
"relocation for a thread-local variable points to an ",
"<STR_LIT>",
"<STR_LIT>",
"absolute symbol",
"<STR_LIT>",
")",
";",
"return",
"Value",
";",
"}",
"if",
"(",
"!",
"IsResolved",
")",
"{",
"Ctx",
".",
"reportError",
"(",
"Fixup",
".",
"getLoc",
"(",
")",
",",
"<STR_LIT>",
"unresolved movw fixup not yet ",
"<STR_LIT>",
"<STR_LIT>",
"implemented",
"<STR_LIT>",
")",
";",
"return",
"Value",
";",
"}",
"if",
"(",
"AArch64MCExpr",
"::",
"getSymbolLoc",
"(",
"RefKind",
")",
"==",
"AArch64MCExpr",
"::",
"VK_SABS",
")",
"{",
"switch",
"(",
"AArch64MCExpr",
"::",
"getAddressFrag",
"(",
"RefKind",
")",
")",
"{",
"case",
"AArch64MCExpr",
"::",
"VK_G0",
":",
"break",
";",
"case",
"AArch64MCExpr",
"::",
"VK_G1",
":",
"SignedValue",
"=",
"SignedValue",
">>",
"<NUM_LIT>",
";",
"break",
";",
"case",
"AArch64MCExpr",
"::",
"VK_G2",
":",
"SignedValue",
"=",
"SignedValue",
">>",
"<NUM_LIT>",
";",
"break",
";",
"case",
"AArch64MCExpr",
"::",
"VK_G3",
":",
"SignedValue",
"=",
"SignedValue",
">>",
"<NUM_LIT>",
";",
"break",
";",
"default",
":",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Variant kind doesn't correspond to fixup",
"<STR_LIT>",
")",
";",
"}",
"}",
"else",
"{",
"switch",
"(",
"AArch64MCExpr",
"::",
"getAddressFrag",
"(",
"RefKind",
")",
")",
"{",
"case",
"AArch64MCExpr",
"::",
"VK_G0",
":",
"break",
";",
"case",
"AArch64MCExpr",
"::",
"VK_G1",
":",
"Value",
"=",
"Value",
">>",
"<NUM_LIT>",
";",
"break",
";",
"case",
"AArch64MCExpr",
"::",
"VK_G2",
":",
"Value",
"=",
"Value",
">>",
"<NUM_LIT>",
";",
"break",
";",
"case",
"AArch64MCExpr",
"::",
"VK_G3",
":",
"Value",
"=",
"Value",
">>",
"<NUM_LIT>",
";",
"break",
";",
"default",
":",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Variant kind doesn't correspond to fixup",
"<STR_LIT>",
")",
";",
"}",
"}",
"if",
"(",
"RefKind",
"&",
"AArch64MCExpr",
"::",
"VK_NC",
")",
"{",
"Value",
"&=",
"<NUM_LIT>",
";",
"}",
"else",
"if",
"(",
"AArch64MCExpr",
"::",
"getSymbolLoc",
"(",
"RefKind",
")",
"==",
"AArch64MCExpr",
"::",
"VK_SABS",
")",
"{",
"if",
"(",
"SignedValue",
">",
"<NUM_LIT>",
"||",
"SignedValue",
"<",
"-",
"<NUM_LIT>",
")",
"Ctx",
".",
"reportError",
"(",
"Fixup",
".",
"getLoc",
"(",
")",
",",
"<STR_LIT>",
"fixup value out of range",
"<STR_LIT>",
")",
";",
"if",
"(",
"SignedValue",
"<",
"<NUM_LIT>",
")",
"SignedValue",
"=",
"~",
"SignedValue",
";",
"Value",
"=",
"static_cast",
"<",
"uint64_t",
">",
"(",
"SignedValue"
] |
LLVM | BPF | CPP | next_suggestion | Virtual ISA | 16 | [
"initializeBPFMIPeepholeTruncElimPass",
"(",
"PR",
")",
";"
] | [
"PassRegistry",
"&",
"PR",
"=",
"*",
"PassRegistry",
"::",
"getPassRegistry",
"(",
")",
";",
"initializeBPFAbstractMemberAccessPass",
"(",
"PR",
")",
";",
"initializeBPFPreserveDITypePass",
"(",
"PR",
")",
";",
"initializeBPFMIPeepholePass",
"(",
"PR",
")",
";"
] |
GCC | mips | MD | stmt_completion | CPU | 17 | [
")",
"]",
")"
] | [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"ANYF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"fma",
":",
"ANYF",
"(",
"match_operand",
":",
"ANYF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"ANYF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"ANYF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 18 | [
"if",
"(",
"Scale",
">",
"<NUM_LIT>",
")",
"O",
"<<",
"<STR_LIT>",
" * ",
"<STR_LIT>",
"<<",
"Scale",
";"
] | [
"}",
"O",
"<<",
"<STR_LIT>",
"[",
"<STR_LIT>",
"<<",
"TRI",
"->",
"getAsmName",
"(",
"MO1",
".",
"getReg",
"(",
")",
")",
";",
"if",
"(",
"MO3",
".",
"getReg",
"(",
")",
")",
"O",
"<<",
"<STR_LIT>",
", ",
"<STR_LIT>",
"<<",
"TRI",
"->",
"getAsmName",
"(",
"MO3",
".",
"getReg",
"(",
")",
")",
";",
"else",
"if",
"(",
"unsigned",
"ImmOffs",
"=",
"MO2",
".",
"getImm",
"(",
")",
")",
"{",
"O",
"<<",
"<STR_LIT>",
", #",
"<STR_LIT>",
"<<",
"ImmOffs",
";"
] |
LLVM | AArch64 | TD | next_suggestion | CPU | 19 | [
"}"
] | [
"def",
"roW",
":",
"LoadStore8RO",
"<",
"sz",
",",
"V",
",",
"opc",
",",
"asm",
",",
"(",
"outs",
"regtype",
":",
"$",
"Rt",
")",
",",
"(",
"ins",
"GPR64sp",
":",
"$",
"Rn",
",",
"GPR32",
":",
"$",
"Rm",
",",
"ro_Wextend8",
":",
"$",
"extend",
")",
",",
"[",
"(",
"set",
"(",
"Ty",
"regtype",
":",
"$",
"Rt",
")",
",",
"(",
"loadop",
"(",
"ro_Windexed8",
"GPR64sp",
":",
"$",
"Rn",
",",
"GPR32",
":",
"$",
"Rm",
",",
"ro_Wextend8",
":",
"$",
"extend",
")",
")",
")",
"]",
">",
",",
"Sched",
"<",
"[",
"WriteLDIdx",
",",
"ReadAdrBase",
"]",
">",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] |
LLVM | ARM | CPP | stmt_completion | CPU | 20 | [
":"
] | [
"setAttributeItem",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"false",
")",
";",
"break",
";",
"case",
"ARM",
"::",
"FK_VFPV3_FP16",
":",
"setAttributeItem",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"false",
")",
";",
"setAttributeItem",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"false",
")",
";",
"break",
";",
"case",
"ARM",
"::",
"FK_VFPV3_D16",
":",
"setAttributeItem",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"false",
")",
";",
"break",
";",
"case",
"ARM",
"::",
"FK_VFPV3_D16_FP16",
":",
"setAttributeItem",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"false",
")",
";",
"setAttributeItem",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"false",
")",
";",
"break",
";",
"case",
"ARM",
"::",
"FK_VFPV3XD",
":",
"setAttributeItem",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"false",
")",
";",
"break",
";",
"case",
"ARM",
"::",
"FK_VFPV3XD_FP16",
":",
"setAttributeItem",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"false",
")",
";",
"setAttributeItem",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"false",
")",
";",
"break",
";",
"case",
"ARM",
"::",
"FK_VFPV4"
] |
LLVM | SNES | TD | stmt_completion | DSP | 21 | [
"src",
",",
"imm",
":",
"$",
"k",
")",
")",
",",
"(",
"implicit",
"P",
")",
"]",
">",
";"
] | [
"def",
"SBCIRdK",
":",
"FRdK",
"<",
"<NUM_LIT>",
",",
"(",
"outs",
"MainRegs",
":",
"$",
"rd",
")",
",",
"(",
"ins",
"MainRegs",
":",
"$",
"src",
",",
"imm_ldi16",
":",
"$",
"k",
")",
",",
"<STR_LIT>",
",",
"[",
"(",
"set",
"i16",
":",
"$",
"rd",
",",
"(",
"sube",
"i16",
":",
"$"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 22 | [
"=",
"<NUM_LIT>",
";"
] | [
"def",
"L2_loadrub_io",
":",
"HInst",
"<",
"(",
"outs",
"IntRegs",
":",
"$",
"Rd32",
")",
",",
"(",
"ins",
"IntRegs",
":",
"$",
"Rs32",
",",
"s32_0Imm",
":",
"$",
"Ii",
")",
",",
"<STR_LIT>",
",",
"tc_17e0d2cd",
",",
"TypeLD",
">",
",",
"Enc_211aaa",
",",
"AddrModeRel",
",",
"PostInc_BaseImm",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"hasNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"opNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"addrMode",
"=",
"BaseImmOffset",
";",
"let",
"accessSize",
"=",
"ByteAccess",
";",
"let",
"mayLoad"
] |
GCC | fr30 | MD | next_suggestion | DSP | 23 | [
"<STR_LIT>"
] | [
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<STR_LIT>"
] |
GCC | i386 | CPP | next_suggestion | CPU | 24 | [
"pic_reg_used",
"=",
"true",
";"
] | [
"x",
"=",
"gen_rtx_EXPR_LIST",
"(",
"REG_FRAME_RELATED_EXPR",
",",
"x",
",",
"NULL",
")",
";",
"REG_NOTES",
"(",
"insn",
")",
"=",
"x",
";",
"}",
"if",
"(",
"frame_pointer_needed",
")",
"{",
"insn",
"=",
"emit_insn",
"(",
"gen_push",
"(",
"hard_frame_pointer_rtx",
")",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"<NUM_LIT>",
";",
"insn",
"=",
"emit_move_insn",
"(",
"hard_frame_pointer_rtx",
",",
"stack_pointer_rtx",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"<NUM_LIT>",
";",
"}",
"allocate",
"=",
"frame",
".",
"to_allocate",
";",
"if",
"(",
"!",
"frame",
".",
"save_regs_using_mov",
")",
"ix86_emit_save_regs",
"(",
")",
";",
"else",
"allocate",
"+=",
"frame",
".",
"nregs",
"*",
"UNITS_PER_WORD",
";",
"if",
"(",
"TARGET_RED_ZONE",
"&&",
"frame",
".",
"save_regs_using_mov",
")",
"ix86_emit_save_regs_using_mov",
"(",
"frame_pointer_needed",
"?",
"hard_frame_pointer_rtx",
":",
"stack_pointer_rtx",
",",
"-",
"frame",
".",
"nregs",
"*",
"UNITS_PER_WORD",
")",
";",
"if",
"(",
"allocate",
"==",
"<NUM_LIT>",
")",
";",
"else",
"if",
"(",
"!",
"TARGET_STACK_PROBE",
"||",
"allocate",
"<",
"CHECK_STACK_LIMIT",
")",
"pro_epilogue_adjust_stack",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"GEN_INT",
"(",
"-",
"allocate",
")",
",",
"-",
"<NUM_LIT>",
")",
";",
"else",
"{",
"rtx",
"eax",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"<NUM_LIT>",
")",
";",
"bool",
"eax_live",
"=",
"ix86_eax_live_at_start_p",
"(",
")",
";",
"rtx",
"t",
";",
"gcc_assert",
"(",
"!",
"TARGET_64BIT",
")",
";",
"if",
"(",
"eax_live",
")",
"{",
"emit_insn",
"(",
"gen_push",
"(",
"eax",
")",
")",
";",
"allocate",
"-=",
"<NUM_LIT>",
";",
"}",
"emit_move_insn",
"(",
"eax",
",",
"GEN_INT",
"(",
"allocate",
")",
")",
";",
"insn",
"=",
"emit_insn",
"(",
"gen_allocate_stack_worker",
"(",
"eax",
")",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"<NUM_LIT>",
";",
"t",
"=",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"GEN_INT",
"(",
"-",
"allocate",
")",
")",
";",
"t",
"=",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"stack_pointer_rtx",
",",
"t",
")",
";",
"REG_NOTES",
"(",
"insn",
")",
"=",
"gen_rtx_EXPR_LIST",
"(",
"REG_FRAME_RELATED_EXPR",
",",
"t",
",",
"REG_NOTES",
"(",
"insn",
")",
")",
";",
"if",
"(",
"eax_live",
")",
"{",
"if",
"(",
"frame_pointer_needed",
")",
"t",
"=",
"plus_constant",
"(",
"hard_frame_pointer_rtx",
",",
"allocate",
"-",
"frame",
".",
"to_allocate",
"-",
"frame",
".",
"nregs",
"*",
"UNITS_PER_WORD",
")",
";",
"else",
"t",
"=",
"plus_constant",
"(",
"stack_pointer_rtx",
",",
"allocate",
")",
";",
"emit_move_insn",
"(",
"eax",
",",
"gen_rtx_MEM",
"(",
"SImode",
",",
"t",
")",
")",
";",
"}",
"}",
"if",
"(",
"frame",
".",
"save_regs_using_mov",
"&&",
"!",
"TARGET_RED_ZONE",
")",
"{",
"if",
"(",
"!",
"frame_pointer_needed",
"||",
"!",
"frame",
".",
"to_allocate",
")",
"ix86_emit_save_regs_using_mov",
"(",
"stack_pointer_rtx",
",",
"frame",
".",
"to_allocate",
")",
";",
"else",
"ix86_emit_save_regs_using_mov",
"(",
"hard_frame_pointer_rtx",
",",
"-",
"frame",
".",
"nregs",
"*",
"UNITS_PER_WORD",
")",
";",
"}",
"pic_reg_used",
"=",
"false",
";",
"if",
"(",
"pic_offset_table_rtx",
"&&",
"(",
"regs_ever_live",
"[",
"REAL_PIC_OFFSET_TABLE_REGNUM",
"]",
"||",
"current_function_profile",
")",
")",
"{",
"unsigned",
"int",
"alt_pic_reg_used",
"=",
"ix86_select_alt_pic_regnum",
"(",
")",
";",
"if",
"(",
"alt_pic_reg_used",
"!=",
"INVALID_REGNUM",
")",
"REGNO",
"(",
"pic_offset_table_rtx",
")",
"=",
"alt_pic_reg_used",
";"
] |
GCC | mips | MD | next_suggestion | CPU | 25 | [
"<STR_LIT>",
")"
] | [
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")"
] |
LLVM | WebAssembly | CPP | next_suggestion | Virtual ISA | 26 | [
"case",
"WebAssembly",
"::",
"ATOMIC_RMW_SUB_I64_S",
":"
] | [
"case",
"WebAssembly",
"::",
"ATOMIC_LOAD8_U_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_LOAD8_U_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_LOAD8_U_I64_S",
":",
"case",
"WebAssembly",
"::",
"STORE8_I32",
":",
"case",
"WebAssembly",
"::",
"STORE8_I32_S",
":",
"case",
"WebAssembly",
"::",
"STORE8_I64",
":",
"case",
"WebAssembly",
"::",
"STORE8_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_STORE8_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_STORE8_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_STORE8_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_STORE8_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_ADD_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_ADD_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_ADD_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_ADD_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_SUB_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_SUB_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_SUB_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_SUB_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_AND_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_AND_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_AND_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_AND_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_OR_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_OR_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_OR_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_OR_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_XOR_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_XOR_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_XOR_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_XOR_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_XCHG_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_XCHG_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_XCHG_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW8_U_XCHG_I64_S",
":",
"return",
"<NUM_LIT>",
";",
"case",
"WebAssembly",
"::",
"LOAD16_S_I32",
":",
"case",
"WebAssembly",
"::",
"LOAD16_S_I32_S",
":",
"case",
"WebAssembly",
"::",
"LOAD16_U_I32",
":",
"case",
"WebAssembly",
"::",
"LOAD16_U_I32_S",
":",
"case",
"WebAssembly",
"::",
"LOAD16_S_I64",
":",
"case",
"WebAssembly",
"::",
"LOAD16_S_I64_S",
":",
"case",
"WebAssembly",
"::",
"LOAD16_U_I64",
":",
"case",
"WebAssembly",
"::",
"LOAD16_U_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_LOAD16_U_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_LOAD16_U_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_LOAD16_U_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_LOAD16_U_I64_S",
":",
"case",
"WebAssembly",
"::",
"STORE16_I32",
":",
"case",
"WebAssembly",
"::",
"STORE16_I32_S",
":",
"case",
"WebAssembly",
"::",
"STORE16_I64",
":",
"case",
"WebAssembly",
"::",
"STORE16_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_STORE16_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_STORE16_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_STORE16_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_STORE16_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_ADD_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_ADD_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_ADD_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_ADD_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_SUB_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_SUB_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_SUB_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_SUB_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_AND_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_AND_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_AND_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_AND_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_OR_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_OR_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_OR_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_OR_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_XOR_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_XOR_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_XOR_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_XOR_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_XCHG_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_XCHG_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_XCHG_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW16_U_XCHG_I64_S",
":",
"return",
"<NUM_LIT>",
";",
"case",
"WebAssembly",
"::",
"LOAD_I32",
":",
"case",
"WebAssembly",
"::",
"LOAD_I32_S",
":",
"case",
"WebAssembly",
"::",
"LOAD_F32",
":",
"case",
"WebAssembly",
"::",
"LOAD_F32_S",
":",
"case",
"WebAssembly",
"::",
"STORE_I32",
":",
"case",
"WebAssembly",
"::",
"STORE_I32_S",
":",
"case",
"WebAssembly",
"::",
"STORE_F32",
":",
"case",
"WebAssembly",
"::",
"STORE_F32_S",
":",
"case",
"WebAssembly",
"::",
"LOAD32_S_I64",
":",
"case",
"WebAssembly",
"::",
"LOAD32_S_I64_S",
":",
"case",
"WebAssembly",
"::",
"LOAD32_U_I64",
":",
"case",
"WebAssembly",
"::",
"LOAD32_U_I64_S",
":",
"case",
"WebAssembly",
"::",
"STORE32_I64",
":",
"case",
"WebAssembly",
"::",
"STORE32_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_LOAD_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_LOAD_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_LOAD32_U_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_LOAD32_U_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_STORE_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_STORE_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_STORE32_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_STORE32_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW_ADD_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW_ADD_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW32_U_ADD_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW32_U_ADD_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW_SUB_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW_SUB_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW32_U_SUB_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW32_U_SUB_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW_AND_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW_AND_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW32_U_AND_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW32_U_AND_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW_OR_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW_OR_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW32_U_OR_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW32_U_OR_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW_XOR_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW_XOR_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW32_U_XOR_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW32_U_XOR_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW_XCHG_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW_XCHG_I32_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW32_U_XCHG_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW32_U_XCHG_I64_S",
":",
"return",
"<NUM_LIT>",
";",
"case",
"WebAssembly",
"::",
"LOAD_I64",
":",
"case",
"WebAssembly",
"::",
"LOAD_I64_S",
":",
"case",
"WebAssembly",
"::",
"LOAD_F64",
":",
"case",
"WebAssembly",
"::",
"LOAD_F64_S",
":",
"case",
"WebAssembly",
"::",
"STORE_I64",
":",
"case",
"WebAssembly",
"::",
"STORE_I64_S",
":",
"case",
"WebAssembly",
"::",
"STORE_F64",
":",
"case",
"WebAssembly",
"::",
"STORE_F64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_LOAD_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_LOAD_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_STORE_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_STORE_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW_ADD_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW_ADD_I64_S",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_RMW_SUB_I64",
":"
] |
LLVM | X86 | CPP | stmt_completion | CPU | 27 | [
"N",
")",
";"
] | [
"assert",
"(",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
"==",
"N",
"->",
"getOpcode",
"(",
")",
"||",
"<STR_LIT>",
"::",
"<STR_LIT>",
"==",
"N",
"->",
"getOpcode",
"(",
")",
"||",
"<STR_LIT>",
"::",
"<STR_LIT>",
"==",
"N",
"->",
"getOpcode",
"(",
")",
"||",
"<STR_LIT>",
"::",
"<STR_LIT>",
"==",
"N",
"->",
"getOpcode",
"(",
")",
")",
"&&",
"<STR_LIT>",
"Unexpected horizontal add/sub opcode",
"<STR_LIT>",
")",
";",
"if",
"(",
"!",
"shouldUseHorizontalOp",
"(",
"true",
",",
"DAG",
",",
"Subtarget",
")",
")",
"{",
"MVT",
"VT",
"=",
"N",
"->",
"getSimpleValueType",
"(",
"<NUM_LIT>",
")",
";",
"SDValue",
"LHS",
"=",
"N",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"SDValue",
"RHS",
"=",
"N",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"LHS",
"!=",
"RHS",
"&&",
"LHS",
".",
"getOpcode",
"(",
")",
"==",
"N",
"->",
"getOpcode",
"(",
")",
"&&",
"LHS",
".",
"getOpcode",
"(",
")",
"==",
"RHS",
".",
"getOpcode",
"(",
")",
"&&",
"LHS",
".",
"getValueType",
"(",
")",
"==",
"RHS",
".",
"getValueType",
"(",
")",
"&&",
"N",
"->",
"isOnlyUserOf",
"(",
"LHS",
".",
"getNode",
"(",
")",
")",
"&&",
"N",
"->",
"isOnlyUserOf",
"(",
"RHS",
".",
"getNode",
"(",
")",
")",
")",
"{",
"SDValue",
"LHS0",
"=",
"LHS",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"SDValue",
"LHS1",
"=",
"LHS",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"SDValue",
"RHS0",
"=",
"RHS",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"SDValue",
"RHS1",
"=",
"RHS",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"(",
"LHS0",
"==",
"LHS1",
"||",
"LHS0",
".",
"isUndef",
"(",
")",
"||",
"LHS1",
".",
"isUndef",
"(",
")",
")",
"&&",
"(",
"RHS0",
"==",
"RHS1",
"||",
"RHS0",
".",
"isUndef",
"(",
")",
"||",
"RHS1",
".",
"isUndef",
"(",
")",
")",
")",
"{",
"SDLoc",
"DL",
"("
] |
LLVM | SPIRV | CPP | stmt_completion | Virtual ISA | 28 | [
")",
";"
] | [
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")"
] |
LLVM | ARM | TD | stmt_completion | CPU | 29 | [
"]",
">",
";"
] | [
"def",
"VST4d16Pseudo",
":",
"VSTQQPseudo",
"<",
"IIC_VST4",
">",
",",
"Sched",
"<",
"[",
"WriteVST4"
] |
LLVM | TriCore | CPP | next_suggestion | MPU | 30 | [
"if",
"(",
"Base",
".",
"getReg",
"(",
")",
")",
"O",
"<<",
"<STR_LIT>",
"[%",
"<STR_LIT>",
"<<",
"StringRef",
"(",
"getRegisterName",
"(",
"Base",
".",
"getReg",
"(",
")",
")",
")",
".",
"lower",
"(",
")",
"<<",
"'",
"]",
"'",
";"
] | [
"const",
"MCOperand",
"&",
"Base",
"=",
"MI",
"->",
"getOperand",
"(",
"OpNum",
")",
";",
"const",
"MCOperand",
"&",
"Disp",
"=",
"MI",
"->",
"getOperand",
"(",
"OpNum",
"+",
"<NUM_LIT>",
")",
";"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 31 | [
"}"
] | [
"SDValue",
"P",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SIGN_EXTEND",
",",
"dl",
",",
"DstVT",
",",
"Op0",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SINT_TO_FP",
",",
"dl",
",",
"N",
"->",
"getValueType",
"(",
"<NUM_LIT>",
")",
",",
"P",
")",
";",
"}",
"if",
"(",
"Op0",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"LOAD",
")",
"{",
"LoadSDNode",
"*",
"Ld",
"=",
"cast",
"<",
"LoadSDNode",
">",
"(",
"Op0",
".",
"getNode",
"(",
")",
")",
";",
"EVT",
"VT",
"=",
"Ld",
"->",
"getValueType",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"!",
"Ld",
"->",
"isVolatile",
"(",
")",
"&&",
"!",
"N",
"->",
"getValueType",
"(",
"<NUM_LIT>",
")",
".",
"isVector",
"(",
")",
"&&",
"ISD",
"::",
"isNON_EXTLoad",
"(",
"Op0",
".",
"getNode",
"(",
")",
")",
"&&",
"Op0",
".",
"hasOneUse",
"(",
")",
"&&",
"!",
"XTLI",
"->",
"getSubtarget",
"(",
")",
"->",
"is64Bit",
"(",
")",
"&&",
"VT",
"==",
"MVT",
"::",
"i64",
")",
"{",
"SDValue",
"FILDChain",
"=",
"XTLI",
"->",
"BuildFILD",
"(",
"SDValue",
"(",
"N",
",",
"<NUM_LIT>",
")",
",",
"Ld",
"->",
"getValueType",
"(",
"<NUM_LIT>",
")",
",",
"Ld",
"->",
"getChain",
"(",
")",
",",
"Op0",
",",
"DAG",
")",
";",
"DAG",
".",
"ReplaceAllUsesOfValueWith",
"(",
"Op0",
".",
"getValue",
"(",
"<NUM_LIT>",
")",
",",
"FILDChain",
".",
"getValue",
"(",
"<NUM_LIT>",
")",
")",
";",
"return",
"FILDChain",
";",
"}"
] |
LLVM | AArch64 | CPP | stmt_completion | CPU | 32 | [
"getValue",
"(",
")",
")",
";"
] | [
"void",
"AArch64InstructionSelector",
"::",
"renderTruncImm",
"(",
"MachineInstrBuilder",
"&",
"MIB",
",",
"const",
"MachineInstr",
"&",
"MI",
",",
"int",
"OpIdx",
")",
"const",
"{",
"const",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
"->",
"getRegInfo",
"(",
")",
";",
"assert",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"TargetOpcode",
"::",
"G_CONSTANT",
"&&",
"OpIdx",
"==",
"-",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Expected G_CONSTANT",
"<STR_LIT>",
")",
";",
"Optional",
"<",
"int64_t",
">",
"CstVal",
"=",
"getConstantVRegSExtVal",
"(",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
",",
"MRI",
")",
";",
"assert",
"(",
"CstVal",
"&&",
"<STR_LIT>",
"Expected constant value",
"<STR_LIT>",
")",
";",
"MIB",
".",
"addImm",
"(",
"CstVal",
"."
] |
LLVM | Hexagon | CPP | next_suggestion | DSP | 33 | [
"return",
"Changed",
";"
] | [
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"E",
",",
"NextI",
";",
"for",
"(",
"I",
"=",
"B",
".",
"begin",
"(",
")",
",",
"E",
"=",
"B",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"I",
"=",
"NextI",
")",
"{",
"NextI",
"=",
"std",
"::",
"next",
"(",
"I",
")",
";",
"if",
"(",
"isCondset",
"(",
"*",
"I",
")",
")",
"Changed",
"|=",
"split",
"(",
"*",
"I",
",",
"UpdRegs",
")",
";",
"}"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 34 | [
">",
",",
"Enc_454a26",
"{"
] | [
"def",
"C2_andn",
":",
"HInst",
"<",
"(",
"outs",
"PredRegs",
":",
"$",
"Pd4",
")",
",",
"(",
"ins",
"PredRegs",
":",
"$",
"Pt4",
",",
"PredRegs",
":",
"$",
"Ps4",
")",
",",
"<STR_LIT>",
",",
"tc_640086b5",
",",
"TypeCR"
] |
LLVM | ARM | TD | next_suggestion | CPU | 35 | [
"let",
"unsignedFlag",
"=",
"(",
"?",
"(",
"i32",
"VTI",
".",
"Unsigned",
")",
")",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"imm",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"VTI",
"=",
"VTI_",
";",
"let",
"immediateType",
"=",
"immType",
";"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 36 | [
"}"
] | [
"void",
"ARMTargetLowering",
"::",
"addMVEVectorTypes",
"(",
"bool",
"HasMVEFP",
")",
"{",
"const",
"MVT",
"IntTypes",
"[",
"]",
"=",
"{",
"MVT",
"::",
"v16i8",
",",
"MVT",
"::",
"v8i16",
",",
"MVT",
"::",
"v4i32",
"}",
";",
"for",
"(",
"auto",
"VT",
":",
"IntTypes",
")",
"{",
"addRegisterClass",
"(",
"VT",
",",
"&",
"ARM",
"::",
"QPRRegClass",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"VECTOR_SHUFFLE",
",",
"VT",
",",
"Custom",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"INSERT_VECTOR_ELT",
",",
"VT",
",",
"Custom",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"EXTRACT_VECTOR_ELT",
",",
"VT",
",",
"Custom",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"BUILD_VECTOR",
",",
"VT",
",",
"Custom",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"SHL",
",",
"VT",
",",
"Custom",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"SRA",
",",
"VT",
",",
"Custom",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"SRL",
",",
"VT",
",",
"Custom",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"SMIN",
",",
"VT",
",",
"Legal",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"SMAX",
",",
"VT",
",",
"Legal",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"UMIN",
",",
"VT",
",",
"Legal",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"UMAX",
",",
"VT",
",",
"Legal",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"ABS",
",",
"VT",
",",
"Legal",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"UDIV",
",",
"VT",
",",
"Expand",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"SDIV",
",",
"VT",
",",
"Expand",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"UREM",
",",
"VT",
",",
"Expand",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"SREM",
",",
"VT",
",",
"Expand",
")",
";",
"if",
"(",
"!",
"HasMVEFP",
")",
"{",
"setOperationAction",
"(",
"ISD",
"::",
"SINT_TO_FP",
",",
"VT",
",",
"Expand",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"UINT_TO_FP",
",",
"VT",
",",
"Expand",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"FP_TO_SINT",
",",
"VT",
",",
"Expand",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"FP_TO_UINT",
",",
"VT",
",",
"Expand",
")",
";",
"}"
] |
LLVM | AArch64 | TD | stmt_completion | CPU | 37 | [
":",
"$",
"Rm",
")",
")",
")",
")",
"]",
">",
";"
] | [
"def",
"v2i32",
":",
"BaseSIMDThreeSameVector",
"<",
"<NUM_LIT>",
",",
"U",
",",
"<NUM_LIT>",
",",
"opc",
",",
"V64",
",",
"asm",
",",
"<STR_LIT>",
",",
"[",
"(",
"set",
"V64",
":",
"$",
"Rd",
",",
"(",
"v2i32",
"(",
"OpNode",
"(",
"v2i32",
"V64",
":",
"$",
"Rn",
")",
",",
"(",
"v2i32",
"V64"
] |
LLVM | ARM | TD | stmt_completion | CPU | 38 | [
"v2i32",
",",
"VectorIndex32",
">",
"{"
] | [
"def",
"VDUPLN32d",
":",
"VDUPLND",
"<",
"{",
"?",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
"}",
",",
"<STR_LIT>",
",",
"<STR_LIT>",
","
] |
GCC | gcn | CPP | stmt_completion | GPU | 39 | [
"<STR_LIT>",
")",
";"
] | [
"exit",
"(",
"<NUM_LIT>",
")",
";",
"}",
"DLSYM_FN",
"(",
"hsa_status_string",
")",
"DLSYM_FN",
"(",
"hsa_agent_get_info",
")",
"DLSYM_FN",
"(",
"hsa_init",
")",
"DLSYM_FN",
"(",
"hsa_iterate_agents",
")",
"DLSYM_FN",
"(",
"hsa_region_get_info",
")",
"DLSYM_FN",
"(",
"hsa_queue_create",
")",
"DLSYM_FN",
"(",
"hsa_agent_iterate_regions",
")",
"DLSYM_FN",
"(",
"hsa_executable_destroy",
")",
"DLSYM_FN",
"(",
"hsa_executable_create",
")",
"DLSYM_FN",
"(",
"hsa_executable_global_variable_define",
")",
"DLSYM_FN",
"(",
"hsa_executable_load_code_object",
")",
"DLSYM_FN",
"(",
"hsa_executable_freeze",
")",
"DLSYM_FN",
"(",
"hsa_signal_create",
")",
"DLSYM_FN",
"(",
"hsa_memory_allocate",
")",
"DLSYM_FN",
"(",
"hsa_memory_copy",
")",
"DLSYM_FN",
"(",
"hsa_memory_free",
")",
"DLSYM_FN",
"(",
"hsa_signal_destroy",
")",
"DLSYM_FN",
"(",
"hsa_executable_get_symbol",
")",
"DLSYM_FN",
"(",
"hsa_executable_symbol_get_info",
")",
"DLSYM_FN",
"(",
"hsa_signal_wait_acquire",
")",
"DLSYM_FN",
"(",
"hsa_signal_wait_relaxed",
")",
"DLSYM_FN",
"(",
"hsa_signal_store_relaxed",
")",
"DLSYM_FN",
"(",
"hsa_queue_destroy",
")",
"DLSYM_FN",
"(",
"hsa_code_object_deserialize",
")",
"DLSYM_FN",
"(",
"hsa_queue_load_write_index_relaxed",
")",
"DLSYM_FN",
"(",
"hsa_queue_store_write_index_relaxed",
")",
"DLSYM_FN",
"(",
"hsa_shut_down",
")",
"return",
";",
"fail",
":",
"fprintf",
"(",
"stderr",
",",
"<STR_LIT>",
"Failed to find HSA functions in ",
"<STR_LIT>",
"HSA_RUNTIME_LIB",
"<STR_LIT>",
"\\n"
] |
GCC | aarch64 | CPP | stmt_completion | CPU | 40 | [
")",
";"
] | [
"void",
"aarch64_gen_atomic_cas",
"(",
"rtx",
"rval",
",",
"rtx",
"mem",
",",
"rtx",
"expected",
",",
"rtx",
"desired",
",",
"rtx",
"model",
")",
"{",
"rtx",
"(",
"*",
"gen",
")",
"(",
"rtx",
",",
"rtx",
",",
"rtx",
",",
"rtx",
")",
";",
"machine_mode",
"mode",
";",
"mode",
"=",
"GET_MODE",
"(",
"mem",
")",
";",
"switch",
"(",
"mode",
")",
"{",
"case",
"QImode",
":",
"gen",
"=",
"gen_aarch64_atomic_casqi",
";",
"break",
";",
"case",
"HImode",
":",
"gen",
"=",
"gen_aarch64_atomic_cashi",
";",
"break",
";",
"case",
"SImode",
":",
"gen",
"=",
"gen_aarch64_atomic_cassi",
";",
"break",
";",
"case",
"DImode",
":",
"gen",
"=",
"gen_aarch64_atomic_casdi",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"rval",
",",
"expected",
")",
")",
";",
"emit_insn",
"(",
"gen",
"(",
"rval",
",",
"mem",
",",
"desired",
",",
"model",
")",
")",
";",
"aarch64_gen_compare_reg",
"(",
"EQ",
",",
"rval",
",",
"expected"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 41 | [
"let",
"isTaken",
"=",
"Inst",
"{",
"<NUM_LIT>",
"}",
";"
] | [
"let",
"isBranch",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicatedNew",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax1",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax2",
"=",
"<NUM_LIT>",
";",
"let",
"cofMax1",
"=",
"<NUM_LIT>",
";",
"let",
"Defs",
"=",
"[",
"PC",
"]",
";",
"let",
"InputType",
"=",
"<STR_LIT>",
";",
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";"
] |
GCC | epiphany | MD | stmt_completion | MPU | 42 | [
"QI",
"V2HI",
"V4QI",
"]",
")"
] | [
"(",
"define_mode_iterator",
"WMODE",
"[",
"SI",
"SF",
"HI",
"QI",
"V2HI",
"V4QI",
"]",
")",
"(",
"define_mode_iterator",
"WMODE2",
"[",
"SI",
"SF",
"HI"
] |
GCC | aarch64 | CPP | stmt_completion | CPU | 43 | [
"<STR_LIT>",
"w",
"<STR_LIT>",
"(",
"a",
")",
":",
")",
";"
] | [
"_",
"_",
"asm__",
"(",
"<STR_LIT>",
"saddlv %d0,%1.4s",
"<STR_LIT>",
":",
"<STR_LIT>",
"=w",
"<STR_LIT>",
"(",
"result",
")",
":"
] |
GCC | m68k | MD | next_suggestion | MPU | 44 | [
"if",
"(",
"REGNO",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
"=",
"=",
"REGNO",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
")"
] | [
"<STR_LIT>",
"{",
"if",
"(",
"FP_REG_P",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
"&",
"&",
"FP_REG_P",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
")",
"{"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 45 | [
"if",
"(",
"VA",
".",
"getLocReg",
"(",
")",
"==",
"X86",
"::",
"FP0",
"||",
"VA",
".",
"getLocReg",
"(",
")",
"==",
"X86",
"::",
"FP1",
")",
"return",
"false",
";"
] | [
"CallingConv",
"::",
"ID",
"CC",
"=",
"F",
".",
"getCallingConv",
"(",
")",
";",
"if",
"(",
"CC",
"!=",
"CallingConv",
"::",
"C",
"&&",
"CC",
"!=",
"CallingConv",
"::",
"Fast",
"&&",
"CC",
"!=",
"CallingConv",
"::",
"Tail",
"&&",
"CC",
"!=",
"CallingConv",
"::",
"SwiftTail",
"&&",
"CC",
"!=",
"CallingConv",
"::",
"X86_FastCall",
"&&",
"CC",
"!=",
"CallingConv",
"::",
"X86_StdCall",
"&&",
"CC",
"!=",
"CallingConv",
"::",
"X86_ThisCall",
"&&",
"CC",
"!=",
"CallingConv",
"::",
"X86_64_SysV",
"&&",
"CC",
"!=",
"CallingConv",
"::",
"Win64",
")",
"return",
"false",
";",
"if",
"(",
"!",
"isUInt",
"<",
"<NUM_LIT>",
">",
"(",
"X86MFInfo",
"->",
"getBytesToPopOnReturn",
"(",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"(",
"CC",
"==",
"CallingConv",
"::",
"Fast",
"&&",
"TM",
".",
"Options",
".",
"GuaranteedTailCallOpt",
")",
"||",
"CC",
"==",
"CallingConv",
"::",
"Tail",
"||",
"CC",
"==",
"CallingConv",
"::",
"SwiftTail",
")",
"return",
"false",
";",
"if",
"(",
"F",
".",
"isVarArg",
"(",
")",
")",
"return",
"false",
";",
"SmallVector",
"<",
"unsigned",
",",
"<NUM_LIT>",
">",
"RetRegs",
";",
"if",
"(",
"Ret",
"->",
"getNumOperands",
"(",
")",
">",
"<NUM_LIT>",
")",
"{",
"SmallVector",
"<",
"ISD",
"::",
"OutputArg",
",",
"<NUM_LIT>",
">",
"Outs",
";",
"GetReturnInfo",
"(",
"CC",
",",
"F",
".",
"getReturnType",
"(",
")",
",",
"F",
".",
"getAttributes",
"(",
")",
",",
"Outs",
",",
"TLI",
",",
"DL",
")",
";",
"SmallVector",
"<",
"CCValAssign",
",",
"<NUM_LIT>",
">",
"ValLocs",
";",
"CCState",
"CCInfo",
"(",
"CC",
",",
"F",
".",
"isVarArg",
"(",
")",
",",
"*",
"FuncInfo",
".",
"MF",
",",
"ValLocs",
",",
"I",
"->",
"getContext",
"(",
")",
")",
";",
"CCInfo",
".",
"AnalyzeReturn",
"(",
"Outs",
",",
"RetCC_X86",
")",
";",
"const",
"Value",
"*",
"RV",
"=",
"Ret",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"Register",
"Reg",
"=",
"getRegForValue",
"(",
"RV",
")",
";",
"if",
"(",
"Reg",
"==",
"<NUM_LIT>",
")",
"return",
"false",
";",
"if",
"(",
"ValLocs",
".",
"size",
"(",
")",
"!=",
"<NUM_LIT>",
")",
"return",
"false",
";",
"CCValAssign",
"&",
"VA",
"=",
"ValLocs",
"[",
"<NUM_LIT>",
"]",
";",
"if",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"!=",
"CCValAssign",
"::",
"Full",
")",
"return",
"false",
";",
"if",
"(",
"!",
"VA",
".",
"isRegLoc",
"(",
")",
")",
"return",
"false",
";"
] |
LLVM | PowerPC | CPP | stmt_completion | CPU | 46 | [
"NewCallSeqStart",
";"
] | [
"ISD",
"::",
"ArgFlagsTy",
"ArgFlags",
"=",
"Outs",
"[",
"i",
"]",
".",
"Flags",
";",
"bool",
"Result",
";",
"if",
"(",
"Outs",
"[",
"i",
"]",
".",
"IsFixed",
")",
"{",
"Result",
"=",
"CC_PPC32_SVR4",
"(",
"i",
",",
"ArgVT",
",",
"ArgVT",
",",
"CCValAssign",
"::",
"Full",
",",
"ArgFlags",
",",
"CCInfo",
")",
";",
"}",
"else",
"{",
"Result",
"=",
"CC_PPC32_SVR4_VarArg",
"(",
"i",
",",
"ArgVT",
",",
"ArgVT",
",",
"CCValAssign",
"::",
"Full",
",",
"ArgFlags",
",",
"CCInfo",
")",
";",
"}",
"if",
"(",
"Result",
")",
"{",
"errs",
"(",
")",
"<<",
"<STR_LIT>",
"Call operand #",
"<STR_LIT>",
"<<",
"i",
"<<",
"<STR_LIT>",
" has unhandled type ",
"<STR_LIT>",
"<<",
"EVT",
"(",
"ArgVT",
")",
".",
"getEVTString",
"(",
")",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
";",
"llvm_unreachable",
"(",
"<NUM_LIT>",
")",
";",
"}",
"}",
"}",
"else",
"{",
"CCInfo",
".",
"AnalyzeCallOperands",
"(",
"Outs",
",",
"CC_PPC32_SVR4",
")",
";",
"}",
"SmallVector",
"<",
"CCValAssign",
",",
"<NUM_LIT>",
">",
"ByValArgLocs",
";",
"CCState",
"CCByValInfo",
"(",
"CallConv",
",",
"isVarArg",
",",
"DAG",
".",
"getMachineFunction",
"(",
")",
",",
"getTargetMachine",
"(",
")",
",",
"ByValArgLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"CCByValInfo",
".",
"AllocateStack",
"(",
"CCInfo",
".",
"getNextStackOffset",
"(",
")",
",",
"PtrByteSize",
")",
";",
"CCByValInfo",
".",
"AnalyzeCallOperands",
"(",
"Outs",
",",
"CC_PPC32_SVR4_ByVal",
")",
";",
"unsigned",
"NumBytes",
"=",
"CCByValInfo",
".",
"getNextStackOffset",
"(",
")",
";",
"int",
"SPDiff",
"=",
"CalculateTailCallSPDiff",
"(",
"DAG",
",",
"isTailCall",
",",
"NumBytes",
")",
";",
"Chain",
"=",
"DAG",
".",
"getCALLSEQ_START",
"(",
"Chain",
",",
"DAG",
".",
"getIntPtrConstant",
"(",
"NumBytes",
",",
"true",
")",
")",
";",
"SDValue",
"CallSeqStart",
"=",
"Chain",
";",
"SDValue",
"LROp",
",",
"FPOp",
";",
"Chain",
"=",
"EmitTailCallLoadFPAndRetAddr",
"(",
"DAG",
",",
"SPDiff",
",",
"Chain",
",",
"LROp",
",",
"FPOp",
",",
"false",
",",
"dl",
")",
";",
"SDValue",
"StackPtr",
"=",
"DAG",
".",
"getRegister",
"(",
"PPC",
"::",
"R1",
",",
"MVT",
"::",
"i32",
")",
";",
"SmallVector",
"<",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"SDValue",
">",
",",
"<NUM_LIT>",
">",
"RegsToPass",
";",
"SmallVector",
"<",
"TailCallArgumentInfo",
",",
"<NUM_LIT>",
">",
"TailCallArguments",
";",
"SmallVector",
"<",
"SDValue",
",",
"<NUM_LIT>",
">",
"MemOpChains",
";",
"bool",
"seenFloatArg",
"=",
"false",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
",",
"j",
"=",
"<NUM_LIT>",
",",
"e",
"=",
"ArgLocs",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"CCValAssign",
"&",
"VA",
"=",
"ArgLocs",
"[",
"i",
"]",
";",
"SDValue",
"Arg",
"=",
"OutVals",
"[",
"i",
"]",
";",
"ISD",
"::",
"ArgFlagsTy",
"Flags",
"=",
"Outs",
"[",
"i",
"]",
".",
"Flags",
";",
"if",
"(",
"Flags",
".",
"isByVal",
"(",
")",
")",
"{",
"assert",
"(",
"(",
"j",
"<",
"ByValArgLocs",
".",
"size",
"(",
")",
")",
"&&",
"<STR_LIT>",
"Index out of bounds!",
"<STR_LIT>",
")",
";",
"CCValAssign",
"&",
"ByValVA",
"=",
"ByValArgLocs",
"[",
"j",
"++",
"]",
";",
"assert",
"(",
"(",
"VA",
".",
"getValNo",
"(",
")",
"==",
"ByValVA",
".",
"getValNo",
"(",
")",
")",
"&&",
"<STR_LIT>",
"ValNo mismatch!",
"<STR_LIT>",
")",
";",
"unsigned",
"LocMemOffset",
"=",
"ByValVA",
".",
"getLocMemOffset",
"(",
")",
";",
"SDValue",
"PtrOff",
"=",
"DAG",
".",
"getIntPtrConstant",
"(",
"LocMemOffset",
")",
";",
"PtrOff",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"dl",
",",
"getPointerTy",
"(",
")",
",",
"StackPtr",
",",
"PtrOff",
")",
";",
"SDValue",
"MemcpyCall",
"=",
"CreateCopyOfByValArgument",
"(",
"Arg",
",",
"PtrOff",
",",
"CallSeqStart",
".",
"getNode",
"(",
")",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Flags",
",",
"DAG",
",",
"dl",
")",
";",
"SDValue",
"NewCallSeqStart",
"=",
"DAG",
".",
"getCALLSEQ_START",
"(",
"MemcpyCall",
",",
"CallSeqStart",
".",
"getNode",
"(",
")",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"DAG",
".",
"ReplaceAllUsesWith",
"(",
"CallSeqStart",
".",
"getNode",
"(",
")",
",",
"NewCallSeqStart",
".",
"getNode",
"(",
")",
")",
";",
"Chain",
"=",
"CallSeqStart",
"="
] |
LLVM | ARM | CPP | next_suggestion | CPU | 47 | [
"}"
] | [
"void",
"addProcIFlagsOperands",
"(",
"MCInst",
"&",
"Inst",
",",
"unsigned",
"N",
")",
"const",
"{",
"assert",
"(",
"N",
"==",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Invalid number of operands!",
"<STR_LIT>",
")",
";",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"unsigned",
"(",
"getProcIFlags",
"(",
")",
")",
")",
")",
";"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 48 | [
"<NUM_LIT>",
";"
] | [
"def",
"A2_addsp",
":",
"HInst",
"<",
"(",
"outs",
"DoubleRegs",
":",
"$",
"Rdd32",
")",
",",
"(",
"ins",
"IntRegs",
":",
"$",
"Rs32",
",",
"DoubleRegs",
":",
"$",
"Rtt32",
")",
",",
"<STR_LIT>",
",",
"tc_679309b8",
",",
"TypeALU64",
">",
"{",
"let",
"isPseudo",
"="
] |
GCC | mips | MD | next_suggestion | CPU | 49 | [
"<STR_LIT>"
] | [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"V2HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"unspec",
":",
"V2HI",
"[",
"(",
"match_operand",
":",
"V4QI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
"UNSPEC_PRECEU_PH_QBLA",
")",
")",
"]"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 50 | [
"let",
"opExtentAlign",
"=",
"<NUM_LIT>",
";"
] | [
"def",
"C2_muxii",
":",
"HInst",
"<",
"(",
"outs",
"IntRegs",
":",
"$",
"Rd32",
")",
",",
"(",
"ins",
"PredRegs",
":",
"$",
"Pu4",
",",
"s32_0Imm",
":",
"$",
"Ii",
",",
"s8_0Imm",
":",
"$",
"II",
")",
",",
"<STR_LIT>",
",",
"tc_4c5ba658",
",",
"TypeALU32_2op",
">",
",",
"Enc_830e5d",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"hasNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"opNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
";"
] |
GCC | rs6000 | MD | stmt_completion | CPU | 51 | [
")"
] | [
"(",
"define_predicate",
"<STR_LIT>",
"(",
"and",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>"
] |
LLVM | ARM | TD | next_suggestion | CPU | 52 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rm",
";"
] | [
"bits",
"<",
"<NUM_LIT>",
">",
"Rm",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] |
LLVM | GBZ80 | TD | next_suggestion | MPU | 53 | [
"field",
"bits",
"<",
"<NUM_LIT>",
">",
"Inst",
";"
] | [
"class",
"GBZ80Inst",
"<",
"dag",
"outs",
",",
"dag",
"ins",
",",
"string",
"asmstr",
">",
":",
"Instruction",
"{",
"let",
"Namespace",
"=",
"<STR_LIT>",
";"
] |
GCC | aarch64 | CPP | stmt_completion | CPU | 54 | [
",",
"_",
"_",
"c",
")",
";"
] | [
"return",
"_",
"_",
"builtin_aarch64_simd_bslv16qi_uuuu",
"(",
"_",
"_",
"a",
",",
"_",
"_",
"b"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 55 | [
"=",
"<NUM_LIT>",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax1",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax2",
"=",
"<NUM_LIT>",
";",
"let",
"Defs",
"=",
"[",
"LC1",
",",
"SA1",
"]",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentBits"
] |
LLVM | Mips | CPP | program_repair | CPU | 56 | [
"<FIXS>",
"const",
"GlobalValue",
"*",
"Val",
"=",
"G",
"->",
"getGlobal",
"(",
")",
";",
"InternalLinkage",
"=",
"Val",
"->",
"hasInternalLinkage",
"(",
")",
";",
"<FIXE>",
"<FIXS>",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"Chain",
",",
"FuncInfo",
"->",
"callPtrInfo",
"(",
"Val",
")",
")",
";",
"<FIXE>",
"<FIXS>",
"Callee",
"=",
"getAddrGlobal",
"(",
"G",
",",
"Ty",
",",
"DAG",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"Chain",
",",
"FuncInfo",
"->",
"callPtrInfo",
"(",
"Val",
")",
")",
";",
"<FIXE>",
"<FIXS>",
"Callee",
"=",
"DAG",
".",
"getTargetExternalSymbol",
"(",
"Sym",
",",
"getPointerTy",
"(",
")",
",",
"<FIXE>",
"<FIXS>",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"Chain",
",",
"FuncInfo",
"->",
"callPtrInfo",
"(",
"Sym",
")",
")",
";",
"<FIXE>",
"<FIXS>",
"Callee",
"=",
"getAddrGlobal",
"(",
"S",
",",
"Ty",
",",
"DAG",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"Chain",
",",
"FuncInfo",
"->",
"callPtrInfo",
"(",
"Sym",
")",
")",
";",
"<FIXE>"
] | [
"if",
"(",
"GlobalAddressSDNode",
"*",
"G",
"=",
"dyn_cast",
"GlobalAddressSDNode",
">",
"(",
"Callee",
")",
")",
"{",
"if",
"(",
"IsPICCall",
")",
"{",
"<BUGS>",
"InternalLinkage",
"=",
"G",
"->",
"getGlobal",
"(",
")",
"->",
"hasInternalLinkage",
"(",
")",
";",
"<BUGE>",
"if",
"(",
"InternalLinkage",
")",
"Callee",
"=",
"getAddrLocal",
"(",
"G",
",",
"Ty",
",",
"DAG",
",",
"HasMips64",
")",
";",
"else",
"if",
"(",
"LargeGOT",
")",
"Callee",
"=",
"getAddrGlobalLargeGOT",
"(",
"G",
",",
"Ty",
",",
"DAG",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<BUGS>",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"<BUGE>",
"else",
"<BUGS>",
"Callee",
"=",
"getAddrGlobal",
"(",
"G",
",",
"Ty",
",",
"DAG",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"<BUGE>",
"}",
"elseCallee",
"=",
"DAG",
".",
"getTargetGlobalAddress",
"(",
"G",
"->",
"getGlobal",
"(",
")",
",",
"DL",
",",
"getPointerTy",
"(",
")",
",",
"<NUM_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"GlobalOrExternal",
"=",
"true",
";",
"}",
"else",
"if",
"(",
"ExternalSymbolSDNode",
"*",
"S",
"=",
"dyn_cast",
"ExternalSymbolSDNode",
">",
"(",
"Callee",
")",
")",
"{",
"if",
"(",
"!",
"IsN64",
"&&",
"!",
"IsPIC",
")",
"<BUGS>",
"Callee",
"=",
"DAG",
".",
"getTargetExternalSymbol",
"(",
"S",
"->",
"getSymbol",
"(",
")",
",",
"getPointerTy",
"(",
")",
",",
"<BUGE>",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"else",
"if",
"(",
"LargeGOT",
")",
"Callee",
"=",
"getAddrGlobalLargeGOT",
"(",
"S",
",",
"Ty",
",",
"DAG",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<BUGS>",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"<BUGE>",
"else",
"<BUGS>",
"Callee",
"=",
"getAddrGlobal",
"(",
"S",
",",
"Ty",
",",
"DAG",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"<BUGE>",
"GlobalOrExternal",
"=",
"true",
";",
"}"
] |
GCC | alpha | MD | stmt_completion | MPU | 57 | [
")",
"]"
] | [
"[",
"(",
"set",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"unspec_volatile",
":",
"DI",
"[",
"(",
"const_int",
"<NUM_LIT>",
")",
"]",
"UNSPECV_SC",
")",
")",
"(",
"set",
"(",
"match_operand",
":",
"I48MODE",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"I48MODE",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
GCC | i386 | MD | stmt_completion | CPU | 58 | [
")"
] | [
"(",
"define_reservation",
"<STR_LIT>",
"<STR_LIT>"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 59 | [
"bits",
"<",
"<NUM_LIT>",
">",
"Rs32",
";"
] | [
"class",
"Enc_a1e29d",
":",
"OpcodeHexagon",
"{",
"bits",
"<",
"<NUM_LIT>",
">",
"Ii",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Ii",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"II",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"II",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"II",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";"
] |
GCC | csky | CPP | code_generation | CPU | 60 | [
"static",
"void",
"push_csky_minipool_fix",
"(",
"rtx_insn",
"*",
"insn",
",",
"HOST_WIDE_INT",
"address",
",",
"rtx",
"*",
"loc",
",",
"machine_mode",
"mode",
",",
"rtx",
"value",
")",
"{",
":",
"CSKY_LRW16_RANGE",
")",
"(",
"GET_MODE_SIZE",
"(",
"(",
"mode",
")",
")",
">=",
"<NUM_LIT>",
"?",
"GET_MODE_SIZE",
"(",
"(",
"mode",
")",
")",
":",
"<NUM_LIT>",
")",
"Mfix",
"*",
"fix",
"=",
"(",
"Mfix",
"*",
")",
"obstack_alloc",
"(",
"&",
"minipool_obstack",
",",
"sizeof",
"(",
"*",
"fix",
")",
")",
";",
"fix",
"->",
"insn",
"=",
"insn",
";",
"fix",
"->",
"address",
"=",
"address",
";",
"fix",
"->",
"loc",
"=",
"loc",
";",
"fix",
"->",
"mode",
"=",
"mode",
";",
"fix",
"->",
"fix_size",
"=",
"CSKY_MINIPOOL_FIX_SIZE",
"(",
"mode",
")",
";",
"fix",
"->",
"value",
"=",
"value",
";",
"fix",
"->",
"forwards",
"=",
"CSKY_CONSTANT_POOL_RANGE",
";",
"fix",
"->",
"backwards",
"=",
"<NUM_LIT>",
";",
"fix",
"->",
"minipool",
"=",
"NULL",
";",
"gcc_assert",
"(",
"fix",
"->",
"forwards",
"||",
"fix",
"->",
"backwards",
")",
";",
"if",
"(",
"dump_file",
")",
"{",
"fprintf",
"(",
"dump_file",
",",
"<STR_LIT>",
";; %smode fixup for i%d; addr %lu, range (%ld,%ld): ",
"<STR_LIT>",
",",
"GET_MODE_NAME",
"(",
"mode",
")",
",",
"INSN_UID",
"(",
"insn",
")",
",",
"(",
"unsigned",
"long",
")",
"address",
",",
"-",
"<NUM_LIT>",
"*",
"(",
"long",
")",
"fix",
"->",
"backwards",
",",
"(",
"long",
")",
"fix",
"->",
"forwards",
")",
";",
"print_csky_value",
"(",
"dump_file",
",",
"fix",
"->",
"value",
")",
";",
"fprintf",
"(",
"dump_file",
",",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
")",
";",
"}",
"fix",
"->",
"next",
"=",
"NULL",
";",
"if",
"(",
"minipool_fix_head",
"!=",
"NULL",
")",
"minipool_fix_tail",
"->",
"next",
"=",
"fix",
";",
"else",
"minipool_fix_head",
"=",
"fix",
";",
"minipool_fix_tail",
"=",
"fix",
";",
"}"
] | [
"Record",
"INSN",
",",
"which",
"will",
"need",
"fixing",
"up",
"to",
"load",
"a",
"value",
"from",
"the",
"minipool",
".",
"ADDRESS",
"is",
"the",
"offset",
"of",
"the",
"insn",
"since",
"the",
"start",
"of",
"the",
"function",
";",
"LOC",
"is",
"a",
"pointer",
"to",
"the",
"part",
"of",
"the",
"insn",
"which",
"requires",
"fixing",
";",
"VALUE",
"is",
"the",
"constant",
"that",
"must",
"be",
"loaded",
",",
"which",
"is",
"of",
"type",
"MODE",
"."
] |
LLVM | Hexagon | CPP | next_suggestion | DSP | 61 | [
"return",
"PReg1",
"==",
"PReg2",
"&&",
"Hexagon",
"::",
"PredRegsRegClass",
".",
"contains",
"(",
"PReg1",
")",
"&&",
"Hexagon",
"::",
"PredRegsRegClass",
".",
"contains",
"(",
"PReg2",
")",
"&&",
"getPredicateSense",
"(",
"MI1",
",",
"HII",
")",
"!=",
"getPredicateSense",
"(",
"MI2",
",",
"HII",
")",
"&&",
"HII",
"->",
"isDotNewInst",
"(",
"MI1",
")",
"==",
"HII",
"->",
"isDotNewInst",
"(",
"MI2",
")",
";"
] | [
"bool",
"HexagonPacketizerList",
"::",
"arePredicatesComplements",
"(",
"MachineInstr",
"*",
"MI1",
",",
"MachineInstr",
"*",
"MI2",
")",
"{",
"if",
"(",
"getPredicateSense",
"(",
"MI1",
",",
"HII",
")",
"==",
"PK_Unknown",
"||",
"getPredicateSense",
"(",
"MI2",
",",
"HII",
")",
"==",
"PK_Unknown",
")",
"return",
"false",
";",
"SUnit",
"*",
"SU",
"=",
"MIToSUnit",
"[",
"MI1",
"]",
";",
"for",
"(",
"auto",
"I",
":",
"CurrentPacketMIs",
")",
"{",
"SUnit",
"*",
"PacketSU",
"=",
"MIToSUnit",
".",
"find",
"(",
"I",
")",
"->",
"second",
";",
"if",
"(",
"PacketSU",
"->",
"isSucc",
"(",
"SU",
")",
")",
"{",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"PacketSU",
"->",
"Succs",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"{",
"auto",
"Dep",
"=",
"PacketSU",
"->",
"Succs",
"[",
"i",
"]",
";",
"if",
"(",
"Dep",
".",
"getSUnit",
"(",
")",
"==",
"SU",
"&&",
"Dep",
".",
"getKind",
"(",
")",
"==",
"SDep",
"::",
"Data",
"&&",
"Hexagon",
"::",
"PredRegsRegClass",
".",
"contains",
"(",
"Dep",
".",
"getReg",
"(",
")",
")",
")",
"{",
"if",
"(",
"restrictingDepExistInPacket",
"(",
"I",
",",
"Dep",
".",
"getReg",
"(",
")",
")",
")",
"return",
"false",
";",
"}",
"}",
"}",
"}",
"unsigned",
"PReg1",
"=",
"getPredicatedRegister",
"(",
"MI1",
",",
"HII",
")",
";",
"unsigned",
"PReg2",
"=",
"getPredicatedRegister",
"(",
"MI2",
",",
"HII",
")",
";"
] |
LLVM | X86 | TD | program_repair | CPU | 62 | [
"<FIXS>",
"def",
"_Fp32",
":",
"FpIf32",
"(",
"outs",
"RFP32",
":",
"$",
"dst",
")",
",",
"(",
"ins",
"RFP32",
":",
"$",
"src1",
",",
"RFP32",
":",
"$",
"src2",
")",
",",
"CondMovFP",
",",
"<FIXE>",
"<FIXS>",
"def",
"_Fp64",
":",
"FpIf64",
"(",
"outs",
"RFP64",
":",
"$",
"dst",
")",
",",
"(",
"ins",
"RFP64",
":",
"$",
"src1",
",",
"RFP64",
":",
"$",
"src2",
")",
",",
"CondMovFP",
",",
"<FIXE>"
] | [
"multiclass",
"FPCMov",
"PatLeaf",
"cc",
">",
"{",
"<BUGS>",
"def",
"_Fp32",
":",
"FpI",
"(",
"outs",
"RFP32",
":",
"$",
"dst",
")",
",",
"(",
"ins",
"RFP32",
":",
"$",
"src1",
",",
"RFP32",
":",
"$",
"src2",
")",
",",
"CondMovFP",
",",
"<BUGE>",
"[",
"(",
"set",
"RFP32",
":",
"$",
"dst",
",",
"(",
"X86cmov",
"RFP32",
":",
"$",
"src1",
",",
"RFP32",
":",
"$",
"src2",
",",
"cc",
")",
")",
"]",
">",
";",
"<BUGS>",
"def",
"_Fp64",
":",
"FpI",
"(",
"outs",
"RFP64",
":",
"$",
"dst",
")",
",",
"(",
"ins",
"RFP64",
":",
"$",
"src1",
",",
"RFP64",
":",
"$",
"src2",
")",
",",
"CondMovFP",
",",
"<BUGE>",
"[",
"(",
"set",
"RFP64",
":",
"$",
"dst",
",",
"(",
"X86cmov",
"RFP64",
":",
"$",
"src1",
",",
"RFP64",
":",
"$",
"src2",
",",
"cc",
")",
")",
"]",
">",
";",
"def",
"_Fp80",
":",
"FpI_",
"(",
"outs",
"RFP80",
":",
"$",
"dst",
")",
",",
"(",
"ins",
"RFP80",
":",
"$",
"src1",
",",
"RFP80",
":",
"$",
"src2",
")",
",",
"CondMovFP",
","
] |
LLVM | AArch64 | TD | stmt_completion | CPU | 63 | [
")",
"(",
"v2i32",
"(",
"INSERT_SUBREG",
"(",
"v2i32",
"(",
"IMPLICIT_DEF",
")",
")",
",",
"FPR32Op",
":",
"$",
"Rd",
",",
"ssub",
")",
")",
",",
"V64",
":",
"$",
"Rn",
",",
"V128",
":",
"$",
"Rm",
",",
"VectorIndexS",
":",
"$",
"idx",
")",
")",
",",
"ssub",
")",
">",
";"
] | [
"def",
":",
"Pat",
"<",
"(",
"i32",
"(",
"Accum",
"(",
"i32",
"FPR32Op",
":",
"$",
"Rd",
")",
",",
"(",
"i32",
"(",
"vector_extract",
"(",
"v4i32",
"(",
"insert_subvector",
"(",
"undef",
")",
",",
"(",
"v2i32",
"(",
"int_aarch64_neon_sqrdmulh",
"(",
"v2i32",
"V64",
":",
"$",
"Rn",
")",
",",
"(",
"v2i32",
"(",
"AArch64duplane32",
"(",
"v4i32",
"V128",
":",
"$",
"Rm",
")",
",",
"VectorIndexS",
":",
"$",
"idx",
")",
")",
")",
")",
",",
"(",
"i64",
"<NUM_LIT>",
")",
")",
")",
",",
"(",
"i64",
"<NUM_LIT>",
")",
")",
")",
")",
")",
",",
"(",
"EXTRACT_SUBREG",
"(",
"v2i32",
"(",
"!",
"cast",
"<",
"Instruction",
">",
"(",
"NAME",
"#",
"v2i32_indexed"
] |
LLVM | ECLair | CPP | stmt_completion | MPU | 64 | [
")",
";"
] | [
"const",
"MCExpr",
"*",
"Val",
"=",
"getImm",
"(",
")",
";",
"return",
"static_cast",
"<",
"const",
"MCConstantExpr",
"*",
">",
"(",
"Val",
")",
"->",
"getValue",
"("
] |
LLVM | Hexagon | CPP | next_suggestion | DSP | 65 | [
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
" Add instruction ",
"<STR_LIT>",
"<<",
"*",
"MI",
")",
";"
] | [
"if",
"(",
"!",
"MI",
")",
"return",
";",
"for",
"(",
"const",
"MachineOperand",
"&",
"MO",
":",
"MI",
"->",
"operands",
"(",
")",
")",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
"&&",
"MO",
".",
"isDef",
"(",
")",
"&&",
"!",
"MO",
".",
"isImplicit",
"(",
")",
")",
"RegDefs",
".",
"insert",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"if",
"(",
"TII",
"->",
"isZeroCost",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
")",
"return",
";",
"if",
"(",
"!",
"Resources",
"->",
"canReserveResources",
"(",
"*",
"MI",
")",
"||",
"isNewStore",
"(",
"*",
"MI",
")",
")",
"{",
"assert",
"(",
"TII",
"->",
"mayBeNewStore",
"(",
"*",
"MI",
")",
"&&",
"<STR_LIT>",
"Expecting .new store",
"<STR_LIT>",
")",
";",
"MachineFunction",
"*",
"MF",
"=",
"MI",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"MachineInstr",
"*",
"NewMI",
"=",
"MF",
"->",
"CreateMachineInstr",
"(",
"TII",
"->",
"get",
"(",
"TII",
"->",
"getDotNewOp",
"(",
"*",
"MI",
")",
")",
",",
"MI",
"->",
"getDebugLoc",
"(",
")",
")",
";",
"if",
"(",
"Resources",
"->",
"canReserveResources",
"(",
"*",
"NewMI",
")",
")",
"Resources",
"->",
"reserveResources",
"(",
"*",
"NewMI",
")",
";",
"else",
"Resources",
"->",
"reserveResources",
"(",
"*",
"MI",
")",
";",
"MF",
"->",
"delete",
"MachineInstr",
"(",
"NewMI",
")",
";",
"}",
"else",
"Resources",
"->",
"reserveResources",
"(",
"*",
"MI",
")",
";"
] |
GCC | bfin | CPP | stmt_completion | DSP | 66 | [
"+",
"<NUM_LIT>",
")",
"return",
"<NUM_LIT>",
";"
] | [
"if",
"(",
"group",
"==",
"<NUM_LIT>",
")",
"{",
"if",
"(",
"D_REGNO_P",
"(",
"regno",
")",
")",
"{",
"group",
"=",
"<NUM_LIT>",
";",
"first_dreg_to_save",
"=",
"lastdreg",
"=",
"regno",
"-",
"REG_R0",
";",
"}",
"else",
"if",
"(",
"regno",
">=",
"REG_P0",
"&&",
"regno",
"<=",
"REG_P7",
")",
"{",
"group",
"=",
"<NUM_LIT>",
";",
"first_preg_to_save",
"=",
"lastpreg",
"=",
"regno",
"-",
"REG_P0",
";",
"}",
"else",
"return",
"<NUM_LIT>",
";",
"continue",
";",
"}",
"if",
"(",
"group",
"==",
"<NUM_LIT>",
")",
"{",
"if",
"(",
"regno",
">=",
"REG_P0",
"&&",
"regno",
"<=",
"REG_P7",
")",
"{",
"group",
"=",
"<NUM_LIT>",
";",
"first_preg_to_save",
"=",
"lastpreg",
"=",
"regno",
"-",
"REG_P0",
";",
"}",
"else",
"if",
"(",
"regno",
"!=",
"REG_R0",
"+",
"lastdreg"
] |
GCC | xtensa | CPP | stmt_completion | MPU | 67 | [
";"
] | [
"x",
"=",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
";",
"return",
"(",
"SYMBOL_REF_P",
"(",
"x",
")",
"||",
"CONST_INT_P",
"(",
"x",
")",
")",
"&&",
"CONSTANT_POOL_ADDRESS_P",
"(",
"x",
")",
";",
"}",
"if",
"(",
"CONST_INT_P",
"(",
"x",
")",
"&&",
"!",
"xtensa_simm12b",
"(",
"INTVAL",
"(",
"x",
")",
")",
")",
"return",
"true",
";",
"return",
"false"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 68 | [
"int",
"FI",
"=",
"MFI",
"->",
"CreateFixedObject",
"(",
"ValVT",
".",
"getSizeInBits",
"(",
")",
"/",
"<NUM_LIT>",
",",
"VA",
".",
"getLocMemOffset",
"(",
")",
",",
"isImmutable",
")",
";"
] | [
"SDValue",
"X86TargetLowering",
"::",
"LowerMemArgument",
"(",
"SDValue",
"Chain",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
",",
"DebugLoc",
"dl",
",",
"SelectionDAG",
"&",
"DAG",
",",
"const",
"CCValAssign",
"&",
"VA",
",",
"MachineFrameInfo",
"*",
"MFI",
",",
"unsigned",
"i",
")",
"const",
"{",
"ISD",
"::",
"ArgFlagsTy",
"Flags",
"=",
"Ins",
"[",
"i",
"]",
".",
"Flags",
";",
"bool",
"AlwaysUseMutable",
"=",
"FuncIsMadeTailCallSafe",
"(",
"CallConv",
")",
";",
"bool",
"isImmutable",
"=",
"!",
"AlwaysUseMutable",
"&&",
"!",
"Flags",
".",
"isByVal",
"(",
")",
";",
"EVT",
"ValVT",
";",
"if",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"Indirect",
")",
"ValVT",
"=",
"VA",
".",
"getLocVT",
"(",
")",
";",
"else",
"ValVT",
"=",
"VA",
".",
"getValVT",
"(",
")",
";",
"if",
"(",
"Flags",
".",
"isByVal",
"(",
")",
")",
"{",
"int",
"FI",
"=",
"MFI",
"->",
"CreateFixedObject",
"(",
"Flags",
".",
"getByValSize",
"(",
")",
",",
"VA",
".",
"getLocMemOffset",
"(",
")",
",",
"isImmutable",
")",
";",
"return",
"DAG",
".",
"getFrameIndex",
"(",
"FI",
",",
"getPointerTy",
"(",
")",
")",
";",
"}",
"else",
"{"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 69 | [
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"VT",
",",
"Small",
",",
"Overflow",
",",
"Small",
")",
";"
] | [
"static",
"SDValue",
"expandFP_TO_UINT_SSE",
"(",
"MVT",
"VT",
",",
"SDValue",
"Src",
",",
"const",
"SDLoc",
"&",
"dl",
",",
"SelectionDAG",
"&",
"DAG",
",",
"const",
"X86Subtarget",
"&",
"Subtarget",
")",
"{",
"MVT",
"SrcVT",
"=",
"Src",
".",
"getSimpleValueType",
"(",
")",
";",
"unsigned",
"DstBits",
"=",
"VT",
".",
"getScalarSizeInBits",
"(",
")",
";",
"assert",
"(",
"DstBits",
"==",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"expandFP_TO_UINT_SSE - only vXi32 supported",
"<STR_LIT>",
")",
";",
"SDValue",
"Small",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"VT",
",",
"Src",
")",
";",
"SDValue",
"Big",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"VT",
",",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"FSUB",
",",
"dl",
",",
"SrcVT",
",",
"Src",
",",
"DAG",
".",
"getConstantFP",
"(",
"<NUM_LIT>",
",",
"dl",
",",
"SrcVT",
")",
")",
")",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"v8i32",
"&&",
"!",
"Subtarget",
".",
"hasAVX2",
"(",
")",
")",
"{",
"SDValue",
"Overflow",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"OR",
",",
"dl",
",",
"VT",
",",
"Small",
",",
"Big",
")",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 70 | [
"let",
"InputType",
"=",
"<STR_LIT>",
";"
] | [
"def",
"A4_cmphgt",
":",
"HInst",
"<",
"(",
"outs",
"PredRegs",
":",
"$",
"Pd4",
")",
",",
"(",
"ins",
"IntRegs",
":",
"$",
"Rs32",
",",
"IntRegs",
":",
"$",
"Rt32",
")",
",",
"<STR_LIT>",
",",
"tc_85d5d03f",
",",
"TypeS_3op",
">",
",",
"Enc_c2b48e",
",",
"ImmRegRel",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"CextOpcode",
"=",
"<STR_LIT>",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 71 | [
"let",
"Defs",
"=",
"[",
"USR_OVF",
"]",
";"
] | [
"def",
"A2_svsubhs",
":",
"HInst",
"<",
"(",
"outs",
"IntRegs",
":",
"$",
"Rd32",
")",
",",
"(",
"ins",
"IntRegs",
":",
"$",
"Rt32",
",",
"IntRegs",
":",
"$",
"Rs32",
")",
",",
"<STR_LIT>",
",",
"tc_61830035",
",",
"TypeALU32_3op",
">",
",",
"Enc_bd6011",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"hasNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"opNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"prefersSlot3",
"=",
"<NUM_LIT>",
";"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 72 | [
"}"
] | [
"SDValue",
"Res",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SCALAR_TO_VECTOR",
",",
"dl",
",",
"VecVT",
",",
"N0",
")",
";",
"Res",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"Res",
")",
";",
"Res",
"=",
"DAG",
".",
"getZExtOrTrunc",
"(",
"Res",
",",
"dl",
",",
"VT",
")",
";",
"Res",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"AND",
",",
"dl",
",",
"VT",
",",
"Res",
",",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"dl",
",",
"VT",
")",
")",
";",
"return",
"Res",
";"
] |
LLVM | AMDGPU | CPP | next_suggestion | GPU | 73 | [
"}"
] | [
"return",
"&",
"(",
"*",
"(",
"--",
"(",
"Region",
"->",
"getEntry",
"(",
")",
"->",
"getParent",
"(",
")",
"->",
"end",
"(",
")",
")",
")",
")",
";",
"}",
"MachineBasicBlock",
"*",
"LastMerge",
"=",
"MF",
"->",
"CreateMachineBasicBlock",
"(",
")",
";",
"if",
"(",
"Exit",
"==",
"nullptr",
")",
"{",
"MachineFunction",
"::",
"iterator",
"ExitIter",
"=",
"MF",
"->",
"end",
"(",
")",
";",
"MF",
"->",
"insert",
"(",
"ExitIter",
",",
"LastMerge",
")",
";",
"}",
"else",
"{",
"MachineFunction",
"::",
"iterator",
"ExitIter",
"=",
"Exit",
"->",
"getIterator",
"(",
")",
";",
"MF",
"->",
"insert",
"(",
"ExitIter",
",",
"LastMerge",
")",
";",
"LastMerge",
"->",
"addSuccessor",
"(",
"Exit",
")",
";",
"insertUnconditionalBranch",
"(",
"LastMerge",
",",
"Exit",
")",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"Created exit block: ",
"<STR_LIT>",
"<<",
"LastMerge",
"->",
"getNumber",
"(",
")",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
")",
";"
] |
GCC | arm | MD | next_suggestion | CPU | 74 | [
"<STR_LIT>",
")"
] | [
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")"
] |
GCC | h8300 | MD | stmt_completion | MPU | 75 | [
"<STR_LIT>",
")",
")"
] | [
"(",
"define_expand",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"mult",
":",
"HI",
"(",
"zero_extend",
":",
"HI",
"(",
"match_operand",
":",
"QI",
"<NUM_LIT>",
"<STR_LIT>"
] |
GCC | frv | MD | next_suggestion | VLIW | 76 | [
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
] | [
"(",
"match_operand",
":",
"HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
"UNSPEC_MPACKH",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>"
] |
GCC | rs6000 | MD | stmt_completion | CPU | 77 | [
"<STR_LIT>",
"<STR_LIT>",
")"
] | [
"(",
"define_cpu_unit",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"define_cpu_unit"
] |
GCC | aarch64 | MD | stmt_completion | CPU | 78 | [
"]",
")"
] | [
"(",
"define_code_iterator",
"ANY_EXTEND",
"[",
"sign_extend",
"zero_extend",
"]",
")",
"(",
"define_code_iterator",
"ANY_EXTEND2",
"[",
"sign_extend",
"zero_extend"
] |
LLVM | SystemZ | TD | stmt_completion | CPU | 79 | [
"CCValues",
";"
] | [
"bits",
"<",
"<NUM_LIT>",
">",
"CompareZeroCCMask",
"=",
"<NUM_LIT>",
";",
"bit",
"CCMaskFirst",
"=",
"<NUM_LIT>",
";",
"bit",
"CCMaskLast",
"=",
"<NUM_LIT>",
";",
"bit",
"IsLogical",
"=",
"<NUM_LIT>",
";",
"bit",
"CCIfNoSignedWrap",
"=",
"<NUM_LIT>",
";",
"let",
"TSFlags",
"{",
"<NUM_LIT>",
"}",
"=",
"SimpleBDXLoad",
";",
"let",
"TSFlags",
"{",
"<NUM_LIT>",
"}",
"=",
"SimpleBDXStore",
";",
"let",
"TSFlags",
"{",
"<NUM_LIT>",
"}",
"=",
"Has20BitOffset",
";",
"let",
"TSFlags",
"{",
"<NUM_LIT>",
"}",
"=",
"HasIndex",
";",
"let",
"TSFlags",
"{",
"<NUM_LIT>",
"}",
"=",
"Is128Bit",
";",
"let",
"TSFlags",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"AccessBytes",
";",
"let",
"TSFlags",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"="
] |
LLVM | PowerPC | CPP | code_generation | CPU | 80 | [
"void",
"PPCRegisterInfo",
"::",
"eliminateFrameIndex",
"(",
"MachineBasicBlock",
"::",
"iterator",
"II",
",",
"int",
"SPAdj",
",",
"unsigned",
"FIOperandNum",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"assert",
"(",
"SPAdj",
"==",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Unexpected",
"<STR_LIT>",
")",
";",
"MachineInstr",
"&",
"MI",
"=",
"*",
"II",
";",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"DebugLoc",
"dl",
"=",
"MI",
".",
"getDebugLoc",
"(",
")",
";",
"unsigned",
"OffsetOperandNo",
"=",
"getOffsetONFromFION",
"(",
"MI",
",",
"FIOperandNum",
")",
";",
"int",
"FrameIndex",
"=",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"getIndex",
"(",
")",
";",
"PPCFunctionInfo",
"*",
"FI",
"=",
"MF",
".",
"getInfo",
"<",
"PPCFunctionInfo",
">",
"(",
")",
";",
"int",
"FPSI",
"=",
"FI",
"->",
"getFramePointerSaveIndex",
"(",
")",
";",
"unsigned",
"OpC",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"if",
"(",
"FPSI",
"&&",
"FrameIndex",
"==",
"FPSI",
"&&",
"(",
"OpC",
"==",
"PPC",
"::",
"DYNALLOC",
"||",
"OpC",
"==",
"PPC",
"::",
"DYNALLOC8",
")",
")",
"{",
"lowerDynamicAlloc",
"(",
"II",
")",
";",
"return",
";",
"}",
"if",
"(",
"OpC",
"==",
"PPC",
"::",
"SPILL_CR",
")",
"{",
"lowerCRSpilling",
"(",
"II",
",",
"FrameIndex",
")",
";",
"return",
";",
"}",
"else",
"if",
"(",
"OpC",
"==",
"PPC",
"::",
"RESTORE_CR",
")",
"{",
"lowerCRRestore",
"(",
"II",
",",
"FrameIndex",
")",
";",
"return",
";",
"}",
"else",
"if",
"(",
"OpC",
"==",
"PPC",
"::",
"SPILL_CRBIT",
")",
"{",
"lowerCRBitSpilling",
"(",
"II",
",",
"FrameIndex",
")",
";",
"return",
";",
"}",
"else",
"if",
"(",
"OpC",
"==",
"PPC",
"::",
"RESTORE_CRBIT",
")",
"{",
"lowerCRBitRestore",
"(",
"II",
",",
"FrameIndex",
")",
";",
"return",
";",
"}",
"else",
"if",
"(",
"OpC",
"==",
"PPC",
"::",
"SPILL_VRSAVE",
")",
"{",
"lowerVRSAVESpilling",
"(",
"II",
",",
"FrameIndex",
")",
";",
"return",
";",
"}",
"else",
"if",
"(",
"OpC",
"==",
"PPC",
"::",
"RESTORE_VRSAVE",
")",
"{",
"lowerVRSAVERestore",
"(",
"II",
",",
"FrameIndex",
")",
";",
"return",
";",
"}",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"ChangeToRegister",
"(",
"FrameIndex",
"<",
"<NUM_LIT>",
"?",
"getBaseRegister",
"(",
"MF",
")",
":",
"getFrameRegister",
"(",
"MF",
")",
",",
"false",
")",
";",
"bool",
"isIXAddr",
"=",
"usesIXAddr",
"(",
"MI",
")",
";",
"bool",
"noImmForm",
"=",
"!",
"MI",
".",
"isInlineAsm",
"(",
")",
"&&",
"!",
"ImmToIdxMap",
".",
"count",
"(",
"OpC",
")",
";",
"int",
"Offset",
"=",
"MFI",
"->",
"getObjectOffset",
"(",
"FrameIndex",
")",
";",
"Offset",
"+=",
"MI",
".",
"getOperand",
"(",
"OffsetOperandNo",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"!",
"MF",
".",
"getFunction",
"(",
")",
"->",
"getAttributes",
"(",
")",
".",
"hasAttribute",
"(",
"AttributeSet",
"::",
"FunctionIndex",
",",
"Attribute",
"::",
"Naked",
")",
")",
"{",
"if",
"(",
"!",
"(",
"hasBasePointer",
"(",
"MF",
")",
"&&",
"FrameIndex",
"<",
"<NUM_LIT>",
")",
")",
"Offset",
"+=",
"MFI",
"->",
"getStackSize",
"(",
")",
";",
"}",
"assert",
"(",
"OpC",
"!=",
"PPC",
"::",
"DBG_VALUE",
"&&",
"<STR_LIT>",
"This should be handle in a target independent way",
"<STR_LIT>",
")",
";",
"if",
"(",
"!",
"noImmForm",
"&&",
"isInt",
"<",
"<NUM_LIT>",
">",
"(",
"Offset",
")",
"&&",
"(",
"!",
"isIXAddr",
"||",
"(",
"Offset",
"&",
"<NUM_LIT>",
")",
"==",
"<NUM_LIT>",
")",
")",
"{",
"MI",
".",
"getOperand",
"(",
"OffsetOperandNo",
")",
".",
"ChangeToImmediate",
"(",
"Offset",
")",
";",
"return",
";",
"}",
"bool",
"is64Bit",
"=",
"Subtarget",
".",
"isPPC64",
"(",
")",
";",
"const",
"TargetRegisterClass",
"*",
"G8RC",
"=",
"&",
"PPC",
"::",
"G8RCRegClass",
";",
"const",
"TargetRegisterClass",
"*",
"GPRC",
"=",
"&",
"PPC",
"::",
"GPRCRegClass",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"is64Bit",
"?",
"G8RC",
":",
"GPRC",
";",
"unsigned",
"SRegHi",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"createVirtualRegister",
"(",
"RC",
")",
",",
"SReg",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"createVirtualRegister",
"(",
"RC",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"II",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"is64Bit",
"?",
"PPC",
"::",
"LIS8",
":",
"PPC",
"::",
"LIS",
")",
",",
"SRegHi",
")",
".",
"addImm",
"(",
"Offset",
">>",
"<NUM_LIT>",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"II",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"is64Bit",
"?",
"PPC",
"::",
"ORI8",
":",
"PPC",
"::",
"ORI",
")",
",",
"SReg",
")",
".",
"addReg",
"(",
"SRegHi",
",",
"RegState",
"::",
"Kill",
")",
".",
"addImm",
"(",
"Offset",
")",
";",
"unsigned",
"OperandBase",
";",
"if",
"(",
"noImmForm",
")",
"OperandBase",
"=",
"<NUM_LIT>",
";",
"else",
"if",
"(",
"OpC",
"!=",
"TargetOpcode",
"::",
"INLINEASM",
")",
"{",
"assert",
"(",
"ImmToIdxMap",
".",
"count",
"(",
"OpC",
")",
"&&",
"<STR_LIT>",
"No indexed form of load or store available!",
"<STR_LIT>",
")",
";",
"unsigned",
"NewOpcode",
"=",
"ImmToIdxMap",
".",
"find",
"(",
"OpC",
")",
"->",
"second",
";",
"MI",
".",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"NewOpcode",
")",
")",
";",
"OperandBase",
"=",
"<NUM_LIT>",
";",
"}",
"else",
"{",
"OperandBase",
"=",
"OffsetOperandNo",
";",
"}",
"unsigned",
"StackReg",
"=",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"getReg",
"(",
")",
";",
"MI",
".",
"getOperand",
"(",
"OperandBase",
")",
".",
"ChangeToRegister",
"(",
"StackReg",
",",
"false",
")",
";",
"MI",
".",
"getOperand",
"(",
"OperandBase",
"+",
"<NUM_LIT>",
")",
".",
"ChangeToRegister",
"(",
"SReg",
",",
"false",
",",
"false",
",",
"true",
")",
";",
"}"
] | [
"This",
"method",
"must",
"be",
"overriden",
"to",
"eliminate",
"abstract",
"frame",
"indices",
"from",
"instructions",
"which",
"may",
"use",
"them",
"."
] |
LLVM | PowerPC | CPP | next_suggestion | CPU | 81 | [
"++",
"Result",
";"
] | [
"unsigned",
"Shift",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"!",
"isInt",
"<",
"<NUM_LIT>",
">",
"(",
"Imm",
")",
")",
"{",
"Shift",
"=",
"countTrailingZeros",
"<",
"uint64_t",
">",
"(",
"Imm",
")",
";",
"int64_t",
"ImmSh",
"=",
"static_cast",
"<",
"uint64_t",
">",
"(",
"Imm",
")",
">>",
"Shift",
";",
"if",
"(",
"isInt",
"<",
"<NUM_LIT>",
">",
"(",
"ImmSh",
")",
")",
"{",
"Imm",
"=",
"ImmSh",
";",
"}",
"else",
"{",
"Remainder",
"=",
"Imm",
";",
"Shift",
"=",
"<NUM_LIT>",
";",
"Imm",
">>=",
"<NUM_LIT>",
";",
"}",
"}",
"unsigned",
"Result",
"=",
"<NUM_LIT>",
";",
"unsigned",
"Lo",
"=",
"Imm",
"&",
"<NUM_LIT>",
";",
"if",
"(",
"isInt",
"<",
"<NUM_LIT>",
">",
"(",
"Imm",
")",
")",
"{"
] |
GCC | i386 | CPP | stmt_completion | CPU | 82 | [
";"
] | [
"bool",
"ix86_function_value_regno_p",
"(",
"int",
"regno",
")",
"{",
"if",
"(",
"regno",
"==",
"<NUM_LIT>",
"||",
"(",
"regno",
"==",
"FIRST_FLOAT_REG",
"&&",
"TARGET_FLOAT_RETURNS_IN_80387",
")",
"||",
"(",
"regno",
"==",
"FIRST_SSE_REG",
"&&",
"TARGET_SSE",
")",
")",
"return",
"true",
";",
"if",
"(",
"!",
"TARGET_64BIT",
"&&",
"(",
"regno",
"==",
"FIRST_MMX_REG",
"&&",
"TARGET_MMX",
")",
")",
"return",
"true",
";",
"return",
"false"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 83 | [
"bits",
"<",
"<NUM_LIT>",
">",
"Rx32",
";"
] | [
"class",
"Enc_d15d19",
":",
"OpcodeHexagon",
"{",
"bits",
"<",
"<NUM_LIT>",
">",
"Mu2",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Mu2",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Vs32",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Vs32",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 84 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] | [
"def",
"C2_or",
":",
"HInst",
"<",
"(",
"outs",
"PredRegs",
":",
"$",
"Pd4",
")",
",",
"(",
"ins",
"PredRegs",
":",
"$",
"Pt4",
",",
"PredRegs",
":",
"$",
"Ps4",
")",
",",
"<STR_LIT>",
",",
"tc_640086b5",
",",
"TypeCR",
">",
",",
"Enc_454a26",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] |
LLVM | Lanai | CPP | next_suggestion | CPU | 85 | [
"}"
] | [
"}",
"void",
"Lower",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"MCInst",
"&",
"OutMI",
")",
"const",
";",
"MCOperand",
"LowerSymbolOperand",
"(",
"const",
"MachineOperand",
"&",
"MO",
",",
"MCSymbol",
"*",
"Sym",
")",
"const",
";",
"MCSymbol",
"*",
"GetGlobalAddressSymbol",
"(",
"const",
"MachineOperand",
"&",
"MO",
")",
"const",
";",
"MCSymbol",
"*",
"GetBlockAddressSymbol",
"(",
"const",
"MachineOperand",
"&",
"MO",
")",
"const",
";",
"MCSymbol",
"*",
"GetExternalSymbolSymbol",
"(",
"const",
"MachineOperand",
"&",
"MO",
")",
"const",
";",
"MCSymbol",
"*",
"GetJumpTableSymbol",
"(",
"const",
"MachineOperand",
"&",
"MO",
")",
"const",
";",
"MCSymbol",
"*",
"GetConstantPoolIndexSymbol",
"(",
"const",
"MachineOperand",
"&",
"MO",
")",
"const",
";"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 86 | [
"OpcodeSelect",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";"
] | [
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"AND",
",",
"dl",
",",
"VT",
",",
"Op",
",",
"VMask",
")",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"OR",
",",
"dl",
",",
"VT",
",",
"Op",
",",
"VMask",
")",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":"
] |
GCC | i386 | CPP | code_generation | CPU | 87 | [
"bool",
"symbolic_reference_mentioned_p",
"(",
"rtx",
"op",
")",
"{",
"const",
"char",
"*",
"fmt",
";",
"int",
"i",
";",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"==",
"SYMBOL_REF",
"||",
"GET_CODE",
"(",
"op",
")",
"==",
"LABEL_REF",
")",
"return",
"true",
";",
"fmt",
"=",
"GET_RTX_FORMAT",
"(",
"GET_CODE",
"(",
"op",
")",
")",
";",
"for",
"(",
"i",
"=",
"GET_RTX_LENGTH",
"(",
"GET_CODE",
"(",
"op",
")",
")",
"-",
"<NUM_LIT>",
";",
"i",
">=",
"<NUM_LIT>",
";",
"i",
"--",
")",
"{",
"if",
"(",
"fmt",
"[",
"i",
"]",
"==",
"'",
"E",
"'",
")",
"{",
"int",
"j",
";",
"for",
"(",
"j",
"=",
"XVECLEN",
"(",
"op",
",",
"i",
")",
"-",
"<NUM_LIT>",
";",
"j",
">=",
"<NUM_LIT>",
";",
"j",
"--",
")",
"if",
"(",
"symbolic_reference_mentioned_p",
"(",
"XVECEXP",
"(",
"op",
",",
"i",
",",
"j",
")",
")",
")",
"return",
"true",
";",
"}",
"else",
"if",
"(",
"fmt",
"[",
"i",
"]",
"==",
"'",
"e",
"'",
"&&",
"symbolic_reference_mentioned_p",
"(",
"XEXP",
"(",
"op",
",",
"i",
")",
")",
")",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}"
] | [
"Return",
"true",
"if",
"OP",
"contains",
"a",
"symbol",
"reference"
] |
GCC | rs6000 | CPP | stmt_completion | CPU | 88 | [
"rtx",
"*",
"str_mem",
")",
"{"
] | [
"static",
"bool",
"is_store_insn",
"(",
"rtx",
"insn",
","
] |
LLVM | AMDGPU | CPP | next_suggestion | GPU | 89 | [
"return",
"false",
";"
] | [
"Id",
"=",
"toFuncId",
"(",
"Loc",
"->",
"second",
")",
";",
"return",
"true",
";",
"}",
"Id",
"=",
"AMDGPULibFunc",
"::",
"EI_NONE",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 90 | [
"let",
"isTaken",
"=",
"Inst",
"{",
"<NUM_LIT>",
"}",
";"
] | [
"let",
"isPredicatedNew",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax1",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax2",
"=",
"<NUM_LIT>",
";",
"let",
"cofMax1",
"=",
"<NUM_LIT>",
";",
"let",
"Defs",
"=",
"[",
"PC",
"]",
";"
] |
LLVM | R600 | CPP | next_suggestion | GPU | 91 | [
"}"
] | [
"bool",
"programSpillsRegisters",
"(",
")",
"{",
"return",
"!",
"SpilledRegisters",
".",
"empty",
"(",
")",
";"
] |
LLVM | AArch64 | TD | stmt_completion | CPU | 92 | [
"<NUM_LIT>",
";"
] | [
"def",
"Xrs",
":",
"BaseAddSubSReg",
"<",
"isSub",
",",
"<NUM_LIT>",
",",
"GPR64",
",",
"arith_shifted_reg64",
",",
"mnemonic",
",",
"OpNode",
">",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"="
] |
LLVM | ARM | TD | stmt_completion | CPU | 93 | [
";"
] | [
"def",
"VecListThreeDByteIndexAsmOperand",
":",
"AsmOperandClass",
"{",
"let",
"Name",
"=",
"<STR_LIT>",
";",
"let",
"ParserMethod",
"=",
"<STR_LIT>"
] |
LLVM | AArch64 | TD | next_suggestion | CPU | 94 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"opc",
";"
] | [
"bits",
"<",
"<NUM_LIT>",
">",
"Rd",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Rn",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Rm",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rm",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 95 | [
"let",
"cofRelax1",
"=",
"<NUM_LIT>",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicateLate",
"=",
"<NUM_LIT>",
";"
] |
LLVM | AMDGPU | CPP | next_suggestion | GPU | 96 | [
"break",
";"
] | [
"const",
"GCNSubtarget",
"&",
"ST",
"=",
"MF",
".",
"getSubtarget",
"<",
"GCNSubtarget",
">",
"(",
")",
";",
"TII",
"=",
"ST",
".",
"getInstrInfo",
"(",
")",
";",
"TRI",
"=",
"&",
"TII",
"->",
"getRegisterInfo",
"(",
")",
";",
"MDT",
"=",
"&",
"getAnalysis",
"<",
"MachineDominatorTree",
">",
"(",
")",
";",
"SkipThreshold",
"=",
"SkipThresholdFlag",
";",
"MachineBasicBlock",
"*",
"EmptyMBBAtEnd",
"=",
"nullptr",
";",
"SmallVector",
"<",
"MachineInstr",
"*",
",",
"<NUM_LIT>",
">",
"KillInstrs",
";",
"bool",
"MadeChange",
"=",
"false",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"MBB",
":",
"MF",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"Next",
";",
"for",
"(",
"I",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
";",
"I",
"=",
"Next",
")",
"{",
"Next",
"=",
"std",
"::",
"next",
"(",
"I",
")",
";",
"MachineInstr",
"&",
"MI",
"=",
"*",
"I",
";",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"AMDGPU",
"::",
"SI_MASK_BRANCH",
":",
"MadeChange",
"|=",
"skipMaskBranch",
"(",
"MI",
",",
"MBB",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"S_BRANCH",
":",
"if",
"(",
"MBB",
".",
"isLayoutSuccessor",
"(",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getMBB",
"(",
")",
")",
")",
"{",
"assert",
"(",
"&",
"MI",
"==",
"&",
"MBB",
".",
"back",
"(",
")",
")",
";",
"MI",
".",
"eraseFromParent",
"(",
")",
";",
"MadeChange",
"=",
"true",
";",
"}"
] |
GCC | arm | MD | stmt_completion | CPU | 97 | [
"<",
"V_mode_nunits",
">",
"/",
"<NUM_LIT>",
")",
"+",
"i",
")"
] | [
"for",
"(",
"i",
"=",
"<NUM_LIT>",
"RTVEC_ELT",
"(",
"v",
",",
"i",
")",
"=",
"GEN_INT",
"(",
"("
] |
GCC | i386 | CPP | stmt_completion | CPU | 98 | [
"_",
"_",
"i0",
",",
"_",
"_",
"i1",
")",
";"
] | [
"return",
"(",
"_",
"_",
"m64",
")",
"_",
"_",
"builtin_ia32_vec_init_v2si",
"("
] |
GCC | i386 | CPP | stmt_completion | CPU | 99 | [
"_",
"_",
"LY",
",",
"const",
"int",
"_",
"_",
"M",
")",
"{"
] | [
"extern",
"_",
"_",
"inline",
"int",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm_cmpestrc",
"(",
"_",
"_",
"m128i",
"_",
"_",
"X",
",",
"int",
"_",
"_",
"LX",
",",
"_",
"_",
"m128i",
"_",
"_",
"Y",
",",
"int"
] |
End of preview. Expand
in Dataset Viewer.
ComBack++: A Multi-Language Dataset Providing End-to-End Support for Compiler Backend Development
ComBack++ is a large-scale, multi-platform and multi-language compiler backend code dataset. It is sourced from GCC and LLVM backends corresponding to 183 target platforms.
Dataset Information
Source Data
- GCC
Category Target Platform C++ Function C++ KLoC Machine Description KLoC CPU 30 56,211 858.2 228.5 MPU 35 8,713 243.8 87.1 GPU 2 731 12.7 3.0 VLIW 5 1,323 32.8 17.8 DSP 4 542 17.2 6.1 Virtual 5 558 10.5 0.1 SUM 81 68,078 1175.2 342.6 - LLVM
Category Target Platform C++ Function C++ KLoC TableGen KLoC CPU 43 97,972 3,768.4 1,157.7 MPU 30 12,552 190.7 24.8 GPU 5 28,267 886.8 168.5 VLIW 5 2,386 27.4 0.8 DSP 7 11,584 296.8 129.4 Virtual 12 10,538 199.4 12.9 SUM 102 163,299 5,369.5 1,494.1 Tasks
- Statement-Level Completion: complete current statement.
//Inputs: ... adjustReg(MBB,LastFrameDestroy, DL, SPReg, FPReg, -StackSize+RVFI->getVarArgsSaveSize() //Ground Truth: MachineInstr::FrameDestroy);
- Next-Statement Suggestion: predict the next statement.
//Inputs: ... maxCallFrameSize = (maxCallFrameSize + AlignMask) & ~AlignMask; //Ground Truth: MFI -> setMaxCallFrameSize(maxCallFrameSize);
- Code Generation: generate a function template with function description in natrual language.
//Inputs: getPointerRegClass: Returns a TargetRegisterClass used for pointer values. //Ground Truth: TargetRegisterClass *RegisterInfo::getPointerRegClass(MachineFunction &MF ,unsigned Kind) { return Subtarget.is64Bit() ? <ISA_LIT> : <ISA_LIT>; }
- Program Repair: automatically fixing bugs at identified locations.
//Inputs: int64_t Imm; <BUGS> MCExpr::VariantKind VK; <BUGE> ... //Ground Truth: <FIXS> MCExpr::VariantKind VK = MCExpr::VK_None; <FIXE>
Organization
./*.jsonl
: Take data of RISC-V,ARC,NVPTX both in GCC and LLVM as test set, split train/valid set in the ratio of 90%:10% of other targets excluding RI5CY(RI5CY is custmoized based on RISCV)Task Programming Language Train Valid Test Statement-Level Completion C++ 149,368 (16.41M) 16,480 (1.84M) 7,897 (0.82M) Statement-Level Completion TableGen/MD 120,460 (4.46M) 13,295 (0.50M) 7,090 (0.25M) Next-Statement Suggestion C++ 137,155 (20.55M) 15,218 (2.32M) 8,109 (1.09M) Next-Statement Suggestion TableGen/MD 124,528 (6.71M) 14,009 (0.76M) 2,726 (0.14M) Code Generation C++ 37,805 (10.69M) 4,137 (1.16M) 2,944 (0.73M) Program Repair C++ 40,578 (4.33M) 4,539 (0.48M) 2,623 (0.29M) Program Repair TableGen/MD 25,983 (2.95M) 2,975 (0.33M) 1,814 (0.24M)
- Downloads last month
- 4