SymbolsX.h

Go to the documentation of this file.

 
#include "MachoX.h"
 
STATIC
BOOLEAN
InternalSymbolIsSectionType (
  IN CONST MACH_NLIST_X  *Symbol
  )
{
  ASSERT (Symbol != NULL);
 
  if ((Symbol->Type & MACH_N_TYPE_STAB) != 0) {
    switch (Symbol->Type) {
      //
      // Labeled as MACH_N_sect in stab.h
      //
      case MACH_N_FUN:
      case MACH_N_STSYM:
      case MACH_N_LCSYM:
      case MACH_N_BNSYM:
      case MACH_N_SLINE:
      case MACH_N_ENSYM:
      case MACH_N_SO:
      case MACH_N_SOL:
      case MACH_N_ENTRY:
      case MACH_N_ECOMM:
      case MACH_N_ECOML:
      //
      // These are labeled as NO_SECT in stab.h, but they are actually
      // section-based on OS X.  We must mark them as such so they get
      // relocated.
      //
      case MACH_N_RBRAC:
      case MACH_N_LBRAC:
      {
        return TRUE;
      }
 
      default:
      {
        break;
      }
    }
  } else if ((Symbol->Type & MACH_N_TYPE_TYPE) == MACH_N_TYPE_SECT) {
    return TRUE;
  }
 
  return FALSE;
}
 
STATIC
MACH_NLIST_X *
MACH_X (
  InternalGetSymbolByValue
  )(
    IN OUT OC_MACHO_CONTEXT   *Context,
    IN     MACH_UINT_X        Value
    ) {
  UINT32  Index;
 
  ASSERT (Context->SymbolTable != NULL);
  ASSERT (Context->Symtab != NULL);
 
  for (Index = 0; Index < Context->Symtab->NumSymbols; ++Index) {
    if ((MACH_X (&Context->SymbolTable->Symbol))[Index].Value == Value) {
      return &(MACH_X (&Context->SymbolTable->Symbol))[Index];
    }
  }
 
  return NULL;
}
 
STATIC
BOOLEAN
InternalGetSymbolByExternRelocationOffset (
  IN OUT OC_MACHO_CONTEXT  *Context,
  IN     MACH_UINT_X       Address,
  OUT    MACH_NLIST_X      **Symbol
  )
{
  CONST MACH_RELOCATION_INFO  *Relocation;
 
  ASSERT (Context != NULL);
  MACH_ASSERT_X (Context);
 
  Relocation = InternalGetExternRelocationByOffset (Context, Address);
  if (Relocation != NULL) {
    *Symbol = MACH_X (MachoGetSymbolByIndex)(Context, Relocation->SymbolNumber);
    return TRUE;
  }
 
  return FALSE;
}
 
STATIC
MACH_NLIST_X *
InternalGetLocalDefinedSymbolByNameWorker (
  IN OUT OC_MACHO_CONTEXT  *Context,
  IN     MACH_NLIST_X      *SymbolTable,
  IN     UINT32            NumberOfSymbols,
  IN     CONST CHAR8       *Name
  )
{
  UINT32       Index;
  CONST CHAR8  *TmpName;
 
  ASSERT (SymbolTable != NULL);
  ASSERT (Name != NULL);
 
  for (Index = 0; Index < NumberOfSymbols; ++Index) {
    if (!MACH_X (InternalSymbolIsSane)(Context, &SymbolTable[Index])) {
      break;
    }
 
    if (!MACH_X (MachoSymbolIsDefined)(&SymbolTable[Index])) {
      continue;
    }
 
    TmpName = MACH_X (MachoGetSymbolName)(Context, &SymbolTable[Index]);
    if (AsciiStrCmp (Name, TmpName) == 0) {
      return &SymbolTable[Index];
    }
  }
 
  return NULL;
}
 
