Diff 36467

llvm/trunk/include/llvm/Bitcode/BitcodeWriterPass.h

	Show All 23 Lines
	class PreservedAnalyses;			class PreservedAnalyses;

	/// \brief Create and return a pass that writes the module to the specified			/// \brief Create and return a pass that writes the module to the specified
	/// ostream. Note that this pass is designed for use with the legacy pass			/// ostream. Note that this pass is designed for use with the legacy pass
	/// manager.			/// manager.
	///			///
	/// If \c ShouldPreserveUseListOrder, encode use-list order so it can be			/// If \c ShouldPreserveUseListOrder, encode use-list order so it can be
	/// reproduced when deserialized.			/// reproduced when deserialized.
				///
				/// If \c EmitFunctionSummary, emit the function summary index (currently
				/// for use in ThinLTO optimization).
	ModulePass *createBitcodeWriterPass(raw_ostream &Str,			ModulePass *createBitcodeWriterPass(raw_ostream &Str,
	bool ShouldPreserveUseListOrder = false);			bool ShouldPreserveUseListOrder = false,
				bool EmitFunctionSummary = false);

	/// \brief Pass for writing a module of IR out to a bitcode file.			/// \brief Pass for writing a module of IR out to a bitcode file.
	///			///
	/// Note that this is intended for use with the new pass manager. To construct			/// Note that this is intended for use with the new pass manager. To construct
	/// a pass for the legacy pass manager, use the function above.			/// a pass for the legacy pass manager, use the function above.
	class BitcodeWriterPass {			class BitcodeWriterPass {
	raw_ostream &OS;			raw_ostream &OS;
	bool ShouldPreserveUseListOrder;			bool ShouldPreserveUseListOrder;
				bool EmitFunctionSummary;

	public:			public:
	/// \brief Construct a bitcode writer pass around a particular output stream.			/// \brief Construct a bitcode writer pass around a particular output stream.
	///			///
	/// If \c ShouldPreserveUseListOrder, encode use-list order so it can be			/// If \c ShouldPreserveUseListOrder, encode use-list order so it can be
	/// reproduced when deserialized.			/// reproduced when deserialized.
				///
				/// If \c EmitFunctionSummary, emit the function summary index (currently
				/// for use in ThinLTO optimization).
	explicit BitcodeWriterPass(raw_ostream &OS,			explicit BitcodeWriterPass(raw_ostream &OS,
	bool ShouldPreserveUseListOrder = false)			bool ShouldPreserveUseListOrder = false,
	: OS(OS), ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {}			bool EmitFunctionSummary = false)
				: OS(OS), ShouldPreserveUseListOrder(ShouldPreserveUseListOrder),
				EmitFunctionSummary(EmitFunctionSummary) {}

	/// \brief Run the bitcode writer pass, and output the module to the selected			/// \brief Run the bitcode writer pass, and output the module to the selected
	/// output stream.			/// output stream.
	PreservedAnalyses run(Module &M);			PreservedAnalyses run(Module &M);

	static StringRef name() { return "BitcodeWriterPass"; }			static StringRef name() { return "BitcodeWriterPass"; }
	};			};

	}			}

	#endif			#endif

llvm/trunk/include/llvm/Bitcode/BitstreamWriter.h

Show First 20 Lines • Show All 89 Lines • ▼ Show 20 Lines	public:
~BitstreamWriter() {		~BitstreamWriter() {
assert(CurBit == 0 && "Unflushed data remaining");		assert(CurBit == 0 && "Unflushed data remaining");
assert(BlockScope.empty() && CurAbbrevs.empty() && "Block imbalance");		assert(BlockScope.empty() && CurAbbrevs.empty() && "Block imbalance");
}		}

/// \brief Retrieve the current position in the stream, in bits.		/// \brief Retrieve the current position in the stream, in bits.
uint64_t GetCurrentBitNo() const { return GetBufferOffset() * 8 + CurBit; }		uint64_t GetCurrentBitNo() const { return GetBufferOffset() * 8 + CurBit; }

		/// \brief Retrieve the number of bits currently used to encode an abbrev ID.
		unsigned GetAbbrevIDWidth() const { return CurCodeSize; }

//===--------------------------------------------------------------------===//		//===--------------------------------------------------------------------===//
// Basic Primitives for emitting bits to the stream.		// Basic Primitives for emitting bits to the stream.
//===--------------------------------------------------------------------===//		//===--------------------------------------------------------------------===//

