/* listing.c - maintain assembly listings

   Copyright (C) 1991-2025 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.  */

/* Contributed by Steve Chamberlain <sac@cygnus.com>

 A listing page looks like:

 LISTING_HEADER  sourcefilename pagenumber

 TITLE LINE

 SUBTITLE LINE

 linenumber address data  source

 linenumber address data  source

 linenumber address data  source

 linenumber address data  source

 If not overridden, the listing commands are:

 .title  "stuff"

  Put "stuff" onto the title line

 .sbttl  "stuff"

        Put stuff onto the subtitle line

  If these commands come within 10 lines of the top of the page, they

  will affect the page they are on, as well as any subsequent page

 .eject

  Throw a page

 .list

  Increment the enable listing counter

 .nolist

  Decrement the enable listing counter

 .psize Y[,X]

  Set the paper size to X wide and Y high. Setting a psize Y of

  zero will suppress form feeds except where demanded by .eject

 If the counter goes below zero, listing is suppressed.

 Listings are a maintained by read calling various listing_<foo>

 functions.  What happens most is that the macro NO_LISTING is not

 defined (from the Makefile), then the macro LISTING_NEWLINE expands

 into a call to listing_newline.  The call is done from read.c, every

 time it sees a newline, and -l is on the command line.

 The function listing_newline remembers the frag associated with the

 newline, and creates a new frag - note that this is wasteful, but not

 a big deal, since listing slows things down a lot anyway.  The

 function also remembers when the filename changes.

 When all the input has finished, and gas has had a chance to settle

 down, the listing is output. This is done by running down the list of

 frag/source file records, and opening the files as needed and printing

 out the bytes and chars associated with them.

 The only things which the architecture can change about the listing

 are defined in these macros:

 LISTING_HEADER   The name of the architecture

 LISTING_WORD_SIZE      The make of the number of bytes in a word, this determines

      the clumping of the output data. eg a value of

      2 makes words look like 1234 5678, whilst 1

      would make the same value look like 12 34 56

      78

 LISTING_LHS_WIDTH      Number of words of above size for the lhs

 LISTING_LHS_WIDTH_SECOND   Number of words for the data on the lhs

      for the second line

 LISTING_LHS_CONT_LINES Max number of lines to use up for a continuation

 LISTING_RHS_WIDTH      Number of chars from the input file to print

                        on a line.  */

#include "as.h"

#include "filenames.h"

#include "safe-ctype.h"

#include "input-file.h"

#include "subsegs.h"

#include "bfdver.h"

#include <time.h>

#include <stdarg.h>

#ifndef NO_LISTING

#ifndef LISTING_HEADER

#define LISTING_HEADER "GAS LISTING"

#endif

#ifndef LISTING_WORD_SIZE

#define LISTING_WORD_SIZE 4

#endif

#ifndef LISTING_LHS_WIDTH

#define LISTING_LHS_WIDTH ((LISTING_WORD_SIZE) > 4 ? 1 : 4 / (LISTING_WORD_SIZE))

#endif

#ifndef LISTING_LHS_WIDTH_SECOND

#define LISTING_LHS_WIDTH_SECOND LISTING_LHS_WIDTH

#endif

#ifndef LISTING_RHS_WIDTH

#define LISTING_RHS_WIDTH 100

#endif

#ifndef LISTING_LHS_CONT_LINES

#define LISTING_LHS_CONT_LINES 4

#endif

#define MAX_DATELEN 30

/* This structure remembers which .s were used.  */

typedef struct file_info_struct

{

  struct file_info_struct * next;

  char *                    filename;

  long                      pos;

  unsigned int              linenum;

  int                       at_end;

} file_info_type;

enum edict_enum

{

  EDICT_NONE,

  EDICT_SBTTL,

  EDICT_TITLE,

  EDICT_NOLIST,

  EDICT_LIST,

  EDICT_NOLIST_NEXT,

  EDICT_EJECT

};

struct list_message

{

  char *message;

  struct list_message *next;

};

/* This structure remembers which line from which file goes into which

   frag.  */

struct list_info_struct

{

