X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=lib%2FBitcode%2FWriter%2FBitcodeWriter.cpp;h=dfbfc9c0bea0e14cd0b5abbc5e695e70f1964523;hp=2eb67219c8a7a791a9480eb289dae35a1b3dc3cd;hb=aa7c94359cf7a8f5781e63f53934628a0fe672da;hpb=e8d9f7b5d1b848c1ed75e70947197658fc45c07a diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp index 2eb67219c8a..dfbfc9c0bea 100644 --- a/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/lib/Bitcode/Writer/BitcodeWriter.cpp @@ -17,6 +17,7 @@ #include "llvm/Bitcode/BitstreamWriter.h" #include "llvm/Bitcode/LLVMBitCodes.h" #include "llvm/IR/Constants.h" +#include "llvm/IR/DebugInfoMetadata.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/InlineAsm.h" #include "llvm/IR/Instructions.h" @@ -480,13 +481,13 @@ static unsigned getEncodedLinkage(const GlobalValue &GV) { case GlobalValue::ExternalLinkage: return 0; case GlobalValue::WeakAnyLinkage: - return 1; + return 16; case GlobalValue::AppendingLinkage: return 2; case GlobalValue::InternalLinkage: return 3; case GlobalValue::LinkOnceAnyLinkage: - return 4; + return 18; case GlobalValue::ExternalWeakLinkage: return 7; case GlobalValue::CommonLinkage: @@ -494,9 +495,9 @@ static unsigned getEncodedLinkage(const GlobalValue &GV) { case GlobalValue::PrivateLinkage: return 9; case GlobalValue::WeakODRLinkage: - return 10; + return 17; case GlobalValue::LinkOnceODRLinkage: - return 11; + return 19; case GlobalValue::AvailableExternallyLinkage: return 12; } @@ -549,11 +550,13 @@ static unsigned getEncodedComdatSelectionKind(const Comdat &C) { } static void writeComdats(const ValueEnumerator &VE, BitstreamWriter &Stream) { - SmallVector Vals; + SmallVector Vals; for (const Comdat *C : VE.getComdats()) { // COMDAT: [selection_kind, name] Vals.push_back(getEncodedComdatSelectionKind(*C)); - Vals.push_back(C->getName().size()); + size_t Size = C->getName().size(); + assert(isUInt<16>(Size)); + Vals.push_back(Size); for (char Chr : C->getName()) Vals.push_back((unsigned char)Chr); Stream.EmitRecord(bitc::MODULE_CODE_COMDAT, Vals, /*AbbrevToUse=*/0); @@ -627,7 +630,7 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE, Log2_32_Ceil(MaxGlobalType+1))); Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Constant. Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Initializer. - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // Linkage. + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // Linkage. if (MaxAlignment == 0) // Alignment. Abbv->Add(BitCodeAbbrevOp(0)); else { @@ -651,7 +654,8 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE, // GLOBALVAR: [type, isconst, initid, // linkage, alignment, section, visibility, threadlocal, - // unnamed_addr, externally_initialized, dllstorageclass] + // unnamed_addr, externally_initialized, dllstorageclass, + // comdat] Vals.push_back(VE.getTypeID(GV.getType())); Vals.push_back(GV.isConstant()); Vals.push_back(GV.isDeclaration() ? 0 : @@ -760,90 +764,276 @@ static void WriteValueAsMetadata(const ValueAsMetadata *MD, Record.clear(); } -static void WriteMDNode(const MDNode *N, - const ValueEnumerator &VE, - BitstreamWriter &Stream, - SmallVectorImpl &Record) { +static void WriteMDTuple(const MDTuple *N, const ValueEnumerator &VE, + BitstreamWriter &Stream, + SmallVectorImpl &Record, unsigned Abbrev) { for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) { Metadata *MD = N->getOperand(i); - if (!MD) { - Record.push_back(0); - continue; - } - assert(!isa(MD) && "Unexpected function-local metadata"); - Record.push_back(VE.getMetadataID(MD) + 1); + assert(!(MD && isa(MD)) && + "Unexpected function-local metadata"); + Record.push_back(VE.getMetadataOrNullID(MD)); } - Stream.EmitRecord(bitc::METADATA_NODE, Record); + Stream.EmitRecord(N->isDistinct() ? bitc::METADATA_DISTINCT_NODE + : bitc::METADATA_NODE, + Record, Abbrev); + Record.clear(); +} + +static void WriteMDLocation(const MDLocation *N, const ValueEnumerator &VE, + BitstreamWriter &Stream, + SmallVectorImpl &Record, + unsigned Abbrev) { + Record.push_back(N->isDistinct()); + Record.push_back(N->getLine()); + Record.push_back(N->getColumn()); + Record.push_back(VE.getMetadataID(N->getScope())); + Record.push_back(VE.getMetadataOrNullID(N->getInlinedAt())); + + Stream.EmitRecord(bitc::METADATA_LOCATION, Record, Abbrev); + Record.clear(); +} + +static void WriteGenericDebugNode(const GenericDebugNode *N, + const ValueEnumerator &VE, + BitstreamWriter &Stream, + SmallVectorImpl &Record, + unsigned Abbrev) { + Record.push_back(N->isDistinct()); + Record.push_back(N->getTag()); + Record.push_back(0); // Per-tag version field; unused for now. + + for (auto &I : N->operands()) + Record.push_back(VE.getMetadataOrNullID(I)); + + Stream.EmitRecord(bitc::METADATA_GENERIC_DEBUG, Record, Abbrev); + Record.clear(); +} + +static uint64_t rotateSign(int64_t I) { + uint64_t U = I; + return I < 0 ? ~(U << 1) : U << 1; +} + +static void WriteMDSubrange(const MDSubrange *N, const ValueEnumerator &, + BitstreamWriter &Stream, + SmallVectorImpl &Record, + unsigned Abbrev) { + Record.push_back(N->isDistinct()); + Record.push_back(N->getCount()); + Record.push_back(rotateSign(N->getLo())); + + Stream.EmitRecord(bitc::METADATA_SUBRANGE, Record, Abbrev); + Record.clear(); +} + +static void WriteMDEnumerator(const MDEnumerator *N, const ValueEnumerator &VE, + BitstreamWriter &Stream, + SmallVectorImpl &Record, + unsigned Abbrev) { + Record.push_back(N->isDistinct()); + Record.push_back(rotateSign(N->getValue())); + Record.push_back(VE.getMetadataOrNullID(N->getRawName())); + + Stream.EmitRecord(bitc::METADATA_ENUMERATOR, Record, Abbrev); Record.clear(); } +static void WriteMDBasicType(const MDBasicType *, const ValueEnumerator &, + BitstreamWriter &, SmallVectorImpl &, + unsigned) { + llvm_unreachable("write not implemented"); +} +static void WriteMDDerivedType(const MDDerivedType *, const ValueEnumerator &, + BitstreamWriter &, SmallVectorImpl &, + unsigned) { + llvm_unreachable("write not implemented"); +} +static void WriteMDCompositeType(const MDCompositeType *, + const ValueEnumerator &, BitstreamWriter &, + SmallVectorImpl &, unsigned) { + llvm_unreachable("write not implemented"); +} +static void WriteMDSubroutineType(const MDSubroutineType *, + const ValueEnumerator &, BitstreamWriter &, + SmallVectorImpl &, unsigned) { + llvm_unreachable("write not implemented"); +} +static void WriteMDFile(const MDFile *, const ValueEnumerator &, + BitstreamWriter &, SmallVectorImpl &, + unsigned) { + llvm_unreachable("write not implemented"); +} +static void WriteMDCompileUnit(const MDCompileUnit *, const ValueEnumerator &, + BitstreamWriter &, SmallVectorImpl &, + unsigned) { + llvm_unreachable("write not implemented"); +} +static void WriteMDSubprogram(const MDSubprogram *, const ValueEnumerator &, + BitstreamWriter &, SmallVectorImpl &, + unsigned) { + llvm_unreachable("write not implemented"); +} +static void WriteMDLexicalBlock(const MDLexicalBlock *, const ValueEnumerator &, + BitstreamWriter &, SmallVectorImpl &, + unsigned) { + llvm_unreachable("write not implemented"); +} +static void WriteMDLexicalBlockFile(const MDLexicalBlockFile *, + const ValueEnumerator &, BitstreamWriter &, + SmallVectorImpl &, unsigned) { + llvm_unreachable("write not implemented"); +} +static void WriteMDNamespace(const MDNamespace *, const ValueEnumerator &, + BitstreamWriter &, SmallVectorImpl &, + unsigned) { + llvm_unreachable("write not implemented"); +} +static void WriteMDTemplateTypeParameter(const MDTemplateTypeParameter *, + const ValueEnumerator &, + BitstreamWriter &, + SmallVectorImpl &, + unsigned) { + llvm_unreachable("write not implemented"); +} +static void WriteMDTemplateValueParameter(const MDTemplateValueParameter *, + const ValueEnumerator &, + BitstreamWriter &, + SmallVectorImpl &, + unsigned) { + llvm_unreachable("write not implemented"); +} +static void WriteMDGlobalVariable(const MDGlobalVariable *, + const ValueEnumerator &, BitstreamWriter &, + SmallVectorImpl &, unsigned) { + llvm_unreachable("write not implemented"); +} +static void WriteMDLocalVariable(const MDLocalVariable *, + const ValueEnumerator &, BitstreamWriter &, + SmallVectorImpl &, unsigned) { + llvm_unreachable("write not implemented"); +} +static void WriteMDExpression(const MDExpression *, const ValueEnumerator &, + BitstreamWriter &, SmallVectorImpl &, + unsigned) { + llvm_unreachable("write not implemented"); +} +static void WriteMDObjCProperty(const MDObjCProperty *, const ValueEnumerator &, + BitstreamWriter &, SmallVectorImpl &, + unsigned) { + llvm_unreachable("write not implemented"); +} +static void WriteMDImportedEntity(const MDImportedEntity *, + const ValueEnumerator &, BitstreamWriter &, + SmallVectorImpl &, unsigned) { + llvm_unreachable("write not implemented"); +} + static void WriteModuleMetadata(const Module *M, const ValueEnumerator &VE, BitstreamWriter &Stream) { const auto &MDs = VE.getMDs(); - bool StartedMetadataBlock = false; + if (MDs.empty() && M->named_metadata_empty()) + return; + + Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3); + unsigned MDSAbbrev = 0; + if (VE.hasMDString()) { + // Abbrev for METADATA_STRING. + BitCodeAbbrev *Abbv = new BitCodeAbbrev(); + Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_STRING)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); + MDSAbbrev = Stream.EmitAbbrev(Abbv); + } + + // Initialize MDNode abbreviations. +#define HANDLE_MDNODE_LEAF(CLASS) unsigned CLASS##Abbrev = 0; +#include "llvm/IR/Metadata.def" + + if (VE.hasMDLocation()) { + // Abbrev for METADATA_LOCATION. + // + // Assume the column is usually under 128, and always output the inlined-at + // location (it's never more expensive than building an array size 1). + BitCodeAbbrev *Abbv = new BitCodeAbbrev(); + Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_LOCATION)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); + MDLocationAbbrev = Stream.EmitAbbrev(Abbv); + } + + if (VE.hasGenericDebugNode()) { + // Abbrev for METADATA_GENERIC_DEBUG. + // + // Assume the column is usually under 128, and always output the inlined-at + // location (it's never more expensive than building an array size 1). + BitCodeAbbrev *Abbv = new BitCodeAbbrev(); + Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_GENERIC_DEBUG)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); + GenericDebugNodeAbbrev = Stream.EmitAbbrev(Abbv); + } + + unsigned NameAbbrev = 0; + if (!M->named_metadata_empty()) { + // Abbrev for METADATA_NAME. + BitCodeAbbrev *Abbv = new BitCodeAbbrev(); + Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_NAME)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); + Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); + NameAbbrev = Stream.EmitAbbrev(Abbv); + } + SmallVector Record; - for (unsigned i = 0, e = MDs.size(); i != e; ++i) { - if (const MDNode *N = dyn_cast(MDs[i])) { - if (!StartedMetadataBlock) { - Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3); - StartedMetadataBlock = true; - } - WriteMDNode(N, VE, Stream, Record); - } else if (const auto *MDC = dyn_cast(MDs[i])) { - if (!StartedMetadataBlock) { - Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3); - StartedMetadataBlock = true; + for (const Metadata *MD : MDs) { + if (const MDNode *N = dyn_cast(MD)) { + switch (N->getMetadataID()) { + default: + llvm_unreachable("Invalid MDNode subclass"); +#define HANDLE_MDNODE_LEAF(CLASS) \ + case Metadata::CLASS##Kind: \ + Write##CLASS(cast(N), VE, Stream, Record, CLASS##Abbrev); \ + continue; +#include "llvm/IR/Metadata.def" } + } + if (const auto *MDC = dyn_cast(MD)) { WriteValueAsMetadata(MDC, VE, Stream, Record); - } else if (const MDString *MDS = dyn_cast(MDs[i])) { - if (!StartedMetadataBlock) { - Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3); - - // Abbrev for METADATA_STRING. - BitCodeAbbrev *Abbv = new BitCodeAbbrev(); - Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_STRING)); - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); - Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); - MDSAbbrev = Stream.EmitAbbrev(Abbv); - StartedMetadataBlock = true; - } - - // Code: [strchar x N] - Record.append(MDS->bytes_begin(), MDS->bytes_end()); - - // Emit the finished record. - Stream.EmitRecord(bitc::METADATA_STRING, Record, MDSAbbrev); - Record.clear(); + continue; } + const MDString *MDS = cast(MD); + // Code: [strchar x N] + Record.append(MDS->bytes_begin(), MDS->bytes_end()); + + // Emit the finished record. + Stream.EmitRecord(bitc::METADATA_STRING, Record, MDSAbbrev); + Record.clear(); } // Write named metadata. - for (Module::const_named_metadata_iterator I = M->named_metadata_begin(), - E = M->named_metadata_end(); I != E; ++I) { - const NamedMDNode *NMD = I; - if (!StartedMetadataBlock) { - Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3); - StartedMetadataBlock = true; - } - + for (const NamedMDNode &NMD : M->named_metadata()) { // Write name. - StringRef Str = NMD->getName(); - for (unsigned i = 0, e = Str.size(); i != e; ++i) - Record.push_back(Str[i]); - Stream.EmitRecord(bitc::METADATA_NAME, Record, 0/*TODO*/); + StringRef Str = NMD.getName(); + Record.append(Str.bytes_begin(), Str.bytes_end()); + Stream.EmitRecord(bitc::METADATA_NAME, Record, NameAbbrev); Record.clear(); // Write named metadata operands. - for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) - Record.push_back(VE.getMetadataID(NMD->getOperand(i))); + for (const MDNode *N : NMD.operands()) + Record.push_back(VE.getMetadataID(N)); Stream.EmitRecord(bitc::METADATA_NAMED_NODE, Record, 0); Record.clear(); } - if (StartedMetadataBlock) - Stream.ExitBlock(); + Stream.ExitBlock(); } static void WriteFunctionLocalMetadata(const Function &F, @@ -1714,8 +1904,8 @@ static void WriteFunction(const Function &F, ValueEnumerator &VE, Vals.push_back(DL.getLine()); Vals.push_back(DL.getCol()); - Vals.push_back(Scope ? VE.getMetadataID(Scope) + 1 : 0); - Vals.push_back(IA ? VE.getMetadataID(IA) + 1 : 0); + Vals.push_back(VE.getMetadataOrNullID(Scope)); + Vals.push_back(VE.getMetadataOrNullID(IA)); Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_LOC, Vals); Vals.clear();