/// Backpatch a 32-bit word in the output at the given bit offset		/// Backpatch a 32-bit word in the output at the given bit offset
/// with the specified value.		/// with the specified value.
void BackpatchWord(uint64_t BitNo, unsigned NewWord) {		void BackpatchWord(uint64_t BitNo, unsigned NewWord) {
using namespace llvm::support;		using namespace llvm::support;
▲ Show 20 Lines • Show All 442 Lines • Show Last 20 Lines

llvm/trunk/include/llvm/Bitcode/LLVMBitCodes.h

Show First 20 Lines • Show All 144 Lines • ▼ Show 20 Lines	enum TypeSymtabCodes {
TST_CODE_ENTRY = 1 // TST_ENTRY: [typeid, namechar x N]		TST_CODE_ENTRY = 1 // TST_ENTRY: [typeid, namechar x N]
};		};

// Value symbol table codes.		// Value symbol table codes.
enum ValueSymtabCodes {		enum ValueSymtabCodes {
VST_CODE_ENTRY = 1, // VST_ENTRY: [valueid, namechar x N]		VST_CODE_ENTRY = 1, // VST_ENTRY: [valueid, namechar x N]
VST_CODE_BBENTRY = 2, // VST_BBENTRY: [bbid, namechar x N]		VST_CODE_BBENTRY = 2, // VST_BBENTRY: [bbid, namechar x N]
VST_CODE_FNENTRY = 3, // VST_FNENTRY: [valueid, offset, namechar x N]		VST_CODE_FNENTRY = 3, // VST_FNENTRY: [valueid, offset, namechar x N]
		// VST_COMBINED_FNENTRY: [offset, namechar x N]
		VST_CODE_COMBINED_FNENTRY = 4
		};

		// The module path symbol table only has one code (MST_CODE_ENTRY).
		enum ModulePathSymtabCodes {
		MST_CODE_ENTRY = 1, // MST_ENTRY: [modid, namechar x N]
		};

		// The function summary section uses different codes in the per-module
		// and combined index cases.
		enum FunctionSummarySymtabCodes {
		FS_CODE_PERMODULE_ENTRY = 1, // FS_ENTRY: [valueid, islocal, instcount]
		FS_CODE_COMBINED_ENTRY = 2, // FS_ENTRY: [modid, instcount]
};		};

enum MetadataCodes {		enum MetadataCodes {
METADATA_STRING = 1, // MDSTRING: [values]		METADATA_STRING = 1, // MDSTRING: [values]
METADATA_VALUE = 2, // VALUE: [type num, value num]		METADATA_VALUE = 2, // VALUE: [type num, value num]
METADATA_NODE = 3, // NODE: [n x md num]		METADATA_NODE = 3, // NODE: [n x md num]
METADATA_NAME = 4, // STRING: [values]		METADATA_NAME = 4, // STRING: [values]
METADATA_DISTINCT_NODE = 5, // DISTINCT_NODE: [n x md num]		METADATA_DISTINCT_NODE = 5, // DISTINCT_NODE: [n x md num]
▲ Show 20 Lines • Show All 292 Lines • Show Last 20 Lines

llvm/trunk/include/llvm/Bitcode/ReaderWriter.h

Show All 9 Lines
// This header defines interfaces to read and write LLVM bitcode files/streams.		// This header defines interfaces to read and write LLVM bitcode files/streams.
//		//
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

#ifndef LLVM_BITCODE_READERWRITER_H		#ifndef LLVM_BITCODE_READERWRITER_H
#define LLVM_BITCODE_READERWRITER_H		#define LLVM_BITCODE_READERWRITER_H

#include "llvm/IR/DiagnosticInfo.h"		#include "llvm/IR/DiagnosticInfo.h"
		#include "llvm/IR/FunctionInfo.h"
#include "llvm/Support/Endian.h"		#include "llvm/Support/Endian.h"
#include "llvm/Support/ErrorOr.h"		#include "llvm/Support/ErrorOr.h"
#include "llvm/Support/MemoryBuffer.h"		#include "llvm/Support/MemoryBuffer.h"
#include <memory>		#include <memory>
#include <string>		#include <string>

namespace llvm {		namespace llvm {
class BitstreamWriter;		class BitstreamWriter;
Show All 27 Lines	namespace llvm {
getBitcodeTargetTriple(MemoryBufferRef Buffer, LLVMContext &Context,		getBitcodeTargetTriple(MemoryBufferRef Buffer, LLVMContext &Context,
DiagnosticHandlerFunction DiagnosticHandler = nullptr);		DiagnosticHandlerFunction DiagnosticHandler = nullptr);

/// Read the specified bitcode file, returning the module.		/// Read the specified bitcode file, returning the module.
ErrorOr<std::unique_ptr<Module>>		ErrorOr<std::unique_ptr<Module>>
parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context,		parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context,
DiagnosticHandlerFunction DiagnosticHandler = nullptr);		DiagnosticHandlerFunction DiagnosticHandler = nullptr);

		/// Check if the given bitcode buffer contains a function summary block.
		bool hasFunctionSummary(MemoryBufferRef Buffer, LLVMContext &Context,
		DiagnosticHandlerFunction DiagnosticHandler);

		/// Parse the specified bitcode buffer, returning the function info index.
		/// If IsLazy is true, parse the entire function summary into
		/// the index. Otherwise skip the function summary section, and only create
		/// an index object with a map from function name to function summary offset.
		/// The index is used to perform lazy function summary reading later.
		ErrorOr<std::unique_ptr<FunctionInfoIndex>> getFunctionInfoIndex(
		MemoryBufferRef Buffer, LLVMContext &Context,
		DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy = false);

		/// This method supports lazy reading of function summary data from the
		/// combined index during function importing. When reading the combined index
		/// file, getFunctionInfoIndex is first invoked with IsLazy=true.
		/// Then this method is called for each function considered for importing,
		/// to parse the summary information for the given function name into
		/// the index.
		std::error_code readFunctionSummary(
		MemoryBufferRef Buffer, LLVMContext &Context,
		DiagnosticHandlerFunction DiagnosticHandler, StringRef FunctionName,
		std::unique_ptr<FunctionInfoIndex> Index);

/// \brief Write the specified module to the specified raw output stream.		/// \brief Write the specified module to the specified raw output stream.
///		///
/// For streams where it matters, the given stream should be in "binary"		/// For streams where it matters, the given stream should be in "binary"
/// mode.		/// mode.
///		///
/// If \c ShouldPreserveUseListOrder, encode the use-list order for each \a		/// If \c ShouldPreserveUseListOrder, encode the use-list order for each \a
/// Value in \c M. These will be reconstructed exactly when \a M is		/// Value in \c M. These will be reconstructed exactly when \a M is
/// deserialized.		/// deserialized.
		///
		/// If \c EmitFunctionSummary, emit the function summary index (currently
		/// for use in ThinLTO optimization).
void WriteBitcodeToFile(const Module *M, raw_ostream &Out,		void WriteBitcodeToFile(const Module *M, raw_ostream &Out,
bool ShouldPreserveUseListOrder = false);		bool ShouldPreserveUseListOrder = false,
		bool EmitFunctionSummary = false);

		/// Write the specified function summary index to the given raw output stream,
		/// where it will be written in a new bitcode block. This is used when
		/// writing the combined index file for ThinLTO.
		void WriteFunctionSummaryToFile(const FunctionInfoIndex *Index,
		raw_ostream &Out);

/// isBitcodeWrapper - Return true if the given bytes are the magic bytes		/// isBitcodeWrapper - Return true if the given bytes are the magic bytes
/// for an LLVM IR bitcode wrapper.		/// for an LLVM IR bitcode wrapper.
///		///
inline bool isBitcodeWrapper(const unsigned char *BufPtr,		inline bool isBitcodeWrapper(const unsigned char *BufPtr,
const unsigned char *BufEnd) {		const unsigned char *BufEnd) {
// See if you can find the hidden message in the magic bytes :-).		// See if you can find the hidden message in the magic bytes :-).
// (Hint: it's a little-endian encoding.)		// (Hint: it's a little-endian encoding.)
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

llvm/trunk/include/llvm/IR/FunctionInfo.h

				//===-- llvm/FunctionInfo.h - Function Info Index ---------------- C++ --===//
				//
				// The LLVM Compiler Infrastructure
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//
				//
				/// @file
				/// FunctionInfo.h This file contains the declarations the classes that hold
				/// the function info index and summary.
				//
				//===----------------------------------------------------------------------===//

				#ifndef LLVM_IR_FUNCTIONINFO_H
				#define LLVM_IR_FUNCTIONINFO_H

				#include "llvm/ADT/SmallString.h"
				#include "llvm/ADT/StringMap.h"
				#include "llvm/IR/Module.h"
				#include "llvm/Support/MemoryBuffer.h"
				#include "llvm/Support/raw_ostream.h"

				namespace llvm {

				/// \brief Function summary information to aid decisions and implementation of
				/// importing.
				///
				/// This is a separate class from FunctionInfo to enable lazy reading of this
				/// function summary information from the combined index file during imporing.
				class FunctionSummary {
				private:
				/// \brief Path of module containing function IR, used to locate module when
				/// importing this function.
				///
				/// This is only used during parsing of the combined function index, or when
				/// parsing the per-module index for creation of the combined function index,
				/// not during writing of the per-module index which doesn't contain a
				/// module path string table.
				StringRef ModulePath;

				/// \brief Used to flag functions that have local linkage types and need to
				/// have module identifier appended before placing into the combined
				/// index, to disambiguate from other functions with the same name.
				///
				/// This is only used in the per-module function index, as it is consumed
				/// while creating the combined index.
				bool IsLocalFunction;

				// The rest of the information is used to help decide whether importing
				// is likely to be profitable.
				// Other information will be added as the importing is tuned, such
				// as hotness (when profile available), and other function characteristics.

				/// Number of instructions (ignoring debug instructions, e.g.) computed
				/// during the initial compile step when the function index is first built.
				echristoUnsubmitted Not Done Reply Inline Actions Comment nit: "during the initial compile step" seems weird and not wholly accurate. Relatedly: would a transform be expected to keep it up to date? Is it recomputed on every write? (Seems reasonable, but costly). echristo: Comment nit: "during the initial compile step" seems weird and not wholly accurate. Relatedly…
				unsigned InstCount;

				public:
				/// Construct a summary object from summary data expected for all
				/// summary records.
				echristoUnsubmitted Not Done Reply Inline Actions This comment seems a bit confusing. Could you elaborate more? echristo: This comment seems a bit confusing. Could you elaborate more?
				FunctionSummary(unsigned NumInsts) : InstCount(NumInsts) {}

				/// Set the path to the module containing this function, for use in
				/// the combined index.
				void setModulePath(StringRef ModPath) { ModulePath = ModPath; }

				/// Get the path to the module containing this function.
				StringRef modulePath() const { return ModulePath; }

				/// Record whether this is a local function in the per-module index.
				void setLocalFunction(bool IsLocal) { IsLocalFunction = IsLocal; }

				/// Check whether this was a local function, for use in creating
				/// the combined index.
				bool isLocalFunction() const { return IsLocalFunction; }

				/// Get the instruction count recorded for this function.
				unsigned instCount() const { return InstCount; }
				};

				/// \brief Class to hold pointer to function summary and information required
				/// for parsing it.
				///
				/// For the per-module index, this holds the bitcode offset
				/// of the corresponding function block. For the combined index,
				/// after parsing of the \a ValueSymbolTable, this initially
				/// holds the offset of the corresponding function summary bitcode
				/// record. After parsing the associated summary information from the summary
				/// block the \a FunctionSummary is populated and stored here.
				class FunctionInfo {
				private:
				/// Function summary information used to help make ThinLTO importing
				/// decisions.
				std::unique_ptr<FunctionSummary> Summary;

				/// \brief The bitcode offset corresponding to either the associated
				/// function's function body record, or its function summary record,
				/// depending on whether this is a per-module or combined index.
				///
				/// This bitcode offset is written to or read from the associated
				/// \a ValueSymbolTable entry for the function.
				/// For the per-module index this holds the bitcode offset of the
				/// function's body record within bitcode module block in its module,
				/// which is used during lazy function parsing or ThinLTO importing.
				/// For the combined index this holds the offset of the corresponding
				/// function summary record, to enable associating the combined index
				/// VST records with the summary records.
				uint64_t BitcodeIndex;

				public:
				/// Constructor used during parsing of VST entries.
				FunctionInfo(uint64_t FuncOffset)
				: Summary(nullptr), BitcodeIndex(FuncOffset) {}

				/// Constructor used for per-module index bitcode writing.
				FunctionInfo(uint64_t FuncOffset,
				std::unique_ptr<FunctionSummary> FuncSummary)
				: Summary(std::move(FuncSummary)), BitcodeIndex(FuncOffset) {}

				/// Record the function summary information parsed out of the function
				/// summary block during parsing or combined index creation.
				void setFunctionSummary(std::unique_ptr<FunctionSummary> FuncSummary) {
				Summary = std::move(FuncSummary);
				}

				/// Get the function summary recorded for this function.
				FunctionSummary *functionSummary() const { return Summary.get(); }

				/// Get the bitcode index recorded for this function, depending on
				/// the index type.
				uint64_t bitcodeIndex() const { return BitcodeIndex; }

				/// Record the bitcode index for this function, depending on
				/// the index type.
				void setBitcodeIndex(uint64_t FuncOffset) { BitcodeIndex = FuncOffset; }
				};

				/// List of function info structures for a particular function name held
				/// in the FunctionMap. Requires a vector in the case of multiple
				/// COMDAT functions of the same name.
				typedef std::vector<std::unique_ptr<FunctionInfo>> FunctionInfoList;

				/// Map from function name to corresponding function info structures.
				typedef StringMap<FunctionInfoList> FunctionInfoMapTy;

				/// Type used for iterating through the function info map.
				typedef FunctionInfoMapTy::const_iterator const_funcinfo_iterator;
				typedef FunctionInfoMapTy::iterator funcinfo_iterator;

				/// String table to hold/own module path strings, which additionally holds the
				/// module ID assigned to each module during the plugin step. The StringMap
				/// makes a copy of and owns inserted strings.
				typedef StringMap<uint64_t> ModulePathStringTableTy;

				/// Class to hold module path string table and function map,
				/// and encapsulate methods for operating on them.
				class FunctionInfoIndex {
				private:
				/// Map from function name to list of function information instances
				/// for functions of that name (may be duplicates in the COMDAT case, e.g.).
				FunctionInfoMapTy FunctionMap;

				/// Holds strings for combined index, mapping to the corresponding module ID.
				ModulePathStringTableTy ModulePathStringTable;

				public:
				FunctionInfoIndex() = default;
				~FunctionInfoIndex() = default;

				// Disable the copy constructor and assignment operators, so
				// no unexpected copying/moving occurs.
				FunctionInfoIndex(const FunctionInfoIndex &) = delete;
				void operator=(const FunctionInfoIndex &) = delete;

				funcinfo_iterator begin() { return FunctionMap.begin(); }
				const_funcinfo_iterator begin() const { return FunctionMap.begin(); }
				funcinfo_iterator end() { return FunctionMap.end(); }
				const_funcinfo_iterator end() const { return FunctionMap.end(); }

				/// Get the list of function info objects for a given function.
				const FunctionInfoList &getFunctionInfoList(StringRef FuncName) {
				return FunctionMap[FuncName];
				}

				/// Add a function info for a function of the given name.
				void addFunctionInfo(StringRef FuncName, std::unique_ptr<FunctionInfo> Info) {
				FunctionMap[FuncName].push_back(std::move(Info));
				}

				/// Iterator to allow writer to walk through table during emission.
				iterator_range<StringMap<uint64_t>::const_iterator> modPathStringEntries()
				const {
				return llvm::make_range(ModulePathStringTable.begin(),
				ModulePathStringTable.end());
				}

				/// Get the module ID recorded for the given module path.
				uint64_t getModuleId(const StringRef ModPath) const {
				return ModulePathStringTable.lookup(ModPath);
				}

				/// Add the given per-module index into this function index/summary,
				/// assigning it the given module ID. Each module merged in should have
				/// a unique ID, necessary for consistent renaming of promoted
				/// static (local) variables.
				void mergeFrom(std::unique_ptr<FunctionInfoIndex> Other,
				uint64_t NextModuleId);

				/// Convenience method for creating a promoted global name
				/// for the given value name of a local, and its original module's ID.
				static std::string getGlobalNameForLocal(StringRef Name, uint64_t ModId) {
				SmallString<256> NewName(Name);
				NewName += ".llvm.";
				raw_svector_ostream(NewName) << ModId;
				return NewName.str();
				}

				/// Add a new module path, mapped to the given module Id, and return StringRef
				/// owned by string table map.
				StringRef addModulePath(StringRef ModPath, uint64_t ModId) {
				return ModulePathStringTable.insert(std::make_pair(ModPath, ModId))
				.first->first();
				}
				};

				} // End llvm namespace

				#endif

llvm/trunk/include/llvm/Object/Binary.h

Show All 37 Lines	protected:

Binary(unsigned int Type, MemoryBufferRef Source);		Binary(unsigned int Type, MemoryBufferRef Source);

enum {		enum {
ID_Archive,		ID_Archive,
ID_MachOUniversalBinary,		ID_MachOUniversalBinary,
ID_COFFImportFile,		ID_COFFImportFile,
ID_IR, // LLVM IR		ID_IR, // LLVM IR
		ID_FunctionIndex, // Function summary index

// Object and children.		// Object and children.
ID_StartObjects,		ID_StartObjects,
ID_COFF,		ID_COFF,

ID_ELF32L, // ELF 32-bit, little endian		ID_ELF32L, // ELF 32-bit, little endian
ID_ELF32B, // ELF 32-bit, big endian		ID_ELF32B, // ELF 32-bit, big endian
ID_ELF64L, // ELF 64-bit, little endian		ID_ELF64L, // ELF 64-bit, little endian
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines	public:
bool isCOFFImportFile() const {		bool isCOFFImportFile() const {
return TypeID == ID_COFFImportFile;		return TypeID == ID_COFFImportFile;
}		}

bool isIR() const {		bool isIR() const {
return TypeID == ID_IR;		return TypeID == ID_IR;
}		}

		bool isFunctionIndex() const {
		return TypeID == ID_FunctionIndex;
		}

bool isLittleEndian() const {		bool isLittleEndian() const {
return !(TypeID == ID_ELF32B \|\| TypeID == ID_ELF64B \|\|		return !(TypeID == ID_ELF32B \|\| TypeID == ID_ELF64B \|\|
TypeID == ID_MachO32B \|\| TypeID == ID_MachO64B);		TypeID == ID_MachO32B \|\| TypeID == ID_MachO64B);
}		}
};		};

/// @brief Create a Binary from Source, autodetecting the file type.		/// @brief Create a Binary from Source, autodetecting the file type.
///		///
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

llvm/trunk/include/llvm/Object/FunctionIndexObjectFile.h

				//===- FunctionIndexObjectFile.h - Function index file implementation -----===//
				//
				// The LLVM Compiler Infrastructure
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//
				//
				// This file declares the FunctionIndexObjectFile template class.
				//
				//===----------------------------------------------------------------------===//

				#ifndef LLVM_OBJECT_FUNCTIONINDEXOBJECTFILE_H
				#define LLVM_OBJECT_FUNCTIONINDEXOBJECTFILE_H

				#include "llvm/Object/SymbolicFile.h"

				namespace llvm {
				class FunctionInfoIndex;

				namespace object {
				class ObjectFile;

				/// This class is used to read just the function summary index related
				/// sections out of the given object (which may contain a single module's
				/// bitcode or be a combined index bitcode file). It builds a FunctionInfoIndex
				/// object.
				class FunctionIndexObjectFile : public SymbolicFile {
				std::unique_ptr<FunctionInfoIndex> Index;

				public:
				FunctionIndexObjectFile(MemoryBufferRef Object,
				std::unique_ptr<FunctionInfoIndex> I);
				~FunctionIndexObjectFile() override;

				// TODO: Walk through FunctionMap entries for function symbols.
				// However, currently these interfaces are not used by any consumers.
				void moveSymbolNext(DataRefImpl &Symb) const override {
				llvm_unreachable("not implemented");
				}
				std::error_code printSymbolName(raw_ostream &OS,
				DataRefImpl Symb) const override {
				llvm_unreachable("not implemented");
				return std::error_code();
				}
				uint32_t getSymbolFlags(DataRefImpl Symb) const override {
				llvm_unreachable("not implemented");
				return 0;
				}
				basic_symbol_iterator symbol_begin_impl() const override {
				llvm_unreachable("not implemented");
				return basic_symbol_iterator(BasicSymbolRef());
				}
				basic_symbol_iterator symbol_end_impl() const override {
				llvm_unreachable("not implemented");
				return basic_symbol_iterator(BasicSymbolRef());
				}

				const FunctionInfoIndex &getIndex() const {
				return const_cast<FunctionIndexObjectFile *>(this)->getIndex();
				}
				FunctionInfoIndex &getIndex() { return *Index; }
				std::unique_ptr<FunctionInfoIndex> takeIndex();

				static inline bool classof(const Binary *v) { return v->isFunctionIndex(); }

				/// \brief Finds and returns bitcode embedded in the given object file, or an
				/// error code if not found.
				static ErrorOr<MemoryBufferRef> findBitcodeInObject(const ObjectFile &Obj);

				/// \brief Finds and returns bitcode in the given memory buffer (which may
				/// be either a bitcode file or a native object file with embedded bitcode),
				/// or an error code if not found.
				static ErrorOr<MemoryBufferRef> findBitcodeInMemBuffer(
				MemoryBufferRef Object);

				/// \brief Looks for function summary in the given memory buffer,
				/// returns true if found, else false.
				static bool hasFunctionSummaryInMemBuffer(MemoryBufferRef Object,
				LLVMContext &Context);

				/// \brief Parse function index in the given memory buffer.
				/// Return new FunctionIndexObjectFile instance containing parsed function
				/// summary/index.
				static ErrorOr<std::unique_ptr<FunctionIndexObjectFile>> create(
				MemoryBufferRef Object, LLVMContext &Context, bool IsLazy = false);

				/// \brief Parse the function summary information for function with the
				/// given name out of the given buffer. Parsed information is
				/// stored on the index object saved in this object.
				std::error_code findFunctionSummaryInMemBuffer(MemoryBufferRef Object,
				LLVMContext &Context,
				StringRef FunctionName);
				};
				}
				}

				#endif

llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp

Show All 21 Lines
#include "llvm/IR/DiagnosticPrinter.h"		#include "llvm/IR/DiagnosticPrinter.h"
#include "llvm/IR/GVMaterializer.h"		#include "llvm/IR/GVMaterializer.h"
#include "llvm/IR/InlineAsm.h"		#include "llvm/IR/InlineAsm.h"
#include "llvm/IR/IntrinsicInst.h"		#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/LLVMContext.h"		#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"		#include "llvm/IR/Module.h"
#include "llvm/IR/OperandTraits.h"		#include "llvm/IR/OperandTraits.h"
#include "llvm/IR/Operator.h"		#include "llvm/IR/Operator.h"
		#include "llvm/IR/FunctionInfo.h"
#include "llvm/IR/ValueHandle.h"		#include "llvm/IR/ValueHandle.h"
#include "llvm/Support/DataStream.h"		#include "llvm/Support/DataStream.h"
#include "llvm/Support/ManagedStatic.h"		#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/MathExtras.h"		#include "llvm/Support/MathExtras.h"
#include "llvm/Support/MemoryBuffer.h"		#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/raw_ostream.h"		#include "llvm/Support/raw_ostream.h"
#include <deque>		#include <deque>
using namespace llvm;		using namespace llvm;
▲ Show 20 Lines • Show All 352 Lines • ▼ Show 20 Lines	private:
std::error_code parseUseLists();		std::error_code parseUseLists();
std::error_code initStream(std::unique_ptr<DataStreamer> Streamer);		std::error_code initStream(std::unique_ptr<DataStreamer> Streamer);
std::error_code initStreamFromBuffer();		std::error_code initStreamFromBuffer();
std::error_code initLazyStream(std::unique_ptr<DataStreamer> Streamer);		std::error_code initLazyStream(std::unique_ptr<DataStreamer> Streamer);
std::error_code findFunctionInStream(		std::error_code findFunctionInStream(
Function *F,		Function *F,
DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator);		DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator);
};		};

		/// Class to manage reading and parsing function summary index bitcode
		/// files/sections.
		class FunctionIndexBitcodeReader {
		LLVMContext &Context;
		DiagnosticHandlerFunction DiagnosticHandler;

		/// Eventually points to the function index built during parsing.
		FunctionInfoIndex *TheIndex = nullptr;

		std::unique_ptr<MemoryBuffer> Buffer;
		std::unique_ptr<BitstreamReader> StreamFile;
		BitstreamCursor Stream;

		/// \brief Used to indicate whether we are doing lazy parsing of summary data.
		///
		/// If false, the summary section is fully parsed into the index during
		/// the initial parse. Otherwise, if true, the caller is expected to
		/// invoke \a readFunctionSummary for each summary needed, and the summary
		/// section is thus parsed lazily.
		bool IsLazy = false;

		/// Used to indicate whether caller only wants to check for the presence
		/// of the function summary bitcode section. All blocks are skipped,
		/// but the SeenFuncSummary boolean is set.
		bool CheckFuncSummaryPresenceOnly = false;

		/// Indicates whether we have encountered a function summary section
		/// yet during parsing, used when checking if file contains function
		/// summary section.
		bool SeenFuncSummary = false;

		/// \brief Map populated during function summary section parsing, and
		/// consumed during ValueSymbolTable parsing.
		///
		/// Used to correlate summary records with VST entries. For the per-module
		/// index this maps the ValueID to the parsed function summary, and
		/// for the combined index this maps the summary record's bitcode
		/// offset to the function summary (since in the combined index the
		/// VST records do not hold value IDs but rather hold the function
		/// summary record offset).
		DenseMap<uint64_t, std::unique_ptr<FunctionSummary>> SummaryMap;

		/// Map populated during module path string table parsing, from the
		/// module ID to a string reference owned by the index's module
		/// path string table, used to correlate with combined index function
		/// summary records.
		DenseMap<uint64_t, StringRef> ModuleIdMap;

		public:
		std::error_code error(BitcodeError E, const Twine &Message);
		std::error_code error(BitcodeError E);
		std::error_code error(const Twine &Message);

		FunctionIndexBitcodeReader(MemoryBuffer *Buffer, LLVMContext &Context,
		DiagnosticHandlerFunction DiagnosticHandler,
		bool IsLazy = false,
		bool CheckFuncSummaryPresenceOnly = false);
		FunctionIndexBitcodeReader(LLVMContext &Context,
		DiagnosticHandlerFunction DiagnosticHandler,
		bool IsLazy = false,
		bool CheckFuncSummaryPresenceOnly = false);
		~FunctionIndexBitcodeReader() { freeState(); }

		void freeState();

		void releaseBuffer();

		/// Check if the parser has encountered a function summary section.
		bool foundFuncSummary() { return SeenFuncSummary; }

		/// \brief Main interface to parsing a bitcode buffer.
		/// \returns true if an error occurred.
		std::error_code parseSummaryIndexInto(std::unique_ptr<DataStreamer> Streamer,
		FunctionInfoIndex *I);

		/// \brief Interface for parsing a function summary lazily.
		std::error_code parseFunctionSummary(std::unique_ptr<DataStreamer> Streamer,
		FunctionInfoIndex *I,
		size_t FunctionSummaryOffset);

		private:
		std::error_code parseModule();
		std::error_code parseValueSymbolTable();
		std::error_code parseEntireSummary();
		std::error_code parseModuleStringTable();
		std::error_code initStream(std::unique_ptr<DataStreamer> Streamer);
		std::error_code initStreamFromBuffer();
		std::error_code initLazyStream(std::unique_ptr<DataStreamer> Streamer);
		};
} // namespace		} // namespace

BitcodeDiagnosticInfo::BitcodeDiagnosticInfo(std::error_code EC,		BitcodeDiagnosticInfo::BitcodeDiagnosticInfo(std::error_code EC,
DiagnosticSeverity Severity,		DiagnosticSeverity Severity,
const Twine &Msg)		const Twine &Msg)
: DiagnosticInfo(DK_Bitcode, Severity), Msg(Msg), EC(EC) {}		: DiagnosticInfo(DK_Bitcode, Severity), Msg(Msg), EC(EC) {}

void BitcodeDiagnosticInfo::print(DiagnosticPrinter &DP) const { DP << Msg; }		void BitcodeDiagnosticInfo::print(DiagnosticPrinter &DP) const { DP << Msg; }
▲ Show 20 Lines • Show All 2,966 Lines • ▼ Show 20 Lines	case bitc::MODULE_CODE_VSTOFFSET:
return error("Invalid record");		return error("Invalid record");
VSTOffset = Record[0];		VSTOffset = Record[0];
break;		break;
}		}
Record.clear();		Record.clear();
}		}
}		}

		/// Helper to read the header common to all bitcode files.
		static bool hasValidBitcodeHeader(BitstreamCursor &Stream) {
		// Sniff for the signature.
		if (Stream.Read(8) != 'B' \|\|
		Stream.Read(8) != 'C' \|\|
		Stream.Read(4) != 0x0 \|\|
		Stream.Read(4) != 0xC \|\|
		Stream.Read(4) != 0xE \|\|
		Stream.Read(4) != 0xD)
		return false;
		return true;
		}