BOOLEAN
MACH_X (
  InternalSymbolIsSane
  )(
          IN OUT OC_MACHO_CONTEXT     *Context,
          IN     CONST MACH_NLIST_X   *Symbol
          ) {
  ASSERT (Context != NULL);
  ASSERT (Symbol != NULL);
  MACH_ASSERT_X (Context);
 
  ASSERT (Context->SymbolTable != NULL);
  ASSERT (Context->Symtab->NumSymbols > 0);
 
  ASSERT (
    (  (Symbol >= &(MACH_X (&Context->SymbolTable->Symbol))[0])
    && (Symbol < &(MACH_X (&Context->SymbolTable->Symbol))[Context->Symtab->NumSymbols]))
    );
  //
  // Symbol->Section is implicitly verified by MachoGetSectionByIndex() when
  // passed to it.
  //
  if (Symbol->UnifiedName.StringIndex >= Context->Symtab->StringsSize) {
    return FALSE;
  }
 
  return TRUE;
}
 
BOOLEAN
MACH_X (
  InternalMachoSymbolGetDirectFileOffset
  )(
                     IN OUT OC_MACHO_CONTEXT       *Context,
                     IN     MACH_UINT_X            Address,
                     OUT    UINT32                 *FileOffset,
                     OUT    UINT32                 *MaxSize OPTIONAL
                     ) {
  MACH_UINT_X             Offset;
  MACH_UINT_X             Base;
  MACH_UINT_X             Size;
  MACH_SEGMENT_COMMAND_X  *Segment;
 
  ASSERT (Context != NULL);
  ASSERT (FileOffset != NULL);
  MACH_ASSERT_X (Context);
 
  for (
       Segment = MACH_X (MachoGetNextSegment)(Context, NULL);
       Segment != NULL;
       Segment = MACH_X (MachoGetNextSegment)(Context, Segment)
       )
  {
    if (  (Address >= Segment->VirtualAddress)
       && (Address < (Segment->VirtualAddress + Segment->Size)))
    {
      break;
    }
  }
 
  if (Segment == NULL) {
    return FALSE;
  }
 
  Offset = Address - Segment->VirtualAddress;
  Base   = Segment->FileOffset;
  Size   = Segment->Size;
 
  *FileOffset = MACH_X_TO_UINT32 (Base + Offset);
 
  if (MaxSize != NULL) {
    *MaxSize = MACH_X_TO_UINT32 (Size - Offset);
  }
 
  return TRUE;
}
 
BOOLEAN
MACH_X (
  MachoIsSymbolValueInRange
  )(
                 IN OUT OC_MACHO_CONTEXT     *Context,
                 IN     CONST MACH_NLIST_X   *Symbol
                 ) {
  CONST MACH_SEGMENT_COMMAND_X  *Segment;
 
  ASSERT (Context != NULL);
  ASSERT (Symbol != NULL);
  MACH_ASSERT_X (Context);
 
  if (MACH_X (MachoSymbolIsLocalDefined)(Context, Symbol)) {
    for (
         Segment = MACH_X (MachoGetNextSegment)(Context, NULL);
         Segment != NULL;
         Segment = MACH_X (MachoGetNextSegment)(Context, Segment)
         )
    {
      if (  (Symbol->Value >= Segment->VirtualAddress)
         && (Symbol->Value < (Segment->VirtualAddress + Segment->Size)))
      {
        return TRUE;
      }
    }
 
    return FALSE;
  }
 
  return TRUE;
}
 
BOOLEAN
MACH_X (
  MachoSymbolIsSection
  )(
                     IN CONST MACH_NLIST_X   *Symbol
                     ) {
  ASSERT (Symbol != NULL);
  return (InternalSymbolIsSectionType (Symbol) && (Symbol->Section != NO_SECT));
}
 
BOOLEAN
MACH_X (
  MachoSymbolIsDefined
  )(
            IN CONST MACH_NLIST_X   *Symbol
            ) {
  ASSERT (Symbol != NULL);
 
  return (  ((Symbol->Type & MACH_N_TYPE_STAB) == 0)
         && (  ((Symbol->Type & MACH_N_TYPE_TYPE) == MACH_N_TYPE_ABS)
            || InternalSymbolIsSectionType (Symbol)));
}
 