  /* Frag which this line of source is nearest to.  */

  fragS *frag;

  /* The actual line in the source file.  */

  unsigned int line;

  /* Pointer to the file info struct for the file which this line

     belongs to.  */

  file_info_type *file;

  /* The expanded text of any macro that may have been executing.  */

  char *line_contents;

  /* Next in list.  */

  struct list_info_struct *next;

  /* Pointer to the file info struct for the high level language

     source line that belongs here.  */

  file_info_type *hll_file;

  /* High level language source line.  */

  unsigned int hll_line;

  /* Pointers to linked list of messages associated with this line.  */

  struct list_message *messages, *last_message;

#ifdef OBJ_ELF

  /* Nonzero if this line is to be omitted because it contains

     debugging information.  This can become a flags field if we come

     up with more information to store here.  */

  bool debugging;

#endif

  enum edict_enum edict;

  char *edict_arg;

};

typedef struct list_info_struct list_info_type;

unsigned int listing_lhs_width        = LISTING_LHS_WIDTH;

unsigned int listing_lhs_width_second = LISTING_LHS_WIDTH_SECOND;

unsigned int listing_lhs_cont_lines   = LISTING_LHS_CONT_LINES;

unsigned int listing_rhs_width        = LISTING_RHS_WIDTH;

struct list_info_struct *        listing_tail;

static file_info_type *          file_info_head;

static file_info_type *          last_open_file_info;

static FILE *                    last_open_file;

static struct list_info_struct * head;

static unsigned int              paper_width = 200;

static unsigned int              paper_height = 60;

extern int                       listing;

/* File to output listings to.  */

static FILE *list_file;

/* This static array is used to keep the text of data to be printed

   before the start of the line.  */

