Imagelibrary/binutils-gdb
1
0
Fork 1
mirror of https://github.com/bminor/binutils-gdb.git synced 2025-12-26 09:08:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

* read.c (read_a_source_file): Fix test for when to stick a colon

Browse Source 
on the end of a label.  Make code conditional on either MRI or
        LABELS_WITHOUT_COLONS.

        * app.c (do_scrub_next_char): If a line begins with whitespace, leave
        the single whitespace character alone.  Eat all others.

        * config/tc-hppa.h (LABELS_WITHOUT_COLONS): Define.
This commit is contained in:
Jeff Law
1993-11-28 06:54:04 +00:00
parent 5f74c94042
commit 385ce4337d
3 changed files with 43 additions and 374 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
gas/ChangeLog
View File

@@ -1,3 +1,14 @@
Sat Nov 27 22:49:07 1993 Jeffrey A. Law (law@snake.cs.utah.edu)
* read.c (read_a_source_file): Fix test for when to stick a colon
on the end of a label. Make code conditional on either MRI or
LABELS_WITHOUT_COLONS.
* app.c (do_scrub_next_char): If a line begins with whitespace, leave
the single whitespace character alone. Eat all others.
* config/tc-hppa.h (LABELS_WITHOUT_COLONS): Define.
Wed Nov 24 01:22:54 1993 Jeffrey A. Law (law@snake.cs.utah.edu)
* config/tc-hppa.c (pa_procend): Do not call process_exit.

34
gas/app.c
View File

