Start using the new intergral type names.
This commit is contained in:
Markus F.X.J. Oberhumer
parent
07b65ca069
commit
b2643b6926
86
src/bele.h
86
src/bele.h
@ -88,7 +88,7 @@ inline void set_be32(void *p, unsigned v)
|
||||
#endif
|
||||
}
|
||||
|
||||
inline acc_uint64l_t get_be64(const void *p)
|
||||
inline upx_uint64_t get_be64(const void *p)
|
||||
{
|
||||
#if defined(ACC_UA_GET_BE64)
|
||||
return ACC_UA_GET_BE64(p);
|
||||
@ -97,7 +97,7 @@ inline acc_uint64l_t get_be64(const void *p)
|
||||
#endif
|
||||
}
|
||||
|
||||
inline void set_be64(void *p, acc_uint64l_t v)
|
||||
inline void set_be64(void *p, upx_uint64_t v)
|
||||
{
|
||||
#if defined(ACC_UA_SET_BE64)
|
||||
ACC_UA_SET_BE64(p, v);
|
||||
@ -160,7 +160,7 @@ inline void set_le32(void *p, unsigned v)
|
||||
#endif
|
||||
}
|
||||
|
||||
inline acc_uint64l_t get_le64(const void *p)
|
||||
inline upx_uint64_t get_le64(const void *p)
|
||||
{
|
||||
#if defined(ACC_UA_GET_LE64)
|
||||
return ACC_UA_GET_LE64(p);
|
||||
@ -169,7 +169,7 @@ inline acc_uint64l_t get_le64(const void *p)
|
||||
#endif
|
||||
}
|
||||
|
||||
inline void set_le64(void *p, acc_uint64l_t v)
|
||||
inline void set_le64(void *p, upx_uint64_t v)
|
||||
{
|
||||
#if defined(ACC_UA_SET_LE64)
|
||||
ACC_UA_SET_LE64(p, v);
|
||||
@ -192,13 +192,13 @@ inline int sign_extend(unsigned v, unsigned bits)
|
||||
return (int) v;
|
||||
}
|
||||
|
||||
inline acc_int64l_t sign_extend(acc_uint64l_t v, unsigned bits)
|
||||
inline upx_int64_t sign_extend(upx_uint64_t v, unsigned bits)
|
||||
{
|
||||
const acc_uint64l_t sign_bit = ACC_UINT64_C(1) << (bits - 1);
|
||||
const upx_uint64_t sign_bit = UPX_UINT64_C(1) << (bits - 1);
|
||||
v &= sign_bit | (sign_bit - 1);
|
||||
//v = (v ^ sign_bit) - sign_bit;
|
||||
v |= 0 - (v & sign_bit);
|
||||
return (acc_int64l_t) v;
|
||||
return (upx_int64_t) v;
|
||||
}
|
||||
|
||||
inline int get_be16_signed(const void *p)
|
||||
@ -219,9 +219,9 @@ inline int get_be32_signed(const void *p)
|
||||
return sign_extend(v, 32);
|
||||
}
|
||||
|
||||
inline acc_int64l_t get_be64_signed(const void *p)
|
||||
inline upx_int64_t get_be64_signed(const void *p)
|
||||
{
|
||||
acc_uint64l_t v = get_be64(p);
|
||||
upx_uint64_t v = get_be64(p);
|
||||
return sign_extend(v, 64);
|
||||
}
|
||||
|
||||
@ -243,9 +243,9 @@ inline int get_le32_signed(const void *p)
|
||||
return sign_extend(v, 32);
|
||||
}
|
||||
|
||||
inline acc_int64l_t get_le64_signed(const void *p)
|
||||
inline upx_int64_t get_le64_signed(const void *p)
|
||||
{
|
||||
acc_uint64l_t v = get_le64(p);
|
||||
upx_uint64_t v = get_le64(p);
|
||||
return sign_extend(v, 64);
|
||||
}
|
||||
|
||||
@ -269,25 +269,25 @@ inline unsigned acc_swab32(unsigned v)
|
||||
}
|
||||
|
||||
|
||||
inline unsigned acc_swab16p(const acc_uint16e_t *p)
|
||||
inline unsigned acc_swab16p(const upx_uint16_t *p)
|
||||
{
|
||||
return acc_swab16(*p);
|
||||
}
|
||||
|
||||
inline unsigned acc_swap32p(const acc_uint32e_t *p)
|
||||
inline unsigned acc_swap32p(const upx_uint32_t *p)
|
||||
{
|
||||
return acc_swab32(*p);
|
||||
}
|
||||
|
||||
|
||||
inline void acc_swab16s(acc_uint16e_t *p)
|
||||
inline void acc_swab16s(upx_uint16_t *p)
|
||||
{
|
||||
*p = (acc_uint16e_t) acc_swab16(*p);
|
||||
*p = (upx_uint16_t) acc_swab16(*p);
|
||||
}
|
||||
|
||||
inline void acc_swab32s(acc_uint32e_t *p)
|
||||
inline void acc_swab32s(upx_uint32_t *p)
|
||||
{
|
||||
*p = (acc_uint32e_t) acc_swab32(*p);
|
||||
*p = (upx_uint32_t) acc_swab32(*p);
|
||||
}
|
||||
|
||||
|
||||
@ -359,20 +359,20 @@ __packed_struct(BE64)
|
||||
unsigned char d[8];
|
||||
|
||||
//inline BE64() { }
|
||||
//BE64(acc_uint64l_t v) { set_be64(d, v); }
|
||||
//BE64(upx_uint64_t v) { set_be64(d, v); }
|
||||
|
||||
BE64& operator = (acc_uint64l_t v) { set_be64(d, v); return *this; }
|
||||
BE64& operator += (acc_uint64l_t v) { set_be64(d, get_be64(d) + v); return *this; }
|
||||
BE64& operator -= (acc_uint64l_t v) { set_be64(d, get_be64(d) - v); return *this; }
|
||||
BE64& operator *= (acc_uint64l_t v) { set_be64(d, get_be64(d) * v); return *this; }
|
||||
BE64& operator /= (acc_uint64l_t v) { set_be64(d, get_be64(d) / v); return *this; }
|
||||
BE64& operator &= (acc_uint64l_t v) { set_be64(d, get_be64(d) & v); return *this; }
|
||||
BE64& operator |= (acc_uint64l_t v) { set_be64(d, get_be64(d) | v); return *this; }
|
||||
BE64& operator ^= (acc_uint64l_t v) { set_be64(d, get_be64(d) ^ v); return *this; }
|
||||
BE64& operator = (upx_uint64_t v) { set_be64(d, v); return *this; }
|
||||
BE64& operator += (upx_uint64_t v) { set_be64(d, get_be64(d) + v); return *this; }
|
||||
BE64& operator -= (upx_uint64_t v) { set_be64(d, get_be64(d) - v); return *this; }
|
||||
BE64& operator *= (upx_uint64_t v) { set_be64(d, get_be64(d) * v); return *this; }
|
||||
BE64& operator /= (upx_uint64_t v) { set_be64(d, get_be64(d) / v); return *this; }
|
||||
BE64& operator &= (upx_uint64_t v) { set_be64(d, get_be64(d) & v); return *this; }
|
||||
BE64& operator |= (upx_uint64_t v) { set_be64(d, get_be64(d) | v); return *this; }
|
||||
BE64& operator ^= (upx_uint64_t v) { set_be64(d, get_be64(d) ^ v); return *this; }
|
||||
BE64& operator <<= (unsigned v) { set_be64(d, get_be64(d) << v); return *this; }
|
||||
BE64& operator >>= (unsigned v) { set_be64(d, get_be64(d) >> v); return *this; }
|
||||
|
||||
operator acc_uint64l_t () const { return get_be64(d); }
|
||||
operator upx_uint64_t () const { return get_be64(d); }
|
||||
__packed_struct_end()
|
||||
|
||||
|
||||
@ -422,20 +422,20 @@ __packed_struct(LE64)
|
||||
unsigned char d[8];
|
||||
|
||||
//inline LE64() { }
|
||||
//LE64(acc_uint64l_t v) { set_le64(d, v); }
|
||||
//LE64(upx_uint64_t v) { set_le64(d, v); }
|
||||
|
||||
LE64& operator = (acc_uint64l_t v) { set_le64(d, v); return *this; }
|
||||
LE64& operator += (acc_uint64l_t v) { set_le64(d, get_le64(d) + v); return *this; }
|
||||
LE64& operator -= (acc_uint64l_t v) { set_le64(d, get_le64(d) - v); return *this; }
|
||||
LE64& operator *= (acc_uint64l_t v) { set_le64(d, get_le64(d) * v); return *this; }
|
||||
LE64& operator /= (acc_uint64l_t v) { set_le64(d, get_le64(d) / v); return *this; }
|
||||
LE64& operator &= (acc_uint64l_t v) { set_le64(d, get_le64(d) & v); return *this; }
|
||||
LE64& operator |= (acc_uint64l_t v) { set_le64(d, get_le64(d) | v); return *this; }
|
||||
LE64& operator ^= (acc_uint64l_t v) { set_le64(d, get_le64(d) ^ v); return *this; }
|
||||
LE64& operator = (upx_uint64_t v) { set_le64(d, v); return *this; }
|
||||
LE64& operator += (upx_uint64_t v) { set_le64(d, get_le64(d) + v); return *this; }
|
||||
LE64& operator -= (upx_uint64_t v) { set_le64(d, get_le64(d) - v); return *this; }
|
||||
LE64& operator *= (upx_uint64_t v) { set_le64(d, get_le64(d) * v); return *this; }
|
||||
LE64& operator /= (upx_uint64_t v) { set_le64(d, get_le64(d) / v); return *this; }
|
||||
LE64& operator &= (upx_uint64_t v) { set_le64(d, get_le64(d) & v); return *this; }
|
||||
LE64& operator |= (upx_uint64_t v) { set_le64(d, get_le64(d) | v); return *this; }
|
||||
LE64& operator ^= (upx_uint64_t v) { set_le64(d, get_le64(d) ^ v); return *this; }
|
||||
LE64& operator <<= (unsigned v) { set_le64(d, get_le64(d) << v); return *this; }
|
||||
LE64& operator >>= (unsigned v) { set_le64(d, get_le64(d) >> v); return *this; }
|
||||
|
||||
operator acc_uint64l_t () const { return get_le64(d); }
|
||||
operator upx_uint64_t () const { return get_le64(d); }
|
||||
__packed_struct_end()
|
||||
|
||||
|
||||
@ -545,8 +545,8 @@ int __acc_cdecl_qsort le64_compare_signed(const void *, const void *);
|
||||
// just for testing...
|
||||
#if !(ACC_CFG_NO_UNALIGNED)
|
||||
#if 0 && (ACC_ARCH_AMD64 || ACC_ARCH_I386) && (ACC_CC_GNUC >= 0x030200)
|
||||
typedef acc_uint16e_t LE16_unaligned __attribute__((__aligned__(1)));
|
||||
typedef acc_uint32e_t LE32_unaligned __attribute__((__aligned__(1)));
|
||||
typedef upx_uint16_t LE16_unaligned __attribute__((__aligned__(1)));
|
||||
typedef upx_uint32_t LE32_unaligned __attribute__((__aligned__(1)));
|
||||
# ifndef LE16
|
||||
# define LE16 LE16_unaligned
|
||||
# endif
|
||||
@ -555,8 +555,8 @@ int __acc_cdecl_qsort le64_compare_signed(const void *, const void *);
|
||||
# endif
|
||||
#endif
|
||||
#if 0 && (ACC_ARCH_I386) && (ACC_CC_INTELC)
|
||||
typedef __declspec(align(1)) acc_uint16e_t LE16_unaligned;
|
||||
typedef __declspec(align(1)) acc_uint32e_t LE32_unaligned;
|
||||
typedef __declspec(align(1)) upx_uint16_t LE16_unaligned;
|
||||
typedef __declspec(align(1)) upx_uint32_t LE32_unaligned;
|
||||
# ifndef LE16
|
||||
# define LE16 LE16_unaligned
|
||||
# endif
|
||||
@ -565,8 +565,8 @@ int __acc_cdecl_qsort le64_compare_signed(const void *, const void *);
|
||||
# endif
|
||||
#endif
|
||||
#if 0 && (ACC_ARCH_AMD64 || ACC_ARCH_I386) && (ACC_CC_MSC) && (_MSC_VER >= 1200)
|
||||
typedef __declspec(align(1)) acc_uint16e_t LE16_unaligned;
|
||||
typedef __declspec(align(1)) acc_uint32e_t LE32_unaligned;
|
||||
typedef __declspec(align(1)) upx_uint16_t LE16_unaligned;
|
||||
typedef __declspec(align(1)) upx_uint32_t LE32_unaligned;
|
||||
# ifndef LE16
|
||||
# define LE16 LE16_unaligned
|
||||
# endif
|
||||
|
||||
@ -61,17 +61,17 @@ struct AbstractPolicy
|
||||
V unsigned get16(const void *p) C = 0;
|
||||
V unsigned get24(const void *p) C = 0;
|
||||
V unsigned get32(const void *p) C = 0;
|
||||
V acc_uint64l_t get64(const void *p) C = 0;
|
||||
V upx_uint64_t get64(const void *p) C = 0;
|
||||
|
||||
V void set16(void *p, unsigned v) C = 0;
|
||||
V void set24(void *p, unsigned v) C = 0;
|
||||
V void set32(void *p, unsigned v) C = 0;
|
||||
V void set64(void *p, acc_uint64l_t v) C = 0;
|
||||
V void set64(void *p, upx_uint64_t v) C = 0;
|
||||
|
||||
V unsigned get16_signed(const void *p) C = 0;
|
||||
V unsigned get24_signed(const void *p) C = 0;
|
||||
V unsigned get32_signed(const void *p) C = 0;
|
||||
V acc_uint64l_t get64_signed(const void *p) C = 0;
|
||||
V upx_uint64_t get64_signed(const void *p) C = 0;
|
||||
|
||||
S u16_compare(const void *a, const void *b) C = 0;
|
||||
S u24_compare(const void *a, const void *b) C = 0;
|
||||
@ -113,7 +113,7 @@ struct BEPolicy
|
||||
{ return get_be24(p); }
|
||||
V unsigned get32(const void *p) C
|
||||
{ return get_be32(p); }
|
||||
V acc_uint64l_t get64(const void *p) C
|
||||
V upx_uint64_t get64(const void *p) C
|
||||
{ return get_be64(p); }
|
||||
|
||||
V void set16(void *p, unsigned v) C
|
||||
@ -122,7 +122,7 @@ struct BEPolicy
|
||||
{ set_be24(p, v); }
|
||||
V void set32(void *p, unsigned v) C
|
||||
{ set_be32(p, v); }
|
||||
V void set64(void *p, acc_uint64l_t v) C
|
||||
V void set64(void *p, upx_uint64_t v) C
|
||||
{ set_be64(p, v); }
|
||||
|
||||
V unsigned get16_signed(const void *p) C
|
||||
@ -131,7 +131,7 @@ struct BEPolicy
|
||||
{ return get_be24_signed(p); }
|
||||
V unsigned get32_signed(const void *p) C
|
||||
{ return get_be32_signed(p); }
|
||||
V acc_uint64l_t get64_signed(const void *p) C
|
||||
V upx_uint64_t get64_signed(const void *p) C
|
||||
{ return get_be64_signed(p); }
|
||||
|
||||
S u16_compare(const void *a, const void *b) C
|
||||
@ -190,7 +190,7 @@ struct LEPolicy
|
||||
{ return get_le24(p); }
|
||||
V unsigned get32(const void *p) C
|
||||
{ return get_le32(p); }
|
||||
V acc_uint64l_t get64(const void *p) C
|
||||
V upx_uint64_t get64(const void *p) C
|
||||
{ return get_le64(p); }
|
||||
|
||||
V void set16(void *p, unsigned v) C
|
||||
@ -199,7 +199,7 @@ struct LEPolicy
|
||||
{ set_le24(p, v); }
|
||||
V void set32(void *p, unsigned v) C
|
||||
{ set_le32(p, v); }
|
||||
V void set64(void *p, acc_uint64l_t v) C
|
||||
V void set64(void *p, upx_uint64_t v) C
|
||||
{ set_le64(p, v); }
|
||||
|
||||
V unsigned get16_signed(const void *p) C
|
||||
@ -208,7 +208,7 @@ struct LEPolicy
|
||||
{ return get_le24_signed(p); }
|
||||
V unsigned get32_signed(const void *p) C
|
||||
{ return get_le32_signed(p); }
|
||||
V acc_uint64l_t get64_signed(const void *p) C
|
||||
V upx_uint64_t get64_signed(const void *p) C
|
||||
{ return get_le64_signed(p); }
|
||||
|
||||
S u16_compare(const void *a, const void *b) C
|
||||
@ -259,9 +259,9 @@ struct HostAlignedPolicy
|
||||
enum { isBE = HostPolicy::isBE, isLE = HostPolicy::isLE };
|
||||
#endif
|
||||
|
||||
typedef acc_uint16e_t U16;
|
||||
typedef acc_uint32e_t U32;
|
||||
typedef acc_uint64l_t U64;
|
||||
typedef upx_uint16_t U16;
|
||||
typedef upx_uint32_t U32;
|
||||
typedef upx_uint64_t U64;
|
||||
|
||||
static void compileTimeAssertions() {
|
||||
COMPILE_TIME_ASSERT(sizeof(U16) == 2)
|
||||
|
||||
@ -84,7 +84,7 @@ ElfLinker::Section::~Section()
|
||||
// Symbol
|
||||
**************************************************************************/
|
||||
|
||||
ElfLinker::Symbol::Symbol(const char *n, Section *s, u64 o) :
|
||||
ElfLinker::Symbol::Symbol(const char *n, Section *s, upx_uint64_t o) :
|
||||
name(NULL), section(s), offset(o)
|
||||
{
|
||||
name = strdup(n);
|
||||
@ -103,7 +103,7 @@ ElfLinker::Symbol::~Symbol()
|
||||
**************************************************************************/
|
||||
|
||||
ElfLinker::Relocation::Relocation(const Section *s, unsigned o, const char *t,
|
||||
const Symbol *v, u64 a) :
|
||||
const Symbol *v, upx_uint64_t a) :
|
||||
section(s), offset(o), type(t), value(v), add(a)
|
||||
{
|
||||
assert(section != NULL);
|
||||
@ -294,7 +294,7 @@ void ElfLinker::preprocessRelocations(char *start, char *end)
|
||||
char *t = strstr(start, type);
|
||||
t[strlen(type)] = 0;
|
||||
|
||||
u64 add = 0;
|
||||
upx_uint64_t add = 0;
|
||||
char *p = strstr(symbol, "+0x");
|
||||
if (p == NULL)
|
||||
p = strstr(symbol, "-0x");
|
||||
@ -306,8 +306,8 @@ void ElfLinker::preprocessRelocations(char *start, char *end)
|
||||
|
||||
assert(strlen(p) == 8 || strlen(p) == 16);
|
||||
char *endptr = NULL;
|
||||
acc_uint64l_t ull = strtoull(p, &endptr, 16);
|
||||
add = (u64) ull;
|
||||
upx_uint64_t ull = strtoull(p, &endptr, 16);
|
||||
add = (upx_uint64_t) ull;
|
||||
assert(add == ull);
|
||||
assert(endptr && *endptr == '\0');
|
||||
if (sign == '-')
|
||||
@ -356,7 +356,7 @@ ElfLinker::Section *ElfLinker::addSection(const char *sname, const void *sdata,
|
||||
}
|
||||
|
||||
ElfLinker::Symbol *ElfLinker::addSymbol(const char *name, const char *section,
|
||||
u64 offset)
|
||||
upx_uint64_t offset)
|
||||
{
|
||||
//printf("addSymbol: %s %s 0x%x\n", name, section, offset);
|
||||
if (update_capacity(nsymbols, &nsymbols_capacity))
|
||||
@ -371,7 +371,7 @@ ElfLinker::Symbol *ElfLinker::addSymbol(const char *name, const char *section,
|
||||
|
||||
ElfLinker::Relocation *ElfLinker::addRelocation(const char *section, unsigned off,
|
||||
const char *type, const char *symbol,
|
||||
u64 add)
|
||||
upx_uint64_t add)
|
||||
{
|
||||
if (update_capacity(nrelocations, &nrelocations_capacity))
|
||||
relocations = static_cast<Relocation **>(realloc(relocations, (nrelocations_capacity) * sizeof(Relocation *)));
|
||||
@ -497,7 +497,7 @@ void ElfLinker::relocate()
|
||||
for (unsigned ic = 0; ic < nrelocations; ic++)
|
||||
{
|
||||
const Relocation *rel = relocations[ic];
|
||||
u64 value = 0;
|
||||
upx_uint64_t value = 0;
|
||||
|
||||
if (rel->section->output == NULL)
|
||||
continue;
|
||||
@ -524,7 +524,7 @@ void ElfLinker::relocate()
|
||||
}
|
||||
}
|
||||
|
||||
void ElfLinker::defineSymbol(const char *name, u64 value)
|
||||
void ElfLinker::defineSymbol(const char *name, upx_uint64_t value)
|
||||
{
|
||||
Symbol *symbol = findSymbol(name);
|
||||
if (strcmp(symbol->section->name, "*ABS*") == 0)
|
||||
@ -550,8 +550,8 @@ void ElfLinker::dumpSymbol(const Symbol *symbol, unsigned flags, FILE *fp) const
|
||||
if ((flags & 1) && symbol->section->output == NULL)
|
||||
return;
|
||||
char d0[16+1], d1[16+1];
|
||||
upx_snprintf(d0, sizeof(d0), "%016llx", (acc_uint64_t) symbol->offset);
|
||||
upx_snprintf(d1, sizeof(d1), "%016llx", (acc_uint64_t) symbol->section->offset);
|
||||
upx_snprintf(d0, sizeof(d0), "%016llx", (upx_uint64_t) symbol->offset);
|
||||
upx_snprintf(d1, sizeof(d1), "%016llx", (upx_uint64_t) symbol->section->offset);
|
||||
fprintf(fp, "%-28s 0x%-16s | %-28s 0x%-16s\n",
|
||||
symbol->name, d0, symbol->section->name, d1);
|
||||
}
|
||||
@ -565,7 +565,7 @@ void ElfLinker::dumpSymbols(unsigned flags, FILE *fp) const
|
||||
for (const Section *section = head; section; section = section->next)
|
||||
{
|
||||
char d1[16+1];
|
||||
upx_snprintf(d1, sizeof(d1), "%016llx", (acc_uint64_t) section->offset);
|
||||
upx_snprintf(d1, sizeof(d1), "%016llx", (upx_uint64_t) section->offset);
|
||||
fprintf(fp, "%-42s%-28s 0x%-16s\n", "", section->name, d1);
|
||||
for (unsigned ic = 0; ic < nsymbols; ic++)
|
||||
{
|
||||
@ -583,7 +583,7 @@ void ElfLinker::dumpSymbols(unsigned flags, FILE *fp) const
|
||||
}
|
||||
}
|
||||
|
||||
ElfLinker::u64 ElfLinker::getSymbolOffset(const char *name) const
|
||||
upx_uint64_t ElfLinker::getSymbolOffset(const char *name) const
|
||||
{
|
||||
const Symbol *symbol = findSymbol(name);
|
||||
if (symbol->section->output == NULL)
|
||||
@ -598,7 +598,7 @@ void ElfLinker::alignWithByte(unsigned len, unsigned char b)
|
||||
}
|
||||
|
||||
void ElfLinker::relocate1(const Relocation *rel, upx_byte *,
|
||||
u64, const char *)
|
||||
upx_uint64_t, const char *)
|
||||
{
|
||||
internal_error("unknown relocation type '%s\n", rel->type);
|
||||
}
|
||||
@ -624,7 +624,7 @@ static void check8(const Relocation *rel, const upx_byte *location, int v, int d
|
||||
|
||||
|
||||
void ElfLinkerAMD64::relocate1(const Relocation *rel, upx_byte *location,
|
||||
u64 value, const char *type)
|
||||
upx_uint64_t value, const char *type)
|
||||
{
|
||||
if (strncmp(type, "R_X86_64_", 9))
|
||||
return super::relocate1(rel, location, value, type);
|
||||
@ -662,7 +662,7 @@ void ElfLinkerAMD64::relocate1(const Relocation *rel, upx_byte *location,
|
||||
|
||||
|
||||
void ElfLinkerArmBE::relocate1(const Relocation *rel, upx_byte *location,
|
||||
u64 value, const char *type)
|
||||
upx_uint64_t value, const char *type)
|
||||
{
|
||||
if (strcmp(type, "R_ARM_PC24") == 0)
|
||||
{
|
||||
@ -697,7 +697,7 @@ void ElfLinkerArmBE::relocate1(const Relocation *rel, upx_byte *location,
|
||||
|
||||
|
||||
void ElfLinkerArmLE::relocate1(const Relocation *rel, upx_byte *location,
|
||||
u64 value, const char *type)
|
||||
upx_uint64_t value, const char *type)
|
||||
{
|
||||
if (strcmp(type, "R_ARM_PC24") == 0)
|
||||
{
|
||||
@ -741,7 +741,7 @@ void ElfLinkerM68k::alignCode(unsigned len)
|
||||
}
|
||||
|
||||
void ElfLinkerM68k::relocate1(const Relocation *rel, upx_byte *location,
|
||||
u64 value, const char *type)
|
||||
upx_uint64_t value, const char *type)
|
||||
{
|
||||
if (strncmp(type, "R_68K_", 6))
|
||||
return super::relocate1(rel, location, value, type);
|
||||
@ -767,7 +767,7 @@ void ElfLinkerM68k::relocate1(const Relocation *rel, upx_byte *location,
|
||||
|
||||
|
||||
void ElfLinkerMipsBE::relocate1(const Relocation *rel, upx_byte *location,
|
||||
u64 value, const char *type)
|
||||
upx_uint64_t value, const char *type)
|
||||
{
|
||||
#define MIPS_HI(a) (((a) >> 16) + (((a) & 0x8000) >> 15))
|
||||
#define MIPS_LO(a) ((a) & 0xffff)
|
||||
@ -798,7 +798,7 @@ void ElfLinkerMipsBE::relocate1(const Relocation *rel, upx_byte *location,
|
||||
|
||||
|
||||
void ElfLinkerMipsLE::relocate1(const Relocation *rel, upx_byte *location,
|
||||
u64 value, const char *type)
|
||||
upx_uint64_t value, const char *type)
|
||||
{
|
||||
#define MIPS_HI(a) (((a) >> 16) + (((a) & 0x8000) >> 15))
|
||||
#define MIPS_LO(a) ((a) & 0xffff)
|
||||
@ -829,7 +829,7 @@ void ElfLinkerMipsLE::relocate1(const Relocation *rel, upx_byte *location,
|
||||
|
||||
|
||||
void ElfLinkerPpc32::relocate1(const Relocation *rel, upx_byte *location,
|
||||
u64 value, const char *type)
|
||||
upx_uint64_t value, const char *type)
|
||||
{
|
||||
if (strncmp(type, "R_PPC_", 6))
|
||||
return super::relocate1(rel, location, value, type);
|
||||
@ -870,7 +870,7 @@ void ElfLinkerPpc32::relocate1(const Relocation *rel, upx_byte *location,
|
||||
|
||||
|
||||
void ElfLinkerX86::relocate1(const Relocation *rel, upx_byte *location,
|
||||
u64 value, const char *type)
|
||||
upx_uint64_t value, const char *type)
|
||||
{
|
||||
if (strncmp(type, "R_386_", 6))
|
||||
return super::relocate1(rel, location, value, type);
|
||||
|
||||
49
src/linker.h
49
src/linker.h
@ -40,7 +40,6 @@ class ElfLinker : private noncopyable
|
||||
public:
|
||||
const N_BELE_RTP::AbstractPolicy *bele; // target endianness
|
||||
protected:
|
||||
typedef acc_uint64l_t u64;
|
||||
struct Section;
|
||||
struct Symbol;
|
||||
struct Relocation;
|
||||
@ -73,9 +72,9 @@ protected:
|
||||
Section *findSection(const char *name, bool fatal=true) const;
|
||||
Symbol *findSymbol(const char *name, bool fatal=true) const;
|
||||
|
||||
Symbol *addSymbol(const char *name, const char *section, u64 offset);
|
||||
Symbol *addSymbol(const char *name, const char *section, upx_uint64_t offset);
|
||||
Relocation *addRelocation(const char *section, unsigned off, const char *type,
|
||||
const char *symbol, u64 add);
|
||||
const char *symbol, upx_uint64_t add);
|
||||
|
||||
public:
|
||||
ElfLinker();
|
||||
@ -94,8 +93,8 @@ public:
|
||||
virtual int getSection(const char *sname, int *slen=NULL) const;
|
||||
virtual int getSectionSize(const char *sname) const;
|
||||
virtual upx_byte *getLoader(int *llen=NULL) const;
|
||||
virtual void defineSymbol(const char *name, u64 value);
|
||||
virtual u64 getSymbolOffset(const char *) const;
|
||||
virtual void defineSymbol(const char *name, upx_uint64_t value);
|
||||
virtual upx_uint64_t getSymbolOffset(const char *) const;
|
||||
|
||||
virtual void dumpSymbol(const Symbol *, unsigned flags, FILE *fp) const;
|
||||
virtual void dumpSymbols(unsigned flags=0, FILE *fp=NULL) const;
|
||||
@ -107,15 +106,15 @@ public:
|
||||
protected:
|
||||
virtual void relocate();
|
||||
virtual void relocate1(const Relocation *, upx_byte *location,
|
||||
u64 value, const char *type);
|
||||
upx_uint64_t value, const char *type);
|
||||
|
||||
// target endianness abstraction
|
||||
unsigned get_te16(const void *p) const { return bele->get16(p); }
|
||||
unsigned get_te32(const void *p) const { return bele->get32(p); }
|
||||
u64 get_te64(const void *p) const { return bele->get64(p); }
|
||||
void set_te16(void *p, unsigned v) const { bele->set16(p, v); }
|
||||
void set_te32(void *p, unsigned v) const { bele->set32(p, v); }
|
||||
void set_te64(void *p, u64 v) const { bele->set64(p, v); }
|
||||
unsigned get_te16(const void *p) const { return bele->get16(p); }
|
||||
unsigned get_te32(const void *p) const { return bele->get32(p); }
|
||||
upx_uint64_t get_te64(const void *p) const { return bele->get64(p); }
|
||||
void set_te16(void *p, unsigned v) const { bele->set16(p, v); }
|
||||
void set_te32(void *p, unsigned v) const { bele->set32(p, v); }
|
||||
void set_te64(void *p, upx_uint64_t v) const { bele->set64(p, v); }
|
||||
};
|
||||
|
||||
|
||||
@ -125,7 +124,7 @@ struct ElfLinker::Section : private noncopyable
|
||||
void *input;
|
||||
upx_byte *output;
|
||||
unsigned size;
|
||||
u64 offset;
|
||||
upx_uint64_t offset;
|
||||
unsigned p2align; // log2
|
||||
Section *next;
|
||||
|
||||
@ -138,9 +137,9 @@ struct ElfLinker::Symbol : private noncopyable
|
||||
{
|
||||
char *name;
|
||||
Section *section;
|
||||
u64 offset;
|
||||
upx_uint64_t offset;
|
||||
|
||||
Symbol(const char *n, Section *s, u64 o);
|
||||
Symbol(const char *n, Section *s, upx_uint64_t o);
|
||||
~Symbol();
|
||||
};
|
||||
|
||||
@ -151,10 +150,10 @@ struct ElfLinker::Relocation : private noncopyable
|
||||
unsigned offset;
|
||||
const char *type;
|
||||
const Symbol *value;
|
||||
u64 add; // used in .rela relocations
|
||||
upx_uint64_t add; // used in .rela relocations
|
||||
|
||||
Relocation(const Section *s, unsigned o, const char *t,
|
||||
const Symbol *v, u64 a);
|
||||
const Symbol *v, upx_uint64_t a);
|
||||
};
|
||||
|
||||
|
||||
@ -168,7 +167,7 @@ class ElfLinkerAMD64 : public ElfLinker
|
||||
protected:
|
||||
virtual void alignCode(unsigned len) { alignWithByte(len, 0x90); }
|
||||
virtual void relocate1(const Relocation *, upx_byte *location,
|
||||
u64 value, const char *type);
|
||||
upx_uint64_t value, const char *type);
|
||||
};
|
||||
|
||||
|
||||
@ -179,7 +178,7 @@ public:
|
||||
ElfLinkerArmBE() { bele = &N_BELE_RTP::be_policy; }
|
||||
protected:
|
||||
virtual void relocate1(const Relocation *, upx_byte *location,
|
||||
u64 value, const char *type);
|
||||
upx_uint64_t value, const char *type);
|
||||
};
|
||||
|
||||
|
||||
@ -188,7 +187,7 @@ class ElfLinkerArmLE : public ElfLinker
|
||||
typedef ElfLinker super;
|
||||
protected:
|
||||
virtual void relocate1(const Relocation *, upx_byte *location,
|
||||
u64 value, const char *type);
|
||||
upx_uint64_t value, const char *type);
|
||||
};
|
||||
|
||||
|
||||
@ -200,7 +199,7 @@ public:
|
||||
protected:
|
||||
virtual void alignCode(unsigned len);
|
||||
virtual void relocate1(const Relocation *, upx_byte *location,
|
||||
u64 value, const char *type);
|
||||
upx_uint64_t value, const char *type);
|
||||
};
|
||||
|
||||
|
||||
@ -211,7 +210,7 @@ public:
|
||||
ElfLinkerMipsBE() { bele = &N_BELE_RTP::be_policy; }
|
||||
protected:
|
||||
virtual void relocate1(const Relocation *, upx_byte *location,
|
||||
u64 value, const char *type);
|
||||
upx_uint64_t value, const char *type);
|
||||
};
|
||||
|
||||
|
||||
@ -220,7 +219,7 @@ class ElfLinkerMipsLE : public ElfLinker
|
||||
typedef ElfLinker super;
|
||||
protected:
|
||||
virtual void relocate1(const Relocation *, upx_byte *location,
|
||||
u64 value, const char *type);
|
||||
upx_uint64_t value, const char *type);
|
||||
};
|
||||
|
||||
|
||||
@ -231,7 +230,7 @@ public:
|
||||
ElfLinkerPpc32() { bele = &N_BELE_RTP::be_policy; }
|
||||
protected:
|
||||
virtual void relocate1(const Relocation *, upx_byte *location,
|
||||
u64 value, const char *type);
|
||||
upx_uint64_t value, const char *type);
|
||||
};
|
||||
|
||||
|
||||
@ -241,7 +240,7 @@ class ElfLinkerX86 : public ElfLinker
|
||||
protected:
|
||||
virtual void alignCode(unsigned len) { alignWithByte(len, 0x90); }
|
||||
virtual void relocate1(const Relocation *, upx_byte *location,
|
||||
u64 value, const char *type);
|
||||
upx_uint64_t value, const char *type);
|
||||
};
|
||||
|
||||
|
||||
|
||||
@ -1408,7 +1408,7 @@ void upx_sanity_check(void)
|
||||
assert(get_le32(d) == 0xfcfdfeff);
|
||||
assert(bele->get32(d) == 0xfcfdfeff);
|
||||
assert(get_le32_signed(d) == -50462977);
|
||||
assert(get_le64_signed(d) == ACC_INT64_C(-506097522914230529));
|
||||
assert(get_le64_signed(d) == UPX_INT64_C(-506097522914230529));
|
||||
assert(find_be16(d, 2, 0xfffe) == 0);
|
||||
assert(find_le16(d, 2, 0xfeff) == 0);
|
||||
assert(find_be32(d, 4, 0xfffefdfc) == 0);
|
||||
@ -1417,7 +1417,7 @@ void upx_sanity_check(void)
|
||||
assert(get_be16_signed(d) == 32638);
|
||||
assert(get_be24_signed(d) == 8355453);
|
||||
assert(get_be32_signed(d) == 2138996092);
|
||||
assert(get_be64_signed(d) == ACC_INT64_C(9186918263483431288));
|
||||
assert(get_be64_signed(d) == UPX_INT64_C(9186918263483431288));
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -154,7 +154,7 @@ void MemBuffer::fill(unsigned off, unsigned len, int value)
|
||||
//
|
||||
**************************************************************************/
|
||||
|
||||
#define PTR(p) ((unsigned) ((acc_uintptr_t)(p) & 0xffffffff))
|
||||
#define PTR(p) ((unsigned) ((upx_uintptr_t)(p) & 0xffffffff))
|
||||
#define MAGIC1(p) (PTR(p) ^ 0xfefdbeeb)
|
||||
#define MAGIC2(p) (PTR(p) ^ 0xfefdbeeb ^ 0x80024001)
|
||||
|
||||
|
||||
@ -63,8 +63,8 @@ umin(unsigned a, unsigned b)
|
||||
return (a < b) ? a : b;
|
||||
}
|
||||
|
||||
static acc_uint64l_t
|
||||
umin64(acc_uint64l_t a, acc_uint64l_t b)
|
||||
static upx_uint64_t
|
||||
umin64(upx_uint64_t a, upx_uint64_t b)
|
||||
{
|
||||
return (a < b) ? a : b;
|
||||
}
|
||||
@ -173,7 +173,7 @@ PackLinuxElf64::checkEhdr(Elf64_Ehdr const *ehdr) const
|
||||
|
||||
if (type == Elf64_Ehdr::ET_EXEC) {
|
||||
// check for Linux kernels
|
||||
acc_uint64l_t const entry = get_te64(&ehdr->e_entry);
|
||||
upx_uint64_t const entry = get_te64(&ehdr->e_entry);
|
||||
if (entry == 0xC0100000) // uncompressed vmlinux
|
||||
return 1000;
|
||||
if (entry == 0x00001000) // compressed vmlinux
|
||||
@ -364,13 +364,13 @@ void PackLinuxElf64::pack3(OutputFile *fo, Filter &ft)
|
||||
Elf64_Phdr *phdr = phdri;
|
||||
unsigned off = fo->st_size();
|
||||
unsigned off_init = 0; // where in file
|
||||
acc_uint64l_t va_init = sz_pack2; // virtual address
|
||||
acc_uint64l_t rel = 0;
|
||||
acc_uint64l_t old_dtinit = 0;
|
||||
upx_uint64_t va_init = sz_pack2; // virtual address
|
||||
upx_uint64_t rel = 0;
|
||||
upx_uint64_t old_dtinit = 0;
|
||||
for (int j = e_phnum; --j>=0; ++phdr) {
|
||||
acc_uint64l_t const len = get_te64(&phdr->p_filesz);
|
||||
acc_uint64l_t const ioff = get_te64(&phdr->p_offset);
|
||||
acc_uint64l_t align= get_te64(&phdr->p_align);
|
||||
upx_uint64_t const len = get_te64(&phdr->p_filesz);
|
||||
upx_uint64_t const ioff = get_te64(&phdr->p_offset);
|
||||
upx_uint64_t align= get_te64(&phdr->p_align);
|
||||
unsigned const type = get_te32(&phdr->p_type);
|
||||
if (phdr->PT_INTERP==type) {
|
||||
// Rotate to highest position, so it can be lopped
|
||||
@ -428,7 +428,7 @@ void PackLinuxElf64::pack3(OutputFile *fo, Filter &ft)
|
||||
}
|
||||
if (off_init) { // change DT_INIT.d_val
|
||||
fo->seek(off_init, SEEK_SET);
|
||||
acc_uint64l_t word; set_te64(&word, va_init);
|
||||
upx_uint64_t word; set_te64(&word, va_init);
|
||||
fo->rewrite(&word, sizeof(word));
|
||||
fo->seek(0, SEEK_END);
|
||||
}
|
||||
@ -860,22 +860,22 @@ PackLinuxElf64amd::defineSymbols(Filter const *)
|
||||
// know the final total compressed size yet, so use the uncompressed
|
||||
// size (total over all PT_LOAD64) as an upper bound.
|
||||
unsigned len = 0;
|
||||
acc_uint64l_t lo_va_user = ~0ull; // infinity
|
||||
upx_uint64_t lo_va_user = ~0ull; // infinity
|
||||
for (int j= e_phnum; --j>=0; ) {
|
||||
if (PT_LOAD64 == get_te32(&phdri[j].p_type)) {
|
||||
len += (unsigned)get_te64(&phdri[j].p_filesz);
|
||||
acc_uint64l_t const va = get_te64(&phdri[j].p_vaddr);
|
||||
upx_uint64_t const va = get_te64(&phdri[j].p_vaddr);
|
||||
if (va < lo_va_user) {
|
||||
lo_va_user = va;
|
||||
}
|
||||
}
|
||||
}
|
||||
lsize = /*getLoaderSize()*/ 64 * 1024; // XXX: upper bound; avoid circularity
|
||||
acc_uint64l_t lo_va_stub = get_te64(&elfout.phdr[0].p_vaddr);
|
||||
acc_uint64l_t adrc;
|
||||
acc_uint64l_t adrm;
|
||||
acc_uint64l_t adru;
|
||||
acc_uint64l_t adrx;
|
||||
upx_uint64_t lo_va_stub = get_te64(&elfout.phdr[0].p_vaddr);
|
||||
upx_uint64_t adrc;
|
||||
upx_uint64_t adrm;
|
||||
upx_uint64_t adru;
|
||||
upx_uint64_t adrx;
|
||||
unsigned cntc;
|
||||
unsigned lenm;
|
||||
unsigned lenu;
|
||||
@ -1479,8 +1479,8 @@ PackLinuxElf64amd::canPack()
|
||||
throwCantPack("invalid Ehdr e_ehsize; try '--force-execve'");
|
||||
return false;
|
||||
}
|
||||
acc_uint64l_t const e_shoff = get_te64(&ehdr->e_shoff);
|
||||
acc_uint64l_t const e_phoff = get_te64(&ehdr->e_phoff);
|
||||
upx_uint64_t const e_shoff = get_te64(&ehdr->e_shoff);
|
||||
upx_uint64_t const e_phoff = get_te64(&ehdr->e_phoff);
|
||||
if (e_phoff != sizeof(*ehdr)) {// Phdrs not contiguous with Ehdr
|
||||
throwCantPack("non-contiguous Ehdr/Phdr; try '--force-execve'");
|
||||
return false;
|
||||
@ -1588,8 +1588,8 @@ PackLinuxElf64amd::canPack()
|
||||
}
|
||||
}
|
||||
// Rely on 0==elf_unsigned_dynamic(tag) if no such tag.
|
||||
acc_uint64l_t const va_gash = elf_unsigned_dynamic(Elf64_Dyn::DT_GNU_HASH);
|
||||
acc_uint64l_t const va_hash = elf_unsigned_dynamic(Elf64_Dyn::DT_HASH);
|
||||
upx_uint64_t const va_gash = elf_unsigned_dynamic(Elf64_Dyn::DT_GNU_HASH);
|
||||
upx_uint64_t const va_hash = elf_unsigned_dynamic(Elf64_Dyn::DT_HASH);
|
||||
if (xct_va < va_gash || (0==va_gash && xct_va < va_hash)
|
||||
|| xct_va < elf_unsigned_dynamic(Elf64_Dyn::DT_STRTAB)
|
||||
|| xct_va < elf_unsigned_dynamic(Elf64_Dyn::DT_SYMTAB)
|
||||
@ -1605,7 +1605,7 @@ PackLinuxElf64amd::canPack()
|
||||
goto abandon;
|
||||
}
|
||||
for ((shdr= shdri), (j= n_elf_shnum); --j>=0; ++shdr) {
|
||||
acc_uint64l_t const sh_addr = get_te64(&shdr->sh_addr);
|
||||
upx_uint64_t const sh_addr = get_te64(&shdr->sh_addr);
|
||||
if ( sh_addr==va_gash
|
||||
|| (sh_addr==va_hash && 0==va_gash) ) {
|
||||
shdr= &shdri[get_te32(&shdr->sh_link)]; // the associated SHT_SYMTAB
|
||||
@ -2871,7 +2871,7 @@ void PackLinuxElf64::pack4(OutputFile *fo, Filter &ft)
|
||||
|
||||
// rewrite Elf header
|
||||
if (Elf64_Ehdr::ET_DYN==get_te16(&ehdri.e_type)) {
|
||||
acc_uint64l_t const base= get_te64(&elfout.phdr[0].p_vaddr);
|
||||
upx_uint64_t const base= get_te64(&elfout.phdr[0].p_vaddr);
|
||||
set_te16(&elfout.ehdr.e_type, Elf64_Ehdr::ET_DYN);
|
||||
set_te16(&elfout.ehdr.e_phnum, 1);
|
||||
set_te64( &elfout.ehdr.e_entry,
|
||||
@ -2889,7 +2889,7 @@ void PackLinuxElf64::pack4(OutputFile *fo, Filter &ft)
|
||||
}
|
||||
else {
|
||||
if (Elf64_Phdr::PT_NOTE==get_te64(&elfout.phdr[2].p_type)) {
|
||||
acc_uint64l_t const reloc = get_te64(&elfout.phdr[0].p_vaddr);
|
||||
upx_uint64_t const reloc = get_te64(&elfout.phdr[0].p_vaddr);
|
||||
set_te64( &elfout.phdr[2].p_vaddr,
|
||||
reloc + get_te64(&elfout.phdr[2].p_vaddr));
|
||||
set_te64( &elfout.phdr[2].p_paddr,
|
||||
@ -2918,7 +2918,7 @@ void PackLinuxElf64::unpack(OutputFile *fo)
|
||||
{
|
||||
fi->seek(0, SEEK_SET);
|
||||
fi->readx(u.buf, MAX_ELF_HDR);
|
||||
acc_uint64l_t const e_entry = get_te64(&ehdr->e_entry);
|
||||
upx_uint64_t const e_entry = get_te64(&ehdr->e_entry);
|
||||
if (e_entry < 0x401180
|
||||
&& ehdr->e_machine==Elf64_Ehdr::EM_386) { /* old style, 8-byte b_info */
|
||||
szb_info = 2*sizeof(unsigned);
|
||||
@ -2961,8 +2961,8 @@ void PackLinuxElf64::unpack(OutputFile *fo)
|
||||
fi->seek(- (off_t) (szb_info + ph.c_len), SEEK_CUR);
|
||||
for (unsigned j=0; j < u_phnum; ++phdr, ++j) {
|
||||
if (PT_LOAD64==get_te32(&phdr->p_type)) {
|
||||
acc_uint64l_t const filesz = get_te64(&phdr->p_filesz);
|
||||
acc_uint64l_t const offset = get_te64(&phdr->p_offset);
|
||||
upx_uint64_t const filesz = get_te64(&phdr->p_filesz);
|
||||
upx_uint64_t const offset = get_te64(&phdr->p_offset);
|
||||
if (fo)
|
||||
fo->seek(offset, SEEK_SET);
|
||||
if (Elf64_Phdr::PF_X & get_te32(&phdr->p_flags)) {
|
||||
@ -3221,7 +3221,7 @@ PackLinuxElf32::elf_find_dynamic(unsigned int const key) const
|
||||
return 0;
|
||||
}
|
||||
|
||||
acc_uint64l_t
|
||||
upx_uint64_t
|
||||
PackLinuxElf32::elf_unsigned_dynamic(unsigned int const key) const
|
||||
{
|
||||
Elf32_Dyn const *dynp= dynseg;
|
||||
@ -3232,13 +3232,13 @@ PackLinuxElf32::elf_unsigned_dynamic(unsigned int const key) const
|
||||
return 0;
|
||||
}
|
||||
|
||||
acc_uint64l_t
|
||||
PackLinuxElf64::elf_get_offset_from_address(acc_uint64l_t const addr) const
|
||||
upx_uint64_t
|
||||
PackLinuxElf64::elf_get_offset_from_address(upx_uint64_t const addr) const
|
||||
{
|
||||
Elf64_Phdr const *phdr = phdri;
|
||||
int j = e_phnum;
|
||||
for (; --j>=0; ++phdr) if (PT_LOAD64 == get_te32(&phdr->p_type)) {
|
||||
acc_uint64l_t const t = addr - get_te64(&phdr->p_vaddr);
|
||||
upx_uint64_t const t = addr - get_te64(&phdr->p_vaddr);
|
||||
if (t < get_te64(&phdr->p_filesz)) {
|
||||
return t + get_te64(&phdr->p_offset);
|
||||
}
|
||||
@ -3263,7 +3263,7 @@ PackLinuxElf64::elf_find_dynamic(unsigned int const key) const
|
||||
Elf64_Dyn const *dynp= dynseg;
|
||||
if (dynp)
|
||||
for (; Elf64_Dyn::DT_NULL!=dynp->d_tag; ++dynp) if (get_te64(&dynp->d_tag)==key) {
|
||||
acc_uint64l_t const t= elf_get_offset_from_address(get_te64(&dynp->d_val));
|
||||
upx_uint64_t const t= elf_get_offset_from_address(get_te64(&dynp->d_val));
|
||||
if (t) {
|
||||
return (size_t)t + file_image;
|
||||
}
|
||||
@ -3272,7 +3272,7 @@ PackLinuxElf64::elf_find_dynamic(unsigned int const key) const
|
||||
return 0;
|
||||
}
|
||||
|
||||
acc_uint64l_t
|
||||
upx_uint64_t
|
||||
PackLinuxElf64::elf_unsigned_dynamic(unsigned int const key) const
|
||||
{
|
||||
Elf64_Dyn const *dynp= dynseg;
|
||||
|
||||
@ -64,7 +64,7 @@ protected:
|
||||
virtual void unpack(OutputFile *fo);
|
||||
|
||||
//virtual void const *elf_find_dynamic(unsigned) const = 0;
|
||||
virtual acc_uint64l_t elf_unsigned_dynamic(unsigned) const = 0;
|
||||
virtual upx_uint64_t elf_unsigned_dynamic(unsigned) const = 0;
|
||||
|
||||
protected:
|
||||
unsigned e_phnum; /* Program header table entry count */
|
||||
@ -79,8 +79,8 @@ protected:
|
||||
unsigned page_size; // 1u<<lg2_page
|
||||
unsigned xct_off; // shared library: file offset of SHT_EXECINSTR
|
||||
unsigned hatch_off; // file offset of escape hatch
|
||||
acc_uint64l_t load_va; // PT_LOAD[0].p_vaddr
|
||||
acc_uint64l_t xct_va; // minimum SHT_EXECINSTR virtual address
|
||||
upx_uint64_t load_va; // PT_LOAD[0].p_vaddr
|
||||
upx_uint64_t xct_va; // minimum SHT_EXECINSTR virtual address
|
||||
|
||||
unsigned short e_machine;
|
||||
unsigned char ei_class;
|
||||
@ -142,7 +142,7 @@ protected:
|
||||
Elf32_Shdr const *elf_find_section_type(unsigned) const;
|
||||
void const *elf_find_dynamic(unsigned) const;
|
||||
Elf32_Dyn const *elf_has_dynamic(unsigned) const;
|
||||
acc_uint64l_t elf_unsigned_dynamic(unsigned) const;
|
||||
upx_uint64_t elf_unsigned_dynamic(unsigned) const;
|
||||
|
||||
protected:
|
||||
Elf32_Ehdr ehdri; // from input file
|
||||
@ -250,12 +250,12 @@ protected:
|
||||
virtual unsigned find_LOAD_gap(Elf64_Phdr const *const phdri, unsigned const k,
|
||||
unsigned const e_phnum);
|
||||
|
||||
virtual acc_uint64l_t elf_get_offset_from_address(acc_uint64l_t) const;
|
||||
virtual upx_uint64_t elf_get_offset_from_address(upx_uint64_t) const;
|
||||
Elf64_Shdr const *elf_find_section_name(char const *) const;
|
||||
Elf64_Shdr const *elf_find_section_type(unsigned) const;
|
||||
void const *elf_find_dynamic(unsigned) const;
|
||||
Elf64_Dyn const *elf_has_dynamic(unsigned) const;
|
||||
acc_uint64l_t elf_unsigned_dynamic(unsigned) const;
|
||||
upx_uint64_t elf_unsigned_dynamic(unsigned) const;
|
||||
|
||||
protected:
|
||||
Elf64_Ehdr ehdri; // from input file
|
||||
@ -263,7 +263,7 @@ protected:
|
||||
unsigned char *note_body; // concatenated contents of PT_NOTEs, if any
|
||||
unsigned note_size; // total size of PT_NOTEs
|
||||
Elf64_Shdr const *shdri; // from input file
|
||||
acc_uint64l_t page_mask; // AND clears the offset-within-page
|
||||
upx_uint64_t page_mask; // AND clears the offset-within-page
|
||||
|
||||
Elf64_Dyn const *dynseg; // from PT_DYNAMIC
|
||||
unsigned int const *hashtab; // from DT_HASH
|
||||
|
||||
@ -375,7 +375,7 @@ PackLinuxI386::buildLinuxLoader(
|
||||
addLoader("FOLDEXEC", NULL);
|
||||
if (M_IS_LZMA(ph.method)) {
|
||||
const lzma_compress_result_t *res = &ph.compress_result.result_lzma;
|
||||
acc_uint32e_t properties = // lc, lp, pb, dummy
|
||||
upx_uint32_t properties = // lc, lp, pb, dummy
|
||||
(res->lit_context_bits << 0) |
|
||||
(res->lit_pos_bits << 8) |
|
||||
(res->pos_bits << 16);
|
||||
|
||||
@ -470,8 +470,8 @@ PackMachBase<T>::compare_segment_command(void const *const aa, void const *const
|
||||
|
||||
#undef PAGE_MASK64
|
||||
#undef PAGE_SIZE64
|
||||
#define PAGE_MASK64 (~(acc_uint64l_t)0<<12)
|
||||
#define PAGE_SIZE64 ((acc_uint64l_t)0-PAGE_MASK64)
|
||||
#define PAGE_MASK64 (~(upx_uint64_t)0<<12)
|
||||
#define PAGE_SIZE64 ((upx_uint64_t)0-PAGE_MASK64)
|
||||
|
||||
// At 2013-02-03 part of the source for codesign was
|
||||
// http://opensource.apple.com/source/cctools/cctools-836/libstuff/ofile.c
|
||||
|
||||
@ -608,7 +608,7 @@ protected:
|
||||
Mach_segment_command *rawmseg; // as input, with sections
|
||||
Mach_segment_command *msegcmd; // LC_SEGMENT first, without sections
|
||||
unsigned o_routines_cmd; // file offset to LC_ROUINTES
|
||||
acc_uint64l_t prev_init_address;
|
||||
upx_uint64_t prev_init_address;
|
||||
Mach_header mhdri;
|
||||
|
||||
Mach_header mhdro;
|
||||
|
||||
@ -591,7 +591,7 @@ void PackBvmlinuzI386::pack(OutputFile *fo)
|
||||
|
||||
if (M_IS_LZMA(ph.method)) {
|
||||
const lzma_compress_result_t *res = &ph.compress_result.result_lzma;
|
||||
acc_uint32e_t properties = // lc, lp, pb, dummy
|
||||
upx_uint32_t properties = // lc, lp, pb, dummy
|
||||
(res->lit_context_bits << 0) |
|
||||
(res->lit_pos_bits << 8) |
|
||||
(res->pos_bits << 16);
|
||||
|
||||
@ -512,7 +512,7 @@ void PackW64Pep::processTls(Interval *iv) // pass 1
|
||||
throwCantPack("invalid TLS callback");
|
||||
else if (tlsp->callbacks - ih.imagebase + 4 >= ih.imagesize)
|
||||
throwCantPack("invalid TLS callback");
|
||||
acc_uint64l_t v = get_le64(ibuf + (tlsp->callbacks - ih.imagebase));
|
||||
upx_uint64_t v = get_le64(ibuf + (tlsp->callbacks - ih.imagebase));
|
||||
if (v != 0)
|
||||
{
|
||||
//count number of callbacks, just for information string - Stefan Widmann
|
||||
@ -580,7 +580,7 @@ void PackW64Pep::processTls(Reloc *rel,const Interval *iv,unsigned newaddr) // p
|
||||
for (ic = 0; ic < iv->ivnum; ic += 4)
|
||||
{
|
||||
void *p = otls + iv->ivarr[ic].start - (tlsp->datastart - ih.imagebase) + sizeof(tls);
|
||||
acc_uint64l_t kc = get_le64(p); //changed to LE64 - Stefan Widmann
|
||||
upx_uint64_t kc = get_le64(p); //changed to LE64 - Stefan Widmann
|
||||
if (kc < tlsp->dataend && kc >= tlsp->datastart)
|
||||
{
|
||||
kc += newaddr + sizeof(tls) - tlsp->datastart;
|
||||
|
||||
12
src/packer.h
12
src/packer.h
@ -292,12 +292,12 @@ protected:
|
||||
static unsigned unoptimizeReloc64(upx_byte **in,upx_byte *image,MemBuffer *out,int bs);
|
||||
|
||||
// target endianness abstraction
|
||||
unsigned get_te16(const void *p) const { return bele->get16(p); }
|
||||
unsigned get_te32(const void *p) const { return bele->get32(p); }
|
||||
acc_uint64l_t get_te64(const void *p) const { return bele->get64(p); }
|
||||
void set_te16(void *p, unsigned v) const { bele->set16(p, v); }
|
||||
void set_te32(void *p, unsigned v) const { bele->set32(p, v); }
|
||||
void set_te64(void *p, acc_uint64l_t v) const { bele->set64(p, v); }
|
||||
unsigned get_te16(const void *p) const { return bele->get16(p); }
|
||||
unsigned get_te32(const void *p) const { return bele->get32(p); }
|
||||
upx_uint64_t get_te64(const void *p) const { return bele->get64(p); }
|
||||
void set_te16(void *p, unsigned v) const { bele->set16(p, v); }
|
||||
void set_te32(void *p, unsigned v) const { bele->set32(p, v); }
|
||||
void set_te64(void *p, upx_uint64_t v) const { bele->set64(p, v); }
|
||||
|
||||
protected:
|
||||
const N_BELE_RTP::AbstractPolicy *bele; // target endianness
|
||||
|
||||
@ -266,7 +266,7 @@ void Packer::defineDecompressorSymbols()
|
||||
if (M_IS_LZMA(ph.method))
|
||||
{
|
||||
const lzma_compress_result_t *res = &ph.compress_result.result_lzma;
|
||||
acc_uint32e_t properties = // lc, lp, pb, dummy
|
||||
upx_uint32_t properties = // lc, lp, pb, dummy
|
||||
(res->lit_context_bits << 0) |
|
||||
(res->lit_pos_bits << 8) |
|
||||
(res->pos_bits << 16);
|
||||
|
||||
@ -72,9 +72,9 @@
|
||||
|
||||
#undef LLONG
|
||||
#undef ULLONG
|
||||
#if 1 && defined(acc_int64l_t)
|
||||
# define LLONG acc_int64l_t
|
||||
# define ULLONG acc_uint64l_t
|
||||
#if 1 && defined(upx_int64_t)
|
||||
# define LLONG upx_int64_t
|
||||
# define ULLONG upx_uint64_t
|
||||
#else
|
||||
# define LLONG long int
|
||||
# define ULLONG unsigned long int
|
||||
@ -713,7 +713,7 @@ static size_t dopr(char *buffer, size_t maxlen, const char *format, va_list args
|
||||
break;
|
||||
case 'p':
|
||||
strvalue = (const char *) va_arg (args, const void *);
|
||||
fmtint (buffer, &currlen, maxlen, (LLONG) (acc_uintptr_t) strvalue, 16, min, max, flags);
|
||||
fmtint (buffer, &currlen, maxlen, (LLONG) (upx_uintptr_t) strvalue, 16, min, max, flags);
|
||||
break;
|
||||
case 'n':
|
||||
if (cflags == DP_C_SHORT) {
|
||||
|
||||
@ -52,7 +52,7 @@ void *VirtualAlloc(void *address, unsigned size, unsigned type, unsigned protect
|
||||
# define PAGE_EXECUTE_READWRITE 0x0040
|
||||
#endif
|
||||
|
||||
typedef size_t acc_uintptr_t;
|
||||
typedef size_t upx_uintptr_t;
|
||||
typedef unsigned short LE16;
|
||||
typedef unsigned int LE32;
|
||||
#define get_le32(p) (* (const unsigned *) (p))
|
||||
|
||||
24
src/util.cpp
24
src/util.cpp
@ -88,8 +88,8 @@ int __acc_cdecl_qsort be32_compare(const void *e1, const void *e2)
|
||||
|
||||
int __acc_cdecl_qsort be64_compare(const void *e1, const void *e2)
|
||||
{
|
||||
const acc_uint64l_t d1 = get_be64(e1);
|
||||
const acc_uint64l_t d2 = get_be64(e2);
|
||||
const upx_uint64_t d1 = get_be64(e1);
|
||||
const upx_uint64_t d2 = get_be64(e2);
|
||||
return (d1 < d2) ? -1 : ((d1 > d2) ? 1 : 0);
|
||||
}
|
||||
|
||||
@ -116,8 +116,8 @@ int __acc_cdecl_qsort le32_compare(const void *e1, const void *e2)
|
||||
|
||||
int __acc_cdecl_qsort le64_compare(const void *e1, const void *e2)
|
||||
{
|
||||
const acc_uint64l_t d1 = get_le64(e1);
|
||||
const acc_uint64l_t d2 = get_le64(e2);
|
||||
const upx_uint64_t d1 = get_le64(e1);
|
||||
const upx_uint64_t d2 = get_le64(e2);
|
||||
return (d1 < d2) ? -1 : ((d1 > d2) ? 1 : 0);
|
||||
}
|
||||
|
||||
@ -145,8 +145,8 @@ int __acc_cdecl_qsort be32_compare_signed(const void *e1, const void *e2)
|
||||
|
||||
int __acc_cdecl_qsort be64_compare_signed(const void *e1, const void *e2)
|
||||
{
|
||||
const acc_int64l_t d1 = get_be64_signed(e1);
|
||||
const acc_int64l_t d2 = get_be64_signed(e2);
|
||||
const upx_int64_t d1 = get_be64_signed(e1);
|
||||
const upx_int64_t d2 = get_be64_signed(e2);
|
||||
return (d1 < d2) ? -1 : ((d1 > d2) ? 1 : 0);
|
||||
}
|
||||
|
||||
@ -173,8 +173,8 @@ int __acc_cdecl_qsort le32_compare_signed(const void *e1, const void *e2)
|
||||
|
||||
int __acc_cdecl_qsort le64_compare_signed(const void *e1, const void *e2)
|
||||
{
|
||||
const acc_int64l_t d1 = get_le64_signed(e1);
|
||||
const acc_int64l_t d2 = get_le64_signed(e2);
|
||||
const upx_int64_t d1 = get_le64_signed(e1);
|
||||
const upx_int64_t d2 = get_le64_signed(e2);
|
||||
return (d1 < d2) ? -1 : ((d1 > d2) ? 1 : 0);
|
||||
}
|
||||
|
||||
@ -217,7 +217,7 @@ int find_be32(const void *b, int blen, unsigned what)
|
||||
}
|
||||
|
||||
|
||||
int find_be64(const void *b, int blen, acc_uint64l_t what)
|
||||
int find_be64(const void *b, int blen, upx_uint64_t what)
|
||||
{
|
||||
unsigned char w[8];
|
||||
set_be64(w, what);
|
||||
@ -241,7 +241,7 @@ int find_le32(const void *b, int blen, unsigned what)
|
||||
}
|
||||
|
||||
|
||||
int find_le64(const void *b, int blen, acc_uint64l_t what)
|
||||
int find_le64(const void *b, int blen, upx_uint64_t what)
|
||||
{
|
||||
unsigned char w[8];
|
||||
set_le64(w, what);
|
||||
@ -562,8 +562,8 @@ unsigned get_ratio(unsigned u_len, unsigned c_len)
|
||||
const unsigned n = 1000000;
|
||||
if (u_len <= 0)
|
||||
return c_len <= 0 ? 0 : n;
|
||||
#if defined(acc_uint64l_t)
|
||||
return (unsigned) ((c_len * (acc_uint64l_t)n) / u_len);
|
||||
#if defined(upx_uint64_t)
|
||||
return (unsigned) ((c_len * (upx_uint64_t)n) / u_len);
|
||||
#else
|
||||
# if 0
|
||||
return (unsigned) acc_umuldiv32(c_len, n, u_len);
|
||||
|
||||
@ -53,10 +53,10 @@ void center_string(char *buf, size_t size, const char *s);
|
||||
int find(const void *b, int blen, const void *what, int wlen);
|
||||
int find_be16(const void *b, int blen, unsigned what);
|
||||
int find_be32(const void *b, int blen, unsigned what);
|
||||
int find_be64(const void *b, int blen, acc_uint64l_t what);
|
||||
int find_be64(const void *b, int blen, upx_uint64_t what);
|
||||
int find_le16(const void *b, int blen, unsigned what);
|
||||
int find_le32(const void *b, int blen, unsigned what);
|
||||
int find_le64(const void *b, int blen, acc_uint64l_t what);
|
||||
int find_le64(const void *b, int blen, upx_uint64_t what);
|
||||
|
||||
int mem_replace(void *b, int blen, const void *what, int wlen, const void *r);
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user