gas/subsegs.c

   1 /* subsegs.c - subsegments -
   2    Copyright (C) 1987, 1990, 1991, 1992 Free Software Foundation, Inc.
   3
   4    This file is part of GAS, the GNU Assembler.
   5
   6    GAS is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    GAS is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with GAS; see the file COPYING.  If not, write to
  18    the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 /*
  21  * Segments & sub-segments.
  22  */
  23
  24 #include "as.h"
  25
  26 #include "subsegs.h"
  27 #include "obstack.h"
  28
  29 #ifdef MANY_SEGMENTS
  30 segment_info_type segment_info[SEG_MAXIMUM_ORDINAL];
  31
  32 frchainS*       frchain_root,
  33     *   frchain_now;
  34
  35 #else
  36 frchainS*       frchain_root,
  37     *   frchain_now,    /* Commented in "subsegs.h". */
  38     *   data0_frchainP,
  39     *   bss0_frchainP;
  40
  41 #endif
  42 char * const /* in: segT   out: char* */
  43     seg_name[] = {
  44             "absolute",
  45 #ifdef MANY_SEGMENTS
  46             "e0","e1","e2","e3","e4","e5","e6","e7","e8","e9",
  47 #else
  48             "text",
  49             "data",
  50             "bss",
  51 #endif
  52             "unknown",
  53             "absent",
  54             "pass1",
  55             "ASSEMBLER-INTERNAL-LOGIC-ERROR!",
  56             "bignum/flonum",
  57             "difference",
  58             "debug",
  59             "transfert vector preload",
  60             "transfert vector postload",
  61             "register",
  62             "",
  63     }; /* Used by error reporters, dumpers etc. */
  64
  65 \f
  66 void
  67     subsegs_begin()
  68 {
  69         /* Check table(s) seg_name[], seg_N_TYPE[] is in correct order */
  70 #ifdef MANY_SEGMENTS
  71 #else
  72         know( SEG_ABSOLUTE      ==  0 );
  73         know( SEG_TEXT          ==  1 );
  74         know( SEG_DATA          ==  2 );
  75         know( SEG_BSS           ==  3 );
  76         know( SEG_UNKNOWN       ==  4 );
  77         know( SEG_ABSENT        ==  5 );
  78         know( SEG_PASS1 ==  6 );
  79         know( SEG_GOOF  ==  7 );
  80         know( SEG_BIG           ==  8 );
  81         know( SEG_DIFFERENCE    ==  9 );
  82         know( SEG_DEBUG == 10 );
  83         know( SEG_NTV           == 11 );
  84         know( SEG_PTV           == 12 );
  85         know( SEG_REGISTER      == 13 );
  86         know( SEG_MAXIMUM_ORDINAL == SEG_REGISTER );
  87         /*  know( segment_name (SEG_MAXIMUM_ORDINAL + 1) [0] == 0 );*/
  88 #endif
  89
  90         obstack_begin( &frags, 5000);
  91         frchain_root = NULL;
  92         frchain_now  = NULL;            /* Warn new_subseg() that we are booting. */
  93         /* Fake up 1st frag. */
  94         /* It won't be used=> is ok if obstack... */
  95         /* pads the end of it for alignment. */
  96         frag_now=(fragS *)obstack_alloc(&frags,SIZEOF_STRUCT_FRAG);
  97         memset(frag_now,  SIZEOF_STRUCT_FRAG, 0);
  98         /* This 1st frag will not be in any frchain. */
  99         /* We simply give subseg_new somewhere to scribble. */
 100         now_subseg = 42;                /* Lie for 1st call to subseg_new. */
 101 #ifdef MANY_SEGMENTS
 102         {
 103                 int i;
 104                 for (i = SEG_E0; i < SEG_UNKNOWN; i++) {
 105                         subseg_new(i, 0);
 106                         segment_info[i].frchainP = frchain_now;
 107                 }
 108         }
 109 #else
 110         subseg_new (SEG_DATA, 0);       /* .data 0 */
 111         data0_frchainP = frchain_now;
 112         subseg_new (SEG_BSS, 0);
 113         bss0_frchainP = frchain_now;
 114 #endif
 115
 116 }
 117 \f
 118 /*
 119  *                      subseg_change()
 120  *
 121  * Change the subsegment we are in, BUT DO NOT MAKE A NEW FRAG for the
 122  * subsegment. If we are already in the correct subsegment, change nothing.
 123  * This is used eg as a worker for subseg_new [which does make a new frag_now]
 124  * and for changing segments after we have read the source. We construct eg
 125  * fixSs even after the source file is read, so we do have to keep the
 126  * segment context correct.
 127  */
 128 void
 129     subseg_change (seg, subseg)
 130 register segT   seg;
 131 register int    subseg;
 132 {
 133         now_seg  = seg;
 134         now_subseg = subseg;
 135 #ifdef MANY_SEGMENTS
 136         seg_fix_rootP = & segment_info[seg].fix_root;
 137         seg_fix_tailP = & segment_info[seg].fix_tail;
 138 #else
 139         if (seg == SEG_BSS)
 140             {
 141                     seg_fix_rootP = & bss_fix_root;
 142                     seg_fix_tailP = & bss_fix_tail;
 143             }
 144         else if (seg == SEG_DATA)
 145             {
 146                     seg_fix_rootP = & data_fix_root;
 147                     seg_fix_tailP = & data_fix_tail;
 148             }
 149         else
 150             {
 151                     know (seg == SEG_TEXT);
 152                     seg_fix_rootP = & text_fix_root;
 153                     seg_fix_tailP = & text_fix_tail;
 154             }
 155 #endif
 156 }
 157 \f
 158 /*
 159  *                      subseg_new()
 160  *
 161  * If you attempt to change to the current subsegment, nothing happens.
 162  *
 163  * In:  segT, subsegT code for new subsegment.
 164  *      frag_now -> incomplete frag for current subsegment.
 165  *      If frag_now==NULL, then there is no old, incomplete frag, so
 166  *      the old frag is not closed off.
 167  *
 168  * Out: now_subseg, now_seg updated.
 169  *      Frchain_now points to the (possibly new) struct frchain for this
 170  *      sub-segment.
 171  *      Frchain_root updated if needed.
 172  */
 173
 174 void
 175     subseg_new (seg, subseg)    /* begin assembly for a new sub-segment */
 176 register segT   seg;    /* SEG_DATA or SEG_TEXT or SEG_BSS */
 177 register subsegT        subseg;
 178 {
 179         long tmp;               /* JF for obstack alignment hacking */
 180 #ifndef MANY_SEGMENTS
 181         know( seg == SEG_DATA || seg == SEG_TEXT || seg == SEG_BSS);
 182 #endif
 183         if (seg != now_seg || subseg != now_subseg)
 184             {                           /* we just changed sub-segments */
 185                     register    frchainS *      frcP;   /* crawl frchain chain */
 186                     register    frchainS**      lastPP; /* address of last pointer */
 187                     frchainS *  newP;   /* address of new frchain */
 188                     register fragS *            former_last_fragP;
 189                     register fragS *            new_fragP;
 190
 191                     if (frag_now)               /* If not bootstrapping. */
 192                         {
 193                                 frag_now -> fr_fix = obstack_next_free(& frags) - frag_now -> fr_literal;
 194                                 frag_wane(frag_now);    /* Close off any frag in old subseg. */
 195                         }
 196                     /*
 197                      * It would be nice to keep an obstack for each subsegment, if we swap
 198                      * subsegments a lot. Hence we would have much fewer frag_wanes().
 199                      */
 200                     {
 201
 202                             obstack_finish( &frags);
 203                             /*
 204                              * If we don't do the above, the next object we put on obstack frags
 205                              * will appear to start at the fr_literal of the current frag.
 206                              * Also, above ensures that the next object will begin on a
 207                              * address that is aligned correctly for the engine that runs
 208                              * this program.
 209                              */
 210                     }
 211                     subseg_change (seg, (int)subseg);
 212                     /*
 213                      * Attempt to find or make a frchain for that sub seg.
 214                      * Crawl along chain of frchainSs, begins @ frchain_root.
 215                      * If we need to make a frchainS, link it into correct
 216                      * position of chain rooted in frchain_root.
 217                      */
 218                     for (frcP = * (lastPP = & frchain_root);
 219                          frcP
 220                          && (int)(frcP -> frch_seg) <= (int)seg;
 221                          frcP = * ( lastPP = & frcP -> frch_next)
 222                          )
 223                         {
 224                                 if (   (int)(frcP -> frch_seg) == (int)seg
 225                                     && frcP -> frch_subseg >= subseg)
 226                                     {
 227                                             break;
 228                                     }
 229                         }
 230                     /*
 231                      * frcP:            Address of the 1st frchainS in correct segment with
 232                      *          frch_subseg >= subseg.
 233                      *          We want to either use this frchainS, or we want
 234                      *          to insert a new frchainS just before it.
 235                      *
 236                      *          If frcP==NULL, then we are at the end of the chain
 237                      *          of frchainS-s. A NULL frcP means we fell off the end
 238                      *          of the chain looking for a
 239                      *          frch_subseg >= subseg, so we
 240                      *          must make a new frchainS.
 241                      *
 242                      *          If we ever maintain a pointer to
 243                      *          the last frchainS in the chain, we change that pointer
 244                      *          ONLY when frcP==NULL.
 245                      *
 246                      * lastPP:  Address of the pointer with value frcP;
 247                      *          Never NULL.
 248                      *          May point to frchain_root.
 249                      *
 250                      */
 251                     if (   ! frcP
 252                         || (   (int)(frcP -> frch_seg) > (int)seg
 253                             || frcP->frch_subseg > subseg)) /* Kinky logic only works with 2 segments. */
 254                         {
 255                                 /*
 256                                  * This should be the only code that creates a frchainS.
 257                                  */
 258                                 newP=(frchainS *)obstack_alloc(&frags,sizeof(frchainS));
 259                                 memset(newP, sizeof(frchainS), 0);
 260                                 /* This begines on a good boundary */
 261                                 /* because a obstack_done() preceeded  it. */
 262                                 /* It implies an obstack_done(), so we */
 263                                 /* expect the next object allocated to */
 264                                 /* begin on a correct boundary. */
 265                                 *lastPP = newP;
 266                                 newP -> frch_next = frcP; /* perhaps NULL */
 267                                 (frcP = newP) -> frch_subseg            = subseg;
 268                                 newP  -> frch_seg               = seg;
 269                                 newP  -> frch_last              = NULL;
 270                         }
 271                     /*
 272                      * Here with frcP ->ing to the frchainS for subseg.
 273                      */
 274                     frchain_now = frcP;
 275                     /*
 276                      * Make a fresh frag for the subsegment.
 277                      */
 278                     /* We expect this to happen on a correct */
 279                     /* boundary since it was proceeded by a */
 280                     /* obstack_done(). */
 281                     tmp=obstack_alignment_mask(&frags); /* JF disable alignment */
 282                     obstack_alignment_mask(&frags)=0;
 283                     frag_now=(fragS *)obstack_alloc(&frags,SIZEOF_STRUCT_FRAG);
 284                     obstack_alignment_mask(&frags)=tmp;
 285                     /* know( frags . obstack_c_next_free == frag_now -> fr_literal ); */
 286                     /* But we want any more chars to come */
 287                     /* immediately after the structure we just made. */
 288                     new_fragP = frag_now;
 289                     new_fragP -> fr_next = NULL;
 290                     /*
 291                      * Append new frag to current frchain.
 292                      */
 293                     former_last_fragP = frcP -> frch_last;
 294                     if (former_last_fragP)
 295                         {
 296                                 know( former_last_fragP -> fr_next == NULL );
 297                                 know( frchain_now -> frch_root );
 298                                 former_last_fragP -> fr_next = new_fragP;
 299                         }
 300                     else
 301                         {
 302                                 frcP -> frch_root = new_fragP;
 303                         }
 304                     frcP -> frch_last = new_fragP;
 305             }                           /* if (changing subsegments) */
 306 }                               /* subseg_new() */
 307
 308 /*
 309  * Local Variables:
 310  * comment-column: 0
 311  * fill-column: 131
 312  * End:
 313  */
 314
 315 /* end of subsegs.c */