mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-15 04:31:49 +08:00
b3aa594daa
Add .cv_ucomp and .cv_scomp pseudo-directives for object files for Windows targets, which encode compressed CodeView integers according to the algorithm in CVCompressData in https://github.com/Microsoft/microsoft-pdb/blob/master/include/cvinfo.h. This is essentially Microsoft's answer to the LEB128, though used in far fewer places. CodeView uses these to encode the "binary annotations" in the S_INLINESITE symbol, which express the relationship between code offsets and line numbers in inlined functions. This has to be done in the assembler as GCC doesn't know how many bytes each instruction takes up. There's no equivalent for this for MSVC or LLVM, as in both cases the assembler and compiler are integrated. .cv_ucomp represents an unsigned big-endian integer between 0 and 0x1fffffff, taking up 1, 2, or 4 bytes: Value between 0 and 0x7f: 0aaaaaaa -> 0aaaaaaa (identity-mapped) Value between 0x80 and 0x3fff: 00aaaaaa bbbbbbbb -> 10aaaaaa bbbbbbbb Value between 0x4000 and 0x1fffffff: 000aaaaa bbbbbbbb ccccccccc dddddddd -> 110aaaaa bbbbbbbb ccccccccc dddddddd .cv_scomp represents a signed big-endian integer between -0xfffffff and 0xfffffff, encoded according to EncodeSignedInt32 in cvinfo.h. The absolute value of the integer is shifted left one bit, the LSB set for a negative value, and the result expressed as if it were a .cv_ucomp: cv_scomp(x) = cv_ucomp((abs(x) << 1) | (x < 0 ? 1 : 0))
633 lines
13 KiB
C
633 lines
13 KiB
C
/* codeview.c - CodeView debug support
|
|
Copyright (C) 2022-2024 Free Software Foundation, Inc.
|
|
|
|
This file is part of GAS, the GNU Assembler.
|
|
|
|
GAS 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, or (at your option)
|
|
any later version.
|
|
|
|
GAS 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 GAS; see the file COPYING. If not, write to the Free
|
|
Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
|
|
02110-1301, USA. */
|
|
|
|
#include "as.h"
|
|
#include "codeview.h"
|
|
#include "subsegs.h"
|
|
#include "filenames.h"
|
|
#include "md5.h"
|
|
|
|
#if defined (TE_PE) && defined (O_secrel)
|
|
|
|
#define NUM_MD5_BYTES 16
|
|
|
|
#define FILE_ENTRY_PADDING 2
|
|
#define FILE_ENTRY_LENGTH (sizeof (struct file_checksum) + NUM_MD5_BYTES \
|
|
+ FILE_ENTRY_PADDING)
|
|
|
|
struct line
|
|
{
|
|
struct line *next;
|
|
unsigned int lineno;
|
|
addressT frag_offset;
|
|
};
|
|
|
|
struct line_file
|
|
{
|
|
struct line_file *next;
|
|
unsigned int fileno;
|
|
struct line *lines_head, *lines_tail;
|
|
unsigned int num_lines;
|
|
};
|
|
|
|
struct line_block
|
|
{
|
|
struct line_block *next;
|
|
segT seg;
|
|
unsigned int subseg;
|
|
fragS *frag;
|
|
symbolS *sym;
|
|
struct line_file *files_head, *files_tail;
|
|
};
|
|
|
|
struct source_file
|
|
{
|
|
struct source_file *next;
|
|
unsigned int num;
|
|
char *filename;
|
|
uint32_t string_pos;
|
|
uint8_t md5[NUM_MD5_BYTES];
|
|
};
|
|
|
|
static struct line_block *blocks_head = NULL, *blocks_tail = NULL;
|
|
static struct source_file *files_head = NULL, *files_tail = NULL;
|
|
static unsigned int num_source_files = 0;
|
|
|
|
/* Return the size of the current fragment (taken from dwarf2dbg.c). */
|
|
static offsetT
|
|
get_frag_fix (fragS *frag, segT seg)
|
|
{
|
|
frchainS *fr;
|
|
|
|
if (frag->fr_next)
|
|
return frag->fr_fix;
|
|
|
|
for (fr = seg_info (seg)->frchainP; fr; fr = fr->frch_next)
|
|
if (fr->frch_last == frag)
|
|
return (char *) obstack_next_free (&fr->frch_obstack) - frag->fr_literal;
|
|
|
|
abort ();
|
|
}
|
|
|
|
/* Emit a .secrel32 relocation. */
|
|
static void
|
|
emit_secrel32_reloc (symbolS *sym)
|
|
{
|
|
expressionS exp;
|
|
|
|
memset (&exp, 0, sizeof (exp));
|
|
exp.X_op = O_secrel;
|
|
exp.X_add_symbol = sym;
|
|
exp.X_add_number = 0;
|
|
emit_expr (&exp, sizeof (uint32_t));
|
|
}
|
|
|
|
/* Emit a .secidx relocation. */
|
|
static void
|
|
emit_secidx_reloc (symbolS *sym)
|
|
{
|
|
expressionS exp;
|
|
|
|
memset (&exp, 0, sizeof (exp));
|
|
exp.X_op = O_secidx;
|
|
exp.X_add_symbol = sym;
|
|
exp.X_add_number = 0;
|
|
emit_expr (&exp, sizeof (uint16_t));
|
|
}
|
|
|
|
/* Write the DEBUG_S_STRINGTABLE subsection. */
|
|
static void
|
|
write_string_table (void)
|
|
{
|
|
uint32_t len;
|
|
unsigned int padding;
|
|
char *ptr, *start;
|
|
|
|
len = 1;
|
|
|
|
for (struct source_file *sf = files_head; sf; sf = sf->next)
|
|
{
|
|
len += strlen (sf->filename) + 1;
|
|
}
|
|
|
|
if (len % 4)
|
|
padding = 4 - (len % 4);
|
|
else
|
|
padding = 0;
|
|
|
|
ptr = frag_more (sizeof (uint32_t) + sizeof (uint32_t) + len + padding);
|
|
|
|
bfd_putl32 (DEBUG_S_STRINGTABLE, ptr);
|
|
ptr += sizeof (uint32_t);
|
|
bfd_putl32 (len, ptr);
|
|
ptr += sizeof (uint32_t);
|
|
|
|
start = ptr;
|
|
|
|
*ptr = 0;
|
|
ptr++;
|
|
|
|
for (struct source_file *sf = files_head; sf; sf = sf->next)
|
|
{
|
|
size_t fn_len = strlen (sf->filename);
|
|
|
|
sf->string_pos = ptr - start;
|
|
|
|
memcpy(ptr, sf->filename, fn_len + 1);
|
|
ptr += fn_len + 1;
|
|
}
|
|
|
|
memset (ptr, 0, padding);
|
|
}
|
|
|
|
/* Write the DEBUG_S_FILECHKSMS subsection. */
|
|
static void
|
|
write_checksums (void)
|
|
{
|
|
uint32_t len;
|
|
char *ptr;
|
|
|
|
len = FILE_ENTRY_LENGTH * num_source_files;
|
|
|
|
ptr = frag_more (sizeof (uint32_t) + sizeof (uint32_t) + len);
|
|
|
|
bfd_putl32 (DEBUG_S_FILECHKSMS, ptr);
|
|
ptr += sizeof (uint32_t);
|
|
bfd_putl32 (len, ptr);
|
|
ptr += sizeof (uint32_t);
|
|
|
|
for (struct source_file *sf = files_head; sf; sf = sf->next)
|
|
{
|
|
struct file_checksum fc;
|
|
|
|
fc.file_id = sf->string_pos;
|
|
fc.checksum_length = NUM_MD5_BYTES;
|
|
fc.checksum_type = CHKSUM_TYPE_MD5;
|
|
|
|
memcpy (ptr, &fc, sizeof (struct file_checksum));
|
|
ptr += sizeof (struct file_checksum);
|
|
|
|
memcpy (ptr, sf->md5, NUM_MD5_BYTES);
|
|
ptr += NUM_MD5_BYTES;
|
|
|
|
memset (ptr, 0, FILE_ENTRY_PADDING);
|
|
ptr += FILE_ENTRY_PADDING;
|
|
}
|
|
}
|
|
|
|
/* Write the DEBUG_S_LINES subsection. */
|
|
static void
|
|
write_lines_info (void)
|
|
{
|
|
while (blocks_head)
|
|
{
|
|
struct line_block *lb;
|
|
struct line_file *lf;
|
|
uint32_t len;
|
|
uint32_t off;
|
|
char *ptr;
|
|
|
|
lb = blocks_head;
|
|
|
|
bfd_putl32 (DEBUG_S_LINES, frag_more (sizeof (uint32_t)));
|
|
|
|
len = sizeof (struct cv_lines_header);
|
|
|
|
for (lf = lb->files_head; lf; lf = lf->next)
|
|
{
|
|
len += sizeof (struct cv_lines_block);
|
|
len += sizeof (struct cv_line) * lf->num_lines;
|
|
}
|
|
|
|
bfd_putl32 (len, frag_more (sizeof (uint32_t)));
|
|
|
|
/* Write the header (struct cv_lines_header). We can't use a struct
|
|
for this as we're also emitting relocations. */
|
|
|
|
emit_secrel32_reloc (lb->sym);
|
|
emit_secidx_reloc (lb->sym);
|
|
|
|
ptr = frag_more (len - sizeof (uint32_t) - sizeof (uint16_t));
|
|
|
|
/* Flags */
|
|
bfd_putl16 (0, ptr);
|
|
ptr += sizeof (uint16_t);
|
|
|
|
off = lb->files_head->lines_head->frag_offset;
|
|
|
|
/* Length of region */
|
|
bfd_putl32 (get_frag_fix (lb->frag, lb->seg) - off, ptr);
|
|
ptr += sizeof (uint32_t);
|
|
|
|
while (lb->files_head)
|
|
{
|
|
struct cv_lines_block *block = (struct cv_lines_block *) ptr;
|
|
|
|
lf = lb->files_head;
|
|
|
|
bfd_putl32(lf->fileno * FILE_ENTRY_LENGTH, &block->file_id);
|
|
bfd_putl32(lf->num_lines, &block->num_lines);
|
|
bfd_putl32(sizeof (struct cv_lines_block)
|
|
+ (sizeof (struct cv_line) * lf->num_lines),
|
|
&block->length);
|
|
|
|
ptr += sizeof (struct cv_lines_block);
|
|
|
|
while (lf->lines_head)
|
|
{
|
|
struct line *l;
|
|
struct cv_line *l2 = (struct cv_line *) ptr;
|
|
|
|
l = lf->lines_head;
|
|
|
|
/* Only the bottom 24 bits of line_no actually encode the
|
|
line number. The top bit is a flag meaning "is
|
|
a statement". */
|
|
|
|
bfd_putl32 (l->frag_offset - off, &l2->offset);
|
|
bfd_putl32 (0x80000000 | (l->lineno & 0xffffff),
|
|
&l2->line_no);
|
|
|
|
lf->lines_head = l->next;
|
|
|
|
free(l);
|
|
|
|
ptr += sizeof (struct cv_line);
|
|
}
|
|
|
|
lb->files_head = lf->next;
|
|
free (lf);
|
|
}
|
|
|
|
blocks_head = lb->next;
|
|
|
|
free (lb);
|
|
}
|
|
}
|
|
|
|
/* Return the CodeView constant for the selected architecture. */
|
|
static uint16_t
|
|
target_processor (void)
|
|
{
|
|
switch (stdoutput->arch_info->arch)
|
|
{
|
|
case bfd_arch_i386:
|
|
if (stdoutput->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;
|
|
}
|
|
}
|
|
|
|
/* Write the CodeView symbols, describing the object name and
|
|
assembler version. */
|
|
static void
|
|
write_symbols_info (void)
|
|
{
|
|
static const char assembler[] = "GNU AS " VERSION;
|
|
|
|
char *path = lrealpath (out_file_name);
|
|
char *path2 = remap_debug_filename (path);
|
|
size_t path_len, padding;
|
|
uint32_t len;
|
|
struct OBJNAMESYM objname;
|
|
struct COMPILESYM3 compile3;
|
|
char *ptr;
|
|
|
|
free (path);
|
|
path = path2;
|
|
|
|
path_len = strlen (path);
|
|
|
|
len = sizeof (struct OBJNAMESYM) + path_len + 1;
|
|
len += sizeof (struct COMPILESYM3) + sizeof (assembler);
|
|
|
|
if (len % 4)
|
|
padding = 4 - (len % 4);
|
|
else
|
|
padding = 0;
|
|
|
|
len += padding;
|
|
|
|
ptr = frag_more (sizeof (uint32_t) + sizeof (uint32_t) + len);
|
|
|
|
bfd_putl32 (DEBUG_S_SYMBOLS, ptr);
|
|
ptr += sizeof (uint32_t);
|
|
bfd_putl32 (len, ptr);
|
|
ptr += sizeof (uint32_t);
|
|
|
|
/* Write S_OBJNAME entry. */
|
|
|
|
bfd_putl16 (sizeof (struct OBJNAMESYM) - sizeof (uint16_t) + path_len + 1,
|
|
&objname.length);
|
|
bfd_putl16 (S_OBJNAME, &objname.type);
|
|
bfd_putl32 (0, &objname.signature);
|
|
|
|
memcpy (ptr, &objname, sizeof (struct OBJNAMESYM));
|
|
ptr += sizeof (struct OBJNAMESYM);
|
|
memcpy (ptr, path, path_len + 1);
|
|
ptr += path_len + 1;
|
|
|
|
free (path);
|
|
|
|
/* Write S_COMPILE3 entry. */
|
|
|
|
bfd_putl16 (sizeof (struct COMPILESYM3) - sizeof (uint16_t)
|
|
+ sizeof (assembler) + padding, &compile3.length);
|
|
bfd_putl16 (S_COMPILE3, &compile3.type);
|
|
bfd_putl32 (CV_CFL_MASM, &compile3.flags);
|
|
bfd_putl16 (target_processor (), &compile3.machine);
|
|
bfd_putl16 (0, &compile3.frontend_major);
|
|
bfd_putl16 (0, &compile3.frontend_minor);
|
|
bfd_putl16 (0, &compile3.frontend_build);
|
|
bfd_putl16 (0, &compile3.frontend_qfe);
|
|
bfd_putl16 (0, &compile3.backend_major);
|
|
bfd_putl16 (0, &compile3.backend_minor);
|
|
bfd_putl16 (0, &compile3.backend_build);
|
|
bfd_putl16 (0, &compile3.backend_qfe);
|
|
|
|
memcpy (ptr, &compile3, sizeof (struct COMPILESYM3));
|
|
ptr += sizeof (struct COMPILESYM3);
|
|
memcpy (ptr, assembler, sizeof (assembler));
|
|
ptr += sizeof (assembler);
|
|
|
|
memset (ptr, 0, padding);
|
|
}
|
|
|
|
/* Processing of the file has finished, emit the .debug$S section. */
|
|
void
|
|
codeview_finish (void)
|
|
{
|
|
segT seg;
|
|
|
|
if (!blocks_head)
|
|
return;
|
|
|
|
seg = subseg_new (".debug$S", 0);
|
|
|
|
bfd_set_section_flags (seg, SEC_READONLY | SEC_NEVER_LOAD);
|
|
|
|
bfd_putl32 (CV_SIGNATURE_C13, frag_more (sizeof (uint32_t)));
|
|
|
|
write_string_table ();
|
|
write_checksums ();
|
|
write_lines_info ();
|
|
write_symbols_info ();
|
|
}
|
|
|
|
/* Assign a new index number for the given file, or return the existing
|
|
one if already assigned. */
|
|
static unsigned int
|
|
get_fileno (const char *file)
|
|
{
|
|
struct source_file *sf;
|
|
char *path = lrealpath (file);
|
|
char *path2 = remap_debug_filename (path);
|
|
size_t path_len;
|
|
FILE *f;
|
|
|
|
free (path);
|
|
path = path2;
|
|
|
|
path_len = strlen (path);
|
|
|
|
for (sf = files_head; sf; sf = sf->next)
|
|
{
|
|
if (path_len == strlen (sf->filename)
|
|
&& !filename_ncmp (sf->filename, path, path_len))
|
|
{
|
|
free (path);
|
|
return sf->num;
|
|
}
|
|
}
|
|
|
|
sf = xmalloc (sizeof (struct source_file));
|
|
|
|
sf->next = NULL;
|
|
sf->num = num_source_files;
|
|
sf->filename = path;
|
|
|
|
f = fopen (file, "r");
|
|
if (!f)
|
|
as_fatal (_("could not open %s for reading"), file);
|
|
|
|
if (md5_stream (f, sf->md5))
|
|
{
|
|
fclose(f);
|
|
as_fatal (_("md5_stream failed"));
|
|
}
|
|
|
|
fclose(f);
|
|
|
|
if (!files_head)
|
|
files_head = sf;
|
|
else
|
|
files_tail->next = sf;
|
|
|
|
files_tail = sf;
|
|
|
|
num_source_files++;
|
|
|
|
return num_source_files - 1;
|
|
}
|
|
|
|
/* Called for each new line in asm file. */
|
|
void
|
|
codeview_generate_asm_lineno (void)
|
|
{
|
|
const char *file;
|
|
unsigned int filenr;
|
|
unsigned int lineno;
|
|
struct line *l;
|
|
symbolS *sym = NULL;
|
|
struct line_block *lb;
|
|
struct line_file *lf;
|
|
|
|
file = as_where (&lineno);
|
|
|
|
filenr = get_fileno (file);
|
|
|
|
if (!blocks_tail || blocks_tail->frag != frag_now)
|
|
{
|
|
static int label_num = 0;
|
|
char name[32];
|
|
|
|
sprintf (name, ".Loc.%u", label_num);
|
|
label_num++;
|
|
sym = symbol_new (name, now_seg, frag_now, frag_now_fix ());
|
|
|
|
lb = xmalloc (sizeof (struct line_block));
|
|
lb->next = NULL;
|
|
lb->seg = now_seg;
|
|
lb->subseg = now_subseg;
|
|
lb->frag = frag_now;
|
|
lb->sym = sym;
|
|
lb->files_head = lb->files_tail = NULL;
|
|
|
|
if (!blocks_head)
|
|
blocks_head = lb;
|
|
else
|
|
blocks_tail->next = lb;
|
|
|
|
blocks_tail = lb;
|
|
}
|
|
else
|
|
{
|
|
lb = blocks_tail;
|
|
}
|
|
|
|
if (!lb->files_tail || lb->files_tail->fileno != filenr)
|
|
{
|
|
lf = xmalloc (sizeof (struct line_file));
|
|
lf->next = NULL;
|
|
lf->fileno = filenr;
|
|
lf->lines_head = lf->lines_tail = NULL;
|
|
lf->num_lines = 0;
|
|
|
|
if (!lb->files_head)
|
|
lb->files_head = lf;
|
|
else
|
|
lb->files_tail->next = lf;
|
|
|
|
lb->files_tail = lf;
|
|
}
|
|
else
|
|
{
|
|
lf = lb->files_tail;
|
|
}
|
|
|
|
l = xmalloc (sizeof (struct line));
|
|
l->next = NULL;
|
|
l->lineno = lineno;
|
|
l->frag_offset = frag_now_fix ();
|
|
|
|
if (!lf->lines_head)
|
|
lf->lines_head = l;
|
|
else
|
|
lf->lines_tail->next = l;
|
|
|
|
lf->lines_tail = l;
|
|
lf->num_lines++;
|
|
}
|
|
|
|
/* Output a compressed CodeView integer. The return value is the number of
|
|
bytes used. */
|
|
|
|
unsigned int
|
|
output_cv_comp (char *p, offsetT value, int sign)
|
|
{
|
|
char *orig = p;
|
|
|
|
if (sign)
|
|
{
|
|
if (value < -0xfffffff || value > 0xfffffff)
|
|
{
|
|
as_bad (_("value cannot be expressed as a .cv_scomp"));
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (value < 0 || value > 0x1fffffff)
|
|
{
|
|
as_bad (_("value cannot be expressed as a .cv_ucomp"));
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (sign)
|
|
{
|
|
if (value >= 0)
|
|
value <<= 1;
|
|
else
|
|
value = (-value << 1) | 1;
|
|
}
|
|
|
|
if (value <= 0x7f)
|
|
{
|
|
*p++ = value;
|
|
}
|
|
else if (value <= 0x3fff)
|
|
{
|
|
*p++ = 0x80 | (value >> 8);
|
|
*p++ = value & 0xff;
|
|
}
|
|
else
|
|
{
|
|
*p++ = 0xc0 | (value >> 24);
|
|
*p++ = (value >> 16) & 0xff;
|
|
*p++ = (value >> 8) & 0xff;
|
|
*p++ = value & 0xff;
|
|
}
|
|
|
|
return p - orig;
|
|
}
|
|
|
|
/* Return the size needed to output a compressed CodeView integer. */
|
|
|
|
unsigned int
|
|
sizeof_cv_comp (offsetT value, int sign)
|
|
{
|
|
if (sign)
|
|
{
|
|
if (value < -0xfffffff || value > 0xfffffff)
|
|
return 0;
|
|
|
|
if (value >= 0)
|
|
value <<= 1;
|
|
else
|
|
value = (-value << 1) | 1;
|
|
}
|
|
else
|
|
{
|
|
if (value > 0x1fffffff)
|
|
return 0;
|
|
}
|
|
|
|
if (value <= 0x7f)
|
|
return 1;
|
|
else if (value <= 0x3fff)
|
|
return 2;
|
|
else if (value <= 0x1fffffff)
|
|
return 4;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
#else
|
|
|
|
void
|
|
codeview_finish (void)
|
|
{
|
|
}
|
|
|
|
void
|
|
codeview_generate_asm_lineno (void)
|
|
{
|
|
}
|
|
|
|
#endif /* TE_PE && O_secrel */
|