std::error_code		std::error_code
BitcodeReader::parseBitcodeInto(std::unique_ptr<DataStreamer> Streamer,		BitcodeReader::parseBitcodeInto(std::unique_ptr<DataStreamer> Streamer,
Module *M, bool ShouldLazyLoadMetadata) {		Module *M, bool ShouldLazyLoadMetadata) {
TheModule = M;		TheModule = M;

if (std::error_code EC = initStream(std::move(Streamer)))		if (std::error_code EC = initStream(std::move(Streamer)))
return EC;		return EC;

// Sniff for the signature.		// Sniff for the signature.
if (Stream.Read(8) != 'B' \|\|		if (!hasValidBitcodeHeader(Stream)) return error("Invalid bitcode signature");
Stream.Read(8) != 'C' \|\|
Stream.Read(4) != 0x0 \|\|
Stream.Read(4) != 0xC \|\|
Stream.Read(4) != 0xE \|\|
Stream.Read(4) != 0xD)
return error("Invalid bitcode signature");

// We expect a number of well-defined blocks, though we don't necessarily		// We expect a number of well-defined blocks, though we don't necessarily
// need to understand them all.		// need to understand them all.
while (1) {		while (1) {
if (Stream.AtEndOfStream()) {		if (Stream.AtEndOfStream()) {
// We didn't really read a proper Module.		// We didn't really read a proper Module.
return error("Malformed IR file");		return error("Malformed IR file");
}		}
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines	ErrorOr<std::string> BitcodeReader::parseModuleTriple() {
llvm_unreachable("Exit infinite loop");		llvm_unreachable("Exit infinite loop");
}		}

ErrorOr<std::string> BitcodeReader::parseTriple() {		ErrorOr<std::string> BitcodeReader::parseTriple() {
if (std::error_code EC = initStream(nullptr))		if (std::error_code EC = initStream(nullptr))
return EC;		return EC;

// Sniff for the signature.		// Sniff for the signature.
if (Stream.Read(8) != 'B' \|\|		if (!hasValidBitcodeHeader(Stream)) return error("Invalid bitcode signature");
Stream.Read(8) != 'C' \|\|
Stream.Read(4) != 0x0 \|\|
Stream.Read(4) != 0xC \|\|
Stream.Read(4) != 0xE \|\|
Stream.Read(4) != 0xD)
return error("Invalid bitcode signature");

// We expect a number of well-defined blocks, though we don't necessarily		// We expect a number of well-defined blocks, though we don't necessarily
// need to understand them all.		// need to understand them all.
while (1) {		while (1) {
BitstreamEntry Entry = Stream.advance();		BitstreamEntry Entry = Stream.advance();

switch (Entry.Kind) {		switch (Entry.Kind) {
case BitstreamEntry::Error:		case BitstreamEntry::Error:
▲ Show 20 Lines • Show All 1,578 Lines • ▼ Show 20 Lines	if (isBitcodeWrapper(buf, buf + 4)) {
const unsigned char *bitcodeEnd = buf + 16;		const unsigned char *bitcodeEnd = buf + 16;
SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false);		SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false);
Bytes.dropLeadingBytes(bitcodeStart - buf);		Bytes.dropLeadingBytes(bitcodeStart - buf);
Bytes.setKnownObjectSize(bitcodeEnd - bitcodeStart);		Bytes.setKnownObjectSize(bitcodeEnd - bitcodeStart);
}		}
return std::error_code();		return std::error_code();
}		}

		std::error_code FunctionIndexBitcodeReader::error(BitcodeError E,
		const Twine &Message) {
		return ::error(DiagnosticHandler, make_error_code(E), Message);
		}

		std::error_code FunctionIndexBitcodeReader::error(const Twine &Message) {
		return ::error(DiagnosticHandler,
		make_error_code(BitcodeError::CorruptedBitcode), Message);
		}

		std::error_code FunctionIndexBitcodeReader::error(BitcodeError E) {
		return ::error(DiagnosticHandler, make_error_code(E));
		}

		FunctionIndexBitcodeReader::FunctionIndexBitcodeReader(
		MemoryBuffer *Buffer, LLVMContext &Context,
		DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy,
		bool CheckFuncSummaryPresenceOnly)
		: Context(Context),
		DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)),
		Buffer(Buffer),
		IsLazy(IsLazy),
		CheckFuncSummaryPresenceOnly(CheckFuncSummaryPresenceOnly) {}

		FunctionIndexBitcodeReader::FunctionIndexBitcodeReader(
		LLVMContext &Context, DiagnosticHandlerFunction DiagnosticHandler,
		bool IsLazy, bool CheckFuncSummaryPresenceOnly)
		: Context(Context),
		DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)),
		Buffer(nullptr),
		IsLazy(IsLazy),
		CheckFuncSummaryPresenceOnly(CheckFuncSummaryPresenceOnly) {}

		void FunctionIndexBitcodeReader::freeState() { Buffer = nullptr; }

		void FunctionIndexBitcodeReader::releaseBuffer() { Buffer.release(); }

		// Specialized value symbol table parser used when reading function index
		// blocks where we don't actually create global values.
		// At the end of this routine the function index is populated with a map
		// from function name to FunctionInfo. The function info contains
		// the function block's bitcode offset as well as the offset into the
		// function summary section.
		std::error_code FunctionIndexBitcodeReader::parseValueSymbolTable() {
		if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
		return error("Invalid record");

		SmallVector<uint64_t, 64> Record;

		// Read all the records for this value table.
		SmallString<128> ValueName;
		while (1) {
		BitstreamEntry Entry = Stream.advanceSkippingSubblocks();

		switch (Entry.Kind) {
		case BitstreamEntry::SubBlock: // Handled for us already.
		case BitstreamEntry::Error:
		return error("Malformed block");
		case BitstreamEntry::EndBlock:
		return std::error_code();
		case BitstreamEntry::Record:
		// The interesting case.
		break;
		}

		// Read a record.
		Record.clear();
		switch (Stream.readRecord(Entry.ID, Record)) {
		default: // Default behavior: ignore (e.g. VST_CODE_BBENTRY records).
		break;
		case bitc::VST_CODE_FNENTRY: {
		// VST_FNENTRY: [valueid, offset, namechar x N]
		if (convertToString(Record, 2, ValueName))
		return error("Invalid record");
		unsigned ValueID = Record[0];
		uint64_t FuncOffset = Record[1];
		std::unique_ptr<FunctionInfo> FuncInfo =
		llvm::make_unique<FunctionInfo>(FuncOffset);
		if (foundFuncSummary() && !IsLazy) {
		DenseMap<uint64_t, std::unique_ptr<FunctionSummary>>::iterator SMI =
		SummaryMap.find(ValueID);
		assert(SMI != SummaryMap.end() && "Summary info not found");
		FuncInfo->setFunctionSummary(std::move(SMI->second));
		}
		TheIndex->addFunctionInfo(ValueName, std::move(FuncInfo));

		ValueName.clear();
		break;
		}
		case bitc::VST_CODE_COMBINED_FNENTRY: {
		// VST_FNENTRY: [offset, namechar x N]
		if (convertToString(Record, 1, ValueName))
		return error("Invalid record");
		uint64_t FuncSummaryOffset = Record[0];
		std::unique_ptr<FunctionInfo> FuncInfo =
		llvm::make_unique<FunctionInfo>(FuncSummaryOffset);
		if (foundFuncSummary() && !IsLazy) {
		DenseMap<uint64_t, std::unique_ptr<FunctionSummary>>::iterator SMI =
		SummaryMap.find(FuncSummaryOffset);
		assert(SMI != SummaryMap.end() && "Summary info not found");
		FuncInfo->setFunctionSummary(std::move(SMI->second));
		}
		TheIndex->addFunctionInfo(ValueName, std::move(FuncInfo));

		ValueName.clear();
		break;
		}
		}
		}
		}

		// Parse just the blocks needed for function index building out of the module.
		// At the end of this routine the function Index is populated with a map
		// from function name to FunctionInfo. The function info contains
		// either the parsed function summary information (when parsing summaries
		// eagerly), or just to the function summary record's offset
		// if parsing lazily (IsLazy).
		std::error_code FunctionIndexBitcodeReader::parseModule() {
		if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
		return error("Invalid record");

		// Read the function index for this module.
		while (1) {
		BitstreamEntry Entry = Stream.advance();

		switch (Entry.Kind) {
		case BitstreamEntry::Error:
		return error("Malformed block");
		case BitstreamEntry::EndBlock:
		return std::error_code();

		case BitstreamEntry::SubBlock:
		if (CheckFuncSummaryPresenceOnly) {
		if (Entry.ID == bitc::FUNCTION_SUMMARY_BLOCK_ID)
		SeenFuncSummary = true;
		if (Stream.SkipBlock()) return error("Invalid record");
		// No need to parse the rest since we found the summary.
		return std::error_code();
		}
		switch (Entry.ID) {
		default: // Skip unknown content.
		if (Stream.SkipBlock()) return error("Invalid record");
		break;
		case bitc::BLOCKINFO_BLOCK_ID:
		// Need to parse these to get abbrev ids (e.g. for VST)
		if (Stream.ReadBlockInfoBlock()) return error("Malformed block");
		break;
		case bitc::VALUE_SYMTAB_BLOCK_ID:
		if (std::error_code EC = parseValueSymbolTable()) return EC;
		break;
		case bitc::FUNCTION_SUMMARY_BLOCK_ID:
		SeenFuncSummary = true;
		if (IsLazy) {
		// Lazy parsing of summary info, skip it.
		if (Stream.SkipBlock()) return error("Invalid record");
		} else if (std::error_code EC = parseEntireSummary())
		return EC;
		break;
		case bitc::MODULE_STRTAB_BLOCK_ID:
		if (std::error_code EC = parseModuleStringTable()) return EC;
		break;
		}
		continue;

		case BitstreamEntry::Record:
		Stream.skipRecord(Entry.ID);
		continue;
		}
		}
		}

		// Eagerly parse the entire function summary block (i.e. for all functions
		// in the index). This populates the FunctionSummary objects in
		// the index.
		std::error_code FunctionIndexBitcodeReader::parseEntireSummary() {
		if (Stream.EnterSubBlock(bitc::FUNCTION_SUMMARY_BLOCK_ID))
		return error("Invalid record");

		SmallVector<uint64_t, 64> Record;

		while (1) {
		BitstreamEntry Entry = Stream.advanceSkippingSubblocks();

		switch (Entry.Kind) {
		case BitstreamEntry::SubBlock: // Handled for us already.
		case BitstreamEntry::Error:
		return error("Malformed block");
		case BitstreamEntry::EndBlock:
		return std::error_code();
		case BitstreamEntry::Record:
		// The interesting case.
		break;
		}

		// Read a record. The record format depends on whether this
		// is a per-module index or a combined index file. In the per-module
		// case the records contain the associated value's ID for correlation
		// with VST entries. In the combined index the correlation is done
		// via the bitcode offset of the summary records (which were saved
		// in the combined index VST entries). The records also contain
		// information used for ThinLTO renaming and importing.
		Record.clear();
		uint64_t CurRecordBit = Stream.GetCurrentBitNo();
		switch (Stream.readRecord(Entry.ID, Record)) {
		default: // Default behavior: ignore.
		break;
		// FS_PERMODULE_ENTRY: [valueid, islocal, instcount]
		case bitc::FS_CODE_PERMODULE_ENTRY: {
		unsigned ValueID = Record[0];
		bool IsLocal = Record[1];
		unsigned InstCount = Record[2];
		std::unique_ptr<FunctionSummary> FS =
		llvm::make_unique<FunctionSummary>(InstCount);
		FS->setLocalFunction(IsLocal);
		// The module path string ref set in the summary must be owned by the
		// index's module string table. Since we don't have a module path
		// string table section in the per-module index, we create a single
		// module path string table entry with an empty (0) ID to take
		// ownership.
		FS->setModulePath(
		TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0));
		SummaryMap[ValueID] = std::move(FS);
		}
		// FS_COMBINED_ENTRY: [modid, instcount]
		case bitc::FS_CODE_COMBINED_ENTRY: {
		uint64_t ModuleId = Record[0];
		unsigned InstCount = Record[1];
		std::unique_ptr<FunctionSummary> FS =
		llvm::make_unique<FunctionSummary>(InstCount);
		FS->setModulePath(ModuleIdMap[ModuleId]);
		SummaryMap[CurRecordBit] = std::move(FS);
		}
		}
		}
		llvm_unreachable("Exit infinite loop");
		}

		// Parse the module string table block into the Index.
		// This populates the ModulePathStringTable map in the index.
		std::error_code FunctionIndexBitcodeReader::parseModuleStringTable() {
		if (Stream.EnterSubBlock(bitc::MODULE_STRTAB_BLOCK_ID))
		return error("Invalid record");

		SmallVector<uint64_t, 64> Record;

		SmallString<128> ModulePath;
		while (1) {
		BitstreamEntry Entry = Stream.advanceSkippingSubblocks();

		switch (Entry.Kind) {
		case BitstreamEntry::SubBlock: // Handled for us already.
		case BitstreamEntry::Error:
		return error("Malformed block");
		case BitstreamEntry::EndBlock:
		return std::error_code();
		case BitstreamEntry::Record:
		// The interesting case.
		break;
		}

		Record.clear();
		switch (Stream.readRecord(Entry.ID, Record)) {
		default: // Default behavior: ignore.
		break;
		case bitc::MST_CODE_ENTRY: {
		// MST_ENTRY: [modid, namechar x N]
		if (convertToString(Record, 1, ModulePath))
		return error("Invalid record");
		uint64_t ModuleId = Record[0];
		StringRef ModulePathInMap =
		TheIndex->addModulePath(ModulePath, ModuleId);
		ModuleIdMap[ModuleId] = ModulePathInMap;
		ModulePath.clear();
		break;
		}
		}
		}
		llvm_unreachable("Exit infinite loop");
		}

		// Parse the function info index from the bitcode streamer into the given index.
		std::error_code FunctionIndexBitcodeReader::parseSummaryIndexInto(
		std::unique_ptr<DataStreamer> Streamer, FunctionInfoIndex *I) {
		TheIndex = I;

		if (std::error_code EC = initStream(std::move(Streamer))) return EC;

		// Sniff for the signature.
		if (!hasValidBitcodeHeader(Stream)) return error("Invalid bitcode signature");

		// We expect a number of well-defined blocks, though we don't necessarily
		// need to understand them all.
		while (1) {
		if (Stream.AtEndOfStream()) {
		// We didn't really read a proper Module block.
		return error("Malformed block");
		}

		BitstreamEntry Entry =
		Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs);

		if (Entry.Kind != BitstreamEntry::SubBlock) return error("Malformed block");

		// If we see a MODULE_BLOCK, parse it to find the blocks needed for
		// building the function summary index.
		if (Entry.ID == bitc::MODULE_BLOCK_ID) return parseModule();

		if (Stream.SkipBlock()) return error("Invalid record");
		}
		}

		// Parse the function information at the given offset in the buffer into
		// the index. Used to support lazy parsing of function summaries from the
		// combined index during importing.
		// TODO: This function is not yet complete as it won't have a consumer
		// until ThinLTO function importing is added.
		std::error_code FunctionIndexBitcodeReader::parseFunctionSummary(
		std::unique_ptr<DataStreamer> Streamer, FunctionInfoIndex *I,
		size_t FunctionSummaryOffset) {
		TheIndex = I;

		if (std::error_code EC = initStream(std::move(Streamer))) return EC;

		// Sniff for the signature.
		if (!hasValidBitcodeHeader(Stream)) return error("Invalid bitcode signature");

		Stream.JumpToBit(FunctionSummaryOffset);

		BitstreamEntry Entry = Stream.advanceSkippingSubblocks();

		switch (Entry.Kind) {
		default:
		return error("Malformed block");
		case BitstreamEntry::Record:
		// The expected case.
		break;
		}

		// TODO: Read a record. This interface will be completed when ThinLTO
		// importing is added so that it can be tested.
		SmallVector<uint64_t, 64> Record;
		switch (Stream.readRecord(Entry.ID, Record)) {
		default:
		return error("Invalid record");
		}

		return std::error_code();
		}

		std::error_code FunctionIndexBitcodeReader::initStream(
		std::unique_ptr<DataStreamer> Streamer) {
		if (Streamer) return initLazyStream(std::move(Streamer));
		return initStreamFromBuffer();
		}

		std::error_code FunctionIndexBitcodeReader::initStreamFromBuffer() {
		const unsigned char BufPtr = (const unsigned char )Buffer->getBufferStart();
		const unsigned char *BufEnd = BufPtr + Buffer->getBufferSize();

		if (Buffer->getBufferSize() & 3) return error("Invalid bitcode signature");

		// If we have a wrapper header, parse it and ignore the non-bc file contents.
		// The magic number is 0x0B17C0DE stored in little endian.
		if (isBitcodeWrapper(BufPtr, BufEnd))
		if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true))
		return error("Invalid bitcode wrapper header");

		StreamFile.reset(new BitstreamReader(BufPtr, BufEnd));
		Stream.init(&*StreamFile);

		return std::error_code();
		}

		std::error_code FunctionIndexBitcodeReader::initLazyStream(
		std::unique_ptr<DataStreamer> Streamer) {
		// Check and strip off the bitcode wrapper; BitstreamReader expects never to
		// see it.
		auto OwnedBytes =
		llvm::make_unique<StreamingMemoryObject>(std::move(Streamer));
		StreamingMemoryObject &Bytes = *OwnedBytes;
		StreamFile = llvm::make_unique<BitstreamReader>(std::move(OwnedBytes));
		Stream.init(&*StreamFile);

		unsigned char buf[16];
		if (Bytes.readBytes(buf, 16, 0) != 16)
		return error("Invalid bitcode signature");

		if (!isBitcode(buf, buf + 16)) return error("Invalid bitcode signature");

		if (isBitcodeWrapper(buf, buf + 4)) {
		const unsigned char *bitcodeStart = buf;
		const unsigned char *bitcodeEnd = buf + 16;
		SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false);
		Bytes.dropLeadingBytes(bitcodeStart - buf);
		Bytes.setKnownObjectSize(bitcodeEnd - bitcodeStart);
		}
		return std::error_code();
		}

