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
  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 if (seg == SEG_TEXT)
 142             {
 143                     seg_fix_rootP = & text_fix_root;
 144                     seg_fix_tailP = & text_fix_tail;
 145             }
 146         else {
 147                     know (seg == SEG_BSS);
 148                     seg_fix_rootP = & bss_fix_root;
 149                     seg_fix_tailP = & bss_fix_tail;
 150             }
 151 #endif
 152 }
 153 \f
 154 /*
 155  *                      subseg_new()
 156  *
 157  * If you attempt to change to the current subsegment, nothing happens.
 158  *
 159  * In:  segT, subsegT code for new subsegment.
 160  *      frag_now -> incomplete frag for current subsegment.
 161  *      If frag_now==NULL, then there is no old, incomplete frag, so
 162  *      the old frag is not closed off.
 163  *
 164  * Out: now_subseg, now_seg updated.
 165  *      Frchain_now points to the (possibly new) struct frchain for this
 166  *      sub-segment.
 167  *      Frchain_root updated if needed.
 168  */
 169
 170 void
 171     subseg_new (seg, subseg)    /* begin assembly for a new sub-segment */
 172 register segT   seg; /* SEG_DATA or SEG_TEXT */
 173 register subsegT        subseg;
 174 {
 175         long tmp;               /* JF for obstack alignment hacking */
 176 #ifndef MANY_SEGMENTS
 177         know(seg == SEG_DATA || seg == SEG_TEXT || seg == SEG_BSS);
 178 #endif
 179 #ifdef OBJ_AOUT
 180 /* If -R specifed, always put stuff into the data section */
 181         if (flagseen['R'])
 182         {
 183           if (seg == SEG_DATA)
 184           {
 185             subseg += 1000;
 186             seg = SEG_TEXT;
 187           }
 188         }
 189 #endif
 190         if (seg != now_seg || subseg != now_subseg)
 191             {                           /* we just changed sub-segments */
 192                     register    frchainS *      frcP;   /* crawl frchain chain */
 193                     register    frchainS**      lastPP; /* address of last pointer */
 194                     frchainS *  newP;   /* address of new frchain */
 195                     register fragS *            former_last_fragP;
 196                     register fragS *            new_fragP;
 197
 198                     if (frag_now)               /* If not bootstrapping. */
 199                         {
 200                                 frag_now -> fr_fix = obstack_next_free(& frags) - frag_now -> fr_literal;
 201                                 frag_wane(frag_now);    /* Close off any frag in old subseg. */
 202                         }
 203                     /*
 204                      * It would be nice to keep an obstack for each subsegment, if we swap
 205                      * subsegments a lot. Hence we would have much fewer frag_wanes().
 206                      */
 207                     {
 208
 209                             obstack_finish( &frags);
 210                             /*
 211                              * If we don't do the above, the next object we put on obstack frags
 212                              * will appear to start at the fr_literal of the current frag.
 213                              * Also, above ensures that the next object will begin on a
 214                              * address that is aligned correctly for the engine that runs
 215                              * this program.
 216                              */
 217                     }
 218                     subseg_change (seg, (int)subseg);
 219                     /*
 220                      * Attempt to find or make a frchain for that sub seg.
 221                      * Crawl along chain of frchainSs, begins @ frchain_root.
 222                      * If we need to make a frchainS, link it into correct
 223                      * position of chain rooted in frchain_root.
 224                      */
 225                     for (frcP = * (lastPP = & frchain_root);
 226                          frcP
 227                          && (int)(frcP -> frch_seg) <= (int)seg;
 228                          frcP = * ( lastPP = & frcP -> frch_next)
 229                          )
 230                         {
 231                                 if (   (int)(frcP -> frch_seg) == (int)seg
 232                                     && frcP -> frch_subseg >= subseg)
 233                                     {
 234                                             break;
 235                                     }
 236                         }
 237                     /*
 238                      * frcP:            Address of the 1st frchainS in correct segment with
 239                      *          frch_subseg >= subseg.
 240                      *          We want to either use this frchainS, or we want
 241                      *          to insert a new frchainS just before it.
 242                      *
 243                      *          If frcP==NULL, then we are at the end of the chain
 244                      *          of frchainS-s. A NULL frcP means we fell off the end
 245                      *          of the chain looking for a
 246                      *          frch_subseg >= subseg, so we
 247                      *          must make a new frchainS.
 248                      *
 249                      *          If we ever maintain a pointer to
 250                      *          the last frchainS in the chain, we change that pointer
 251                      *          ONLY when frcP==NULL.
 252                      *
 253                      * lastPP:  Address of the pointer with value frcP;
 254                      *          Never NULL.
 255                      *          May point to frchain_root.
 256                      *
 257                      */
 258                     if (   ! frcP
 259                         || (   (int)(frcP -> frch_seg) > (int)seg
 260                             || frcP->frch_subseg > subseg)) /* Kinky logic only works with 2 segments. */
 261                         {
 262                                 /*
 263                                  * This should be the only code that creates a frchainS.
 264                                  */
 265                                 newP=(frchainS *)obstack_alloc(&frags,sizeof(frchainS));
 266                                 memset(newP, sizeof(frchainS), 0);
 267                                 /* This begines on a good boundary */
 268                                 /* because a obstack_done() preceeded  it. */
 269                                 /* It implies an obstack_done(), so we */
 270                                 /* expect the next object allocated to */
 271                                 /* begin on a correct boundary. */
 272                                 *lastPP = newP;
 273                                 newP -> frch_next = frcP; /* perhaps NULL */
 274                                 (frcP = newP) -> frch_subseg            = subseg;
 275                                 newP  -> frch_seg               = seg;
 276                                 newP  -> frch_last              = NULL;
 277                         }
 278                     /*
 279                      * Here with frcP ->ing to the frchainS for subseg.
 280                      */
 281                     frchain_now = frcP;
 282                     /*
 283                      * Make a fresh frag for the subsegment.
 284                      */
 285                     /* We expect this to happen on a correct */
 286                     /* boundary since it was proceeded by a */
 287                     /* obstack_done(). */
 288                     tmp=obstack_alignment_mask(&frags); /* JF disable alignment */
 289                     obstack_alignment_mask(&frags)=0;
 290                     frag_now=(fragS *)obstack_alloc(&frags,SIZEOF_STRUCT_FRAG);
 291                     obstack_alignment_mask(&frags)=tmp;
 292                     /* know( frags . obstack_c_next_free == frag_now -> fr_literal ); */
 293                     /* But we want any more chars to come */
 294                     /* immediately after the structure we just made. */
 295                     new_fragP = frag_now;
 296                     new_fragP -> fr_next = NULL;
 297                     /*
 298                      * Append new frag to current frchain.
 299                      */
 300                     former_last_fragP = frcP -> frch_last;
 301                     if (former_last_fragP)
 302                         {
 303                                 know( former_last_fragP -> fr_next == NULL );
 304                                 know( frchain_now -> frch_root );
 305                                 former_last_fragP -> fr_next = new_fragP;
 306                         }
 307                     else
 308                         {
 309                                 frcP -> frch_root = new_fragP;
 310                         }
 311                     frcP -> frch_last = new_fragP;
 312             }                           /* if (changing subsegments) */
 313 }                               /* subseg_new() */
 314
 315 /*
 316  * Local Variables:
 317  * comment-column: 0
 318  * fill-column: 131
 319  * End:
 320  */
 321
 322 /* end of subsegs.c */