Update mclinker for LLVM rebase to r222494.
This corresponds to the following upstream mclinker change:
commit b2f1691276052c4215abf36715d43248d6337cf8
Author: Diana Chen <mysekki@gmail.com>
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/lib/MC/Attribute.cpp b/lib/MC/Attribute.cpp
index 64782db..859689d 100644
--- a/lib/MC/Attribute.cpp
+++ b/lib/MC/Attribute.cpp
@@ -6,17 +6,17 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/MC/Attribute.h>
-#include <mcld/MC/AttributeSet.h>
-#include <mcld/Support/MsgHandling.h>
+#include "mcld/MC/Attribute.h"
-using namespace mcld;
+#include "mcld/MC/AttributeSet.h"
+#include "mcld/Support/MsgHandling.h"
+
+namespace mcld {
//===----------------------------------------------------------------------===//
// AttrConstraint
//===----------------------------------------------------------------------===//
-bool AttrConstraint::isLegal(const Attribute& pAttr) const
-{
+bool AttrConstraint::isLegal(const Attribute& pAttr) const {
if (!isWholeArchive() && pAttr.isWholeArchive()) {
error(diag::err_unsupported_whole_archive);
return false;
@@ -51,47 +51,41 @@
AttributeProxy::AttributeProxy(AttributeSet& pParent,
const Attribute& pBase,
const AttrConstraint& pConstraint)
- : m_AttrPool(pParent), m_pBase(&pBase), m_Constraint(pConstraint) {
+ : m_AttrPool(pParent), m_pBase(&pBase), m_Constraint(pConstraint) {
}
-AttributeProxy::~AttributeProxy()
-{
+AttributeProxy::~AttributeProxy() {
}
-bool AttributeProxy::isWholeArchive() const
-{
+bool AttributeProxy::isWholeArchive() const {
if (m_Constraint.isWholeArchive())
return m_pBase->isWholeArchive();
else
return false;
}
-bool AttributeProxy::isAsNeeded() const
-{
+bool AttributeProxy::isAsNeeded() const {
if (m_Constraint.isAsNeeded())
return m_pBase->isAsNeeded();
else
return false;
}
-bool AttributeProxy::isAddNeeded() const
-{
+bool AttributeProxy::isAddNeeded() const {
if (m_Constraint.isAddNeeded())
return m_pBase->isAddNeeded();
else
return false;
}
-bool AttributeProxy::isStatic() const
-{
+bool AttributeProxy::isStatic() const {
if (m_Constraint.isSharedSystem())
return m_pBase->isStatic();
else
return true;
}
-bool AttributeProxy::isDynamic() const
-{
+bool AttributeProxy::isDynamic() const {
if (m_Constraint.isSharedSystem())
return m_pBase->isDynamic();
else
@@ -99,79 +93,69 @@
}
static inline void ReplaceOrRecord(AttributeSet& pParent,
- const Attribute *&pBase,
- Attribute *&pCopy)
-{
- Attribute *result = pParent.exists(*pCopy);
- if (NULL == result) { // can not find
+ const Attribute*& pBase,
+ Attribute*& pCopy) {
+ Attribute* result = pParent.exists(*pCopy);
+ if (result == NULL) { // can not find
pParent.record(*pCopy);
pBase = pCopy;
- }
- else { // find
+ } else { // find
delete pCopy;
pBase = result;
}
}
-void AttributeProxy::setWholeArchive()
-{
- Attribute *copy = new Attribute(*m_pBase);
+void AttributeProxy::setWholeArchive() {
+ Attribute* copy = new Attribute(*m_pBase);
copy->setWholeArchive();
ReplaceOrRecord(m_AttrPool, m_pBase, copy);
}
-void AttributeProxy::unsetWholeArchive()
-{
- Attribute *copy = new Attribute(*m_pBase);
+void AttributeProxy::unsetWholeArchive() {
+ Attribute* copy = new Attribute(*m_pBase);
copy->unsetWholeArchive();
ReplaceOrRecord(m_AttrPool, m_pBase, copy);
}
-void AttributeProxy::setAsNeeded()
-{
- Attribute *copy = new Attribute(*m_pBase);
+void AttributeProxy::setAsNeeded() {
+ Attribute* copy = new Attribute(*m_pBase);
copy->setAsNeeded();
ReplaceOrRecord(m_AttrPool, m_pBase, copy);
}
-void AttributeProxy::unsetAsNeeded()
-{
- Attribute *copy = new Attribute(*m_pBase);
+void AttributeProxy::unsetAsNeeded() {
+ Attribute* copy = new Attribute(*m_pBase);
copy->unsetAsNeeded();
ReplaceOrRecord(m_AttrPool, m_pBase, copy);
}
-void AttributeProxy::setAddNeeded()
-{
- Attribute *copy = new Attribute(*m_pBase);
+void AttributeProxy::setAddNeeded() {
+ Attribute* copy = new Attribute(*m_pBase);
copy->setAddNeeded();
ReplaceOrRecord(m_AttrPool, m_pBase, copy);
}
-void AttributeProxy::unsetAddNeeded()
-{
- Attribute *copy = new Attribute(*m_pBase);
+void AttributeProxy::unsetAddNeeded() {
+ Attribute* copy = new Attribute(*m_pBase);
copy->unsetAddNeeded();
ReplaceOrRecord(m_AttrPool, m_pBase, copy);
}
-void AttributeProxy::setStatic()
-{
- Attribute *copy = new Attribute(*m_pBase);
+void AttributeProxy::setStatic() {
+ Attribute* copy = new Attribute(*m_pBase);
copy->setStatic();
ReplaceOrRecord(m_AttrPool, m_pBase, copy);
}
-void AttributeProxy::setDynamic()
-{
- Attribute *copy = new Attribute(*m_pBase);
+void AttributeProxy::setDynamic() {
+ Attribute* copy = new Attribute(*m_pBase);
copy->setDynamic();
ReplaceOrRecord(m_AttrPool, m_pBase, copy);
}
-AttributeProxy& AttributeProxy::assign(Attribute* pBase)
-{
+AttributeProxy& AttributeProxy::assign(Attribute* pBase) {
m_pBase = pBase;
return *this;
}
+} // namespace mcld
diff --git a/lib/MC/AttributeSet.cpp b/lib/MC/AttributeSet.cpp
index e657207..96dc77f 100644
--- a/lib/MC/AttributeSet.cpp
+++ b/lib/MC/AttributeSet.cpp
@@ -6,39 +6,39 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/MC/Attribute.h>
-#include <mcld/MC/AttributeSet.h>
+#include "mcld/MC/AttributeSet.h"
+
+#include "mcld/MC/Attribute.h"
+
#include <cstddef>
-using namespace mcld;
+namespace mcld {
//===----------------------------------------------------------------------===//
// AttributeSet
//===----------------------------------------------------------------------===//
AttributeSet::AttributeSet(unsigned int pNum, const Attribute& pPredefined)
- : m_AttrSet(), m_Predefined(pPredefined) {
+ : m_AttrSet(), m_Predefined(pPredefined) {
m_AttrSet.reserve(pNum);
}
-AttributeSet::~AttributeSet()
-{
+AttributeSet::~AttributeSet() {
iterator cur = m_AttrSet.begin();
iterator aEnd = m_AttrSet.end();
- while(cur != aEnd) {
+ while (cur != aEnd) {
delete (*cur);
++cur;
}
}
-Attribute* AttributeSet::exists(const Attribute& pAttr) const
-{
+Attribute* AttributeSet::exists(const Attribute& pAttr) const {
if (m_Predefined == pAttr)
return const_cast<Attribute*>(&m_Predefined);
const_iterator cur = m_AttrSet.begin();
const_iterator aEnd = m_AttrSet.end();
- while(cur != aEnd) {
+ while (cur != aEnd) {
if (*(*cur) == pAttr) {
return *cur;
}
@@ -47,8 +47,8 @@
return NULL;
}
-void AttributeSet::record(mcld::Attribute &pAttr)
-{
+void AttributeSet::record(mcld::Attribute& pAttr) {
m_AttrSet.push_back(&pAttr);
}
+} // namespace mcld
diff --git a/lib/MC/CommandAction.cpp b/lib/MC/CommandAction.cpp
index bae5fbf..4439d7e 100644
--- a/lib/MC/CommandAction.cpp
+++ b/lib/MC/CommandAction.cpp
@@ -6,15 +6,16 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/MC/CommandAction.h>
-#include <mcld/MC/InputBuilder.h>
-#include <mcld/MC/SearchDirs.h>
-#include <mcld/MC/Attribute.h>
-#include <mcld/Support/MsgHandling.h>
-#include <mcld/Support/FileSystem.h>
-#include <mcld/LinkerConfig.h>
+#include "mcld/MC/CommandAction.h"
-using namespace mcld;
+#include "mcld/LinkerConfig.h"
+#include "mcld/MC/Attribute.h"
+#include "mcld/MC/InputBuilder.h"
+#include "mcld/MC/SearchDirs.h"
+#include "mcld/Support/MsgHandling.h"
+#include "mcld/Support/FileSystem.h"
+
+namespace mcld {
//===----------------------------------------------------------------------===//
// Derived Positional Option
@@ -22,12 +23,16 @@
// InputFileAction
//===----------------------------------------------------------------------===//
InputFileAction::InputFileAction(unsigned int pPosition,
- const sys::fs::Path &pPath)
- : InputAction(pPosition), m_Path(pPath) {
+ const sys::fs::Path& pPath)
+ : InputAction(pPosition), m_Path(pPath) {
}
-bool InputFileAction::activate(InputBuilder& pBuilder) const
-{
+InputFileAction::InputFileAction(unsigned int pPosition,
+ const char* pPath)
+ : InputAction(pPosition), m_Path(pPath) {
+}
+
+bool InputFileAction::activate(InputBuilder& pBuilder) const {
pBuilder.createNode<InputTree::Positional>(path().stem().native(), path());
return true;
}
@@ -36,13 +41,12 @@
// NamespecAction
//===----------------------------------------------------------------------===//
NamespecAction::NamespecAction(unsigned int pPosition,
- const std::string &pNamespec,
+ const std::string& pNamespec,
const SearchDirs& pSearchDirs)
- : InputAction(pPosition), m_Namespec(pNamespec), m_SearchDirs(pSearchDirs) {
+ : InputAction(pPosition), m_Namespec(pNamespec), m_SearchDirs(pSearchDirs) {
}
-bool NamespecAction::activate(InputBuilder& pBuilder) const
-{
+bool NamespecAction::activate(InputBuilder& pBuilder) const {
const sys::fs::Path* path = NULL;
// find out the real path of the namespec.
if (pBuilder.getConstraint().isSharedSystem()) {
@@ -52,19 +56,17 @@
if (pBuilder.getAttributes().isStatic()) {
// with --static, we must search an archive.
path = m_SearchDirs.find(namespec(), Input::Archive);
- }
- else {
+ } else {
// otherwise, with --Bdynamic, we can find either an archive or a
// shared object.
path = m_SearchDirs.find(namespec(), Input::DynObj);
}
- }
- else {
+ } else {
// In the system without shared object support, we only look for an archive
path = m_SearchDirs.find(namespec(), Input::Archive);
}
- if (NULL == path) {
+ if (path == NULL) {
fatal(diag::err_cannot_find_namespec) << namespec();
return false;
}
@@ -76,13 +78,13 @@
//===----------------------------------------------------------------------===//
// BitcodeAction
//===----------------------------------------------------------------------===//
-BitcodeAction::BitcodeAction(unsigned int pPosition, const sys::fs::Path &pPath)
- : InputAction(pPosition), m_Path(pPath) {
+BitcodeAction::BitcodeAction(unsigned int pPosition, const sys::fs::Path& pPath)
+ : InputAction(pPosition), m_Path(pPath) {
}
-bool BitcodeAction::activate(InputBuilder& pBuilder) const
-{
- pBuilder.createNode<InputTree::Positional>("bitcode", path(), Input::External);
+bool BitcodeAction::activate(InputBuilder& pBuilder) const {
+ pBuilder.createNode<InputTree::Positional>(
+ "bitcode", path(), Input::External);
return true;
}
@@ -90,11 +92,10 @@
// StartGroupAction
//===----------------------------------------------------------------------===//
StartGroupAction::StartGroupAction(unsigned int pPosition)
- : InputAction(pPosition) {
+ : InputAction(pPosition) {
}
-bool StartGroupAction::activate(InputBuilder& pBuilder) const
-{
+bool StartGroupAction::activate(InputBuilder& pBuilder) const {
if (pBuilder.isInGroup()) {
fatal(diag::fatal_forbid_nest_group);
return false;
@@ -107,11 +108,10 @@
// EndGroupAction
//===----------------------------------------------------------------------===//
EndGroupAction::EndGroupAction(unsigned int pPosition)
- : InputAction(pPosition) {
+ : InputAction(pPosition) {
}
-bool EndGroupAction::activate(InputBuilder& pBuilder) const
-{
+bool EndGroupAction::activate(InputBuilder& pBuilder) const {
pBuilder.exitGroup();
return true;
}
@@ -120,11 +120,10 @@
// WholeArchiveAction
//===----------------------------------------------------------------------===//
WholeArchiveAction::WholeArchiveAction(unsigned int pPosition)
- : InputAction(pPosition) {
+ : InputAction(pPosition) {
}
-bool WholeArchiveAction::activate(InputBuilder& pBuilder) const
-{
+bool WholeArchiveAction::activate(InputBuilder& pBuilder) const {
pBuilder.getAttributes().setWholeArchive();
return true;
}
@@ -133,11 +132,10 @@
// NoWholeArchiveAction
//===----------------------------------------------------------------------===//
NoWholeArchiveAction::NoWholeArchiveAction(unsigned int pPosition)
- : InputAction(pPosition) {
+ : InputAction(pPosition) {
}
-bool NoWholeArchiveAction::activate(InputBuilder& pBuilder) const
-{
+bool NoWholeArchiveAction::activate(InputBuilder& pBuilder) const {
pBuilder.getAttributes().unsetWholeArchive();
return true;
}
@@ -146,11 +144,10 @@
// AsNeededAction
//===----------------------------------------------------------------------===//
AsNeededAction::AsNeededAction(unsigned int pPosition)
- : InputAction(pPosition) {
+ : InputAction(pPosition) {
}
-bool AsNeededAction::activate(InputBuilder& pBuilder) const
-{
+bool AsNeededAction::activate(InputBuilder& pBuilder) const {
pBuilder.getAttributes().setAsNeeded();
return true;
}
@@ -159,11 +156,10 @@
// NoAsNeededAction
//===----------------------------------------------------------------------===//
NoAsNeededAction::NoAsNeededAction(unsigned int pPosition)
- : InputAction(pPosition) {
+ : InputAction(pPosition) {
}
-bool NoAsNeededAction::activate(InputBuilder& pBuilder) const
-{
+bool NoAsNeededAction::activate(InputBuilder& pBuilder) const {
pBuilder.getAttributes().unsetAsNeeded();
return true;
}
@@ -172,11 +168,10 @@
// AddNeededAction
//===----------------------------------------------------------------------===//
AddNeededAction::AddNeededAction(unsigned int pPosition)
- : InputAction(pPosition) {
+ : InputAction(pPosition) {
}
-bool AddNeededAction::activate(InputBuilder& pBuilder) const
-{
+bool AddNeededAction::activate(InputBuilder& pBuilder) const {
pBuilder.getAttributes().setAddNeeded();
return true;
}
@@ -185,11 +180,10 @@
// NoAddNeededAction
//===----------------------------------------------------------------------===//
NoAddNeededAction::NoAddNeededAction(unsigned int pPosition)
- : InputAction(pPosition) {
+ : InputAction(pPosition) {
}
-bool NoAddNeededAction::activate(InputBuilder& pBuilder) const
-{
+bool NoAddNeededAction::activate(InputBuilder& pBuilder) const {
pBuilder.getAttributes().unsetAddNeeded();
return true;
}
@@ -198,11 +192,10 @@
// BDynamicAction
//===----------------------------------------------------------------------===//
BDynamicAction::BDynamicAction(unsigned int pPosition)
- : InputAction(pPosition) {
+ : InputAction(pPosition) {
}
-bool BDynamicAction::activate(InputBuilder& pBuilder) const
-{
+bool BDynamicAction::activate(InputBuilder& pBuilder) const {
pBuilder.getAttributes().setDynamic();
return true;
}
@@ -210,12 +203,10 @@
//===----------------------------------------------------------------------===//
// BStaticAction
//===----------------------------------------------------------------------===//
-BStaticAction::BStaticAction(unsigned int pPosition)
- : InputAction(pPosition) {
+BStaticAction::BStaticAction(unsigned int pPosition) : InputAction(pPosition) {
}
-bool BStaticAction::activate(InputBuilder& pBuilder) const
-{
+bool BStaticAction::activate(InputBuilder& pBuilder) const {
pBuilder.getAttributes().setStatic();
return true;
}
@@ -224,12 +215,11 @@
// DefSymAction
//===----------------------------------------------------------------------===//
DefSymAction::DefSymAction(unsigned int pPosition, std::string& pAssignment)
- : InputAction(pPosition), m_Assignment(pAssignment) {
+ : InputAction(pPosition), m_Assignment(pAssignment) {
}
-bool DefSymAction::activate(InputBuilder& pBuilder) const
-{
- pBuilder.createNode<InputTree::Positional>("defsym", "NAN");
+bool DefSymAction::activate(InputBuilder& pBuilder) const {
+ pBuilder.createNode<InputTree::Positional>("defsym", sys::fs::Path("NAN"));
Input* input = *pBuilder.getCurrentNode();
pBuilder.setContext(*input, false);
@@ -245,31 +235,33 @@
const std::string& pFileName,
ScriptFile::Kind pKind,
const SearchDirs& pSearchDirs)
- : InputAction(pPosition),
- m_FileName(pFileName),
- m_Kind(pKind),
- m_SearchDirs(pSearchDirs) {
+ : InputAction(pPosition),
+ m_FileName(pFileName),
+ m_Kind(pKind),
+ m_SearchDirs(pSearchDirs) {
}
-bool ScriptAction::activate(InputBuilder& pBuilder) const
-{
+bool ScriptAction::activate(InputBuilder& pBuilder) const {
sys::fs::Path path(m_FileName);
if (!exists(path)) {
const sys::fs::Path* res = m_SearchDirs.find(m_FileName, Input::Script);
if (res == NULL) {
switch (m_Kind) {
- case ScriptFile::LDScript:
- fatal(diag::err_cannot_find_scriptfile) << "linker script" << m_FileName;
- break;
- case ScriptFile::VersionScript:
- fatal(diag::err_cannot_find_scriptfile) << "version script" << m_FileName;
- break;
- case ScriptFile::DynamicList:
- fatal(diag::err_cannot_find_scriptfile) << "dynamic list" << m_FileName;
- break;
- default:
- break;
+ case ScriptFile::LDScript:
+ fatal(diag::err_cannot_find_scriptfile) << "linker script"
+ << m_FileName;
+ break;
+ case ScriptFile::VersionScript:
+ fatal(diag::err_cannot_find_scriptfile) << "version script"
+ << m_FileName;
+ break;
+ case ScriptFile::DynamicList:
+ fatal(diag::err_cannot_find_scriptfile) << "dynamic list"
+ << m_FileName;
+ break;
+ default:
+ break;
}
return false;
}
@@ -280,3 +272,5 @@
return true;
}
+
+} // namespace mcld
diff --git a/lib/MC/ContextFactory.cpp b/lib/MC/ContextFactory.cpp
index 5b698c7..fe0489c 100644
--- a/lib/MC/ContextFactory.cpp
+++ b/lib/MC/ContextFactory.cpp
@@ -6,26 +6,24 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/LD/LDContext.h>
-#include <mcld/MC/ContextFactory.h>
+#include "mcld/MC/ContextFactory.h"
-using namespace mcld;
+#include "mcld/LD/LDContext.h"
+
+namespace mcld {
//===---------------------------------------------------------------------===//
// LDContextFactory
ContextFactory::ContextFactory(size_t pNum)
- : UniqueGCFactoryBase<sys::fs::Path, LDContext, 0>(pNum)
-{
+ : UniqueGCFactoryBase<sys::fs::Path, LDContext, 0>(pNum) {
}
-ContextFactory::~ContextFactory()
-{
+ContextFactory::~ContextFactory() {
}
-LDContext* ContextFactory::produce(const sys::fs::Path& pPath)
-{
+LDContext* ContextFactory::produce(const sys::fs::Path& pPath) {
LDContext* result = find(pPath);
- if (0 == result) {
+ if (result == NULL) {
result = UniqueGCFactoryBase<sys::fs::Path, LDContext, 0>::allocate();
new (result) LDContext();
f_KeyMap.insert(std::make_pair(pPath, result));
@@ -33,10 +31,14 @@
return result;
}
-LDContext* ContextFactory::produce()
-{
+LDContext* ContextFactory::produce(const char* pPath) {
+ return produce(sys::fs::Path(pPath));
+}
+
+LDContext* ContextFactory::produce() {
LDContext* result = allocate();
new (result) LDContext();
return result;
}
+} // namespace mcld
diff --git a/lib/MC/FileAction.cpp b/lib/MC/FileAction.cpp
index 0de60ee..f4e68df 100644
--- a/lib/MC/FileAction.cpp
+++ b/lib/MC/FileAction.cpp
@@ -6,31 +6,28 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/MC/FileAction.h>
-#include <mcld/MC/Input.h>
-#include <mcld/MC/InputBuilder.h>
+#include "mcld/MC/FileAction.h"
-using namespace mcld;
+#include "mcld/MC/Input.h"
+#include "mcld/MC/InputBuilder.h"
+
+namespace mcld {
//===----------------------------------------------------------------------===//
// ContextAction
//===----------------------------------------------------------------------===//
-ContextAction::ContextAction(unsigned int pPosition)
- : InputAction(pPosition) {
+ContextAction::ContextAction(unsigned int pPosition) : InputAction(pPosition) {
}
-bool ContextAction::activate(InputBuilder& pBuilder) const
-{
+bool ContextAction::activate(InputBuilder& pBuilder) const {
Input* input = *pBuilder.getCurrentNode();
if (input->hasContext())
return false;
// already got type - for example, bitcode
- if (input->type() == Input::Script ||
- input->type() == Input::Object ||
- input->type() == Input::DynObj ||
- input->type() == Input::Archive)
+ if (input->type() == Input::Script || input->type() == Input::Object ||
+ input->type() == Input::DynObj || input->type() == Input::Archive)
return false;
return pBuilder.setContext(*input);
@@ -40,25 +37,23 @@
// MemoryAreaAction
//===----------------------------------------------------------------------===//
MemoryAreaAction::MemoryAreaAction(unsigned int pPosition,
- FileHandle::OpenMode pMode,
- FileHandle::Permission pPerm)
- : InputAction(pPosition), m_Mode(pMode), m_Permission(pPerm) {
+ FileHandle::OpenModeEnum pMode,
+ FileHandle::PermissionEnum pPerm)
+ : InputAction(pPosition), m_Mode(pMode), m_Permission(pPerm) {
}
-bool MemoryAreaAction::activate(InputBuilder& pBuilder) const
-{
+bool MemoryAreaAction::activate(InputBuilder& pBuilder) const {
Input* input = *pBuilder.getCurrentNode();
if (input->hasMemArea())
return false;
// already got type - for example, bitcode
- if (input->type() == Input::Script ||
- input->type() == Input::Object ||
- input->type() == Input::DynObj ||
- input->type() == Input::Archive)
+ if (input->type() == Input::Script || input->type() == Input::Object ||
+ input->type() == Input::DynObj || input->type() == Input::Archive)
return false;
return pBuilder.setMemory(*input, m_Mode, m_Permission);
}
+} // namespace mcld
diff --git a/lib/MC/Input.cpp b/lib/MC/Input.cpp
index 26234fc..e19f667 100644
--- a/lib/MC/Input.cpp
+++ b/lib/MC/Input.cpp
@@ -6,73 +6,74 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/MC/Input.h>
-#include <mcld/MC/Attribute.h>
-#include <mcld/LD/LDContext.h>
+#include "mcld/MC/Input.h"
-using namespace mcld;
+#include "mcld/MC/Attribute.h"
+#include "mcld/LD/LDContext.h"
+
+namespace mcld {
//===----------------------------------------------------------------------===//
// mcld::Input
//===----------------------------------------------------------------------===//
Input::Input(llvm::StringRef pName)
- : m_Type(Unknown),
- m_Name(pName.data()),
- m_Path(),
- m_pAttr(NULL),
- m_bNeeded(false),
- m_bNoExport(false),
- m_fileOffset(0),
- m_pMemArea(NULL),
- m_pContext(NULL) {
+ : m_Type(Unknown),
+ m_Name(pName.data()),
+ m_Path(),
+ m_pAttr(NULL),
+ m_bNeeded(false),
+ m_bNoExport(false),
+ m_fileOffset(0),
+ m_pMemArea(NULL),
+ m_pContext(NULL) {
}
Input::Input(llvm::StringRef pName, const AttributeProxy& pProxy)
- : m_Type(Unknown),
- m_Name(pName.data()),
- m_Path(),
- m_pAttr(const_cast<Attribute*>(pProxy.attr())),
- m_bNeeded(false),
- m_bNoExport(false),
- m_fileOffset(0),
- m_pMemArea(NULL),
- m_pContext(NULL) {
+ : m_Type(Unknown),
+ m_Name(pName.data()),
+ m_Path(),
+ m_pAttr(const_cast<Attribute*>(pProxy.attr())),
+ m_bNeeded(false),
+ m_bNoExport(false),
+ m_fileOffset(0),
+ m_pMemArea(NULL),
+ m_pContext(NULL) {
}
Input::Input(llvm::StringRef pName,
- const sys::fs::Path& pPath,
- unsigned int pType,
- off_t pFileOffset)
- : m_Type(pType),
- m_Name(pName.data()),
- m_Path(pPath),
- m_pAttr(NULL),
- m_bNeeded(false),
- m_bNoExport(false),
- m_fileOffset(pFileOffset),
- m_pMemArea(NULL),
- m_pContext(NULL) {
+ const sys::fs::Path& pPath,
+ unsigned int pType,
+ off_t pFileOffset)
+ : m_Type(pType),
+ m_Name(pName.data()),
+ m_Path(pPath),
+ m_pAttr(NULL),
+ m_bNeeded(false),
+ m_bNoExport(false),
+ m_fileOffset(pFileOffset),
+ m_pMemArea(NULL),
+ m_pContext(NULL) {
}
Input::Input(llvm::StringRef pName,
- const sys::fs::Path& pPath,
- const AttributeProxy& pProxy,
- unsigned int pType,
- off_t pFileOffset)
- : m_Type(pType),
- m_Name(pName.data()),
- m_Path(pPath),
- m_pAttr(const_cast<Attribute*>(pProxy.attr())),
- m_bNeeded(false),
- m_bNoExport(false),
- m_fileOffset(pFileOffset),
- m_pMemArea(NULL),
- m_pContext(NULL) {
+ const sys::fs::Path& pPath,
+ const AttributeProxy& pProxy,
+ unsigned int pType,
+ off_t pFileOffset)
+ : m_Type(pType),
+ m_Name(pName.data()),
+ m_Path(pPath),
+ m_pAttr(const_cast<Attribute*>(pProxy.attr())),
+ m_bNeeded(false),
+ m_bNoExport(false),
+ m_fileOffset(pFileOffset),
+ m_pMemArea(NULL),
+ m_pContext(NULL) {
}
-Input::~Input()
-{
+Input::~Input() {
// Attribute is deleted by AttributeFactory
// MemoryArea is deleted by MemoryAreaFactory
}
+} // namespace mcld
diff --git a/lib/MC/InputAction.cpp b/lib/MC/InputAction.cpp
index f9078c6..7fdb93a 100644
--- a/lib/MC/InputAction.cpp
+++ b/lib/MC/InputAction.cpp
@@ -6,18 +6,17 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/MC/InputAction.h>
+#include "mcld/MC/InputAction.h"
-using namespace mcld;
+namespace mcld {
//===----------------------------------------------------------------------===//
// Base Positional Option
//===----------------------------------------------------------------------===//
-InputAction::InputAction(unsigned int pPosition)
- : m_Position(pPosition) {
+InputAction::InputAction(unsigned int pPosition) : m_Position(pPosition) {
}
-InputAction::~InputAction()
-{
+InputAction::~InputAction() {
}
+} // namespace mcld
diff --git a/lib/MC/InputBuilder.cpp b/lib/MC/InputBuilder.cpp
index 842c476..e20403f 100644
--- a/lib/MC/InputBuilder.cpp
+++ b/lib/MC/InputBuilder.cpp
@@ -6,25 +6,26 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/MC/InputBuilder.h>
+#include "mcld/MC/InputBuilder.h"
-#include <mcld/LinkerConfig.h>
-#include <mcld/Config/Config.h>
-#include <mcld/Support/Path.h>
-#include <mcld/MC/InputFactory.h>
-#include <mcld/MC/ContextFactory.h>
-#include <mcld/Support/MemoryAreaFactory.h>
+#include "mcld/LinkerConfig.h"
+#include "mcld/Config/Config.h"
+#include "mcld/MC/ContextFactory.h"
+#include "mcld/MC/InputFactory.h"
+#include "mcld/Support/MemoryAreaFactory.h"
+#include "mcld/Support/Path.h"
-using namespace mcld;
+namespace mcld {
InputBuilder::InputBuilder(const LinkerConfig& pConfig)
- : m_Config(pConfig),
- m_pCurrentTree(NULL), m_pMove(NULL), m_Root(),
- m_bOwnFactory(true) {
-
- m_pInputFactory = new InputFactory(MCLD_NUM_OF_INPUTS, pConfig);
- m_pContextFactory = new ContextFactory(MCLD_NUM_OF_INPUTS);
- m_pMemFactory = new MemoryAreaFactory(MCLD_NUM_OF_INPUTS);
+ : m_Config(pConfig),
+ m_pCurrentTree(NULL),
+ m_pMove(NULL),
+ m_Root(),
+ m_bOwnFactory(true) {
+ m_pInputFactory = new InputFactory(MCLD_NUM_OF_INPUTS, pConfig);
+ m_pContextFactory = new ContextFactory(MCLD_NUM_OF_INPUTS);
+ m_pMemFactory = new MemoryAreaFactory(MCLD_NUM_OF_INPUTS);
}
InputBuilder::InputBuilder(const LinkerConfig& pConfig,
@@ -32,17 +33,17 @@
ContextFactory& pContextFactory,
MemoryAreaFactory& pMemoryFactory,
bool pDelegate)
- : m_Config(pConfig),
- m_pInputFactory(&pInputFactory),
- m_pMemFactory(&pMemoryFactory),
- m_pContextFactory(&pContextFactory),
- m_pCurrentTree(NULL), m_pMove(NULL), m_Root(),
- m_bOwnFactory(pDelegate) {
-
+ : m_Config(pConfig),
+ m_pInputFactory(&pInputFactory),
+ m_pMemFactory(&pMemoryFactory),
+ m_pContextFactory(&pContextFactory),
+ m_pCurrentTree(NULL),
+ m_pMove(NULL),
+ m_Root(),
+ m_bOwnFactory(pDelegate) {
}
-InputBuilder::~InputBuilder()
-{
+InputBuilder::~InputBuilder() {
if (m_bOwnFactory) {
delete m_pInputFactory;
delete m_pContextFactory;
@@ -53,14 +54,12 @@
Input* InputBuilder::createInput(const std::string& pName,
const sys::fs::Path& pPath,
unsigned int pType,
- off_t pFileOffset)
-{
+ off_t pFileOffset) {
return m_pInputFactory->produce(pName, pPath, pType, pFileOffset);
}
-InputTree& InputBuilder::enterGroup()
-{
- assert(NULL != m_pCurrentTree && NULL != m_pMove);
+InputTree& InputBuilder::enterGroup() {
+ assert(m_pCurrentTree != NULL && m_pMove != NULL);
m_pCurrentTree->enterGroup(m_Root, *m_pMove);
m_pMove->move(m_Root);
@@ -70,9 +69,8 @@
return *m_pCurrentTree;
}
-InputTree& InputBuilder::exitGroup()
-{
- assert(NULL != m_pCurrentTree && NULL != m_pMove);
+InputTree& InputBuilder::exitGroup() {
+ assert(m_pCurrentTree != NULL && m_pMove != NULL);
m_Root = m_ReturnStack.top();
m_ReturnStack.pop();
@@ -81,42 +79,36 @@
return *m_pCurrentTree;
}
-bool InputBuilder::isInGroup() const
-{
+bool InputBuilder::isInGroup() const {
return !m_ReturnStack.empty();
}
-const InputTree& InputBuilder::getCurrentTree() const
-{
- assert(NULL != m_pCurrentTree && NULL != m_pMove);
+const InputTree& InputBuilder::getCurrentTree() const {
+ assert(m_pCurrentTree != NULL && m_pMove != NULL);
return *m_pCurrentTree;
}
-InputTree& InputBuilder::getCurrentTree()
-{
- assert(NULL != m_pCurrentTree && NULL != m_pMove);
+InputTree& InputBuilder::getCurrentTree() {
+ assert(m_pCurrentTree != NULL && m_pMove != NULL);
return *m_pCurrentTree;
}
-void InputBuilder::setCurrentTree(InputTree& pInputTree)
-{
+void InputBuilder::setCurrentTree(InputTree& pInputTree) {
m_pCurrentTree = &pInputTree;
m_Root = m_pCurrentTree->root();
m_pMove = &InputTree::Downward;
}
-bool InputBuilder::setContext(Input& pInput, bool pCheck)
-{
+bool InputBuilder::setContext(Input& pInput, bool pCheck) {
// The object files in an archive have common path. Every object files in an
// archive needs a individual context. We identify the object files in an
// archive by its file offset. Their file offsets are not zero.
LDContext* context = NULL;
- if (0 != pInput.fileOffset() || !pCheck) {
+ if (pInput.fileOffset() != 0 || !pCheck) {
// pInput is an object in an archive file. Produce a new context in this
// case.
context = m_pContextFactory->produce();
- }
- else {
+ } else {
// Using pInput.path() to avoid from creating context for identical file
// twice.
context = m_pContextFactory->produce(pInput.path());
@@ -128,32 +120,28 @@
bool InputBuilder::setMemory(Input& pInput,
FileHandle::OpenMode pMode,
- FileHandle::Permission pPerm)
-{
- MemoryArea *memory = m_pMemFactory->produce(pInput.path(), pMode, pPerm);
+ FileHandle::Permission pPerm) {
+ MemoryArea* memory = m_pMemFactory->produce(pInput.path(), pMode, pPerm);
pInput.setMemArea(memory);
return true;
}
-bool InputBuilder::setMemory(Input& pInput, void* pMemBuffer, size_t pSize)
-{
- MemoryArea *memory = m_pMemFactory->produce(pMemBuffer, pSize);
+bool InputBuilder::setMemory(Input& pInput, void* pMemBuffer, size_t pSize) {
+ MemoryArea* memory = m_pMemFactory->produce(pMemBuffer, pSize);
pInput.setMemArea(memory);
return true;
}
-const AttrConstraint& InputBuilder::getConstraint() const
-{
+const AttrConstraint& InputBuilder::getConstraint() const {
return m_Config.attribute().constraint();
}
-const AttributeProxy& InputBuilder::getAttributes() const
-{
+const AttributeProxy& InputBuilder::getAttributes() const {
return m_pInputFactory->attr();
}
-AttributeProxy& InputBuilder::getAttributes()
-{
+AttributeProxy& InputBuilder::getAttributes() {
return m_pInputFactory->attr();
}
+} // namespace mcld
diff --git a/lib/MC/InputFactory.cpp b/lib/MC/InputFactory.cpp
index b0b7aaa..32d1913 100644
--- a/lib/MC/InputFactory.cpp
+++ b/lib/MC/InputFactory.cpp
@@ -6,27 +6,26 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/MC/InputFactory.h>
-#include <mcld/LinkerConfig.h>
-#include <mcld/MC/AttributeSet.h>
-#include <mcld/AttributeOption.h>
+#include "mcld/MC/InputFactory.h"
-using namespace mcld;
+#include "mcld/LinkerConfig.h"
+#include "mcld/AttributeOption.h"
+#include "mcld/MC/AttributeSet.h"
+
+namespace mcld {
//===----------------------------------------------------------------------===//
// InputFactory
//===----------------------------------------------------------------------===//
InputFactory::InputFactory(size_t pNum, const LinkerConfig& pConfig)
- : GCFactory<Input,0>(pNum) {
-
+ : GCFactory<Input, 0>(pNum) {
m_pAttrSet = new AttributeSet(16, pConfig.attribute().predefined());
m_pLast = new AttributeProxy(*m_pAttrSet,
pConfig.attribute().predefined(),
pConfig.attribute().constraint());
}
-InputFactory::~InputFactory()
-{
+InputFactory::~InputFactory() {
delete m_pAttrSet;
delete m_pLast;
}
@@ -34,10 +33,19 @@
Input* InputFactory::produce(llvm::StringRef pName,
const sys::fs::Path& pPath,
unsigned int pType,
- off_t pFileOffset)
-{
+ off_t pFileOffset) {
Input* result = Alloc::allocate();
new (result) Input(pName, pPath, *m_pLast, pType, pFileOffset);
return result;
}
+Input* InputFactory::produce(llvm::StringRef pName,
+ const char* pPath,
+ unsigned int pType,
+ off_t pFileOffset) {
+ Input* result = Alloc::allocate();
+ new (result) Input(pName, sys::fs::Path(pPath), *m_pLast, pType, pFileOffset);
+ return result;
+}
+
+} // namespace mcld
diff --git a/lib/MC/MCLDDirectory.cpp b/lib/MC/MCLDDirectory.cpp
index a15e744..5d281d5 100644
--- a/lib/MC/MCLDDirectory.cpp
+++ b/lib/MC/MCLDDirectory.cpp
@@ -6,99 +6,93 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/MC/MCLDDirectory.h>
-#include <mcld/Support/FileSystem.h>
+#include "mcld/MC/MCLDDirectory.h"
+#include "mcld/Support/FileSystem.h"
-using namespace mcld;
-using namespace mcld::sys::fs;
+namespace mcld {
//===----------------------------------------------------------------------===//
// MCLDDirectory
//===----------------------------------------------------------------------===//
-MCLDDirectory::MCLDDirectory()
- : Directory(), m_Name(), m_bInSysroot(false) {
+MCLDDirectory::MCLDDirectory() : Directory(), m_Name(), m_bInSysroot(false) {
}
-MCLDDirectory::MCLDDirectory(const char* pName)
- : Directory(), m_Name(pName) {
+MCLDDirectory::MCLDDirectory(const char* pName) : Directory(), m_Name(pName) {
Directory::m_Path.assign(pName);
if (!Directory::m_Path.empty())
- m_bInSysroot = ('=' == Directory::m_Path.native()[0]);
+ m_bInSysroot = (Directory::m_Path.native()[0] == '=');
Directory::m_Path.m_append_separator_if_needed();
if (m_bInSysroot)
Directory::m_Path.native().erase(Directory::m_Path.native().begin());
else
- detail::open_dir(*this);
+ sys::fs::detail::open_dir(*this);
}
-MCLDDirectory::MCLDDirectory(const std::string &pName)
- : Directory(), m_Name(pName) {
+MCLDDirectory::MCLDDirectory(const std::string& pName)
+ : Directory(), m_Name(pName) {
Directory::m_Path.assign(pName);
if (!Directory::m_Path.empty())
- m_bInSysroot = ('=' == Directory::m_Path.native()[0]);
+ m_bInSysroot = (Directory::m_Path.native()[0] == '=');
Directory::m_Path.m_append_separator_if_needed();
if (m_bInSysroot)
Directory::m_Path.native().erase(Directory::m_Path.native().begin());
else
- detail::open_dir(*this);
+ sys::fs::detail::open_dir(*this);
}
MCLDDirectory::MCLDDirectory(llvm::StringRef pName)
- : Directory(), m_Name(pName.data(), pName.size()) {
+ : Directory(), m_Name(pName.data(), pName.size()) {
Directory::m_Path.assign(pName.str());
if (!Directory::m_Path.empty())
- m_bInSysroot = ('=' == Directory::m_Path.native()[0]);
+ m_bInSysroot = (Directory::m_Path.native()[0] == '=');
Directory::m_Path.m_append_separator_if_needed();
if (m_bInSysroot)
Directory::m_Path.native().erase(Directory::m_Path.native().begin());
else
- detail::open_dir(*this);
+ sys::fs::detail::open_dir(*this);
}
-MCLDDirectory &MCLDDirectory::assign(llvm::StringRef pName)
-{
+MCLDDirectory& MCLDDirectory::assign(llvm::StringRef pName) {
m_Name.assign(pName.data(), pName.size());
Directory::m_Path.assign(pName.str());
if (!Directory::m_Path.empty())
- m_bInSysroot = ('=' == Directory::m_Path.native()[0]);
+ m_bInSysroot = (Directory::m_Path.native()[0] == '=');
Directory::m_Path.m_append_separator_if_needed();
if (m_bInSysroot)
Directory::m_Path.native().erase(Directory::m_Path.native().begin());
else
- detail::open_dir(*this);
- Directory::m_FileStatus = FileStatus();
- Directory::m_SymLinkStatus = FileStatus();
+ sys::fs::detail::open_dir(*this);
+ Directory::m_FileStatus = sys::fs::FileStatus();
+ Directory::m_SymLinkStatus = sys::fs::FileStatus();
Directory::m_Cache.clear();
Directory::m_Handler = 0;
return (*this);
}
-MCLDDirectory::~MCLDDirectory()
-{
+MCLDDirectory::~MCLDDirectory() {
}
-bool MCLDDirectory::isInSysroot() const
-{
+bool MCLDDirectory::isInSysroot() const {
return m_bInSysroot;
}
-void MCLDDirectory::setSysroot(const sys::fs::Path& pSysroot)
-{
+void MCLDDirectory::setSysroot(const sys::fs::Path& pSysroot) {
if (m_bInSysroot) {
std::string old_path = Directory::m_Path.native();
Directory::m_Path.native() = pSysroot.native();
Directory::m_Path.m_append_separator_if_needed();
Directory::m_Path.native() += old_path;
- detail::canonicalize(Directory::m_Path.native());
- detail::open_dir(*this);
+ sys::fs::detail::canonicalize(Directory::m_Path.native());
+ sys::fs::detail::open_dir(*this);
}
}
+} // namespace mcld
diff --git a/lib/MC/SearchDirs.cpp b/lib/MC/SearchDirs.cpp
index 1950f96..07c02b6 100644
--- a/lib/MC/SearchDirs.cpp
+++ b/lib/MC/SearchDirs.cpp
@@ -6,17 +6,18 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/MC/SearchDirs.h>
-#include <mcld/MC/MCLDDirectory.h>
-#include <mcld/Support/FileSystem.h>
+#include "mcld/MC/SearchDirs.h"
-using namespace mcld;
+#include "mcld/MC/MCLDDirectory.h"
+#include "mcld/Support/FileSystem.h"
+
+namespace mcld {
//===----------------------------------------------------------------------===//
// Non-member functions
//===----------------------------------------------------------------------===//
-static inline void SpecToFilename(const std::string& pSpec, std::string& pFile)
-{
+static inline void SpecToFilename(const std::string& pSpec,
+ std::string& pFile) {
pFile = "lib";
pFile += pSpec;
}
@@ -24,30 +25,26 @@
//===----------------------------------------------------------------------===//
// SearchDirs
//===----------------------------------------------------------------------===//
-SearchDirs::SearchDirs()
-{
+SearchDirs::SearchDirs() {
// a magic number 8, no why.
// please prove it or change it
m_DirList.reserve(8);
}
-SearchDirs::SearchDirs(const sys::fs::Path& pSysRoot)
- : m_SysRoot(pSysRoot) {
+SearchDirs::SearchDirs(const sys::fs::Path& pSysRoot) : m_SysRoot(pSysRoot) {
// a magic number 8, no why.
// please prove it or change it
m_DirList.reserve(8);
}
-SearchDirs::~SearchDirs()
-{
+SearchDirs::~SearchDirs() {
iterator dir, dirEnd = end();
- for (dir = begin(); dir!=dirEnd; ++dir) {
+ for (dir = begin(); dir != dirEnd; ++dir) {
delete (*dir);
}
}
-bool SearchDirs::insert(const std::string& pPath)
-{
+bool SearchDirs::insert(const std::string& pPath) {
MCLDDirectory* dir = new MCLDDirectory(pPath);
if (dir->isInSysroot())
dir->setSysroot(m_SysRoot);
@@ -55,43 +52,38 @@
if (exists(dir->path()) && is_directory(dir->path())) {
m_DirList.push_back(dir);
return true;
- }
- else {
+ } else {
delete dir;
return false;
}
return true;
}
-bool SearchDirs::insert(const char* pPath)
-{
+bool SearchDirs::insert(const char* pPath) {
return insert(std::string(pPath));
}
-bool SearchDirs::insert(const sys::fs::Path& pPath)
-{
+bool SearchDirs::insert(const sys::fs::Path& pPath) {
return insert(pPath.native());
}
-mcld::sys::fs::Path*
-SearchDirs::find(const std::string& pNamespec, mcld::Input::Type pType)
-{
- assert(Input::DynObj == pType ||
- Input::Archive == pType ||
- Input::Script == pType);
+mcld::sys::fs::Path* SearchDirs::find(const std::string& pNamespec,
+ mcld::Input::Type pType) {
+ assert(Input::DynObj == pType || Input::Archive == pType ||
+ Input::Script == pType);
std::string file;
- switch(pType) {
- case Input::Script:
- file.assign(pNamespec);
- break;
- case Input::DynObj:
- case Input::Archive :
- SpecToFilename(pNamespec, file);
- break;
- default:
- break;
- } // end of switch
+ switch (pType) {
+ case Input::Script:
+ file.assign(pNamespec);
+ break;
+ case Input::DynObj:
+ case Input::Archive:
+ SpecToFilename(pNamespec, file);
+ break;
+ default:
+ break;
+ } // end of switch
// for all MCLDDirectorys
DirList::iterator mcld_dir, mcld_dir_end = m_DirList.end();
@@ -100,65 +92,63 @@
MCLDDirectory::iterator entry = (*mcld_dir)->begin();
MCLDDirectory::iterator enEnd = (*mcld_dir)->end();
- switch(pType) {
- case Input::Script: {
- while (entry != enEnd) {
- if (file == entry.path()->filename())
- return entry.path();
- ++entry;
+ switch (pType) {
+ case Input::Script: {
+ while (entry != enEnd) {
+ if (file == entry.path()->filename().native())
+ return entry.path();
+ ++entry;
+ }
+ break;
}
- break;
- }
- case Input::DynObj: {
- while (entry != enEnd) {
- if (file == entry.path()->stem().native() ) {
- if (mcld::sys::fs::detail::shared_library_extension ==
+ case Input::DynObj: {
+ while (entry != enEnd) {
+ if (file == entry.path()->stem().native()) {
+ if (mcld::sys::fs::detail::shared_library_extension ==
entry.path()->extension().native()) {
+ return entry.path();
+ }
+ }
+ ++entry;
+ }
+ }
+ /** Fall through **/
+ case Input::Archive: {
+ entry = (*mcld_dir)->begin();
+ enEnd = (*mcld_dir)->end();
+ while (entry != enEnd) {
+ if (file == entry.path()->stem().native() &&
+ mcld::sys::fs::detail::static_library_extension ==
+ entry.path()->extension().native()) {
return entry.path();
}
+ ++entry;
}
- ++entry;
}
- }
- /** Fall through **/
- case Input::Archive : {
- entry = (*mcld_dir)->begin();
- enEnd = (*mcld_dir)->end();
- while (entry != enEnd) {
- if (file == entry.path()->stem().native() &&
- mcld::sys::fs::detail::static_library_extension ==
- entry.path()->extension().native()) {
- return entry.path();
- }
- ++entry;
- }
- }
- default:
- break;
- } // end of switch
- } // end of for
+ default:
+ break;
+ } // end of switch
+ } // end of for
return NULL;
}
-const mcld::sys::fs::Path*
-SearchDirs::find(const std::string& pNamespec, mcld::Input::Type pType) const
-{
- assert(Input::DynObj == pType ||
- Input::Archive == pType ||
- Input::Script == pType);
+const mcld::sys::fs::Path* SearchDirs::find(const std::string& pNamespec,
+ mcld::Input::Type pType) const {
+ assert(Input::DynObj == pType || Input::Archive == pType ||
+ Input::Script == pType);
std::string file;
- switch(pType) {
- case Input::Script:
- file.assign(pNamespec);
- break;
- case Input::DynObj:
- case Input::Archive :
- SpecToFilename(pNamespec, file);
- break;
- default:
- break;
- } // end of switch
+ switch (pType) {
+ case Input::Script:
+ file.assign(pNamespec);
+ break;
+ case Input::DynObj:
+ case Input::Archive:
+ SpecToFilename(pNamespec, file);
+ break;
+ default:
+ break;
+ } // end of switch
// for all MCLDDirectorys
DirList::const_iterator mcld_dir, mcld_dir_end = m_DirList.end();
@@ -167,42 +157,44 @@
MCLDDirectory::iterator entry = (*mcld_dir)->begin();
MCLDDirectory::iterator enEnd = (*mcld_dir)->end();
- switch(pType) {
- case Input::Script: {
- while (entry != enEnd) {
- if (file == entry.path()->filename())
- return entry.path();
- ++entry;
+ switch (pType) {
+ case Input::Script: {
+ while (entry != enEnd) {
+ if (file == entry.path()->filename().native())
+ return entry.path();
+ ++entry;
+ }
+ break;
}
- break;
- }
- case Input::DynObj: {
- while (entry != enEnd) {
- if (file == entry.path()->stem().native() ) {
- if (mcld::sys::fs::detail::shared_library_extension ==
+ case Input::DynObj: {
+ while (entry != enEnd) {
+ if (file == entry.path()->stem().native()) {
+ if (mcld::sys::fs::detail::shared_library_extension ==
entry.path()->extension().native()) {
+ return entry.path();
+ }
+ }
+ ++entry;
+ }
+ }
+ /** Fall through **/
+ case Input::Archive: {
+ entry = (*mcld_dir)->begin();
+ enEnd = (*mcld_dir)->end();
+ while (entry != enEnd) {
+ if (file == entry.path()->stem().native() &&
+ mcld::sys::fs::detail::static_library_extension ==
+ entry.path()->extension().native()) {
return entry.path();
}
+ ++entry;
}
- ++entry;
}
- }
- /** Fall through **/
- case Input::Archive : {
- entry = (*mcld_dir)->begin();
- enEnd = (*mcld_dir)->end();
- while ( entry!=enEnd ) {
- if (file == entry.path()->stem().native() &&
- mcld::sys::fs::detail::static_library_extension ==
- entry.path()->extension().native()) {
- return entry.path();
- }
- ++entry;
- }
- }
- default:
- break;
- } // end of switch
- } // end of for
+ default:
+ break;
+ } // end of switch
+ } // end of for
return NULL;
}
+
+} // namespace mcld
diff --git a/lib/MC/SymbolCategory.cpp b/lib/MC/SymbolCategory.cpp
index 3bd3df6..71a5bfd 100644
--- a/lib/MC/SymbolCategory.cpp
+++ b/lib/MC/SymbolCategory.cpp
@@ -6,26 +6,27 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/MC/SymbolCategory.h>
-#include <mcld/LD/LDSymbol.h>
-#include <mcld/LD/ResolveInfo.h>
+#include "mcld/MC/SymbolCategory.h"
+
+#include "mcld/LD/LDSymbol.h"
+#include "mcld/LD/ResolveInfo.h"
+
#include <algorithm>
#include <cassert>
-using namespace mcld;
+namespace mcld {
//===----------------------------------------------------------------------===//
// Category
-SymbolCategory::Category::Type
-SymbolCategory::Category::categorize(const ResolveInfo& pInfo)
-{
+SymbolCategory::Category::Type SymbolCategory::Category::categorize(
+ const ResolveInfo& pInfo) {
if (ResolveInfo::File == pInfo.type())
return Category::File;
if (ResolveInfo::Local == pInfo.binding())
return Category::Local;
if (ResolveInfo::Common == pInfo.desc())
return Category::Common;
- if (ResolveInfo::Default == pInfo.visibility() ||
+ if (ResolveInfo::Default == pInfo.visibility() ||
ResolveInfo::Protected == pInfo.visibility())
return Category::Dynamic;
return Category::Regular;
@@ -33,50 +34,46 @@
//===----------------------------------------------------------------------===//
// SymbolCategory
-SymbolCategory::SymbolCategory()
-{
- m_pFile = new Category(Category::File);
- m_pLocal = new Category(Category::Local);
+SymbolCategory::SymbolCategory() {
+ m_pFile = new Category(Category::File);
+ m_pLocal = new Category(Category::Local);
m_pLocalDyn = new Category(Category::LocalDyn);
- m_pCommon = new Category(Category::Common);
- m_pDynamic = new Category(Category::Dynamic);
- m_pRegular = new Category(Category::Regular);
+ m_pCommon = new Category(Category::Common);
+ m_pDynamic = new Category(Category::Dynamic);
+ m_pRegular = new Category(Category::Regular);
- m_pFile->next = m_pLocal;
- m_pLocal->next = m_pLocalDyn;
+ m_pFile->next = m_pLocal;
+ m_pLocal->next = m_pLocalDyn;
m_pLocalDyn->next = m_pCommon;
- m_pCommon->next = m_pDynamic;
- m_pDynamic->next = m_pRegular;
+ m_pCommon->next = m_pDynamic;
+ m_pDynamic->next = m_pRegular;
- m_pRegular->prev = m_pDynamic;
- m_pDynamic->prev = m_pCommon;
- m_pCommon->prev = m_pLocalDyn;
+ m_pRegular->prev = m_pDynamic;
+ m_pDynamic->prev = m_pCommon;
+ m_pCommon->prev = m_pLocalDyn;
m_pLocalDyn->prev = m_pLocal;
- m_pLocal->prev = m_pFile;
+ m_pLocal->prev = m_pFile;
}
-SymbolCategory::~SymbolCategory()
-{
+SymbolCategory::~SymbolCategory() {
Category* current = m_pFile;
- while (NULL != current) {
+ while (current != NULL) {
Category* tmp = current;
current = current->next;
delete tmp;
}
}
-SymbolCategory& SymbolCategory::add(LDSymbol& pSymbol, Category::Type pTarget)
-{
+SymbolCategory& SymbolCategory::add(LDSymbol& pSymbol, Category::Type pTarget) {
Category* current = m_pRegular;
m_OutputSymbols.push_back(&pSymbol);
// use non-stable bubble sort to arrange the order of symbols.
- while (NULL != current) {
+ while (current != NULL) {
if (current->type == pTarget) {
current->end++;
break;
- }
- else {
+ } else {
if (!current->empty()) {
std::swap(m_OutputSymbols[current->begin],
m_OutputSymbols[current->end]);
@@ -89,23 +86,20 @@
return *this;
}
-SymbolCategory& SymbolCategory::add(LDSymbol& pSymbol)
-{
- assert(NULL != pSymbol.resolveInfo());
+SymbolCategory& SymbolCategory::add(LDSymbol& pSymbol) {
+ assert(pSymbol.resolveInfo() != NULL);
return add(pSymbol, Category::categorize(*pSymbol.resolveInfo()));
}
-SymbolCategory& SymbolCategory::forceLocal(LDSymbol& pSymbol)
-{
+SymbolCategory& SymbolCategory::forceLocal(LDSymbol& pSymbol) {
return add(pSymbol, Category::Local);
}
SymbolCategory& SymbolCategory::arrange(LDSymbol& pSymbol,
Category::Type pSource,
- Category::Type pTarget)
-{
+ Category::Type pTarget) {
int distance = pTarget - pSource;
- if (0 == distance) {
+ if (distance == 0) {
// in the same category, do not need to re-arrange
return *this;
}
@@ -113,13 +107,13 @@
// source and target are not in the same category
// find the category of source
Category* current = m_pFile;
- while(NULL != current) {
+ while (current != NULL) {
if (pSource == current->type)
break;
current = current->next;
}
- assert(NULL != current);
+ assert(current != NULL);
size_t pos = 0;
if (!current->empty()) {
// find the position of source
@@ -158,8 +152,7 @@
do {
if (current->type == pTarget) {
break;
- }
- else {
+ } else {
assert(!current->isLast() && "target category is wrong.");
rear = current->end - 1;
std::swap(m_OutputSymbols[pos], m_OutputSymbols[rear]);
@@ -168,20 +161,18 @@
current->end--;
}
current = current->next;
- } while(NULL != current);
+ } while (current != NULL);
return *this;
- } // downward
+ } // downward
// The distance is negative. It means we should bubble sort upward.
if (distance < 0) {
-
// upward
do {
if (current->type == pTarget) {
break;
- }
- else {
+ } else {
assert(!current->isFirst() && "target category is wrong.");
std::swap(m_OutputSymbols[current->begin], m_OutputSymbols[pos]);
pos = current->begin;
@@ -189,282 +180,238 @@
current->prev->end++;
}
current = current->prev;
- } while(NULL != current);
+ } while (current != NULL);
return *this;
- } // upward
+ } // upward
return *this;
}
SymbolCategory& SymbolCategory::arrange(LDSymbol& pSymbol,
- const ResolveInfo& pSourceInfo)
-{
- assert(NULL != pSymbol.resolveInfo());
+ const ResolveInfo& pSourceInfo) {
+ assert(pSymbol.resolveInfo() != NULL);
return arrange(pSymbol,
Category::categorize(pSourceInfo),
Category::categorize(*pSymbol.resolveInfo()));
}
-SymbolCategory& SymbolCategory::changeCommonsToGlobal()
-{
+SymbolCategory& SymbolCategory::changeCommonsToGlobal() {
// Change Common to Dynamic/Regular
while (!emptyCommons()) {
size_t pos = m_pCommon->end - 1;
switch (Category::categorize(*(m_OutputSymbols[pos]->resolveInfo()))) {
- case Category::Dynamic:
- m_pCommon->end--;
- m_pDynamic->begin--;
- break;
- case Category::Regular:
- std::swap(m_OutputSymbols[pos], m_OutputSymbols[m_pDynamic->end - 1]);
- m_pCommon->end--;
- m_pDynamic->begin--;
- m_pDynamic->end--;
- m_pRegular->begin--;
- break;
- default:
- assert(0);
- break;
+ case Category::Dynamic:
+ m_pCommon->end--;
+ m_pDynamic->begin--;
+ break;
+ case Category::Regular:
+ std::swap(m_OutputSymbols[pos], m_OutputSymbols[m_pDynamic->end - 1]);
+ m_pCommon->end--;
+ m_pDynamic->begin--;
+ m_pDynamic->end--;
+ m_pRegular->begin--;
+ break;
+ default:
+ assert(0);
+ break;
}
}
return *this;
}
-SymbolCategory& SymbolCategory::changeToDynamic(LDSymbol& pSymbol)
-{
- assert(NULL != pSymbol.resolveInfo());
+SymbolCategory& SymbolCategory::changeToDynamic(LDSymbol& pSymbol) {
+ assert(pSymbol.resolveInfo() != NULL);
return arrange(pSymbol,
Category::categorize(*pSymbol.resolveInfo()),
Category::LocalDyn);
}
-size_t SymbolCategory::numOfSymbols() const
-{
+size_t SymbolCategory::numOfSymbols() const {
return m_OutputSymbols.size();
}
-size_t SymbolCategory::numOfFiles() const
-{
+size_t SymbolCategory::numOfFiles() const {
return m_pFile->size();
}
-size_t SymbolCategory::numOfLocals() const
-{
+size_t SymbolCategory::numOfLocals() const {
return m_pLocal->size();
}
-size_t SymbolCategory::numOfLocalDyns() const
-{
+size_t SymbolCategory::numOfLocalDyns() const {
return m_pLocalDyn->size();
}
-size_t SymbolCategory::numOfCommons() const
-{
+size_t SymbolCategory::numOfCommons() const {
return m_pCommon->size();
}
-size_t SymbolCategory::numOfDynamics() const
-{
+size_t SymbolCategory::numOfDynamics() const {
return m_pDynamic->size();
}
-size_t SymbolCategory::numOfRegulars() const
-{
+size_t SymbolCategory::numOfRegulars() const {
return m_pRegular->size();
}
-bool SymbolCategory::empty() const
-{
+bool SymbolCategory::empty() const {
return m_OutputSymbols.empty();
}
-bool SymbolCategory::emptyFiles() const
-{
+bool SymbolCategory::emptyFiles() const {
return m_pFile->empty();
}
-bool SymbolCategory::emptyLocals() const
-{
+bool SymbolCategory::emptyLocals() const {
return m_pLocal->empty();
}
-bool SymbolCategory::emptyLocalDyns() const
-{
+bool SymbolCategory::emptyLocalDyns() const {
return m_pLocalDyn->empty();
}
-bool SymbolCategory::emptyCommons() const
-{
+bool SymbolCategory::emptyCommons() const {
return m_pCommon->empty();
}
-bool SymbolCategory::emptyDynamics() const
-{
+bool SymbolCategory::emptyDynamics() const {
return m_pDynamic->empty();
}
-bool SymbolCategory::emptyRegulars() const
-{
+bool SymbolCategory::emptyRegulars() const {
return m_pRegular->empty();
}
-SymbolCategory::iterator SymbolCategory::begin()
-{
+SymbolCategory::iterator SymbolCategory::begin() {
return m_OutputSymbols.begin();
}
-SymbolCategory::iterator SymbolCategory::end()
-{
+SymbolCategory::iterator SymbolCategory::end() {
return m_OutputSymbols.end();
}
-SymbolCategory::const_iterator SymbolCategory::begin() const
-{
+SymbolCategory::const_iterator SymbolCategory::begin() const {
return m_OutputSymbols.begin();
}
-SymbolCategory::const_iterator SymbolCategory::end() const
-{
+SymbolCategory::const_iterator SymbolCategory::end() const {
return m_OutputSymbols.end();
}
-SymbolCategory::iterator SymbolCategory::fileBegin()
-{
+SymbolCategory::iterator SymbolCategory::fileBegin() {
return m_OutputSymbols.begin();
}
-SymbolCategory::iterator SymbolCategory::fileEnd()
-{
+SymbolCategory::iterator SymbolCategory::fileEnd() {
iterator iter = fileBegin();
iter += m_pFile->size();
return iter;
}
-SymbolCategory::const_iterator SymbolCategory::fileBegin() const
-{
+SymbolCategory::const_iterator SymbolCategory::fileBegin() const {
return m_OutputSymbols.begin();
}
-SymbolCategory::const_iterator SymbolCategory::fileEnd() const
-{
+SymbolCategory::const_iterator SymbolCategory::fileEnd() const {
const_iterator iter = fileBegin();
iter += m_pFile->size();
return iter;
}
-SymbolCategory::iterator SymbolCategory::localBegin()
-{
+SymbolCategory::iterator SymbolCategory::localBegin() {
return fileEnd();
}
-SymbolCategory::iterator SymbolCategory::localEnd()
-{
+SymbolCategory::iterator SymbolCategory::localEnd() {
iterator iter = localBegin();
iter += m_pLocal->size();
return iter;
}
-SymbolCategory::const_iterator SymbolCategory::localBegin() const
-{
+SymbolCategory::const_iterator SymbolCategory::localBegin() const {
return fileEnd();
}
-SymbolCategory::const_iterator SymbolCategory::localEnd() const
-{
+SymbolCategory::const_iterator SymbolCategory::localEnd() const {
const_iterator iter = localBegin();
iter += m_pLocal->size();
return iter;
}
-SymbolCategory::iterator SymbolCategory::localDynBegin()
-{
+SymbolCategory::iterator SymbolCategory::localDynBegin() {
return localEnd();
}
-SymbolCategory::iterator SymbolCategory::localDynEnd()
-{
+SymbolCategory::iterator SymbolCategory::localDynEnd() {
iterator iter = localDynBegin();
iter += m_pLocalDyn->size();
return iter;
}
-SymbolCategory::const_iterator SymbolCategory::localDynBegin() const
-{
+SymbolCategory::const_iterator SymbolCategory::localDynBegin() const {
return localEnd();
}
-SymbolCategory::const_iterator SymbolCategory::localDynEnd() const
-{
+SymbolCategory::const_iterator SymbolCategory::localDynEnd() const {
const_iterator iter = localDynBegin();
iter += m_pLocalDyn->size();
return iter;
}
-SymbolCategory::iterator SymbolCategory::commonBegin()
-{
+SymbolCategory::iterator SymbolCategory::commonBegin() {
return localDynEnd();
}
-SymbolCategory::iterator SymbolCategory::commonEnd()
-{
+SymbolCategory::iterator SymbolCategory::commonEnd() {
iterator iter = commonBegin();
iter += m_pCommon->size();
return iter;
}
-SymbolCategory::const_iterator SymbolCategory::commonBegin() const
-{
+SymbolCategory::const_iterator SymbolCategory::commonBegin() const {
return localDynEnd();
}
-SymbolCategory::const_iterator SymbolCategory::commonEnd() const
-{
+SymbolCategory::const_iterator SymbolCategory::commonEnd() const {
const_iterator iter = commonBegin();
iter += m_pCommon->size();
return iter;
}
-SymbolCategory::iterator SymbolCategory::dynamicBegin()
-{
+SymbolCategory::iterator SymbolCategory::dynamicBegin() {
return commonEnd();
}
-SymbolCategory::iterator SymbolCategory::dynamicEnd()
-{
+SymbolCategory::iterator SymbolCategory::dynamicEnd() {
iterator iter = dynamicBegin();
iter += m_pDynamic->size();
return iter;
}
-SymbolCategory::const_iterator SymbolCategory::dynamicBegin() const
-{
+SymbolCategory::const_iterator SymbolCategory::dynamicBegin() const {
return commonEnd();
}
-SymbolCategory::const_iterator SymbolCategory::dynamicEnd() const
-{
+SymbolCategory::const_iterator SymbolCategory::dynamicEnd() const {
const_iterator iter = dynamicBegin();
iter += m_pDynamic->size();
return iter;
}
-SymbolCategory::iterator SymbolCategory::regularBegin()
-{
- return commonEnd();
+SymbolCategory::iterator SymbolCategory::regularBegin() {
+ return dynamicEnd();
}
-SymbolCategory::iterator SymbolCategory::regularEnd()
-{
+SymbolCategory::iterator SymbolCategory::regularEnd() {
return m_OutputSymbols.end();
}
-SymbolCategory::const_iterator SymbolCategory::regularBegin() const
-{
- return commonEnd();
+SymbolCategory::const_iterator SymbolCategory::regularBegin() const {
+ return dynamicEnd();
}
-SymbolCategory::const_iterator SymbolCategory::regularEnd() const
-{
+SymbolCategory::const_iterator SymbolCategory::regularEnd() const {
return m_OutputSymbols.end();
}
+} // namespace mcld
diff --git a/lib/MC/ZOption.cpp b/lib/MC/ZOption.cpp
index 8b11765..c955967 100644
--- a/lib/MC/ZOption.cpp
+++ b/lib/MC/ZOption.cpp
@@ -6,14 +6,21 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/MC/ZOption.h>
+#include "mcld/MC/ZOption.h"
-using namespace mcld;
+namespace mcld {
//===----------------------------------------------------------------------===//
// ZOption
//===----------------------------------------------------------------------===//
-ZOption::ZOption()
- : m_Kind(Unknown), m_PageSize(0x0) {
+ZOption::ZOption() : ZOption(Unknown) {
}
+ZOption::ZOption(Kind pKind) : ZOption(pKind, 0x0) {
+}
+
+ZOption::ZOption(Kind pKind, uint64_t pPageSize)
+ : m_Kind(pKind), m_PageSize(pPageSize) {
+}
+
+} // namespace mcld