namespace {		namespace {
class BitcodeErrorCategoryType : public std::error_category {		class BitcodeErrorCategoryType : public std::error_category {
const char *name() const LLVM_NOEXCEPT override {		const char *name() const LLVM_NOEXCEPT override {
return "llvm.bitcode";		return "llvm.bitcode";
}		}
std::string message(int IE) const override {		std::string message(int IE) const override {
BitcodeError E = static_cast<BitcodeError>(IE);		BitcodeError E = static_cast<BitcodeError>(IE);
switch (E) {		switch (E) {
▲ Show 20 Lines • Show All 105 Lines • ▼ Show 20 Lines	llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer, LLVMContext &Context,
std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);		std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
auto R = llvm::make_unique<BitcodeReader>(Buf.release(), Context,		auto R = llvm::make_unique<BitcodeReader>(Buf.release(), Context,
DiagnosticHandler);		DiagnosticHandler);
ErrorOr<std::string> Triple = R->parseTriple();		ErrorOr<std::string> Triple = R->parseTriple();
if (Triple.getError())		if (Triple.getError())
return "";		return "";
return Triple.get();		return Triple.get();
}		}

		// Parse the specified bitcode buffer, returning the function info index.
		// If IsLazy is false, parse the entire function summary into
		// the index. Otherwise skip the function summary section, and only create
		// an index object with a map from function name to function summary offset.
		// The index is used to perform lazy function summary reading later.
		ErrorOr<std::unique_ptr<FunctionInfoIndex>> llvm::getFunctionInfoIndex(
		MemoryBufferRef Buffer, LLVMContext &Context,
		DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy) {
		std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
		FunctionIndexBitcodeReader R(Buf.get(), Context, DiagnosticHandler, IsLazy);

		std::unique_ptr<FunctionInfoIndex> Index =
		llvm::make_unique<FunctionInfoIndex>();

		auto cleanupOnError = [&](std::error_code EC) {
		R.releaseBuffer(); // Never take ownership on error.
		return EC;
		};

		if (std::error_code EC = R.parseSummaryIndexInto(nullptr, Index.get()))
		return cleanupOnError(EC);

		Buf.release(); // The FunctionIndexBitcodeReader owns it now.
		return std::move(Index);
		}

		// Check if the given bitcode buffer contains a function summary block.
		bool llvm::hasFunctionSummary(MemoryBufferRef Buffer, LLVMContext &Context,
		DiagnosticHandlerFunction DiagnosticHandler) {
		std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
		FunctionIndexBitcodeReader R(Buf.get(), Context, DiagnosticHandler, false,
		true);

		auto cleanupOnError = [&](std::error_code EC) {
		R.releaseBuffer(); // Never take ownership on error.
		return false;
		};

		if (std::error_code EC = R.parseSummaryIndexInto(nullptr, nullptr))
		return cleanupOnError(EC);

		Buf.release(); // The FunctionIndexBitcodeReader owns it now.
		return R.foundFuncSummary();
		}

		// This method supports lazy reading of function summary data from the combined
		// index during ThinLTO function importing. When reading the combined index
		// file, getFunctionInfoIndex is first invoked with IsLazy=true.
		// Then this method is called for each function considered for importing,
		// to parse the summary information for the given function name into
		// the index.
		std::error_code llvm::readFunctionSummary(
		MemoryBufferRef Buffer, LLVMContext &Context,
		DiagnosticHandlerFunction DiagnosticHandler, StringRef FunctionName,
		std::unique_ptr<FunctionInfoIndex> Index) {
		std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
		FunctionIndexBitcodeReader R(Buf.get(), Context, DiagnosticHandler);

		auto cleanupOnError = [&](std::error_code EC) {
		R.releaseBuffer(); // Never take ownership on error.
		return EC;
		};

		// Lookup the given function name in the FunctionMap, which may
		// contain a list of function infos in the case of a COMDAT. Walk through
		// and parse each function summary info at the function summary offset
		// recorded when parsing the value symbol table.
		for (const auto &FI : Index->getFunctionInfoList(FunctionName)) {
		size_t FunctionSummaryOffset = FI->bitcodeIndex();
		if (std::error_code EC =
		R.parseFunctionSummary(nullptr, Index.get(), FunctionSummaryOffset))
		return cleanupOnError(EC);
		}

		Buf.release(); // The FunctionIndexBitcodeReader owns it now.
		return std::error_code();
		}

llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp

//===--- Bitcode/Writer/BitcodeWriter.cpp - Bitcode Writer ----------------===//		//===--- Bitcode/Writer/BitcodeWriter.cpp - Bitcode Writer ----------------===//
//		//
// The LLVM Compiler Infrastructure		// The LLVM Compiler Infrastructure
//		//
// This file is distributed under the University of Illinois Open Source		// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.		// License. See LICENSE.TXT for details.
//		//
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
//		//
// Bitcode writer implementation.		// Bitcode writer implementation.
//		//
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

#include "llvm/Bitcode/ReaderWriter.h"		#include "llvm/Bitcode/ReaderWriter.h"
#include "ValueEnumerator.h"		#include "ValueEnumerator.h"
		#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Triple.h"		#include "llvm/ADT/Triple.h"
#include "llvm/Bitcode/BitstreamWriter.h"		#include "llvm/Bitcode/BitstreamWriter.h"
#include "llvm/Bitcode/LLVMBitCodes.h"		#include "llvm/Bitcode/LLVMBitCodes.h"
#include "llvm/IR/CallSite.h"		#include "llvm/IR/CallSite.h"
#include "llvm/IR/Constants.h"		#include "llvm/IR/Constants.h"
#include "llvm/IR/DebugInfoMetadata.h"		#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/DerivedTypes.h"		#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/InlineAsm.h"		#include "llvm/IR/InlineAsm.h"
#include "llvm/IR/Instructions.h"		#include "llvm/IR/Instructions.h"
#include "llvm/IR/LLVMContext.h"		#include "llvm/IR/LLVMContext.h"
		#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/Module.h"		#include "llvm/IR/Module.h"
#include "llvm/IR/Operator.h"		#include "llvm/IR/Operator.h"
#include "llvm/IR/UseListOrder.h"		#include "llvm/IR/UseListOrder.h"
#include "llvm/IR/ValueSymbolTable.h"		#include "llvm/IR/ValueSymbolTable.h"
#include "llvm/Support/CommandLine.h"		#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ErrorHandling.h"		#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/MathExtras.h"		#include "llvm/Support/MathExtras.h"
#include "llvm/Support/Program.h"		#include "llvm/Support/Program.h"
▲ Show 20 Lines • Show All 2,148 Lines • ▼ Show 20 Lines
/// Emit names for globals/functions etc. The VSTOffsetPlaceholder,		/// Emit names for globals/functions etc. The VSTOffsetPlaceholder,
/// BitcodeStartBit and FunctionIndex are only passed for the module-level		/// BitcodeStartBit and FunctionIndex are only passed for the module-level
/// VST, where we are including a function bitcode index and need to		/// VST, where we are including a function bitcode index and need to
/// backpatch the VST forward declaration record.		/// backpatch the VST forward declaration record.
static void WriteValueSymbolTable(		static void WriteValueSymbolTable(
const ValueSymbolTable &VST, const ValueEnumerator &VE,		const ValueSymbolTable &VST, const ValueEnumerator &VE,
BitstreamWriter &Stream, uint64_t VSTOffsetPlaceholder = 0,		BitstreamWriter &Stream, uint64_t VSTOffsetPlaceholder = 0,
uint64_t BitcodeStartBit = 0,		uint64_t BitcodeStartBit = 0,
DenseMap<const Function , uint64_t> FunctionIndex = nullptr) {		DenseMap<const Function , std::unique_ptr<FunctionInfo>> FunctionIndex =
		nullptr) {
if (VST.empty()) {		if (VST.empty()) {
// WriteValueSymbolTableForwardDecl should have returned early as		// WriteValueSymbolTableForwardDecl should have returned early as
// well. Ensure this handling remains in sync by asserting that		// well. Ensure this handling remains in sync by asserting that
// the placeholder offset is not set.		// the placeholder offset is not set.
assert(VSTOffsetPlaceholder == 0);		assert(VSTOffsetPlaceholder == 0);
return;		return;
}		}

▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines	if (isa<BasicBlock>(Name.getValue())) {
// have a VSTOffsetPlaceholder. The function-level VST should not		// have a VSTOffsetPlaceholder. The function-level VST should not
// contain any Function symbols.		// contain any Function symbols.
assert(FunctionIndex);		assert(FunctionIndex);
assert(VSTOffsetPlaceholder > 0);		assert(VSTOffsetPlaceholder > 0);

// Save the word offset of the function (from the start of the		// Save the word offset of the function (from the start of the
// actual bitcode written to the stream).		// actual bitcode written to the stream).
assert(FunctionIndex->count(F) == 1);		assert(FunctionIndex->count(F) == 1);
uint64_t BitcodeIndex = (*FunctionIndex)[F] - BitcodeStartBit;		uint64_t BitcodeIndex =
		(*FunctionIndex)[F]->bitcodeIndex() - BitcodeStartBit;
assert((BitcodeIndex & 31) == 0 && "function block not 32-bit aligned");		assert((BitcodeIndex & 31) == 0 && "function block not 32-bit aligned");
NameVals.push_back(BitcodeIndex / 32);		NameVals.push_back(BitcodeIndex / 32);

Code = bitc::VST_CODE_FNENTRY;		Code = bitc::VST_CODE_FNENTRY;
AbbrevToUse = FnEntry8BitAbbrev;		AbbrevToUse = FnEntry8BitAbbrev;
if (Bits == SE_Char6)		if (Bits == SE_Char6)
AbbrevToUse = FnEntry6BitAbbrev;		AbbrevToUse = FnEntry6BitAbbrev;
else if (Bits == SE_Fixed7)		else if (Bits == SE_Fixed7)
AbbrevToUse = FnEntry7BitAbbrev;		AbbrevToUse = FnEntry7BitAbbrev;
} else {		} else {
Code = bitc::VST_CODE_ENTRY;		Code = bitc::VST_CODE_ENTRY;
if (Bits == SE_Char6)		if (Bits == SE_Char6)
AbbrevToUse = VST_ENTRY_6_ABBREV;		AbbrevToUse = VST_ENTRY_6_ABBREV;
else if (Bits == SE_Fixed7)		else if (Bits == SE_Fixed7)
AbbrevToUse = VST_ENTRY_7_ABBREV;		AbbrevToUse = VST_ENTRY_7_ABBREV;
}		}

for (const char *P = Name.getKeyData(),		for (const auto P : Name.getKey()) NameVals.push_back((unsigned char)P);
*E = Name.getKeyData()+Name.getKeyLength(); P != E; ++P)
NameVals.push_back((unsigned char)*P);

// Emit the finished record.		// Emit the finished record.
Stream.EmitRecord(Code, NameVals, AbbrevToUse);		Stream.EmitRecord(Code, NameVals, AbbrevToUse);
NameVals.clear();		NameVals.clear();
}		}
Stream.ExitBlock();		Stream.ExitBlock();
}		}

