merge from gcc

[deliverable/binutils-gdb.git] / gas / frags.h

diff --git a/gas/frags.h b/gas/frags.h
index b188e33cf4347726d1f7b2d21eea5e5efa96a376..52a6cfeb4bd5e70fe0672cf4f5c619fb3e04b07f 100644 (file)
--- a/gas/frags.h
+++ b/gas/frags.h
@@ -1,5 +1,5 @@
 /* frags.h - Header file for the frag concept.
 /* frags.h - Header file for the frag concept.

-   Copyright (C) 1987, 92, 93, 94, 95, 97, 98, 1999
+   Copyright 1987, 1992, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2001

    Free Software Foundation, Inc.
 
    This file is part of GAS, the GNU Assembler.
    Free Software Foundation, Inc.
 
    This file is part of GAS, the GNU Assembler.


@@ -26,44 +26,54 @@
 struct obstack;
 #endif
 
 struct obstack;
 #endif
 

-/*
- * A code fragment (frag) is some known number of chars, followed by some
- * unknown number of chars. Typically the unknown number of chars is an
- * instruction address whose size is yet unknown. We always know the greatest
- * possible size the unknown number of chars may become, and reserve that
- * much room at the end of the frag.
- * Once created, frags do not change address during assembly.
- * We chain the frags in (a) forward-linked list(s). The object-file address
- * of the 1st char of a frag is generally not known until after relax().
- * Many things at assembly time describe an address by {object-file-address
- * of a particular frag}+offset.
-
- BUG: it may be smarter to have a single pointer off to various different
- notes for different frag kinds. See how code pans
- */
-
-struct frag
-{
-  /* Object file address. */
+/* A code fragment (frag) is some known number of chars, followed by some
+   unknown number of chars. Typically the unknown number of chars is an
+   instruction address whose size is yet unknown. We always know the greatest
+   possible size the unknown number of chars may become, and reserve that
+   much room at the end of the frag.
+   Once created, frags do not change address during assembly.
+   We chain the frags in (a) forward-linked list(s). The object-file address
+   of the 1st char of a frag is generally not known until after relax().
+   Many things at assembly time describe an address by {object-file-address
+   of a particular frag}+offset.
+
+   BUG: it may be smarter to have a single pointer off to various different
+   notes for different frag kinds.  See how code pans.  */
+
+struct frag {
+  /* Object file address (as an octet offset).  */

   addressT fr_address;
   addressT fr_address;

-  /* Chain forward; ascending address order.  Rooted in frch_root. */
-  struct frag *fr_next;
+  /* When relaxing multiple times, remember the address the frag had
+     in the last relax pass.  */
+  addressT last_fr_address;

 
 

-  /* (Fixed) number of chars we know we have.  May be 0. */
+  /* (Fixed) number of octets we know we have.  May be 0.  */

   offsetT fr_fix;
   offsetT fr_fix;

-  /* (Variable) number of chars after above.  May be 0. */
+  /* May be used for (Variable) number of octets after above.
+     The generic frag handling code no longer makes any use of fr_var.  */

   offsetT fr_var;
   offsetT fr_var;

-  /* For variable-length tail. */
-  symbolS *fr_symbol;
-  /* For variable-length tail. */
+  /* For variable-length tail.  */

   offsetT fr_offset;
   offsetT fr_offset;

+  /* For variable-length tail.  */
+  symbolS *fr_symbol;

   /* Points to opcode low addr byte, for relaxation.  */
   char *fr_opcode;
 
   /* Points to opcode low addr byte, for relaxation.  */
   char *fr_opcode;
 

+  /* Chain forward; ascending address order.  Rooted in frch_root.  */
+  struct frag *fr_next;
+
+  /* Where the frag was created, or where it became a variant frag.  */
+  char *fr_file;
+  unsigned int fr_line;
+

 #ifndef NO_LISTING
   struct list_info_struct *line;
 #endif
 
 #ifndef NO_LISTING
   struct list_info_struct *line;
 #endif
 

+  /* Flipped each relax pass so we can easily determine whether
+     fr_address has been adjusted.  */
+  unsigned int relax_marker:1;
+

   /* What state is my tail in? */
   relax_stateT fr_type;
   relax_substateT fr_subtype;
   /* What state is my tail in? */
   relax_stateT fr_type;
   relax_substateT fr_subtype;


@@ -84,75 +94,69 @@ struct frag
   TC_FRAG_TYPE tc_frag_data;
 #endif
 
   TC_FRAG_TYPE tc_frag_data;
 #endif
 

-  /* Where the frag was created, or where it became a variant frag.  */
-  char *fr_file;
-  unsigned int fr_line;
-

   /* Data begins here.  */
   char fr_literal[1];
 };
 
 #define SIZEOF_STRUCT_FRAG \
   /* Data begins here.  */
   char fr_literal[1];
 };
 
 #define SIZEOF_STRUCT_FRAG \

