mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-11-27 03:51:15 +08:00
909fcd9bc8
The DEBUG_S_INLINEELINES block in the .debug$S section records the line numbers in a source file covered by inlined functions. It's similar to the DEBUG_S_LINES block, but as it references LF_FUNC_ID types we also need to parse it to remap the type numbers.
5413 lines
123 KiB
C
5413 lines
123 KiB
C
/* Support for generating PDB CodeView debugging files.
|
|
Copyright (C) 2022-2024 Free Software Foundation, Inc.
|
|
|
|
This file is part of the GNU Binutils.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
|
|
MA 02110-1301, USA. */
|
|
|
|
#include "pdb.h"
|
|
#include "bfdlink.h"
|
|
#include "ld.h"
|
|
#include "ldmain.h"
|
|
#include "ldmisc.h"
|
|
#include "libbfd.h"
|
|
#include "libiberty.h"
|
|
#include "coff/i386.h"
|
|
#include "coff/external.h"
|
|
#include "coff/internal.h"
|
|
#include "coff/pe.h"
|
|
#include "libcoff.h"
|
|
#include <time.h>
|
|
|
|
struct public
|
|
{
|
|
struct public *next;
|
|
uint32_t offset;
|
|
uint32_t hash;
|
|
unsigned int index;
|
|
uint16_t section;
|
|
uint32_t address;
|
|
};
|
|
|
|
struct string
|
|
{
|
|
struct string *next;
|
|
uint32_t hash;
|
|
uint32_t offset;
|
|
uint32_t source_file_offset;
|
|
size_t len;
|
|
char s[];
|
|
};
|
|
|
|
struct string_table
|
|
{
|
|
struct string *strings_head;
|
|
struct string *strings_tail;
|
|
uint32_t strings_len;
|
|
htab_t hashmap;
|
|
};
|
|
|
|
struct mod_source_files
|
|
{
|
|
uint16_t files_count;
|
|
struct string **files;
|
|
};
|
|
|
|
struct source_files_info
|
|
{
|
|
uint16_t mod_count;
|
|
struct mod_source_files *mods;
|
|
};
|
|
|
|
struct type_entry
|
|
{
|
|
struct type_entry *next;
|
|
uint32_t index;
|
|
uint32_t cv_hash;
|
|
bool has_udt_src_line;
|
|
uint8_t data[];
|
|
};
|
|
|
|
struct types
|
|
{
|
|
htab_t hashmap;
|
|
uint32_t num_types;
|
|
struct type_entry *first;
|
|
struct type_entry *last;
|
|
};
|
|
|
|
struct global
|
|
{
|
|
struct global *next;
|
|
uint32_t offset;
|
|
uint32_t hash;
|
|
uint32_t refcount;
|
|
unsigned int index;
|
|
uint8_t data[];
|
|
};
|
|
|
|
struct globals
|
|
{
|
|
uint32_t num_entries;
|
|
struct global *first;
|
|
struct global *last;
|
|
htab_t hashmap;
|
|
};
|
|
|
|
struct in_sc
|
|
{
|
|
asection *s;
|
|
uint16_t sect_num;
|
|
uint16_t mod_index;
|
|
};
|
|
|
|
static const uint32_t crc_table[] =
|
|
{
|
|
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
|
|
0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
|
|
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
|
|
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
|
|
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
|
|
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
|
|
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
|
|
0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
|
|
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
|
|
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
|
|
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
|
|
0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
|
|
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
|
|
0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
|
|
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
|
|
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
|
|
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
|
|
0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
|
|
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
|
|
0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
|
|
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
|
|
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
|
|
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
|
|
0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
|
|
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
|
|
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
|
|
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
|
|
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
|
|
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
|
|
0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
|
|
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
|
|
0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
|
|
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
|
|
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
|
|
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
|
|
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
|
|
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
|
|
0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
|
|
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
|
|
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
|
|
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
|
|
0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
|
|
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
|
|
};
|
|
|
|
static bool remap_type (void *data, struct type_entry **map,
|
|
uint32_t type_num, uint32_t num_types);
|
|
|
|
/* Add a new stream to the PDB archive, and return its BFD. */
|
|
static bfd *
|
|
add_stream (bfd *pdb, const char *name, uint16_t *stream_num)
|
|
{
|
|
bfd *stream;
|
|
uint16_t num;
|
|
|
|
stream = bfd_create (name ? name : "", pdb);
|
|
if (!stream)
|
|
return NULL;
|
|
|
|
if (!bfd_make_writable (stream))
|
|
{
|
|
bfd_close (stream);
|
|
return false;
|
|
}
|
|
|
|
if (!pdb->archive_head)
|
|
{
|
|
bfd_set_archive_head (pdb, stream);
|
|
num = 0;
|
|
}
|
|
else
|
|
{
|
|
bfd *b = pdb->archive_head;
|
|
|
|
num = 1;
|
|
|
|
while (b->archive_next)
|
|
{
|
|
num++;
|
|
b = b->archive_next;
|
|
}
|
|
|
|
b->archive_next = stream;
|
|
}
|
|
|
|
if (stream_num)
|
|
*stream_num = num;
|
|
|
|
return stream;
|
|
}
|
|
|
|
/* Stream 0 ought to be a copy of the MSF directory from the last
|
|
time the PDB file was written. Because we don't do incremental
|
|
writes this isn't applicable to us, but we fill it with a dummy
|
|
value so as not to confuse radare. */
|
|
static bool
|
|
create_old_directory_stream (bfd *pdb)
|
|
{
|
|
bfd *stream;
|
|
char buf[sizeof (uint32_t)];
|
|
|
|
stream = add_stream (pdb, NULL, NULL);
|
|
if (!stream)
|
|
return false;
|
|
|
|
bfd_putl32 (0, buf);
|
|
|
|
return bfd_write (buf, sizeof (uint32_t), stream) == sizeof (uint32_t);
|
|
}
|
|
|
|
/* Calculate the hash of a given string. */
|
|
static uint32_t
|
|
calc_hash (const char *data, size_t len)
|
|
{
|
|
uint32_t hash = 0;
|
|
|
|
while (len >= 4)
|
|
{
|
|
hash ^= data[0];
|
|
hash ^= data[1] << 8;
|
|
hash ^= data[2] << 16;
|
|
hash ^= data[3] << 24;
|
|
|
|
data += 4;
|
|
len -= 4;
|
|
}
|
|
|
|
if (len >= 2)
|
|
{
|
|
hash ^= data[0];
|
|
hash ^= data[1] << 8;
|
|
|
|
data += 2;
|
|
len -= 2;
|
|
}
|
|
|
|
if (len != 0)
|
|
hash ^= *data;
|
|
|
|
hash |= 0x20202020;
|
|
hash ^= (hash >> 11);
|
|
|
|
return hash ^ (hash >> 16);
|
|
}
|
|
|
|
/* Stream 1 is the PDB info stream - see
|
|
https://llvm.org/docs/PDB/PdbStream.html. */
|
|
static bool
|
|
populate_info_stream (bfd *pdb, bfd *info_stream, const unsigned char *guid)
|
|
{
|
|
bool ret = false;
|
|
struct pdb_stream_70 h;
|
|
uint32_t num_entries, num_buckets;
|
|
uint32_t names_length, stream_num;
|
|
char int_buf[sizeof (uint32_t)];
|
|
|
|
struct hash_entry
|
|
{
|
|
uint32_t offset;
|
|
uint32_t value;
|
|
};
|
|
|
|
struct hash_entry **buckets = NULL;
|
|
|
|
/* Write header. */
|
|
|
|
bfd_putl32 (PDB_STREAM_VERSION_VC70, &h.version);
|
|
bfd_putl32 (time (NULL), &h.signature);
|
|
bfd_putl32 (1, &h.age);
|
|
|
|
bfd_putl32 (bfd_getb32 (guid), h.guid);
|
|
bfd_putl16 (bfd_getb16 (&guid[4]), &h.guid[4]);
|
|
bfd_putl16 (bfd_getb16 (&guid[6]), &h.guid[6]);
|
|
memcpy (&h.guid[8], &guid[8], 8);
|
|
|
|
if (bfd_write (&h, sizeof (h), info_stream) != sizeof (h))
|
|
return false;
|
|
|
|
/* Write hash list of named streams. This is a "rollover" hash, i.e.
|
|
if a bucket is filled an entry gets placed in the next free
|
|
slot. */
|
|
|
|
num_entries = 0;
|
|
for (bfd *b = pdb->archive_head; b; b = b->archive_next)
|
|
{
|
|
if (strcmp (b->filename, ""))
|
|
num_entries++;
|
|
}
|
|
|
|
num_buckets = num_entries * 2;
|
|
|
|
names_length = 0;
|
|
stream_num = 0;
|
|
|
|
if (num_buckets > 0)
|
|
{
|
|
buckets = xmalloc (sizeof (struct hash_entry *) * num_buckets);
|
|
memset (buckets, 0, sizeof (struct hash_entry *) * num_buckets);
|
|
|
|
for (bfd *b = pdb->archive_head; b; b = b->archive_next)
|
|
{
|
|
if (strcmp (b->filename, ""))
|
|
{
|
|
size_t len = strlen (b->filename);
|
|
uint32_t hash = (uint16_t) calc_hash (b->filename, len);
|
|
uint32_t bucket_num = hash % num_buckets;
|
|
|
|
while (buckets[bucket_num])
|
|
{
|
|
bucket_num++;
|
|
|
|
if (bucket_num == num_buckets)
|
|
bucket_num = 0;
|
|
}
|
|
|
|
buckets[bucket_num] = xmalloc (sizeof (struct hash_entry));
|
|
|
|
buckets[bucket_num]->offset = names_length;
|
|
buckets[bucket_num]->value = stream_num;
|
|
|
|
names_length += len + 1;
|
|
}
|
|
|
|
stream_num++;
|
|
}
|
|
}
|
|
|
|
/* Write the strings list - the hash keys are indexes into this. */
|
|
|
|
bfd_putl32 (names_length, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), info_stream) !=
|
|
sizeof (uint32_t))
|
|
goto end;
|
|
|
|
for (bfd *b = pdb->archive_head; b; b = b->archive_next)
|
|
{
|
|
if (!strcmp (b->filename, ""))
|
|
continue;
|
|
|
|
size_t len = strlen (b->filename) + 1;
|
|
|
|
if (bfd_write (b->filename, len, info_stream) != len)
|
|
goto end;
|
|
}
|
|
|
|
/* Write the number of entries and buckets. */
|
|
|
|
bfd_putl32 (num_entries, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), info_stream) !=
|
|
sizeof (uint32_t))
|
|
goto end;
|
|
|
|
bfd_putl32 (num_buckets, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), info_stream) !=
|
|
sizeof (uint32_t))
|
|
goto end;
|
|
|
|
/* Write the present bitmap. */
|
|
|
|
bfd_putl32 ((num_buckets + 31) / 32, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), info_stream) !=
|
|
sizeof (uint32_t))
|
|
goto end;
|
|
|
|
for (unsigned int i = 0; i < num_buckets; i += 32)
|
|
{
|
|
uint32_t v = 0;
|
|
|
|
for (unsigned int j = 0; j < 32; j++)
|
|
{
|
|
if (i + j >= num_buckets)
|
|
break;
|
|
|
|
if (buckets[i + j])
|
|
v |= 1 << j;
|
|
}
|
|
|
|
bfd_putl32 (v, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), info_stream) !=
|
|
sizeof (uint32_t))
|
|
goto end;
|
|
}
|
|
|
|
/* Write the (empty) deleted bitmap. */
|
|
|
|
bfd_putl32 (0, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), info_stream) !=
|
|
sizeof (uint32_t))
|
|
goto end;
|
|
|
|
/* Write the buckets. */
|
|
|
|
for (unsigned int i = 0; i < num_buckets; i++)
|
|
{
|
|
if (buckets[i])
|
|
{
|
|
bfd_putl32 (buckets[i]->offset, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), info_stream) !=
|
|
sizeof (uint32_t))
|
|
goto end;
|
|
|
|
bfd_putl32 (buckets[i]->value, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), info_stream) !=
|
|
sizeof (uint32_t))
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
bfd_putl32 (0, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), info_stream) !=
|
|
sizeof (uint32_t))
|
|
goto end;
|
|
|
|
bfd_putl32 (PDB_STREAM_VERSION_VC140, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), info_stream) !=
|
|
sizeof (uint32_t))
|
|
goto end;
|
|
|
|
ret = true;
|
|
|
|
end:
|
|
for (unsigned int i = 0; i < num_buckets; i++)
|
|
{
|
|
if (buckets[i])
|
|
free (buckets[i]);
|
|
}
|
|
|
|
free (buckets);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Calculate the CRC32 used for type hashes. */
|
|
static uint32_t
|
|
crc32 (const uint8_t *data, size_t len)
|
|
{
|
|
uint32_t crc = 0;
|
|
|
|
while (len > 0)
|
|
{
|
|
crc = (crc >> 8) ^ crc_table[(crc & 0xff) ^ *data];
|
|
|
|
data++;
|
|
len--;
|
|
}
|
|
|
|
return crc;
|
|
}
|
|
|
|
/* Stream 2 is the type information (TPI) stream, and stream 4 is
|
|
the ID information (IPI) stream. They differ only in which records
|
|
go in which stream. */
|
|
static bool
|
|
populate_type_stream (bfd *pdb, bfd *stream, struct types *types)
|
|
{
|
|
struct pdb_tpi_stream_header h;
|
|
struct type_entry *e;
|
|
uint32_t len = 0, index_offset_len, off;
|
|
struct bfd *hash_stream = NULL;
|
|
uint16_t hash_stream_index;
|
|
|
|
static const uint32_t index_skip = 0x2000;
|
|
|
|
e = types->first;
|
|
|
|
index_offset_len = 0;
|
|
|
|
while (e)
|
|
{
|
|
uint32_t old_len = len;
|
|
|
|
len += sizeof (uint16_t) + bfd_getl16 (e->data);
|
|
|
|
if (old_len == 0 || old_len / index_skip != len / index_skip)
|
|
index_offset_len += sizeof (uint32_t) * 2;
|
|
|
|
e = e->next;
|
|
}
|
|
|
|
/* Each type stream also has a stream which holds the hash value for each
|
|
type, along with a skip list to speed up searching. */
|
|
|
|
hash_stream = add_stream (pdb, "", &hash_stream_index);
|
|
|
|
if (!hash_stream)
|
|
return false;
|
|
|
|
bfd_putl32 (TPI_STREAM_VERSION_80, &h.version);
|
|
bfd_putl32 (sizeof (h), &h.header_size);
|
|
bfd_putl32 (TPI_FIRST_INDEX, &h.type_index_begin);
|
|
bfd_putl32 (TPI_FIRST_INDEX + types->num_types, &h.type_index_end);
|
|
bfd_putl32 (len, &h.type_record_bytes);
|
|
bfd_putl16 (hash_stream_index, &h.hash_stream_index);
|
|
bfd_putl16 (0xffff, &h.hash_aux_stream_index);
|
|
bfd_putl32 (sizeof (uint32_t), &h.hash_key_size);
|
|
bfd_putl32 (NUM_TPI_HASH_BUCKETS, &h.num_hash_buckets);
|
|
bfd_putl32 (0, &h.hash_value_buffer_offset);
|
|
bfd_putl32 (types->num_types * sizeof (uint32_t),
|
|
&h.hash_value_buffer_length);
|
|
bfd_putl32 (types->num_types * sizeof (uint32_t),
|
|
&h.index_offset_buffer_offset);
|
|
bfd_putl32 (index_offset_len, &h.index_offset_buffer_length);
|
|
bfd_putl32 ((types->num_types * sizeof (uint32_t)) + index_offset_len,
|
|
&h.hash_adj_buffer_offset);
|
|
bfd_putl32 (0, &h.hash_adj_buffer_length);
|
|
|
|
if (bfd_write (&h, sizeof (h), stream) != sizeof (h))
|
|
return false;
|
|
|
|
/* Write the type definitions into the main stream, and the hashes
|
|
into the hash stream. The hashes have already been calculated
|
|
in handle_type. */
|
|
|
|
e = types->first;
|
|
|
|
while (e)
|
|
{
|
|
uint8_t buf[sizeof (uint32_t)];
|
|
uint16_t size;
|
|
|
|
size = bfd_getl16 (e->data);
|
|
|
|
if (bfd_write (e->data, size + sizeof (uint16_t), stream)
|
|
!= size + sizeof (uint16_t))
|
|
return false;
|
|
|
|
bfd_putl32 (e->cv_hash % NUM_TPI_HASH_BUCKETS, buf);
|
|
|
|
if (bfd_write (buf, sizeof (uint32_t), hash_stream)
|
|
!= sizeof (uint32_t))
|
|
return false;
|
|
|
|
e = e->next;
|
|
}
|
|
|
|
/* Write the index offsets, i.e. the skip list, into the hash stream. We
|
|
copy MSVC here by writing a new entry for every 8192 bytes. */
|
|
|
|
e = types->first;
|
|
off = 0;
|
|
|
|
while (e)
|
|
{
|
|
uint32_t old_off = off;
|
|
uint16_t size = bfd_getl16 (e->data);
|
|
|
|
off += size + sizeof (uint16_t);
|
|
|
|
if (old_off == 0 || old_off / index_skip != len / index_skip)
|
|
{
|
|
uint8_t buf[sizeof (uint32_t)];
|
|
|
|
bfd_putl32 (TPI_FIRST_INDEX + e->index, buf);
|
|
|
|
if (bfd_write (buf, sizeof (uint32_t), hash_stream)
|
|
!= sizeof (uint32_t))
|
|
return false;
|
|
|
|
bfd_putl32 (old_off, buf);
|
|
|
|
if (bfd_write (buf, sizeof (uint32_t), hash_stream)
|
|
!= sizeof (uint32_t))
|
|
return false;
|
|
}
|
|
|
|
e = e->next;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/* Return the PE architecture number for the image. */
|
|
static uint16_t
|
|
get_arch_number (bfd *abfd)
|
|
{
|
|
switch (abfd->arch_info->arch)
|
|
{
|
|
case bfd_arch_i386:
|
|
if (abfd->arch_info->mach & bfd_mach_x86_64)
|
|
return IMAGE_FILE_MACHINE_AMD64;
|
|
else
|
|
return IMAGE_FILE_MACHINE_I386;
|
|
|
|
case bfd_arch_aarch64:
|
|
return IMAGE_FILE_MACHINE_ARM64;
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* Validate the DEBUG_S_FILECHKSMS entry within a module's .debug$S
|
|
section, and copy it to the module's symbol stream. */
|
|
static bool
|
|
copy_filechksms (uint8_t *data, uint32_t size, char *string_table,
|
|
struct string_table *strings, uint8_t *out,
|
|
struct mod_source_files *mod_source)
|
|
{
|
|
uint8_t *orig_data = data;
|
|
uint32_t orig_size = size;
|
|
uint16_t num_files = 0;
|
|
struct string **strptr;
|
|
|
|
bfd_putl32 (DEBUG_S_FILECHKSMS, out);
|
|
out += sizeof (uint32_t);
|
|
|
|
bfd_putl32 (size, out);
|
|
out += sizeof (uint32_t);
|
|
|
|
/* Calculate the number of files, and check for any overflows. */
|
|
|
|
while (size > 0)
|
|
{
|
|
struct file_checksum *fc = (struct file_checksum *) data;
|
|
uint8_t padding;
|
|
size_t len;
|
|
|
|
if (size < sizeof (struct file_checksum))
|
|
{
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
len = sizeof (struct file_checksum) + fc->checksum_length;
|
|
|
|
if (size < len)
|
|
{
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
data += len;
|
|
size -= len;
|
|
|
|
if (len % sizeof (uint32_t))
|
|
padding = sizeof (uint32_t) - (len % sizeof (uint32_t));
|
|
else
|
|
padding = 0;
|
|
|
|
if (size < padding)
|
|
{
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
num_files++;
|
|
|
|
data += padding;
|
|
size -= padding;
|
|
}
|
|
|
|
/* Add the files to mod_source, so that they'll appear in the source
|
|
info substream. */
|
|
|
|
strptr = NULL;
|
|
if (num_files > 0)
|
|
{
|
|
uint16_t new_count = num_files + mod_source->files_count;
|
|
|
|
mod_source->files = xrealloc (mod_source->files,
|
|
sizeof (struct string *) * new_count);
|
|
|
|
strptr = mod_source->files + mod_source->files_count;
|
|
|
|
mod_source->files_count += num_files;
|
|
}
|
|
|
|
/* Actually copy the data. */
|
|
|
|
data = orig_data;
|
|
size = orig_size;
|
|
|
|
while (size > 0)
|
|
{
|
|
struct file_checksum *fc = (struct file_checksum *) data;
|
|
uint32_t string_off;
|
|
uint8_t padding;
|
|
size_t len;
|
|
struct string *str = NULL;
|
|
|
|
string_off = bfd_getl32 (&fc->file_id);
|
|
len = sizeof (struct file_checksum) + fc->checksum_length;
|
|
|
|
if (len % sizeof (uint32_t))
|
|
padding = sizeof (uint32_t) - (len % sizeof (uint32_t));
|
|
else
|
|
padding = 0;
|
|
|
|
/* Remap the "file ID", i.e. the offset in the module's string table,
|
|
so it points to the right place in the main string table. */
|
|
|
|
if (string_table)
|
|
{
|
|
char *fn = string_table + string_off;
|
|
size_t fn_len = strlen (fn);
|
|
uint32_t hash = calc_hash (fn, fn_len);
|
|
void **slot;
|
|
|
|
slot = htab_find_slot_with_hash (strings->hashmap, fn, hash,
|
|
NO_INSERT);
|
|
|
|
if (slot)
|
|
str = (struct string *) *slot;
|
|
}
|
|
|
|
*strptr = str;
|
|
strptr++;
|
|
|
|
bfd_putl32 (str ? str->offset : 0, &fc->file_id);
|
|
|
|
memcpy (out, data, len + padding);
|
|
|
|
data += len + padding;
|
|
size -= len + padding;
|
|
out += len + padding;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/* Add a string to the strings table, if it's not already there. Returns its
|
|
offset within the string table. */
|
|
static uint32_t
|
|
add_string (char *str, size_t len, struct string_table *strings)
|
|
{
|
|
uint32_t hash = calc_hash (str, len);
|
|
struct string *s;
|
|
void **slot;
|
|
|
|
slot = htab_find_slot_with_hash (strings->hashmap, str, hash, INSERT);
|
|
|
|
if (!*slot)
|
|
{
|
|
*slot = xmalloc (offsetof (struct string, s) + len);
|
|
|
|
s = (struct string *) *slot;
|
|
|
|
s->next = NULL;
|
|
s->hash = hash;
|
|
s->offset = strings->strings_len;
|
|
s->source_file_offset = 0xffffffff;
|
|
s->len = len;
|
|
memcpy (s->s, str, len);
|
|
|
|
if (strings->strings_tail)
|
|
strings->strings_tail->next = s;
|
|
else
|
|
strings->strings_head = s;
|
|
|
|
strings->strings_tail = s;
|
|
|
|
strings->strings_len += len + 1;
|
|
}
|
|
else
|
|
{
|
|
s = (struct string *) *slot;
|
|
}
|
|
|
|
return s->offset;
|
|
}
|
|
|
|
/* Return the hash of an entry in the string table. */
|
|
static hashval_t
|
|
hash_string_table_entry (const void *p)
|
|
{
|
|
const struct string *s = (const struct string *) p;
|
|
|
|
return s->hash;
|
|
}
|
|
|
|
/* Compare an entry in the string table with a string. */
|
|
static int
|
|
eq_string_table_entry (const void *a, const void *b)
|
|
{
|
|
const struct string *s1 = (const struct string *) a;
|
|
const char *s2 = (const char *) b;
|
|
size_t s2_len = strlen (s2);
|
|
|
|
if (s2_len != s1->len)
|
|
return 0;
|
|
|
|
return memcmp (s1->s, s2, s2_len) == 0;
|
|
}
|
|
|
|
/* Parse the string table within the .debug$S section. */
|
|
static void
|
|
parse_string_table (bfd_byte *data, size_t size,
|
|
struct string_table *strings)
|
|
{
|
|
while (true)
|
|
{
|
|
size_t len = strnlen ((char *) data, size);
|
|
|
|
add_string ((char *) data, len, strings);
|
|
|
|
data += len + 1;
|
|
|
|
if (size <= len + 1)
|
|
break;
|
|
|
|
size -= len + 1;
|
|
}
|
|
}
|
|
|
|
/* Remap a type reference within a CodeView symbol. */
|
|
static bool
|
|
remap_symbol_type (void *data, struct type_entry **map, uint32_t num_types)
|
|
{
|
|
uint32_t type = bfd_getl32 (data);
|
|
|
|
/* Ignore builtin types (those with IDs below 0x1000). */
|
|
if (type < TPI_FIRST_INDEX)
|
|
return true;
|
|
|
|
if (type >= TPI_FIRST_INDEX + num_types)
|
|
{
|
|
einfo (_("%P: CodeView symbol references out of range type %v\n"),
|
|
type);
|
|
return false;
|
|
}
|
|
|
|
type = TPI_FIRST_INDEX + map[type - TPI_FIRST_INDEX]->index;
|
|
bfd_putl32 (type, data);
|
|
|
|
return true;
|
|
}
|
|
|
|
/* Add an entry into the globals stream. If it already exists, increase
|
|
the refcount. */
|
|
static bool
|
|
add_globals_ref (struct globals *glob, bfd *sym_rec_stream, const char *name,
|
|
size_t name_len, uint8_t *data, size_t len)
|
|
{
|
|
void **slot;
|
|
uint32_t hash;
|
|
struct global *g;
|
|
|
|
slot = htab_find_slot_with_hash (glob->hashmap, data,
|
|
iterative_hash (data, len, 0), INSERT);
|
|
|
|
if (*slot)
|
|
{
|
|
g = *slot;
|
|
g->refcount++;
|
|
return true;
|
|
}
|
|
|
|
*slot = xmalloc (offsetof (struct global, data) + len);
|
|
|
|
hash = calc_hash (name, name_len);
|
|
hash %= NUM_GLOBALS_HASH_BUCKETS;
|
|
|
|
g = *slot;
|
|
g->next = NULL;
|
|
g->offset = bfd_tell (sym_rec_stream);
|
|
g->hash = hash;
|
|
g->refcount = 1;
|
|
memcpy (g->data, data, len);
|
|
|
|
glob->num_entries++;
|
|
|
|
if (glob->last)
|
|
glob->last->next = g;
|
|
else
|
|
glob->first = g;
|
|
|
|
glob->last = g;
|
|
|
|
return bfd_write (data, len, sym_rec_stream) == len;
|
|
}
|
|
|
|
/* Find the end of the current scope within symbols data. */
|
|
static uint8_t *
|
|
find_end_of_scope (uint8_t *data, uint32_t size)
|
|
{
|
|
unsigned int scope_level = 1;
|
|
uint16_t len;
|
|
|
|
len = bfd_getl16 (data) + sizeof (uint16_t);
|
|
|
|
data += len;
|
|
size -= len;
|
|
|
|
while (true)
|
|
{
|
|
uint16_t type;
|
|
|
|
if (size < sizeof (uint32_t))
|
|
return NULL;
|
|
|
|
len = bfd_getl16 (data) + sizeof (uint16_t);
|
|
type = bfd_getl16 (data + sizeof (uint16_t));
|
|
|
|
if (size < len)
|
|
return NULL;
|
|
|
|
switch (type)
|
|
{
|
|
case S_GPROC32:
|
|
case S_LPROC32:
|
|
case S_BLOCK32:
|
|
case S_INLINESITE:
|
|
case S_THUNK32:
|
|
scope_level++;
|
|
break;
|
|
|
|
case S_END:
|
|
case S_PROC_ID_END:
|
|
case S_INLINESITE_END:
|
|
scope_level--;
|
|
|
|
if (scope_level == 0)
|
|
return data;
|
|
|
|
break;
|
|
}
|
|
|
|
data += len;
|
|
size -= len;
|
|
}
|
|
}
|
|
|
|
/* Return the size of an extended value parameter, as used in
|
|
LF_ENUMERATE etc. */
|
|
static unsigned int
|
|
extended_value_len (uint16_t type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case LF_CHAR:
|
|
return 1;
|
|
|
|
case LF_SHORT:
|
|
case LF_USHORT:
|
|
return 2;
|
|
|
|
case LF_LONG:
|
|
case LF_ULONG:
|
|
return 4;
|
|
|
|
case LF_QUADWORD:
|
|
case LF_UQUADWORD:
|
|
return 8;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Parse the symbols in a .debug$S section, and copy them to the module's
|
|
symbol stream. */
|
|
static bool
|
|
parse_symbols (uint8_t *data, uint32_t size, uint8_t **buf,
|
|
struct type_entry **map, uint32_t num_types,
|
|
bfd *sym_rec_stream, struct globals *glob, uint16_t mod_num)
|
|
{
|
|
uint8_t *orig_buf = *buf;
|
|
unsigned int scope_level = 0;
|
|
uint8_t *scope = NULL;
|
|
|
|
while (size >= sizeof (uint16_t))
|
|
{
|
|
uint16_t len, type;
|
|
|
|
len = bfd_getl16 (data) + sizeof (uint16_t);
|
|
|
|
if (len > size)
|
|
{
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
type = bfd_getl16 (data + sizeof (uint16_t));
|
|
|
|
switch (type)
|
|
{
|
|
case S_LDATA32:
|
|
case S_GDATA32:
|
|
case S_LTHREAD32:
|
|
case S_GTHREAD32:
|
|
{
|
|
struct datasym *d = (struct datasym *) data;
|
|
size_t name_len;
|
|
|
|
if (len < offsetof (struct datasym, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView record"
|
|
" S_LDATA32/S_GDATA32/S_LTHREAD32/S_GTHREAD32\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
if (scope_level == 0)
|
|
{
|
|
uint16_t section = bfd_getl16 (&d->section);
|
|
|
|
if (section == 0) /* GC'd, ignore */
|
|
break;
|
|
}
|
|
|
|
name_len =
|
|
strnlen (d->name, len - offsetof (struct datasym, name));
|
|
|
|
if (name_len == len - offsetof (struct datasym, name))
|
|
{
|
|
einfo (_("%P: warning: name for S_LDATA32/S_GDATA32/"
|
|
"S_LTHREAD32/S_GTHREAD32 has no terminating"
|
|
" zero\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
if (!remap_symbol_type (&d->type, map, num_types))
|
|
{
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
/* If S_LDATA32 or S_LTHREAD32, copy into module symbols. */
|
|
|
|
if (type == S_LDATA32 || type == S_LTHREAD32)
|
|
{
|
|
memcpy (*buf, d, len);
|
|
*buf += len;
|
|
}
|
|
|
|
/* S_LDATA32 and S_LTHREAD32 only go in globals if
|
|
not in function scope. */
|
|
if (type == S_GDATA32 || type == S_GTHREAD32 || scope_level == 0)
|
|
{
|
|
if (!add_globals_ref (glob, sym_rec_stream, d->name,
|
|
name_len, data, len))
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case S_GPROC32:
|
|
case S_LPROC32:
|
|
case S_GPROC32_ID:
|
|
case S_LPROC32_ID:
|
|
{
|
|
struct procsym *proc = (struct procsym *) data;
|
|
size_t name_len;
|
|
uint16_t section;
|
|
uint32_t end;
|
|
uint8_t *endptr;
|
|
size_t ref_size, padding;
|
|
struct refsym *ref;
|
|
|
|
if (len < offsetof (struct procsym, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView record"
|
|
" S_GPROC32/S_LPROC32\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
section = bfd_getl16 (&proc->section);
|
|
|
|
endptr = find_end_of_scope (data, size);
|
|
|
|
if (!endptr)
|
|
{
|
|
einfo (_("%P: warning: could not find end of"
|
|
" S_GPROC32/S_LPROC32 record\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
if (section == 0) /* skip if GC'd */
|
|
{
|
|
/* Skip to after S_END. */
|
|
|
|
size -= endptr - data;
|
|
data = endptr;
|
|
|
|
len = bfd_getl16 (data) + sizeof (uint16_t);
|
|
|
|
data += len;
|
|
size -= len;
|
|
|
|
continue;
|
|
}
|
|
|
|
name_len =
|
|
strnlen (proc->name, len - offsetof (struct procsym, name));
|
|
|
|
if (name_len == len - offsetof (struct procsym, name))
|
|
{
|
|
einfo (_("%P: warning: name for S_GPROC32/S_LPROC32 has no"
|
|
" terminating zero\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
if (type == S_GPROC32_ID || type == S_LPROC32_ID)
|
|
{
|
|
/* Transform into S_GPROC32 / S_LPROC32. */
|
|
|
|
uint32_t t_idx = bfd_getl32 (&proc->type);
|
|
struct type_entry *t;
|
|
uint16_t t_type;
|
|
|
|
if (t_idx < TPI_FIRST_INDEX
|
|
|| t_idx >= TPI_FIRST_INDEX + num_types)
|
|
{
|
|
einfo (_("%P: CodeView symbol references out of range"
|
|
" type %v\n"), type);
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
t = map[t_idx - TPI_FIRST_INDEX];
|
|
|
|
t_type = bfd_getl16 (t->data + sizeof (uint16_t));
|
|
|
|
switch (t_type)
|
|
{
|
|
case LF_FUNC_ID:
|
|
{
|
|
struct lf_func_id *t_data =
|
|
(struct lf_func_id *) t->data;
|
|
|
|
/* Replace proc->type with function type. */
|
|
|
|
memcpy (&proc->type, &t_data->function_type,
|
|
sizeof (uint32_t));
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_MFUNC_ID:
|
|
{
|
|
struct lf_mfunc_id *t_data =
|
|
(struct lf_mfunc_id *) t->data;
|
|
|
|
/* Replace proc->type with function type. */
|
|
|
|
memcpy (&proc->type, &t_data->function_type,
|
|
sizeof (uint32_t));
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
einfo (_("%P: CodeView S_GPROC32_ID/S_LPROC32_ID symbol"
|
|
" referenced unknown type as ID\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
/* Change record type. */
|
|
|
|
if (type == S_GPROC32_ID)
|
|
bfd_putl32 (S_GPROC32, &proc->kind);
|
|
else
|
|
bfd_putl32 (S_LPROC32, &proc->kind);
|
|
}
|
|
else
|
|
{
|
|
if (!remap_symbol_type (&proc->type, map, num_types))
|
|
{
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
end = *buf - orig_buf + sizeof (uint32_t) + endptr - data;
|
|
bfd_putl32 (end, &proc->end);
|
|
|
|
/* Add S_PROCREF / S_LPROCREF to globals stream. */
|
|
|
|
ref_size = offsetof (struct refsym, name) + name_len + 1;
|
|
|
|
if (ref_size % sizeof (uint32_t))
|
|
padding = sizeof (uint32_t) - (ref_size % sizeof (uint32_t));
|
|
else
|
|
padding = 0;
|
|
|
|
ref = xmalloc (ref_size + padding);
|
|
|
|
bfd_putl16 (ref_size + padding - sizeof (uint16_t), &ref->size);
|
|
bfd_putl16 (type == S_GPROC32 || type == S_GPROC32_ID ?
|
|
S_PROCREF : S_LPROCREF, &ref->kind);
|
|
bfd_putl32 (0, &ref->sum_name);
|
|
bfd_putl32 (*buf - orig_buf + sizeof (uint32_t),
|
|
&ref->symbol_offset);
|
|
bfd_putl16 (mod_num + 1, &ref->mod);
|
|
|
|
memcpy (ref->name, proc->name, name_len + 1);
|
|
|
|
memset (ref->name + name_len + 1, 0, padding);
|
|
|
|
if (!add_globals_ref (glob, sym_rec_stream, proc->name, name_len,
|
|
(uint8_t *) ref, ref_size + padding))
|
|
{
|
|
free (ref);
|
|
return false;
|
|
}
|
|
|
|
free (ref);
|
|
|
|
scope = *buf;
|
|
|
|
memcpy (*buf, proc, len);
|
|
*buf += len;
|
|
|
|
scope_level++;
|
|
|
|
break;
|
|
}
|
|
|
|
case S_UDT:
|
|
{
|
|
struct udtsym *udt = (struct udtsym *) data;
|
|
size_t name_len;
|
|
|
|
if (len < offsetof (struct udtsym, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView record"
|
|
" S_UDT\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
name_len =
|
|
strnlen (udt->name, len - offsetof (struct udtsym, name));
|
|
|
|
if (name_len == len - offsetof (struct udtsym, name))
|
|
{
|
|
einfo (_("%P: warning: name for S_UDT has no"
|
|
" terminating zero\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
if (!remap_symbol_type (&udt->type, map, num_types))
|
|
{
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
/* S_UDT goes in the symbols stream if within a procedure,
|
|
otherwise it goes in the globals stream. */
|
|
if (scope_level == 0)
|
|
{
|
|
if (!add_globals_ref (glob, sym_rec_stream, udt->name,
|
|
name_len, data, len))
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
memcpy (*buf, udt, len);
|
|
*buf += len;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case S_CONSTANT:
|
|
{
|
|
struct constsym *c = (struct constsym *) data;
|
|
size_t name_len, rec_size;
|
|
uint16_t val;
|
|
|
|
if (len < offsetof (struct constsym, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView record"
|
|
" S_CONSTANT\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
rec_size = offsetof (struct constsym, name);
|
|
|
|
val = bfd_getl16 (&c->value);
|
|
|
|
/* If val >= 0x8000, actual value follows. */
|
|
if (val >= 0x8000)
|
|
{
|
|
unsigned int param_len = extended_value_len (val);
|
|
|
|
if (param_len == 0)
|
|
{
|
|
einfo (_("%P: warning: unhandled type %v within"
|
|
" S_CONSTANT\n"), val);
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
rec_size += param_len;
|
|
}
|
|
|
|
name_len =
|
|
strnlen ((const char *) data + rec_size, len - rec_size);
|
|
|
|
if (name_len == len - rec_size)
|
|
{
|
|
einfo (_("%P: warning: name for S_CONSTANT has no"
|
|
" terminating zero\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
if (!remap_symbol_type (&c->type, map, num_types))
|
|
{
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
if (!add_globals_ref (glob, sym_rec_stream,
|
|
(const char *) data + rec_size, name_len,
|
|
data, len))
|
|
return false;
|
|
|
|
break;
|
|
}
|
|
|
|
case S_END:
|
|
case S_INLINESITE_END:
|
|
case S_PROC_ID_END:
|
|
memcpy (*buf, data, len);
|
|
|
|
if (type == S_PROC_ID_END) /* transform to S_END */
|
|
bfd_putl16 (S_END, *buf + sizeof (uint16_t));
|
|
|
|
/* Reset scope variable back to the address of the previous
|
|
scope start. */
|
|
if (scope)
|
|
{
|
|
uint32_t parent;
|
|
uint16_t scope_start_type =
|
|
bfd_getl16 (scope + sizeof (uint16_t));
|
|
|
|
switch (scope_start_type)
|
|
{
|
|
case S_GPROC32:
|
|
case S_LPROC32:
|
|
parent = bfd_getl32 (scope + offsetof (struct procsym,
|
|
parent));
|
|
break;
|
|
|
|
case S_BLOCK32:
|
|
parent = bfd_getl32 (scope + offsetof (struct blocksym,
|
|
parent));
|
|
break;
|
|
|
|
case S_INLINESITE:
|
|
parent = bfd_getl32 (scope + offsetof (struct inline_site,
|
|
parent));
|
|
break;
|
|
|
|
case S_THUNK32:
|
|
parent = bfd_getl32 (scope + offsetof (struct thunk,
|
|
parent));
|
|
break;
|
|
|
|
default:
|
|
einfo (_("%P: warning: unexpected CodeView scope start"
|
|
" record %v\n"), scope_start_type);
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
if (parent == 0)
|
|
scope = NULL;
|
|
else
|
|
scope = orig_buf + parent - sizeof (uint32_t);
|
|
}
|
|
|
|
*buf += len;
|
|
scope_level--;
|
|
break;
|
|
|
|
case S_BUILDINFO:
|
|
{
|
|
struct buildinfosym *bi = (struct buildinfosym *) data;
|
|
|
|
if (len < sizeof (struct buildinfosym))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView record"
|
|
" S_BUILDINFO\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
if (!remap_symbol_type (&bi->type, map, num_types))
|
|
{
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
memcpy (*buf, data, len);
|
|
*buf += len;
|
|
|
|
break;
|
|
}
|
|
|
|
case S_BLOCK32:
|
|
{
|
|
struct blocksym *bl = (struct blocksym *) data;
|
|
uint8_t *endptr;
|
|
uint32_t end;
|
|
|
|
if (len < offsetof (struct blocksym, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView record"
|
|
" S_BLOCK32\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
bfd_putl32 (scope - orig_buf + sizeof (uint32_t), &bl->parent);
|
|
|
|
endptr = find_end_of_scope (data, size);
|
|
|
|
if (!endptr)
|
|
{
|
|
einfo (_("%P: warning: could not find end of"
|
|
" S_BLOCK32 record\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
end = *buf - orig_buf + sizeof (uint32_t) + endptr - data;
|
|
bfd_putl32 (end, &bl->end);
|
|
|
|
scope = *buf;
|
|
|
|
memcpy (*buf, data, len);
|
|
*buf += len;
|
|
|
|
scope_level++;
|
|
|
|
break;
|
|
}
|
|
|
|
case S_BPREL32:
|
|
{
|
|
struct bprelsym *bp = (struct bprelsym *) data;
|
|
|
|
if (len < offsetof (struct bprelsym, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView record"
|
|
" S_BPREL32\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
if (!remap_symbol_type (&bp->type, map, num_types))
|
|
{
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
memcpy (*buf, data, len);
|
|
*buf += len;
|
|
|
|
break;
|
|
}
|
|
|
|
case S_REGISTER:
|
|
{
|
|
struct regsym *reg = (struct regsym *) data;
|
|
|
|
if (len < offsetof (struct regsym, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView record"
|
|
" S_REGISTER\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
if (!remap_symbol_type (®->type, map, num_types))
|
|
{
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
memcpy (*buf, data, len);
|
|
*buf += len;
|
|
|
|
break;
|
|
}
|
|
|
|
case S_REGREL32:
|
|
{
|
|
struct regrel *rr = (struct regrel *) data;
|
|
|
|
if (len < offsetof (struct regrel, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView record"
|
|
" S_REGREL32\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
if (!remap_symbol_type (&rr->type, map, num_types))
|
|
{
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
memcpy (*buf, data, len);
|
|
*buf += len;
|
|
|
|
break;
|
|
}
|
|
|
|
case S_LOCAL:
|
|
{
|
|
struct localsym *l = (struct localsym *) data;
|
|
|
|
if (len < offsetof (struct localsym, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView record"
|
|
" S_LOCAL\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
if (!remap_symbol_type (&l->type, map, num_types))
|
|
{
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
memcpy (*buf, data, len);
|
|
*buf += len;
|
|
|
|
break;
|
|
}
|
|
|
|
case S_INLINESITE:
|
|
{
|
|
struct inline_site *is = (struct inline_site *) data;
|
|
uint8_t *endptr;
|
|
uint32_t end;
|
|
|
|
if (len < offsetof (struct inline_site, binary_annotations))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView record"
|
|
" S_INLINESITE\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
bfd_putl32 (scope - orig_buf + sizeof (uint32_t), &is->parent);
|
|
|
|
endptr = find_end_of_scope (data, size);
|
|
|
|
if (!endptr)
|
|
{
|
|
einfo (_("%P: warning: could not find end of"
|
|
" S_INLINESITE record\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
end = *buf - orig_buf + sizeof (uint32_t) + endptr - data;
|
|
bfd_putl32 (end, &is->end);
|
|
|
|
if (!remap_symbol_type (&is->inlinee, map, num_types))
|
|
{
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
scope = *buf;
|
|
|
|
memcpy (*buf, data, len);
|
|
*buf += len;
|
|
|
|
scope_level++;
|
|
|
|
break;
|
|
}
|
|
|
|
case S_THUNK32:
|
|
{
|
|
struct thunk *th = (struct thunk *) data;
|
|
uint8_t *endptr;
|
|
uint32_t end;
|
|
|
|
if (len < offsetof (struct thunk, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView record"
|
|
" S_THUNK32\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
bfd_putl32 (scope - orig_buf + sizeof (uint32_t), &th->parent);
|
|
|
|
endptr = find_end_of_scope (data, size);
|
|
|
|
if (!endptr)
|
|
{
|
|
einfo (_("%P: warning: could not find end of"
|
|
" S_THUNK32 record\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
end = *buf - orig_buf + sizeof (uint32_t) + endptr - data;
|
|
bfd_putl32 (end, &th->end);
|
|
|
|
scope = *buf;
|
|
|
|
memcpy (*buf, data, len);
|
|
*buf += len;
|
|
|
|
scope_level++;
|
|
|
|
break;
|
|
}
|
|
|
|
case S_HEAPALLOCSITE:
|
|
{
|
|
struct heap_alloc_site *has = (struct heap_alloc_site *) data;
|
|
|
|
if (len < sizeof (struct heap_alloc_site))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView record"
|
|
" S_HEAPALLOCSITE\n"));
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
if (!remap_symbol_type (&has->type, map, num_types))
|
|
{
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
memcpy (*buf, data, len);
|
|
*buf += len;
|
|
|
|
break;
|
|
}
|
|
|
|
case S_OBJNAME: /* just copy */
|
|
case S_COMPILE3:
|
|
case S_UNAMESPACE:
|
|
case S_FRAMEPROC:
|
|
case S_FRAMECOOKIE:
|
|
case S_LABEL32:
|
|
case S_DEFRANGE_REGISTER_REL:
|
|
case S_DEFRANGE_FRAMEPOINTER_REL:
|
|
case S_DEFRANGE_SUBFIELD_REGISTER:
|
|
case S_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE:
|
|
case S_DEFRANGE_REGISTER:
|
|
memcpy (*buf, data, len);
|
|
*buf += len;
|
|
break;
|
|
|
|
default:
|
|
einfo (_("%P: warning: unrecognized CodeView record %v\n"), type);
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
data += len;
|
|
size -= len;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/* For a given symbol subsection, work out how much space to allocate in the
|
|
result module stream. This is different because we don't copy certain
|
|
symbols, such as S_CONSTANT, and we skip over any procedures or data that
|
|
have been GC'd out. */
|
|
static bool
|
|
calculate_symbols_size (uint8_t *data, uint32_t size, uint32_t *sym_size)
|
|
{
|
|
unsigned int scope_level = 0;
|
|
|
|
while (size >= sizeof (uint32_t))
|
|
{
|
|
uint16_t len = bfd_getl16 (data) + sizeof (uint16_t);
|
|
uint16_t type = bfd_getl16 (data + sizeof (uint16_t));
|
|
|
|
switch (type)
|
|
{
|
|
case S_LDATA32:
|
|
case S_LTHREAD32:
|
|
{
|
|
struct datasym *d = (struct datasym *) data;
|
|
uint16_t section;
|
|
|
|
if (len < offsetof (struct datasym, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView record"
|
|
" S_LDATA32/S_LTHREAD32\n"));
|
|
return false;
|
|
}
|
|
|
|
section = bfd_getl16 (&d->section);
|
|
|
|
/* copy if not GC'd or within function */
|
|
if (scope_level != 0 || section != 0)
|
|
*sym_size += len;
|
|
}
|
|
|
|
case S_GDATA32:
|
|
case S_GTHREAD32:
|
|
case S_CONSTANT:
|
|
/* Not copied into symbols stream. */
|
|
break;
|
|
|
|
case S_GPROC32:
|
|
case S_LPROC32:
|
|
case S_GPROC32_ID:
|
|
case S_LPROC32_ID:
|
|
{
|
|
struct procsym *proc = (struct procsym *) data;
|
|
uint16_t section;
|
|
|
|
if (len < offsetof (struct procsym, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView record"
|
|
" S_GPROC32/S_LPROC32\n"));
|
|
return false;
|
|
}
|
|
|
|
section = bfd_getl16 (&proc->section);
|
|
|
|
if (section != 0)
|
|
{
|
|
*sym_size += len;
|
|
}
|
|
else
|
|
{
|
|
uint8_t *endptr = find_end_of_scope (data, size);
|
|
|
|
if (!endptr)
|
|
{
|
|
einfo (_("%P: warning: could not find end of"
|
|
" S_GPROC32/S_LPROC32 record\n"));
|
|
return false;
|
|
}
|
|
|
|
/* Skip to after S_END. */
|
|
|
|
size -= endptr - data;
|
|
data = endptr;
|
|
|
|
len = bfd_getl16 (data) + sizeof (uint16_t);
|
|
|
|
data += len;
|
|
size -= len;
|
|
|
|
continue;
|
|
}
|
|
|
|
scope_level++;
|
|
|
|
break;
|
|
}
|
|
|
|
case S_UDT:
|
|
if (scope_level != 0) /* only goes in symbols if local */
|
|
*sym_size += len;
|
|
break;
|
|
|
|
case S_BLOCK32: /* always copied */
|
|
case S_INLINESITE:
|
|
case S_THUNK32:
|
|
*sym_size += len;
|
|
scope_level++;
|
|
break;
|
|
|
|
case S_END: /* always copied */
|
|
case S_PROC_ID_END:
|
|
case S_INLINESITE_END:
|
|
*sym_size += len;
|
|
scope_level--;
|
|
break;
|
|
|
|
case S_OBJNAME: /* always copied */
|
|
case S_COMPILE3:
|
|
case S_UNAMESPACE:
|
|
case S_FRAMEPROC:
|
|
case S_FRAMECOOKIE:
|
|
case S_LABEL32:
|
|
case S_BUILDINFO:
|
|
case S_BPREL32:
|
|
case S_REGISTER:
|
|
case S_REGREL32:
|
|
case S_LOCAL:
|
|
case S_DEFRANGE_REGISTER_REL:
|
|
case S_DEFRANGE_FRAMEPOINTER_REL:
|
|
case S_DEFRANGE_SUBFIELD_REGISTER:
|
|
case S_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE:
|
|
case S_DEFRANGE_REGISTER:
|
|
case S_HEAPALLOCSITE:
|
|
*sym_size += len;
|
|
break;
|
|
|
|
default:
|
|
einfo (_("%P: warning: unrecognized CodeView record %v\n"), type);
|
|
return false;
|
|
}
|
|
|
|
data += len;
|
|
size -= len;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/* Parse the DEBUG_S_INLINEELINES data, which records the line numbers that
|
|
correspond to inlined functions. This is similar to DEBUG_S_LINES (see
|
|
handle_debugs_section), but rather than just copying we also need to remap
|
|
the numbers of the referenced LF_FUNC_ID types. */
|
|
|
|
static bool
|
|
parse_inlinee_lines (uint8_t *data, uint32_t size, uint8_t **bufptr,
|
|
struct type_entry **map, uint32_t num_types)
|
|
{
|
|
uint32_t version;
|
|
uint8_t *ptr;
|
|
unsigned int num_entries;
|
|
|
|
bfd_putl32 (DEBUG_S_INLINEELINES, *bufptr);
|
|
*bufptr += sizeof (uint32_t);
|
|
|
|
bfd_putl32 (size, *bufptr);
|
|
*bufptr += sizeof (uint32_t);
|
|
|
|
/* The inlinee lines data consists of a version uint32_t (0), followed by an
|
|
array of struct inlinee_source_line:
|
|
|
|
struct inlinee_source_line
|
|
{
|
|
uint32_t function_id;
|
|
uint32_t file_id;
|
|
uint32_t line_no;
|
|
};
|
|
|
|
(see InlineeSourceLine in cvinfo.h)
|
|
|
|
We're only interested here in the function_id, as we need to remap its
|
|
type number.
|
|
*/
|
|
|
|
if (size < sizeof (uint32_t))
|
|
{
|
|
einfo (_("%P: warning: truncated DEBUG_S_INLINEELINES data\n"));
|
|
return false;
|
|
}
|
|
|
|
version = bfd_getl32 (data + sizeof (uint32_t) + sizeof (uint32_t));
|
|
if (version != CV_INLINEE_SOURCE_LINE_SIGNATURE)
|
|
{
|
|
einfo (_("%P: warning: unexpected DEBUG_S_INLINEELINES version %u\n"),
|
|
version);
|
|
return false;
|
|
}
|
|
|
|
memcpy (*bufptr, data, size);
|
|
ptr = *bufptr + sizeof (uint32_t);
|
|
*bufptr += size;
|
|
|
|
num_entries = (size - sizeof (uint32_t)) / (3 * sizeof (uint32_t));
|
|
|
|
for (unsigned int i = 0; i < num_entries; i++)
|
|
{
|
|
uint32_t func_id;
|
|
|
|
func_id = bfd_getl32 (ptr);
|
|
|
|
if (!remap_type (ptr, map, func_id, num_types))
|
|
return false;
|
|
|
|
ptr += 3 * sizeof (uint32_t);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/* Parse the .debug$S section within an object file. */
|
|
static bool
|
|
handle_debugs_section (asection *s, bfd *mod, struct string_table *strings,
|
|
uint8_t **dataptr, uint32_t *sizeptr,
|
|
struct mod_source_files *mod_source,
|
|
bfd *abfd, uint8_t **syms, uint32_t *sym_byte_size,
|
|
struct type_entry **map, uint32_t num_types,
|
|
bfd *sym_rec_stream, struct globals *glob,
|
|
uint16_t mod_num)
|
|
{
|
|
bfd_byte *data = NULL;
|
|
size_t off;
|
|
uint32_t c13_size = 0;
|
|
char *string_table = NULL;
|
|
uint8_t *buf, *bufptr, *symbuf, *symbufptr;
|
|
uint32_t sym_size = 0;
|
|
|
|
if (!bfd_get_full_section_contents (mod, s, &data))
|
|
return false;
|
|
|
|
if (!data)
|
|
return false;
|
|
|
|
/* Resolve relocations. Addresses are stored within the .debug$S section as
|
|
a .secidx, .secrel32 pair. */
|
|
|
|
if (s->flags & SEC_RELOC)
|
|
{
|
|
struct internal_reloc *relocs;
|
|
struct internal_syment *symbols;
|
|
asection **sectlist;
|
|
unsigned int syment_count;
|
|
int sect_num;
|
|
struct external_syment *ext;
|
|
|
|
syment_count = obj_raw_syment_count (mod);
|
|
|
|
relocs =
|
|
_bfd_coff_read_internal_relocs (mod, s, false, NULL, true, NULL);
|
|
|
|
symbols = xmalloc (sizeof (struct internal_syment) * syment_count);
|
|
sectlist = xmalloc (sizeof (asection *) * syment_count);
|
|
|
|
ext = (struct external_syment *) (coff_data (mod)->external_syms);
|
|
|
|
for (unsigned int i = 0; i < syment_count; i++)
|
|
{
|
|
bfd_coff_swap_sym_in (mod, &ext[i], &symbols[i]);
|
|
}
|
|
|
|
sect_num = 1;
|
|
|
|
for (asection *sect = mod->sections; sect; sect = sect->next)
|
|
{
|
|
for (unsigned int i = 0; i < syment_count; i++)
|
|
{
|
|
if (symbols[i].n_scnum == sect_num)
|
|
sectlist[i] = sect;
|
|
}
|
|
|
|
sect_num++;
|
|
}
|
|
|
|
if (!bfd_coff_relocate_section (abfd, coff_data (abfd)->link_info, mod,
|
|
s, data, relocs, symbols, sectlist))
|
|
{
|
|
free (sectlist);
|
|
free (symbols);
|
|
free (data);
|
|
return false;
|
|
}
|
|
|
|
free (sectlist);
|
|
free (symbols);
|
|
}
|
|
|
|
if (bfd_getl32 (data) != CV_SIGNATURE_C13)
|
|
{
|
|
free (data);
|
|
return true;
|
|
}
|
|
|
|
off = sizeof (uint32_t);
|
|
|
|
/* calculate size */
|
|
|
|
while (off + sizeof (uint32_t) <= s->size)
|
|
{
|
|
uint32_t type, size;
|
|
|
|
type = bfd_getl32 (data + off);
|
|
|
|
off += sizeof (uint32_t);
|
|
|
|
if (off + sizeof (uint32_t) > s->size)
|
|
{
|
|
free (data);
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
size = bfd_getl32 (data + off);
|
|
|
|
off += sizeof (uint32_t);
|
|
|
|
if (off + size > s->size)
|
|
{
|
|
free (data);
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
switch (type)
|
|
{
|
|
case DEBUG_S_FILECHKSMS:
|
|
case DEBUG_S_INLINEELINES:
|
|
c13_size += sizeof (uint32_t) + sizeof (uint32_t) + size;
|
|
|
|
if (c13_size % sizeof (uint32_t))
|
|
c13_size += sizeof (uint32_t) - (c13_size % sizeof (uint32_t));
|
|
|
|
break;
|
|
|
|
case DEBUG_S_STRINGTABLE:
|
|
parse_string_table (data + off, size, strings);
|
|
|
|
string_table = (char *) data + off;
|
|
|
|
break;
|
|
|
|
case DEBUG_S_LINES:
|
|
{
|
|
uint16_t sect;
|
|
|
|
if (size < sizeof (uint32_t) + sizeof (uint16_t))
|
|
{
|
|
free (data);
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
sect = bfd_getl16 (data + off + sizeof (uint32_t));
|
|
|
|
/* Skip GC'd symbols. */
|
|
if (sect != 0)
|
|
{
|
|
c13_size += sizeof (uint32_t) + sizeof (uint32_t) + size;
|
|
|
|
if (c13_size % sizeof (uint32_t))
|
|
c13_size +=
|
|
sizeof (uint32_t) - (c13_size % sizeof (uint32_t));
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case DEBUG_S_SYMBOLS:
|
|
if (!calculate_symbols_size (data + off, size, &sym_size))
|
|
{
|
|
free (data);
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
off += size;
|
|
|
|
if (off % sizeof (uint32_t))
|
|
off += sizeof (uint32_t) - (off % sizeof (uint32_t));
|
|
}
|
|
|
|
if (sym_size % sizeof (uint32_t))
|
|
sym_size += sizeof (uint32_t) - (sym_size % sizeof (uint32_t));
|
|
|
|
if (c13_size == 0 && sym_size == 0)
|
|
{
|
|
free (data);
|
|
return true;
|
|
}
|
|
|
|
/* copy data */
|
|
|
|
buf = NULL;
|
|
if (c13_size != 0)
|
|
buf = xmalloc (c13_size);
|
|
bufptr = buf;
|
|
|
|
symbuf = NULL;
|
|
if (sym_size != 0)
|
|
symbuf = xmalloc (sym_size);
|
|
symbufptr = symbuf;
|
|
|
|
off = sizeof (uint32_t);
|
|
|
|
while (off + sizeof (uint32_t) <= s->size)
|
|
{
|
|
uint32_t type, size;
|
|
|
|
type = bfd_getl32 (data + off);
|
|
off += sizeof (uint32_t);
|
|
|
|
size = bfd_getl32 (data + off);
|
|
off += sizeof (uint32_t);
|
|
|
|
switch (type)
|
|
{
|
|
case DEBUG_S_FILECHKSMS:
|
|
if (!copy_filechksms (data + off, size, string_table,
|
|
strings, bufptr, mod_source))
|
|
{
|
|
free (data);
|
|
free (symbuf);
|
|
return false;
|
|
}
|
|
|
|
bufptr += sizeof (uint32_t) + sizeof (uint32_t) + size;
|
|
|
|
break;
|
|
|
|
case DEBUG_S_LINES:
|
|
{
|
|
uint16_t sect;
|
|
|
|
sect = bfd_getl16 (data + off + sizeof (uint32_t));
|
|
|
|
/* Skip if GC'd. */
|
|
if (sect != 0)
|
|
{
|
|
bfd_putl32 (type, bufptr);
|
|
bufptr += sizeof (uint32_t);
|
|
|
|
bfd_putl32 (size, bufptr);
|
|
bufptr += sizeof (uint32_t);
|
|
|
|
memcpy (bufptr, data + off, size);
|
|
bufptr += size;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case DEBUG_S_SYMBOLS:
|
|
if (!parse_symbols (data + off, size, &symbufptr, map, num_types,
|
|
sym_rec_stream, glob, mod_num))
|
|
{
|
|
free (data);
|
|
free (symbuf);
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
|
|
case DEBUG_S_INLINEELINES:
|
|
if (!parse_inlinee_lines (data + off, size, &bufptr, map, num_types))
|
|
{
|
|
free (data);
|
|
free (symbuf);
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
off += size;
|
|
|
|
if (off % sizeof (uint32_t))
|
|
off += sizeof (uint32_t) - (off % sizeof (uint32_t));
|
|
}
|
|
|
|
free (data);
|
|
|
|
if (buf)
|
|
{
|
|
if (*dataptr)
|
|
{
|
|
/* Append the C13 info to what's already there, if the module has
|
|
multiple .debug$S sections. */
|
|
|
|
*dataptr = xrealloc (*dataptr, *sizeptr + c13_size);
|
|
memcpy (*dataptr + *sizeptr, buf, c13_size);
|
|
|
|
free (buf);
|
|
}
|
|
else
|
|
{
|
|
*dataptr = buf;
|
|
}
|
|
|
|
*sizeptr += c13_size;
|
|
}
|
|
|
|
if (symbuf)
|
|
{
|
|
if (*syms)
|
|
{
|
|
*syms = xrealloc (*syms, *sym_byte_size + sym_size);
|
|
memcpy (*syms + *sym_byte_size, symbuf, sym_size);
|
|
|
|
free (symbuf);
|
|
}
|
|
else
|
|
{
|
|
*syms = symbuf;
|
|
}
|
|
|
|
*sym_byte_size += sym_size;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/* Remap the type number stored in data from the per-module numbering to
|
|
that of the deduplicated output list. */
|
|
static bool
|
|
remap_type (void *data, struct type_entry **map,
|
|
uint32_t type_num, uint32_t num_types)
|
|
{
|
|
uint32_t type = bfd_getl32 (data);
|
|
|
|
/* Ignore builtin types (those with IDs below 0x1000). */
|
|
if (type < TPI_FIRST_INDEX)
|
|
return true;
|
|
|
|
if (type >= TPI_FIRST_INDEX + type_num)
|
|
{
|
|
einfo (_("%P: CodeView type %v references other type %v not yet "
|
|
"declared\n"), TPI_FIRST_INDEX + type_num, type);
|
|
return false;
|
|
}
|
|
|
|
if (type >= TPI_FIRST_INDEX + num_types)
|
|
{
|
|
einfo (_("%P: CodeView type %v references out of range type %v\n"),
|
|
TPI_FIRST_INDEX + type_num, type);
|
|
return false;
|
|
}
|
|
|
|
type = TPI_FIRST_INDEX + map[type - TPI_FIRST_INDEX]->index;
|
|
bfd_putl32 (type, data);
|
|
|
|
return true;
|
|
}
|
|
|
|
/* Determines whether the name of a struct, class, or union counts as
|
|
"anonymous". Non-anonymous types have a hash based on just the name,
|
|
rather than the whole structure. */
|
|
static bool
|
|
is_name_anonymous (char *name, size_t len)
|
|
{
|
|
static const char tag1[] = "<unnamed-tag>";
|
|
static const char tag2[] = "__unnamed";
|
|
static const char tag3[] = "::<unnamed-tag>";
|
|
static const char tag4[] = "::__unnamed";
|
|
|
|
if (len == sizeof (tag1) - 1 && !memcmp (name, tag1, sizeof (tag1) - 1))
|
|
return true;
|
|
|
|
if (len == sizeof (tag2) - 1 && !memcmp (name, tag2, sizeof (tag2) - 1))
|
|
return true;
|
|
|
|
if (len >= sizeof (tag3) - 1
|
|
&& !memcmp (name + len - sizeof (tag3) + 1, tag3, sizeof (tag3) - 1))
|
|
return true;
|
|
|
|
if (len >= sizeof (tag4) - 1
|
|
&& !memcmp (name + len - sizeof (tag4) + 1, tag4, sizeof (tag4) - 1))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
/* Handle LF_UDT_SRC_LINE type entries, which are a special case. These
|
|
give the source file and line number for each user-defined type that is
|
|
declared. We parse these and emit instead an LF_UDT_MOD_SRC_LINE entry,
|
|
which also includes the module number. */
|
|
static bool
|
|
handle_udt_src_line (uint8_t *data, uint16_t size, struct type_entry **map,
|
|
uint32_t type_num, uint32_t num_types,
|
|
struct types *ids, uint16_t mod_num,
|
|
struct string_table *strings)
|
|
{
|
|
struct lf_udt_src_line *usl = (struct lf_udt_src_line *) data;
|
|
uint32_t orig_type, source_file_type;
|
|
void **slot;
|
|
hashval_t hash;
|
|
struct type_entry *e, *type_e, *str_e;
|
|
struct lf_udt_mod_src_line *umsl;
|
|
struct lf_string_id *str;
|
|
uint32_t source_file_offset;
|
|
|
|
if (size < sizeof (struct lf_udt_src_line))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_UDT_SRC_LINE\n"));
|
|
return false;
|
|
}
|
|
|
|
/* Check if LF_UDT_MOD_SRC_LINE already present for type, and return. */
|
|
|
|
orig_type = bfd_getl32 (&usl->type);
|
|
|
|
if (orig_type < TPI_FIRST_INDEX ||
|
|
orig_type >= TPI_FIRST_INDEX + num_types ||
|
|
!map[orig_type - TPI_FIRST_INDEX])
|
|
{
|
|
einfo (_("%P: warning: CodeView type record LF_UDT_SRC_LINE"
|
|
" referred to unknown type %v\n"), orig_type);
|
|
return false;
|
|
}
|
|
|
|
type_e = map[orig_type - TPI_FIRST_INDEX];
|
|
|
|
/* Skip if type already declared in other module. */
|
|
if (type_e->has_udt_src_line)
|
|
return true;
|
|
|
|
if (!remap_type (&usl->type, map, type_num, num_types))
|
|
return false;
|
|
|
|
/* Extract string from source_file_type. */
|
|
|
|
source_file_type = bfd_getl32 (&usl->source_file_type);
|
|
|
|
if (source_file_type < TPI_FIRST_INDEX ||
|
|
source_file_type >= TPI_FIRST_INDEX + num_types ||
|
|
!map[source_file_type - TPI_FIRST_INDEX])
|
|
{
|
|
einfo (_("%P: warning: CodeView type record LF_UDT_SRC_LINE"
|
|
" referred to unknown string %v\n"), source_file_type);
|
|
return false;
|
|
}
|
|
|
|
str_e = map[source_file_type - TPI_FIRST_INDEX];
|
|
|
|
if (bfd_getl16 (str_e->data + sizeof (uint16_t)) != LF_STRING_ID)
|
|
{
|
|
einfo (_("%P: warning: CodeView type record LF_UDT_SRC_LINE"
|
|
" pointed to unexpected record type\n"));
|
|
return false;
|
|
}
|
|
|
|
str = (struct lf_string_id *) str_e->data;
|
|
|
|
/* Add string to string table. */
|
|
|
|
source_file_offset = add_string (str->string, strlen (str->string),
|
|
strings);
|
|
|
|
/* Add LF_UDT_MOD_SRC_LINE entry. */
|
|
|
|
size = sizeof (struct lf_udt_mod_src_line);
|
|
|
|
e = xmalloc (offsetof (struct type_entry, data) + size);
|
|
|
|
e->next = NULL;
|
|
e->index = ids->num_types;
|
|
e->has_udt_src_line = false;
|
|
|
|
/* LF_UDT_MOD_SRC_LINE use calc_hash on the type number, rather than
|
|
the crc32 used for type hashes elsewhere. */
|
|
e->cv_hash = calc_hash ((char *) &usl->type, sizeof (uint32_t));
|
|
|
|
type_e->has_udt_src_line = true;
|
|
|
|
umsl = (struct lf_udt_mod_src_line *) e->data;
|
|
|
|
bfd_putl16 (size - sizeof (uint16_t), &umsl->size);
|
|
bfd_putl16 (LF_UDT_MOD_SRC_LINE, &umsl->kind);
|
|
memcpy (&umsl->type, &usl->type, sizeof (uint32_t));
|
|
bfd_putl32 (source_file_offset, &umsl->source_file_string);
|
|
memcpy (&umsl->line_no, &usl->line_no, sizeof (uint32_t));
|
|
bfd_putl16 (mod_num + 1, &umsl->module_no);
|
|
|
|
hash = iterative_hash (e->data, size, 0);
|
|
|
|
slot = htab_find_slot_with_hash (ids->hashmap, data, hash, INSERT);
|
|
if (!slot)
|
|
{
|
|
free (e);
|
|
return false;
|
|
}
|
|
|
|
if (*slot)
|
|
{
|
|
free (e);
|
|
einfo (_("%P: warning: duplicate CodeView type record "
|
|
"LF_UDT_MOD_SRC_LINE\n"));
|
|
return false;
|
|
}
|
|
|
|
*slot = e;
|
|
|
|
if (ids->last)
|
|
ids->last->next = e;
|
|
else
|
|
ids->first = e;
|
|
|
|
ids->last = e;
|
|
|
|
map[type_num] = e;
|
|
|
|
ids->num_types++;
|
|
|
|
return true;
|
|
}
|
|
|
|
/* Parse a type definition in the .debug$T section. We remap the numbers
|
|
of any referenced types, and if the type is not a duplicate of one
|
|
already seen add it to types (for TPI types) or ids (for IPI types). */
|
|
static bool
|
|
handle_type (uint8_t *data, struct type_entry **map, uint32_t type_num,
|
|
uint32_t num_types, struct types *types,
|
|
struct types *ids, uint16_t mod_num,
|
|
struct string_table *strings)
|
|
{
|
|
uint16_t size, type;
|
|
void **slot;
|
|
hashval_t hash;
|
|
bool other_hash = false;
|
|
uint32_t cv_hash;
|
|
struct types *t;
|
|
bool ipi = false;
|
|
|
|
size = bfd_getl16 (data) + sizeof (uint16_t);
|
|
type = bfd_getl16 (data + sizeof (uint16_t));
|
|
|
|
switch (type)
|
|
{
|
|
case LF_MODIFIER:
|
|
{
|
|
struct lf_modifier *mod = (struct lf_modifier *) data;
|
|
|
|
if (size < offsetof (struct lf_modifier, modifier))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record "
|
|
"LF_MODIFIER\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&mod->base_type, map, type_num, num_types))
|
|
return false;
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_POINTER:
|
|
{
|
|
struct lf_pointer *ptr = (struct lf_pointer *) data;
|
|
uint32_t attributes;
|
|
|
|
if (size < offsetof (struct lf_pointer, attributes))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_POINTER\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&ptr->base_type, map, type_num, num_types))
|
|
return false;
|
|
|
|
attributes = bfd_getl32 (&ptr->attributes);
|
|
|
|
if ((attributes & CV_PTR_MODE_MASK) == CV_PTR_MODE_PMEM
|
|
|| (attributes & CV_PTR_MODE_MASK) == CV_PTR_MODE_PMFUNC)
|
|
{
|
|
if (size < offsetof (struct lf_pointer, ptr_to_mem_type))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_POINTER\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&ptr->containing_class, map, type_num, num_types))
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_PROCEDURE:
|
|
{
|
|
struct lf_procedure *proc = (struct lf_procedure *) data;
|
|
|
|
if (size < sizeof (struct lf_procedure))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_PROCEDURE\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&proc->return_type, map, type_num, num_types))
|
|
return false;
|
|
|
|
if (!remap_type (&proc->arglist, map, type_num, num_types))
|
|
return false;
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_MFUNCTION:
|
|
{
|
|
struct lf_mfunction *func = (struct lf_mfunction *) data;
|
|
|
|
if (size < sizeof (struct lf_procedure))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_MFUNCTION\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&func->return_type, map, type_num, num_types))
|
|
return false;
|
|
|
|
if (!remap_type (&func->containing_class_type, map, type_num,
|
|
num_types))
|
|
return false;
|
|
|
|
if (!remap_type (&func->this_type, map, type_num, num_types))
|
|
return false;
|
|
|
|
if (!remap_type (&func->arglist, map, type_num, num_types))
|
|
return false;
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_ARGLIST:
|
|
{
|
|
uint32_t num_entries;
|
|
struct lf_arglist *al = (struct lf_arglist *) data;
|
|
|
|
if (size < offsetof (struct lf_arglist, args))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_ARGLIST\n"));
|
|
return false;
|
|
}
|
|
|
|
num_entries = bfd_getl32 (&al->num_entries);
|
|
|
|
if (size < offsetof (struct lf_arglist, args)
|
|
+ (num_entries * sizeof (uint32_t)))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_ARGLIST\n"));
|
|
return false;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < num_entries; i++)
|
|
{
|
|
if (!remap_type (&al->args[i], map, type_num, num_types))
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_FIELDLIST:
|
|
{
|
|
uint16_t left = size - sizeof (uint16_t) - sizeof (uint16_t);
|
|
uint8_t *ptr = data + sizeof (uint16_t) + sizeof (uint16_t);
|
|
|
|
while (left > 0)
|
|
{
|
|
uint16_t subtype;
|
|
|
|
if (left < sizeof (uint16_t))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_FIELDLIST\n"));
|
|
return false;
|
|
}
|
|
|
|
subtype = bfd_getl16 (ptr);
|
|
|
|
switch (subtype)
|
|
{
|
|
case LF_MEMBER:
|
|
{
|
|
struct lf_member *mem = (struct lf_member *) ptr;
|
|
uint16_t offset;
|
|
size_t name_len, subtype_len;
|
|
|
|
if (left < offsetof (struct lf_member, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_MEMBER\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&mem->type, map, type_num, num_types))
|
|
return false;
|
|
|
|
subtype_len = offsetof (struct lf_member, name);
|
|
|
|
offset = bfd_getl16 (&mem->offset);
|
|
|
|
/* If offset >= 0x8000, actual value follows. */
|
|
if (offset >= 0x8000)
|
|
{
|
|
unsigned int param_len = extended_value_len (offset);
|
|
|
|
if (param_len == 0)
|
|
{
|
|
einfo (_("%P: warning: unhandled type %v within"
|
|
" LF_MEMBER\n"), offset);
|
|
return false;
|
|
}
|
|
|
|
subtype_len += param_len;
|
|
|
|
if (left < subtype_len)
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_MEMBER\n"));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
name_len =
|
|
strnlen ((char *) mem + subtype_len, left - subtype_len);
|
|
|
|
if (name_len == left - offsetof (struct lf_member, name))
|
|
{
|
|
einfo (_("%P: warning: name for LF_MEMBER has no"
|
|
" terminating zero\n"));
|
|
return false;
|
|
}
|
|
|
|
name_len++;
|
|
|
|
subtype_len += name_len;
|
|
|
|
if (subtype_len % 4 != 0)
|
|
subtype_len += 4 - (subtype_len % 4);
|
|
|
|
if (left < subtype_len)
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_FIELDLIST\n"));
|
|
return false;
|
|
}
|
|
|
|
ptr += subtype_len;
|
|
left -= subtype_len;
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_ENUMERATE:
|
|
{
|
|
struct lf_enumerate *en = (struct lf_enumerate *) ptr;
|
|
size_t name_len, subtype_len;
|
|
uint16_t val;
|
|
|
|
if (left < offsetof (struct lf_enumerate, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_ENUMERATE\n"));
|
|
return false;
|
|
}
|
|
|
|
subtype_len = offsetof (struct lf_enumerate, name);
|
|
|
|
val = bfd_getl16 (&en->value);
|
|
|
|
/* If val >= 0x8000, the actual value immediately follows. */
|
|
if (val >= 0x8000)
|
|
{
|
|
unsigned int param_len = extended_value_len (val);
|
|
|
|
if (param_len == 0)
|
|
{
|
|
einfo (_("%P: warning: unhandled type %v within"
|
|
" LF_ENUMERATE\n"), val);
|
|
return false;
|
|
}
|
|
|
|
if (left < subtype_len + param_len)
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type"
|
|
" record LF_ENUMERATE\n"));
|
|
return false;
|
|
}
|
|
|
|
subtype_len += param_len;
|
|
}
|
|
|
|
name_len = strnlen ((char *) ptr + subtype_len,
|
|
left - subtype_len);
|
|
|
|
if (name_len == left - offsetof (struct lf_enumerate, name))
|
|
{
|
|
einfo (_("%P: warning: name for LF_ENUMERATE has no"
|
|
" terminating zero\n"));
|
|
return false;
|
|
}
|
|
|
|
name_len++;
|
|
|
|
subtype_len += name_len;
|
|
|
|
if (subtype_len % 4 != 0)
|
|
subtype_len += 4 - (subtype_len % 4);
|
|
|
|
if (left < subtype_len)
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_ENUMERATE\n"));
|
|
return false;
|
|
}
|
|
|
|
ptr += subtype_len;
|
|
left -= subtype_len;
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_INDEX:
|
|
{
|
|
struct lf_index *ind = (struct lf_index *) ptr;
|
|
|
|
if (left < sizeof (struct lf_index))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_INDEX\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&ind->index, map, type_num, num_types))
|
|
return false;
|
|
|
|
ptr += sizeof (struct lf_index);
|
|
left -= sizeof (struct lf_index);
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_ONEMETHOD:
|
|
{
|
|
struct lf_onemethod *meth = (struct lf_onemethod *) ptr;
|
|
size_t name_len, subtype_len;
|
|
|
|
if (left < offsetof (struct lf_onemethod, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_ONEMETHOD\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&meth->method_type, map, type_num,
|
|
num_types))
|
|
return false;
|
|
|
|
name_len =
|
|
strnlen (meth->name,
|
|
left - offsetof (struct lf_onemethod, name));
|
|
|
|
if (name_len == left - offsetof (struct lf_onemethod, name))
|
|
{
|
|
einfo (_("%P: warning: name for LF_ONEMETHOD has no"
|
|
" terminating zero\n"));
|
|
return false;
|
|
}
|
|
|
|
name_len++;
|
|
|
|
subtype_len = offsetof (struct lf_onemethod, name)
|
|
+ name_len;
|
|
|
|
if (subtype_len % 4 != 0)
|
|
subtype_len += 4 - (subtype_len % 4);
|
|
|
|
if (left < subtype_len)
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_FIELDLIST\n"));
|
|
return false;
|
|
}
|
|
|
|
ptr += subtype_len;
|
|
left -= subtype_len;
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_METHOD:
|
|
{
|
|
struct lf_method *meth = (struct lf_method *) ptr;
|
|
size_t name_len, subtype_len;
|
|
|
|
if (left < offsetof (struct lf_method, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_METHOD\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&meth->method_list, map, type_num,
|
|
num_types))
|
|
return false;
|
|
|
|
name_len =
|
|
strnlen (meth->name,
|
|
left - offsetof (struct lf_method, name));
|
|
|
|
if (name_len == left - offsetof (struct lf_method, name))
|
|
{
|
|
einfo (_("%P: warning: name for LF_METHOD has no"
|
|
" terminating zero\n"));
|
|
return false;
|
|
}
|
|
|
|
name_len++;
|
|
|
|
subtype_len = offsetof (struct lf_method, name) + name_len;
|
|
|
|
if (subtype_len % 4 != 0)
|
|
subtype_len += 4 - (subtype_len % 4);
|
|
|
|
if (left < subtype_len)
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_FIELDLIST\n"));
|
|
return false;
|
|
}
|
|
|
|
ptr += subtype_len;
|
|
left -= subtype_len;
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_BCLASS:
|
|
{
|
|
struct lf_bclass *bc = (struct lf_bclass *) ptr;
|
|
size_t subtype_len;
|
|
uint16_t offset;
|
|
|
|
if (left < sizeof (struct lf_bclass))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_BCLASS\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&bc->base_class_type, map, type_num,
|
|
num_types))
|
|
return false;
|
|
|
|
subtype_len = sizeof (struct lf_bclass);
|
|
|
|
offset = bfd_getl16 (&bc->offset);
|
|
|
|
/* If offset >= 0x8000, actual value follows. */
|
|
if (offset >= 0x8000)
|
|
{
|
|
unsigned int param_len = extended_value_len (offset);
|
|
|
|
if (param_len == 0)
|
|
{
|
|
einfo (_("%P: warning: unhandled type %v within"
|
|
" LF_BCLASS\n"), offset);
|
|
return false;
|
|
}
|
|
|
|
subtype_len += param_len;
|
|
|
|
if (left < subtype_len)
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_BCLASS\n"));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (subtype_len % 4 != 0)
|
|
subtype_len += 4 - (subtype_len % 4);
|
|
|
|
if (left < subtype_len)
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_BCLASS\n"));
|
|
return false;
|
|
}
|
|
|
|
ptr += subtype_len;
|
|
left -= subtype_len;
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_VFUNCTAB:
|
|
{
|
|
struct lf_vfunctab *vft = (struct lf_vfunctab *) ptr;
|
|
|
|
if (left < sizeof (struct lf_vfunctab))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_VFUNCTAB\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&vft->type, map, type_num, num_types))
|
|
return false;
|
|
|
|
ptr += sizeof (struct lf_vfunctab);
|
|
left -= sizeof (struct lf_vfunctab);
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_VBCLASS:
|
|
case LF_IVBCLASS:
|
|
{
|
|
struct lf_vbclass *vbc = (struct lf_vbclass *) ptr;
|
|
size_t subtype_len;
|
|
uint16_t offset;
|
|
|
|
if (left < sizeof (struct lf_vbclass))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_VBCLASS/LF_IVBCLASS\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&vbc->base_class_type, map, type_num,
|
|
num_types))
|
|
return false;
|
|
|
|
if (!remap_type (&vbc->virtual_base_pointer_type, map,
|
|
type_num, num_types))
|
|
return false;
|
|
|
|
subtype_len = offsetof (struct lf_vbclass,
|
|
virtual_base_vbtable_offset);
|
|
|
|
offset = bfd_getl16 (&vbc->virtual_base_pointer_offset);
|
|
|
|
/* If offset >= 0x8000, actual value follows. */
|
|
if (offset >= 0x8000)
|
|
{
|
|
unsigned int param_len = extended_value_len (offset);
|
|
|
|
if (param_len == 0)
|
|
{
|
|
einfo (_("%P: warning: unhandled type %v within"
|
|
" LF_VBCLASS/LF_IVBCLASS\n"), offset);
|
|
return false;
|
|
}
|
|
|
|
subtype_len += param_len;
|
|
|
|
if (left < subtype_len)
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_VBCLASS/LF_IVBCLASS\n"));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
offset = bfd_getl16 ((char *)vbc + subtype_len);
|
|
subtype_len += sizeof (uint16_t);
|
|
|
|
/* If offset >= 0x8000, actual value follows. */
|
|
if (offset >= 0x8000)
|
|
{
|
|
unsigned int param_len = extended_value_len (offset);
|
|
|
|
if (param_len == 0)
|
|
{
|
|
einfo (_("%P: warning: unhandled type %v within"
|
|
" LF_VBCLASS/LF_IVBCLASS\n"), offset);
|
|
return false;
|
|
}
|
|
|
|
subtype_len += param_len;
|
|
|
|
if (left < subtype_len)
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_VBCLASS/LF_IVBCLASS\n"));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (subtype_len % 4 != 0)
|
|
subtype_len += 4 - (subtype_len % 4);
|
|
|
|
if (left < subtype_len)
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_VBCLASS/LF_IVBCLASS\n"));
|
|
return false;
|
|
}
|
|
|
|
ptr += subtype_len;
|
|
left -= subtype_len;
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_STMEMBER:
|
|
{
|
|
struct lf_static_member *st =
|
|
(struct lf_static_member *) ptr;
|
|
size_t name_len, subtype_len;
|
|
|
|
if (left < offsetof (struct lf_static_member, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_STMEMBER\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&st->type, map, type_num, num_types))
|
|
return false;
|
|
|
|
name_len =
|
|
strnlen (st->name,
|
|
left - offsetof (struct lf_static_member, name));
|
|
|
|
if (name_len == left
|
|
- offsetof (struct lf_static_member, name))
|
|
{
|
|
einfo (_("%P: warning: name for LF_STMEMBER has no"
|
|
" terminating zero\n"));
|
|
return false;
|
|
}
|
|
|
|
name_len++;
|
|
|
|
subtype_len = offsetof (struct lf_static_member, name)
|
|
+ name_len;
|
|
|
|
if (subtype_len % 4 != 0)
|
|
subtype_len += 4 - (subtype_len % 4);
|
|
|
|
if (left < subtype_len)
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_FIELDLIST\n"));
|
|
return false;
|
|
}
|
|
|
|
ptr += subtype_len;
|
|
left -= subtype_len;
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_NESTTYPE:
|
|
{
|
|
struct lf_nest_type *nest = (struct lf_nest_type *) ptr;
|
|
size_t name_len, subtype_len;
|
|
|
|
if (left < offsetof (struct lf_nest_type, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_NESTTYPE\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&nest->type, map, type_num, num_types))
|
|
return false;
|
|
|
|
name_len =
|
|
strnlen (nest->name,
|
|
left - offsetof (struct lf_nest_type, name));
|
|
|
|
if (name_len == left - offsetof (struct lf_nest_type, name))
|
|
{
|
|
einfo (_("%P: warning: name for LF_NESTTYPE has no"
|
|
" terminating zero\n"));
|
|
return false;
|
|
}
|
|
|
|
name_len++;
|
|
|
|
subtype_len = offsetof (struct lf_nest_type, name)
|
|
+ name_len;
|
|
|
|
if (subtype_len % 4 != 0)
|
|
subtype_len += 4 - (subtype_len % 4);
|
|
|
|
if (left < subtype_len)
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_FIELDLIST\n"));
|
|
return false;
|
|
}
|
|
|
|
ptr += subtype_len;
|
|
left -= subtype_len;
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
einfo (_("%P: warning: unrecognized CodeView subtype %v\n"),
|
|
subtype);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_BITFIELD:
|
|
{
|
|
struct lf_bitfield *bf = (struct lf_bitfield *) data;
|
|
|
|
if (size < offsetof (struct lf_bitfield, length))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_BITFIELD\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&bf->base_type, map, type_num, num_types))
|
|
return false;
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_METHODLIST:
|
|
{
|
|
struct lf_methodlist *ml = (struct lf_methodlist *) data;
|
|
unsigned int num_entries;
|
|
|
|
if (size < offsetof (struct lf_methodlist, entries))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_METHODLIST\n"));
|
|
return false;
|
|
}
|
|
|
|
if ((size - offsetof (struct lf_methodlist, entries))
|
|
% sizeof (struct lf_methodlist_entry))
|
|
{
|
|
einfo (_("%P: warning: malformed CodeView type record"
|
|
" LF_METHODLIST\n"));
|
|
return false;
|
|
}
|
|
|
|
num_entries = (size - offsetof (struct lf_methodlist, entries))
|
|
/ sizeof (struct lf_methodlist_entry);
|
|
|
|
for (unsigned int i = 0; i < num_entries; i++)
|
|
{
|
|
if (!remap_type (&ml->entries[i].method_type, map,
|
|
type_num, num_types))
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_ARRAY:
|
|
{
|
|
struct lf_array *arr = (struct lf_array *) data;
|
|
|
|
if (size < offsetof (struct lf_array, length_in_bytes))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_ARRAY\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&arr->element_type, map, type_num, num_types))
|
|
return false;
|
|
|
|
if (!remap_type (&arr->index_type, map, type_num, num_types))
|
|
return false;
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_CLASS:
|
|
case LF_STRUCTURE:
|
|
{
|
|
struct lf_class *cl = (struct lf_class *) data;
|
|
uint16_t prop, num_bytes;
|
|
size_t name_len, name_off;
|
|
|
|
if (size < offsetof (struct lf_class, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_CLASS/LF_STRUCTURE\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&cl->field_list, map, type_num, num_types))
|
|
return false;
|
|
|
|
if (!remap_type (&cl->derived_from, map, type_num, num_types))
|
|
return false;
|
|
|
|
if (!remap_type (&cl->vshape, map, type_num, num_types))
|
|
return false;
|
|
|
|
name_off = offsetof (struct lf_class, name);
|
|
|
|
num_bytes = bfd_getl16 (&cl->length);
|
|
|
|
/* If num_bytes >= 0x8000, actual value follows. */
|
|
if (num_bytes >= 0x8000)
|
|
{
|
|
unsigned int param_len = extended_value_len (num_bytes);
|
|
|
|
if (param_len == 0)
|
|
{
|
|
einfo (_("%P: warning: unhandled type %v within"
|
|
" LF_CLASS/LF_STRUCTURE\n"), num_bytes);
|
|
return false;
|
|
}
|
|
|
|
name_off += param_len;
|
|
|
|
if (size < name_off)
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_CLASS/LF_STRUCTURE\n"));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
name_len = strnlen ((char *) cl + name_off, size - name_off);
|
|
|
|
if (name_len == size - name_off)
|
|
{
|
|
einfo (_("%P: warning: name for LF_CLASS/LF_STRUCTURE has no"
|
|
" terminating zero\n"));
|
|
return false;
|
|
}
|
|
|
|
prop = bfd_getl16 (&cl->properties);
|
|
|
|
if (prop & CV_PROP_HAS_UNIQUE_NAME)
|
|
{
|
|
/* Structure has another name following first one. */
|
|
|
|
size_t len = name_off + name_len + 1;
|
|
size_t unique_name_len;
|
|
|
|
unique_name_len = strnlen ((char *) cl + name_off + name_len + 1,
|
|
size - len);
|
|
|
|
if (unique_name_len == size - len)
|
|
{
|
|
einfo (_("%P: warning: unique name for LF_CLASS/LF_STRUCTURE"
|
|
" has no terminating zero\n"));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (!(prop & (CV_PROP_FORWARD_REF | CV_PROP_SCOPED))
|
|
&& !is_name_anonymous ((char *) cl + name_off, name_len))
|
|
{
|
|
other_hash = true;
|
|
cv_hash = crc32 ((uint8_t *) cl + name_off, name_len);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_UNION:
|
|
{
|
|
struct lf_union *un = (struct lf_union *) data;
|
|
uint16_t prop, num_bytes;
|
|
size_t name_len, name_off;
|
|
|
|
if (size < offsetof (struct lf_union, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_UNION\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&un->field_list, map, type_num, num_types))
|
|
return false;
|
|
|
|
name_off = offsetof (struct lf_union, name);
|
|
|
|
num_bytes = bfd_getl16 (&un->length);
|
|
|
|
/* If num_bytes >= 0x8000, actual value follows. */
|
|
if (num_bytes >= 0x8000)
|
|
{
|
|
unsigned int param_len = extended_value_len (num_bytes);
|
|
|
|
if (param_len == 0)
|
|
{
|
|
einfo (_("%P: warning: unhandled type %v within"
|
|
" LF_UNION\n"), num_bytes);
|
|
return false;
|
|
}
|
|
|
|
name_off += param_len;
|
|
|
|
if (size < name_off)
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_UNION\n"));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
name_len = strnlen ((char *) un + name_off, size - name_off);
|
|
|
|
if (name_len == size - name_off)
|
|
{
|
|
einfo (_("%P: warning: name for LF_UNION has no"
|
|
" terminating zero\n"));
|
|
return false;
|
|
}
|
|
|
|
prop = bfd_getl16 (&un->properties);
|
|
|
|
if (prop & CV_PROP_HAS_UNIQUE_NAME)
|
|
{
|
|
/* Structure has another name following first one. */
|
|
|
|
size_t len = name_off + name_len + 1;
|
|
size_t unique_name_len;
|
|
|
|
unique_name_len = strnlen ((char *) un + name_off + name_len + 1,
|
|
size - len);
|
|
|
|
if (unique_name_len == size - len)
|
|
{
|
|
einfo (_("%P: warning: unique name for LF_UNION has"
|
|
" no terminating zero\n"));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (!(prop & (CV_PROP_FORWARD_REF | CV_PROP_SCOPED))
|
|
&& !is_name_anonymous ((char *) un + name_off, name_len))
|
|
{
|
|
other_hash = true;
|
|
cv_hash = crc32 ((uint8_t *) un + name_off, name_len);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_ENUM:
|
|
{
|
|
struct lf_enum *en = (struct lf_enum *) data;
|
|
uint16_t prop;
|
|
size_t name_len;
|
|
|
|
if (size < offsetof (struct lf_enum, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_ENUM\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&en->underlying_type, map, type_num, num_types))
|
|
return false;
|
|
|
|
if (!remap_type (&en->field_list, map, type_num, num_types))
|
|
return false;
|
|
|
|
name_len = strnlen (en->name, size - offsetof (struct lf_enum, name));
|
|
|
|
if (name_len == size - offsetof (struct lf_enum, name))
|
|
{
|
|
einfo (_("%P: warning: name for LF_ENUM has no"
|
|
" terminating zero\n"));
|
|
return false;
|
|
}
|
|
|
|
prop = bfd_getl16 (&en->properties);
|
|
|
|
if (prop & CV_PROP_HAS_UNIQUE_NAME)
|
|
{
|
|
/* Structure has another name following first one. */
|
|
|
|
size_t len = offsetof (struct lf_enum, name) + name_len + 1;
|
|
size_t unique_name_len;
|
|
|
|
unique_name_len = strnlen (en->name + name_len + 1, size - len);
|
|
|
|
if (unique_name_len == size - len)
|
|
{
|
|
einfo (_("%P: warning: unique name for LF_ENUM has"
|
|
" no terminating zero\n"));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_VTSHAPE:
|
|
/* Does not reference any types, nothing to be done. */
|
|
break;
|
|
|
|
case LF_VFTABLE:
|
|
{
|
|
struct lf_vftable *vft = (struct lf_vftable *) data;
|
|
|
|
if (size < offsetof (struct lf_vftable, names))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_VFTABLE\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&vft->type, map, type_num, num_types))
|
|
return false;
|
|
|
|
if (!remap_type (&vft->base_vftable, map, type_num, num_types))
|
|
return false;
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_STRING_ID:
|
|
{
|
|
struct lf_string_id *str = (struct lf_string_id *) data;
|
|
size_t string_len;
|
|
|
|
if (size < offsetof (struct lf_string_id, string))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_STRING_ID\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&str->substring, map, type_num, num_types))
|
|
return false;
|
|
|
|
string_len = strnlen (str->string,
|
|
size - offsetof (struct lf_string_id, string));
|
|
|
|
if (string_len == size - offsetof (struct lf_string_id, string))
|
|
{
|
|
einfo (_("%P: warning: string for LF_STRING_ID has no"
|
|
" terminating zero\n"));
|
|
return false;
|
|
}
|
|
|
|
ipi = true;
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_SUBSTR_LIST:
|
|
{
|
|
uint32_t num_entries;
|
|
struct lf_arglist *ssl = (struct lf_arglist *) data;
|
|
|
|
if (size < offsetof (struct lf_arglist, args))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_SUBSTR_LIST\n"));
|
|
return false;
|
|
}
|
|
|
|
num_entries = bfd_getl32 (&ssl->num_entries);
|
|
|
|
if (size < offsetof (struct lf_arglist, args)
|
|
+ (num_entries * sizeof (uint32_t)))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_SUBSTR_LIST\n"));
|
|
return false;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < num_entries; i++)
|
|
{
|
|
if (!remap_type (&ssl->args[i], map, type_num, num_types))
|
|
return false;
|
|
}
|
|
|
|
ipi = true;
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_BUILDINFO:
|
|
{
|
|
uint16_t num_entries;
|
|
struct lf_build_info *bi = (struct lf_build_info *) data;
|
|
|
|
if (size < offsetof (struct lf_build_info, strings))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_BUILDINFO\n"));
|
|
return false;
|
|
}
|
|
|
|
num_entries = bfd_getl16 (&bi->count);
|
|
|
|
if (size < offsetof (struct lf_build_info, strings)
|
|
+ (num_entries * sizeof (uint32_t)))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_BUILDINFO\n"));
|
|
return false;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < num_entries; i++)
|
|
{
|
|
if (!remap_type (&bi->strings[i], map, type_num, num_types))
|
|
return false;
|
|
}
|
|
|
|
ipi = true;
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_FUNC_ID:
|
|
{
|
|
struct lf_func_id *func = (struct lf_func_id *) data;
|
|
size_t name_len;
|
|
|
|
if (size < offsetof (struct lf_func_id, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_FUNC_ID\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&func->parent_scope, map, type_num, num_types))
|
|
return false;
|
|
|
|
if (!remap_type (&func->function_type, map, type_num, num_types))
|
|
return false;
|
|
|
|
name_len = strnlen (func->name,
|
|
size - offsetof (struct lf_func_id, name));
|
|
|
|
if (name_len == size - offsetof (struct lf_func_id, name))
|
|
{
|
|
einfo (_("%P: warning: string for LF_FUNC_ID has no"
|
|
" terminating zero\n"));
|
|
return false;
|
|
}
|
|
|
|
ipi = true;
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_MFUNC_ID:
|
|
{
|
|
struct lf_mfunc_id *mfunc = (struct lf_mfunc_id *) data;
|
|
size_t name_len;
|
|
|
|
if (size < offsetof (struct lf_mfunc_id, name))
|
|
{
|
|
einfo (_("%P: warning: truncated CodeView type record"
|
|
" LF_MFUNC_ID\n"));
|
|
return false;
|
|
}
|
|
|
|
if (!remap_type (&mfunc->parent_type, map, type_num, num_types))
|
|
return false;
|
|
|
|
if (!remap_type (&mfunc->function_type, map, type_num, num_types))
|
|
return false;
|
|
|
|
name_len = strnlen (mfunc->name,
|
|
size - offsetof (struct lf_mfunc_id, name));
|
|
|
|
if (name_len == size - offsetof (struct lf_mfunc_id, name))
|
|
{
|
|
einfo (_("%P: warning: string for LF_MFUNC_ID has no"
|
|
" terminating zero\n"));
|
|
return false;
|
|
}
|
|
|
|
ipi = true;
|
|
|
|
break;
|
|
}
|
|
|
|
case LF_UDT_SRC_LINE:
|
|
return handle_udt_src_line (data, size, map, type_num, num_types,
|
|
ids, mod_num, strings);
|
|
|
|
default:
|
|
einfo (_("%P: warning: unrecognized CodeView type %v\n"), type);
|
|
return false;
|
|
}
|
|
|
|
hash = iterative_hash (data, size, 0);
|
|
|
|
t = ipi ? ids : types;
|
|
|
|
slot = htab_find_slot_with_hash (t->hashmap, data, hash, INSERT);
|
|
if (!slot)
|
|
return false;
|
|
|
|
if (!*slot) /* new entry */
|
|
{
|
|
struct type_entry *e;
|
|
|
|
*slot = xmalloc (offsetof (struct type_entry, data) + size);
|
|
|
|
e = (struct type_entry *) *slot;
|
|
|
|
e->next = NULL;
|
|
e->index = t->num_types;
|
|
|
|
if (other_hash)
|
|
e->cv_hash = cv_hash;
|
|
else
|
|
e->cv_hash = crc32 (data, size);
|
|
|
|
e->has_udt_src_line = false;
|
|
|
|
memcpy (e->data, data, size);
|
|
|
|
if (t->last)
|
|
t->last->next = e;
|
|
else
|
|
t->first = e;
|
|
|
|
t->last = e;
|
|
|
|
map[type_num] = e;
|
|
|
|
t->num_types++;
|
|
}
|
|
else /* duplicate */
|
|
{
|
|
map[type_num] = (struct type_entry *) *slot;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/* Parse the .debug$T section of a module, and pass any type definitions
|
|
found to handle_type. */
|
|
static bool
|
|
handle_debugt_section (asection *s, bfd *mod, struct types *types,
|
|
struct types *ids, uint16_t mod_num,
|
|
struct string_table *strings,
|
|
struct type_entry ***map, uint32_t *num_types)
|
|
{
|
|
bfd_byte *data = NULL;
|
|
size_t off;
|
|
uint32_t type_num;
|
|
|
|
if (!bfd_get_full_section_contents (mod, s, &data))
|
|
return false;
|
|
|
|
if (!data)
|
|
return false;
|
|
|
|
if (bfd_getl32 (data) != CV_SIGNATURE_C13)
|
|
{
|
|
free (data);
|
|
return true;
|
|
}
|
|
|
|
off = sizeof (uint32_t);
|
|
|
|
while (off + sizeof (uint16_t) <= s->size)
|
|
{
|
|
uint16_t size;
|
|
|
|
size = bfd_getl16 (data + off);
|
|
off += sizeof (uint16_t);
|
|
|
|
if (size + off > s->size || size < sizeof (uint16_t))
|
|
{
|
|
free (data);
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
(*num_types)++;
|
|
off += size;
|
|
}
|
|
|
|
if (*num_types == 0)
|
|
{
|
|
free (data);
|
|
return true;
|
|
}
|
|
|
|
*map = xcalloc (*num_types, sizeof (struct type_entry *));
|
|
|
|
off = sizeof (uint32_t);
|
|
type_num = 0;
|
|
|
|
while (off + sizeof (uint16_t) <= s->size)
|
|
{
|
|
uint16_t size;
|
|
|
|
size = bfd_getl16 (data + off);
|
|
|
|
if (!handle_type (data + off, *map, type_num, *num_types, types, ids,
|
|
mod_num, strings))
|
|
{
|
|
free (data);
|
|
free (*map);
|
|
bfd_set_error (bfd_error_bad_value);
|
|
return false;
|
|
}
|
|
|
|
off += sizeof (uint16_t) + size;
|
|
type_num++;
|
|
}
|
|
|
|
free (data);
|
|
|
|
return true;
|
|
}
|
|
|
|
/* Return the CodeView constant for the selected architecture. */
|
|
static uint16_t
|
|
target_processor (bfd *abfd)
|
|
{
|
|
switch (abfd->arch_info->arch)
|
|
{
|
|
case bfd_arch_i386:
|
|
if (abfd->arch_info->mach & bfd_mach_x86_64)
|
|
return CV_CFL_X64;
|
|
else
|
|
return CV_CFL_80386;
|
|
|
|
case bfd_arch_aarch64:
|
|
return CV_CFL_ARM64;
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* Create the symbols that go in "* Linker *", the dummy module created
|
|
for the linker itself. */
|
|
static bool
|
|
create_linker_symbols (bfd *abfd, uint8_t **syms, uint32_t *sym_byte_size,
|
|
const char *pdb_name)
|
|
{
|
|
uint8_t *ptr;
|
|
struct objname *name;
|
|
struct compile3 *comp;
|
|
struct envblock *env;
|
|
size_t padding1, padding2, env_size;
|
|
char *cwdval, *exeval, *pdbval;
|
|
|
|
/* extra NUL for padding */
|
|
static const char linker_fn[] = "* Linker *\0";
|
|
static const char linker_name[] = "GNU LD " VERSION;
|
|
|
|
static const char cwd[] = "cwd";
|
|
static const char exe[] = "exe";
|
|
static const char pdb[] = "pdb";
|
|
|
|
cwdval = getcwd (NULL, 0);
|
|
if (!cwdval)
|
|
{
|
|
einfo (_("%P: warning: unable to get working directory\n"));
|
|
return false;
|
|
}
|
|
|
|
exeval = lrealpath (program_name);
|
|
|
|
if (!exeval)
|
|
{
|
|
einfo (_("%P: warning: unable to get program name\n"));
|
|
free (cwdval);
|
|
return false;
|
|
}
|
|
|
|
pdbval = lrealpath (pdb_name);
|
|
|
|
if (!pdbval)
|
|
{
|
|
einfo (_("%P: warning: unable to get full path to PDB\n"));
|
|
free (exeval);
|
|
free (cwdval);
|
|
return false;
|
|
}
|
|
|
|
*sym_byte_size += offsetof (struct objname, name) + sizeof (linker_fn);
|
|
*sym_byte_size += offsetof (struct compile3, compiler) + sizeof (linker_name);
|
|
|
|
if (*sym_byte_size % 4)
|
|
padding1 = 4 - (*sym_byte_size % 4);
|
|
else
|
|
padding1 = 0;
|
|
|
|
*sym_byte_size += padding1;
|
|
|
|
env_size = offsetof (struct envblock, strings);
|
|
env_size += sizeof (cwd);
|
|
env_size += strlen (cwdval) + 1;
|
|
env_size += sizeof (exe);
|
|
env_size += strlen (exeval) + 1;
|
|
env_size += sizeof (pdb);
|
|
env_size += strlen (pdbval) + 1;
|
|
|
|
if (env_size % 4)
|
|
padding2 = 4 - (env_size % 4);
|
|
else
|
|
padding2 = 0;
|
|
|
|
env_size += padding2;
|
|
|
|
*sym_byte_size += env_size;
|
|
|
|
*syms = xmalloc (*sym_byte_size);
|
|
ptr = *syms;
|
|
|
|
/* Write S_OBJNAME */
|
|
|
|
name = (struct objname *) ptr;
|
|
bfd_putl16 (offsetof (struct objname, name)
|
|
+ sizeof (linker_fn) - sizeof (uint16_t), &name->size);
|
|
bfd_putl16 (S_OBJNAME, &name->kind);
|
|
bfd_putl32 (0, &name->signature);
|
|
memcpy (name->name, linker_fn, sizeof (linker_fn));
|
|
|
|
ptr += offsetof (struct objname, name) + sizeof (linker_fn);
|
|
|
|
/* Write S_COMPILE3 */
|
|
|
|
comp = (struct compile3 *) ptr;
|
|
|
|
bfd_putl16 (offsetof (struct compile3, compiler) + sizeof (linker_name)
|
|
+ padding1 - sizeof (uint16_t), &comp->size);
|
|
bfd_putl16 (S_COMPILE3, &comp->kind);
|
|
bfd_putl32 (CV_CFL_LINK, &comp->flags);
|
|
bfd_putl16 (target_processor (abfd), &comp->machine);
|
|
bfd_putl16 (0, &comp->frontend_major);
|
|
bfd_putl16 (0, &comp->frontend_minor);
|
|
bfd_putl16 (0, &comp->frontend_build);
|
|
bfd_putl16 (0, &comp->frontend_qfe);
|
|
bfd_putl16 (0, &comp->backend_major);
|
|
bfd_putl16 (0, &comp->backend_minor);
|
|
bfd_putl16 (0, &comp->backend_build);
|
|
bfd_putl16 (0, &comp->backend_qfe);
|
|
memcpy (comp->compiler, linker_name, sizeof (linker_name));
|
|
|
|
memset (comp->compiler + sizeof (linker_name), 0, padding1);
|
|
|
|
ptr += offsetof (struct compile3, compiler) + sizeof (linker_name) + padding1;
|
|
|
|
/* Write S_ENVBLOCK */
|
|
|
|
env = (struct envblock *) ptr;
|
|
|
|
bfd_putl16 (env_size - sizeof (uint16_t), &env->size);
|
|
bfd_putl16 (S_ENVBLOCK, &env->kind);
|
|
env->flags = 0;
|
|
|
|
ptr += offsetof (struct envblock, strings);
|
|
|
|
memcpy (ptr, cwd, sizeof (cwd));
|
|
ptr += sizeof (cwd);
|
|
memcpy (ptr, cwdval, strlen (cwdval) + 1);
|
|
ptr += strlen (cwdval) + 1;
|
|
|
|
memcpy (ptr, exe, sizeof (exe));
|
|
ptr += sizeof (exe);
|
|
memcpy (ptr, exeval, strlen (exeval) + 1);
|
|
ptr += strlen (exeval) + 1;
|
|
|
|
memcpy (ptr, pdb, sizeof (pdb));
|
|
ptr += sizeof (pdb);
|
|
memcpy (ptr, pdbval, strlen (pdbval) + 1);
|
|
ptr += strlen (pdbval) + 1;
|
|
|
|
/* Microsoft's LINK also includes "cmd", the command-line options passed
|
|
to the linker, but unfortunately we don't have access to argc and argv
|
|
at this stage. */
|
|
|
|
memset (ptr, 0, padding2);
|
|
|
|
free (pdbval);
|
|
free (exeval);
|
|
free (cwdval);
|
|
|
|
return true;
|
|
}
|
|
|
|
/* Populate the module stream, which consists of the transformed .debug$S
|
|
data for each object file. */
|
|
static bool
|
|
populate_module_stream (bfd *stream, bfd *mod, uint32_t *sym_byte_size,
|
|
struct string_table *strings,
|
|
uint32_t *c13_info_size,
|
|
struct mod_source_files *mod_source,
|
|
bfd *abfd, struct types *types,
|
|
struct types *ids, uint16_t mod_num,
|
|
bfd *sym_rec_stream, struct globals *glob,
|
|
const char *pdb_name)
|
|
{
|
|
uint8_t int_buf[sizeof (uint32_t)];
|
|
uint8_t *c13_info = NULL;
|
|
uint8_t *syms = NULL;
|
|
|
|
*sym_byte_size = 0;
|
|
*c13_info_size = 0;
|
|
|
|
if (!strcmp (bfd_get_filename (mod), "dll stuff"))
|
|
{
|
|
if (!create_linker_symbols (mod, &syms, sym_byte_size, pdb_name))
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
struct type_entry **map = NULL;
|
|
uint32_t num_types = 0;
|
|
|
|
/* Process .debug$T section. */
|
|
|
|
for (asection *s = mod->sections; s; s = s->next)
|
|
{
|
|
if (!strcmp (s->name, ".debug$T") && s->size >= sizeof (uint32_t))
|
|
{
|
|
if (!handle_debugt_section (s, mod, types, ids, mod_num, strings,
|
|
&map, &num_types))
|
|
{
|
|
free (mod_source->files);
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Process .debug$S section(s). */
|
|
|
|
for (asection *s = mod->sections; s; s = s->next)
|
|
{
|
|
if (!strcmp (s->name, ".debug$S") && s->size >= sizeof (uint32_t))
|
|
{
|
|
if (!handle_debugs_section (s, mod, strings, &c13_info,
|
|
c13_info_size, mod_source, abfd,
|
|
&syms, sym_byte_size, map, num_types,
|
|
sym_rec_stream, glob, mod_num))
|
|
{
|
|
free (c13_info);
|
|
free (syms);
|
|
free (mod_source->files);
|
|
free (map);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
free (map);
|
|
}
|
|
|
|
/* Write the signature. */
|
|
|
|
bfd_putl32 (CV_SIGNATURE_C13, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), stream) != sizeof (uint32_t))
|
|
{
|
|
free (c13_info);
|
|
free (syms);
|
|
return false;
|
|
}
|
|
|
|
if (syms)
|
|
{
|
|
if (bfd_write (syms, *sym_byte_size, stream) != *sym_byte_size)
|
|
{
|
|
free (c13_info);
|
|
free (syms);
|
|
return false;
|
|
}
|
|
|
|
free (syms);
|
|
}
|
|
|
|
if (c13_info)
|
|
{
|
|
if (bfd_write (c13_info, *c13_info_size, stream) != *c13_info_size)
|
|
{
|
|
free (c13_info);
|
|
return false;
|
|
}
|
|
|
|
free (c13_info);
|
|
}
|
|
|
|
/* Write the global refs size. */
|
|
|
|
bfd_putl32 (0, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), stream) != sizeof (uint32_t))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/* Create the module info substream within the DBI. */
|
|
static bool
|
|
create_module_info_substream (bfd *abfd, bfd *pdb, void **data,
|
|
uint32_t *size, struct string_table *strings,
|
|
struct source_files_info *source,
|
|
struct types *types, struct types *ids,
|
|
bfd *sym_rec_stream, struct globals *glob,
|
|
const char *pdb_name)
|
|
{
|
|
uint8_t *ptr;
|
|
unsigned int mod_num;
|
|
|
|
static const char linker_fn[] = "* Linker *";
|
|
|
|
*size = 0;
|
|
|
|
for (bfd *in = coff_data (abfd)->link_info->input_bfds; in;
|
|
in = in->link.next)
|
|
{
|
|
size_t len = sizeof (struct module_info);
|
|
|
|
if (!strcmp (bfd_get_filename (in), "dll stuff"))
|
|
{
|
|
len += sizeof (linker_fn); /* Object name. */
|
|
len++; /* Empty module name. */
|
|
}
|
|
else if (in->my_archive)
|
|
{
|
|
char *name = lrealpath (bfd_get_filename (in));
|
|
|
|
len += strlen (name) + 1; /* Object name. */
|
|
|
|
free (name);
|
|
|
|
name = lrealpath (bfd_get_filename (in->my_archive));
|
|
|
|
len += strlen (name) + 1; /* Archive name. */
|
|
|
|
free (name);
|
|
}
|
|
else
|
|
{
|
|
char *name = lrealpath (bfd_get_filename (in));
|
|
size_t name_len = strlen (name) + 1;
|
|
|
|
len += name_len; /* Object name. */
|
|
len += name_len; /* And again as the archive name. */
|
|
|
|
free (name);
|
|
}
|
|
|
|
if (len % 4)
|
|
len += 4 - (len % 4);
|
|
|
|
*size += len;
|
|
|
|
source->mod_count++;
|
|
}
|
|
|
|
*data = xmalloc (*size);
|
|
|
|
ptr = *data;
|
|
|
|
source->mods = xmalloc (source->mod_count
|
|
* sizeof (struct mod_source_files));
|
|
memset (source->mods, 0,
|
|
source->mod_count * sizeof (struct mod_source_files));
|
|
|
|
mod_num = 0;
|
|
|
|
for (bfd *in = coff_data (abfd)->link_info->input_bfds; in;
|
|
in = in->link.next)
|
|
{
|
|
struct module_info *mod = (struct module_info *) ptr;
|
|
uint16_t stream_num;
|
|
bfd *stream;
|
|
uint32_t sym_byte_size, c13_info_size;
|
|
uint8_t *start = ptr;
|
|
|
|
stream = add_stream (pdb, NULL, &stream_num);
|
|
|
|
if (!stream)
|
|
{
|
|
for (unsigned int i = 0; i < source->mod_count; i++)
|
|
{
|
|
free (source->mods[i].files);
|
|
}
|
|
|
|
free (source->mods);
|
|
free (*data);
|
|
return false;
|
|
}
|
|
|
|
if (!populate_module_stream (stream, in, &sym_byte_size,
|
|
strings, &c13_info_size,
|
|
&source->mods[mod_num], abfd,
|
|
types, ids, mod_num,
|
|
sym_rec_stream, glob, pdb_name))
|
|
{
|
|
for (unsigned int i = 0; i < source->mod_count; i++)
|
|
{
|
|
free (source->mods[i].files);
|
|
}
|
|
|
|
free (source->mods);
|
|
free (*data);
|
|
return false;
|
|
}
|
|
|
|
bfd_putl32 (0, &mod->unused1);
|
|
|
|
/* These are dummy values - MSVC copies the first section contribution
|
|
entry here, but doesn't seem to use it for anything. */
|
|
bfd_putl16 (0xffff, &mod->sc.section);
|
|
bfd_putl16 (0, &mod->sc.padding1);
|
|
bfd_putl32 (0, &mod->sc.offset);
|
|
bfd_putl32 (0xffffffff, &mod->sc.size);
|
|
bfd_putl32 (0, &mod->sc.characteristics);
|
|
bfd_putl16 (0xffff, &mod->sc.module_index);
|
|
bfd_putl16 (0, &mod->sc.padding2);
|
|
bfd_putl32 (0, &mod->sc.data_crc);
|
|
bfd_putl32 (0, &mod->sc.reloc_crc);
|
|
|
|
bfd_putl16 (0, &mod->flags);
|
|
bfd_putl16 (stream_num, &mod->module_sym_stream);
|
|
bfd_putl32 (sizeof (uint32_t) + sym_byte_size, &mod->sym_byte_size);
|
|
bfd_putl32 (0, &mod->c11_byte_size);
|
|
bfd_putl32 (c13_info_size, &mod->c13_byte_size);
|
|
bfd_putl16 (0, &mod->source_file_count);
|
|
bfd_putl16 (0, &mod->padding);
|
|
bfd_putl32 (0, &mod->unused2);
|
|
bfd_putl32 (0, &mod->source_file_name_index);
|
|
bfd_putl32 (0, &mod->pdb_file_path_name_index);
|
|
|
|
ptr += sizeof (struct module_info);
|
|
|
|
if (!strcmp (bfd_get_filename (in), "dll stuff"))
|
|
{
|
|
/* Object name. */
|
|
memcpy (ptr, linker_fn, sizeof (linker_fn));
|
|
ptr += sizeof (linker_fn);
|
|
|
|
/* Empty module name. */
|
|
*ptr = 0;
|
|
ptr++;
|
|
}
|
|
else if (in->my_archive)
|
|
{
|
|
char *name = lrealpath (bfd_get_filename (in));
|
|
size_t name_len = strlen (name) + 1;
|
|
|
|
/* Object name. */
|
|
memcpy (ptr, name, name_len);
|
|
ptr += name_len;
|
|
|
|
free (name);
|
|
|
|
name = lrealpath (bfd_get_filename (in->my_archive));
|
|
name_len = strlen (name) + 1;
|
|
|
|
/* Archive name. */
|
|
memcpy (ptr, name, name_len);
|
|
ptr += name_len;
|
|
|
|
free (name);
|
|
}
|
|
else
|
|
{
|
|
char *name = lrealpath (bfd_get_filename (in));
|
|
size_t name_len = strlen (name) + 1;
|
|
|
|
/* Object name. */
|
|
memcpy (ptr, name, name_len);
|
|
ptr += name_len;
|
|
|
|
/* Object name again as archive name. */
|
|
memcpy (ptr, name, name_len);
|
|
ptr += name_len;
|
|
|
|
free (name);
|
|
}
|
|
|
|
/* Pad to next four-byte boundary. */
|
|
|
|
if ((ptr - start) % 4)
|
|
{
|
|
memset (ptr, 0, 4 - ((ptr - start) % 4));
|
|
ptr += 4 - ((ptr - start) % 4);
|
|
}
|
|
|
|
mod_num++;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/* Return the index of a given output section. */
|
|
static uint16_t
|
|
find_section_number (bfd *abfd, asection *sect)
|
|
{
|
|
uint16_t i = 1;
|
|
|
|
for (asection *s = abfd->sections; s; s = s->next)
|
|
{
|
|
if (s == sect)
|
|
return i;
|
|
|
|
/* Empty sections aren't output. */
|
|
if (s->size != 0)
|
|
i++;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Used as parameter to qsort, to sort section contributions by section and
|
|
offset. */
|
|
static int
|
|
section_contribs_compare (const void *p1, const void *p2)
|
|
{
|
|
const struct in_sc *sc1 = p1;
|
|
const struct in_sc *sc2 = p2;
|
|
|
|
if (sc1->sect_num < sc2->sect_num)
|
|
return -1;
|
|
if (sc1->sect_num > sc2->sect_num)
|
|
return 1;
|
|
|
|
if (sc1->s->output_offset < sc2->s->output_offset)
|
|
return -1;
|
|
if (sc1->s->output_offset > sc2->s->output_offset)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Create the substream which maps addresses in the image file to locations
|
|
in the original object files. */
|
|
static bool
|
|
create_section_contrib_substream (bfd *abfd, void **data, uint32_t *size)
|
|
{
|
|
unsigned int num_sc = 0;
|
|
struct section_contribution *sc;
|
|
uint16_t mod_index;
|
|
char *sect_flags;
|
|
file_ptr offset;
|
|
struct in_sc *sc_in, *sc2;
|
|
uint32_t *ptr;
|
|
|
|
for (bfd *in = coff_data (abfd)->link_info->input_bfds; in;
|
|
in = in->link.next)
|
|
{
|
|
for (asection *s = in->sections; s; s = s->next)
|
|
{
|
|
if (s->size == 0 || discarded_section (s))
|
|
continue;
|
|
|
|
num_sc++;
|
|
}
|
|
}
|
|
|
|
*size = sizeof (uint32_t) + (num_sc * sizeof (struct section_contribution));
|
|
*data = xmalloc (*size);
|
|
|
|
bfd_putl32 (SECTION_CONTRIB_VERSION_60, *data);
|
|
|
|
/* Read characteristics of outputted sections. */
|
|
|
|
sect_flags = xmalloc (sizeof (uint32_t) * abfd->section_count);
|
|
|
|
offset = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
|
|
offset += offsetof (struct external_scnhdr, s_flags);
|
|
|
|
for (unsigned int i = 0; i < abfd->section_count; i++)
|
|
{
|
|
if (bfd_seek (abfd, offset, SEEK_SET) != 0
|
|
|| bfd_read (sect_flags + (i * sizeof (uint32_t)), sizeof (uint32_t),
|
|
abfd) != sizeof (uint32_t))
|
|
{
|
|
free (*data);
|
|
free (sect_flags);
|
|
return false;
|
|
}
|
|
|
|
offset += sizeof (struct external_scnhdr);
|
|
}
|
|
|
|
/* Microsoft's DIA expects section contributions to be sorted by section
|
|
number and offset, otherwise it will be unable to resolve line numbers. */
|
|
|
|
sc_in = xmalloc (num_sc * sizeof (* sc_in));
|
|
sc2 = sc_in;
|
|
|
|
mod_index = 0;
|
|
for (bfd *in = coff_data (abfd)->link_info->input_bfds; in;
|
|
in = in->link.next)
|
|
{
|
|
for (asection *s = in->sections; s; s = s->next)
|
|
{
|
|
if (s->size == 0 || discarded_section (s))
|
|
continue;
|
|
|
|
sc2->s = s;
|
|
sc2->sect_num = find_section_number (abfd, s->output_section);
|
|
sc2->mod_index = mod_index;
|
|
|
|
sc2++;
|
|
}
|
|
|
|
mod_index++;
|
|
}
|
|
|
|
qsort (sc_in, num_sc, sizeof (* sc_in), section_contribs_compare);
|
|
|
|
ptr = *data;
|
|
sc = (struct section_contribution *) (ptr + 1); /* Skip the version word. */
|
|
|
|
for (unsigned int i = 0; i < num_sc; i++)
|
|
{
|
|
memcpy (&sc->characteristics,
|
|
sect_flags + ((sc_in[i].sect_num - 1) * sizeof (uint32_t)),
|
|
sizeof (uint32_t));
|
|
|
|
bfd_putl16 (sc_in[i].sect_num, &sc->section);
|
|
bfd_putl16 (0, &sc->padding1);
|
|
bfd_putl32 (sc_in[i].s->output_offset, &sc->offset);
|
|
bfd_putl32 (sc_in[i].s->size, &sc->size);
|
|
bfd_putl16 (sc_in[i].mod_index, &sc->module_index);
|
|
bfd_putl16 (0, &sc->padding2);
|
|
bfd_putl32 (0, &sc->data_crc);
|
|
bfd_putl32 (0, &sc->reloc_crc);
|
|
|
|
sc++;
|
|
}
|
|
|
|
free (sc_in);
|
|
free (sect_flags);
|
|
|
|
return true;
|
|
}
|
|
|
|
/* The source info substream lives within the DBI stream, and lists the
|
|
source files for each object file (i.e. it's derived from the
|
|
DEBUG_S_FILECHKSMS parts of the .debug$S sections). This is a bit
|
|
superfluous, as the filenames are also available in the C13 parts of
|
|
the module streams, but MSVC relies on it to work properly. */
|
|
static void
|
|
create_source_info_substream (void **data, uint32_t *size,
|
|
struct source_files_info *source)
|
|
{
|
|
uint16_t dedupe_source_files_count = 0;
|
|
uint16_t source_files_count = 0;
|
|
uint32_t strings_len = 0;
|
|
uint8_t *ptr;
|
|
|
|
/* Loop through the source files, marking unique filenames. The pointers
|
|
here are for entries in the main string table, and so have already
|
|
been deduplicated. */
|
|
|
|
for (uint16_t i = 0; i < source->mod_count; i++)
|
|
{
|
|
for (uint16_t j = 0; j < source->mods[i].files_count; j++)
|
|
{
|
|
if (source->mods[i].files[j])
|
|
{
|
|
if (source->mods[i].files[j]->source_file_offset == 0xffffffff)
|
|
{
|
|
source->mods[i].files[j]->source_file_offset = strings_len;
|
|
strings_len += source->mods[i].files[j]->len + 1;
|
|
dedupe_source_files_count++;
|
|
}
|
|
|
|
source_files_count++;
|
|
}
|
|
}
|
|
}
|
|
|
|
*size = sizeof (uint16_t) + sizeof (uint16_t);
|
|
*size += (sizeof (uint16_t) + sizeof (uint16_t)) * source->mod_count;
|
|
*size += sizeof (uint32_t) * source_files_count;
|
|
*size += strings_len;
|
|
|
|
*data = xmalloc (*size);
|
|
|
|
ptr = (uint8_t *) *data;
|
|
|
|
/* Write header (module count and source file count). */
|
|
|
|
bfd_putl16 (source->mod_count, ptr);
|
|
ptr += sizeof (uint16_t);
|
|
|
|
bfd_putl16 (dedupe_source_files_count, ptr);
|
|
ptr += sizeof (uint16_t);
|
|
|
|
/* Write "ModIndices". As the LLVM documentation puts it, "this array is
|
|
present, but does not appear to be useful". */
|
|
|
|
for (uint16_t i = 0; i < source->mod_count; i++)
|
|
{
|
|
bfd_putl16 (i, ptr);
|
|
ptr += sizeof (uint16_t);
|
|
}
|
|
|
|
/* Write source file count for each module. */
|
|
|
|
for (uint16_t i = 0; i < source->mod_count; i++)
|
|
{
|
|
bfd_putl16 (source->mods[i].files_count, ptr);
|
|
ptr += sizeof (uint16_t);
|
|
}
|
|
|
|
/* For each module, write the offsets within the string table
|
|
for each source file. */
|
|
|
|
for (uint16_t i = 0; i < source->mod_count; i++)
|
|
{
|
|
for (uint16_t j = 0; j < source->mods[i].files_count; j++)
|
|
{
|
|
if (source->mods[i].files[j])
|
|
{
|
|
bfd_putl32 (source->mods[i].files[j]->source_file_offset, ptr);
|
|
ptr += sizeof (uint32_t);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Write the string table. We set source_file_offset to a dummy value for
|
|
each entry we write, so we don't write duplicate filenames. */
|
|
|
|
for (uint16_t i = 0; i < source->mod_count; i++)
|
|
{
|
|
for (uint16_t j = 0; j < source->mods[i].files_count; j++)
|
|
{
|
|
if (source->mods[i].files[j]
|
|
&& source->mods[i].files[j]->source_file_offset != 0xffffffff)
|
|
{
|
|
memcpy (ptr, source->mods[i].files[j]->s,
|
|
source->mods[i].files[j]->len);
|
|
ptr += source->mods[i].files[j]->len;
|
|
|
|
*ptr = 0;
|
|
ptr++;
|
|
|
|
source->mods[i].files[j]->source_file_offset = 0xffffffff;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Used as parameter to qsort, to sort globals by hash. */
|
|
static int
|
|
global_compare_hash (const void *s1, const void *s2)
|
|
{
|
|
const struct global *g1 = *(const struct global **) s1;
|
|
const struct global *g2 = *(const struct global **) s2;
|
|
|
|
if (g1->hash < g2->hash)
|
|
return -1;
|
|
if (g1->hash > g2->hash)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Create the globals stream, which contains the unmangled symbol names. */
|
|
static bool
|
|
create_globals_stream (bfd *pdb, struct globals *glob, uint16_t *stream_num)
|
|
{
|
|
bfd *stream;
|
|
struct globals_hash_header h;
|
|
uint32_t buckets_size, filled_buckets = 0;
|
|
struct global **sorted = NULL;
|
|
bool ret = false;
|
|
struct global *buckets[NUM_GLOBALS_HASH_BUCKETS];
|
|
char int_buf[sizeof (uint32_t)];
|
|
|
|
stream = add_stream (pdb, NULL, stream_num);
|
|
if (!stream)
|
|
return false;
|
|
|
|
memset (buckets, 0, sizeof (buckets));
|
|
|
|
if (glob->num_entries > 0)
|
|
{
|
|
struct global *g;
|
|
|
|
/* Create an array of pointers, sorted by hash value. */
|
|
|
|
sorted = xmalloc (sizeof (struct global *) * glob->num_entries);
|
|
|
|
g = glob->first;
|
|
for (unsigned int i = 0; i < glob->num_entries; i++)
|
|
{
|
|
sorted[i] = g;
|
|
g = g->next;
|
|
}
|
|
|
|
qsort (sorted, glob->num_entries, sizeof (struct global *),
|
|
global_compare_hash);
|
|
|
|
/* Populate the buckets. */
|
|
|
|
for (unsigned int i = 0; i < glob->num_entries; i++)
|
|
{
|
|
if (!buckets[sorted[i]->hash])
|
|
{
|
|
buckets[sorted[i]->hash] = sorted[i];
|
|
filled_buckets++;
|
|
}
|
|
|
|
sorted[i]->index = i;
|
|
}
|
|
}
|
|
|
|
buckets_size = NUM_GLOBALS_HASH_BUCKETS / 8;
|
|
buckets_size += sizeof (uint32_t);
|
|
buckets_size += filled_buckets * sizeof (uint32_t);
|
|
|
|
bfd_putl32 (GLOBALS_HASH_SIGNATURE, &h.signature);
|
|
bfd_putl32 (GLOBALS_HASH_VERSION_70, &h.version);
|
|
bfd_putl32 (glob->num_entries * sizeof (struct hash_record),
|
|
&h.entries_size);
|
|
bfd_putl32 (buckets_size, &h.buckets_size);
|
|
|
|
if (bfd_write (&h, sizeof (h), stream) != sizeof (h))
|
|
return false;
|
|
|
|
/* Write hash entries, sorted by hash. */
|
|
|
|
for (unsigned int i = 0; i < glob->num_entries; i++)
|
|
{
|
|
struct hash_record hr;
|
|
|
|
bfd_putl32 (sorted[i]->offset + 1, &hr.offset);
|
|
bfd_putl32 (sorted[i]->refcount, &hr.reference);
|
|
|
|
if (bfd_write (&hr, sizeof (hr), stream) != sizeof (hr))
|
|
goto end;
|
|
}
|
|
|
|
/* Write the bitmap for filled and unfilled buckets. */
|
|
|
|
for (unsigned int i = 0; i < NUM_GLOBALS_HASH_BUCKETS; i += 8)
|
|
{
|
|
uint8_t v = 0;
|
|
|
|
for (unsigned int j = 0; j < 8; j++)
|
|
{
|
|
if (buckets[i + j])
|
|
v |= 1 << j;
|
|
}
|
|
|
|
if (bfd_write (&v, sizeof (v), stream) != sizeof (v))
|
|
goto end;
|
|
}
|
|
|
|
/* Add a 4-byte gap. */
|
|
|
|
bfd_putl32 (0, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), stream) != sizeof (uint32_t))
|
|
goto end;
|
|
|
|
/* Write the bucket offsets. */
|
|
|
|
for (unsigned int i = 0; i < NUM_GLOBALS_HASH_BUCKETS; i++)
|
|
{
|
|
if (buckets[i])
|
|
{
|
|
/* 0xc is size of internal hash_record structure in
|
|
Microsoft's parser. */
|
|
bfd_putl32 (buckets[i]->index * 0xc, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), stream) !=
|
|
sizeof (uint32_t))
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
ret = true;
|
|
|
|
end:
|
|
free (sorted);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Hash an entry in the globals list. */
|
|
static hashval_t
|
|
hash_global_entry (const void *p)
|
|
{
|
|
const struct global *g = (const struct global *) p;
|
|
uint16_t len = bfd_getl16 (g->data);
|
|
|
|
return iterative_hash (g->data, len, 0);
|
|
}
|
|
|
|
/* Compare an entry in the globals list with a symbol. */
|
|
static int
|
|
eq_global_entry (const void *a, const void *b)
|
|
{
|
|
const struct global *g = (const struct global *) a;
|
|
uint16_t len1, len2;
|
|
|
|
len1 = bfd_getl16 (g->data) + sizeof (uint16_t);
|
|
len2 = bfd_getl16 (b) + sizeof (uint16_t);
|
|
|
|
if (len1 != len2)
|
|
return 0;
|
|
|
|
return !memcmp (g->data, b, len1);
|
|
}
|
|
|
|
/* Stream 4 is the debug information (DBI) stream. */
|
|
static bool
|
|
populate_dbi_stream (bfd *stream, bfd *abfd, bfd *pdb,
|
|
uint16_t section_header_stream_num,
|
|
uint16_t sym_rec_stream_num,
|
|
uint16_t publics_stream_num,
|
|
struct string_table *strings,
|
|
struct types *types,
|
|
struct types *ids,
|
|
bfd *sym_rec_stream, const char *pdb_name)
|
|
{
|
|
struct pdb_dbi_stream_header h;
|
|
struct optional_dbg_header opt;
|
|
void *mod_info, *sc, *source_info;
|
|
uint32_t mod_info_size, sc_size, source_info_size;
|
|
struct source_files_info source;
|
|
struct globals glob;
|
|
uint16_t globals_stream_num;
|
|
|
|
source.mod_count = 0;
|
|
source.mods = NULL;
|
|
|
|
glob.num_entries = 0;
|
|
glob.first = NULL;
|
|
glob.last = NULL;
|
|
|
|
glob.hashmap = htab_create_alloc (0, hash_global_entry,
|
|
eq_global_entry, free, xcalloc, free);
|
|
|
|
if (!create_module_info_substream (abfd, pdb, &mod_info, &mod_info_size,
|
|
strings, &source, types, ids,
|
|
sym_rec_stream, &glob, pdb_name))
|
|
{
|
|
htab_delete (glob.hashmap);
|
|
return false;
|
|
}
|
|
|
|
if (!create_globals_stream (pdb, &glob, &globals_stream_num))
|
|
{
|
|
htab_delete (glob.hashmap);
|
|
|
|
for (unsigned int i = 0; i < source.mod_count; i++)
|
|
{
|
|
free (source.mods[i].files);
|
|
}
|
|
free (source.mods);
|
|
|
|
free (mod_info);
|
|
return false;
|
|
}
|
|
|
|
htab_delete (glob.hashmap);
|
|
|
|
if (!create_section_contrib_substream (abfd, &sc, &sc_size))
|
|
{
|
|
for (unsigned int i = 0; i < source.mod_count; i++)
|
|
{
|
|
free (source.mods[i].files);
|
|
}
|
|
free (source.mods);
|
|
|
|
free (mod_info);
|
|
return false;
|
|
}
|
|
|
|
create_source_info_substream (&source_info, &source_info_size, &source);
|
|
|
|
for (unsigned int i = 0; i < source.mod_count; i++)
|
|
{
|
|
free (source.mods[i].files);
|
|
}
|
|
free (source.mods);
|
|
|
|
bfd_putl32 (0xffffffff, &h.version_signature);
|
|
bfd_putl32 (DBI_STREAM_VERSION_70, &h.version_header);
|
|
bfd_putl32 (1, &h.age);
|
|
bfd_putl16 (globals_stream_num, &h.global_stream_index);
|
|
bfd_putl16 (0x8e1d, &h.build_number); // MSVC 14.29
|
|
bfd_putl16 (publics_stream_num, &h.public_stream_index);
|
|
bfd_putl16 (0, &h.pdb_dll_version);
|
|
bfd_putl16 (sym_rec_stream_num, &h.sym_record_stream);
|
|
bfd_putl16 (0, &h.pdb_dll_rbld);
|
|
bfd_putl32 (mod_info_size, &h.mod_info_size);
|
|
bfd_putl32 (sc_size, &h.section_contribution_size);
|
|
bfd_putl32 (0, &h.section_map_size);
|
|
bfd_putl32 (source_info_size, &h.source_info_size);
|
|
bfd_putl32 (0, &h.type_server_map_size);
|
|
bfd_putl32 (0, &h.mfc_type_server_index);
|
|
bfd_putl32 (sizeof (opt), &h.optional_dbg_header_size);
|
|
bfd_putl32 (0, &h.ec_substream_size);
|
|
bfd_putl16 (0, &h.flags);
|
|
bfd_putl16 (get_arch_number (abfd), &h.machine);
|
|
bfd_putl32 (0, &h.padding);
|
|
|
|
if (bfd_write (&h, sizeof (h), stream) != sizeof (h))
|
|
{
|
|
free (source_info);
|
|
free (sc);
|
|
free (mod_info);
|
|
return false;
|
|
}
|
|
|
|
if (bfd_write (mod_info, mod_info_size, stream) != mod_info_size)
|
|
{
|
|
free (source_info);
|
|
free (sc);
|
|
free (mod_info);
|
|
return false;
|
|
}
|
|
|
|
free (mod_info);
|
|
|
|
if (bfd_write (sc, sc_size, stream) != sc_size)
|
|
{
|
|
free (source_info);
|
|
free (sc);
|
|
return false;
|
|
}
|
|
|
|
free (sc);
|
|
|
|
if (bfd_write (source_info, source_info_size, stream) != source_info_size)
|
|
{
|
|
free (source_info);
|
|
return false;
|
|
}
|
|
|
|
free (source_info);
|
|
|
|
bfd_putl16 (0xffff, &opt.fpo_stream);
|
|
bfd_putl16 (0xffff, &opt.exception_stream);
|
|
bfd_putl16 (0xffff, &opt.fixup_stream);
|
|
bfd_putl16 (0xffff, &opt.omap_to_src_stream);
|
|
bfd_putl16 (0xffff, &opt.omap_from_src_stream);
|
|
bfd_putl16 (section_header_stream_num, &opt.section_header_stream);
|
|
bfd_putl16 (0xffff, &opt.token_map_stream);
|
|
bfd_putl16 (0xffff, &opt.xdata_stream);
|
|
bfd_putl16 (0xffff, &opt.pdata_stream);
|
|
bfd_putl16 (0xffff, &opt.new_fpo_stream);
|
|
bfd_putl16 (0xffff, &opt.orig_section_header_stream);
|
|
|
|
if (bfd_write (&opt, sizeof (opt), stream) != sizeof (opt))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/* Used as parameter to qsort, to sort publics by hash. */
|
|
static int
|
|
public_compare_hash (const void *s1, const void *s2)
|
|
{
|
|
const struct public *p1 = *(const struct public **) s1;
|
|
const struct public *p2 = *(const struct public **) s2;
|
|
|
|
if (p1->hash < p2->hash)
|
|
return -1;
|
|
if (p1->hash > p2->hash)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Used as parameter to qsort, to sort publics by address. */
|
|
static int
|
|
public_compare_addr (const void *s1, const void *s2)
|
|
{
|
|
const struct public *p1 = *(const struct public **) s1;
|
|
const struct public *p2 = *(const struct public **) s2;
|
|
|
|
if (p1->section < p2->section)
|
|
return -1;
|
|
if (p1->section > p2->section)
|
|
return 1;
|
|
|
|
if (p1->address < p2->address)
|
|
return -1;
|
|
if (p1->address > p2->address)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* The publics stream is a hash map of S_PUB32 records, which are stored
|
|
in the symbol record stream. Each S_PUB32 entry represents a symbol
|
|
from the point of view of the linker: a section index, an offset within
|
|
the section, and a mangled name. Compare with S_GDATA32 and S_GPROC32,
|
|
which are the same thing but generated by the compiler. */
|
|
static bool
|
|
populate_publics_stream (bfd *stream, bfd *abfd, bfd *sym_rec_stream)
|
|
{
|
|
struct publics_header header;
|
|
struct globals_hash_header hash_header;
|
|
const unsigned int num_buckets = 4096;
|
|
unsigned int num_entries = 0, filled_buckets = 0;
|
|
unsigned int buckets_size, sym_hash_size;
|
|
char int_buf[sizeof (uint32_t)];
|
|
struct public *publics_head = NULL, *publics_tail = NULL;
|
|
struct public **buckets;
|
|
struct public **sorted = NULL;
|
|
bool ret = false;
|
|
|
|
buckets = xmalloc (sizeof (struct public *) * num_buckets);
|
|
memset (buckets, 0, sizeof (struct public *) * num_buckets);
|
|
|
|
/* Loop through the global symbols in our input files, and write S_PUB32
|
|
records in the symbol record stream for those that make it into the
|
|
final image. */
|
|
for (bfd *in = coff_data (abfd)->link_info->input_bfds; in;
|
|
in = in->link.next)
|
|
{
|
|
if (!in->outsymbols)
|
|
continue;
|
|
|
|
for (unsigned int i = 0; i < in->symcount; i++)
|
|
{
|
|
struct bfd_symbol *sym = in->outsymbols[i];
|
|
|
|
if (sym->flags & BSF_GLOBAL)
|
|
{
|
|
struct pubsym ps;
|
|
uint16_t record_length;
|
|
const char *name = sym->name;
|
|
size_t name_len = strlen (name);
|
|
struct public *p = xmalloc (sizeof (struct public));
|
|
unsigned int padding = 0;
|
|
uint16_t section;
|
|
uint32_t flags = 0;
|
|
|
|
section =
|
|
find_section_number (abfd, sym->section->output_section);
|
|
|
|
if (section == 0)
|
|
continue;
|
|
|
|
p->next = NULL;
|
|
p->offset = bfd_tell (sym_rec_stream);
|
|
p->hash = calc_hash (name, name_len) % num_buckets;
|
|
p->section = section;
|
|
p->address = sym->section->output_offset + sym->value;
|
|
|
|
record_length = sizeof (struct pubsym) + name_len + 1;
|
|
|
|
if (record_length % 4)
|
|
padding = 4 - (record_length % 4);
|
|
|
|
/* Assume that all global symbols in executable sections
|
|
are functions. */
|
|
if (sym->section->flags & SEC_CODE)
|
|
flags = PUBSYM_FUNCTION;
|
|
|
|
bfd_putl16 (record_length + padding - sizeof (uint16_t),
|
|
&ps.record_length);
|
|
bfd_putl16 (S_PUB32, &ps.record_type);
|
|
bfd_putl32 (flags, &ps.flags);
|
|
bfd_putl32 (p->address, &ps.offset);
|
|
bfd_putl16 (p->section, &ps.section);
|
|
|
|
if (bfd_write (&ps, sizeof (struct pubsym), sym_rec_stream) !=
|
|
sizeof (struct pubsym))
|
|
goto end;
|
|
|
|
if (bfd_write (name, name_len + 1, sym_rec_stream) !=
|
|
name_len + 1)
|
|
goto end;
|
|
|
|
for (unsigned int j = 0; j < padding; j++)
|
|
{
|
|
uint8_t b = 0;
|
|
|
|
if (bfd_write (&b, sizeof (uint8_t), sym_rec_stream) !=
|
|
sizeof (uint8_t))
|
|
goto end;
|
|
}
|
|
|
|
if (!publics_head)
|
|
publics_head = p;
|
|
else
|
|
publics_tail->next = p;
|
|
|
|
publics_tail = p;
|
|
num_entries++;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if (num_entries > 0)
|
|
{
|
|
/* Create an array of pointers, sorted by hash value. */
|
|
|
|
sorted = xmalloc (sizeof (struct public *) * num_entries);
|
|
|
|
struct public *p = publics_head;
|
|
for (unsigned int i = 0; i < num_entries; i++)
|
|
{
|
|
sorted[i] = p;
|
|
p = p->next;
|
|
}
|
|
|
|
qsort (sorted, num_entries, sizeof (struct public *),
|
|
public_compare_hash);
|
|
|
|
/* Populate the buckets. */
|
|
|
|
for (unsigned int i = 0; i < num_entries; i++)
|
|
{
|
|
if (!buckets[sorted[i]->hash])
|
|
{
|
|
buckets[sorted[i]->hash] = sorted[i];
|
|
filled_buckets++;
|
|
}
|
|
|
|
sorted[i]->index = i;
|
|
}
|
|
}
|
|
|
|
buckets_size = num_buckets / 8;
|
|
buckets_size += sizeof (uint32_t);
|
|
buckets_size += filled_buckets * sizeof (uint32_t);
|
|
|
|
sym_hash_size = sizeof (hash_header);
|
|
sym_hash_size += num_entries * sizeof (struct hash_record);
|
|
sym_hash_size += buckets_size;
|
|
|
|
/* Output the publics header. */
|
|
|
|
bfd_putl32 (sym_hash_size, &header.sym_hash_size);
|
|
bfd_putl32 (num_entries * sizeof (uint32_t), &header.addr_map_size);
|
|
bfd_putl32 (0, &header.num_thunks);
|
|
bfd_putl32 (0, &header.thunks_size);
|
|
bfd_putl32 (0, &header.thunk_table);
|
|
bfd_putl32 (0, &header.thunk_table_offset);
|
|
bfd_putl32 (0, &header.num_sects);
|
|
|
|
if (bfd_write (&header, sizeof (header), stream) != sizeof (header))
|
|
goto end;
|
|
|
|
/* Output the global hash header. */
|
|
|
|
bfd_putl32 (GLOBALS_HASH_SIGNATURE, &hash_header.signature);
|
|
bfd_putl32 (GLOBALS_HASH_VERSION_70, &hash_header.version);
|
|
bfd_putl32 (num_entries * sizeof (struct hash_record),
|
|
&hash_header.entries_size);
|
|
bfd_putl32 (buckets_size, &hash_header.buckets_size);
|
|
|
|
if (bfd_write (&hash_header, sizeof (hash_header), stream) !=
|
|
sizeof (hash_header))
|
|
goto end;
|
|
|
|
/* Write the entries in hash order. */
|
|
|
|
for (unsigned int i = 0; i < num_entries; i++)
|
|
{
|
|
struct hash_record hr;
|
|
|
|
bfd_putl32 (sorted[i]->offset + 1, &hr.offset);
|
|
bfd_putl32 (1, &hr.reference);
|
|
|
|
if (bfd_write (&hr, sizeof (hr), stream) != sizeof (hr))
|
|
goto end;
|
|
}
|
|
|
|
/* Write the bitmap for filled and unfilled buckets. */
|
|
|
|
for (unsigned int i = 0; i < num_buckets; i += 8)
|
|
{
|
|
uint8_t v = 0;
|
|
|
|
for (unsigned int j = 0; j < 8; j++)
|
|
{
|
|
if (buckets[i + j])
|
|
v |= 1 << j;
|
|
}
|
|
|
|
if (bfd_write (&v, sizeof (v), stream) != sizeof (v))
|
|
goto end;
|
|
}
|
|
|
|
/* Add a 4-byte gap. */
|
|
|
|
bfd_putl32 (0, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), stream) != sizeof (uint32_t))
|
|
goto end;
|
|
|
|
/* Write the bucket offsets. */
|
|
|
|
for (unsigned int i = 0; i < num_buckets; i++)
|
|
{
|
|
if (buckets[i])
|
|
{
|
|
/* 0xc is size of internal hash_record structure in
|
|
Microsoft's parser. */
|
|
bfd_putl32 (buckets[i]->index * 0xc, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), stream) !=
|
|
sizeof (uint32_t))
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
/* Write the address map: offsets into the symbol record stream of
|
|
S_PUB32 records, ordered by address. */
|
|
|
|
if (num_entries > 0)
|
|
{
|
|
qsort (sorted, num_entries, sizeof (struct public *),
|
|
public_compare_addr);
|
|
|
|
for (unsigned int i = 0; i < num_entries; i++)
|
|
{
|
|
bfd_putl32 (sorted[i]->offset, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), stream) !=
|
|
sizeof (uint32_t))
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
ret = true;
|
|
|
|
end:
|
|
free (buckets);
|
|
|
|
while (publics_head)
|
|
{
|
|
struct public *p = publics_head->next;
|
|
|
|
free (publics_head);
|
|
publics_head = p;
|
|
}
|
|
|
|
free (sorted);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* The section header stream contains a copy of the section headers
|
|
from the PE file, in the same format. */
|
|
static bool
|
|
create_section_header_stream (bfd *pdb, bfd *abfd, uint16_t *num)
|
|
{
|
|
bfd *stream;
|
|
unsigned int section_count;
|
|
file_ptr scn_base;
|
|
size_t len;
|
|
char *buf;
|
|
|
|
stream = add_stream (pdb, NULL, num);
|
|
if (!stream)
|
|
return false;
|
|
|
|
section_count = abfd->section_count;
|
|
|
|
/* Empty sections aren't output. */
|
|
for (asection *sect = abfd->sections; sect; sect = sect->next)
|
|
{
|
|
if (sect->size == 0)
|
|
section_count--;
|
|
}
|
|
|
|
if (section_count == 0)
|
|
return true;
|
|
|
|
/* Copy section table from output - it's already been written at this
|
|
point. */
|
|
|
|
scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
|
|
|
|
if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
|
|
return false;
|
|
|
|
len = section_count * sizeof (struct external_scnhdr);
|
|
buf = xmalloc (len);
|
|
|
|
if (bfd_read (buf, len, abfd) != len)
|
|
{
|
|
free (buf);
|
|
return false;
|
|
}
|
|
|
|
if (bfd_write (buf, len, stream) != len)
|
|
{
|
|
free (buf);
|
|
return false;
|
|
}
|
|
|
|
free (buf);
|
|
|
|
return true;
|
|
}
|
|
|
|
/* Populate the "/names" named stream, which contains the string table. */
|
|
static bool
|
|
populate_names_stream (bfd *stream, struct string_table *strings)
|
|
{
|
|
char int_buf[sizeof (uint32_t)];
|
|
struct string_table_header h;
|
|
uint32_t num_strings = 0, num_buckets;
|
|
struct string **buckets;
|
|
|
|
bfd_putl32 (STRING_TABLE_SIGNATURE, &h.signature);
|
|
bfd_putl32 (STRING_TABLE_VERSION, &h.version);
|
|
|
|
if (bfd_write (&h, sizeof (h), stream) != sizeof (h))
|
|
return false;
|
|
|
|
bfd_putl32 (strings->strings_len, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), stream) != sizeof (uint32_t))
|
|
return false;
|
|
|
|
int_buf[0] = 0;
|
|
|
|
if (bfd_write (int_buf, 1, stream) != 1)
|
|
return false;
|
|
|
|
for (struct string *s = strings->strings_head; s; s = s->next)
|
|
{
|
|
if (bfd_write (s->s, s->len, stream) != s->len)
|
|
return false;
|
|
|
|
if (bfd_write (int_buf, 1, stream) != 1)
|
|
return false;
|
|
|
|
num_strings++;
|
|
}
|
|
|
|
num_buckets = num_strings * 2;
|
|
|
|
buckets = xmalloc (sizeof (struct string *) * num_buckets);
|
|
memset (buckets, 0, sizeof (struct string *) * num_buckets);
|
|
|
|
for (struct string *s = strings->strings_head; s; s = s->next)
|
|
{
|
|
uint32_t bucket_num = s->hash % num_buckets;
|
|
|
|
while (buckets[bucket_num])
|
|
{
|
|
bucket_num++;
|
|
|
|
if (bucket_num == num_buckets)
|
|
bucket_num = 0;
|
|
}
|
|
|
|
buckets[bucket_num] = s;
|
|
}
|
|
|
|
bfd_putl32 (num_buckets, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), stream) != sizeof (uint32_t))
|
|
{
|
|
free (buckets);
|
|
return false;
|
|
}
|
|
|
|
for (unsigned int i = 0; i < num_buckets; i++)
|
|
{
|
|
if (buckets[i])
|
|
bfd_putl32 (buckets[i]->offset, int_buf);
|
|
else
|
|
bfd_putl32 (0, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), stream) !=
|
|
sizeof (uint32_t))
|
|
{
|
|
free (buckets);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
free (buckets);
|
|
|
|
bfd_putl32 (num_strings, int_buf);
|
|
|
|
if (bfd_write (int_buf, sizeof (uint32_t), stream) != sizeof (uint32_t))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/* Calculate the hash of a type_entry. */
|
|
static hashval_t
|
|
hash_type_entry (const void *p)
|
|
{
|
|
const struct type_entry *e = (const struct type_entry *) p;
|
|
uint16_t size = bfd_getl16 (e->data) + sizeof (uint16_t);
|
|
|
|
return iterative_hash (e->data, size, 0);
|
|
}
|
|
|
|
/* Compare a type_entry with a type. */
|
|
static int
|
|
eq_type_entry (const void *a, const void *b)
|
|
{
|
|
const struct type_entry *e = (const struct type_entry *) a;
|
|
uint16_t size_a = bfd_getl16 (e->data);
|
|
uint16_t size_b = bfd_getl16 (b);
|
|
|
|
if (size_a != size_b)
|
|
return 0;
|
|
|
|
return memcmp (e->data + sizeof (uint16_t),
|
|
(const uint8_t *) b + sizeof (uint16_t), size_a) == 0;
|
|
}
|
|
|
|
/* Create a PDB debugging file for the PE image file abfd with the build ID
|
|
guid, stored at pdb_name. */
|
|
bool
|
|
create_pdb_file (bfd *abfd, const char *pdb_name, const unsigned char *guid)
|
|
{
|
|
bfd *pdb;
|
|
bool ret = false;
|
|
bfd *info_stream, *dbi_stream, *names_stream, *sym_rec_stream,
|
|
*publics_stream, *tpi_stream, *ipi_stream;
|
|
uint16_t section_header_stream_num, sym_rec_stream_num, publics_stream_num;
|
|
struct string_table strings;
|
|
struct types types, ids;
|
|
|
|
pdb = bfd_openw (pdb_name, "pdb");
|
|
if (!pdb)
|
|
{
|
|
einfo (_("%P: warning: cannot create PDB file: %E\n"));
|
|
return false;
|
|
}
|
|
|
|
strings.strings_head = NULL;
|
|
strings.strings_tail = NULL;
|
|
strings.strings_len = 1;
|
|
strings.hashmap = htab_create_alloc (0, hash_string_table_entry,
|
|
eq_string_table_entry, free,
|
|
xcalloc, free);
|
|
|
|
bfd_set_format (pdb, bfd_archive);
|
|
|
|
if (!create_old_directory_stream (pdb))
|
|
{
|
|
einfo (_("%P: warning: cannot create old directory stream "
|
|
"in PDB file: %E\n"));
|
|
goto end;
|
|
}
|
|
|
|
info_stream = add_stream (pdb, NULL, NULL);
|
|
|
|
if (!info_stream)
|
|
{
|
|
einfo (_("%P: warning: cannot create info stream "
|
|
"in PDB file: %E\n"));
|
|
goto end;
|
|
}
|
|
|
|
tpi_stream = add_stream (pdb, NULL, NULL);
|
|
|
|
if (!tpi_stream)
|
|
{
|
|
einfo (_("%P: warning: cannot create TPI stream "
|
|
"in PDB file: %E\n"));
|
|
goto end;
|
|
}
|
|
|
|
dbi_stream = add_stream (pdb, NULL, NULL);
|
|
|
|
if (!dbi_stream)
|
|
{
|
|
einfo (_("%P: warning: cannot create DBI stream "
|
|
"in PDB file: %E\n"));
|
|
goto end;
|
|
}
|
|
|
|
ipi_stream = add_stream (pdb, NULL, NULL);
|
|
|
|
if (!ipi_stream)
|
|
{
|
|
einfo (_("%P: warning: cannot create IPI stream "
|
|
"in PDB file: %E\n"));
|
|
goto end;
|
|
}
|
|
|
|
names_stream = add_stream (pdb, "/names", NULL);
|
|
|
|
if (!names_stream)
|
|
{
|
|
einfo (_("%P: warning: cannot create /names stream "
|
|
"in PDB file: %E\n"));
|
|
goto end;
|
|
}
|
|
|
|
sym_rec_stream = add_stream (pdb, NULL, &sym_rec_stream_num);
|
|
|
|
if (!sym_rec_stream)
|
|
{
|
|
einfo (_("%P: warning: cannot create symbol record stream "
|
|
"in PDB file: %E\n"));
|
|
goto end;
|
|
}
|
|
|
|
publics_stream = add_stream (pdb, NULL, &publics_stream_num);
|
|
|
|
if (!publics_stream)
|
|
{
|
|
einfo (_("%P: warning: cannot create publics stream "
|
|
"in PDB file: %E\n"));
|
|
goto end;
|
|
}
|
|
|
|
if (!create_section_header_stream (pdb, abfd, §ion_header_stream_num))
|
|
{
|
|
einfo (_("%P: warning: cannot create section header stream "
|
|
"in PDB file: %E\n"));
|
|
goto end;
|
|
}
|
|
|
|
types.num_types = 0;
|
|
types.hashmap = htab_create_alloc (0, hash_type_entry, eq_type_entry,
|
|
free, xcalloc, free);
|
|
types.first = types.last = NULL;
|
|
|
|
ids.num_types = 0;
|
|
ids.hashmap = htab_create_alloc (0, hash_type_entry, eq_type_entry,
|
|
free, xcalloc, free);
|
|
ids.first = ids.last = NULL;
|
|
|
|
if (!populate_dbi_stream (dbi_stream, abfd, pdb, section_header_stream_num,
|
|
sym_rec_stream_num, publics_stream_num,
|
|
&strings, &types, &ids, sym_rec_stream, pdb_name))
|
|
{
|
|
einfo (_("%P: warning: cannot populate DBI stream "
|
|
"in PDB file: %E\n"));
|
|
htab_delete (types.hashmap);
|
|
htab_delete (ids.hashmap);
|
|
goto end;
|
|
}
|
|
|
|
if (!populate_type_stream (pdb, tpi_stream, &types))
|
|
{
|
|
einfo (_("%P: warning: cannot populate TPI stream "
|
|
"in PDB file: %E\n"));
|
|
htab_delete (types.hashmap);
|
|
htab_delete (ids.hashmap);
|
|
goto end;
|
|
}
|
|
|
|
htab_delete (types.hashmap);
|
|
|
|
if (!populate_type_stream (pdb, ipi_stream, &ids))
|
|
{
|
|
einfo (_("%P: warning: cannot populate IPI stream "
|
|
"in PDB file: %E\n"));
|
|
htab_delete (ids.hashmap);
|
|
goto end;
|
|
}
|
|
|
|
htab_delete (ids.hashmap);
|
|
|
|
add_string ("", 0, &strings);
|
|
|
|
if (!populate_names_stream (names_stream, &strings))
|
|
{
|
|
einfo (_("%P: warning: cannot populate names stream "
|
|
"in PDB file: %E\n"));
|
|
goto end;
|
|
}
|
|
|
|
if (!populate_publics_stream (publics_stream, abfd, sym_rec_stream))
|
|
{
|
|
einfo (_("%P: warning: cannot populate publics stream "
|
|
"in PDB file: %E\n"));
|
|
goto end;
|
|
}
|
|
|
|
if (!populate_info_stream (pdb, info_stream, guid))
|
|
{
|
|
einfo (_("%P: warning: cannot populate info stream "
|
|
"in PDB file: %E\n"));
|
|
goto end;
|
|
}
|
|
|
|
ret = true;
|
|
|
|
end:
|
|
bfd_close (pdb);
|
|
|
|
htab_delete (strings.hashmap);
|
|
|
|
return ret;
|
|
}
|