		/// Emit function names and summary offsets for the combined index
		/// used by ThinLTO.
		static void WriteCombinedValueSymbolTable(const FunctionInfoIndex *Index,
		BitstreamWriter &Stream) {
		Stream.EnterSubblock(bitc::VALUE_SYMTAB_BLOCK_ID, 4);

		// 8-bit fixed-width VST_COMBINED_FNENTRY function strings.
		BitCodeAbbrev *Abbv = new BitCodeAbbrev();
		Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_COMBINED_FNENTRY));
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
		unsigned FnEntry8BitAbbrev = Stream.EmitAbbrev(Abbv);

		// 7-bit fixed width VST_COMBINED_FNENTRY function strings.
		Abbv = new BitCodeAbbrev();
		Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_COMBINED_FNENTRY));
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
		unsigned FnEntry7BitAbbrev = Stream.EmitAbbrev(Abbv);

		// 6-bit char6 VST_COMBINED_FNENTRY function strings.
		Abbv = new BitCodeAbbrev();
		Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_COMBINED_FNENTRY));
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
		unsigned FnEntry6BitAbbrev = Stream.EmitAbbrev(Abbv);

		// FIXME: We know if the type names can use 7-bit ascii.
		SmallVector<unsigned, 64> NameVals;

		for (const auto &FII : *Index) {
		for (const auto &FI : FII.getValue()) {
		NameVals.push_back(FI->bitcodeIndex());

		StringRef FuncName = FII.first();

		// Figure out the encoding to use for the name.
		StringEncoding Bits = getStringEncoding(FuncName.data(), FuncName.size());

		// VST_COMBINED_FNENTRY: [funcsumoffset, namechar x N]
		unsigned AbbrevToUse = FnEntry8BitAbbrev;
		if (Bits == SE_Char6)
		AbbrevToUse = FnEntry6BitAbbrev;
		else if (Bits == SE_Fixed7)
		AbbrevToUse = FnEntry7BitAbbrev;

		for (const auto P : FuncName) NameVals.push_back((unsigned char)P);

		// Emit the finished record.
		Stream.EmitRecord(bitc::VST_CODE_COMBINED_FNENTRY, NameVals, AbbrevToUse);
		NameVals.clear();
		}
		}
		Stream.ExitBlock();
		}

static void WriteUseList(ValueEnumerator &VE, UseListOrder &&Order,		static void WriteUseList(ValueEnumerator &VE, UseListOrder &&Order,
BitstreamWriter &Stream) {		BitstreamWriter &Stream) {
assert(Order.Shuffle.size() >= 2 && "Shuffle too small");		assert(Order.Shuffle.size() >= 2 && "Shuffle too small");
unsigned Code;		unsigned Code;
if (isa<BasicBlock>(Order.V))		if (isa<BasicBlock>(Order.V))
Code = bitc::USELIST_CODE_BB;		Code = bitc::USELIST_CODE_BB;
else		else
Code = bitc::USELIST_CODE_DEFAULT;		Code = bitc::USELIST_CODE_DEFAULT;
Show All 18 Lines	static void WriteUseListBlock(const Function *F, ValueEnumerator &VE,
Stream.EnterSubblock(bitc::USELIST_BLOCK_ID, 3);		Stream.EnterSubblock(bitc::USELIST_BLOCK_ID, 3);
while (hasMore()) {		while (hasMore()) {
WriteUseList(VE, std::move(VE.UseListOrders.back()), Stream);		WriteUseList(VE, std::move(VE.UseListOrders.back()), Stream);
VE.UseListOrders.pop_back();		VE.UseListOrders.pop_back();
}		}
Stream.ExitBlock();		Stream.ExitBlock();
}		}

/// WriteFunction - Emit a function body to the module stream.		/// \brief Save information for the given function into the function index.
static void WriteFunction(const Function &F, ValueEnumerator &VE,		///
BitstreamWriter &Stream,		/// At a minimum this saves the bitcode index of the function record that
DenseMap<const Function *, uint64_t> &FunctionIndex) {		/// was just written. However, if we are emitting function summary information,
		/// for example for ThinLTO, then a \a FunctionSummary object is created
		/// to hold the provided summary information.
		static void SaveFunctionInfo(
		const Function &F,
		DenseMap<const Function *, std::unique_ptr<FunctionInfo>> &FunctionIndex,
		unsigned NumInsts, uint64_t BitcodeIndex, bool EmitFunctionSummary) {
		std::unique_ptr<FunctionSummary> FuncSummary;
		if (EmitFunctionSummary) {
		FuncSummary = llvm::make_unique<FunctionSummary>(NumInsts);
		FuncSummary->setLocalFunction(F.hasLocalLinkage());
		}
		FunctionIndex[&F] =
		llvm::make_unique<FunctionInfo>(BitcodeIndex, std::move(FuncSummary));
		}

		/// Emit a function body to the module stream.
		static void WriteFunction(
		const Function &F, ValueEnumerator &VE, BitstreamWriter &Stream,
		DenseMap<const Function *, std::unique_ptr<FunctionInfo>> &FunctionIndex,
		bool EmitFunctionSummary) {
// Save the bitcode index of the start of this function block for recording		// Save the bitcode index of the start of this function block for recording
// in the VST.		// in the VST.
uint64_t BitcodeIndex = Stream.GetCurrentBitNo();		uint64_t BitcodeIndex = Stream.GetCurrentBitNo();
FunctionIndex[&F] = BitcodeIndex;

Stream.EnterSubblock(bitc::FUNCTION_BLOCK_ID, 4);		Stream.EnterSubblock(bitc::FUNCTION_BLOCK_ID, 4);
VE.incorporateFunction(F);		VE.incorporateFunction(F);

SmallVector<unsigned, 64> Vals;		SmallVector<unsigned, 64> Vals;

// Emit the number of basic blocks, so the reader can create them ahead of		// Emit the number of basic blocks, so the reader can create them ahead of
// time.		// time.
Show All 10 Lines	static void WriteFunction(
WriteFunctionLocalMetadata(F, VE, Stream);		WriteFunctionLocalMetadata(F, VE, Stream);

// Keep a running idea of what the instruction ID is.		// Keep a running idea of what the instruction ID is.
unsigned InstID = CstEnd;		unsigned InstID = CstEnd;

bool NeedsMetadataAttachment = F.hasMetadata();		bool NeedsMetadataAttachment = F.hasMetadata();

DILocation *LastDL = nullptr;		DILocation *LastDL = nullptr;
		unsigned NumInsts = 0;

// Finally, emit all the instructions, in order.		// Finally, emit all the instructions, in order.
for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB)		for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
for (BasicBlock::const_iterator I = BB->begin(), E = BB->end();		for (BasicBlock::const_iterator I = BB->begin(), E = BB->end();
I != E; ++I) {		I != E; ++I) {
WriteInstruction(*I, InstID, VE, Stream, Vals);		WriteInstruction(*I, InstID, VE, Stream, Vals);

		if (!isa<DbgInfoIntrinsic>(I)) ++NumInsts;

if (!I->getType()->isVoidTy())		if (!I->getType()->isVoidTy())
++InstID;		++InstID;

// If the instruction has metadata, write a metadata attachment later.		// If the instruction has metadata, write a metadata attachment later.
NeedsMetadataAttachment \|= I->hasMetadataOtherThanDebugLoc();		NeedsMetadataAttachment \|= I->hasMetadataOtherThanDebugLoc();

// If the instruction has a debug location, emit it.		// If the instruction has a debug location, emit it.
DILocation *DL = I->getDebugLoc();		DILocation *DL = I->getDebugLoc();
Show All 20 Lines	static void WriteFunction(
WriteValueSymbolTable(F.getValueSymbolTable(), VE, Stream);		WriteValueSymbolTable(F.getValueSymbolTable(), VE, Stream);

if (NeedsMetadataAttachment)		if (NeedsMetadataAttachment)
WriteMetadataAttachment(F, VE, Stream);		WriteMetadataAttachment(F, VE, Stream);
if (VE.shouldPreserveUseListOrder())		if (VE.shouldPreserveUseListOrder())
WriteUseListBlock(&F, VE, Stream);		WriteUseListBlock(&F, VE, Stream);
VE.purgeFunction();		VE.purgeFunction();
Stream.ExitBlock();		Stream.ExitBlock();

		SaveFunctionInfo(F, FunctionIndex, NumInsts, BitcodeIndex,
		EmitFunctionSummary);
}		}

// Emit blockinfo, which defines the standard abbreviations etc.		// Emit blockinfo, which defines the standard abbreviations etc.
static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) {		static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) {
// We only want to emit block info records for blocks that have multiple		// We only want to emit block info records for blocks that have multiple
// instances: CONSTANTS_BLOCK, FUNCTION_BLOCK and VALUE_SYMTAB_BLOCK.		// instances: CONSTANTS_BLOCK, FUNCTION_BLOCK and VALUE_SYMTAB_BLOCK.
// Other blocks can define their abbrevs inline.		// Other blocks can define their abbrevs inline.
Stream.EnterBlockInfoBlock(2);		Stream.EnterBlockInfoBlock(2);
▲ Show 20 Lines • Show All 161 Lines • ▼ Show 20 Lines	// FIXME: This should only use space for first class types!
if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=		if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID, Abbv) !=
FUNCTION_INST_GEP_ABBREV)		FUNCTION_INST_GEP_ABBREV)
llvm_unreachable("Unexpected abbrev ordering!");		llvm_unreachable("Unexpected abbrev ordering!");
}		}

Stream.ExitBlock();		Stream.ExitBlock();
}		}

		/// Write the module path strings, currently only used when generating
		/// a combined index file.
		static void WriteModStrings(const FunctionInfoIndex *I,
		BitstreamWriter &Stream) {
		Stream.EnterSubblock(bitc::MODULE_STRTAB_BLOCK_ID, 3);

		// TODO: See which abbrev sizes we actually need to emit

		// 8-bit fixed-width MST_ENTRY strings.
		BitCodeAbbrev *Abbv = new BitCodeAbbrev();
		Abbv->Add(BitCodeAbbrevOp(bitc::MST_CODE_ENTRY));
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
		unsigned Abbrev8Bit = Stream.EmitAbbrev(Abbv);

		// 7-bit fixed width MST_ENTRY strings.
		Abbv = new BitCodeAbbrev();
		Abbv->Add(BitCodeAbbrevOp(bitc::MST_CODE_ENTRY));
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
		unsigned Abbrev7Bit = Stream.EmitAbbrev(Abbv);

		// 6-bit char6 MST_ENTRY strings.
		Abbv = new BitCodeAbbrev();
		Abbv->Add(BitCodeAbbrevOp(bitc::MST_CODE_ENTRY));
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
		unsigned Abbrev6Bit = Stream.EmitAbbrev(Abbv);

		SmallVector<unsigned, 64> NameVals;
		for (const StringMapEntry<uint64_t> &MPSE : I->modPathStringEntries()) {
		StringEncoding Bits =
		getStringEncoding(MPSE.getKey().data(), MPSE.getKey().size());
		unsigned AbbrevToUse = Abbrev8Bit;
		if (Bits == SE_Char6)
		AbbrevToUse = Abbrev6Bit;
		else if (Bits == SE_Fixed7)
		AbbrevToUse = Abbrev7Bit;

		NameVals.push_back(MPSE.getValue());

		for (const auto P : MPSE.getKey()) NameVals.push_back((unsigned char)P);

		// Emit the finished record.
		Stream.EmitRecord(bitc::MST_CODE_ENTRY, NameVals, AbbrevToUse);
		NameVals.clear();
		}
		Stream.ExitBlock();
		}

		// Helper to emit a single function summary record.
		static void WritePerModuleFunctionSummaryRecord(
		SmallVector<unsigned, 64> &NameVals, FunctionSummary *FS, unsigned ValueID,
		unsigned FSAbbrev, BitstreamWriter &Stream) {
		assert(FS);
		NameVals.push_back(ValueID);
		NameVals.push_back(FS->isLocalFunction());
		NameVals.push_back(FS->instCount());

		// Emit the finished record.
		Stream.EmitRecord(bitc::FS_CODE_PERMODULE_ENTRY, NameVals, FSAbbrev);
		NameVals.clear();
		}

		/// Emit the per-module function summary section alongside the rest of
		/// the module's bitcode.
		static void WritePerModuleFunctionSummary(
		DenseMap<const Function *, std::unique_ptr<FunctionInfo>> &FunctionIndex,
		const Module *M, const ValueEnumerator &VE, BitstreamWriter &Stream) {
		Stream.EnterSubblock(bitc::FUNCTION_SUMMARY_BLOCK_ID, 3);

		// Abbrev for FS_CODE_PERMODULE_ENTRY.
		BitCodeAbbrev *Abbv = new BitCodeAbbrev();
		Abbv->Add(BitCodeAbbrevOp(bitc::FS_CODE_PERMODULE_ENTRY));
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // islocal
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount
		unsigned FSAbbrev = Stream.EmitAbbrev(Abbv);

		SmallVector<unsigned, 64> NameVals;
		for (auto &I : FunctionIndex) {
		// Skip anonymous functions. We will emit a function summary for
		// any aliases below.
		if (!I.first->hasName()) continue;

		WritePerModuleFunctionSummaryRecord(
		NameVals, I.second->functionSummary(),
		VE.getValueID(M->getValueSymbolTable().lookup(I.first->getName())),
		FSAbbrev, Stream);
		}

		for (const GlobalAlias &A : M->aliases()) {
		if (!A.getBaseObject()) continue;
		const Function *F = dyn_cast<Function>(A.getBaseObject());
		if (!F \|\| F->isDeclaration()) continue;

		assert(FunctionIndex.count(F) == 1);
		WritePerModuleFunctionSummaryRecord(
		NameVals, FunctionIndex[F]->functionSummary(),
		VE.getValueID(M->getValueSymbolTable().lookup(A.getName())), FSAbbrev,
		Stream);
		}

		Stream.ExitBlock();
		}

		/// Emit the combined function summary section into the combined index
		/// file.
		static void WriteCombinedFunctionSummary(const FunctionInfoIndex *I,
		BitstreamWriter &Stream) {
		Stream.EnterSubblock(bitc::FUNCTION_SUMMARY_BLOCK_ID, 3);

		// Abbrev for FS_CODE_COMBINED_ENTRY.
		BitCodeAbbrev *Abbv = new BitCodeAbbrev();
		Abbv->Add(BitCodeAbbrevOp(bitc::FS_CODE_COMBINED_ENTRY));
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid
		Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount
		unsigned FSAbbrev = Stream.EmitAbbrev(Abbv);

		SmallVector<unsigned, 64> NameVals;
		for (const auto &FII : *I) {
		for (auto &FI : FII.getValue()) {
		FunctionSummary *FS = FI->functionSummary();
		assert(FS);

		NameVals.push_back(I->getModuleId(FS->modulePath()));
		NameVals.push_back(FS->instCount());

		// Record the starting offset of this summary entry for use
		// in the VST entry. Add the current code size since the
		// reader will invoke readRecord after the abbrev id read.
		FI->setBitcodeIndex(Stream.GetCurrentBitNo() + Stream.GetAbbrevIDWidth());

		// Emit the finished record.
		Stream.EmitRecord(bitc::FS_CODE_COMBINED_ENTRY, NameVals, FSAbbrev);
		NameVals.clear();
		}
		}

		Stream.ExitBlock();
		}