-((char *)zero_address_frag.fr_literal-(char *)&zero_address_frag)
-/* We want to say fr_literal[0] above. */
+((char *) zero_address_frag.fr_literal - (char *) &zero_address_frag)
+/* We want to say fr_literal[0] above.  */

 
 /* Current frag we are building.  This frag is incomplete.  It is,
    however, included in frchain_now.  The fr_fix field is bogus;
    instead, use frag_now_fix ().  */
 COMMON fragS *frag_now;
 
 /* Current frag we are building.  This frag is incomplete.  It is,
    however, included in frchain_now.  The fr_fix field is bogus;
    instead, use frag_now_fix ().  */
 COMMON fragS *frag_now;

-extern addressT frag_now_fix PARAMS ((void));
+extern addressT frag_now_fix (void);
+extern addressT frag_now_fix_octets (void);

 
 

-/* For foreign-segment symbol fixups. */
+/* For foreign-segment symbol fixups.  */

 COMMON fragS zero_address_frag;
 COMMON fragS zero_address_frag;

-/* For local common (N_BSS segment) fixups. */
+/* For local common (N_BSS segment) fixups.  */

 COMMON fragS bss_address_frag;
 
 #if 0
 COMMON fragS bss_address_frag;
 
 #if 0

-/*
- * A macro to speed up appending exactly 1 char
- * to current frag.
- */
-/* JF changed < 1 to <= 1 to avoid a race conditon */
-#define FRAG_APPEND_1_CHAR(datum)      \
-{                                      \
-  if (obstack_room( &frags ) <= 1) {\
-    frag_wane (frag_now);      \
-    frag_new (0);              \
-  }                            \
-  obstack_1grow( &frags, datum );      \
+/* A macro to speed up appending exactly 1 char to current frag.  */
+/* JF changed < 1 to <= 1 to avoid a race condition.  */
+#define FRAG_APPEND_1_CHAR(datum)                      \
+{                                                      \
+  if (obstack_room (&frags) <= 1)                      \
+    {                                                  \
+      frag_wane (frag_now);                            \
+      frag_new (0);                                    \
+    }                                                  \
+  obstack_1grow (&frags, datum);                       \

 }
 #else
 }
 #else

-extern void frag_append_1_char PARAMS ((int));
+extern void frag_append_1_char (int);

 #define FRAG_APPEND_1_CHAR(X) frag_append_1_char (X)
 #endif
 
 #define FRAG_APPEND_1_CHAR(X) frag_append_1_char (X)
 #endif
 

-
-void frag_init PARAMS ((void));
-fragS *frag_alloc PARAMS ((struct obstack *));
-void frag_grow PARAMS ((unsigned int nchars));
-char *frag_more PARAMS ((int nchars));
-void frag_align PARAMS ((int alignment, int fill_character, int max));
-void frag_align_pattern PARAMS ((int alignment,
-                                const char *fill_pattern,
-                                int n_fill,
-                                int max));
-void frag_new PARAMS ((int old_frags_var_max_size));
-void frag_wane PARAMS ((fragS * fragP));
-
-char *frag_variant PARAMS ((relax_stateT type,
-                           int max_chars,
-                           int var,
-                           relax_substateT subtype,
-                           symbolS * symbol,
-                           offsetT offset,
-                           char *opcode));
-
-char *frag_var PARAMS ((relax_stateT type,
-                       int max_chars,
-                       int var,
-                       relax_substateT subtype,
-                       symbolS * symbol,
-                       offsetT offset,
-                       char *opcode));
+void frag_init (void);
+fragS *frag_alloc (struct obstack *);
+void frag_grow (unsigned int nchars);
+char *frag_more (int nchars);
+void frag_align (int alignment, int fill_character, int max);
+void frag_align_pattern (int alignment, const char *fill_pattern,
+                        int n_fill, int max);
+void frag_align_code (int alignment, int max);
+void frag_new (int old_frags_var_max_size);
+void frag_wane (fragS * fragP);
+int frag_room (void);
+
+char *frag_variant (relax_stateT type,
+                   int max_chars,
+                   int var,
+                   relax_substateT subtype,
+                   symbolS * symbol,
+                   offsetT offset,
+                   char *opcode);
+
+char *frag_var (relax_stateT type,
+               int max_chars,
+               int var,
+               relax_substateT subtype,
+               symbolS * symbol,
+               offsetT offset,
+               char *opcode);

 
 #endif /* FRAGS_H */
 
 #endif /* FRAGS_H */