WebSVN – Kolibri OS – Diff – /contrib/toolchain/binutils/gas/read.c

 /* read.c - read a source file -
-   Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
-, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
-, 2011, 2012  Free Software Foundation, Inc.
+   Copyright (C) 1986-2015 Free Software Foundation, Inc.
    This file is part of GAS, the GNU Assembler.
 #include "ecoff.h"
 #include "dw2gencfi.h"
 #include "wchar.h"
 #ifndef TC_START_LABEL
-#define TC_START_LABEL(x,y,z) (x == ':')
+#define TC_START_LABEL(STR, NUL_CHAR, NEXT_CHAR) (NEXT_CHAR == ':')
 #endif
 /* Set by the object-format or the target.  */
   /* Something close -- but not too close -- to a multiple of 1024.
      The debugging malloc I'm using has 24 bytes of overhead.  */
   obstack_begin (¬es, chunksize);
   obstack_begin (&cond_obstack, chunksize);
+#ifndef tc_line_separator_chars
+#define tc_line_separator_chars line_separator_chars
 #endif
   /* Use machine dependent syntax.  */
-  for (p = line_separator_chars; *p; p++)
+  for (p = tc_line_separator_chars; *p; p++)
     is_end_of_line[(unsigned char) *p] = 2;
   /* Use more.  FIXME-SOMEDAY.  */
   pop_table_name = "cfi";
   pop_override_ok = 1;
   cfi_pop_insert ();