/// WriteModule - Emit the specified module to the bitstream.		/// WriteModule - Emit the specified module to the bitstream.
static void WriteModule(const Module *M, BitstreamWriter &Stream,		static void WriteModule(const Module *M, BitstreamWriter &Stream,
bool ShouldPreserveUseListOrder,		bool ShouldPreserveUseListOrder,
uint64_t BitcodeStartBit) {		uint64_t BitcodeStartBit, bool EmitFunctionSummary) {
Stream.EnterSubblock(bitc::MODULE_BLOCK_ID, 3);		Stream.EnterSubblock(bitc::MODULE_BLOCK_ID, 3);

SmallVector<unsigned, 1> Vals;		SmallVector<unsigned, 1> Vals;
unsigned CurVersion = 1;		unsigned CurVersion = 1;
Vals.push_back(CurVersion);		Vals.push_back(CurVersion);
Stream.EmitRecord(bitc::MODULE_CODE_VERSION, Vals);		Stream.EmitRecord(bitc::MODULE_CODE_VERSION, Vals);

// Analyze the module, enumerating globals, functions, etc.		// Analyze the module, enumerating globals, functions, etc.
Show All 28 Lines	static void WriteModule(const Module *M, BitstreamWriter &Stream,

// Emit module-level use-lists.		// Emit module-level use-lists.
if (VE.shouldPreserveUseListOrder())		if (VE.shouldPreserveUseListOrder())
WriteUseListBlock(nullptr, VE, Stream);		WriteUseListBlock(nullptr, VE, Stream);

WriteOperandBundleTags(M, Stream);		WriteOperandBundleTags(M, Stream);

// Emit function bodies.		// Emit function bodies.
DenseMap<const Function *, uint64_t> FunctionIndex;		DenseMap<const Function *, std::unique_ptr<FunctionInfo>> FunctionIndex;
for (Module::const_iterator F = M->begin(), E = M->end(); F != E; ++F)		for (Module::const_iterator F = M->begin(), E = M->end(); F != E; ++F)
if (!F->isDeclaration())		if (!F->isDeclaration())
WriteFunction(*F, VE, Stream, FunctionIndex);		WriteFunction(*F, VE, Stream, FunctionIndex, EmitFunctionSummary);

		// Need to write after the above call to WriteFunction which populates
		// the summary information in the index.
		if (EmitFunctionSummary)
		WritePerModuleFunctionSummary(FunctionIndex, M, VE, Stream);

WriteValueSymbolTable(M->getValueSymbolTable(), VE, Stream,		WriteValueSymbolTable(M->getValueSymbolTable(), VE, Stream,
VSTOffsetPlaceholder, BitcodeStartBit, &FunctionIndex);		VSTOffsetPlaceholder, BitcodeStartBit, &FunctionIndex);

Stream.ExitBlock();		Stream.ExitBlock();
}		}

/// EmitDarwinBCHeader - If generating a bc file on darwin, we have to emit a		/// EmitDarwinBCHeader - If generating a bc file on darwin, we have to emit a
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines	static void EmitDarwinBCHeaderAndTrailer(SmallVectorImpl<char> &Buffer,
WriteInt32ToBuffer(BCSize , Buffer, Position);		WriteInt32ToBuffer(BCSize , Buffer, Position);
WriteInt32ToBuffer(CPUType , Buffer, Position);		WriteInt32ToBuffer(CPUType , Buffer, Position);

// If the file is not a multiple of 16 bytes, insert dummy padding.		// If the file is not a multiple of 16 bytes, insert dummy padding.
while (Buffer.size() & 15)		while (Buffer.size() & 15)
Buffer.push_back(0);		Buffer.push_back(0);
}		}

		/// Helper to write the header common to all bitcode files.
		static void WriteBitcodeHeader(BitstreamWriter &Stream) {
		// Emit the file header.
		Stream.Emit((unsigned)'B', 8);
		Stream.Emit((unsigned)'C', 8);
		Stream.Emit(0x0, 4);
		Stream.Emit(0xC, 4);
		Stream.Emit(0xE, 4);
		Stream.Emit(0xD, 4);
		}

/// WriteBitcodeToFile - Write the specified module to the specified output		/// WriteBitcodeToFile - Write the specified module to the specified output
/// stream.		/// stream.
void llvm::WriteBitcodeToFile(const Module *M, raw_ostream &Out,		void llvm::WriteBitcodeToFile(const Module *M, raw_ostream &Out,
bool ShouldPreserveUseListOrder) {		bool ShouldPreserveUseListOrder,
		bool EmitFunctionSummary) {
SmallVector<char, 0> Buffer;		SmallVector<char, 0> Buffer;
Buffer.reserve(256*1024);		Buffer.reserve(256*1024);

// If this is darwin or another generic macho target, reserve space for the		// If this is darwin or another generic macho target, reserve space for the
// header.		// header.
Triple TT(M->getTargetTriple());		Triple TT(M->getTargetTriple());
if (TT.isOSDarwin())		if (TT.isOSDarwin())
Buffer.insert(Buffer.begin(), DarwinBCHeaderSize, 0);		Buffer.insert(Buffer.begin(), DarwinBCHeaderSize, 0);

// Emit the module into the buffer.		// Emit the module into the buffer.
{		{
BitstreamWriter Stream(Buffer);		BitstreamWriter Stream(Buffer);
// Save the start bit of the actual bitcode, in case there is space		// Save the start bit of the actual bitcode, in case there is space
// saved at the start for the darwin header above. The reader stream		// saved at the start for the darwin header above. The reader stream
// will start at the bitcode, and we need the offset of the VST		// will start at the bitcode, and we need the offset of the VST
// to line up.		// to line up.
uint64_t BitcodeStartBit = Stream.GetCurrentBitNo();		uint64_t BitcodeStartBit = Stream.GetCurrentBitNo();

// Emit the file header.		// Emit the file header.
Stream.Emit((unsigned)'B', 8);		WriteBitcodeHeader(Stream);
Stream.Emit((unsigned)'C', 8);
Stream.Emit(0x0, 4);
Stream.Emit(0xC, 4);
Stream.Emit(0xE, 4);
Stream.Emit(0xD, 4);

// Emit the module.		// Emit the module.
WriteModule(M, Stream, ShouldPreserveUseListOrder, BitcodeStartBit);		WriteModule(M, Stream, ShouldPreserveUseListOrder, BitcodeStartBit,
		EmitFunctionSummary);
}		}

if (TT.isOSDarwin())		if (TT.isOSDarwin())
EmitDarwinBCHeaderAndTrailer(Buffer, TT);		EmitDarwinBCHeaderAndTrailer(Buffer, TT);

// Write the generated bitstream to "Out".		// Write the generated bitstream to "Out".
Out.write((char*)&Buffer.front(), Buffer.size());		Out.write((char*)&Buffer.front(), Buffer.size());
}		}

		// Write the specified function summary index to the given raw output stream,
		// where it will be written in a new bitcode block. This is used when
		// writing the combined index file for ThinLTO.
		void llvm::WriteFunctionSummaryToFile(const FunctionInfoIndex *Index,
		raw_ostream &Out) {
		SmallVector<char, 0> Buffer;
		Buffer.reserve(256 * 1024);

		BitstreamWriter Stream(Buffer);

		// Emit the bitcode header.
		WriteBitcodeHeader(Stream);

		Stream.EnterSubblock(bitc::MODULE_BLOCK_ID, 3);

		SmallVector<unsigned, 1> Vals;
		unsigned CurVersion = 1;
		Vals.push_back(CurVersion);
		Stream.EmitRecord(bitc::MODULE_CODE_VERSION, Vals);

		// Write the module paths in the combined index.
		WriteModStrings(Index, Stream);

		// Write the function summary combined index records.
		WriteCombinedFunctionSummary(Index, Stream);

		// Need a special VST writer for the combined index (we don't have a
		// real VST and real values when this is invoked).
		WriteCombinedValueSymbolTable(Index, Stream);

		Stream.ExitBlock();

		Out.write((char *)&Buffer.front(), Buffer.size());
		}

llvm/trunk/lib/Bitcode/Writer/BitcodeWriterPass.cpp

	Show All 13 Lines
	#include "llvm/Bitcode/BitcodeWriterPass.h"			#include "llvm/Bitcode/BitcodeWriterPass.h"
	#include "llvm/Bitcode/ReaderWriter.h"			#include "llvm/Bitcode/ReaderWriter.h"
	#include "llvm/IR/Module.h"			#include "llvm/IR/Module.h"
	#include "llvm/IR/PassManager.h"			#include "llvm/IR/PassManager.h"
	#include "llvm/Pass.h"			#include "llvm/Pass.h"
	using namespace llvm;			using namespace llvm;

	PreservedAnalyses BitcodeWriterPass::run(Module &M) {			PreservedAnalyses BitcodeWriterPass::run(Module &M) {
	WriteBitcodeToFile(&M, OS, ShouldPreserveUseListOrder);			WriteBitcodeToFile(&M, OS, ShouldPreserveUseListOrder, EmitFunctionSummary);
	return PreservedAnalyses::all();			return PreservedAnalyses::all();
	}			}

	namespace {			namespace {
	class WriteBitcodePass : public ModulePass {			class WriteBitcodePass : public ModulePass {
	raw_ostream &OS; // raw_ostream to print on			raw_ostream &OS; // raw_ostream to print on
	bool ShouldPreserveUseListOrder;			bool ShouldPreserveUseListOrder;
				bool EmitFunctionSummary;

	public:			public:
	static char ID; // Pass identification, replacement for typeid			static char ID; // Pass identification, replacement for typeid
	explicit WriteBitcodePass(raw_ostream &o, bool ShouldPreserveUseListOrder)			explicit WriteBitcodePass(raw_ostream &o, bool ShouldPreserveUseListOrder,
				bool EmitFunctionSummary)
	: ModulePass(ID), OS(o),			: ModulePass(ID), OS(o),
	ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {}			ShouldPreserveUseListOrder(ShouldPreserveUseListOrder),
				EmitFunctionSummary(EmitFunctionSummary) {}

	const char *getPassName() const override { return "Bitcode Writer"; }			const char *getPassName() const override { return "Bitcode Writer"; }

	bool runOnModule(Module &M) override {			bool runOnModule(Module &M) override {
	WriteBitcodeToFile(&M, OS, ShouldPreserveUseListOrder);			WriteBitcodeToFile(&M, OS, ShouldPreserveUseListOrder,
				EmitFunctionSummary);
	return false;			return false;
	}			}
	};			};
	}			}

	char WriteBitcodePass::ID = 0;			char WriteBitcodePass::ID = 0;

	ModulePass *llvm::createBitcodeWriterPass(raw_ostream &Str,			ModulePass *llvm::createBitcodeWriterPass(raw_ostream &Str,
	bool ShouldPreserveUseListOrder) {			bool ShouldPreserveUseListOrder,
	return new WriteBitcodePass(Str, ShouldPreserveUseListOrder);			bool EmitFunctionSummary) {
				return new WriteBitcodePass(Str, ShouldPreserveUseListOrder,
				EmitFunctionSummary);
	}			}

llvm/trunk/lib/IR/CMakeLists.txt