BOOLEAN
MACH_X (
  MachoSymbolIsLocalDefined
  )(
                 IN OUT OC_MACHO_CONTEXT     *Context,
                 IN     CONST MACH_NLIST_X   *Symbol
                 ) {
  CONST MACH_DYSYMTAB_COMMAND  *DySymtab;
  CONST MACH_NLIST_X           *UndefinedSymbols;
  CONST MACH_NLIST_X           *UndefinedSymbolsTop;
 
 #ifdef SOLVE_INDR
  CONST MACH_NLIST_X  *ExternalSymbols;
  CONST MACH_NLIST_X  *ExternalSymbolsTop;
 #endif
 
  ASSERT (Context != NULL);
  ASSERT (Symbol != NULL);
  MACH_ASSERT_X (Context);
 
  DySymtab = Context->DySymtab;
  ASSERT (Context->SymbolTable != NULL);
 
  if ((DySymtab == NULL) || (DySymtab->NumUndefinedSymbols == 0)) {
    return FALSE; // FIXME: Required under 32-bit during vtable parent resolution, if using MH_OBJECT.
  }
 
  //
  // The symbol must have been declared locally prior to solving.  As there is
  // no information on whether the symbol has been solved explicitely, check
  // its storage location for Undefined or Indirect.
  //
  UndefinedSymbols    = &(MACH_X (&Context->SymbolTable->Symbol))[DySymtab->UndefinedSymbolsIndex];
  UndefinedSymbolsTop = &UndefinedSymbols[DySymtab->NumUndefinedSymbols];
 
  if ((Symbol >= UndefinedSymbols) && (Symbol < UndefinedSymbolsTop)) {
    return FALSE;
  }
 
 #ifdef SOLVE_INDR
  //
  // If a symbol is marked as external, but is outside the external symbol
  // range, it is likely a resolved indirect symbol.
  //
  if (Symbol->Type == (MACH_N_TYPE_ABS | MACH_N_TYPE_EXT)) {
    ExternalSymbols    = &(MACH_X (&Context->SymbolTable->Symbol))[DySymtab->ExternalSymbolsIndex];
    ExternalSymbolsTop = &ExternalSymbols[DySymtab->NumExternalSymbols];
 
    if (!((Symbol >= ExternalSymbols) && (Symbol < ExternalSymbolsTop))) {
      return FALSE;
    }
  }
 
 #endif
 
  return MACH_X (MachoSymbolIsDefined)(Symbol);
}
 
MACH_NLIST_X *
MACH_X (
  MachoGetSymbolByIndex
  )(
           IN OUT OC_MACHO_CONTEXT  *Context,
           IN     UINT32            Index
           ) {
  MACH_NLIST_X  *Symbol;
 
  ASSERT (Context != NULL);
  MACH_ASSERT_X (Context);
 
  if (!InternalRetrieveSymtabs (Context)) {
    return NULL;
  }
 
  ASSERT (Context->SymbolTable != NULL);
 
  if (Index < Context->Symtab->NumSymbols) {
    Symbol = &(MACH_X (&Context->SymbolTable->Symbol))[Index];
    if (MACH_X (InternalSymbolIsSane)(Context, Symbol)) {
      return Symbol;
    }
  }
 
  return NULL;
}
 
CONST CHAR8 *
MACH_X (
  MachoGetSymbolName
  )(
          IN OUT OC_MACHO_CONTEXT     *Context,
          IN     CONST MACH_NLIST_X   *Symbol
          ) {
  ASSERT (Context != NULL);
  ASSERT (Symbol != NULL);
  MACH_ASSERT_X (Context);
 
  ASSERT (Context->SymbolTable != NULL);
  ASSERT (Context->Symtab->StringsSize > Symbol->UnifiedName.StringIndex);
 
  return (Context->StringTable + Symbol->UnifiedName.StringIndex);
}
 
