gas/subsegs.c

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