Пример #1
0
SymbolRef
ElfSymbol::CreateSymbol(Object& object, const StringTable& strtab) const
{
    SymbolRef sym(0);
    std::string name = strtab.getString(m_name_index);

    if (m_bind == STB_GLOBAL || m_bind == STB_WEAK)
    {
        sym = object.getSymbol(name);
        if (m_index == SHN_UNDEF)
            sym->Declare(Symbol::EXTERN);
        else
            sym->Declare(Symbol::GLOBAL);
    }
    else
    {
        // don't index by name, just append
        sym = object.AppendSymbol(name);
    }

    if (m_index == SHN_ABS)
    {
        if (hasSize())
            sym->DefineEqu(m_size);
        else
            sym->DefineEqu(Expr(0));
    }
    else if (m_index == SHN_COMMON)
    {
        sym->Declare(Symbol::COMMON);
    }
    else if (m_sect != 0)
    {
        Location loc = {&m_sect->bytecodes_front(), m_value.getUInt()};
        sym->DefineLabel(loc);
    }

    return sym;
}
Пример #2
0
bool LocalizedString::loadFromStream(std::istream& in_Stream, const uint32_t subHeader,
                        const bool withHeader, uint32_t& bytesRead,
                        const bool localized, const StringTable& table,
                        char* buffer)
{
  if (withHeader)
  {
    uint32_t subRecName = 0;
    //read header
    in_Stream.read((char*) &subRecName, 4);
    bytesRead += 4;
    if (subRecName!=subHeader)
    {
      UnexpectedRecord(subHeader, subRecName);
      return false;
    }
  }//if with header

  //subrecord's length
  uint16_t subLength = 0;
  in_Stream.read((char*) &subLength, 2);
  bytesRead += 2;
  if (localized)
  {
    if (subLength!=4)
    {
      std::cout << "Error: sub record " << IntTo4Char(subHeader)
                << " has invalid length (" << subLength
                << " bytes). Should be four bytes.\n";
      return false;
    }
    //read value
    in_Stream.read((char*) &m_Index, 4);
    bytesRead += 4;
    if (!in_Stream.good())
    {
      std::cout << "LocalizedString::loadFromStream: Error while reading subrecord "
                << IntTo4Char(subHeader)<<"!\n";
      return false;
    }
    //treat index zero as empty string, some subrecords allow zero as index
    if (m_Index==0)
    {
      m_String.clear();
      m_Type = lsIndex;
      return true;
    }//if zero
    if (!table.hasString(m_Index))
    {
      std::cout << "LocalizedString::loadFromStream: table has no entry for index "<<m_Index<<"!\n";
      return false;
    }
    m_String = table.getString(m_Index);
    m_Type = lsIndex;
  }
  else
  {
    //unlocalized (plain string)
    if (subLength>511)
    {
      std::cout <<"Error: subrecord "<<IntTo4Char(subHeader)<<" is longer than 511 characters!\n";
      return false;
    }
    //read string
    memset(buffer, 0, 512);
    in_Stream.read(buffer, subLength);
    bytesRead += subLength;
    if (!in_Stream.good())
    {
      std::cout << "Error while reading subrecord "<<IntTo4Char(subHeader)<<"!\n";
      return false;
    }
    m_String = std::string(buffer);
    m_Type = lsString;
  }
  return true;
}