+}
-#define HANDLE_CONDITIONAL_ASSEMBLY()					\
+#define HANDLE_CONDITIONAL_ASSEMBLY(num_read)				\
   if (ignore_input ())							\
     {									\
-      char *eol = find_end_of_line (input_line_pointer, flag_m68k_mri); \
+      char *eol = find_end_of_line (input_line_pointer - (num_read),	\
+				    flag_m68k_mri);			\
       input_line_pointer = (input_line_pointer <= buffer_limit		\
 			    && eol >= buffer_limit)			\
 			   ? buffer_limit				\
 			   : eol + 1;					\
       continue;								\
 /* We read the file, putting things into a web that represents what we
    have been reading.  */
 void
 read_a_source_file (char *name)
+{
-  char c;
+  char nul_char;
+  char next_char;
   char *s;		/* String of symbol, '\0' appended.  */
   int temp;
   pseudo_typeS *pop;
+	    {
 	      line_label = NULL;
 	      if (LABELS_WITHOUT_COLONS || flag_m68k_mri)
+		{
 		  next_char = * input_line_pointer;
 		  /* 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))
+		  if (is_name_beginner (next_char) || next_char == '"')
 		    {
-		      char *line_start = input_line_pointer;
+		      char *line_start;
 		      int mri_line_macro;
+		      HANDLE_CONDITIONAL_ASSEMBLY (0);
 		      HANDLE_CONDITIONAL_ASSEMBLY ();
 		      nul_char = get_symbol_name (& line_start);
-		      c = get_symbol_end ();
+		      next_char = (nul_char == '"' ? input_line_pointer[1] : nul_char);
 		      /* In MRI mode, we need to handle the MACRO
 			 pseudo-op specially: we don't want to put the
 			 symbol in the symbol table.  */
 		      if (!mri_line_macro
 #ifdef TC_START_LABEL_WITHOUT_COLON
-			  && TC_START_LABEL_WITHOUT_COLON(c,
+			  && TC_START_LABEL_WITHOUT_COLON (nul_char, next_char)
-							  input_line_pointer)
 #endif
+			  )
 			line_label = colon (line_start);
 		      else
 			line_label = symbol_create (line_start,
 						    absolute_section,
 						    (valueT) 0,
 						    &zero_address_frag);
-		      *input_line_pointer = c;
+		      next_char = restore_line_pointer (nul_char);
-		      if (c == ':')
+		      if (next_char == ':')
 			input_line_pointer++;
+		    }
+		}
 	     Depending on what compiler is used, the order of these tests
 	     may vary to catch most common case 1st.
 	     Each test is independent of all other tests at the (top)
 	     level.  */
 	  do
-	    c = *input_line_pointer++;
+	    nul_char = next_char = *input_line_pointer++;
-	  while (c == '\t' || c == ' ' || c == '\f');
+	  while (next_char == '\t' || next_char == ' ' || next_char == '\f');
 	  /* C is the 1st significant character.
 	     Input_line_pointer points after that character.  */
-	  if (is_name_beginner (c))
+	  if (is_name_beginner (next_char) || next_char == '"')
+	    {
+	      char *rest;
 	      /* Want user-defined label or pseudo/opcode.  */
-	      HANDLE_CONDITIONAL_ASSEMBLY ();
+	      HANDLE_CONDITIONAL_ASSEMBLY (1);
+	      --input_line_pointer;
+	      nul_char = get_symbol_name (& s);	/* name's delimiter.  */
-	      s = --input_line_pointer;
+	      next_char = (nul_char == '"' ? input_line_pointer[1] : nul_char);
-	      c = get_symbol_end ();	/* name's delimiter.  */
+	      rest = input_line_pointer + (nul_char == '"' ? 2 : 1);
-	      /* C is character after symbol.
+	      /* NEXT_CHAR is character after symbol.
-		 That character's place in the input line is now '\0'.
+		 The end of symbol in the input line is now '\0'.
 		 S points to the beginning of the symbol.
 		   [In case of pseudo-op, s->'.'.]
-		 Input_line_pointer->'\0' where c was.  */
+		 Input_line_pointer->'\0' where NUL_CHAR was.  */
-	      if (TC_START_LABEL (c, s, input_line_pointer))
+	      if (TC_START_LABEL (s, nul_char, next_char))
-		{
-		  if (flag_m68k_mri)
+		{
-		      char *rest = input_line_pointer + 1;
+		  if (flag_m68k_mri)
+		    {
 		      /* In MRI mode, \tsym: set 0 is permitted.  */
 			  continue;
+			}
+		    }
 		  line_label = colon (s);	/* User-defined label.  */
-		  /* Put ':' back for error messages' sake.  */
+		  restore_line_pointer (nul_char);
-		  *input_line_pointer++ = ':';
+		  ++ input_line_pointer;
 #ifdef tc_check_label
 		  tc_check_label (line_label);
 #endif
 		  /* Input_line_pointer->after ':'.  */
 		  SKIP_WHITESPACE ();
 		}
-	      else if ((c == '=' && input_line_pointer[1] == '=')
+	      else if ((next_char == '=' && *rest == '=')
-		       || ((c == ' ' || c == '\t')
+		       || ((next_char == ' ' || next_char == '\t')
-			   && input_line_pointer[1] == '='
+			   && rest[0] == '='
-			   && input_line_pointer[2] == '='))
+			   && rest[1] == '='))
+		{
 		  equals (s, -1);
 		  demand_empty_rest_of_line ();
 		}
-	      else if ((c == '='
+	      else if ((next_char == '='
-		       || ((c == ' ' || c == '\t')
+		       || ((next_char == ' ' || next_char == '\t')
-			    && input_line_pointer[1] == '='))
+			    && *rest == '='))
 #ifdef TC_EQUAL_IN_INSN
-			   && !TC_EQUAL_IN_INSN (c, s)
+			   && !TC_EQUAL_IN_INSN (next_char, s)
 #endif
+			   )
+		{
 		  equals (s, 1);
 		  if (pop != NULL
 		      || (!flag_m68k_mri && *s == '.'))
+		    {
 		      /* PSEUDO - OP.
-			 WARNING: c has next char, which may be end-of-line.
+			 WARNING: next_char may be end-of-line.
 			 We lookup the pseudo-op table with s+1 because we
 			 already know that the pseudo-op begins with a '.'.  */
 		      /* Print the error msg now, while we still can.  */
 		      if (pop == NULL)
+			{
 			  char *end = input_line_pointer;
-			  *input_line_pointer = c;
+			  (void) restore_line_pointer (nul_char);
 			  s_ignore (0);
-			  c = *--input_line_pointer;
+			  nul_char = next_char = *--input_line_pointer;
 			  *input_line_pointer = '\0';
-			  if (! macro_defined || ! try_macro (c, s))
+			  if (! macro_defined || ! try_macro (next_char, s))
+			    {
 			      *end = '\0';
 			      as_bad (_("unknown pseudo-op: `%s'"), s);
-			      *input_line_pointer++ = c;
+			      *input_line_pointer++ = nul_char;
+			    }
 			  continue;
+			}
 		      /* Put it back for error messages etc.  */
-		      *input_line_pointer = c;
+		      next_char = restore_line_pointer (nul_char);
 		      /* The following skip of whitespace is compulsory.
 			 A well shaped space is sometimes all that separates
 			 keyword from operands.  */
-		      if (c == ' ' || c == '\t')
+		      if (next_char == ' ' || next_char == '\t')
 			input_line_pointer++;
 		      if (pop->poc_handler == s_end)
 			goto quit;
+		    }
 		  else
+		    {
-		      /* WARNING: c has char, which may be end-of-line.  */
+		      /* WARNING: next_char may be end-of-line.  */
-		      /* Also: input_line_pointer->`\0` where c was.  */
+		      /* Also: input_line_pointer->`\0` where nul_char was.  */
-		      *input_line_pointer = c;
+		      (void) restore_line_pointer (nul_char);
 		      input_line_pointer = _find_end_of_line (input_line_pointer, flag_m68k_mri, 1, 0);
-		      c = *input_line_pointer;
+		      next_char = nul_char = *input_line_pointer;
 		      *input_line_pointer = '\0';
 		      generate_lineno_debug ();
-		      if (macro_defined && try_macro (c, s))
+		      if (macro_defined && try_macro (next_char, s))
 			continue;
+			    }
+			}
 		      assemble_one (s); /* Assemble 1 instruction.  */
-		      *input_line_pointer++ = c;
+		      *input_line_pointer++ = nul_char;
 		      /* We resume loop AFTER the end-of-line from
 			 this instruction.  */
+		    }
+		}
 	      continue;
+	    }
 	  /* Empty statement?  */
-	  if (is_end_of_line[(unsigned char) c])
+	  if (is_end_of_line[(unsigned char) next_char])
 	    continue;
-	  if ((LOCAL_LABELS_DOLLAR || LOCAL_LABELS_FB) && ISDIGIT (c))
+	  if ((LOCAL_LABELS_DOLLAR || LOCAL_LABELS_FB) && ISDIGIT (next_char))
+	    {
+	      /* local label  ("4:")  */
+	      char *backup = input_line_pointer;
-	      /* local label  ("4:")  */
+	      HANDLE_CONDITIONAL_ASSEMBLY (1);
 	      char *backup = input_line_pointer;
 	      temp = next_char - '0';
 		  colon (fb_label_name (temp, 0));
 		  continue;
+		}
 	      input_line_pointer = backup;
-	    }			/* local label  ("4:") */
+	    }
-	  if (c && strchr (line_comment_chars, c))
+	  if (next_char && strchr (line_comment_chars, next_char))
 	    {			/* Its a comment.  Better say APP or NO_APP.  */
 	      sb sbuf;
 	      char *ends;
 	      buffer_limit = input_scrub_next_buffer (&input_line_pointer);
 	      free (new_buf);
 	      continue;
+	    }
-	  HANDLE_CONDITIONAL_ASSEMBLY ();
+	  HANDLE_CONDITIONAL_ASSEMBLY (1);
 #ifdef tc_unrecognized_line
