{"ground_truth": ["", "void", "CSKYAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "if", "(", "Kind", ">=", "FirstLiteralRelocationKind", ")", "return", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Kind", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ",", "Ctx", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "alignTo", "(", "Info", ".", "TargetSize", "+", "Info", ".", "TargetOffset", ",", "8", ")", "/", "8", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "bool", "IsLittleEndian", "=", "(", "Endian", "==", "support", "::", "little", ")", ";", "if", "(", "IsLittleEndian", "&&", "(", "NumBytes", "==", "4", ")", ")", "{", "Data", "[", "Offset", "+", "0", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "16", ")", "&", "0xff", ")", ";", "Data", "[", "Offset", "+", "1", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "24", ")", "&", "0xff", ")", ";", "Data", "[", "Offset", "+", "2", "]", "|=", "uint8_t", "(", "Value", "&", "0xff", ")", ";", "Data", "[", "Offset", "+", "3", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "8", ")", "&", "0xff", ")", ";", "}", "else", "{", "for", "(", "unsigned", "I", "=", "0", ";", "I", "!=", "NumBytes", ";", "I", "++", ")", "{", "unsigned", "Idx", "=", "IsLittleEndian", "?", "I", ":", "(", "NumBytes", "-", "1", "-", "I", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "I", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "}", ""], "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": ["CSKY", "CSKY", "8", "8", "\"Invalid fixup offset!\"", "support::little", "4", "0", "16", "0xff", "1", "24", "0xff", "2", "0xff", "3", "8", "0xff", "0", "1", "8", "0xff"], "File": "CSKYAsmBackend1", "Func": "applyFixup", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17133, "Length": 288} {"ground_truth": ["", "void", "CSKYAsmBackend", "::", "relaxInstruction", "(", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "llvm_unreachable", "(", "\"CSKYAsmBackend::relaxInstruction() unimplemented\"", ")", ";", "}", ""], "natrual_language": ["Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "."], "TS_V_token": ["CSKY", "CSKY", "\"CSKYAsmBackend::relaxInstruction() unimplemented\""], "File": "CSKYAsmBackend1", "Func": "relaxInstruction", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17134, "Length": 22} {"ground_truth": ["", "bool", "CSKYAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "if", "(", "Count", "%", "2", ")", "return", "false", ";", "while", "(", "Count", ">=", "4", ")", "{", "OS", ".", "write", "(", "\"\\xc4\\x00\\x48\\x20\"", ",", "4", ")", ";", "Count", "-=", "4", ";", "}", "if", "(", "Count", ")", "OS", ".", "write", "(", "\"\\x6c\\x03\"", ",", "2", ")", ";", "return", "true", ";", "}", ""], "natrual_language": ["Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "."], "TS_V_token": ["CSKY", "CSKY", "2", "4", "\"\\xc4\\x00\\x48\\x20\"", "4", "4", "\"\\x6c\\x03\"", "2"], "File": "CSKYAsmBackend1", "Func": "writeNopData", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17135, "Length": 66} {"ground_truth": ["", "void", "CSKYAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "return", ";", "}", ""], "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": ["CSKY", "CSKY"], "File": "CSKYAsmBackend2", "Func": "applyFixup", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17136, "Length": 42} {"ground_truth": ["", "unsigned", "int", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "CSKY", "::", "NumTargetFixupKinds", ";", "}", ""], "natrual_language": ["Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "."], "TS_V_token": ["CSKY", "CSKY::NumTargetFixupKinds"], "File": "CSKYAsmBackend2", "Func": "getNumFixupKinds", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17137, "Length": 14} {"ground_truth": ["", "bool", "CSKYAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "if", "(", "Count", "%", "2", ")", "return", "false", ";", "while", "(", "Count", ">=", "4", ")", "{", "OS", ".", "write", "(", "\"\\xc4\\x00\\x48\\x20\"", ",", "4", ")", ";", "Count", "-=", "4", ";", "}", "if", "(", "Count", ")", "OS", ".", "write", "(", "\"\\x6c\\x03\"", ",", "2", ")", ";", "return", "true", ";", "}", ""], "natrual_language": ["Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "."], "TS_V_token": ["CSKY", "CSKY", "2", "4", "\"\\xc4\\x00\\x48\\x20\"", "4", "4", "\"\\x6c\\x03\"", "2"], "File": "CSKYAsmBackend2", "Func": "writeNopData", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17138, "Length": 61} {"ground_truth": ["", "const", "MCFixupKindInfo", "&", "CSKYAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "static", "llvm", "::", "DenseMap", "<", "unsigned", ",", "MCFixupKindInfo", ">", "Infos", "=", "{", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_addr32", ",", "{", "\"fixup_csky_addr32\"", ",", "0", ",", "32", ",", "0", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_pcrel_imm16_scale2", ",", "{", "\"fixup_csky_pcrel_imm16_scale2\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_pcrel_uimm16_scale4", ",", "{", "\"fixup_csky_pcrel_uimm16_scale4\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_pcrel_imm26_scale2", ",", "{", "\"fixup_csky_pcrel_imm26_scale2\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_pcrel_imm18_scale2", ",", "{", "\"fixup_csky_pcrel_imm18_scale2\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", "}", ";", "assert", "(", "Infos", ".", "size", "(", ")", "==", "CSKY", "::", "NumTargetFixupKinds", "&&", "\"Not all fixup kinds added to Infos array\"", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "if", "(", "FirstTargetFixupKind", "<=", "Kind", "&&", "Kind", "<", "FirstLiteralRelocationKind", ")", "return", "Infos", "[", "Kind", "]", ";", "else", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "else", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "FK_NONE", ")", ";", "}", ""], "natrual_language": ["Get", "information", "on", "a", "fixup", "kind", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY::Fixups", "\"fixup_csky_addr32\"", "0", "32", "0", "CSKY::Fixups", "\"fixup_csky_pcrel_imm16_scale2\"", "0", "32", "CSKY::Fixups", "\"fixup_csky_pcrel_uimm16_scale4\"", "0", "32", "CSKY::Fixups", "\"fixup_csky_pcrel_imm26_scale2\"", "0", "32", "CSKY::Fixups", "\"fixup_csky_pcrel_imm18_scale2\"", "0", "32", "CSKY::NumTargetFixupKinds", "\"Not all fixup kinds added to Infos array\"", "\"Invalid kind!\""], "File": "CSKYAsmBackend3", "Func": "getFixupKindInfo", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17139, "Length": 195} {"ground_truth": ["", "void", "CSKYAsmBackend", "::", "relaxInstruction", "(", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "MCInst", "Res", ";", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "LLVM_DEBUG", "(", "Inst", ".", "dump", "(", ")", ")", ";", "llvm_unreachable", "(", "\"Opcode not expected!\"", ")", ";", "case", "CSKY", "::", "LRW16", ":", "Res", ".", "setOpcode", "(", "CSKY", "::", "LRW32", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "0", ")", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "1", ")", ")", ";", "break", ";", "case", "CSKY", "::", "BR16", ":", "Res", ".", "setOpcode", "(", "CSKY", "::", "BR32", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "0", ")", ")", ";", "break", ";", "case", "CSKY", "::", "JBSR32", ":", "Res", ".", "setOpcode", "(", "CSKY", "::", "JSRI32", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "1", ")", ")", ";", "break", ";", "case", "CSKY", "::", "JBR32", ":", "Res", ".", "setOpcode", "(", "CSKY", "::", "JMPI32", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "1", ")", ")", ";", "break", ";", "case", "CSKY", "::", "JBT32", ":", "case", "CSKY", "::", "JBF32", ":", "Res", ".", "setOpcode", "(", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "JBT32", "?", "CSKY", "::", "JBT_E", ":", "CSKY", "::", "JBF_E", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "0", ")", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "1", ")", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "2", ")", ")", ";", "break", ";", "case", "CSKY", "::", "JBR16", ":", "Res", ".", "setOpcode", "(", "CSKY", "::", "JBR32", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "0", ")", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "1", ")", ")", ";", "break", ";", "case", "CSKY", "::", "JBT16", ":", "case", "CSKY", "::", "JBF16", ":", "unsigned", "opcode", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "CSKY", "::", "HasE2", "]", ")", "opcode", "=", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "JBT16", "?", "CSKY", "::", "JBT32", ":", "CSKY", "::", "JBF32", ";", "else", "opcode", "=", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "JBT16", "?", "CSKY", "::", "JBT_E", ":", "CSKY", "::", "JBF_E", ";", "Res", ".", "setOpcode", "(", "opcode", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "0", ")", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "1", ")", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "2", ")", ")", ";", "break", ";", "}", "Inst", "=", "std", "::", "move", "(", "Res", ")", ";", "}", ""], "natrual_language": ["Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "."], "TS_V_token": ["CSKY", "CSKY", "\"Opcode not expected!\"", "CSKY::LRW16", "CSKY::LRW32", "0", "1", "CSKY::BR16", "CSKY::BR32", "0", "CSKY::JBSR32", "CSKY::JSRI32", "1", "CSKY::JBR32", "CSKY::JMPI32", "1", "CSKY::JBT32", "CSKY::JBF32", "CSKY::JBT32", "CSKY::JBT_E", "CSKY::JBF_E", "0", "1", "2", "CSKY::JBR16", "CSKY::JBR32", "0", "1", "CSKY::JBT16", "CSKY::JBF16", "CSKY::HasE2", "CSKY::JBT16", "CSKY::JBT32", "CSKY::JBF32", "CSKY::JBT16", "CSKY::JBT_E", "CSKY::JBF_E", "0", "1", "2"], "File": "CSKYAsmBackend4", "Func": "relaxInstruction", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17140, "Length": 402} {"ground_truth": ["", "void", "CSKYAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "if", "(", "Kind", ">=", "FirstLiteralRelocationKind", ")", "return", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Kind", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ",", "Ctx", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "alignTo", "(", "Info", ".", "TargetSize", "+", "Info", ".", "TargetOffset", ",", "8", ")", "/", "8", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "bool", "IsLittleEndian", "=", "(", "Endian", "==", "support", "::", "little", ")", ";", "bool", "IsInstFixup", "=", "(", "Kind", ">=", "FirstTargetFixupKind", ")", ";", "if", "(", "IsLittleEndian", "&&", "IsInstFixup", "&&", "(", "NumBytes", "==", "4", ")", ")", "{", "Data", "[", "Offset", "+", "0", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "16", ")", "&", "0xff", ")", ";", "Data", "[", "Offset", "+", "1", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "24", ")", "&", "0xff", ")", ";", "Data", "[", "Offset", "+", "2", "]", "|=", "uint8_t", "(", "Value", "&", "0xff", ")", ";", "Data", "[", "Offset", "+", "3", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "8", ")", "&", "0xff", ")", ";", "}", "else", "{", "for", "(", "unsigned", "I", "=", "0", ";", "I", "!=", "NumBytes", ";", "I", "++", ")", "{", "unsigned", "Idx", "=", "IsLittleEndian", "?", "I", ":", "(", "NumBytes", "-", "1", "-", "I", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "I", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "}", ""], "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": ["CSKY", "CSKY", "8", "8", "\"Invalid fixup offset!\"", "support::little", "4", "0", "16", "0xff", "1", "24", "0xff", "2", "0xff", "3", "8", "0xff", "0", "1", "8", "0xff"], "File": "CSKYAsmBackend", "Func": "applyFixup", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17141, "Length": 299} {"ground_truth": ["", "bool", "CSKYAsmBackend", "::", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "{", "return", "false", ";", "}", ""], "natrual_language": ["Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYAsmBackend", "Func": "fixupNeedsRelaxation", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17142, "Length": 29} {"ground_truth": ["", "bool", "CSKYAsmBackend", "::", "fixupNeedsRelaxationAdvanced", "(", "const", "MCFixup", "&", "Fixup", ",", "bool", "Resolved", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ",", "const", "bool", "WasForced", ")", "const", "{", "if", "(", "!", "Resolved", "&&", "!", "WasForced", ")", "return", "true", ";", "int64_t", "Offset", "=", "int64_t", "(", "Value", ")", ";", "switch", "(", "Fixup", ".", "getTargetKind", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "CSKY", "::", "fixup_csky_pcrel_imm10_scale2", ":", "return", "!", "isShiftedInt", "<", "10", ",", "1", ">", "(", "Offset", ")", ";", "case", "CSKY", "::", "fixup_csky_pcrel_imm16_scale2", ":", "return", "!", "isShiftedInt", "<", "16", ",", "1", ">", "(", "Offset", ")", ";", "case", "CSKY", "::", "fixup_csky_pcrel_imm26_scale2", ":", "return", "!", "isShiftedInt", "<", "26", ",", "1", ">", "(", "Offset", ")", ";", "case", "CSKY", "::", "fixup_csky_pcrel_uimm7_scale4", ":", "return", "!", "isShiftedUInt", "<", "8", ",", "2", ">", "(", "Offset", ")", ";", "}", "}", ""], "natrual_language": ["Target", "specific", "predicate", "for", "whether", "a", "given", "fixup", "requires", "the", "associated", "instruction", "to", "be", "relaxed", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY::fixup_csky_pcrel_imm10_scale2", "10", "1", "CSKY::fixup_csky_pcrel_imm16_scale2", "16", "1", "CSKY::fixup_csky_pcrel_imm26_scale2", "26", "1", "CSKY::fixup_csky_pcrel_uimm7_scale4", "8", "2"], "File": "CSKYAsmBackend", "Func": "fixupNeedsRelaxationAdvanced", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17143, "Length": 135} {"ground_truth": ["", "const", "MCFixupKindInfo", "&", "CSKYAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "static", "llvm", "::", "DenseMap", "<", "unsigned", ",", "MCFixupKindInfo", ">", "Infos", "=", "{", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_addr32", ",", "{", "\"fixup_csky_addr32\"", ",", "0", ",", "32", ",", "0", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_addr_hi16", ",", "{", "\"fixup_csky_addr_hi16\"", ",", "0", ",", "32", ",", "0", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_addr_lo16", ",", "{", "\"fixup_csky_addr_lo16\"", ",", "0", ",", "32", ",", "0", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_pcrel_imm16_scale2", ",", "{", "\"fixup_csky_pcrel_imm16_scale2\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_pcrel_uimm16_scale4", ",", "{", "\"fixup_csky_pcrel_uimm16_scale4\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_pcrel_uimm8_scale4", ",", "{", "\"fixup_csky_pcrel_uimm8_scale4\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_pcrel_imm26_scale2", ",", "{", "\"fixup_csky_pcrel_imm26_scale2\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_pcrel_imm18_scale2", ",", "{", "\"fixup_csky_pcrel_imm18_scale2\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_got32", ",", "{", "\"fixup_csky_got32\"", ",", "0", ",", "32", ",", "0", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_got_imm18_scale4", ",", "{", "\"fixup_csky_got_imm18_scale4\"", ",", "0", ",", "32", ",", "0", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_gotoff", ",", "{", "\"fixup_csky_gotoff\"", ",", "0", ",", "32", ",", "0", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_gotpc", ",", "{", "\"fixup_csky_gotpc\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_plt32", ",", "{", "\"fixup_csky_plt32\"", ",", "0", ",", "32", ",", "0", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_plt_imm18_scale4", ",", "{", "\"fixup_csky_plt_imm18_scale4\"", ",", "0", ",", "32", ",", "0", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_pcrel_imm10_scale2", ",", "{", "\"fixup_csky_pcrel_imm10_scale2\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_pcrel_uimm7_scale4", ",", "{", "\"fixup_csky_pcrel_uimm7_scale4\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_doffset_imm18", ",", "{", "\"fixup_csky_doffset_imm18\"", ",", "0", ",", "18", ",", "0", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_doffset_imm18_scale2", ",", "{", "\"fixup_csky_doffset_imm18_scale2\"", ",", "0", ",", "18", ",", "0", "}", "}", ",", "{", "CSKY", "::", "Fixups", "::", "fixup_csky_doffset_imm18_scale4", ",", "{", "\"fixup_csky_doffset_imm18_scale4\"", ",", "0", ",", "18", ",", "0", "}", "}", "}", ";", "assert", "(", "Infos", ".", "size", "(", ")", "==", "CSKY", "::", "NumTargetFixupKinds", "&&", "\"Not all fixup kinds added to Infos array\"", ")", ";", "if", "(", "FirstTargetFixupKind", "<=", "Kind", "&&", "Kind", "<", "FirstLiteralRelocationKind", ")", "{", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "]", ";", "}", "else", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "{", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "}", "else", "{", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "FK_NONE", ")", ";", "}", "}", ""], "natrual_language": ["Get", "information", "on", "a", "fixup", "kind", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY::Fixups", "\"fixup_csky_addr32\"", "0", "32", "0", "CSKY::Fixups", "\"fixup_csky_addr_hi16\"", "0", "32", "0", "CSKY::Fixups", "\"fixup_csky_addr_lo16\"", "0", "32", "0", "CSKY::Fixups", "\"fixup_csky_pcrel_imm16_scale2\"", "0", "32", "CSKY::Fixups", "\"fixup_csky_pcrel_uimm16_scale4\"", "0", "32", "CSKY::Fixups", "\"fixup_csky_pcrel_uimm8_scale4\"", "0", "32", "CSKY::Fixups", "\"fixup_csky_pcrel_imm26_scale2\"", "0", "32", "CSKY::Fixups", "\"fixup_csky_pcrel_imm18_scale2\"", "0", "32", "CSKY::Fixups", "\"fixup_csky_got32\"", "0", "32", "0", "CSKY::Fixups", "\"fixup_csky_got_imm18_scale4\"", "0", "32", "0", "CSKY::Fixups", "\"fixup_csky_gotoff\"", "0", "32", "0", "CSKY::Fixups", "\"fixup_csky_gotpc\"", "0", "32", "CSKY::Fixups", "\"fixup_csky_plt32\"", "0", "32", "0", "CSKY::Fixups", "\"fixup_csky_plt_imm18_scale4\"", "0", "32", "0", "CSKY::Fixups", "\"fixup_csky_pcrel_imm10_scale2\"", "0", "16", "CSKY::Fixups", "\"fixup_csky_pcrel_uimm7_scale4\"", "0", "16", "CSKY::Fixups", "\"fixup_csky_doffset_imm18\"", "0", "18", "0", "CSKY::Fixups", "\"fixup_csky_doffset_imm18_scale2\"", "0", "18", "0", "CSKY::Fixups", "\"fixup_csky_doffset_imm18_scale4\"", "0", "18", "0", "CSKY::NumTargetFixupKinds", "\"Not all fixup kinds added to Infos array\"", "\"Invalid kind!\""], "File": "CSKYAsmBackend", "Func": "getFixupKindInfo", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17144, "Length": 473} {"ground_truth": ["", "bool", "CSKYAsmBackend", "::", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "CSKY", "::", "JBR32", ":", "case", "CSKY", "::", "JBT32", ":", "case", "CSKY", "::", "JBF32", ":", "case", "CSKY", "::", "JBSR32", ":", "if", "(", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "CSKY", "::", "Has2E3", "]", ")", "return", "false", ";", "return", "true", ";", "case", "CSKY", "::", "JBR16", ":", "case", "CSKY", "::", "JBT16", ":", "case", "CSKY", "::", "JBF16", ":", "case", "CSKY", "::", "LRW16", ":", "case", "CSKY", "::", "BR16", ":", "return", "true", ";", "}", "}", ""], "natrual_language": ["Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY::JBR32", "CSKY::JBT32", "CSKY::JBF32", "CSKY::JBSR32", "CSKY::Has2E3", "CSKY::JBR16", "CSKY::JBT16", "CSKY::JBF16", "CSKY::LRW16", "CSKY::BR16"], "File": "CSKYAsmBackend", "Func": "mayNeedRelaxation", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17145, "Length": 101} {"ground_truth": ["", "void", "CSKYAsmBackend", "::", "relaxInstruction", "(", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "MCInst", "Res", ";", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "Inst", ".", "dump", "(", ")", ";", "llvm_unreachable", "(", "\"Opcode not expected!\"", ")", ";", "case", "CSKY", "::", "LRW16", ":", "Res", ".", "setOpcode", "(", "CSKY", "::", "LRW32", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "0", ")", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "1", ")", ")", ";", "break", ";", "case", "CSKY", "::", "BR16", ":", "Res", ".", "setOpcode", "(", "CSKY", "::", "BR32", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "0", ")", ")", ";", "break", ";", "case", "CSKY", "::", "JBSR32", ":", "Res", ".", "setOpcode", "(", "CSKY", "::", "JSRI32", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "1", ")", ")", ";", "break", ";", "case", "CSKY", "::", "JBR32", ":", "Res", ".", "setOpcode", "(", "CSKY", "::", "JMPI32", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "1", ")", ")", ";", "break", ";", "case", "CSKY", "::", "JBT32", ":", "case", "CSKY", "::", "JBF32", ":", "Res", ".", "setOpcode", "(", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "JBT32", "?", "CSKY", "::", "JBT_E", ":", "CSKY", "::", "JBF_E", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "0", ")", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "1", ")", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "2", ")", ")", ";", "break", ";", "case", "CSKY", "::", "JBR16", ":", "Res", ".", "setOpcode", "(", "CSKY", "::", "JBR32", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "0", ")", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "1", ")", ")", ";", "break", ";", "case", "CSKY", "::", "JBT16", ":", "case", "CSKY", "::", "JBF16", ":", "unsigned", "opcode", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "CSKY", "::", "HasE2", "]", ")", "opcode", "=", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "JBT16", "?", "CSKY", "::", "JBT32", ":", "CSKY", "::", "JBF32", ";", "else", "opcode", "=", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "JBT16", "?", "CSKY", "::", "JBT_E", ":", "CSKY", "::", "JBF_E", ";", "Res", ".", "setOpcode", "(", "opcode", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "0", ")", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "1", ")", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "2", ")", ")", ";", "break", ";", "}", "Inst", "=", "std", "::", "move", "(", "Res", ")", ";", "}", ""], "natrual_language": ["Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "."], "TS_V_token": ["CSKY", "CSKY", "\"Opcode not expected!\"", "CSKY::LRW16", "CSKY::LRW32", "0", "1", "CSKY::BR16", "CSKY::BR32", "0", "CSKY::JBSR32", "CSKY::JSRI32", "1", "CSKY::JBR32", "CSKY::JMPI32", "1", "CSKY::JBT32", "CSKY::JBF32", "CSKY::JBT32", "CSKY::JBT_E", "CSKY::JBF_E", "0", "1", "2", "CSKY::JBR16", "CSKY::JBR32", "0", "1", "CSKY::JBT16", "CSKY::JBF16", "CSKY::HasE2", "CSKY::JBT16", "CSKY::JBT32", "CSKY::JBF32", "CSKY::JBT16", "CSKY::JBT_E", "CSKY::JBF_E", "0", "1", "2"], "File": "CSKYAsmBackend", "Func": "relaxInstruction", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17146, "Length": 399} {"ground_truth": ["", "bool", "CSKYAsmBackend", "::", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "{", "if", "(", "Fixup", ".", "getKind", "(", ")", ">=", "FirstLiteralRelocationKind", ")", "return", "true", ";", "switch", "(", "Fixup", ".", "getTargetKind", "(", ")", ")", "{", "default", ":", "break", ";", "case", "CSKY", "::", "fixup_csky_got32", ":", "case", "CSKY", "::", "fixup_csky_got_imm18_scale4", ":", "case", "CSKY", "::", "fixup_csky_gotoff", ":", "case", "CSKY", "::", "fixup_csky_gotpc", ":", "case", "CSKY", "::", "fixup_csky_plt32", ":", "case", "CSKY", "::", "fixup_csky_plt_imm18_scale4", ":", "case", "CSKY", "::", "fixup_csky_doffset_imm18", ":", "case", "CSKY", "::", "fixup_csky_doffset_imm18_scale2", ":", "case", "CSKY", "::", "fixup_csky_doffset_imm18_scale4", ":", "return", "true", ";", "}", "return", "false", ";", "}", ""], "natrual_language": ["Hook", "to", "check", "if", "a", "relocation", "is", "needed", "for", "some", "target", "specific", "reason", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY::fixup_csky_got32", "CSKY::fixup_csky_got_imm18_scale4", "CSKY::fixup_csky_gotoff", "CSKY::fixup_csky_gotpc", "CSKY::fixup_csky_plt32", "CSKY::fixup_csky_plt_imm18_scale4", "CSKY::fixup_csky_doffset_imm18", "CSKY::fixup_csky_doffset_imm18_scale2", "CSKY::fixup_csky_doffset_imm18_scale4"], "File": "CSKYAsmBackend", "Func": "shouldForceRelocation", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17147, "Length": 100} {"ground_truth": ["", "bool", "CSKYAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "OS", ".", "write_zeros", "(", "Count", ")", ";", "return", "true", ";", "}", ""], "natrual_language": ["Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYAsmBackend", "Func": "writeNopData", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17148, "Length": 30} {"ground_truth": ["", "bool", "CSKYAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "IDVal", "==", "\".csky_attribute\"", ")", "return", "parseDirectiveAttribute", "(", ")", ";", "return", "true", ";", "}", ""], "natrual_language": ["ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "."], "TS_V_token": ["CSKY", "CSKY", "\".csky_attribute\""], "File": "CSKYAsmParser1", "Func": "ParseDirective", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17149, "Length": 33} {"ground_truth": ["", "unsigned", "CSKYAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "CSKYOperand", "&", "Op", "=", "static_cast", "<", "CSKYOperand", "&", ">", "(", "AsmOp", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "return", "Match_InvalidOperand", ";", "MCRegister", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "if", "(", "CSKYMCRegisterClasses", "[", "CSKY", "::", "FPR32RegClassID", "]", ".", "contains", "(", "Reg", ")", ")", "{", "if", "(", "Kind", "==", "MCK_FPR64", "||", "Kind", "==", "MCK_sFPR64_V", ")", "{", "Op", ".", "Reg", ".", "RegNum", "=", "convertFPR32ToFPR64", "(", "Reg", ")", ";", "if", "(", "Kind", "==", "MCK_sFPR64_V", "&&", "(", "Op", ".", "Reg", ".", "RegNum", "<", "CSKY", "::", "F0_64", "||", "Op", ".", "Reg", ".", "RegNum", ">", "CSKY", "::", "F15_64", ")", ")", "return", "Match_InvalidRegOutOfRange", ";", "if", "(", "Kind", "==", "MCK_FPR64", "&&", "(", "Op", ".", "Reg", ".", "RegNum", "<", "CSKY", "::", "F0_64", "||", "Op", ".", "Reg", ".", "RegNum", ">", "CSKY", "::", "F31_64", ")", ")", "return", "Match_InvalidRegOutOfRange", ";", "return", "Match_Success", ";", "}", "}", "if", "(", "CSKYMCRegisterClasses", "[", "CSKY", "::", "GPRRegClassID", "]", ".", "contains", "(", "Reg", ")", ")", "{", "if", "(", "Kind", "==", "MCK_GPRPair", ")", "{", "Op", ".", "Reg", ".", "RegNum", "=", "MRI", "->", "getEncodingValue", "(", "Reg", ")", "+", "CSKY", "::", "R0_R1", ";", "return", "Match_Success", ";", "}", "}", "return", "Match_InvalidOperand", ";", "}", ""], "natrual_language": ["Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY", "CSKY", "CSKY::FPR32RegClassID", "CSKY::F0_64", "CSKY::F15_64", "CSKY::F0_64", "CSKY::F31_64", "CSKY", "CSKY::GPRRegClassID", "CSKY::R0_R1"], "File": "CSKYAsmParser1", "Func": "validateTargetOperandClass", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17150, "Length": 199} {"ground_truth": ["", "bool", "CSKYAsmParser", "::", "processInstruction", "(", "MCInst", "&", "Inst", ",", "SMLoc", "IDLoc", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ")", "{", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "CSKY", "::", "LDQ32", ":", "case", "CSKY", "::", "STQ32", ":", "if", "(", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "!=", "CSKY", "::", "R4", "||", "Inst", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "!=", "CSKY", "::", "R7", ")", "{", "return", "Error", "(", "IDLoc", ",", "\"Register sequence is not valid. 'r4-r7' expected\"", ")", ";", "}", "Inst", ".", "setOpcode", "(", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "LDQ32", "?", "CSKY", "::", "LDM32", ":", "CSKY", "::", "STM32", ")", ";", "break", ";", "case", "CSKY", "::", "SEXT32", ":", "case", "CSKY", "::", "ZEXT32", ":", "if", "(", "Inst", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "<", "Inst", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"msb must be greater or equal to lsb\"", ")", ";", "break", ";", "case", "CSKY", "::", "INS32", ":", "if", "(", "Inst", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "<", "Inst", ".", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"msb must be greater or equal to lsb\"", ")", ";", "break", ";", "case", "CSKY", "::", "IDLY32", ":", "if", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ">", "32", "||", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", "<", "0", ")", "return", "Error", "(", "IDLoc", ",", "\"n must be in range [0,32]\"", ")", ";", "break", ";", "case", "CSKY", "::", "ADDC32", ":", "case", "CSKY", "::", "SUBC32", ":", "case", "CSKY", "::", "ADDC16", ":", "case", "CSKY", "::", "SUBC16", ":", "Inst", ".", "erase", "(", "std", "::", "next", "(", "Inst", ".", "begin", "(", ")", ")", ")", ";", "Inst", ".", "erase", "(", "std", "::", "prev", "(", "Inst", ".", "end", "(", ")", ")", ")", ";", "Inst", ".", "insert", "(", "std", "::", "next", "(", "Inst", ".", "begin", "(", ")", ")", ",", "MCOperand", "::", "createReg", "(", "CSKY", "::", "C", ")", ")", ";", "Inst", ".", "insert", "(", "Inst", ".", "end", "(", ")", ",", "MCOperand", "::", "createReg", "(", "CSKY", "::", "C", ")", ")", ";", "break", ";", "case", "CSKY", "::", "CMPNEI32", ":", "case", "CSKY", "::", "CMPNEI16", ":", "case", "CSKY", "::", "CMPNE32", ":", "case", "CSKY", "::", "CMPNE16", ":", "case", "CSKY", "::", "CMPHSI32", ":", "case", "CSKY", "::", "CMPHSI16", ":", "case", "CSKY", "::", "CMPHS32", ":", "case", "CSKY", "::", "CMPHS16", ":", "case", "CSKY", "::", "CMPLTI32", ":", "case", "CSKY", "::", "CMPLTI16", ":", "case", "CSKY", "::", "CMPLT32", ":", "case", "CSKY", "::", "CMPLT16", ":", "case", "CSKY", "::", "BTSTI32", ":", "Inst", ".", "erase", "(", "Inst", ".", "begin", "(", ")", ")", ";", "Inst", ".", "insert", "(", "Inst", ".", "begin", "(", ")", ",", "MCOperand", "::", "createReg", "(", "CSKY", "::", "C", ")", ")", ";", "break", ";", "case", "CSKY", "::", "MVCV32", ":", "Inst", ".", "erase", "(", "std", "::", "next", "(", "Inst", ".", "begin", "(", ")", ")", ")", ";", "Inst", ".", "insert", "(", "Inst", ".", "end", "(", ")", ",", "MCOperand", "::", "createReg", "(", "CSKY", "::", "C", ")", ")", ";", "break", ";", "}", "emitToStreamer", "(", "Out", ",", "Inst", ")", ";", "return", "false", ";", "}", ""], "natrual_language": ["Process", "a", "single", "instruction", "and", "collect", "debug", "info", "anchors", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY::LDQ32", "CSKY::STQ32", "1", "CSKY::R4", "2", "CSKY::R7", "\"Register sequence is not valid. 'r4-r7' expected\"", "CSKY::LDQ32", "CSKY::LDM32", "CSKY::STM32", "CSKY::SEXT32", "CSKY::ZEXT32", "2", "3", "\"msb must be greater or equal to lsb\"", "CSKY::INS32", "3", "4", "\"msb must be greater or equal to lsb\"", "CSKY::IDLY32", "0", "32", "0", "0", "\"n must be in range [0,32]\"", "CSKY::ADDC32", "CSKY::SUBC32", "CSKY::ADDC16", "CSKY::SUBC16", "CSKY::C", "CSKY::C", "CSKY::CMPNEI32", "CSKY::CMPNEI16", "CSKY::CMPNE32", "CSKY::CMPNE16", "CSKY::CMPHSI32", "CSKY::CMPHSI16", "CSKY::CMPHS32", "CSKY::CMPHS16", "CSKY::CMPLTI32", "CSKY::CMPLTI16", "CSKY::CMPLT32", "CSKY::CMPLT16", "CSKY::BTSTI32", "CSKY::C", "CSKY::MVCV32", "CSKY::C"], "File": "CSKYAsmParser3", "Func": "processInstruction", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17151, "Length": 489} {"ground_truth": ["", "unsigned", "CSKYAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "CSKYOperand", "&", "Op", "=", "static_cast", "<", "CSKYOperand", "&", ">", "(", "AsmOp", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "return", "Match_InvalidOperand", ";", "MCRegister", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "if", "(", "CSKYMCRegisterClasses", "[", "CSKY", "::", "FPR32RegClassID", "]", ".", "contains", "(", "Reg", ")", ")", "{", "if", "(", "Kind", "==", "MCK_FPR64", "||", "Kind", "==", "MCK_sFPR64", ")", "{", "Op", ".", "Reg", ".", "RegNum", "=", "convertFPR32ToFPR64", "(", "Reg", ")", ";", "if", "(", "Kind", "==", "MCK_sFPR64", "&&", "(", "Op", ".", "Reg", ".", "RegNum", "<", "CSKY", "::", "F0_64", "||", "Op", ".", "Reg", ".", "RegNum", ">", "CSKY", "::", "F15_64", ")", ")", "return", "Match_InvalidRegOutOfRange", ";", "if", "(", "Kind", "==", "MCK_FPR64", "&&", "(", "Op", ".", "Reg", ".", "RegNum", "<", "CSKY", "::", "F0_64", "||", "Op", ".", "Reg", ".", "RegNum", ">", "CSKY", "::", "F31_64", ")", ")", "return", "Match_InvalidRegOutOfRange", ";", "return", "Match_Success", ";", "}", "}", "if", "(", "CSKYMCRegisterClasses", "[", "CSKY", "::", "GPRRegClassID", "]", ".", "contains", "(", "Reg", ")", ")", "{", "if", "(", "Kind", "==", "MCK_GPRPair", ")", "{", "Op", ".", "Reg", ".", "RegNum", "=", "MRI", "->", "getEncodingValue", "(", "Reg", ")", "+", "CSKY", "::", "R0_R1", ";", "return", "Match_Success", ";", "}", "}", "return", "Match_InvalidOperand", ";", "}", ""], "natrual_language": ["Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY", "CSKY", "CSKY::FPR32RegClassID", "CSKY::F0_64", "CSKY::F15_64", "CSKY::F0_64", "CSKY::F31_64", "CSKY", "CSKY::GPRRegClassID", "CSKY::R0_R1"], "File": "CSKYAsmParser4", "Func": "validateTargetOperandClass", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17152, "Length": 199} {"ground_truth": ["", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "switch", "(", "Kind", ")", "{", "case", "Immediate", ":", "OS", "<<", "*", "getImm", "(", ")", ";", "break", ";", "case", "Register", ":", "OS", "<<", "\"\"", ";", "break", ";", "case", "Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "}", "}", ""], "natrual_language": ["print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "."], "TS_V_token": ["CSKY", "\"\"", "\"'\"", "\"'\""], "File": "CSKYAsmParser6", "Func": "print", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17153, "Length": 59} {"ground_truth": ["", "OperandMatchResultTy", "CSKYAsmParser", "::", "tryParseRegister", "(", "unsigned", "&", "RegNo", ",", "SMLoc", "&", "StartLoc", ",", "SMLoc", "&", "EndLoc", ")", "{", "const", "AsmToken", "&", "Tok", "=", "getParser", "(", ")", ".", "getTok", "(", ")", ";", "StartLoc", "=", "Tok", ".", "getLoc", "(", ")", ";", "EndLoc", "=", "Tok", ".", "getEndLoc", "(", ")", ";", "StringRef", "Name", "=", "getLexer", "(", ")", ".", "getTok", "(", ")", ".", "getIdentifier", "(", ")", ";", "if", "(", "matchRegisterNameHelper", "(", "(", "MCRegister", "&", ")", "RegNo", ",", "Name", ")", ")", "return", "MatchOperand_NoMatch", ";", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "MatchOperand_Success", ";", "}", ""], "natrual_language": ["tryParseRegister", "-", "parse", "one", "register", "if", "possible"], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYAsmParser6", "Func": "tryParseRegister", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17154, "Length": 90} {"ground_truth": ["", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "assert", "(", "Expr", "&&", "\"Expr shouldn't be null!\"", ")", ";", "if", "(", "auto", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Expr", ")", ")", ";", "}", ""], "natrual_language": ["Add", "a", "new", "MCExpr", "operand", "."], "TS_V_token": ["CSKY", "\"Expr shouldn't be null!\""], "File": "CSKYAsmParser", "Func": "addExpr", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17155, "Length": 65} {"ground_truth": ["", "SMLoc", "getEndLoc", "(", ")", "const", "override", "{", "return", "EndLoc", ";", "}", ""], "natrual_language": ["getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "."], "TS_V_token": ["CSKY"], "File": "CSKYAsmParser", "Func": "getEndLoc", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17156, "Length": 11} {"ground_truth": ["", "SMLoc", "getLoc", "(", ")", "const", "{", "return", "getParser", "(", ")", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "}", ""], "natrual_language": ["Get", "the", "source", "location", "of", "the", "point", "where", "the", "field", "was", "defined", "."], "TS_V_token": ["CSKY"], "File": "CSKYAsmParser", "Func": "getLoc", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17157, "Length": 20} {"ground_truth": ["", "unsigned", "getReg", "(", ")", "const", "override", "{", "assert", "(", "Kind", "==", "Register", "&&", "\"Invalid type access!\"", ")", ";", "return", "Reg", ".", "RegNum", ";", "}", ""], "natrual_language": ["Returns", "the", "register", "associated", "with", "this", "edge", "."], "TS_V_token": ["CSKY", "\"Invalid type access!\""], "File": "CSKYAsmParser", "Func": "getReg", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17158, "Length": 22} {"ground_truth": ["", "SMLoc", "getStartLoc", "(", ")", "const", "override", "{", "return", "StartLoc", ";", "}", ""], "natrual_language": ["getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "."], "TS_V_token": ["CSKY"], "File": "CSKYAsmParser", "Func": "getStartLoc", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17159, "Length": 11} {"ground_truth": ["", "bool", "isImm", "(", ")", "const", "override", "{", "return", "Kind", "==", "Immediate", ";", "}", ""], "natrual_language": ["isImm", "-", "Is", "this", "an", "immediate", "operand", "?"], "TS_V_token": ["CSKY"], "File": "CSKYAsmParser", "Func": "isImm", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17160, "Length": 13} {"ground_truth": ["", "bool", "isMem", "(", ")", "const", "override", "{", "return", "false", ";", "}", ""], "natrual_language": ["isMem", "-", "Is", "this", "a", "memory", "operand", "?"], "TS_V_token": ["CSKY"], "File": "CSKYAsmParser", "Func": "isMem", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17161, "Length": 11} {"ground_truth": ["", "bool", "isReg", "(", ")", "const", "override", "{", "return", "Kind", "==", "Register", ";", "}", ""], "natrual_language": ["isReg", "-", "Is", "this", "a", "register", "operand", "?"], "TS_V_token": ["CSKY"], "File": "CSKYAsmParser", "Func": "isReg", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17162, "Length": 13} {"ground_truth": ["", "bool", "isToken", "(", ")", "const", "override", "{", "return", "Kind", "==", "Token", ";", "}", ""], "natrual_language": ["isToken", "-", "Is", "this", "a", "token", "operand", "?"], "TS_V_token": ["CSKY"], "File": "CSKYAsmParser", "Func": "isToken", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17163, "Length": 13} {"ground_truth": ["", "bool", "CSKYAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "return", "true", ";", "}", ""], "natrual_language": ["ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYAsmParser", "Func": "ParseDirective", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17164, "Length": 13} {"ground_truth": ["", "bool", "CSKYAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Operands", ".", "push_back", "(", "CSKYOperand", "::", "createToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "return", "true", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "getParser", "(", ")", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", ""], "natrual_language": ["ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "."], "TS_V_token": ["CSKY", "CSKY", "CSKYOperand::createToken", "\"unexpected token\""], "File": "CSKYAsmParser", "Func": "ParseInstruction", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17165, "Length": 151} {"ground_truth": ["", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "auto", "RegName", "=", "[", "]", "(", "unsigned", "Reg", ")", "{", "if", "(", "Reg", ")", "return", "CSKYInstPrinter", "::", "getRegisterName", "(", "Reg", ")", ";", "else", "return", "\"noreg\"", ";", "}", ";", "switch", "(", "Kind", ")", "{", "case", "CPOP", ":", "OS", "<<", "*", "getConstpoolOp", "(", ")", ";", "break", ";", "case", "Immediate", ":", "OS", "<<", "*", "getImm", "(", ")", ";", "break", ";", "case", "KindTy", "::", "Register", ":", "OS", "<<", "\"\"", ";", "break", ";", "case", "RegisterSeq", ":", "OS", "<<", "\"\"", ";", "break", ";", "case", "RegisterList", ":", "OS", "<<", "\""], "natrual_language": ["print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "."], "TS_V_token": ["CSKY", "CSKY", "\"noreg\"", "\"\"", "\"\"", "\"", "bool", "CSKYAsmParser", "::", "processInstruction", "(", "MCInst", "&", "Inst", ",", "SMLoc", "IDLoc", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ")", "{", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "LDQ32", "||", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "STQ32", ")", "{", "if", "(", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "!=", "CSKY", "::", "R4", "||", "Inst", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "!=", "CSKY", "::", "R7", ")", "{", "return", "Error", "(", "IDLoc", ",", "\"Register sequence is not valid. 'r4-r7' expected\"", ")", ";", "}", "Inst", ".", "setOpcode", "(", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "LDQ32", "?", "CSKY", "::", "LDM32", ":", "CSKY", "::", "STM32", ")", ";", "Out", ".", "emitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "}", "else", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "SEXT32", "||", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "ZEXT32", ")", "{", "if", "(", "Inst", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "<", "Inst", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"msb must be greater or equal to lsb\"", ")", ";", "}", "else", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "INS32", ")", "{", "if", "(", "Inst", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "<", "Inst", ".", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"msb must be greater or equal to lsb\"", ")", ";", "}", "else", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "IDLY32", ")", "{", "if", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ">", "32", "||", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", "<", "0", ")", "return", "Error", "(", "IDLoc", ",", "\"n must be in range [0,32]\"", ")", ";", "}", "Out", ".", "emitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "}", ""], "natrual_language": ["Process", "a", "single", "instruction", "and", "collect", "debug", "info", "anchors", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY::LDQ32", "CSKY::STQ32", "1", "CSKY::R4", "2", "CSKY::R7", "\"Register sequence is not valid. 'r4-r7' expected\"", "CSKY::LDQ32", "CSKY::LDM32", "CSKY::STM32", "CSKY::SEXT32", "CSKY::ZEXT32", "2", "3", "\"msb must be greater or equal to lsb\"", "CSKY::INS32", "3", "4", "\"msb must be greater or equal to lsb\"", "CSKY::IDLY32", "0", "32", "0", "0", "\"n must be in range [0,32]\""], "File": "CSKYAsmParser", "Func": "processInstruction", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17167, "Length": 294} {"ground_truth": ["", "OperandMatchResultTy", "CSKYAsmParser", "::", "tryParseRegister", "(", "unsigned", "&", "RegNo", ",", "SMLoc", "&", "StartLoc", ",", "SMLoc", "&", "EndLoc", ")", "{", "const", "AsmToken", "&", "Tok", "=", "getParser", "(", ")", ".", "getTok", "(", ")", ";", "StartLoc", "=", "Tok", ".", "getLoc", "(", ")", ";", "EndLoc", "=", "Tok", ".", "getEndLoc", "(", ")", ";", "StringRef", "Name", "=", "getLexer", "(", ")", ".", "getTok", "(", ")", ".", "getIdentifier", "(", ")", ";", "if", "(", "matchRegisterNameHelper", "(", "getSTI", "(", ")", ",", "(", "MCRegister", "&", ")", "RegNo", ",", "Name", ")", ")", "return", "MatchOperand_NoMatch", ";", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "MatchOperand_Success", ";", "}", ""], "natrual_language": ["tryParseRegister", "-", "parse", "one", "register", "if", "possible"], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYAsmParser", "Func": "tryParseRegister", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17168, "Length": 94} {"ground_truth": ["", "void", "CSKYAsmPrinter", "::", "emitEndOfAsmFile", "(", "Module", "&", "M", ")", "{", "CSKYTargetStreamer", "&", "CTS", "=", "static_cast", "<", "CSKYTargetStreamer", "&", ">", "(", "*", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", ")", "CTS", ".", "finishAttributeSection", "(", ")", ";", "}", ""], "natrual_language": ["This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "end", "of", "their", "file", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY"], "File": "CSKYAsmPrinter1", "Func": "emitEndOfAsmFile", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17169, "Length": 47} {"ground_truth": ["", "void", "CSKYAsmPrinter", "::", "emitFunctionBodyEnd", "(", ")", "{", "if", "(", "!", "InConstantPool", ")", "return", ";", "InConstantPool", "=", "false", ";", "}", ""], "natrual_language": ["Targets", "can", "override", "this", "to", "emit", "stuff", "after", "the", "last", "basic", "block", "in", "the", "function", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYAsmPrinter1", "Func": "emitFunctionBodyEnd", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17170, "Length": 19} {"ground_truth": ["", "void", "CSKYAsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "MI", ")", ")", "return", ";", "if", "(", "InConstantPool", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "CSKY", "::", "CONSTPOOL_ENTRY", ")", "{", "InConstantPool", "=", "false", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "CSKY", "::", "PseudoTLSLA32", ")", "return", "expandTLSLA", "(", "MI", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "CSKY", "::", "CONSTPOOL_ENTRY", ")", "return", "emitCustomConstantPool", "(", "MI", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", ""], "natrual_language": ["Targets", "should", "implement", "this", "to", "emit", "instructions", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY::CONSTPOOL_ENTRY", "CSKY::PseudoTLSLA32", "CSKY::CONSTPOOL_ENTRY"], "File": "CSKYAsmPrinter1", "Func": "emitInstruction", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17171, "Length": 100} {"ground_truth": ["", "void", "CSKYAsmPrinter", "::", "emitMachineConstantPoolValue", "(", "MachineConstantPoolValue", "*", "MCPV", ")", "{", "int", "Size", "=", "getDataLayout", "(", ")", ".", "getTypeAllocSize", "(", "MCPV", "->", "getType", "(", ")", ")", ";", "CSKYConstantPoolValue", "*", "CCPV", "=", "static_cast", "<", "CSKYConstantPoolValue", "*", ">", "(", "MCPV", ")", ";", "MCSymbol", "*", "MCSym", ";", "if", "(", "CCPV", "->", "isBlockAddress", "(", ")", ")", "{", "const", "BlockAddress", "*", "BA", "=", "cast", "<", "CSKYConstantPoolConstant", ">", "(", "CCPV", ")", "->", "getBlockAddress", "(", ")", ";", "MCSym", "=", "GetBlockAddressSymbol", "(", "BA", ")", ";", "}", "else", "if", "(", "CCPV", "->", "isGlobalValue", "(", ")", ")", "{", "const", "GlobalValue", "*", "GV", "=", "cast", "<", "CSKYConstantPoolConstant", ">", "(", "CCPV", ")", "->", "getGV", "(", ")", ";", "MCSym", "=", "getSymbol", "(", "GV", ")", ";", "}", "else", "if", "(", "CCPV", "->", "isMachineBasicBlock", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "cast", "<", "CSKYConstantPoolMBB", ">", "(", "CCPV", ")", "->", "getMBB", "(", ")", ";", "MCSym", "=", "MBB", "->", "getSymbol", "(", ")", ";", "}", "else", "if", "(", "CCPV", "->", "isJT", "(", ")", ")", "{", "signed", "JTI", "=", "cast", "<", "CSKYConstantPoolJT", ">", "(", "CCPV", ")", "->", "getJTI", "(", ")", ";", "MCSym", "=", "GetJTISymbol", "(", "JTI", ")", ";", "}", "else", "{", "assert", "(", "CCPV", "->", "isExtSymbol", "(", ")", "&&", "\"unrecognized constant pool value\"", ")", ";", "StringRef", "Sym", "=", "cast", "<", "CSKYConstantPoolSymbol", ">", "(", "CCPV", ")", "->", "getSymbol", "(", ")", ";", "MCSym", "=", "GetExternalSymbolSymbol", "(", "Sym", ")", ";", "}", "const", "MCExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "create", "(", "MCSym", ",", "MCSymbolRefExpr", "::", "VK_None", ",", "OutContext", ")", ";", "if", "(", "CCPV", "->", "getPCAdjustment", "(", ")", ")", "{", "MCSymbol", "*", "PCLabel", "=", "OutContext", ".", "getOrCreateSymbol", "(", "Twine", "(", "MAI", "->", "getPrivateGlobalPrefix", "(", ")", ")", "+", "\"PC\"", "+", "Twine", "(", "getFunctionNumber", "(", ")", ")", "+", "\"_\"", "+", "Twine", "(", "CCPV", "->", "getLabelID", "(", ")", ")", ")", ";", "const", "MCExpr", "*", "PCRelExpr", "=", "MCSymbolRefExpr", "::", "create", "(", "PCLabel", ",", "OutContext", ")", ";", "if", "(", "CCPV", "->", "mustAddCurrentAddress", "(", ")", ")", "{", "MCSymbol", "*", "DotSym", "=", "OutContext", ".", "createTempSymbol", "(", ")", ";", "OutStreamer", "->", "emitLabel", "(", "DotSym", ")", ";", "const", "MCExpr", "*", "DotExpr", "=", "MCSymbolRefExpr", "::", "create", "(", "DotSym", ",", "OutContext", ")", ";", "PCRelExpr", "=", "MCBinaryExpr", "::", "createSub", "(", "PCRelExpr", ",", "DotExpr", ",", "OutContext", ")", ";", "}", "Expr", "=", "MCBinaryExpr", "::", "createSub", "(", "Expr", ",", "PCRelExpr", ",", "OutContext", ")", ";", "}", "Expr", "=", "CSKYMCExpr", "::", "create", "(", "Expr", ",", "getModifierVariantKind", "(", "CCPV", "->", "getModifier", "(", ")", ")", ",", "OutContext", ")", ";", "OutStreamer", "->", "emitValue", "(", "Expr", ",", "Size", ")", ";", "}", ""], "natrual_language": ["EmitMachineConstantPoolValue", "-", "Print", "a", "machine", "constantpool", "value", "to", "the", ".s", "file", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY", "CSKY", "CSKY", "CSKY", "CSKY", "\"unrecognized constant pool value\"", "CSKY", "\"PC\"", "\"_\"", "CSKY"], "File": "CSKYAsmPrinter1", "Func": "emitMachineConstantPoolValue", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17172, "Length": 394} {"ground_truth": ["", "void", "CSKYAsmPrinter", "::", "emitStartOfAsmFile", "(", "Module", "&", "M", ")", "{", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", ")", "emitAttributes", "(", ")", ";", "}", ""], "natrual_language": ["This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "start", "of", "their", "file", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYAsmPrinter1", "Func": "emitStartOfAsmFile", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17173, "Length": 27} {"ground_truth": ["", "bool", "CSKYAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "!", "ExtraCode", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "return", "true", ";", "OS", "<<", "\"(\"", "<<", "CSKYInstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "\", 0)\"", ";", "return", "false", ";", "}", "return", "AsmPrinter", "::", "PrintAsmMemoryOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "OS", ")", ";", "}", ""], "natrual_language": ["Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "."], "TS_V_token": ["CSKY", "CSKY", "\"(\"", "CSKY", "\", 0)\""], "File": "CSKYAsmPrinter1", "Func": "PrintAsmMemoryOperand", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17174, "Length": 89} {"ground_truth": ["", "bool", "CSKYAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "!", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "OS", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'R'", ":", "if", "(", "MO", ".", "getType", "(", ")", "==", "MachineOperand", "::", "MO_Register", ")", "{", "OS", "<<", "CSKYInstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", "+", "1", ")", ";", "return", "false", ";", "}", "}", "}", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "case", "MachineOperand", "::", "MO_Immediate", ":", "OS", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "getReg", "(", ")", "==", "CSKY", "::", "C", ")", "return", "false", ";", "OS", "<<", "CSKYInstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "PrintSymbolOperand", "(", "MO", ",", "OS", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "{", "MCSymbol", "*", "Sym", "=", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ";", "Sym", "->", "print", "(", "OS", ",", "MAI", ")", ";", "return", "false", ";", "}", "default", ":", "break", ";", "}", "return", "true", ";", "}", ""], "natrual_language": ["PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "."], "TS_V_token": ["CSKY", "CSKY", "0", "1", "0", "0", "CSKY", "1", "CSKY::C", "CSKY"], "File": "CSKYAsmPrinter1", "Func": "PrintAsmOperand", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17175, "Length": 243} {"ground_truth": ["", "bool", "CSKYAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MCP", "=", "MF", ".", "getConstantPool", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MCSubtargetInfo", "&", "NewSTI", "=", "OutStreamer", "->", "getContext", "(", ")", ".", "getSubtargetCopy", "(", "*", "TM", ".", "getMCSubtargetInfo", "(", ")", ")", ";", "NewSTI", ".", "setFeatureBits", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getFeatureBits", "(", ")", ")", ";", "Subtarget", "=", "&", "NewSTI", ";", "return", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", ""], "natrual_language": ["runOnMachineFunction", "-", "Emit", "the", "function", "body", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYAsmPrinter1", "Func": "runOnMachineFunction", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17176, "Length": 79} {"ground_truth": ["", "bool", "CSKYAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MCP", "=", "MF", ".", "getConstantPool", "(", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "CSKYSubtarget", ">", "(", ")", ";", "return", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", ""], "natrual_language": ["runOnMachineFunction", "-", "Emit", "the", "function", "body", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY"], "File": "CSKYAsmPrinter2", "Func": "runOnMachineFunction", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17177, "Length": 39} {"ground_truth": ["", "void", "CSKYAsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "MI", ")", ")", "return", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", ""], "natrual_language": ["Targets", "should", "implement", "this", "to", "emit", "instructions", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYAsmPrinter", "Func": "emitInstruction", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17178, "Length": 44} {"ground_truth": ["", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"CSKY Assembly Printer\"", ";", "}", ""], "natrual_language": ["getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "."], "TS_V_token": ["CSKY", "\"CSKY Assembly Printer\""], "File": "CSKYAsmPrinter", "Func": "getPassName", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17179, "Length": 11} {"ground_truth": ["", "bool", "CSKYAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "CSKYSubtarget", ">", "(", ")", ";", "return", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", ""], "natrual_language": ["runOnMachineFunction", "-", "Emit", "the", "function", "body", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY"], "File": "CSKYAsmPrinter", "Func": "runOnMachineFunction", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17180, "Length": 31} {"ground_truth": ["", "bool", "CSKYConstantIslands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Mf", ")", "{", "MF", "=", "&", "Mf", ";", "MCP", "=", "Mf", ".", "getConstantPool", "(", ")", ";", "STI", "=", "&", "Mf", ".", "getSubtarget", "<", "CSKYSubtarget", ">", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** CSKYConstantIslands: \"", "<<", "MCP", "->", "getConstants", "(", ")", ".", "size", "(", ")", "<<", "\" CP entries, aligned to \"", "<<", "MCP", "->", "getConstantPoolAlign", "(", ")", ".", "value", "(", ")", "<<", "\" bytes *****\\n\"", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "MFI", "=", "MF", "->", "getInfo", "<", "CSKYMachineFunctionInfo", ">", "(", ")", ";", "MF", "->", "getRegInfo", "(", ")", ".", "invalidateLiveness", "(", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "std", "::", "vector", "<", "MachineInstr", "*", ">", "CPEMIs", ";", "if", "(", "!", "MCP", "->", "isEmpty", "(", ")", ")", "doInitialPlacement", "(", "CPEMIs", ")", ";", "initPICLabelUId", "(", "CPEMIs", ".", "size", "(", ")", ")", ";", "initializeFunctionInfo", "(", "CPEMIs", ")", ";", "CPEMIs", ".", "clear", "(", ")", ";", "LLVM_DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "MadeChange", "|=", "removeUnusedCPEntries", "(", ")", ";", "unsigned", "NoCPIters", "=", "0", ",", "NoBRIters", "=", "0", ";", "(", "void", ")", "NoBRIters", ";", "while", "(", "true", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Beginning CP iteration #\"", "<<", "NoCPIters", "<<", "'\\n'", ")", ";", "bool", "CPChange", "=", "false", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "CPUsers", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "CPChange", "|=", "handleConstantPoolUser", "(", "I", ")", ";", "if", "(", "CPChange", "&&", "++", "NoCPIters", ">", "30", ")", "report_fatal_error", "(", "\"Constant Island pass failed to converge!\"", ")", ";", "LLVM_DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "NewWaterList", ".", "clear", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Beginning BR iteration #\"", "<<", "NoBRIters", "<<", "'\\n'", ")", ";", "bool", "BRChange", "=", "false", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "ImmBranches", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "BRChange", "|=", "fixupImmediateBr", "(", "ImmBranches", "[", "I", "]", ")", ";", "if", "(", "BRChange", "&&", "++", "NoBRIters", ">", "30", ")", "report_fatal_error", "(", "\"Branch Fix Up pass failed to converge!\"", ")", ";", "LLVM_DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "if", "(", "!", "CPChange", "&&", "!", "BRChange", ")", "break", ";", "MadeChange", "=", "true", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "'\\n'", ";", "dumpBBs", "(", ")", ")", ";", "BBInfo", ".", "clear", "(", ")", ";", "WaterList", ".", "clear", "(", ")", ";", "CPUsers", ".", "clear", "(", ")", ";", "CPEntries", ".", "clear", "(", ")", ";", "ImmBranches", ".", "clear", "(", ")", ";", "return", "MadeChange", ";", "}", ""], "natrual_language": ["runOnMachineFunction", "-", "Emit", "the", "function", "body", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "\"***** CSKYConstantIslands: \"", "\" CP entries, aligned to \"", "\" bytes *****\\n\"", "CSKY", "0", "0", "\"Beginning CP iteration #\"", "0", "30", "\"Constant Island pass failed to converge!\"", "\"Beginning BR iteration #\"", "0", "30", "\"Branch Fix Up pass failed to converge!\""], "File": "CSKYConstantIslandPass2", "Func": "runOnMachineFunction", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17181, "Length": 390} {"ground_truth": ["", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", ""], "natrual_language": ["getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "."], "TS_V_token": ["CSKY"], "File": "CSKYConstantIslandPass", "Func": "getAnalysisUsage", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17182, "Length": 27} {"ground_truth": ["", "unsigned", "CSKYConstantIslands", "::", "getOffsetOf", "(", "MachineInstr", "*", "MI", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "unsigned", "Offset", "=", "BBInfo", "[", "MBB", "->", "getNumber", "(", ")", "]", ".", "Offset", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", "->", "begin", "(", ")", ";", "&", "*", "I", "!=", "MI", ";", "++", "I", ")", "{", "assert", "(", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "\"Didn't find MI in its own basic block?\"", ")", ";", "Offset", "+=", "TII", "->", "getInstSizeInBytes", "(", "*", "I", ")", ";", "}", "return", "Offset", ";", "}", ""], "natrual_language": ["getOffsetOf", "-", "Return", "the", "current", "offset", "of", "the", "specified", "machine", "instruction", "from", "the", "start", "of", "the", "function", "."], "TS_V_token": ["CSKY", "CSKY", "\"Didn't find MI in its own basic block?\""], "File": "CSKYConstantIslandPass", "Func": "getOffsetOf", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17183, "Length": 86} {"ground_truth": ["", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"CSKY Constant Islands\"", ";", "}", ""], "natrual_language": ["getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "."], "TS_V_token": ["CSKY", "\"CSKY Constant Islands\""], "File": "CSKYConstantIslandPass", "Func": "getPassName", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17184, "Length": 11} {"ground_truth": ["", "bool", "CSKYConstantIslands", "::", "isBBInRange", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "DestBB", ",", "unsigned", "MaxDisp", ")", "{", "unsigned", "BrOffset", "=", "getOffsetOf", "(", "MI", ")", ";", "unsigned", "DestOffset", "=", "BBInfo", "[", "DestBB", "->", "getNumber", "(", ")", "]", ".", "Offset", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Branch of destination \"", "<<", "printMBBReference", "(", "*", "DestBB", ")", "<<", "\" from \"", "<<", "printMBBReference", "(", "*", "MI", "->", "getParent", "(", ")", ")", "<<", "\" max delta=\"", "<<", "MaxDisp", "<<", "\" from \"", "<<", "getOffsetOf", "(", "MI", ")", "<<", "\" to \"", "<<", "DestOffset", "<<", "\" offset \"", "<<", "int", "(", "DestOffset", "-", "BrOffset", ")", "<<", "\"\\t\"", "<<", "*", "MI", ")", ";", "if", "(", "BrOffset", "<=", "DestOffset", ")", "{", "if", "(", "DestOffset", "-", "BrOffset", "<=", "MaxDisp", ")", "return", "true", ";", "}", "else", "{", "if", "(", "BrOffset", "-", "DestOffset", "<=", "MaxDisp", ")", "return", "true", ";", "}", "return", "false", ";", "}", ""], "natrual_language": ["isBBInRange", "-", "Returns", "true", "if", "the", "distance", "between", "specific", "MI", "and", "specific", "BB", "can", "fit", "in", "MI", "'s", "displacement", "field", "."], "TS_V_token": ["CSKY", "CSKY", "\"Branch of destination \"", "\" from \"", "\" max delta=\"", "\" from \"", "\" to \"", "\" offset \"", "\"\\t\""], "File": "CSKYConstantIslandPass", "Func": "isBBInRange", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17185, "Length": 132} {"ground_truth": ["", "unsigned", "postOffset", "(", ")", "const", "{", "return", "Offset", "+", "Size", ";", "}", ""], "natrual_language": ["Compute", "the", "offset", "immediately", "following", "this", "block", "."], "TS_V_token": ["CSKY"], "File": "CSKYConstantIslandPass", "Func": "postOffset", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17186, "Length": 12} {"ground_truth": ["", "bool", "CSKYConstantIslands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Mf", ")", "{", "MF", "=", "&", "Mf", ";", "MCP", "=", "Mf", ".", "getConstantPool", "(", ")", ";", "STI", "=", "&", "static_cast", "<", "const", "CSKYSubtarget", "&", ">", "(", "Mf", ".", "getSubtarget", "(", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** CSKYConstantIslands: \"", "<<", "MCP", "->", "getConstants", "(", ")", ".", "size", "(", ")", "<<", "\" CP entries, aligned to \"", "<<", "MCP", "->", "getConstantPoolAlign", "(", ")", ".", "value", "(", ")", "<<", "\" bytes *****\\n\"", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "MFI", "=", "MF", "->", "getInfo", "<", "CSKYMachineFunctionInfo", ">", "(", ")", ";", "MF", "->", "getRegInfo", "(", ")", ".", "invalidateLiveness", "(", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "std", "::", "vector", "<", "MachineInstr", "*", ">", "CPEMIs", ";", "if", "(", "!", "MCP", "->", "isEmpty", "(", ")", ")", "doInitialPlacement", "(", "CPEMIs", ")", ";", "initPICLabelUId", "(", "CPEMIs", ".", "size", "(", ")", ")", ";", "initializeFunctionInfo", "(", "CPEMIs", ")", ";", "CPEMIs", ".", "clear", "(", ")", ";", "LLVM_DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "MadeChange", "|=", "removeUnusedCPEntries", "(", ")", ";", "unsigned", "NoCPIters", "=", "0", ",", "NoBRIters", "=", "0", ";", "(", "void", ")", "NoBRIters", ";", "while", "(", "true", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Beginning CP iteration #\"", "<<", "NoCPIters", "<<", "'\\n'", ")", ";", "bool", "CPChange", "=", "false", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "CPUsers", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "CPChange", "|=", "handleConstantPoolUser", "(", "I", ")", ";", "if", "(", "CPChange", "&&", "++", "NoCPIters", ">", "30", ")", "report_fatal_error", "(", "\"Constant Island pass failed to converge!\"", ")", ";", "LLVM_DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "NewWaterList", ".", "clear", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Beginning BR iteration #\"", "<<", "NoBRIters", "<<", "'\\n'", ")", ";", "bool", "BRChange", "=", "false", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "ImmBranches", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "BRChange", "|=", "fixupImmediateBr", "(", "ImmBranches", "[", "I", "]", ")", ";", "if", "(", "BRChange", "&&", "++", "NoBRIters", ">", "30", ")", "report_fatal_error", "(", "\"Branch Fix Up pass failed to converge!\"", ")", ";", "LLVM_DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "if", "(", "!", "CPChange", "&&", "!", "BRChange", ")", "break", ";", "MadeChange", "=", "true", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "'\\n'", ";", "dumpBBs", "(", ")", ")", ";", "BBInfo", ".", "clear", "(", ")", ";", "WaterList", ".", "clear", "(", ")", ";", "CPUsers", ".", "clear", "(", ")", ";", "CPEntries", ".", "clear", "(", ")", ";", "ImmBranches", ".", "clear", "(", ")", ";", "return", "MadeChange", ";", "}", ""], "natrual_language": ["runOnMachineFunction", "-", "Emit", "the", "function", "body", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "\"***** CSKYConstantIslands: \"", "\" CP entries, aligned to \"", "\" bytes *****\\n\"", "CSKY", "0", "0", "\"Beginning CP iteration #\"", "0", "30", "\"Constant Island pass failed to converge!\"", "\"Beginning BR iteration #\"", "0", "30", "\"Branch Fix Up pass failed to converge!\""], "File": "CSKYConstantIslandPass", "Func": "runOnMachineFunction", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17187, "Length": 395} {"ground_truth": ["", "static", "bool", "classof", "(", "const", "CSKYConstantPoolValue", "*", "ACPV", ")", "{", "return", "ACPV", "->", "isJT", "(", ")", ";", "}", ""], "natrual_language": ["Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":"], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYConstantPoolValue", "Func": "classof", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17188, "Length": 18} {"ground_truth": ["", "CSKYConstantPoolJT", "*", "CSKYConstantPoolJT", "::", "Create", "(", "Type", "*", "Ty", ",", "int", "JTI", ",", "unsigned", "PCAdj", ",", "CSKYCP", "::", "CSKYCPModifier", "Modifier", ")", "{", "return", "new", "CSKYConstantPoolJT", "(", "Ty", ",", "JTI", ",", "PCAdj", ",", "Modifier", ",", "false", ")", ";", "}", ""], "natrual_language": ["Construct", "a", "unary", "instruction", ",", "given", "the", "opcode", "and", "an", "operand", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKYCP::CSKYCPModifier", "CSKY"], "File": "CSKYConstantPoolValue", "Func": "Create", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17189, "Length": 38} {"ground_truth": ["", "bool", "equals", "(", "const", "CSKYConstantPoolJT", "*", "A", ")", "const", "{", "return", "JTI", "==", "A", "->", "JTI", "&&", "CSKYConstantPoolValue", "::", "equals", "(", "A", ")", ";", "}", ""], "natrual_language": ["equals", "-", "Check", "for", "string", "equality", ",", "this", "is", "more", "efficient", "than", "compare", "(", ")", "when", "the", "relative", "ordering", "of", "inequal", "strings", "is", "n't", "needed", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY"], "File": "CSKYConstantPoolValue", "Func": "equals", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17190, "Length": 25} {"ground_truth": ["", "const", "MachineBasicBlock", "*", "getMBB", "(", ")", "const", "{", "return", "MBB", ";", "}", ""], "natrual_language": ["Return", "a", "reference", "to", "the", "basic", "block", "containing", "this", "bundle", "."], "TS_V_token": ["CSKY"], "File": "CSKYConstantPoolValue", "Func": "getMBB", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17191, "Length": 12} {"ground_truth": ["", "StringRef", "getSymbol", "(", ")", "const", "{", "return", "S", ";", "}", ""], "natrual_language": ["Get", "the", "target", "address", "and", "flags", "for", "the", "named", "symbol", "."], "TS_V_token": ["CSKY"], "File": "CSKYConstantPoolValue", "Func": "getSymbol", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17192, "Length": 10} {"ground_truth": ["", "bool", "isBlockAddress", "(", ")", "const", "{", "return", "Kind", "==", "CSKYCP", "::", "CPBlockAddress", ";", "}", ""], "natrual_language": ["isBlockAddress", "-", "Tests", "if", "this", "is", "a", "MO_BlockAddress", "operand", "."], "TS_V_token": ["CSKY", "CSKYCP::CPBlockAddress"], "File": "CSKYConstantPoolValue", "Func": "isBlockAddress", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17193, "Length": 14} {"ground_truth": ["", "void", "CSKYConstantPoolJT", "::", "print", "(", "raw_ostream", "&", "O", ")", "const", "{", "O", "<<", "\"JTI#\"", "<<", "JTI", ";", "CSKYConstantPoolValue", "::", "print", "(", "O", ")", ";", "}", ""], "natrual_language": ["print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "."], "TS_V_token": ["CSKY", "CSKY", "\"JTI#\"", "CSKY"], "File": "CSKYConstantPoolValue", "Func": "print", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17194, "Length": 25} {"ground_truth": ["", "DecodeStatus", "CSKYDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CS", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", "=", "MCDisassembler", "::", "Fail", ";", "Insn", "=", "support", "::", "endian", "::", "read16le", "(", "Bytes", ".", "data", "(", ")", ")", ";", "if", "(", "(", "Insn", ">>", "14", ")", "==", "0x3", ")", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Insn", "=", "(", "Insn", "<<", "16", ")", "|", "support", "::", "endian", "::", "read16le", "(", "&", "Bytes", "[", "2", "]", ")", ";", "if", "(", "decodeFPUV3Instruction", "(", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ")", "Result", "=", "MCDisassembler", "::", "Success", ";", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying CSKY 32-bit table :\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable32", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "Size", "=", "4", ";", "}", "else", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "2", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying CSKY 16-bit table :\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable16", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "Size", "=", "2", ";", "}", "handleCROperand", "(", "MI", ")", ";", "return", "Result", ";", "}", ""], "natrual_language": ["Returns", "the", "disassembly", "of", "a", "single", "instruction", "."], "TS_V_token": ["CSKY", "CSKY", "support::endian", "14", "0x3", "4", "0", "16", "support::endian", "2", "\"Trying CSKY 32-bit table :\\n\"", "4", "2", "0", "\"Trying CSKY 16-bit table :\\n\"", "2"], "File": "CSKYDisassembler", "Func": "getInstruction", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17195, "Length": 224} {"ground_truth": ["", "void", "reset", "(", ")", "override", "{", "MappingSymbolCounter", "=", "0", ";", "State", "=", "EMS_None", ";", "MCELFStreamer", "::", "reset", "(", ")", ";", "}", ""], "natrual_language": ["Reset", "an", "existing", "scalar", "value", "for", "Def", "and", "a", "given", "Instance", "."], "TS_V_token": ["CSKY", "0"], "File": "CSKYELFStreamer1", "Func": "reset", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17196, "Length": 21} {"ground_truth": ["", "void", "emitBytes", "(", "StringRef", "Data", ")", "override", "{", "EmitMappingSymbol", "(", "\"$d\"", ")", ";", "MCELFStreamer", "::", "emitBytes", "(", "Data", ")", ";", "}", ""], "natrual_language": ["Emit", "the", "bytes", "in", "Data", "into", "the", "output", "."], "TS_V_token": ["CSKY", "\"$d\""], "File": "CSKYELFStreamer", "Func": "emitBytes", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17197, "Length": 21} {"ground_truth": ["", "void", "emitFill", "(", "const", "MCExpr", "&", "NumBytes", ",", "uint64_t", "FillValue", ",", "SMLoc", "Loc", ")", "override", "{", "EmitMappingSymbol", "(", "\"$d\"", ")", ";", "MCObjectStreamer", "::", "emitFill", "(", "NumBytes", ",", "FillValue", ",", "Loc", ")", ";", "}", ""], "natrual_language": ["Emit", "Size", "bytes", "worth", "of", "the", "value", "specified", "by", "FillValue", "."], "TS_V_token": ["CSKY", "\"$d\""], "File": "CSKYELFStreamer", "Func": "emitFill", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17198, "Length": 33} {"ground_truth": ["", "void", "emitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "override", "{", "EmitMappingSymbol", "(", "\"$t\"", ")", ";", "MCELFStreamer", "::", "emitInstruction", "(", "Inst", ",", "STI", ")", ";", "}", ""], "natrual_language": ["Targets", "should", "implement", "this", "to", "emit", "instructions", "."], "TS_V_token": ["CSKY", "\"$t\""], "File": "CSKYELFStreamer", "Func": "emitInstruction", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17199, "Length": 30} {"ground_truth": ["", "void", "emitValueImpl", "(", "const", "MCExpr", "*", "Value", ",", "unsigned", "Size", ",", "SMLoc", "Loc", ")", "override", "{", "EmitMappingSymbol", "(", "\"$d\"", ")", ";", "MCELFStreamer", "::", "emitValueImpl", "(", "Value", ",", "Size", ",", "Loc", ")", ";", "}", ""], "natrual_language": ["Overriding", "these", "functions", "allows", "us", "to", "dismiss", "all", "labels", "that", "are", "candidates", "for", "marking", "as", "microMIPS", "when", ".word/.long/.4byte", "etc", "directives", "are", "emitted", "."], "TS_V_token": ["CSKY", "\"$d\""], "File": "CSKYELFStreamer", "Func": "emitValueImpl", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17200, "Length": 33} {"ground_truth": ["", "MCELFStreamer", "&", "CSKYTargetELFStreamer", "::", "getStreamer", "(", ")", "{", "return", "static_cast", "<", "MCELFStreamer", "&", ">", "(", "Streamer", ")", ";", "}", ""], "natrual_language": ["Return", "the", "output", "streamer", "for", "the", "assembler", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYELFStreamer", "Func": "getStreamer", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17201, "Length": 19} {"ground_truth": ["", "void", "reset", "(", ")", "{", "MappingSymbolCounter", "=", "0", ";", "State", "=", "EMS_None", ";", "MCELFStreamer", "::", "reset", "(", ")", ";", "}", ""], "natrual_language": ["Reset", "an", "existing", "scalar", "value", "for", "Def", "and", "a", "given", "Instance", "."], "TS_V_token": ["CSKY", "0"], "File": "CSKYELFStreamer", "Func": "reset", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17202, "Length": 20} {"ground_truth": ["", "bool", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "override", "{", "std", "::", "reverse", "(", "CSI", ".", "begin", "(", ")", ",", "CSI", ".", "end", "(", ")", ")", ";", "return", "false", ";", "}", ""], "natrual_language": ["This", "function", "will", "assign", "callee", "saved", "gprs", "to", "volatile", "vector", "registers", "for", "prologue", "spills", "when", "applicable", "."], "TS_V_token": ["CSKY"], "File": "CSKYFrameLowering1", "Func": "assignCalleeSavedSpillSlots", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17203, "Length": 45} {"ground_truth": ["", "void", "CSKYFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "CSKYRegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "uint64_t", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "Align", "StackAlign", "=", "getStackAlign", "(", ")", ";", "if", "(", "RI", "->", "hasStackRealignment", "(", "MF", ")", ")", "{", "Align", "MaxStackAlign", "=", "std", "::", "max", "(", "StackAlign", ",", "MFI", ".", "getMaxAlign", "(", ")", ")", ";", "FrameSize", "+=", "(", "MaxStackAlign", ".", "value", "(", ")", "-", "StackAlign", ".", "value", "(", ")", ")", ";", "StackAlign", "=", "MaxStackAlign", ";", "}", "uint64_t", "MaxCallSize", "=", "alignTo", "(", "MFI", ".", "getMaxCallFrameSize", "(", ")", ",", "StackAlign", ")", ";", "MFI", ".", "setMaxCallFrameSize", "(", "MaxCallSize", ")", ";", "FrameSize", "=", "alignTo", "(", "FrameSize", ",", "StackAlign", ")", ";", "MFI", ".", "setStackSize", "(", "FrameSize", ")", ";", "}", ""], "natrual_language": ["Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY"], "File": "CSKYFrameLowering1", "Func": "determineFrameLayout", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17204, "Length": 133} {"ground_truth": ["", "MachineBasicBlock", "::", "iterator", "CSKYFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "Register", "SPReg", "=", "CSKY", "::", "R14", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "int64_t", "Amount", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "Amount", "=", "alignSPAdjust", "(", "Amount", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "CSKY", "::", "ADJCALLSTACKDOWN", ")", "Amount", "=", "-", "Amount", ";", "adjustReg", "(", "MBB", ",", "MI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "Amount", ",", "MachineInstr", "::", "NoFlags", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", ""], "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": ["CSKY", "CSKY", "CSKY::R14", "0", "0", "CSKY::ADJCALLSTACKDOWN"], "File": "CSKYFrameLowering1", "Func": "eliminateCallFramePseudoInstr", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17205, "Length": 122} {"ground_truth": ["", "void", "CSKYFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "CSKYMachineFunctionInfo", "*", "CFI", "=", "MF", ".", "getInfo", "<", "CSKYMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "Register", "FPReg", "=", "getFPReg", "(", "STI", ")", ";", "Register", "SPReg", "=", "CSKY", "::", "R14", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "end", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "{", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "if", "(", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "!", "MBBI", "->", "isTerminator", "(", ")", ")", "MBBI", "=", "std", "::", "next", "(", "MBBI", ")", ";", "}", "const", "auto", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "uint64_t", "ActualSize", "=", "CFI", "->", "getCalleeSaveAreaSize", "(", ")", "+", "CFI", "->", "getVarArgsSaveSize", "(", ")", ";", "auto", "LastFrameDestroy", "=", "MBBI", ";", "if", "(", "!", "CSI", ".", "empty", "(", ")", ")", "LastFrameDestroy", "=", "std", "::", "prev", "(", "MBBI", ",", "CSI", ".", "size", "(", ")", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "const", "CSKYInstrInfo", "*", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "BuildMI", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "SPReg", ")", ".", "addReg", "(", "FPReg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "NoFlags", ")", ";", "}", "else", "{", "adjustReg", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "(", "StackSize", "-", "ActualSize", ")", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "ActualSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", ""], "natrual_language": ["Insert", "epilog", "code", "into", "the", "function", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY", "CSKY::R14", "CSKY"], "File": "CSKYFrameLowering1", "Func": "emitEpilogue", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17206, "Length": 292} {"ground_truth": ["", "StackOffset", "CSKYFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "const", "CSKYMachineFunctionInfo", "*", "CFI", "=", "MF", ".", "getInfo", "<", "CSKYMachineFunctionInfo", ">", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "auto", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "int", "MinCSFI", "=", "0", ";", "int", "MaxCSFI", "=", "-", "1", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", "+", "MFI", ".", "getOffsetAdjustment", "(", ")", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "MinCSFI", "=", "CSI", "[", "0", "]", ".", "getFrameIdx", "(", ")", ";", "MaxCSFI", "=", "CSI", "[", "CSI", ".", "size", "(", ")", "-", "1", "]", ".", "getFrameIdx", "(", ")", ";", "}", "if", "(", "FI", ">=", "MinCSFI", "&&", "FI", "<=", "MaxCSFI", ")", "{", "FrameReg", "=", "CSKY", "::", "R14", ";", "Offset", "+=", "CFI", "->", "getVarArgsSaveSize", "(", ")", "+", "CFI", "->", "getCalleeSaveAreaSize", "(", ")", ";", "}", "else", "if", "(", "RI", "->", "hasStackRealignment", "(", "MF", ")", ")", "{", "assert", "(", "hasFP", "(", "MF", ")", ")", ";", "if", "(", "!", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", ")", "{", "FrameReg", "=", "hasBP", "(", "MF", ")", "?", "getBPReg", "(", "STI", ")", ":", "CSKY", "::", "R14", ";", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", ";", "}", "else", "{", "FrameReg", "=", "getFPReg", "(", "STI", ")", ";", "Offset", "+=", "CFI", "->", "getVarArgsSaveSize", "(", ")", "+", "CFI", "->", "getCalleeSaveAreaSize", "(", ")", ";", "}", "}", "else", "{", "if", "(", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", "&&", "hasFP", "(", "MF", ")", ")", "{", "FrameReg", "=", "getFPReg", "(", "STI", ")", ";", "Offset", "+=", "CFI", "->", "getVarArgsSaveSize", "(", ")", "+", "CFI", "->", "getCalleeSaveAreaSize", "(", ")", ";", "}", "else", "{", "FrameReg", "=", "hasBP", "(", "MF", ")", "?", "getBPReg", "(", "STI", ")", ":", "CSKY", "::", "R14", ";", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", ";", "}", "}", "return", "StackOffset", "::", "getFixed", "(", "Offset", ")", ";", "}", ""], "natrual_language": ["getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY", "0", "1", "0", "1", "CSKY::R14", "CSKY::R14", "CSKY::R14"], "File": "CSKYFrameLowering1", "Func": "getFrameIndexReference", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17207, "Length": 323} {"ground_truth": ["", "bool", "CSKYFrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", ";", "}", ""], "natrual_language": ["hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYFrameLowering1", "Func": "hasReservedCallFrame", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17208, "Length": 25} {"ground_truth": ["", "bool", "CSKYFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "MutableArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "MI", "->", "isDebugInstr", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "auto", "&", "CS", ":", "reverse", "(", "CSI", ")", ")", "{", "Register", "Reg", "=", "CS", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "CS", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "assert", "(", "MI", "!=", "MBB", ".", "begin", "(", ")", "&&", "\"loadRegFromStackSlot didn't insert any code!\"", ")", ";", "}", "return", "true", ";", "}", ""], "natrual_language": ["restoreCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "restore", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "load", "instructions", "via", "loadRegToStackSlot", "(", ")", "."], "TS_V_token": ["CSKY", "CSKY", "\"loadRegFromStackSlot didn't insert any code!\""], "File": "CSKYFrameLowering1", "Func": "restoreCalleeSavedRegisters", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17209, "Length": 164} {"ground_truth": ["", "bool", "CSKYFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "MI", "->", "isDebugInstr", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "auto", "&", "CS", ":", "CSI", ")", "{", "Register", "Reg", "=", "CS", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CS", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "return", "true", ";", "}", ""], "natrual_language": ["spillCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "spill", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "store", "instructions", "via", "storeRegToStackSlot", "(", ")", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYFrameLowering1", "Func": "spillCalleeSavedRegisters", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17210, "Length": 150} {"ground_truth": ["", "void", "CSKYFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", ""], "natrual_language": ["Insert", "epilog", "code", "into", "the", "function", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYFrameLowering", "Func": "emitEpilogue", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17211, "Length": 16} {"ground_truth": ["", "void", "CSKYFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", ""], "natrual_language": ["emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYFrameLowering", "Func": "emitPrologue", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17212, "Length": 16} {"ground_truth": ["", "bool", "CSKYFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "RegInfo", "->", "hasStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", ";", "}", ""], "natrual_language": ["hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYFrameLowering", "Func": "hasFP", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17213, "Length": 72} {"ground_truth": ["", "bool", "CSKYInstPrinter", "::", "applyTargetSpecificCLOption", "(", "StringRef", "Opt", ")", "{", "if", "(", "Opt", "==", "\"no-aliases\"", ")", "{", "NoAliases", "=", "true", ";", "return", "true", ";", "}", "if", "(", "Opt", "==", "\"numeric\"", ")", "{", "ArchRegNames", "=", "true", ";", "return", "true", ";", "}", "if", "(", "Opt", "==", "\"debug\"", ")", "{", "DebugFlag", "=", "true", ";", "return", "true", ";", "}", "if", "(", "Opt", "==", "\"abi-names\"", ")", "{", "ABIRegNames", "=", "true", ";", "return", "true", ";", "}", "return", "false", ";", "}", ""], "natrual_language": ["Customize", "the", "printer", "according", "to", "a", "command", "line", "option", "."], "TS_V_token": ["CSKY", "CSKY", "\"no-aliases\"", "\"numeric\"", "\"debug\"", "\"abi-names\""], "File": "CSKYInstPrinter1", "Func": "applyTargetSpecificCLOption", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17214, "Length": 73} {"ground_truth": ["", "void", "CSKYInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "O", ",", "unsigned", "RegNo", ")", "const", "{", "if", "(", "PrintBranchImmAsAddress", ")", "O", "<<", "getRegisterName", "(", "RegNo", ",", "ABIRegNames", "?", "CSKY", "::", "ABIRegAltName", ":", "CSKY", "::", "NoRegAltName", ")", ";", "else", "O", "<<", "getRegisterName", "(", "RegNo", ")", ";", "}", ""], "natrual_language": ["Print", "the", "assembler", "register", "name", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY::ABIRegAltName", "CSKY::NoRegAltName"], "File": "CSKYInstPrinter1", "Func": "printRegName", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17215, "Length": 44} {"ground_truth": ["", "bool", "CSKYInstPrinter", "::", "applyTargetSpecificCLOption", "(", "StringRef", "Opt", ")", "{", "if", "(", "Opt", "==", "\"no-aliases\"", ")", "{", "NoAliases", "=", "true", ";", "return", "true", ";", "}", "if", "(", "Opt", "==", "\"numeric\"", ")", "{", "ArchRegNames", "=", "true", ";", "return", "true", ";", "}", "return", "false", ";", "}", ""], "natrual_language": ["Customize", "the", "printer", "according", "to", "a", "command", "line", "option", "."], "TS_V_token": ["CSKY", "CSKY", "\"no-aliases\"", "\"numeric\""], "File": "CSKYInstPrinter", "Func": "applyTargetSpecificCLOption", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17216, "Length": 43} {"ground_truth": ["", "void", "CSKYInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "O", ")", "{", "const", "MCInst", "*", "NewMI", "=", "MI", ";", "if", "(", "NoAliases", "||", "!", "printAliasInstr", "(", "NewMI", ",", "Address", ",", "STI", ",", "O", ")", ")", "printInstruction", "(", "NewMI", ",", "Address", ",", "STI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", ""], "natrual_language": ["Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYInstPrinter", "Func": "printInst", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17217, "Length": 68} {"ground_truth": ["", "void", "CSKYInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "O", ",", "unsigned", "RegNo", ")", "const", "{", "O", "<<", "getRegisterName", "(", "RegNo", ")", ";", "}", ""], "natrual_language": ["Print", "the", "assembler", "register", "name", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYInstPrinter", "Func": "printRegName", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17218, "Length": 22} {"ground_truth": ["", "bool", "CSKYInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "TBB", "=", "FBB", "=", "nullptr", ";", "Cond", ".", "clear", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", "||", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "iterator", "FirstUncondOrIndirectBr", "=", "MBB", ".", "end", "(", ")", ";", "int", "NumTerminators", "=", "0", ";", "for", "(", "auto", "J", "=", "I", ".", "getReverse", "(", ")", ";", "J", "!=", "MBB", ".", "rend", "(", ")", "&&", "isUnpredicatedTerminator", "(", "*", "J", ")", ";", "J", "++", ")", "{", "NumTerminators", "++", ";", "if", "(", "J", "->", "getDesc", "(", ")", ".", "isUnconditionalBranch", "(", ")", "||", "J", "->", "getDesc", "(", ")", ".", "isIndirectBranch", "(", ")", ")", "{", "FirstUncondOrIndirectBr", "=", "J", ".", "getReverse", "(", ")", ";", "}", "}", "if", "(", "AllowModify", "&&", "FirstUncondOrIndirectBr", "!=", "MBB", ".", "end", "(", ")", ")", "{", "while", "(", "std", "::", "next", "(", "FirstUncondOrIndirectBr", ")", "!=", "MBB", ".", "end", "(", ")", ")", "{", "std", "::", "next", "(", "FirstUncondOrIndirectBr", ")", "->", "eraseFromParent", "(", ")", ";", "NumTerminators", "--", ";", "}", "I", "=", "FirstUncondOrIndirectBr", ";", "}", "if", "(", "I", "->", "getDesc", "(", ")", ".", "isIndirectBranch", "(", ")", ")", "return", "true", ";", "if", "(", "NumTerminators", ">", "2", ")", "return", "true", ";", "if", "(", "NumTerminators", "==", "1", "&&", "I", "->", "getDesc", "(", ")", ".", "isUnconditionalBranch", "(", ")", ")", "{", "TBB", "=", "getBranchDestBlock", "(", "*", "I", ")", ";", "return", "false", ";", "}", "if", "(", "NumTerminators", "==", "1", "&&", "I", "->", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", ")", "{", "parseCondBranch", "(", "*", "I", ",", "TBB", ",", "Cond", ")", ";", "return", "false", ";", "}", "if", "(", "NumTerminators", "==", "2", "&&", "std", "::", "prev", "(", "I", ")", "->", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", "&&", "I", "->", "getDesc", "(", ")", ".", "isUnconditionalBranch", "(", ")", ")", "{", "parseCondBranch", "(", "*", "std", "::", "prev", "(", "I", ")", ",", "TBB", ",", "Cond", ")", ";", "FBB", "=", "getBranchDestBlock", "(", "*", "I", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", ""], "natrual_language": ["analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "."], "TS_V_token": ["CSKY", "CSKY", "0", "2", "1", "1", "2"], "File": "CSKYInstrInfo1", "Func": "analyzeBranch", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17219, "Length": 351} {"ground_truth": ["", "Register", "CSKYInstrInfo", "::", "getGlobalBaseReg", "(", "MachineFunction", "&", "MF", ")", "const", "{", "CSKYMachineFunctionInfo", "*", "CFI", "=", "MF", ".", "getInfo", "<", "CSKYMachineFunctionInfo", ">", "(", ")", ";", "MachineConstantPool", "*", "MCP", "=", "MF", ".", "getConstantPool", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "Register", "GlobalBaseReg", "=", "CFI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "!=", "0", ")", "return", "GlobalBaseReg", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "CSKYConstantPoolValue", "*", "CPV", "=", "CSKYConstantPoolSymbol", "::", "Create", "(", "Type", "::", "getInt32Ty", "(", "MF", ".", "getFunction", "(", ")", ".", "getContext", "(", ")", ")", ",", "\"_GLOBAL_OFFSET_TABLE_\"", ",", "0", ",", "CSKYCP", "::", "ADDR", ")", ";", "unsigned", "CPI", "=", "MCP", "->", "getConstantPoolIndex", "(", "CPV", ",", "Align", "(", "4", ")", ")", ";", "MachineMemOperand", "*", "MO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getConstantPool", "(", "MF", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "4", ",", "Align", "(", "4", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "get", "(", "CSKY", "::", "LRW32", ")", ",", "CSKY", "::", "R28", ")", ".", "addConstantPoolIndex", "(", "CPI", ")", ".", "addMemOperand", "(", "MO", ")", ";", "GlobalBaseReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "CSKY", "::", "GPRRegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "CSKY", "::", "R28", ")", ";", "CFI", "->", "setGlobalBaseReg", "(", "GlobalBaseReg", ")", ";", "return", "GlobalBaseReg", ";", "}", ""], "natrual_language": ["getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY", "0", "CSKY", "CSKY", "\"_GLOBAL_OFFSET_TABLE_\"", "0", "CSKYCP::ADDR", "4", "4", "4", "CSKY::LRW32", "CSKY::R28", "CSKY::GPRRegClass", "CSKY::R28"], "File": "CSKYInstrInfo1", "Func": "getGlobalBaseReg", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17220, "Length": 238} {"ground_truth": ["", "unsigned", "CSKYInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "MI", ".", "getDesc", "(", ")", ".", "getSize", "(", ")", ";", "case", "CSKY", "::", "CONSTPOOL_ENTRY", ":", "return", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "case", "CSKY", "::", "SPILL_CARRY", ":", "case", "CSKY", "::", "RESTORE_CARRY", ":", "case", "CSKY", "::", "PseudoTLSLA32", ":", "return", "8", ";", "case", "TargetOpcode", "::", "INLINEASM_BR", ":", "case", "TargetOpcode", "::", "INLINEASM", ":", "{", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "char", "*", "AsmStr", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ";", "return", "getInlineAsmLength", "(", "AsmStr", ",", "*", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "}", ""], "natrual_language": ["Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY::CONSTPOOL_ENTRY", "2", "CSKY::SPILL_CARRY", "CSKY::RESTORE_CARRY", "CSKY::PseudoTLSLA32", "8", "0"], "File": "CSKYInstrInfo1", "Func": "getInstSizeInBytes", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17221, "Length": 131} {"ground_truth": ["", "static", "unsigned", "getOppositeBranchOpc", "(", "unsigned", "Opcode", ")", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown conditional branch!\"", ")", ";", "case", "CSKY", "::", "BT32", ":", "return", "CSKY", "::", "BF32", ";", "case", "CSKY", "::", "BT16", ":", "return", "CSKY", "::", "BF16", ";", "case", "CSKY", "::", "BF32", ":", "return", "CSKY", "::", "BT32", ";", "case", "CSKY", "::", "BF16", ":", "return", "CSKY", "::", "BT16", ";", "case", "CSKY", "::", "BHZ32", ":", "return", "CSKY", "::", "BLSZ32", ";", "case", "CSKY", "::", "BHSZ32", ":", "return", "CSKY", "::", "BLZ32", ";", "case", "CSKY", "::", "BLZ32", ":", "return", "CSKY", "::", "BHSZ32", ";", "case", "CSKY", "::", "BLSZ32", ":", "return", "CSKY", "::", "BHZ32", ";", "case", "CSKY", "::", "BNEZ32", ":", "return", "CSKY", "::", "BEZ32", ";", "case", "CSKY", "::", "BEZ32", ":", "return", "CSKY", "::", "BNEZ32", ";", "}", "}", ""], "natrual_language": ["getOppositeBranchOpc", "-", "Return", "the", "inverse", "of", "the", "specified", "opcode", ",", "e.g", "."], "TS_V_token": ["CSKY", "\"Unknown conditional branch!\"", "CSKY::BT32", "CSKY::BF32", "CSKY::BT16", "CSKY::BF16", "CSKY::BF32", "CSKY::BT32", "CSKY::BF16", "CSKY::BT16", "CSKY::BHZ32", "CSKY::BLSZ32", "CSKY::BHSZ32", "CSKY::BLZ32", "CSKY::BLZ32", "CSKY::BHSZ32", "CSKY::BLSZ32", "CSKY::BHZ32", "CSKY::BNEZ32", "CSKY::BEZ32", "CSKY::BEZ32", "CSKY::BNEZ32"], "File": "CSKYInstrInfo1", "Func": "getOppositeBranchOpc", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17222, "Length": 122} {"ground_truth": ["", "unsigned", "CSKYInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "0", ";", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "2", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"CSKY branch conditions have two components!\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "MachineInstr", "&", "MI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "CSKY", "::", "BR32", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "MI", ")", ";", "return", "1", ";", "}", "unsigned", "Opc", "=", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "MachineInstr", "&", "CondMI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ".", "addMBB", "(", "TBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "CondMI", ")", ";", "if", "(", "!", "FBB", ")", "return", "1", ";", "MachineInstr", "&", "MI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "CSKY", "::", "BR32", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "MI", ")", ";", "return", "2", ";", "}", ""], "natrual_language": ["Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "."], "TS_V_token": ["CSKY", "CSKY", "0", "\"insertBranch must not be told to insert a fallthrough\"", "2", "0", "\"CSKY branch conditions have two components!\"", "CSKY::BR32", "1", "0", "1", "1", "CSKY::BR32", "2"], "File": "CSKYInstrInfo1", "Func": "insertBranch", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17223, "Length": 227} {"ground_truth": ["", "unsigned", "CSKYInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "CSKY", "::", "LD16B", ":", "case", "CSKY", "::", "LD16H", ":", "case", "CSKY", "::", "LD16W", ":", "case", "CSKY", "::", "LD32B", ":", "case", "CSKY", "::", "LD32BS", ":", "case", "CSKY", "::", "LD32H", ":", "case", "CSKY", "::", "LD32HS", ":", "case", "CSKY", "::", "LD32W", ":", "case", "CSKY", "::", "FLD_S", ":", "case", "CSKY", "::", "FLD_D", ":", "case", "CSKY", "::", "f2FLD_S", ":", "case", "CSKY", "::", "f2FLD_D", ":", "case", "CSKY", "::", "RESTORE_CARRY", ":", "break", ";", "}", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "return", "0", ";", "}", ""], "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": ["CSKY", "CSKY", "0", "CSKY::LD16B", "CSKY::LD16H", "CSKY::LD16W", "CSKY::LD32B", "CSKY::LD32BS", "CSKY::LD32H", "CSKY::LD32HS", "CSKY::LD32W", "CSKY::FLD_S", "CSKY::FLD_D", "CSKY::f2FLD_S", "CSKY::f2FLD_D", "CSKY::RESTORE_CARRY", "1", "2", "2", "0", "1", "0", "0"], "File": "CSKYInstrInfo1", "Func": "isLoadFromStackSlot", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17224, "Length": 166} {"ground_truth": ["", "unsigned", "CSKYInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "CSKY", "::", "ST16B", ":", "case", "CSKY", "::", "ST16H", ":", "case", "CSKY", "::", "ST16W", ":", "case", "CSKY", "::", "ST32B", ":", "case", "CSKY", "::", "ST32H", ":", "case", "CSKY", "::", "ST32W", ":", "case", "CSKY", "::", "FST_S", ":", "case", "CSKY", "::", "FST_D", ":", "case", "CSKY", "::", "f2FST_S", ":", "case", "CSKY", "::", "f2FST_D", ":", "case", "CSKY", "::", "SPILL_CARRY", ":", "break", ";", "}", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "return", "0", ";", "}", ""], "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": ["CSKY", "CSKY", "0", "CSKY::ST16B", "CSKY::ST16H", "CSKY::ST16W", "CSKY::ST32B", "CSKY::ST32H", "CSKY::ST32W", "CSKY::FST_S", "CSKY::FST_D", "CSKY::f2FST_S", "CSKY::f2FST_D", "CSKY::SPILL_CARRY", "1", "2", "2", "0", "1", "0", "0"], "File": "CSKYInstrInfo1", "Func": "isStoreToStackSlot", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17225, "Length": 156} {"ground_truth": ["", "void", "CSKYInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "CSKYMachineFunctionInfo", "*", "CFI", "=", "MF", ".", "getInfo", "<", "CSKYMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "CSKY", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opcode", "=", "CSKY", "::", "LD32W", ";", "}", "else", "if", "(", "CSKY", "::", "CARRYRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opcode", "=", "CSKY", "::", "RESTORE_CARRY", ";", "CFI", "->", "setSpillsCR", "(", ")", ";", "}", "else", "if", "(", "v2sf", "&&", "CSKY", "::", "sFPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "CSKY", "::", "FLD_S", ";", "else", "if", "(", "v2df", "&&", "CSKY", "::", "sFPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "CSKY", "::", "FLD_D", ";", "else", "if", "(", "v3sf", "&&", "CSKY", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "CSKY", "::", "f2FLD_S", ";", "else", "if", "(", "v3df", "&&", "CSKY", "::", "FPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "CSKY", "::", "f2FLD_D", ";", "else", "{", "llvm_unreachable", "(", "\"Unknown RegisterClass\"", ")", ";", "}", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", ""], "natrual_language": ["Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY", "0", "CSKY::GPRRegClass", "CSKY::LD32W", "CSKY::CARRYRegClass", "CSKY::RESTORE_CARRY", "CSKY::sFPR32RegClass", "CSKY::FLD_S", "CSKY::sFPR64RegClass", "CSKY::FLD_D", "CSKY::FPR32RegClass", "CSKY::f2FLD_S", "CSKY::FPR64RegClass", "CSKY::f2FLD_D", "\"Unknown RegisterClass\"", "0"], "File": "CSKYInstrInfo1", "Func": "loadRegFromStackSlot", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17226, "Length": 293} {"ground_truth": ["", "unsigned", "CSKYInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "0", ";", "if", "(", "!", "I", "->", "getDesc", "(", ")", ".", "isUnconditionalBranch", "(", ")", "&&", "!", "I", "->", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", ")", "return", "0", ";", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "1", ";", "--", "I", ";", "if", "(", "!", "I", "->", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", ")", "return", "1", ";", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "return", "2", ";", "}", ""], "natrual_language": ["Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "."], "TS_V_token": ["CSKY", "CSKY", "0", "0", "0", "1", "1", "2"], "File": "CSKYInstrInfo1", "Func": "removeBranch", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17227, "Length": 157} {"ground_truth": ["", "bool", "CSKYInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "2", ")", "&&", "\"Invalid branch condition!\"", ")", ";", "Cond", "[", "0", "]", ".", "setImm", "(", "getOppositeBranchOpc", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", ";", "return", "false", ";", "}", ""], "natrual_language": ["Reverses", "the", "branch", "condition", "of", "the", "specified", "condition", "list", ",", "returning", "false", "on", "success", "and", "true", "if", "it", "can", "not", "be", "reversed", "."], "TS_V_token": ["CSKY", "CSKY", "2", "\"Invalid branch condition!\"", "0", "0"], "File": "CSKYInstrInfo1", "Func": "reverseBranchCondition", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17228, "Length": 53} {"ground_truth": ["", "void", "CSKYInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "SrcReg", ",", "bool", "IsKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "CSKYMachineFunctionInfo", "*", "CFI", "=", "MF", ".", "getInfo", "<", "CSKYMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "CSKY", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opcode", "=", "CSKY", "::", "ST32W", ";", "}", "else", "if", "(", "CSKY", "::", "CARRYRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opcode", "=", "CSKY", "::", "SPILL_CARRY", ";", "CFI", "->", "setSpillsCR", "(", ")", ";", "}", "else", "if", "(", "v2sf", "&&", "CSKY", "::", "sFPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "CSKY", "::", "FST_S", ";", "else", "if", "(", "v2df", "&&", "CSKY", "::", "sFPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "CSKY", "::", "FST_D", ";", "else", "if", "(", "v3sf", "&&", "CSKY", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "CSKY", "::", "f2FST_S", ";", "else", "if", "(", "v3df", "&&", "CSKY", "::", "FPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "CSKY", "::", "f2FST_D", ";", "else", "{", "llvm_unreachable", "(", "\"Unknown RegisterClass\"", ")", ";", "}", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "IsKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", ""], "natrual_language": ["Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY", "0", "CSKY::GPRRegClass", "CSKY::ST32W", "CSKY::CARRYRegClass", "CSKY::SPILL_CARRY", "CSKY::sFPR32RegClass", "CSKY::FST_S", "CSKY::sFPR64RegClass", "CSKY::FST_D", "CSKY::FPR32RegClass", "CSKY::f2FST_S", "CSKY::FPR64RegClass", "CSKY::f2FST_D", "\"Unknown RegisterClass\"", "0"], "File": "CSKYInstrInfo1", "Func": "storeRegToStackSlot", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17229, "Length": 304} {"ground_truth": ["", "void", "CSKYInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DestReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "if", "(", "CSKY", "::", "GPRRegClass", ".", "contains", "(", "SrcReg", ")", "&&", "CSKY", "::", "CARRYRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "if", "(", "STI", ".", "hasE2", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "CSKY", "::", "BTSTI32", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "else", "{", "assert", "(", "SrcReg", "<", "CSKY", "::", "R8", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "CSKY", "::", "BTSTI16", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "return", ";", "}", "if", "(", "CSKY", "::", "CARRYRegClass", ".", "contains", "(", "SrcReg", ")", "&&", "CSKY", "::", "GPRRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "if", "(", "STI", ".", "hasE2", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "CSKY", "::", "MVC32", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "{", "assert", "(", "DestReg", "<", "CSKY", "::", "R16", ")", ";", "assert", "(", "DestReg", "<", "CSKY", "::", "R8", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "CSKY", "::", "MOVI16", ")", ",", "DestReg", ")", ".", "addImm", "(", "0", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "CSKY", "::", "ADDC16", ")", ")", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "SrcReg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "DestReg", ",", "getKillRegState", "(", "true", ")", ")", ".", "addReg", "(", "DestReg", ",", "getKillRegState", "(", "true", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "true", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "CSKY", "::", "BTSTI16", ")", ")", ".", "addReg", "(", "SrcReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "KillSrc", ")", ")", ".", "addReg", "(", "DestReg", ")", ".", "addImm", "(", "0", ")", ";", "}", "return", ";", "}", "unsigned", "Opcode", "=", "0", ";", "if", "(", "CSKY", "::", "GPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "CSKY", "::", "MOV32", ";", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"src = \"", "<<", "SrcReg", "<<", "\", dst = \"", "<<", "DestReg", ")", ";", "LLVM_DEBUG", "(", "I", "->", "dump", "(", ")", ")", ";", "llvm_unreachable", "(", "\"Unknown RegisterClass\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", ""], "natrual_language": ["}", "Branch", "Analysis", "&", "Modification"], "TS_V_token": ["CSKY", "CSKY", "CSKY::GPRRegClass", "CSKY::CARRYRegClass", "CSKY::BTSTI32", "0", "CSKY::R8", "CSKY::BTSTI16", "0", "CSKY::CARRYRegClass", "CSKY::GPRRegClass", "CSKY::MVC32", "CSKY::R16", "CSKY::R8", "CSKY::MOVI16", "0", "CSKY::ADDC16", "CSKY::BTSTI16", "0", "0", "CSKY::GPRRegClass", "CSKY::MOV32", "\"src = \"", "\", dst = \"", "\"Unknown RegisterClass\""], "File": "CSKYInstrInfo4", "Func": "copyPhysReg", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17230, "Length": 449} {"ground_truth": ["", "unsigned", "CSKYInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "CSKY", "::", "LD16B", ":", "case", "CSKY", "::", "LD16H", ":", "case", "CSKY", "::", "LD16W", ":", "case", "CSKY", "::", "LD32B", ":", "case", "CSKY", "::", "LD32BS", ":", "case", "CSKY", "::", "LD32H", ":", "case", "CSKY", "::", "LD32HS", ":", "case", "CSKY", "::", "LD32W", ":", "case", "CSKY", "::", "RESTORE_CARRY", ":", "break", ";", "}", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "return", "0", ";", "}", ""], "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": ["CSKY", "CSKY", "0", "CSKY::LD16B", "CSKY::LD16H", "CSKY::LD16W", "CSKY::LD32B", "CSKY::LD32BS", "CSKY::LD32H", "CSKY::LD32HS", "CSKY::LD32W", "CSKY::RESTORE_CARRY", "1", "2", "2", "0", "1", "0", "0"], "File": "CSKYInstrInfo4", "Func": "isLoadFromStackSlot", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17231, "Length": 146} {"ground_truth": ["", "unsigned", "CSKYInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "CSKY", "::", "ST16B", ":", "case", "CSKY", "::", "ST16H", ":", "case", "CSKY", "::", "ST16W", ":", "case", "CSKY", "::", "ST32B", ":", "case", "CSKY", "::", "ST32H", ":", "case", "CSKY", "::", "ST32W", ":", "case", "CSKY", "::", "SPILL_CARRY", ":", "break", ";", "}", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "return", "0", ";", "}", ""], "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": ["CSKY", "CSKY", "0", "CSKY::ST16B", "CSKY::ST16H", "CSKY::ST16W", "CSKY::ST32B", "CSKY::ST32H", "CSKY::ST32W", "CSKY::SPILL_CARRY", "1", "2", "2", "0", "1", "0", "0"], "File": "CSKYInstrInfo4", "Func": "isStoreToStackSlot", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17232, "Length": 136} {"ground_truth": ["", "void", "CSKYInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "CSKYMachineFunctionInfo", "*", "CFI", "=", "MF", ".", "getInfo", "<", "CSKYMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "CSKY", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opcode", "=", "CSKY", "::", "LD32W", ";", "}", "else", "if", "(", "CSKY", "::", "CARRYRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opcode", "=", "CSKY", "::", "RESTORE_CARRY", ";", "CFI", "->", "setSpillsCR", "(", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Unknown RegisterClass\"", ")", ";", "}", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", ""], "natrual_language": ["Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY", "0", "CSKY::GPRRegClass", "CSKY::LD32W", "CSKY::CARRYRegClass", "CSKY::RESTORE_CARRY", "\"Unknown RegisterClass\"", "0"], "File": "CSKYInstrInfo4", "Func": "loadRegFromStackSlot", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17233, "Length": 213} {"ground_truth": ["", "void", "CSKYInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "SrcReg", ",", "bool", "IsKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "CSKYMachineFunctionInfo", "*", "CFI", "=", "MF", ".", "getInfo", "<", "CSKYMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "CSKY", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opcode", "=", "CSKY", "::", "ST32W", ";", "}", "else", "if", "(", "CSKY", "::", "CARRYRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opcode", "=", "CSKY", "::", "SPILL_CARRY", ";", "CFI", "->", "setSpillsCR", "(", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Unknown RegisterClass\"", ")", ";", "}", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "IsKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", ""], "natrual_language": ["Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY", "0", "CSKY::GPRRegClass", "CSKY::ST32W", "CSKY::CARRYRegClass", "CSKY::SPILL_CARRY", "\"Unknown RegisterClass\"", "0"], "File": "CSKYInstrInfo4", "Func": "storeRegToStackSlot", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17234, "Length": 224} {"ground_truth": ["", "void", "CSKYDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "SDLoc", "Dl", "(", "N", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", ";", "bool", "IsSelected", "=", "false", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADDCARRY", ":", "IsSelected", "=", "selectAddCarry", "(", "N", ")", ";", "break", ";", "case", "ISD", "::", "SUBCARRY", ":", "IsSelected", "=", "selectSubCarry", "(", "N", ")", ";", "break", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "{", "Register", "GP", "=", "Subtarget", "->", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "*", "MF", ")", ";", "ReplaceNode", "(", "N", ",", "CurDAG", "->", "getRegister", "(", "GP", ",", "N", "->", "getValueType", "(", "0", ")", ")", ".", "getNode", "(", ")", ")", ";", "IsSelected", "=", "true", ";", "break", ";", "}", "case", "ISD", "::", "FrameIndex", ":", "{", "SDValue", "Imm", "=", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "Dl", ",", "MVT", "::", "i32", ")", ";", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "N", ")", "->", "getIndex", "(", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "ReplaceNode", "(", "N", ",", "CurDAG", "->", "getMachineNode", "(", "Subtarget", "->", "hasE2", "(", ")", "?", "CSKY", "::", "ADDI32", ":", "CSKY", "::", "ADDI16XZ", ",", "Dl", ",", "MVT", "::", "i32", ",", "TFI", ",", "Imm", ")", ")", ";", "IsSelected", "=", "true", ";", "break", ";", "}", "}", "if", "(", "IsSelected", ")", "return", ";", "SelectCode", "(", "N", ")", ";", "}", ""], "natrual_language": ["Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "."], "TS_V_token": ["CSKY", "CSKY", "\"== \"", "\"\\n\"", "1", "ISD::ADDCARRY", "ISD::SUBCARRY", "ISD::GLOBAL_OFFSET_TABLE", "0", "ISD::FrameIndex", "0", "MVT::i32", "MVT::i32", "CSKY::ADDI32", "CSKY::ADDI16XZ", "MVT::i32"], "File": "CSKYISelDAGToDAG1", "Func": "Select", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17235, "Length": 265} {"ground_truth": ["", "void", "CSKYDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "SDLoc", "Dl", "(", "N", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", ";", "bool", "IsSelected", "=", "false", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "}", "if", "(", "IsSelected", ")", "return", ";", "SelectCode", "(", "N", ")", ";", "}", ""], "natrual_language": ["Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "."], "TS_V_token": ["CSKY", "CSKY", "\"== \"", "\"\\n\"", "1"], "File": "CSKYISelDAGToDAG2", "Func": "Select", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17236, "Length": 94} {"ground_truth": ["", "void", "CSKYDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "SDLoc", "Dl", "(", "N", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", ";", "bool", "IsSelected", "=", "false", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADDCARRY", ":", "IsSelected", "=", "selectAddCarry", "(", "N", ")", ";", "break", ";", "case", "ISD", "::", "SUBCARRY", ":", "IsSelected", "=", "selectSubCarry", "(", "N", ")", ";", "break", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "{", "Register", "GP", "=", "Subtarget", "->", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "*", "MF", ")", ";", "ReplaceNode", "(", "N", ",", "CurDAG", "->", "getRegister", "(", "GP", ",", "N", "->", "getValueType", "(", "0", ")", ")", ".", "getNode", "(", ")", ")", ";", "IsSelected", "=", "true", ";", "break", ";", "}", "case", "ISD", "::", "FrameIndex", ":", "{", "SDValue", "Imm", "=", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "Dl", ",", "MVT", "::", "i32", ")", ";", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "N", ")", "->", "getIndex", "(", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "ReplaceNode", "(", "N", ",", "CurDAG", "->", "getMachineNode", "(", "Subtarget", "->", "hasE2", "(", ")", "?", "CSKY", "::", "ADDI32", ":", "CSKY", "::", "ADDI16XZ", ",", "Dl", ",", "MVT", "::", "i32", ",", "TFI", ",", "Imm", ")", ")", ";", "IsSelected", "=", "true", ";", "break", ";", "}", "case", "CSKYISD", "::", "BITCAST_TO_LOHI", ":", "IsSelected", "=", "selectBITCAST_TO_LOHI", "(", "N", ")", ";", "break", ";", "case", "ISD", "::", "INLINEASM", ":", "case", "ISD", "::", "INLINEASM_BR", ":", "IsSelected", "=", "selectInlineAsm", "(", "N", ")", ";", "break", ";", "}", "if", "(", "IsSelected", ")", "return", ";", "SelectCode", "(", "N", ")", ";", "}", ""], "natrual_language": ["Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "."], "TS_V_token": ["CSKY", "CSKY", "\"== \"", "\"\\n\"", "1", "ISD::ADDCARRY", "ISD::SUBCARRY", "ISD::GLOBAL_OFFSET_TABLE", "0", "ISD::FrameIndex", "0", "MVT::i32", "MVT::i32", "CSKY::ADDI32", "CSKY::ADDI16XZ", "MVT::i32", "CSKYISD::BITCAST_TO_LOHI", "ISD::INLINEASM", "ISD::INLINEASM_BR"], "File": "CSKYISelDAGToDAG3", "Func": "Select", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17237, "Length": 298} {"ground_truth": ["", "void", "CSKYDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "SDLoc", "Dl", "(", "N", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", ";", "bool", "IsSelected", "=", "false", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADDCARRY", ":", "IsSelected", "=", "selectAddCarry", "(", "N", ")", ";", "break", ";", "case", "ISD", "::", "SUBCARRY", ":", "IsSelected", "=", "selectSubCarry", "(", "N", ")", ";", "break", ";", "}", "if", "(", "IsSelected", ")", "return", ";", "SelectCode", "(", "N", ")", ";", "}", ""], "natrual_language": ["Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "."], "TS_V_token": ["CSKY", "CSKY", "\"== \"", "\"\\n\"", "1", "ISD::ADDCARRY", "ISD::SUBCARRY"], "File": "CSKYISelDAGToDAG4", "Func": "Select", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17238, "Length": 122} {"ground_truth": ["", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"CSKY DAG->DAG Pattern Instruction Selection\"", ";", "}", ""], "natrual_language": ["getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "."], "TS_V_token": ["CSKY", "\"CSKY DAG->DAG Pattern Instruction Selection\""], "File": "CSKYISelDAGToDAG", "Func": "getPassName", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17239, "Length": 11} {"ground_truth": ["", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "CSKYSubtarget", ">", "(", ")", ";", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", ""], "natrual_language": ["runOnMachineFunction", "-", "Emit", "the", "function", "body", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYISelDAGToDAG", "Func": "runOnMachineFunction", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17240, "Length": 32} {"ground_truth": ["", "void", "CSKYDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "SDLoc", "Dl", "(", "N", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", ";", "bool", "IsSelected", "=", "false", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADDCARRY", ":", "IsSelected", "=", "selectAddCarry", "(", "N", ")", ";", "break", ";", "case", "ISD", "::", "SUBCARRY", ":", "IsSelected", "=", "selectSubCarry", "(", "N", ")", ";", "break", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "{", "Register", "GP", "=", "Subtarget", "->", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "*", "MF", ")", ";", "ReplaceNode", "(", "N", ",", "CurDAG", "->", "getRegister", "(", "GP", ",", "N", "->", "getValueType", "(", "0", ")", ")", ".", "getNode", "(", ")", ")", ";", "IsSelected", "=", "true", ";", "break", ";", "}", "case", "ISD", "::", "FrameIndex", ":", "{", "SDValue", "Imm", "=", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "Dl", ",", "MVT", "::", "i32", ")", ";", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "N", ")", "->", "getIndex", "(", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "ReplaceNode", "(", "N", ",", "CurDAG", "->", "getMachineNode", "(", "Subtarget", "->", "hasE2", "(", ")", "?", "CSKY", "::", "ADDI32", ":", "CSKY", "::", "ADDI16XZ", ",", "Dl", ",", "MVT", "::", "i32", ",", "TFI", ",", "Imm", ")", ")", ";", "IsSelected", "=", "true", ";", "break", ";", "}", "case", "ISD", "::", "INLINEASM", ":", "case", "ISD", "::", "INLINEASM_BR", ":", "IsSelected", "=", "selectInlineAsm", "(", "N", ")", ";", "break", ";", "}", "if", "(", "IsSelected", ")", "return", ";", "SelectCode", "(", "N", ")", ";", "}", ""], "natrual_language": ["Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "."], "TS_V_token": ["CSKY", "CSKY", "\"== \"", "\"\\n\"", "1", "ISD::ADDCARRY", "ISD::SUBCARRY", "ISD::GLOBAL_OFFSET_TABLE", "0", "ISD::FrameIndex", "0", "MVT::i32", "MVT::i32", "CSKY::ADDI32", "CSKY::ADDI16XZ", "MVT::i32", "ISD::INLINEASM", "ISD::INLINEASM_BR"], "File": "CSKYISelDAGToDAG", "Func": "Select", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17241, "Length": 284} {"ground_truth": ["", "bool", "CSKYDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "switch", "(", "ConstraintID", ")", "{", "case", "InlineAsm", "::", "Constraint_m", ":", "OutOps", ".", "push_back", "(", "Op", ")", ";", "return", "false", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", ""], "natrual_language": ["SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYISelDAGToDAG", "Func": "SelectInlineAsmMemoryOperand", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17242, "Length": 52} {"ground_truth": ["", "SDValue", "getAddr", "(", "NodeTy", "*", "N", ",", "SelectionDAG", "&", "DAG", ",", "bool", "IsLocal", "=", "true", ")", "const", "{", "SDLoc", "DL", "(", "N", ")", ";", "EVT", "Ty", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "unsigned", "Flag", "=", "CSKYII", "::", "MO_None", ";", "bool", "IsPIC", "=", "isPositionIndependent", "(", ")", ";", "if", "(", "IsPIC", ")", "Flag", "=", "IsLocal", "?", "CSKYII", "::", "MO_GOTOFF", ":", "IsCall", "?", "CSKYII", "::", "MO_PLT32", ":", "CSKYII", "::", "MO_GOT32", ";", "SDValue", "TCPV", "=", "getTargetConstantPoolValue", "(", "N", ",", "Ty", ",", "DAG", ",", "Flag", ")", ";", "SDValue", "TV", "=", "getTargetNode", "(", "N", ",", "DL", ",", "Ty", ",", "DAG", ",", "Flag", ")", ";", "SDValue", "Addr", "=", "DAG", ".", "getNode", "(", "CSKYISD", "::", "LOAD_ADDR", ",", "DL", ",", "Ty", ",", "{", "TV", ",", "TCPV", "}", ")", ";", "if", "(", "!", "IsPIC", ")", "return", "Addr", ";", "SDValue", "Result", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "Ty", ",", "{", "DAG", ".", "getGLOBAL_OFFSET_TABLE", "(", "Ty", ")", ",", "Addr", "}", ")", ";", "if", "(", "IsLocal", ")", "return", "Result", ";", "return", "DAG", ".", "getLoad", "(", "Ty", ",", "DL", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "Result", ",", "MachinePointerInfo", "::", "getGOT", "(", "DAG", ".", "getMachineFunction", "(", ")", ")", ")", ";", "}", ""], "natrual_language": ["Return", "the", "address", "accessed", "by", "this", "recipe", "."], "TS_V_token": ["CSKY", "CSKYII::MO_None", "CSKYII::MO_GOTOFF", "CSKYII::MO_PLT32", "CSKYII::MO_GOT32", "CSKYISD::LOAD_ADDR", "ISD::ADD"], "File": "CSKYISelLowering1", "Func": "getAddr", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17243, "Length": 196} {"ground_truth": ["", "const", "char", "*", "CSKYTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown CSKYISD node\"", ")", ";", "case", "CSKYISD", "::", "NIE", ":", "return", "\"CSKYISD::NIE\"", ";", "case", "CSKYISD", "::", "NIR", ":", "return", "\"CSKYISD::NIR\"", ";", "case", "CSKYISD", "::", "RET", ":", "return", "\"CSKYISD::RET\"", ";", "case", "CSKYISD", "::", "BITCAST_TO_LOHI", ":", "return", "\"CSKYISD::BITCAST_TO_LOHI\"", ";", "}", "}", ""], "natrual_language": ["getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific"], "TS_V_token": ["CSKY", "CSKY", "\"unknown CSKYISD node\"", "CSKYISD::NIE", "\"CSKYISD::NIE\"", "CSKYISD::NIR", "\"CSKYISD::NIR\"", "CSKYISD::RET", "\"CSKYISD::RET\"", "CSKYISD::BITCAST_TO_LOHI", "\"CSKYISD::BITCAST_TO_LOHI\""], "File": "CSKYISelLowering2", "Func": "getTargetNodeName", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17244, "Length": 58} {"ground_truth": ["", "MachineBasicBlock", "*", "CSKYTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "case", "CSKY", "::", "FSELS", ":", "case", "CSKY", "::", "FSELD", ":", "if", "(", "Subtarget", ".", "hasE2", "(", ")", ")", "return", "emitSelectPseudo", "(", "MI", ",", "BB", ",", "CSKY", "::", "BT32", ")", ";", "else", "return", "emitSelectPseudo", "(", "MI", ",", "BB", ",", "CSKY", "::", "BT16", ")", ";", "case", "CSKY", "::", "ISEL32", ":", "return", "emitSelectPseudo", "(", "MI", ",", "BB", ",", "CSKY", "::", "BT32", ")", ";", "case", "CSKY", "::", "ISEL16", ":", "return", "emitSelectPseudo", "(", "MI", ",", "BB", ",", "CSKY", "::", "BT16", ")", ";", "}", "}", ""], "natrual_language": ["This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "."], "TS_V_token": ["CSKY", "CSKY", "\"Unexpected instr type to insert\"", "CSKY::FSELS", "CSKY::FSELD", "CSKY::BT32", "CSKY::BT16", "CSKY::ISEL32", "CSKY::BT32", "CSKY::ISEL16", "CSKY::BT16"], "File": "CSKYISelLowering3", "Func": "EmitInstrWithCustomInserter", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17245, "Length": 111} {"ground_truth": ["", "bool", "CSKYTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "CSKYLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "CSKYLocs", ",", "Context", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "CCAssignFnForReturn", "(", "CallConv", ",", "IsVarArg", ")", ")", ";", "}", ""], "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": ["CSKY", "CSKY", "ISD::OutputArg", "16", "CSKY", "CSKY"], "File": "CSKYISelLowering", "Func": "CanLowerReturn", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17246, "Length": 71} {"ground_truth": ["", "CCAssignFn", "*", "CSKYTargetLowering", "::", "CCAssignFnForCall", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "IsVarArg", ")", "const", "{", "if", "(", "IsVarArg", "||", "!", "Subtarget", ".", "useHardFloatABI", "(", ")", ")", "return", "CC_CSKY_ABIV2_SOFT", ";", "else", "return", "CC_CSKY_ABIV2_FP", ";", "}", ""], "natrual_language": ["Selects", "the", "correct", "CCAssignFn", "for", "a", "given", "CallingConvention", "value", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY"], "File": "CSKYISelLowering", "Func": "CCAssignFnForCall", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17247, "Length": 35} {"ground_truth": ["", "CCAssignFn", "*", "CSKYTargetLowering", "::", "CCAssignFnForReturn", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "IsVarArg", ")", "const", "{", "if", "(", "IsVarArg", "||", "!", "Subtarget", ".", "useHardFloatABI", "(", ")", ")", "return", "RetCC_CSKY_ABIV2_SOFT", ";", "else", "return", "RetCC_CSKY_ABIV2_FP", ";", "}", ""], "natrual_language": ["Selects", "the", "correct", "CCAssignFn", "for", "a", "given", "CallingConvention", "value", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY"], "File": "CSKYISelLowering", "Func": "CCAssignFnForReturn", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17248, "Length": 35} {"ground_truth": ["", "MachineBasicBlock", "*", "CSKYTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "case", "CSKY", "::", "ISEL32", ":", "return", "emitSelectPseudo", "(", "MI", ",", "BB", ",", "CSKY", "::", "BT32", ")", ";", "case", "CSKY", "::", "ISEL16", ":", "return", "emitSelectPseudo", "(", "MI", ",", "BB", ",", "CSKY", "::", "BT16", ")", ";", "}", "}", ""], "natrual_language": ["This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "."], "TS_V_token": ["CSKY", "CSKY", "\"Unexpected instr type to insert\"", "CSKY::ISEL32", "CSKY::BT32", "CSKY::ISEL16", "CSKY::BT16"], "File": "CSKYISelLowering", "Func": "EmitInstrWithCustomInserter", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17249, "Length": 68} {"ground_truth": ["", "CSKYTargetLowering", "::", "ConstraintType", "CSKYTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'a'", ":", "case", "'b'", ":", "case", "'v'", ":", "case", "'w'", ":", "case", "'y'", ":", "return", "C_RegisterClass", ";", "case", "'c'", ":", "case", "'l'", ":", "case", "'h'", ":", "case", "'z'", ":", "return", "C_Register", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", ""], "natrual_language": ["Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "1", "0"], "File": "CSKYISelLowering", "Func": "getConstraintType", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17250, "Length": 79} {"ground_truth": ["", "Register", "CSKYTargetLowering", "::", "getExceptionPointerRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "return", "CSKY", "::", "R0", ";", "}", ""], "natrual_language": ["If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "address", "on", "entry", "to", "an", "EH", "pad", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY::R0"], "File": "CSKYISelLowering", "Func": "getExceptionPointerRegister", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17251, "Length": 18} {"ground_truth": ["", "Register", "CSKYTargetLowering", "::", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "return", "CSKY", "::", "R1", ";", "}", ""], "natrual_language": ["If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "typeid", "on", "entry", "to", "a", "landing", "pad", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY::R1"], "File": "CSKYISelLowering", "Func": "getExceptionSelectorRegister", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17252, "Length": 18} {"ground_truth": ["", "EVT", "CSKYTargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "MVT", "::", "i32", ";", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", ""], "natrual_language": ["Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "."], "TS_V_token": ["CSKY", "CSKY", "MVT::i32"], "File": "CSKYISelLowering", "Func": "getSetCCResultType", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17253, "Length": 41} {"ground_truth": ["", "SDValue", "CSKYTargetLowering", "::", "getTargetNode", "(", "BlockAddressSDNode", "*", "N", ",", "SDLoc", "DL", ",", "EVT", "Ty", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "Flags", ")", "const", "{", "return", "DAG", ".", "getTargetBlockAddress", "(", "N", "->", "getBlockAddress", "(", ")", ",", "Ty", ",", "N", "->", "getOffset", "(", ")", ",", "Flags", ")", ";", "}", ""], "natrual_language": ["Retrieve", "the", "target", "node", "this", "edge", "connects", "to", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYISelLowering", "Func": "getTargetNode", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17254, "Length": 47} {"ground_truth": ["", "const", "char", "*", "CSKYTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown CSKYISD node\"", ")", ";", "case", "CSKYISD", "::", "NIE", ":", "return", "\"CSKYISD::NIE\"", ";", "case", "CSKYISD", "::", "NIR", ":", "return", "\"CSKYISD::NIR\"", ";", "case", "CSKYISD", "::", "RET", ":", "return", "\"CSKYISD::RET\"", ";", "case", "CSKYISD", "::", "CALL", ":", "return", "\"CSKYISD::CALL\"", ";", "case", "CSKYISD", "::", "CALLReg", ":", "return", "\"CSKYISD::CALLReg\"", ";", "case", "CSKYISD", "::", "TAIL", ":", "return", "\"CSKYISD::TAIL\"", ";", "case", "CSKYISD", "::", "TAILReg", ":", "return", "\"CSKYISD::TAILReg\"", ";", "case", "CSKYISD", "::", "LOAD_ADDR", ":", "return", "\"CSKYISD::LOAD_ADDR\"", ";", "case", "CSKYISD", "::", "BITCAST_TO_LOHI", ":", "return", "\"CSKYISD::BITCAST_TO_LOHI\"", ";", "case", "CSKYISD", "::", "BITCAST_FROM_LOHI", ":", "return", "\"CSKYISD::BITCAST_FROM_LOHI\"", ";", "}", "}", ""], "natrual_language": ["getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific"], "TS_V_token": ["CSKY", "CSKY", "\"unknown CSKYISD node\"", "CSKYISD::NIE", "\"CSKYISD::NIE\"", "CSKYISD::NIR", "\"CSKYISD::NIR\"", "CSKYISD::RET", "\"CSKYISD::RET\"", "CSKYISD::CALL", "\"CSKYISD::CALL\"", "CSKYISD::CALLReg", "\"CSKYISD::CALLReg\"", "CSKYISD::TAIL", "\"CSKYISD::TAIL\"", "CSKYISD::TAILReg", "\"CSKYISD::TAILReg\"", "CSKYISD::LOAD_ADDR", "\"CSKYISD::LOAD_ADDR\"", "CSKYISD::BITCAST_TO_LOHI", "\"CSKYISD::BITCAST_TO_LOHI\"", "CSKYISD::BITCAST_FROM_LOHI", "\"CSKYISD::BITCAST_FROM_LOHI\""], "File": "CSKYISelLowering", "Func": "getTargetNodeName", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17255, "Length": 106} {"ground_truth": ["", "SDValue", "CSKYTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unimplemented op\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ExternalSymbol", ":", "return", "LowerExternalSymbol", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "}", "}", ""], "natrual_language": ["LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "."], "TS_V_token": ["CSKY", "CSKY", "\"unimplemented op\"", "ISD::GlobalAddress", "ISD::ExternalSymbol", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::BlockAddress", "ISD::VASTART", "ISD::FRAMEADDR", "ISD::RETURNADDR"], "File": "CSKYISelLowering", "Func": "LowerOperation", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17256, "Length": 136} {"ground_truth": ["", "SDValue", "CSKYTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "CSKYLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "CSKYLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "CCAssignFnForReturn", "(", "CallConv", ",", "IsVarArg", ")", ")", ";", "SDValue", "Glue", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSKYLocs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "SDValue", "Val", "=", "OutVals", "[", "i", "]", ";", "CCValAssign", "&", "VA", "=", "CSKYLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "bool", "IsF64OnCSKY", "=", "VA", ".", "getLocVT", "(", ")", "==", "MVT", "::", "i32", "&&", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "f64", ";", "if", "(", "IsF64OnCSKY", ")", "{", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Expected return via registers\"", ")", ";", "SDValue", "Split64", "=", "DAG", ".", "getNode", "(", "CSKYISD", "::", "BITCAST_TO_LOHI", ",", "DL", ",", "DAG", ".", "getVTList", "(", "MVT", "::", "i32", ",", "MVT", "::", "i32", ")", ",", "Val", ")", ";", "SDValue", "Lo", "=", "Split64", ".", "getValue", "(", "0", ")", ";", "SDValue", "Hi", "=", "Split64", ".", "getValue", "(", "1", ")", ";", "Register", "RegLo", "=", "VA", ".", "getLocReg", "(", ")", ";", "assert", "(", "RegLo", "<", "CSKY", "::", "R31", "&&", "\"Invalid register pair\"", ")", ";", "Register", "RegHi", "=", "RegLo", "+", "1", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "RegLo", ",", "Lo", ",", "Glue", ")", ";", "Glue", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "RegLo", ",", "MVT", "::", "i32", ")", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "RegHi", ",", "Hi", ",", "Glue", ")", ";", "Glue", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "RegHi", ",", "MVT", "::", "i32", ")", ")", ";", "}", "else", "{", "Val", "=", "convertValVTToLocVT", "(", "DAG", ",", "Val", ",", "VA", ",", "DL", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "Val", ",", "Glue", ")", ";", "Glue", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Glue", ".", "getNode", "(", ")", ")", "{", "RetOps", ".", "push_back", "(", "Glue", ")", ";", "}", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "return", "DAG", ".", "getNode", "(", "CSKYISD", "::", "NIR", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "return", "DAG", ".", "getNode", "(", "CSKYISD", "::", "RET", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", ""], "natrual_language": ["This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "."], "TS_V_token": ["CSKY", "CSKY", "ISD::OutputArg", "16", "CSKY", "CSKY", "4", "1", "0", "CSKY", "CSKY", "\"Can only return in registers!\"", "CSKY", "MVT::i32", "MVT::f64", "CSKY", "\"Expected return via registers\"", "CSKYISD::BITCAST_TO_LOHI", "MVT::i32", "MVT::i32", "0", "1", "CSKY::R31", "\"Invalid register pair\"", "1", "1", "MVT::i32", "1", "MVT::i32", "1", "0", "\"interrupt\"", "CSKYISD::NIR", "MVT::Other", "CSKYISD::RET", "MVT::Other"], "File": "CSKYISelLowering", "Func": "LowerReturn", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17257, "Length": 504} {"ground_truth": ["", "Register", "getGlobalBaseReg", "(", ")", "const", "{", "return", "GlobalBaseReg", ";", "}", ""], "natrual_language": ["getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "."], "TS_V_token": ["CSKY"], "File": "CSKYMachineFunctionInfo", "Func": "getGlobalBaseReg", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17258, "Length": 10} {"ground_truth": ["", "void", "CSKYMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "uint32_t", "Bin", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "uint16_t", "LO16", "=", "static_cast", "<", "uint16_t", ">", "(", "Bin", ")", ";", "uint16_t", "HI16", "=", "static_cast", "<", "uint16_t", ">", "(", "Bin", ">>", "16", ")", ";", "if", "(", "Size", "==", "4", ")", "support", "::", "endian", "::", "write", "<", "uint16_t", ">", "(", "OS", ",", "HI16", ",", "support", "::", "little", ")", ";", "support", "::", "endian", "::", "write", "<", "uint16_t", ">", "(", "OS", ",", "LO16", ",", "support", "::", "little", ")", ";", "++", "MCNumEmitted", ";", "}", ""], "natrual_language": ["Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "."], "TS_V_token": ["CSKY", "CSKY", "16", "4", "support::endian", "support::little", "support::endian", "support::little"], "File": "CSKYMCCodeEmitter2", "Func": "encodeInstruction", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17259, "Length": 135} {"ground_truth": ["", "void", "CSKYMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "++", "MCNumEmitted", ";", "uint32_t", "Bin", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "uint16_t", "LO16", "=", "static_cast", "<", "uint16_t", ">", "(", "Bin", ")", ";", "uint16_t", "HI16", "=", "static_cast", "<", "uint16_t", ">", "(", "Bin", ">>", "16", ")", ";", "if", "(", "Size", "==", "4", ")", "support", "::", "endian", "::", "write", "<", "uint16_t", ">", "(", "OS", ",", "HI16", ",", "support", "::", "little", ")", ";", "support", "::", "endian", "::", "write", "<", "uint16_t", ">", "(", "OS", ",", "LO16", ",", "support", "::", "little", ")", ";", "}", ""], "natrual_language": ["Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "."], "TS_V_token": ["CSKY", "CSKY", "16", "4", "support::endian", "support::little", "support::endian", "support::little"], "File": "CSKYMCCodeEmitter", "Func": "encodeInstruction", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17260, "Length": 135} {"ground_truth": ["", "unsigned", "CSKYMCCodeEmitter", "::", "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", "(", ")", ")", ";", "llvm_unreachable", "(", "\"Unhandled expression!\"", ")", ";", "return", "0", ";", "}", ""], "natrual_language": ["getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "."], "TS_V_token": ["CSKY", "CSKY", "\"Unhandled expression!\"", "0"], "File": "CSKYMCCodeEmitter", "Func": "getMachineOpValue", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17261, "Length": 83} {"ground_truth": ["", "StringRef", "CSKYMCExpr", "::", "getVariantKindName", "(", "VariantKind", "Kind", ")", "{", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid ELF symbol kind\"", ")", ";", "case", "VK_CSKY_ADDR", ":", "return", "\"\"", ";", "case", "VK_CSKY_PCREL", ":", "return", "\"\"", ";", "case", "VK_CSKY_GOT", ":", "return", "\"@GOT\"", ";", "case", "VK_CSKY_GOTPC", ":", "return", "\"@GOTPC\"", ";", "case", "VK_CSKY_GOTOFF", ":", "return", "\"@GOTOFF\"", ";", "case", "VK_CSKY_PLT", ":", "return", "\"@PLT\"", ";", "case", "VK_CSKY_TPOFF", ":", "return", "\"@TPOFF\"", ";", "case", "VK_CSKY_TLSGD", ":", "return", "\"@TLSGD\"", ";", "}", "}", ""], "natrual_language": ["Convert", "the", "variant", "kind", "into", "an", "ELF-appropriate", "modifier", "(", "e.g", "."], "TS_V_token": ["CSKY", "CSKY", "\"Invalid ELF symbol kind\"", "CSKY", "\"\"", "CSKY", "\"\"", "CSKY", "\"@GOT\"", "CSKY", "\"@GOTPC\"", "CSKY", "\"@GOTOFF\"", "CSKY", "\"@PLT\"", "CSKY", "\"@TPOFF\"", "CSKY", "\"@TLSGD\""], "File": "CSKYMCExpr2", "Func": "getVariantKindName", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17262, "Length": 71} {"ground_truth": ["", "static", "bool", "classof", "(", "const", "MCExpr", "*", "E", ")", "{", "return", "E", "->", "getKind", "(", ")", "==", "MCExpr", "::", "Target", ";", "}", ""], "natrual_language": ["Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":"], "TS_V_token": ["CSKY"], "File": "CSKYMCExpr", "Func": "classof", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17263, "Length": 22} {"ground_truth": ["", "const", "CSKYMCExpr", "*", "CSKYMCExpr", "::", "create", "(", "const", "MCExpr", "*", "Expr", ",", "VariantKind", "Kind", ",", "MCContext", "&", "Ctx", ")", "{", "return", "new", "(", "Ctx", ")", "CSKYMCExpr", "(", "Kind", ",", "Expr", ")", ";", "}", ""], "natrual_language": ["This", "creates", "an", "identified", "struct", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY"], "File": "CSKYMCExpr", "Func": "create", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17264, "Length": 33} {"ground_truth": ["", "MCFragment", "*", "findAssociatedFragment", "(", ")", "const", "override", "{", "return", "getSubExpr", "(", ")", "->", "findAssociatedFragment", "(", ")", ";", "}", ""], "natrual_language": ["Find", "the", "``", "associated", "section", "''", "for", "this", "expression", ",", "which", "is", "currently", "defined", "as", "the", "absolute", "section", "for", "constants", ",", "or", "otherwise", "the", "section", "associated", "with", "the", "first", "defined", "symbol", "in", "the", "expression", "."], "TS_V_token": ["CSKY"], "File": "CSKYMCExpr", "Func": "findAssociatedFragment", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17265, "Length": 18} {"ground_truth": ["", "VariantKind", "getKind", "(", ")", "const", "{", "return", "Kind", ";", "}", ""], "natrual_language": ["Returns", "the", "Kind", "of", "lane", "offset", "."], "TS_V_token": ["CSKY"], "File": "CSKYMCExpr", "Func": "getKind", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17266, "Length": 10} {"ground_truth": ["", "const", "MCExpr", "*", "getSubExpr", "(", ")", "const", "{", "return", "Expr", ";", "}", ""], "natrual_language": ["getSubExpr", "-", "Get", "the", "child", "of", "this", "expression", "."], "TS_V_token": ["CSKY"], "File": "CSKYMCExpr", "Func": "getSubExpr", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17267, "Length": 12} {"ground_truth": ["", "StringRef", "CSKYMCExpr", "::", "getVariantKindName", "(", "VariantKind", "Kind", ")", "{", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid ELF symbol kind\"", ")", ";", "case", "VK_CSKY_None", ":", "case", "VK_CSKY_ADDR", ":", "return", "\"\"", ";", "case", "VK_CSKY_ADDR_HI16", ":", "return", "\"@HI16\"", ";", "case", "VK_CSKY_ADDR_LO16", ":", "return", "\"@LO16\"", ";", "case", "VK_CSKY_GOT_IMM18_BY4", ":", "case", "VK_CSKY_GOT", ":", "return", "\"@GOT\"", ";", "case", "VK_CSKY_GOTPC", ":", "return", "\"@GOTPC\"", ";", "case", "VK_CSKY_GOTOFF", ":", "return", "\"@GOTOFF\"", ";", "case", "VK_CSKY_PLT_IMM18_BY4", ":", "case", "VK_CSKY_PLT", ":", "return", "\"@PLT\"", ";", "case", "VK_CSKY_TLSLE", ":", "return", "\"@TPOFF\"", ";", "case", "VK_CSKY_TLSIE", ":", "return", "\"@GOTTPOFF\"", ";", "case", "VK_CSKY_TLSGD", ":", "return", "\"@TLSGD32\"", ";", "case", "VK_CSKY_TLSLDO", ":", "return", "\"@TLSLDO32\"", ";", "case", "VK_CSKY_TLSLDM", ":", "return", "\"@TLSLDM32\"", ";", "}", "}", ""], "natrual_language": ["Convert", "the", "variant", "kind", "into", "an", "ELF-appropriate", "modifier", "(", "e.g", "."], "TS_V_token": ["CSKY", "CSKY", "\"Invalid ELF symbol kind\"", "CSKY", "CSKY", "\"\"", "CSKY", "\"@HI16\"", "CSKY", "\"@LO16\"", "CSKY", "CSKY", "\"@GOT\"", "CSKY", "\"@GOTPC\"", "CSKY", "\"@GOTOFF\"", "CSKY", "CSKY", "\"@PLT\"", "CSKY", "\"@TPOFF\"", "CSKY", "\"@GOTTPOFF\"", "CSKY", "\"@TLSGD32\"", "CSKY", "\"@TLSLDO32\"", "CSKY", "\"@TLSLDM32\""], "File": "CSKYMCExpr", "Func": "getVariantKindName", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17268, "Length": 104} {"ground_truth": ["", "bool", "CSKYMCInstLower", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "const", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_RegisterMask", ":", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "return", "false", ";", "MCOp", "=", "MCOperand", "::", "createReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "Ctx", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Printer", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MCSymbol", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "MO", ".", "getMCSymbol", "(", ")", ")", ";", "break", ";", "}", "return", "true", ";", "}", ""], "natrual_language": ["Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "."], "TS_V_token": ["CSKY", "CSKY", "\"unknown operand type\""], "File": "CSKYMCInstLower", "Func": "lowerOperand", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17269, "Length": 271} {"ground_truth": ["", "bool", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "override", "{", "if", "(", "isConditionalBranch", "(", "Inst", ")", "||", "isUnconditionalBranch", "(", "Inst", ")", ")", "{", "int64_t", "Imm", ";", "Imm", "=", "Inst", ".", "getOperand", "(", "Inst", ".", "getNumOperands", "(", ")", "-", "1", ")", ".", "getImm", "(", ")", ";", "Target", "=", "Addr", "+", "Imm", ";", "return", "true", ";", "}", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "BSR32", ")", "{", "Target", "=", "Addr", "+", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "CSKY", "::", "LRW16", ":", "case", "CSKY", "::", "LRW32", ":", "case", "CSKY", "::", "JSRI32", ":", "case", "CSKY", "::", "JMPI32", ":", "int64_t", "Imm", "=", "Inst", ".", "getOperand", "(", "Inst", ".", "getNumOperands", "(", ")", "-", "1", ")", ".", "getImm", "(", ")", ";", "Target", "=", "(", "(", "Addr", "+", "Imm", ")", "&", "0xFFFFFFFC", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", ""], "natrual_language": ["Given", "a", "branch", "instruction", "try", "to", "get", "the", "address", "the", "branch", "targets", "."], "TS_V_token": ["CSKY", "1", "CSKY::BSR32", "0", "CSKY::LRW16", "CSKY::LRW32", "CSKY::JSRI32", "CSKY::JMPI32", "1", "0xFFFFFFFC"], "File": "CSKYMCTargetDesc", "Func": "evaluateBranch", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17270, "Length": 172} {"ground_truth": ["", "const", "MCPhysReg", "*", "CSKYRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "CSKYSubtarget", "&", "STI", "=", "MF", "->", "getSubtarget", "<", "CSKYSubtarget", ">", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "if", "(", "STI", ".", "hasFPUv3DoubleFloat", "(", ")", ")", "return", "CSR_GPR_FPR64v3_ISR_SaveList", ";", "if", "(", "STI", ".", "hasFPUv3SingleFloat", "(", ")", ")", "return", "CSR_GPR_FPR32v3_ISR_SaveList", ";", "if", "(", "STI", ".", "hasFPUv2DoubleFloat", "(", ")", ")", "return", "CSR_GPR_FPR64_ISR_SaveList", ";", "if", "(", "STI", ".", "hasFPUv2SingleFloat", "(", ")", ")", "return", "CSR_GPR_FPR32_ISR_SaveList", ";", "return", "CSR_GPR_ISR_SaveList", ";", "}", "if", "(", "STI", ".", "hasFPUv2DoubleFloat", "(", ")", "||", "STI", ".", "hasFPUv3DoubleFloat", "(", ")", ")", "return", "CSR_GPR_FPR64_SaveList", ";", "if", "(", "STI", ".", "hasFPUv2SingleFloat", "(", ")", "||", "STI", ".", "hasFPUv3SingleFloat", "(", ")", ")", "return", "CSR_GPR_FPR32_SaveList", ";", "return", "CSR_I32_SaveList", ";", "}", ""], "natrual_language": ["Code", "Generation", "virtual", "methods", "..."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY", "\"interrupt\""], "File": "CSKYRegisterInfo1", "Func": "getCalleeSavedRegs", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17271, "Length": 128} {"ground_truth": ["", "const", "uint32_t", "*", "CSKYRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "Id", ")", "const", "{", "const", "CSKYSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "CSKYSubtarget", ">", "(", ")", ";", "if", "(", "STI", ".", "hasFPUv2DoubleFloat", "(", ")", "||", "STI", ".", "hasFPUv3DoubleFloat", "(", ")", ")", "return", "CSR_GPR_FPR64_RegMask", ";", "if", "(", "STI", ".", "hasFPUv2SingleFloat", "(", ")", "||", "STI", ".", "hasFPUv3SingleFloat", "(", ")", ")", "return", "CSR_GPR_FPR32_RegMask", ";", "return", "CSR_I32_RegMask", ";", "}", ""], "natrual_language": ["Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY"], "File": "CSKYRegisterInfo1", "Func": "getCallPreservedMask", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17272, "Length": 71} {"ground_truth": ["", "bool", "requiresFrameIndexScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "true", ";", "}", ""], "natrual_language": ["Returns", "true", "if", "the", "target", "requires", "post", "PEI", "scavenging", "of", "registers", "for", "materializing", "frame", "index", "constants", "."], "TS_V_token": ["CSKY"], "File": "CSKYRegisterInfo1", "Func": "requiresFrameIndexScavenging", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17273, "Length": 15} {"ground_truth": ["", "bool", "requiresRegisterScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "true", ";", "}", ""], "natrual_language": ["Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "."], "TS_V_token": ["CSKY"], "File": "CSKYRegisterInfo1", "Func": "requiresRegisterScavenging", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17274, "Length": 15} {"ground_truth": ["", "bool", "useFPForScavengingIndex", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "false", ";", "}", ""], "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": ["CSKY"], "File": "CSKYRegisterInfo1", "Func": "useFPForScavengingIndex", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17275, "Length": 15} {"ground_truth": ["", "void", "CSKYRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected non-zero SPAdj value\"", ")", ";", "}", ""], "natrual_language": ["This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "."], "TS_V_token": ["CSKY", "CSKY", "0", "\"Unexpected non-zero SPAdj value\""], "File": "CSKYRegisterInfo", "Func": "eliminateFrameIndex", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17276, "Length": 32} {"ground_truth": ["", "const", "MCPhysReg", "*", "CSKYRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "CSKYSubtarget", "&", "STI", "=", "MF", "->", "getSubtarget", "<", "CSKYSubtarget", ">", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "return", "CSR_GPR_ISR_SaveList", ";", "}", "return", "CSR_I32_SaveList", ";", "}", ""], "natrual_language": ["Code", "Generation", "virtual", "methods", "..."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY", "\"interrupt\""], "File": "CSKYRegisterInfo", "Func": "getCalleeSavedRegs", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17277, "Length": 50} {"ground_truth": ["", "const", "uint32_t", "*", "CSKYRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "Id", ")", "const", "{", "const", "CSKYSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "CSKYSubtarget", ">", "(", ")", ";", "return", "CSR_I32_RegMask", ";", "}", ""], "natrual_language": ["Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY"], "File": "CSKYRegisterInfo", "Func": "getCallPreservedMask", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17278, "Length": 37} {"ground_truth": ["", "Register", "CSKYRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "CSKY", "::", "R8", ":", "CSKY", "::", "R14", ";", "}", ""], "natrual_language": ["Debug", "information", "queries", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY::R8", "CSKY::R14"], "File": "CSKYRegisterInfo", "Func": "getFrameRegister", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17279, "Length": 39} {"ground_truth": ["", "const", "uint32_t", "*", "CSKYRegisterInfo", "::", "getNoPreservedMask", "(", ")", "const", "{", "return", "CSR_NoRegs_RegMask", ";", "}", ""], "natrual_language": ["Return", "a", "register", "mask", "that", "clobbers", "everything", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYRegisterInfo", "Func": "getNoPreservedMask", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17280, "Length": 14} {"ground_truth": ["", "BitVector", "CSKYRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "CSKYFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "const", "CSKYSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "CSKYSubtarget", ">", "(", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "if", "(", "TFI", "->", "hasBP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "CSKY", "::", "R7", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "CSKY", "::", "R8", ")", ";", "if", "(", "!", "STI", ".", "hasE2", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "6", ";", "i", "++", ")", "markSuperRegs", "(", "Reserved", ",", "CSKY", "::", "R8", "+", "i", ")", ";", "}", "markSuperRegs", "(", "Reserved", ",", "CSKY", "::", "R14", ")", ";", "markSuperRegs", "(", "Reserved", ",", "CSKY", "::", "R15", ")", ";", "if", "(", "!", "STI", ".", "hasHighRegisters", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "10", ";", "i", "++", ")", "markSuperRegs", "(", "Reserved", ",", "CSKY", "::", "R16", "+", "i", ")", ";", "}", "markSuperRegs", "(", "Reserved", ",", "CSKY", "::", "R26", ")", ";", "markSuperRegs", "(", "Reserved", ",", "CSKY", "::", "R27", ")", ";", "markSuperRegs", "(", "Reserved", ",", "CSKY", "::", "R28", ")", ";", "markSuperRegs", "(", "Reserved", ",", "CSKY", "::", "R29", ")", ";", "markSuperRegs", "(", "Reserved", ",", "CSKY", "::", "R30", ")", ";", "markSuperRegs", "(", "Reserved", ",", "CSKY", "::", "R31", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "return", "Reserved", ";", "}", ""], "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": ["CSKY", "CSKY", "CSKY", "CSKY", "CSKY", "CSKY::R7", "CSKY::R8", "0", "6", "CSKY::R8", "CSKY::R14", "CSKY::R15", "0", "10", "CSKY::R16", "CSKY::R26", "CSKY::R27", "CSKY::R28", "CSKY::R29", "CSKY::R30", "CSKY::R31"], "File": "CSKYRegisterInfo", "Func": "getReservedRegs", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17281, "Length": 236} {"ground_truth": ["", "CSKYSubtarget", "&", "CSKYSubtarget", "::", "initializeSubtargetDependencies", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPUName", ",", "StringRef", "TuneCPUName", ",", "StringRef", "FS", ")", "{", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"generic\"", ";", "if", "(", "TuneCPUName", ".", "empty", "(", ")", ")", "TuneCPUName", "=", "CPUName", ";", "UseHardFloat", "=", "false", ";", "UseHardFloatABI", "=", "false", ";", "HasFPUv2SingleFloat", "=", "false", ";", "HasFPUv2DoubleFloat", "=", "false", ";", "HasFPUv3HalfWord", "=", "false", ";", "HasFPUv3HalfFloat", "=", "false", ";", "HasFPUv3SingleFloat", "=", "false", ";", "HasFPUv3DoubleFloat", "=", "false", ";", "HasFdivdu", "=", "false", ";", "HasFLOATE1", "=", "false", ";", "HasFLOAT1E2", "=", "false", ";", "HasFLOAT1E3", "=", "false", ";", "HasFLOAT3E4", "=", "false", ";", "HasFLOAT7E60", "=", "false", ";", "HasExtendLrw", "=", "false", ";", "HasBTST16", "=", "false", ";", "HasTrust", "=", "false", ";", "HasJAVA", "=", "false", ";", "HasCache", "=", "false", ";", "HasNVIC", "=", "false", ";", "HasDSP", "=", "false", ";", "HasDSP1E2", "=", "false", ";", "HasDSPE60", "=", "false", ";", "HasDSPV2", "=", "false", ";", "HasDSP_Silan", "=", "false", ";", "HasDoloop", "=", "false", ";", "HasHardwareDivide", "=", "false", ";", "HasHighRegisters", "=", "false", ";", "HasVDSPV2", "=", "false", ";", "HasVDSP2E3", "=", "false", ";", "HasVDSP2E60F", "=", "false", ";", "ReadTPHard", "=", "false", ";", "HasVDSPV1_128", "=", "false", ";", "UseCCRT", "=", "false", ";", "DumpConstPool", "=", "false", ";", "EnableInterruptAttribute", "=", "false", ";", "HasPushPop", "=", "false", ";", "HasSTM", "=", "false", ";", "SmartMode", "=", "false", ";", "EnableStackSize", "=", "false", ";", "HasE1", "=", "false", ";", "HasE2", "=", "false", ";", "Has2E3", "=", "false", ";", "HasMP", "=", "false", ";", "Has3E3r1", "=", "false", ";", "Has3r1E3r2", "=", "false", ";", "Has3r2E3r3", "=", "false", ";", "Has3E7", "=", "false", ";", "HasMP1E2", "=", "false", ";", "Has7E10", "=", "false", ";", "Has10E60", "=", "false", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "TuneCPUName", ",", "FS", ")", ";", "return", "*", "this", ";", "}", ""], "natrual_language": ["initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "\"generic\""], "File": "CSKYSubtarget1", "Func": "initializeSubtargetDependencies", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17282, "Length": 263} {"ground_truth": ["", "CSKYSubtarget", "&", "CSKYSubtarget", "::", "initializeSubtargetDependencies", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPUName", ",", "StringRef", "TuneCPUName", ",", "StringRef", "FS", ")", "{", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"generic\"", ";", "if", "(", "TuneCPUName", ".", "empty", "(", ")", ")", "TuneCPUName", "=", "CPUName", ";", "UseHardFloat", "=", "false", ";", "UseHardFloatABI", "=", "false", ";", "HasFPUv2SingleFloat", "=", "false", ";", "HasFPUv2DoubleFloat", "=", "false", ";", "HasFPUv3SingleFloat", "=", "false", ";", "HasFPUv3DoubleFloat", "=", "false", ";", "HasBTST16", "=", "false", ";", "HasJAVA", "=", "false", ";", "HasExtendLrw", "=", "false", ";", "HasDoloop", "=", "false", ";", "HasHighRegisters", "=", "false", ";", "HasE1", "=", "false", ";", "HasE2", "=", "false", ";", "Has2E3", "=", "false", ";", "HasMP", "=", "false", ";", "Has3E3r1", "=", "false", ";", "Has3r1E3r2", "=", "false", ";", "Has3r2E3r3", "=", "false", ";", "Has3E7", "=", "false", ";", "HasMP1E2", "=", "false", ";", "Has7E10", "=", "false", ";", "Has10E60", "=", "false", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "TuneCPUName", ",", "FS", ")", ";", "return", "*", "this", ";", "}", ""], "natrual_language": ["initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "\"generic\""], "File": "CSKYSubtarget2", "Func": "initializeSubtargetDependencies", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17283, "Length": 147} {"ground_truth": ["", "const", "CSKYInstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ";", "}", ""], "natrual_language": ["TargetInstrInfo", "getter", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYSubtarget", "Func": "getInstrInfo", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17284, "Length": 14} {"ground_truth": ["", "const", "CSKYRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "RegInfo", ";", "}", ""], "natrual_language": ["getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYSubtarget", "Func": "getRegisterInfo", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17285, "Length": 14} {"ground_truth": ["", "CSKYSubtarget", "&", "CSKYSubtarget", "::", "initializeSubtargetDependencies", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPUName", ",", "StringRef", "TuneCPUName", ",", "StringRef", "FS", ")", "{", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"generic\"", ";", "if", "(", "TuneCPUName", ".", "empty", "(", ")", ")", "TuneCPUName", "=", "CPUName", ";", "HasE1", "=", "false", ";", "HasE2", "=", "false", ";", "Has2E3", "=", "false", ";", "HasMP", "=", "false", ";", "Has3E3r1", "=", "false", ";", "Has3r1E3r2", "=", "false", ";", "Has3r2E3r3", "=", "false", ";", "Has3E7", "=", "false", ";", "HasMP1E2", "=", "false", ";", "Has7E10", "=", "false", ";", "Has10E60", "=", "false", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "TuneCPUName", ",", "FS", ")", ";", "return", "*", "this", ";", "}", ""], "natrual_language": ["initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "\"generic\""], "File": "CSKYSubtarget", "Func": "initializeSubtargetDependencies", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17286, "Length": 103} {"ground_truth": ["", "bool", "CSKYPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createCSKYISelDag", "(", "getCSKYTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", ""], "natrual_language": ["addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY"], "File": "CSKYTargetMachine (2)", "Func": "addInstSelector", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17287, "Length": 21} {"ground_truth": ["", "void", "CSKYPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", ""], "natrual_language": ["Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYTargetMachine (2)", "Func": "addIRPasses", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17288, "Length": 21} {"ground_truth": ["", "void", "CSKYPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createCSKYConstantIslandPass", "(", ")", ")", ";", "}", ""], "natrual_language": ["This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY"], "File": "CSKYTargetMachine (2)", "Func": "addPreEmitPass", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17289, "Length": 15} {"ground_truth": ["", "TargetPassConfig", "*", "CSKYTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "CSKYPassConfig", "(", "*", "this", ",", "PM", ")", ";", "}", ""], "natrual_language": ["Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY"], "File": "CSKYTargetMachine (2)", "Func": "createPassConfig", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17290, "Length": 22} {"ground_truth": ["", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", ""], "natrual_language": ["Return", "information", "about", "object", "file", "lowering", "."], "TS_V_token": ["CSKY"], "File": "CSKYTargetMachine (2)", "Func": "getObjFileLowering", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17291, "Length": 16} {"ground_truth": ["", "const", "CSKYSubtarget", "*", "CSKYTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "TuneAttr", "=", "F", ".", "getFnAttribute", "(", "\"tune-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "CPUAttr", ".", "isValid", "(", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "TuneCPU", "=", "TuneAttr", ".", "isValid", "(", ")", "?", "TuneAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "CPU", ";", "std", "::", "string", "FS", "=", "FSAttr", ".", "isValid", "(", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "std", "::", "string", "Key", "=", "CPU", "+", "TuneCPU", "+", "FS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "CSKYSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "TuneCPU", ",", "FS", ",", "*", "this", ")", ";", "if", "(", "I", "->", "useHardFloat", "(", ")", "&&", "!", "I", "->", "hasAnyFloatExt", "(", ")", ")", "errs", "(", ")", "<<", "\"Hard-float can't be used with current CPU,\"", "\" set to Soft-float\\n\"", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", ""], "natrual_language": ["Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "\"target-cpu\"", "\"tune-cpu\"", "\"target-features\"", "CSKY", "\"Hard-float can't be used with current CPU,\"", "\" set to Soft-float\\n\""], "File": "CSKYTargetMachine (2)", "Func": "getSubtargetImpl", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17292, "Length": 196} {"ground_truth": ["", "void", "CSKYELFTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "LSDAEncoding", "=", "dwarf", "::", "DW_EH_PE_pcrel", "|", "dwarf", "::", "DW_EH_PE_sdata4", ";", "PersonalityEncoding", "=", "dwarf", "::", "DW_EH_PE_indirect", "|", "dwarf", "::", "DW_EH_PE_pcrel", "|", "dwarf", "::", "DW_EH_PE_sdata4", ";", "TTypeEncoding", "=", "dwarf", "::", "DW_EH_PE_indirect", "|", "dwarf", "::", "DW_EH_PE_pcrel", "|", "dwarf", "::", "DW_EH_PE_sdata4", ";", "}", ""], "natrual_language": ["This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYTargetObjectFile", "Func": "Initialize", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17293, "Length": 63} {"ground_truth": ["", "const", "MCExpr", "*", "CSKYTargetStreamer", "::", "addConstantPoolEntry", "(", "const", "MCExpr", "*", "Expr", ",", "SMLoc", "Loc", ",", "const", "MCExpr", "*", "AdjustExpr", ")", "{", "auto", "ELFRefKind", "=", "CSKYMCExpr", "::", "VK_CSKY_Invalid", ";", "ConstantCounter", "++", ";", "const", "MCExpr", "*", "OrigExpr", "=", "Expr", ";", "if", "(", "const", "CSKYMCExpr", "*", "CE", "=", "dyn_cast", "<", "CSKYMCExpr", ">", "(", "Expr", ")", ")", "{", "Expr", "=", "CE", "->", "getSubExpr", "(", ")", ";", "ELFRefKind", "=", "CE", "->", "getKind", "(", ")", ";", "}", "if", "(", "const", "MCSymbolRefExpr", "*", "SymExpr", "=", "dyn_cast", "<", "MCSymbolRefExpr", ">", "(", "Expr", ")", ")", "{", "const", "MCSymbol", "*", "Sym", "=", "&", "SymExpr", "->", "getSymbol", "(", ")", ";", "SymbolIndex", "Index", "=", "{", "Sym", ",", "ELFRefKind", "}", ";", "if", "(", "ConstantMap", ".", "find", "(", "Index", ")", "==", "ConstantMap", ".", "end", "(", ")", ")", "{", "ConstantMap", "[", "Index", "]", "=", "ConstantPool", "->", "addEntry", "(", "getStreamer", "(", ")", ",", "OrigExpr", ",", "4", ",", "Loc", ",", "AdjustExpr", ")", ";", "}", "return", "ConstantMap", "[", "Index", "]", ";", "}", "return", "ConstantPool", "->", "addEntry", "(", "getStreamer", "(", ")", ",", "Expr", ",", "4", ",", "Loc", ",", "AdjustExpr", ")", ";", "}", ""], "natrual_language": ["Add", "a", "new", "entry", "to", "the", "constant", "pool", "for", "the", "current", "section", "and", "return", "an", "MCExpr", "that", "can", "be", "used", "to", "refer", "to", "the", "constant", "pool", "location", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY", "CSKY", "CSKY", "4", "4"], "File": "CSKYTargetStreamer", "Func": "addConstantPoolEntry", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17294, "Length": 173} {"ground_truth": ["", "void", "CSKYTargetStreamer", "::", "emitCurrentConstantPool", "(", ")", "{", "ConstantPool", "->", "emitAll", "(", "Streamer", ")", ";", "ConstantPool", "->", "clearCache", "(", ")", ";", "}", ""], "natrual_language": ["Callback", "used", "to", "implement", "the", ".ltorg", "directive", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYTargetStreamer", "Func": "emitCurrentConstantPool", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17295, "Length": 21} {"ground_truth": ["", "void", "CSKYTargetStreamer", "::", "emitTargetAttributes", "(", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "}", ""], "natrual_language": ["Emit", "the", "build", "attributes", "that", "only", "depend", "on", "the", "hardware", "that", "we", "expect", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYTargetStreamer", "Func": "emitTargetAttributes", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17296, "Length": 12} {"ground_truth": ["", "bool", "CSKYConstantPool", "::", "empty", "(", ")", "{", "return", "Entries", ".", "empty", "(", ")", ";", "}", ""], "natrual_language": ["Determine", "whether", "this", "version", "information", "is", "empty", "(", "e.g.", ",", "all", "version", "components", "are", "zero", ")", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYTargetStreamer", "Func": "empty", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17297, "Length": 15} {"ground_truth": ["", "void", "CSKYTargetStreamer", "::", "finish", "(", ")", "{", "if", "(", "ConstantCounter", "!=", "0", ")", "{", "ConstantPool", "->", "emitAll", "(", "Streamer", ")", ";", "}", "finishAttributeSection", "(", ")", ";", "}", ""], "natrual_language": ["finish", "-", "after", "all", "the", "new", "live", "ranges", "have", "been", "created", ",", "compute", "the", "remaining", "live", "range", ",", "and", "rewrite", "instructions", "to", "use", "the", "new", "registers", "."], "TS_V_token": ["CSKY", "CSKY", "0"], "File": "CSKYTargetStreamer", "Func": "finish", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17298, "Length": 27} {"ground_truth": ["", "static", "inline", "CSKYTargetStreamer", "::", "SymbolIndex", "getEmptyKey", "(", ")", "{", "return", "{", "nullptr", ",", "CSKYMCExpr", "::", "VK_CSKY_Invalid", "}", ";", "}", ""], "natrual_language": ["Empty", "key", ":", "no", "key", "should", "be", "generated", "that", "has", "no", "DILocalVariable", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY"], "File": "CSKYTargetStreamer", "Func": "getEmptyKey", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17299, "Length": 19} {"ground_truth": ["", "static", "unsigned", "getHashValue", "(", "const", "CSKYTargetStreamer", "::", "SymbolIndex", "&", "V", ")", "{", "return", "hash_combine", "(", "DenseMapInfo", "<", "const", "MCSymbol", "*", ">", "::", "getHashValue", "(", "V", ".", "sym", ")", ",", "DenseMapInfo", "<", "int", ">", "::", "getHashValue", "(", "V", ".", "kind", ")", ")", ";", "}", ""], "natrual_language": ["Using", "name", "and", "line", "to", "get", "hash", "value", ".", "It", "should", "already", "be", "mostly", "unique", "."], "TS_V_token": ["CSKY", "CSKY"], "File": "CSKYTargetStreamer", "Func": "getHashValue", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17300, "Length": 43} {"ground_truth": ["", "static", "inline", "CSKYTargetStreamer", "::", "SymbolIndex", "getTombstoneKey", "(", ")", "{", "return", "{", "nullptr", ",", "CSKYMCExpr", "::", "VK_CSKY_Invalid", "}", ";", "}", ""], "natrual_language": ["Difference", "in", "tombstone", "is", "that", "the", "Optional", "is", "meaningful", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY", "CSKY"], "File": "CSKYTargetStreamer", "Func": "getTombstoneKey", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17301, "Length": 19} {"ground_truth": ["", "static", "bool", "isEqual", "(", "const", "CSKYTargetStreamer", "::", "SymbolIndex", "&", "A", ",", "const", "CSKYTargetStreamer", "::", "SymbolIndex", "&", "B", ")", "{", "return", "A", ".", "sym", "==", "B", ".", "sym", "&&", "A", ".", "kind", "==", "B", ".", "kind", ";", "}", ""], "natrual_language": ["isEqual", "-", "Compares", "two", "trees", "for", "structural", "equality", "and", "returns", "true", "if", "they", "are", "equal", "."], "TS_V_token": ["CSKY", "CSKY", "CSKY"], "File": "CSKYTargetStreamer", "Func": "isEqual", "Target": "CSKY", "Target_Clf": "CPU", "Compiler_Type": "LLVM", "Idx": 17302, "Length": 37}