Show All 33 Lines	add_llvm_library(LLVMCore
Metadata.cpp		Metadata.cpp
MetadataTracking.cpp		MetadataTracking.cpp
Module.cpp		Module.cpp
Operator.cpp		Operator.cpp
Pass.cpp		Pass.cpp
PassManager.cpp		PassManager.cpp
PassRegistry.cpp		PassRegistry.cpp
Statepoint.cpp		Statepoint.cpp
		FunctionInfo.cpp
Type.cpp		Type.cpp
TypeFinder.cpp		TypeFinder.cpp
Use.cpp		Use.cpp
User.cpp		User.cpp
Value.cpp		Value.cpp
ValueSymbolTable.cpp		ValueSymbolTable.cpp
ValueTypes.cpp		ValueTypes.cpp
Verifier.cpp		Verifier.cpp
Show All 14 Lines

llvm/trunk/lib/IR/FunctionInfo.cpp

				//===-- FunctionInfo.cpp - Function Info Index ----------------------------===//
				//
				// The LLVM Compiler Infrastructure
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//
				//
				// This file implements the function info index and summary classes for the
				// IR library.
				//
				//===----------------------------------------------------------------------===//

				#include "llvm/IR/FunctionInfo.h"
				#include "llvm/ADT/StringMap.h"
				using namespace llvm;

				// Create the combined function index/summary from multiple
				// per-module instances.
				void FunctionInfoIndex::mergeFrom(std::unique_ptr<FunctionInfoIndex> Other,
				uint64_t NextModuleId) {

				StringRef ModPath;
				for (auto &OtherFuncInfoLists : *Other) {
				StringRef FuncName = OtherFuncInfoLists.getKey();
				FunctionInfoList &List = OtherFuncInfoLists.second;

				// Assert that the func info list only has one entry, since we shouldn't
				// have duplicate names within a single per-module index.
				assert(List.size() == 1);
				std::unique_ptr<FunctionInfo> Info = std::move(List.front());

				// Add the module path string ref for this module if we haven't already
				// saved a reference to it.
				if (ModPath.empty())
				ModPath =
				addModulePath(Info->functionSummary()->modulePath(), NextModuleId);
				else
				assert(ModPath == Info->functionSummary()->modulePath() &&
				"Each module in the combined map should have a unique ID");

				// Note the module path string ref was copied above and is still owned by
				// the original per-module index. Reset it to the new module path
				// string reference owned by the combined index.
				Info->functionSummary()->setModulePath(ModPath);

				// If it is a local function, rename it.
				if (Info->functionSummary()->isLocalFunction()) {
				// Any local functions are virtually renamed when being added to the
				// combined index map, to disambiguate from other functions with
				// the same name. The symbol table created for the combined index
				// file should contain the renamed symbols.
				FuncName =
				FunctionInfoIndex::getGlobalNameForLocal(FuncName, NextModuleId);
				}

				// Add new function info to existing list. There may be duplicates when
				// combining FunctionMap entries, due to COMDAT functions. Any local
				// functions were virtually renamed above.
				addFunctionInfo(FuncName, std::move(Info));
				}
				}

llvm/trunk/lib/Object/CMakeLists.txt

Show All 10 Lines	add_llvm_library(LLVMObject
IRObjectFile.cpp		IRObjectFile.cpp
MachOObjectFile.cpp		MachOObjectFile.cpp
MachOUniversal.cpp		MachOUniversal.cpp
Object.cpp		Object.cpp
ObjectFile.cpp		ObjectFile.cpp
RecordStreamer.cpp		RecordStreamer.cpp
SymbolicFile.cpp		SymbolicFile.cpp
SymbolSize.cpp		SymbolSize.cpp
		FunctionIndexObjectFile.cpp

ADDITIONAL_HEADER_DIRS		ADDITIONAL_HEADER_DIRS
${LLVM_MAIN_INCLUDE_DIR}/llvm/Object		${LLVM_MAIN_INCLUDE_DIR}/llvm/Object

DEPENDS		DEPENDS
intrinsics_gen		intrinsics_gen
)		)

llvm/trunk/lib/Object/FunctionIndexObjectFile.cpp

				//===- FunctionIndexObjectFile.cpp - Function index file implementation ----===//
				//
				// The LLVM Compiler Infrastructure
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//
				//
				// Part of the FunctionIndexObjectFile class implementation.
				//
				//===----------------------------------------------------------------------===//

				#include "llvm/Object/FunctionIndexObjectFile.h"
				#include "llvm/ADT/STLExtras.h"
				#include "llvm/Bitcode/ReaderWriter.h"
				#include "llvm/IR/FunctionInfo.h"
				#include "llvm/MC/MCStreamer.h"
				#include "llvm/Object/ObjectFile.h"
				#include "llvm/Support/MemoryBuffer.h"
				#include "llvm/Support/raw_ostream.h"
				using namespace llvm;
				using namespace object;

				FunctionIndexObjectFile::FunctionIndexObjectFile(
				MemoryBufferRef Object, std::unique_ptr<FunctionInfoIndex> I)
				: SymbolicFile(Binary::ID_FunctionIndex, Object), Index(std::move(I)) {}

				FunctionIndexObjectFile::~FunctionIndexObjectFile() {}

				std::unique_ptr<FunctionInfoIndex> FunctionIndexObjectFile::takeIndex() {
				return std::move(Index);
				}

				ErrorOr<MemoryBufferRef> FunctionIndexObjectFile::findBitcodeInObject(
				const ObjectFile &Obj) {
				for (const SectionRef &Sec : Obj.sections()) {
				StringRef SecName;
				if (std::error_code EC = Sec.getName(SecName)) return EC;
				if (SecName == ".llvmbc") {
				StringRef SecContents;
				if (std::error_code EC = Sec.getContents(SecContents)) return EC;
				return MemoryBufferRef(SecContents, Obj.getFileName());
				}
				}

				return object_error::bitcode_section_not_found;
				}

				ErrorOr<MemoryBufferRef> FunctionIndexObjectFile::findBitcodeInMemBuffer(
				MemoryBufferRef Object) {
				sys::fs::file_magic Type = sys::fs::identify_magic(Object.getBuffer());
				switch (Type) {
				case sys::fs::file_magic::bitcode:
				return Object;
				case sys::fs::file_magic::elf_relocatable:
				case sys::fs::file_magic::macho_object:
				case sys::fs::file_magic::coff_object: {
				ErrorOr<std::unique_ptr<ObjectFile>> ObjFile =
				ObjectFile::createObjectFile(Object, Type);
				if (!ObjFile) return ObjFile.getError();
				return findBitcodeInObject(*ObjFile->get());
				}
				default:
				return object_error::invalid_file_type;
				}
				}

				// Looks for function index in the given memory buffer.
				// returns true if found, else false.
				bool FunctionIndexObjectFile::hasFunctionSummaryInMemBuffer(
				MemoryBufferRef Object, LLVMContext &Context) {
				ErrorOr<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object);
				if (!BCOrErr) return false;

				return hasFunctionSummary(BCOrErr.get(), Context, nullptr);
				}

				// Parse function index in the given memory buffer.
				// Return new FunctionIndexObjectFile instance containing parsed
				// function summary/index.
				ErrorOr<std::unique_ptr<FunctionIndexObjectFile>>
				FunctionIndexObjectFile::create(MemoryBufferRef Object, LLVMContext &Context,
				bool IsLazy) {
				std::unique_ptr<FunctionInfoIndex> Index;

				ErrorOr<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object);
				if (!BCOrErr) return BCOrErr.getError();

				ErrorOr<std::unique_ptr<FunctionInfoIndex>> IOrErr =
				getFunctionInfoIndex(BCOrErr.get(), Context, nullptr, IsLazy);

				if (std::error_code EC = IOrErr.getError()) return EC;

				Index = std::move(IOrErr.get());

				return llvm::make_unique<FunctionIndexObjectFile>(Object, std::move(Index));
				}

				// Parse the function summary information for function with the
				// given name out of the given buffer. Parsed information is
				// stored on the index object saved in this object.
				std::error_code FunctionIndexObjectFile::findFunctionSummaryInMemBuffer(
				MemoryBufferRef Object, LLVMContext &Context, StringRef FunctionName) {
				sys::fs::file_magic Type = sys::fs::identify_magic(Object.getBuffer());
				switch (Type) {
				case sys::fs::file_magic::bitcode: {
				return readFunctionSummary(Object, Context, nullptr, FunctionName,
				std::move(Index));
				}
				default:
				return object_error::invalid_file_type;
				}
				}