-	  if (tc_unrecognized_line (c))
+	  if (tc_unrecognized_line (next_char))
 	    continue;
 #endif
 	  input_line_pointer--;
+    }
   else
+    {
       align = get_absolute_expression ();
       SKIP_WHITESPACE ();
+#ifdef TC_ALIGN_ZERO_IS_DEFAULT
+      if (arg > 0 && align == 0)
+	align = arg;
+#endif
+    }
   if (bytes_p)
+    {
   s_align (arg, 0);
+}
 /* Switch in and out of alternate macro mode.  */
-void
+static void
 s_altmacro (int on)
+{
   demand_empty_rest_of_line ();
    Advances i_l_p to the next non-whitespace character.
    If a symbol name could not be read, the routine issues an error
    messages, skips to the end of the line and returns NULL.  */
-static char *
+char *
 read_symbol_name (void)
+{
   char * name;
   if (*input_line_pointer == ',')
     input_line_pointer++;
   temp = get_absolute_expr (&exp);
   size = temp;
-  size &= ((offsetT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1;
+  size &= ((addressT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1;
   if (exp.X_op == O_absent)
+    {
       as_bad (_("missing size expression"));
       ignore_rest_of_line ();
   SKIP_WHITESPACE ();
   name = input_line_pointer;
   if (!ISDIGIT (*name))
-    c = get_symbol_end ();
+    c = get_symbol_name (& name);
   else
+    {
       do
 	  name = alc;
+	}
+    }
   sym = symbol_find_or_make (name);
-  *input_line_pointer = c;
+  c = restore_line_pointer (c);
   if (alc != NULL)
     free (alc);
   if (!is_end_of_line[(unsigned char) *input_line_pointer])
+    {
       char *s;
       char c;
-      s = input_line_pointer;
-      c = get_symbol_end ();
+      c = get_symbol_name (& s);
       if (strcasecmp (s, "discard") == 0)
 	type = LINKONCE_DISCARD;
       else if (strcasecmp (s, "one_only") == 0)
 	type = LINKONCE_ONE_ONLY;
       else if (strcasecmp (s, "same_contents") == 0)
 	type = LINKONCE_SAME_CONTENTS;
       else
 	as_warn (_("unrecognized .linkonce type `%s'"), s);
-      *input_line_pointer = c;
+      (void) restore_line_pointer (c);
+    }
 #ifdef obj_handle_link_once
   SKIP_WHITESPACE ();
   name = input_line_pointer;
   if (!ISDIGIT (*name))
-    c = get_symbol_end ();
+    c = get_symbol_name (& name);
   else
+    {
       do
       *input_line_pointer = '\0';
+    }
   name = xstrdup (name);
-  *input_line_pointer = c;
+  c = restore_line_pointer (c);
   seg = subseg_new (name, 0);
-  if (*input_line_pointer == ',')
+  if (c == ',')
   char c;
   segT seg;
-  SKIP_WHITESPACE ();
+  SKIP_WHITESPACE ();
   name = input_line_pointer;
-  c = get_symbol_end ();
+  c = get_symbol_name (& name);
   name = xstrdup (name);
-  *input_line_pointer = c;
+  c = restore_line_pointer (c);
   seg = subseg_new (name, 0);
-  if (*input_line_pointer != ',')
+  if (c != ',')
-    *type = 'C';
-  else
+    *type = 'C';
   else
       char *sectype;
       char *sectype;
       ++input_line_pointer;
-      SKIP_WHITESPACE ();
+      ++input_line_pointer;
-      sectype = input_line_pointer;
+      SKIP_WHITESPACE ();
-      c = get_symbol_end ();
+      c = get_symbol_name (& sectype);
       if (*sectype == '\0')
 	*type = 'C';
       else if (strcasecmp (sectype, "text") == 0)
 	*type = 'C';
       else if (strcasecmp (sectype, "data") == 0)
 	*type = 'D';
       else if (strcasecmp (sectype, "romdata") == 0)
 	*type = 'R';
       else
 	as_warn (_("unrecognized section type `%s'"), sectype);
-      *input_line_pointer = c;
-    }
+      (void) restore_line_pointer (c);
+    }
   if (*input_line_pointer == ',')
   if (*input_line_pointer == ',')
       char *seccmd;
       char *seccmd;
+	}
       else if (strcasecmp (seccmd, "align") == 0)
+	{
 	  int align;
-	  *input_line_pointer = c;
+	  (void) restore_line_pointer (c);
 	  align = get_absolute_expression ();
 	  record_alignment (seg, align);
+	}
       else
+	{
 	  as_warn (_("unrecognized section command `%s'"), seccmd);
-	  *input_line_pointer = c;
+	  (void) restore_line_pointer (c);
+	}
+    }
+    {
       char *name;
       char c;
-      SKIP_WHITESPACE ();
-      name = input_line_pointer;
+      SKIP_WHITESPACE ();
-      c = get_symbol_end ();
+      c = get_symbol_name (& name);
       delete_macro (name);
       *input_line_pointer = c;
-      SKIP_WHITESPACE ();
+      SKIP_WHITESPACE_AFTER_NAME ();
+    }
   while (*input_line_pointer++ == ',');
 	  dummy_frag->line = listing_tail;
 	  dummy_frag->fr_symbol = symbolP;
 	  symbol_set_frag (symbolP, dummy_frag);
+	}
 #endif
-#ifdef OBJ_COFF
+#if defined (OBJ_COFF) && !defined (TE_PE)
       /* "set" symbols are local unless otherwise specified.  */
       SF_SET_LOCAL (symbolP);
 #endif
+    }
 parse_mri_cons (expressionS *exp, unsigned int nbytes);
 #endif
 #ifndef TC_PARSE_CONS_EXPRESSION
 #ifdef BITFIELD_CONS_EXPRESSIONS
