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
listlengths 0
2.32k
| Input
listlengths 1
1.02k
|
|---|---|---|---|---|---|---|---|
LLVM | AArch64 | CPP | stmt_completion | CPU | 3,700 | [
"new",
"AArch64TargetStreamer",
"(",
"S",
")",
";"
] | [
"IsILP32",
"=",
"Options",
".",
"getABIName",
"(",
")",
"==",
"<STR_LIT>",
"ilp32",
"<STR_LIT>",
";",
"MCAsmParserExtension",
"::",
"Initialize",
"(",
"Parser",
")",
";",
"MCStreamer",
"&",
"S",
"=",
"getParser",
"(",
")",
".",
"getStreamer",
"(",
")",
";",
"if",
"(",
"S",
".",
"getTargetStreamer",
"(",
")",
"==",
"nullptr",
")"
] |
LLVM | ARM | CPP | program_repair | CPU | 3,701 | [
"<FIXS>",
"FeatureBitset",
"ToggleFeatures",
"=",
"EnableFeature",
"?",
"(",
"~",
"STI",
".",
"getFeatureBits",
"(",
")",
"&",
"Extension",
".",
"Features",
")",
":",
"(",
"STI",
".",
"getFeatureBits",
"(",
")",
"&",
"Extension",
".",
"Features",
")",
";",
"<FIXE>"
] | [
"return",
"false",
";",
"}",
"<BUGS>",
"uint64_t",
"ToggleFeatures",
"=",
"EnableFeature",
"?",
"(",
"~",
"STI",
".",
"getFeatureBits",
"(",
")",
"&",
"Extension",
".",
"Features",
")",
":",
"(",
"STI",
".",
"getFeatureBits",
"(",
")",
"&",
"Extension",
".",
"Features",
")",
";",
"<BUGE>",
"uint64_t",
"Features",
"=",
"ComputeAvailableFeatures",
"(",
"STI",
".",
"ToggleFeature",
"(",
"ToggleFeatures",
")",
")",
";",
"setAvailableFeatures",
"(",
"Features",
")",
";"
] |
LLVM | ARM64 | TD | stmt_completion | CPU | 3,702 | [
"label",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"opc",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"V",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"="
] |
LLVM | VE | CPP | stmt_completion | CPU | 3,703 | [
";"
] | [
"printRegName",
"(",
"O",
",",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"return",
";",
"}",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"{",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"int32_t",
"TruncatedImm",
"=",
"static_cast",
"<",
"int32_t",
">",
"(",
"MO",
".",
"getImm",
"(",
")",
")",
";",
"O",
"<<",
"TruncatedImm"
] |
GCC | i386 | MD | program_repair | CPU | 3,704 | [
"<FIXS>",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"<FIXE>"
] | [
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"<BUGS>",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"<BUGE>",
"(",
"define_expand",
"<STR_LIT>",
"[",
"(",
"const_int",
"<NUM_LIT>",
")",
"]"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 3,705 | [
"DEBUG",
"(",
"{"
] | [
"bool",
"X86DAGToDAGISel",
"::",
"matchAddressRecursively",
"(",
"SDValue",
"N",
",",
"X86ISelAddressMode",
"&",
"AM",
",",
"unsigned",
"Depth",
")",
"{",
"SDLoc",
"dl",
"(",
"N",
")",
";"
] |
GCC | sparc | CPP | next_suggestion | CPU | 3,706 | [
"}"
] | [
"d_add_builtin_version",
"(",
"<STR_LIT>",
"SPARC_HardFloat",
"<STR_LIT>",
")",
";",
"}",
"else",
"{",
"d_add_builtin_version",
"(",
"<STR_LIT>",
"D_SoftFloat",
"<STR_LIT>",
")",
";",
"d_add_builtin_version",
"(",
"<STR_LIT>",
"SPARC_SoftFloat",
"<STR_LIT>",
")",
";"
] |
GCC | bfin | CPP | code_generation | DSP | 3,707 | [
"static",
"reg_class_t",
"bfin_secondary_reload",
"(",
"bool",
"in_p",
",",
"rtx",
"x",
",",
"reg_class_t",
"rclass_i",
",",
"machine_mode",
"mode",
",",
"secondary_reload_info",
"*",
"sri",
")",
"{",
"enum",
"reg_class",
"default_class",
"=",
"GET_MODE_SIZE",
"(",
"mode",
")",
">=",
"<NUM_LIT>",
"?",
"DPREGS",
":",
"DREGS",
";",
"enum",
"reg_class",
"x_class",
"=",
"NO_REGS",
";",
"enum",
"rtx_code",
"code",
"=",
"GET_CODE",
"(",
"x",
")",
";",
"enum",
"reg_class",
"rclass",
"=",
"(",
"enum",
"reg_class",
")",
"rclass_i",
";",
"if",
"(",
"code",
"==",
"SUBREG",
")",
"x",
"=",
"SUBREG_REG",
"(",
"x",
")",
",",
"code",
"=",
"GET_CODE",
"(",
"x",
")",
";",
"if",
"(",
"REG_P",
"(",
"x",
")",
")",
"{",
"int",
"regno",
"=",
"REGNO",
"(",
"x",
")",
";",
"if",
"(",
"regno",
">=",
"FIRST_PSEUDO_REGISTER",
")",
"regno",
"=",
"reg_renumber",
"[",
"regno",
"]",
";",
"if",
"(",
"regno",
"==",
"-",
"<NUM_LIT>",
")",
"code",
"=",
"MEM",
";",
"else",
"x_class",
"=",
"REGNO_REG_CLASS",
"(",
"regno",
")",
";",
"}",
"if",
"(",
"fp_plus_const_operand",
"(",
"x",
",",
"mode",
")",
")",
"{",
"rtx",
"op2",
"=",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
";",
"int",
"large_constant_p",
"=",
"!",
"satisfies_constraint_Ks7",
"(",
"op2",
")",
";",
"if",
"(",
"rclass",
"==",
"PREGS",
"||",
"rclass",
"==",
"PREGS_CLOBBERED",
")",
"return",
"NO_REGS",
";",
"if",
"(",
"(",
"rclass",
"==",
"DREGS",
"||",
"rclass",
"==",
"DPREGS",
")",
"&&",
"!",
"large_constant_p",
")",
"return",
"NO_REGS",
";",
"sri",
"->",
"icode",
"=",
"CODE_FOR_reload_insi",
";",
"return",
"NO_REGS",
";",
"}",
"if",
"(",
"x_class",
"==",
"AREGS",
"||",
"x_class",
"==",
"EVEN_AREGS",
"||",
"x_class",
"==",
"ODD_AREGS",
")",
"return",
"(",
"rclass",
"==",
"DREGS",
"||",
"rclass",
"==",
"AREGS",
"||",
"rclass",
"==",
"EVEN_AREGS",
"||",
"rclass",
"==",
"ODD_AREGS",
"?",
"NO_REGS",
":",
"DREGS",
")",
";",
"if",
"(",
"rclass",
"==",
"AREGS",
"||",
"rclass",
"==",
"EVEN_AREGS",
"||",
"rclass",
"==",
"ODD_AREGS",
")",
"{",
"if",
"(",
"code",
"==",
"MEM",
")",
"{",
"sri",
"->",
"icode",
"=",
"in_p",
"?",
"CODE_FOR_reload_inpdi",
":",
"CODE_FOR_reload_outpdi",
";",
"return",
"NO_REGS",
";",
"}",
"if",
"(",
"x",
"!=",
"const0_rtx",
"&&",
"x_class",
"!=",
"DREGS",
")",
"{",
"return",
"DREGS",
";",
"}",
"else",
"return",
"NO_REGS",
";",
"}",
"if",
"(",
"rclass",
"==",
"CCREGS",
"&&",
"x_class",
"!=",
"DREGS",
")",
"return",
"DREGS",
";",
"if",
"(",
"x_class",
"==",
"CCREGS",
"&&",
"rclass",
"!=",
"DREGS",
")",
"return",
"DREGS",
";",
"if",
"(",
"code",
"==",
"MEM",
")",
"if",
"(",
"!",
"reg_class_subset_p",
"(",
"rclass",
",",
"default_class",
")",
")",
"return",
"default_class",
";",
"return",
"NO_REGS",
";",
"}"
] | [
"Inform",
"reload",
"about",
"cases",
"where",
"moving",
"X",
"with",
"a",
"mode",
"MODE",
"to",
"a",
"register",
"in",
"RCLASS",
"requires",
"an",
"extra",
"scratch",
"register",
".",
"Return",
"the",
"class",
"needed",
"for",
"the",
"scratch",
"register",
"."
] |
GCC | sparc | MD | next_suggestion | CPU | 3,708 | [
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")"
] | [
"(",
"match_operand",
":",
"SF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"neg",
":",
"SF",
"(",
"match_operand",
":",
"SF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>"
] |
LLVM | AMDGPU | CPP | next_suggestion | GPU | 3,709 | [
"Value",
"*",
"Div",
"=",
"Builder",
".",
"CreateAdd",
"(",
"IQ",
",",
"JQ",
")",
";"
] | [
"Value",
"*",
"RCP",
"=",
"Builder",
".",
"CreateFDiv",
"(",
"ConstantFP",
"::",
"get",
"(",
"F32Ty",
",",
"<NUM_LIT>",
")",
",",
"FB",
")",
";",
"Value",
"*",
"FQM",
"=",
"Builder",
".",
"CreateFMul",
"(",
"FA",
",",
"RCP",
")",
";",
"CallInst",
"*",
"FQ",
"=",
"Builder",
".",
"CreateUnaryIntrinsic",
"(",
"Intrinsic",
"::",
"trunc",
",",
"FQM",
")",
";",
"FQ",
"->",
"copyFastMathFlags",
"(",
"Builder",
".",
"getFastMathFlags",
"(",
")",
")",
";",
"Value",
"*",
"FQNeg",
"=",
"Builder",
".",
"CreateFNeg",
"(",
"FQ",
")",
";",
"Value",
"*",
"FR",
"=",
"Builder",
".",
"CreateIntrinsic",
"(",
"Intrinsic",
"::",
"amdgcn_fmad_ftz",
",",
"{",
"FQNeg",
"->",
"getType",
"(",
")",
"}",
",",
"{",
"FQNeg",
",",
"FB",
",",
"FA",
"}",
",",
"FQ",
")",
";",
"Value",
"*",
"IQ",
"=",
"IsSigned",
"?",
"Builder",
".",
"CreateFPToSI",
"(",
"FQ",
",",
"I32Ty",
")",
":",
"Builder",
".",
"CreateFPToUI",
"(",
"FQ",
",",
"I32Ty",
")",
";",
"FR",
"=",
"Builder",
".",
"CreateUnaryIntrinsic",
"(",
"Intrinsic",
"::",
"fabs",
",",
"FR",
",",
"FQ",
")",
";",
"FB",
"=",
"Builder",
".",
"CreateUnaryIntrinsic",
"(",
"Intrinsic",
"::",
"fabs",
",",
"FB",
",",
"FQ",
")",
";",
"Value",
"*",
"CV",
"=",
"Builder",
".",
"CreateFCmpOGE",
"(",
"FR",
",",
"FB",
")",
";",
"JQ",
"=",
"Builder",
".",
"CreateSelect",
"(",
"CV",
",",
"JQ",
",",
"Builder",
".",
"getInt32",
"(",
"<NUM_LIT>",
")",
")",
";"
] |
GCC | mep | CPP | program_repair | CPU | 3,710 | [
"<FIXS>",
"(",
"OPTIONAL_CP_INSN",
"ivc2",
"-",
"p1",
"-",
"isa",
"(",
"SLOTS",
"P1",
")",
"(",
"INTRINSIC",
"<STR_LIT>",
"cpsadua1_h",
"<STR_LIT>",
")",
"(",
"CPTYPE",
"V4HI",
")",
"VOLATILE",
")",
"<FIXE>"
] | [
";",
"<NUM_LIT>",
"<NUM_LIT>",
"qqqqq",
"ppppp",
"<NUM_LIT>",
"cpsadua1",
".",
"h",
"crqp",
",",
"crpp",
"(",
"p0_1",
")",
"(",
"dni",
"cpsadua1_h_P1",
"<STR_LIT>",
"cpsadua1.h $crqp,$crpp Pn",
"<STR_LIT>",
"<BUGS>",
"(",
"OPTIONAL_CP_INSN",
"ivc2",
"-",
"p1",
"-",
"isa",
"(",
"SLOTS",
"P1",
")",
"(",
"INTRINSIC",
"<STR_LIT>",
"cpsadua1_h",
"<STR_LIT>",
")",
"(",
"CPTYPE",
"V4HI",
")",
")",
"<BUGE>",
"<STR_LIT>",
"cpsadua1.h $crqp,$crpp",
"<STR_LIT>",
"(",
"+",
"(",
"f",
"-",
"ivc2",
"-",
"<NUM_LIT>",
"u0",
"#",
"x0",
")",
"(",
"f",
"-",
"ivc2",
"-",
"<NUM_LIT>",
"u8",
"#",
"x18",
")",
"crqp",
"crpp",
"(",
"f",
"-",
"ivc2",
"-",
"<NUM_LIT>",
"u23",
"#",
"x16",
")",
"(",
"f",
"-",
"ivc2",
"-",
"<NUM_LIT>",
"u28",
"<NUM_LIT>",
")",
")",
"(",
"sequence",
"(",
")"
] |
LLVM | TPC | TD | next_suggestion | Virtual ISA | 3,711 | [
"let",
"HasImm",
"=",
"!",
"isa",
"<",
"Operand",
">",
"(",
"Src",
")",
";"
] | [
"let",
"OutOperandList",
"=",
"(",
"outs",
"Rdst",
":",
"$",
"dest",
")",
";",
"let",
"InOperandList",
"=",
"(",
"ins",
"Src",
":",
"$",
"src",
",",
"i8imm",
":",
"$",
"flavor",
",",
"SwitchSet",
":",
"$",
"sw",
",",
"Rdst",
":",
"$",
"income",
",",
"Pred",
":",
"$",
"pred",
")",
";",
"let",
"Itinerary",
"=",
"IIC_VectorOp",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"dest",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"src",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"flavor",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"sw",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"pred",
";",
"let",
"Switches",
"=",
"sw",
";",
"let",
"Dest",
"=",
"dest",
";",
"let",
"SrcA",
"=",
"src",
";",
"let",
"SrcB",
"=",
"flavor",
";",
"let",
"OperandType",
"=",
"OpType",
".",
"UINT32",
";",
"let",
"VectorPred",
"=",
"!",
"eq",
"(",
"!",
"cast",
"<",
"string",
">",
"(",
"Pred",
")",
",",
"<STR_LIT>",
")",
";",
"let",
"PredAddress",
"=",
"pred",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"PredPolarity",
"=",
"pred",
"{",
"<NUM_LIT>",
"}",
";"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 3,712 | [
",",
"P3",
",",
"PC",
",",
"USR",
"]",
";"
] | [
"let",
"Uses",
"=",
"[",
"LC0",
",",
"LC1",
",",
"SA0",
",",
"SA1",
"]",
";",
"let",
"Defs",
"=",
"[",
"LC0",
",",
"LC1"
] |
LLVM | Mips | CPP | next_suggestion | CPU | 3,713 | [
"return",
"IsGlobalInSmallSectionImpl",
"(",
"GO",
",",
"TM",
")",
"&&",
"(",
"Kind",
".",
"isData",
"(",
")",
"||",
"Kind",
".",
"isBSS",
"(",
")",
"||",
"Kind",
".",
"isCommon",
"(",
")",
"||",
"Kind",
".",
"isReadOnly",
"(",
")",
")",
";"
] | [
"bool",
"MipsTargetObjectFile",
"::",
"IsGlobalInSmallSection",
"(",
"const",
"GlobalObject",
"*",
"GO",
",",
"const",
"TargetMachine",
"&",
"TM",
",",
"SectionKind",
"Kind",
")",
"const",
"{"
] |
LLVM | AMDGPU | CPP | next_suggestion | GPU | 3,714 | [
"SDValue",
"FFBX",
"=",
"DAG",
".",
"getNode",
"(",
"Opc",
",",
"DL",
",",
"MVT",
"::",
"i32",
",",
"Op",
")",
";"
] | [
"EVT",
"LegalVT",
"=",
"getTypeToTransformTo",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
",",
"VT",
")",
";",
"if",
"(",
"LegalVT",
"!=",
"MVT",
"::",
"i32",
"&&",
"(",
"Subtarget",
"->",
"has16BitInsts",
"(",
")",
"&&",
"LegalVT",
"!=",
"MVT",
"::",
"i16",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"if",
"(",
"VT",
"!=",
"MVT",
"::",
"i32",
")",
"Op",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ZERO_EXTEND",
",",
"DL",
",",
"MVT",
"::",
"i32",
",",
"Op",
")",
";"
] |
LLVM | ARM | CPP | stmt_completion | CPU | 3,715 | [
"end",
"(",
")",
";"
] | [
"JTI",
"=",
"(",
"(",
"ARMTargetMachine",
"&",
")",
"MF",
".",
"getTarget",
"(",
")",
")",
".",
"getJITInfo",
"(",
")",
";",
"II",
"=",
"(",
"(",
"const",
"ARMTargetMachine",
"&",
")",
"MF",
".",
"getTarget",
"(",
")",
")",
".",
"getInstrInfo",
"(",
")",
";",
"TD",
"=",
"(",
"(",
"const",
"ARMTargetMachine",
"&",
")",
"MF",
".",
"getTarget",
"(",
")",
")",
".",
"getTargetData",
"(",
")",
";",
"Subtarget",
"=",
"&",
"TM",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
";",
"MCPEs",
"=",
"&",
"MF",
".",
"getConstantPool",
"(",
")",
"->",
"getConstants",
"(",
")",
";",
"MJTEs",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"MF",
".",
"getJumpTableInfo",
"(",
")",
")",
"MJTEs",
"=",
"&",
"MF",
".",
"getJumpTableInfo",
"(",
")",
"->",
"getJumpTables",
"(",
")",
";",
"IsPIC",
"=",
"TM",
".",
"getRelocationModel",
"(",
")",
"==",
"Reloc",
"::",
"PIC_",
";",
"IsThumb",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
"->",
"isThumbFunction",
"(",
")",
";",
"JTI",
"->",
"Initialize",
"(",
"MF",
",",
"IsPIC",
")",
";",
"MMI",
"=",
"&",
"getAnalysis",
"<",
"MachineModuleInfo",
">",
"(",
")",
";",
"MCE",
".",
"setModuleInfo",
"(",
"MMI",
")",
";",
"do",
"{",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"<STR_LIT>",
"JITTing function '",
"<STR_LIT>",
"<<",
"MF",
".",
"getFunction",
"(",
")",
"->",
"getName",
"(",
")",
"<<",
"<STR_LIT>",
"'\\n",
"<STR_LIT>",
")",
";",
"MCE",
".",
"startFunction",
"(",
"MF",
")",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"MBB",
"=",
"MF",
".",
"begin",
"(",
")",
",",
"E",
"=",
"MF",
".",
"end",
"(",
")",
";",
"MBB",
"!=",
"E",
";",
"++",
"MBB",
")",
"{",
"MCE",
".",
"StartMachineBasicBlock",
"(",
"MBB",
")",
";",
"for",
"(",
"MachineBasicBlock",
"::",
"const_iterator",
"I",
"=",
"MBB",
"->",
"begin",
"(",
")",
",",
"E",
"=",
"MBB",
"->"
] |
GCC | i386 | CPP | stmt_completion | CPU | 3,716 | [
"v4di",
")",
"_",
"mm256_setzero_si256",
"(",
")",
",",
"(",
"_",
"_",
"mmask8",
")",
"_",
"_",
"U",
")",
";"
] | [
"return",
"(",
"_",
"_",
"m256i",
")",
"_",
"_",
"builtin_ia32_prolq256_mask",
"(",
"(",
"_",
"_",
"v4di",
")",
"_",
"_",
"A",
",",
"_",
"_",
"B",
",",
"(",
"_",
"_"
] |
LLVM | AMDGPU | CPP | stmt_completion | GPU | 3,717 | [
")",
")",
"{"
] | [
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"MRI",
".",
"constrainRegClass",
"(",
"DestReg",
",",
"&",
"AMDGPU",
"::",
"SReg_32_XM0RegClass",
")",
";",
"}",
"FrameInfo",
".",
"setStackID",
"(",
"FrameIndex",
",",
"<NUM_LIT>",
")",
";",
"MachineInstrBuilder",
"Spill",
"=",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"OpDesc",
",",
"DestReg",
")",
".",
"addFrameIndex",
"(",
"FrameIndex",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getScratchRSrcReg",
"(",
")",
",",
"RegState",
"::",
"Implicit",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getFrameOffsetReg",
"(",
")",
",",
"RegState",
"::",
"Implicit",
")",
";",
"if",
"(",
"ST",
".",
"hasScalarStores",
"(",
")",
")",
"{",
"Spill",
".",
"addReg",
"(",
"AMDGPU",
"::",
"M0",
",",
"RegState",
"::",
"ImplicitDefine",
"|",
"RegState",
"::",
"Dead",
")",
";",
"}",
"return",
";",
"}",
"if",
"(",
"!",
"ST",
".",
"isVGPRSpillingEnabled",
"(",
"*",
"MF",
"->",
"getFunction",
"(",
")"
] |
GCC | mmix | MD | next_suggestion | CPU | 3,718 | [
"<STR_LIT>"
] | [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"xor",
":",
"DI",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]"
] |
GCC | visium | CPP | code_generation | Virtual ISA | 3,719 | [
"int",
"gr5_hazard_bypass_p",
"(",
"rtx_insn",
"*",
"out_insn",
",",
"rtx_insn",
"*",
"in_insn",
")",
"{",
"rtx",
"out_set",
",",
"in_set",
",",
"dest",
",",
"memexpr",
";",
"unsigned",
"int",
"out_reg",
",",
"in_reg",
";",
"if",
"(",
"GET_CODE",
"(",
"out_insn",
")",
"==",
"CALL_INSN",
")",
"return",
"<NUM_LIT>",
";",
"out_set",
"=",
"single_set_and_flags",
"(",
"out_insn",
")",
";",
"dest",
"=",
"SET_DEST",
"(",
"out_set",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"dest",
")",
"==",
"MEM",
")",
"return",
"<NUM_LIT>",
";",
"if",
"(",
"GET_CODE",
"(",
"dest",
")",
"==",
"STRICT_LOW_PART",
")",
"dest",
"=",
"XEXP",
"(",
"dest",
",",
"<NUM_LIT>",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"dest",
")",
"==",
"SUBREG",
")",
"dest",
"=",
"SUBREG_REG",
"(",
"dest",
")",
";",
"out_reg",
"=",
"REGNO",
"(",
"dest",
")",
";",
"in_set",
"=",
"single_set_and_flags",
"(",
"in_insn",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"SET_SRC",
"(",
"in_set",
")",
")",
"==",
"MEM",
")",
"memexpr",
"=",
"XEXP",
"(",
"SET_SRC",
"(",
"in_set",
")",
",",
"<NUM_LIT>",
")",
";",
"else",
"memexpr",
"=",
"XEXP",
"(",
"SET_DEST",
"(",
"in_set",
")",
",",
"<NUM_LIT>",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"memexpr",
")",
"==",
"PLUS",
")",
"{",
"memexpr",
"=",
"XEXP",
"(",
"memexpr",
",",
"<NUM_LIT>",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"memexpr",
")",
"==",
"SUBREG",
")",
"in_reg",
"=",
"REGNO",
"(",
"SUBREG_REG",
"(",
"memexpr",
")",
")",
";",
"else",
"in_reg",
"=",
"REGNO",
"(",
"memexpr",
")",
";",
"if",
"(",
"in_reg",
"==",
"out_reg",
")",
"return",
"<NUM_LIT>",
";",
"}",
"else",
"if",
"(",
"TARGET_MCM",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"memexpr",
")",
"==",
"STRICT_LOW_PART",
")",
"memexpr",
"=",
"XEXP",
"(",
"memexpr",
",",
"<NUM_LIT>",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"memexpr",
")",
"==",
"SUBREG",
")",
"memexpr",
"=",
"SUBREG_REG",
"(",
"memexpr",
")",
";",
"in_reg",
"=",
"REGNO",
"(",
"memexpr",
")",
";",
"if",
"(",
"in_reg",
"==",
"out_reg",
")",
"return",
"<NUM_LIT>",
";",
"}",
"return",
"<NUM_LIT>",
";",
"}"
] | [
"This",
"is",
"called",
"with",
"OUT_INSN",
"an",
"instruction",
"setting",
"a",
"(",
"base",
")",
"register",
"and",
"IN_INSN",
"a",
"read",
"or",
"a",
"write",
".",
"Return",
"1",
"if",
"these",
"instructions",
"together",
"constitute",
"a",
"pipeline",
"hazard",
".",
"On",
"the",
"original",
"architecture",
",",
"a",
"pipeline",
"data",
"hazard",
"occurs",
"when",
"the",
"Dest",
"of",
"one",
"instruction",
"becomes",
"the",
"SrcA",
"for",
"an",
"immediately",
"following",
"READ",
"or",
"WRITE",
"instruction",
"with",
"a",
"non-zero",
"index",
"(",
"indexing",
"occurs",
"at",
"the",
"decode",
"stage",
"and",
"so",
"a",
"NOP",
"must",
"be",
"inserted",
"in-between",
"for",
"this",
"to",
"work",
")",
".",
"An",
"example",
"is",
":",
"move.l",
"r2",
",",
"r1",
"read.l",
"r4,10",
"(",
"r2",
")",
"On",
"the",
"MCM",
",",
"the",
"non-zero",
"index",
"condition",
"is",
"lifted",
"but",
"the",
"hazard",
"is",
"patched",
"up",
"by",
"the",
"hardware",
"through",
"the",
"injection",
"of",
"wait",
"states",
":",
"move.l",
"r2",
",",
"r1",
"read.l",
"r4",
",",
"(",
"r2",
")",
"We",
"nevertheless",
"try",
"to",
"schedule",
"instructions",
"around",
"this",
"."
] |
GCC | frv | CPP | stmt_completion | VLIW | 3,720 | [
"<NUM_LIT>",
";"
] | [
"}",
"break",
";",
"default",
":",
"if",
"(",
"next_io",
"->",
"var_address",
")",
"not",
"e_stores",
"(",
"insn",
",",
"frv_io_check_address",
",",
"&",
"next_io",
"->",
"var_address",
")",
";",
"set",
"=",
"PATTERN",
"(",
"insn",
")",
";",
"if",
"(",
"next_io",
"->",
"type",
"==",
"FRV_IO_READ",
"&&",
"next_io",
"->",
"var_address",
"!=",
"<NUM_LIT>",
"&&",
"next_membar",
"!=",
"<NUM_LIT>",
"&&",
"GET_CODE",
"(",
"set",
")",
"==",
"SET",
"&&",
"GET_CODE",
"(",
"SET_DEST",
"(",
"set",
")",
")",
"==",
"REG",
"&&",
"TEST_HARD_REG_BIT",
"(",
"used_regs",
",",
"REGNO",
"(",
"SET_DEST",
"(",
"set",
")",
")",
")",
")",
"{",
"rtx",
"src",
";",
"src",
"=",
"SET_SRC",
"(",
"set",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"src",
")",
"==",
"ZERO_EXTEND",
")",
"src",
"=",
"XEXP",
"(",
"src",
",",
"<NUM_LIT>",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"src",
")",
"==",
"MEM",
"&&",
"rtx_equal_p",
"(",
"XEXP",
"(",
"src",
",",
"<NUM_LIT>",
")",
",",
"next_io",
"->",
"var_address",
")",
")",
"{",
"if",
"(",
"dump_file",
")",
"fprintf",
"(",
"dump_file",
",",
"<STR_LIT>",
";; [Local] Removing membar %d since the target",
"<STR_LIT>",
"<STR_LIT>",
" of %d is used before the I/O operation\\n",
"<STR_LIT>",
",",
"INSN_UID",
"(",
"next_membar",
")",
",",
"INSN_UID",
"(",
"insn",
")",
")",
";",
"if",
"(",
"next_membar",
"==",
"*",
"last_membar",
")",
"*",
"last_membar",
"=",
"<NUM_LIT>",
";",
"delete",
"_",
"insn",
"(",
"next_membar",
")",
";",
"next_membar",
"="
] |
LLVM | Mips | CPP | next_suggestion | CPU | 3,721 | [
"if",
"(",
"TopCPUSavedRegOff",
">=",
"<NUM_LIT>",
")",
"MipsFI",
"->",
"setCPUTopSavedRegOff",
"(",
"TopCPUSavedRegOff",
"-",
"StackOffset",
")",
";"
] | [
"if",
"(",
"i",
">=",
"MinCSFI",
"&&",
"i",
"<=",
"MaxCSFI",
")",
"continue",
";",
"if",
"(",
"MFI",
"->",
"isDeadObjectIndex",
"(",
"i",
")",
")",
"continue",
";",
"unsigned",
"Offset",
"=",
"StackOffset",
"+",
"MFI",
"->",
"getObjectOffset",
"(",
"i",
")",
"-",
"CalleeSavedAreaSize",
";",
"if",
"(",
"LastOffsetFI",
"==",
"-",
"<NUM_LIT>",
")",
"LastOffsetFI",
"=",
"i",
";",
"if",
"(",
"Offset",
">",
"MFI",
"->",
"getObjectOffset",
"(",
"LastOffsetFI",
")",
")",
"LastOffsetFI",
"=",
"i",
";",
"MFI",
"->",
"setObjectOffset",
"(",
"i",
",",
"Offset",
")",
";",
"}",
"if",
"(",
"LastOffsetFI",
">=",
"<NUM_LIT>",
")",
"StackOffset",
"=",
"MFI",
"->",
"getObjectOffset",
"(",
"LastOffsetFI",
")",
"+",
"MFI",
"->",
"getObjectSize",
"(",
"LastOffsetFI",
")",
";",
"StackOffset",
"=",
"(",
"(",
"StackOffset",
"+",
"StackAlign",
"-",
"<NUM_LIT>",
")",
"/",
"StackAlign",
"*",
"StackAlign",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
",",
"e",
"=",
"CSI",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"if",
"(",
"CSI",
"[",
"i",
"]",
".",
"getRegClass",
"(",
")",
"!=",
"Mips",
"::",
"CPURegsRegisterClass",
")",
"break",
";",
"MFI",
"->",
"setObjectOffset",
"(",
"CSI",
"[",
"i",
"]",
".",
"getFrameIdx",
"(",
")",
",",
"StackOffset",
")",
";",
"TopCPUSavedRegOff",
"=",
"StackOffset",
";",
"StackOffset",
"+=",
"MFI",
"->",
"getObjectAlignment",
"(",
"CSI",
"[",
"i",
"]",
".",
"getFrameIdx",
"(",
")",
")",
";",
"}",
"if",
"(",
"hasFP",
"(",
"MF",
")",
"||",
"MFI",
"->",
"hasCalls",
"(",
")",
")",
"{",
"MFI",
"->",
"setObjectOffset",
"(",
"MFI",
"->",
"CreateStackObject",
"(",
"RegSize",
",",
"RegSize",
",",
"true",
")",
",",
"StackOffset",
")",
";",
"MipsFI",
"->",
"setFPStackOffset",
"(",
"StackOffset",
")",
";",
"TopCPUSavedRegOff",
"=",
"StackOffset",
";",
"StackOffset",
"+=",
"RegSize",
";",
"MFI",
"->",
"setObjectOffset",
"(",
"MFI",
"->",
"CreateStackObject",
"(",
"RegSize",
",",
"RegSize",
",",
"true",
")",
",",
"StackOffset",
")",
";",
"MipsFI",
"->",
"setRAStackOffset",
"(",
"StackOffset",
")",
";",
"StackOffset",
"+=",
"RegSize",
";",
"if",
"(",
"MFI",
"->",
"hasCalls",
"(",
")",
")",
"TopCPUSavedRegOff",
"+=",
"RegSize",
";",
"}",
"StackOffset",
"=",
"(",
"(",
"StackOffset",
"+",
"StackAlign",
"-",
"<NUM_LIT>",
")",
"/",
"StackAlign",
"*",
"StackAlign",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
",",
"e",
"=",
"CSI",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"if",
"(",
"CSI",
"[",
"i",
"]",
".",
"getRegClass",
"(",
")",
"==",
"Mips",
"::",
"CPURegsRegisterClass",
")",
"continue",
";",
"MFI",
"->",
"setObjectOffset",
"(",
"CSI",
"[",
"i",
"]",
".",
"getFrameIdx",
"(",
")",
",",
"StackOffset",
")",
";",
"TopFPUSavedRegOff",
"=",
"StackOffset",
";",
"StackOffset",
"+=",
"MFI",
"->",
"getObjectAlignment",
"(",
"CSI",
"[",
"i",
"]",
".",
"getFrameIdx",
"(",
")",
")",
";",
"}",
"StackOffset",
"=",
"(",
"(",
"StackOffset",
"+",
"StackAlign",
"-",
"<NUM_LIT>",
")",
"/",
"StackAlign",
"*",
"StackAlign",
")",
";",
"MFI",
"->",
"setStackSize",
"(",
"StackOffset",
")",
";"
] |
GCC | powerpcspe | CPP | code_generation | CPU | 3,722 | [
"static",
"rtx",
"altivec_expand_vec_init_builtin",
"(",
"tree",
"type",
",",
"tree",
"exp",
",",
"rtx",
"target",
")",
"{",
"machine_mode",
"tmode",
"=",
"TYPE_MODE",
"(",
"type",
")",
";",
"machine_mode",
"inner_mode",
"=",
"GET_MODE_INNER",
"(",
"tmode",
")",
";",
"int",
"i",
",",
"n_elt",
"=",
"GET_MODE_NUNITS",
"(",
"tmode",
")",
";",
"gcc_assert",
"(",
"VECTOR_MODE_P",
"(",
"tmode",
")",
")",
";",
"gcc_assert",
"(",
"n_elt",
"==",
"call_expr_nargs",
"(",
"exp",
")",
")",
";",
"if",
"(",
"!",
"target",
"||",
"!",
"register_operand",
"(",
"target",
",",
"tmode",
")",
")",
"target",
"=",
"gen_reg_rtx",
"(",
"tmode",
")",
";",
"if",
"(",
"n_elt",
"==",
"<NUM_LIT>",
"&&",
"GET_MODE_SIZE",
"(",
"tmode",
")",
"==",
"GET_MODE_SIZE",
"(",
"inner_mode",
")",
")",
"{",
"rtx",
"x",
"=",
"expand_normal",
"(",
"CALL_EXPR_ARG",
"(",
"exp",
",",
"<NUM_LIT>",
")",
")",
";",
"emit_move_insn",
"(",
"target",
",",
"gen_lowpart",
"(",
"tmode",
",",
"x",
")",
")",
";",
"}",
"else",
"{",
"rtvec",
"v",
"=",
"rtvec_alloc",
"(",
"n_elt",
")",
";",
"for",
"(",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"n_elt",
";",
"++",
"i",
")",
"{",
"rtx",
"x",
"=",
"expand_normal",
"(",
"CALL_EXPR_ARG",
"(",
"exp",
",",
"i",
")",
")",
";",
"RTVEC_ELT",
"(",
"v",
",",
"i",
")",
"=",
"gen_lowpart",
"(",
"inner_mode",
",",
"x",
")",
";",
"}",
"rs6000_expand_vector_init",
"(",
"target",
",",
"gen_rtx_PARALLEL",
"(",
"tmode",
",",
"v",
")",
")",
";",
"}",
"return",
"target",
";",
"}"
] | [
"Expand",
"vec_init",
"builtin",
"."
] |
LLVM | AArch64 | TD | next_suggestion | CPU | 3,723 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"imm",
";"
] | [
"bits",
"<",
"<NUM_LIT>",
">",
"shift",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"opc",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"shift",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";"
] |
LLVM | Mips | TD | stmt_completion | CPU | 3,724 | [
">",
",",
"FJ",
"<",
"<NUM_LIT>",
">",
",",
"AdditionalRequires",
"<",
"[",
"RelocStatic",
"]",
">",
",",
"IsBranch",
";"
] | [
"def",
"J",
":",
"MMRel",
",",
"JumpFJ",
"<",
"jmptarget",
",",
"<STR_LIT>",
",",
"br",
",",
"bb",
",",
"<STR_LIT>"
] |
LLVM | ARM | TD | program_repair | CPU | 3,725 | [
"<FIXS>",
"def",
"TCRETURNriND",
":",
"AInoP",
"(",
"outs",
")",
",",
"(",
"ins",
"tcGPR",
":",
"$",
"dst",
",",
"variable_ops",
")",
",",
"<FIXE>"
] | [
"Pseudo",
",",
"IIC_Br",
",",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"[",
"]",
">",
",",
"Requires",
"[",
"IsNotDarwin",
"]",
">",
";",
"<BUGS>",
"def",
"TCRETURNriND",
":",
"AInoP",
"(",
"outs",
")",
",",
"(",
"ins",
"tGPR",
":",
"$",
"dst",
",",
"variable_ops",
")",
",",
"<BUGE>",
"Pseudo",
",",
"IIC_Br",
",",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"[",
"]",
">",
",",
"Requires",
"[",
"IsNotDarwin",
"]",
">",
";"
] |
GCC | arm | MD | next_suggestion | CPU | 3,726 | [
"<STR_LIT>",
")"
] | [
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")"
] |
GCC | mcore | CPP | code_generation | MPU | 3,727 | [
"int",
"mcore_num_ones",
"(",
"HOST_WIDE_INT",
"mask",
")",
"{",
"mask",
"=",
"(",
"mask",
">>",
"<NUM_LIT>",
"&",
"<NUM_LIT>",
")",
"+",
"(",
"mask",
"&",
"<NUM_LIT>",
")",
";",
"mask",
"=",
"(",
"(",
"mask",
">>",
"<NUM_LIT>",
")",
"&",
"<NUM_LIT>",
")",
"+",
"(",
"mask",
"&",
"<NUM_LIT>",
")",
";",
"mask",
"=",
"(",
"(",
"mask",
">>",
"<NUM_LIT>",
")",
"+",
"mask",
")",
"&",
"<NUM_LIT>",
";",
"mask",
"=",
"(",
"(",
"mask",
">>",
"<NUM_LIT>",
")",
"+",
"mask",
")",
";",
"return",
"(",
"mask",
"+",
"(",
"mask",
">>",
"<NUM_LIT>",
")",
")",
"&",
"<NUM_LIT>",
";",
"}"
] | [
"Count",
"the",
"number",
"of",
"ones",
"in",
"mask",
"."
] |
LLVM | ARM64 | TD | next_suggestion | CPU | 3,728 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"Q",
";"
] | [
"class",
"BaseSIMDThreeSameVector",
"<",
"bit",
"Q",
",",
"bit",
"U",
",",
"bits",
"<",
"<NUM_LIT>",
">",
"size",
",",
"bits",
"<",
"<NUM_LIT>",
">",
"opcode",
",",
"RegisterOperand",
"regtype",
",",
"string",
"asm",
",",
"string",
"kind",
",",
"list",
"<",
"dag",
">",
"pattern",
">",
":",
"I",
"<",
"(",
"outs",
"regtype",
":",
"$",
"Rd",
")",
",",
"(",
"ins",
"regtype",
":",
"$",
"Rn",
",",
"regtype",
":",
"$",
"Rm",
")",
",",
"asm",
",",
"<STR_LIT>",
"#",
"kind",
"#",
"<STR_LIT>",
"#",
"kind",
"#",
"<STR_LIT>",
"#",
"kind",
"#",
"<STR_LIT>",
"#",
"kind",
"#",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"pattern",
">",
",",
"Sched",
"<",
"[",
"WriteV",
"]",
">",
"{",
"bits",
"<",
"<NUM_LIT>",
">",
"Rd",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Rn",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Rm",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] |
LLVM | AVR | CPP | code_generation | MPU | 3,729 | [
"AVRTargetLowering",
"::",
"ConstraintWeight",
"AVRTargetLowering",
"::",
"getSingleConstraintMatchWeight",
"(",
"AsmOperandInfo",
"&",
"info",
",",
"const",
"char",
"*",
"constraint",
")",
"const",
"{",
"ConstraintWeight",
"weight",
"=",
"CW_Invalid",
";",
"Value",
"*",
"CallOperandVal",
"=",
"info",
".",
"CallOperandVal",
";",
"if",
"(",
"!",
"CallOperandVal",
")",
"{",
"return",
"CW_Default",
";",
"}",
"switch",
"(",
"*",
"constraint",
")",
"{",
"default",
":",
"weight",
"=",
"TargetLowering",
"::",
"getSingleConstraintMatchWeight",
"(",
"info",
",",
"constraint",
")",
";",
"break",
";",
"case",
"'",
"d",
"'",
":",
"case",
"'",
"r",
"'",
":",
"case",
"'",
"l",
"'",
":",
"weight",
"=",
"CW_Register",
";",
"break",
";",
"case",
"'",
"a",
"'",
":",
"case",
"'",
"b",
"'",
":",
"case",
"'",
"e",
"'",
":",
"case",
"'",
"q",
"'",
":",
"case",
"'",
"t",
"'",
":",
"case",
"'",
"w",
"'",
":",
"case",
"'",
"x",
"'",
":",
"case",
"'",
"X",
"'",
":",
"case",
"'",
"y",
"'",
":",
"case",
"'",
"Y",
"'",
":",
"case",
"'",
"z",
"'",
":",
"case",
"'",
"Z",
"'",
":",
"weight",
"=",
"CW_SpecificReg",
";",
"break",
";",
"case",
"'",
"G",
"'",
":",
"if",
"(",
"const",
"ConstantFP",
"*",
"C",
"=",
"dyn_cast",
"<",
"ConstantFP",
">",
"(",
"CallOperandVal",
")",
")",
"{",
"if",
"(",
"C",
"->",
"isZero",
"(",
")",
")",
"{",
"weight",
"=",
"CW_Constant",
";",
"}",
"}",
"break",
";",
"case",
"'",
"I",
"'",
":",
"if",
"(",
"const",
"ConstantInt",
"*",
"C",
"=",
"dyn_cast",
"<",
"ConstantInt",
">",
"(",
"CallOperandVal",
")",
")",
"{",
"if",
"(",
"isUInt",
"<",
"<NUM_LIT>",
">",
"(",
"C",
"->",
"getZExtValue",
"(",
")",
")",
")",
"{",
"weight",
"=",
"CW_Constant",
";",
"}",
"}",
"break",
";",
"case",
"'",
"J",
"'",
":",
"if",
"(",
"const",
"ConstantInt",
"*",
"C",
"=",
"dyn_cast",
"<",
"ConstantInt",
">",
"(",
"CallOperandVal",
")",
")",
"{",
"if",
"(",
"(",
"C",
"->",
"getSExtValue",
"(",
")",
">=",
"-",
"<NUM_LIT>",
")",
"&&",
"(",
"C",
"->",
"getSExtValue",
"(",
")",
"<=",
"<NUM_LIT>",
")",
")",
"{",
"weight",
"=",
"CW_Constant",
";",
"}",
"}",
"break",
";",
"case",
"'",
"K",
"'",
":",
"if",
"(",
"const",
"ConstantInt",
"*",
"C",
"=",
"dyn_cast",
"<",
"ConstantInt",
">",
"(",
"CallOperandVal",
")",
")",
"{",
"if",
"(",
"C",
"->",
"getZExtValue",
"(",
")",
"==",
"<NUM_LIT>",
")",
"{",
"weight",
"=",
"CW_Constant",
";",
"}",
"}",
"break",
";",
"case",
"'",
"L",
"'",
":",
"if",
"(",
"const",
"ConstantInt",
"*",
"C",
"=",
"dyn_cast",
"<",
"ConstantInt",
">",
"(",
"CallOperandVal",
")",
")",
"{",
"if",
"(",
"C",
"->",
"getZExtValue",
"(",
")",
"==",
"<NUM_LIT>",
")",
"{",
"weight",
"=",
"CW_Constant",
";",
"}",
"}",
"break",
";",
"case",
"'",
"M",
"'",
":",
"if",
"(",
"const",
"ConstantInt",
"*",
"C",
"=",
"dyn_cast",
"<",
"ConstantInt",
">",
"(",
"CallOperandVal",
")",
")",
"{",
"if",
"(",
"isUInt",
"<",
"<NUM_LIT>",
">",
"(",
"C",
"->",
"getZExtValue",
"(",
")",
")",
")",
"{",
"weight",
"=",
"CW_Constant",
";",
"}",
"}",
"break",
";",
"case",
"'",
"N",
"'",
":",
"if",
"(",
"const",
"ConstantInt",
"*",
"C",
"=",
"dyn_cast",
"<",
"ConstantInt",
">",
"(",
"CallOperandVal",
")",
")",
"{",
"if",
"(",
"C",
"->",
"getSExtValue",
"(",
")",
"==",
"-",
"<NUM_LIT>",
")",
"{",
"weight",
"=",
"CW_Constant",
";",
"}",
"}",
"break",
";",
"case",
"'",
"O",
"'",
":",
"if",
"(",
"const",
"ConstantInt",
"*",
"C",
"=",
"dyn_cast",
"<",
"ConstantInt",
">",
"(",
"CallOperandVal",
")",
")",
"{",
"if",
"(",
"(",
"C",
"->",
"getZExtValue",
"(",
")",
"==",
"<NUM_LIT>",
")",
"||",
"(",
"C",
"->",
"getZExtValue",
"(",
")",
"==",
"<NUM_LIT>",
")",
"||",
"(",
"C",
"->",
"getZExtValue",
"(",
")",
"==",
"<NUM_LIT>",
")",
")",
"{",
"weight",
"=",
"CW_Constant",
";",
"}",
"}",
"break",
";",
"case",
"'",
"P",
"'",
":",
"if",
"(",
"const",
"ConstantInt",
"*",
"C",
"=",
"dyn_cast",
"<",
"ConstantInt",
">",
"(",
"CallOperandVal",
")",
")",
"{",
"if",
"(",
"C",
"->",
"getZExtValue",
"(",
")",
"==",
"<NUM_LIT>",
")",
"{",
"weight",
"=",
"CW_Constant",
";",
"}",
"}",
"break",
";",
"case",
"'",
"R",
"'",
":",
"if",
"(",
"const",
"ConstantInt",
"*",
"C",
"=",
"dyn_cast",
"<",
"ConstantInt",
">",
"(",
"CallOperandVal",
")",
")",
"{",
"if",
"(",
"(",
"C",
"->",
"getSExtValue",
"(",
")",
">=",
"-",
"<NUM_LIT>",
")",
"&&",
"(",
"C",
"->",
"getSExtValue",
"(",
")",
"<=",
"<NUM_LIT>",
")",
")",
"{",
"weight",
"=",
"CW_Constant",
";",
"}",
"}",
"break",
";",
"case",
"'",
"Q",
"'",
":",
"weight",
"=",
"CW_Memory",
";",
"break",
";",
"}",
"return",
"weight",
";",
"}"
] | [
"Examine",
"constraint",
"string",
"and",
"operand",
"type",
"and",
"determine",
"a",
"weight",
"value",
"."
] |
LLVM | AMDGPU | CPP | stmt_completion | GPU | 3,730 | [
",",
"SL",
",",
"MVT",
"::",
"i32",
")",
")",
";"
] | [
"if",
"(",
"RHSVal",
"==",
"<NUM_LIT>",
")",
"{",
"SDValue",
"Hi",
"=",
"getHiHalf64",
"(",
"N",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"DAG",
")",
";",
"SDValue",
"NewShift",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SRA",
",",
"SL",
",",
"MVT",
"::",
"i32",
",",
"Hi",
",",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"SL",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"SDValue",
"BuildVec",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"BUILD_VECTOR",
",",
"SL",
",",
"MVT",
"::",
"v2i32",
",",
"Hi",
",",
"NewShift",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"BITCAST",
",",
"SL",
",",
"MVT",
"::",
"i64",
",",
"BuildVec",
")",
";",
"}",
"if",
"(",
"RHSVal",
"==",
"<NUM_LIT>",
")",
"{",
"SDValue",
"Hi",
"=",
"getHiHalf64",
"(",
"N",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"DAG",
")",
";",
"SDValue",
"NewShift",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SRA",
",",
"SL",
",",
"MVT",
"::",
"i32",
",",
"Hi",
",",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>"
] |
LLVM | CSKY | TD | stmt_completion | CPU | 3,731 | [
"}",
";"
] | [
"bits",
"<",
"<NUM_LIT>",
">",
"usdef",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"cpid",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"usdef",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>"
] |
GCC | arm | MD | program_repair | CPU | 3,732 | [
"<FIXS>",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
"<FIXE>"
] | [
"VOIDmode",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"const0_rtx",
")",
"}",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"<BUGS>",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
"<BUGE>",
")",
"(",
"define_insn_and_split",
"<STR_LIT>"
] |
GCC | i386 | MD | program_repair | CPU | 3,733 | [
"<FIXS>",
"<STR_LIT>",
"<FIXE>"
] | [
"(",
"sign_extend",
":",
"V4SI",
"(",
"match_operand",
":",
"V4HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
")",
")",
"]",
"<STR_LIT>",
"<BUGS>",
"<STR_LIT>",
"<BUGE>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"(",
"define_insn",
"<STR_LIT>"
] |
GCC | nds32 | MD | stmt_completion | CPU | 3,734 | [
")",
")"
] | [
"(",
"define_special_predicate",
"<STR_LIT>",
"(",
"match_code",
"<STR_LIT>"
] |
LLVM | Z80 | CPP | stmt_completion | MPU | 3,735 | [
"CodeModel",
"::",
"Model",
"CM",
",",
"CodeGenOpt",
"::",
"Level",
"OL",
")",
"{"
] | [
"static",
"MCCodeGenInfo",
"*",
"createZ80MCCodeGenInfo",
"(",
"StringRef",
"TT",
",",
"Reloc",
"::",
"Model",
"RM",
","
] |
LLVM | ARM | TD | next_suggestion | CPU | 3,736 | [
"}"
] | [
"bit",
"bit_20",
";",
"dag",
"oops",
";",
"dag",
"iops",
";",
"string",
"ops",
";",
"string",
"cstr",
";"
] |
LLVM | Mips | CPP | stmt_completion | CPU | 3,737 | [
";"
] | [
"MachineFunction",
"::",
"iterator",
"It",
"=",
"++",
"BB",
".",
"getIterator",
"(",
")",
";",
"MF",
"->",
"insert",
"(",
"It",
",",
"loop1MBB",
")",
";",
"MF",
"->",
"insert",
"(",
"It",
",",
"loop2MBB",
")",
";",
"MF",
"->",
"insert",
"(",
"It",
",",
"exitMBB",
")",
";",
"exitMBB",
"->",
"splice",
"(",
"exitMBB",
"->",
"begin",
"(",
")",
",",
"&",
"BB",
",",
"std",
"::",
"next",
"(",
"MachineBasicBlock",
"::",
"iterator",
"(",
"I",
")",
")",
",",
"BB",
".",
"end",
"(",
")",
")",
";",
"exitMBB",
"->",
"transferSuccessorsAndUpdatePHIs",
"(",
"&",
"BB",
")",
";",
"BB",
".",
"addSuccessor",
"(",
"loop1MBB",
",",
"BranchProbability",
"::",
"getOne",
"(",
")",
")",
";",
"loop1MBB",
"->",
"addSuccessor",
"(",
"exitMBB",
")",
";",
"loop1MBB",
"->",
"addSuccessor",
"(",
"loop2MBB",
")",
";",
"loop2MBB",
"->",
"addSuccessor",
"(",
"loop1MBB",
")",
";",
"loop2MBB",
"->",
"addSuccessor",
"(",
"exitMBB",
")",
";",
"BuildMI",
"(",
"loop1MBB",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"LL",
")",
",",
"Dest",
")",
".",
"addReg",
"(",
"Ptr",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
")",
";",
"BuildMI",
"(",
"loop1MBB",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"BNE",
")",
")",
".",
"addReg",
"(",
"Dest",
")",
".",
"addReg",
"(",
"OldVal",
")",
".",
"addMBB",
"(",
"exitMBB",
")",
";",
"loop1MBB",
"->",
"addLiveIn",
"(",
"Ptr",
")",
";",
"loop1MBB",
"->",
"addLiveIn",
"(",
"OldVal",
")",
";",
"BuildMI",
"(",
"loop2MBB",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"SC",
")",
",",
"NewVal",
")",
".",
"addReg",
"(",
"NewVal",
")",
".",
"addReg",
"(",
"Ptr",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
")",
";",
"BuildMI",
"(",
"loop2MBB",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"BEQ",
")",
")",
".",
"addReg",
"(",
"NewVal",
",",
"RegState",
"::",
"Kill",
")",
".",
"addReg",
"(",
"ZERO",
")",
".",
"addMBB",
"(",
"loop1MBB",
")",
";",
"loop2MBB",
"->",
"addLiveIn",
"(",
"Ptr",
")",
";",
"loop2MBB",
"->",
"addLiveIn",
"(",
"NewVal",
")"
] |
GCC | iq2000 | MD | stmt_completion | CPU | 3,738 | [
"]",
")"
] | [
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"\t",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"\t",
"<STR_LIT>",
")"
] |
GCC | i386 | CPP | stmt_completion | CPU | 3,739 | [
"(",
"_",
"_",
"mmask8",
")",
"_",
"_",
"U",
")",
";"
] | [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m128i",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm256_maskz_cvttpd_epu32",
"(",
"_",
"_",
"mmask8",
"_",
"_",
"U",
",",
"_",
"_",
"m256d",
"_",
"_",
"A",
")",
"{",
"return",
"(",
"_",
"_",
"m128i",
")",
"_",
"_",
"builtin_ia32_cvttpd2udq256_mask",
"(",
"(",
"_",
"_",
"v4df",
")",
"_",
"_",
"A",
",",
"(",
"_",
"_",
"v4si",
")",
"_",
"mm_avx512_setzero_si128",
"(",
")",
","
] |
GCC | i386 | MD | stmt_completion | CPU | 3,740 | [
"<NUM_LIT>",
"<STR_LIT>",
")",
")",
")",
"]"
] | [
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_operand",
":",
"<",
"avx512fmaskmode",
">"
] |
GCC | c6x | CPP | stmt_completion | VLIW | 3,741 | [
"<NUM_LIT>",
"]",
",",
"VOIDmode",
")",
";"
] | [
"FOR_EACH_BB_FN",
"(",
"bb",
",",
"cfun",
")",
"{",
"rtx_insn",
"*",
"insn",
",",
"*",
"next",
";",
"rtx_insn",
"*",
"slot",
"[",
"<NUM_LIT>",
"]",
";",
"int",
"n_filled",
"=",
"<NUM_LIT>",
";",
"int",
"first_slot",
"=",
"<NUM_LIT>",
";",
"for",
"(",
"insn",
"=",
"BB_HEAD",
"(",
"bb",
")",
";",
";",
"insn",
"=",
"next",
")",
"{",
"int",
"at_end",
";",
"rtx",
"delete",
"_",
"this",
"=",
"NULL_RTX",
";",
"if",
"(",
"NONDEBUG_INSN_P",
"(",
"insn",
")",
")",
"{",
"if",
"(",
"CALL_P",
"(",
"insn",
")",
")",
"{",
"first_slot",
"++",
";",
"if",
"(",
"n_filled",
")",
"{",
"memmove",
"(",
"&",
"slot",
"[",
"<NUM_LIT>",
"]",
",",
"&",
"slot",
"[",
"<NUM_LIT>",
"]",
",",
"n_filled",
"*",
"sizeof",
"(",
"slot",
"[",
"<NUM_LIT>",
"]",
")",
")",
";",
"}",
"if",
"(",
"!",
"shadow_p",
"(",
"insn",
")",
")",
"{",
"PUT_MODE",
"(",
"insn",
",",
"TImode",
")",
";",
"if",
"(",
"n_filled",
")",
"PUT_MODE",
"(",
"slot",
"["
] |
GCC | h8300 | MD | next_suggestion | MPU | 3,742 | [
"[",
"(",
"parallel",
"[",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")"
] | [
"[",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"and",
":",
"SI",
"(",
"lshiftrt",
":",
"SI",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"<STR_LIT>"
] |
GCC | h8300 | CPP | program_repair | MPU | 3,743 | [
"<FIXS>",
"if",
"(",
"satisfies_constraint_G",
"(",
"src",
")",
")",
"<FIXE>"
] | [
"if",
"(",
"REG_P",
"(",
"src",
")",
")",
"return",
"<NUM_LIT>",
";",
"<BUGS>",
"if",
"(",
"CONST_DOUBLE_OK_FOR_LETTER_P",
"(",
"src",
",",
"'",
"G",
"'",
")",
")",
"<BUGE>",
"return",
"<NUM_LIT>",
";",
"return",
"<NUM_LIT>",
";"
] |
LLVM | ARM | CPP | code_generation | CPU | 3,744 | [
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"<STR_LIT>",
"ARM MLA / MLS expansion pass",
"<STR_LIT>",
";",
"}"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] |
LLVM | X86 | CPP | stmt_completion | CPU | 3,745 | [
">",
"<NUM_LIT>",
")",
"{"
] | [
"SDValue",
"BC",
"=",
"peekThroughBitcasts",
"(",
"V",
")",
";",
"if",
"(",
"(",
"V",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"BUILD_VECTOR",
"&&",
"V",
".",
"hasOneUse",
"(",
")",
")",
"||",
"(",
"V",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SCALAR_TO_VECTOR",
"&&",
"BroadcastIdx",
"==",
"<NUM_LIT>",
")",
")",
"{",
"V",
"=",
"V",
".",
"getOperand",
"(",
"BroadcastIdx",
")",
";",
"if",
"(",
"!",
"BroadcastFromReg",
"&&",
"!",
"isShuffleFoldableLoad",
"(",
"V",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"}",
"else",
"if",
"(",
"MayFoldLoad",
"(",
"BC",
")",
"&&",
"!",
"cast",
"<",
"LoadSDNode",
">",
"(",
"BC",
")",
"->",
"isVolatile",
"(",
")",
")",
"{",
"if",
"(",
"!",
"Subtarget",
".",
"is64Bit",
"(",
")",
"&&",
"VT",
".",
"getScalarType",
"(",
")",
"==",
"MVT",
"::",
"i64",
")",
"{",
"BroadcastVT",
"=",
"MVT",
"::",
"getVectorVT",
"(",
"MVT",
"::",
"f64",
",",
"VT",
".",
"getVectorNumElements",
"(",
")",
")",
";",
"Opcode",
"=",
"(",
"BroadcastVT",
".",
"is128BitVector",
"(",
")",
"&&",
"!",
"Subtarget",
".",
"hasAVX2",
"(",
")",
")",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"Opcode",
";",
"}",
"LoadSDNode",
"*",
"Ld",
"=",
"cast",
"<",
"LoadSDNode",
">",
"(",
"BC",
")",
";",
"SDValue",
"BaseAddr",
"=",
"Ld",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"EVT",
"SVT",
"=",
"BroadcastVT",
".",
"getScalarType",
"(",
")",
";",
"unsigned",
"Offset",
"=",
"BroadcastIdx",
"*",
"SVT",
".",
"getStoreSize",
"(",
")",
";",
"SDValue",
"NewAddr",
"=",
"DAG",
".",
"getMemBasePlusOffset",
"(",
"BaseAddr",
",",
"Offset",
",",
"DL",
")",
";",
"V",
"=",
"DAG",
".",
"getLoad",
"(",
"SVT",
",",
"DL",
",",
"Ld",
"->",
"getChain",
"(",
")",
",",
"NewAddr",
",",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getMachineMemOperand",
"(",
"Ld",
"->",
"getMemOperand",
"(",
")",
",",
"Offset",
",",
"SVT",
".",
"getStoreSize",
"(",
")",
")",
")",
";",
"DAG",
".",
"makeEquivalentMemoryOrdering",
"(",
"Ld",
",",
"V",
")",
";",
"}",
"else",
"if",
"(",
"!",
"BroadcastFromReg",
")",
"{",
"return",
"SDValue",
"(",
")",
";",
"}",
"else",
"if",
"(",
"BroadcastIdx",
"!=",
"<NUM_LIT>",
")",
"{",
"if",
"(",
"!",
"VT",
".",
"is256BitVector",
"(",
")",
"&&",
"!",
"VT",
".",
"is512BitVector",
"(",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"v4f64",
"||",
"VT",
"==",
"MVT",
"::",
"v4i64",
")",
"return",
"SDValue",
"(",
")",
";",
"unsigned",
"EltSize",
"=",
"VT",
".",
"getScalarSizeInBits",
"(",
")",
";",
"if",
"(",
"(",
"(",
"BroadcastIdx",
"*",
"EltSize",
")",
"%",
"<NUM_LIT>",
")",
"!=",
"<NUM_LIT>",
")",
"return",
"SDValue",
"(",
")",
";",
"assert",
"(",
"V",
".",
"getScalarValueSizeInBits",
"(",
")",
"==",
"BroadcastVT",
".",
"getScalarSizeInBits",
"(",
")",
"&&",
"<STR_LIT>",
"Unexpected vector element size",
"<STR_LIT>",
")",
";",
"assert",
"(",
"(",
"V",
".",
"getValueSizeInBits",
"(",
")",
"==",
"<NUM_LIT>",
"||",
"V",
".",
"getValueSizeInBits",
"(",
")",
"==",
"<NUM_LIT>",
")",
"&&",
"<STR_LIT>",
"Unexpected vector size",
"<STR_LIT>",
")",
";",
"V",
"=",
"extract128BitVector",
"(",
"V",
",",
"BroadcastIdx",
",",
"DAG",
",",
"DL",
")",
";",
"}",
"if",
"(",
"Opcode",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
"&&",
"!",
"V",
".",
"getValueType",
"(",
")",
".",
"isVector",
"(",
")",
")",
"V",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SCALAR_TO_VECTOR",
",",
"DL",
",",
"MVT",
"::",
"v2f64",
",",
"DAG",
".",
"getBitcast",
"(",
"MVT",
"::",
"f64",
",",
"V",
")",
")",
";",
"MVT",
"SrcVT",
"=",
"V",
".",
"getSimpleValueType",
"(",
")",
";",
"if",
"(",
"SrcVT",
".",
"getScalarType",
"(",
")",
"!=",
"BroadcastVT",
".",
"getScalarType",
"(",
")",
")",
"{",
"assert",
"(",
"SrcVT",
".",
"getScalarSizeInBits",
"(",
")",
"==",
"BroadcastVT",
".",
"getScalarSizeInBits",
"(",
")",
"&&",
"<STR_LIT>",
"Unexpected vector element size",
"<STR_LIT>",
")",
";",
"if",
"(",
"SrcVT",
".",
"isVector",
"(",
")",
")",
"{",
"unsigned",
"NumSrcElts",
"=",
"SrcVT",
".",
"getVectorNumElements",
"(",
")",
";",
"SrcVT",
"=",
"MVT",
"::",
"getVectorVT",
"(",
"BroadcastVT",
".",
"getScalarType",
"(",
")",
",",
"NumSrcElts",
")",
";",
"}",
"else",
"{",
"SrcVT",
"=",
"BroadcastVT",
".",
"getScalarType",
"(",
")",
";",
"}",
"V",
"=",
"DAG",
".",
"getBitcast",
"(",
"SrcVT",
",",
"V",
")",
";",
"}",
"if",
"(",
"!",
"Subtarget",
".",
"is64Bit",
"(",
")",
"&&",
"SrcVT",
"==",
"MVT",
"::",
"i64",
")",
"{",
"V",
"=",
"DAG",
".",
"getBitcast",
"(",
"MVT",
"::",
"f64",
",",
"V",
")",
";",
"unsigned",
"NumBroadcastElts",
"=",
"BroadcastVT",
".",
"getVectorNumElements",
"(",
")",
";",
"BroadcastVT",
"=",
"MVT",
"::",
"getVectorVT",
"(",
"MVT",
"::",
"f64",
",",
"NumBroadcastElts",
")",
";",
"}",
"if",
"(",
"SrcVT",
".",
"getSizeInBits",
"(",
")"
] |
LLVM | LoongArch | CPP | stmt_completion | CPU | 3,746 | [
",",
"DL",
",",
"ResTy",
")",
";"
] | [
"EVT",
"ResTy",
"=",
"Node",
"->",
"getValueType",
"(",
"<NUM_LIT>",
")",
";",
"auto",
"*",
"CImm",
"=",
"cast",
"<",
"ConstantSDNode",
">",
"(",
"Node",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"if",
"(",
"!",
"isUInt",
"<",
"N",
">",
"(",
"CImm",
"->",
"getZExtValue",
"(",
")",
")",
")",
"{",
"DAG",
".",
"getContext",
"(",
")",
"->",
"emitError",
"(",
"Node",
"->",
"getOperationName",
"(",
"<NUM_LIT>",
")",
"+",
"<STR_LIT>",
": argument out of range.",
"<STR_LIT>",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"UNDEF"
] |
GCC | ia64 | MD | next_suggestion | CPU | 3,747 | [
"rtx",
"rh",
"=",
"gen_highpart",
"(",
"DImode",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
")"
] | [
"<STR_LIT>",
"[",
"(",
"const_int",
"<NUM_LIT>",
")",
"]",
"{",
"HOST_WIDE_INT",
"shift",
"=",
"INTVAL",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
"rtx",
"rl",
"=",
"gen_lowpart",
"(",
"DImode",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
")"
] |
LLVM | TPC | TD | stmt_completion | Virtual ISA | 3,748 | [
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";"
] | [
"let",
"OperandType",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"sw",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"OperandType",
"{",
"<NUM_LIT>",
"}",
"=",
"sw",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"Switches",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"sw",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"PredAddress",
"=",
"pred",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"PredPolarity",
"=",
"pred",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"VectorPred",
"=",
"!",
"eq",
"(",
"!",
"cast",
"<",
"string",
">",
"(",
"Pred",
")",
",",
"<STR_LIT>",
")",
";",
"let",
"HasImm",
"=",
"hasImm",
";",
"let",
"immOpNum",
"=",
"!",
"if",
"(",
"hasImm"
] |
LLVM | TPC | TD | stmt_completion | Virtual ISA | 3,749 | [
"<NUM_LIT>",
";"
] | [
"def",
"SwitchVal",
"{",
"bits",
"<",
"<NUM_LIT>",
">",
"SW_DOUBLE_AND_ROUND32",
"=",
"<NUM_LIT>",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"SW_ACC_FP32",
"=",
"<NUM_LIT>",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"SW_UPPER32",
"=",
"<NUM_LIT>",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"SW_AUTO_INC",
"=",
"<NUM_LIT>",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"SW_FORCE_SIGN0",
"=",
"<NUM_LIT>",
";",
"int",
"RM_DEFAULT",
"=",
"<NUM_LIT>",
";",
"int",
"RM_G1_RHNE",
"=",
"<NUM_LIT>",
";",
"int",
"RM_G1_RD",
"=",
"<NUM_LIT>",
";",
"int",
"RM_G1_RU",
"=",
"<NUM_LIT>",
";",
"int",
"RM_G1_SR",
"=",
"<NUM_LIT>",
";",
"int",
"CVT_G1_RZ",
"=",
"<NUM_LIT>",
";",
"int",
"RM_RHNE",
"=",
"<NUM_LIT>",
";",
"int",
"RM_RZ",
"=",
"<NUM_LIT>",
";",
"int",
"RM_RU",
"=",
"<NUM_LIT>",
";",
"int",
"RM_RD",
"=",
"<NUM_LIT>",
";",
"int",
"RM_SR",
"=",
"<NUM_LIT>",
";",
"int",
"RM_RHAZ",
"=",
"<NUM_LIT>",
";",
"int",
"TO_FP32",
"=",
"<NUM_LIT>",
";",
"int",
"TO_BF16",
"=",
"<NUM_LIT>",
";",
"int",
"TO_INT32",
"=",
"<NUM_LIT>",
";",
"int",
"TO_UINT32",
"=",
"<NUM_LIT>",
";",
"int",
"TO_INT8",
"=",
"<NUM_LIT>",
";",
"int",
"TO_UINT8",
"=",
"<NUM_LIT>",
";",
"int",
"TO_INT16",
"=",
"<NUM_LIT>",
";",
"int",
"TO_UINT16",
"="
] |
LLVM | BPF | CPP | stmt_completion | Virtual ISA | 3,750 | [
"BPFISD::Wrapper",
"<STR_LIT>",
";"
] | [
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"return",
"<STR_LIT>",
"BPFISD::RET_FLAG",
"<STR_LIT>",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"return",
"<STR_LIT>",
"BPFISD::CALL",
"<STR_LIT>",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"return",
"<STR_LIT>",
"BPFISD::SELECT_CC",
"<STR_LIT>",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"return",
"<STR_LIT>",
"BPFISD::BR_CC",
"<STR_LIT>",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"return",
"<STR_LIT>"
] |
GCC | i386 | CPP | stmt_completion | CPU | 3,751 | [
"_",
"m256d",
"_",
"_",
"A",
")",
"{"
] | [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m128i",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm256_cvttpd_epi32",
"(",
"_"
] |
GCC | s390 | CPP | stmt_completion | MPU | 3,752 | [
";"
] | [
"if",
"(",
"GENERAL_REGNO_P",
"(",
"new",
"_",
"reg",
")",
"&&",
"!",
"call_used_regs",
"[",
"new",
"_",
"reg",
"]",
"&&",
"cfun_gpr_save_slot",
"(",
"new",
"_",
"reg",
")",
"==",
"SAVE_SLOT_NONE",
")",
"return",
"false",
";",
"return",
"true"
] |
GCC | i386 | CPP | stmt_completion | CPU | 3,753 | [
",",
"_",
"_",
"m128d",
"_",
"_",
"B",
")",
"{"
] | [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m128d",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm_cmpord_sd",
"(",
"_",
"_",
"m128d",
"_",
"_",
"A"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 3,754 | [
"}"
] | [
"void",
"addMem256Operands",
"(",
"MCInst",
"&",
"Inst",
",",
"unsigned",
"N",
")",
"const",
"{",
"addMemOperands",
"(",
"Inst",
",",
"N",
")",
";"
] |
GCC | m68k | MD | next_suggestion | MPU | 3,755 | [
"<STR_LIT>",
")"
] | [
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")"
] |
GCC | rs6000 | CPP | program_repair | CPU | 3,756 | [
"<FIXS>",
"&&",
"(",
"ALTIVEC_OR_VSX_VECTOR_MODE",
"(",
"elt_mode",
")",
"<FIXE>",
"<FIXS>",
"if",
"(",
"USE_ALTIVEC_FOR_ARG_P",
"(",
"cum",
",",
"elt_mode",
",",
"named",
")",
")",
"<FIXE>",
"<FIXS>",
"cum",
"->",
"vregno",
"+=",
"n_elts",
";",
"<FIXE>"
] | [
"#",
"endifif",
"(",
"TARGET_ALTIVEC_ABI",
"<BUGS>",
"&&",
"(",
"ALTIVEC_OR_VSX_VECTOR_MODE",
"(",
"mode",
")",
"<BUGE>",
"||",
"(",
"type",
"&&",
"TREE_CODE",
"(",
"type",
")",
"==",
"VECTOR_TYPE",
"&&",
"int_size_in_bytes",
"(",
"type",
")",
"==",
"<NUM_LIT>",
")",
")",
")",
"{",
"bool",
"stack",
"=",
"false",
";",
"<BUGS>",
"if",
"(",
"USE_ALTIVEC_FOR_ARG_P",
"(",
"cum",
",",
"mode",
",",
"named",
")",
")",
"<BUGE>",
"{",
"<BUGS>",
"cum",
"->",
"vregno",
"++",
";",
"<BUGE>",
"if",
"(",
"!",
"TARGET_ALTIVEC",
")",
"error",
"(",
"<STR_LIT>",
"cannot pass argument in vector register because",
"<STR_LIT>",
"<STR_LIT>",
" altivec instructions are disabled, use -maltivec",
"<STR_LIT>"
] |
GCC | tilepro | MD | stmt_completion | VLIW | 3,757 | [
")",
")",
")"
] | [
"if",
"(",
"memory_operand",
"(",
"op",
",",
"mode",
")",
")",
"return",
"nonautoinc_operand",
"(",
"XEXP",
"(",
"op",
",",
"<NUM_LIT>",
")",
",",
"GET_MODE",
"(",
"XEXP",
"(",
"op",
",",
"<NUM_LIT>"
] |
LLVM | ARM | TD | program_repair | CPU | 3,758 | [
"<FIXS>",
"(",
"COPY_TO_REGCLASS",
"(",
"VCVTBDH",
"(",
"IMPLICIT_DEF",
")",
",",
"DPR",
":",
"$",
"Dm",
")",
",",
"HPR",
")",
">",
",",
"<FIXE>",
"<FIXS>",
"(",
"i32",
"(",
"COPY_TO_REGCLASS",
"(",
"VCVTBDH",
"(",
"IMPLICIT_DEF",
")",
",",
"DPR",
":",
"$",
"a",
")",
",",
"GPR",
")",
")",
">",
",",
"<FIXE>",
"<FIXS>",
"NoItinerary",
",",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"<FIXE>"
] | [
"}",
"def",
":",
"FullFP16Pat",
"(",
"f16",
"(",
"fpround",
"DPR",
":",
"$",
"Dm",
")",
")",
",",
"<BUGS>",
"(",
"COPY_TO_REGCLASS",
"(",
"VCVTBDH",
"DPR",
":",
"$",
"Dm",
")",
",",
"HPR",
")",
">",
",",
"<BUGE>",
"Requires",
"[",
"HasFPARMv8",
",",
"HasDPVFP",
"]",
">",
";",
"def",
":",
"FP16Pat",
"(",
"fp_to_f16",
"(",
"f64",
"DPR",
":",
"$",
"a",
")",
")",
",",
"<BUGS>",
"(",
"i32",
"(",
"COPY_TO_REGCLASS",
"(",
"VCVTBDH",
"DPR",
":",
"$",
"a",
")",
",",
"GPR",
")",
")",
">",
",",
"<BUGE>",
"Requires",
"[",
"HasFPARMv8",
",",
"HasDPVFP",
"]",
">",
";",
"def",
"VCVTTHD",
":",
"ADuI",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"(",
"outs",
"DPR",
":",
"$",
"Dd",
")",
",",
"(",
"ins",
"SPR",
":",
"$",
"Sm",
")",
",",
"<BUGS>",
"NoItinerary",
",",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"<BUGE>",
"[",
"]",
">",
",",
"Requires",
"[",
"HasFPARMv8",
",",
"HasDPVFP",
"]",
">",
"{",
"bits",
"<NUM_LIT>",
">",
"Sm",
";"
] |
GCC | rs6000 | CPP | code_generation | CPU | 3,759 | [
"void",
"rs6000_emit_swdiv",
"(",
"rtx",
"dst",
",",
"rtx",
"n",
",",
"rtx",
"d",
",",
"bool",
"not",
"e_p",
")",
"{",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"dst",
")",
";",
"rtx",
"one",
",",
"x0",
",",
"e0",
",",
"x1",
",",
"xprev",
",",
"eprev",
",",
"xnext",
",",
"enext",
",",
"u",
",",
"v",
";",
"int",
"i",
";",
"int",
"passes",
"=",
"(",
"TARGET_RECIP_PRECISION",
")",
"?",
"<NUM_LIT>",
":",
"<NUM_LIT>",
";",
"if",
"(",
"mode",
"==",
"DFmode",
"||",
"mode",
"==",
"V2DFmode",
")",
"passes",
"++",
";",
"enum",
"insn_code",
"code",
"=",
"optab_handler",
"(",
"smul_optab",
",",
"mode",
")",
";",
"insn_gen_fn",
"gen_mul",
"=",
"GEN_FCN",
"(",
"code",
")",
";",
"gcc_assert",
"(",
"code",
"!=",
"CODE_FOR_nothing",
")",
";",
"one",
"=",
"rs6000_load_constant_and_splat",
"(",
"mode",
",",
"dconst1",
")",
";",
"x0",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"x0",
",",
"gen_rtx_UNSPEC",
"(",
"mode",
",",
"gen_rtvec",
"(",
"<NUM_LIT>",
",",
"d",
")",
",",
"UNSPEC_FRES",
")",
")",
")",
";",
"if",
"(",
"passes",
">",
"<NUM_LIT>",
")",
"{",
"e0",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"rs6000_emit_nmsub",
"(",
"e0",
",",
"d",
",",
"x0",
",",
"one",
")",
";",
"x1",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"rs6000_emit_madd",
"(",
"x1",
",",
"e0",
",",
"x0",
",",
"x0",
")",
";",
"for",
"(",
"i",
"=",
"<NUM_LIT>",
",",
"xprev",
"=",
"x1",
",",
"eprev",
"=",
"e0",
";",
"i",
"<",
"passes",
"-",
"<NUM_LIT>",
";",
"++",
"i",
",",
"xprev",
"=",
"xnext",
",",
"eprev",
"=",
"enext",
")",
"{",
"enext",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"emit_insn",
"(",
"gen_mul",
"(",
"enext",
",",
"eprev",
",",
"eprev",
")",
")",
";",
"xnext",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"rs6000_emit_madd",
"(",
"xnext",
",",
"enext",
",",
"xprev",
",",
"xprev",
")",
";",
"}",
"}",
"else",
"xprev",
"=",
"x0",
";",
"u",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"emit_insn",
"(",
"gen_mul",
"(",
"u",
",",
"n",
",",
"xprev",
")",
")",
";",
"v",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"rs6000_emit_nmsub",
"(",
"v",
",",
"d",
",",
"u",
",",
"n",
")",
";",
"rs6000_emit_madd",
"(",
"dst",
",",
"v",
",",
"xprev",
",",
"u",
")",
";",
"if",
"(",
"not",
"e_p",
")",
"add_reg_note",
"(",
"get_last_insn",
"(",
")",
",",
"REG_EQUAL",
",",
"gen_rtx_DIV",
"(",
"mode",
",",
"n",
",",
"d",
")",
")",
";",
"}"
] | [
"Newton-Raphson",
"approximation",
"of",
"floating",
"point",
"divide",
"DST",
"=",
"N/D",
".",
"If",
"NOTE_P",
",",
"add",
"a",
"reg_note",
"saying",
"that",
"this",
"was",
"a",
"division",
".",
"Support",
"both",
"scalar",
"and",
"vector",
"divide",
".",
"Assumes",
"no",
"trapping",
"math",
"and",
"finite",
"arguments",
"."
] |
LLVM | AMDGPU | CPP | stmt_completion | GPU | 3,760 | [
"(",
")",
"-",
"NumElements",
";"
] | [
"allocateSpecialEntryInputVGPRs",
"(",
"CCInfo",
",",
"MF",
",",
"*",
"TRI",
",",
"*",
"Info",
")",
";",
"allocateHSAUserSGPRs",
"(",
"CCInfo",
",",
"MF",
",",
"*",
"TRI",
",",
"*",
"Info",
")",
";",
"}",
"if",
"(",
"IsKernel",
")",
"{",
"analyzeFormalArgumentsCompute",
"(",
"CCInfo",
",",
"Ins",
")",
";",
"}",
"else",
"{",
"CCAssignFn",
"*",
"AssignFn",
"=",
"CCAssignFnForCall",
"(",
"CallConv",
",",
"isVarArg",
")",
";",
"CCInfo",
".",
"AnalyzeFormalArguments",
"(",
"Splits",
",",
"AssignFn",
")",
";",
"}",
"SmallVector",
"<",
"SDValue",
",",
"<NUM_LIT>",
">",
"Chains",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
",",
"e",
"=",
"Ins",
".",
"size",
"(",
")",
",",
"ArgIdx",
"=",
"<NUM_LIT>",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"const",
"ISD",
"::",
"InputArg",
"&",
"Arg",
"=",
"Ins",
"[",
"i",
"]",
";",
"if",
"(",
"Skipped",
"[",
"i",
"]",
")",
"{",
"InVals",
".",
"push_back",
"(",
"DAG",
".",
"getUNDEF",
"(",
"Arg",
".",
"VT",
")",
")",
";",
"continue",
";",
"}",
"CCValAssign",
"&",
"VA",
"=",
"ArgLocs",
"[",
"ArgIdx",
"++",
"]",
";",
"MVT",
"VT",
"=",
"VA",
".",
"getLocVT",
"(",
")",
";",
"if",
"(",
"IsEntryFunc",
"&&",
"VA",
".",
"isMemLoc",
"(",
")",
")",
"{",
"VT",
"=",
"Ins",
"[",
"i",
"]",
".",
"VT",
";",
"EVT",
"MemVT",
"=",
"VA",
".",
"getLocVT",
"(",
")",
";",
"const",
"uint64_t",
"Offset",
"=",
"Subtarget",
"->",
"getExplicitKernelArgOffset",
"(",
"MF",
")",
"+",
"VA",
".",
"getLocMemOffset",
"(",
")",
";",
"Info",
"->",
"setABIArgOffset",
"(",
"Offset",
"+",
"MemVT",
".",
"getStoreSize",
"(",
")",
")",
";",
"SDValue",
"Arg",
"=",
"lowerKernargMemParameter",
"(",
"DAG",
",",
"VT",
",",
"MemVT",
",",
"DL",
",",
"Chain",
",",
"Offset",
",",
"Ins",
"[",
"i",
"]",
".",
"Flags",
".",
"isSExt",
"(",
")",
",",
"&",
"Ins",
"[",
"i",
"]",
")",
";",
"Chains",
".",
"push_back",
"(",
"Arg",
".",
"getValue",
"(",
"<NUM_LIT>",
")",
")",
";",
"auto",
"*",
"ParamTy",
"=",
"dyn_cast",
"<",
"PointerType",
">",
"(",
"FType",
"->",
"getParamType",
"(",
"Ins",
"[",
"i",
"]",
".",
"getOrigArgIndex",
"(",
")",
")",
")",
";",
"if",
"(",
"Subtarget",
"->",
"getGeneration",
"(",
")",
"==",
"SISubtarget",
"::",
"SOUTHERN_ISLANDS",
"&&",
"ParamTy",
"&&",
"ParamTy",
"->",
"getAddressSpace",
"(",
")",
"==",
"AMDGPUAS",
"::",
"LOCAL_ADDRESS",
")",
"{",
"Arg",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"AssertZext",
",",
"DL",
",",
"Arg",
".",
"getValueType",
"(",
")",
",",
"Arg",
",",
"DAG",
".",
"getValueType",
"(",
"MVT",
"::",
"i16",
")",
")",
";",
"}",
"InVals",
".",
"push_back",
"(",
"Arg",
")",
";",
"continue",
";",
"}",
"else",
"if",
"(",
"!",
"IsEntryFunc",
"&&",
"VA",
".",
"isMemLoc",
"(",
")",
")",
"{",
"SDValue",
"Val",
"=",
"lowerStackParameter",
"(",
"DAG",
",",
"VA",
",",
"DL",
",",
"Chain",
",",
"Arg",
")",
";",
"InVals",
".",
"push_back",
"(",
"Val",
")",
";",
"if",
"(",
"!",
"Arg",
".",
"Flags",
".",
"isByVal",
"(",
")",
")",
"Chains",
".",
"push_back",
"(",
"Val",
".",
"getValue",
"(",
"<NUM_LIT>",
")",
")",
";",
"continue",
";",
"}",
"assert",
"(",
"VA",
".",
"isRegLoc",
"(",
")",
"&&",
"<STR_LIT>",
"Parameter must be in a register!",
"<STR_LIT>",
")",
";",
"unsigned",
"Reg",
"=",
"VA",
".",
"getLocReg",
"(",
")",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"TRI",
"->",
"getMinimalPhysRegClass",
"(",
"Reg",
",",
"VT",
")",
";",
"EVT",
"ValVT",
"=",
"VA",
".",
"getValVT",
"(",
")",
";",
"Reg",
"=",
"MF",
".",
"addLiveIn",
"(",
"Reg",
",",
"RC",
")",
";",
"SDValue",
"Val",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"DL",
",",
"Reg",
",",
"VT",
")",
";",
"switch",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
")",
"{",
"case",
"CCValAssign",
"::",
"Full",
":",
"break",
";",
"case",
"CCValAssign",
"::",
"BCvt",
":",
"Val",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"BITCAST",
",",
"DL",
",",
"ValVT",
",",
"Val",
")",
";",
"break",
";",
"case",
"CCValAssign",
"::",
"SExt",
":",
"Val",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"AssertSext",
",",
"DL",
",",
"VT",
",",
"Val",
",",
"DAG",
".",
"getValueType",
"(",
"ValVT",
")",
")",
";",
"Val",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"TRUNCATE",
",",
"DL",
",",
"ValVT",
",",
"Val",
")",
";",
"break",
";",
"case",
"CCValAssign",
"::",
"ZExt",
":",
"Val",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"AssertZext",
",",
"DL",
",",
"VT",
",",
"Val",
",",
"DAG",
".",
"getValueType",
"(",
"ValVT",
")",
")",
";",
"Val",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"TRUNCATE",
",",
"DL",
",",
"ValVT",
",",
"Val",
")",
";",
"break",
";",
"case",
"CCValAssign",
"::",
"AExt",
":",
"Val",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"TRUNCATE",
",",
"DL",
",",
"ValVT",
",",
"Val",
")",
";",
"break",
";",
"default",
":",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Unknown loc info!",
"<STR_LIT>",
")",
";",
"}",
"if",
"(",
"IsShader",
"&&",
"Arg",
".",
"VT",
".",
"isVector",
"(",
")",
")",
"{",
"Type",
"*",
"ParamType",
"=",
"FType",
"->",
"getParamType",
"(",
"Arg",
".",
"getOrigArgIndex",
"(",
")",
")",
";",
"unsigned",
"NumElements",
"=",
"ParamType",
"->",
"getVectorNumElements",
"(",
")",
";",
"SmallVector",
"<",
"SDValue",
",",
"<NUM_LIT>",
">",
"Regs",
";",
"Regs",
".",
"push_back",
"(",
"Val",
")",
";",
"for",
"(",
"unsigned",
"j",
"=",
"<NUM_LIT>",
";",
"j",
"!=",
"NumElements",
";",
"++",
"j",
")",
"{",
"Reg",
"=",
"ArgLocs",
"[",
"ArgIdx",
"++",
"]",
".",
"getLocReg",
"(",
")",
";",
"Reg",
"=",
"MF",
".",
"addLiveIn",
"(",
"Reg",
",",
"RC",
")",
";",
"SDValue",
"Copy",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"DL",
",",
"Reg",
",",
"VT",
")",
";",
"Regs",
".",
"push_back",
"(",
"Copy",
")",
";",
"}",
"NumElements",
"=",
"Arg",
".",
"VT",
".",
"getVectorNumElements"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 3,761 | [
"=",
"<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",
"prefersSlot3"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 3,762 | [
"case",
"ARM",
"::",
"fixup_t2_ldst_pcrel_12",
":"
] | [
"return",
"<NUM_LIT>",
";",
"case",
"FK_Data_2",
":",
"return",
"<NUM_LIT>",
";",
"case",
"FK_Data_4",
":",
"return",
"<NUM_LIT>",
";",
"case",
"ARM",
"::",
"fixup_arm_thumb_bcc",
":",
"case",
"ARM",
"::",
"fixup_arm_thumb_cp",
":",
"case",
"ARM",
"::",
"fixup_thumb_adr_pcrel_10",
":",
"case",
"ARM",
"::",
"fixup_arm_thumb_br",
":",
"case",
"ARM",
"::",
"fixup_arm_thumb_cb",
":",
"return",
"<NUM_LIT>",
";",
"case",
"ARM",
"::",
"fixup_arm_pcrel_10_unscaled",
":",
"case",
"ARM",
"::",
"fixup_arm_ldst_pcrel_12",
":",
"case",
"ARM",
"::",
"fixup_arm_pcrel_10",
":",
"case",
"ARM",
"::",
"fixup_arm_adr_pcrel_12",
":",
"case",
"ARM",
"::",
"fixup_arm_uncondbl",
":",
"case",
"ARM",
"::",
"fixup_arm_condbl",
":",
"case",
"ARM",
"::",
"fixup_arm_blx",
":",
"case",
"ARM",
"::",
"fixup_arm_condbranch",
":",
"case",
"ARM",
"::",
"fixup_arm_uncondbranch",
":"
] |
LLVM | PowerPC | CPP | stmt_completion | CPU | 3,763 | [
"::",
"DIVW",
")",
",",
"Div",
")",
".",
"addReg",
"(",
"ActualNegSizeReg",
")",
".",
"addReg",
"(",
"ScratchReg",
")",
";"
] | [
"const",
"bool",
"isPPC64",
"=",
"Subtarget",
".",
"isPPC64",
"(",
")",
";",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
"->",
"getParent",
"(",
")",
";",
"const",
"TargetInstrInfo",
"*",
"TII",
"=",
"Subtarget",
".",
"getInstrInfo",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"MI",
".",
"getDebugLoc",
"(",
")",
";",
"const",
"unsigned",
"ProbeSize",
"=",
"getStackProbeSize",
"(",
"*",
"MF",
")",
";",
"const",
"BasicBlock",
"*",
"ProbedBB",
"=",
"MBB",
"->",
"getBasicBlock",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"MachineBasicBlock",
"*",
"TestMBB",
"=",
"MF",
"->",
"CreateMachineBasicBlock",
"(",
"ProbedBB",
")",
";",
"MachineBasicBlock",
"*",
"TailMBB",
"=",
"MF",
"->",
"CreateMachineBasicBlock",
"(",
"ProbedBB",
")",
";",
"MachineBasicBlock",
"*",
"BlockMBB",
"=",
"MF",
"->",
"CreateMachineBasicBlock",
"(",
"ProbedBB",
")",
";",
"MachineFunction",
"::",
"iterator",
"MBBIter",
"=",
"++",
"MBB",
"->",
"getIterator",
"(",
")",
";",
"MF",
"->",
"insert",
"(",
"MBBIter",
",",
"TestMBB",
")",
";",
"MF",
"->",
"insert",
"(",
"MBBIter",
",",
"BlockMBB",
")",
";",
"MF",
"->",
"insert",
"(",
"MBBIter",
",",
"TailMBB",
")",
";",
"const",
"TargetRegisterClass",
"*",
"G8RC",
"=",
"&",
"PPC",
"::",
"G8RCRegClass",
";",
"const",
"TargetRegisterClass",
"*",
"GPRC",
"=",
"&",
"PPC",
"::",
"GPRCRegClass",
";",
"Register",
"DstReg",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
";",
"Register",
"NegSizeReg",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
";",
"Register",
"SPReg",
"=",
"isPPC64",
"?",
"PPC",
"::",
"X1",
":",
"PPC",
"::",
"R1",
";",
"Register",
"FinalStackPtr",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"isPPC64",
"?",
"G8RC",
":",
"GPRC",
")",
";",
"Register",
"FramePointer",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"isPPC64",
"?",
"G8RC",
":",
"GPRC",
")",
";",
"Register",
"ActualNegSizeReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"isPPC64",
"?",
"G8RC",
":",
"GPRC",
")",
";",
"unsigned",
"ProbeOpc",
";",
"if",
"(",
"!",
"MRI",
".",
"hasOneNonDBGUse",
"(",
"NegSizeReg",
")",
")",
"ProbeOpc",
"=",
"isPPC64",
"?",
"PPC",
"::",
"PREPARE_PROBED_ALLOCA_64",
":",
"PPC",
"::",
"PREPARE_PROBED_ALLOCA_32",
";",
"else",
"ProbeOpc",
"=",
"isPPC64",
"?",
"PPC",
"::",
"PREPARE_PROBED_ALLOCA_NEGSIZE_SAME_REG_64",
":",
"PPC",
"::",
"PREPARE_PROBED_ALLOCA_NEGSIZE_SAME_REG_32",
";",
"BuildMI",
"(",
"*",
"MBB",
",",
"{",
"MI",
"}",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"ProbeOpc",
")",
",",
"FramePointer",
")",
".",
"addDef",
"(",
"ActualNegSizeReg",
")",
".",
"addReg",
"(",
"NegSizeReg",
")",
".",
"add",
"(",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
".",
"add",
"(",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"BuildMI",
"(",
"*",
"MBB",
",",
"{",
"MI",
"}",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"isPPC64",
"?",
"PPC",
"::",
"ADD8",
":",
"PPC",
"::",
"ADD4",
")",
",",
"FinalStackPtr",
")",
".",
"addReg",
"(",
"SPReg",
")",
".",
"addReg",
"(",
"ActualNegSizeReg",
")",
";",
"int64_t",
"NegProbeSize",
"=",
"-",
"(",
"int64_t",
")",
"ProbeSize",
";",
"assert",
"(",
"isInt",
"<",
"<NUM_LIT>",
">",
"(",
"NegProbeSize",
")",
"&&",
"<STR_LIT>",
"Unhandled probe size!",
"<STR_LIT>",
")",
";",
"Register",
"ScratchReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"isPPC64",
"?",
"G8RC",
":",
"GPRC",
")",
";",
"if",
"(",
"!",
"isInt",
"<",
"<NUM_LIT>",
">",
"(",
"NegProbeSize",
")",
")",
"{",
"Register",
"TempReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"isPPC64",
"?",
"G8RC",
":",
"GPRC",
")",
";",
"BuildMI",
"(",
"*",
"MBB",
",",
"{",
"MI",
"}",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"isPPC64",
"?",
"PPC",
"::",
"LIS8",
":",
"PPC",
"::",
"LIS",
")",
",",
"TempReg",
")",
".",
"addImm",
"(",
"NegProbeSize",
">>",
"<NUM_LIT>",
")",
";",
"BuildMI",
"(",
"*",
"MBB",
",",
"{",
"MI",
"}",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"isPPC64",
"?",
"PPC",
"::",
"ORI8",
":",
"PPC",
"::",
"ORI",
")",
",",
"ScratchReg",
")",
".",
"addReg",
"(",
"TempReg",
")",
".",
"addImm",
"(",
"NegProbeSize",
"&",
"<NUM_LIT>",
")",
";",
"}",
"else",
"BuildMI",
"(",
"*",
"MBB",
",",
"{",
"MI",
"}",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"isPPC64",
"?",
"PPC",
"::",
"LI8",
":",
"PPC",
"::",
"LI",
")",
",",
"ScratchReg",
")",
".",
"addImm",
"(",
"NegProbeSize",
")",
";",
"{",
"Register",
"Div",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"isPPC64",
"?",
"G8RC",
":",
"GPRC",
")",
";",
"BuildMI",
"(",
"*",
"MBB",
",",
"{",
"MI",
"}",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"isPPC64",
"?",
"PPC",
"::",
"DIVD",
":",
"PPC"
] |
GCC | aarch64 | CPP | stmt_completion | CPU | 3,764 | [
")",
")",
")",
"return",
"PAD_DOWNWARD",
";"
] | [
"if",
"(",
"!",
"BYTES_BIG_ENDIAN",
")",
"return",
"PAD_UPWARD",
";",
"if",
"(",
"type",
"?",
"(",
"INTEGRAL_TYPE_P",
"(",
"type",
")",
"||",
"SCALAR_FLOAT_TYPE_P",
"(",
"type",
")",
"||",
"POINTER_TYPE_P",
"(",
"type",
")",
")",
":",
"(",
"SCALAR_INT_MODE_P",
"(",
"mode",
")",
"||",
"SCALAR_FLOAT_MODE_P",
"(",
"mode"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 3,765 | [
"return",
"SDValue",
"(",
")",
";"
] | [
"if",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SRA",
")",
"if",
"(",
"SDValue",
"V",
"=",
"combineShiftRightArithmetic",
"(",
"N",
",",
"DAG",
")",
")",
"return",
"V",
";",
"if",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SRL",
")",
"if",
"(",
"SDValue",
"V",
"=",
"combineShiftRightLogical",
"(",
"N",
",",
"DAG",
",",
"DCI",
")",
")",
"return",
"V",
";"
] |
LLVM | PowerPC | TD | stmt_completion | CPU | 3,766 | [
"=",
"<STR_LIT>",
";"
] | [
"def",
"memrix16",
":",
"Operand",
"<",
"iPTR",
">",
"{",
"let",
"PrintMethod",
"=",
"<STR_LIT>",
";",
"let",
"MIOperandInfo",
"=",
"(",
"ops",
"dispRIX16",
":",
"$",
"imm",
",",
"ptr_rc_nor0",
":",
"$",
"reg",
")",
";",
"let",
"EncoderMethod",
"=",
"<STR_LIT>",
";",
"let",
"DecoderMethod"
] |
LLVM | MOS | CPP | stmt_completion | MPU | 3,767 | [
")",
";"
] | [
"TargetRegistry",
"::",
"RegisterMCInstrInfo",
"(",
"getTheMOSTarget",
"(",
")",
",",
"createMOSMCInstrInfo",
")",
";",
"TargetRegistry",
"::",
"RegisterMCRegInfo",
"(",
"getTheMOSTarget",
"(",
")",
",",
"createMOSMCRegisterInfo",
")",
";",
"TargetRegistry",
"::",
"RegisterMCSubtargetInfo",
"(",
"getTheMOSTarget",
"(",
")",
",",
"createMOSMCSubtargetInfo",
")",
";",
"TargetRegistry",
"::",
"RegisterMCInstPrinter",
"(",
"getTheMOSTarget",
"(",
")",
",",
"createMOSMCInstPrinter",
")",
";",
"TargetRegistry",
"::",
"RegisterMCCodeEmitter",
"(",
"getTheMOSTarget",
"(",
")",
",",
"createMOSMCCodeEmitter"
] |
LLVM | AArch64 | TD | next_suggestion | CPU | 3,768 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] | [
"bits",
"<",
"<NUM_LIT>",
">",
"idx",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"idx",
";"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 3,769 | [
"}"
] | [
"bool",
"ARMLowOverheadLoops",
"::",
"RevertLoopDec",
"(",
"MachineInstr",
"*",
"MI",
")",
"const",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"ARM Loops: Reverting to sub: ",
"<STR_LIT>",
"<<",
"*",
"MI",
")",
";",
"MachineBasicBlock",
"*",
"MBB",
"=",
"MI",
"->",
"getParent",
"(",
")",
";",
"SmallPtrSet",
"<",
"MachineInstr",
"*",
",",
"<NUM_LIT>",
">",
"Ignore",
";",
"for",
"(",
"auto",
"I",
"=",
"MachineBasicBlock",
"::",
"iterator",
"(",
"MI",
")",
",",
"E",
"=",
"MBB",
"->",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"if",
"(",
"I",
"->",
"getOpcode",
"(",
")",
"==",
"ARM",
"::",
"t2LoopEnd",
")",
"{",
"Ignore",
".",
"insert",
"(",
"&",
"*",
"I",
")",
";",
"break",
";",
"}"
] |
GCC | rs6000 | MD | next_suggestion | CPU | 3,770 | [
"rs6000_scale_v2df",
"(",
"op0",
",",
"op0",
",",
"-",
"scale",
")"
] | [
"emit_insn",
"(",
"gen_vsx_xvcvuxddp",
"(",
"op0",
",",
"op1",
")",
")",
"if",
"(",
"scale",
"!",
"=",
"<NUM_LIT>",
")"
] |
LLVM | AMDGPU | CPP | next_suggestion | GPU | 3,771 | [
"}"
] | [
"MachineFunction",
"&",
"MF",
"=",
"*",
"MI",
".",
"getMF",
"(",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"MI",
".",
"getDesc",
"(",
")",
".",
"getNumOperands",
"(",
")",
"+",
"MI",
".",
"getDesc",
"(",
")",
".",
"getNumImplicitUses",
"(",
")",
"+",
"MI",
".",
"getDesc",
"(",
")",
".",
"getNumImplicitDefs",
"(",
")",
",",
"e",
"=",
"MI",
".",
"getNumOperands",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"const",
"MachineOperand",
"&",
"MO",
"=",
"MI",
".",
"getOperand",
"(",
"i",
")",
";",
"if",
"(",
"(",
"MO",
".",
"isReg",
"(",
")",
"&&",
"MO",
".",
"isImplicit",
"(",
")",
")",
"||",
"MO",
".",
"isRegMask",
"(",
")",
")",
"NewMI",
".",
"addOperand",
"(",
"MF",
",",
"MO",
")",
";",
"}"
] |
GCC | i386 | MD | stmt_completion | CPU | 3,772 | [
"<STR_LIT>",
")"
] | [
"[",
"(",
"QI",
"<STR_LIT>",
")",
"(",
"HI"
] |
GCC | rs6000 | MD | stmt_completion | CPU | 3,773 | [
"]",
")"
] | [
"(",
"define_mode_iterator",
"VI2",
"[",
"V4SI",
"V8HI",
"V16QI",
"V2DI"
] |
GCC | msp430 | CPP | next_suggestion | MPU | 3,774 | [
"}"
] | [
"char",
"*",
"msp430_dirname",
"(",
"char",
"*",
"path",
")",
"{",
"int",
"last_elem",
"=",
"strlen",
"(",
"path",
")",
"-",
"<NUM_LIT>",
";",
"int",
"i",
"=",
"last_elem",
"-",
"(",
"IS_DIR_SEPARATOR",
"(",
"path",
"[",
"last_elem",
"]",
")",
"?",
"<NUM_LIT>",
":",
"<NUM_LIT>",
")",
";",
"for",
"(",
";",
"i",
">=",
"<NUM_LIT>",
";",
"i",
"--",
")",
"{",
"if",
"(",
"IS_DIR_SEPARATOR",
"(",
"path",
"[",
"i",
"]",
")",
")",
"{",
"path",
"[",
"i",
"]",
"=",
"'",
"\\0",
"'",
";",
"return",
"path",
";",
"}",
"}",
"return",
"path",
";"
] |
GCC | arm | CPP | next_suggestion | CPU | 3,775 | [
"param_sched_autopref_queue_depth",
"=",
"max_insn_queue_index",
"+",
"<NUM_LIT>",
";"
] | [
"if",
"(",
"arm_fp16_inst",
")",
"{",
"if",
"(",
"arm_fp16_format",
"==",
"ARM_FP16_FORMAT_ALTERNATIVE",
")",
"error",
"(",
"<STR_LIT>",
"selected fp16 options are incompatible",
"<STR_LIT>",
")",
";",
"arm_fp16_format",
"=",
"ARM_FP16_FORMAT_IEEE",
";",
"}",
"arm_ld_sched",
"=",
"(",
"tune_flags",
"&",
"TF_LDSCHED",
")",
"!=",
"<NUM_LIT>",
";",
"arm_tune_strongarm",
"=",
"(",
"tune_flags",
"&",
"TF_STRONG",
")",
"!=",
"<NUM_LIT>",
";",
"arm_tune_wbuf",
"=",
"(",
"tune_flags",
"&",
"TF_WBUF",
")",
"!=",
"<NUM_LIT>",
";",
"arm_tune_xscale",
"=",
"(",
"tune_flags",
"&",
"TF_XSCALE",
")",
"!=",
"<NUM_LIT>",
";",
"arm_tune_cortex_a9",
"=",
"(",
"arm_tune",
"==",
"TARGET_CPU_cortexa9",
")",
"!=",
"<NUM_LIT>",
";",
"arm_m_profile_small_mul",
"=",
"(",
"tune_flags",
"&",
"TF_SMALLMUL",
")",
"!=",
"<NUM_LIT>",
";",
"arm_arch_no_volatile_ce",
"=",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_quirk_no_volatile_ce",
")",
";",
"arm_arch6kz",
"=",
"arm_arch6k",
"&&",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_quirk_ARMv6kz",
")",
";",
"if",
"(",
"TARGET_INTERWORK",
")",
"arm_cpp_interwork",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"arm_arch5",
")",
"target_flags",
"&=",
"~",
"MASK_INTERWORK",
";",
"if",
"(",
"TARGET_IWMMXT",
"&&",
"!",
"ARM_DOUBLEWORD_ALIGN",
")",
"error",
"(",
"<STR_LIT>",
"iwmmxt requires an AAPCS compatible ABI for proper operation",
"<STR_LIT>",
")",
";",
"if",
"(",
"TARGET_IWMMXT_ABI",
"&&",
"!",
"TARGET_IWMMXT",
")",
"error",
"(",
"<STR_LIT>",
"iwmmxt abi requires an iwmmxt capable cpu",
"<STR_LIT>",
")",
";",
"if",
"(",
"TARGET_SOFT_FLOAT",
")",
"arm_fpu_attr",
"=",
"FPU_NONE",
";",
"else",
"arm_fpu_attr",
"=",
"FPU_VFP",
";",
"if",
"(",
"TARGET_AAPCS_BASED",
")",
"{",
"if",
"(",
"TARGET_CALLER_INTERWORKING",
")",
"error",
"(",
"<STR_LIT>",
"AAPCS does not support -mcaller-super-interworking",
"<STR_LIT>",
")",
";",
"else",
"if",
"(",
"TARGET_CALLEE_INTERWORKING",
")",
"error",
"(",
"<STR_LIT>",
"AAPCS does not support -mcallee-super-interworking",
"<STR_LIT>",
")",
";",
"}",
"if",
"(",
"!",
"arm_arch4",
"&&",
"arm_fp16_format",
"!=",
"ARM_FP16_FORMAT_NONE",
")",
"sorry",
"(",
"<STR_LIT>",
"__fp16 and no ldrh",
"<STR_LIT>",
")",
";",
"if",
"(",
"TARGET_AAPCS_BASED",
")",
"{",
"if",
"(",
"arm_abi",
"==",
"ARM_ABI_IWMMXT",
")",
"arm_pcs_default",
"=",
"ARM_PCS_AAPCS_IWMMXT",
";",
"else",
"if",
"(",
"arm_float_abi",
"==",
"ARM_FLOAT_ABI_HARD",
"&&",
"TARGET_HARD_FLOAT",
")",
"{",
"arm_pcs_default",
"=",
"ARM_PCS_AAPCS_VFP",
";",
"if",
"(",
"!",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_bit_VFPv2",
")",
")",
"error",
"(",
"<STR_LIT>",
"-mfloat-abi=hard: selected processor lacks an FPU",
"<STR_LIT>",
")",
";",
"}",
"else",
"arm_pcs_default",
"=",
"ARM_PCS_AAPCS",
";",
"}",
"else",
"{",
"if",
"(",
"arm_float_abi",
"==",
"ARM_FLOAT_ABI_HARD",
")",
"sorry",
"(",
"<STR_LIT>",
"-mfloat-abi=hard and VFP",
"<STR_LIT>",
")",
";",
"if",
"(",
"arm_abi",
"==",
"ARM_ABI_APCS",
")",
"arm_pcs_default",
"=",
"ARM_PCS_APCS",
";",
"else",
"arm_pcs_default",
"=",
"ARM_PCS_ATPCS",
";",
"}",
"if",
"(",
"TARGET_SOFT_FLOAT",
"&&",
"(",
"tune_flags",
"&",
"TF_NO_MODE32",
")",
")",
"flag_schedule_insns",
"=",
"flag_schedule_insns_after_reload",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"target_thread_pointer",
"==",
"TP_AUTO",
")",
"{",
"if",
"(",
"arm_arch6k",
"&&",
"!",
"TARGET_THUMB1",
")",
"target_thread_pointer",
"=",
"TP_CP15",
";",
"else",
"target_thread_pointer",
"=",
"TP_SOFT",
";",
"}",
"if",
"(",
"!",
"global_options_set",
".",
"x_arm_structure_size_boundary",
")",
"{",
"if",
"(",
"TARGET_AAPCS_BASED",
")",
"arm_structure_size_boundary",
"=",
"<NUM_LIT>",
";",
"}",
"else",
"{",
"if",
"(",
"arm_structure_size_boundary",
"!=",
"<NUM_LIT>",
"&&",
"arm_structure_size_boundary",
"!=",
"<NUM_LIT>",
"&&",
"!",
"(",
"ARM_DOUBLEWORD_ALIGN",
"&&",
"arm_structure_size_boundary",
"==",
"<NUM_LIT>",
")",
")",
"{",
"if",
"(",
"ARM_DOUBLEWORD_ALIGN",
")",
"warning",
"(",
"<NUM_LIT>",
",",
"<STR_LIT>",
"structure size boundary can only be set to 8, 32 or 64",
"<STR_LIT>",
")",
";",
"else",
"warning",
"(",
"<NUM_LIT>",
",",
"<STR_LIT>",
"structure size boundary can only be set to 8 or 32",
"<STR_LIT>",
")",
";",
"arm_structure_size_boundary",
"=",
"(",
"TARGET_AAPCS_BASED",
"?",
"<NUM_LIT>",
":",
"DEFAULT_STRUCTURE_SIZE_BOUNDARY",
")",
";",
"}",
"}",
"if",
"(",
"TARGET_VXWORKS_RTP",
")",
"{",
"if",
"(",
"!",
"global_options_set",
".",
"x_arm_pic_data_is_text_relative",
")",
"arm_pic_data_is_text_relative",
"=",
"<NUM_LIT>",
";",
"}",
"else",
"if",
"(",
"flag_pic",
"&&",
"!",
"arm_pic_data_is_text_relative",
"&&",
"!",
"(",
"global_options_set",
".",
"x_target_flags",
"&",
"MASK_SINGLE_PIC_BASE",
")",
")",
"target_flags",
"|=",
"MASK_SINGLE_PIC_BASE",
";",
"if",
"(",
"flag_pic",
"&&",
"TARGET_SINGLE_PIC_BASE",
")",
"{",
"if",
"(",
"TARGET_VXWORKS_RTP",
")",
"warning",
"(",
"<NUM_LIT>",
",",
"<STR_LIT>",
"RTP PIC is incompatible with -msingle-pic-base",
"<STR_LIT>",
")",
";",
"arm_pic_register",
"=",
"(",
"TARGET_APCS_STACK",
"||",
"TARGET_AAPCS_BASED",
")",
"?",
"<NUM_LIT>",
":",
"<NUM_LIT>",
";",
"}",
"if",
"(",
"flag_pic",
"&&",
"TARGET_VXWORKS_RTP",
")",
"arm_pic_register",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"arm_pic_register_string",
"!=",
"NULL",
")",
"{",
"int",
"pic_register",
"=",
"decode_reg_name",
"(",
"arm_pic_register_string",
")",
";",
"if",
"(",
"!",
"flag_pic",
")",
"warning",
"(",
"<NUM_LIT>",
",",
"<STR_LIT>",
"-mpic-register= is useless without -fpic",
"<STR_LIT>",
")",
";",
"else",
"if",
"(",
"pic_register",
"<",
"<NUM_LIT>",
"||",
"call_used_regs",
"[",
"pic_register",
"]",
"||",
"pic_register",
"==",
"HARD_FRAME_POINTER_REGNUM",
"||",
"pic_register",
"==",
"STACK_POINTER_REGNUM",
"||",
"pic_register",
">=",
"PC_REGNUM",
"||",
"(",
"TARGET_VXWORKS_RTP",
"&&",
"(",
"unsigned",
"int",
")",
"pic_register",
"!=",
"arm_pic_register",
")",
")",
"error",
"(",
"<STR_LIT>",
"unable to use '%s' for PIC register",
"<STR_LIT>",
",",
"arm_pic_register_string",
")",
";",
"else",
"arm_pic_register",
"=",
"pic_register",
";",
"}",
"if",
"(",
"fix_cm3_ldrd",
"==",
"<NUM_LIT>",
")",
"{",
"if",
"(",
"bitmap_bit_p",
"(",
"arm_active_target",
".",
"isa",
",",
"isa_quirk_cm3_ldrd",
")",
")",
"fix_cm3_ldrd",
"=",
"<NUM_LIT>",
";",
"else",
"fix_cm3_ldrd",
"=",
"<NUM_LIT>",
";",
"}",
"if",
"(",
"flag_reorder_blocks_and_partition",
")",
"{",
"inform",
"(",
"input_location",
",",
"<STR_LIT>",
"-freorder-blocks-and-partition not supported on this architecture",
"<STR_LIT>",
")",
";",
"flag_reorder_blocks_and_partition",
"=",
"<NUM_LIT>",
";",
"flag_reorder_blocks",
"=",
"<NUM_LIT>",
";",
"}",
"if",
"(",
"flag_pic",
")",
"maybe_set_param_value",
"(",
"PARAM_GCSE_UNRESTRICTED_COST",
",",
"<NUM_LIT>",
",",
"global_options",
".",
"x_param_values",
",",
"global_options_set",
".",
"x_param_values",
")",
";",
"if",
"(",
"TARGET_AAPCS_BASED",
"&&",
"flag_strict_volatile_bitfields",
"<",
"<NUM_LIT>",
"&&",
"abi_version_at_least",
"(",
"<NUM_LIT>",
")",
")",
"flag_strict_volatile_bitfields",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"flag_prefetch_loop_arrays",
"<",
"<NUM_LIT>",
"&&",
"HAVE_prefetch",
"&&",
"optimize",
">=",
"<NUM_LIT>",
"&&",
"current_tune",
"->",
"prefetch",
".",
"num_slots",
">",
"<NUM_LIT>",
")",
"flag_prefetch_loop_arrays",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"current_tune",
"->",
"prefetch",
".",
"num_slots",
">",
"<NUM_LIT>",
")",
"maybe_set_param_value",
"(",
"PARAM_SIMULTANEOUS_PREFETCHES",
",",
"current_tune",
"->",
"prefetch",
".",
"num_slots",
",",
"global_options",
".",
"x_param_values",
",",
"global_options_set",
".",
"x_param_values",
")",
";",
"if",
"(",
"current_tune",
"->",
"prefetch",
".",
"l1_cache_line_size",
">=",
"<NUM_LIT>",
")",
"maybe_set_param_value",
"(",
"PARAM_L1_CACHE_LINE_SIZE",
",",
"current_tune",
"->",
"prefetch",
".",
"l1_cache_line_size",
",",
"global_options",
".",
"x_param_values",
",",
"global_options_set",
".",
"x_param_values",
")",
";",
"if",
"(",
"current_tune",
"->",
"prefetch",
".",
"l1_cache_size",
">=",
"<NUM_LIT>",
")",
"maybe_set_param_value",
"(",
"PARAM_L1_CACHE_SIZE",
",",
"current_tune",
"->",
"prefetch",
".",
"l1_cache_size",
",",
"global_options",
".",
"x_param_values",
",",
"global_options_set",
".",
"x_param_values",
")",
";",
"prefer_neon_for_64bits",
"=",
"current_tune",
"->",
"prefer_neon_for_64bits",
";",
"if",
"(",
"use_neon_for_64bits",
"==",
"<NUM_LIT>",
")",
"prefer_neon_for_64bits",
"=",
"true",
";",
"maybe_set_param_value",
"(",
"PARAM_SCHED_PRESSURE_ALGORITHM",
",",
"SCHED_PRESSURE_MODEL",
",",
"global_options",
".",
"x_param_values",
",",
"global_options_set",
".",
"x_param_values",
")",
";",
"int",
"param_sched_autopref_queue_depth",
";",
"switch",
"(",
"current_tune",
"->",
"sched_autopref",
")",
"{",
"case",
"tune_params",
"::",
"SCHED_AUTOPREF_OFF",
":",
"param_sched_autopref_queue_depth",
"=",
"-",
"<NUM_LIT>",
";",
"break",
";",
"case",
"tune_params",
"::",
"SCHED_AUTOPREF_RANK",
":",
"param_sched_autopref_queue_depth",
"=",
"<NUM_LIT>",
";",
"break",
";",
"case",
"tune_params",
"::",
"SCHED_AUTOPREF_FULL",
":"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 3,776 | [
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
";"
] | [
"let",
"isBranch",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicatedNew",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax1",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax2",
"=",
"<NUM_LIT>",
";",
"let",
"cofMax1",
"=",
"<NUM_LIT>",
";",
"let",
"Uses",
"=",
"[",
"P0",
"]",
";",
"let",
"Defs",
"=",
"[",
"P0",
",",
"PC",
"]",
";",
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";",
"let",
"isTaken",
"=",
"Inst",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";"
] |
GCC | rs6000 | MD | stmt_completion | CPU | 3,777 | [
")",
"]",
")"
] | [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"V2DF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"float_extend",
":",
"V2DF",
"(",
"vec_select",
":",
"V2SF",
"(",
"match_operand",
":",
"V4SF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"parallel",
"[",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"]",
")",
")",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>"
] |
LLVM | AArch64 | CPP | next_suggestion | CPU | 3,778 | [
"RegBankInfo",
".",
"reset",
"(",
"RBI",
")",
";"
] | [
"InlineAsmLoweringInfo",
".",
"reset",
"(",
"new",
"InlineAsmLowering",
"(",
"getTargetLowering",
"(",
")",
")",
")",
";",
"Legalizer",
".",
"reset",
"(",
"new",
"AArch64LegalizerInfo",
"(",
"*",
"this",
")",
")",
";",
"auto",
"*",
"RBI",
"=",
"new",
"AArch64RegisterBankInfo",
"(",
"*",
"getRegisterInfo",
"(",
")",
")",
";",
"InstSelector",
".",
"reset",
"(",
"createAArch64InstructionSelector",
"(",
"*",
"static_cast",
"<",
"const",
"AArch64TargetMachine",
"*",
">",
"(",
"&",
"TM",
")",
",",
"*",
"this",
",",
"*",
"RBI",
")",
")",
";"
] |
GCC | mips | CPP | stmt_completion | CPU | 3,779 | [
"=",
"x",
";"
] | [
"static",
"void",
"mips_multi_set_operand",
"(",
"unsigned",
"int",
"i",
",",
"unsigned",
"int",
"op",
",",
"rtx",
"x",
")",
"{",
"mips_multi_members",
"[",
"i",
"]",
".",
"operands",
"[",
"op",
"]"
] |
LLVM | AArch64 | TD | next_suggestion | CPU | 3,780 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"imm",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] |
GCC | m32r | CPP | stmt_completion | MPU | 3,781 | [
"X",
"'",
":"
] | [
"case",
"'",
"H",
"'",
":",
"case",
"'",
"L",
"'",
":",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"REG",
")",
"{",
"if",
"(",
"(",
"WORDS_BIG_ENDIAN",
"!=",
"<NUM_LIT>",
")",
"^",
"(",
"code",
"==",
"'",
"L",
"'",
")",
")",
"fputs",
"(",
"reg_names",
"[",
"REGNO",
"(",
"x",
")",
"]",
",",
"file",
")",
";",
"else",
"fputs",
"(",
"reg_names",
"[",
"REGNO",
"(",
"x",
")",
"+",
"<NUM_LIT>",
"]",
",",
"file",
")",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"CONST_INT",
"||",
"GET_CODE",
"(",
"x",
")",
"==",
"CONST_DOUBLE",
")",
"{",
"rtx",
"first",
",",
"second",
";",
"split_double",
"(",
"x",
",",
"&",
"first",
",",
"&",
"second",
")",
";",
"fprintf",
"(",
"file",
",",
"HOST_WIDE_INT_PRINT_HEX",
",",
"code",
"==",
"'",
"L",
"'",
"?",
"INTVAL",
"(",
"first",
")",
":",
"INTVAL",
"(",
"second",
")",
")",
";",
"}",
"else",
"output_operand_lossage",
"(",
"<STR_LIT>",
"invalid operand to %%H/%%L code",
"<STR_LIT>",
")",
";",
"return",
";",
"case",
"'",
"A",
"'",
":",
"{",
"char",
"str",
"[",
"<NUM_LIT>",
"]",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"!=",
"CONST_DOUBLE",
"||",
"GET_MODE_CLASS",
"(",
"GET_MODE",
"(",
"x",
")",
")",
"!=",
"MODE_FLOAT",
")",
"fatal_insn",
"(",
"<STR_LIT>",
"bad insn for 'A'",
"<STR_LIT>",
",",
"x",
")",
";",
"real_to_decimal",
"(",
"str",
",",
"CONST_DOUBLE_REAL_VALUE",
"(",
"x",
")",
",",
"sizeof",
"(",
"str",
")",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";",
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"%s",
"<STR_LIT>",
",",
"str",
")",
";",
"return",
";",
"}",
"case",
"'",
"B",
"'",
":",
"case",
"'",
"T",
"'",
":",
"switch",
"(",
"GET_CODE",
"(",
"x",
")",
")",
"{",
"case",
"CONST_INT",
":",
"case",
"CONST_DOUBLE",
":",
"{",
"rtx",
"first",
",",
"second",
";",
"split_double",
"(",
"x",
",",
"&",
"first",
",",
"&",
"second",
")",
";",
"x",
"=",
"WORDS_BIG_ENDIAN",
"?",
"second",
":",
"first",
";",
"fprintf",
"(",
"file",
",",
"HOST_WIDE_INT_PRINT_HEX",
",",
"(",
"code",
"==",
"'",
"B",
"'",
"?",
"INTVAL",
"(",
"x",
")",
"&",
"<NUM_LIT>",
":",
"(",
"INTVAL",
"(",
"x",
")",
">>",
"<NUM_LIT>",
")",
"&",
"<NUM_LIT>",
")",
")",
";",
"}",
"return",
";",
"case",
"CONST",
":",
"case",
"SYMBOL_REF",
":",
"if",
"(",
"code",
"==",
"'",
"B",
"'",
"&&",
"small_data_operand",
"(",
"x",
",",
"VOIDmode",
")",
")",
"{",
"fputs",
"(",
"<STR_LIT>",
"sda(",
"<STR_LIT>",
",",
"file",
")",
";",
"output_addr_const",
"(",
"file",
",",
"x",
")",
";",
"fputc",
"(",
"'",
")",
"'",
",",
"file",
")",
";",
"return",
";",
"}",
"case",
"LABEL_REF",
":",
"fputs",
"(",
"code",
"==",
"'",
"T",
"'",
"?",
"<STR_LIT>",
"shigh(",
"<STR_LIT>",
":",
"<STR_LIT>",
"low(",
"<STR_LIT>",
",",
"file",
")",
";",
"output_addr_const",
"(",
"file",
",",
"x",
")",
";",
"fputc",
"(",
"'",
")",
"'",
",",
"file",
")",
";",
"return",
";",
"default",
":",
"output_operand_lossage",
"(",
"<STR_LIT>",
"invalid operand to %%T/%%B code",
"<STR_LIT>",
")",
";",
"return",
";",
"}",
"break",
";",
"case",
"'",
"U",
"'",
":",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"MEM",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"==",
"PRE_INC",
"||",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"==",
"PRE_DEC",
")",
"fputs",
"(",
"<STR_LIT>",
".a",
"<STR_LIT>",
",",
"file",
")",
";",
"}",
"else",
"output_operand_lossage",
"(",
"<STR_LIT>",
"invalid operand to %%U code",
"<STR_LIT>",
")",
";",
"return",
";",
"case",
"'",
"N",
"'",
":",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"CONST_INT",
")",
"output_addr_const",
"(",
"file",
",",
"GEN_INT",
"(",
"-",
"INTVAL",
"(",
"x",
")",
")",
")",
";",
"else",
"output_operand_lossage",
"(",
"<STR_LIT>",
"invalid operand to %%N code",
"<STR_LIT>",
")",
";",
"return",
";",
"case",
"'"
] |
GCC | i386 | MD | stmt_completion | CPU | 3,782 | [
"<NUM_LIT>",
")",
","
] | [
"int",
"mask",
"=",
"INTVAL",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
"emit_insn",
"(",
"gen_avx2_pshufhw_1",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"GEN_INT",
"(",
"(",
"(",
"mask",
">",
">",
"<NUM_LIT>",
")",
"&",
"<NUM_LIT>",
")",
"+",
"<NUM_LIT>",
")",
",",
"GEN_INT",
"(",
"(",
"(",
"mask",
">",
">",
"<NUM_LIT>",
")",
"&",
"<NUM_LIT>",
")",
"+",
"<NUM_LIT>",
")",
",",
"GEN_INT",
"(",
"(",
"(",
"mask",
">",
">",
"<NUM_LIT>",
")",
"&",
"<NUM_LIT>",
")",
"+",
"<NUM_LIT>",
")",
",",
"GEN_INT",
"(",
"(",
"(",
"mask",
">",
">",
"<NUM_LIT>",
")",
"&",
"<NUM_LIT>",
")",
"+",
"<NUM_LIT>",
")",
",",
"GEN_INT",
"(",
"(",
"(",
"mask",
">",
">",
"<NUM_LIT>",
")",
"&",
"<NUM_LIT>",
")",
"+"
] |
LLVM | PTX | CPP | next_suggestion | GPU | 3,783 | [
"}"
] | [
"if",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"RegIndex",
"=",
"<NUM_LIT>",
";",
"OpIndex",
"=",
"<NUM_LIT>",
";",
"}",
"else",
"{",
"RegIndex",
"=",
"MI",
"->",
"getNumOperands",
"(",
")",
"-",
"<NUM_LIT>",
";",
"OpIndex",
"=",
"MI",
"->",
"getNumOperands",
"(",
")",
"-",
"<NUM_LIT>",
";"
] |
LLVM | PowerPC | CPP | stmt_completion | CPU | 3,784 | [
")",
";"
] | [
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"*",
"MI",
";",
"return",
"(",
"std",
"::",
"prev",
"(",
"MBBI",
")",
"==",
"PrevPushedMBBI"
] |
LLVM | Hexagon | CPP | next_suggestion | DSP | 3,785 | [
"}"
] | [
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"<STR_LIT>",
"Hexagon Hardware Loop Fixup",
"<STR_LIT>",
";"
] |
LLVM | AArch64 | TD | stmt_completion | CPU | 3,786 | [
",",
"<STR_LIT>",
"]",
">",
",",
"DwarfRegAlias",
"<",
"B1",
">",
";"
] | [
"def",
"Q1",
":",
"AArch64Reg",
"<",
"<NUM_LIT>",
",",
"<STR_LIT>",
",",
"[",
"D1",
"]",
",",
"[",
"<STR_LIT>"
] |
GCC | mips | CPP | next_suggestion | CPU | 3,787 | [
"}"
] | [
"case",
"ACC_REGS",
":",
"return",
"<NUM_LIT>",
";",
"case",
"FP_REGS",
":",
"return",
"<NUM_LIT>",
";",
"case",
"COP0_REGS",
":",
"case",
"COP2_REGS",
":",
"case",
"COP3_REGS",
":",
"return",
"<NUM_LIT>",
";",
"default",
":",
"return",
"<NUM_LIT>",
";",
"}"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 3,788 | [
"let",
"isPredicatedNew",
"=",
"<NUM_LIT>",
";"
] | [
"def",
"J4_cmpgti_tp0_jump_nt",
":",
"HInst",
"<",
"(",
"outs",
")",
",",
"(",
"ins",
"GeneralSubRegs",
":",
"$",
"Rs16",
",",
"u5_0Imm",
":",
"$",
"II",
",",
"b30_2Imm",
":",
"$",
"Ii",
")",
",",
"<STR_LIT>",
",",
"tc_3d495a39",
",",
"TypeCJ",
">",
",",
"Enc_14d27a",
",",
"PredRel",
"{",
"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",
"isPredicated",
"=",
"<NUM_LIT>",
";",
"let",
"isTerminator",
"=",
"<NUM_LIT>",
";",
"let",
"isBranch",
"=",
"<NUM_LIT>",
";"
] |
GCC | i386 | CPP | stmt_completion | CPU | 3,789 | [
"_",
"A",
",",
"_",
"_",
"M",
")",
";"
] | [
"_",
"_",
"builtin_ia32_pmovsdb256mem_mask",
"(",
"(",
"unsigned",
"long",
"long",
"*",
")",
"_",
"_",
"P",
",",
"(",
"_",
"_",
"v8si",
")",
"_"
] |
GCC | msp430 | MD | stmt_completion | MPU | 3,790 | [
")",
"]"
] | [
"(",
"match_operand",
":",
"PSI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>"
] |
LLVM | AArch64 | CPP | stmt_completion | CPU | 3,791 | [
":"
] | [
"}",
"SDValue",
"OpLHS",
",",
"OpRHS",
";",
"OpLHS",
"=",
"GeneratePerfectShuffle",
"(",
"PerfectShuffleTable",
"[",
"LHSID",
"]",
",",
"LHS",
",",
"RHS",
",",
"DAG",
",",
"dl",
")",
";",
"OpRHS",
"=",
"GeneratePerfectShuffle",
"(",
"PerfectShuffleTable",
"[",
"RHSID",
"]",
",",
"LHS",
",",
"RHS",
",",
"DAG",
",",
"dl",
")",
";",
"EVT",
"VT",
"=",
"OpLHS",
".",
"getValueType",
"(",
")",
";",
"switch",
"(",
"OpNum",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Unknown shuffle opcode!",
"<STR_LIT>",
")",
";",
"case",
"OP_VREV",
":",
"if",
"(",
"VT",
".",
"getVectorElementType",
"(",
")",
"==",
"MVT",
"::",
"i32",
"||",
"VT",
".",
"getVectorElementType",
"(",
")",
"==",
"MVT",
"::",
"f32",
")",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"VT",
",",
"OpLHS",
")",
";",
"if",
"(",
"VT",
".",
"getVectorElementType",
"(",
")",
"==",
"MVT",
"::",
"i16",
"||",
"VT",
".",
"getVectorElementType",
"(",
")",
"==",
"MVT",
"::",
"f16",
")",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"VT",
",",
"OpLHS",
")",
";",
"assert",
"(",
"VT",
".",
"getVectorElementType",
"(",
")",
"==",
"MVT",
"::",
"i8",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"VT",
",",
"OpLHS",
")",
";",
"case",
"OP_VDUP0",
":",
"case",
"OP_VDUP1",
":",
"case",
"OP_VDUP2",
":",
"case",
"OP_VDUP3",
":",
"{",
"EVT",
"EltTy",
"=",
"VT",
".",
"getVectorElementType",
"(",
")",
";",
"unsigned",
"Opcode",
";",
"if",
"(",
"EltTy",
"==",
"MVT",
"::",
"i8",
")",
"Opcode",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"else",
"if",
"(",
"EltTy",
"==",
"MVT",
"::",
"i16",
"||",
"EltTy",
"==",
"MVT",
"::",
"f16",
")",
"Opcode",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"else",
"if",
"(",
"EltTy",
"==",
"MVT",
"::",
"i32",
"||",
"EltTy",
"==",
"MVT",
"::",
"f32",
")",
"Opcode",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"else",
"if",
"(",
"EltTy",
"==",
"MVT",
"::",
"i64",
"||",
"EltTy",
"==",
"MVT",
"::",
"f64",
")",
"Opcode",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"else",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Invalid vector element type?",
"<STR_LIT>",
")",
";",
"if",
"(",
"VT",
".",
"getSizeInBits",
"(",
")",
"==",
"<NUM_LIT>",
")",
"OpLHS",
"=",
"WidenVector",
"(",
"OpLHS",
",",
"DAG",
")",
";",
"SDValue",
"Lane",
"=",
"DAG",
".",
"getConstant",
"(",
"OpNum",
"-",
"OP_VDUP0",
",",
"dl",
",",
"MVT",
"::",
"i64",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"Opcode",
",",
"dl",
",",
"VT",
",",
"OpLHS",
",",
"Lane",
")",
";",
"}",
"case",
"OP_VEXT1",
":",
"case",
"OP_VEXT2",
":",
"case",
"OP_VEXT3",
":",
"{",
"unsigned",
"Imm",
"=",
"(",
"OpNum",
"-",
"OP_VEXT1",
"+",
"<NUM_LIT>",
")",
"*",
"getExtFactor",
"(",
"OpLHS",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"VT",
",",
"OpLHS",
",",
"OpRHS",
",",
"DAG",
".",
"getConstant",
"(",
"Imm",
",",
"dl",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"}",
"case",
"OP_VUZPL",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"DAG",
".",
"getVTList",
"(",
"VT",
",",
"VT",
")",
",",
"OpLHS",
",",
"OpRHS",
")",
";",
"case",
"OP_VUZPR",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"DAG",
".",
"getVTList",
"(",
"VT",
",",
"VT",
")",
",",
"OpLHS",
",",
"OpRHS",
")",
";",
"case",
"OP_VZIPL",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"DAG",
".",
"getVTList",
"(",
"VT",
",",
"VT",
")",
",",
"OpLHS",
",",
"OpRHS",
")",
";",
"case",
"OP_VZIPR",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"DAG",
".",
"getVTList",
"(",
"VT",
",",
"VT",
")",
",",
"OpLHS",
",",
"OpRHS",
")",
";",
"case",
"OP_VTRNL",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"DAG",
".",
"getVTList",
"(",
"VT",
",",
"VT",
")",
",",
"OpLHS",
",",
"OpRHS",
")",
";",
"case",
"OP_VTRNR"
] |
GCC | i386 | CPP | next_suggestion | CPU | 3,792 | [
"return",
"(",
"c2",
".",
"dispatch_priority",
"-",
"c1",
".",
"dispatch_priority",
")",
";"
] | [
"unsigned",
"int",
"dispatch_priority",
";",
"}",
"function_version_info",
";",
"const",
"function_version_info",
"c1",
"=",
"*",
"(",
"const",
"function_version_info",
"*",
")",
"v1",
";",
"const",
"function_version_info",
"c2",
"=",
"*",
"(",
"const",
"function_version_info",
"*",
")",
"v2",
";"
] |
LLVM | TPC | CPP | stmt_completion | Virtual ISA | 3,793 | [
")",
"{"
] | [
"~",
"ValueReplacer",
"("
] |
LLVM | CellSPU | TD | stmt_completion | MPU | 3,794 | [
"$",
"rB",
")",
")",
")",
")",
"]",
">",
";"
] | [
"class",
"ANDCVecInst",
"<",
"ValueType",
"vectype",
",",
"PatFrag",
"vnot_frag",
"=",
"vnot",
">",
":",
"ANDCInst",
"<",
"(",
"outs",
"VECREG",
":",
"$",
"rT",
")",
",",
"(",
"ins",
"VECREG",
":",
"$",
"rA",
",",
"VECREG",
":",
"$",
"rB",
")",
",",
"[",
"(",
"set",
"(",
"vectype",
"VECREG",
":",
"$",
"rT",
")",
",",
"(",
"and",
"(",
"vectype",
"VECREG",
":",
"$",
"rA",
")",
",",
"(",
"vnot_frag",
"(",
"vectype",
"VECREG",
":"
] |
GCC | bpf | CPP | stmt_completion | Virtual ISA | 3,795 | [
";"
] | [
"static",
"inline",
"int",
"search_builtin_data",
"(",
"builtin_local_data_compare_fn",
"callback",
",",
"struct",
"cr_builtins",
"*",
"elem",
")",
"{",
"unsigned",
"int",
"i",
";",
"if",
"(",
"builtins_data",
"!=",
"NULL",
")",
"for",
"(",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"builtins_data",
"->",
"length",
"(",
")",
";",
"i",
"++",
")",
"if",
"(",
"(",
"callback",
"!=",
"NULL",
"&&",
"(",
"callback",
")",
"(",
"elem",
",",
"(",
"*",
"builtins_data",
")",
"[",
"i",
"]",
")",
")",
"||",
"(",
"callback",
"==",
"NULL",
"&&",
"(",
"(",
"*",
"builtins_data",
")",
"[",
"i",
"]",
"->",
"or",
"ig_arg_expr",
"==",
"elem",
"->",
"or",
"ig_arg_expr",
")",
")",
")",
"return",
"(",
"int",
")",
"i",
";",
"return",
"-",
"<NUM_LIT>"
] |
LLVM | AArch64 | CPP | next_suggestion | CPU | 3,796 | [
"if",
"(",
"ImmedCmp",
")",
"return",
"{",
"ImmedCmp",
",",
"P",
"}",
";"
] | [
"LLT",
"CmpTy",
"=",
"MRI",
".",
"getType",
"(",
"LHS",
".",
"getReg",
"(",
")",
")",
";",
"assert",
"(",
"(",
"CmpTy",
".",
"isScalar",
"(",
")",
"||",
"CmpTy",
".",
"isPointer",
"(",
")",
")",
"&&",
"<STR_LIT>",
"Expected scalar or pointer",
"<STR_LIT>",
")",
";",
"if",
"(",
"CmpTy",
"==",
"LLT",
"::",
"scalar",
"(",
"<NUM_LIT>",
")",
")",
"{",
"CmpOpc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"ZReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"}",
"else",
"if",
"(",
"CmpTy",
"==",
"LLT",
"::",
"scalar",
"(",
"<NUM_LIT>",
")",
"||",
"CmpTy",
".",
"isPointer",
"(",
")",
")",
"{",
"CmpOpc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"ZReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"}",
"else",
"{",
"return",
"{",
"nullptr",
",",
"CmpInst",
"::",
"Predicate",
"::",
"BAD_ICMP_PREDICATE",
"}",
";",
"}",
"MachineInstr",
"*",
"ImmedCmp",
"=",
"tryOptArithImmedIntegerCompare",
"(",
"LHS",
",",
"RHS",
",",
"P",
",",
"MIRBuilder",
")",
";"
] |
GCC | lm32 | CPP | next_suggestion | MPU | 3,797 | [
"}"
] | [
"return",
"<NUM_LIT>",
";",
"}",
"size",
"=",
"int_size_in_bytes",
"(",
"type",
")",
";",
"if",
"(",
"size",
">=",
"<NUM_LIT>",
"&&",
"size",
"<=",
"UNITS_PER_WORD",
")",
"{",
"return",
"<NUM_LIT>",
";"
] |
GCC | rs6000 | MD | next_suggestion | CPU | 3,798 | [
"}",
")"
] | [
"{",
"emit_insn",
"(",
"gen_vector_select_",
"<",
"mode",
">",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"gen_lowpart",
"(",
"<",
"MODE",
">",
"mode",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
")",
")",
"DONE"
] |
GCC | ia64 | MD | stmt_completion | CPU | 3,799 | [
")",
")",
")",
")"
] | [
"(",
"define_predicate",
"<STR_LIT>",
"(",
"and",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"not",
"(",
"match_code",
"<STR_LIT>"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.