#define MAX_BYTES             \

  (((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width      \

   + ((((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width_second)  \

      * listing_lhs_cont_lines)           \

   + 20)

static char *data_buffer;

static void

listing_message (const char *name, const char *message)

{

  if (listing_tail != (list_info_type *) NULL)

    {

      char *n = concat (name, message, (char *) NULL);

      struct list_message *lm = XNEW (struct list_message);

      lm->message = n;

      lm->next = NULL;

      if (listing_tail->last_message)

  listing_tail->last_message->next = lm;

      else

  listing_tail->messages = lm;

      listing_tail->last_message = lm;

    }

}

void

listing_warning (const char *message)

{

  listing_message (_("Warning: "), message);

}

void

listing_error (const char *message)

{

  listing_message (_("Error: "), message);

}

static file_info_type *

file_info (const char *file_name)

{

  /* Find an entry with this file name.  */

  file_info_type *p = file_info_head;

  while (p != (file_info_type *) NULL)

    {

      if (filename_cmp (p->filename, file_name) == 0)

  return p;

      p = p->next;

    }

  /* Make new entry.  */

  p = XNEW (file_info_type);

  p->next = file_info_head;

  file_info_head = p;

  p->filename = xstrdup (file_name);

  p->pos = 0;

  p->linenum = 0;

  p->at_end = 0;

  return p;

}

static void

new_frag (void)

{

  frag_wane (frag_now);

  frag_new (0);

}

void

listing_newline (char *ps)

{

  const char *file;

  unsigned int line;

  static unsigned int last_line = 0xffff;

  static const char *last_file = NULL;

  list_info_type *new_i = NULL;

  if (listing == 0)

    return;

  if (now_seg == absolute_section)

    return;

#ifdef OBJ_ELF

  /* In ELF, anything in a section beginning with .debug or .line is

     considered to be debugging information.  This includes the

     statement which switches us into the debugging section, which we

     can only set after we are already in the debugging section.  */

  if (IS_ELF

      && (listing & LISTING_NODEBUG) != 0

      && listing_tail != NULL

      && ! listing_tail->debugging)

    {

      const char *segname;

      segname = segment_name (now_seg);

      if (startswith (segname, ".debug")

    || startswith (segname, ".line"))

  listing_tail->debugging = true;

    }

#endif

  /* PR 21977 - use the physical file name not the logical one unless high

     level source files are being included in the listing.  */

  if (listing & LISTING_HLL)

    file = as_where (&line);

  else

    file = as_where_physical (&line);

  if (ps == NULL)

    {

      if (line == last_line

    && !(last_file && file && filename_cmp (file, last_file)))

  return;

      new_i = XNEW (list_info_type);

      /* Detect if we are reading from stdin by examining the file

   name returned by as_where().

   [FIXME: We rely upon the name in the strcmp below being the

   same as the one used by input_scrub_new_file(), if that is

   not true, then this code will fail].

   If we are reading from stdin, then we need to save each input

   line here (assuming of course that we actually have a line of

   input to read), so that it can be displayed in the listing

   that is produced at the end of the assembly.  */

      if (strcmp (file, _("{standard input}")) == 0

    && input_line_pointer != NULL)

  {

    char *copy, *src, *dest;

    int len;

    int seen_quote = 0;

    int seen_slash = 0;

    for (copy = input_line_pointer;

         seen_quote ? *copy : !is_end_of_line (*copy);

         copy++)

      {

        if (seen_slash)

    seen_slash = 0;

        else if (*copy == '\\')

    seen_slash = 1;

        else if (*copy == '"')

    seen_quote = !seen_quote;

      }

    len = copy - input_line_pointer + 1;

    copy = XNEWVEC (char, len);

    src = input_line_pointer;

    dest = copy;

    while (--len)

      {

        unsigned char c = *src++;

        /* Omit control characters in the listing.  */

        if (!ISCNTRL (c))

    *dest++ = c;

      }

    *dest = 0;

    new_i->line_contents = copy;

  }

      else

  new_i->line_contents = NULL;

    }

  else

    {

      new_i = XNEW (list_info_type);

      new_i->line_contents = ps;

    }

  last_line = line;

  last_file = file;

  new_frag ();

  if (listing_tail)

    listing_tail->next = new_i;

  else

    head = new_i;

  listing_tail = new_i;

  new_i->frag = frag_now;

  new_i->line = line;

  new_i->file = file_info (file);

  new_i->next = (list_info_type *) NULL;

  new_i->messages = NULL;

  new_i->last_message = NULL;

  new_i->edict = EDICT_NONE;

  new_i->hll_file = (file_info_type *) NULL;

  new_i->hll_line = 0;

  new_frag ();

#ifdef OBJ_ELF

  /* In ELF, anything in a section beginning with .debug or .line is

     considered to be debugging information.  */

  new_i->debugging = false;

  if ((listing & LISTING_NODEBUG) != 0)

    {

      const char *segname;

      segname = segment_name (now_seg);

      if (startswith (segname, ".debug")

    || startswith (segname, ".line"))

  new_i->debugging = true;

    }

#endif

}

/* Set listing context back to where it was when input was parsed, to allow

   associating late code/data emission to segments with their origin.  */

struct list_info_struct *listing_override_tail (struct list_info_struct *info)

{

  struct list_info_struct *prev = listing_tail;

  const fragS *frag;

  if (!info)

    return NULL;

  listing_tail = info;

  /* The first frag created by listing_newline() is still associated with the

     earlier line.  For the adjustment done below this property doesn't hold,

     though.  */

  frag = info->frag;

  if (frag->line != info)

    frag = frag->fr_next;

  /* Check whether there's any other output data already for this line.  Replace

     info->frag only if there's none.  This is to cover for contributions to

     multiple sections from a single line not being properly represented in the

     listing, at the time of writing.  Prefer the listing to show any "ordinary"

     code/data contributions over any .eh_frame ones.  (This way multiple .cfi_*

     on a single line will also have all their contributions listed, rather

     than just those from the last such directive.)  */

  for (; frag; frag = frag->fr_next)

    if (frag->line != info

  || (frag->fr_type != rs_dummy

      && (frag->fr_type != rs_fill

    || frag->fr_fix

    || (frag->fr_var && frag->fr_offset))))

      break;

  if (!frag || frag->line != info)

    {

      new_frag ();

      info->frag = frag_now;

      new_frag ();

    }

  return prev;

}

/* Attach all current frags to the previous line instead of the

   current line.  This is called by the MIPS backend when it discovers

   that it needs to add some NOP instructions; the added NOP

   instructions should go with the instruction that has the delay, not

   with the new instruction.  */

void

listing_prev_line (void)

{

  list_info_type *l;

  fragS *f;

  if (head == (list_info_type *) NULL

      || head == listing_tail)

    return;

  new_frag ();

  for (l = head; l->next != listing_tail; l = l->next)

    ;

  for (f = frchain_now->frch_root; f != (fragS *) NULL; f = f->fr_next)

    if (f->line == listing_tail)

      f->line = l;

  listing_tail->frag = frag_now;

  new_frag ();

}

/* This function returns the next source line from the file supplied,

   truncated to size.  It appends a fake line to the end of each input

   file to make using the returned buffer simpler.  */

static const char *

buffer_line (file_info_type *file, char *line, unsigned int size)

{

  unsigned int count = 0;

  int c;

  char *p = line;

  /* If we couldn't open the file, return an empty line.  */

  if (file->at_end)

    return "";

  /* Check the cache and see if we last used this file.  */

  if (!last_open_file_info || file != last_open_file_info)

    {

      if (last_open_file)

  {

    last_open_file_info->pos = ftell (last_open_file);

    fclose (last_open_file);

  }

      /* Open the file in the binary mode so that ftell above can

   return a reliable value that we can feed to fseek below.  */

      last_open_file_info = file;

      last_open_file = fopen (file->filename, FOPEN_RB);

      if (last_open_file == NULL)

  {

    file->at_end = 1;

    return "";

  }

      /* Seek to where we were last time this file was open.  */

      if (file->pos)

  fseek (last_open_file, file->pos, SEEK_SET);

    }

  c = fgetc (last_open_file);

  while (c != EOF && c != '\n' && c != '\r')

    {

      if (++count < size)

  *p++ = c;

      c = fgetc (last_open_file);

    }

  /* If '\r' is followed by '\n', swallow that.  Likewise, if '\n'

     is followed by '\r', swallow that as well.  */

  if (c == '\r' || c == '\n')

    {

      int next = fgetc (last_open_file);

      if ((c == '\r' && next != '\n')

    || (c == '\n' && next != '\r'))

  ungetc (next, last_open_file);

    }

  if (c == EOF)

    {

      file->at_end = 1;

      if (count + 3 < size)

  {

    *p++ = '.';

    *p++ = '.';

    *p++ = '.';

  }

    }

  file->linenum++;

  *p++ = 0;

  return line;

}

/* This function rewinds the requested file back to the line requested,

   reads it in again into the buffer provided and then restores the file

   back to its original location.  */

static void

rebuffer_line (file_info_type *  file,

         unsigned int      linenum,

         char *            buffer,

         unsigned int      size)

{

  unsigned int count = 0;

  unsigned int current_line;

  char * p = buffer;

  long pos;

  long pos2;

  int c;

  bool found = false;

  /* Sanity checks.  */

  if (file == NULL || buffer == NULL || size <= 1 || file->linenum <= linenum)

    return;

  /* Check the cache and see if we last used this file.  */

  if (last_open_file_info == NULL || file != last_open_file_info)

    {

      if (last_open_file)

  {

    last_open_file_info->pos = ftell (last_open_file);

    fclose (last_open_file);

  }

      /* Open the file in the binary mode so that ftell above can

   return a reliable value that we can feed to fseek below.  */

      last_open_file_info = file;

      last_open_file = fopen (file->filename, FOPEN_RB);

      if (last_open_file == NULL)

  {

    file->at_end = 1;

    return;

  }

      /* Seek to where we were last time this file was open.  */

      if (file->pos)

  fseek (last_open_file, file->pos, SEEK_SET);

    }

  /* Remember where we are in the current file.  */

  pos2 = pos = ftell (last_open_file);

  if (pos < 3)

    return;

  current_line = file->linenum;

  /* Leave room for the nul at the end of the buffer.  */

  size -= 1;

  buffer[size] = 0;

  /* Increment the current line count by one.

     This is to allow for the fact that we are searching for the

     start of a previous line, but we do this by detecting end-of-line

     character(s) not start-of-line characters.  */

  ++ current_line;

  while (pos2 > 0 && ! found)

    {

      char * ptr;

      /* Move backwards through the file, looking for earlier lines.  */

      pos2 = (long) size > pos2 ? 0 : pos2 - size;

      fseek (last_open_file, pos2, SEEK_SET);

      /* Our caller has kindly provided us with a buffer, so we use it.  */

      if (fread (buffer, 1, size, last_open_file) != size)

  {

    as_warn (_("unable to rebuffer file: %s\n"), file->filename);

    return;

  }

      for (ptr = buffer + size; ptr >= buffer; -- ptr)

  {

    if (*ptr == '\n')

      {

        -- current_line;

        if (current_line == linenum)

    {

      /* We have found the start of the line we seek.  */

      found = true;

      /* FIXME: We could skip the read-in-the-line code

         below if we know that we already have the whole

         line in the buffer.  */

      /* Advance pos2 to the newline character we have just located.  */

      pos2 += (ptr - buffer);

      /* Skip the newline and, if present, the carriage return.  */

      if (ptr + 1 == buffer + size)

        {

          ++pos2;

          if (fgetc (last_open_file) == '\r')

      ++ pos2;

        }

      else

        pos2 += (ptr[1] == '\r' ? 2 : 1);

      /* Move the file pointer to this location.  */

      fseek (last_open_file, pos2, SEEK_SET);

      break;

    }

      }

  }

    }

  /* Read in the line.  */

  c = fgetc (last_open_file);

  while (c != EOF && c != '\n' && c != '\r')

    {

      if (count < size)

  *p++ = c;

      count++;

      c = fgetc (last_open_file);

    }

  /* If '\r' is followed by '\n', swallow that.  Likewise, if '\n'

     is followed by '\r', swallow that as well.  */

  if (c == '\r' || c == '\n')

    {

      int next = fgetc (last_open_file);

      if ((c == '\r' && next != '\n')

    || (c == '\n' && next != '\r'))

  ungetc (next, last_open_file);

    }

  /* Terminate the line.  */

  *p++ = 0;

  /* Reset the file position.  */

  fseek (last_open_file, pos, SEEK_SET);

}

static const char *fn;

static unsigned int eject;  /* Eject pending.  */

static unsigned int page; /* Current page number.  */

static const char *title; /* Current title.  */

static const char *subtitle;  /* Current subtitle.  */

static unsigned int on_page;  /* Number of lines printed on current page.  */

static void

listing_page (list_info_type *list)

{

  /* Grope around, see if we can see a title or subtitle edict coming up

     soon.  (we look down 10 lines of the page and see if it's there)  */

  if ((eject || (on_page >= paper_height))

      && paper_height != 0)

    {

      unsigned int c = 10;

      int had_title = 0;

      int had_subtitle = 0;

      page++;

      while (c != 0 && list)

  {

    if (list->edict == EDICT_SBTTL && !had_subtitle)

      {

        had_subtitle = 1;

        subtitle = list->edict_arg;

      }

    if (list->edict == EDICT_TITLE && !had_title)

      {

        had_title = 1;

        title = list->edict_arg;

      }

    list = list->next;

    c--;

  }

      if (page > 1)

  {

    fprintf (list_file, "\f");

  }

      fprintf (list_file, "%s %s \t\t\tpage %d\n", LISTING_HEADER, fn, page);

      fprintf (list_file, "%s\n", title);

      fprintf (list_file, "%s\n", subtitle);

      on_page = 3;

      eject = 0;

    }

}

/* Print a line into the list_file.  Update the line count

   and if necessary start a new page.  */

static void

emit_line (list_info_type * list, const char * format, ...)

{

  va_list args;

  va_start (args, format);

  vfprintf (list_file, format, args);

  on_page++;

  listing_page (list);

  va_end (args);

}

static unsigned int

calc_hex (list_info_type *list)

{

  size_t data_buffer_size;

  list_info_type *first = list;

  unsigned int address = ~(unsigned int) 0;

  fragS *frag;

  fragS *frag_ptr;

  unsigned int octet_in_frag;

  /* Find first frag which says it belongs to this line.  */

  frag = list->frag;

  while (frag && frag->line != list)

    frag = frag->fr_next;

  frag_ptr = frag;

  data_buffer_size = 0;

  /* Dump all the frags which belong to this line.  */

  while (frag_ptr != (fragS *) NULL && frag_ptr->line == first)

    {

      /* Print as many bytes from the fixed part as is sensible.  */

      octet_in_frag = 0;

      while (octet_in_frag < frag_ptr->fr_fix

       && data_buffer_size < MAX_BYTES - 3)

  {

    if (address == ~(unsigned int) 0)

      address = frag_ptr->fr_address / OCTETS_PER_BYTE;

    sprintf (data_buffer + data_buffer_size,

       "%02X",

       (frag_ptr->fr_literal[octet_in_frag]) & 0xff);

    data_buffer_size += 2;

    octet_in_frag++;

  }

      if (frag_ptr->fr_type == rs_fill || frag_ptr->fr_type == rs_fill_nop)

  {

    unsigned int var_rep_max = octet_in_frag;

    unsigned int var_rep_idx = octet_in_frag;

    /* Print as many bytes from the variable part as is sensible.  */

    while ((octet_in_frag

      < frag_ptr->fr_fix + frag_ptr->fr_var * frag_ptr->fr_offset)

     && data_buffer_size < MAX_BYTES - 3)

      {

        if (address == ~(unsigned int) 0)

    address = frag_ptr->fr_address / OCTETS_PER_BYTE;

        sprintf (data_buffer + data_buffer_size,

           "%02X",

           (frag_ptr->fr_literal[var_rep_idx]) & 0xff);

        data_buffer_size += 2;

        var_rep_idx++;

        octet_in_frag++;

        if (var_rep_idx >= frag_ptr->fr_fix + frag_ptr->fr_var)

    var_rep_idx = var_rep_max;

      }

  }

      frag_ptr = frag_ptr->fr_next;

    }

  data_buffer[data_buffer_size] = '\0';

  return address;

}

static void

print_lines (list_info_type *list, unsigned int lineno,

       const char *string, unsigned int address)

{

  unsigned int idx;

  unsigned int nchars;

  unsigned int lines;

  unsigned int octet_in_word = 0;

  char *src = data_buffer;

  int cur;

  struct list_message *msg;

  /* Print the stuff on the first line.  */

  listing_page (list);

  nchars = (LISTING_WORD_SIZE * 2 + 1) * listing_lhs_width;

  /* Print the hex for the first line.  */

  if (address == ~(unsigned int) 0)

    {

      fprintf (list_file, "% 4d     ", lineno);

      for (idx = 0; idx < nchars; idx++)

  fprintf (list_file, " ");

      emit_line (NULL, "\t%s\n", string ? string : "");

      return;

    }

  if (had_errors ())

    fprintf (list_file, "% 4d ???? ", lineno);

  else

    fprintf (list_file, "% 4d %04x ", lineno, address);

  /* And the data to go along with it.  */

  idx = 0;

  cur = 0;

  while (src[cur] && idx < nchars)

    {

      int offset;

      offset = cur;

      fprintf (list_file, "%c%c", src[offset], src[offset + 1]);

      cur += 2;

      octet_in_word++;

      if (octet_in_word == LISTING_WORD_SIZE)

  {

    fprintf (list_file, " ");

    idx++;

    octet_in_word = 0;

  }

      idx += 2;

    }

  for (; idx < nchars; idx++)

    fprintf (list_file, " ");

  emit_line (list, "\t%s\n", string ? string : "");

  for (msg = list->messages; msg; msg = msg->next)

    emit_line (list, "****  %s\n", msg->message);

  for (lines = 0;

       lines < listing_lhs_cont_lines

   && src[cur];

       lines++)

    {

      nchars = ((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width_second - 1;

      idx = 0;