Update mclinker for LLVM rebase to r222494. This corresponds to the following upstream mclinker change: commit b2f1691276052c4215abf36715d43248d6337cf8 Author: Diana Chen <[email protected]> Date: Tue Nov 25 14:03:29 2014 +0800 option: Allow `-hash-style' can be specified zero or more times Change-Id: I332546680bb45cf9692adfa2c2d3dcdc84361afc
diff --git a/include/mcld/Support/Allocators.h b/include/mcld/Support/Allocators.h index bb95bd6..c66b77e 100644 --- a/include/mcld/Support/Allocators.h +++ b/include/mcld/Support/Allocators.h
@@ -1,4 +1,4 @@ -//===- Allocators.h ---------------------------------------------------------===// +//===- Allocators.h -------------------------------------------------------===// // // The MCLinker Project // @@ -6,10 +6,10 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_ALLOCATORS_H -#define MCLD_SUPPORT_ALLOCATORS_H -#include <mcld/ADT/Uncopyable.h> -#include <mcld/ADT/TypeTraits.h> +#ifndef MCLD_SUPPORT_ALLOCATORS_H_ +#define MCLD_SUPPORT_ALLOCATORS_H_ +#include "mcld/ADT/TypeTraits.h" +#include "mcld/Support/Compiler.h" #include <cstddef> #include <cstdlib> @@ -21,44 +21,39 @@ * * @see LinearAllocator */ -template<typename DataType, size_t ChunkSize> -class Chunk -{ -public: +template <typename DataType, size_t ChunkSize> +class Chunk { + public: typedef DataType value_type; -public: - Chunk() - : next(0), bound(0) - { } + + public: + Chunk() : next(NULL), bound(0) {} static size_t size() { return ChunkSize; } - static void construct(value_type* pPtr) - { new (pPtr) value_type(); } + static void construct(value_type* pPtr) { new (pPtr) value_type(); } - static void construct(value_type* pPtr, const value_type& pValue) - { new (pPtr) value_type(pValue); } + static void construct(value_type* pPtr, const value_type& pValue) { + new (pPtr) value_type(pValue); + } - static void destroy(value_type* pPtr) - { } + static void destroy(value_type* pPtr) {} -public: + public: Chunk* next; size_t bound; DataType data[ChunkSize]; }; -template<typename DataType> -class Chunk<DataType, 0> -{ -public: +template <typename DataType> +class Chunk<DataType, 0> { + public: typedef DataType value_type; -public: - Chunk() - : next(0), bound(0) { - if (0 != m_Size) - data = (DataType*)malloc(sizeof(DataType)*m_Size); + public: + Chunk() : next(NULL), bound(0) { + if (m_Size != 0) + data = reinterpret_cast<DataType*>(malloc(sizeof(DataType) * m_Size)); else data = 0; } @@ -72,79 +67,69 @@ static void setSize(size_t pSize) { m_Size = pSize; } - static void construct(value_type* pPtr) - { new (pPtr) value_type(); } + static void construct(value_type* pPtr) { new (pPtr) value_type(); } - static void construct(value_type* pPtr, const value_type& pValue) - { new (pPtr) value_type(pValue); } + static void construct(value_type* pPtr, const value_type& pValue) { + new (pPtr) value_type(pValue); + } - static void destroy(value_type* pPtr) - { pPtr->~value_type(); } + static void destroy(value_type* pPtr) { pPtr->~value_type(); } -public: + public: Chunk* next; size_t bound; - DataType *data; + DataType* data; static size_t m_Size; }; -template<typename DataType> +template <typename DataType> size_t Chunk<DataType, 0>::m_Size = 0; -template<typename ChunkType> -class LinearAllocatorBase : private Uncopyable -{ -public: - typedef ChunkType chunk_type; - typedef typename ChunkType::value_type value_type; - typedef typename ChunkType::value_type* pointer; - typedef typename ChunkType::value_type& reference; +template <typename ChunkType> +class LinearAllocatorBase { + public: + typedef ChunkType chunk_type; + typedef typename ChunkType::value_type value_type; + typedef typename ChunkType::value_type* pointer; + typedef typename ChunkType::value_type& reference; typedef const typename ChunkType::value_type* const_pointer; typedef const typename ChunkType::value_type& const_reference; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef unsigned char byte_type; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef unsigned char byte_type; -protected: - LinearAllocatorBase() - : m_pRoot(0), - m_pCurrent(0), - m_AllocatedNum(0) { - } + protected: + LinearAllocatorBase() : m_pRoot(NULL), m_pCurrent(NULL), m_AllocatedNum(0) {} // LinearAllocatorBase does NOT mean to destroy the allocated memory. // If you want a memory allocator to release memory at destruction, please // use GCFactory series. - virtual ~LinearAllocatorBase() - { } + virtual ~LinearAllocatorBase() {} -public: - pointer address(reference X) const - { return &X; } + public: + pointer address(reference X) const { return &X; } - const_pointer address(const_reference X) const - { return &X; } + const_pointer address(const_reference X) const { return &X; } /// standard construct - constructing an object on the location pointed by // pPtr, and using its copy constructor to initialized its value to pValue. // // @param pPtr the address where the object to be constructed // @param pValue the value to be constructed - void construct(pointer pPtr, const_reference pValue) - { chunk_type::construct(pPtr, pValue); } + void construct(pointer pPtr, const_reference pValue) { + chunk_type::construct(pPtr, pValue); + } /// default construct - constructing an object on the location pointed by // pPtr, and using its default constructor to initialized its value to // pValue. // // @param pPtr the address where the object to be constructed - void construct(pointer pPtr) - { chunk_type::construct(pPtr); } + void construct(pointer pPtr) { chunk_type::construct(pPtr); } /// standard destroy - destroy data on arbitrary address // @para pPtr the address where the data to be destruected. - void destroy(pointer pPtr) - { chunk_type::destroy(pPtr); } + void destroy(pointer pPtr) { chunk_type::destroy(pPtr); } /// allocate - allocate N data in order. // - Disallow to allocate a chunk whose size is bigger than a chunk. @@ -152,7 +137,7 @@ // @param N the number of allocated data. // @return the start address of the allocated memory pointer allocate(size_type N) { - if (0 == N || N > chunk_type::size()) + if (N == 0 || N > chunk_type::size()) return 0; if (empty()) @@ -183,10 +168,8 @@ /// deallocate - deallocate N data from the pPtr // - if we can simply release some memory, then do it. Otherwise, do // nothing. - void deallocate(pointer &pPtr, size_type N) { - if (0 == N || - N > chunk_type::size() || - 0 == m_pCurrent->bound || + void deallocate(pointer& pPtr, size_type N) { + if (N == 0 || N > chunk_type::size() || m_pCurrent->bound == 0 || N >= m_pCurrent->bound) return; if (!isAvailable(pPtr)) @@ -196,8 +179,8 @@ } /// deallocate - clone function of deallocating one datum - void deallocate(pointer &pPtr) { - if (0 == m_pCurrent->bound) + void deallocate(pointer& pPtr) { + if (m_pCurrent->bound == 0) return; if (!isAvailable(pPtr)) return; @@ -208,7 +191,7 @@ /// isIn - whether the pPtr is in the current chunk? bool isIn(pointer pPtr) const { if (pPtr >= &(m_pCurrent->data[0]) && - pPtr <= &(m_pCurrent->data[chunk_type::size()-1])) + pPtr <= &(m_pCurrent->data[chunk_type::size() - 1])) return true; return false; } @@ -216,7 +199,7 @@ /// isIn - whether the pPtr is allocated, and can be constructed. bool isAvailable(pointer pPtr) const { if (pPtr >= &(m_pCurrent->data[m_pCurrent->bound]) && - pPtr <= &(m_pCurrent->data[chunk_type::size()-1])) + pPtr <= &(m_pCurrent->data[chunk_type::size() - 1])) return true; return false; } @@ -229,8 +212,8 @@ /// clear - clear all chunks void clear() { - chunk_type *cur = m_pRoot, *prev; - while (0 != cur) { + chunk_type* cur = m_pRoot, *prev; + while (cur != 0) { prev = cur; cur = cur->next; for (unsigned int idx = 0; idx != prev->bound; ++idx) @@ -241,32 +224,32 @@ } // ----- observers ----- // - bool empty() const { - return (0 == m_pRoot); - } + bool empty() const { return (m_pRoot == 0); } - size_type max_size() const - { return m_AllocatedNum; } + size_type max_size() const { return m_AllocatedNum; } -protected: + protected: inline void initialize() { m_pRoot = new chunk_type(); m_pCurrent = m_pRoot; m_AllocatedNum += chunk_type::size(); } - inline chunk_type *getNewChunk() { - chunk_type *result = new chunk_type(); + inline chunk_type* getNewChunk() { + chunk_type* result = new chunk_type(); m_pCurrent->next = result; m_pCurrent = result; m_AllocatedNum += chunk_type::size(); return result; } -protected: - chunk_type *m_pRoot; - chunk_type *m_pCurrent; - size_type m_AllocatedNum; + protected: + chunk_type* m_pRoot; + chunk_type* m_pCurrent; + size_type m_AllocatedNum; + + private: + DISALLOW_COPY_AND_ASSIGN(LinearAllocatorBase); }; /** \class LinearAllocator @@ -285,167 +268,145 @@ * template argument DataType is the DataType to be allocated * template argument ChunkSize is the number of bytes of a chunk */ -template<typename DataType, size_t ChunkSize> -class LinearAllocator : public LinearAllocatorBase<Chunk<DataType, ChunkSize> > -{ -public: - template<typename NewDataType> +template <typename DataType, size_t ChunkSize> +class LinearAllocator + : public LinearAllocatorBase<Chunk<DataType, ChunkSize> > { + public: + template <typename NewDataType> struct rebind { typedef LinearAllocator<NewDataType, ChunkSize> other; }; -public: - LinearAllocator() - : LinearAllocatorBase<Chunk<DataType, ChunkSize> >() { - } + public: + LinearAllocator() : LinearAllocatorBase<Chunk<DataType, ChunkSize> >() {} - virtual ~LinearAllocator() - { } + virtual ~LinearAllocator() {} }; -template<typename DataType> -class LinearAllocator<DataType, 0> : public LinearAllocatorBase<Chunk<DataType, 0> > -{ -public: - template<typename NewDataType> +template <typename DataType> +class LinearAllocator<DataType, 0> + : public LinearAllocatorBase<Chunk<DataType, 0> > { + public: + template <typename NewDataType> struct rebind { typedef LinearAllocator<NewDataType, 0> other; }; -public: + public: explicit LinearAllocator(size_t pNum) - : LinearAllocatorBase<Chunk<DataType, 0> >() { + : LinearAllocatorBase<Chunk<DataType, 0> >() { Chunk<DataType, 0>::setSize(pNum); } - virtual ~LinearAllocator() - { } + virtual ~LinearAllocator() {} }; -template<typename DataType> -class MallocAllocator -{ -public: - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef DataType* pointer; +template <typename DataType> +class MallocAllocator { + public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef DataType* pointer; typedef const DataType* const_pointer; - typedef DataType& reference; + typedef DataType& reference; typedef const DataType& const_reference; - typedef DataType value_type; + typedef DataType value_type; - template<typename OtherDataType> - struct rebind - { + template <typename OtherDataType> + struct rebind { typedef MallocAllocator<OtherDataType> other; }; -public: - MallocAllocator() throw() - { } + public: + MallocAllocator() throw() {} - MallocAllocator(const MallocAllocator&) throw() - { } + MallocAllocator(const MallocAllocator&) throw() {} - ~MallocAllocator() throw() - { } + ~MallocAllocator() throw() {} - pointer address(reference X) const - { return &X; } + pointer address(reference X) const { return &X; } - const_pointer address(const_reference X) const - { return &X; } + const_pointer address(const_reference X) const { return &X; } - pointer allocate(size_type pNumOfElements, const void* = 0) - { + pointer allocate(size_type pNumOfElements, const void* = 0) { return static_cast<DataType*>( - std::malloc(pNumOfElements*sizeof(DataType))); + std::malloc(pNumOfElements * sizeof(DataType))); } - void deallocate(pointer pObject, size_type) - { std::free(static_cast<void*>(pObject)); } + void deallocate(pointer pObject, size_type) { + std::free(static_cast<void*>(pObject)); + } - size_type max_size() const throw() - { return size_t(-1) / sizeof(DataType); } + size_type max_size() const throw() { return size_t(-1) / sizeof(DataType); } - void construct(pointer pObject, const DataType& pValue) - { ::new((void *)pObject) value_type(pValue); } + void construct(pointer pObject, const DataType& pValue) { + ::new (reinterpret_cast<void*>(pObject)) value_type(pValue); + } - void destroy(pointer pObject) - { pObject->~DataType(); } - + void destroy(pointer pObject) { pObject->~DataType(); } }; -template<> -class MallocAllocator<void> -{ -public: - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef void* pointer; +template <> +class MallocAllocator<void> { + public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef void* pointer; typedef const void* const_pointer; - typedef void* reference; + typedef void* reference; typedef const void* const_reference; - typedef void* value_type; + typedef void* value_type; - template<typename OtherDataType> - struct rebind - { + template <typename OtherDataType> + struct rebind { typedef MallocAllocator<OtherDataType> other; }; -public: - MallocAllocator() throw() - { } + public: + MallocAllocator() throw() {} - MallocAllocator(const MallocAllocator&) throw() - { } + MallocAllocator(const MallocAllocator&) throw() {} - ~MallocAllocator() throw() - { } + ~MallocAllocator() throw() {} - size_type max_size() const throw() - { return size_t(-1) / sizeof(void*); } + size_type max_size() const throw() { return size_t(-1) / sizeof(void*); } - pointer address(reference X) const - { return X; } + pointer address(reference X) const { return X; } - const_pointer address(const_reference X) const - { return X; } + const_pointer address(const_reference X) const { return X; } - template<typename DataType> + template <typename DataType> DataType* allocate(size_type pNumOfElements, const void* = 0) { return static_cast<DataType*>( - std::malloc(pNumOfElements*sizeof(DataType))); + std::malloc(pNumOfElements * sizeof(DataType))); } pointer allocate(size_type pNumOfElements, const void* = 0) { return std::malloc(pNumOfElements); } - template<typename DataType> - void deallocate(DataType* pObject, size_type) - { std::free(static_cast<void*>(pObject)); } + template <typename DataType> + void deallocate(DataType* pObject, size_type) { + std::free(static_cast<void*>(pObject)); + } - void deallocate(pointer pObject, size_type) - { std::free(pObject); } + void deallocate(pointer pObject, size_type) { std::free(pObject); } - template<typename DataType> - void construct(DataType* pObject, const DataType& pValue) - { /* do nothing */ } + template <typename DataType> + void construct(DataType* pObject, const DataType& pValue) { /* do nothing */ + } - void construct(pointer pObject, const_reference pValue) - { /* do nothing */ } + void construct(pointer pObject, const_reference pValue) { /* do nothing */ + } - template<typename DataType> - void destroy(DataType* pObject) - { /* do nothing */ } + template <typename DataType> + void destroy(DataType* pObject) { /* do nothing */ + } - void destroy(pointer pObject) - { /* do nothing */ } + void destroy(pointer pObject) { /* do nothing */ + } }; -} // namespace mcld +} // namespace mcld -#endif - +#endif // MCLD_SUPPORT_ALLOCATORS_H_
diff --git a/include/mcld/Support/CommandLine.h b/include/mcld/Support/CommandLine.h index 1801354..8c10b91 100644 --- a/include/mcld/Support/CommandLine.h +++ b/include/mcld/Support/CommandLine.h
@@ -6,10 +6,10 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_COMMANDLINE_H -#define MCLD_SUPPORT_COMMANDLINE_H -#include <mcld/Support/FileSystem.h> -#include <mcld/MC/ZOption.h> +#ifndef MCLD_SUPPORT_COMMANDLINE_H_ +#define MCLD_SUPPORT_COMMANDLINE_H_ +#include "mcld/MC/ZOption.h" +#include "mcld/Support/FileSystem.h" #include <llvm/ADT/StringRef.h> #include <llvm/ADT/Triple.h> @@ -23,18 +23,17 @@ //===----------------------------------------------------------------------===// // SearchDirParser //===----------------------------------------------------------------------===// -class SearchDirParser : public llvm::cl::basic_parser<std::string> -{ -public: +class SearchDirParser : public llvm::cl::basic_parser<std::string> { + public: // parse - Return true on error. - bool parse(Option &pOption, + bool parse(Option& pOption, StringRef pArgName, StringRef pArg, - std::string &pValue); + std::string& pValue); - const char *getValueName() const { return "searchdir"; } + const char* getValueName() const { return "searchdir"; } - void printOptionDiff(const Option &pOption, + void printOptionDiff(const Option& pOption, StringRef pValue, OptVal pDefault, size_t pGlobalWidth) const; @@ -45,11 +44,10 @@ //===----------------------------------------------------------------------===// // FalseParser //===----------------------------------------------------------------------===// -class FalseParser : public cl::parser<bool> -{ -public: +class FalseParser : public cl::parser<bool> { + public: // parse - Return true on error. - bool parse(cl::Option &O, StringRef ArgName, StringRef Arg, bool &Val) { + bool parse(cl::Option& O, StringRef ArgName, StringRef Arg, bool& Val) { if (cl::parser<bool>::parse(O, ArgName, Arg, Val)) return false; Val = false; @@ -60,18 +58,17 @@ //===----------------------------------------------------------------------===// // parser<mcld::sys::fs::Path> //===----------------------------------------------------------------------===// -template<> -class parser<mcld::sys::fs::Path> : public basic_parser<mcld::sys::fs::Path> -{ -public: - bool parse(Option &O, +template <> +class parser<mcld::sys::fs::Path> : public basic_parser<mcld::sys::fs::Path> { + public: + bool parse(Option& O, StringRef ArgName, StringRef Arg, - mcld::sys::fs::Path &Val); + mcld::sys::fs::Path& Val); - virtual const char *getValueName() const { return "path"; } - void printOptionDiff(const Option &O, - const mcld::sys::fs::Path &V, + virtual const char* getValueName() const { return "path"; } + void printOptionDiff(const Option& O, + const mcld::sys::fs::Path& V, OptVal Default, size_t GlobalWidth) const; virtual void anchor(); @@ -80,22 +77,20 @@ //===----------------------------------------------------------------------===// // parser<mcld::ZOption> //===----------------------------------------------------------------------===// -template<> -class parser<mcld::ZOption> : public llvm::cl::basic_parser<mcld::ZOption> -{ -public: - bool parse(Option &O, StringRef ArgName, StringRef Arg, mcld::ZOption &Val); +template <> +class parser<mcld::ZOption> : public llvm::cl::basic_parser<mcld::ZOption> { + public: + bool parse(Option& O, StringRef ArgName, StringRef Arg, mcld::ZOption& Val); - virtual const char *getValueName() const { return "z-option"; } - void printOptionDiff(const Option &O, - const mcld::ZOption &V, + virtual const char* getValueName() const { return "z-option"; } + void printOptionDiff(const Option& O, + const mcld::ZOption& V, OptVal Default, size_t GlobalWidth) const; virtual void anchor(); }; -} // namespace of cl -} // namespace of llvm +} // namespace cl +} // namespace llvm -#endif - +#endif // MCLD_SUPPORT_COMMANDLINE_H_
diff --git a/include/mcld/Support/Compiler.h b/include/mcld/Support/Compiler.h new file mode 100644 index 0000000..9a0d738 --- /dev/null +++ b/include/mcld/Support/Compiler.h
@@ -0,0 +1,30 @@ +//===- Compiler.h ---------------------------------------------------------===// +// +// The MCLinker Project +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +#ifndef MCLD_SUPPORT_COMPILER_H_ +#define MCLD_SUPPORT_COMPILER_H_ + +#include <llvm/Support/Compiler.h> + +// DISALLOW_COPY_AND_ASSIGN disallows the copy and operator= functions. It goes +// in the private: declarations in a class. +#define DISALLOW_COPY_AND_ASSIGN(TypeName) \ + TypeName(const TypeName&) = delete; \ + void operator=(const TypeName&) = delete + +// A macro to disallow all the implicit constructors, namely the default +// constructor, copy constructor and operator= functions. +// +// This should be used in the private: declarations for a class that wants to +// prevent anyone from instantiating it. This is especially useful for classes +// containing only static methods. +#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \ + TypeName() = delete; \ + DISALLOW_COPY_AND_ASSIGN(TypeName) + +#endif // MCLD_SUPPORT_COMPILER_H_
diff --git a/include/mcld/Support/Demangle.h b/include/mcld/Support/Demangle.h index b6f7412..6f671b9 100644 --- a/include/mcld/Support/Demangle.h +++ b/include/mcld/Support/Demangle.h
@@ -6,8 +6,8 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_DEMANGLE_H -#define MCLD_SUPPORT_DEMANGLE_H +#ifndef MCLD_SUPPORT_DEMANGLE_H_ +#define MCLD_SUPPORT_DEMANGLE_H_ #include <string> @@ -17,6 +17,6 @@ bool isCtorOrDtor(const char* pName, size_t pLength); -} // namespace mcld +} // namespace mcld -#endif +#endif // MCLD_SUPPORT_DEMANGLE_H_
diff --git a/include/mcld/Support/Directory.h b/include/mcld/Support/Directory.h index 09b7221..00ba531 100644 --- a/include/mcld/Support/Directory.h +++ b/include/mcld/Support/Directory.h
@@ -6,17 +6,17 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_DIRECTORY_H -#define MCLD_SUPPORT_DIRECTORY_H +#ifndef MCLD_SUPPORT_DIRECTORY_H_ +#define MCLD_SUPPORT_DIRECTORY_H_ -#include <mcld/ADT/TypeTraits.h> -#include <mcld/Support/FileSystem.h> -#include <mcld/Support/Path.h> +#include "mcld/ADT/TypeTraits.h" +#include "mcld/Support/FileSystem.h" +#include "mcld/Support/Path.h" +#include "mcld/Support/PathCache.h" + #include <llvm/Support/Allocator.h> #include <cstddef> -#include "PathCache.h" - namespace mcld { namespace sys { namespace fs { @@ -28,18 +28,19 @@ * non-symbolic link status, and a FileStatus object for symbolic link * status. The FileStatus objects act as value caches. */ -class Directory -{ -friend mcld::sys::fs::PathCache::entry_type* detail::bring_one_into_cache(DirIterator& pIter); -friend void detail::open_dir(Directory& pDir); -friend void detail::close_dir(Directory& pDir); -private: +class Directory { + friend mcld::sys::fs::PathCache::entry_type* detail::bring_one_into_cache( + DirIterator& pIter); + friend void detail::open_dir(Directory& pDir); + friend void detail::close_dir(Directory& pDir); + + private: friend class DirIterator; -public: + public: typedef DirIterator iterator; -public: + public: /// default constructor Directory(); @@ -48,6 +49,10 @@ FileStatus st = FileStatus(), FileStatus symlink_st = FileStatus()); + explicit Directory(const char* pPath, + FileStatus st = FileStatus(), + FileStatus symlink_st = FileStatus()); + /// copy constructor /// when a copying construction happens, the cache is not copied. Directory(const Directory& pCopy); @@ -70,8 +75,7 @@ bool isGood() const; /// path - the path of the directory - const Path& path() const - { return m_Path; } + const Path& path() const { return m_Path; } FileStatus status() const; FileStatus symlinkStatus() const; @@ -82,7 +86,7 @@ iterator begin(); iterator end(); -protected: + protected: mcld::sys::fs::Path m_Path; mutable FileStatus m_FileStatus; mutable FileStatus m_SymLinkStatus; @@ -102,28 +106,28 @@ * * @see Directory */ -class DirIterator -{ -friend mcld::sys::fs::PathCache::entry_type* detail::bring_one_into_cache(DirIterator& pIter); -friend class Directory; -public: - typedef mcld::sys::fs::PathCache DirCache; +class DirIterator { + friend mcld::sys::fs::PathCache::entry_type* detail::bring_one_into_cache( + DirIterator& pIter); + friend class Directory; -public: - typedef Directory value_type; - typedef ConstTraits<Directory> const_traits; - typedef NonConstTraits<Directory> non_const_traits; - typedef std::input_iterator_tag iterator_category; - typedef size_t size_type; - typedef ptrdiff_t difference_type; + public: + typedef mcld::sys::fs::PathCache DirCache; -private: - explicit DirIterator(Directory* pParent, - const DirCache::iterator& pIter); + public: + typedef Directory value_type; + typedef ConstTraits<Directory> const_traits; + typedef NonConstTraits<Directory> non_const_traits; + typedef std::input_iterator_tag iterator_category; + typedef size_t size_type; + typedef ptrdiff_t difference_type; -public: + private: + explicit DirIterator(Directory* pParent, const DirCache::iterator& pIter); + + public: // Since StringMapIterator has no default constructor, we also have none. - DirIterator(const DirIterator &X); + DirIterator(const DirIterator& X); ~DirIterator(); DirIterator& operator=(const DirIterator& pCopy); @@ -138,14 +142,14 @@ bool operator==(const DirIterator& y) const; bool operator!=(const DirIterator& y) const; -private: - Directory* m_pParent; // get handler - DirCache::iterator m_Iter; // for full situation + private: + Directory* m_pParent; // get handler + DirCache::iterator m_Iter; // for full situation DirCache::entry_type* m_pEntry; }; -} // namespace of fs -} // namespace of sys -} // namespace of mcld +} // namespace fs +} // namespace sys +} // namespace mcld -#endif +#endif // MCLD_SUPPORT_DIRECTORY_H_
diff --git a/include/mcld/Support/ELF.h b/include/mcld/Support/ELF.h index 321c3c6..d1cdc0c 100644 --- a/include/mcld/Support/ELF.h +++ b/include/mcld/Support/ELF.h
@@ -6,8 +6,8 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_ELF_H -#define MCLD_SUPPORT_ELF_H +#ifndef MCLD_SUPPORT_ELF_H_ +#define MCLD_SUPPORT_ELF_H_ namespace mcld { namespace ELF { @@ -18,17 +18,11 @@ // other sections of the same type. SHF_ORDERED = 0x40000000, - // This section is excluded from input of an executable or shared object. - // Ignore this flag if SHF_ALLOC is also set or if a relocation refers to - // the section - SHF_EXCLUDE = 0x80000000, - // Section with data that is GP relative addressable. SHF_MIPS_GPREL = 0x10000000 -}; // enum SHF +}; // enum SHF -} // namespace of ELF -} // namespace of mcld +} // namespace ELF +} // namespace mcld -#endif - +#endif // MCLD_SUPPORT_ELF_H_
diff --git a/include/mcld/Support/FileHandle.h b/include/mcld/Support/FileHandle.h index ecd335c..96467f1 100644 --- a/include/mcld/Support/FileHandle.h +++ b/include/mcld/Support/FileHandle.h
@@ -6,10 +6,10 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_FILEHANDLE_H -#define MCLD_SUPPORT_FILEHANDLE_H -#include <mcld/Support/Path.h> -#include <mcld/ADT/Flags.h> +#ifndef MCLD_SUPPORT_FILEHANDLE_H_ +#define MCLD_SUPPORT_FILEHANDLE_H_ +#include "mcld/ADT/Flags.h" +#include "mcld/Support/Path.h" #include <errno.h> @@ -22,50 +22,46 @@ * Operators of FileHandle should neither throw exceptions nor call expressive * diagnostic output. */ -class FileHandle -{ -public: - enum IOState - { - GoodBit = 0, // no error - BadBit = 1L << 0, // error due to the inappropriate operation - EOFBit = 1L << 1, // reached End-Of-File - FailBit = 1L << 2, // internal logic fail - DeputedBit = 1L << 3, // the file descriptor is delegated +class FileHandle { + public: + enum IOState { + GoodBit = 0, // no error + BadBit = 1L << 0, // error due to the inappropriate operation + EOFBit = 1L << 1, // reached End-Of-File + FailBit = 1L << 2, // internal logic fail + DeputedBit = 1L << 3, // the file descriptor is delegated IOStateEnd = 1L << 16 }; - enum OpenModeEnum - { - NotOpen = 0x00, - ReadOnly = 0x01, + enum OpenModeEnum { + NotOpen = 0x00, + ReadOnly = 0x01, WriteOnly = 0x02, ReadWrite = ReadOnly | WriteOnly, - Append = 0x04, - Create = 0x08, - Truncate = 0x10, - Unknown = 0xFF + Append = 0x04, + Create = 0x08, + Truncate = 0x10, + Unknown = 0xFF }; typedef Flags<OpenModeEnum> OpenMode; - enum PermissionEnum - { - ReadOwner = 0x0400, - WriteOwner = 0x0200, - ExeOwner = 0x0100, - ReadGroup = 0x0040, - WriteGroup = 0x0020, - ExeGroup = 0x0010, - ReadOther = 0x0004, - WriteOther = 0x0002, - ExeOther = 0x0001, - System = 0xFFFF + enum PermissionEnum { + ReadOwner = 0x0400, + WriteOwner = 0x0200, + ExeOwner = 0x0100, + ReadGroup = 0x0040, + WriteGroup = 0x0020, + ExeGroup = 0x0010, + ReadOther = 0x0004, + WriteOther = 0x0002, + ExeOther = 0x0001, + System = 0xFFFF }; typedef Flags<PermissionEnum> Permission; -public: + public: FileHandle(); ~FileHandle(); @@ -73,11 +69,9 @@ /// open - open the file. /// @return if we meet any trouble during opening the file, return false. /// use rdstate() to see what happens. - bool open(const sys::fs::Path& pPath, - OpenMode pMode, - Permission pPerm = System); + bool open(const sys::fs::Path& pPath, OpenMode pMode, Permission pPerm); - bool delegate(int pFD, OpenMode pMode = Unknown); + bool delegate(int pFD, OpenModeEnum pMode = Unknown); bool close(); @@ -97,17 +91,13 @@ bool munmap(void* pMemBuffer, size_t pLength); // ----- observers ----- // - const sys::fs::Path& path() const - { return m_Path; } + const sys::fs::Path& path() const { return m_Path; } - size_t size() const - { return m_Size; } + size_t size() const { return m_Size; } - int handler() const - { return m_Handler; } + int handler() const { return m_Handler; } - uint16_t rdstate() const - { return m_State; } + uint16_t rdstate() const { return m_State; } bool isOpened() const; @@ -127,7 +117,7 @@ int error() const { return errno; } -private: + private: sys::fs::Path m_Path; int m_Handler; unsigned int m_Size; @@ -135,7 +125,6 @@ OpenMode m_OpenMode; }; -} // namespace of mcld +} // namespace mcld -#endif - +#endif // MCLD_SUPPORT_FILEHANDLE_H_
diff --git a/include/mcld/Support/FileOutputBuffer.h b/include/mcld/Support/FileOutputBuffer.h index 6b48e14..afe670f 100644 --- a/include/mcld/Support/FileOutputBuffer.h +++ b/include/mcld/Support/FileOutputBuffer.h
@@ -6,13 +6,15 @@ // license. see license.txt for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_FILEOUTPUTBUFFER_H -#define MCLD_SUPPORT_FILEOUTPUTBUFFER_H +#ifndef MCLD_SUPPORT_FILEOUTPUTBUFFER_H_ +#define MCLD_SUPPORT_FILEOUTPUTBUFFER_H_ -#include <mcld/Support/MemoryRegion.h> +#include "mcld/Support/MemoryRegion.h" + #include <llvm/ADT/StringRef.h> #include <llvm/Support/DataTypes.h> #include <llvm/Support/FileSystem.h> + #include <system_error> namespace mcld { @@ -22,7 +24,7 @@ /// FileOutputBuffer - This interface is borrowed from llvm bassically, and we /// may use ostream to emit output later. class FileOutputBuffer { -public: + public: /// Factory method to create an OutputBuffer object which manages a read/write /// buffer of the specified size. When committed, the buffer will be written /// to the file at the specified path. @@ -32,18 +34,16 @@ /// Returns a pointer to the start of the buffer. uint8_t* getBufferStart() { - return (uint8_t*)m_pRegion->data(); + return reinterpret_cast<uint8_t*>(m_pRegion->data()); } /// Returns a pointer to the end of the buffer. uint8_t* getBufferEnd() { - return (uint8_t*)m_pRegion->data() + m_pRegion->size(); + return reinterpret_cast<uint8_t*>(m_pRegion->data()) + m_pRegion->size(); } /// Returns size of the buffer. - size_t getBufferSize() const { - return m_pRegion->size(); - } + size_t getBufferSize() const { return m_pRegion->size(); } MemoryRegion request(size_t pOffset, size_t pLength); @@ -52,9 +52,9 @@ ~FileOutputBuffer(); -private: - FileOutputBuffer(const FileOutputBuffer &); - FileOutputBuffer &operator=(const FileOutputBuffer &); + private: + FileOutputBuffer(const FileOutputBuffer&); + FileOutputBuffer& operator=(const FileOutputBuffer&); FileOutputBuffer(llvm::sys::fs::mapped_file_region* pRegion, FileHandle& pFileHandle); @@ -63,6 +63,6 @@ FileHandle& m_FileHandle; }; -} // namespace mcld +} // namespace mcld -#endif +#endif // MCLD_SUPPORT_FILEOUTPUTBUFFER_H_
diff --git a/include/mcld/Support/FileSystem.h b/include/mcld/Support/FileSystem.h index ba4edff..15b33f9 100644 --- a/include/mcld/Support/FileSystem.h +++ b/include/mcld/Support/FileSystem.h
@@ -10,23 +10,22 @@ // filesystem (v3), but modified to remove exception handling and the // path class. //===----------------------------------------------------------------------===// +#ifndef MCLD_SUPPORT_FILESYSTEM_H_ +#define MCLD_SUPPORT_FILESYSTEM_H_ -#ifndef MCLD_SUPPORT_FILESYSTEM_H -#define MCLD_SUPPORT_FILESYSTEM_H - +#include "mcld/Config/Config.h" #include "mcld/Support/PathCache.h" -#include <mcld/Config/Config.h> -#include <string> + #include <iosfwd> #include <locale> +#include <string> namespace mcld { namespace sys { namespace fs { -enum FileType -{ +enum FileType { StatusError, StatusUnknown = StatusError, FileNotFound, @@ -46,19 +45,16 @@ /** \class FileStatus * \brief FileStatus */ -class FileStatus -{ -public: - FileStatus() - : m_Value(StatusError) {} +class FileStatus { + public: + FileStatus() : m_Value(StatusError) {} - explicit FileStatus(FileType v) - : m_Value(v) {} + explicit FileStatus(FileType v) : m_Value(v) {} - void setType(FileType v) { m_Value = v; } - FileType type() const { return m_Value; } + void setType(FileType v) { m_Value = v; } + FileType type() const { return m_Value; } -private: + private: FileType m_Value; }; @@ -66,7 +62,7 @@ return rhs.type() == lhs.type(); } -inline bool operator!=(const FileStatus& rhs, const FileStatus& lhs ) { +inline bool operator!=(const FileStatus& rhs, const FileStatus& lhs) { return !(rhs == lhs); } @@ -74,8 +70,8 @@ class DirIterator; class Directory; -bool exists(const Path &pPath); -bool is_directory(const Path &pPath); +bool exists(const Path& pPath); +bool is_directory(const Path& pPath); namespace detail { @@ -100,14 +96,17 @@ ssize_t pread(int pFD, void* pBuf, size_t pCount, off_t pOffset); ssize_t pwrite(int pFD, const void* pBuf, size_t pCount, off_t pOffset); int ftruncate(int pFD, size_t pLength); -void* mmap(void *pAddr, size_t pLen, - int pProt, int pFlags, int pFD, off_t pOffset); -int munmap(void *pAddr, size_t pLen); +void* mmap(void* pAddr, + size_t pLen, + int pProt, + int pFlags, + int pFD, + off_t pOffset); +int munmap(void* pAddr, size_t pLen); -} // namespace of detail -} // namespace of fs -} // namespace of sys -} // namespace of mcld +} // namespace detail +} // namespace fs +} // namespace sys +} // namespace mcld -#endif - +#endif // MCLD_SUPPORT_FILESYSTEM_H_
diff --git a/include/mcld/Support/GCFactory.h b/include/mcld/Support/GCFactory.h index 452f539..fd86cdd 100644 --- a/include/mcld/Support/GCFactory.h +++ b/include/mcld/Support/GCFactory.h
@@ -6,8 +6,8 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_GCFACTORY_H -#define MCLD_SUPPORT_GCFACTORY_H +#ifndef MCLD_SUPPORT_GCFACTORY_H_ +#define MCLD_SUPPORT_GCFACTORY_H_ #include "mcld/ADT/TypeTraits.h" #include "mcld/Support/Allocators.h" @@ -15,24 +15,21 @@ #include <cstddef> #include <iterator> -namespace mcld -{ +namespace mcld { /** \class DataIteratorBase * \brief DataIteratorBase provides the basic functions of DataIterator * @see DataIterator */ -template<typename ChunkType> -struct DataIteratorBase -{ -public: +template <typename ChunkType> +struct DataIteratorBase { + public: ChunkType* m_pChunk; unsigned int m_Pos; -public: + public: DataIteratorBase(ChunkType* X, unsigned int pPos) - : m_pChunk(X), m_Pos(pPos) - { } + : m_pChunk(X), m_Pos(pPos) {} inline void advance() { ++m_Pos; @@ -44,55 +41,49 @@ } } - bool operator==(const DataIteratorBase& y) const - { return ((this->m_pChunk == y.m_pChunk) && (this->m_Pos == y.m_Pos)); } + bool operator==(const DataIteratorBase& y) const { + return ((this->m_pChunk == y.m_pChunk) && (this->m_Pos == y.m_Pos)); + } - bool operator!=(const DataIteratorBase& y) const - { return ((this->m_pChunk != y.m_pChunk) || (this->m_Pos != y.m_Pos)); } + bool operator!=(const DataIteratorBase& y) const { + return ((this->m_pChunk != y.m_pChunk) || (this->m_Pos != y.m_Pos)); + } }; /** \class DataIterator * \brief DataIterator provides STL compatible iterator for allocators */ -template<typename ChunkType, class Traits> -class DataIterator : public DataIteratorBase<ChunkType> -{ -public: - typedef typename ChunkType::value_type value_type; - typedef Traits traits; - typedef typename traits::pointer pointer; - typedef typename traits::reference reference; +template <typename ChunkType, class Traits> +class DataIterator : public DataIteratorBase<ChunkType> { + public: + typedef typename ChunkType::value_type value_type; + typedef Traits traits; + typedef typename traits::pointer pointer; + typedef typename traits::reference reference; typedef DataIterator<ChunkType, Traits> Self; - typedef DataIteratorBase<ChunkType> Base; + typedef DataIteratorBase<ChunkType> Base; - typedef typename traits::nonconst_traits nonconst_traits; + typedef typename traits::nonconst_traits nonconst_traits; typedef DataIterator<ChunkType, nonconst_traits> iterator; - typedef typename traits::const_traits const_traits; - typedef DataIterator<ChunkType, const_traits> const_iterator; - typedef std::forward_iterator_tag iterator_category; - typedef size_t size_type; - typedef ptrdiff_t difference_type; + typedef typename traits::const_traits const_traits; + typedef DataIterator<ChunkType, const_traits> const_iterator; + typedef std::forward_iterator_tag iterator_category; + typedef size_t size_type; + typedef ptrdiff_t difference_type; -public: - DataIterator() - : Base(0, 0) - { } + public: + DataIterator() : Base(NULL, 0) {} - DataIterator(ChunkType* pChunk, unsigned int pPos) - : Base(pChunk, pPos) - { } + DataIterator(ChunkType* pChunk, unsigned int pPos) : Base(pChunk, pPos) {} - DataIterator(const DataIterator& pCopy) - : Base(pCopy.m_pChunk, pCopy.m_Pos) - { } + DataIterator(const DataIterator& pCopy) : Base(pCopy.m_pChunk, pCopy.m_Pos) {} - ~DataIterator() - { } + ~DataIterator() {} // ----- operators ----- // reference operator*() { - if (0 == this->m_pChunk) - assert(0 && "data iterator goes to a invalid position"); + assert(this->m_pChunk != NULL && + "data iterator goes to a invalid position"); return this->m_pChunk->data[Base::m_Pos]; } @@ -108,39 +99,31 @@ } }; -template<typename Alloc> -class GCFactoryBase : public Alloc -{ -public: +template <typename Alloc> +class GCFactoryBase : public Alloc { + public: typedef DataIterator<typename Alloc::chunk_type, - NonConstTraits< - typename Alloc::value_type> > iterator; + NonConstTraits<typename Alloc::value_type> > iterator; typedef DataIterator<typename Alloc::chunk_type, - ConstTraits< - typename Alloc::value_type> > const_iterator; + ConstTraits<typename Alloc::value_type> > const_iterator; typedef typename Alloc::value_type value_type; - typedef typename Alloc::pointer pointer; - typedef typename Alloc::reference reference; - typedef typename Alloc::size_type size_type; + typedef typename Alloc::pointer pointer; + typedef typename Alloc::reference reference; + typedef typename Alloc::size_type size_type; -protected: - GCFactoryBase() - : Alloc(), m_NumAllocData(0) - { } + protected: + GCFactoryBase() : Alloc(), m_NumAllocData(0) {} - GCFactoryBase(size_t pNum) - : Alloc(pNum), m_NumAllocData(0) - { } + explicit GCFactoryBase(size_t pNum) : Alloc(pNum), m_NumAllocData(0) {} -public: - virtual ~GCFactoryBase() - { Alloc::clear(); } + public: + virtual ~GCFactoryBase() { Alloc::clear(); } // ----- modifiers ----- // value_type* allocate(size_t N) { value_type* result = Alloc::allocate(N); - if (0 != result) + if (result != NULL) m_NumAllocData += N; return result; } @@ -150,15 +133,15 @@ return Alloc::allocate(); } - void deallocate(pointer &pPtr, size_type N) { + void deallocate(pointer& pPtr, size_type N) { Alloc::deallocate(pPtr, N); - if (0 == pPtr) + if (pPtr == NULL) m_NumAllocData -= N; } - void deallocate(pointer &pPtr) { + void deallocate(pointer& pPtr) { Alloc::deallocate(pPtr); - if (0 == pPtr) + if (pPtr == NULL) --m_NumAllocData; } @@ -168,35 +151,30 @@ } // ----- iterators ----- // - iterator begin() - { return iterator(Alloc::m_pRoot, 0); } + iterator begin() { return iterator(Alloc::m_pRoot, 0); } - const_iterator begin() const - { return const_iterator(Alloc::m_pRoot, 0); } + const_iterator begin() const { return const_iterator(Alloc::m_pRoot, 0); } iterator end() { - return (0 == Alloc::m_pCurrent)? - begin(): - iterator(Alloc::m_pCurrent, Alloc::m_pCurrent->bound); + return (Alloc::m_pCurrent) == 0 + ? begin() + : iterator(Alloc::m_pCurrent, Alloc::m_pCurrent->bound); } const_iterator end() const { - return (0 == Alloc::m_pCurrent)? - begin(): - const_iterator(Alloc::m_pCurrent, Alloc::m_pCurrent->bound); + return (Alloc::m_pCurrent) == 0 + ? begin() + : const_iterator(Alloc::m_pCurrent, Alloc::m_pCurrent->bound); } // ----- observers ----- // - bool empty() const - { return Alloc::empty(); } + bool empty() const { return Alloc::empty(); } - unsigned int capacity() const - { return Alloc::max_size(); } + unsigned int capacity() const { return Alloc::max_size(); } - unsigned int size() const - { return m_NumAllocData; } + unsigned int size() const { return m_NumAllocData; } -protected: + protected: unsigned int m_NumAllocData; }; @@ -204,25 +182,20 @@ * \brief GCFactory provides a factory that guaratees to remove all allocated * data. */ -template<typename DataType, size_t ChunkSize> -class GCFactory : public GCFactoryBase<LinearAllocator<DataType, ChunkSize> > -{ -public: - GCFactory() - : GCFactoryBase<LinearAllocator<DataType, ChunkSize> >() - { } +template <typename DataType, size_t ChunkSize> +class GCFactory : public GCFactoryBase<LinearAllocator<DataType, ChunkSize> > { + public: + GCFactory() : GCFactoryBase<LinearAllocator<DataType, ChunkSize> >() {} }; -template<typename DataType> -class GCFactory<DataType, 0> : public GCFactoryBase<LinearAllocator<DataType, 0> > -{ -public: - GCFactory(size_t pNum) - : GCFactoryBase<LinearAllocator<DataType, 0> >(pNum) - { } +template <typename DataType> +class GCFactory<DataType, 0> + : public GCFactoryBase<LinearAllocator<DataType, 0> > { + public: + explicit GCFactory(size_t pNum) + : GCFactoryBase<LinearAllocator<DataType, 0> >(pNum) {} }; -} // namespace of mcld +} // namespace mcld -#endif - +#endif // MCLD_SUPPORT_GCFACTORY_H_
diff --git a/include/mcld/Support/GCFactoryListTraits.h b/include/mcld/Support/GCFactoryListTraits.h index 7a8871c..b8afe81 100644 --- a/include/mcld/Support/GCFactoryListTraits.h +++ b/include/mcld/Support/GCFactoryListTraits.h
@@ -6,11 +6,11 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_GCFACTORYLISTTRAITS_H -#define MCLD_SUPPORT_GCFACTORYLISTTRAITS_H +#ifndef MCLD_SUPPORT_GCFACTORYLISTTRAITS_H_ +#define MCLD_SUPPORT_GCFACTORYLISTTRAITS_H_ -#include <llvm/ADT/ilist_node.h> #include <llvm/ADT/ilist.h> +#include <llvm/ADT/ilist_node.h> #include <assert.h> @@ -20,44 +20,41 @@ * \brief GCFactoryListTraits provides trait class for llvm::iplist when * the nodes in the list is produced by GCFactory. */ -template<typename DataType> -class GCFactoryListTraits : public llvm::ilist_default_traits<DataType> -{ -private: - class SentinelNode : public DataType - { - public: - SentinelNode() { } +template <typename DataType> +class GCFactoryListTraits : public llvm::ilist_default_traits<DataType> { + private: + class SentinelNode : public DataType { + public: + SentinelNode() {} }; -public: + public: // override the traits provided in llvm::ilist_sentinel_traits since we've // defined our own sentinel. - DataType *createSentinel() const - { return reinterpret_cast<DataType*>(&mSentinel); } + DataType* createSentinel() const { + return reinterpret_cast<DataType*>(&mSentinel); + } - static void destroySentinel(DataType*) { } + static void destroySentinel(DataType* pData) {} - DataType *provideInitialHead() const - { return createSentinel(); } + DataType* provideInitialHead() const { return createSentinel(); } - DataType *ensureHead(DataType*) const - { return createSentinel(); } + DataType* ensureHead(DataType* pData) const { return createSentinel(); } - static void noteHead(DataType*, DataType*) { } + static void noteHead(DataType* pNew, DataType* pSentinel) {} // override the traits provided in llvm::ilist_node_traits since - static DataType *createNode(const DataType &V) { + static DataType* createNode(const DataType& V) { assert(false && "Only GCFactory knows how to create a node."); } - static void deleteNode(DataType *V) { + static void deleteNode(DataType* V) { // No action. GCFactory will handle it by itself. } -private: + private: mutable SentinelNode mSentinel; }; -} // namespace of mcld +} // namespace mcld -#endif +#endif // MCLD_SUPPORT_GCFACTORYLISTTRAITS_H_
diff --git a/include/mcld/Support/LEB128.h b/include/mcld/Support/LEB128.h index e90980f..2c6c1c8 100644 --- a/include/mcld/Support/LEB128.h +++ b/include/mcld/Support/LEB128.h
@@ -6,9 +6,8 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// - -#ifndef MCLD_SUPPORT_LEB128_H -#define MCLD_SUPPORT_LEB128_H +#ifndef MCLD_SUPPORT_LEB128_H_ +#define MCLD_SUPPORT_LEB128_H_ #include <stdint.h> #include <sys/types.h> @@ -20,20 +19,20 @@ typedef unsigned char ByteType; /* Forward declarations */ -template<typename IntType> -size_t encode(ByteType *&pBuf, IntType pValue); +template <typename IntType> +size_t encode(ByteType*& pBuf, IntType pValue); -template<typename IntType> -IntType decode(const ByteType *pBuf, size_t &pSize); +template <typename IntType> +IntType decode(const ByteType* pBuf, size_t& pSize); -template<typename IntType> -IntType decode(const ByteType *&pBuf); +template <typename IntType> +IntType decode(const ByteType*& pBuf); /* * Given an integer, this function returns the number of bytes required to * encode it in ULEB128 format. */ -template<typename IntType> +template <typename IntType> size_t size(IntType pValue) { size_t size = 1; while (pValue > 0x80) { @@ -49,66 +48,66 @@ * given buffer pointer to the point just past the end of the write value and * return the number of bytes being written. */ -template<> -size_t encode<uint64_t>(ByteType *&pBuf, uint64_t pValue); +template <> +size_t encode<uint64_t>(ByteType*& pBuf, uint64_t pValue); -template<> -size_t encode<uint32_t>(ByteType *&pBuf, uint32_t pValue); +template <> +size_t encode<uint32_t>(ByteType*& pBuf, uint32_t pValue); /* * Encoding functions for signed LEB128. */ -template<> -size_t encode<int64_t>(ByteType *&pBuf, int64_t pValue); +template <> +size_t encode<int64_t>(ByteType*& pBuf, int64_t pValue); -template<> -size_t encode<int32_t>(ByteType *&pBuf, int32_t pValue); +template <> +size_t encode<int32_t>(ByteType*& pBuf, int32_t pValue); /* * Read an integer encoded in ULEB128 format from the given buffer. pSize will * contain the number of bytes used in the buffer to encode the returned * integer. */ -template<> -uint64_t decode<uint64_t>(const ByteType *pBuf, size_t &pSize); +template <> +uint64_t decode<uint64_t>(const ByteType* pBuf, size_t& pSize); /* * Read an integer encoded in ULEB128 format from the given buffer. Update the * given buffer pointer to the point just past the end of the read value. */ -template<> -uint64_t decode<uint64_t>(const ByteType *&pBuf); +template <> +uint64_t decode<uint64_t>(const ByteType*& pBuf); /* * Decoding functions for signed LEB128. */ -template<> -int64_t decode<int64_t>(const ByteType *pBuf, size_t &pSize); +template <> +int64_t decode<int64_t>(const ByteType* pBuf, size_t& pSize); -template<> -int64_t decode<int64_t>(const ByteType *&pBuf); +template <> +int64_t decode<int64_t>(const ByteType*& pBuf); /* * The functions below handle the signed byte stream. This helps the user to get * rid of annoying type conversions when using the LEB128 encoding/decoding APIs * defined above. */ -template<typename IntType> -size_t encode(char *&pBuf, IntType pValue) { +template <typename IntType> +size_t encode(char*& pBuf, IntType pValue) { return encode<IntType>(reinterpret_cast<ByteType*&>(pBuf), pValue); } -template<typename IntType> -IntType decode(const char *pBuf, size_t &pSize) { +template <typename IntType> +IntType decode(const char* pBuf, size_t& pSize) { return decode<IntType>(reinterpret_cast<const ByteType*>(pBuf), pSize); } -template<typename IntType> -IntType decode(const char *&pBuf) { +template <typename IntType> +IntType decode(const char*& pBuf) { return decode<IntType>(reinterpret_cast<const ByteType*&>(pBuf)); } -} // namespace of leb128 -} // namespace of mcld +} // namespace leb128 +} // namespace mcld -#endif +#endif // MCLD_SUPPORT_LEB128_H_
diff --git a/include/mcld/Support/MemoryArea.h b/include/mcld/Support/MemoryArea.h index 570e293..105b23a 100644 --- a/include/mcld/Support/MemoryArea.h +++ b/include/mcld/Support/MemoryArea.h
@@ -6,10 +6,10 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_MEMORYAREA_H -#define MCLD_SUPPORT_MEMORYAREA_H +#ifndef MCLD_SUPPORT_MEMORYAREA_H_ +#define MCLD_SUPPORT_MEMORYAREA_H_ -#include <mcld/ADT/Uncopyable.h> +#include "mcld/Support/Compiler.h" #include <llvm/ADT/StringRef.h> #include <llvm/Support/MemoryBuffer.h> @@ -19,10 +19,10 @@ /** \class MemoryArea * \brief MemoryArea is used to manage input read-only memory space. */ -class MemoryArea : private Uncopyable -{ +class MemoryArea { friend class MemoryAreaFactory; -public: + + public: // constructor by file handler. // If the given file handler is read-only, client can not request a region // that out of the file size. @@ -39,10 +39,13 @@ size_t size() const; -private: + private: std::unique_ptr<llvm::MemoryBuffer> m_pMemoryBuffer; + + private: + DISALLOW_COPY_AND_ASSIGN(MemoryArea); }; -} // namespace of mcld +} // namespace mcld -#endif +#endif // MCLD_SUPPORT_MEMORYAREA_H_
diff --git a/include/mcld/Support/MemoryAreaFactory.h b/include/mcld/Support/MemoryAreaFactory.h index 8b6d879..348169b 100644 --- a/include/mcld/Support/MemoryAreaFactory.h +++ b/include/mcld/Support/MemoryAreaFactory.h
@@ -6,16 +6,16 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_MEMORYAREAFACTORY_H -#define MCLD_SUPPORT_MEMORYAREAFACTORY_H -#include <mcld/Support/GCFactory.h> -#include <mcld/Support/MemoryArea.h> -#include <mcld/Support/Path.h> -#include <mcld/Support/FileHandle.h> +#ifndef MCLD_SUPPORT_MEMORYAREAFACTORY_H_ +#define MCLD_SUPPORT_MEMORYAREAFACTORY_H_ +#include "mcld/Support/FileHandle.h" +#include "mcld/Support/GCFactory.h" +#include "mcld/Support/MemoryArea.h" +#include "mcld/Support/Path.h" + #include <llvm/ADT/StringMap.h> -namespace mcld -{ +namespace mcld { /** \class MemoryAreaFactory * \brief MemoryAreaFactory avoids creating duplicated MemoryAreas of the @@ -35,16 +35,14 @@ * * @see MemoryRegion */ -class MemoryAreaFactory : public GCFactory<MemoryArea, 0> -{ -public: +class MemoryAreaFactory : public GCFactory<MemoryArea, 0> { + public: explicit MemoryAreaFactory(size_t pNum); virtual ~MemoryAreaFactory(); // produce - create a MemoryArea and open its file. - MemoryArea* produce(const sys::fs::Path& pPath, - FileHandle::OpenMode pMode); + MemoryArea* produce(const sys::fs::Path& pPath, FileHandle::OpenMode pMode); // produce - create a MemoryArea and open its file. MemoryArea* produce(const sys::fs::Path& pPath, @@ -60,10 +58,11 @@ MemoryArea* produce(int pFD, FileHandle::OpenMode pMode); void destruct(MemoryArea* pArea); -private: + + private: llvm::StringMap<MemoryArea*> m_AreaMap; }; -} // namespace of mcld +} // namespace mcld -#endif +#endif // MCLD_SUPPORT_MEMORYAREAFACTORY_H_
diff --git a/include/mcld/Support/MemoryRegion.h b/include/mcld/Support/MemoryRegion.h index ff81a30..28205f1 100644 --- a/include/mcld/Support/MemoryRegion.h +++ b/include/mcld/Support/MemoryRegion.h
@@ -6,10 +6,11 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_MEMORYREGION_H -#define MCLD_SUPPORT_MEMORYREGION_H +#ifndef MCLD_SUPPORT_MEMORYREGION_H_ +#define MCLD_SUPPORT_MEMORYREGION_H_ -#include <mcld/ADT/TypeTraits.h> +#include "mcld/ADT/TypeTraits.h" + #include <llvm/ADT/ArrayRef.h> #include <llvm/Support/DataTypes.h> @@ -21,6 +22,6 @@ typedef llvm::ArrayRef<uint8_t> ConstMemoryRegion; typedef llvm::MutableArrayRef<uint8_t> MemoryRegion; -} // namespace mcld +} // namespace mcld -#endif +#endif // MCLD_SUPPORT_MEMORYREGION_H_
diff --git a/include/mcld/Support/MsgHandling.h b/include/mcld/Support/MsgHandling.h index 71d173e..5720ce5 100644 --- a/include/mcld/Support/MsgHandling.h +++ b/include/mcld/Support/MsgHandling.h
@@ -6,9 +6,9 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_MSGHANDLING_H -#define MCLD_SUPPORT_MSGHANDLING_H -#include <mcld/LD/MsgHandler.h> +#ifndef MCLD_SUPPORT_MSGHANDLING_H_ +#define MCLD_SUPPORT_MSGHANDLING_H_ +#include "mcld/LD/MsgHandler.h" namespace mcld { @@ -33,45 +33,37 @@ MsgHandler note(unsigned int pID); MsgHandler ignore(unsigned int pID); -} // namespace of mcld +} // namespace mcld //===----------------------------------------------------------------------===// // Inline functions //===----------------------------------------------------------------------===// -inline mcld::MsgHandler mcld::unreachable(unsigned int pID) -{ +inline mcld::MsgHandler mcld::unreachable(unsigned int pID) { return getDiagnosticEngine().report(pID, DiagnosticEngine::Unreachable); } -inline mcld::MsgHandler mcld::fatal(unsigned int pID) -{ +inline mcld::MsgHandler mcld::fatal(unsigned int pID) { return getDiagnosticEngine().report(pID, DiagnosticEngine::Fatal); } -inline mcld::MsgHandler mcld::error(unsigned int pID) -{ +inline mcld::MsgHandler mcld::error(unsigned int pID) { return getDiagnosticEngine().report(pID, DiagnosticEngine::Error); } -inline mcld::MsgHandler mcld::warning(unsigned int pID) -{ +inline mcld::MsgHandler mcld::warning(unsigned int pID) { return getDiagnosticEngine().report(pID, DiagnosticEngine::Warning); } -inline mcld::MsgHandler mcld::debug(unsigned int pID) -{ +inline mcld::MsgHandler mcld::debug(unsigned int pID) { return getDiagnosticEngine().report(pID, DiagnosticEngine::Debug); } -inline mcld::MsgHandler mcld::note(unsigned int pID) -{ +inline mcld::MsgHandler mcld::note(unsigned int pID) { return getDiagnosticEngine().report(pID, DiagnosticEngine::Note); } -inline mcld::MsgHandler mcld::ignore(unsigned int pID) -{ +inline mcld::MsgHandler mcld::ignore(unsigned int pID) { return getDiagnosticEngine().report(pID, DiagnosticEngine::Ignore); } -#endif - +#endif // MCLD_SUPPORT_MSGHANDLING_H_
diff --git a/include/mcld/Support/Path.h b/include/mcld/Support/Path.h index 9fdb95c..33f4705 100644 --- a/include/mcld/Support/Path.h +++ b/include/mcld/Support/Path.h
@@ -10,11 +10,12 @@ // filesystem (v3), but modified to remove exception handling and the // path class. //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_PATH_H -#define MCLD_SUPPORT_PATH_H +#ifndef MCLD_SUPPORT_PATH_H_ +#define MCLD_SUPPORT_PATH_H_ + +#include "mcld/Config/Config.h" #include <llvm/Support/raw_ostream.h> -#include <mcld/Config/Config.h> #include <iosfwd> #include <functional> @@ -22,8 +23,8 @@ #include <locale> namespace mcld { -namespace sys { -namespace fs { +namespace sys { +namespace fs { #if defined(MCLD_ON_WIN32) const char preferred_separator = '/'; @@ -40,29 +41,29 @@ * \brief Path provides an abstraction for the path to a file or directory in * the operating system's filesystem. */ -class Path -{ -public: - typedef char ValueType; - typedef std::string StringType; +class Path { + public: + typedef char ValueType; + typedef std::string StringType; -public: + public: Path(); - Path(const ValueType* s); - Path(const StringType &s); + explicit Path(const ValueType* s); + explicit Path(const StringType& s); Path(const Path& pCopy); virtual ~Path(); // ----- assignments ----- // template <class InputIterator> Path& assign(InputIterator begin, InputIterator end); - Path& assign(const StringType &s); + Path& assign(const StringType& s); Path& assign(const ValueType* s, unsigned int length); // ----- appends ----- // template <class InputIterator> Path& append(InputIterator begin, InputIterator end); Path& append(const Path& pPath); + Path& append(const StringType& pPath); // ----- observers ----- // bool empty() const; @@ -71,10 +72,9 @@ bool isFromPWD() const; const StringType& native() const { return m_PathName; } - StringType& native() { return m_PathName; } + StringType& native() { return m_PathName; } - const ValueType* c_str() const - { return m_PathName.c_str(); } + const ValueType* c_str() const { return m_PathName.c_str(); } // ----- decomposition ----- // Path parent_path() const; @@ -86,42 +86,41 @@ StringType generic_string() const; bool canonicalize(); -public: + public: StringType::size_type m_append_separator_if_needed(); void m_erase_redundant_separator(StringType::size_type sep_pos); -protected: + protected: StringType m_PathName; }; -bool operator==(const Path& pLHS,const Path& pRHS); -bool operator!=(const Path& pLHS,const Path& pRHS); +bool operator==(const Path& pLHS, const Path& pRHS); +bool operator!=(const Path& pLHS, const Path& pRHS); Path operator+(const Path& pLHS, const Path& pRHS); //===----------------------------------------------------------------------===// // Non-member Functions //===----------------------------------------------------------------------===// -bool exists(const Path &pPath); +bool exists(const Path& pPath); -bool is_directory(const Path &pPath); +bool is_directory(const Path& pPath); template <class Char, class Traits> -inline std::basic_ostream<Char, Traits>& -operator<<(std::basic_ostream<Char, Traits>& pOS, const Path& pPath) -{ +inline std::basic_ostream<Char, Traits>& operator<<( + std::basic_ostream<Char, Traits>& pOS, + const Path& pPath) { return pOS << pPath.native(); } template <class Char, class Traits> -inline std::basic_istream<Char, Traits>& -operator>>(std::basic_istream<Char, Traits>& pOS, Path& pPath) -{ +inline std::basic_istream<Char, Traits>& operator>>( + std::basic_istream<Char, Traits>& pOS, + Path& pPath) { return pOS >> pPath.native(); } -inline llvm::raw_ostream& -operator<<(llvm::raw_ostream& pOS, const Path& pPath) -{ +inline llvm::raw_ostream& operator<<(llvm::raw_ostream& pOS, + const Path& pPath) { return pOS << pPath.native(); } @@ -129,8 +128,7 @@ // class path member template implementation //===----------------------------------------------------------------------===// template <class InputIterator> -Path& Path::assign(InputIterator begin, InputIterator end) -{ +Path& Path::assign(InputIterator begin, InputIterator end) { m_PathName.clear(); if (begin != end) m_PathName.append<InputIterator>(begin, end); @@ -138,8 +136,7 @@ } template <class InputIterator> -Path& Path::append(InputIterator begin, InputIterator end) -{ +Path& Path::append(InputIterator begin, InputIterator end) { if (begin == end) return *this; StringType::size_type sep_pos(m_append_separator_if_needed()); @@ -149,28 +146,26 @@ return *this; } -} // namespace of fs -} // namespace of sys -} // namespace of mcld +} // namespace fs +} // namespace sys +} // namespace mcld //===----------------------------------------------------------------------===// // STL compatible functions //===----------------------------------------------------------------------===// namespace std { -template<> -struct less<mcld::sys::fs::Path> : public binary_function<mcld::sys::fs::Path, - mcld::sys::fs::Path, - bool> -{ - bool operator() (const mcld::sys::fs::Path& pX,const mcld::sys::fs::Path& pY) const { +template <> +struct less<mcld::sys::fs::Path> + : public binary_function<mcld::sys::fs::Path, mcld::sys::fs::Path, bool> { + bool operator()(const mcld::sys::fs::Path& pX, + const mcld::sys::fs::Path& pY) const { if (pX.generic_string().size() < pY.generic_string().size()) return true; return (pX.generic_string() < pY.generic_string()); } }; -} // namespace of std +} // namespace std -#endif - +#endif // MCLD_SUPPORT_PATH_H_
diff --git a/include/mcld/Support/PathCache.h b/include/mcld/Support/PathCache.h index aca49fb..8b61556 100644 --- a/include/mcld/Support/PathCache.h +++ b/include/mcld/Support/PathCache.h
@@ -6,29 +6,28 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_PATHCACHE_H -#define MCLD_SUPPORT_PATHCACHE_H +#ifndef MCLD_SUPPORT_PATHCACHE_H_ +#define MCLD_SUPPORT_PATHCACHE_H_ -#include <mcld/ADT/HashEntry.h> -#include <mcld/ADT/HashTable.h> -#include <mcld/ADT/StringHash.h> -#include <mcld/Support/Path.h> +#include "mcld/ADT/HashEntry.h" +#include "mcld/ADT/HashTable.h" +#include "mcld/ADT/StringHash.h" +#include "mcld/Support/Path.h" namespace mcld { -namespace sys { -namespace fs { +namespace sys { +namespace fs { -namespace { - typedef HashEntry<llvm::StringRef, - mcld::sys::fs::Path, - hash::StringCompare<llvm::StringRef> > HashEntryType; -} // anonymous namespace +typedef HashEntry<llvm::StringRef, + mcld::sys::fs::Path, + hash::StringCompare<llvm::StringRef> > HashEntryType; -typedef HashTable<HashEntryType, hash::StringHash<hash::BKDR>, EntryFactory<HashEntryType> > PathCache; +typedef HashTable<HashEntryType, + hash::StringHash<hash::DJB>, + EntryFactory<HashEntryType> > PathCache; -} // namespace of fs -} // namespace of sys -} // namespace of mcld +} // namespace fs +} // namespace sys +} // namespace mcld -#endif - +#endif // MCLD_SUPPORT_PATHCACHE_H_
diff --git a/include/mcld/Support/RealPath.h b/include/mcld/Support/RealPath.h index b630fd6..b5edc76 100644 --- a/include/mcld/Support/RealPath.h +++ b/include/mcld/Support/RealPath.h
@@ -6,64 +6,61 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_REALPATH_H -#define MCLD_SUPPORT_REALPATH_H +#ifndef MCLD_SUPPORT_REALPATH_H_ +#define MCLD_SUPPORT_REALPATH_H_ #include "mcld/Support/Path.h" + #include <string> namespace mcld { -namespace sys { -namespace fs { +namespace sys { +namespace fs { /** \class RealPath * \brief The canonicalized absolute pathname. * */ -class RealPath : public Path -{ -public: - typedef Path::ValueType ValueType; +class RealPath : public Path { + public: + typedef Path::ValueType ValueType; typedef Path::StringType StringType; -public: + public: RealPath(); - explicit RealPath(const ValueType* s ); - explicit RealPath(const StringType &s ); + explicit RealPath(const ValueType* s); + explicit RealPath(const StringType& s); explicit RealPath(const Path& pPath); ~RealPath(); RealPath& assign(const Path& pPath); -protected: + protected: void initialize(); }; -} // namespace of fs -} // namespace of sys -} // namespace of mcld +} // namespace fs +} // namespace sys +} // namespace mcld -//-------------------------------------------------------------------------// -// STL compatible functions // -//-------------------------------------------------------------------------// +//----------------------------------------------------------------------------// +// STL compatible functions // +//----------------------------------------------------------------------------// namespace std { -template<> -struct less<mcld::sys::fs::RealPath> : public binary_function< - mcld::sys::fs::RealPath, - mcld::sys::fs::RealPath, - bool> -{ - bool operator() (const mcld::sys::fs::RealPath& pX, - const mcld::sys::fs::RealPath& pY) const { +template <> +struct less<mcld::sys::fs::RealPath> + : public binary_function<mcld::sys::fs::RealPath, + mcld::sys::fs::RealPath, + bool> { + bool operator()(const mcld::sys::fs::RealPath& pX, + const mcld::sys::fs::RealPath& pY) const { if (pX.native().size() < pY.native().size()) return true; return (pX.native() < pY.native()); } }; -} // namespace of std +} // namespace std - -#endif - +#endif // MCLD_SUPPORT_REALPATH_H_
diff --git a/include/mcld/Support/SystemUtils.h b/include/mcld/Support/SystemUtils.h index 7057110..4502e20 100644 --- a/include/mcld/Support/SystemUtils.h +++ b/include/mcld/Support/SystemUtils.h
@@ -6,11 +6,13 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_SYSTEMUTILS_H -#define MCLD_SUPPORT_SYSTEMUTILS_H +#ifndef MCLD_SUPPORT_SYSTEMUTILS_H_ +#define MCLD_SUPPORT_SYSTEMUTILS_H_ + +#include "mcld/Config/Config.h" #include <llvm/Support/DataTypes.h> -#include <mcld/Config/Config.h> + #include <string> namespace mcld { @@ -22,7 +24,7 @@ /** \fn strerror * \brief system error message */ -char *strerror(int pErrnum); +char* strerror(int pErrnum); std::string getDefaultTargetTriple(); @@ -34,8 +36,7 @@ /// SetRandomSeed - set the initial seed value for future calls to random(). void SetRandomSeed(unsigned pSeed); -} // namespace of sys -} // namespace of mcld +} // namespace sys +} // namespace mcld -#endif - +#endif // MCLD_SUPPORT_SYSTEMUTILS_H_
diff --git a/include/mcld/Support/Target.h b/include/mcld/Support/Target.h index 021fc2e..703dc82 100644 --- a/include/mcld/Support/Target.h +++ b/include/mcld/Support/Target.h
@@ -6,16 +6,15 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_TARGET_H -#define MCLD_SUPPORT_TARGET_H +#ifndef MCLD_SUPPORT_TARGET_H_ +#define MCLD_SUPPORT_TARGET_H_ #include <string> -#include <list> namespace llvm { class Target; class Triple; class TargetMachine; -} // namespace of llvm +} // namespace llvm namespace mcld { @@ -32,32 +31,31 @@ /** \class Target * \brief Target collects target specific information */ -class Target -{ +class Target { friend class mcld::MCLDTargetMachine; friend class mcld::TargetRegistry; -public: + public: typedef unsigned int (*TripleMatchQualityFnTy)(const llvm::Triple& pTriple); - typedef MCLDTargetMachine *(*TargetMachineCtorTy)(const llvm::Target &, - const mcld::Target &, - llvm::TargetMachine &, + typedef MCLDTargetMachine* (*TargetMachineCtorTy)(const llvm::Target&, + const mcld::Target&, + llvm::TargetMachine&, const std::string&); - typedef MCLinker *(*MCLinkerCtorTy)(const std::string& pTriple, + typedef MCLinker* (*MCLinkerCtorTy)(const std::string& pTriple, LinkerConfig&, Module&, FileHandle& pFileHandle); typedef bool (*EmulationFnTy)(LinkerScript&, LinkerConfig&); - typedef TargetLDBackend *(*TargetLDBackendCtorTy)(const LinkerConfig&); + typedef TargetLDBackend* (*TargetLDBackendCtorTy)(const LinkerConfig&); - typedef DiagnosticLineInfo *(*DiagnosticLineInfoCtorTy)(const mcld::Target&, + typedef DiagnosticLineInfo* (*DiagnosticLineInfoCtorTy)(const mcld::Target&, const std::string&); -public: + public: Target(); /// getName - get the target name @@ -71,7 +69,7 @@ llvm::TargetMachine& pTM) const; /// createMCLinker - create target-specific MCLinker - MCLinker *createMCLinker(const std::string &pTriple, + MCLinker* createMCLinker(const std::string& pTriple, LinkerConfig& pConfig, Module& pModule, FileHandle& pFileHandle) const; @@ -84,10 +82,11 @@ TargetLDBackend* createLDBackend(const LinkerConfig& pConfig) const; /// createDiagnosticLineInfo - create target-specific DiagnosticLineInfo - DiagnosticLineInfo* createDiagnosticLineInfo(const mcld::Target& pTarget, - const std::string& pTriple) const; + DiagnosticLineInfo* createDiagnosticLineInfo( + const mcld::Target& pTarget, + const std::string& pTriple) const; -private: + private: /// Name - The target name const char* Name; @@ -99,7 +98,6 @@ DiagnosticLineInfoCtorTy DiagnosticLineInfoCtorFn; }; -} //end namespace mcld +} // namespace mcld -#endif - +#endif // MCLD_SUPPORT_TARGET_H_
diff --git a/include/mcld/Support/TargetRegistry.h b/include/mcld/Support/TargetRegistry.h index 1ae6245..c76ff74 100644 --- a/include/mcld/Support/TargetRegistry.h +++ b/include/mcld/Support/TargetRegistry.h
@@ -6,36 +6,36 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_TARGETREGISTRY_H -#define MCLD_SUPPORT_TARGETREGISTRY_H -#include <mcld/Support/Target.h> +#ifndef MCLD_SUPPORT_TARGETREGISTRY_H_ +#define MCLD_SUPPORT_TARGETREGISTRY_H_ +#include "mcld/Support/Target.h" + #include <llvm/ADT/Triple.h> -#include <string> #include <list> +#include <string> namespace llvm { class TargetMachine; class MCCodeEmitter; class MCContext; class AsmPrinter; -} // namespace of llvm +} // namespace llvm namespace mcld { /** \class TargetRegistry * \brief TargetRegistry is an object adapter of llvm::TargetRegistry */ -class TargetRegistry -{ -public: +class TargetRegistry { + public: typedef std::list<mcld::Target*> TargetListTy; typedef TargetListTy::iterator iterator; -private: + private: static TargetListTy s_TargetList; -public: + public: static iterator begin() { return s_TargetList.begin(); } static iterator end() { return s_TargetList.end(); } @@ -54,36 +54,13 @@ const char* pName, Target::TripleMatchQualityFnTy pQualityFn); - /// RegisterTargetMachine - Register a TargetMachine implementation for the - /// given target. - /// - /// @param T - The target being registered. - /// @param Fn - A function to construct a TargetMachine for the target. - static void RegisterTargetMachine(mcld::Target &T, mcld::Target::TargetMachineCtorTy Fn) - { - // Ignore duplicate registration. - if (!T.TargetMachineCtorFn) - T.TargetMachineCtorFn = Fn; - } - - /// RegisterMCLinker - Register a MCLinker implementation for the given - /// target. - /// - /// @param T - the target being registered - /// @param Fn - A function to create MCLinker for the target - static void RegisterMCLinker(mcld::Target &T, mcld::Target::MCLinkerCtorTy Fn) - { - if (!T.MCLinkerCtorFn) - T.MCLinkerCtorFn = Fn; - } - /// RegisterEmulation - Register a emulation function for the target. /// target. /// /// @param T - the target being registered /// @param Fn - A emulation function - static void RegisterEmulation(mcld::Target &T, mcld::Target::EmulationFnTy Fn) - { + static void RegisterEmulation(mcld::Target& T, + mcld::Target::EmulationFnTy Fn) { if (!T.EmulationFn) T.EmulationFn = Fn; } @@ -93,8 +70,8 @@ /// /// @param T - The target being registered /// @param Fn - A function to create TargetLDBackend for the target - static void RegisterTargetLDBackend(mcld::Target &T, mcld::Target::TargetLDBackendCtorTy Fn) - { + static void RegisterTargetLDBackend(mcld::Target& T, + mcld::Target::TargetLDBackendCtorTy Fn) { if (!T.TargetLDBackendCtorFn) T.TargetLDBackendCtorFn = Fn; } @@ -104,10 +81,9 @@ /// /// @param T - The target being registered /// @param Fn - A function to create DiagnosticLineInfo for the target - static void - RegisterDiagnosticLineInfo(mcld::Target &T, - mcld::Target::DiagnosticLineInfoCtorTy Fn) - { + static void RegisterDiagnosticLineInfo( + mcld::Target& T, + mcld::Target::DiagnosticLineInfoCtorTy Fn) { if (!T.DiagnosticLineInfoCtorFn) T.DiagnosticLineInfoCtorFn = Fn; } @@ -116,7 +92,7 @@ /// /// @param Triple - The Triple string /// @param Error - The returned error message - static const mcld::Target *lookupTarget(const std::string& pTriple, + static const mcld::Target* lookupTarget(const std::string& pTriple, std::string& pError); /// lookupTarget - Look up MCLinker target by an architecture name @@ -127,9 +103,9 @@ /// @param pArch - The architecture name /// @param pTriple - The target triple /// @param pError - The returned error message - static const mcld::Target *lookupTarget(const std::string& pArchName, + static const mcld::Target* lookupTarget(const std::string& pArchName, llvm::Triple& pTriple, - std::string &Error); + std::string& Error); }; /// RegisterTarget - Helper function for registering a target, for use in the @@ -140,15 +116,14 @@ /// extern "C" void MCLDInitializeFooTargetInfo() { /// RegisterTarget<llvm::Foo> X(TheFooTarget, "foo", "Foo description"); /// } -template<llvm::Triple::ArchType TargetArchType = llvm::Triple::UnknownArch> -struct RegisterTarget -{ -public: - RegisterTarget(mcld::Target &pTarget, const char* pName) { +template <llvm::Triple::ArchType TargetArchType = llvm::Triple::UnknownArch> +struct RegisterTarget { + public: + RegisterTarget(mcld::Target& pTarget, const char* pName) { // if we've registered one, then return immediately. TargetRegistry::iterator target, ie = TargetRegistry::end(); for (target = TargetRegistry::begin(); target != ie; ++target) { - if (0 == strcmp((*target)->name(), pName)) + if (strcmp((*target)->name(), pName) == 0) return; } @@ -162,31 +137,6 @@ } }; -/// RegisterTargetMachine - Helper template for registering a target machine -/// implementation, for use in the target machine initialization -/// function. Usage: -/// -/// extern "C" void MCLDInitializeFooTarget() { -/// extern mcld::Target TheFooTarget; -/// RegisterTargetMachine<mcld::FooTargetMachine> X(TheFooTarget); -/// } -template<class TargetMachineImpl> -struct RegisterTargetMachine -{ - RegisterTargetMachine(mcld::Target &T) { - TargetRegistry::RegisterTargetMachine(T, &Allocator); - } +} // namespace mcld -private: - static MCLDTargetMachine *Allocator(const llvm::Target& pLLVMTarget, - const mcld::Target& pMCLDTarget, - llvm::TargetMachine& pTM, - const std::string& pTriple) { - return new TargetMachineImpl(pTM, pLLVMTarget, pMCLDTarget, pTriple); - } -}; - -} //end namespace mcld - -#endif - +#endif // MCLD_SUPPORT_TARGETREGISTRY_H_
diff --git a/include/mcld/Support/TargetSelect.h b/include/mcld/Support/TargetSelect.h index 32e568b..96bd510 100644 --- a/include/mcld/Support/TargetSelect.h +++ b/include/mcld/Support/TargetSelect.h
@@ -6,94 +6,69 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_TARGETSELECT_H -#define MCLD_SUPPORT_TARGETSELECT_H +#ifndef MCLD_SUPPORT_TARGETSELECT_H_ +#define MCLD_SUPPORT_TARGETSELECT_H_ extern "C" { - // Declare all of the target-initialization functions that are available. +// Declare all of the target-initialization functions that are available. #define MCLD_TARGET(TargetName) void MCLDInitialize##TargetName##LDTargetInfo(); -#include "mcld/Config/Targets.def" +#include "mcld/Config/Targets.def" // NOLINT [build/include] [4] - // Declare all of the target-dependent functions that are available. -#define MCLD_TARGET(TargetName) void MCLDInitialize##TargetName##LDTarget(); -#include "mcld/Config/Targets.def" - - // Declare all of the target-depedent linker information -#define MCLD_LINKER(TargetName) void MCLDInitialize##TargetName##LDInfo(); -#include "mcld/Config/Linkers.def" - - // Declare all of the available linker environment. -#define MCLD_LINKER(TargetName) void MCLDInitialize##TargetName##MCLinker(); -#include "mcld/Config/Linkers.def" - - // Declare all of the available emulators. +// Declare all of the available emulators. #define MCLD_TARGET(TargetName) void MCLDInitialize##TargetName##Emulation(); -#include "mcld/Config/Targets.def" +#include "mcld/Config/Targets.def" // NOLINT [build/include] [4] - // Declare all of the available target-specific linker +// Declare all of the available target-specific linker #define MCLD_LINKER(TargetName) void MCLDInitialize##TargetName##LDBackend(); -#include "mcld/Config/Linkers.def" +#include "mcld/Config/Linkers.def" // NOLINT [build/include] [4] - // Declare all of the available target-specific diagnostic line infomation -#define MCLD_LINKER(TargetName) void MCLDInitialize##TargetName##DiagnosticLineInfo(); -#include "mcld/Config/Linkers.def" +// Declare all of the available target-specific diagnostic line infomation +#define MCLD_LINKER(TargetName) \ + void MCLDInitialize##TargetName##DiagnosticLineInfo(); +#include "mcld/Config/Linkers.def" // NOLINT [build/include] [4] -} // extern "C" +} // extern "C" -namespace mcld -{ - /// InitializeAllTargetInfos - The main program should call this function if - /// it wants access to all available targets that MCLD is configured to - /// support, to make them available via the TargetRegistry. - /// - /// It is legal for a client to make multiple calls to this function. - inline void InitializeAllTargetInfos() { +namespace mcld { +/// InitializeAllTargetInfos - The main program should call this function if +/// it wants access to all available targets that MCLD is configured to +/// support, to make them available via the TargetRegistry. +/// +/// It is legal for a client to make multiple calls to this function. +inline void InitializeAllTargetInfos() { #define MCLD_TARGET(TargetName) MCLDInitialize##TargetName##LDTargetInfo(); -#include "mcld/Config/Targets.def" - } +#include "mcld/Config/Targets.def" // NOLINT [build/include] [4] +} - /// InitializeAllTargets - The main program should call this function if it - /// wants access to all available target machines that MCLD is configured to - /// support, to make them available via the TargetRegistry. - /// - /// It is legal for a client to make multiple calls to this function. - inline void InitializeAllTargets() { - mcld::InitializeAllTargetInfos(); +/// InitializeAllTargets - The main program should call this function if it +/// wants access to all available target machines that MCLD is configured to +/// support, to make them available via the TargetRegistry. +/// +/// It is legal for a client to make multiple calls to this function. +inline void InitializeAllTargets() { + mcld::InitializeAllTargetInfos(); #define MCLD_TARGET(TargetName) MCLDInitialize##TargetName##LDBackend(); -#include "mcld/Config/Targets.def" - } +#include "mcld/Config/Targets.def" // NOLINT [build/include] [4] +} - /// InitializeAllEmulations - The main program should call this function if - /// it wants all emulations to be configured to support. This function makes - /// all emulations available via the TargetRegistry. - inline void InitializeAllEmulations() { +/// InitializeAllEmulations - The main program should call this function if +/// it wants all emulations to be configured to support. This function makes +/// all emulations available via the TargetRegistry. +inline void InitializeAllEmulations() { #define MCLD_TARGET(TargetName) MCLDInitialize##TargetName##Emulation(); -#include "mcld/Config/Targets.def" - } +#include "mcld/Config/Targets.def" // NOLINT [build/include] [4] +} - /// InitializeAllLinkers - The main program should call this function if it - /// wants all linkers that is configured to support, to make them - /// available via the TargetRegistry. - /// - /// It is legal for a client to make multiple calls to this function. - inline void InitializeAllLinkers() { -#define MCLD_TARGET(TargetName) MCLDInitialize##TargetName##LDTarget(); -#include "mcld/Config/Targets.def" +/// InitializeMsgHandler - The main program should call this function if it +/// wants to print linker-specific messages. To make them available via the +/// TargetRegistry. +inline void InitializeAllDiagnostics() { +#define MCLD_LINKER(TargetName) \ + MCLDInitialize##TargetName##DiagnosticLineInfo(); +#include "mcld/Config/Linkers.def" // NOLINT [build/include] [4] +} -#define MCLD_LINKER(TargetName) MCLDInitialize##TargetName##MCLinker(); -#include "mcld/Config/Linkers.def" - } +} // namespace mcld - /// InitializeMsgHandler - The main program should call this function if it - /// wants to print linker-specific messages. To make them available via the - /// TargetRegistry. - inline void InitializeAllDiagnostics() { -#define MCLD_LINKER(TargetName) MCLDInitialize##TargetName##DiagnosticLineInfo(); -#include "mcld/Config/Linkers.def" - } - -} // namespace of mcld - -#endif - +#endif // MCLD_SUPPORT_TARGETSELECT_H_
diff --git a/include/mcld/Support/UniqueGCFactory.h b/include/mcld/Support/UniqueGCFactory.h index 8d7927b..a0d5a8f 100644 --- a/include/mcld/Support/UniqueGCFactory.h +++ b/include/mcld/Support/UniqueGCFactory.h
@@ -6,39 +6,36 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_UNIQUEGCFACTORY_H -#define MCLD_SUPPORT_UNIQUEGCFACTORY_H +#ifndef MCLD_SUPPORT_UNIQUEGCFACTORY_H_ +#define MCLD_SUPPORT_UNIQUEGCFACTORY_H_ #include "mcld/Support/GCFactory.h" + #include <map> #include <utility> -namespace mcld -{ +namespace mcld { /** \class UniqueGCFactoryBase * \brief UniqueGCFactories are unique associative factories, meaning that * no two elements have the same key. */ -template<typename KeyType, typename DataType, size_t ChunkSize> -class UniqueGCFactoryBase : public GCFactoryBase<LinearAllocator<DataType, ChunkSize> > -{ -protected: +template <typename KeyType, typename DataType, size_t ChunkSize> +class UniqueGCFactoryBase + : public GCFactoryBase<LinearAllocator<DataType, ChunkSize> > { + protected: typedef GCFactoryBase<LinearAllocator<DataType, ChunkSize> > Alloc; typedef std::map<KeyType, DataType*> KeyMap; -protected: + protected: UniqueGCFactoryBase() - : GCFactoryBase<LinearAllocator<DataType, ChunkSize> >() - { } + : GCFactoryBase<LinearAllocator<DataType, ChunkSize> >() {} - UniqueGCFactoryBase(size_t pNum) - : GCFactoryBase<LinearAllocator<DataType, ChunkSize> >(pNum) - { } + explicit UniqueGCFactoryBase(size_t pNum) + : GCFactoryBase<LinearAllocator<DataType, ChunkSize> >(pNum) {} -public: - virtual ~UniqueGCFactoryBase() - { f_KeyMap.clear(); } + public: + virtual ~UniqueGCFactoryBase() { f_KeyMap.clear(); } DataType* find(const KeyType& pKey) { typename KeyMap::iterator dataIter = f_KeyMap.find(pKey); @@ -80,12 +77,10 @@ return data; } -protected: + protected: KeyMap f_KeyMap; - }; -} // namespace of mcld +} // namespace mcld -#endif - +#endif // MCLD_SUPPORT_UNIQUEGCFACTORY_H_
diff --git a/include/mcld/Support/raw_ostream.h b/include/mcld/Support/raw_ostream.h index aae2336..b3a9f83 100644 --- a/include/mcld/Support/raw_ostream.h +++ b/include/mcld/Support/raw_ostream.h
@@ -6,17 +6,17 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -#ifndef MCLD_SUPPORT_RAWOSTREAM_H -#define MCLD_SUPPORT_RAWOSTREAM_H -#include <string> +#ifndef MCLD_SUPPORT_RAW_OSTREAM_H_ +#define MCLD_SUPPORT_RAW_OSTREAM_H_ #include <llvm/Support/FileSystem.h> #include <llvm/Support/raw_ostream.h> +#include <string> + namespace mcld { -class raw_fd_ostream : public llvm::raw_fd_ostream -{ -public: +class raw_fd_ostream : public llvm::raw_fd_ostream { + public: /// raw_fd_ostream - Open the specified file for writing. If an error occurs, /// information about the error is put into ErrorInfo, and the stream should /// be immediately destroyed; the string will be empty if no error occurred. @@ -27,44 +27,41 @@ /// itself to own the file descriptor. In particular, it will close the /// file descriptor when it is done (this is necessary to detect /// output errors). - raw_fd_ostream(const char *pFilename, - std::string &pErrorInfo, + raw_fd_ostream(const char* pFilename, + std::error_code& pErrorCode, llvm::sys::fs::OpenFlags pFlags = llvm::sys::fs::F_None); /// raw_fd_ostream ctor - FD is the file descriptor that this writes to. If /// ShouldClose is true, this closes the file when the stream is destroyed. - raw_fd_ostream(int pFD, bool pShouldClose, bool pUnbuffered=false); + raw_fd_ostream(int pFD, bool pShouldClose, bool pUnbuffered = false); virtual ~raw_fd_ostream(); void setColor(bool pEnable = true); + llvm::raw_ostream& changeColor(enum llvm::raw_ostream::Colors pColors, + bool pBold = false, + bool pBackground = false); - llvm::raw_ostream &changeColor(enum llvm::raw_ostream::Colors pColors, - bool pBold=false, - bool pBackground=false); + llvm::raw_ostream& resetColor(); - llvm::raw_ostream &resetColor(); - - llvm::raw_ostream &reverseColor(); + llvm::raw_ostream& reverseColor(); bool is_displayed() const; -private: + private: bool m_bConfigColor : 1; bool m_bSetColor : 1; - }; /// outs() - This returns a reference to a raw_ostream for standard output. /// Use it like: outs() << "foo" << "bar"; -mcld::raw_fd_ostream &outs(); +mcld::raw_fd_ostream& outs(); /// errs() - This returns a reference to a raw_ostream for standard error. /// Use it like: errs() << "foo" << "bar"; -mcld::raw_fd_ostream &errs(); +mcld::raw_fd_ostream& errs(); -} // namespace of mcld +} // namespace mcld -#endif - +#endif // MCLD_SUPPORT_RAW_OSTREAM_H_