xref: /frameworks/rs/cpu_ref/linkloader/include/impl/ELFSymbol.hxx

/*
 * Copyright 2011, The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef ELF_SYMBOL_HXX
#define ELF_SYMBOL_HXX

#include "ELFSectionHeaderTable.h"
#include "ELFSection.h"
#include "ELFSectionStrTab.h"

#include "ELFObject.h"
#include "ELFSectionHeaderTable.h"
#include "ELFSectionProgBits.h"
#include "ELFSectionNoBits.h"

#include "utils/rsl_assert.h"
#include "ELF.h"

template <unsigned Bitwidth>
inline char const *ELFSymbol_CRTP<Bitwidth>::getName() const {
  ELFSectionHeaderTableTy const &shtab = *owner->getSectionHeaderTable();
  size_t const index = shtab.getByName(std::string(".strtab"))->getIndex();
  ELFSectionTy const *section = owner->getSectionByIndex(index);
  ELFSectionStrTabTy const &strtab =
    *static_cast<ELFSectionStrTabTy const *>(section);
  return strtab[getNameIndex()];
}

template <unsigned Bitwidth>
template <typename Archiver>
inline ELFSymbol<Bitwidth> *
ELFSymbol_CRTP<Bitwidth>::read(Archiver &AR,
                               ELFObjectTy const *owner,
                               size_t index) {
  if (!AR) {
    // Archiver is in bad state before calling read function.
    // Return NULL and do nothing.
    return 0;
  }

  std::unique_ptr<ELFSymbolTy> sh(new ELFSymbolTy());

  if (!sh->serialize(AR)) {
    // Unable to read the structure.  Return NULL.
    return 0;
  }

  if (!sh->isValid()) {
    // SymTabEntry read from archiver is not valid.  Return NULL.
    return 0;
  }

  // Set the section header index
  sh->index = index;

  // Set the owner elf object
  sh->owner = owner;

  return sh.release();
}

template <unsigned Bitwidth>
inline void ELFSymbol_CRTP<Bitwidth>::print(bool shouldPrintHeader) const {
  using namespace llvm;

  if (shouldPrintHeader) {
    out() << '\n' << fillformat('=', 79) << '\n';
    out().changeColor(raw_ostream::WHITE, true);
    out() << "ELF Symbol Table Entry "
          << this->getIndex() << '\n';
    out().resetColor();
    out() << fillformat('-', 79) << '\n';
  } else {
    out() << fillformat('-', 79) << '\n';
    out().changeColor(raw_ostream::YELLOW, true);
    out() << "ELF Symbol Table Entry "
          << this->getIndex() << " : " << '\n';
    out().resetColor();
  }

#define PRINT_LINT(title, value) \
  out() << format("  %-11s : ", (char const *)(title)) << (value) << '\n'
  PRINT_LINT("Name",        getName()                                    );
  PRINT_LINT("Type",        getTypeStr(getType())                        );
  PRINT_LINT("Bind",        getBindingAttributeStr(getBindingAttribute()));
  PRINT_LINT("Visibility",  getVisibilityStr(getVisibility())            );
  PRINT_LINT("Shtab Index", getSectionIndex()                            );
  PRINT_LINT("Value",       getValue()                                   );
  PRINT_LINT("Size",        getSize()                                    );
#undef PRINT_LINT

// TODO: Horizontal type or vertical type can use option to decide.
#if 0
  using namespace term::color;
  using namespace std;

  cout << setw(20) << getName() <<
          setw(10) << getTypeStr(getType()) <<
          setw(10) << getBindingAttributeStr(getBindingAttribute()) <<
          setw(15) << getVisibilityStr(getVisibility()) <<
          setw(10) << getSectionIndex() <<
          setw(7) << getValue() <<
          setw(7) << getSize() <<
          endl;
#endif
}

template <unsigned Bitwidth>
void *ELFSymbol_CRTP<Bitwidth>::getAddress(int machine, bool autoAlloc) const {
  if (my_addr != 0) {
    return my_addr;
  }
  size_t idx = (size_t)getSectionIndex();
  switch (getType()) {
    default:
      break;

    case STT_OBJECT:
      switch (idx) {
        default:
          {
            ELFSectionHeaderTableTy const *header =
              owner->getSectionHeaderTable();

            unsigned section_type = (*header)[idx]->getType();

            rsl_assert((section_type == SHT_PROGBITS ||
                        section_type == SHT_NOBITS) &&
                       "STT_OBJECT with not BITS section.");

            if (section_type == SHT_NOBITS) {
              // FIXME(logan): This is a workaround for .lcomm directives
              // bug of LLVM ARM MC code generator.  Remove this when the
              // LLVM bug is fixed.

              size_t align = 16;

              my_addr = const_cast<ELFObjectTy *>(owner)->
                allocateSHNCommonData((size_t)getSize(), align);

              if (!my_addr) {
                rsl_assert(0 && "Unable to allocate memory for SHN_COMMON.");
                abort();
              }
            } else {
              ELFSectionTy const *sec = owner->getSectionByIndex(idx);
              rsl_assert(sec != 0 && "STT_OBJECT with null section.");

              ELFSectionBitsTy const &st =
                static_cast<ELFSectionBitsTy const &>(*sec);
              my_addr =const_cast<unsigned char *>(&st[0] + (off_t)getValue());
            }
          }
          break;

        case SHN_COMMON:
          {
            if (!autoAlloc) {
              return NULL;
            }
#if 0
#if _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600
            if (posix_memalign(&my_addr,
                               std::max((size_t)getValue(), sizeof(void*)),
                               (size_t)getSize()) != 0) {
              rsl_assert(0 && "posix_memalign failed.");
            }
#else
            my_addr = memalign(std::max((size_t)getValue(), sizeof(void *)),
                               (size_t)getSize());

            rsl_assert(my_addr != NULL && "memalign failed.");
#endif
            if (my_addr) {
              memset(my_addr, '\0', getSize());
            }
#else
            size_t align = (size_t)getValue();
            my_addr = const_cast<ELFObjectTy *>(owner)->
                          allocateSHNCommonData((size_t)getSize(), align);
            if (!my_addr) {
              rsl_assert(0 && "Unable to allocate memory for SHN_COMMON.");
              abort();
            }
#endif
          }
          break;

        case SHN_UNDEF:
          if (machine == EM_MIPS && strcmp(getName(), "_gp_disp") == 0) // OK for MIPS
            break;

        case SHN_ABS:
        case SHN_XINDEX:
          rsl_assert(0 && "STT_OBJECT with special st_shndx.");
          break;
      }
      break;


    case STT_FUNC:
      switch (idx) {
        default:
          {
#ifndef NDEBUG
            ELFSectionHeaderTableTy const *header =
              owner->getSectionHeaderTable();
            rsl_assert((*header)[idx]->getType() == SHT_PROGBITS &&
                   "STT_FUNC with not PROGBITS section.");
#endif
            ELFSectionTy const *sec = owner->getSectionByIndex(idx);
            rsl_assert(sec != 0 && "STT_FUNC with null section.");

            ELFSectionProgBitsTy const &st =
              static_cast<ELFSectionProgBitsTy const &>(*sec);
            my_addr = const_cast<unsigned char *>(&st[0] + (off_t)getValue());
          }
          break;

        case SHN_ABS:
        case SHN_COMMON:
        case SHN_UNDEF:
        case SHN_XINDEX:
          rsl_assert(0 && "STT_FUNC with special st_shndx.");
          break;
      }
      break;


    case STT_SECTION:
      switch (idx) {
        default:
          {
#ifndef NDEBUG
            ELFSectionHeaderTableTy const *header =
              owner->getSectionHeaderTable();
            rsl_assert(((*header)[idx]->getType() == SHT_PROGBITS ||
                    (*header)[idx]->getType() == SHT_NOBITS) &&
                   "STT_SECTION with not BITS section.");
#endif
            ELFSectionTy const *sec = owner->getSectionByIndex(idx);
            rsl_assert(sec != 0 && "STT_SECTION with null section.");

            ELFSectionBitsTy const &st =
              static_cast<ELFSectionBitsTy const &>(*sec);
            my_addr = const_cast<unsigned char *>(&st[0] + (off_t)getValue());
          }
          break;

        case SHN_ABS:
        case SHN_COMMON:
        case SHN_UNDEF:
        case SHN_XINDEX:
          rsl_assert(0 && "STT_SECTION with special st_shndx.");
          break;
      }
      break;

    case STT_NOTYPE:
      switch (idx) {
        default:
          {
#ifndef NDEBUG
            ELFSectionHeaderTableTy const *header =
              owner->getSectionHeaderTable();
            rsl_assert(((*header)[idx]->getType() == SHT_PROGBITS ||
                    (*header)[idx]->getType() == SHT_NOBITS) &&
                   "STT_SECTION with not BITS section.");
#endif
            ELFSectionTy const *sec = owner->getSectionByIndex(idx);
            rsl_assert(sec != 0 && "STT_SECTION with null section.");

            ELFSectionBitsTy const &st =
              static_cast<ELFSectionBitsTy const &>(*sec);
            my_addr = const_cast<unsigned char *>(&st[0] + (off_t)getValue());
          }
          break;

        case SHN_ABS:
        case SHN_COMMON:
        case SHN_XINDEX:
          rsl_assert(0 && "STT_SECTION with special st_shndx.");
          break;
        case SHN_UNDEF:
          return 0;
      }
      break;
      return 0;

    case STT_COMMON:
    case STT_FILE:
    case STT_TLS:
    case STT_LOOS:
    case STT_HIOS:
    case STT_LOPROC:
    case STT_HIPROC:
      rsl_assert(0 && "Not implement.");
      return 0;
  }
  return my_addr;
}

#endif // ELF_SYMBOL_HXX