+#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
-#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_bitfield_cons (EXP, NBYTES)
+  (parse_bitfield_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
 static void
 parse_bitfield_cons (expressionS *exp, unsigned int nbytes);
 #endif
 #ifdef REPEAT_CONS_EXPRESSIONS
+#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
-#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) parse_repeat_cons (EXP, NBYTES)
+  (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
 static void
 parse_repeat_cons (expressionS *exp, unsigned int nbytes);
 #endif
 /* If we haven't gotten one yet, just call expression.  */
+#ifndef TC_PARSE_CONS_EXPRESSION
-#ifndef TC_PARSE_CONS_EXPRESSION
+#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
-#define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) expression (EXP)
+  (expression (EXP), TC_PARSE_CONS_RETURN_NONE)
 #endif
 #endif
 void
 do_parse_cons_expression (expressionS *exp,
 			  int nbytes ATTRIBUTE_UNUSED)
+{
-  TC_PARSE_CONS_EXPRESSION (exp, nbytes);
+  (void) TC_PARSE_CONS_EXPRESSION (exp, nbytes);
 #endif
   c = 0;
   do
+    {
+      TC_PARSE_CONS_RETURN_TYPE ret = TC_PARSE_CONS_RETURN_NONE;
+#ifdef TC_CONS_FIX_CHECK
+      fixS **cur_fix = &frchain_now->fix_tail;
+      if (*cur_fix != NULL)
+	cur_fix = &(*cur_fix)->fx_next;
+#endif
 #ifdef TC_M68K
       if (flag_m68k_mri)
 	parse_mri_cons (&exp, (unsigned int) nbytes);
       else
 #endif
+	{
 #if 0
 	  if (*input_line_pointer == '"')
+	    {
 	      as_bad (_("unexpected `\"' in expression"));
 	      ignore_rest_of_line ();
 	      return;
+	    }
-	    }
+#endif
-	  TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
+	  ret = TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
+	}
       if (rva)
+	{
 	  if (exp.X_op == O_symbol)
 	    exp.X_op = O_symbol_rva;
 	  else
 	    as_fatal (_("rva without symbol"));
+	}
+      emit_expr_with_reloc (&exp, (unsigned int) nbytes, ret);
+#ifdef TC_CONS_FIX_CHECK
       TC_CONS_FIX_CHECK (&exp, nbytes, *cur_fix);
-      emit_expr (&exp, (unsigned int) nbytes);
+#endif
       ++c;
+    }
   cons_worker (size, 1);
+}
 /* .reloc offset, reloc_name, symbol+addend.  */
-void
+static void
 s_reloc (int ignore ATTRIBUTE_UNUSED)
+{
   char *stop = NULL;
   char stopc = 0;
   expressionS exp;
   char *r_name;
+  int c;
+  struct reloc_list *reloc;
+  struct _bfd_rel { char *name; bfd_reloc_code_real_type code; };
+  static struct _bfd_rel bfd_relocs[] = {
+    { "NONE", BFD_RELOC_NONE },
+    { "8", BFD_RELOC_8 },
+    { "16", BFD_RELOC_16 },
+    { "32", BFD_RELOC_32 },
-  int c;
+    { "64", BFD_RELOC_64 }
-  struct reloc_list *reloc;
+  };
       goto err_out;
+    }
   ++input_line_pointer;
   SKIP_WHITESPACE ();
+  c = get_symbol_name (& r_name);
+  if (strncasecmp (r_name, "BFD_RELOC_", 10) == 0)
-  r_name = input_line_pointer;
+    {
+      unsigned int i;
+      for (reloc->u.a.howto = NULL, i = 0; i < ARRAY_SIZE (bfd_relocs); i++)
+	if (strcasecmp (r_name + 10, bfd_relocs[i].name) == 0)
+	  {
+	    reloc->u.a.howto = bfd_reloc_type_lookup (stdoutput,
+						      bfd_relocs[i].code);
+	    break;
+	  }
+    }
-  c = get_symbol_end ();
+  else
   reloc->u.a.howto = bfd_reloc_name_lookup (stdoutput, r_name);
   *input_line_pointer = c;
   if (reloc->u.a.howto == NULL)
+    {
       as_bad (_("unrecognized reloc type"));
       goto err_out;
+    }
   exp.X_op = O_absent;
-  SKIP_WHITESPACE ();
+  SKIP_WHITESPACE_AFTER_NAME ();
   if (*input_line_pointer == ',')
+    {
       ++input_line_pointer;
    NBYTES bytes.  If need_pass_2 is 1, this does nothing.  */
 void
 emit_expr (expressionS *exp, unsigned int nbytes)
+{
+  emit_expr_with_reloc (exp, nbytes, TC_PARSE_CONS_RETURN_NONE);
+}
+void
+emit_expr_with_reloc (expressionS *exp,
+		      unsigned int nbytes,
+		      TC_PARSE_CONS_RETURN_TYPE reloc)
+{
   operatorT op;
   char *p;
   valueT extra_digit = 0;
       op = O_constant;
+    }
+  p = frag_more ((int) nbytes);
+  if (reloc != TC_PARSE_CONS_RETURN_NONE)
+    {
+      emit_expr_fix (exp, nbytes, frag_now, p, reloc);
+      return;
   p = frag_more ((int) nbytes);
 #ifndef WORKING_DOT_WORD
   /* If we have the difference of two symbols in a word, save it on
      the broken_words list.  See the code in write.c.  */
 	      p += CHARS_PER_LITTLENUM;
+	    }
+	}
+    }
   else
