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 | Hexagon | TD | next_suggestion | DSP | 8,500 | [
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";"
]
| [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicateLate",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax1",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax2",
"=",
"<NUM_LIT>",
";",
"let",
"Defs",
"=",
"[",
"LC0",
",",
"P3",
",",
"SA0",
",",
"USR",
"]",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";"
]
|
LLVM | TPC | TD | next_suggestion | Virtual ISA | 8,501 | [
"let",
"PredAddress",
"=",
"pred",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";"
]
| [
"bits",
"<",
"<NUM_LIT>",
">",
"dest",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"op1",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"op2",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"sw",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"pred",
";",
"let",
"Dest",
"=",
"dest",
";",
"let",
"SrcA",
"=",
"op1",
";",
"let",
"SrcB",
"=",
"op2",
";",
"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",
"Switches",
"{",
"<NUM_LIT>",
"}",
"=",
"sw",
"{",
"<NUM_LIT>",
"}",
";"
]
|
LLVM | AArch64 | TD | stmt_completion | CPU | 8,502 | [
"(",
"extract_high_v8i16",
"V128",
":",
"$",
"Rn",
")",
",",
"(",
"extract_high_v8i16",
"V128",
":",
"$",
"Rm",
")",
")",
")",
")",
")",
")",
"]",
">",
";"
]
| [
"def",
"v8i16_v4i32",
":",
"BaseSIMDDifferentThreeVectorTied",
"<",
"U",
",",
"<NUM_LIT>",
",",
"opc",
",",
"V128",
",",
"V128",
",",
"V128",
",",
"asm",
"#",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"[",
"(",
"set",
"(",
"v4i32",
"V128",
":",
"$",
"dst",
")",
",",
"(",
"add",
"(",
"v4i32",
"V128",
":",
"$",
"Rd",
")",
",",
"(",
"zext",
"(",
"v4i16",
"(",
"OpNode"
]
|
GCC | rs6000 | CPP | code_generation | CPU | 8,503 | [
"sbitmap",
"rs6000_get_separate_components",
"(",
"void",
")",
"{",
"rs6000_stack_t",
"*",
"info",
"=",
"rs6000_stack_info",
"(",
")",
";",
"if",
"(",
"WORLD_SAVE_P",
"(",
"info",
")",
")",
"return",
"NULL",
";",
"gcc_assert",
"(",
"!",
"(",
"info",
"->",
"savres_strategy",
"&",
"SAVE_MULTIPLE",
")",
"&&",
"!",
"(",
"info",
"->",
"savres_strategy",
"&",
"REST_MULTIPLE",
")",
")",
";",
"cfun",
"->",
"machine",
"->",
"n_components",
"=",
"<NUM_LIT>",
";",
"sbitmap",
"components",
"=",
"sbitmap_alloc",
"(",
"cfun",
"->",
"machine",
"->",
"n_components",
")",
";",
"bitmap_clear",
"(",
"components",
")",
";",
"int",
"reg_size",
"=",
"TARGET_32BIT",
"?",
"<NUM_LIT>",
":",
"<NUM_LIT>",
";",
"int",
"fp_reg_size",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"(",
"info",
"->",
"savres_strategy",
"&",
"SAVE_INLINE_GPRS",
")",
"&&",
"(",
"info",
"->",
"savres_strategy",
"&",
"REST_INLINE_GPRS",
")",
")",
"{",
"int",
"offset",
"=",
"info",
"->",
"gp_save_offset",
";",
"if",
"(",
"info",
"->",
"push_p",
")",
"offset",
"+=",
"info",
"->",
"total_size",
";",
"for",
"(",
"unsigned",
"regno",
"=",
"info",
"->",
"first_gp_reg_save",
";",
"regno",
"<",
"<NUM_LIT>",
";",
"regno",
"++",
")",
"{",
"if",
"(",
"IN_RANGE",
"(",
"offset",
",",
"-",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
"&&",
"save_reg_p",
"(",
"regno",
")",
")",
"bitmap_set_bit",
"(",
"components",
",",
"regno",
")",
";",
"offset",
"+=",
"reg_size",
";",
"}",
"}",
"if",
"(",
"frame_pointer_needed",
")",
"bitmap_clear_bit",
"(",
"components",
",",
"HARD_FRAME_POINTER_REGNUM",
")",
";",
"if",
"(",
"(",
"TARGET_TOC",
"&&",
"TARGET_MINIMAL_TOC",
")",
"||",
"(",
"flag_pic",
"==",
"<NUM_LIT>",
"&&",
"DEFAULT_ABI",
"==",
"ABI_V4",
")",
"||",
"(",
"flag_pic",
"&&",
"DEFAULT_ABI",
"==",
"ABI_DARWIN",
")",
")",
"bitmap_clear_bit",
"(",
"components",
",",
"RS6000_PIC_OFFSET_TABLE_REGNUM",
")",
";",
"if",
"(",
"(",
"info",
"->",
"savres_strategy",
"&",
"SAVE_INLINE_FPRS",
")",
"&&",
"(",
"info",
"->",
"savres_strategy",
"&",
"REST_INLINE_FPRS",
")",
")",
"{",
"int",
"offset",
"=",
"info",
"->",
"fp_save_offset",
";",
"if",
"(",
"info",
"->",
"push_p",
")",
"offset",
"+=",
"info",
"->",
"total_size",
";",
"for",
"(",
"unsigned",
"regno",
"=",
"info",
"->",
"first_fp_reg_save",
";",
"regno",
"<",
"<NUM_LIT>",
";",
"regno",
"++",
")",
"{",
"if",
"(",
"IN_RANGE",
"(",
"offset",
",",
"-",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
"&&",
"save_reg_p",
"(",
"regno",
")",
")",
"bitmap_set_bit",
"(",
"components",
",",
"regno",
")",
";",
"offset",
"+=",
"fp_reg_size",
";",
"}",
"}",
"if",
"(",
"info",
"->",
"lr_save_p",
"&&",
"!",
"(",
"flag_pic",
"&&",
"(",
"DEFAULT_ABI",
"==",
"ABI_V4",
"||",
"DEFAULT_ABI",
"==",
"ABI_DARWIN",
")",
")",
"&&",
"(",
"info",
"->",
"savres_strategy",
"&",
"SAVE_INLINE_GPRS",
")",
"&&",
"(",
"info",
"->",
"savres_strategy",
"&",
"REST_INLINE_GPRS",
")",
"&&",
"(",
"info",
"->",
"savres_strategy",
"&",
"SAVE_INLINE_FPRS",
")",
"&&",
"(",
"info",
"->",
"savres_strategy",
"&",
"REST_INLINE_FPRS",
")",
"&&",
"(",
"info",
"->",
"savres_strategy",
"&",
"SAVE_INLINE_VRS",
")",
"&&",
"(",
"info",
"->",
"savres_strategy",
"&",
"REST_INLINE_VRS",
")",
")",
"{",
"int",
"offset",
"=",
"info",
"->",
"lr_save_offset",
";",
"if",
"(",
"info",
"->",
"push_p",
")",
"offset",
"+=",
"info",
"->",
"total_size",
";",
"if",
"(",
"IN_RANGE",
"(",
"offset",
",",
"-",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
")",
"bitmap_set_bit",
"(",
"components",
",",
"<NUM_LIT>",
")",
";",
"}",
"if",
"(",
"cfun",
"->",
"machine",
"->",
"save_toc_in_prologue",
")",
"bitmap_set_bit",
"(",
"components",
",",
"<NUM_LIT>",
")",
";",
"return",
"components",
";",
"}"
]
| [
"Implement",
"TARGET_SHRINK_WRAP_GET_SEPARATE_COMPONENTS",
"."
]
|
LLVM | AMDGPU | CPP | stmt_completion | GPU | 8,504 | [
"SplitBB",
";"
]
| [
"MachineBasicBlock",
"*",
"SITargetLowering",
"::",
"splitKillBlock",
"(",
"MachineInstr",
"&",
"MI",
",",
"MachineBasicBlock",
"*",
"BB",
")",
"const",
"{",
"MachineBasicBlock",
"*",
"SplitBB",
"=",
"BB",
"->",
"splitAt",
"(",
"MI",
",",
"false",
")",
";",
"const",
"SIInstrInfo",
"*",
"TII",
"=",
"getSubtarget",
"(",
")",
"->",
"getInstrInfo",
"(",
")",
";",
"MI",
".",
"setDesc",
"(",
"TII",
"->",
"getKillTerminatorFromPseudo",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
")",
";",
"return"
]
|
LLVM | ARM | CPP | next_suggestion | CPU | 8,505 | [
"return",
"MCDisassembler",
"::",
"Success",
";"
]
| [
"if",
"(",
"RegNo",
">",
"<NUM_LIT>",
")",
"return",
"MCDisassembler",
"::",
"Fail",
";",
"unsigned",
"Register",
"=",
"QPRDecoderTable",
"[",
"RegNo",
"]",
";",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createReg",
"(",
"Register",
")",
")",
";"
]
|
GCC | rs6000 | CPP | stmt_completion | CPU | 8,506 | [
"signed",
"char",
")",
"a2",
")",
";"
]
| [
"return",
"(",
"vector",
"unsigned",
"char",
")",
"_",
"_",
"builtin_altivec_vmrglb",
"(",
"(",
"vector",
"signed",
"char",
")",
"a1",
",",
"(",
"vector"
]
|
LLVM | AArch64 | CPP | next_suggestion | CPU | 8,507 | [
"}"
]
| [
"SDValue",
"ShuffleVec",
";",
"int",
"WindowBase",
";",
"int",
"WindowScale",
";",
"bool",
"operator",
"==",
"(",
"SDValue",
"OtherVec",
")",
"{",
"return",
"Vec",
"==",
"OtherVec",
";",
"}",
"ShuffleSourceInfo",
"(",
"SDValue",
"Vec",
")",
":",
"Vec",
"(",
"Vec",
")",
",",
"MinElt",
"(",
"UINT_MAX",
")",
",",
"MaxElt",
"(",
"<NUM_LIT>",
")",
",",
"ShuffleVec",
"(",
"Vec",
")",
",",
"WindowBase",
"(",
"<NUM_LIT>",
")",
",",
"WindowScale",
"(",
"<NUM_LIT>",
")",
"{",
"}",
"}",
";",
"SmallVector",
"<",
"ShuffleSourceInfo",
",",
"<NUM_LIT>",
">",
"Sources",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"NumElts",
";",
"++",
"i",
")",
"{",
"SDValue",
"V",
"=",
"Op",
".",
"getOperand",
"(",
"i",
")",
";",
"if",
"(",
"V",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"UNDEF",
")",
"continue",
";",
"else",
"if",
"(",
"V",
".",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"EXTRACT_VECTOR_ELT",
")",
"{",
"return",
"SDValue",
"(",
")",
";",
"}",
"SDValue",
"SourceVec",
"=",
"V",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"auto",
"Source",
"=",
"std",
"::",
"find",
"(",
"Sources",
".",
"begin",
"(",
")",
",",
"Sources",
".",
"end",
"(",
")",
",",
"SourceVec",
")",
";",
"if",
"(",
"Source",
"==",
"Sources",
".",
"end",
"(",
")",
")",
"Source",
"=",
"Sources",
".",
"insert",
"(",
"Sources",
".",
"end",
"(",
")",
",",
"ShuffleSourceInfo",
"(",
"SourceVec",
")",
")",
";",
"unsigned",
"EltNo",
"=",
"cast",
"<",
"ConstantSDNode",
">",
"(",
"V",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
"->",
"getZExtValue",
"(",
")",
";",
"Source",
"->",
"MinElt",
"=",
"std",
"::",
"min",
"(",
"Source",
"->",
"MinElt",
",",
"EltNo",
")",
";",
"Source",
"->",
"MaxElt",
"=",
"std",
"::",
"max",
"(",
"Source",
"->",
"MaxElt",
",",
"EltNo",
")",
";",
"}",
"if",
"(",
"Sources",
".",
"size",
"(",
")",
">",
"<NUM_LIT>",
")",
"return",
"SDValue",
"(",
")",
";",
"EVT",
"SmallestEltTy",
"=",
"VT",
".",
"getVectorElementType",
"(",
")",
";",
"for",
"(",
"auto",
"&",
"Source",
":",
"Sources",
")",
"{",
"EVT",
"SrcEltTy",
"=",
"Source",
".",
"Vec",
".",
"getValueType",
"(",
")",
".",
"getVectorElementType",
"(",
")",
";",
"if",
"(",
"SrcEltTy",
".",
"bitsLT",
"(",
"SmallestEltTy",
")",
")",
"{",
"SmallestEltTy",
"=",
"SrcEltTy",
";",
"}",
"}",
"unsigned",
"ResMultiplier",
"=",
"VT",
".",
"getVectorElementType",
"(",
")",
".",
"getSizeInBits",
"(",
")",
"/",
"SmallestEltTy",
".",
"getSizeInBits",
"(",
")",
";",
"NumElts",
"=",
"VT",
".",
"getSizeInBits",
"(",
")",
"/",
"SmallestEltTy",
".",
"getSizeInBits",
"(",
")",
";",
"EVT",
"ShuffleVT",
"=",
"EVT",
"::",
"getVectorVT",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
",",
"SmallestEltTy",
",",
"NumElts",
")",
";",
"for",
"(",
"auto",
"&",
"Src",
":",
"Sources",
")",
"{",
"EVT",
"SrcVT",
"=",
"Src",
".",
"ShuffleVec",
".",
"getValueType",
"(",
")",
";",
"if",
"(",
"SrcVT",
".",
"getSizeInBits",
"(",
")",
"==",
"VT",
".",
"getSizeInBits",
"(",
")",
")",
"continue",
";",
"EVT",
"EltVT",
"=",
"SrcVT",
".",
"getVectorElementType",
"(",
")",
";",
"unsigned",
"NumSrcElts",
"=",
"VT",
".",
"getSizeInBits",
"(",
")",
"/",
"EltVT",
".",
"getSizeInBits",
"(",
")",
";",
"EVT",
"DestVT",
"=",
"EVT",
"::",
"getVectorVT",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
",",
"EltVT",
",",
"NumSrcElts",
")",
";",
"if",
"(",
"SrcVT",
".",
"getSizeInBits",
"(",
")",
"<",
"VT",
".",
"getSizeInBits",
"(",
")",
")",
"{",
"assert",
"(",
"<NUM_LIT>",
"*",
"SrcVT",
".",
"getSizeInBits",
"(",
")",
"==",
"VT",
".",
"getSizeInBits",
"(",
")",
")",
";",
"Src",
".",
"ShuffleVec",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"CONCAT_VECTORS",
",",
"dl",
",",
"DestVT",
",",
"Src",
".",
"ShuffleVec",
",",
"DAG",
".",
"getUNDEF",
"(",
"Src",
".",
"ShuffleVec",
".",
"getValueType",
"(",
")",
")",
")",
";",
"continue",
";",
"}",
"assert",
"(",
"SrcVT",
".",
"getSizeInBits",
"(",
")",
"==",
"<NUM_LIT>",
"*",
"VT",
".",
"getSizeInBits",
"(",
")",
")",
";",
"if",
"(",
"Src",
".",
"MaxElt",
"-",
"Src",
".",
"MinElt",
">=",
"NumSrcElts",
")",
"{",
"return",
"SDValue",
"(",
")",
";",
"}",
"if",
"(",
"Src",
".",
"MinElt",
">=",
"NumSrcElts",
")",
"{",
"Src",
".",
"ShuffleVec",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"EXTRACT_SUBVECTOR",
",",
"dl",
",",
"DestVT",
",",
"Src",
".",
"ShuffleVec",
",",
"DAG",
".",
"getIntPtrConstant",
"(",
"NumSrcElts",
")",
")",
";",
"Src",
".",
"WindowBase",
"=",
"-",
"NumSrcElts",
";",
"}",
"else",
"if",
"(",
"Src",
".",
"MaxElt",
"<",
"NumSrcElts",
")",
"{",
"Src",
".",
"ShuffleVec",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"EXTRACT_SUBVECTOR",
",",
"dl",
",",
"DestVT",
",",
"Src",
".",
"ShuffleVec",
",",
"DAG",
".",
"getIntPtrConstant",
"(",
"<NUM_LIT>",
")",
")",
";",
"}",
"else",
"{",
"SDValue",
"VEXTSrc1",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"EXTRACT_SUBVECTOR",
",",
"dl",
",",
"DestVT",
",",
"Src",
".",
"ShuffleVec",
",",
"DAG",
".",
"getIntPtrConstant",
"(",
"<NUM_LIT>",
")",
")",
";",
"SDValue",
"VEXTSrc2",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"EXTRACT_SUBVECTOR",
",",
"dl",
",",
"DestVT",
",",
"Src",
".",
"ShuffleVec",
",",
"DAG",
".",
"getIntPtrConstant",
"(",
"NumSrcElts",
")",
")",
";",
"unsigned",
"Imm",
"=",
"Src",
".",
"MinElt",
"*",
"getExtFactor",
"(",
"VEXTSrc1",
")",
";",
"Src",
".",
"ShuffleVec",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"DestVT",
",",
"VEXTSrc1",
",",
"VEXTSrc2",
",",
"DAG",
".",
"getConstant",
"(",
"Imm",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"Src",
".",
"WindowBase",
"=",
"-",
"Src",
".",
"MinElt",
";",
"}"
]
|
GCC | arm | MD | next_suggestion | CPU | 8,508 | [
"<STR_LIT>"
]
| [
"(",
"plus",
":",
"VH",
"(",
"match_operand",
":",
"VH",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"VH",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]"
]
|
LLVM | X86 | CPP | next_suggestion | CPU | 8,509 | [
"if",
"(",
"Is1BitVector",
")",
"return",
"lower1BitVectorShuffle",
"(",
"DL",
",",
"Mask",
",",
"VT",
",",
"V1",
",",
"V2",
",",
"Zeroable",
",",
"Subtarget",
",",
"DAG",
")",
";"
]
| [
"if",
"(",
"SDValue",
"Broadcast",
"=",
"lowerVectorShuffleAsBroadcast",
"(",
"DL",
",",
"VT",
",",
"V1",
",",
"V2",
",",
"Mask",
",",
"Subtarget",
",",
"DAG",
")",
")",
"return",
"Broadcast",
";",
"MVT",
"NewEltVT",
"=",
"VT",
".",
"isFloatingPoint",
"(",
")",
"?",
"MVT",
"::",
"getFloatingPointVT",
"(",
"VT",
".",
"getScalarSizeInBits",
"(",
")",
"*",
"<NUM_LIT>",
")",
":",
"MVT",
"::",
"getIntegerVT",
"(",
"VT",
".",
"getScalarSizeInBits",
"(",
")",
"*",
"<NUM_LIT>",
")",
";",
"int",
"NewNumElts",
"=",
"NumElements",
"/",
"<NUM_LIT>",
";",
"MVT",
"NewVT",
"=",
"MVT",
"::",
"getVectorVT",
"(",
"NewEltVT",
",",
"NewNumElts",
")",
";",
"if",
"(",
"DAG",
".",
"getTargetLoweringInfo",
"(",
")",
".",
"isTypeLegal",
"(",
"NewVT",
")",
")",
"{",
"if",
"(",
"V2IsZero",
")",
"{",
"bool",
"UsedZeroVector",
"=",
"false",
";",
"assert",
"(",
"find",
"(",
"WidenedMask",
",",
"SM_SentinelZero",
")",
"!=",
"WidenedMask",
".",
"end",
"(",
")",
"&&",
"<STR_LIT>",
"V2's non-undef elements are used?!",
"<STR_LIT>",
")",
";",
"for",
"(",
"int",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"!=",
"NewNumElts",
";",
"++",
"i",
")",
"if",
"(",
"WidenedMask",
"[",
"i",
"]",
"==",
"SM_SentinelZero",
")",
"{",
"WidenedMask",
"[",
"i",
"]",
"=",
"i",
"+",
"NewNumElts",
";",
"UsedZeroVector",
"=",
"true",
";",
"}",
"if",
"(",
"UsedZeroVector",
")",
"V2",
"=",
"getZeroVector",
"(",
"NewVT",
",",
"Subtarget",
",",
"DAG",
",",
"DL",
")",
";",
"}",
"V1",
"=",
"DAG",
".",
"getBitcast",
"(",
"NewVT",
",",
"V1",
")",
";",
"V2",
"=",
"DAG",
".",
"getBitcast",
"(",
"NewVT",
",",
"V2",
")",
";",
"return",
"DAG",
".",
"getBitcast",
"(",
"VT",
",",
"DAG",
".",
"getVectorShuffle",
"(",
"NewVT",
",",
"DL",
",",
"V1",
",",
"V2",
",",
"WidenedMask",
")",
")",
";",
"}",
"}",
"if",
"(",
"canonicalizeShuffleMaskWithCommute",
"(",
"Mask",
")",
")",
"return",
"DAG",
".",
"getCommutedVectorShuffle",
"(",
"*",
"SVOp",
")",
";",
"if",
"(",
"SDValue",
"V",
"=",
"lowerVectorShuffleWithVPMOV",
"(",
"DL",
",",
"Mask",
",",
"VT",
",",
"V1",
",",
"V2",
",",
"DAG",
",",
"Subtarget",
")",
")",
"return",
"V",
";",
"if",
"(",
"VT",
".",
"is128BitVector",
"(",
")",
")",
"return",
"lower128BitVectorShuffle",
"(",
"DL",
",",
"Mask",
",",
"VT",
",",
"V1",
",",
"V2",
",",
"Zeroable",
",",
"Subtarget",
",",
"DAG",
")",
";",
"if",
"(",
"VT",
".",
"is256BitVector",
"(",
")",
")",
"return",
"lower256BitVectorShuffle",
"(",
"DL",
",",
"Mask",
",",
"VT",
",",
"V1",
",",
"V2",
",",
"Zeroable",
",",
"Subtarget",
",",
"DAG",
")",
";",
"if",
"(",
"VT",
".",
"is512BitVector",
"(",
")",
")",
"return",
"lower512BitVectorShuffle",
"(",
"DL",
",",
"Mask",
",",
"VT",
",",
"V1",
",",
"V2",
",",
"Zeroable",
",",
"Subtarget",
",",
"DAG",
")",
";"
]
|
LLVM | PowerPC | CPP | next_suggestion | CPU | 8,510 | [
"}"
]
| [
"if",
"(",
"this",
"->",
"PPCSubTarget",
".",
"isPPC64",
"(",
")",
")",
"{",
"return",
"MVT",
"::",
"i64",
";",
"}",
"else",
"{",
"return",
"MVT",
"::",
"i32",
";"
]
|
GCC | rs6000 | MD | next_suggestion | CPU | 8,511 | [
"<STR_LIT>",
")"
]
| [
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")"
]
|
GCC | s390 | CPP | program_repair | MPU | 8,512 | [
"<FIXS>",
"error",
"(",
"<STR_LIT>",
"thunk-inline is only supported with %<-mindirect-branch-jump%>",
"<STR_LIT>",
")",
";",
"<FIXE>"
]
| [
"||",
"opts",
"->",
"x_s390_function_return",
"==",
"indirect_branch_thunk_inline",
"||",
"opts",
"->",
"x_s390_function_return_reg",
"==",
"indirect_branch_thunk_inline",
"||",
"opts",
"->",
"x_s390_function_return_mem",
"==",
"indirect_branch_thunk_inline",
")",
"<BUGS>",
"error",
"(",
"<STR_LIT>",
"thunk-inline is only supported with -mindirect-branch-jump",
"<STR_LIT>",
")",
";",
"<BUGE>",
"if",
"(",
"opts",
"->",
"x_s390_indirect_branch",
"!=",
"indirect_branch_keep",
")",
"{"
]
|
LLVM | AArch64 | CPP | stmt_completion | CPU | 8,513 | [
",",
"ShiftOpB",
")",
";"
]
| [
"}",
";",
"auto",
"IsSignExtended",
"=",
"[",
"&",
"DAG",
"]",
"(",
"SDValue",
"&",
"Node",
")",
"{",
"return",
"(",
"DAG",
".",
"ComputeNumSignBits",
"(",
"Node",
",",
"<NUM_LIT>",
")",
">",
"<NUM_LIT>",
")",
";",
"}",
";",
"SDValue",
"ConstantOne",
"=",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"dl",
",",
"VT",
")",
";",
"if",
"(",
"(",
"!",
"IsSigned",
"&&",
"IsZeroExtended",
"(",
"OpA",
")",
"&&",
"IsZeroExtended",
"(",
"OpB",
")",
")",
"||",
"(",
"IsSigned",
"&&",
"IsSignExtended",
"(",
"OpA",
")",
"&&",
"IsSignExtended",
"(",
"OpB",
")",
")",
")",
"{",
"SDValue",
"Add",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"dl",
",",
"VT",
",",
"OpA",
",",
"OpB",
")",
";",
"if",
"(",
"IsCeil",
")",
"Add",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"dl",
",",
"VT",
",",
"Add",
",",
"ConstantOne",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"ShiftOpc",
",",
"dl",
",",
"VT",
",",
"Add",
",",
"ConstantOne",
")",
";",
"}",
"SDValue",
"ShiftOpA",
"=",
"DAG",
".",
"getNode",
"(",
"ShiftOpc",
",",
"dl",
",",
"VT",
",",
"OpA",
",",
"ConstantOne",
")",
";",
"SDValue",
"ShiftOpB",
"=",
"DAG",
".",
"getNode",
"(",
"ShiftOpc",
",",
"dl",
",",
"VT",
",",
"OpB",
",",
"ConstantOne",
")",
";",
"SDValue",
"tmp",
"=",
"DAG",
".",
"getNode",
"(",
"IsCeil",
"?",
"ISD",
"::",
"OR",
":",
"ISD",
"::",
"AND",
",",
"dl",
",",
"VT",
",",
"OpA",
",",
"OpB",
")",
";",
"tmp",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"AND",
",",
"dl",
",",
"VT",
",",
"tmp",
",",
"ConstantOne",
")",
";",
"SDValue",
"Add",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"dl",
",",
"VT",
",",
"ShiftOpA"
]
|
LLVM | AMDGPU | CPP | stmt_completion | GPU | 8,514 | [
"const",
"{"
]
| [
"bool",
"hasDX10ClampMode",
"(",
")"
]
|
GCC | aarch64 | CPP | program_repair | CPU | 8,515 | [
"<FIXS>",
"mode_for_vector",
"(",
"int_mode_for_mode",
"(",
"GET_MODE_INNER",
"(",
"mode",
")",
")",
".",
"require",
"(",
")",
",",
"<FIXE>"
]
| [
"}",
"machine_mode",
"mmsk",
"<BUGS>",
"mode_for_vector",
"(",
"int_mode_for_mode",
"(",
"GET_MODE_INNER",
"(",
"mode",
")",
")",
",",
"<BUGE>",
"GET_MODE_NUNITS",
"(",
"mode",
")",
")",
";",
"if",
"(",
"!",
"recp",
")",
"{"
]
|
GCC | arm | CPP | stmt_completion | CPU | 8,516 | [
"<STR_LIT>",
")",
";"
]
| [
"int",
"i",
";",
"char",
"pattern",
"[",
"<NUM_LIT>",
"]",
";",
"int",
"offset",
";",
"const",
"char",
"*",
"conditional",
";",
"int",
"num_saves",
"=",
"XVECLEN",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"<NUM_LIT>",
")",
";",
"unsigned",
"int",
"regno",
";",
"unsigned",
"int",
"regno_base",
"=",
"REGNO",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
";",
"offset",
"=",
"<NUM_LIT>",
";",
"offset",
"+=",
"update",
"?",
"<NUM_LIT>",
":",
"<NUM_LIT>",
";",
"offset",
"+=",
"return_pc",
"?",
"<NUM_LIT>",
":",
"<NUM_LIT>",
";",
"for",
"(",
"i",
"=",
"offset",
";",
"i",
"<",
"num_saves",
";",
"i",
"++",
")",
"{",
"regno",
"=",
"REGNO",
"(",
"XEXP",
"(",
"XVECEXP",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"<NUM_LIT>",
",",
"i",
")",
",",
"<NUM_LIT>",
")",
")",
";",
"gcc_assert",
"(",
"(",
"regno",
"!=",
"SP_REGNUM",
")",
"||",
"(",
"regno_base",
"==",
"SP_REGNUM",
")",
")",
";",
"if",
"(",
"regno",
"==",
"regno_base",
")",
"gcc_assert",
"(",
"!",
"update",
")",
";",
"}",
"conditional",
"=",
"reverse",
"?",
"<STR_LIT>",
"%?%D0",
"<STR_LIT>",
":",
"<STR_LIT>",
"%?%d0",
"<STR_LIT>",
";",
"if",
"(",
"(",
"regno_base",
"==",
"SP_REGNUM",
")",
"&&",
"TARGET_UNIFIED_ASM",
")",
"{",
"gcc_assert",
"(",
"update",
")",
";",
"sprintf",
"(",
"pattern",
",",
"<STR_LIT>",
"pop%s\\t{",
"<STR_LIT>",
",",
"conditional",
")",
";",
"}",
"else",
"{",
"if",
"(",
"regno_base",
"==",
"SP_REGNUM",
")",
"sprintf",
"(",
"pattern",
",",
"<STR_LIT>",
"ldm%sfd\\t",
"<STR_LIT>",
",",
"conditional",
")",
";",
"else",
"if",
"(",
"TARGET_UNIFIED_ASM",
")",
"sprintf",
"(",
"pattern",
",",
"<STR_LIT>",
"ldmia%s\\t",
"<STR_LIT>",
",",
"conditional",
")",
";",
"else",
"sprintf",
"(",
"pattern",
",",
"<STR_LIT>",
"ldm%sia\\t",
"<STR_LIT>",
",",
"conditional",
")",
";",
"strcat",
"(",
"pattern",
",",
"reg_names",
"[",
"regno_base",
"]",
")",
";",
"if",
"(",
"update",
")",
"strcat",
"(",
"pattern",
",",
"<STR_LIT>",
"!, {",
"<STR_LIT>",
")",
";",
"else",
"strcat",
"(",
"pattern",
",",
"<STR_LIT>",
", {",
"<STR_LIT>",
")",
";",
"}",
"strcat",
"(",
"pattern",
",",
"reg_names",
"[",
"REGNO",
"(",
"XEXP",
"(",
"XVECEXP",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"<NUM_LIT>",
",",
"offset",
")",
",",
"<NUM_LIT>",
")",
")",
"]",
")",
";",
"for",
"(",
"i",
"=",
"offset",
"+",
"<NUM_LIT>",
";",
"i",
"<",
"num_saves",
";",
"i",
"++",
")",
"{",
"strcat",
"(",
"pattern",
",",
"<STR_LIT>",
", "
]
|
GCC | stormy16 | CPP | stmt_completion | CPU | 8,517 | [
"frame_size",
"==",
"<NUM_LIT>",
")",
";"
]
| [
"int",
"direct_return",
"(",
"void",
")",
"{",
"return",
"(",
"reload_completed",
"&&",
"xstormy16_compute_stack_layout",
"(",
")",
"."
]
|
GCC | xtensa | CPP | next_suggestion | MPU | 8,518 | [
"}"
]
| [
"if",
"(",
"suffix",
"&&",
"strcmp",
"(",
"suffix",
",",
"<STR_LIT>",
".bss",
"<STR_LIT>",
")",
"==",
"<NUM_LIT>",
")",
"{",
"if",
"(",
"!",
"decl",
"||",
"(",
"VAR_P",
"(",
"decl",
")",
"&&",
"DECL_INITIAL",
"(",
"decl",
")",
"==",
"NULL_TREE",
")",
")",
"flags",
"|=",
"SECTION_BSS",
";",
"else",
"warning",
"(",
"<NUM_LIT>",
",",
"<STR_LIT>",
"only uninitialized variables can be placed in a ",
"<STR_LIT>",
"<STR_LIT>",
"%<.bss%> section",
"<STR_LIT>",
")",
";",
"}",
"return",
"flags",
";"
]
|
GCC | mep | MD | stmt_completion | CPU | 8,519 | [
"match_code",
"<STR_LIT>",
")"
]
| [
"(",
"define_predicate",
"<STR_LIT>",
"(",
"and",
"("
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 8,520 | [
"let",
"opExtentAlign",
"=",
"<NUM_LIT>",
";"
]
| [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax1",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax2",
"=",
"<NUM_LIT>",
";",
"let",
"Defs",
"=",
"[",
"LC1",
",",
"SA1",
"]",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
";"
]
|
GCC | aarch64 | CPP | stmt_completion | CPU | 8,521 | [
"_",
"_",
"b",
",",
"_",
"_",
"c",
")",
";"
]
| [
"return",
"_",
"_",
"builtin_aarch64_ursra_nv8qi_uuus",
"(",
"_",
"_",
"a",
","
]
|
GCC | arm | CPP | stmt_completion | CPU | 8,522 | [
"c",
",",
"const",
"int",
"_",
"_",
"d",
")",
"{"
]
| [
"vmlsl_lane_u16",
"(",
"uint32x4_t",
"_",
"_",
"a",
",",
"uint16x4_t",
"_",
"_",
"b",
",",
"uint16x4_t",
"_",
"_"
]
|
LLVM | AArch64 | CPP | stmt_completion | CPU | 8,523 | [
";"
]
| [
"if",
"(",
"useSVEForFixedLengthVectorVT",
"(",
"VT",
",",
"true",
")",
")",
"return",
"LowerFixedLengthVectorStoreToSVE",
"(",
"Op",
",",
"DAG",
")",
";",
"unsigned",
"AS",
"=",
"StoreNode",
"->",
"getAddressSpace",
"(",
")",
";",
"Align",
"Alignment",
"=",
"StoreNode",
"->",
"getAlign",
"(",
")",
";",
"if",
"(",
"Alignment",
"<",
"MemVT",
".",
"getStoreSize",
"(",
")",
"&&",
"!",
"allowsMisalignedMemoryAccesses",
"(",
"MemVT",
",",
"AS",
",",
"Alignment",
",",
"StoreNode",
"->",
"getMemOperand",
"(",
")",
"->",
"getFlags",
"(",
")",
",",
"nullptr",
")",
")",
"{",
"return",
"scalarizeVectorStore",
"(",
"StoreNode",
",",
"DAG",
")",
";",
"}",
"if",
"(",
"StoreNode",
"->",
"isTruncatingStore",
"(",
")",
"&&",
"VT",
"==",
"MVT",
"::",
"v4i16",
"&&",
"MemVT",
"==",
"MVT",
"::",
"v4i8",
")",
"{",
"return",
"LowerTruncateVectorStore",
"(",
"Dl",
",",
"StoreNode",
",",
"VT",
",",
"MemVT",
",",
"DAG",
")",
";",
"}",
"ElementCount",
"EC",
"=",
"MemVT",
".",
"getVectorElementCount",
"(",
")",
";",
"if",
"(",
"StoreNode",
"->",
"isNonTemporal",
"(",
")",
"&&",
"MemVT",
".",
"getSizeInBits",
"(",
")",
"==",
"<NUM_LIT>",
"u",
"&&",
"EC",
".",
"isKnownEven",
"(",
")",
"&&",
"(",
"(",
"MemVT",
".",
"getScalarSizeInBits",
"(",
")",
"==",
"<NUM_LIT>",
"u",
"||",
"MemVT",
".",
"getScalarSizeInBits",
"(",
")",
"==",
"<NUM_LIT>",
"u",
"||",
"MemVT",
".",
"getScalarSizeInBits",
"(",
")",
"==",
"<NUM_LIT>",
"u",
"||",
"MemVT",
".",
"getScalarSizeInBits",
"(",
")",
"==",
"<NUM_LIT>",
"u",
")",
")",
")",
"{",
"SDValue",
"Lo",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"EXTRACT_SUBVECTOR",
",",
"Dl",
",",
"MemVT",
".",
"getHalfNumVectorElementsVT",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
",",
"StoreNode",
"->",
"getValue",
"(",
")",
",",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"Dl",
",",
"MVT",
"::",
"i64",
")",
")",
";",
"SDValue",
"Hi",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"EXTRACT_SUBVECTOR",
",",
"Dl",
",",
"MemVT",
".",
"getHalfNumVectorElementsVT",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
",",
"StoreNode",
"->",
"getValue",
"(",
")",
",",
"DAG",
".",
"getConstant",
"(",
"EC",
".",
"getKnownMinValue",
"(",
")",
"/",
"<NUM_LIT>",
",",
"Dl",
",",
"MVT",
"::",
"i64",
")",
")",
";",
"SDValue",
"Result",
"=",
"DAG",
".",
"getMemIntrinsicNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"Dl",
",",
"DAG",
".",
"getVTList",
"(",
"MVT",
"::",
"Other",
")",
",",
"{",
"StoreNode",
"->",
"getChain",
"(",
")",
",",
"Lo",
",",
"Hi",
",",
"StoreNode",
"->",
"getBasePtr",
"(",
")",
"}",
",",
"StoreNode",
"->",
"getMemoryVT",
"(",
")",
",",
"StoreNode",
"->",
"getMemOperand",
"(",
")",
")",
";",
"return",
"Result",
";",
"}",
"}",
"else",
"if",
"(",
"MemVT",
"==",
"MVT",
"::",
"i128",
"&&",
"StoreNode",
"->",
"isVolatile",
"(",
")",
")",
"{",
"return",
"LowerStore128",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"else",
"if",
"(",
"MemVT",
"==",
"MVT",
"::",
"i64x8",
")",
"{",
"SDValue",
"Value",
"=",
"StoreNode",
"->",
"getValue",
"(",
")",
";",
"assert",
"(",
"Value",
"->",
"getValueType",
"(",
"<NUM_LIT>",
")",
"==",
"MVT",
"::",
"i64x8",
")",
";",
"SDValue",
"Chain",
"=",
"StoreNode",
"->",
"getChain",
"(",
")",
";",
"SDValue",
"Base",
"=",
"StoreNode",
"->",
"getBasePtr",
"(",
")",
";",
"EVT",
"PtrVT",
"=",
"Base",
".",
"getValueType",
"(",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"<NUM_LIT>",
";",
"i",
"++",
")",
"{",
"SDValue",
"Part",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"Dl",
",",
"MVT",
"::",
"i64",
",",
"Value",
",",
"DAG",
".",
"getConstant",
"(",
"i",
",",
"Dl",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"SDValue",
"Ptr",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"Dl",
",",
"PtrVT",
",",
"Base",
",",
"DAG",
".",
"getConstant",
"(",
"i",
"*",
"<NUM_LIT>",
",",
"Dl",
",",
"PtrVT",
")",
")",
";",
"Chain",
"=",
"DAG",
".",
"getStore",
"(",
"Chain",
",",
"Dl",
",",
"Part",
",",
"Ptr",
",",
"StoreNode",
"->",
"getPointerInfo",
"(",
")",
",",
"StoreNode",
"->",
"getOriginalAlign",
"(",
")",
")",
";",
"}",
"return",
"Chain"
]
|
LLVM | ARM | CPP | next_suggestion | CPU | 8,524 | [
"}"
]
| [
"void",
"EmitValueImpl",
"(",
"const",
"MCExpr",
"*",
"Value",
",",
"unsigned",
"Size",
",",
"const",
"SMLoc",
"&",
"Loc",
")",
"override",
"{",
"if",
"(",
"const",
"MCSymbolRefExpr",
"*",
"SRE",
"=",
"dyn_cast_or_null",
"<",
"MCSymbolRefExpr",
">",
"(",
"Value",
")",
")",
"if",
"(",
"SRE",
"->",
"getKind",
"(",
")",
"==",
"MCSymbolRefExpr",
"::",
"VK_ARM_SBREL",
"&&",
"!",
"(",
"Size",
"==",
"<NUM_LIT>",
")",
")",
"getContext",
"(",
")",
".",
"FatalError",
"(",
"Loc",
",",
"<STR_LIT>",
"relocated expression must be 32-bit",
"<STR_LIT>",
")",
";",
"EmitDataMappingSymbol",
"(",
")",
";",
"MCELFStreamer",
"::",
"EmitValueImpl",
"(",
"Value",
",",
"Size",
")",
";"
]
|
GCC | alpha | MD | stmt_completion | MPU | 8,525 | [
")"
]
| [
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
]
|
GCC | sparc | MD | stmt_completion | CPU | 8,526 | [
")",
"]"
]
| [
"[",
"(",
"set",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"lo_sum",
":",
"DI",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")"
]
|
LLVM | ARM | CPP | stmt_completion | CPU | 8,527 | [
"predOps",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
";"
]
| [
"if",
"(",
"Arg",
".",
"Flags",
"[",
"<NUM_LIT>",
"]",
".",
"isByVal",
"(",
")",
")",
"return",
"false",
";",
"splitToValueTypes",
"(",
"Arg",
",",
"ArgInfos",
",",
"MF",
")",
";",
"}",
"auto",
"ArgAssignFn",
"=",
"TLI",
".",
"CCAssignFnForCall",
"(",
"Info",
".",
"CallConv",
",",
"IsVarArg",
")",
";",
"ARMOutgoingValueHandler",
"ArgHandler",
"(",
"MIRBuilder",
",",
"MRI",
",",
"MIB",
",",
"ArgAssignFn",
")",
";",
"if",
"(",
"!",
"handleAssignments",
"(",
"MIRBuilder",
",",
"ArgInfos",
",",
"ArgHandler",
")",
")",
"return",
"false",
";",
"MIRBuilder",
".",
"insertInstr",
"(",
"MIB",
")",
";",
"if",
"(",
"!",
"Info",
".",
"OrigRet",
".",
"Ty",
"->",
"isVoidTy",
"(",
")",
")",
"{",
"if",
"(",
"!",
"isSupportedType",
"(",
"DL",
",",
"TLI",
",",
"Info",
".",
"OrigRet",
".",
"Ty",
")",
")",
"return",
"false",
";",
"ArgInfos",
".",
"clear",
"(",
")",
";",
"splitToValueTypes",
"(",
"Info",
".",
"OrigRet",
",",
"ArgInfos",
",",
"MF",
")",
";",
"auto",
"RetAssignFn",
"=",
"TLI",
".",
"CCAssignFnForReturn",
"(",
"Info",
".",
"CallConv",
",",
"IsVarArg",
")",
";",
"CallReturnHandler",
"RetHandler",
"(",
"MIRBuilder",
",",
"MRI",
",",
"MIB",
",",
"RetAssignFn",
")",
";",
"if",
"(",
"!",
"handleAssignments",
"(",
"MIRBuilder",
",",
"ArgInfos",
",",
"RetHandler",
")",
")",
"return",
"false",
";",
"}",
"CallSeqStart",
".",
"addImm",
"(",
"ArgHandler",
".",
"StackSize",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
")",
".",
"add",
"("
]
|
LLVM | Hexagon | TD | stmt_completion | DSP | 8,528 | [
"<NUM_LIT>",
";"
]
| [
"def",
"A2_combineii",
":",
"HInst",
"<",
"(",
"outs",
"DoubleRegs",
":",
"$",
"Rdd32",
")",
",",
"(",
"ins",
"s32_0Imm",
":",
"$",
"Ii",
",",
"s8_0Imm",
":",
"$",
"II",
")",
",",
"<STR_LIT>",
",",
"tc_5a2711e5",
",",
"TypeALU32_2op",
">",
",",
"Enc_18c338",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"isReMaterializable",
"=",
"<NUM_LIT>",
";",
"let",
"isAsCheapAsAMove",
"=",
"<NUM_LIT>",
";",
"let",
"isMoveImm",
"=",
"<NUM_LIT>",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentBits",
"="
]
|
LLVM | AArch64 | TD | next_suggestion | CPU | 8,529 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
]
| [
"class",
"sve_int_perm_insrv",
"<",
"bits",
"<",
"<NUM_LIT>",
">",
"sz8_64",
",",
"string",
"asm",
",",
"ZPRRegOp",
"zprty",
",",
"RegisterClass",
"srcRegType",
">",
":",
"I",
"<",
"(",
"outs",
"zprty",
":",
"$",
"Zdn",
")",
",",
"(",
"ins",
"zprty",
":",
"$",
"_Zdn",
",",
"srcRegType",
":",
"$",
"Vm",
")",
",",
"asm",
",",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"[",
"]",
">",
",",
"Sched",
"<",
"[",
"]",
">",
"{",
"bits",
"<",
"<NUM_LIT>",
">",
"Vm",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Zdn",
";"
]
|
LLVM | Hexagon | CPP | program_repair | DSP | 8,530 | [
"<FIXS>",
"assert",
"(",
"Rt",
".",
"isReg",
"(",
")",
"&&",
"<STR_LIT>",
"Expected register and none was found",
"<STR_LIT>",
")",
";",
"<FIXE>"
]
| [
"case",
"Hexagon",
"::",
"A2_addsp",
":",
"{",
"MCOperand",
"&",
"Rt",
"=",
"Inst",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"<BUGS>",
"assert",
"(",
"Rt",
".",
"isReg",
"(",
")",
"&&",
"<STR_LIT>",
"Expected register and none was found",
"<STR_LIT>",
")",
";",
"<BUGE>",
"unsigned",
"Reg",
"=",
"RI",
"->",
"getEncodingValue",
"(",
"Rt",
".",
"getReg",
"(",
")",
")",
";",
"if",
"(",
"Reg",
"&",
"<NUM_LIT>",
")",
"MappedInst",
".",
"setOpcode",
"(",
"Hexagon",
"::",
"A2_addsph",
")",
";"
]
|
GCC | i386 | MD | stmt_completion | CPU | 8,531 | [
")"
]
| [
"(",
"define_automaton",
"<STR_LIT>"
]
|
GCC | s390 | MD | program_repair | MPU | 8,532 | [
"<FIXS>",
"<FIXE>",
"<FIXS>",
"case",
"<NUM_LIT>",
":",
"return",
"<STR_LIT>",
"case",
"<NUM_LIT>",
":",
"return",
"<STR_LIT>",
"case",
"<NUM_LIT>",
":",
"return",
"<STR_LIT>",
"case",
"<NUM_LIT>",
":",
"return",
"<STR_LIT>",
"<FIXE>",
"<FIXS>",
"}",
"<FIXE>"
]
| [
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"]",
"<STR_LIT>",
"<BUGS>",
"<STR_LIT>",
"<BUGE>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"(",
"define_insn",
"<STR_LIT>"
]
|
GCC | m68k | MD | stmt_completion | MPU | 8,533 | [
")",
">",
"=",
"<NUM_LIT>",
")"
]
| [
"<STR_LIT>",
"{",
"if",
"(",
"GET_CODE",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
"=",
"=",
"CONST_INT",
"&",
"&",
"INTVAL",
"(",
"operands",
"[",
"<NUM_LIT>",
"]"
]
|
GCC | i386 | CPP | stmt_completion | CPU | 8,534 | [
",",
"(",
"_",
"_",
"v1di",
")",
"_",
"_",
"m2",
")",
";"
]
| [
"return",
"(",
"_",
"_",
"m64",
")",
"_",
"_",
"builtin_ia32_paddq",
"(",
"(",
"_",
"_",
"v1di",
")",
"_",
"_",
"m1"
]
|
GCC | ia64 | CPP | next_suggestion | CPU | 8,535 | [
"free",
"(",
"curr_state",
"->",
"dfa_state",
")",
";"
]
| [
"for",
"(",
"curr_state",
"=",
"allocated_bundle_states_chain",
";",
"curr_state",
"!=",
"NULL",
";",
"curr_state",
"=",
"next_state",
")",
"{",
"next_state",
"=",
"curr_state",
"->",
"allocated_states_chain",
";"
]
|
GCC | h8300 | MD | stmt_completion | MPU | 8,536 | [
")"
]
| [
"(",
"eqne",
":",
"HI",
"(",
"and",
":",
"HI",
"(",
"match_operand",
":",
"HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"const_int",
"-",
"<NUM_LIT>",
")",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"reg",
":",
"CCZ",
"CC_REG",
")",
"(",
"compare",
"(",
"and",
":",
"HI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"const_int",
"-",
"<NUM_LIT>",
")",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
")",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>"
]
|
LLVM | AMDGPU | CPP | next_suggestion | GPU | 8,537 | [
"SDValue",
"Hi",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"EXTRACT_VECTOR_ELT",
",",
"SL",
",",
"MVT",
"::",
"i32",
",",
"Vec",
",",
"One",
")",
";"
]
| [
"const",
"SDValue",
"One",
"=",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"SL",
",",
"MVT",
"::",
"i32",
")",
";",
"SDValue",
"Lo",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"EXTRACT_VECTOR_ELT",
",",
"SL",
",",
"MVT",
"::",
"i32",
",",
"Vec",
",",
"Zero",
")",
";"
]
|
LLVM | TGSI | CPP | next_suggestion | Virtual ISA | 8,538 | [
"const",
"TGSIInstrInfo",
"&",
"tii",
"=",
"*",
"static_cast",
"<",
"const",
"TGSIInstrInfo",
"*",
">",
"(",
"mf",
".",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";"
]
| [
"MachineBasicBlock",
"::",
"iterator",
"mbbi",
"=",
"mbb",
".",
"getLastNonDebugInstr",
"(",
")",
";",
"MachineFrameInfo",
"&",
"mfi",
"=",
"mf",
".",
"getFrameInfo",
"(",
")",
";"
]
|
LLVM | Mips | TD | next_suggestion | CPU | 8,539 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"addr",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";"
]
| [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"addr",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"funct",
";"
]
|
LLVM | X86 | CPP | program_repair | CPU | 8,540 | [
"<FIXS>",
"const",
"MIMetadata",
"MIMD",
"(",
"MI",
")",
";",
"<FIXE>"
]
| [
"MachineBasicBlock",
"*",
"BB",
")",
"const",
"{",
"<BUGS>",
"const",
"DebugLoc",
"&",
"DL",
"=",
"MI",
".",
"getDebugLoc",
"(",
")",
";",
"<BUGE>",
"const",
"X86InstrInfo",
"*",
"TII",
"=",
"Subtarget",
".",
"getInstrInfo",
"(",
")",
";",
"Register",
"CalleeVReg",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
";",
"unsigned",
"Opc",
"=",
"getOpcodeForIndirectThunk",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
";"
]
|
GCC | aarch64 | MD | stmt_completion | CPU | 8,541 | [
")",
")"
]
| [
"(",
"and",
"(",
"match_code",
"<STR_LIT>",
")",
"(",
"match_test",
"<STR_LIT>",
")"
]
|
LLVM | AMDGPU | CPP | stmt_completion | GPU | 8,542 | [
"S_LOAD_DWORDX8_IMM",
":"
]
| [
"case",
"AMDGPU",
"::",
"FLAT_STORE_DWORD",
":",
"return",
"<NUM_LIT>",
";",
"case",
"AMDGPU",
"::",
"S_BUFFER_LOAD_DWORDX2_IMM",
":",
"case",
"AMDGPU",
"::",
"S_BUFFER_LOAD_DWORDX2_SGPR_IMM",
":",
"case",
"AMDGPU",
"::",
"S_LOAD_DWORDX2_IMM",
":",
"case",
"AMDGPU",
"::",
"S_LOAD_DWORDX2_IMM_ec",
":",
"case",
"AMDGPU",
"::",
"GLOBAL_LOAD_DWORDX2",
":",
"case",
"AMDGPU",
"::",
"GLOBAL_LOAD_DWORDX2_SADDR",
":",
"case",
"AMDGPU",
"::",
"GLOBAL_STORE_DWORDX2",
":",
"case",
"AMDGPU",
"::",
"GLOBAL_STORE_DWORDX2_SADDR",
":",
"case",
"AMDGPU",
"::",
"FLAT_LOAD_DWORDX2",
":",
"case",
"AMDGPU",
"::",
"FLAT_STORE_DWORDX2",
":",
"return",
"<NUM_LIT>",
";",
"case",
"AMDGPU",
"::",
"S_BUFFER_LOAD_DWORDX3_IMM",
":",
"case",
"AMDGPU",
"::",
"S_BUFFER_LOAD_DWORDX3_SGPR_IMM",
":",
"case",
"AMDGPU",
"::",
"S_LOAD_DWORDX3_IMM",
":",
"case",
"AMDGPU",
"::",
"S_LOAD_DWORDX3_IMM_ec",
":",
"case",
"AMDGPU",
"::",
"GLOBAL_LOAD_DWORDX3",
":",
"case",
"AMDGPU",
"::",
"GLOBAL_LOAD_DWORDX3_SADDR",
":",
"case",
"AMDGPU",
"::",
"GLOBAL_STORE_DWORDX3",
":",
"case",
"AMDGPU",
"::",
"GLOBAL_STORE_DWORDX3_SADDR",
":",
"case",
"AMDGPU",
"::",
"FLAT_LOAD_DWORDX3",
":",
"case",
"AMDGPU",
"::",
"FLAT_STORE_DWORDX3",
":",
"return",
"<NUM_LIT>",
";",
"case",
"AMDGPU",
"::",
"S_BUFFER_LOAD_DWORDX4_IMM",
":",
"case",
"AMDGPU",
"::",
"S_BUFFER_LOAD_DWORDX4_SGPR_IMM",
":",
"case",
"AMDGPU",
"::",
"S_LOAD_DWORDX4_IMM",
":",
"case",
"AMDGPU",
"::",
"S_LOAD_DWORDX4_IMM_ec",
":",
"case",
"AMDGPU",
"::",
"GLOBAL_LOAD_DWORDX4",
":",
"case",
"AMDGPU",
"::",
"GLOBAL_LOAD_DWORDX4_SADDR",
":",
"case",
"AMDGPU",
"::",
"GLOBAL_STORE_DWORDX4",
":",
"case",
"AMDGPU",
"::",
"GLOBAL_STORE_DWORDX4_SADDR",
":",
"case",
"AMDGPU",
"::",
"FLAT_LOAD_DWORDX4",
":",
"case",
"AMDGPU",
"::",
"FLAT_STORE_DWORDX4",
":",
"return",
"<NUM_LIT>",
";",
"case",
"AMDGPU",
"::",
"S_BUFFER_LOAD_DWORDX8_IMM",
":",
"case",
"AMDGPU",
"::",
"S_BUFFER_LOAD_DWORDX8_SGPR_IMM",
":",
"case",
"AMDGPU",
"::"
]
|
LLVM | SystemZ | CPP | code_generation | CPU | 8,543 | [
"const",
"char",
"*",
"SystemZTargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"Opcode",
")",
"{",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"break",
";",
"OPCODE",
"(",
"RET_FLAG",
")",
";",
"OPCODE",
"(",
"CALL",
")",
";",
"OPCODE",
"(",
"SIBCALL",
")",
";",
"OPCODE",
"(",
"TLS_GDCALL",
")",
";",
"OPCODE",
"(",
"TLS_LDCALL",
")",
";",
"OPCODE",
"(",
"PCREL_WRAPPER",
")",
";",
"OPCODE",
"(",
"PCREL_OFFSET",
")",
";",
"OPCODE",
"(",
"IABS",
")",
";",
"OPCODE",
"(",
"ICMP",
")",
";",
"OPCODE",
"(",
"FCMP",
")",
";",
"OPCODE",
"(",
"TM",
")",
";",
"OPCODE",
"(",
"BR_CCMASK",
")",
";",
"OPCODE",
"(",
"SELECT_CCMASK",
")",
";",
"OPCODE",
"(",
"ADJDYNALLOC",
")",
";",
"OPCODE",
"(",
"POPCNT",
")",
";",
"OPCODE",
"(",
"SMUL_LOHI",
")",
";",
"OPCODE",
"(",
"UMUL_LOHI",
")",
";",
"OPCODE",
"(",
"SDIVREM",
")",
";",
"OPCODE",
"(",
"UDIVREM",
")",
";",
"OPCODE",
"(",
"MVC",
")",
";",
"OPCODE",
"(",
"MVC_LOOP",
")",
";",
"OPCODE",
"(",
"NC",
")",
";",
"OPCODE",
"(",
"NC_LOOP",
")",
";",
"OPCODE",
"(",
"OC",
")",
";",
"OPCODE",
"(",
"OC_LOOP",
")",
";",
"OPCODE",
"(",
"XC",
")",
";",
"OPCODE",
"(",
"XC_LOOP",
")",
";",
"OPCODE",
"(",
"CLC",
")",
";",
"OPCODE",
"(",
"CLC_LOOP",
")",
";",
"OPCODE",
"(",
"STPCPY",
")",
";",
"OPCODE",
"(",
"STRCMP",
")",
";",
"OPCODE",
"(",
"SEARCH_STRING",
")",
";",
"OPCODE",
"(",
"IPM",
")",
";",
"OPCODE",
"(",
"MEMBARRIER",
")",
";",
"OPCODE",
"(",
"TBEGIN",
")",
";",
"OPCODE",
"(",
"TBEGIN_NOFLOAT",
")",
";",
"OPCODE",
"(",
"TEND",
")",
";",
"OPCODE",
"(",
"BYTE_MASK",
")",
";",
"OPCODE",
"(",
"ROTATE_MASK",
")",
";",
"OPCODE",
"(",
"REPLICATE",
")",
";",
"OPCODE",
"(",
"JOIN_DWORDS",
")",
";",
"OPCODE",
"(",
"SPLAT",
")",
";",
"OPCODE",
"(",
"MERGE_HIGH",
")",
";",
"OPCODE",
"(",
"MERGE_LOW",
")",
";",
"OPCODE",
"(",
"SHL_DOUBLE",
")",
";",
"OPCODE",
"(",
"PERMUTE_DWORDS",
")",
";",
"OPCODE",
"(",
"PERMUTE",
")",
";",
"OPCODE",
"(",
"PACK",
")",
";",
"OPCODE",
"(",
"PACKS_CC",
")",
";",
"OPCODE",
"(",
"PACKLS_CC",
")",
";",
"OPCODE",
"(",
"UNPACK_HIGH",
")",
";",
"OPCODE",
"(",
"UNPACKL_HIGH",
")",
";",
"OPCODE",
"(",
"UNPACK_LOW",
")",
";",
"OPCODE",
"(",
"UNPACKL_LOW",
")",
";",
"OPCODE",
"(",
"VSHL_BY_SCALAR",
")",
";",
"OPCODE",
"(",
"VSRL_BY_SCALAR",
")",
";",
"OPCODE",
"(",
"VSRA_BY_SCALAR",
")",
";",
"OPCODE",
"(",
"VSUM",
")",
";",
"OPCODE",
"(",
"VICMPE",
")",
";",
"OPCODE",
"(",
"VICMPH",
")",
";",
"OPCODE",
"(",
"VICMPHL",
")",
";",
"OPCODE",
"(",
"VICMPES",
")",
";",
"OPCODE",
"(",
"VICMPHS",
")",
";",
"OPCODE",
"(",
"VICMPHLS",
")",
";",
"OPCODE",
"(",
"VFCMPE",
")",
";",
"OPCODE",
"(",
"VFCMPH",
")",
";",
"OPCODE",
"(",
"VFCMPHE",
")",
";",
"OPCODE",
"(",
"VFCMPES",
")",
";",
"OPCODE",
"(",
"VFCMPHS",
")",
";",
"OPCODE",
"(",
"VFCMPHES",
")",
";",
"OPCODE",
"(",
"VFTCI",
")",
";",
"OPCODE",
"(",
"VEXTEND",
")",
";",
"OPCODE",
"(",
"VROUND",
")",
";",
"OPCODE",
"(",
"VTM",
")",
";",
"OPCODE",
"(",
"VFAE_CC",
")",
";",
"OPCODE",
"(",
"VFAEZ_CC",
")",
";",
"OPCODE",
"(",
"VFEE_CC",
")",
";",
"OPCODE",
"(",
"VFEEZ_CC",
")",
";",
"OPCODE",
"(",
"VFENE_CC",
")",
";",
"OPCODE",
"(",
"VFENEZ_CC",
")",
";",
"OPCODE",
"(",
"VISTR_CC",
")",
";",
"OPCODE",
"(",
"VSTRC_CC",
")",
";",
"OPCODE",
"(",
"VSTRCZ_CC",
")",
";",
"OPCODE",
"(",
"TDC",
")",
";",
"OPCODE",
"(",
"ATOMIC_SWAPW",
")",
";",
"OPCODE",
"(",
"ATOMIC_LOADW_ADD",
")",
";",
"OPCODE",
"(",
"ATOMIC_LOADW_SUB",
")",
";",
"OPCODE",
"(",
"ATOMIC_LOADW_AND",
")",
";",
"OPCODE",
"(",
"ATOMIC_LOADW_OR",
")",
";",
"OPCODE",
"(",
"ATOMIC_LOADW_XOR",
")",
";",
"OPCODE",
"(",
"ATOMIC_LOADW_NAND",
")",
";",
"OPCODE",
"(",
"ATOMIC_LOADW_MIN",
")",
";",
"OPCODE",
"(",
"ATOMIC_LOADW_MAX",
")",
";",
"OPCODE",
"(",
"ATOMIC_LOADW_UMIN",
")",
";",
"OPCODE",
"(",
"ATOMIC_LOADW_UMAX",
")",
";",
"OPCODE",
"(",
"ATOMIC_CMP_SWAPW",
")",
";",
"OPCODE",
"(",
"LRV",
")",
";",
"OPCODE",
"(",
"STRV",
")",
";",
"OPCODE",
"(",
"PREFETCH",
")",
";",
"}",
"return",
"nullptr",
";",
"}"
]
| [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
]
|
GCC | mips | MD | stmt_completion | CPU | 8,544 | [
"<NUM_LIT>",
")",
"]",
")",
")",
")"
]
| [
"(",
"plus",
":",
"V2DI",
"(",
"plus",
":",
"V2DI",
"(",
"mult",
":",
"V2DI",
"(",
"any_extend",
":",
"V2DI",
"(",
"vec_select",
":",
"V2SI",
"(",
"match_operand",
":",
"V4SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"parallel",
"[",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"]",
")",
")",
")",
"(",
"any_extend",
":",
"V2DI",
"(",
"vec_select",
":",
"V2SI",
"(",
"match_operand",
":",
"V4SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"parallel",
"[",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"]",
")",
")",
")",
")",
"(",
"mult",
":",
"V2DI",
"(",
"any_extend",
":",
"V2DI",
"(",
"vec_select",
":",
"V2SI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"parallel",
"[",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int"
]
|
GCC | arm | MD | stmt_completion | CPU | 8,545 | [
")",
")"
]
| [
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>"
]
|
LLVM | TPC | TD | next_suggestion | Virtual ISA | 8,546 | [
"let",
"VectorPred",
"=",
"!",
"eq",
"(",
"!",
"cast",
"<",
"string",
">",
"(",
"Pred",
")",
",",
"<STR_LIT>",
")",
";"
]
| [
"let",
"OutOperandList",
"=",
"(",
"outs",
"Rdst",
":",
"$",
"dest",
")",
";",
"let",
"InOperandList",
"=",
"(",
"ins",
"Rsrc",
":",
"$",
"src",
",",
"SwitchSet",
":",
"$",
"sw",
",",
"Rdst",
":",
"$",
"income",
",",
"Pred",
":",
"$",
"pred",
")",
";",
"let",
"Itinerary",
"=",
"IIC_LoadComplexOp",
";",
"let",
"isNotUsedInDisasm",
"=",
"!",
"if",
"(",
"!",
"eq",
"(",
"!",
"cast",
"<",
"string",
">",
"(",
"Rsrc",
")",
",",
"<STR_LIT>",
")",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"dest",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"src",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"sw",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"pred",
";",
"let",
"SrcA",
"=",
"src",
";",
"let",
"SrcExtra",
"=",
"{",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"dest",
"}",
";",
"let",
"Switches",
"=",
"{",
"sw",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
",",
"<NUM_LIT>",
"}",
";",
"let",
"PredAddress",
"=",
"pred",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";"
]
|
GCC | rs6000 | MD | next_suggestion | CPU | 8,547 | [
"<STR_LIT>",
")"
]
| [
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")"
]
|
GCC | rs6000 | CPP | code_generation | CPU | 8,548 | [
"static",
"enum",
"rs6000_reg_type",
"register_to_reg_type",
"(",
"rtx",
"reg",
",",
"bool",
"*",
"is_altivec",
")",
"{",
"HOST_WIDE_INT",
"regno",
";",
"enum",
"reg_class",
"rclass",
";",
"if",
"(",
"SUBREG_P",
"(",
"reg",
")",
")",
"reg",
"=",
"SUBREG_REG",
"(",
"reg",
")",
";",
"if",
"(",
"!",
"REG_P",
"(",
"reg",
")",
")",
"return",
"NO_REG_TYPE",
";",
"regno",
"=",
"REGNO",
"(",
"reg",
")",
";",
"if",
"(",
"!",
"HARD_REGISTER_NUM_P",
"(",
"regno",
")",
")",
"{",
"if",
"(",
"!",
"lra_in_progress",
"&&",
"!",
"reload_completed",
")",
"return",
"PSEUDO_REG_TYPE",
";",
"regno",
"=",
"true_regnum",
"(",
"reg",
")",
";",
"if",
"(",
"regno",
"<",
"<NUM_LIT>",
"||",
"!",
"HARD_REGISTER_NUM_P",
"(",
"regno",
")",
")",
"return",
"PSEUDO_REG_TYPE",
";",
"}",
"gcc_assert",
"(",
"regno",
">=",
"<NUM_LIT>",
")",
";",
"if",
"(",
"is_altivec",
"&&",
"ALTIVEC_REGNO_P",
"(",
"regno",
")",
")",
"*",
"is_altivec",
"=",
"true",
";",
"rclass",
"=",
"rs6000_regno_regclass",
"[",
"regno",
"]",
";",
"return",
"reg_class_to_reg_type",
"[",
"(",
"int",
")",
"rclass",
"]",
";",
"}"
]
| [
"Classify",
"a",
"register",
"type",
".",
"Because",
"the",
"FMRGOW/FMRGEW",
"instructions",
"only",
"work",
"on",
"traditional",
"floating",
"point",
"registers",
",",
"and",
"the",
"VMRGOW/VMRGEW",
"instructions",
"only",
"work",
"on",
"the",
"traditional",
"altivec",
"registers",
",",
"note",
"if",
"an",
"altivec",
"register",
"was",
"chosen",
"."
]
|
LLVM | M68k | CPP | next_suggestion | MPU | 8,549 | [
"if",
"(",
"!",
"MergeWithPrevious",
")",
"MBBI",
"=",
"NI",
";"
]
| [
"if",
"(",
"!",
"MergeWithPrevious",
"&&",
"NI",
"!=",
"MBB",
".",
"end",
"(",
")",
"&&",
"NI",
"->",
"getOpcode",
"(",
")",
"==",
"TargetOpcode",
"::",
"CFI_INSTRUCTION",
")",
"{",
"return",
"Offset",
";",
"}",
"if",
"(",
"Opc",
"==",
"M68k",
"::",
"ADD32ai",
"&&",
"PI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
"==",
"StackPtr",
")",
"{",
"assert",
"(",
"PI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
"==",
"StackPtr",
")",
";",
"Offset",
"+=",
"PI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getImm",
"(",
")",
";",
"MBB",
".",
"erase",
"(",
"PI",
")",
";",
"if",
"(",
"!",
"MergeWithPrevious",
")",
"MBBI",
"=",
"NI",
";",
"}",
"else",
"if",
"(",
"Opc",
"==",
"M68k",
"::",
"SUB32ai",
"&&",
"PI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
"==",
"StackPtr",
")",
"{",
"assert",
"(",
"PI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
"==",
"StackPtr",
")",
";",
"Offset",
"-=",
"PI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getImm",
"(",
")",
";",
"MBB",
".",
"erase",
"(",
"PI",
")",
";"
]
|
GCC | ia64 | MD | next_suggestion | CPU | 8,550 | [
"<STR_LIT>"
]
| [
"(",
"and",
":",
"DI",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<STR_LIT>"
]
|
LLVM | AAP | CPP | stmt_completion | MPU | 8,551 | [
"(",
")",
")",
";"
]
| [
"return",
"false",
";",
"}",
"if",
"(",
"Mem",
".",
"WithPreDec",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"!",
"Mem",
".",
"WithPostInc",
")",
"{",
"return",
"false",
";",
"}",
"return",
"isOff10",
"(",
"getMemSrcImm"
]
|
LLVM | Mips | CPP | stmt_completion | CPU | 8,552 | [
"fixup_Mips_32",
";"
]
| [
"break",
";",
"}",
"FixupKind",
"=",
"isMicroMips",
"(",
"STI",
")",
"?",
"Mips",
"::",
"fixup_MICROMIPS_HI16",
":",
"Mips",
"::",
"fixup_Mips_HI16",
";",
"break",
";",
"case",
"MipsMCExpr",
"::",
"MEK_PCREL_HI16",
":",
"FixupKind",
"=",
"Mips",
"::",
"fixup_MIPS_PCHI16",
";",
"break",
";",
"case",
"MipsMCExpr",
"::",
"MEK_PCREL_LO16",
":",
"FixupKind",
"=",
"Mips",
"::",
"fixup_MIPS_PCLO16",
";",
"break",
";",
"case",
"MipsMCExpr",
"::",
"MEK_TLSGD",
":",
"FixupKind",
"=",
"isMicroMips",
"(",
"STI",
")",
"?",
"Mips",
"::",
"fixup_MICROMIPS_TLS_GD",
":",
"Mips",
"::",
"fixup_Mips_TLSGD",
";",
"break",
";",
"case",
"MipsMCExpr",
"::",
"MEK_TLSLDM",
":",
"FixupKind",
"=",
"isMicroMips",
"(",
"STI",
")",
"?",
"Mips",
"::",
"fixup_MICROMIPS_TLS_LDM",
":",
"Mips",
"::",
"fixup_Mips_TLSLDM",
";",
"break",
";",
"case",
"MipsMCExpr",
"::",
"MEK_TPREL_HI",
":",
"FixupKind",
"=",
"isMicroMips",
"(",
"STI",
")",
"?",
"Mips",
"::",
"fixup_MICROMIPS_TLS_TPREL_HI16",
":",
"Mips",
"::",
"fixup_Mips_TPREL_HI",
";",
"break",
";",
"case",
"MipsMCExpr",
"::",
"MEK_TPREL_LO",
":",
"FixupKind",
"=",
"isMicroMips",
"(",
"STI",
")",
"?",
"Mips",
"::",
"fixup_MICROMIPS_TLS_TPREL_LO16",
":",
"Mips",
"::",
"fixup_Mips_TPREL_LO",
";",
"break",
";",
"case",
"MipsMCExpr",
"::",
"MEK_NEG",
":",
"FixupKind",
"=",
"isMicroMips",
"(",
"STI",
")",
"?",
"Mips",
"::",
"fixup_MICROMIPS_SUB",
":",
"Mips",
"::",
"fixup_Mips_SUB",
";",
"break",
";",
"}",
"Fixups",
".",
"push_back",
"(",
"MCFixup",
"::",
"create",
"(",
"<NUM_LIT>",
",",
"MipsExpr",
",",
"MCFixupKind",
"(",
"FixupKind",
")",
")",
")",
";",
"return",
"<NUM_LIT>",
";",
"}",
"if",
"(",
"Kind",
"==",
"MCExpr",
"::",
"SymbolRef",
")",
"{",
"Mips",
"::",
"Fixups",
"FixupKind",
"=",
"Mips",
"::",
"Fixups",
"(",
"<NUM_LIT>",
")",
";",
"switch",
"(",
"cast",
"<",
"MCSymbolRefExpr",
">",
"(",
"Expr",
")",
"->",
"getKind",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Unknown fixup kind!",
"<STR_LIT>",
")",
";",
"break",
";",
"case",
"MCSymbolRefExpr",
"::",
"VK_None",
":",
"FixupKind",
"=",
"Mips",
"::"
]
|
LLVM | WebAssembly | CPP | next_suggestion | Virtual ISA | 8,553 | [
"llvm_unreachable",
"(",
"<STR_LIT>",
"unexpected runtime library name",
"<STR_LIT>",
")",
";"
]
| [
"assert",
"(",
"strcmp",
"(",
"RuntimeLibcallNames",
"[",
"RTLIB",
"::",
"DEOPTIMIZE",
"]",
",",
"<STR_LIT>",
"__llvm_deoptimize",
"<STR_LIT>",
")",
"==",
"<NUM_LIT>",
")",
";",
"for",
"(",
"size_t",
"i",
"=",
"<NUM_LIT>",
",",
"e",
"=",
"RTLIB",
"::",
"UNKNOWN_LIBCALL",
";",
"i",
"<",
"e",
";",
"++",
"i",
")",
"if",
"(",
"RuntimeLibcallNames",
"[",
"i",
"]",
"&&",
"strcmp",
"(",
"RuntimeLibcallNames",
"[",
"i",
"]",
",",
"Name",
")",
"==",
"<NUM_LIT>",
")",
"return",
"GetSignature",
"(",
"Subtarget",
",",
"RTLIB",
"::",
"Libcall",
"(",
"i",
")",
",",
"Rets",
",",
"Params",
")",
";"
]
|
LLVM | ARM | CPP | program_repair | CPU | 8,554 | [
"<FIXS>",
"k_CondCode",
",",
"k_CCOut",
",",
"k_ITCondMask",
",",
"k_CoprocNum",
",",
"k_CoprocReg",
",",
"k_Immediate",
",",
"k_FPImmediate",
",",
"k_MemBarrierOpt",
",",
"k_Memory",
",",
"k_PostIndexRegister",
",",
"k_MSRMask",
",",
"k_ProcIFlags",
",",
"k_Register",
",",
"k_RegisterList",
",",
"k_DPRRegisterList",
",",
"k_SPRRegisterList",
",",
"k_ShiftedRegister",
",",
"k_ShiftedImmediate",
",",
"k_ShifterImmediate",
",",
"k_RotateImmediate",
",",
"k_BitfieldDescriptor",
",",
"k_Token",
"<FIXE>"
]
| [
"class",
"ARMOperand",
":",
"public",
"MCParsedAsmOperand",
"{",
"enum",
"KindTy",
"{",
"<BUGS>",
"CondCode",
",",
"CCOut",
",",
"ITCondMask",
",",
"CoprocNum",
",",
"CoprocReg",
",",
"Immediate",
",",
"FPImmediate",
",",
"MemBarrierOpt",
",",
"Memory",
",",
"PostIndexRegister",
",",
"MSRMask",
",",
"ProcIFlags",
",",
"Register",
",",
"RegisterList",
",",
"DPRRegisterList",
",",
"SPRRegisterList",
",",
"ShiftedRegister",
",",
"ShiftedImmediate",
",",
"ShifterImmediate",
",",
"RotateImmediate",
",",
"BitfieldDescriptor",
",",
"Token",
"<BUGE>",
"}",
"Kind",
";",
"SMLoc",
"StartLoc",
",",
"EndLoc",
";"
]
|
GCC | v850 | MD | stmt_completion | MPU | 8,555 | [
"CC_REGNUM",
")",
")",
"]"
]
| [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"rotate",
":",
"SI",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
")",
"(",
"clobber",
"(",
"reg",
":",
"CC"
]
|
GCC | arm | MD | next_suggestion | CPU | 8,556 | [
"<STR_LIT>"
]
| [
"(",
"unspec_volatile",
":",
"V4HI",
"[",
"(",
"match_operand",
":",
"V4HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"V4HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
"VUNSPEC_WCMP_GT",
")",
")",
"]",
"<STR_LIT>"
]
|
LLVM | SystemZ | CPP | stmt_completion | CPU | 8,557 | [
";"
]
| [
"bool",
"LSRWithInstrQueries",
"(",
")",
"{",
"return",
"true"
]
|
LLVM | AMDGPU | CPP | stmt_completion | GPU | 8,558 | [
";"
]
| [
"std",
"::",
"optional",
"<",
"int",
">",
"getOptionalScavengeFI",
"(",
")",
"const",
"{",
"return",
"ScavengeFI"
]
|
GCC | i386 | MD | next_suggestion | CPU | 8,559 | [
"<STR_LIT>"
]
| [
"(",
"parallel",
"[",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"]",
")",
")",
"(",
"match_operand",
":",
"QI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"const_vector",
":",
"V4HI",
"[",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"]",
")",
")",
")",
"]",
"<STR_LIT>"
]
|
LLVM | MSP430 | CPP | code_generation | MPU | 8,560 | [
"bool",
"MSP430AsmBackend",
"::",
"writeNopData",
"(",
"raw_ostream",
"&",
"OS",
",",
"uint64_t",
"Count",
")",
"const",
"{",
"if",
"(",
"(",
"Count",
"%",
"<NUM_LIT>",
")",
"!=",
"<NUM_LIT>",
")",
"return",
"false",
";",
"uint64_t",
"NopCount",
"=",
"Count",
"/",
"<NUM_LIT>",
";",
"while",
"(",
"NopCount",
"--",
")",
"OS",
".",
"write",
"(",
"<STR_LIT>",
"\\x03\\x43",
"<STR_LIT>",
",",
"<NUM_LIT>",
")",
";",
"return",
"true",
";",
"}"
]
| [
"Write",
"an",
"(",
"optimal",
")",
"nop",
"sequence",
"of",
"Count",
"bytes",
"to",
"the",
"given",
"output",
"."
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 8,561 | [
"let",
"addrMode",
"=",
"PostInc",
";"
]
| [
"def",
"L2_loadalignb_pci",
":",
"HInst",
"<",
"(",
"outs",
"DoubleRegs",
":",
"$",
"Ryy32",
",",
"IntRegs",
":",
"$",
"Rx32",
")",
",",
"(",
"ins",
"DoubleRegs",
":",
"$",
"Ryy32in",
",",
"IntRegs",
":",
"$",
"Rx32in",
",",
"s4_0Imm",
":",
"$",
"Ii",
",",
"ModRegs",
":",
"$",
"Mu2",
")",
",",
"<STR_LIT>",
",",
"tc_785f65a7",
",",
"TypeLD",
">",
",",
"Enc_74aef2",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
]
|
GCC | i386 | CPP | stmt_completion | CPU | 8,562 | [
"_",
"_",
"m128",
"_",
"_",
"A",
",",
"_",
"_",
"m128",
"_",
"_",
"B",
")",
"{"
]
| [
"static",
"_",
"_",
"inline",
"_",
"_",
"m128",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"always_inline__",
")",
")",
"_",
"mm_cmpnlt_ps",
"("
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 8,563 | [
"let",
"opExtentBits",
"=",
"<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>",
";",
"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 | bfin | CPP | next_suggestion | DSP | 8,564 | [
"return",
"<NUM_LIT>",
";"
]
| [
"return",
"profile_probability",
"::",
"from_reg_br_prob_note",
"(",
"XINT",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
">=",
"profile_probability",
"::",
"even",
"(",
")",
";",
"}"
]
|
GCC | arm | CPP | stmt_completion | CPU | 8,565 | [
"init_one_libfunc",
"(",
"<STR_LIT>",
"__tls_get_addr",
"<STR_LIT>",
")",
";"
]
| [
"static",
"rtx",
"get_tls_get_addr",
"(",
"void",
")",
"{",
"if",
"(",
"!",
"tls_get_addr_libfunc",
")",
"tls_get_addr_libfunc",
"="
]
|
LLVM | Z80 | CPP | next_suggestion | MPU | 8,566 | [
"MCOperand",
"MCOp",
";"
]
| [
"void",
"Z80MCInstLower",
"::",
"Lower",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"MCInst",
"&",
"OutMI",
")",
"const",
"{",
"OutMI",
".",
"setOpcode",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
";"
]
|
LLVM | X86 | CPP | next_suggestion | CPU | 8,567 | [
"BuildMI",
"(",
"*",
"FuncInfo",
".",
"MBB",
",",
"FuncInfo",
".",
"InsertPt",
",",
"DbgLoc",
",",
"TII",
".",
"get",
"(",
"TargetOpcode",
"::",
"COPY",
")",
",",
"CopyReg",
")",
".",
"addReg",
"(",
"InputReg",
")",
";"
]
| [
"unsigned",
"InputReg",
"=",
"getRegForValue",
"(",
"I",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"if",
"(",
"!",
"InputReg",
")",
"return",
"false",
";",
"if",
"(",
"SrcVT",
"==",
"MVT",
"::",
"i8",
")",
"{",
"updateValueMap",
"(",
"I",
",",
"InputReg",
")",
";",
"return",
"true",
";",
"}",
"bool",
"KillInputReg",
"=",
"false",
";",
"if",
"(",
"!",
"Subtarget",
"->",
"is64Bit",
"(",
")",
")",
"{",
"const",
"TargetRegisterClass",
"*",
"CopyRC",
"=",
"(",
"SrcVT",
"==",
"MVT",
"::",
"i16",
")",
"?",
"&",
"X86",
"::",
"GR16_ABCDRegClass",
":",
"&",
"X86",
"::",
"GR32_ABCDRegClass",
";",
"unsigned",
"CopyReg",
"=",
"createResultReg",
"(",
"CopyRC",
")",
";"
]
|
GCC | i386 | MD | stmt_completion | CPU | 8,568 | [
")"
]
| [
"(",
"define_reservation",
"<STR_LIT>",
"<STR_LIT>"
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 8,569 | [
"let",
"mayLoad",
"=",
"<NUM_LIT>",
";"
]
| [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"addrMode",
"=",
"PostInc",
";",
"let",
"accessSize",
"=",
"DoubleWordAccess",
";"
]
|
GCC | arm | MD | stmt_completion | CPU | 8,570 | [
"<STR_LIT>",
"<STR_LIT>",
")"
]
| [
"(",
"and",
"(",
"eq_attr"
]
|
LLVM | AMDGPU | CPP | stmt_completion | GPU | 8,571 | [
")",
"{"
]
| [
"bool",
"hasG16",
"(",
"const",
"MCSubtargetInfo",
"&",
"STI"
]
|
LLVM | Mips | CPP | code_generation | CPU | 8,572 | [
"bool",
"MipsCallLowering",
"::",
"lowerCall",
"(",
"MachineIRBuilder",
"&",
"MIRBuilder",
",",
"CallLoweringInfo",
"&",
"Info",
")",
"const",
"{",
"if",
"(",
"Info",
".",
"CallConv",
"!=",
"CallingConv",
"::",
"C",
")",
"return",
"false",
";",
"for",
"(",
"auto",
"&",
"Arg",
":",
"Info",
".",
"OrigArgs",
")",
"{",
"if",
"(",
"!",
"isSupportedArgumentType",
"(",
"Arg",
".",
"Ty",
")",
")",
"return",
"false",
";",
"if",
"(",
"Arg",
".",
"Flags",
"[",
"<NUM_LIT>",
"]",
".",
"isByVal",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"Arg",
".",
"Flags",
"[",
"<NUM_LIT>",
"]",
".",
"isSRet",
"(",
")",
"&&",
"!",
"Arg",
".",
"Ty",
"->",
"isPointerTy",
"(",
")",
")",
"return",
"false",
";",
"}",
"if",
"(",
"!",
"Info",
".",
"OrigRet",
".",
"Ty",
"->",
"isVoidTy",
"(",
")",
"&&",
"!",
"isSupportedReturnType",
"(",
"Info",
".",
"OrigRet",
".",
"Ty",
")",
")",
"return",
"false",
";",
"MachineFunction",
"&",
"MF",
"=",
"MIRBuilder",
".",
"getMF",
"(",
")",
";",
"const",
"Function",
"&",
"F",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"const",
"DataLayout",
"&",
"DL",
"=",
"MF",
".",
"getDataLayout",
"(",
")",
";",
"const",
"MipsTargetLowering",
"&",
"TLI",
"=",
"*",
"getTLI",
"<",
"MipsTargetLowering",
">",
"(",
")",
";",
"const",
"MipsTargetMachine",
"&",
"TM",
"=",
"static_cast",
"<",
"const",
"MipsTargetMachine",
"&",
">",
"(",
"MF",
".",
"getTarget",
"(",
")",
")",
";",
"const",
"MipsABIInfo",
"&",
"ABI",
"=",
"TM",
".",
"getABI",
"(",
")",
";",
"MachineInstrBuilder",
"CallSeqStart",
"=",
"MIRBuilder",
".",
"buildInstr",
"(",
"Mips",
"::",
"ADJCALLSTACKDOWN",
")",
";",
"const",
"bool",
"IsCalleeGlobalPIC",
"=",
"Info",
".",
"Callee",
".",
"isGlobal",
"(",
")",
"&&",
"TM",
".",
"isPositionIndependent",
"(",
")",
";",
"MachineInstrBuilder",
"MIB",
"=",
"MIRBuilder",
".",
"buildInstrNoInsert",
"(",
"Info",
".",
"Callee",
".",
"isReg",
"(",
")",
"||",
"IsCalleeGlobalPIC",
"?",
"Mips",
"::",
"JALRPseudo",
":",
"Mips",
"::",
"JAL",
")",
";",
"MIB",
".",
"addDef",
"(",
"Mips",
"::",
"SP",
",",
"RegState",
"::",
"Implicit",
")",
";",
"if",
"(",
"IsCalleeGlobalPIC",
")",
"{",
"Register",
"CalleeReg",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"createGenericVirtualRegister",
"(",
"LLT",
"::",
"pointer",
"(",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
")",
";",
"MachineInstr",
"*",
"CalleeGlobalValue",
"=",
"MIRBuilder",
".",
"buildGlobalValue",
"(",
"CalleeReg",
",",
"Info",
".",
"Callee",
".",
"getGlobal",
"(",
")",
")",
";",
"if",
"(",
"!",
"Info",
".",
"Callee",
".",
"getGlobal",
"(",
")",
"->",
"hasLocalLinkage",
"(",
")",
")",
"CalleeGlobalValue",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"setTargetFlags",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"MIB",
".",
"addUse",
"(",
"CalleeReg",
")",
";",
"}",
"else",
"MIB",
".",
"add",
"(",
"Info",
".",
"Callee",
")",
";",
"const",
"TargetRegisterInfo",
"*",
"TRI",
"=",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"MIB",
".",
"addRegMask",
"(",
"TRI",
"->",
"getCallPreservedMask",
"(",
"MF",
",",
"F",
".",
"getCallingConv",
"(",
")",
")",
")",
";",
"TargetLowering",
"::",
"ArgListTy",
"FuncOrigArgs",
";",
"FuncOrigArgs",
".",
"reserve",
"(",
"Info",
".",
"OrigArgs",
".",
"size",
"(",
")",
")",
";",
"SmallVector",
"<",
"ArgInfo",
",",
"<NUM_LIT>",
">",
"ArgInfos",
";",
"SmallVector",
"<",
"unsigned",
",",
"<NUM_LIT>",
">",
"OrigArgIndices",
";",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"for",
"(",
"auto",
"&",
"Arg",
":",
"Info",
".",
"OrigArgs",
")",
"{",
"TargetLowering",
"::",
"ArgListEntry",
"Entry",
";",
"Entry",
".",
"Ty",
"=",
"Arg",
".",
"Ty",
";",
"FuncOrigArgs",
".",
"push_back",
"(",
"Entry",
")",
";",
"ArgInfos",
".",
"push_back",
"(",
"Arg",
")",
";",
"OrigArgIndices",
".",
"push_back",
"(",
"i",
")",
";",
"++",
"i",
";",
"}",
"SmallVector",
"<",
"ISD",
"::",
"OutputArg",
",",
"<NUM_LIT>",
">",
"Outs",
";",
"subTargetRegTypeForCallingConv",
"(",
"F",
",",
"ArgInfos",
",",
"OrigArgIndices",
",",
"Outs",
")",
";",
"SmallVector",
"<",
"CCValAssign",
",",
"<NUM_LIT>",
">",
"ArgLocs",
";",
"bool",
"IsCalleeVarArg",
"=",
"false",
";",
"if",
"(",
"Info",
".",
"Callee",
".",
"isGlobal",
"(",
")",
")",
"{",
"const",
"Function",
"*",
"CF",
"=",
"static_cast",
"<",
"const",
"Function",
"*",
">",
"(",
"Info",
".",
"Callee",
".",
"getGlobal",
"(",
")",
")",
";",
"IsCalleeVarArg",
"=",
"CF",
"->",
"isVarArg",
"(",
")",
";",
"}",
"MipsCCState",
"CCInfo",
"(",
"F",
".",
"getCallingConv",
"(",
")",
",",
"IsCalleeVarArg",
",",
"MF",
",",
"ArgLocs",
",",
"F",
".",
"getContext",
"(",
")",
")",
";",
"CCInfo",
".",
"AllocateStack",
"(",
"ABI",
".",
"GetCalleeAllocdArgSizeInBytes",
"(",
"Info",
".",
"CallConv",
")",
",",
"Align",
"(",
"<NUM_LIT>",
")",
")",
";",
"const",
"char",
"*",
"Call",
"=",
"Info",
".",
"Callee",
".",
"isSymbol",
"(",
")",
"?",
"Info",
".",
"Callee",
".",
"getSymbolName",
"(",
")",
":",
"nullptr",
";",
"CCInfo",
".",
"AnalyzeCallOperands",
"(",
"Outs",
",",
"TLI",
".",
"CCAssignFnForCall",
"(",
")",
",",
"FuncOrigArgs",
",",
"Call",
")",
";",
"setLocInfo",
"(",
"ArgLocs",
",",
"Outs",
")",
";",
"OutgoingValueHandler",
"RetHandler",
"(",
"MIRBuilder",
",",
"MF",
".",
"getRegInfo",
"(",
")",
",",
"MIB",
")",
";",
"if",
"(",
"!",
"RetHandler",
".",
"handle",
"(",
"ArgLocs",
",",
"ArgInfos",
")",
")",
"{",
"return",
"false",
";",
"}",
"unsigned",
"NextStackOffset",
"=",
"CCInfo",
".",
"getNextStackOffset",
"(",
")",
";",
"const",
"TargetFrameLowering",
"*",
"TFL",
"=",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getFrameLowering",
"(",
")",
";",
"unsigned",
"StackAlignment",
"=",
"TFL",
"->",
"getStackAlignment",
"(",
")",
";",
"NextStackOffset",
"=",
"alignTo",
"(",
"NextStackOffset",
",",
"StackAlignment",
")",
";",
"CallSeqStart",
".",
"addImm",
"(",
"NextStackOffset",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"IsCalleeGlobalPIC",
")",
"{",
"MIRBuilder",
".",
"buildCopy",
"(",
"Register",
"(",
"Mips",
"::",
"GP",
")",
",",
"MF",
".",
"getInfo",
"<",
"MipsFunctionInfo",
">",
"(",
")",
"->",
"getGlobalBaseRegForGlobalISel",
"(",
")",
")",
";",
"MIB",
".",
"addDef",
"(",
"Mips",
"::",
"GP",
",",
"RegState",
"::",
"Implicit",
")",
";",
"}",
"MIRBuilder",
".",
"insertInstr",
"(",
"MIB",
")",
";",
"if",
"(",
"MIB",
"->",
"getOpcode",
"(",
")",
"==",
"Mips",
"::",
"JALRPseudo",
")",
"{",
"const",
"MipsSubtarget",
"&",
"STI",
"=",
"static_cast",
"<",
"const",
"MipsSubtarget",
"&",
">",
"(",
"MIRBuilder",
".",
"getMF",
"(",
")",
".",
"getSubtarget",
"(",
")",
")",
";",
"MIB",
".",
"constrainAllUses",
"(",
"MIRBuilder",
".",
"getTII",
"(",
")",
",",
"*",
"STI",
".",
"getRegisterInfo",
"(",
")",
",",
"*",
"STI",
".",
"getRegBankInfo",
"(",
")",
")",
";",
"}",
"if",
"(",
"!",
"Info",
".",
"OrigRet",
".",
"Ty",
"->",
"isVoidTy",
"(",
")",
")",
"{",
"ArgInfos",
".",
"clear",
"(",
")",
";",
"SmallVector",
"<",
"unsigned",
",",
"<NUM_LIT>",
">",
"OrigRetIndices",
";",
"splitToValueTypes",
"(",
"DL",
",",
"Info",
".",
"OrigRet",
",",
"<NUM_LIT>",
",",
"ArgInfos",
",",
"OrigRetIndices",
")",
";",
"SmallVector",
"<",
"ISD",
"::",
"InputArg",
",",
"<NUM_LIT>",
">",
"Ins",
";",
"subTargetRegTypeForCallingConv",
"(",
"F",
",",
"ArgInfos",
",",
"OrigRetIndices",
",",
"Ins",
")",
";",
"SmallVector",
"<",
"CCValAssign",
",",
"<NUM_LIT>",
">",
"ArgLocs",
";",
"MipsCCState",
"CCInfo",
"(",
"F",
".",
"getCallingConv",
"(",
")",
",",
"F",
".",
"isVarArg",
"(",
")",
",",
"MF",
",",
"ArgLocs",
",",
"F",
".",
"getContext",
"(",
")",
")",
";",
"CCInfo",
".",
"AnalyzeCallResult",
"(",
"Ins",
",",
"TLI",
".",
"CCAssignFnForReturn",
"(",
")",
",",
"Info",
".",
"OrigRet",
".",
"Ty",
",",
"Call",
")",
";",
"setLocInfo",
"(",
"ArgLocs",
",",
"Ins",
")",
";",
"CallReturnHandler",
"Handler",
"(",
"MIRBuilder",
",",
"MF",
".",
"getRegInfo",
"(",
")",
",",
"MIB",
")",
";",
"if",
"(",
"!",
"Handler",
".",
"handle",
"(",
"ArgLocs",
",",
"ArgInfos",
")",
")",
"return",
"false",
";",
"}",
"MIRBuilder",
".",
"buildInstr",
"(",
"Mips",
"::",
"ADJCALLSTACKUP",
")",
".",
"addImm",
"(",
"NextStackOffset",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
")",
";",
"return",
"true",
";",
"}"
]
| [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"the",
"given",
"call",
"instruction",
",",
"including",
"argument",
"and",
"return",
"value",
"marshalling",
"."
]
|
GCC | alpha | MD | next_suggestion | MPU | 8,573 | [
"<STR_LIT>"
]
| [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"zero_extract",
":",
"DI",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]"
]
|
GCC | i386 | CPP | stmt_completion | CPU | 8,574 | [
"_",
"D",
",",
"(",
"_",
"_",
"mmask8",
")",
"_",
"_",
"B",
")",
";"
]
| [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m128i",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm_mask_shrdv_epi64",
"(",
"_",
"_",
"m128i",
"_",
"_",
"A",
",",
"_",
"_",
"mmask8",
"_",
"_",
"B",
",",
"_",
"_",
"m128i",
"_",
"_",
"C",
",",
"_",
"_",
"m128i",
"_",
"_",
"D",
")",
"{",
"return",
"(",
"_",
"_",
"m128i",
")",
"_",
"_",
"builtin_ia32_vpshrdv_v2di_mask",
"(",
"(",
"_",
"_",
"v2di",
")",
"_",
"_",
"A",
",",
"(",
"_",
"_",
"v2di",
")",
"_",
"_",
"C",
",",
"(",
"_",
"_",
"v2di",
")",
"_"
]
|
LLVM | AArch64 | CPP | next_suggestion | CPU | 8,575 | [
"return",
"makeLibCall",
"(",
"DAG",
",",
"LC",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"&",
"SrcVal",
",",
"<NUM_LIT>",
",",
"false",
",",
"SDLoc",
"(",
"Op",
")",
")",
";"
]
| [
"}",
"RTLIB",
"::",
"Libcall",
"LC",
";",
"LC",
"=",
"RTLIB",
"::",
"getFPROUND",
"(",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getValueType",
"(",
")",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
";",
"SDValue",
"SrcVal",
"=",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";"
]
|
LLVM | ARM | CPP | stmt_completion | CPU | 8,576 | [
"ATOMIC_LOAD_UMAX",
":"
]
| [
"case",
"ISD",
"::",
"READCYCLECOUNTER",
":",
"ReplaceREADCYCLECOUNTER",
"(",
"N",
",",
"Results",
",",
"DAG",
",",
"Subtarget",
")",
";",
"return",
";",
"case",
"ISD",
"::",
"ATOMIC_STORE",
":",
"case",
"ISD",
"::",
"ATOMIC_LOAD",
":",
"case",
"ISD",
"::",
"ATOMIC_LOAD_ADD",
":",
"case",
"ISD",
"::",
"ATOMIC_LOAD_AND",
":",
"case",
"ISD",
"::",
"ATOMIC_LOAD_NAND",
":",
"case",
"ISD",
"::",
"ATOMIC_LOAD_OR",
":",
"case",
"ISD",
"::",
"ATOMIC_LOAD_SUB",
":",
"case",
"ISD",
"::",
"ATOMIC_LOAD_XOR",
":",
"case",
"ISD",
"::",
"ATOMIC_SWAP",
":",
"case",
"ISD",
"::",
"ATOMIC_CMP_SWAP",
":",
"case",
"ISD",
"::",
"ATOMIC_LOAD_MIN",
":",
"case",
"ISD",
"::",
"ATOMIC_LOAD_UMIN",
":",
"case",
"ISD",
"::",
"ATOMIC_LOAD_MAX",
":",
"case",
"ISD",
"::"
]
|
LLVM | Blackfin | CPP | next_suggestion | DSP | 8,577 | [
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
",",
"getSubReg",
"(",
"Reg",
",",
"bfin_subreg_hi16",
")",
")",
".",
"addImm",
"(",
"(",
"value",
">>",
"<NUM_LIT>",
")",
"&",
"<NUM_LIT>",
")",
".",
"addReg",
"(",
"Reg",
",",
"RegState",
"::",
"ImplicitDefine",
")",
";"
]
| [
"if",
"(",
"isInt",
"<",
"<NUM_LIT>",
">",
"(",
"value",
")",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
",",
"Reg",
")",
".",
"addImm",
"(",
"value",
")",
";",
"return",
";",
"}"
]
|
LLVM | X86 | CPP | stmt_completion | CPU | 8,578 | [
")",
";"
]
| [
"bool",
"hasInt256",
"(",
")",
"const",
"{",
"return",
"hasAVX2",
"("
]
|
GCC | arm | MD | next_suggestion | CPU | 8,579 | [
"}",
")"
]
| [
"gen_mve_vldrwq_gather_base_wb_",
"<",
"supf",
">",
"v4si_insn",
"(",
"ignore_result",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
")",
"DONE"
]
|
GCC | ia64 | CPP | code_generation | CPU | 8,580 | [
"static",
"void",
"ia64_asm_emit_except_personality",
"(",
"rtx",
"personality",
")",
"{",
"fputs",
"(",
"<STR_LIT>",
"\\t.personality\\t",
"<STR_LIT>",
",",
"asm_out_file",
")",
";",
"output_addr_const",
"(",
"asm_out_file",
",",
"personality",
")",
";",
"fputc",
"(",
"'",
"\\n",
"'",
",",
"asm_out_file",
")",
";",
"}"
]
| [
"Implement",
"TARGET_ASM_EMIT_EXCEPT_PERSONALITY",
"."
]
|
GCC | bpf | CPP | code_generation | Virtual ISA | 8,581 | [
"static",
"rtx",
"bpf_function_value",
"(",
"const_tree",
"ret_type",
",",
"const_tree",
"fntype_or_decl",
",",
"bool",
"outgoing",
"ATTRIBUTE_UNUSED",
")",
"{",
"enum",
"machine_mode",
"mode",
";",
"int",
"unsignedp",
";",
"mode",
"=",
"TYPE_MODE",
"(",
"ret_type",
")",
";",
"if",
"(",
"INTEGRAL_TYPE_P",
"(",
"ret_type",
")",
")",
"mode",
"=",
"promote_function_mode",
"(",
"ret_type",
",",
"mode",
",",
"&",
"unsignedp",
",",
"fntype_or_decl",
",",
"<NUM_LIT>",
")",
";",
"return",
"gen_rtx_REG",
"(",
"mode",
",",
"BPF_R0",
")",
";",
"}"
]
| [
"Return",
"an",
"RTX",
"representing",
"the",
"place",
"where",
"a",
"function",
"returns",
"or",
"receives",
"a",
"value",
"of",
"data",
"type",
"RET_TYPE",
",",
"a",
"tree",
"node",
"representing",
"a",
"data",
"type",
"."
]
|
GCC | pa | MD | stmt_completion | CPU | 8,582 | [
")"
]
| [
"(",
"define_predicate",
"<STR_LIT>",
"(",
"match_code",
"<STR_LIT>",
")"
]
|
GCC | avr | MD | next_suggestion | MPU | 8,583 | [
"{"
]
| [
"[",
"(",
"parallel",
"[",
"(",
"match_operand",
":",
"ALL124U",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"ALL124U",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"]",
"<STR_LIT>"
]
|
LLVM | ARM | TD | next_suggestion | CPU | 8,584 | [
"let",
"RenderMethod",
"=",
"<STR_LIT>",
";"
]
| [
"let",
"Name",
"=",
"<STR_LIT>",
"#",
"shift",
"#",
"<STR_LIT>",
";",
"let",
"PredicateMethod",
"=",
"<STR_LIT>",
"#",
"shift",
"#",
"<STR_LIT>",
";"
]
|
LLVM | AMDGPU | CPP | next_suggestion | GPU | 8,585 | [
"Value",
"*",
"MaskOp",
"=",
"II",
"->",
"getArgOperand",
"(",
"<NUM_LIT>",
")",
";"
]
| [
"case",
"Intrinsic",
"::",
"amdgcn_ds_fmax",
":",
"{",
"const",
"ConstantInt",
"*",
"IsVolatile",
"=",
"cast",
"<",
"ConstantInt",
">",
"(",
"II",
"->",
"getArgOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"if",
"(",
"!",
"IsVolatile",
"->",
"isZero",
"(",
")",
")",
"return",
"nullptr",
";",
"Module",
"*",
"M",
"=",
"II",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"Type",
"*",
"DestTy",
"=",
"II",
"->",
"getType",
"(",
")",
";",
"Type",
"*",
"SrcTy",
"=",
"NewV",
"->",
"getType",
"(",
")",
";",
"Function",
"*",
"NewDecl",
"=",
"Intrinsic",
"::",
"getDeclaration",
"(",
"M",
",",
"II",
"->",
"getIntrinsicID",
"(",
")",
",",
"{",
"DestTy",
",",
"SrcTy",
"}",
")",
";",
"II",
"->",
"setArgOperand",
"(",
"<NUM_LIT>",
",",
"NewV",
")",
";",
"II",
"->",
"setCalledFunction",
"(",
"NewDecl",
")",
";",
"return",
"II",
";",
"}",
"case",
"Intrinsic",
"::",
"amdgcn_is_shared",
":",
"case",
"Intrinsic",
"::",
"amdgcn_is_private",
":",
"{",
"unsigned",
"TrueAS",
"=",
"IntrID",
"==",
"Intrinsic",
"::",
"amdgcn_is_shared",
"?",
"AMDGPUAS",
"::",
"LOCAL_ADDRESS",
":",
"AMDGPUAS",
"::",
"PRIVATE_ADDRESS",
";",
"unsigned",
"NewAS",
"=",
"NewV",
"->",
"getType",
"(",
")",
"->",
"getPointerAddressSpace",
"(",
")",
";",
"LLVMContext",
"&",
"Ctx",
"=",
"NewV",
"->",
"getType",
"(",
")",
"->",
"getContext",
"(",
")",
";",
"ConstantInt",
"*",
"NewVal",
"=",
"(",
"TrueAS",
"==",
"NewAS",
")",
"?",
"ConstantInt",
"::",
"getTrue",
"(",
"Ctx",
")",
":",
"ConstantInt",
"::",
"getFalse",
"(",
"Ctx",
")",
";",
"return",
"NewVal",
";",
"}",
"case",
"Intrinsic",
"::",
"ptrmask",
":",
"{",
"unsigned",
"OldAS",
"=",
"OldV",
"->",
"getType",
"(",
")",
"->",
"getPointerAddressSpace",
"(",
")",
";",
"unsigned",
"NewAS",
"=",
"NewV",
"->",
"getType",
"(",
")",
"->",
"getPointerAddressSpace",
"(",
")",
";"
]
|
LLVM | M68k | TD | next_suggestion | MPU | 8,586 | [
"let",
"Inst",
"=",
"(",
"ascend",
"(",
"descend",
"<NUM_LIT>",
",",
"!",
"cast",
"<",
"MxNewEncSize",
">",
"(",
"<STR_LIT>",
"#",
"TYPE",
".",
"Size",
")",
".",
"Value",
",",
"AbsEncoding",
".",
"EA",
")",
",",
"MxEncAddrMode_i",
"<",
"<STR_LIT>",
",",
"TYPE",
".",
"Size",
">",
".",
"Supplement",
",",
"AbsEncoding",
".",
"Supplement",
")",
";"
]
| [
"class",
"MxCmp_BI",
"<",
"MxType",
"TYPE",
">",
":",
"MxInst",
"<",
"(",
"outs",
")",
",",
"(",
"ins",
"TYPE",
".",
"IOp",
":",
"$",
"imm",
",",
"MxAL32",
":",
"$",
"abs",
")",
",",
"<STR_LIT>",
"#",
"TYPE",
".",
"Prefix",
"#",
"<STR_LIT>",
",",
"[",
"(",
"set",
"CCR",
",",
"(",
"MxCmp",
"TYPE",
".",
"IPat",
":",
"$",
"imm",
",",
"(",
"load",
"(",
"i32",
"(",
"MxWrapper",
"tglobaladdr",
":",
"$",
"abs",
")",
")",
")",
")",
")",
"]",
">",
"{",
"defvar",
"AbsEncoding",
"=",
"MxEncAddrMode_abs",
"<",
"<STR_LIT>",
",",
"true",
">",
";"
]
|
GCC | aarch64 | MD | program_repair | CPU | 8,587 | [
"<FIXS>",
"(",
"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>",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")"
]
|
LLVM | ARM | TD | stmt_completion | CPU | 8,588 | [
"amt1",
",",
"timm",
":",
"$",
"amt2",
")",
"]",
">",
";"
]
| [
"def",
"ADJCALLSTACKUP",
":",
"PseudoInst",
"<",
"(",
"outs",
")",
",",
"(",
"ins",
"i32imm",
":",
"$",
"amt1",
",",
"i32imm",
":",
"$",
"amt2",
",",
"pred",
":",
"$",
"p",
")",
",",
"NoItinerary",
",",
"[",
"(",
"ARMcallseq_end",
"timm",
":",
"$"
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 8,589 | [
"let",
"isBranch",
"=",
"<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",
"isPredicated",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicatedFalse",
"=",
"<NUM_LIT>",
";",
"let",
"isTerminator",
"=",
"<NUM_LIT>",
";"
]
|
LLVM | AMDGPU | TD | stmt_completion | GPU | 8,590 | [
"outs",
")",
",",
"ins",
",",
"<STR_LIT>",
"#",
"name",
",",
"pattern",
">",
";"
]
| [
"class",
"CF_MEM_RAT_CACHELESS",
"<",
"bits",
"<",
"<NUM_LIT>",
">",
"rat_inst",
",",
"bits",
"<",
"<NUM_LIT>",
">",
"rat_id",
",",
"bits",
"<",
"<NUM_LIT>",
">",
"mask",
",",
"dag",
"ins",
",",
"string",
"name",
",",
"list",
"<",
"dag",
">",
"pattern",
">",
":",
"EG_CF_RAT",
"<",
"<NUM_LIT>",
",",
"rat_inst",
",",
"rat_id",
",",
"mask",
",",
"("
]
|
GCC | powerpcspe | CPP | stmt_completion | CPU | 8,591 | [
";"
]
| [
"extern",
"_",
"_",
"inline",
"long",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"_",
"TM_end",
"(",
"void",
")",
"{",
"unsigned",
"char",
"status",
"=",
"_",
"HTM_STATE",
"(",
"_",
"_",
"builtin_tend",
"(",
"<NUM_LIT>",
")",
")",
";",
"if",
"(",
"_",
"_",
"builtin_expect",
"(",
"status",
",",
"_",
"HTM_TRANSACTIONAL",
")",
")",
"return",
"<NUM_LIT>",
";",
"return",
"<NUM_LIT>"
]
|
LLVM | PowerPC | CPP | next_suggestion | CPU | 8,592 | [
"}"
]
| [
"static",
"DecodeStatus",
"DecodeGPRCRegisterClass",
"(",
"MCInst",
"&",
"Inst",
",",
"uint64_t",
"RegNo",
",",
"uint64_t",
"Address",
",",
"const",
"void",
"*",
"Decoder",
")",
"{",
"return",
"decodeRegisterClass",
"(",
"Inst",
",",
"RegNo",
",",
"RRegs",
")",
";"
]
|
LLVM | AArch64 | CPP | next_suggestion | CPU | 8,593 | [
"assert",
"(",
"(",
"ThisVal",
">>",
"ShiftSize",
")",
"<=",
"MaxEncoding",
"&&",
"<STR_LIT>",
"Encoding cannot handle value that big",
"<STR_LIT>",
")",
";"
]
| [
"unsigned",
"MaxEncoding",
",",
"ShiftSize",
";",
"switch",
"(",
"Opc",
")",
"{",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"MaxEncoding",
"=",
"<NUM_LIT>",
";",
"ShiftSize",
"=",
"<NUM_LIT>",
";",
"break",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"MaxEncoding",
"=",
"<NUM_LIT>",
";",
"ShiftSize",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"Offset",
"<",
"<NUM_LIT>",
")",
"{",
"MaxEncoding",
"=",
"<NUM_LIT>",
";",
"Sign",
"=",
"-",
"<NUM_LIT>",
";",
"Offset",
"=",
"-",
"Offset",
";",
"}",
"break",
";",
"default",
":",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Unsupported opcode",
"<STR_LIT>",
")",
";",
"}",
"const",
"unsigned",
"MaxEncodableValue",
"=",
"MaxEncoding",
"<<",
"ShiftSize",
";",
"do",
"{",
"uint64_t",
"ThisVal",
"=",
"std",
"::",
"min",
"<",
"uint64_t",
">",
"(",
"Offset",
",",
"MaxEncodableValue",
")",
";",
"unsigned",
"LocalShiftSize",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"ThisVal",
">",
"MaxEncoding",
")",
"{",
"ThisVal",
"=",
"ThisVal",
">>",
"ShiftSize",
";",
"LocalShiftSize",
"=",
"ShiftSize",
";",
"}"
]
|
GCC | nios2 | MD | stmt_completion | MPU | 8,594 | [
")",
")",
")",
")"
]
| [
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"mem",
":",
"SI",
"(",
"plus",
":",
"SI",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"const_int",
"-",
"<NUM_LIT>",
")",
")",
")",
")",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"mem",
":",
"SI",
"(",
"plus",
":",
"SI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"const_int",
"-",
"<NUM_LIT>",
")",
")",
")",
")",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"mem",
":",
"SI",
"(",
"plus",
":",
"SI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"const_int",
"-",
"<NUM_LIT>",
")",
")",
")",
")",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"mem",
":",
"SI",
"(",
"plus",
":",
"SI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"const_int",
"-",
"<NUM_LIT>",
")",
")",
")",
")",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"mem",
":",
"SI",
"(",
"plus",
":",
"SI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"const_int",
"-",
"<NUM_LIT>"
]
|
LLVM | X86 | CPP | next_suggestion | CPU | 8,595 | [
"return",
"splitAndLowerVectorShuffle",
"(",
"DL",
",",
"MVT",
"::",
"v64i8",
",",
"V1",
",",
"V2",
",",
"Mask",
",",
"DAG",
")",
";"
]
| [
"assert",
"(",
"Mask",
".",
"size",
"(",
")",
"==",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Unexpected mask size for v64 shuffle!",
"<STR_LIT>",
")",
";",
"assert",
"(",
"Subtarget",
".",
"hasBWI",
"(",
")",
"&&",
"<STR_LIT>",
"We can only lower v64i8 with AVX-512-BWI!",
"<STR_LIT>",
")",
";"
]
|
LLVM | MSP430 | CPP | next_suggestion | MPU | 8,596 | [
"MFI",
"->",
"setCalleeSavedFrameSize",
"(",
"CSI",
".",
"size",
"(",
")",
"*",
"<NUM_LIT>",
")",
";"
]
| [
"bool",
"MSP430InstrInfo",
"::",
"spillCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"const",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"if",
"(",
"CSI",
".",
"empty",
"(",
")",
")",
"return",
"false",
";",
"DebugLoc",
"DL",
";",
"if",
"(",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MSP430MachineFunctionInfo",
"*",
"MFI",
"=",
"MF",
".",
"getInfo",
"<",
"MSP430MachineFunctionInfo",
">",
"(",
")",
";"
]
|
LLVM | SystemZ | CPP | next_suggestion | CPU | 8,597 | [
"}"
]
| [
"int",
"NumSrcParts",
"=",
"(",
"(",
"NumWideParts",
">",
"NumElsPerVector",
")",
"?",
"NumElsPerVector",
":",
"NumWideParts",
")",
";",
"unsigned",
"NumOperands",
"=",
"(",
"(",
"Opcode",
"==",
"Instruction",
"::",
"Load",
")",
"?",
"Indices",
".",
"size",
"(",
")",
":",
"Factor",
")",
";",
"if",
"(",
"NumSrcParts",
">",
"<NUM_LIT>",
")",
"NumSrcParts",
"--",
";",
"int",
"NumPermutes",
"=",
"NumSrcParts",
"*",
"NumOperands",
";",
"return",
"NumWideParts",
"+",
"NumPermutes",
";"
]
|
LLVM | WebAssembly | CPP | next_suggestion | Virtual ISA | 8,598 | [
"}"
]
| [
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"********** Replace Physical Registers **********\\n",
"<STR_LIT>",
"<<",
"<STR_LIT>",
"********** Function: ",
"<STR_LIT>",
"<<",
"MF",
".",
"getName",
"(",
")",
"<<",
"'",
"\\n",
"'",
";",
"}",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"const",
"auto",
"&",
"TRI",
"=",
"*",
"MF",
".",
"getSubtarget",
"<",
"WebAssemblySubtarget",
">",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"assert",
"(",
"!",
"mustPreserveAnalysisID",
"(",
"LiveIntervalsID",
")",
"&&",
"<STR_LIT>",
"LiveIntervals shouldn't be active yet!",
"<STR_LIT>",
")",
";",
"MRI",
".",
"leaveSSA",
"(",
")",
";",
"MRI",
".",
"invalidateLiveness",
"(",
")",
";",
"for",
"(",
"unsigned",
"PReg",
"=",
"WebAssembly",
"::",
"NoRegister",
"+",
"<NUM_LIT>",
";",
"PReg",
"<",
"WebAssembly",
"::",
"NUM_TARGET_REGS",
";",
"++",
"PReg",
")",
"{",
"if",
"(",
"PReg",
"==",
"WebAssembly",
"::",
"EXPR_STACK",
"||",
"PReg",
"==",
"WebAssembly",
"::",
"ARGUMENTS",
")",
"continue",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"TRI",
".",
"getMinimalPhysRegClass",
"(",
"PReg",
")",
";",
"unsigned",
"VReg",
"=",
"WebAssembly",
"::",
"NoRegister",
";",
"for",
"(",
"auto",
"I",
"=",
"MRI",
".",
"reg_begin",
"(",
"PReg",
")",
",",
"E",
"=",
"MRI",
".",
"reg_end",
"(",
")",
";",
"I",
"!=",
"E",
";",
")",
"{",
"MachineOperand",
"&",
"MO",
"=",
"*",
"I",
"++",
";",
"if",
"(",
"!",
"MO",
".",
"isImplicit",
"(",
")",
")",
"{",
"if",
"(",
"VReg",
"==",
"WebAssembly",
"::",
"NoRegister",
")",
"VReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"RC",
")",
";",
"MO",
".",
"setReg",
"(",
"VReg",
")",
";",
"Changed",
"=",
"true",
";",
"}",
"}"
]
|
LLVM | XCore | CPP | next_suggestion | MPU | 8,599 | [
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"{"
]
| [
"case",
"ISD",
"::",
"Constant",
":",
"{",
"if",
"(",
"Predicate_immMskBitp",
"(",
"N",
")",
")",
"{",
"SDValue",
"MskSize",
"=",
"Transform_msksize_xform",
"(",
"N",
")",
";",
"return",
"CurDAG",
"->",
"getTargetNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"MskSize",
")",
";",
"}",
"else",
"if",
"(",
"!",
"Predicate_immU16",
"(",
"N",
")",
")",
"{",
"unsigned",
"Val",
"=",
"cast",
"<",
"ConstantSDNode",
">",
"(",
"N",
")",
"->",
"getZExtValue",
"(",
")",
";",
"SDValue",
"CPIdx",
"=",
"CurDAG",
"->",
"getTargetConstantPool",
"(",
"ConstantInt",
"::",
"get",
"(",
"Type",
"::",
"getInt32Ty",
"(",
"*",
"CurDAG",
"->",
"getContext",
"(",
")",
")",
",",
"Val",
")",
",",
"TLI",
".",
"getPointerTy",
"(",
")",
")",
";",
"return",
"CurDAG",
"->",
"getTargetNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"MVT",
"::",
"Other",
",",
"CPIdx",
",",
"CurDAG",
"->",
"getEntryNode",
"(",
")",
")",
";",
"}",
"break",
";",
"}",
"case",
"ISD",
"::",
"SMUL_LOHI",
":",
"{",
"if",
"(",
"!",
"Subtarget",
".",
"isXS1A",
"(",
")",
")",
"{",
"SDValue",
"Zero",
"(",
"CurDAG",
"->",
"getTargetNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"CurDAG",
"->",
"getTargetConstant",
"(",
"<NUM_LIT>",
",",
"MVT",
"::",
"i32",
")",
")",
",",
"<NUM_LIT>",
")",
";",
"SDValue",
"Ops",
"[",
"]",
"=",
"{",
"Zero",
",",
"Zero",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
"}",
";",
"SDNode",
"*",
"ResNode",
"=",
"CurDAG",
"->",
"getTargetNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"MVT",
"::",
"i32",
",",
"Ops",
",",
"<NUM_LIT>",
")",
";",
"ReplaceUses",
"(",
"SDValue",
"(",
"N",
",",
"<NUM_LIT>",
")",
",",
"SDValue",
"(",
"ResNode",
",",
"<NUM_LIT>",
")",
")",
";",
"ReplaceUses",
"(",
"SDValue",
"(",
"N",
",",
"<NUM_LIT>",
")",
",",
"SDValue",
"(",
"ResNode",
",",
"<NUM_LIT>",
")",
")",
";",
"return",
"NULL",
";",
"}",
"break",
";",
"}",
"case",
"ISD",
"::",
"UMUL_LOHI",
":",
"{",
"SDValue",
"Zero",
"(",
"CurDAG",
"->",
"getTargetNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"CurDAG",
"->",
"getTargetConstant",
"(",
"<NUM_LIT>",
",",
"MVT",
"::",
"i32",
")",
")",
",",
"<NUM_LIT>",
")",
";",
"SDValue",
"Ops",
"[",
"]",
"=",
"{",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Zero",
",",
"Zero",
"}",
";",
"SDNode",
"*",
"ResNode",
"=",
"CurDAG",
"->",
"getTargetNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"MVT",
"::",
"i32",
",",
"Ops",
",",
"<NUM_LIT>",
")",
";",
"ReplaceUses",
"(",
"SDValue",
"(",
"N",
",",
"<NUM_LIT>",
")",
",",
"SDValue",
"(",
"ResNode",
",",
"<NUM_LIT>",
")",
")",
";",
"ReplaceUses",
"(",
"SDValue",
"(",
"N",
",",
"<NUM_LIT>",
")",
",",
"SDValue",
"(",
"ResNode",
",",
"<NUM_LIT>",
")",
")",
";",
"return",
"NULL",
";",
"}"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.