xref: /frameworks/compile/mclinker/lib/Object/ObjectBuilder.cpp

//===- ObjectBuilder.cpp --------------------------------------------------===//
//
//                     The MCLinker Project
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "mcld/Object/ObjectBuilder.h"

#include "mcld/IRBuilder.h"
#include "mcld/LinkerScript.h"
#include "mcld/Module.h"
#include "mcld/Fragment/AlignFragment.h"
#include "mcld/Fragment/FillFragment.h"
#include "mcld/Fragment/NullFragment.h"
#include "mcld/LD/DebugString.h"
#include "mcld/LD/EhFrame.h"
#include "mcld/LD/LDSection.h"
#include "mcld/LD/SectionData.h"
#include "mcld/Object/SectionMap.h"

#include <llvm/Support/Casting.h>

namespace mcld {

//===----------------------------------------------------------------------===//
// ObjectBuilder
//===----------------------------------------------------------------------===//
ObjectBuilder::ObjectBuilder(Module& pTheModule) : m_Module(pTheModule) {
}

/// CreateSection - create an output section.
LDSection* ObjectBuilder::CreateSection(const std::string& pName,
                                        LDFileFormat::Kind pKind,
                                        uint32_t pType,
                                        uint32_t pFlag,
                                        uint32_t pAlign) {
  // try to get one from output LDSection
  SectionMap::const_mapping pair =
      m_Module.getScript().sectionMap().find("*", pName);

  std::string output_name = (pair.first == NULL) ? pName : pair.first->name();

  LDSection* output_sect = m_Module.getSection(output_name);
  if (output_sect == NULL) {
    output_sect = LDSection::Create(pName, pKind, pType, pFlag);
    output_sect->setAlign(pAlign);
    m_Module.getSectionTable().push_back(output_sect);
  }
  return output_sect;
}

/// MergeSection - merge the pInput section to the pOutput section
LDSection* ObjectBuilder::MergeSection(const Input& pInputFile,
                                       LDSection& pInputSection) {
  SectionMap::mapping pair = m_Module.getScript().sectionMap().find(
      pInputFile.path().native(), pInputSection.name());

  if (pair.first != NULL && pair.first->isDiscard()) {
    pInputSection.setKind(LDFileFormat::Ignore);
    return NULL;
  }

  std::string output_name =
      (pair.first == NULL) ? pInputSection.name() : pair.first->name();
  LDSection* target = m_Module.getSection(output_name);

  if (target == NULL) {
    target = LDSection::Create(output_name,
                               pInputSection.kind(),
                               pInputSection.type(),
                               pInputSection.flag());
    target->setAlign(pInputSection.align());
    m_Module.getSectionTable().push_back(target);
  }

  switch (target->kind()) {
    case LDFileFormat::EhFrame: {
      EhFrame* eh_frame = NULL;
      if (target->hasEhFrame())
        eh_frame = target->getEhFrame();
      else
        eh_frame = IRBuilder::CreateEhFrame(*target);

      eh_frame->merge(pInputFile, *pInputSection.getEhFrame());
      UpdateSectionAlign(*target, pInputSection);
      return target;
    }
    case LDFileFormat::DebugString: {
      DebugString* debug_str = NULL;
      if (target->hasDebugString())
        debug_str = target->getDebugString();
      else
        debug_str = IRBuilder::CreateDebugString(*target);

      debug_str->merge(pInputSection);
      UpdateSectionAlign(*target, pInputSection);
      return target;
    }
    default: {
      if (!target->hasSectionData())
        IRBuilder::CreateSectionData(*target);

      SectionData* data = NULL;
      if (pair.first != NULL) {
        assert(pair.second != NULL);
        data = pair.second->getSection()->getSectionData();

        // force input alignment from ldscript if any
        if (pair.first->prolog().hasSubAlign()) {
          pInputSection.setAlign(pair.second->getSection()->align());
        }
      } else {
        // orphan section
        data = target->getSectionData();
      }

      if (MoveSectionData(*pInputSection.getSectionData(), *data)) {
        UpdateSectionAlign(*target, pInputSection);
        return target;
      }
      return NULL;
    }
  }
  return target;
}

/// MoveSectionData - move the fragments of pTO section data to pTo
bool ObjectBuilder::MoveSectionData(SectionData& pFrom, SectionData& pTo) {
  assert(&pFrom != &pTo && "Cannot move section data to itself!");

  uint64_t offset = pTo.getSection().size();
  AlignFragment* align = NULL;
  if (pFrom.getSection().align() > 1) {
    // if the align constraint is larger than 1, append an alignment
    unsigned int alignment = pFrom.getSection().align();
    align = new AlignFragment(/*alignment*/alignment,
                              /*the filled value*/0x0,
                              /*the size of filled value*/1u,
                              /*max bytes to emit*/alignment - 1);
    align->setOffset(offset);
    align->setParent(&pTo);
    pTo.getFragmentList().push_back(align);
    offset += align->size();
  }

  // move fragments from pFrom to pTO
  SectionData::FragmentListType& from_list = pFrom.getFragmentList();
  SectionData::FragmentListType& to_list = pTo.getFragmentList();
  SectionData::FragmentListType::iterator frag, fragEnd = from_list.end();
  for (frag = from_list.begin(); frag != fragEnd; ++frag) {
    frag->setParent(&pTo);
    frag->setOffset(offset);
    offset += frag->size();
  }
  to_list.splice(to_list.end(), from_list);

  // set up pTo's header
  pTo.getSection().setSize(offset);

  return true;
}

/// UpdateSectionAlign - update alignment for input section
void ObjectBuilder::UpdateSectionAlign(LDSection& pTo, const LDSection& pFrom) {
  if (pFrom.align() > pTo.align())
    pTo.setAlign(pFrom.align());
}

/// UpdateSectionAlign - update alignment for input section
void ObjectBuilder::UpdateSectionAlign(LDSection& pSection,
                                       uint32_t pAlignConstraint) {
  if (pSection.align() < pAlignConstraint)
    pSection.setAlign(pAlignConstraint);
}

/// AppendFragment - To append pFrag to the given SectionData pSD.
uint64_t ObjectBuilder::AppendFragment(Fragment& pFrag,
                                       SectionData& pSD,
                                       uint32_t pAlignConstraint) {
  // get initial offset.
  uint64_t offset = 0;
  if (!pSD.empty())
    offset = pSD.back().getOffset() + pSD.back().size();

  AlignFragment* align = NULL;
  if (pAlignConstraint > 1) {
    // if the align constraint is larger than 1, append an alignment
    align = new AlignFragment(/*alignment*/pAlignConstraint,
                              /*the filled value*/0x0,
                              /*the size of filled value*/1u,
                              /*max bytes to emit*/pAlignConstraint - 1);
    align->setOffset(offset);
    align->setParent(&pSD);
    pSD.getFragmentList().push_back(align);
    offset += align->size();
  }

  // append the fragment
  pFrag.setParent(&pSD);
  pFrag.setOffset(offset);
  pSD.getFragmentList().push_back(&pFrag);

  // append the null fragment
  offset += pFrag.size();
  NullFragment* null = new NullFragment(&pSD);
  null->setOffset(offset);

  if (align != NULL)
    return align->size() + pFrag.size();
  else
    return pFrag.size();
}

}  // namespace mcld