CONST CHAR8 *
MACH_X (
  MachoGetIndirectSymbolName
  )(
    IN OUT OC_MACHO_CONTEXT     *Context,
    IN     CONST MACH_NLIST_X   *Symbol
    ) {
  ASSERT (Context != NULL);
  ASSERT (Symbol != NULL);
  MACH_ASSERT_X (Context);
 
  ASSERT (Context->SymbolTable != NULL);
 
  if (  ((Symbol->Type & MACH_N_TYPE_STAB) != 0)
     || ((Symbol->Type & MACH_N_TYPE_TYPE) != MACH_N_TYPE_INDR))
  {
    return NULL;
  }
 
  if (Context->Symtab->StringsSize <= Symbol->Value) {
    return NULL;
  }
 
  return (Context->StringTable + Symbol->Value);
}
 
BOOLEAN
MACH_X (
  MachoGetSymbolByExternRelocationOffset
  )(
    IN OUT OC_MACHO_CONTEXT   *Context,
    IN     MACH_UINT_X        Address,
    OUT    MACH_NLIST_X       **Symbol
    ) {
  if (Address >= MachoGetFileSize (Context)) {
    return FALSE;
  }
 
  return InternalGetSymbolByExternRelocationOffset (
           Context,
           Address,
           Symbol
           );
}
 
BOOLEAN
MACH_X (
  MachoGetSymbolByRelocationOffset
  )(
           IN OUT OC_MACHO_CONTEXT   *Context,
           IN     MACH_UINT_X        Address,
           OUT    MACH_NLIST_X       **Symbol
           ) {
  BOOLEAN                     Result;
  CONST MACH_RELOCATION_INFO  *Relocation;
  CONST MACH_UINT_X           *Data;
  MACH_NLIST_X                *Sym;
  MACH_UINT_X                 AddressTop;
  UINT32                      MaxSize;
 
  VOID  *Tmp;
 
  ASSERT (Context != NULL);
  MACH_ASSERT_X (Context);
 
  Result = MACH_X (BaseOverflowAddU)(Address, sizeof (MACH_UINT_X), &AddressTop);
  if (Result || (AddressTop > MachoGetFileSize (Context))) {
    return FALSE;
  }
 
  Result = InternalGetSymbolByExternRelocationOffset (
             Context,
             Address,
             Symbol
             );
  if (Result) {
    return TRUE;
  }
 
  Relocation = InternalGetLocalRelocationByOffset (Context, Address);
  if (Relocation != NULL) {
    Sym = NULL;
 
    Tmp = (VOID *)MachoGetFilePointerByAddress (Context, Address, &MaxSize);
    if ((Tmp == NULL) || (MaxSize < sizeof (MACH_UINT_X))) {
      return FALSE;
    }
 
    if (BASE_TYPE_ALIGNED (MACH_UINT_X, Tmp)) {
      Data = (MACH_UINT_X *)Tmp;
 
      // FIXME: Only C++ symbols.
      Sym = MACH_X (InternalGetSymbolByValue)(Context, *Data);
      if ((Sym != NULL) && !MACH_X (InternalSymbolIsSane)(Context, Sym)) {
        Sym = NULL;
      }
    }
 
    *Symbol = Sym;
    return TRUE;
  }
 
  return FALSE;
}
 
MACH_NLIST_X *
MACH_X (
  MachoGetLocalDefinedSymbolByName
  )(
                              IN OUT OC_MACHO_CONTEXT   *Context,
                              IN     CONST CHAR8        *Name
                              ) {
  MACH_NLIST_X                 *SymbolTable;
  CONST MACH_DYSYMTAB_COMMAND  *DySymtab;
  MACH_NLIST_X                 *Symbol;
 
  ASSERT (Context != NULL);
  ASSERT (Name != NULL);
  MACH_ASSERT_X (Context);
 
  if (!InternalRetrieveSymtabs (Context)) {
    return NULL;
  }
 
  ASSERT (Context->SymbolTable != NULL);
  SymbolTable = MACH_X (&Context->SymbolTable->Symbol);
 
  DySymtab = Context->DySymtab;
 
  if (DySymtab != NULL) {
    Symbol = InternalGetLocalDefinedSymbolByNameWorker (
               Context,
               &SymbolTable[DySymtab->LocalSymbolsIndex],
               DySymtab->NumLocalSymbols,
               Name
               );
    if (Symbol == NULL) {
      Symbol = InternalGetLocalDefinedSymbolByNameWorker (
                 Context,
                 &SymbolTable[DySymtab->ExternalSymbolsIndex],
                 DySymtab->NumExternalSymbols,
                 Name
                 );
    }
  } else {
    ASSERT (Context->Symtab != NULL);
    Symbol = InternalGetLocalDefinedSymbolByNameWorker (
               Context,
               SymbolTable,
               Context->Symtab->NumSymbols,
               Name
               );
  }
 
  return Symbol;
}
 