llvm/trunk/test/Bitcode/thinlto-function-summary.ll

				; RUN: llvm-as -function-summary < %s \| llvm-bcanalyzer -dump \| FileCheck %s -check-prefix=BC
				; Check for function summary block/records.

				; BC: <FUNCTION_SUMMARY_BLOCK
				; BC-NEXT: <PERMODULE_ENTRY
				; BC-NEXT: <PERMODULE_ENTRY
				; BC-NEXT: <PERMODULE_ENTRY
				; BC-NEXT: </FUNCTION_SUMMARY_BLOCK

				; RUN: llvm-as -function-summary < %s \| llvm-dis \| FileCheck %s
				; Check that this round-trips correctly.

				; ModuleID = '<stdin>'
				target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
				target triple = "x86_64-unknown-linux-gnu"

				; CHECK: define i32 @foo()

				; Function Attrs: nounwind uwtable
				define i32 @foo() #0 {
				entry:
				ret i32 1
				}

				; CHECK: define i32 @bar(i32 %x)

				; Function Attrs: nounwind uwtable
				define i32 @bar(i32 %x) #0 {
				entry:
				ret i32 %x
				}

				; Check an anonymous function as well, since in that case only the alias
				; ends up in the value symbol table and having a summary.
				@f = alias void (), void ()* @0 ; <void ()*> [#uses=0]
				@h = external global void ()* ; <void ()*> [#uses=0]

				define internal void @0() nounwind {
				entry:
				store void()* @0, void()** @h
				br label %return

				return: ; preds = %entry
				ret void
				}

llvm/trunk/test/tools/gold/X86/Inputs/thinlto.ll

				define void @g() {
				entry:
				ret void
				}

llvm/trunk/test/tools/gold/X86/thinlto.ll

				; RUN: llvm-as -function-summary %s -o %t.o
				; RUN: llvm-as -function-summary %p/Inputs/thinlto.ll -o %t2.o

				; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
				; RUN: --plugin-opt=thinlto \
				; RUN: -shared %t.o %t2.o -o %t3
				; RUN: llvm-bcanalyzer -dump %t3.thinlto.bc \| FileCheck %s --check-prefix=COMBINED
				; RUN: not test -e %t3

				; COMBINED: <MODULE_STRTAB_BLOCK
				; COMBINED-NEXT: <ENTRY
				; COMBINED-NEXT: <ENTRY
				; COMBINED-NEXT: </MODULE_STRTAB_BLOCK
				; COMBINED-NEXT: <FUNCTION_SUMMARY_BLOCK
				; COMBINED-NEXT: <COMBINED_ENTRY
				; COMBINED-NEXT: <COMBINED_ENTRY
				; COMBINED-NEXT: </FUNCTION_SUMMARY_BLOCK

				define void @f() {
				entry:
				ret void
				}

llvm/trunk/tools/gold/gold-plugin.cpp

Show All 26 Lines
#include "llvm/IR/DiagnosticPrinter.h"		#include "llvm/IR/DiagnosticPrinter.h"
#include "llvm/IR/LLVMContext.h"		#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/LegacyPassManager.h"		#include "llvm/IR/LegacyPassManager.h"
#include "llvm/IR/Module.h"		#include "llvm/IR/Module.h"
#include "llvm/IR/Verifier.h"		#include "llvm/IR/Verifier.h"
#include "llvm/Linker/Linker.h"		#include "llvm/Linker/Linker.h"
#include "llvm/MC/SubtargetFeature.h"		#include "llvm/MC/SubtargetFeature.h"
#include "llvm/Object/IRObjectFile.h"		#include "llvm/Object/IRObjectFile.h"
		#include "llvm/Object/FunctionIndexObjectFile.h"
#include "llvm/Support/raw_ostream.h"		#include "llvm/Support/raw_ostream.h"
#include "llvm/Support/Host.h"		#include "llvm/Support/Host.h"
#include "llvm/Support/ManagedStatic.h"		#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/MemoryBuffer.h"		#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/TargetRegistry.h"		#include "llvm/Support/TargetRegistry.h"
#include "llvm/Support/TargetSelect.h"		#include "llvm/Support/TargetSelect.h"
#include "llvm/Transforms/IPO.h"		#include "llvm/Transforms/IPO.h"
#include "llvm/Transforms/IPO/PassManagerBuilder.h"		#include "llvm/Transforms/IPO/PassManagerBuilder.h"
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines	#ifdef NDEBUG
static bool DisableVerify = true;		static bool DisableVerify = true;
#else		#else
static bool DisableVerify = false;		static bool DisableVerify = false;
#endif		#endif
static std::string obj_path;		static std::string obj_path;
static std::string extra_library_path;		static std::string extra_library_path;
static std::string triple;		static std::string triple;
static std::string mcpu;		static std::string mcpu;
		// When the thinlto plugin option is specified, only read the function
		// the information from intermediate files and write a combined
		// global index for the ThinLTO backends.
		static bool thinlto = false;
// Additional options to pass into the code generator.		// Additional options to pass into the code generator.
// Note: This array will contain all plugin options which are not claimed		// Note: This array will contain all plugin options which are not claimed
// as plugin exclusive to pass to the code generator.		// as plugin exclusive to pass to the code generator.
// For example, "generate-api-file" and "as"options are for the plugin		// For example, "generate-api-file" and "as"options are for the plugin
// use only and will not be passed.		// use only and will not be passed.
static std::vector<const char *> extra;		static std::vector<const char *> extra;

static void process_plugin_option(const char *opt_)		static void process_plugin_option(const char *opt_)
Show All 13 Lines	static void process_plugin_option(const char *opt_)
} else if (opt.startswith("obj-path=")) {		} else if (opt.startswith("obj-path=")) {
obj_path = opt.substr(strlen("obj-path="));		obj_path = opt.substr(strlen("obj-path="));
} else if (opt == "emit-llvm") {		} else if (opt == "emit-llvm") {
TheOutputType = OT_BC_ONLY;		TheOutputType = OT_BC_ONLY;
} else if (opt == "save-temps") {		} else if (opt == "save-temps") {
TheOutputType = OT_SAVE_TEMPS;		TheOutputType = OT_SAVE_TEMPS;
} else if (opt == "disable-output") {		} else if (opt == "disable-output") {
TheOutputType = OT_DISABLE;		TheOutputType = OT_DISABLE;
		} else if (opt == "thinlto") {
		thinlto = true;
} else if (opt.size() == 2 && opt[0] == 'O') {		} else if (opt.size() == 2 && opt[0] == 'O') {
if (opt[1] < '0' \|\| opt[1] > '3')		if (opt[1] < '0' \|\| opt[1] > '3')
message(LDPL_FATAL, "Optimization level must be between 0 and 3");		message(LDPL_FATAL, "Optimization level must be between 0 and 3");
OptLevel = opt[1] - '0';		OptLevel = opt[1] - '0';
} else if (opt.startswith("jobs=")) {		} else if (opt.startswith("jobs=")) {
if (StringRef(opt_ + 5).getAsInteger(10, Parallelism))		if (StringRef(opt_ + 5).getAsInteger(10, Parallelism))
message(LDPL_FATAL, "Invalid parallelism level: %s", opt_ + 5);		message(LDPL_FATAL, "Invalid parallelism level: %s", opt_ + 5);
} else if (opt == "disable-verify") {		} else if (opt == "disable-verify") {
▲ Show 20 Lines • Show All 228 Lines • ▼ Show 20 Lines	static ld_plugin_status claim_file_hook(const ld_plugin_input_file *file,
}		}
std::unique_ptr<object::IRObjectFile> Obj = std::move(*ObjOrErr);		std::unique_ptr<object::IRObjectFile> Obj = std::move(*ObjOrErr);

Modules.resize(Modules.size() + 1);		Modules.resize(Modules.size() + 1);
claimed_file &cf = Modules.back();		claimed_file &cf = Modules.back();

cf.handle = file->handle;		cf.handle = file->handle;

		// If we are doing ThinLTO compilation, don't need to process the symbols.
		// Later we simply build a combined index file after all files are claimed.
		if (options::thinlto) return LDPS_OK;

for (auto &Sym : Obj->symbols()) {		for (auto &Sym : Obj->symbols()) {
uint32_t Symflags = Sym.getFlags();		uint32_t Symflags = Sym.getFlags();
if (shouldSkip(Symflags))		if (shouldSkip(Symflags))
continue;		continue;

cf.syms.push_back(ld_plugin_symbol());		cf.syms.push_back(ld_plugin_symbol());
ld_plugin_symbol &sym = cf.syms.back();		ld_plugin_symbol &sym = cf.syms.back();
sym.version = nullptr;		sym.version = nullptr;
▲ Show 20 Lines • Show All 199 Lines • ▼ Show 20 Lines

static void freeSymName(ld_plugin_symbol &Sym) {		static void freeSymName(ld_plugin_symbol &Sym) {
free(Sym.name);		free(Sym.name);
free(Sym.comdat_key);		free(Sym.comdat_key);
Sym.name = nullptr;		Sym.name = nullptr;
Sym.comdat_key = nullptr;		Sym.comdat_key = nullptr;
}		}

		static std::unique_ptr<FunctionInfoIndex> getFunctionIndexForFile(
		LLVMContext &Context, claimed_file &F, ld_plugin_input_file &Info) {

		if (get_symbols(F.handle, F.syms.size(), &F.syms[0]) != LDPS_OK)
		message(LDPL_FATAL, "Failed to get symbol information");

		const void *View;
		if (get_view(F.handle, &View) != LDPS_OK)
		message(LDPL_FATAL, "Failed to get a view of file");

		MemoryBufferRef BufferRef(StringRef((const char *)View, Info.filesize),
		Info.name);
		ErrorOr<std::unique_ptr<object::FunctionIndexObjectFile>> ObjOrErr =
		object::FunctionIndexObjectFile::create(BufferRef, Context);

		if (std::error_code EC = ObjOrErr.getError())
		message(LDPL_FATAL, "Could not read function index bitcode from file : %s",
		EC.message().c_str());

		object::FunctionIndexObjectFile &Obj = **ObjOrErr;

		return Obj.takeIndex();
		}

static std::unique_ptr<Module>		static std::unique_ptr<Module>
getModuleForFile(LLVMContext &Context, claimed_file &F,		getModuleForFile(LLVMContext &Context, claimed_file &F,
ld_plugin_input_file &Info, raw_fd_ostream *ApiFile,		ld_plugin_input_file &Info, raw_fd_ostream *ApiFile,
StringSet<> &Internalize, StringSet<> &Maybe) {		StringSet<> &Internalize, StringSet<> &Maybe) {

if (get_symbols(F.handle, F.syms.size(), F.syms.data()) != LDPS_OK)		if (get_symbols(F.handle, F.syms.size(), F.syms.data()) != LDPS_OK)
message(LDPL_FATAL, "Failed to get symbol information");		message(LDPL_FATAL, "Failed to get symbol information");

▲ Show 20 Lines • Show All 250 Lines • ▼ Show 20 Lines
/// native object file. Then, perform optimization and codegen.		/// native object file. Then, perform optimization and codegen.
static ld_plugin_status allSymbolsReadHook(raw_fd_ostream *ApiFile) {		static ld_plugin_status allSymbolsReadHook(raw_fd_ostream *ApiFile) {
if (Modules.empty())		if (Modules.empty())
return LDPS_OK;		return LDPS_OK;

LLVMContext Context;		LLVMContext Context;
Context.setDiagnosticHandler(diagnosticHandler, nullptr, true);		Context.setDiagnosticHandler(diagnosticHandler, nullptr, true);

		// If we are doing ThinLTO compilation, simply build the combined
		// function index/summary and emit it. We don't need to parse the modules
		// and link them in this case.
		if (options::thinlto) {
		std::unique_ptr<FunctionInfoIndex> CombinedIndex(new FunctionInfoIndex());
		uint64_t NextModuleId = 0;
		for (claimed_file &F : Modules) {
		ld_plugin_input_file File;
		if (get_input_file(F.handle, &File) != LDPS_OK)
		message(LDPL_FATAL, "Failed to get file information");

		std::unique_ptr<FunctionInfoIndex> Index =
		getFunctionIndexForFile(Context, F, File);
		CombinedIndex->mergeFrom(std::move(Index), ++NextModuleId);
		}

		std::error_code EC;
		raw_fd_ostream OS(output_name + ".thinlto.bc", EC,
		sys::fs::OpenFlags::F_None);
		if (EC)
		message(LDPL_FATAL, "Unable to open %s.thinlto.bc for writing: %s",
		output_name.data(), EC.message().c_str());
		WriteFunctionSummaryToFile(CombinedIndex.get(), OS);
		OS.close();

		cleanup_hook();
		exit(0);
		}

std::unique_ptr<Module> Combined(new Module("ld-temp.o", Context));		std::unique_ptr<Module> Combined(new Module("ld-temp.o", Context));
Linker L(Combined.get());		Linker L(Combined.get());

std::string DefaultTriple = sys::getDefaultTargetTriple();		std::string DefaultTriple = sys::getDefaultTargetTriple();

StringSet<> Internalize;		StringSet<> Internalize;
StringSet<> Maybe;		StringSet<> Maybe;
for (claimed_file &F : Modules) {		for (claimed_file &F : Modules) {
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

llvm/trunk/tools/llvm-as/llvm-as.cpp

Show All 39 Lines

static cl::opt<bool>		static cl::opt<bool>
Force("f", cl::desc("Enable binary output on terminals"));		Force("f", cl::desc("Enable binary output on terminals"));

static cl::opt<bool>		static cl::opt<bool>
DisableOutput("disable-output", cl::desc("Disable output"), cl::init(false));		DisableOutput("disable-output", cl::desc("Disable output"), cl::init(false));

static cl::opt<bool>		static cl::opt<bool>
		EmitFunctionSummary("function-summary", cl::desc("Emit function summary index"),
		cl::init(false));

		static cl::opt<bool>
DumpAsm("d", cl::desc("Print assembly as parsed"), cl::Hidden);		DumpAsm("d", cl::desc("Print assembly as parsed"), cl::Hidden);

static cl::opt<bool>		static cl::opt<bool>
DisableVerify("disable-verify", cl::Hidden,		DisableVerify("disable-verify", cl::Hidden,
cl::desc("Do not run verifier on input LLVM (dangerous!)"));		cl::desc("Do not run verifier on input LLVM (dangerous!)"));

static cl::opt<bool> PreserveBitcodeUseListOrder(		static cl::opt<bool> PreserveBitcodeUseListOrder(
"preserve-bc-uselistorder",		"preserve-bc-uselistorder",
Show All 16 Lines	static void WriteOutputFile(const Module *M) {
std::unique_ptr<tool_output_file> Out(		std::unique_ptr<tool_output_file> Out(
new tool_output_file(OutputFilename, EC, sys::fs::F_None));		new tool_output_file(OutputFilename, EC, sys::fs::F_None));
if (EC) {		if (EC) {
errs() << EC.message() << '\n';		errs() << EC.message() << '\n';
exit(1);		exit(1);
}		}

if (Force \|\| !CheckBitcodeOutputToConsole(Out->os(), true))		if (Force \|\| !CheckBitcodeOutputToConsole(Out->os(), true))
WriteBitcodeToFile(M, Out->os(), PreserveBitcodeUseListOrder);		WriteBitcodeToFile(M, Out->os(), PreserveBitcodeUseListOrder,
		EmitFunctionSummary);

// Declare success.		// Declare success.
Out->keep();		Out->keep();
}		}

int main(int argc, char **argv) {		int main(int argc, char **argv) {
// Print a stack trace if we signal out.		// Print a stack trace if we signal out.
sys::PrintStackTraceOnErrorSignal();		sys::PrintStackTraceOnErrorSignal();
Show All 31 Lines

llvm/trunk/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp

Show First 20 Lines • Show All 108 Lines • ▼ Show 20 Lines	static const char *GetBlockName(unsigned BlockID,
case bitc::PARAMATTR_GROUP_BLOCK_ID: return "PARAMATTR_GROUP_BLOCK_ID";		case bitc::PARAMATTR_GROUP_BLOCK_ID: return "PARAMATTR_GROUP_BLOCK_ID";
case bitc::TYPE_BLOCK_ID_NEW: return "TYPE_BLOCK_ID";		case bitc::TYPE_BLOCK_ID_NEW: return "TYPE_BLOCK_ID";
case bitc::CONSTANTS_BLOCK_ID: return "CONSTANTS_BLOCK";		case bitc::CONSTANTS_BLOCK_ID: return "CONSTANTS_BLOCK";
case bitc::FUNCTION_BLOCK_ID: return "FUNCTION_BLOCK";		case bitc::FUNCTION_BLOCK_ID: return "FUNCTION_BLOCK";
case bitc::VALUE_SYMTAB_BLOCK_ID: return "VALUE_SYMTAB";		case bitc::VALUE_SYMTAB_BLOCK_ID: return "VALUE_SYMTAB";
case bitc::METADATA_BLOCK_ID: return "METADATA_BLOCK";		case bitc::METADATA_BLOCK_ID: return "METADATA_BLOCK";
case bitc::METADATA_ATTACHMENT_ID: return "METADATA_ATTACHMENT_BLOCK";		case bitc::METADATA_ATTACHMENT_ID: return "METADATA_ATTACHMENT_BLOCK";
case bitc::USELIST_BLOCK_ID: return "USELIST_BLOCK_ID";		case bitc::USELIST_BLOCK_ID: return "USELIST_BLOCK_ID";
		case bitc::FUNCTION_SUMMARY_BLOCK_ID:
		return "FUNCTION_SUMMARY_BLOCK";
		case bitc::MODULE_STRTAB_BLOCK_ID: return "MODULE_STRTAB_BLOCK";
}		}
}		}

/// GetCodeName - Return a symbolic code name if known, otherwise return		/// GetCodeName - Return a symbolic code name if known, otherwise return
/// null.		/// null.
static const char *GetCodeName(unsigned CodeID, unsigned BlockID,		static const char *GetCodeName(unsigned CodeID, unsigned BlockID,
const BitstreamReader &StreamFile,		const BitstreamReader &StreamFile,
CurStreamTypeType CurStreamType) {		CurStreamTypeType CurStreamType) {
▲ Show 20 Lines • Show All 138 Lines • ▼ Show 20 Lines	default: return nullptr;
STRINGIFY_CODE(FUNC_CODE, INST_GEP)		STRINGIFY_CODE(FUNC_CODE, INST_GEP)
}		}
case bitc::VALUE_SYMTAB_BLOCK_ID:		case bitc::VALUE_SYMTAB_BLOCK_ID:
switch (CodeID) {		switch (CodeID) {
default: return nullptr;		default: return nullptr;
STRINGIFY_CODE(VST_CODE, ENTRY)		STRINGIFY_CODE(VST_CODE, ENTRY)
STRINGIFY_CODE(VST_CODE, BBENTRY)		STRINGIFY_CODE(VST_CODE, BBENTRY)
STRINGIFY_CODE(VST_CODE, FNENTRY)		STRINGIFY_CODE(VST_CODE, FNENTRY)
		STRINGIFY_CODE(VST_CODE, COMBINED_FNENTRY)
		}
		case bitc::MODULE_STRTAB_BLOCK_ID:
		switch (CodeID) {
		default: return nullptr;
		STRINGIFY_CODE(MST_CODE, ENTRY)
		}
		case bitc::FUNCTION_SUMMARY_BLOCK_ID:
		switch (CodeID) {
		default: return nullptr;
		STRINGIFY_CODE(FS_CODE, PERMODULE_ENTRY)
		STRINGIFY_CODE(FS_CODE, COMBINED_ENTRY)
}		}
case bitc::METADATA_ATTACHMENT_ID:		case bitc::METADATA_ATTACHMENT_ID:
switch(CodeID) {		switch(CodeID) {
default:return nullptr;		default:return nullptr;
STRINGIFY_CODE(METADATA, ATTACHMENT)		STRINGIFY_CODE(METADATA, ATTACHMENT)
}		}
case bitc::METADATA_BLOCK_ID:		case bitc::METADATA_BLOCK_ID:
switch(CodeID) {		switch(CodeID) {
▲ Show 20 Lines • Show All 453 Lines • Show Last 20 Lines

This is an archive of the discontinued LLVM Phabricator instance.

Support for function summary index bitcode sections and files
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 36467

llvm/trunk/include/llvm/Bitcode/BitcodeWriterPass.h

llvm/trunk/include/llvm/Bitcode/BitstreamWriter.h

llvm/trunk/include/llvm/Bitcode/LLVMBitCodes.h

llvm/trunk/include/llvm/Bitcode/ReaderWriter.h

llvm/trunk/include/llvm/IR/FunctionInfo.h

llvm/trunk/include/llvm/Object/Binary.h

llvm/trunk/include/llvm/Object/FunctionIndexObjectFile.h

llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp

llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp

llvm/trunk/lib/Bitcode/Writer/BitcodeWriterPass.cpp

llvm/trunk/lib/IR/CMakeLists.txt

llvm/trunk/lib/IR/FunctionInfo.cpp

llvm/trunk/lib/Object/CMakeLists.txt

llvm/trunk/lib/Object/FunctionIndexObjectFile.cpp

llvm/trunk/test/Bitcode/thinlto-function-summary.ll

llvm/trunk/test/tools/gold/X86/Inputs/thinlto.ll

llvm/trunk/test/tools/gold/X86/thinlto.ll

llvm/trunk/tools/gold/gold-plugin.cpp

llvm/trunk/tools/llvm-as/llvm-as.cpp

llvm/trunk/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp

This is an archive of the discontinued LLVM Phabricator instance.

Support for function summary index bitcode sections and filesClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 36467

llvm/trunk/include/llvm/Bitcode/BitcodeWriterPass.h

llvm/trunk/include/llvm/Bitcode/BitstreamWriter.h

llvm/trunk/include/llvm/Bitcode/LLVMBitCodes.h

llvm/trunk/include/llvm/Bitcode/ReaderWriter.h

llvm/trunk/include/llvm/IR/FunctionInfo.h

llvm/trunk/include/llvm/Object/Binary.h

llvm/trunk/include/llvm/Object/FunctionIndexObjectFile.h

llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp

llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp

llvm/trunk/lib/Bitcode/Writer/BitcodeWriterPass.cpp

llvm/trunk/lib/IR/CMakeLists.txt

llvm/trunk/lib/IR/FunctionInfo.cpp

llvm/trunk/lib/Object/CMakeLists.txt

llvm/trunk/lib/Object/FunctionIndexObjectFile.cpp

llvm/trunk/test/Bitcode/thinlto-function-summary.ll

llvm/trunk/test/tools/gold/X86/Inputs/thinlto.ll

llvm/trunk/test/tools/gold/X86/thinlto.ll

llvm/trunk/tools/gold/gold-plugin.cpp

llvm/trunk/tools/llvm-as/llvm-as.cpp

llvm/trunk/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp

Support for function summary index bitcode sections and files
ClosedPublic