-    emit_expr_fix (exp, nbytes, frag_now, p);
+    emit_expr_fix (exp, nbytes, frag_now, p, TC_PARSE_CONS_RETURN_NONE);
+}
 void
+emit_expr_fix (expressionS *exp, unsigned int nbytes, fragS *frag, char *p,
-emit_expr_fix (expressionS *exp, unsigned int nbytes, fragS *frag, char *p)
+	       TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED)
+{
+  int offset = 0;
+  unsigned int size = nbytes;
-{
-  memset (p, 0, nbytes);
+  memset (p, 0, size);
   /* Generate a fixS to record the symbol value.  */
+#ifdef TC_CONS_FIX_NEW
-#ifdef TC_CONS_FIX_NEW
+  TC_CONS_FIX_NEW (frag, p - frag->fr_literal + offset, size, exp, r);
-  TC_CONS_FIX_NEW (frag, p - frag->fr_literal, nbytes, exp);
+#else
+  if (r != TC_PARSE_CONS_RETURN_NONE)
+  {
+      reloc_howto_type *reloc_howto;
+      reloc_howto = bfd_reloc_type_lookup (stdoutput, r);
+      size = bfd_get_reloc_size (reloc_howto);
+      if (size > nbytes)
+	{
+	  as_bad (_("%s relocations do not fit in %u bytes\n"),
+		  reloc_howto->name, nbytes);
+	  return;
+	}
-#else
+      else if (target_big_endian)
 	offset = nbytes - size;
     bfd_reloc_code_real_type r;
   else
-    switch (nbytes)
+    switch (size)
+      {
 	break;
       case 8:
 	r = BFD_RELOC_64;
 	break;
       default:
-	as_bad (_("unsupported BFD relocation size %u"), nbytes);
+	as_bad (_("unsupported BFD relocation size %u"), size);
-	r = BFD_RELOC_32;
-	break;
+	return;
-      }
-    fix_new_exp (frag, p - frag->fr_literal, (int) nbytes, exp,
-, r);
+      }
+  fix_new_exp (frag, p - frag->fr_literal + offset, size,
+	       exp, 0, r);
 #endif
+}
 #ifdef BITFIELD_CONS_EXPRESSIONS
 	      *input_line_pointer = cache;
 	      demand_empty_rest_of_line ();
 	      return;
 	    }			/* Too complex.  */
