| //===- Bitcode/Writer/BitcodeWriter.cpp - Bitcode Writer ------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // Bitcode writer implementation. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "llvm/Bitcode/BitcodeWriter.h" |
| #include "ValueEnumerator.h" |
| #include "llvm/ADT/APFloat.h" |
| #include "llvm/ADT/APInt.h" |
| #include "llvm/ADT/ArrayRef.h" |
| #include "llvm/ADT/DenseMap.h" |
| #include "llvm/ADT/None.h" |
| #include "llvm/ADT/Optional.h" |
| #include "llvm/ADT/STLExtras.h" |
| #include "llvm/ADT/SmallString.h" |
| #include "llvm/ADT/SmallVector.h" |
| #include "llvm/ADT/StringMap.h" |
| #include "llvm/ADT/StringRef.h" |
| #include "llvm/ADT/Triple.h" |
| #include "llvm/Bitcode/BitcodeCommon.h" |
| #include "llvm/Bitcode/BitcodeReader.h" |
| #include "llvm/Bitcode/LLVMBitCodes.h" |
| #include "llvm/Bitstream/BitCodes.h" |
| #include "llvm/Bitstream/BitstreamWriter.h" |
| #include "llvm/Config/llvm-config.h" |
| #include "llvm/IR/Attributes.h" |
| #include "llvm/IR/BasicBlock.h" |
| #include "llvm/IR/Comdat.h" |
| #include "llvm/IR/Constant.h" |
| #include "llvm/IR/Constants.h" |
| #include "llvm/IR/DebugInfoMetadata.h" |
| #include "llvm/IR/DebugLoc.h" |
| #include "llvm/IR/DerivedTypes.h" |
| #include "llvm/IR/Function.h" |
| #include "llvm/IR/GlobalAlias.h" |
| #include "llvm/IR/GlobalIFunc.h" |
| #include "llvm/IR/GlobalObject.h" |
| #include "llvm/IR/GlobalValue.h" |
| #include "llvm/IR/GlobalVariable.h" |
| #include "llvm/IR/InlineAsm.h" |
| #include "llvm/IR/InstrTypes.h" |
| #include "llvm/IR/Instruction.h" |
| #include "llvm/IR/Instructions.h" |
| #include "llvm/IR/LLVMContext.h" |
| #include "llvm/IR/Metadata.h" |
| #include "llvm/IR/Module.h" |
| #include "llvm/IR/ModuleSummaryIndex.h" |
| #include "llvm/IR/Operator.h" |
| #include "llvm/IR/Type.h" |
| #include "llvm/IR/UseListOrder.h" |
| #include "llvm/IR/Value.h" |
| #include "llvm/IR/ValueSymbolTable.h" |
| #include "llvm/MC/StringTableBuilder.h" |
| #include "llvm/MC/TargetRegistry.h" |
| #include "llvm/Object/IRSymtab.h" |
| #include "llvm/Support/AtomicOrdering.h" |
| #include "llvm/Support/Casting.h" |
| #include "llvm/Support/CommandLine.h" |
| #include "llvm/Support/Endian.h" |
| #include "llvm/Support/Error.h" |
| #include "llvm/Support/ErrorHandling.h" |
| #include "llvm/Support/MathExtras.h" |
| #include "llvm/Support/SHA1.h" |
| #include "llvm/Support/raw_ostream.h" |
| #include <algorithm> |
| #include <cassert> |
| #include <cstddef> |
| #include <cstdint> |
| #include <iterator> |
| #include <map> |
| #include <memory> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| using namespace llvm; |
| |
| static cl::opt<unsigned> |
| IndexThreshold("bitcode-mdindex-threshold", cl::Hidden, cl::init(25), |
| cl::desc("Number of metadatas above which we emit an index " |
| "to enable lazy-loading")); |
| static cl::opt<uint32_t> FlushThreshold( |
| "bitcode-flush-threshold", cl::Hidden, cl::init(512), |
| cl::desc("The threshold (unit M) for flushing LLVM bitcode.")); |
| |
| static cl::opt<bool> WriteRelBFToSummary( |
| "write-relbf-to-summary", cl::Hidden, cl::init(false), |
| cl::desc("Write relative block frequency to function summary ")); |
| |
| extern FunctionSummary::ForceSummaryHotnessType ForceSummaryEdgesCold; |
| |
| namespace { |
| |
| /// These are manifest constants used by the bitcode writer. They do not need to |
| /// be kept in sync with the reader, but need to be consistent within this file. |
| enum { |
| // VALUE_SYMTAB_BLOCK abbrev id's. |
| VST_ENTRY_8_ABBREV = bitc::FIRST_APPLICATION_ABBREV, |
| VST_ENTRY_7_ABBREV, |
| VST_ENTRY_6_ABBREV, |
| VST_BBENTRY_6_ABBREV, |
| |
| // CONSTANTS_BLOCK abbrev id's. |
| CONSTANTS_SETTYPE_ABBREV = bitc::FIRST_APPLICATION_ABBREV, |
| CONSTANTS_INTEGER_ABBREV, |
| CONSTANTS_CE_CAST_Abbrev, |
| CONSTANTS_NULL_Abbrev, |
| |
| // FUNCTION_BLOCK abbrev id's. |
| FUNCTION_INST_LOAD_ABBREV = bitc::FIRST_APPLICATION_ABBREV, |
| FUNCTION_INST_UNOP_ABBREV, |
| FUNCTION_INST_UNOP_FLAGS_ABBREV, |
| FUNCTION_INST_BINOP_ABBREV, |
| FUNCTION_INST_BINOP_FLAGS_ABBREV, |
| FUNCTION_INST_CAST_ABBREV, |
| FUNCTION_INST_RET_VOID_ABBREV, |
| FUNCTION_INST_RET_VAL_ABBREV, |
| FUNCTION_INST_UNREACHABLE_ABBREV, |
| FUNCTION_INST_GEP_ABBREV, |
| }; |
| |
| /// Abstract class to manage the bitcode writing, subclassed for each bitcode |
| /// file type. |
| class BitcodeWriterBase { |
| protected: |
| /// The stream created and owned by the client. |
| BitstreamWriter &Stream; |
| |
| StringTableBuilder &StrtabBuilder; |
| |
| public: |
| /// Constructs a BitcodeWriterBase object that writes to the provided |
| /// \p Stream. |
| BitcodeWriterBase(BitstreamWriter &Stream, StringTableBuilder &StrtabBuilder) |
| : Stream(Stream), StrtabBuilder(StrtabBuilder) {} |
| |
| protected: |
| void writeModuleVersion(); |
| }; |
| |
| void BitcodeWriterBase::writeModuleVersion() { |
| // VERSION: [version#] |
| Stream.EmitRecord(bitc::MODULE_CODE_VERSION, ArrayRef<uint64_t>{2}); |
| } |
| |
| /// Base class to manage the module bitcode writing, currently subclassed for |
| /// ModuleBitcodeWriter and ThinLinkBitcodeWriter. |
| class ModuleBitcodeWriterBase : public BitcodeWriterBase { |
| protected: |
| /// The Module to write to bitcode. |
| const Module &M; |
| |
| /// Enumerates ids for all values in the module. |
| ValueEnumerator VE; |
| |
| /// Optional per-module index to write for ThinLTO. |
| const ModuleSummaryIndex *Index; |
| |
| /// Map that holds the correspondence between GUIDs in the summary index, |
| /// that came from indirect call profiles, and a value id generated by this |
| /// class to use in the VST and summary block records. |
| std::map<GlobalValue::GUID, unsigned> GUIDToValueIdMap; |
| |
| /// Tracks the last value id recorded in the GUIDToValueMap. |
| unsigned GlobalValueId; |
| |
| /// Saves the offset of the VSTOffset record that must eventually be |
| /// backpatched with the offset of the actual VST. |
| uint64_t VSTOffsetPlaceholder = 0; |
| |
| public: |
| /// Constructs a ModuleBitcodeWriterBase object for the given Module, |
| /// writing to the provided \p Buffer. |
| ModuleBitcodeWriterBase(const Module &M, StringTableBuilder &StrtabBuilder, |
| BitstreamWriter &Stream, |
| bool ShouldPreserveUseListOrder, |
| const ModuleSummaryIndex *Index) |
| : BitcodeWriterBase(Stream, StrtabBuilder), M(M), |
| VE(M, ShouldPreserveUseListOrder), Index(Index) { |
| // Assign ValueIds to any callee values in the index that came from |
| // indirect call profiles and were recorded as a GUID not a Value* |
| // (which would have been assigned an ID by the ValueEnumerator). |
| // The starting ValueId is just after the number of values in the |
| // ValueEnumerator, so that they can be emitted in the VST. |
| GlobalValueId = VE.getValues().size(); |
| if (!Index) |
| return; |
| for (const auto &GUIDSummaryLists : *Index) |
| // Examine all summaries for this GUID. |
| for (auto &Summary : GUIDSummaryLists.second.SummaryList) |
| if (auto FS = dyn_cast<FunctionSummary>(Summary.get())) |
| // For each call in the function summary, see if the call |
| // is to a GUID (which means it is for an indirect call, |
| // otherwise we would have a Value for it). If so, synthesize |
| // a value id. |
| for (auto &CallEdge : FS->calls()) |
| if (!CallEdge.first.haveGVs() || !CallEdge.first.getValue()) |
| assignValueId(CallEdge.first.getGUID()); |
| } |
| |
| protected: |
| void writePerModuleGlobalValueSummary(); |
| |
| private: |
| void writePerModuleFunctionSummaryRecord(SmallVector<uint64_t, 64> &NameVals, |
| GlobalValueSummary *Summary, |
| unsigned ValueID, |
| unsigned FSCallsAbbrev, |
| unsigned FSCallsProfileAbbrev, |
| const Function &F); |
| void writeModuleLevelReferences(const GlobalVariable &V, |
| SmallVector<uint64_t, 64> &NameVals, |
| unsigned FSModRefsAbbrev, |
| unsigned FSModVTableRefsAbbrev); |
| |
| void assignValueId(GlobalValue::GUID ValGUID) { |
| GUIDToValueIdMap[ValGUID] = ++GlobalValueId; |
| } |
| |
| unsigned getValueId(GlobalValue::GUID ValGUID) { |
| const auto &VMI = GUIDToValueIdMap.find(ValGUID); |
| // Expect that any GUID value had a value Id assigned by an |
| // earlier call to assignValueId. |
| assert(VMI != GUIDToValueIdMap.end() && |
| "GUID does not have assigned value Id"); |
| return VMI->second; |
| } |
| |
| // Helper to get the valueId for the type of value recorded in VI. |
| unsigned getValueId(ValueInfo VI) { |
| if (!VI.haveGVs() || !VI.getValue()) |
| return getValueId(VI.getGUID()); |
| return VE.getValueID(VI.getValue()); |
| } |
| |
| std::map<GlobalValue::GUID, unsigned> &valueIds() { return GUIDToValueIdMap; } |
| }; |
| |
| /// Class to manage the bitcode writing for a module. |
| class ModuleBitcodeWriter : public ModuleBitcodeWriterBase { |
| /// Pointer to the buffer allocated by caller for bitcode writing. |
| const SmallVectorImpl<char> &Buffer; |
| |
| /// True if a module hash record should be written. |
| bool GenerateHash; |
| |
| /// If non-null, when GenerateHash is true, the resulting hash is written |
| /// into ModHash. |
| ModuleHash *ModHash; |
| |
| SHA1 Hasher; |
| |
| /// The start bit of the identification block. |
| uint64_t BitcodeStartBit; |
| |
| public: |
| /// Constructs a ModuleBitcodeWriter object for the given Module, |
| /// writing to the provided \p Buffer. |
| ModuleBitcodeWriter(const Module &M, SmallVectorImpl<char> &Buffer, |
| StringTableBuilder &StrtabBuilder, |
| BitstreamWriter &Stream, bool ShouldPreserveUseListOrder, |
| const ModuleSummaryIndex *Index, bool GenerateHash, |
| ModuleHash *ModHash = nullptr) |
| : ModuleBitcodeWriterBase(M, StrtabBuilder, Stream, |
| ShouldPreserveUseListOrder, Index), |
| Buffer(Buffer), GenerateHash(GenerateHash), ModHash(ModHash), |
| BitcodeStartBit(Stream.GetCurrentBitNo()) {} |
| |
| /// Emit the current module to the bitstream. |
| void write(); |
| |
| private: |
| uint64_t bitcodeStartBit() { return BitcodeStartBit; } |
| |
| size_t addToStrtab(StringRef Str); |
| |
| void writeAttributeGroupTable(); |
| void writeAttributeTable(); |
| void writeTypeTable(); |
| void writeComdats(); |
| void writeValueSymbolTableForwardDecl(); |
| void writeModuleInfo(); |
| void writeValueAsMetadata(const ValueAsMetadata *MD, |
| SmallVectorImpl<uint64_t> &Record); |
| void writeMDTuple(const MDTuple *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev); |
| unsigned createDILocationAbbrev(); |
| void writeDILocation(const DILocation *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned &Abbrev); |
| unsigned createGenericDINodeAbbrev(); |
| void writeGenericDINode(const GenericDINode *N, |
| SmallVectorImpl<uint64_t> &Record, unsigned &Abbrev); |
| void writeDISubrange(const DISubrange *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev); |
| void writeDIGenericSubrange(const DIGenericSubrange *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev); |
| void writeDIEnumerator(const DIEnumerator *N, |
| SmallVectorImpl<uint64_t> &Record, unsigned Abbrev); |
| void writeDIBasicType(const DIBasicType *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev); |
| void writeDIStringType(const DIStringType *N, |
| SmallVectorImpl<uint64_t> &Record, unsigned Abbrev); |
| void writeDIDerivedType(const DIDerivedType *N, |
| SmallVectorImpl<uint64_t> &Record, unsigned Abbrev); |
| void writeDICompositeType(const DICompositeType *N, |
| SmallVectorImpl<uint64_t> &Record, unsigned Abbrev); |
| void writeDISubroutineType(const DISubroutineType *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev); |
| void writeDIFile(const DIFile *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev); |
| void writeDICompileUnit(const DICompileUnit *N, |
| SmallVectorImpl<uint64_t> &Record, unsigned Abbrev); |
| void writeDISubprogram(const DISubprogram *N, |
| SmallVectorImpl<uint64_t> &Record, unsigned Abbrev); |
| void writeDILexicalBlock(const DILexicalBlock *N, |
| SmallVectorImpl<uint64_t> &Record, unsigned Abbrev); |
| void writeDILexicalBlockFile(const DILexicalBlockFile *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev); |
| void writeDICommonBlock(const DICommonBlock *N, |
| SmallVectorImpl<uint64_t> &Record, unsigned Abbrev); |
| void writeDINamespace(const DINamespace *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev); |
| void writeDIMacro(const DIMacro *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev); |
| void writeDIMacroFile(const DIMacroFile *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev); |
| void writeDIArgList(const DIArgList *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev); |
| void writeDIModule(const DIModule *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev); |
| void writeDITemplateTypeParameter(const DITemplateTypeParameter *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev); |
| void writeDITemplateValueParameter(const DITemplateValueParameter *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev); |
| void writeDIGlobalVariable(const DIGlobalVariable *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev); |
| void writeDILocalVariable(const DILocalVariable *N, |
| SmallVectorImpl<uint64_t> &Record, unsigned Abbrev); |
| void writeDILabel(const DILabel *N, |
| SmallVectorImpl<uint64_t> &Record, unsigned Abbrev); |
| void writeDIExpression(const DIExpression *N, |
| SmallVectorImpl<uint64_t> &Record, unsigned Abbrev); |
| void writeDIGlobalVariableExpression(const DIGlobalVariableExpression *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev); |
| void writeDIObjCProperty(const DIObjCProperty *N, |
| SmallVectorImpl<uint64_t> &Record, unsigned Abbrev); |
| void writeDIImportedEntity(const DIImportedEntity *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev); |
| unsigned createNamedMetadataAbbrev(); |
| void writeNamedMetadata(SmallVectorImpl<uint64_t> &Record); |
| unsigned createMetadataStringsAbbrev(); |
| void writeMetadataStrings(ArrayRef<const Metadata *> Strings, |
| SmallVectorImpl<uint64_t> &Record); |
| void writeMetadataRecords(ArrayRef<const Metadata *> MDs, |
| SmallVectorImpl<uint64_t> &Record, |
| std::vector<unsigned> *MDAbbrevs = nullptr, |
| std::vector<uint64_t> *IndexPos = nullptr); |
| void writeModuleMetadata(); |
| void writeFunctionMetadata(const Function &F); |
| void writeFunctionMetadataAttachment(const Function &F); |
| void pushGlobalMetadataAttachment(SmallVectorImpl<uint64_t> &Record, |
| const GlobalObject &GO); |
| void writeModuleMetadataKinds(); |
| void writeOperandBundleTags(); |
| void writeSyncScopeNames(); |
| void writeConstants(unsigned FirstVal, unsigned LastVal, bool isGlobal); |
| void writeModuleConstants(); |
| bool pushValueAndType(const Value *V, unsigned InstID, |
| SmallVectorImpl<unsigned> &Vals); |
| void writeOperandBundles(const CallBase &CB, unsigned InstID); |
| void pushValue(const Value *V, unsigned InstID, |
| SmallVectorImpl<unsigned> &Vals); |
| void pushValueSigned(const Value *V, unsigned InstID, |
| SmallVectorImpl<uint64_t> &Vals); |
| void writeInstruction(const Instruction &I, unsigned InstID, |
| SmallVectorImpl<unsigned> &Vals); |
| void writeFunctionLevelValueSymbolTable(const ValueSymbolTable &VST); |
| void writeGlobalValueSymbolTable( |
| DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex); |
| void writeUseList(UseListOrder &&Order); |
| void writeUseListBlock(const Function *F); |
| void |
| writeFunction(const Function &F, |
| DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex); |
| void writeBlockInfo(); |
| void writeModuleHash(size_t BlockStartPos); |
| |
| unsigned getEncodedSyncScopeID(SyncScope::ID SSID) { |
| return unsigned(SSID); |
| } |
| |
| unsigned getEncodedAlign(MaybeAlign Alignment) { return encode(Alignment); } |
| }; |
| |
| /// Class to manage the bitcode writing for a combined index. |
| class IndexBitcodeWriter : public BitcodeWriterBase { |
| /// The combined index to write to bitcode. |
| const ModuleSummaryIndex &Index; |
| |
| /// When writing a subset of the index for distributed backends, client |
| /// provides a map of modules to the corresponding GUIDs/summaries to write. |
| const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex; |
| |
| /// Map that holds the correspondence between the GUID used in the combined |
| /// index and a value id generated by this class to use in references. |
| std::map<GlobalValue::GUID, unsigned> GUIDToValueIdMap; |
| |
| /// Tracks the last value id recorded in the GUIDToValueMap. |
| unsigned GlobalValueId = 0; |
| |
| public: |
| /// Constructs a IndexBitcodeWriter object for the given combined index, |
| /// writing to the provided \p Buffer. When writing a subset of the index |
| /// for a distributed backend, provide a \p ModuleToSummariesForIndex map. |
| IndexBitcodeWriter(BitstreamWriter &Stream, StringTableBuilder &StrtabBuilder, |
| const ModuleSummaryIndex &Index, |
| const std::map<std::string, GVSummaryMapTy> |
| *ModuleToSummariesForIndex = nullptr) |
| : BitcodeWriterBase(Stream, StrtabBuilder), Index(Index), |
| ModuleToSummariesForIndex(ModuleToSummariesForIndex) { |
| // Assign unique value ids to all summaries to be written, for use |
| // in writing out the call graph edges. Save the mapping from GUID |
| // to the new global value id to use when writing those edges, which |
| // are currently saved in the index in terms of GUID. |
| forEachSummary([&](GVInfo I, bool) { |
| GUIDToValueIdMap[I.first] = ++GlobalValueId; |
| }); |
| } |
| |
| /// The below iterator returns the GUID and associated summary. |
| using GVInfo = std::pair<GlobalValue::GUID, GlobalValueSummary *>; |
| |
| /// Calls the callback for each value GUID and summary to be written to |
| /// bitcode. This hides the details of whether they are being pulled from the |
| /// entire index or just those in a provided ModuleToSummariesForIndex map. |
| template<typename Functor> |
| void forEachSummary(Functor Callback) { |
| if (ModuleToSummariesForIndex) { |
| for (auto &M : *ModuleToSummariesForIndex) |
| for (auto &Summary : M.second) { |
| Callback(Summary, false); |
| // Ensure aliasee is handled, e.g. for assigning a valueId, |
| // even if we are not importing the aliasee directly (the |
| // imported alias will contain a copy of aliasee). |
| if (auto *AS = dyn_cast<AliasSummary>(Summary.getSecond())) |
| Callback({AS->getAliaseeGUID(), &AS->getAliasee()}, true); |
| } |
| } else { |
| for (auto &Summaries : Index) |
| for (auto &Summary : Summaries.second.SummaryList) |
| Callback({Summaries.first, Summary.get()}, false); |
| } |
| } |
| |
| /// Calls the callback for each entry in the modulePaths StringMap that |
| /// should be written to the module path string table. This hides the details |
| /// of whether they are being pulled from the entire index or just those in a |
| /// provided ModuleToSummariesForIndex map. |
| template <typename Functor> void forEachModule(Functor Callback) { |
| if (ModuleToSummariesForIndex) { |
| for (const auto &M : *ModuleToSummariesForIndex) { |
| const auto &MPI = Index.modulePaths().find(M.first); |
| if (MPI == Index.modulePaths().end()) { |
| // This should only happen if the bitcode file was empty, in which |
| // case we shouldn't be importing (the ModuleToSummariesForIndex |
| // would only include the module we are writing and index for). |
| assert(ModuleToSummariesForIndex->size() == 1); |
| continue; |
| } |
| Callback(*MPI); |
| } |
| } else { |
| for (const auto &MPSE : Index.modulePaths()) |
| Callback(MPSE); |
| } |
| } |
| |
| /// Main entry point for writing a combined index to bitcode. |
| void write(); |
| |
| private: |
| void writeModStrings(); |
| void writeCombinedGlobalValueSummary(); |
| |
| Optional<unsigned> getValueId(GlobalValue::GUID ValGUID) { |
| auto VMI = GUIDToValueIdMap.find(ValGUID); |
| if (VMI == GUIDToValueIdMap.end()) |
| return None; |
| return VMI->second; |
| } |
| |
| std::map<GlobalValue::GUID, unsigned> &valueIds() { return GUIDToValueIdMap; } |
| }; |
| |
| } // end anonymous namespace |
| |
| static unsigned getEncodedCastOpcode(unsigned Opcode) { |
| switch (Opcode) { |
| default: llvm_unreachable("Unknown cast instruction!"); |
| case Instruction::Trunc : return bitc::CAST_TRUNC; |
| case Instruction::ZExt : return bitc::CAST_ZEXT; |
| case Instruction::SExt : return bitc::CAST_SEXT; |
| case Instruction::FPToUI : return bitc::CAST_FPTOUI; |
| case Instruction::FPToSI : return bitc::CAST_FPTOSI; |
| case Instruction::UIToFP : return bitc::CAST_UITOFP; |
| case Instruction::SIToFP : return bitc::CAST_SITOFP; |
| case Instruction::FPTrunc : return bitc::CAST_FPTRUNC; |
| case Instruction::FPExt : return bitc::CAST_FPEXT; |
| case Instruction::PtrToInt: return bitc::CAST_PTRTOINT; |
| case Instruction::IntToPtr: return bitc::CAST_INTTOPTR; |
| case Instruction::BitCast : return bitc::CAST_BITCAST; |
| case Instruction::AddrSpaceCast: return bitc::CAST_ADDRSPACECAST; |
| } |
| } |
| |
| static unsigned getEncodedUnaryOpcode(unsigned Opcode) { |
| switch (Opcode) { |
| default: llvm_unreachable("Unknown binary instruction!"); |
| case Instruction::FNeg: return bitc::UNOP_FNEG; |
| } |
| } |
| |
| static unsigned getEncodedBinaryOpcode(unsigned Opcode) { |
| switch (Opcode) { |
| default: llvm_unreachable("Unknown binary instruction!"); |
| case Instruction::Add: |
| case Instruction::FAdd: return bitc::BINOP_ADD; |
| case Instruction::Sub: |
| case Instruction::FSub: return bitc::BINOP_SUB; |
| case Instruction::Mul: |
| case Instruction::FMul: return bitc::BINOP_MUL; |
| case Instruction::UDiv: return bitc::BINOP_UDIV; |
| case Instruction::FDiv: |
| case Instruction::SDiv: return bitc::BINOP_SDIV; |
| case Instruction::URem: return bitc::BINOP_UREM; |
| case Instruction::FRem: |
| case Instruction::SRem: return bitc::BINOP_SREM; |
| case Instruction::Shl: return bitc::BINOP_SHL; |
| case Instruction::LShr: return bitc::BINOP_LSHR; |
| case Instruction::AShr: return bitc::BINOP_ASHR; |
| case Instruction::And: return bitc::BINOP_AND; |
| case Instruction::Or: return bitc::BINOP_OR; |
| case Instruction::Xor: return bitc::BINOP_XOR; |
| } |
| } |
| |
| static unsigned getEncodedRMWOperation(AtomicRMWInst::BinOp Op) { |
| switch (Op) { |
| default: llvm_unreachable("Unknown RMW operation!"); |
| case AtomicRMWInst::Xchg: return bitc::RMW_XCHG; |
| case AtomicRMWInst::Add: return bitc::RMW_ADD; |
| case AtomicRMWInst::Sub: return bitc::RMW_SUB; |
| case AtomicRMWInst::And: return bitc::RMW_AND; |
| case AtomicRMWInst::Nand: return bitc::RMW_NAND; |
| case AtomicRMWInst::Or: return bitc::RMW_OR; |
| case AtomicRMWInst::Xor: return bitc::RMW_XOR; |
| case AtomicRMWInst::Max: return bitc::RMW_MAX; |
| case AtomicRMWInst::Min: return bitc::RMW_MIN; |
| case AtomicRMWInst::UMax: return bitc::RMW_UMAX; |
| case AtomicRMWInst::UMin: return bitc::RMW_UMIN; |
| case AtomicRMWInst::FAdd: return bitc::RMW_FADD; |
| case AtomicRMWInst::FSub: return bitc::RMW_FSUB; |
| } |
| } |
| |
| static unsigned getEncodedOrdering(AtomicOrdering Ordering) { |
| switch (Ordering) { |
| case AtomicOrdering::NotAtomic: return bitc::ORDERING_NOTATOMIC; |
| case AtomicOrdering::Unordered: return bitc::ORDERING_UNORDERED; |
| case AtomicOrdering::Monotonic: return bitc::ORDERING_MONOTONIC; |
| case AtomicOrdering::Acquire: return bitc::ORDERING_ACQUIRE; |
| case AtomicOrdering::Release: return bitc::ORDERING_RELEASE; |
| case AtomicOrdering::AcquireRelease: return bitc::ORDERING_ACQREL; |
| case AtomicOrdering::SequentiallyConsistent: return bitc::ORDERING_SEQCST; |
| } |
| llvm_unreachable("Invalid ordering"); |
| } |
| |
| static void writeStringRecord(BitstreamWriter &Stream, unsigned Code, |
| StringRef Str, unsigned AbbrevToUse) { |
| SmallVector<unsigned, 64> Vals; |
| |
| // Code: [strchar x N] |
| for (char C : Str) { |
| if (AbbrevToUse && !BitCodeAbbrevOp::isChar6(C)) |
| AbbrevToUse = 0; |
| Vals.push_back(C); |
| } |
| |
| // Emit the finished record. |
| Stream.EmitRecord(Code, Vals, AbbrevToUse); |
| } |
| |
| static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) { |
| switch (Kind) { |
| case Attribute::Alignment: |
| return bitc::ATTR_KIND_ALIGNMENT; |
| case Attribute::AllocSize: |
| return bitc::ATTR_KIND_ALLOC_SIZE; |
| case Attribute::AlwaysInline: |
| return bitc::ATTR_KIND_ALWAYS_INLINE; |
| case Attribute::ArgMemOnly: |
| return bitc::ATTR_KIND_ARGMEMONLY; |
| case Attribute::Builtin: |
| return bitc::ATTR_KIND_BUILTIN; |
| case Attribute::ByVal: |
| return bitc::ATTR_KIND_BY_VAL; |
| case Attribute::Convergent: |
| return bitc::ATTR_KIND_CONVERGENT; |
| case Attribute::InAlloca: |
| return bitc::ATTR_KIND_IN_ALLOCA; |
| case Attribute::Cold: |
| return bitc::ATTR_KIND_COLD; |
| case Attribute::DisableSanitizerInstrumentation: |
| return bitc::ATTR_KIND_DISABLE_SANITIZER_INSTRUMENTATION; |
| case Attribute::Hot: |
| return bitc::ATTR_KIND_HOT; |
| case Attribute::ElementType: |
| return bitc::ATTR_KIND_ELEMENTTYPE; |
| case Attribute::InaccessibleMemOnly: |
| return bitc::ATTR_KIND_INACCESSIBLEMEM_ONLY; |
| case Attribute::InaccessibleMemOrArgMemOnly: |
| return bitc::ATTR_KIND_INACCESSIBLEMEM_OR_ARGMEMONLY; |
| case Attribute::InlineHint: |
| return bitc::ATTR_KIND_INLINE_HINT; |
| case Attribute::InReg: |
| return bitc::ATTR_KIND_IN_REG; |
| case Attribute::JumpTable: |
| return bitc::ATTR_KIND_JUMP_TABLE; |
| case Attribute::MinSize: |
| return bitc::ATTR_KIND_MIN_SIZE; |
| case Attribute::Naked: |
| return bitc::ATTR_KIND_NAKED; |
| case Attribute::Nest: |
| return bitc::ATTR_KIND_NEST; |
| case Attribute::NoAlias: |
| return bitc::ATTR_KIND_NO_ALIAS; |
| case Attribute::NoBuiltin: |
| return bitc::ATTR_KIND_NO_BUILTIN; |
| case Attribute::NoCallback: |
| return bitc::ATTR_KIND_NO_CALLBACK; |
| case Attribute::NoCapture: |
| return bitc::ATTR_KIND_NO_CAPTURE; |
| case Attribute::NoDuplicate: |
| return bitc::ATTR_KIND_NO_DUPLICATE; |
| case Attribute::NoFree: |
| return bitc::ATTR_KIND_NOFREE; |
| case Attribute::NoImplicitFloat: |
| return bitc::ATTR_KIND_NO_IMPLICIT_FLOAT; |
| case Attribute::NoInline: |
| return bitc::ATTR_KIND_NO_INLINE; |
| case Attribute::NoRecurse: |
| return bitc::ATTR_KIND_NO_RECURSE; |
| case Attribute::NoMerge: |
| return bitc::ATTR_KIND_NO_MERGE; |
| case Attribute::NonLazyBind: |
| return bitc::ATTR_KIND_NON_LAZY_BIND; |
| case Attribute::NonNull: |
| return bitc::ATTR_KIND_NON_NULL; |
| case Attribute::Dereferenceable: |
| return bitc::ATTR_KIND_DEREFERENCEABLE; |
| case Attribute::DereferenceableOrNull: |
| return bitc::ATTR_KIND_DEREFERENCEABLE_OR_NULL; |
| case Attribute::NoRedZone: |
| return bitc::ATTR_KIND_NO_RED_ZONE; |
| case Attribute::NoReturn: |
| return bitc::ATTR_KIND_NO_RETURN; |
| case Attribute::NoSync: |
| return bitc::ATTR_KIND_NOSYNC; |
| case Attribute::NoCfCheck: |
| return bitc::ATTR_KIND_NOCF_CHECK; |
| case Attribute::NoProfile: |
| return bitc::ATTR_KIND_NO_PROFILE; |
| case Attribute::NoUnwind: |
| return bitc::ATTR_KIND_NO_UNWIND; |
| case Attribute::NoSanitizeCoverage: |
| return bitc::ATTR_KIND_NO_SANITIZE_COVERAGE; |
| case Attribute::NullPointerIsValid: |
| return bitc::ATTR_KIND_NULL_POINTER_IS_VALID; |
| case Attribute::OptForFuzzing: |
| return bitc::ATTR_KIND_OPT_FOR_FUZZING; |
| case Attribute::OptimizeForSize: |
| return bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE; |
| case Attribute::OptimizeNone: |
| return bitc::ATTR_KIND_OPTIMIZE_NONE; |
| case Attribute::ReadNone: |
| return bitc::ATTR_KIND_READ_NONE; |
| case Attribute::ReadOnly: |
| return bitc::ATTR_KIND_READ_ONLY; |
| case Attribute::Returned: |
| return bitc::ATTR_KIND_RETURNED; |
| case Attribute::ReturnsTwice: |
| return bitc::ATTR_KIND_RETURNS_TWICE; |
| case Attribute::SExt: |
| return bitc::ATTR_KIND_S_EXT; |
| case Attribute::Speculatable: |
| return bitc::ATTR_KIND_SPECULATABLE; |
| case Attribute::StackAlignment: |
| return bitc::ATTR_KIND_STACK_ALIGNMENT; |
| case Attribute::StackProtect: |
| return bitc::ATTR_KIND_STACK_PROTECT; |
| case Attribute::StackProtectReq: |
| return bitc::ATTR_KIND_STACK_PROTECT_REQ; |
| case Attribute::StackProtectStrong: |
| return bitc::ATTR_KIND_STACK_PROTECT_STRONG; |
| case Attribute::SafeStack: |
| return bitc::ATTR_KIND_SAFESTACK; |
| case Attribute::ShadowCallStack: |
| return bitc::ATTR_KIND_SHADOWCALLSTACK; |
| case Attribute::StrictFP: |
| return bitc::ATTR_KIND_STRICT_FP; |
| case Attribute::StructRet: |
| return bitc::ATTR_KIND_STRUCT_RET; |
| case Attribute::SanitizeAddress: |
| return bitc::ATTR_KIND_SANITIZE_ADDRESS; |
| case Attribute::SanitizeHWAddress: |
| return bitc::ATTR_KIND_SANITIZE_HWADDRESS; |
| case Attribute::SanitizeThread: |
| return bitc::ATTR_KIND_SANITIZE_THREAD; |
| case Attribute::SanitizeMemory: |
| return bitc::ATTR_KIND_SANITIZE_MEMORY; |
| case Attribute::SpeculativeLoadHardening: |
| return bitc::ATTR_KIND_SPECULATIVE_LOAD_HARDENING; |
| case Attribute::SwiftError: |
| return bitc::ATTR_KIND_SWIFT_ERROR; |
| case Attribute::SwiftSelf: |
| return bitc::ATTR_KIND_SWIFT_SELF; |
| case Attribute::SwiftAsync: |
| return bitc::ATTR_KIND_SWIFT_ASYNC; |
| case Attribute::UWTable: |
| return bitc::ATTR_KIND_UW_TABLE; |
| case Attribute::VScaleRange: |
| return bitc::ATTR_KIND_VSCALE_RANGE; |
| case Attribute::WillReturn: |
| return bitc::ATTR_KIND_WILLRETURN; |
| case Attribute::WriteOnly: |
| return bitc::ATTR_KIND_WRITEONLY; |
| case Attribute::ZExt: |
| return bitc::ATTR_KIND_Z_EXT; |
| case Attribute::ImmArg: |
| return bitc::ATTR_KIND_IMMARG; |
| case Attribute::SanitizeMemTag: |
| return bitc::ATTR_KIND_SANITIZE_MEMTAG; |
| case Attribute::Preallocated: |
| return bitc::ATTR_KIND_PREALLOCATED; |
| case Attribute::NoUndef: |
| return bitc::ATTR_KIND_NOUNDEF; |
| case Attribute::ByRef: |
| return bitc::ATTR_KIND_BYREF; |
| case Attribute::MustProgress: |
| return bitc::ATTR_KIND_MUSTPROGRESS; |
| case Attribute::EndAttrKinds: |
| llvm_unreachable("Can not encode end-attribute kinds marker."); |
| case Attribute::None: |
| llvm_unreachable("Can not encode none-attribute."); |
| case Attribute::EmptyKey: |
| case Attribute::TombstoneKey: |
| llvm_unreachable("Trying to encode EmptyKey/TombstoneKey"); |
| } |
| |
| llvm_unreachable("Trying to encode unknown attribute"); |
| } |
| |
| void ModuleBitcodeWriter::writeAttributeGroupTable() { |
| const std::vector<ValueEnumerator::IndexAndAttrSet> &AttrGrps = |
| VE.getAttributeGroups(); |
| if (AttrGrps.empty()) return; |
| |
| Stream.EnterSubblock(bitc::PARAMATTR_GROUP_BLOCK_ID, 3); |
| |
| SmallVector<uint64_t, 64> Record; |
| for (ValueEnumerator::IndexAndAttrSet Pair : AttrGrps) { |
| unsigned AttrListIndex = Pair.first; |
| AttributeSet AS = Pair.second; |
| Record.push_back(VE.getAttributeGroupID(Pair)); |
| Record.push_back(AttrListIndex); |
| |
| for (Attribute Attr : AS) { |
| if (Attr.isEnumAttribute()) { |
| Record.push_back(0); |
| Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum())); |
| } else if (Attr.isIntAttribute()) { |
| Record.push_back(1); |
| Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum())); |
| Record.push_back(Attr.getValueAsInt()); |
| } else if (Attr.isStringAttribute()) { |
| StringRef Kind = Attr.getKindAsString(); |
| StringRef Val = Attr.getValueAsString(); |
| |
| Record.push_back(Val.empty() ? 3 : 4); |
| Record.append(Kind.begin(), Kind.end()); |
| Record.push_back(0); |
| if (!Val.empty()) { |
| Record.append(Val.begin(), Val.end()); |
| Record.push_back(0); |
| } |
| } else { |
| assert(Attr.isTypeAttribute()); |
| Type *Ty = Attr.getValueAsType(); |
| Record.push_back(Ty ? 6 : 5); |
| Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum())); |
| if (Ty) |
| Record.push_back(VE.getTypeID(Attr.getValueAsType())); |
| } |
| } |
| |
| Stream.EmitRecord(bitc::PARAMATTR_GRP_CODE_ENTRY, Record); |
| Record.clear(); |
| } |
| |
| Stream.ExitBlock(); |
| } |
| |
| void ModuleBitcodeWriter::writeAttributeTable() { |
| const std::vector<AttributeList> &Attrs = VE.getAttributeLists(); |
| if (Attrs.empty()) return; |
| |
| Stream.EnterSubblock(bitc::PARAMATTR_BLOCK_ID, 3); |
| |
| SmallVector<uint64_t, 64> Record; |
| for (unsigned i = 0, e = Attrs.size(); i != e; ++i) { |
| AttributeList AL = Attrs[i]; |
| for (unsigned i : AL.indexes()) { |
| AttributeSet AS = AL.getAttributes(i); |
| if (AS.hasAttributes()) |
| Record.push_back(VE.getAttributeGroupID({i, AS})); |
| } |
| |
| Stream.EmitRecord(bitc::PARAMATTR_CODE_ENTRY, Record); |
| Record.clear(); |
| } |
| |
| Stream.ExitBlock(); |
| } |
| |
| /// WriteTypeTable - Write out the type table for a module. |
| void ModuleBitcodeWriter::writeTypeTable() { |
| const ValueEnumerator::TypeList &TypeList = VE.getTypes(); |
| |
| Stream.EnterSubblock(bitc::TYPE_BLOCK_ID_NEW, 4 /*count from # abbrevs */); |
| SmallVector<uint64_t, 64> TypeVals; |
| |
| uint64_t NumBits = VE.computeBitsRequiredForTypeIndicies(); |
| |
| // Abbrev for TYPE_CODE_POINTER. |
| auto Abbv = std::make_shared<BitCodeAbbrev>(); |
| Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_POINTER)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits)); |
| Abbv->Add(BitCodeAbbrevOp(0)); // Addrspace = 0 |
| unsigned PtrAbbrev = Stream.EmitAbbrev(std::move(Abbv)); |
| |
| // Abbrev for TYPE_CODE_OPAQUE_POINTER. |
| Abbv = std::make_shared<BitCodeAbbrev>(); |
| Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_OPAQUE_POINTER)); |
| Abbv->Add(BitCodeAbbrevOp(0)); // Addrspace = 0 |
| unsigned OpaquePtrAbbrev = Stream.EmitAbbrev(std::move(Abbv)); |
| |
| // Abbrev for TYPE_CODE_FUNCTION. |
| Abbv = std::make_shared<BitCodeAbbrev>(); |
| Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_FUNCTION)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isvararg |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits)); |
| unsigned FunctionAbbrev = Stream.EmitAbbrev(std::move(Abbv)); |
| |
| // Abbrev for TYPE_CODE_STRUCT_ANON. |
| Abbv = std::make_shared<BitCodeAbbrev>(); |
| Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT_ANON)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ispacked |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits)); |
| unsigned StructAnonAbbrev = Stream.EmitAbbrev(std::move(Abbv)); |
| |
| // Abbrev for TYPE_CODE_STRUCT_NAME. |
| Abbv = std::make_shared<BitCodeAbbrev>(); |
| Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT_NAME)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6)); |
| unsigned StructNameAbbrev = Stream.EmitAbbrev(std::move(Abbv)); |
| |
| // Abbrev for TYPE_CODE_STRUCT_NAMED. |
| Abbv = std::make_shared<BitCodeAbbrev>(); |
| Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT_NAMED)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ispacked |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits)); |
| unsigned StructNamedAbbrev = Stream.EmitAbbrev(std::move(Abbv)); |
| |
| // Abbrev for TYPE_CODE_ARRAY. |
| Abbv = std::make_shared<BitCodeAbbrev>(); |
| Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_ARRAY)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // size |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits)); |
| unsigned ArrayAbbrev = Stream.EmitAbbrev(std::move(Abbv)); |
| |
| // Emit an entry count so the reader can reserve space. |
| TypeVals.push_back(TypeList.size()); |
| Stream.EmitRecord(bitc::TYPE_CODE_NUMENTRY, TypeVals); |
| TypeVals.clear(); |
| |
| // Loop over all of the types, emitting each in turn. |
| for (Type *T : TypeList) { |
| int AbbrevToUse = 0; |
| unsigned Code = 0; |
| |
| switch (T->getTypeID()) { |
| case Type::VoidTyID: Code = bitc::TYPE_CODE_VOID; break; |
| case Type::HalfTyID: Code = bitc::TYPE_CODE_HALF; break; |
| case Type::BFloatTyID: Code = bitc::TYPE_CODE_BFLOAT; break; |
| case Type::FloatTyID: Code = bitc::TYPE_CODE_FLOAT; break; |
| case Type::DoubleTyID: Code = bitc::TYPE_CODE_DOUBLE; break; |
| case Type::X86_FP80TyID: Code = bitc::TYPE_CODE_X86_FP80; break; |
| case Type::FP128TyID: Code = bitc::TYPE_CODE_FP128; break; |
| case Type::PPC_FP128TyID: Code = bitc::TYPE_CODE_PPC_FP128; break; |
| case Type::LabelTyID: Code = bitc::TYPE_CODE_LABEL; break; |
| case Type::MetadataTyID: Code = bitc::TYPE_CODE_METADATA; break; |
| case Type::X86_MMXTyID: Code = bitc::TYPE_CODE_X86_MMX; break; |
| case Type::X86_AMXTyID: Code = bitc::TYPE_CODE_X86_AMX; break; |
| case Type::TokenTyID: Code = bitc::TYPE_CODE_TOKEN; break; |
| case Type::IntegerTyID: |
| // INTEGER: [width] |
| Code = bitc::TYPE_CODE_INTEGER; |
| TypeVals.push_back(cast<IntegerType>(T)->getBitWidth()); |
| break; |
| case Type::PointerTyID: { |
| PointerType *PTy = cast<PointerType>(T); |
| unsigned AddressSpace = PTy->getAddressSpace(); |
| if (PTy->isOpaque()) { |
| // OPAQUE_POINTER: [address space] |
| Code = bitc::TYPE_CODE_OPAQUE_POINTER; |
| TypeVals.push_back(AddressSpace); |
| if (AddressSpace == 0) |
| AbbrevToUse = OpaquePtrAbbrev; |
| } else { |
| // POINTER: [pointee type, address space] |
| Code = bitc::TYPE_CODE_POINTER; |
| TypeVals.push_back(VE.getTypeID(PTy->getElementType())); |
| TypeVals.push_back(AddressSpace); |
| if (AddressSpace == 0) |
| AbbrevToUse = PtrAbbrev; |
| } |
| break; |
| } |
| case Type::FunctionTyID: { |
| FunctionType *FT = cast<FunctionType>(T); |
| // FUNCTION: [isvararg, retty, paramty x N] |
| Code = bitc::TYPE_CODE_FUNCTION; |
| TypeVals.push_back(FT->isVarArg()); |
| TypeVals.push_back(VE.getTypeID(FT->getReturnType())); |
| for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) |
| TypeVals.push_back(VE.getTypeID(FT->getParamType(i))); |
| AbbrevToUse = FunctionAbbrev; |
| break; |
| } |
| case Type::StructTyID: { |
| StructType *ST = cast<StructType>(T); |
| // STRUCT: [ispacked, eltty x N] |
| TypeVals.push_back(ST->isPacked()); |
| // Output all of the element types. |
| for (Type *ET : ST->elements()) |
| TypeVals.push_back(VE.getTypeID(ET)); |
| |
| if (ST->isLiteral()) { |
| Code = bitc::TYPE_CODE_STRUCT_ANON; |
| AbbrevToUse = StructAnonAbbrev; |
| } else { |
| if (ST->isOpaque()) { |
| Code = bitc::TYPE_CODE_OPAQUE; |
| } else { |
| Code = bitc::TYPE_CODE_STRUCT_NAMED; |
| AbbrevToUse = StructNamedAbbrev; |
| } |
| |
| // Emit the name if it is present. |
| if (!ST->getName().empty()) |
| writeStringRecord(Stream, bitc::TYPE_CODE_STRUCT_NAME, ST->getName(), |
| StructNameAbbrev); |
| } |
| break; |
| } |
| case Type::ArrayTyID: { |
| ArrayType *AT = cast<ArrayType>(T); |
| // ARRAY: [numelts, eltty] |
| Code = bitc::TYPE_CODE_ARRAY; |
| TypeVals.push_back(AT->getNumElements()); |
| TypeVals.push_back(VE.getTypeID(AT->getElementType())); |
| AbbrevToUse = ArrayAbbrev; |
| break; |
| } |
| case Type::FixedVectorTyID: |
| case Type::ScalableVectorTyID: { |
| VectorType *VT = cast<VectorType>(T); |
| // VECTOR [numelts, eltty] or |
| // [numelts, eltty, scalable] |
| Code = bitc::TYPE_CODE_VECTOR; |
| TypeVals.push_back(VT->getElementCount().getKnownMinValue()); |
| TypeVals.push_back(VE.getTypeID(VT->getElementType())); |
| if (isa<ScalableVectorType>(VT)) |
| TypeVals.push_back(true); |
| break; |
| } |
| } |
| |
| // Emit the finished record. |
| Stream.EmitRecord(Code, TypeVals, AbbrevToUse); |
| TypeVals.clear(); |
| } |
| |
| Stream.ExitBlock(); |
| } |
| |
| static unsigned getEncodedLinkage(const GlobalValue::LinkageTypes Linkage) { |
| switch (Linkage) { |
| case GlobalValue::ExternalLinkage: |
| return 0; |
| case GlobalValue::WeakAnyLinkage: |
| return 16; |
| case GlobalValue::AppendingLinkage: |
| return 2; |
| case GlobalValue::InternalLinkage: |
| return 3; |
| case GlobalValue::LinkOnceAnyLinkage: |
| return 18; |
| case GlobalValue::ExternalWeakLinkage: |
| return 7; |
| case GlobalValue::CommonLinkage: |
| return 8; |
| case GlobalValue::PrivateLinkage: |
| return 9; |
| case GlobalValue::WeakODRLinkage: |
| return 17; |
| case GlobalValue::LinkOnceODRLinkage: |
| return 19; |
| case GlobalValue::AvailableExternallyLinkage: |
| return 12; |
| } |
| llvm_unreachable("Invalid linkage"); |
| } |
| |
| static unsigned getEncodedLinkage(const GlobalValue &GV) { |
| return getEncodedLinkage(GV.getLinkage()); |
| } |
| |
| static uint64_t getEncodedFFlags(FunctionSummary::FFlags Flags) { |
| uint64_t RawFlags = 0; |
| RawFlags |= Flags.ReadNone; |
| RawFlags |= (Flags.ReadOnly << 1); |
| RawFlags |= (Flags.NoRecurse << 2); |
| RawFlags |= (Flags.ReturnDoesNotAlias << 3); |
| RawFlags |= (Flags.NoInline << 4); |
| RawFlags |= (Flags.AlwaysInline << 5); |
| RawFlags |= (Flags.NoUnwind << 6); |
| RawFlags |= (Flags.MayThrow << 7); |
| RawFlags |= (Flags.HasUnknownCall << 8); |
| return RawFlags; |
| } |
| |
| // Decode the flags for GlobalValue in the summary. See getDecodedGVSummaryFlags |
| // in BitcodeReader.cpp. |
| static uint64_t getEncodedGVSummaryFlags(GlobalValueSummary::GVFlags Flags) { |
| uint64_t RawFlags = 0; |
| |
| RawFlags |= Flags.NotEligibleToImport; // bool |
| RawFlags |= (Flags.Live << 1); |
| RawFlags |= (Flags.DSOLocal << 2); |
| RawFlags |= (Flags.CanAutoHide << 3); |
| |
| // Linkage don't need to be remapped at that time for the summary. Any future |
| // change to the getEncodedLinkage() function will need to be taken into |
| // account here as well. |
| RawFlags = (RawFlags << 4) | Flags.Linkage; // 4 bits |
| |
| RawFlags |= (Flags.Visibility << 8); // 2 bits |
| |
| return RawFlags; |
| } |
| |
| static uint64_t getEncodedGVarFlags(GlobalVarSummary::GVarFlags Flags) { |
| uint64_t RawFlags = Flags.MaybeReadOnly | (Flags.MaybeWriteOnly << 1) | |
| (Flags.Constant << 2) | Flags.VCallVisibility << 3; |
| return RawFlags; |
| } |
| |
| static unsigned getEncodedVisibility(const GlobalValue &GV) { |
| switch (GV.getVisibility()) { |
| case GlobalValue::DefaultVisibility: return 0; |
| case GlobalValue::HiddenVisibility: return 1; |
| case GlobalValue::ProtectedVisibility: return 2; |
| } |
| llvm_unreachable("Invalid visibility"); |
| } |
| |
| static unsigned getEncodedDLLStorageClass(const GlobalValue &GV) { |
| switch (GV.getDLLStorageClass()) { |
| case GlobalValue::DefaultStorageClass: return 0; |
| case GlobalValue::DLLImportStorageClass: return 1; |
| case GlobalValue::DLLExportStorageClass: return 2; |
| } |
| llvm_unreachable("Invalid DLL storage class"); |
| } |
| |
| static unsigned getEncodedThreadLocalMode(const GlobalValue &GV) { |
| switch (GV.getThreadLocalMode()) { |
| case GlobalVariable::NotThreadLocal: return 0; |
| case GlobalVariable::GeneralDynamicTLSModel: return 1; |
| case GlobalVariable::LocalDynamicTLSModel: return 2; |
| case GlobalVariable::InitialExecTLSModel: return 3; |
| case GlobalVariable::LocalExecTLSModel: return 4; |
| } |
| llvm_unreachable("Invalid TLS model"); |
| } |
| |
| static unsigned getEncodedComdatSelectionKind(const Comdat &C) { |
| switch (C.getSelectionKind()) { |
| case Comdat::Any: |
| return bitc::COMDAT_SELECTION_KIND_ANY; |
| case Comdat::ExactMatch: |
| return bitc::COMDAT_SELECTION_KIND_EXACT_MATCH; |
| case Comdat::Largest: |
| return bitc::COMDAT_SELECTION_KIND_LARGEST; |
| case Comdat::NoDeduplicate: |
| return bitc::COMDAT_SELECTION_KIND_NO_DUPLICATES; |
| case Comdat::SameSize: |
| return bitc::COMDAT_SELECTION_KIND_SAME_SIZE; |
| } |
| llvm_unreachable("Invalid selection kind"); |
| } |
| |
| static unsigned getEncodedUnnamedAddr(const GlobalValue &GV) { |
| switch (GV.getUnnamedAddr()) { |
| case GlobalValue::UnnamedAddr::None: return 0; |
| case GlobalValue::UnnamedAddr::Local: return 2; |
| case GlobalValue::UnnamedAddr::Global: return 1; |
| } |
| llvm_unreachable("Invalid unnamed_addr"); |
| } |
| |
| size_t ModuleBitcodeWriter::addToStrtab(StringRef Str) { |
| if (GenerateHash) |
| Hasher.update(Str); |
| return StrtabBuilder.add(Str); |
| } |
| |
| void ModuleBitcodeWriter::writeComdats() { |
| SmallVector<unsigned, 64> Vals; |
| for (const Comdat *C : VE.getComdats()) { |
| // COMDAT: [strtab offset, strtab size, selection_kind] |
| Vals.push_back(addToStrtab(C->getName())); |
| Vals.push_back(C->getName().size()); |
| Vals.push_back(getEncodedComdatSelectionKind(*C)); |
| Stream.EmitRecord(bitc::MODULE_CODE_COMDAT, Vals, /*AbbrevToUse=*/0); |
| Vals.clear(); |
| } |
| } |
| |
| /// Write a record that will eventually hold the word offset of the |
| /// module-level VST. For now the offset is 0, which will be backpatched |
| /// after the real VST is written. Saves the bit offset to backpatch. |
| void ModuleBitcodeWriter::writeValueSymbolTableForwardDecl() { |
| // Write a placeholder value in for the offset of the real VST, |
| // which is written after the function blocks so that it can include |
| // the offset of each function. The placeholder offset will be |
| // updated when the real VST is written. |
| auto Abbv = std::make_shared<BitCodeAbbrev>(); |
| Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_VSTOFFSET)); |
| // Blocks are 32-bit aligned, so we can use a 32-bit word offset to |
| // hold the real VST offset. Must use fixed instead of VBR as we don't |
| // know how many VBR chunks to reserve ahead of time. |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); |
| unsigned VSTOffsetAbbrev = Stream.EmitAbbrev(std::move(Abbv)); |
| |
| // Emit the placeholder |
| uint64_t Vals[] = {bitc::MODULE_CODE_VSTOFFSET, 0}; |
| Stream.EmitRecordWithAbbrev(VSTOffsetAbbrev, Vals); |
| |
| // Compute and save the bit offset to the placeholder, which will be |
| // patched when the real VST is written. We can simply subtract the 32-bit |
| // fixed size from the current bit number to get the location to backpatch. |
| VSTOffsetPlaceholder = Stream.GetCurrentBitNo() - 32; |
| } |
| |
| enum StringEncoding { SE_Char6, SE_Fixed7, SE_Fixed8 }; |
| |
| /// Determine the encoding to use for the given string name and length. |
| static StringEncoding getStringEncoding(StringRef Str) { |
| bool isChar6 = true; |
| for (char C : Str) { |
| if (isChar6) |
| isChar6 = BitCodeAbbrevOp::isChar6(C); |
| if ((unsigned char)C & 128) |
| // don't bother scanning the rest. |
| return SE_Fixed8; |
| } |
| if (isChar6) |
| return SE_Char6; |
| return SE_Fixed7; |
| } |
| |
| /// Emit top-level description of module, including target triple, inline asm, |
| /// descriptors for global variables, and function prototype info. |
| /// Returns the bit offset to backpatch with the location of the real VST. |
| void ModuleBitcodeWriter::writeModuleInfo() { |
| // Emit various pieces of data attached to a module. |
| if (!M.getTargetTriple().empty()) |
| writeStringRecord(Stream, bitc::MODULE_CODE_TRIPLE, M.getTargetTriple(), |
| 0 /*TODO*/); |
| const std::string &DL = M.getDataLayoutStr(); |
| if (!DL.empty()) |
| writeStringRecord(Stream, bitc::MODULE_CODE_DATALAYOUT, DL, 0 /*TODO*/); |
| if (!M.getModuleInlineAsm().empty()) |
| writeStringRecord(Stream, bitc::MODULE_CODE_ASM, M.getModuleInlineAsm(), |
| 0 /*TODO*/); |
| |
| // Emit information about sections and GC, computing how many there are. Also |
| // compute the maximum alignment value. |
| std::map<std::string, unsigned> SectionMap; |
| std::map<std::string, unsigned> GCMap; |
| MaybeAlign MaxAlignment; |
| unsigned MaxGlobalType = 0; |
| const auto UpdateMaxAlignment = [&MaxAlignment](const MaybeAlign A) { |
| if (A) |
| MaxAlignment = !MaxAlignment ? *A : std::max(*MaxAlignment, *A); |
| }; |
| for (const GlobalVariable &GV : M.globals()) { |
| UpdateMaxAlignment(GV.getAlign()); |
| MaxGlobalType = std::max(MaxGlobalType, VE.getTypeID(GV.getValueType())); |
| if (GV.hasSection()) { |
| // Give section names unique ID's. |
| unsigned &Entry = SectionMap[std::string(GV.getSection())]; |
| if (!Entry) { |
| writeStringRecord(Stream, bitc::MODULE_CODE_SECTIONNAME, GV.getSection(), |
| 0 /*TODO*/); |
| Entry = SectionMap.size(); |
| } |
| } |
| } |
| for (const Function &F : M) { |
| UpdateMaxAlignment(F.getAlign()); |
| if (F.hasSection()) { |
| // Give section names unique ID's. |
| unsigned &Entry = SectionMap[std::string(F.getSection())]; |
| if (!Entry) { |
| writeStringRecord(Stream, bitc::MODULE_CODE_SECTIONNAME, F.getSection(), |
| 0 /*TODO*/); |
| Entry = SectionMap.size(); |
| } |
| } |
| if (F.hasGC()) { |
| // Same for GC names. |
| unsigned &Entry = GCMap[F.getGC()]; |
| if (!Entry) { |
| writeStringRecord(Stream, bitc::MODULE_CODE_GCNAME, F.getGC(), |
| 0 /*TODO*/); |
| Entry = GCMap.size(); |
| } |
| } |
| } |
| |
| // Emit abbrev for globals, now that we know # sections and max alignment. |
| unsigned SimpleGVarAbbrev = 0; |
| if (!M.global_empty()) { |
| // Add an abbrev for common globals with no visibility or thread localness. |
| auto Abbv = std::make_shared<BitCodeAbbrev>(); |
| Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_GLOBALVAR)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, |
| Log2_32_Ceil(MaxGlobalType+1))); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // AddrSpace << 2 |
| //| explicitType << 1 |
| //| constant |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Initializer. |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // Linkage. |
| if (!MaxAlignment) // Alignment. |
| Abbv->Add(BitCodeAbbrevOp(0)); |
| else { |
| unsigned MaxEncAlignment = getEncodedAlign(MaxAlignment); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, |
| Log2_32_Ceil(MaxEncAlignment+1))); |
| } |
| if (SectionMap.empty()) // Section. |
| Abbv->Add(BitCodeAbbrevOp(0)); |
| else |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, |
| Log2_32_Ceil(SectionMap.size()+1))); |
| // Don't bother emitting vis + thread local. |
| SimpleGVarAbbrev = Stream.EmitAbbrev(std::move(Abbv)); |
| } |
| |
| SmallVector<unsigned, 64> Vals; |
| // Emit the module's source file name. |
| { |
| StringEncoding Bits = getStringEncoding(M.getSourceFileName()); |
| BitCodeAbbrevOp AbbrevOpToUse = BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8); |
| if (Bits == SE_Char6) |
| AbbrevOpToUse = BitCodeAbbrevOp(BitCodeAbbrevOp::Char6); |
| else if (Bits == SE_Fixed7) |
| AbbrevOpToUse = BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7); |
| |
| // MODULE_CODE_SOURCE_FILENAME: [namechar x N] |
| auto Abbv = std::make_shared<BitCodeAbbrev>(); |
| Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_SOURCE_FILENAME)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); |
| Abbv->Add(AbbrevOpToUse); |
| unsigned FilenameAbbrev = Stream.EmitAbbrev(std::move(Abbv)); |
| |
| for (const auto P : M.getSourceFileName()) |
| Vals.push_back((unsigned char)P); |
| |
| // Emit the finished record. |
| Stream.EmitRecord(bitc::MODULE_CODE_SOURCE_FILENAME, Vals, FilenameAbbrev); |
| Vals.clear(); |
| } |
| |
| // Emit the global variable information. |
| for (const GlobalVariable &GV : M.globals()) { |
| unsigned AbbrevToUse = 0; |
| |
| // GLOBALVAR: [strtab offset, strtab size, type, isconst, initid, |
| // linkage, alignment, section, visibility, threadlocal, |
| // unnamed_addr, externally_initialized, dllstorageclass, |
| // comdat, attributes, DSO_Local] |
| Vals.push_back(addToStrtab(GV.getName())); |
| Vals.push_back(GV.getName().size()); |
| Vals.push_back(VE.getTypeID(GV.getValueType())); |
| Vals.push_back(GV.getType()->getAddressSpace() << 2 | 2 | GV.isConstant()); |
| Vals.push_back(GV.isDeclaration() ? 0 : |
| (VE.getValueID(GV.getInitializer()) + 1)); |
| Vals.push_back(getEncodedLinkage(GV)); |
| Vals.push_back(getEncodedAlign(GV.getAlign())); |
| Vals.push_back(GV.hasSection() ? SectionMap[std::string(GV.getSection())] |
| : 0); |
| if (GV.isThreadLocal() || |
| GV.getVisibility() != GlobalValue::DefaultVisibility || |
| GV.getUnnamedAddr() != GlobalValue::UnnamedAddr::None || |
| GV.isExternallyInitialized() || |
| GV.getDLLStorageClass() != GlobalValue::DefaultStorageClass || |
| GV.hasComdat() || |
| GV.hasAttributes() || |
| GV.isDSOLocal() || |
| GV.hasPartition()) { |
| Vals.push_back(getEncodedVisibility(GV)); |
| Vals.push_back(getEncodedThreadLocalMode(GV)); |
| Vals.push_back(getEncodedUnnamedAddr(GV)); |
| Vals.push_back(GV.isExternallyInitialized()); |
| Vals.push_back(getEncodedDLLStorageClass(GV)); |
| Vals.push_back(GV.hasComdat() ? VE.getComdatID(GV.getComdat()) : 0); |
| |
| auto AL = GV.getAttributesAsList(AttributeList::FunctionIndex); |
| Vals.push_back(VE.getAttributeListID(AL)); |
| |
| Vals.push_back(GV.isDSOLocal()); |
| Vals.push_back(addToStrtab(GV.getPartition())); |
| Vals.push_back(GV.getPartition().size()); |
| } else { |
| AbbrevToUse = SimpleGVarAbbrev; |
| } |
| |
| Stream.EmitRecord(bitc::MODULE_CODE_GLOBALVAR, Vals, AbbrevToUse); |
| Vals.clear(); |
| } |
| |
| // Emit the function proto information. |
| for (const Function &F : M) { |
| // FUNCTION: [strtab offset, strtab size, type, callingconv, isproto, |
| // linkage, paramattrs, alignment, section, visibility, gc, |
| // unnamed_addr, prologuedata, dllstorageclass, comdat, |
| // prefixdata, personalityfn, DSO_Local, addrspace] |
| Vals.push_back(addToStrtab(F.getName())); |
| Vals.push_back(F.getName().size()); |
| Vals.push_back(VE.getTypeID(F.getFunctionType())); |
| Vals.push_back(F.getCallingConv()); |
| Vals.push_back(F.isDeclaration()); |
| Vals.push_back(getEncodedLinkage(F)); |
| Vals.push_back(VE.getAttributeListID(F.getAttributes())); |
| Vals.push_back(getEncodedAlign(F.getAlign())); |
| Vals.push_back(F.hasSection() ? SectionMap[std::string(F.getSection())] |
| : 0); |
| Vals.push_back(getEncodedVisibility(F)); |
| Vals.push_back(F.hasGC() ? GCMap[F.getGC()] : 0); |
| Vals.push_back(getEncodedUnnamedAddr(F)); |
| Vals.push_back(F.hasPrologueData() ? (VE.getValueID(F.getPrologueData()) + 1) |
| : 0); |
| Vals.push_back(getEncodedDLLStorageClass(F)); |
| Vals.push_back(F.hasComdat() ? VE.getComdatID(F.getComdat()) : 0); |
| Vals.push_back(F.hasPrefixData() ? (VE.getValueID(F.getPrefixData()) + 1) |
| : 0); |
| Vals.push_back( |
| F.hasPersonalityFn() ? (VE.getValueID(F.getPersonalityFn()) + 1) : 0); |
| |
| Vals.push_back(F.isDSOLocal()); |
| Vals.push_back(F.getAddressSpace()); |
| Vals.push_back(addToStrtab(F.getPartition())); |
| Vals.push_back(F.getPartition().size()); |
| |
| unsigned AbbrevToUse = 0; |
| Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals, AbbrevToUse); |
| Vals.clear(); |
| } |
| |
| // Emit the alias information. |
| for (const GlobalAlias &A : M.aliases()) { |
| // ALIAS: [strtab offset, strtab size, alias type, aliasee val#, linkage, |
| // visibility, dllstorageclass, threadlocal, unnamed_addr, |
| // DSO_Local] |
| Vals.push_back(addToStrtab(A.getName())); |
| Vals.push_back(A.getName().size()); |
| Vals.push_back(VE.getTypeID(A.getValueType())); |
| Vals.push_back(A.getType()->getAddressSpace()); |
| Vals.push_back(VE.getValueID(A.getAliasee())); |
| Vals.push_back(getEncodedLinkage(A)); |
| Vals.push_back(getEncodedVisibility(A)); |
| Vals.push_back(getEncodedDLLStorageClass(A)); |
| Vals.push_back(getEncodedThreadLocalMode(A)); |
| Vals.push_back(getEncodedUnnamedAddr(A)); |
| Vals.push_back(A.isDSOLocal()); |
| Vals.push_back(addToStrtab(A.getPartition())); |
| Vals.push_back(A.getPartition().size()); |
| |
| unsigned AbbrevToUse = 0; |
| Stream.EmitRecord(bitc::MODULE_CODE_ALIAS, Vals, AbbrevToUse); |
| Vals.clear(); |
| } |
| |
| // Emit the ifunc information. |
| for (const GlobalIFunc &I : M.ifuncs()) { |
| // IFUNC: [strtab offset, strtab size, ifunc type, address space, resolver |
| // val#, linkage, visibility, DSO_Local] |
| Vals.push_back(addToStrtab(I.getName())); |
| Vals.push_back(I.getName().size()); |
| Vals.push_back(VE.getTypeID(I.getValueType())); |
| Vals.push_back(I.getType()->getAddressSpace()); |
| Vals.push_back(VE.getValueID(I.getResolver())); |
| Vals.push_back(getEncodedLinkage(I)); |
| Vals.push_back(getEncodedVisibility(I)); |
| Vals.push_back(I.isDSOLocal()); |
| Vals.push_back(addToStrtab(I.getPartition())); |
| Vals.push_back(I.getPartition().size()); |
| Stream.EmitRecord(bitc::MODULE_CODE_IFUNC, Vals); |
| Vals.clear(); |
| } |
| |
| writeValueSymbolTableForwardDecl(); |
| } |
| |
| static uint64_t getOptimizationFlags(const Value *V) { |
| uint64_t Flags = 0; |
| |
| if (const auto *OBO = dyn_cast<OverflowingBinaryOperator>(V)) { |
| if (OBO->hasNoSignedWrap()) |
| Flags |= 1 << bitc::OBO_NO_SIGNED_WRAP; |
| if (OBO->hasNoUnsignedWrap()) |
| Flags |= 1 << bitc::OBO_NO_UNSIGNED_WRAP; |
| } else if (const auto *PEO = dyn_cast<PossiblyExactOperator>(V)) { |
| if (PEO->isExact()) |
| Flags |= 1 << bitc::PEO_EXACT; |
| } else if (const auto *FPMO = dyn_cast<FPMathOperator>(V)) { |
| if (FPMO->hasAllowReassoc()) |
| Flags |= bitc::AllowReassoc; |
| if (FPMO->hasNoNaNs()) |
| Flags |= bitc::NoNaNs; |
| if (FPMO->hasNoInfs()) |
| Flags |= bitc::NoInfs; |
| if (FPMO->hasNoSignedZeros()) |
| Flags |= bitc::NoSignedZeros; |
| if (FPMO->hasAllowReciprocal()) |
| Flags |= bitc::AllowReciprocal; |
| if (FPMO->hasAllowContract()) |
| Flags |= bitc::AllowContract; |
| if (FPMO->hasApproxFunc()) |
| Flags |= bitc::ApproxFunc; |
| } |
| |
| return Flags; |
| } |
| |
| void ModuleBitcodeWriter::writeValueAsMetadata( |
| const ValueAsMetadata *MD, SmallVectorImpl<uint64_t> &Record) { |
| // Mimic an MDNode with a value as one operand. |
| Value *V = MD->getValue(); |
| Record.push_back(VE.getTypeID(V->getType())); |
| Record.push_back(VE.getValueID(V)); |
| Stream.EmitRecord(bitc::METADATA_VALUE, Record, 0); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeMDTuple(const MDTuple *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) { |
| Metadata *MD = N->getOperand(i); |
| assert(!(MD && isa<LocalAsMetadata>(MD)) && |
| "Unexpected function-local metadata"); |
| Record.push_back(VE.getMetadataOrNullID(MD)); |
| } |
| Stream.EmitRecord(N->isDistinct() ? bitc::METADATA_DISTINCT_NODE |
| : bitc::METADATA_NODE, |
| Record, Abbrev); |
| Record.clear(); |
| } |
| |
| unsigned ModuleBitcodeWriter::createDILocationAbbrev() { |
| // 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). |
| auto Abbv = std::make_shared<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)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); |
| return Stream.EmitAbbrev(std::move(Abbv)); |
| } |
| |
| void ModuleBitcodeWriter::writeDILocation(const DILocation *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned &Abbrev) { |
| if (!Abbrev) |
| Abbrev = createDILocationAbbrev(); |
| |
| 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())); |
| Record.push_back(N->isImplicitCode()); |
| |
| Stream.EmitRecord(bitc::METADATA_LOCATION, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| unsigned ModuleBitcodeWriter::createGenericDINodeAbbrev() { |
| // 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). |
| auto Abbv = std::make_shared<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)); |
| return Stream.EmitAbbrev(std::move(Abbv)); |
| } |
| |
| void ModuleBitcodeWriter::writeGenericDINode(const GenericDINode *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned &Abbrev) { |
| if (!Abbrev) |
| Abbrev = createGenericDINodeAbbrev(); |
| |
| 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(); |
| } |
| |
| void ModuleBitcodeWriter::writeDISubrange(const DISubrange *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| const uint64_t Version = 2 << 1; |
| Record.push_back((uint64_t)N->isDistinct() | Version); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawCountNode())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawLowerBound())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawUpperBound())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawStride())); |
| |
| Stream.EmitRecord(bitc::METADATA_SUBRANGE, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDIGenericSubrange( |
| const DIGenericSubrange *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| Record.push_back((uint64_t)N->isDistinct()); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawCountNode())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawLowerBound())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawUpperBound())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawStride())); |
| |
| Stream.EmitRecord(bitc::METADATA_GENERIC_SUBRANGE, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| static void emitSignedInt64(SmallVectorImpl<uint64_t> &Vals, uint64_t V) { |
| if ((int64_t)V >= 0) |
| Vals.push_back(V << 1); |
| else |
| Vals.push_back((-V << 1) | 1); |
| } |
| |
| static void emitWideAPInt(SmallVectorImpl<uint64_t> &Vals, const APInt &A) { |
| // We have an arbitrary precision integer value to write whose |
| // bit width is > 64. However, in canonical unsigned integer |
| // format it is likely that the high bits are going to be zero. |
| // So, we only write the number of active words. |
| unsigned NumWords = A.getActiveWords(); |
| const uint64_t *RawData = A.getRawData(); |
| for (unsigned i = 0; i < NumWords; i++) |
| emitSignedInt64(Vals, RawData[i]); |
| } |
| |
| void ModuleBitcodeWriter::writeDIEnumerator(const DIEnumerator *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| const uint64_t IsBigInt = 1 << 2; |
| Record.push_back(IsBigInt | (N->isUnsigned() << 1) | N->isDistinct()); |
| Record.push_back(N->getValue().getBitWidth()); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawName())); |
| emitWideAPInt(Record, N->getValue()); |
| |
| Stream.EmitRecord(bitc::METADATA_ENUMERATOR, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDIBasicType(const DIBasicType *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| Record.push_back(N->isDistinct()); |
| Record.push_back(N->getTag()); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawName())); |
| Record.push_back(N->getSizeInBits()); |
| Record.push_back(N->getAlignInBits()); |
| Record.push_back(N->getEncoding()); |
| Record.push_back(N->getFlags()); |
| |
| Stream.EmitRecord(bitc::METADATA_BASIC_TYPE, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDIStringType(const DIStringType *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| Record.push_back(N->isDistinct()); |
| Record.push_back(N->getTag()); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawName())); |
| Record.push_back(VE.getMetadataOrNullID(N->getStringLength())); |
| Record.push_back(VE.getMetadataOrNullID(N->getStringLengthExp())); |
| Record.push_back(N->getSizeInBits()); |
| Record.push_back(N->getAlignInBits()); |
| Record.push_back(N->getEncoding()); |
| |
| Stream.EmitRecord(bitc::METADATA_STRING_TYPE, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDIDerivedType(const DIDerivedType *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| Record.push_back(N->isDistinct()); |
| Record.push_back(N->getTag()); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawName())); |
| Record.push_back(VE.getMetadataOrNullID(N->getFile())); |
| Record.push_back(N->getLine()); |
| Record.push_back(VE.getMetadataOrNullID(N->getScope())); |
| Record.push_back(VE.getMetadataOrNullID(N->getBaseType())); |
| Record.push_back(N->getSizeInBits()); |
| Record.push_back(N->getAlignInBits()); |
| Record.push_back(N->getOffsetInBits()); |
| Record.push_back(N->getFlags()); |
| Record.push_back(VE.getMetadataOrNullID(N->getExtraData())); |
| |
| // DWARF address space is encoded as N->getDWARFAddressSpace() + 1. 0 means |
| // that there is no DWARF address space associated with DIDerivedType. |
| if (const auto &DWARFAddressSpace = N->getDWARFAddressSpace()) |
| Record.push_back(*DWARFAddressSpace + 1); |
| else |
| Record.push_back(0); |
| |
| Record.push_back(VE.getMetadataOrNullID(N->getAnnotations().get())); |
| |
| Stream.EmitRecord(bitc::METADATA_DERIVED_TYPE, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDICompositeType( |
| const DICompositeType *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| const unsigned IsNotUsedInOldTypeRef = 0x2; |
| Record.push_back(IsNotUsedInOldTypeRef | (unsigned)N->isDistinct()); |
| Record.push_back(N->getTag()); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawName())); |
| Record.push_back(VE.getMetadataOrNullID(N->getFile())); |
| Record.push_back(N->getLine()); |
| Record.push_back(VE.getMetadataOrNullID(N->getScope())); |
| Record.push_back(VE.getMetadataOrNullID(N->getBaseType())); |
| Record.push_back(N->getSizeInBits()); |
| Record.push_back(N->getAlignInBits()); |
| Record.push_back(N->getOffsetInBits()); |
| Record.push_back(N->getFlags()); |
| Record.push_back(VE.getMetadataOrNullID(N->getElements().get())); |
| Record.push_back(N->getRuntimeLang()); |
| Record.push_back(VE.getMetadataOrNullID(N->getVTableHolder())); |
| Record.push_back(VE.getMetadataOrNullID(N->getTemplateParams().get())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawIdentifier())); |
| Record.push_back(VE.getMetadataOrNullID(N->getDiscriminator())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawDataLocation())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawAssociated())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawAllocated())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawRank())); |
| Record.push_back(VE.getMetadataOrNullID(N->getAnnotations().get())); |
| |
| Stream.EmitRecord(bitc::METADATA_COMPOSITE_TYPE, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDISubroutineType( |
| const DISubroutineType *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| const unsigned HasNoOldTypeRefs = 0x2; |
| Record.push_back(HasNoOldTypeRefs | (unsigned)N->isDistinct()); |
| Record.push_back(N->getFlags()); |
| Record.push_back(VE.getMetadataOrNullID(N->getTypeArray().get())); |
| Record.push_back(N->getCC()); |
| |
| Stream.EmitRecord(bitc::METADATA_SUBROUTINE_TYPE, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDIFile(const DIFile *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| Record.push_back(N->isDistinct()); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawFilename())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawDirectory())); |
| if (N->getRawChecksum()) { |
| Record.push_back(N->getRawChecksum()->Kind); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawChecksum()->Value)); |
| } else { |
| // Maintain backwards compatibility with the old internal representation of |
| // CSK_None in ChecksumKind by writing nulls here when Checksum is None. |
| Record.push_back(0); |
| Record.push_back(VE.getMetadataOrNullID(nullptr)); |
| } |
| auto Source = N->getRawSource(); |
| if (Source) |
| Record.push_back(VE.getMetadataOrNullID(*Source)); |
| |
| Stream.EmitRecord(bitc::METADATA_FILE, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDICompileUnit(const DICompileUnit *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| assert(N->isDistinct() && "Expected distinct compile units"); |
| Record.push_back(/* IsDistinct */ true); |
| Record.push_back(N->getSourceLanguage()); |
| Record.push_back(VE.getMetadataOrNullID(N->getFile())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawProducer())); |
| Record.push_back(N->isOptimized()); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawFlags())); |
| Record.push_back(N->getRuntimeVersion()); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawSplitDebugFilename())); |
| Record.push_back(N->getEmissionKind()); |
| Record.push_back(VE.getMetadataOrNullID(N->getEnumTypes().get())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRetainedTypes().get())); |
| Record.push_back(/* subprograms */ 0); |
| Record.push_back(VE.getMetadataOrNullID(N->getGlobalVariables().get())); |
| Record.push_back(VE.getMetadataOrNullID(N->getImportedEntities().get())); |
| Record.push_back(N->getDWOId()); |
| Record.push_back(VE.getMetadataOrNullID(N->getMacros().get())); |
| Record.push_back(N->getSplitDebugInlining()); |
| Record.push_back(N->getDebugInfoForProfiling()); |
| Record.push_back((unsigned)N->getNameTableKind()); |
| Record.push_back(N->getRangesBaseAddress()); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawSysRoot())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawSDK())); |
| |
| Stream.EmitRecord(bitc::METADATA_COMPILE_UNIT, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDISubprogram(const DISubprogram *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| const uint64_t HasUnitFlag = 1 << 1; |
| const uint64_t HasSPFlagsFlag = 1 << 2; |
| Record.push_back(uint64_t(N->isDistinct()) | HasUnitFlag | HasSPFlagsFlag); |
| Record.push_back(VE.getMetadataOrNullID(N->getScope())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawName())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawLinkageName())); |
| Record.push_back(VE.getMetadataOrNullID(N->getFile())); |
| Record.push_back(N->getLine()); |
| Record.push_back(VE.getMetadataOrNullID(N->getType())); |
| Record.push_back(N->getScopeLine()); |
| Record.push_back(VE.getMetadataOrNullID(N->getContainingType())); |
| Record.push_back(N->getSPFlags()); |
| Record.push_back(N->getVirtualIndex()); |
| Record.push_back(N->getFlags()); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawUnit())); |
| Record.push_back(VE.getMetadataOrNullID(N->getTemplateParams().get())); |
| Record.push_back(VE.getMetadataOrNullID(N->getDeclaration())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRetainedNodes().get())); |
| Record.push_back(N->getThisAdjustment()); |
| Record.push_back(VE.getMetadataOrNullID(N->getThrownTypes().get())); |
| Record.push_back(VE.getMetadataOrNullID(N->getAnnotations().get())); |
| |
| Stream.EmitRecord(bitc::METADATA_SUBPROGRAM, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDILexicalBlock(const DILexicalBlock *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| Record.push_back(N->isDistinct()); |
| Record.push_back(VE.getMetadataOrNullID(N->getScope())); |
| Record.push_back(VE.getMetadataOrNullID(N->getFile())); |
| Record.push_back(N->getLine()); |
| Record.push_back(N->getColumn()); |
| |
| Stream.EmitRecord(bitc::METADATA_LEXICAL_BLOCK, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDILexicalBlockFile( |
| const DILexicalBlockFile *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| Record.push_back(N->isDistinct()); |
| Record.push_back(VE.getMetadataOrNullID(N->getScope())); |
| Record.push_back(VE.getMetadataOrNullID(N->getFile())); |
| Record.push_back(N->getDiscriminator()); |
| |
| Stream.EmitRecord(bitc::METADATA_LEXICAL_BLOCK_FILE, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDICommonBlock(const DICommonBlock *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| Record.push_back(N->isDistinct()); |
| Record.push_back(VE.getMetadataOrNullID(N->getScope())); |
| Record.push_back(VE.getMetadataOrNullID(N->getDecl())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawName())); |
| Record.push_back(VE.getMetadataOrNullID(N->getFile())); |
| Record.push_back(N->getLineNo()); |
| |
| Stream.EmitRecord(bitc::METADATA_COMMON_BLOCK, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDINamespace(const DINamespace *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| Record.push_back(N->isDistinct() | N->getExportSymbols() << 1); |
| Record.push_back(VE.getMetadataOrNullID(N->getScope())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawName())); |
| |
| Stream.EmitRecord(bitc::METADATA_NAMESPACE, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDIMacro(const DIMacro *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| Record.push_back(N->isDistinct()); |
| Record.push_back(N->getMacinfoType()); |
| Record.push_back(N->getLine()); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawName())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawValue())); |
| |
| Stream.EmitRecord(bitc::METADATA_MACRO, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDIMacroFile(const DIMacroFile *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| Record.push_back(N->isDistinct()); |
| Record.push_back(N->getMacinfoType()); |
| Record.push_back(N->getLine()); |
| Record.push_back(VE.getMetadataOrNullID(N->getFile())); |
| Record.push_back(VE.getMetadataOrNullID(N->getElements().get())); |
| |
| Stream.EmitRecord(bitc::METADATA_MACRO_FILE, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDIArgList(const DIArgList *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| Record.reserve(N->getArgs().size()); |
| for (ValueAsMetadata *MD : N->getArgs()) |
| Record.push_back(VE.getMetadataID(MD)); |
| |
| Stream.EmitRecord(bitc::METADATA_ARG_LIST, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDIModule(const DIModule *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| Record.push_back(N->isDistinct()); |
| for (auto &I : N->operands()) |
| Record.push_back(VE.getMetadataOrNullID(I)); |
| Record.push_back(N->getLineNo()); |
| Record.push_back(N->getIsDecl()); |
| |
| Stream.EmitRecord(bitc::METADATA_MODULE, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDITemplateTypeParameter( |
| const DITemplateTypeParameter *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| Record.push_back(N->isDistinct()); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawName())); |
| Record.push_back(VE.getMetadataOrNullID(N->getType())); |
| Record.push_back(N->isDefault()); |
| |
| Stream.EmitRecord(bitc::METADATA_TEMPLATE_TYPE, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDITemplateValueParameter( |
| const DITemplateValueParameter *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| Record.push_back(N->isDistinct()); |
| Record.push_back(N->getTag()); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawName())); |
| Record.push_back(VE.getMetadataOrNullID(N->getType())); |
| Record.push_back(N->isDefault()); |
| Record.push_back(VE.getMetadataOrNullID(N->getValue())); |
| |
| Stream.EmitRecord(bitc::METADATA_TEMPLATE_VALUE, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDIGlobalVariable( |
| const DIGlobalVariable *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| const uint64_t Version = 2 << 1; |
| Record.push_back((uint64_t)N->isDistinct() | Version); |
| Record.push_back(VE.getMetadataOrNullID(N->getScope())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawName())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawLinkageName())); |
| Record.push_back(VE.getMetadataOrNullID(N->getFile())); |
| Record.push_back(N->getLine()); |
| Record.push_back(VE.getMetadataOrNullID(N->getType())); |
| Record.push_back(N->isLocalToUnit()); |
| Record.push_back(N->isDefinition()); |
| Record.push_back(VE.getMetadataOrNullID(N->getStaticDataMemberDeclaration())); |
| Record.push_back(VE.getMetadataOrNullID(N->getTemplateParams())); |
| Record.push_back(N->getAlignInBits()); |
| Record.push_back(VE.getMetadataOrNullID(N->getAnnotations().get())); |
| |
| Stream.EmitRecord(bitc::METADATA_GLOBAL_VAR, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDILocalVariable( |
| const DILocalVariable *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| // In order to support all possible bitcode formats in BitcodeReader we need |
| // to distinguish the following cases: |
| // 1) Record has no artificial tag (Record[1]), |
| // has no obsolete inlinedAt field (Record[9]). |
| // In this case Record size will be 8, HasAlignment flag is false. |
| // 2) Record has artificial tag (Record[1]), |
| // has no obsolete inlignedAt field (Record[9]). |
| // In this case Record size will be 9, HasAlignment flag is false. |
| // 3) Record has both artificial tag (Record[1]) and |
| // obsolete inlignedAt field (Record[9]). |
| // In this case Record size will be 10, HasAlignment flag is false. |
| // 4) Record has neither artificial tag, nor inlignedAt field, but |
| // HasAlignment flag is true and Record[8] contains alignment value. |
| const uint64_t HasAlignmentFlag = 1 << 1; |
| Record.push_back((uint64_t)N->isDistinct() | HasAlignmentFlag); |
| Record.push_back(VE.getMetadataOrNullID(N->getScope())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawName())); |
| Record.push_back(VE.getMetadataOrNullID(N->getFile())); |
| Record.push_back(N->getLine()); |
| Record.push_back(VE.getMetadataOrNullID(N->getType())); |
| Record.push_back(N->getArg()); |
| Record.push_back(N->getFlags()); |
| Record.push_back(N->getAlignInBits()); |
| Record.push_back(VE.getMetadataOrNullID(N->getAnnotations().get())); |
| |
| Stream.EmitRecord(bitc::METADATA_LOCAL_VAR, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDILabel( |
| const DILabel *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| Record.push_back((uint64_t)N->isDistinct()); |
| Record.push_back(VE.getMetadataOrNullID(N->getScope())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawName())); |
| Record.push_back(VE.getMetadataOrNullID(N->getFile())); |
| Record.push_back(N->getLine()); |
| |
| Stream.EmitRecord(bitc::METADATA_LABEL, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDIExpression(const DIExpression *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| Record.reserve(N->getElements().size() + 1); |
| const uint64_t Version = 3 << 1; |
| Record.push_back((uint64_t)N->isDistinct() | Version); |
| Record.append(N->elements_begin(), N->elements_end()); |
| |
| Stream.EmitRecord(bitc::METADATA_EXPRESSION, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDIGlobalVariableExpression( |
| const DIGlobalVariableExpression *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| Record.push_back(N->isDistinct()); |
| Record.push_back(VE.getMetadataOrNullID(N->getVariable())); |
| Record.push_back(VE.getMetadataOrNullID(N->getExpression())); |
| |
| Stream.EmitRecord(bitc::METADATA_GLOBAL_VAR_EXPR, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDIObjCProperty(const DIObjCProperty *N, |
| SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| Record.push_back(N->isDistinct()); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawName())); |
| Record.push_back(VE.getMetadataOrNullID(N->getFile())); |
| Record.push_back(N->getLine()); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawSetterName())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawGetterName())); |
| Record.push_back(N->getAttributes()); |
| Record.push_back(VE.getMetadataOrNullID(N->getType())); |
| |
| Stream.EmitRecord(bitc::METADATA_OBJC_PROPERTY, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| void ModuleBitcodeWriter::writeDIImportedEntity( |
| const DIImportedEntity *N, SmallVectorImpl<uint64_t> &Record, |
| unsigned Abbrev) { |
| Record.push_back(N->isDistinct()); |
| Record.push_back(N->getTag()); |
| Record.push_back(VE.getMetadataOrNullID(N->getScope())); |
| Record.push_back(VE.getMetadataOrNullID(N->getEntity())); |
| Record.push_back(N->getLine()); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawName())); |
| Record.push_back(VE.getMetadataOrNullID(N->getRawFile())); |
| Record.push_back(VE.getMetadataOrNullID(N->getElements().get())); |
| |
| Stream.EmitRecord(bitc::METADATA_IMPORTED_ENTITY, Record, Abbrev); |
| Record.clear(); |
| } |
| |
| unsigned ModuleBitcodeWriter::createNamedMetadataAbbrev() { |
| auto Abbv = std::make_shared<BitCodeAbbrev>(); |
| Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_NAME)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); |
| return Stream.EmitAbbrev(std::move(Abbv)); |
| } |
| |
| void ModuleBitcodeWriter::writeNamedMetadata( |
| SmallVectorImpl<uint64_t> &Record) { |
| if (M.named_metadata_empty()) |
| return; |
| |
| unsigned Abbrev = createNamedMetadataAbbrev(); |
| for (const NamedMDNode &NMD : M.named_metadata()) { |
| // Write name. |
| StringRef Str = NMD.getName(); |
| Record.append(Str.bytes_begin(), Str.bytes_end()); |
| Stream.EmitRecord(bitc::METADATA_NAME, Record, Abbrev); |
| Record.clear(); |
| |
| // Write named metadata operands. |
| for (const MDNode *N : NMD.operands()) |
| Record.push_back(VE.getMetadataID(N)); |
| Stream.EmitRecord(bitc::METADATA_NAMED_NODE, Record, 0); |
| Record.clear(); |
| } |
| } |
| |
| unsigned ModuleBitcodeWriter::createMetadataStringsAbbrev() { |
| auto Abbv = std::make_shared<BitCodeAbbrev>(); |
| Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_STRINGS)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of strings |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // offset to chars |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); |
| return Stream.EmitAbbrev(std::move(Abbv)); |
| } |
| |
| /// Write out a record for MDString. |
| /// |
| /// All the metadata strings in a metadata block are emitted in a single |
| /// record. The sizes and strings themselves are shoved into a blob. |
| void ModuleBitcodeWriter::writeMetadataStrings( |
| ArrayRef<const Metadata *> Strings, SmallVectorImpl<uint64_t> &Record) { |
| if (Strings.empty()) |
| return; |
| |
| // Start the record with the number of strings. |
| Record.push_back(bitc::METADATA_STRINGS); |
| Record.push_back(Strings.size()); |
| |
| // Emit the sizes of the strings in the blob. |
| SmallString<256> Blob; |
| { |
| BitstreamWriter W(Blob); |
| for (const Metadata *MD : Strings) |
| W.EmitVBR(cast<MDString>(MD)->getLength(), 6); |
| W.FlushToWord(); |
| } |
| |
| // Add the offset to the strings to the record. |
| Record.push_back(Blob.size()); |
| |
| // Add the strings to the blob. |
| for (const Metadata *MD : Strings) |
| Blob.append(cast<MDString>(MD)->getString()); |
| |
| // Emit the final record. |
| Stream.EmitRecordWithBlob(createMetadataStringsAbbrev(), Record, Blob); |
| Record.clear(); |
| } |
| |
| // Generates an enum to use as an index in the Abbrev array of Metadata record. |
| enum MetadataAbbrev : unsigned { |
| #define HANDLE_MDNODE_LEAF(CLASS) CLASS##AbbrevID, |
| #include "llvm/IR/Metadata.def" |
| LastPlusOne |
| }; |
| |
| void ModuleBitcodeWriter::writeMetadataRecords( |
| ArrayRef<const Metadata *> MDs, SmallVectorImpl<uint64_t> &Record, |
| std::vector<unsigned> *MDAbbrevs, std::vector<uint64_t> *IndexPos) { |
| if (MDs.empty()) |
| return; |
| |
| // Initialize MDNode abbreviations. |
| #define HANDLE_MDNODE_LEAF(CLASS) unsigned CLASS##Abbrev = 0; |
| #include "llvm/IR/Metadata.def" |
| |
| for (const Metadata *MD : MDs) { |
| if (IndexPos) |
| IndexPos->push_back(Stream.GetCurrentBitNo()); |
| if (const MDNode *N = dyn_cast<MDNode>(MD)) { |
| assert(N->isResolved() && "Expected forward references to be resolved"); |
| |
| switch (N->getMetadataID()) { |
| default: |
| llvm_unreachable("Invalid MDNode subclass"); |
| #define HANDLE_MDNODE_LEAF(CLASS) \ |
| case Metadata::CLASS##Kind: \ |
| if (MDAbbrevs) \ |
| write##CLASS(cast<CLASS>(N), Record, \ |
| (*MDAbbrevs)[MetadataAbbrev::CLASS##AbbrevID]); \ |
| else \ |
| write##CLASS(cast<CLASS>(N), Record, CLASS##Abbrev); \ |
| continue; |
| #include "llvm/IR/Metadata.def" |
| } |
| } |
| writeValueAsMetadata(cast<ValueAsMetadata>(MD), Record); |
| } |
| } |
| |
| void ModuleBitcodeWriter::writeModuleMetadata() { |
| if (!VE.hasMDs() && M.named_metadata_empty()) |
| return; |
| |
| Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 4); |
| SmallVector<uint64_t, 64> Record; |
| |
| // Emit all abbrevs upfront, so that the reader can jump in the middle of the |
| // block and load any metadata. |
| std::vector<unsigned> MDAbbrevs; |
| |
| MDAbbrevs.resize(MetadataAbbrev::LastPlusOne); |
| MDAbbrevs[MetadataAbbrev::DILocationAbbrevID] = createDILocationAbbrev(); |
| MDAbbrevs[MetadataAbbrev::GenericDINodeAbbrevID] = |
| createGenericDINodeAbbrev(); |
| |
| auto Abbv = std::make_shared<BitCodeAbbrev>(); |
| Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_INDEX_OFFSET)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); |
| unsigned OffsetAbbrev = Stream.EmitAbbrev(std::move(Abbv)); |
| |
| Abbv = std::make_shared<BitCodeAbbrev>(); |
| Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_INDEX)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); |
| unsigned IndexAbbrev = Stream.EmitAbbrev(std::move(Abbv)); |
| |
| // Emit MDStrings together upfront. |
| writeMetadataStrings(VE.getMDStrings(), Record); |
| |
| // We only emit an index for the metadata record if we have more than a given |
| // (naive) threshold of metadatas, otherwise it is not worth it. |
| if (VE.getNonMDStrings().size() > IndexThreshold) { |
| // Write a placeholder value in for the offset of the metadata index, |
| // which is written after the records, so that it can include |
| // the offset of each entry. The placeholder offset will be |
| // updated after all records are emitted. |
| uint64_t Vals[] = {0, 0}; |
| Stream.EmitRecord(bitc::METADATA_INDEX_OFFSET, Vals, OffsetAbbrev); |
| } |
| |
| // Compute and save the bit offset to the current position, which will be |
| // patched when we emit the index later. We can simply subtract the 64-bit |
| // fixed size from the current bit number to get the location to backpatch. |
| uint64_t IndexOffsetRecordBitPos = Stream.GetCurrentBitNo(); |
| |
| // This index will contain the bitpos for each individual record. |
| std::vector<uint64_t> IndexPos; |
| IndexPos.reserve(VE.getNonMDStrings().size()); |
| |
| // Write all the records |
| writeMetadataRecords(VE.getNonMDStrings(), Record, &MDAbbrevs, &IndexPos); |
| |
| if (VE.getNonMDStrings().size() > IndexThreshold) { |
| // Now that we have emitted all the records we will emit the index. But |
| // first |
| // backpatch the forward reference so that the reader can skip the records |
| // efficiently. |
| Stream.BackpatchWord64(IndexOffsetRecordBitPos - 64, |
| Stream.GetCurrentBitNo() - IndexOffsetRecordBitPos); |
| |
| // Delta encode the index. |
| uint64_t PreviousValue = IndexOffsetRecordBitPos; |
| for (auto &Elt : IndexPos) { |
| auto EltDelta = Elt - PreviousValue; |
| PreviousValue = Elt; |
| Elt = EltDelta; |
| } |
| // Emit the index record. |
| Stream.EmitRecord(bitc::METADATA_INDEX, IndexPos, IndexAbbrev); |
| IndexPos.clear(); |
| } |
| |
| // Write the named metadata now. |
| writeNamedMetadata(Record); |
| |
| auto AddDeclAttachedMetadata = [&](const GlobalObject &GO) { |
| SmallVector<uint64_t, 4> Record; |
| Record.push_back(VE.getValueID(&GO)); |
| pushGlobalMetadataAttachment(Record, GO); |
| Stream.EmitRecord(bitc::METADATA_GLOBAL_DECL_ATTACHMENT, Record); |
| }; |
| for (const Function &F : M) |
| if (F.isDeclaration() && F.hasMetadata()) |
| AddDeclAttachedMetadata(F); |
| // FIXME: Only store metadata for declarations here, and move data for global |
| // variable definitions to a separate block (PR28134). |
| for (const GlobalVariable &GV : M.globals()) |
| if (GV.hasMetadata()) |
| AddDeclAttachedMetadata(GV); |
| |
| Stream.ExitBlock(); |
| } |
| |
| void ModuleBitcodeWriter::writeFunctionMetadata(const Function &F) { |
| if (!VE.hasMDs()) |
| return; |
| |
| Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3); |
| SmallVector<uint64_t, 64> Record; |
| writeMetadataStrings(VE.getMDStrings(), Record); |
| writeMetadataRecords(VE.getNonMDStrings(), Record); |
| Stream.ExitBlock(); |
| } |
| |
| void ModuleBitcodeWriter::pushGlobalMetadataAttachment( |
| SmallVectorImpl<uint64_t> &Record, const GlobalObject &GO) { |
| // [n x [id, mdnode]] |
| SmallVector<std::pair<unsigned, MDNode *>, 4> MDs; |
| GO.getAllMetadata(MDs); |
| for (const auto &I : MDs) { |
| Record.push_back(I.first); |
| Record.push_back(VE.getMetadataID(I.second)); |
| } |
| } |
| |
| void ModuleBitcodeWriter::writeFunctionMetadataAttachment(const Function &F) { |
| Stream.EnterSubblock(bitc::METADATA_ATTACHMENT_ID, 3); |
| |
| SmallVector<uint64_t, 64> Record; |
| |
| if (F.hasMetadata()) { |
| pushGlobalMetadataAttachment(Record, F); |
| Stream.EmitRecord(bitc::METADATA_ATTACHMENT, Record, 0); |
| Record.clear(); |
| } |
| |
| // Write metadata attachments |
| // METADATA_ATTACHMENT - [m x [value, [n x [id, mdnode]]] |
| SmallVector<std::pair<unsigned, MDNode *>, 4> MDs; |
| for (const BasicBlock &BB : F) |
| for (const Instruction &I : BB) { |
| MDs.clear(); |
| I.getAllMetadataOtherThanDebugLoc(MDs); |
| |
| // If no metadata, ignore instruction. |
| if (MDs.empty()) continue; |
| |
| Record.push_back(VE.getInstructionID(&I)); |
| |
| for (unsigned i = 0, e = MDs.size(); i != e; ++i) { |
| Record.push_back(MDs[i].first); |
| Record.push_back(VE.getMetadataID(MDs[i].second)); |
| } |
| Stream.EmitRecord(bitc::METADATA_ATTACHMENT, Record, 0); |
| Record.clear(); |
| } |
| |
| Stream.ExitBlock(); |
| } |
| |
| void ModuleBitcodeWriter::writeModuleMetadataKinds() { |
| SmallVector<uint64_t, 64> Record; |
| |
| // Write metadata kinds |
| // METADATA_KIND - [n x [id, name]] |
| SmallVector<StringRef, 8> Names; |
| M.getMDKindNames(Names); |
| |
| if (Names.empty()) return; |
| |
| Stream.EnterSubblock(bitc::METADATA_KIND_BLOCK_ID, 3); |
| |
| for (unsigned MDKindID = 0, e = Names.size(); MDKindID != e; ++MDKindID) { |
| Record.push_back(MDKindID); |
| StringRef KName = Names[MDKindID]; |
| Record.append(KName.begin(), KName.end()); |
| |
| Stream.EmitRecord(bitc::METADATA_KIND, Record, 0); |
| Record.clear(); |
| } |
| |
| Stream.ExitBlock(); |
| } |
| |
| void ModuleBitcodeWriter::writeOperandBundleTags() { |
| // Write metadata kinds |
| // |
| // OPERAND_BUNDLE_TAGS_BLOCK_ID : N x OPERAND_BUNDLE_TAG |
| // |
| // OPERAND_BUNDLE_TAG - [strchr x N] |
| |
| SmallVector<StringRef, 8> Tags; |
| M.getOperandBundleTags(Tags); |
| |
| if (Tags.empty()) |
| return; |
| |
| Stream.EnterSubblock(bitc::OPERAND_BUNDLE_TAGS_BLOCK_ID, 3); |
| |
| SmallVector<uint64_t, 64> Record; |
| |
| for (auto Tag : Tags) { |
| Record.append(Tag.begin(), Tag.end()); |
| |
| Stream.EmitRecord(bitc::OPERAND_BUNDLE_TAG, Record, 0); |
| Record.clear(); |
| } |
| |
| Stream.ExitBlock(); |
| } |
| |
| void ModuleBitcodeWriter::writeSyncScopeNames() { |
| SmallVector<StringRef, 8> SSNs; |
| M.getContext().getSyncScopeNames(SSNs); |
| if (SSNs.empty()) |
| return; |
| |
| Stream.EnterSubblock(bitc::SYNC_SCOPE_NAMES_BLOCK_ID, 2); |
| |
| SmallVector<uint64_t, 64> Record; |
| for (auto SSN : SSNs) { |
| Record.append(SSN.begin(), SSN.end()); |
| Stream.EmitRecord(bitc::SYNC_SCOPE_NAME, Record, 0); |
| Record.clear(); |
| } |
| |
| Stream.ExitBlock(); |
| } |
| |
| void ModuleBitcodeWriter::writeConstants(unsigned FirstVal, unsigned LastVal, |
| bool isGlobal) { |
| if (FirstVal == LastVal) return; |
| |
| Stream.EnterSubblock(bitc::CONSTANTS_BLOCK_ID, 4); |
| |
| unsigned AggregateAbbrev = 0; |
| unsigned String8Abbrev = 0; |
| unsigned CString7Abbrev = 0; |
| unsigned CString6Abbrev = 0; |
| // If this is a constant pool for the module, emit module-specific abbrevs. |
| if (isGlobal) { |
| // Abbrev for CST_CODE_AGGREGATE. |
| auto Abbv = std::make_shared<BitCodeAbbrev>(); |
| Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_AGGREGATE)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, Log2_32_Ceil(LastVal+1))); |
| AggregateAbbrev = Stream.EmitAbbrev(std::move(Abbv)); |
| |
| // Abbrev for CST_CODE_STRING. |
| Abbv = std::make_shared<BitCodeAbbrev>(); |
| Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_STRING)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); |
| String8Abbrev = Stream.EmitAbbrev(std::move(Abbv)); |
| // Abbrev for CST_CODE_CSTRING. |
| Abbv = std::make_shared<BitCodeAbbrev>(); |
| Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CSTRING)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7)); |
| CString7Abbrev = Stream.EmitAbbrev(std::move(Abbv)); |
| // Abbrev for CST_CODE_CSTRING. |
| Abbv = std::make_shared<BitCodeAbbrev>(); |
| Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CSTRING)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); |
| Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6)); |
| CString6Abbrev = Stream.EmitAbbrev(std::move(Abbv)); |
| } |
| |
| SmallVector<uint64_t, 64> Record; |
| |
| const ValueEnumerator::ValueList &Vals = VE.getValues(); |
| Type *LastTy = nullptr; |
| for (unsigned i = FirstVal; i != LastVal; ++i) { |
| const Value *V = Vals[i].first; |
| // If we need to switch types, do so now. |
| if (V->getType() != LastTy) { |
| LastTy = V->getType(); |
| Record.push_back(VE.getTypeID(LastTy)); |
| Stream.EmitRecord(bitc::CST_CODE_SETTYPE, Record, |
| CONSTANTS_SETTYPE_ABBREV); |
| Record.clear(); |
| } |
| |
| if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) { |
| Record.push_back( |
| unsigned(IA->hasSideEffects()) | unsigned(IA->isAlignStack()) << 1 | |
| unsigned(IA->getDialect() & 1) << 2 | unsigned(IA->canThrow()) << 3); |
| |
| // Add the asm string. |
| const std::string &AsmStr = IA->getAsmString(); |
| Record.push_back(AsmStr.size()); |
| Record.append(AsmStr.begin(), AsmStr.end()); |
| |
| // Add the constraint string. |
| const std::string &ConstraintStr = IA->getConstraintString(); |
| Record.push_back(ConstraintStr.size()); |
| Record.append(ConstraintStr.begin(), ConstraintStr.end()); |
| Stream.EmitRecord(bitc::CST_CODE_INLINEASM, Record); |
| Record.clear(); |
| continue; |
| } |
| const Constant *C = cast<Constant>(V); |
| unsigned Code = -1U; |
| unsigned AbbrevToUse = 0; |
| if (C->isNullValue()) { |
| Code = bitc::CST_CODE_NULL; |
| } else if (isa<PoisonValue>(C)) { |
| Code = bitc::CST_CODE_POISON; |
| } else if (isa<UndefValue>(C)) { |
| Code = bitc::CST_CODE_UNDEF; |
| } else if (const ConstantInt *IV = dyn_cast<ConstantInt>(C)) { |
| if (IV->getBitWidth() <= 64) { |
| uint64_t V = IV->getSExtValue(); |
| emitSignedInt64(Record, V); |
| Code = bitc::CST_CODE_INTEGER; |
| AbbrevToUse = CONSTANTS_INTEGER_ABBREV; |
| } else { // Wide integers, > 64 bits in size. |
| emitWideAPInt(Record, IV->getValue()); |
| Code = bitc::CST_CODE_WIDE_INTEGER; |
| } |
| } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C)) { |
| Code = bitc::CST_CODE_FLOAT; |
| Type *Ty = CFP->getType(); |
| if (Ty->isHalfTy() || Ty->isBFloatTy() || Ty->isFloatTy() || |
| Ty->isDoubleTy()) { |
| Record.push_back(CFP->getValueAPF().bitcastToAPInt().getZExtValue()); |
| } else if (Ty->isX86_FP80Ty()) { |
| // api needed to prevent premature destruction |
| // bits are not in the same order as a normal i80 APInt, compensate. |
| APInt api = CFP->getValueAPF().bitcastToAPInt(); |
| const uint64_t *p = api.getRawData(); |
| Record.push_back((p[1] << 48) | (p[0] >> 16)); |
| Record.push_back(p[0] & 0xffffLL); |
| } else if (Ty->isFP128Ty() || Ty->isPPC_FP128Ty()) { |
| APInt api = CFP->getValueAPF().bitcastToAPInt(); |
| const uint64_t *p = api.getRawData(); |
| Record.push_back(p[0]); |
| Record.push_back(p[1]); |
| } else { |
| assert(0 && "Unknown FP type!"); |
| } |
| } else if (isa<ConstantDataSequential>(C) && |
| cast<ConstantDataSequential>(C)->isString()) { |
| const ConstantDataSequential *Str = cast<ConstantDataSequential>(C); |
| // Emit constant strings specially. |
| unsigned NumElts = Str->getNumElements(); |
| // If this is a null-terminated string, use the denser CSTRING encoding. |
| if (Str->isCString()) { |
| Code = bitc::CST_CODE_CSTRING; |
| --NumElts; // Don't encode the null, which isn't allowed by char6. |
| } else { |
| Code = bitc::CST_CODE_STRING; |
| |