mirrors/binutils-gdb
0
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-11-28 12:33:36 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

* as.c: change -l to -a[lsn], to avoid conflict with 68000

Browse Source 
command line option.

	* listing.h, listing.c: now prints addresses with ??? instead of 0 when
	errors in assemble prevent addresses being known. Prints
	symbol table more tidily. Allows different parts of the
	listing to be selected.
This commit is contained in:
Steve Chamberlain 1992-01-21 22:14:16 +00:00
parent 7316c642a3
commit 5d9f0ecf62
5 changed files with 1727 additions and 412 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
gas/as.c
View File

@ -5,7 +5,7 @@ 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 1, or (at your option)
the Free Software Foundation; either version 2, or (at your option)
any later version.
GAS is distributed in the hope that it will be useful,
@ -45,7 +45,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#define COMMON
#include "as.h"
#include "subsegs.h"
#ifdef __STDC__
/* This prototype for got_sig() is ansi. If you want
@ -77,6 +77,8 @@ static char * gdb_symbol_file_name;
long gdb_begin();
#endif
int listing; /* true if a listing is wanted */
char *myname; /* argv[0] */
extern char version_string[];
@ -139,10 +141,42 @@ char **argv;
while ((a = * arg) != '\0') {/* scan all the 1-char flags */
arg ++; /* arg->after letter. */
a &= 0x7F; /* ascii only please */
if (flagseen[a])
as_tsktsk("%s: Flag option - %c has already been seen.", myname, a);
/* if (flagseen[a])
as_tsktsk("%s: Flag option - %c has already been seen.", myname, a); */
flagseen[a] = 1;
switch (a) {
case 'a':
{
int loop =1;
while (loop) {
switch (*arg)
{
case 'l':
listing |= LISTING_LISTING;
arg++;
break;
case 's':
listing |= LISTING_SYMBOLS;
arg++;
break;
case 'n':
listing |= LISTING_NOFORM;
arg++;
break;
default:
if (!listing)
listing= LISTING_DEFAULT;
loop = 0;
break;
}
}
}
break;
case 'f':
break; /* -f means fast - no need for "app" preprocessor. */
@ -167,7 +201,7 @@ char **argv;
case 'I': { /* Include file directory */
char *temp;
char *temp = NULL;
if (*arg)
temp = stralloc (arg);
else if (work_argc) {
@ -264,6 +298,10 @@ char **argv;
input_scrub_end();
md_end(); /* MACHINE.c */
#ifndef NO_LISTING
listing_print();
#endif
#ifndef VMS
return((had_warnings() && flagseen['Z'])
|| had_errors() > 0); /* WIN */
@ -290,26 +328,43 @@ static void perform_an_assembly_pass(argc, argv)
int argc;
char **argv;
{
int saw_a_file = 0;
int saw_a_file = 0;
unsigned int i;
need_pass_2 = 0;
text_fix_root = NULL;
data_fix_root = NULL;
need_pass_2 = 0;
#ifdef MANY_SEGMENTS
subseg_new (SEG_TEXT, 0);
for (i= SEG_E0; i < SEG_UNKNOWN; i++)
{
segment_info[i].fix_root = 0;
}
/* Create the three fixed ones */
subseg_new (SEG_E0, 0);
subseg_new (SEG_E1, 0);
subseg_new (SEG_E2, 0);
strcpy(segment_info[SEG_E0].scnhdr.s_name,".text");
strcpy(segment_info[SEG_E1].scnhdr.s_name,".data");
strcpy(segment_info[SEG_E2].scnhdr.s_name,".bss");
subseg_new (SEG_E0, 0);
#else
text_fix_root = NULL;
data_fix_root = NULL;
argv++; /* skip argv[0] */
argc--; /* skip argv[0] */
while (argc--) {
if (*argv) { /* Is it a file-name argument? */
saw_a_file++;
/* argv->"" if stdin desired, else->filename */
read_a_source_file(*argv);
}
argv++; /* completed that argv */
}
if(!saw_a_file)
read_a_source_file("");
subseg_new (SEG_TEXT, 0);
#endif
argv++; /* skip argv[0] */
argc--; /* skip argv[0] */
while (argc--) {
if (*argv) { /* Is it a file-name argument? */
saw_a_file++;
/* argv->"" if stdin desired, else->filename */
read_a_source_file(*argv);
}
argv++; /* completed that argv */
}
if(!saw_a_file)
read_a_source_file("");
} /* perform_an_assembly_pass() */
/*

6
gas/config/ho-sunos.h
View File

@ -9,7 +9,7 @@
#else
extern int memset();
#endif
#include <stddef.h>
#include <ctype.h>
#include <string.h>
@ -21,11 +21,11 @@ extern char *realloc();
extern char *strrchr();
extern int _filbuf();
extern int _flsbuf();
extern int abort();
/*extern int abort();*/
extern int bcopy();
extern int bzero();
extern int bzero();
extern int exit();
/*extern int exit();*/
extern int fclose();
extern int fprintf();
extern int fread();

1193
gas/config/tc-h8300.c
View File

File diff suppressed because it is too large Load Diff

821
gas/listing.c Normal file
View File

@ -0,0 +1,821 @@
/* listing.c - mainting assembly listings
Copyright (C) 1991, 1992 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 2, 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, 675 Mass Ave, Cambridge, MA 02139, 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
Thow 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 rememebers 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 continutation
LISTING_RHS_WIDTH Number of chars from the input file to print
on a line
*/
#include "as.h"
#include <obstack.h>
#include "input-file.h"
#include "targ-cpu.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 1
#endif
#ifndef LISTING_LHS_WIDTH_SECOND
#define LISTING_LHS_WIDTH_SECOND 1
#endif
#ifndef LISTING_RHS_WIDTH
#define LISTING_RHS_WIDTH 100
#endif
#ifndef LISTING_LHS_CONT_LINES
#define LISTING_LHS_CONT_LINES 4
#endif
/* This structure remembers which files were used */
typedef struct file_info_struct
{
char *filename;
int linenum;
FILE *file;
struct file_info_struct *next;
} file_info_type ;
/* this structure rememebrs which line from which file goes into which
frag */
typedef 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;
/* Next in list */
struct list_info_struct *next;
/* Pointer to any error message associated with this line */
char *message;
enum
{
EDICT_NONE,
EDICT_SBTTL,
EDICT_TITLE,
EDICT_NOLIST,
EDICT_LIST,
EDICT_EJECT
} edict;
char *edict_arg;
} list_info_type;
static struct list_info_struct *head;
struct list_info_struct *listing_tail;
extern int listing;
extern unsigned int physical_input_line;
extern fragS *frag_now;
static int paper_width = 200;
static int paper_height = 60;
/* this static array is used to keep the text of data to be printed
before the start of the line.
It is stored so we can give a bit more info on the next line. To much, and large
initialized arrays will use up lots of paper.
*/
static char data_buffer[100];
static unsigned int data_buffer_size;
static void
DEFUN(listing_message,(name, message),
char *name AND
char *message)
{
unsigned int l = strlen(name) + strlen(message)+1;
char *n = malloc(l);
strcpy(n,name);
strcat(n,message);
if(listing_tail != (list_info_type *)NULL)
{
listing_tail->message = n;
}
}
void
DEFUN(listing_warning,(message),
char *message)
{
listing_message("Warning:", message);
}
void
DEFUN(listing_error,(message),
char *message)
{
listing_message("Error:", message);
}
extern char *file_name;
static file_info_type *file_info_head;
static file_info_type *
DEFUN_VOID(file_info)
{
/* Find an entry with this file name */
file_info_type *p = file_info_head;
while (p != (file_info_type *)NULL)
{
if (strcmp(p->filename, file_name) == 0)
return p;
p = p->next;
}
/* Make new entry */
p = (file_info_type *)xmalloc(sizeof(file_info_type));
p->next = file_info_head;
file_info_head = p;
p->filename = xmalloc(strlen(file_name)+1);
strcpy(p->filename, file_name);
p->linenum = 0;
p->file = fopen(p->filename,"r");
return p;
}
void
DEFUN(listing_newline,(ps),
char *ps)
{
char *s = ps;
static unsigned int last_line =0xffff ;
list_info_type *new;
if (physical_input_line != last_line)
{
last_line = physical_input_line;
frag_wane(frag_now);
frag_new(0);
new = (list_info_type *)malloc(sizeof(list_info_type));
new->frag = frag_now;
new->line = physical_input_line ;
new->file = file_info();
if (listing_tail)
{
listing_tail->next = new;
}
else
{
head = new;
}
listing_tail = new;
new->next = (list_info_type *)NULL;
new->message = (char *)NULL;
new->edict = EDICT_NONE;
frag_wane(frag_now);
frag_new(0);
}
}
static char *
DEFUN(buffer_line,(ptr,line, size),
list_info_type *ptr AND
char *line AND
unsigned int size)
{
unsigned int count = 0;
char *p = line;
int c = fgetc(ptr->file->file);
size -= 1; /* leave room for null */
while (c != EOF && c != '\n')
{
if (count < size)
*p++ = c;
count++;
c= fgetc(ptr->file->file);
}
if (c == EOF)
{
rewind(ptr->file->file);
}
*p++ = 0;
return line;
}
static char *fn;
static unsigned int eject; /* Eject pending */
static unsigned int page; /* Current page number */
static char *title; /* current title */
static char *subtitle; /* current subtitle */
static unsigned int on_page; /* number of lines printed on current page */
static void
DEFUN(listing_page,(list),
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)
{
printf("\f");
}
printf("%s %s \t\t\tpage %d\n", LISTING_HEADER, fn, page);
printf("%s\n", title);
printf("%s\n", subtitle);
on_page = 3;
eject = 0;
}
}
static unsigned int
DEFUN(calc_hex,(list),
list_info_type *list)
{
list_info_type *first = list;
list_info_type *last = first;
unsigned int address = ~0;
fragS *frag;
fragS *frag_ptr;
unsigned int byte_in_frag = 0;
int anything = 0;
/* 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 */
while(byte_in_frag < frag_ptr->fr_fix && data_buffer_size < sizeof(data_buffer)-10)
{
if (address == ~0)
{
address = frag_ptr->fr_address;
}
sprintf(data_buffer + data_buffer_size, "%02X",(frag_ptr->fr_literal[byte_in_frag]) & 0xff);
data_buffer_size += 2;
byte_in_frag++;
}
/* Print as many bytes from the variable part as is sensible */
while (byte_in_frag < frag_ptr->fr_var * frag_ptr->fr_offset
&& data_buffer_size < sizeof(data_buffer)-10)
{
if (address == ~0)
{
address = frag_ptr->fr_address;
}
data_buffer[data_buffer_size++] = '*';
data_buffer[data_buffer_size++] = '*';
byte_in_frag++;
}
frag_ptr = frag_ptr->fr_next;
}
data_buffer[data_buffer_size++] = 0;
return address;
}
static void
DEFUN(print_lines,(list, string, address),
list_info_type *list AND
char *string AND
unsigned int address)
{
unsigned int idx;
unsigned int nchars;
unsigned int lines;
unsigned int byte_in_word =0;
char *src = data_buffer;
/* 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 == ~0)
{
printf("% 4d ", list->line);
for (idx = 0; idx < nchars; idx++)
printf(" ");
printf("\t%s\n", string ? string : "");
on_page++;
listing_page(0);
}
else
{
if (had_errors())
{
printf("% 4d ???? ", list->line);
}
else
{
printf("% 4d %04x ", list->line, address);
}
/* And the data to go along with it */
idx = 0;
while (*src && idx < nchars)
{
printf("%c%c", src[0], src[1]);
src += 2;
byte_in_word++;
if (byte_in_word == LISTING_WORD_SIZE)
{
printf(" ");
idx++;
byte_in_word = 0;
}
idx+=2;
}
for (;idx < nchars; idx++)
printf(" ");
printf("\t%s\n", string ? string : "");
on_page++;
listing_page(list);
if (list->message)
{
printf("**** %s\n",list->message);
listing_page(list);
on_page++;
}
for (lines = 0;
lines < LISTING_LHS_CONT_LINES
&& *src;
lines++) {
nchars = ((LISTING_WORD_SIZE*2) +1) * LISTING_LHS_WIDTH_SECOND -1;
idx = 0;
/* Print any more lines of data, but more compactly */
printf("% 4d ", list->line);
while (*src && idx < nchars)
{
printf("%c%c", src[0], src[1]);
src+=2;
idx+=2;
byte_in_word++;
if (byte_in_word == LISTING_WORD_SIZE)
{
printf(" ");
idx++;
byte_in_word = 0;
}
}
printf("\n");
on_page++;
listing_page(list);
}
}
}
static void
DEFUN_VOID(list_symbol_table)
{
extern symbolS *symbol_rootP;
symbolS *ptr ;
eject = 1;
listing_page(0);
printf("DEFINED SYMBOLS\n");
on_page++;
for (ptr = symbol_rootP; ptr != (symbolS*)NULL; ptr = symbol_next(ptr))
{
if (ptr->sy_frag->line)
{
printf("%20s:%-5d %2d:%08x %s \n",
ptr->sy_frag->line->file->filename,
ptr->sy_frag->line->line,
S_GET_SEGMENT(ptr),
S_GET_VALUE(ptr),
S_GET_NAME(ptr));
on_page++;
listing_page(0);
}
}
printf("\n");
on_page++;
listing_page(0);
printf("UNDEFINED SYMBOLS\n");
on_page++;
listing_page(0);
for (ptr = symbol_rootP; ptr != (symbolS*)NULL; ptr = symbol_next(ptr))
{
if (ptr->sy_frag->line == 0)
{
printf("%s\n", S_GET_NAME(ptr));
on_page++;
listing_page(0);
}
}
}
void
DEFUN(listing_listing,(name),
char *name)
{
list_info_type *list = head;
unsigned int page= 1;
unsigned int prev = 0;
char *message;
char *buffer;
char *p;
unsigned int addr = 0;
int on_page = 0;
int show_listing = 1;
buffer = malloc(LISTING_RHS_WIDTH);
eject = 1;
list = head;
while (list != (list_info_type *)NULL && 0)
{
if (list->next)
list->frag = list->next->frag;
list = list->next;
}
list = head->next;
while ( list)
{
p = buffer_line(list, buffer, LISTING_RHS_WIDTH > paper_width ?
paper_width : LISTING_RHS_WIDTH);
switch (list->edict) {
case EDICT_LIST:
show_listing++;
break;
case EDICT_NOLIST:
show_listing--;
break;
case EDICT_EJECT:
break;
case EDICT_NONE:
break;
case EDICT_TITLE:
title = list->edict_arg;
break;
case EDICT_SBTTL:
subtitle = list->edict_arg;
break;
default:
abort();
}
if (show_listing > 0)
{
/* Scan down the list and print all the stuff which can be done
with this line (or lines) */
message = 0;
print_lines(list, p, calc_hex(list));
if (list->edict == EDICT_EJECT)
{
eject = 1;
}
}
list = list->next;
}
free(buffer);
}
void
DEFUN(listing_print,(name),
char *name)
{
title = "";
subtitle = "";
if (listing & LISTING_NOFORM)
{
paper_height = 0;
}
if (listing & LISTING_LISTING)
{
listing_listing(name);
}
if (listing & LISTING_SYMBOLS)
{
list_symbol_table();
}
}
void
DEFUN(listing_file,(name),
char *name)
{
fn = name;
}
void
DEFUN_VOID(listing_eject)
{
listing_tail->edict = EDICT_EJECT;
}
void
DEFUN_VOID(listing_flags)
{
}
void
DEFUN(listing_list,(on),
unsigned int on)
{
listing_tail->edict = on ? EDICT_LIST : EDICT_NOLIST;
}
void
DEFUN_VOID(listing_psize)
{
paper_height = get_absolute_expression();
if (paper_height < 0 || paper_height > 1000)
{
paper_height = 0;
as_warn("strantge paper height, set to no form");
}
if (*input_line_pointer == ',')
{
input_line_pointer++;
paper_width = get_absolute_expression();
}
}
void
DEFUN(listing_title,(depth),
unsigned int depth)
{
char *start;
char *title;
unsigned int length;
SKIP_WHITESPACE();
if (*input_line_pointer=='\"') {
input_line_pointer++;
start = input_line_pointer;
while (*input_line_pointer)
{
if (*input_line_pointer == '\"')
{
length = input_line_pointer - start;
title = malloc(length + 1);
memcpy(title, start, length);
title[length] = 0;
listing_tail->edict = depth ? EDICT_SBTTL : EDICT_TITLE;
listing_tail->edict_arg = title;
input_line_pointer++;
demand_empty_rest_of_line();
return;
}
else if (*input_line_pointer == '\n')
{
as_bad("New line in title");
demand_empty_rest_of_line();
return;
}
else
{
input_line_pointer++;
}
}
}
else
{
as_bad("expecting title in quotes");
}
}
#else
/* Dummy functions for when compiled without listing enabled */
void
DEFUN_VOID(listing_flags)
{
s_ignore();
}
void DEFUN_VOID(listing_list)
{
s_ignore();
}
void DEFUN_VOID(listing_eject)
{
s_ignore();
}
void DEFUN(listing_psize)
{
s_ignore();
}
void DEFUN(listing_title, (depth),
unsigned int depth)
{
s_ignore();
}
void
DEFUN(listing_file,(name),
char *name)
{
}
void DEFUN(listing_newline,(name),
char *name)
{
}
#endif

20
gas/listing.h Normal file
View File

@ -0,0 +1,20 @@
#ifndef NO_LISTING
#define LISTING_NEWLINE() if (listing) listing_newline(input_line_pointer);
#else
#define LISTING_NEWLINE()
#endif
void EXFUN(listing_title,(unsigned int depth));
void EXFUN(listing_list,());
void EXFUN(listing_flags,());
void EXFUN(listing_psize,());
void EXFUN(listing_eject,());
void EXFUN(listing_width,(unsigned int x));
#define LISTING_LISTING 1
#define LISTING_SYMBOLS 2
#define LISTING_NOFORM 4
#define LISTING_DEFAULT 3