@@ -53,6 +53,8 @@ static const char symbol_chars[] =
#define IS_LINE_COMMENT(c) (lex[c] == LEX_IS_LINE_COMMENT_START)
#define IS_NEWLINE(c) (lex[c] == LEX_IS_NEWLINE)
static int process_escape PARAMS ((int));
/* FIXME-soon: The entire lexer/parser thingy should be
built statically at compile time rather than dynamically
each and every time the assembler is run. xoxorich. */
@@ -210,9 +212,9 @@ app_pop (arg)
/* @@ This assumes that \n &c are the same on host and target. This is not
necessarily true. */
int
static int
process_escape (ch)
char ch;
int ch;
{
switch (ch)
{
@@ -261,6 +263,7 @@ do_scrub_next_char (get, unget)
Taylor, ian@cygnus.com. */
register int ch, ch2 = 0;
int not_cpp_line = 0;
switch (state)
{
@@ -359,9 +362,6 @@ do_scrub_next_char (get, unget)
case '"':
case '\\':
#ifdef TC_HPPA
case 'x': /* '\\x' introduces escaped sequences on the PA */
#endif
case 'b':
case 'f':
case 'n':
@@ -370,6 +370,8 @@ do_scrub_next_char (get, unget)
#ifdef BACKSLASH_V
case 'v':
#endif /* BACKSLASH_V */
case 'x':
case 'X':
case '0':
case '1':
case '2':
@@ -425,13 +427,24 @@ recycle:
{
case LEX_IS_WHITESPACE:
do
ch = (*get) ();
/* Preserve a single whitespace character at the beginning of
a line. */
if (state == 0)
{
state = 1;
return ch;
}
else
ch = (*get) ();
while (ch != EOF && IS_WHITESPACE (ch));
if (ch == EOF)
return ch;
if (IS_COMMENT (ch) || (state == 0 && IS_LINE_COMMENT (ch)) || ch == '/' || IS_LINE_SEPARATOR (ch))
{
/* cpp never outputs a leading space before the #, so try to
avoid being confused. */
not_cpp_line = 1;
goto recycle;
}
#ifdef MRI
@@ -455,7 +468,9 @@ recycle:
state++;
goto recycle; /* Punted leading sp */
case 1:
BAD_CASE (state); /* We can't get here */
/* We can arrive here if we leave a leading whitespace character
at the beginning of a line. */
goto recycle;
case 2:
state = 3;
(*unget) (ch);
@@ -600,6 +615,9 @@ recycle:
}
} /* bad hack */
if (ch != '#')
not_cpp_line = 1;
do
ch = (*get) ();
while (ch != EOF && IS_WHITESPACE (ch));
@@ -608,7 +626,7 @@ recycle:
as_warn ("EOF in comment: Newline inserted");
return '\n';
}
if (ch < '0' || ch > '9')
if (ch < '0' || ch > '9' || not_cpp_line)
{
/* Non-numerics: Eat whole comment line */
while (ch != EOF && !IS_NEWLINE (ch))

372
gas/read.c
View File

@@ -45,20 +45,6 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "obstack.h"
#include "listing.h"
/* We need this, despite the apparent object format dependency, since
it defines stab types, which all object formats can use now. */
#include "aout/stab_gnu.h"
/* Allow backends to override the names used for the stab sections. */
#ifndef STAB_SECTION_NAME
#define STAB_SECTION_NAME ".stab"
#endif
#ifndef STAB_STRING_SECTION_NAME
#define STAB_STRING_SECTION_NAME ".stabstr"
#endif
#ifndef TC_START_LABEL
#define TC_START_LABEL(x,y) (x==':')
#endif
@@ -370,12 +356,14 @@ read_a_source_file (name)
* If input_line_pointer [-1] == '\n' then we just
* scanned another line: so bump line counters.
*/
if (input_line_pointer[-1] == '\n')
if (is_end_of_line[input_line_pointer[-1]])
{
bump_line_counters ();
if (input_line_pointer[-1] == '\n')
bump_line_counters ();
#ifdef MRI
/* Text at the start of a line must be a label, we run down and stick a colon in */
#if defined (MRI) || defined (LABLES_WITHOUT_COLONS)
/* Text at the start of a line must be a label, we run down
and stick a colon in. */
if (is_name_beginner (*input_line_pointer))
{
char *line_start = input_line_pointer;
@@ -2608,355 +2596,7 @@ s_ignore (arg)
++input_line_pointer;
}
++input_line_pointer;
return;
} /* s_ignore() */
/*
* Handle .stabX directives, which used to be open-coded.
* So much creeping featurism overloaded the semantics that we decided
* to put all .stabX thinking in one place. Here.
*
* We try to make any .stabX directive legal. Other people's AS will often
* do assembly-time consistency checks: eg assigning meaning to n_type bits
* and "protecting" you from setting them to certain values. (They also zero
* certain bits before emitting symbols. Tut tut.)
*
* If an expression is not absolute we either gripe or use the relocation
* information. Other people's assemblers silently forget information they
* don't need and invent information they need that you didn't supply.
*/
/*
* Build a string dictionary entry for a .stabX symbol.
* The symbol is added to the .<secname>str section.
*/
#ifdef SEPARATE_STAB_SECTIONS
unsigned int
get_stab_string_offset (string, stabstr_secname)
const char *string;
const char *stabstr_secname;
{
unsigned int length;
unsigned int retval;
retval = 0;
length = strlen (string);
if (length > 0)
{ /* Ordinary case. */
segT save_seg;
subsegT save_subseg;
char *newsecname;
segT seg;
char *p;
save_seg = now_seg;
save_subseg = now_subseg;
/* Create the stab string section. */
newsecname = xmalloc ((unsigned long) (strlen (stabstr_secname) + 1));
strcpy (newsecname, stabstr_secname);
seg = subseg_new (newsecname, 0);
retval = seg_info (seg)->stabu.stab_string_size;
if (retval > 0)
free (newsecname);
else
{
/* Make sure the first string is empty. */
p = frag_more (1);
*p = 0;
retval = seg_info (seg)->stabu.stab_string_size = 1;
#ifdef BFD_ASSEMBLER
bfd_set_section_flags (stdoutput, seg, SEC_READONLY | SEC_DEBUGGING);
#else
free (newsecname);
#endif
}
p = frag_more (length + 1);
strcpy (p, string);
seg_info (seg)->stabu.stab_string_size += length + 1;
subseg_set (save_seg, save_subseg);
}
return retval;
}
#endif /* SEPARATE_STAB_SECTIONS */
/* This can handle different kinds of stabs (s,n,d) and different
kinds of stab sections. */
static void
s_stab_generic (what, stab_secname, stabstr_secname)
int what;
char *stab_secname;
char *stabstr_secname;
{
long longint;
char *string;
int type;
int other;
int desc;
/* The general format is:
.stabs "STRING",TYPE,OTHER,DESC,VALUE
.stabn TYPE,OTHER,DESC,VALUE
.stabd TYPE,OTHER,DESC
At this point input_line_pointer points after the pseudo-op and
any trailing whitespace. The argument what is one of 's', 'n' or
'd' indicating which type of .stab this is. */
if (what != 's')
string = "";
else
{
int length;
string = demand_copy_C_string (&length);
SKIP_WHITESPACE ();
if (*input_line_pointer == ',')
input_line_pointer++;
else
{
as_warn (".stabs: Missing comma");
ignore_rest_of_line ();
return;
}
}
if (get_absolute_expression_and_terminator (&longint) != ',')
{
as_warn (".stab%c: Missing comma", what);
ignore_rest_of_line ();
return;
}
type = longint;
if (get_absolute_expression_and_terminator (&longint) != ',')
{
as_warn (".stab%c: Missing comma", what);
ignore_rest_of_line ();
return;
}
other = longint;
desc = get_absolute_expression ();
if (what == 's' || what == 'n')
{
if (*input_line_pointer != ',')
{
as_warn (".stab%c: Missing comma", what);
ignore_rest_of_line ();
return;
}
input_line_pointer++;
SKIP_WHITESPACE ();
}
/* We have now gathered the type, other, and desc information. For
.stabs or .stabn, input_line_pointer is now pointing at the
value. */
#ifdef SEPARATE_STAB_SECTIONS
/* Output the stab information in a separate section. This is used
at least for COFF and ELF. */
{
segT saved_seg = now_seg;
subsegT saved_subseg = now_subseg;
fragS *saved_frag = frag_now;
valueT dot;
segT seg;
unsigned int stroff;
char *p;
dot = frag_now_fix ();
seg = subseg_new (stab_secname, 0);
if (! seg_info (seg)->hadone)
{
#ifdef BFD_ASSEMBLER
bfd_set_section_flags (stdoutput, seg,
SEC_READONLY | SEC_RELOC | SEC_DEBUGGING);
#endif
#ifdef INIT_STAB_SECTION
INIT_STAB_SECTION (seg);
#endif
seg_info (seg)->hadone = 1;
}
stroff = get_stab_string_offset (string, stabstr_secname);
/* At least for now, stabs in a special stab section are always
output as 12 byte blocks of information. */
p = frag_more (8);
md_number_to_chars (p, (valueT) stroff, 4);
md_number_to_chars (p + 4, (valueT) type, 1);
md_number_to_chars (p + 5, (valueT) other, 1);
md_number_to_chars (p + 6, (valueT) desc, 2);
if (what == 's' || what == 'n')
{
/* Pick up the value from the input line. */
cons (4);
input_line_pointer--;
}
else
{
const char *fake;
symbolS *symbol;
expressionS exp;
/* Arrange for a value representing the current location. */
fake = FAKE_LABEL_NAME;
symbol = symbol_new (fake, saved_seg, dot, saved_frag);
exp.X_op = O_symbol;
exp.X_add_symbol = symbol;
exp.X_add_number = 0;
emit_expr (&exp, 4);
}
#ifdef OBJ_PROCESS_STAB
OBJ_PROCESS_STAB (seg, string, stroff, type, other, desc);
#endif
subseg_set (saved_seg, saved_subseg);
}
#else /* ! SEPARATE_STAB_SECTIONS */
#ifdef OBJ_PROCESS_STAB
OBJ_PROCESS_STAB (what, string, type, other, desc);
#else
/* Put the stab information in the symbol table. */
{
symbolS *symbol;
symbol = symbol_new (string, undefined_section, 0,
(struct frag *) NULL);
if (what == 's' || what == 'n')
{
/* Pick up the value from the input line. */
symbol->sy_frag = &zero_address_frag;
pseudo_set (symbol);
}
else
{
/* .stabd sets the name to NULL. Why? */
S_SET_NAME (symbol, NULL);
symbol->sy_frag = frag_now;
S_SET_VALUE (symbol, (valueT) frag_now_fix ());
}
S_SET_TYPE (symbol, type);
S_SET_OTHER (symbol, other);
S_SET_DESC (symbol, desc);
}
#endif /* ! OBJ_PROCESS_STAB */
#endif /* ! SEPARATE_STAB_SECTIONS */
#ifndef NO_LISTING
if (listing)
{
switch (type)
{
case N_SLINE:
listing_source_line ((unsigned int) desc);
break;
case N_SO:
case N_SOL:
listing_source_file (string);
break;
}
}
#endif /* ! NO_LISTING */
demand_empty_rest_of_line ();
}
/* Regular stab directive. */
void
s_stab (what)
int what;
{
s_stab_generic (what, STAB_SECTION_NAME, STAB_STRING_SECTION_NAME);
}
/* "Extended stabs", used in Solaris only now. */
void
s_xstab (what)
int what;
{
int length;
char *stab_secname, *stabstr_secname;
stab_secname = demand_copy_C_string (&length);
SKIP_WHITESPACE ();
if (*input_line_pointer == ',')
input_line_pointer++;
else
{
as_bad ("comma missing in .xstabs");
ignore_rest_of_line ();
return;
}
/* To get the name of the stab string section, simply .str to
the stab section name. */
stabstr_secname = (char *) xmalloc (strlen (stab_secname) + 4);
strcpy (stabstr_secname, stab_secname);
strcat (stabstr_secname, "str");
s_stab_generic (what, stab_secname, stabstr_secname);
free (stabstr_secname);
}
#ifdef S_SET_DESC
/* Frob invented at RMS' request. Set the n_desc of a symbol. */
void
s_desc (ignore)
int ignore;
{
char *name;
char c;
char *p;
symbolS *symbolP;
int temp;
name = input_line_pointer;
c = get_symbol_end ();
p = input_line_pointer;
*p = c;
SKIP_WHITESPACE ();
if (*input_line_pointer != ',')
{
*p = 0;
as_bad ("Expected comma after name \"%s\"", name);
*p = c;
ignore_rest_of_line ();
}
else
{
input_line_pointer++;
temp = get_absolute_expression ();
*p = 0;
symbolP = symbol_find_or_make (name);
*p = c;
S_SET_DESC (symbolP, temp);
}
demand_empty_rest_of_line ();
} /* s_desc() */
#endif /* defined (S_SET_DESC) */
/* end of read.c */