-	  value |= ((~(-1 << width) & exp->X_add_number)
+	  value |= ((~(-(1 << width)) & exp->X_add_number)
 		    << ((BITS_PER_CHAR * nbytes) - bits_available));
 	  if ((bits_available -= width) == 0
 /* Handle an MRI style string expression.  */
 #ifdef TC_M68K
 static void
-parse_mri_cons (exp, nbytes)
-     expressionS *exp;
-     unsigned int nbytes;
+parse_mri_cons (expressionS *exp, unsigned int nbytes)
+{
   if (*input_line_pointer != '\''
       && (input_line_pointer[1] != '\''
 	  || (*input_line_pointer != 'A'
 	      && *input_line_pointer != 'E')))
-    TC_PARSE_CONS_EXPRESSION (exp, nbytes);
+    (void) TC_PARSE_CONS_EXPRESSION (exp, nbytes);
   else
+    {
       unsigned int scan;
   /* Mop up any left-over bits (of which there will be less than 7).  */
   if ((byte & 0x80) != 0)
+    {
       /* Sign-extend VAL.  */
       if (val & (1 << (loaded - 1)))
-	val |= ~0 << loaded;
+	val |= ~0U << loaded;
       if (orig)
 	*p = val & 0x7f;
       p++;
+    }
       bump_line_counters ();
       break;
 #ifndef NO_STRING_ESCAPES
     case '\\':
-      switch (c = *input_line_pointer++)
+      switch (c = *input_line_pointer++ & CHAR_MASK)
+	{
 	case 'b':
 	  c = '\b';
 		 c = *input_line_pointer++, i++)
+	      {
 		number = number * 8 + c - '0';
+	      }
-	    c = number & 0xff;
+	    c = number & CHAR_MASK;
+	  }
 	  --input_line_pointer;
 	  break;
 		  number = number * 16 + c - 'A' + 10;
 		else
 		  number = number * 16 + c - 'a' + 10;
 		c = *input_line_pointer++;
+	      }
-	    c = number & 0xff;
+	    c = number & CHAR_MASK;
 	    --input_line_pointer;
+	  }
 	  break;
+    }
   else
