{"ground_truth": ["<s>", "void", "FISCAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "isPCRel", ")", "const", "{", "unsigned", "NumBytes", "=", "4", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "(", "NumBytes", "-", "i", "-", "1", ")", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "</s>"], "natrual_language": ["Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "."], "TS_V_token": ["FISC", "FISC", "4", "\"Invalid fixup offset!\"", "0", "1", "8", "0xff"], "File": "FISCAsmBackend", "Func": "applyFixup", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20842, "Length": 109}
{"ground_truth": ["<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "override", "{", "return", "createFISCELFObjectWriter", "(", "OS", ",", "OSABI", ")", ";", "}", "</s>"], "natrual_language": ["Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "."], "TS_V_token": ["FISC", "FISC"], "File": "FISCAsmBackend", "Func": "createObjectWriter", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20843, "Length": 20}
{"ground_truth": ["<s>", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "return", "false", ";", "}", "</s>"], "natrual_language": ["Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "."], "TS_V_token": ["FISC"], "File": "FISCAsmBackend", "Func": "fixupNeedsRelaxation", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20844, "Length": 28}
{"ground_truth": ["<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "FISC", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_fisc_mov_q1_pcrel\"", ",", "0", ",", "64", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_fisc_mov_q2_pcrel\"", ",", "0", ",", "64", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_fisc_mov_q3_pcrel\"", ",", "0", ",", "64", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_fisc_mov_q4_pcrel\"", ",", "0", ",", "64", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_fisc_call26_pcrel\"", ",", "0", ",", "64", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_fisc_call19_pcrel\"", ",", "0", ",", "64", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_fisc_9bit_address\"", ",", "0", ",", "64", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_fisc_6bit_shamt\"", ",", "0", ",", "64", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_fisc_12bit_imm\"", ",", "0", ",", "64", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_fisc_movrz_pcrel\"", ",", "0", ",", "64", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>"], "natrual_language": ["Get", "information", "on", "a", "fixup", "kind", "."], "TS_V_token": ["FISC", "FISC::NumTargetFixupKinds", "\"fixup_fisc_mov_q1_pcrel\"", "0", "64", "\"fixup_fisc_mov_q2_pcrel\"", "0", "64", "\"fixup_fisc_mov_q3_pcrel\"", "0", "64", "\"fixup_fisc_mov_q4_pcrel\"", "0", "64", "\"fixup_fisc_call26_pcrel\"", "0", "64", "\"fixup_fisc_call19_pcrel\"", "0", "64", "\"fixup_fisc_9bit_address\"", "0", "64", "\"fixup_fisc_6bit_shamt\"", "0", "64", "\"fixup_fisc_12bit_imm\"", "0", "64", "\"fixup_fisc_movrz_pcrel\"", "0", "64", "\"Invalid kind!\""], "File": "FISCAsmBackend", "Func": "getFixupKindInfo", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20845, "Length": 183}
{"ground_truth": ["<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "FISC", "::", "NumTargetFixupKinds", ";", "}", "</s>"], "natrual_language": ["Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "."], "TS_V_token": ["FISC", "FISC::NumTargetFixupKinds"], "File": "FISCAsmBackend", "Func": "getNumFixupKinds", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20846, "Length": 13}
{"ground_truth": ["<s>", "unsigned", "getPointerSize", "(", ")", "const", "{", "return", "8", ";", "}", "</s>"], "natrual_language": ["Layout", "pointer", "size", "in", "bytes", ",", "rounded", "up", "to", "a", "whole", "number", "of", "bytes", "."], "TS_V_token": ["FISC", "8"], "File": "FISCAsmBackend", "Func": "getPointerSize", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20847, "Length": 10}
{"ground_truth": ["<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "override", "{", "return", "false", ";", "}", "</s>"], "natrual_language": ["Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "."], "TS_V_token": ["FISC"], "File": "FISCAsmBackend", "Func": "mayNeedRelaxation", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20848, "Length": 15}
{"ground_truth": ["<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "}", "</s>"], "natrual_language": ["Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "."], "TS_V_token": ["FISC"], "File": "FISCAsmBackend", "Func": "relaxInstruction", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20849, "Length": 16}
{"ground_truth": ["<s>", "bool", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "override", "{", "if", "(", "Count", "==", "0", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "."], "TS_V_token": ["FISC", "0"], "File": "FISCAsmBackend", "Func": "writeNopData", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20850, "Length": 26}
{"ground_truth": ["<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "if", "(", "Expr", "==", "0", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "else", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Expr", ")", ")", ";", "}", "</s>"], "natrual_language": ["Add", "a", "new", "MCExpr", "operand", "."], "TS_V_token": ["FISC", "0", "0"], "File": "FISCAsmParser", "Func": "addExpr", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20851, "Length": 78}
{"ground_truth": ["<s>", "static", "std", "::", "unique_ptr", "<", "FISCOperand", ">", "CreateMem", "(", "unsigned", "Base", ",", "const", "MCExpr", "*", "Off", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "auto", "Op", "=", "make_unique", "<", "FISCOperand", ">", "(", "k_Memory", ")", ";", "Op", "->", "Mem", ".", "Base", "=", "Base", ";", "Op", "->", "Mem", ".", "Off", "=", "Off", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>"], "natrual_language": ["Create", "a", "generalized", "memory", "operand", "."], "TS_V_token": ["FISC", "FISC", "FISC"], "File": "FISCAsmParser", "Func": "CreateMem", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20852, "Length": 67}
{"ground_truth": ["<s>", "static", "std", "::", "unique_ptr", "<", "FISCOperand", ">", "CreateReg", "(", "unsigned", "RegNum", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "auto", "Op", "=", "make_unique", "<", "FISCOperand", ">", "(", "k_Register", ")", ";", "Op", "->", "Reg", ".", "RegNum", "=", "RegNum", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>"], "natrual_language": ["CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "."], "TS_V_token": ["FISC", "FISC", "FISC"], "File": "FISCAsmParser", "Func": "CreateReg", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20853, "Length": 54}
{"ground_truth": ["<s>", "SMLoc", "getEndLoc", "(", ")", "const", "{", "return", "EndLoc", ";", "}", "</s>"], "natrual_language": ["getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "."], "TS_V_token": ["FISC"], "File": "FISCAsmParser", "Func": "getEndLoc", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20854, "Length": 10}
{"ground_truth": ["<s>", "unsigned", "FISCAsmParser", "::", "getReg", "(", "int", "RC", ",", "int", "RegNo", ")", "{", "return", "*", "(", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", "->", "getRegClass", "(", "RC", ")", ".", "begin", "(", ")", "+", "RegNo", ")", ";", "}", "</s>"], "natrual_language": ["Returns", "the", "register", "associated", "with", "this", "edge", "."], "TS_V_token": ["FISC", "FISC"], "File": "FISCAsmParser", "Func": "getReg", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20855, "Length": 36}
{"ground_truth": ["<s>", "SMLoc", "getStartLoc", "(", ")", "const", "{", "return", "StartLoc", ";", "}", "</s>"], "natrual_language": ["getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "."], "TS_V_token": ["FISC"], "File": "FISCAsmParser", "Func": "getStartLoc", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20856, "Length": 10}
{"ground_truth": ["<s>", "bool", "isImm", "(", ")", "const", "{", "return", "Kind", "==", "k_Immediate", ";", "}", "</s>"], "natrual_language": ["isImm", "-", "Is", "this", "an", "immediate", "operand", "?"], "TS_V_token": ["FISC"], "File": "FISCAsmParser", "Func": "isImm", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20857, "Length": 12}
{"ground_truth": ["<s>", "bool", "isMem", "(", ")", "const", "{", "return", "Kind", "==", "k_Memory", ";", "}", "</s>"], "natrual_language": ["isMem", "-", "Is", "this", "a", "memory", "operand", "?"], "TS_V_token": ["FISC"], "File": "FISCAsmParser", "Func": "isMem", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20858, "Length": 12}
{"ground_truth": ["<s>", "bool", "isReg", "(", ")", "const", "{", "return", "Kind", "==", "k_Register", ";", "}", "</s>"], "natrual_language": ["isReg", "-", "Is", "this", "a", "register", "operand", "?"], "TS_V_token": ["FISC"], "File": "FISCAsmParser", "Func": "isReg", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20859, "Length": 12}
{"ground_truth": ["<s>", "bool", "isToken", "(", ")", "const", "{", "return", "Kind", "==", "k_Token", ";", "}", "</s>"], "natrual_language": ["isToken", "-", "Is", "this", "a", "token", "operand", "?"], "TS_V_token": ["FISC"], "File": "FISCAsmParser", "Func": "isToken", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20860, "Length": 12}
{"ground_truth": ["<s>", "bool", "FISCAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "{", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "Error", "(", "IDLoc", ",", "\"instruction requires a CPU feature not currently enabled\"", ")", ";", "return", "true", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "FISCOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "."], "TS_V_token": ["FISC", "FISC", "\"instruction requires a CPU feature not currently enabled\"", "0U", "\"too few operands for instruction\"", "FISC", "\"invalid operand for instruction\"", "\"invalid instruction\""], "File": "FISCAsmParser", "Func": "MatchAndEmitInstruction", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20861, "Length": 184}
{"ground_truth": ["<s>", "bool", "FISCAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "IDVal", "==", "\".ent\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".end\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".frame\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".set\"", ")", "{", "return", "parseDirectiveSet", "(", ")", ";", "}", "if", "(", "IDVal", "==", "\".fmask\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".mask\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".gpword\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".byte\"", ")", "return", "parseDirectiveWord", "(", "1", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "IDVal", "==", "\".half\"", ")", "return", "parseDirectiveWord", "(", "2", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "IDVal", "==", "\".word\"", ")", "return", "parseDirectiveWord", "(", "4", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "IDVal", "==", "\".nword\"", ")", "return", "parseDirectiveWord", "(", "8", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "IDVal", "==", "\".xword\"", ")", "return", "parseDirectiveWord", "(", "8", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "."], "TS_V_token": ["FISC", "FISC", "\".ent\"", "\".end\"", "\".frame\"", "\".set\"", "\".fmask\"", "\".mask\"", "\".gpword\"", "\".byte\"", "1", "\".half\"", "2", "\".word\"", "4", "\".nword\"", "8", "\".xword\"", "8"], "File": "FISCAsmParser", "Func": "ParseDirective", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20862, "Length": 227}
{"ground_truth": ["<s>", "virtual", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "llvm_unreachable", "(", "\"unimplemented!\"", ")", ";", "}", "</s>"], "natrual_language": ["print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "."], "TS_V_token": ["FISC", "\"unimplemented!\""], "File": "FISCAsmParser", "Func": "print", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20863, "Length": 16}
{"ground_truth": ["<s>", "void", "FISCAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>"], "natrual_language": ["EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "."], "TS_V_token": ["FISC", "FISC"], "File": "FISCAsmPrinter", "Func": "EmitInstruction", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20864, "Length": 32}
{"ground_truth": ["<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"FISC Assembly Printer\"", ";", "}", "</s>"], "natrual_language": ["getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "."], "TS_V_token": ["FISC", "\"FISC Assembly Printer\""], "File": "FISCAsmPrinter", "Func": "getPassName", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20865, "Length": 13}
{"ground_truth": ["<s>", "bool", "FISCAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "int", "Offset", "=", "0", ";", "if", "(", "ExtraCode", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"unexpected inline asm memory operand\"", ")", ";", "O", "<<", "\"[\"", "<<", "FISCInstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "\", \"", "<<", "Offset", "<<", "\"]\"", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "."], "TS_V_token": ["FISC", "FISC", "0", "\"unexpected inline asm memory operand\"", "\"[\"", "FISC", "\", \"", "\"]\""], "File": "FISCAsmPrinter", "Func": "PrintAsmMemoryOperand", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20866, "Length": 86}
{"ground_truth": ["<s>", "bool", "FISCAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ";", "case", "'X'", ":", "if", "(", "(", "MO", ".", "getType", "(", ")", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "O", "<<", "\"0x\"", "<<", "StringRef", "(", "utohexstr", "(", "MO", ".", "getImm", "(", ")", ")", ")", ".", "lower", "(", ")", ";", "return", "false", ";", "case", "'x'", ":", "if", "(", "(", "MO", ".", "getType", "(", ")", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "O", "<<", "\"0x\"", "<<", "StringRef", "(", "utohexstr", "(", "MO", ".", "getImm", "(", ")", "&", "0xffff", ")", ")", ".", "lower", "(", ")", ";", "return", "false", ";", "case", "'d'", ":", "if", "(", "(", "MO", ".", "getType", "(", ")", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "O", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "'m'", ":", "if", "(", "(", "MO", ".", "getType", "(", ")", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "O", "<<", "MO", ".", "getImm", "(", ")", "-", "1", ";", "return", "false", ";", "case", "'z'", ":", "{", "if", "(", "MO", ".", "getType", "(", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "int64_t", "Val", "=", "MO", ".", "getImm", "(", ")", ";", "if", "(", "Val", ")", "O", "<<", "Val", ";", "else", "O", "<<", "\"xzr\"", ";", "return", "false", ";", "}", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "."], "TS_V_token": ["FISC", "FISC", "0", "1", "0", "0", "\"0x\"", "\"0x\"", "0xffff", "1", "\"xzr\""], "File": "FISCAsmPrinter", "Func": "PrintAsmOperand", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20867, "Length": 298}
{"ground_truth": ["<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"FISC Delay Slot Filler\"", ";", "}", "</s>"], "natrual_language": ["getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "."], "TS_V_token": ["FISC", "\"FISC Delay Slot Filler\""], "File": "FISCDelaySlotFiller", "Func": "getPassName", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20868, "Length": 13}
{"ground_truth": ["<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "override", "{", "bool", "Changed", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "F", ".", "begin", "(", ")", ",", "FE", "=", "F", ".", "end", "(", ")", ";", "FI", "!=", "FE", ";", "++", "FI", ")", "{", "Changed", "|=", "runOnMachineBasicBlock", "(", "*", "FI", ")", ";", "FISCTextSectOffset", "+=", "FI", "->", "size", "(", ")", ";", "}", "return", "Changed", ";", "}", "</s>"], "natrual_language": ["runOnMachineFunction", "-", "Emit", "the", "function", "body", "."], "TS_V_token": ["FISC", "FISC"], "File": "FISCDelaySlotFiller", "Func": "runOnMachineFunction", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20869, "Length": 64}
{"ground_truth": ["<s>", "DecodeStatus", "FISCDisassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "VStream", ",", "raw_ostream", "&", "CStream", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", "=", "readInstruction32", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "Result", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableFISC32", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "</s>"], "natrual_language": ["Returns", "the", "disassembly", "of", "a", "single", "instruction", "."], "TS_V_token": ["FISC", "FISC", "FISC", "4"], "File": "FISCDisassembler", "Func": "getInstruction", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20870, "Length": 100}
{"ground_truth": ["<s>", "void", "FISCFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "FISC", "::", "ADJCALLSTACKUP", "||", "I", "->", "getOpcode", "(", ")", "==", "FISC", "::", "ADJCALLSTACKDOWN", ")", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>"], "natrual_language": ["This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "."], "TS_V_token": ["FISC", "FISC", "FISC::ADJCALLSTACKUP", "FISC::ADJCALLSTACKDOWN"], "File": "FISCFrameLowering", "Func": "eliminateCallFramePseudoInstr", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20871, "Length": 50}
{"ground_truth": ["<s>", "void", "FISCFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "computeStackSize", "(", "MF", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "unsigned", "StackReg", "=", "FISC", "::", "SP", ";", "unsigned", "OffsetReg", "=", "materializeOffset", "(", "MF", ",", "MBB", ",", "MBBI", ",", "(", "unsigned", ")", "StackSize", ")", ";", "if", "(", "OffsetReg", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "FISC", "::", "ADDrr", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addReg", "(", "OffsetReg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "FISC", "::", "ADDri", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addImm", "(", "StackSize", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "}", "</s>"], "natrual_language": ["Insert", "epilog", "code", "into", "the", "function", "."], "TS_V_token": ["FISC", "FISC", "FISC::SP", "FISC::ADDrr", "FISC::ADDri"], "File": "FISCFrameLowering", "Func": "emitEpilogue", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20872, "Length": 174}
{"ground_truth": ["<s>", "void", "FISCFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "computeStackSize", "(", "MF", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "unsigned", "StackReg", "=", "FISC", "::", "SP", ";", "unsigned", "OffsetReg", "=", "materializeOffset", "(", "MF", ",", "MBB", ",", "MBBI", ",", "(", "unsigned", ")", "StackSize", ")", ";", "if", "(", "OffsetReg", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "FISC", "::", "SUBrr", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addReg", "(", "OffsetReg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "FISC", "::", "SUBri", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addImm", "(", "StackSize", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "}", "</s>"], "natrual_language": ["emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "."], "TS_V_token": ["FISC", "FISC", "FISC::SP", "FISC::SUBrr", "FISC::SUBri"], "File": "FISCFrameLowering", "Func": "emitPrologue", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20873, "Length": 186}
{"ground_truth": ["<s>", "bool", "FISCFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>"], "natrual_language": ["hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "."], "TS_V_token": ["FISC", "FISC"], "File": "FISCFrameLowering", "Func": "hasFP", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20874, "Length": 37}
{"ground_truth": ["<s>", "static", "int", "stackSlotSize", "(", ")", "{", "return", "8", ";", "}", "</s>"], "natrual_language": ["Stack", "slot", "size", "(", "4", "bytes", ")"], "TS_V_token": ["FISC", "8"], "File": "FISCFrameLowering", "Func": "stackSlotSize", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20875, "Length": 10}
{"ground_truth": ["<s>", "void", "FISCInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>"], "natrual_language": ["Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "."], "TS_V_token": ["FISC", "FISC"], "File": "FISCInstPrinter", "Func": "printInst", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20876, "Length": 38}
{"ground_truth": ["<s>", "void", "FISCInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "StringRef", "(", "getRegisterName", "(", "RegNo", ")", ")", ".", "lower", "(", ")", ";", "}", "</s>"], "natrual_language": ["Print", "the", "assembler", "register", "name", "."], "TS_V_token": ["FISC", "FISC"], "File": "FISCInstPrinter", "Func": "printRegName", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20877, "Length": 29}
{"ground_truth": ["<s>", "void", "FISCInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "BuildMI", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "get", "(", "FISC", "::", "MOVrr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>"], "natrual_language": ["}", "Branch", "Analysis", "&", "Modification"], "TS_V_token": ["FISC", "FISC", "FISC::MOVrr"], "File": "FISCInstrInfo", "Func": "copyPhysReg", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20878, "Length": 61}
{"ground_truth": ["<s>", "bool", "FISCInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "FISC", "::", "MOVi64", ":", "{", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "const", "unsigned", "DstReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "const", "bool", "DstIsDead", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "1", ")", ";", "auto", "Q1", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "FISC", "::", "MOVZ", ")", ",", "DstReg", ")", ";", "auto", "Q2", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "FISC", "::", "MOVK", ")", ")", ".", "addReg", "(", "DstReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "DstIsDead", ")", ")", ".", "addReg", "(", "DstReg", ")", ";", "auto", "Q3", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "FISC", "::", "MOVK", ")", ")", ".", "addReg", "(", "DstReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "DstIsDead", ")", ")", ".", "addReg", "(", "DstReg", ")", ";", "auto", "Q4", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "FISC", "::", "MOVK", ")", ")", ".", "addReg", "(", "DstReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "DstIsDead", ")", ")", ".", "addReg", "(", "DstReg", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "const", "uint64_t", "Imm", "=", "MO", ".", "getImm", "(", ")", ";", "Q1", "=", "Q1", ".", "addImm", "(", "Imm", "&", "0xffff", ")", ".", "addImm", "(", "0", ")", ";", "Q2", "=", "Q2", ".", "addImm", "(", "(", "Imm", ">>", "16", ")", "&", "0xffff", ")", ".", "addImm", "(", "1", ")", ";", "Q3", "=", "Q3", ".", "addImm", "(", "(", "Imm", ">>", "32", ")", "&", "0xffff", ")", ".", "addImm", "(", "2", ")", ";", "Q4", "=", "Q4", ".", "addImm", "(", "(", "Imm", ">>", "48", ")", "&", "0xffff", ")", ".", "addImm", "(", "3", ")", ";", "}", "else", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "const", "unsigned", "TF", "=", "MO", ".", "getTargetFlags", "(", ")", ";", "Q1", "=", "Q1", ".", "addGlobalAddress", "(", "GV", ",", "MO", ".", "getOffset", "(", ")", ",", "FISCII", "::", "MO_Q1", ")", ".", "addImm", "(", "0", ")", ";", "Q2", "=", "Q2", ".", "addGlobalAddress", "(", "GV", ",", "MO", ".", "getOffset", "(", ")", ",", "FISCII", "::", "MO_Q2", ")", ".", "addImm", "(", "1", ")", ";", "Q3", "=", "Q3", ".", "addGlobalAddress", "(", "GV", ",", "MO", ".", "getOffset", "(", ")", ",", "FISCII", "::", "MO_Q3", ")", ".", "addImm", "(", "2", ")", ";", "Q4", "=", "Q4", ".", "addGlobalAddress", "(", "GV", ",", "MO", ".", "getOffset", "(", ")", ",", "FISCII", "::", "MO_Q4", ")", ".", "addImm", "(", "3", ")", ";", "}", "MBB", ".", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "}", "}", "</s>"], "natrual_language": ["This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "."], "TS_V_token": ["FISC", "FISC", "FISC::MOVi64", "0", "0", "1", "FISC::MOVZ", "FISC::MOVK", "FISC::MOVK", "FISC::MOVK", "0xffff", "0", "16", "0xffff", "1", "32", "0xffff", "2", "48", "0xffff", "3", "FISCII::MO_Q1", "0", "FISCII::MO_Q2", "1", "FISCII::MO_Q3", "2", "FISCII::MO_Q4", "3"], "File": "FISCInstrInfo", "Func": "expandPostRAPseudo", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20879, "Length": 458}
{"ground_truth": ["<s>", "const", "FISCRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>"], "natrual_language": ["getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "."], "TS_V_token": ["FISC", "FISC"], "File": "FISCInstrInfo", "Func": "getRegisterInfo", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20880, "Length": 12}
{"ground_truth": ["<s>", "unsigned", "FISCInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "0", ";", "}", "</s>"], "natrual_language": ["isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "."], "TS_V_token": ["FISC", "FISC", "0"], "File": "FISCInstrInfo", "Func": "isLoadFromStackSlot", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20881, "Length": 20}
{"ground_truth": ["<s>", "unsigned", "FISCInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "0", ";", "}", "</s>"], "natrual_language": ["isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "."], "TS_V_token": ["FISC", "FISC", "0"], "File": "FISCInstrInfo", "Func": "isStoreToStackSlot", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20882, "Length": 20}
{"ground_truth": ["<s>", "void", "FISCInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "BuildMI", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "get", "(", "FISC", "::", "LDR", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>"], "natrual_language": ["Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "."], "TS_V_token": ["FISC", "FISC", "FISC::LDR", "0"], "File": "FISCInstrInfo", "Func": "loadRegFromStackSlot", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20883, "Length": 65}
{"ground_truth": ["<s>", "void", "FISCInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "BuildMI", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "get", "(", "FISC", "::", "STR", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>"], "natrual_language": ["Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "."], "TS_V_token": ["FISC", "FISC", "FISC::STR", "0"], "File": "FISCInstrInfo", "Func": "storeRegToStackSlot", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20884, "Length": 76}
{"ground_truth": ["<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"FISC DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>"], "natrual_language": ["getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "."], "TS_V_token": ["FISC", "\"FISC DAG->DAG Pattern Instruction Selection\""], "File": "FISCISelDAGToDAG", "Func": "getPassName", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20885, "Length": 14}
{"ground_truth": ["<s>", "SDNode", "*", "FISCDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\">>>>>> Selecting Node: \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "LOAD", ":", "return", "SelectIndexedLoad", "(", "N", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "SelectIndexedStore", "(", "N", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "return", "SelectFrameIndex", "(", "N", ")", ";", "case", "ISD", "::", "Constant", ":", "return", "ConstantToRegisterExpand", "(", "N", ",", "SDValue", "(", "N", ",", "0", ")", ")", ".", "getNode", "(", ")", ";", "case", "ISD", "::", "ADD", ":", "if", "(", "N", "->", "getOperand", "(", "0", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "TargetGlobalAddress", ")", "return", "SelectTargetGlobalAddressforADD", "(", "N", ",", "N", "->", "getOperand", "(", "0", ")", ".", "getNode", "(", ")", ")", ";", "break", ";", "case", "FISCISD", "::", "CMP", ":", "return", "SelectCompare", "(", "N", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "SelectConditionalBranch", "(", "N", ")", ";", "case", "ISD", "::", "CopyToReg", ":", "if", "(", "N", "->", "getOperand", "(", "2", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "TargetGlobalAddress", ")", "{", "GlobalAddressSDNode", "*", "GA", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "N", "->", "getOperand", "(", "2", ")", ")", ";", "const", "GlobalValue", "*", "GV", "=", "GA", "->", "getGlobal", "(", ")", ";", "unsigned", "char", "TargetFlags", "=", "FISCII", "::", "MO_MOVRZ", ";", "if", "(", "GV", "->", "getValueID", "(", ")", "==", "Value", "::", "FunctionVal", ")", "TargetFlags", "=", "FISCII", "::", "MO_Q1", ";", "SDValue", "TargetGlobalAddr", "=", "CurDAG", "->", "getTargetGlobalAddress", "(", "GV", ",", "SDLoc", "(", "N", ")", ",", "MVT", "::", "i64", ",", "GA", "->", "getOffset", "(", ")", ",", "TargetFlags", ")", ";", "MachineSDNode", "*", "Move", "=", "CurDAG", "->", "getMachineNode", "(", "FISC", "::", "MOVRZ", ",", "N", ",", "MVT", "::", "i64", ",", "TargetGlobalAddr", ",", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "N", ",", "MVT", "::", "i64", ")", ")", ";", "CurDAG", "->", "ReplaceAllUsesWith", "(", "N", "->", "getOperand", "(", "2", ")", ",", "SDValue", "(", "Move", ",", "0", ")", ")", ";", "}", "break", ";", "case", "FISCISD", "::", "CALL", ":", "{", "unsigned", "int", "operand2Opc", "=", "N", "->", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", ";", "if", "(", "operand2Opc", "==", "ISD", "::", "LOAD", "||", "operand2Opc", "==", "ISD", "::", "CopyFromReg", ")", "{", "return", "SelectCallFunctionPointer", "(", "N", ")", ";", "}", "break", ";", "}", "case", "ISD", "::", "SRL", ":", "return", "SelectShifts", "(", "N", ")", ";", "case", "ISD", "::", "MULHU", ":", "case", "ISD", "::", "MULHS", ":", "return", "SelectMUL", "(", "N", ")", ";", "}", "return", "SelectCode", "(", "N", ")", ";", "}", "</s>"], "natrual_language": ["Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "."], "TS_V_token": ["FISC", "FISC", "\">>>>>> Selecting Node: \"", "\"\\n\"", "ISD::LOAD", "ISD::STORE", "ISD::FrameIndex", "ISD::Constant", "0", "ISD::ADD", "0", "ISD::TargetGlobalAddress", "0", "FISCISD::CMP", "ISD::BR_CC", "ISD::CopyToReg", "2", "ISD::TargetGlobalAddress", "2", "FISCII::MO_MOVRZ", "FISCII::MO_Q1", "MVT::i64", "FISC::MOVRZ", "MVT::i64", "0", "MVT::i64", "2", "0", "FISCISD::CALL", "1", "ISD::LOAD", "ISD::CopyFromReg", "ISD::SRL", "ISD::MULHU", "ISD::MULHS"], "File": "FISCISelDAGToDAG", "Func": "Select", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20886, "Length": 401}
{"ground_truth": ["<s>", "bool", "FISCDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "switch", "(", "ConstraintID", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_m", ":", "OutOps", ".", "push_back", "(", "Op", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "."], "TS_V_token": ["FISC", "FISC", "\"Unexpected asm memory constraint\""], "File": "FISCISelDAGToDAG", "Func": "SelectInlineAsmMemoryOperand", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20887, "Length": 55}
{"ground_truth": ["<s>", "static", "void", "AnalyzeArguments", "(", "CCState", "&", "State", ",", "SmallVectorImpl", "<", "CCValAssign", ">", "&", "ArgLocs", ",", "const", "SmallVectorImpl", "<", "ArgT", ">", "&", "Args", ")", "{", "static", "const", "MCPhysReg", "RegList", "[", "]", "=", "{", "FISC", "::", "X10", ",", "FISC", "::", "X11", ",", "FISC", "::", "X12", ",", "FISC", "::", "X13", ",", "FISC", "::", "X14", ",", "FISC", "::", "X15", ",", "FISC", "::", "X26", ",", "FISC", "::", "X27", ",", "FISC", "::", "X18", "}", ";", "static", "const", "unsigned", "NbRegs", "=", "array_lengthof", "(", "RegList", ")", ";", "SmallVector", "<", "unsigned", ",", "4", ">", "ArgsParts", ";", "ParseFunctionArgs", "(", "Args", ",", "ArgsParts", ")", ";", "if", "(", "State", ".", "isVarArg", "(", ")", ")", "{", "unsigned", "ValNo", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgsParts", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "MVT", "ArgVT", "=", "Args", "[", "ValNo", "]", ".", "VT", ";", "MVT", "LocVT", "=", "ArgVT", ";", "CCValAssign", "::", "LocInfo", "LocInfo", "=", "CCValAssign", "::", "Full", ";", "for", "(", "unsigned", "j", "=", "0", ";", "j", "<", "ArgsParts", "[", "i", "]", ";", "j", "++", ")", "{", "if", "(", "i", "==", "0", "&&", "j", "==", "0", ")", "State", ".", "addLoc", "(", "CCValAssign", "::", "getCustomMem", "(", "ValNo", "++", ",", "ArgVT", ",", "State", ".", "AllocateStack", "(", "8", ",", "8", ")", ",", "LocVT", ",", "LocInfo", ")", ")", ";", "else", "State", ".", "addLoc", "(", "CCValAssign", "::", "getCustomMem", "(", "ValNo", "++", ",", "ArgVT", ",", "State", ".", "AllocateStack", "(", "8", ",", "8", ")", ",", "LocVT", ",", "LocInfo", ")", ")", ";", "}", "}", "return", ";", "}", "unsigned", "RegsLeft", "=", "NbRegs", ";", "bool", "UseStack", "=", "false", ";", "unsigned", "ValNo", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgsParts", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "MVT", "ArgVT", "=", "Args", "[", "ValNo", "]", ".", "VT", ";", "ISD", "::", "ArgFlagsTy", "ArgFlags", "=", "Args", "[", "ValNo", "]", ".", "Flags", ";", "MVT", "LocVT", "=", "ArgVT", ";", "CCValAssign", "::", "LocInfo", "LocInfo", "=", "CCValAssign", "::", "Full", ";", "if", "(", "ArgFlags", ".", "isByVal", "(", ")", ")", "{", "State", ".", "HandleByVal", "(", "ValNo", "++", ",", "ArgVT", ",", "LocVT", ",", "LocInfo", ",", "8", ",", "8", ",", "ArgFlags", ")", ";", "continue", ";", "}", "unsigned", "Parts", "=", "ArgsParts", "[", "i", "]", ";", "if", "(", "!", "UseStack", "&&", "Parts", "<=", "RegsLeft", ")", "{", "unsigned", "FirstVal", "=", "ValNo", ";", "for", "(", "unsigned", "j", "=", "0", ";", "j", "<", "Parts", ";", "j", "++", ")", "{", "unsigned", "Reg", "=", "State", ".", "AllocateReg", "(", "RegList", ")", ";", "State", ".", "addLoc", "(", "CCValAssign", "::", "getReg", "(", "ValNo", "++", ",", "ArgVT", ",", "Reg", ",", "LocVT", ",", "LocInfo", ")", ")", ";", "RegsLeft", "--", ";", "}", "SmallVectorImpl", "<", "CCValAssign", ">", "::", "iterator", "B", "=", "ArgLocs", ".", "begin", "(", ")", "+", "FirstVal", ";", "std", "::", "reverse", "(", "B", ",", "B", "+", "Parts", ")", ";", "}", "else", "{", "UseStack", "=", "true", ";", "for", "(", "unsigned", "j", "=", "0", ";", "j", "<", "Parts", ";", "j", "++", ")", "CC_FISC", "(", "ValNo", "++", ",", "ArgVT", ",", "LocVT", ",", "LocInfo", ",", "ArgFlags", ",", "State", ")", ";", "}", "}", "}", "</s>"], "natrual_language": ["The", "function", "will", "invoke", "AnalyzeCallOperands", "."], "TS_V_token": ["FISC", "FISC::X10", "FISC::X11", "FISC::X12", "FISC::X13", "FISC::X14", "FISC::X15", "FISC::X26", "FISC::X27", "FISC::X18", "4", "0", "0", "0", "0", "0", "8", "8", "8", "8", "0", "0", "ISD::ArgFlagsTy", "8", "8", "0", "0", "FISC"], "File": "FISCISelLowering", "Func": "AnalyzeArguments", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20888, "Length": 491}
{"ground_truth": ["<s>", "bool", "FISCTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "if", "(", "!", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC_FISC", ")", ")", "return", "false", ";", "if", "(", "CCInfo", ".", "getNextStackOffset", "(", ")", "!=", "0", "&&", "isVarArg", ")", "return", "false", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "."], "TS_V_token": ["FISC", "FISC", "ISD::OutputArg", "16", "FISC", "0"], "File": "FISCISelLowering", "Func": "CanLowerReturn", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20889, "Length": 89}
{"ground_truth": ["<s>", "MachineBasicBlock", "*", "FISCTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "BB", "->", "getParent", "(", ")", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "MI", "->", "getOpcode", "(", ")", "==", "FISC", "::", "Select", "&&", "\"Unexpected instr type to insert\"", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "I", "=", "++", "BB", "->", "getIterator", "(", ")", ";", "MachineBasicBlock", "*", "ThisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "Copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "Copy1MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "I", ",", "Copy0MBB", ")", ";", "F", "->", "insert", "(", "I", ",", "Copy1MBB", ")", ";", "Copy1MBB", "->", "splice", "(", "Copy1MBB", "->", "begin", "(", ")", ",", "BB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "Copy1MBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "Copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "Copy1MBB", ")", ";", "BuildMI", "(", "BB", ",", "DL", ",", "TII", ".", "get", "(", "FISC", "::", "Bcc", ")", ")", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "3", ")", ")", ".", "addMBB", "(", "Copy1MBB", ",", "FISCII", "::", "MO_CALL19", ")", ";", "BB", "=", "Copy0MBB", ";", "BB", "->", "addSuccessor", "(", "Copy1MBB", ")", ";", "BB", "=", "Copy1MBB", ";", "BuildMI", "(", "*", "BB", ",", "BB", "->", "begin", "(", ")", ",", "DL", ",", "TII", ".", "get", "(", "FISC", "::", "PHI", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "Copy0MBB", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "ThisMBB", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "BB", ";", "}", "</s>"], "natrual_language": ["This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "."], "TS_V_token": ["FISC", "FISC", "FISC::Select", "\"Unexpected instr type to insert\"", "FISC::Bcc", "3", "FISCII::MO_CALL19", "FISC::PHI", "0", "2", "1"], "File": "FISCISelLowering", "Func": "EmitInstrWithCustomInserter", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20890, "Length": 323}
{"ground_truth": ["<s>", "FISCTargetLowering", "::", "ConstraintType", "FISCTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'c'", ":", "return", "C_RegisterClass", ";", "case", "'R'", ":", "return", "C_Memory", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>"], "natrual_language": ["Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "."], "TS_V_token": ["FISC", "FISC", "FISC", "1", "0"], "File": "FISCISelLowering", "Func": "getConstraintType", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20891, "Length": 58}
{"ground_truth": ["<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "FISCTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "FISC", "::", "GRRegsRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0u", ",", "static_cast", "<", "const", "TargetRegisterClass", "*", ">", "(", "0", ")", ")", ";", "case", "'c'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "FISC", "::", "X19", ",", "&", "FISC", "::", "GRRegsRegClass", ")", ";", "assert", "(", "\"Unexpected type.\"", ")", ";", "}", "}", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "R", ";", "R", "=", "parseRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "if", "(", "R", ".", "second", ")", "return", "R", ";", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>"], "natrual_language": ["Given", "a", "physical", "register", "constraint", "(", "e.g", "."], "TS_V_token": ["FISC", "FISC", "1", "0", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::i64", "0U", "FISC::GRRegsRegClass", "0u", "0", "MVT::i64", "FISC::X19", "FISC::GRRegsRegClass", "\"Unexpected type.\""], "File": "FISCISelLowering", "Func": "getRegForInlineAsmConstraint", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20892, "Length": 185}
{"ground_truth": ["<s>", "TargetLowering", "::", "ConstraintWeight", "FISCTargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "!", "CallOperandVal", ")", "return", "CW_Default", ";", "Type", "*", "type", "=", "CallOperandVal", "->", "getType", "(", ")", ";", "switch", "(", "*", "constraint", ")", "{", "default", ":", "weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "info", ",", "constraint", ")", ";", "break", ";", "case", "'c'", ":", "if", "(", "type", "->", "isIntegerTy", "(", ")", ")", "weight", "=", "CW_SpecificReg", ";", "break", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'N'", ":", "case", "'O'", ":", "case", "'P'", ":", "if", "(", "isa", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "weight", "=", "CW_Constant", ";", "break", ";", "case", "'R'", ":", "weight", "=", "CW_Memory", ";", "break", ";", "}", "return", "weight", ";", "}", "</s>"], "natrual_language": ["Examine", "constraint", "string", "and", "operand", "type", "and", "determine", "a", "weight", "value", "."], "TS_V_token": ["FISC", "FISC"], "File": "FISCISelLowering", "Func": "getSingleConstraintMatchWeight", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20893, "Length": 138}
{"ground_truth": ["<s>", "const", "char", "*", "FISCTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "NULL", ";", "case", "FISCISD", "::", "RET_FLAG", ":", "return", "\"RetFlag\"", ";", "case", "FISCISD", "::", "LOAD_SYM", ":", "return", "\"LOAD_SYM\"", ";", "case", "FISCISD", "::", "MOVEi64", ":", "return", "\"MOVEi64\"", ";", "case", "FISCISD", "::", "CALL", ":", "return", "\"CALL\"", ";", "case", "FISCISD", "::", "SELECT_CC", ":", "return", "\"SELECT_CC\"", ";", "case", "FISCISD", "::", "CMP", ":", "return", "\"CMP\"", ";", "}", "}", "</s>"], "natrual_language": ["getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific"], "TS_V_token": ["FISC", "FISC", "FISCISD::RET_FLAG", "\"RetFlag\"", "FISCISD::LOAD_SYM", "\"LOAD_SYM\"", "FISCISD::MOVEi64", "\"MOVEi64\"", "FISCISD::CALL", "\"CALL\"", "FISCISD::SELECT_CC", "\"SELECT_CC\"", "FISCISD::CMP", "\"CMP\""], "File": "FISCISelLowering", "Func": "getTargetNodeName", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20894, "Length": 72}
{"ground_truth": ["<s>", "bool", "FISCTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "!", "AM", ".", "HasBaseReg", ")", "break", ";", "return", "false", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "."], "TS_V_token": ["FISC", "FISC", "0", "1"], "File": "FISCISelLowering", "Func": "isLegalAddressingMode", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20895, "Length": 70}
{"ground_truth": ["<s>", "SDValue", "FISCTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InGlue", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "AnalyzeReturnValues", "(", "CCInfo", ",", "RVLocs", ",", "Ins", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InGlue", ")", ".", "getValue", "(", "1", ")", ";", "InGlue", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>"], "natrual_language": ["LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "."], "TS_V_token": ["FISC", "FISC", "ISD::InputArg", "16", "0", "1", "2", "0"], "File": "FISCISelLowering", "Func": "LowerCallResult", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20896, "Length": 166}
{"ground_truth": ["<s>", "SDValue", "FISCTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unimplemented operand\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSelectCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>"], "natrual_language": ["LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "."], "TS_V_token": ["FISC", "FISC", "\"Unimplemented operand\"", "ISD::GlobalAddress", "ISD::SELECT_CC", "ISD::VASTART"], "File": "FISCISelLowering", "Func": "LowerOperation", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20897, "Length": 71}
{"ground_truth": ["<s>", "SDValue", "FISCTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_FISC", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "8", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "FISCISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>"], "natrual_language": ["This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "."], "TS_V_token": ["FISC", "FISC", "ISD::OutputArg", "16", "FISC", "8", "1", "0", "\"Can only return in registers!\"", "1", "0", "FISCISD::RET_FLAG", "MVT::Other"], "File": "FISCISelLowering", "Func": "LowerReturn", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20898, "Length": 239}
{"ground_truth": ["<s>", "void", "FISCMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "Desc", ".", "getSize", "(", ")", "!=", "4", ")", "{", "llvm_unreachable", "(", "\"Unexpected instruction size!\"", ")", ";", "}", "const", "uint32_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "EmitConstant", "(", "Binary", ",", "Desc", ".", "getSize", "(", ")", ",", "OS", ")", ";", "++", "MCNumEmitted", ";", "}", "</s>"], "natrual_language": ["Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "."], "TS_V_token": ["FISC", "FISC", "4", "\"Unexpected instruction size!\""], "File": "FISCMCCodeEmitter", "Func": "encodeInstruction", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20899, "Length": 91}
{"ground_truth": ["<s>", "unsigned", "FISCMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "CTX", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"unknown operand kind in printOperand\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "MCExpr", "::", "ExprKind", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "if", "(", "Kind", "==", "MCExpr", "::", "Binary", ")", "{", "Expr", "=", "static_cast", "<", "const", "MCBinaryExpr", "*", ">", "(", "Expr", ")", "->", "getLHS", "(", ")", ";", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "}", "if", "(", "Kind", "==", "MCExpr", "::", "Constant", ")", "return", "cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", "->", "getValue", "(", ")", ";", "assert", "(", "Kind", "==", "MCExpr", "::", "SymbolRef", ")", ";", "unsigned", "FixupKind", ";", "unsigned", "VKind", "=", "cast", "<", "MCSymbolRefExpr", ">", "(", "Expr", ")", "->", "getKind", "(", ")", ";", "switch", "(", "VKind", ")", "{", "case", "MCSymbolRefExpr", "::", "VK_None", ":", "return", "0", ";", "default", ":", "{", "std", "::", "string", "msg", "=", "\"Unknown fixup kind! (\"", "+", "std", "::", "to_string", "(", "VKind", ")", "+", "\")\"", ";", "llvm_unreachable", "(", "msg", ".", "c_str", "(", ")", ")", ";", "}", "case", "MCSymbolRefExpr", "::", "VK_FISC_Q1", ":", "FixupKind", "=", "FISC", "::", "fixup_fisc_mov_q1_pcrel", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_FISC_Q2", ":", "FixupKind", "=", "FISC", "::", "fixup_fisc_mov_q2_pcrel", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_FISC_Q3", ":", "FixupKind", "=", "FISC", "::", "fixup_fisc_mov_q3_pcrel", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_FISC_Q4", ":", "FixupKind", "=", "FISC", "::", "fixup_fisc_mov_q4_pcrel", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_FISC_CALL26", ":", "FixupKind", "=", "FISC", "::", "fixup_fisc_call26_pcrel", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_FISC_CALL19", ":", "FixupKind", "=", "FISC", "::", "fixup_fisc_call19_pcrel", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_FISC_9BIT", ":", "FixupKind", "=", "FISC", "::", "fixup_fisc_9bit_address", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_FISC_6BIT", ":", "FixupKind", "=", "FISC", "::", "fixup_fisc_6bit_shamt", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_FISC_12BIT", ":", "FixupKind", "=", "FISC", "::", "fixup_fisc_12bit_imm", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_FISC_MOVRZ", ":", "FixupKind", "=", "FISC", "::", "fixup_fisc_movrz_pcrel", ";", "break", ";", "}", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "MO", ".", "getExpr", "(", ")", ",", "MCFixupKind", "(", "FixupKind", ")", ")", ")", ";", "return", "0", ";", "}", "</s>"], "natrual_language": ["getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "."], "TS_V_token": ["FISC", "FISC", "\"unknown operand kind in printOperand\"", "0", "\"Unknown fixup kind! (\"", "\")\"", "FISC", "FISC::fixup_fisc_mov_q1_pcrel", "FISC", "FISC::fixup_fisc_mov_q2_pcrel", "FISC", "FISC::fixup_fisc_mov_q3_pcrel", "FISC", "FISC::fixup_fisc_mov_q4_pcrel", "FISC", "FISC::fixup_fisc_call26_pcrel", "FISC", "FISC::fixup_fisc_call19_pcrel", "FISC", "FISC::fixup_fisc_9bit_address", "FISC", "FISC::fixup_fisc_6bit_shamt", "FISC", "FISC::fixup_fisc_12bit_imm", "FISC", "FISC::fixup_fisc_movrz_pcrel", "0", "0"], "File": "FISCMCCodeEmitter", "Func": "getMachineOpValue", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20900, "Length": 389}
{"ground_truth": ["<s>", "void", "FISCMCInstLower", "::", "Initialize", "(", "Mangler", "*", "M", ",", "MCContext", "*", "C", ")", "{", "Mang", "=", "M", ";", "Ctx", "=", "C", ";", "}", "</s>"], "natrual_language": ["This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "."], "TS_V_token": ["FISC", "FISC"], "File": "FISCMCInstLower", "Func": "Initialize", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20901, "Length": 23}
{"ground_truth": ["<s>", "void", "FISCRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineOperand", "&", "FIOp", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "unsigned", "FI", "=", "FIOp", ".", "getIndex", "(", ")", ";", "unsigned", "ImmOpIdx", "=", "0", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", ";", "case", "FISC", "::", "ADDri", ":", "case", "FISC", "::", "LDR", ":", "case", "FISC", "::", "LDRB", ":", "case", "FISC", "::", "LDRH", ":", "case", "FISC", "::", "LDRSW", ":", "case", "FISC", "::", "LDRXR", ":", "case", "FISC", "::", "LDRR", ":", "case", "FISC", "::", "LDRBR", ":", "case", "FISC", "::", "LDRHR", ":", "case", "FISC", "::", "LDRSWR", ":", "case", "FISC", "::", "LDRXRR", ":", "case", "FISC", "::", "STR", ":", "case", "FISC", "::", "STRB", ":", "case", "FISC", "::", "STRH", ":", "case", "FISC", "::", "STRW", ":", "case", "FISC", "::", "STRXR", ":", "case", "FISC", "::", "STRR", ":", "case", "FISC", "::", "STRBR", ":", "case", "FISC", "::", "STRHR", ":", "case", "FISC", "::", "STRWR", ":", "case", "FISC", "::", "STRXRR", ":", "ImmOpIdx", "=", "FIOperandNum", "+", "1", ";", "break", ";", "}", "MachineOperand", "&", "ImmOp", "=", "MI", ".", "getOperand", "(", "ImmOpIdx", ")", ";", "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "FI", ")", "+", "MFI", "->", "getStackSize", "(", ")", "+", "ImmOp", ".", "getImm", "(", ")", ";", "FIOp", ".", "ChangeToRegister", "(", "FISC", "::", "SP", ",", "false", ")", ";", "ImmOp", ".", "setImm", "(", "Offset", ")", ";", "}", "</s>"], "natrual_language": ["This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "."], "TS_V_token": ["FISC", "FISC", "0", "FISC::ADDri", "FISC::LDR", "FISC::LDRB", "FISC::LDRH", "FISC::LDRSW", "FISC::LDRXR", "FISC::LDRR", "FISC::LDRBR", "FISC::LDRHR", "FISC::LDRSWR", "FISC::LDRXRR", "FISC::STR", "FISC::STRB", "FISC::STRH", "FISC::STRW", "FISC::STRXR", "FISC::STRR", "FISC::STRBR", "FISC::STRHR", "FISC::STRWR", "FISC::STRXRR", "1", "FISC::SP"], "File": "FISCRegisterInfo", "Func": "eliminateFrameIndex", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20902, "Length": 260}
{"ground_truth": ["<s>", "const", "uint16_t", "*", "FISCRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "FISC", "::", "LR", ",", "FISC", "::", "X19", ",", "FISC", "::", "X20", ",", "FISC", "::", "X21", ",", "FISC", "::", "X22", ",", "FISC", "::", "X23", ",", "FISC", "::", "X24", ",", "FISC", "::", "X25", ",", "FISC", "::", "X26", ",", "FISC", "::", "X27", ",", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>"], "natrual_language": ["Code", "Generation", "virtual", "methods", "..."], "TS_V_token": ["FISC", "FISC", "FISC::LR", "FISC::X19", "FISC::X20", "FISC::X21", "FISC::X22", "FISC::X23", "FISC::X24", "FISC::X25", "FISC::X26", "FISC::X27", "0"], "File": "FISCRegisterInfo", "Func": "getCalleeSavedRegs", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20903, "Length": 69}
{"ground_truth": ["<s>", "const", "uint32_t", "*", "FISCRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", ")", "const", "{", "return", "CC_Save_RegMask", ";", "}", "</s>"], "natrual_language": ["Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "."], "TS_V_token": ["FISC", "FISC"], "File": "FISCRegisterInfo", "Func": "getCallPreservedMask", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20904, "Length": 22}
{"ground_truth": ["<s>", "unsigned", "FISCRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "FISC", "::", "SP", ";", "}", "</s>"], "natrual_language": ["Debug", "information", "queries", "."], "TS_V_token": ["FISC", "FISC", "FISC::SP"], "File": "FISCRegisterInfo", "Func": "getFrameRegister", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20905, "Length": 18}
{"ground_truth": ["<s>", "BitVector", "FISCRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "FISC", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "FISC", "::", "LR", ")", ";", "return", "Reserved", ";", "}", "</s>"], "natrual_language": ["getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "."], "TS_V_token": ["FISC", "FISC", "FISC::SP", "FISC::LR"], "File": "FISCRegisterInfo", "Func": "getReservedRegs", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20906, "Length": 42}
{"ground_truth": ["<s>", "bool", "FISCRegisterInfo", "::", "requiresRegisterScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>"], "natrual_language": ["Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "."], "TS_V_token": ["FISC", "FISC"], "File": "FISCRegisterInfo", "Func": "requiresRegisterScavenging", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20907, "Length": 16}
{"ground_truth": ["<s>", "bool", "FISCRegisterInfo", "::", "trackLivenessAfterRegAlloc", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>"], "natrual_language": ["Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "."], "TS_V_token": ["FISC", "FISC"], "File": "FISCRegisterInfo", "Func": "trackLivenessAfterRegAlloc", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20908, "Length": 16}
{"ground_truth": ["<s>", "bool", "FISCRegisterInfo", "::", "useFPForScavengingIndex", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "false", ";", "}", "</s>"], "natrual_language": ["Returns", "true", "if", "the", "target", "wants", "to", "use", "frame", "pointer", "based", "accesses", "to", "spill", "to", "the", "scavenger", "emergency", "spill", "slot", "."], "TS_V_token": ["FISC", "FISC"], "File": "FISCRegisterInfo", "Func": "useFPForScavengingIndex", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20909, "Length": 16}
{"ground_truth": ["<s>", "const", "FISCInstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ";", "}", "</s>"], "natrual_language": ["TargetInstrInfo", "getter", "."], "TS_V_token": ["FISC", "FISC"], "File": "FISCSubtarget", "Func": "getInstrInfo", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20910, "Length": 14}
{"ground_truth": ["<s>", "const", "InstrItineraryData", "*", "getInstrItineraryData", "(", ")", "const", "override", "{", "return", "&", "InstrItins", ";", "}", "</s>"], "natrual_language": ["getInstrItineraryData", "-", "Returns", "instruction", "itinerary", "data", "for", "the", "target", "or", "specific", "subtarget", "."], "TS_V_token": ["FISC"], "File": "FISCSubtarget", "Func": "getInstrItineraryData", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20911, "Length": 14}
{"ground_truth": ["<s>", "const", "FISCRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>"], "natrual_language": ["getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "."], "TS_V_token": ["FISC", "FISC"], "File": "FISCSubtarget", "Func": "getRegisterInfo", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20912, "Length": 18}
{"ground_truth": ["<s>", "bool", "FISCPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createFISCISelDag", "(", "getFISCTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "."], "TS_V_token": ["FISC", "FISC", "FISC", "FISC"], "File": "FISCTargetMachine", "Func": "addInstSelector", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20913, "Length": 25}
{"ground_truth": ["<s>", "void", "FISCPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createFISCDelaySlotFillerPass", "(", "getFISCTargetMachine", "(", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "."], "TS_V_token": ["FISC", "FISC", "FISC", "FISC"], "File": "FISCTargetMachine", "Func": "addPreEmitPass", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20914, "Length": 18}
{"ground_truth": ["<s>", "bool", "FISCPassConfig", "::", "addPreISel", "(", ")", "{", "return", "false", ";", "}", "</s>"], "natrual_language": ["{", "{", "@", "For", "GlobalISel"], "TS_V_token": ["FISC", "FISC"], "File": "FISCTargetMachine", "Func": "addPreISel", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20915, "Length": 11}
{"ground_truth": ["<s>", "TargetPassConfig", "*", "FISCTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "FISCPassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>"], "natrual_language": ["Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "."], "TS_V_token": ["FISC", "FISC", "FISC"], "File": "FISCTargetMachine", "Func": "createPassConfig", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20916, "Length": 21}
{"ground_truth": ["<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", "</s>"], "natrual_language": ["Return", "information", "about", "object", "file", "lowering", "."], "TS_V_token": ["FISC"], "File": "FISCTargetMachine", "Func": "getObjFileLowering", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20917, "Length": 16}
{"ground_truth": ["<s>", "virtual", "const", "TargetSubtargetInfo", "*", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>"], "natrual_language": ["Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "."], "TS_V_token": ["FISC"], "File": "FISCTargetMachine", "Func": "getSubtargetImpl", "Target": "FISC", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 20918, "Length": 18}