/* 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++;
}

#else

void
codeview_finish (void)
{
}

void
codeview_generate_asm_lineno (void)
{
}

#endif /* TE_PE && O_secrel */

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.