BOOLEAN
MACH_X (
  MachoRelocateSymbol
  )(
               IN OUT OC_MACHO_CONTEXT   *Context,
               IN     MACH_UINT_X        LinkAddress,
               IN OUT MACH_NLIST_X       *Symbol
               ) {
  CONST MACH_SECTION_X  *Section;
  MACH_UINT_X           Value;
  BOOLEAN               Result;
 
  ASSERT (Context != NULL);
  ASSERT (Symbol != NULL);
  MACH_ASSERT_X (Context);
 
  //
  // Symbols are relocated when they describe sections.
  //
  if (MACH_X (MachoSymbolIsSection)(Symbol)) {
    Section = MACH_X (MachoGetSectionByIndex)(Context, (Symbol->Section - 1));
    if (Section == NULL) {
      return FALSE;
    }
 
    Value = ALIGN_VALUE (
              (Section->Address + LinkAddress),
              (MACH_UINT_X)(1U << Section->Alignment)
              );
    Value -= Section->Address;
 
    //
    // The overflow arithmetic functions are not used as an overflow within the
    // ALIGN_VALUE addition and a subsequent "underflow" of the section address
    // subtraction is valid, hence just verify whether the final result
    // overflew.
    //
    if (Value < LinkAddress) {
      return FALSE;
    }
 
    Result = MACH_X (BaseOverflowAddU)(Symbol->Value, Value, &Value);
    if (Result) {
      return FALSE;
    }
 
    Symbol->Value = Value;
  }
 
  return TRUE;
}
 
BOOLEAN
MACH_X (
  MachoSymbolGetFileOffset
  )(
               IN OUT OC_MACHO_CONTEXT       *Context,
               IN     CONST MACH_NLIST_X     *Symbol,
               OUT    UINT32                 *FileOffset,
               OUT    UINT32                 *MaxSize OPTIONAL
               ) {
  MACH_UINT_X             Offset;
  MACH_UINT_X             Base;
  MACH_UINT_X             Size;
  MACH_SEGMENT_COMMAND_X  *Segment;
  MACH_SECTION_X          *Section;
 
  ASSERT (Context != NULL);
  ASSERT (Symbol != NULL);
  ASSERT (FileOffset != NULL);
  MACH_ASSERT_X (Context);
 
  if (Symbol->Section == NO_SECT) {
    return FALSE;
  }
 
  Section = MACH_X (MachoGetSectionByIndex)(
              Context,
              (Symbol->Section - 1)
              );
  if ((Section == NULL) || (Section->Size == 0)) {
    for (
         Segment = MACH_X (MachoGetNextSegment)(Context, NULL);
         Segment != NULL;
         Segment = MACH_X (MachoGetNextSegment)(Context, Segment)
         )
    {
      if (  (Symbol->Value >= Segment->VirtualAddress)
         && (Symbol->Value < (Segment->VirtualAddress + Segment->Size)))
      {
        break;
      }
    }
 
    if (Segment == NULL) {
      return FALSE;
    }
 
    Offset = Symbol->Value - Segment->VirtualAddress;
    Base   = Segment->FileOffset;
    Size   = Segment->Size;
  } else {
    if (Symbol->Value < Section->Address) {
      return FALSE;
    }
 
    Offset = Symbol->Value - Section->Address;
    Base   = Section->Offset;
    Size   = Section->Size;
    if (Offset > Section->Size) {
      return FALSE;
    }
  }
 
  *FileOffset = MACH_X_TO_UINT32 (Base + Offset);
 
  if (MaxSize != NULL) {
    *MaxSize = MACH_X_TO_UINT32 (Size - Offset);
  }
 
  return TRUE;
}