+    {
       include_dir_count++;
       include_dirs =
-	(char **) realloc (include_dirs,
+	(char **) xrealloc (include_dirs,
 			   include_dir_count * sizeof (*include_dirs));
+    }
 	  as_bad (_(".endfunc missing for previous .func"));
 	  ignore_rest_of_line ();
 	  return;
+	}
-      name = input_line_pointer;
-      delim1 = get_symbol_end ();
+      delim1 = get_symbol_name (& name);
       name = xstrdup (name);
       *input_line_pointer = delim1;
-      SKIP_WHITESPACE ();
+      SKIP_WHITESPACE_AFTER_NAME ();
       if (*input_line_pointer != ',')
+	{
 	  if (default_prefix)
+	    {
+	}
       else
+	{
 	  ++input_line_pointer;
 	  SKIP_WHITESPACE ();
-	  label = input_line_pointer;
-	  delim2 = get_symbol_end ();
+	  delim2 = get_symbol_name (& label);
 	  label = xstrdup (label);
-	  *input_line_pointer = delim2;
+	  restore_line_pointer (delim2);
+	}
       if (debug_type == DEBUG_STABS)
 	inquote ^= *s;
       ++s;
+    }
   if (inquote)
     as_warn (_("missing closing `%c'"), inquote);
-  if (inescape)
+  if (inescape && !ignore_input ())
     as_warn (_("stray `\\'"));
   return s;
+}

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/gas/read.c – Rev 5222 → 6324