From 92ccf70ad448eb02f9f273d2c70ae4708b3bd0f2 Mon Sep 17 00:00:00 2001 From: Daniel Dunbar Date: Sat, 25 Jul 2009 06:02:13 +0000 Subject: [PATCH] Finish migrating VMCore to StringRef/Twine based APIs. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@77051 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/GlobalAlias.h | 2 +- include/llvm/GlobalValue.h | 2 +- include/llvm/InlineAsm.h | 14 ++++----- include/llvm/LLVMContext.h | 32 +++++++++---------- include/llvm/Linker.h | 18 +++++------ include/llvm/Module.h | 46 +++++++++++++--------------- include/llvm/TypeSymbolTable.h | 6 ++-- lib/AsmParser/LLParser.cpp | 2 +- lib/Bitcode/Reader/BitcodeReader.cpp | 3 +- lib/Linker/LinkItems.cpp | 6 ++-- lib/Linker/Linker.cpp | 28 ++++++++--------- lib/VMCore/Globals.cpp | 2 +- lib/VMCore/InlineAsm.cpp | 26 ++++++++-------- lib/VMCore/LLVMContext.cpp | 12 +++----- lib/VMCore/Module.cpp | 41 ++++++++++--------------- lib/VMCore/TypeSymbolTable.cpp | 11 ++++--- unittests/VMCore/MetadataTest.cpp | 16 +++++----- 17 files changed, 126 insertions(+), 141 deletions(-) diff --git a/include/llvm/GlobalAlias.h b/include/llvm/GlobalAlias.h index b106116f375..91bd61b8380 100644 --- a/include/llvm/GlobalAlias.h +++ b/include/llvm/GlobalAlias.h @@ -40,7 +40,7 @@ public: } /// GlobalAlias ctor - If a parent module is specified, the alias is /// automatically inserted into the end of the specified module's alias list. - GlobalAlias(const Type *Ty, LinkageTypes Linkage, const std::string &Name = "", + GlobalAlias(const Type *Ty, LinkageTypes Linkage, const Twine &Name = "", Constant* Aliasee = 0, Module *Parent = 0); /// Provide fast operand accessors diff --git a/include/llvm/GlobalValue.h b/include/llvm/GlobalValue.h index d53d49bfec1..7b0de34d9cb 100644 --- a/include/llvm/GlobalValue.h +++ b/include/llvm/GlobalValue.h @@ -90,7 +90,7 @@ public: bool hasSection() const { return !Section.empty(); } const std::string &getSection() const { return Section; } - void setSection(const std::string &S) { Section = S; } + void setSection(const StringRef &S) { Section = S; } /// If the usage is empty (except transitively dead constants), then this /// global value can can be safely deleted since the destructor will diff --git a/include/llvm/InlineAsm.h b/include/llvm/InlineAsm.h index 84292cf19e3..e0d992be7ed 100644 --- a/include/llvm/InlineAsm.h +++ b/include/llvm/InlineAsm.h @@ -32,15 +32,15 @@ class InlineAsm : public Value { std::string AsmString, Constraints; bool HasSideEffects; - InlineAsm(const FunctionType *Ty, const std::string &AsmString, - const std::string &Constraints, bool hasSideEffects); + InlineAsm(const FunctionType *Ty, const StringRef &AsmString, + const StringRef &Constraints, bool hasSideEffects); virtual ~InlineAsm(); public: /// InlineAsm::get - Return the the specified uniqued inline asm string. /// - static InlineAsm *get(const FunctionType *Ty, const std::string &AsmString, - const std::string &Constraints, bool hasSideEffects); + static InlineAsm *get(const FunctionType *Ty, const StringRef &AsmString, + const StringRef &Constraints, bool hasSideEffects); bool hasSideEffects() const { return HasSideEffects; } @@ -61,7 +61,7 @@ public: /// the specified constraint string is legal for the type. This returns true /// if legal, false if not. /// - static bool Verify(const FunctionType *Ty, const std::string &Constraints); + static bool Verify(const FunctionType *Ty, const StringRef &Constraints); // Constraint String Parsing enum ConstraintPrefix { @@ -106,7 +106,7 @@ public: /// Parse - Analyze the specified string (e.g. "=*&{eax}") and fill in the /// fields in this structure. If the constraint string is not understood, /// return true, otherwise return false. - bool Parse(const std::string &Str, + bool Parse(const StringRef &Str, std::vector &ConstraintsSoFar); }; @@ -114,7 +114,7 @@ public: /// constraints and their prefixes. If this returns an empty vector, and if /// the constraint string itself isn't empty, there was an error parsing. static std::vector - ParseConstraints(const std::string &ConstraintString); + ParseConstraints(const StringRef &ConstraintString); /// ParseConstraints - Parse the constraints of this inlineasm object, /// returning them the same way that ParseConstraints(str) does. diff --git a/include/llvm/LLVMContext.h b/include/llvm/LLVMContext.h index 73d88984c1e..ab815957220 100644 --- a/include/llvm/LLVMContext.h +++ b/include/llvm/LLVMContext.h @@ -21,30 +21,31 @@ namespace llvm { -class LLVMContextImpl; +class APFloat; +class APInt; +class ArrayType; class Constant; -class ConstantInt; -class ConstantPointerNull; -class ConstantStruct; class ConstantAggregateZero; class ConstantArray; class ConstantFP; +class ConstantInt; +class ConstantPointerNull; +class ConstantStruct; class ConstantVector; -class UndefValue; +class FunctionType; +class IntegerType; +class LLVMContextImpl; class MDNode; class MDString; -class IntegerType; +class OpaqueType; class PointerType; +class StringRef; class StructType; -class ArrayType; -class VectorType; -class OpaqueType; -class FunctionType; class Type; -class APInt; -class APFloat; -class Value; +class UndefValue; class Use; +class Value; +class VectorType; /// This is an important class for using LLVM in a threaded context. It /// (opaquely) owns and manages the core "global" data of LLVM's core @@ -100,7 +101,7 @@ public: /// of the array by one (you've been warned). However, in some situations /// this is not desired so if AddNull==false then the string is copied without /// null termination. - Constant* getConstantArray(const std::string& Initializer, + Constant* getConstantArray(const StringRef &Initializer, bool AddNull = true); // ConstantExpr accessors @@ -204,8 +205,7 @@ public: MDNode* getMDNode(Value* const* Vals, unsigned NumVals); // MDString accessors - MDString* getMDString(const char *StrBegin, unsigned Length); - MDString* getMDString(const std::string &Str); + MDString* getMDString(const StringRef &Str); // FunctionType accessors FunctionType* getFunctionType(const Type* Result, bool isVarArg); diff --git a/include/llvm/Linker.h b/include/llvm/Linker.h index 2d0c2cd96b7..ec3e17b5415 100644 --- a/include/llvm/Linker.h +++ b/include/llvm/Linker.h @@ -65,8 +65,8 @@ class Linker { /// name \p progname. \p progname will also be used for error messages. /// @brief Construct with empty module Linker( - const std::string& progname, ///< name of tool running linker - const std::string& modulename, ///< name of linker's end-result module + const StringRef& progname, ///< name of tool running linker + const StringRef& modulename, ///< name of linker's end-result module LLVMContext& C, ///< Context for global info unsigned Flags = 0 ///< ControlFlags (one or more |'d together) ); @@ -74,7 +74,7 @@ class Linker { /// Construct the Linker with a previously defined module, \p aModule. Use /// \p progname for the name of the program in error messages. /// @brief Construct with existing module - Linker(const std::string& progname, Module* aModule, unsigned Flags = 0); + Linker(const StringRef& progname, Module* aModule, unsigned Flags = 0); /// Destruct the Linker. /// @brief Destructor @@ -116,7 +116,7 @@ class Linker { /// the Quiet control flag is not set, the error string will have already /// been printed to std::cerr. /// @brief Get the text of the last error that occurred. - const std::string& getLastError() const { return Error; } + const std::string &getLastError() const { return Error; } /// @} /// @name Mutators @@ -214,7 +214,7 @@ class Linker { /// @returns true if an error occurs, false otherwise /// @brief Link one library into the module bool LinkInLibrary ( - const std::string& Library, ///< The library to link in + const StringRef &Library, ///< The library to link in bool& is_native ///< Indicates if lib a native library ); @@ -267,7 +267,7 @@ class Linker { /// will be empty (i.e. sys::Path::isEmpty() will return true). /// @returns A sys::Path to the found library /// @brief Find a library from its short name. - sys::Path FindLib(const std::string &Filename); + sys::Path FindLib(const StringRef &Filename); /// @} /// @name Implementation @@ -277,9 +277,9 @@ class Linker { /// Module it contains (wrapped in an auto_ptr), or 0 if an error occurs. std::auto_ptr LoadObject(const sys::Path& FN); - bool warning(const std::string& message); - bool error(const std::string& message); - void verbose(const std::string& message); + bool warning(const StringRef &message); + bool error(const StringRef &message); + void verbose(const StringRef &message); /// @} /// @name Data diff --git a/include/llvm/Module.h b/include/llvm/Module.h index 7a139cc1e0a..888eac2a69c 100644 --- a/include/llvm/Module.h +++ b/include/llvm/Module.h @@ -131,7 +131,7 @@ private: public: /// The Module constructor. Note that there is no default constructor. You /// must provide a name for the module upon construction. - explicit Module(const std::string &ModuleID, LLVMContext& C); + explicit Module(const StringRef &ModuleID, LLVMContext& C); /// The module destructor. This will dropAllReferences. ~Module(); @@ -146,7 +146,7 @@ public: /// Get the data layout string for the module's target platform. This encodes /// the type sizes and alignments expected by this module. /// @returns the data layout as a string - const std::string& getDataLayout() const { return DataLayout; } + const std::string &getDataLayout() const { return DataLayout; } /// Get the target triple which is a string describing the target host. /// @returns a string containing the target triple. @@ -173,20 +173,20 @@ public: public: /// Set the module identifier. - void setModuleIdentifier(const std::string &ID) { ModuleID = ID; } + void setModuleIdentifier(const StringRef &ID) { ModuleID = ID; } /// Set the data layout - void setDataLayout(const std::string& DL) { DataLayout = DL; } + void setDataLayout(const StringRef &DL) { DataLayout = DL; } /// Set the target triple. - void setTargetTriple(const std::string &T) { TargetTriple = T; } + void setTargetTriple(const StringRef &T) { TargetTriple = T; } /// Set the module-scope inline assembly blocks. - void setModuleInlineAsm(const std::string &Asm) { GlobalScopeAsm = Asm; } + void setModuleInlineAsm(const StringRef &Asm) { GlobalScopeAsm = Asm; } /// Append to the module-scope inline assembly blocks, automatically /// appending a newline to the end. - void appendModuleInlineAsm(const std::string &Asm) { + void appendModuleInlineAsm(const StringRef &Asm) { GlobalScopeAsm += Asm; GlobalScopeAsm += '\n'; } @@ -198,8 +198,7 @@ public: /// getNamedValue - Return the first global value in the module with /// the specified name, of arbitrary type. This method returns null /// if a global with the specified name is not found. - GlobalValue *getNamedValue(const std::string &Name) const; - GlobalValue *getNamedValue(const char *Name) const; + GlobalValue *getNamedValue(const StringRef &Name) const; /// @} /// @name Function Accessors @@ -214,10 +213,10 @@ public: /// the existing function. /// 4. Finally, the function exists but has the wrong prototype: return the /// function with a constantexpr cast to the right prototype. - Constant *getOrInsertFunction(const std::string &Name, const FunctionType *T, + Constant *getOrInsertFunction(const StringRef &Name, const FunctionType *T, AttrListPtr AttributeList); - Constant *getOrInsertFunction(const std::string &Name, const FunctionType *T); + Constant *getOrInsertFunction(const StringRef &Name, const FunctionType *T); /// getOrInsertFunction - Look up the specified function in the module symbol /// table. If it does not exist, add a prototype for the function and return @@ -226,21 +225,20 @@ public: /// named function has a different type. This version of the method takes a /// null terminated list of function arguments, which makes it easier for /// clients to use. - Constant *getOrInsertFunction(const std::string &Name, + Constant *getOrInsertFunction(const StringRef &Name, AttrListPtr AttributeList, const Type *RetTy, ...) END_WITH_NULL; - Constant *getOrInsertFunction(const std::string &Name, const Type *RetTy, ...) + Constant *getOrInsertFunction(const StringRef &Name, const Type *RetTy, ...) END_WITH_NULL; - Constant *getOrInsertTargetIntrinsic(const std::string &Name, + Constant *getOrInsertTargetIntrinsic(const StringRef &Name, const FunctionType *Ty, AttrListPtr AttributeList); /// getFunction - Look up the specified function in the module symbol table. /// If it does not exist, return null. - Function *getFunction(const std::string &Name) const; - Function *getFunction(const char *Name) const; + Function *getFunction(const StringRef &Name) const; /// @} /// @name Global Variable Accessors @@ -250,13 +248,13 @@ public: /// symbol table. If it does not exist, return null. If AllowInternal is set /// to true, this function will return types that have InternalLinkage. By /// default, these types are not returned. - GlobalVariable *getGlobalVariable(const std::string &Name, + GlobalVariable *getGlobalVariable(const StringRef &Name, bool AllowInternal = false) const; /// getNamedGlobal - Return the first global variable in the module with the /// specified name, of arbitrary type. This method returns null if a global /// with the specified name is not found. - GlobalVariable *getNamedGlobal(const std::string &Name) const { + GlobalVariable *getNamedGlobal(const StringRef &Name) const { return getGlobalVariable(Name, true); } @@ -267,7 +265,7 @@ public: /// with a constantexpr cast to the right type. /// 3. Finally, if the existing global is the correct delclaration, return /// the existing global. - Constant *getOrInsertGlobal(const std::string &Name, const Type *Ty); + Constant *getOrInsertGlobal(const StringRef &Name, const Type *Ty); /// @} /// @name Global Alias Accessors @@ -276,7 +274,7 @@ public: /// getNamedAlias - Return the first global alias in the module with the /// specified name, of arbitrary type. This method returns null if a global /// with the specified name is not found. - GlobalAlias *getNamedAlias(const std::string &Name) const; + GlobalAlias *getNamedAlias(const StringRef &Name) const; /// @} /// @name Type Accessors @@ -285,7 +283,7 @@ public: /// addTypeName - Insert an entry in the symbol table mapping Str to Type. If /// there is already an entry for this name, true is returned and the symbol /// table is not modified. - bool addTypeName(const std::string &Name, const Type *Ty); + bool addTypeName(const StringRef &Name, const Type *Ty); /// getTypeName - If there is at least one entry in the symbol table for the /// specified type, return it. @@ -293,7 +291,7 @@ public: /// getTypeByName - Return the type with the specified name in this module, or /// null if there is none by that name. - const Type *getTypeByName(const std::string &Name) const; + const Type *getTypeByName(const StringRef &Name) const; /// @} /// @name Direct access to the globals list, functions list, and symbol table @@ -372,9 +370,9 @@ public: /// @brief Returns the number of items in the list of libraries. inline size_t lib_size() const { return LibraryList.size(); } /// @brief Add a library to the list of dependent libraries - void addLibrary(const std::string& Lib); + void addLibrary(const StringRef &Lib); /// @brief Remove a library from the list of dependent libraries - void removeLibrary(const std::string& Lib); + void removeLibrary(const StringRef &Lib); /// @brief Get all the libraries inline const LibraryListType& getLibraries() const { return LibraryList; } diff --git a/include/llvm/TypeSymbolTable.h b/include/llvm/TypeSymbolTable.h index e1459b05794..d2d909587a8 100644 --- a/include/llvm/TypeSymbolTable.h +++ b/include/llvm/TypeSymbolTable.h @@ -55,14 +55,14 @@ public: /// incrementing an integer and appending it to the name, if necessary /// @returns the unique name /// @brief Get a unique name for a type - std::string getUniqueName(const std::string &BaseName) const; + std::string getUniqueName(const StringRef &BaseName) const; /// This method finds the type with the given \p name in the type map /// and returns it. /// @returns null if the name is not found, otherwise the Type /// associated with the \p name. /// @brief Lookup a type by name. - Type* lookup(const std::string& name) const; + Type *lookup(const StringRef &name) const; /// @returns true iff the symbol table is empty. /// @brief Determine if the symbol table is empty @@ -102,7 +102,7 @@ public: /// a many-to-one mapping between names and types. This method allows a type /// with an existing entry in the symbol table to get a new name. /// @brief Insert a type under a new name. - void insert(const std::string &Name, const Type *Typ); + void insert(const StringRef &Name, const Type *Typ); /// Remove a type at the specified position in the symbol table. /// @returns the removed Type. diff --git a/lib/AsmParser/LLParser.cpp b/lib/AsmParser/LLParser.cpp index 60fc8ade7ac..00db4debda0 100644 --- a/lib/AsmParser/LLParser.cpp +++ b/lib/AsmParser/LLParser.cpp @@ -373,7 +373,7 @@ bool LLParser::ParseNamedGlobal() { bool LLParser::ParseMDString(MetadataBase *&MDS) { std::string Str; if (ParseStringConstant(Str)) return true; - MDS = Context.getMDString(Str.data(), Str.size()); + MDS = Context.getMDString(Str); return false; } diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp index dadfb9ebbce..7a224025532 100644 --- a/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/lib/Bitcode/Reader/BitcodeReader.cpp @@ -757,8 +757,7 @@ bool BitcodeReader::ParseMetadata() { String.resize(MDStringLength); for (unsigned i = 0; i != MDStringLength; ++i) String[i] = Record[i]; - Value *V = - Context.getMDString(String.c_str(), MDStringLength); + Value *V = Context.getMDString(StringRef(String.data(), String.size())); ValueList.AssignValue(V, NextValueNo++); break; } diff --git a/lib/Linker/LinkItems.cpp b/lib/Linker/LinkItems.cpp index db86005876e..3c9a8571480 100644 --- a/lib/Linker/LinkItems.cpp +++ b/lib/Linker/LinkItems.cpp @@ -70,12 +70,12 @@ Linker::LinkInItems(const ItemList& Items, ItemList& NativeItems) { /// LinkInLibrary - links one library into the HeadModule. /// -bool Linker::LinkInLibrary(const std::string& Lib, bool& is_native) { +bool Linker::LinkInLibrary(const StringRef &Lib, bool& is_native) { is_native = false; // Determine where this library lives. sys::Path Pathname = FindLib(Lib); if (Pathname.isEmpty()) - return error("Cannot find library '" + Lib + "'"); + return error("Cannot find library '" + Lib.str() + "'"); // If its an archive, try to link it in std::string Magic; @@ -83,7 +83,7 @@ bool Linker::LinkInLibrary(const std::string& Lib, bool& is_native) { switch (sys::IdentifyFileType(Magic.c_str(), 64)) { default: llvm_unreachable("Bad file type identification"); case sys::Unknown_FileType: - return warning("Supposed library '" + Lib + "' isn't a library."); + return warning("Supposed library '" + Lib.str() + "' isn't a library."); case sys::Bitcode_FileType: // LLVM ".so" file. diff --git a/lib/Linker/Linker.cpp b/lib/Linker/Linker.cpp index 6e0b760b85d..bd569b50653 100644 --- a/lib/Linker/Linker.cpp +++ b/lib/Linker/Linker.cpp @@ -16,10 +16,10 @@ #include "llvm/Bitcode/ReaderWriter.h" #include "llvm/Config/config.h" #include "llvm/Support/MemoryBuffer.h" -#include "llvm/Support/Streams.h" +#include "llvm/Support/raw_ostream.h" using namespace llvm; -Linker::Linker(const std::string& progname, const std::string& modname, +Linker::Linker(const StringRef &progname, const StringRef &modname, LLVMContext& C, unsigned flags): Context(C), Composite(new Module(modname, C)), @@ -28,7 +28,7 @@ Linker::Linker(const std::string& progname, const std::string& modname, Error(), ProgramName(progname) { } -Linker::Linker(const std::string& progname, Module* aModule, unsigned flags) : +Linker::Linker(const StringRef &progname, Module* aModule, unsigned flags) : Context(aModule->getContext()), Composite(aModule), LibPaths(), @@ -41,25 +41,25 @@ Linker::~Linker() { } bool -Linker::error(const std::string& message) { +Linker::error(const StringRef &message) { Error = message; if (!(Flags&QuietErrors)) - cerr << ProgramName << ": error: " << message << "\n"; + errs() << ProgramName << ": error: " << message << "\n"; return true; } bool -Linker::warning(const std::string& message) { +Linker::warning(const StringRef &message) { Error = message; if (!(Flags&QuietWarnings)) - cerr << ProgramName << ": warning: " << message << "\n"; + errs() << ProgramName << ": warning: " << message << "\n"; return false; } void -Linker::verbose(const std::string& message) { +Linker::verbose(const StringRef &message) { if (Flags&Verbose) - cerr << " " << message << "\n"; + errs() << " " << message << "\n"; } void @@ -117,13 +117,13 @@ Linker::LoadObject(const sys::Path &FN) { // IsLibrary - Determine if "Name" is a library in "Directory". Return // a non-empty sys::Path if its found, an empty one otherwise. -static inline sys::Path IsLibrary(const std::string& Name, - const sys::Path& Directory) { +static inline sys::Path IsLibrary(const StringRef &Name, + const sys::Path &Directory) { sys::Path FullPath(Directory); // Try the libX.a form - FullPath.appendComponent("lib" + Name); + FullPath.appendComponent(("lib" + Name).str()); FullPath.appendSuffix("a"); if (FullPath.isArchive()) return FullPath; @@ -156,7 +156,7 @@ static inline sys::Path IsLibrary(const std::string& Name, /// Path if no matching file can be found. /// sys::Path -Linker::FindLib(const std::string &Filename) { +Linker::FindLib(const StringRef &Filename) { // Determine if the pathname can be found as it stands. sys::Path FilePath(Filename); if (FilePath.canRead() && @@ -167,7 +167,7 @@ Linker::FindLib(const std::string &Filename) { // there. for (unsigned Index = 0; Index != LibPaths.size(); ++Index) { sys::Path Directory(LibPaths[Index]); - sys::Path FullPath = IsLibrary(Filename,Directory); + sys::Path FullPath = IsLibrary(Filename, Directory); if (!FullPath.isEmpty()) return FullPath; } diff --git a/lib/VMCore/Globals.cpp b/lib/VMCore/Globals.cpp index aa4c30aab08..e01dedd597b 100644 --- a/lib/VMCore/Globals.cpp +++ b/lib/VMCore/Globals.cpp @@ -187,7 +187,7 @@ void GlobalVariable::copyAttributesFrom(const GlobalValue *Src) { //===----------------------------------------------------------------------===// GlobalAlias::GlobalAlias(const Type *Ty, LinkageTypes Link, - const std::string &Name, Constant* aliasee, + const Twine &Name, Constant* aliasee, Module *ParentModule) : GlobalValue(Ty, Value::GlobalAliasVal, &Op<0>(), 1, Link, Name) { LeakDetector::addGarbageObject(this); diff --git a/lib/VMCore/InlineAsm.cpp b/lib/VMCore/InlineAsm.cpp index 524e294ab75..485092e6ffb 100644 --- a/lib/VMCore/InlineAsm.cpp +++ b/lib/VMCore/InlineAsm.cpp @@ -26,14 +26,14 @@ InlineAsm::~InlineAsm() { // NOTE: when memoizing the function type, we have to be careful to handle the // case when the type gets refined. -InlineAsm *InlineAsm::get(const FunctionType *Ty, const std::string &AsmString, - const std::string &Constraints, bool hasSideEffects) { +InlineAsm *InlineAsm::get(const FunctionType *Ty, const StringRef &AsmString, + const StringRef &Constraints, bool hasSideEffects) { // FIXME: memoize! return new InlineAsm(Ty, AsmString, Constraints, hasSideEffects); } -InlineAsm::InlineAsm(const FunctionType *Ty, const std::string &asmString, - const std::string &constraints, bool hasSideEffects) +InlineAsm::InlineAsm(const FunctionType *Ty, const StringRef &asmString, + const StringRef &constraints, bool hasSideEffects) : Value(PointerType::getUnqual(Ty), Value::InlineAsmVal), AsmString(asmString), @@ -50,9 +50,9 @@ const FunctionType *InlineAsm::getFunctionType() const { /// Parse - Analyze the specified string (e.g. "==&{eax}") and fill in the /// fields in this structure. If the constraint string is not understood, /// return true, otherwise return false. -bool InlineAsm::ConstraintInfo::Parse(const std::string &Str, +bool InlineAsm::ConstraintInfo::Parse(const StringRef &Str, std::vector &ConstraintsSoFar) { - std::string::const_iterator I = Str.begin(), E = Str.end(); + StringRef::iterator I = Str.begin(), E = Str.end(); // Initialize Type = isInput; @@ -111,13 +111,13 @@ bool InlineAsm::ConstraintInfo::Parse(const std::string &Str, while (I != E) { if (*I == '{') { // Physical register reference. // Find the end of the register name. - std::string::const_iterator ConstraintEnd = std::find(I+1, E, '}'); + StringRef::iterator ConstraintEnd = std::find(I+1, E, '}'); if (ConstraintEnd == E) return true; // "{foo" Codes.push_back(std::string(I, ConstraintEnd+1)); I = ConstraintEnd+1; } else if (isdigit(*I)) { // Matching Constraint // Maximal munch numbers. - std::string::const_iterator NumStart = I; + StringRef::iterator NumStart = I; while (I != E && isdigit(*I)) ++I; Codes.push_back(std::string(NumStart, I)); @@ -145,16 +145,16 @@ bool InlineAsm::ConstraintInfo::Parse(const std::string &Str, } std::vector -InlineAsm::ParseConstraints(const std::string &Constraints) { +InlineAsm::ParseConstraints(const StringRef &Constraints) { std::vector Result; // Scan the constraints string. - for (std::string::const_iterator I = Constraints.begin(), - E = Constraints.end(); I != E; ) { + for (StringRef::iterator I = Constraints.begin(), + E = Constraints.end(); I != E; ) { ConstraintInfo Info; // Find the end of this constraint. - std::string::const_iterator ConstraintEnd = std::find(I, E, ','); + StringRef::iterator ConstraintEnd = std::find(I, E, ','); if (ConstraintEnd == I || // Empty constraint like ",," Info.Parse(std::string(I, ConstraintEnd), Result)) { @@ -179,7 +179,7 @@ InlineAsm::ParseConstraints(const std::string &Constraints) { /// Verify - Verify that the specified constraint string is reasonable for the /// specified function type, and otherwise validate the constraint string. -bool InlineAsm::Verify(const FunctionType *Ty, const std::string &ConstStr) { +bool InlineAsm::Verify(const FunctionType *Ty, const StringRef &ConstStr) { if (Ty->isVarArg()) return false; std::vector Constraints = ParseConstraints(ConstStr); diff --git a/lib/VMCore/LLVMContext.cpp b/lib/VMCore/LLVMContext.cpp index db81c61ace0..3ee029d4c31 100644 --- a/lib/VMCore/LLVMContext.cpp +++ b/lib/VMCore/LLVMContext.cpp @@ -145,10 +145,10 @@ Constant* LLVMContext::getConstantArray(const ArrayType* T, /// Otherwise, the length parameter specifies how much of the string to use /// and it won't be null terminated. /// -Constant* LLVMContext::getConstantArray(const std::string& Str, +Constant* LLVMContext::getConstantArray(const StringRef &Str, bool AddNull) { std::vector ElementVals; - for (unsigned i = 0; i < Str.length(); ++i) + for (unsigned i = 0; i < Str.size(); ++i) ElementVals.push_back(ConstantInt::get(Type::Int8Ty, Str[i])); // Add a null terminator to the string... @@ -506,12 +506,8 @@ MDNode* LLVMContext::getMDNode(Value* const* Vals, unsigned NumVals) { } // MDString accessors -MDString* LLVMContext::getMDString(const char *StrBegin, unsigned StrLength) { - return pImpl->getMDString(StrBegin, StrLength); -} - -MDString* LLVMContext::getMDString(const std::string &Str) { - return getMDString(Str.data(), Str.size()); +MDString* LLVMContext::getMDString(const StringRef &Str) { + return pImpl->getMDString(Str.data(), Str.size()); } // FunctionType accessors diff --git a/lib/VMCore/Module.cpp b/lib/VMCore/Module.cpp index 9e6e31a9b9e..35db8d25b5b 100644 --- a/lib/VMCore/Module.cpp +++ b/lib/VMCore/Module.cpp @@ -55,7 +55,7 @@ template class SymbolTableListTraits; // Primitive Module methods. // -Module::Module(const std::string &MID, LLVMContext& C) +Module::Module(const StringRef &MID, LLVMContext& C) : Context(C), ModuleID(MID), DataLayout("") { ValSymTab = new ValueSymbolTable(); TypeSymTab = new TypeSymbolTable(); @@ -113,15 +113,10 @@ Module::PointerSize Module::getPointerSize() const { /// getNamedValue - Return the first global value in the module with /// the specified name, of arbitrary type. This method returns null /// if a global with the specified name is not found. -GlobalValue *Module::getNamedValue(const std::string &Name) const { +GlobalValue *Module::getNamedValue(const StringRef &Name) const { return cast_or_null(getValueSymbolTable().lookup(Name)); } -GlobalValue *Module::getNamedValue(const char *Name) const { - llvm::Value *V = getValueSymbolTable().lookup(Name); - return cast_or_null(V); -} - //===----------------------------------------------------------------------===// // Methods for easy access to the functions in the module. // @@ -131,7 +126,7 @@ GlobalValue *Module::getNamedValue(const char *Name) const { // it. This is nice because it allows most passes to get away with not handling // the symbol table directly for this common task. // -Constant *Module::getOrInsertFunction(const std::string &Name, +Constant *Module::getOrInsertFunction(const StringRef &Name, const FunctionType *Ty, AttrListPtr AttributeList) { // See if we have a definition for the specified function already. @@ -151,7 +146,7 @@ Constant *Module::getOrInsertFunction(const std::string &Name, F->setName(""); // Retry, now there won't be a conflict. Constant *NewF = getOrInsertFunction(Name, Ty); - F->setName(&Name[0], Name.size()); + F->setName(Name); return NewF; } @@ -164,7 +159,7 @@ Constant *Module::getOrInsertFunction(const std::string &Name, return F; } -Constant *Module::getOrInsertTargetIntrinsic(const std::string &Name, +Constant *Module::getOrInsertTargetIntrinsic(const StringRef &Name, const FunctionType *Ty, AttrListPtr AttributeList) { // See if we have a definition for the specified function already. @@ -181,7 +176,7 @@ Constant *Module::getOrInsertTargetIntrinsic(const std::string &Name, return F; } -Constant *Module::getOrInsertFunction(const std::string &Name, +Constant *Module::getOrInsertFunction(const StringRef &Name, const FunctionType *Ty) { AttrListPtr AttributeList = AttrListPtr::get((AttributeWithIndex *)0, 0); return getOrInsertFunction(Name, Ty, AttributeList); @@ -192,7 +187,7 @@ Constant *Module::getOrInsertFunction(const std::string &Name, // This version of the method takes a null terminated list of function // arguments, which makes it easier for clients to use. // -Constant *Module::getOrInsertFunction(const std::string &Name, +Constant *Module::getOrInsertFunction(const StringRef &Name, AttrListPtr AttributeList, const Type *RetTy, ...) { va_list Args; @@ -211,7 +206,7 @@ Constant *Module::getOrInsertFunction(const std::string &Name, AttributeList); } -Constant *Module::getOrInsertFunction(const std::string &Name, +Constant *Module::getOrInsertFunction(const StringRef &Name, const Type *RetTy, ...) { va_list Args; va_start(Args, RetTy); @@ -232,11 +227,7 @@ Constant *Module::getOrInsertFunction(const std::string &Name, // getFunction - Look up the specified function in the module symbol table. // If it does not exist, return null. // -Function *Module::getFunction(const std::string &Name) const { - return dyn_cast_or_null(getNamedValue(Name)); -} - -Function *Module::getFunction(const char *Name) const { +Function *Module::getFunction(const StringRef &Name) const { return dyn_cast_or_null(getNamedValue(Name)); } @@ -251,7 +242,7 @@ Function *Module::getFunction(const char *Name) const { /// If AllowLocal is set to true, this function will return types that /// have an local. By default, these types are not returned. /// -GlobalVariable *Module::getGlobalVariable(const std::string &Name, +GlobalVariable *Module::getGlobalVariable(const StringRef &Name, bool AllowLocal) const { if (GlobalVariable *Result = dyn_cast_or_null(getNamedValue(Name))) @@ -266,7 +257,7 @@ GlobalVariable *Module::getGlobalVariable(const std::string &Name, /// with a constantexpr cast to the right type. /// 3. Finally, if the existing global is the correct delclaration, return the /// existing global. -Constant *Module::getOrInsertGlobal(const std::string &Name, const Type *Ty) { +Constant *Module::getOrInsertGlobal(const StringRef &Name, const Type *Ty) { // See if we have a definition for the specified global already. GlobalVariable *GV = dyn_cast_or_null(getNamedValue(Name)); if (GV == 0) { @@ -293,7 +284,7 @@ Constant *Module::getOrInsertGlobal(const std::string &Name, const Type *Ty) { // getNamedAlias - Look up the specified global in the module symbol table. // If it does not exist, return null. // -GlobalAlias *Module::getNamedAlias(const std::string &Name) const { +GlobalAlias *Module::getNamedAlias(const StringRef &Name) const { return dyn_cast_or_null(getNamedValue(Name)); } @@ -306,7 +297,7 @@ GlobalAlias *Module::getNamedAlias(const std::string &Name) const { // there is already an entry for this name, true is returned and the symbol // table is not modified. // -bool Module::addTypeName(const std::string &Name, const Type *Ty) { +bool Module::addTypeName(const StringRef &Name, const Type *Ty) { TypeSymbolTable &ST = getTypeSymbolTable(); if (ST.lookup(Name)) return true; // Already in symtab... @@ -320,7 +311,7 @@ bool Module::addTypeName(const std::string &Name, const Type *Ty) { /// getTypeByName - Return the type with the specified name in this module, or /// null if there is none by that name. -const Type *Module::getTypeByName(const std::string &Name) const { +const Type *Module::getTypeByName(const StringRef &Name) const { const TypeSymbolTable &ST = getTypeSymbolTable(); return cast_or_null(ST.lookup(Name)); } @@ -366,14 +357,14 @@ void Module::dropAllReferences() { I->dropAllReferences(); } -void Module::addLibrary(const std::string& Lib) { +void Module::addLibrary(const StringRef& Lib) { for (Module::lib_iterator I = lib_begin(), E = lib_end(); I != E; ++I) if (*I == Lib) return; LibraryList.push_back(Lib); } -void Module::removeLibrary(const std::string& Lib) { +void Module::removeLibrary(const StringRef& Lib) { LibraryListType::iterator I = LibraryList.begin(); LibraryListType::iterator E = LibraryList.end(); for (;I != E; ++I) diff --git a/lib/VMCore/TypeSymbolTable.cpp b/lib/VMCore/TypeSymbolTable.cpp index 54da8099634..e9c62559332 100644 --- a/lib/VMCore/TypeSymbolTable.cpp +++ b/lib/VMCore/TypeSymbolTable.cpp @@ -14,6 +14,7 @@ #include "llvm/TypeSymbolTable.h" #include "llvm/DerivedTypes.h" #include "llvm/ADT/StringExtras.h" +#include "llvm/ADT/StringRef.h" #include "llvm/Support/ManagedStatic.h" #include "llvm/Support/Streams.h" #include "llvm/System/RWMutex.h" @@ -34,7 +35,7 @@ TypeSymbolTable::~TypeSymbolTable() { } } -std::string TypeSymbolTable::getUniqueName(const std::string &BaseName) const { +std::string TypeSymbolTable::getUniqueName(const StringRef &BaseName) const { std::string TryName = BaseName; sys::SmartScopedReader Reader(*TypeSymbolTableLock); @@ -43,12 +44,12 @@ std::string TypeSymbolTable::getUniqueName(const std::string &BaseName) const { // See if the name exists while (tmap.find(TryName) != End) // Loop until we find a free - TryName = BaseName + utostr(++LastUnique); // name in the symbol table + TryName = BaseName.str() + utostr(++LastUnique); // name in the symbol table return TryName; } // lookup a type by name - returns null on failure -Type* TypeSymbolTable::lookup(const std::string& Name) const { +Type* TypeSymbolTable::lookup(const StringRef &Name) const { sys::SmartScopedReader Reader(*TypeSymbolTableLock); const_iterator TI = tmap.find(Name); @@ -90,12 +91,12 @@ Type* TypeSymbolTable::remove(iterator Entry) { // insert - Insert a type into the symbol table with the specified name... -void TypeSymbolTable::insert(const std::string& Name, const Type* T) { +void TypeSymbolTable::insert(const StringRef &Name, const Type* T) { assert(T && "Can't insert null type into symbol table!"); TypeSymbolTableLock->writer_acquire(); - if (tmap.insert(make_pair(Name, T)).second) { + if (tmap.insert(std::make_pair(Name, T)).second) { // Type inserted fine with no conflict. #if DEBUG_SYMBOL_TABLE diff --git a/unittests/VMCore/MetadataTest.cpp b/unittests/VMCore/MetadataTest.cpp index 5da1328803f..560a31d4ab6 100644 --- a/unittests/VMCore/MetadataTest.cpp +++ b/unittests/VMCore/MetadataTest.cpp @@ -23,9 +23,9 @@ namespace { // MDString objects, even with the same string pointer and nulls in the string. TEST(MDStringTest, CreateDifferent) { char x[3] = { 'f', 0, 'A' }; - MDString *s1 = getGlobalContext().getMDString(&x[0], 3); + MDString *s1 = getGlobalContext().getMDString(StringRef(&x[0], 3)); x[2] = 'B'; - MDString *s2 = getGlobalContext().getMDString(&x[0], 3); + MDString *s2 = getGlobalContext().getMDString(StringRef(&x[0], 3)); EXPECT_NE(s1, s2); } @@ -35,8 +35,8 @@ TEST(MDStringTest, CreateSame) { char x[4] = { 'a', 'b', 'c', 'X' }; char y[4] = { 'a', 'b', 'c', 'Y' }; - MDString *s1 = getGlobalContext().getMDString(&x[0], 3); - MDString *s2 = getGlobalContext().getMDString(&y[0], 3); + MDString *s1 = getGlobalContext().getMDString(StringRef(&x[0], 3)); + MDString *s2 = getGlobalContext().getMDString(StringRef(&y[0], 3)); EXPECT_EQ(s1, s2); } @@ -44,7 +44,7 @@ TEST(MDStringTest, CreateSame) { TEST(MDStringTest, PrintingSimple) { char *str = new char[13]; strncpy(str, "testing 1 2 3", 13); - MDString *s = getGlobalContext().getMDString(str, 13); + MDString *s = getGlobalContext().getMDString(StringRef(str, 13)); strncpy(str, "aaaaaaaaaaaaa", 13); delete[] str; @@ -56,7 +56,7 @@ TEST(MDStringTest, PrintingSimple) { // Test printing of MDString with non-printable characters. TEST(MDStringTest, PrintingComplex) { char str[5] = {0, '\n', '"', '\\', -1}; - MDString *s = getGlobalContext().getMDString(str+0, 5); + MDString *s = getGlobalContext().getMDString(StringRef(str+0, 5)); std::ostringstream oss; s->print(oss); EXPECT_STREQ("metadata !\"\\00\\0A\\22\\5C\\FF\"", oss.str().c_str()); @@ -67,8 +67,8 @@ TEST(MDNodeTest, Simple) { char x[3] = { 'a', 'b', 'c' }; char y[3] = { '1', '2', '3' }; - MDString *s1 = getGlobalContext().getMDString(&x[0], 3); - MDString *s2 = getGlobalContext().getMDString(&y[0], 3); + MDString *s1 = getGlobalContext().getMDString(StringRef(&x[0], 3)); + MDString *s2 = getGlobalContext().getMDString(StringRef(&y[0], 3)); ConstantInt *CI = ConstantInt::get(getGlobalContext(), APInt(8, 0)); std::vector V; -- 2.34.1