/* * frag_new() * * Call this to close off a completed frag, and start up a new (empty) * frag, in the same subsegment as the old frag. * [frchain_now remains the same but frag_now is updated.] * Because this calculates the correct value of fr_fix by * looking at the obstack 'frags', it needs to know how many * characters at the end of the old frag belong to (the maximal) * fr_var: the rest must belong to fr_fix. * It doesn't actually set up the old frag's fr_var: you may have * set fr_var == 1, but allocated 10 chars to the end of the frag: * in this case you pass old_frags_var_max_size == 10. * * Make a new frag, initialising some components. Link new frag at end * of frchain_now. */ void frag_new( int old_frags_var_max_size) /* Number of chars (already allocated on obstack frags) in variable_length part of frag. */ { register fragS * former_last_fragP; /* char *throw_away_pointer; JF unused */ register frchainS * frchP; long tmp; /* JF */ if(frags.chunk_size == 0) { know(flagseen['n']); as_fatal("with -n a section directive must be seen before assembly " "can begin"); } frag_now->fr_fix = (char *) (obstack_next_free (&frags)) - (frag_now->fr_literal) - old_frags_var_max_size; /* Fix up old frag's fr_fix. */ obstack_finish (&frags); /* This will align the obstack so the */ /* next struct we allocate on it will */ /* begin at a correct boundary. */ frchP = frchain_now; know (frchP); former_last_fragP = frchP->frch_last; know (former_last_fragP); know (former_last_fragP == frag_now); obstack_blank (&frags, SIZEOF_STRUCT_FRAG); /* We expect this will begin at a correct */ /* boundary for a struct. */ tmp=obstack_alignment_mask(&frags); obstack_alignment_mask(&frags)=0; /* Turn off alignment */ /* If we ever hit a machine where strings must be aligned, we Lose Big */ frag_now=(fragS *)obstack_finish(&frags); obstack_alignment_mask(&frags)=tmp; /* Restore alignment */ /* Just in case we don't get zero'd bytes */ memset(frag_now, '\0', SIZEOF_STRUCT_FRAG); /* obstack_unaligned_done (&frags, &frag_now); */ /* know (frags.obstack_c_next_free == frag_now->fr_literal); */ /* Generally, frag_now->points to an */ /* address rounded up to next alignment. */ /* However, characters will add to obstack */ /* frags IMMEDIATELY after the struct frag, */ /* even if they are not starting at an */ /* alignment address. */ former_last_fragP->fr_next = frag_now; frchP->frch_last = frag_now; frag_now->fr_next = NULL; } /* frag_new() */
fragS * frag_alloc (struct obstack *ob) { fragS *ptr; int oalign; (void) obstack_alloc (ob, 0); oalign = obstack_alignment_mask (ob); obstack_alignment_mask (ob) = 0; ptr = (fragS *) obstack_alloc (ob, SIZEOF_STRUCT_FRAG); obstack_alignment_mask (ob) = oalign; memset (ptr, 0, SIZEOF_STRUCT_FRAG); return ptr; }
void ArrayPtrNew(ArrayPtr *arr) { arr->obstackPtr = (struct obstack *) malloc (sizeof (struct obstack)); obstack_init (arr->obstackPtr); obstack_alloc_failed_handler =&ArrayPtrAllocFailed; obstack_alignment_mask(arr->obstackPtr)=0; arr->totalNum=0; }
void subsegs_begin () { /* Check table(s) seg_name[], seg_N_TYPE[] is in correct order */ #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER) know (SEG_ABSOLUTE == 0); know (SEG_TEXT == 1); know (SEG_DATA == 2); know (SEG_BSS == 3); know (SEG_UNKNOWN == 4); know (SEG_GOOF == 5); know (SEG_EXPR == 6); know (SEG_DEBUG == 7); know (SEG_NTV == 8); know (SEG_PTV == 9); know (SEG_REGISTER == 10); know (SEG_MAXIMUM_ORDINAL == SEG_REGISTER); #endif obstack_begin (&frchains, chunksize); #if __GNUC__ >= 2 obstack_alignment_mask (&frchains) = __alignof__ (frchainS) - 1; #endif frchain_root = NULL; frchain_now = NULL; /* Warn new_subseg() that we are booting. */ frag_now = &dummy_frag; #ifndef BFD_ASSEMBLER now_subseg = 42; /* Lie for 1st call to subseg_new. */ #ifdef MANY_SEGMENTS { int i; for (i = SEG_E0; i < SEG_UNKNOWN; i++) { subseg_set (i, 0); segment_info[i].frchainP = frchain_now; } } #else subseg_set (SEG_DATA, 0); /* .data 0 */ data0_frchainP = frchain_now; subseg_set (SEG_BSS, 0); bss0_frchainP = frchain_now; #endif /* ! MANY_SEGMENTS */ #endif /* ! BFD_ASSEMBLER */ absolute_frchain.frch_seg = absolute_section; absolute_frchain.frch_subseg = 0; #ifdef BFD_ASSEMBLER absolute_frchain.fix_root = absolute_frchain.fix_tail = 0; #endif absolute_frchain.frch_frag_now = &zero_address_frag; absolute_frchain.frch_root = absolute_frchain.frch_last = &zero_address_frag; }
static void subseg_set_rest (segT seg, subsegT subseg) { frchainS *frcP; /* crawl frchain chain */ frchainS **lastPP; /* address of last pointer */ frchainS *newP; /* address of new frchain */ segment_info_type *seginfo; mri_common_symbol = NULL; if (frag_now && frchain_now) frchain_now->frch_frag_now = frag_now; gas_assert (frchain_now == 0 || frchain_now->frch_last == frag_now); subseg_change (seg, (int) subseg); seginfo = seg_info (seg); /* Attempt to find or make a frchain for that subsection. We keep the list sorted by subsection number. */ for (frcP = *(lastPP = &seginfo->frchainP); frcP != NULL; frcP = *(lastPP = &frcP->frch_next)) if (frcP->frch_subseg >= subseg) break; if (frcP == NULL || frcP->frch_subseg != subseg) { /* This should be the only code that creates a frchainS. */ newP = (frchainS *) obstack_alloc (&frchains, sizeof (frchainS)); newP->frch_subseg = subseg; newP->fix_root = NULL; newP->fix_tail = NULL; obstack_begin (&newP->frch_obstack, chunksize); #if __GNUC__ >= 2 obstack_alignment_mask (&newP->frch_obstack) = __alignof__ (fragS) - 1; #endif newP->frch_frag_now = frag_alloc (&newP->frch_obstack); newP->frch_frag_now->fr_type = rs_fill; newP->frch_cfi_data = NULL; newP->frch_root = newP->frch_last = newP->frch_frag_now; *lastPP = newP; newP->frch_next = frcP; frcP = newP; } frchain_now = frcP; frag_now = frcP->frch_frag_now; gas_assert (frchain_now->frch_last == frag_now); }
void subsegs_begin (void) { obstack_begin (&frchains, chunksize); #if __GNUC__ >= 2 obstack_alignment_mask (&frchains) = __alignof__ (frchainS) - 1; #endif frchain_now = NULL; /* Warn new_subseg() that we are booting. */ frag_now = &dummy_frag; }
mem_String mem_create_strings( void ) { stringInfo info = xmalloc( sizeof( struct stringInfo ) ); #if MAA_MAGIC info->magic = MEM_STRINGS_MAGIC; #endif info->count = 0; info->bytes = 0; info->obstack = xmalloc( sizeof( struct obstack ) ); obstack_init( info->obstack ); obstack_alignment_mask( info->obstack ) = 0; /* no alignment for chars */ return info; }
cpp_hash_table * ht_create (unsigned int order) { unsigned int nslots = 1 << order; cpp_hash_table *table; table = XCNEW (cpp_hash_table); /* Strings need no alignment. */ obstack_specify_allocation (&table->stack, 0, 0, xmalloc, free); obstack_alignment_mask (&table->stack) = 0; table->entries = XCNEWVEC (hashnode, nslots); table->entries_owned = true; table->nslots = nslots; return table; }
hash_table * ht_create (unsigned int order) { unsigned int nslots = 1 << order; hash_table *table; table = XCNEW (hash_table); /* Strings need no alignment. */ _obstack_begin (&table->stack, 0, 0, (void *(*) (long)) xmalloc, (void (*) (void *)) free); obstack_alignment_mask (&table->stack) = 0; table->entries = XCNEWVEC (hashnode, nslots); table->entries_owned = true; table->nslots = nslots; return table; }