![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to read.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cctools / as|
Return to read.c CVS log | Up to [Apple XNU] / GNUtools / cctools / as |
1.1 ! root 1: /* read.c - read a source file - ! 2: Copyright (C) 1986,1987 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 1, 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: #define MASK_CHAR (0xFF) /* If your chars aren't 8 bits, you will ! 21: change this a bit. But then, GNU isn't ! 22: spozed to run on your machine anyway. ! 23: (RMS is so shortsighted sometimes.) ! 24: */ ! 25: ! 26: #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16) ! 27: /* This is the largest known floating point */ ! 28: /* format (for now). It will grow when we */ ! 29: /* do 4361 style flonums. */ ! 30: ! 31: ! 32: /* Routines that read assembler source text to build spagetti in memory. */ ! 33: /* Another group of these functions is in the expr.c module */ ! 34: ! 35: #include <ctype.h> ! 36: #include <string.h> ! 37: #include <stdlib.h> ! 38: #include <sys/types.h> ! 39: #include <sys/stat.h> ! 40: #include "stuff/round.h" ! 41: #include "as.h" ! 42: #include "flonum.h" ! 43: #include "struc-symbol.h" ! 44: #include "expr.h" ! 45: #include "read.h" ! 46: #include "hash.h" ! 47: #include "obstack.h" ! 48: #include "md.h" ! 49: #include "symbols.h" ! 50: #include "sections.h" ! 51: #include "input-scrub.h" ! 52: #include "input-file.h" ! 53: #include "hex_value.h" ! 54: #include "messages.h" ! 55: #include "xmalloc.h" ! 56: #include "app.h" ! 57: ! 58: /* ! 59: * Parsing of input is done off of this pointer which points to the next char ! 60: * of source file to parse. ! 61: */ ! 62: char *input_line_pointer = NULL; ! 63: ! 64: /* ! 65: * buffer_limit is the value returned by the input_scrub_next_buffer() in ! 66: * read_a_source_file() and is not static only so read_an_include_file can save ! 67: * and restore it. ! 68: */ ! 69: char *buffer_limit = NULL; /* -> 1 + last char in buffer. */ ! 70: ! 71: /* ! 72: * This table is used by the macros is_name_beginner() and is_part_of_name() ! 73: * defined in read.h . ! 74: */ ! 75: const char lex_type[256] = { ! 76: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ABCDEFGHIJKLMNO */ ! 77: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* PQRSTUVWXYZ[\]^_ */ ! 78: 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */ ! 79: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 0123456789:;<=>? */ ! 80: 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* @ABCDEFGHIJKLMNO */ ! 81: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 3, /* PQRSTUVWXYZ[\]^_ */ ! 82: 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* `abcdefghijklmno */ ! 83: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, /* pqrstuvwxyz{|}~. */ ! 84: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* Allow all chars */ ! 85: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* with the high bit */ ! 86: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* set in names */ ! 87: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ! 88: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ! 89: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ! 90: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 ! 91: }; ! 92: ! 93: /* ! 94: * In: a character. ! 95: * Out: TRUE if this character ends a line. ! 96: */ ! 97: #define _ (0) ! 98: static const char is_end_of_line[256] = { ! 99: _, _, _, _, _, _, _, _, _, _,99, _, _, _, _, _, /* @abcdefghijklmno */ ! 100: _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* */ ! 101: _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* */ ! 102: _, _, _, _, _, _, _, _, _, _, _,99, _, _, _, _, /* 0123456789:;<=>? */ ! 103: #if defined(M88K) || defined(M98K) || defined(HPPA) ! 104: 99, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* @ABCDEFGHIJKLMNO */ ! 105: #else ! 106: _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* */ ! 107: #endif ! 108: _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* */ ! 109: _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* */ ! 110: _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* */ ! 111: _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* */ ! 112: _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* */ ! 113: _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* */ ! 114: _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* */ ! 115: _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ /* */ ! 116: }; ! 117: #undef _ ! 118: ! 119: /* ! 120: * The conditional assembly feature (.if, .else, .elseif and .endif) is ! 121: * implemented with cond_state that tells us what we are in the middle of ! 122: * processing. ignore can be either TRUE or FALSE. When TRUE we are ignoring ! 123: * the block of code in the middle of a conditional. MAX_IF_DEPTH is the ! 124: * maximum depth that if's can be nested. ! 125: */ ! 126: #define MAX_IF_DEPTH 20 ! 127: typedef enum { ! 128: no_cond, /* no conditional is being processed */ ! 129: if_cond, /* inside if conditional */ ! 130: elseif_cond,/* inside elseif conditional */ ! 131: else_cond /* inside else conditional */ ! 132: }cond_type; ! 133: ! 134: struct cond_state { ! 135: cond_type the_cond; ! 136: int cond_met; ! 137: int ignore; ! 138: }; ! 139: typedef struct cond_state cond_stateS; ! 140: static cond_stateS the_cond_state = {no_cond, FALSE, FALSE}; ! 141: static cond_stateS last_states[MAX_IF_DEPTH]; ! 142: static int if_depth = 0; ! 143: ! 144: /* ! 145: * Assembler macros are implemented with these variables and functions. ! 146: */ ! 147: #define MAX_MACRO_DEPTH 20 ! 148: static int macro_depth = 0; ! 149: static struct hash_control ! 150: *ma_hash = NULL; /* use before set up: NULL-> address error */ ! 151: static struct obstack macros; /* obstack for macro text */ ! 152: static char *macro_name = NULL; /* name of macro we are defining */ ! 153: static int count_lines = TRUE; /* turns line number counting on and off */ ! 154: static int macros_on = TRUE; /* .macros_on and .macros_off toggles this to ! 155: allow macros to be turned off, which allows ! 156: macros to override a machine instruction and ! 157: still use it. */ ! 158: static void expand_macro(char *macro_contents); ! 159: static void macro_begin(void); ! 160: ! 161: ! 162: /* ! 163: * The .dump and .load feature is implemented with these variables and ! 164: * functions. ! 165: */ ! 166: static FILE *dump_fp = NULL; ! 167: static char *write_macro(char *string, char *value); ! 168: static char * write_symbol(char *string, char *value); ! 169: ! 170: ! 171: /* Functions private to this file */ ! 172: static void parse_a_buffer(char *buffer); ! 173: static void parse_line_comment(char **buffer); ! 174: static segT get_segmented_expression(expressionS *expP); ! 175: static void pseudo_op_begin(void); ! 176: static void pseudo_set(symbolS *symbolP); ! 177: static void stab(int what); ! 178: static char get_absolute_expression_and_terminator(long *val_pointer); ! 179: static char *demand_copy_C_string(int *len_pointer); ! 180: static char *demand_copy_string(int *lenP); ! 181: static int is_it_end_of_statement(void); ! 182: static void equals(char *sym_name); ! 183: static int next_char_of_string(void); ! 184: ! 185: #ifdef M68K /* we allow big cons only on the 68k machines */ ! 186: /* ! 187: * This is setup by read_begin() and used by big_cons() with using grow_bignum() ! 188: * to make it bigger if needed. ! 189: */ ! 190: #define BIGNUM_BEGIN_SIZE (16) ! 191: static char *bignum_low; /* Lowest char of bignum. */ ! 192: static char *bignum_limit;/* 1st illegal address of bignum. */ ! 193: static char *bignum_high; /* Highest char of bignum, may point to ! 194: (bignum_start-1), never >= bignum_limit. */ ! 195: static void grow_bignum(void); ! 196: #endif /* M68K */ ! 197: /* ! 198: * This is set in read_a_source_file() to the section number of the text section ! 199: * for used by the machine dependent md_assemble() to create line number stabs ! 200: * for assembly instructions in the text section when -g is seen. ! 201: */ ! 202: unsigned long text_nsect = 0; ! 203: ! 204: /* ! 205: * These are the names of the section types used by the .section directive. ! 206: */ ! 207: struct type_name { ! 208: char *name; ! 209: unsigned type; ! 210: }; ! 211: static struct type_name type_names[] = { ! 212: { "regular", S_REGULAR }, ! 213: { "cstring_literals", S_CSTRING_LITERALS }, ! 214: { "4byte_literals", S_4BYTE_LITERALS }, ! 215: { "8byte_literals", S_8BYTE_LITERALS }, ! 216: { "literal_pointers", S_LITERAL_POINTERS }, ! 217: { "non_lazy_symbol_pointers", S_NON_LAZY_SYMBOL_POINTERS }, ! 218: { "lazy_symbol_pointers", S_LAZY_SYMBOL_POINTERS }, ! 219: { "symbol_stubs", S_SYMBOL_STUBS }, ! 220: { "mod_init_funcs", S_MOD_INIT_FUNC_POINTERS }, ! 221: { NULL, 0 } ! 222: }; ! 223: ! 224: /* ! 225: * These are the names of the section attributes used by the .section directive. ! 226: */ ! 227: struct attribute_name { ! 228: char *name; ! 229: unsigned attribute; ! 230: }; ! 231: static struct attribute_name attribute_names[] = { ! 232: { "none", 0 }, ! 233: { "pure_instructions", S_ATTR_PURE_INSTRUCTIONS }, ! 234: { "reloc_at_launch", S_ATTR_RELOC_AT_LAUNCH }, ! 235: { NULL, 0 } ! 236: }; ! 237: ! 238: /* ! 239: * These are the built in sections know to the assembler with a directive. ! 240: * They are known as which segment and section name as well as the type & ! 241: * attribute, and default alignment. ! 242: */ ! 243: struct builtin_section { ! 244: char *directive; ! 245: char *segname; ! 246: char *sectname; ! 247: unsigned long flags; /* type & attribute */ ! 248: unsigned long default_align; ! 249: unsigned long sizeof_stub; ! 250: }; ! 251: static const struct builtin_section builtin_sections[] = { ! 252: /* ! 253: * The text section must be first in this list as it is used by ! 254: * read_a_source_file() to do the equivalent of a .text at the start ! 255: * of the file and for s_builtin_section() to set S_ATTR_PURE_INSTRUCTIONS. ! 256: */ ! 257: { "text", "__TEXT", "__text" }, ! 258: { "const", "__TEXT", "__const" }, ! 259: { "static_const", "__TEXT", "__static_const" }, ! 260: { "cstring", "__TEXT", "__cstring", S_CSTRING_LITERALS }, ! 261: { "literal4", "__TEXT", "__literal4", S_4BYTE_LITERALS, 2 }, ! 262: { "literal8", "__TEXT", "__literal8", S_8BYTE_LITERALS, 3 }, ! 263: { "constructor", "__TEXT", "__constructor" }, ! 264: { "destructor", "__TEXT", "__destructor" }, ! 265: { "fvmlib_init0", "__TEXT", "__fvmlib_init0" }, ! 266: { "fvmlib_init1", "__TEXT", "__fvmlib_init1" }, ! 267: { "mod_init_func", "__TEXT", "__mod_init_func", ! 268: S_MOD_INIT_FUNC_POINTERS, 2 }, ! 269: { "symbol_stub", "__TEXT", "__symbol_stub", ! 270: S_SYMBOL_STUBS | S_ATTR_PURE_INSTRUCTIONS, ! 271: #if defined(M68K) ! 272: 1, 20 ! 273: #endif ! 274: #if defined(I386) ! 275: 0, 16 ! 276: #endif ! 277: #if defined(HPPA) ! 278: 2, 28 ! 279: #endif ! 280: #if defined(SPARC) ! 281: 2, 30 ! 282: #endif ! 283: }, ! 284: { "picsymbol_stub", "__TEXT", "__picsymbol_stub", ! 285: S_SYMBOL_STUBS | S_ATTR_PURE_INSTRUCTIONS, ! 286: #if defined(M68K) ! 287: 1, 24 ! 288: #endif ! 289: #if defined(I386) ! 290: 0, 26 ! 291: #endif ! 292: #if defined(HPPA) ! 293: 2, 32 ! 294: #endif ! 295: #if defined(SPARC) ! 296: 2, 40 ! 297: #endif ! 298: }, ! 299: { "non_lazy_symbol_pointer","__DATA","__nl_symbol_ptr", ! 300: S_NON_LAZY_SYMBOL_POINTERS, 2 }, ! 301: { "lazy_symbol_pointer", "__DATA", "__la_symbol_ptr", ! 302: S_LAZY_SYMBOL_POINTERS, 2 }, ! 303: { "dyld", "__DATA", "__dyld" }, ! 304: { "data", "__DATA", "__data" }, ! 305: { "static_data", "__DATA", "__static_data" }, ! 306: { "objc_class", "__OBJC", "__class" }, ! 307: { "objc_meta_class", "__OBJC", "__meta_class" }, ! 308: { "objc_string_object", "__OBJC", "__string_object" }, ! 309: { "objc_protocol", "__OBJC", "__protocol" }, ! 310: { "objc_cat_cls_meth", "__OBJC", "__cat_cls_meth" }, ! 311: { "objc_cat_inst_meth", "__OBJC", "__cat_inst_meth" }, ! 312: { "objc_cls_meth", "__OBJC", "__cls_meth" }, ! 313: { "objc_inst_meth", "__OBJC", "__inst_meth" }, ! 314: { "objc_message_refs", "__OBJC", "__message_refs", S_LITERAL_POINTERS, 2}, ! 315: { "objc_cls_refs", "__OBJC", "__cls_refs", S_LITERAL_POINTERS, 2}, ! 316: { "objc_class_names", "__OBJC", "__class_names", S_CSTRING_LITERALS }, ! 317: { "objc_module_info", "__OBJC", "__module_info" }, ! 318: { "objc_symbols", "__OBJC", "__symbols" }, ! 319: { "objc_category", "__OBJC", "__category" }, ! 320: { "objc_meth_var_types", "__OBJC", "__meth_var_types", S_CSTRING_LITERALS }, ! 321: { "objc_class_vars", "__OBJC", "__class_vars" }, ! 322: { "objc_instance_vars", "__OBJC", "__instance_vars" }, ! 323: { "objc_meth_var_names", "__OBJC", "__meth_var_names", S_CSTRING_LITERALS }, ! 324: { "objc_selector_strs", "__OBJC", "__selector_strs", S_CSTRING_LITERALS }, ! 325: { 0 } ! 326: }; ! 327: ! 328: /* set up pseudo-op tables */ ! 329: static struct hash_control *po_hash = NULL; ! 330: ! 331: #if !defined(I860) /* i860 has it's own align and org */ ! 332: static void s_align(int value); ! 333: static void s_org(int value); ! 334: #endif ! 335: static void s_private_extern(int value); ! 336: static void s_indirect_symbol(int value); ! 337: static void s_abort(int value); ! 338: static void s_comm(int value); ! 339: static void s_desc(int value); ! 340: static void s_file(int value); ! 341: static void s_fill(int value); ! 342: static void s_lcomm(int value); ! 343: static void s_lsym(int value); ! 344: static void s_set(int value); ! 345: static void s_reference(int value); ! 346: static void s_lazy_reference(int value); ! 347: static void s_include(int value); ! 348: static void s_dump(int value); ! 349: static void s_load(int value); ! 350: static void s_if(int value); ! 351: static void s_elseif(int value); ! 352: static void s_else(int value); ! 353: static void s_endif(int value); ! 354: static void s_macros_on(int value); ! 355: static void s_macros_off(int value); ! 356: static void s_section(int value); ! 357: static void s_zerofill(int value); ! 358: static unsigned long s_builtin_section(const struct builtin_section *s); ! 359: ! 360: /* ! 361: * The machine independent pseudo op table. ! 362: */ ! 363: static const pseudo_typeS pseudo_table[] = { ! 364: #if !defined(I860) /* i860 has it's own align and org */ ! 365: { "align", s_align, 0 }, ! 366: { "org", s_org, 0 }, ! 367: #endif ! 368: #ifndef M88K /* m88k has it's own abs that uses the s_abs() in here */ ! 369: { "abs", s_abs, 0 }, ! 370: #endif ! 371: { "private_extern", s_private_extern, 0}, ! 372: { "indirect_symbol", s_indirect_symbol, 0}, ! 373: { "abort", s_abort, 0 }, ! 374: { "ascii", stringer, 0 }, ! 375: { "asciz", stringer, 1 }, ! 376: { "byte", cons, 1 }, ! 377: { "comm", s_comm, 0 }, ! 378: { "desc", s_desc, 0 }, ! 379: { "double", float_cons, 'd' }, ! 380: { "file", s_file, 0 }, ! 381: { "fill", s_fill, 0 }, ! 382: { "globl", s_globl, 0 }, ! 383: { "lcomm", s_lcomm, 0 }, ! 384: { "line", s_line, 0 }, ! 385: { "long", cons, 4 }, ! 386: { "lsym", s_lsym, 0 }, ! 387: { "section", s_section, 0 }, ! 388: { "zerofill", s_zerofill, 0 }, ! 389: { "set", s_set, 0 }, ! 390: { "short", cons, 2 }, ! 391: { "single", float_cons, 'f' }, ! 392: { "space", s_space, 0 }, ! 393: { "stabd", stab, 'd' }, ! 394: { "stabn", stab, 'n' }, ! 395: { "stabs", stab, 's' }, ! 396: { "reference",s_reference, 0 }, ! 397: { "lazy_reference",s_lazy_reference, 0 }, ! 398: { "include", s_include, 0 }, ! 399: { "macro", s_macro, 0 }, ! 400: { "endmacro", s_endmacro, 0 }, ! 401: { "macros_on",s_macros_on, 0 }, ! 402: { "macros_off",s_macros_off, 0 }, ! 403: { "if", s_if, 0 }, ! 404: { "elseif", s_elseif, 0 }, ! 405: { "else", s_else, 0 }, ! 406: { "endif", s_endif, 0 }, ! 407: { "dump", s_dump, 0 }, ! 408: { "load", s_load, 0 }, ! 409: { NULL } /* end sentinel */ ! 410: }; ! 411: ! 412: /* ! 413: * read_begin() initializes the assember to read assembler source input. ! 414: */ ! 415: void ! 416: read_begin( ! 417: void) ! 418: { ! 419: pseudo_op_begin(); ! 420: macro_begin(); ! 421: obstack_begin(¬es, 5000); ! 422: ! 423: #ifdef M68K /* we allow big cons only on the 68k machines */ ! 424: bignum_low = xmalloc((long)BIGNUM_BEGIN_SIZE); ! 425: bignum_limit = bignum_low + BIGNUM_BEGIN_SIZE; ! 426: #endif ! 427: } ! 428: ! 429: /* ! 430: * pseudo_op_begin() creates a hash table of pseudo ops from the machine ! 431: * independent and machine dependent pseudo op tables. ! 432: */ ! 433: static ! 434: void ! 435: pseudo_op_begin( ! 436: void) ! 437: { ! 438: char *errtxt; ! 439: const pseudo_typeS *pop; ! 440: unsigned long i; ! 441: pseudo_typeS *sections_pseudo_table; ! 442: ! 443: po_hash = hash_new(); ! 444: errtxt = ""; ! 445: for(pop = pseudo_table; pop->poc_name && *errtxt == '\0'; pop++) ! 446: errtxt = hash_insert(po_hash, pop->poc_name, (char *)pop); ! 447: ! 448: for(pop = md_pseudo_table; pop->poc_name && *errtxt == '\0'; pop++) ! 449: errtxt = hash_insert(po_hash, pop->poc_name, (char *)pop); ! 450: ! 451: for(i = 0; builtin_sections[i].directive != NULL; i++) ! 452: ; ! 453: sections_pseudo_table = xmalloc((i + 1) * sizeof(pseudo_typeS)); ! 454: for(i = 0; builtin_sections[i].directive != NULL; i++){ ! 455: sections_pseudo_table[i].poc_name = builtin_sections[i].directive; ! 456: sections_pseudo_table[i].poc_handler = ! 457: (void (*)(int))s_builtin_section; ! 458: sections_pseudo_table[i].poc_val = (int)(builtin_sections + i); ! 459: } ! 460: sections_pseudo_table[i].poc_name = NULL; ! 461: for(pop = (const pseudo_typeS *)sections_pseudo_table; ! 462: pop->poc_name && *errtxt == '\0'; ! 463: pop++) ! 464: errtxt = hash_insert(po_hash, pop->poc_name, (char *)pop); ! 465: ! 466: if(*errtxt != '\0'){ ! 467: as_fatal("error constructing pseudo-op table (%s)", errtxt); ! 468: } ! 469: } ! 470: ! 471: /* ! 472: * The NeXT version of: read_a_source_file() ! 473: * ! 474: * This differs from the GNU version by taking the guts of the GNU ! 475: * read_a_source_file() (with the outer most loop removed) and renaming it ! 476: * parse_a_buffer(). With the NeXT version of read_a_source file simply ! 477: * containing that outer loop and a call to parse_a_buffer(). This is done ! 478: * So that expand_macro() and parse_line_comment() can call parse_a_buffer() ! 479: * with the buffers they create. ! 480: */ ! 481: void ! 482: read_a_source_file( ! 483: char *buffer) /* 1st character of each buffer of lines is here. */ ! 484: { ! 485: cond_stateS starting_cond_state; ! 486: short starting_if_depth; ! 487: ! 488: symbolS *symbolP; ! 489: ! 490: starting_cond_state = the_cond_state; ! 491: starting_if_depth = if_depth; ! 492: ! 493: /* Do not change segments or subsegments if this is a .include */ ! 494: if(doing_include == FALSE){ ! 495: /* ! 496: * This is a new file so switch start as if a .text was seen. This ! 497: * call to s_builtin_section() relys on the fact that the text ! 498: * section is first in the built in sections list. ! 499: */ ! 500: if(flagseen['n'] == FALSE) ! 501: text_nsect = s_builtin_section(builtin_sections); ! 502: ! 503: /* ! 504: * If the -g flag is present generate the lead stabs for this ! 505: * physical file that is not an include file. Each physical file's ! 506: * stabs are enclosed by a pair of source name stabs, N_SO, (one at ! 507: * the begining of the file with the name of the file and one at the ! 508: * end with the name ""). This is seen by nm(1) as: ! 509: * 00000000 - 01 0000 SO {standard input} ! 510: * ... ! 511: * 00000020 - 01 0000 SO ! 512: * To make the debugger work line numbers stabs, N_SLINE, must be ! 513: * contained "in a function" (after a function stab, N_FUN). To ! 514: * make a function stab work it must have a type number. Since type ! 515: * numbers 1 and 2 (the 1 in "int:t1=..." and the 2 in "char:t2=..." ! 516: * are "magic" to the debugger we use type 3 for the types of the ! 517: * function stabs we generate for each text label (see the routine ! 518: * make_stab_for_symbol() in symbols.c). So at lead stabs at the ! 519: * begining of each physical file include three type stabs, L_LSYM ! 520: * with the correct symbol name. The since we must have the types ! 521: * 1 and 2 they are just what the 'C' would produce but we don't ! 522: * use them. Type 3 is the void type like the 'C' compiler would ! 523: * produce which we use for the function stabs' type. These three ! 524: * look like this to nm(1): ! 525: * 00000000 - 00 0000 LSYM int:t1=r1;-2147483648;2147483647; ! 526: * 00000000 - 00 0000 LSYM char:t2=r2;0;127; ! 527: * 00000000 - 00 0000 LSYM void:t3=3 ! 528: * ! 529: * Then for each text label we see, make_stab_for_symbol() will ! 530: * generate a stab like this (for the example lable _main): ! 531: * 00000000 - 01 0007 FUN _main:F3 ! 532: * where the 'F' in F3 is an upper case 'F' for global labels and ! 533: * a lower case 'f' for non globals. ! 534: * ! 535: * Then for each instruction we assemble in the text we generate ! 536: * a line number, S_LINE, stab (see md_assembler in m68k.c, m88k.c ! 537: * etc). These look like: ! 538: * 00000000 - 01 0008 SLINE ! 539: * where the 0008 is the line number. ! 540: */ ! 541: if(flagseen['g']){ ! 542: symbolP = symbol_new( ! 543: physical_input_file, ! 544: 100 /* N_SO */, ! 545: text_nsect, ! 546: 0, ! 547: obstack_next_free(&frags) - frag_now->fr_literal, ! 548: frag_now); ! 549: symbolP = symbol_new( ! 550: "int:t1=r1;-2147483648;2147483647;", ! 551: 128 /* N_LSYM */, ! 552: 0,0,0, ! 553: &zero_address_frag); ! 554: symbolP = symbol_new( ! 555: "char:t2=r2;0;127;", ! 556: 128 /* N_LSYM */, ! 557: 0,0,0, ! 558: &zero_address_frag); ! 559: symbolP = symbol_new( ! 560: "void:t3=3", ! 561: 128 /* N_LSYM */, ! 562: 0,0,0, ! 563: &zero_address_frag); ! 564: } ! 565: } ! 566: else{ ! 567: /* ! 568: * If we are now reading an include file we will bracket it's ! 569: * stabs with a pair of: ! 570: * 00000010 - 01 0000 SOL include_file ! 571: * ... ! 572: * 0000001c - 01 0000 SOL previous_file ! 573: * We generate the first N_SOL here and the one for the ! 574: * previous_file in s_include() in read.c. ! 575: * ! 576: * CAVAT: This will only work if the include file starts off in the ! 577: * (__TEXT,__text) sections and ends in the (__TEXT,__text) section. ! 578: */ ! 579: if(flagseen['g'] && frchain_now->frch_nsect == text_nsect){ ! 580: symbolP = symbol_new( ! 581: physical_input_file, ! 582: 132 /* N_SOL */, ! 583: text_nsect, ! 584: 0, ! 585: obstack_next_free(&frags) - frag_now->fr_literal, ! 586: frag_now); ! 587: } ! 588: } ! 589: ! 590: while((buffer_limit = input_scrub_next_buffer(&buffer)) != NULL) ! 591: parse_a_buffer(buffer); ! 592: ! 593: if(the_cond_state.the_cond != starting_cond_state.the_cond || ! 594: the_cond_state.ignore != starting_cond_state.ignore|| ! 595: if_depth != starting_if_depth) ! 596: as_warn("file contains unmatched .ifs or .elses"); ! 597: ! 598: if(doing_include == FALSE){ ! 599: /* See the comment at the top of this routine for a description of ! 600: what is going on here */ ! 601: if(flagseen['n'] == FALSE) ! 602: text_nsect = s_builtin_section(builtin_sections); ! 603: if(flagseen['g']){ ! 604: (void)symbol_new( ! 605: "", ! 606: 100 /* N_SO */, ! 607: text_nsect, ! 608: 0, ! 609: obstack_next_free(&frags) - frag_now->fr_literal, ! 610: frag_now); ! 611: } ! 612: } ! 613: } ! 614: ! 615: /* ! 616: * parse_a_buffer() operates on a buffer of lines. It drives the ! 617: * parsing of lines of assembly code. The lines are assumed to be "well formed" ! 618: * assembly so the syntax recognized in here is that produced by the output of ! 619: * the assembly preprocessor (app) or by the compiler when it produces a file ! 620: * that starts with "#NO_APP\n". A "well formed" assembly is lines with exactly ! 621: * zero or one leading "well formed space character" (' ', '\t' or '\f') ! 622: * followed by lines of: ! 623: * zero or more lables (a name or a digit followed by a colon) ! 624: * each followed by zero or one "well formed space character" ! 625: * exactly one of the following followed by a logicial end of line: ! 626: * a pseudo opcode ! 627: * followed by zero or one space (' ') characters and it's ! 628: * arguments (the space is required when the first ! 629: * character of the first argument could be part of a name) ! 630: * a macro to be expanded ! 631: * a machine opcode ! 632: * a null statement ! 633: * an assignment to a symbol ! 634: * a full line comment (in the case of "well formed" assembly it ! 635: * must be "#APP\n" of a collection of lines ! 636: * wrapped in "#APP\n ... #NO_APP\n") ! 637: * ! 638: * input: ! 639: * buffer pointer to the start of the buffer of lines ! 640: * (passed as an argument) ! 641: * buffer_limit pointer to the end of the buffer of lines, that is the ! 642: * the character it points to is NOT part of the buffer ! 643: * (buffer_limit is declared in this file) ! 644: * ! 645: * Assumptions about the buffer of lines: ! 646: * buffer[-1] == '\n' as done in input-scrub.c with the cpp macro ! 647: * BEFORE_STRING ("\n") ! 648: * buffer_limit[-1] == '\n' also as done in input-scrub.c which handles ! 649: * partial lines internally to itself and always ! 650: * passes back a buffer of complete lines. ! 651: * ! 652: * input/output: (for other parsing routines) ! 653: * input_line_pointer pointer to the next thing in the buffer after ! 654: * what has been recognized (a global) ! 655: */ ! 656: static ! 657: void ! 658: parse_a_buffer( ! 659: char *buffer) ! 660: { ! 661: char c; /* contains the first non-space character the current ! 662: word used to figure out what it is */ ! 663: char *s; /* points to a name with character after the name ! 664: replaced with a '\0' so it is a 'C' string */ ! 665: char after_name; /* contains that first character after a name that ! 666: got replaced with a '\0' */ ! 667: char *after_name_pointer;/* points to the end of the name where the '\0' is ! 668: for error use only */ ! 669: char end_of_line; /* contains an end of line character that got replaced ! 670: with a '\0' */ ! 671: char *start_of_line;/* points to the locical start of line we're parsing, ! 672: used only for macro expansion */ ! 673: pseudo_typeS *pop; /* pointer to a pseudo op stucture returned by ! 674: hash_find(po_hash, s+1) to determine if it is one */ ! 675: char *the_macro; /* pointer to a macro name returned by ! 676: hash_find(ma_hash, s) to determine if it is one */ ! 677: int digit_value; /* the value of a digit label as an integer, 1: == 1 */ ! 678: ! 679: /* since this is a buffer of full lines it must end in a new line */ ! 680: know(buffer_limit[-1] == '\n'); ! 681: ! 682: input_line_pointer = buffer; ! 683: ! 684: /* while we have more of this buffer to parse keep parsing */ ! 685: while(input_line_pointer < buffer_limit){ ! 686: /* ! 687: * At the top of this loop we know that we just parsed a label or we ! 688: * are at the beginning of a logical line (since their can be more ! 689: * than one label on a line). start_of_line is only used by ! 690: * expand_macro() ! 691: */ ! 692: start_of_line = input_line_pointer; ! 693: ! 694: /* ! 695: * If we are not counting lines (as in the case when called by ! 696: * expand_macro() ) and we just previously scaned over a newline ! 697: * (a physical end of line) bump the line counters (see the comments ! 698: * at the head of this routine about "assumptions about the buffer" ! 699: * and why it is safe to index input_line_pointer by -1. ! 700: */ ! 701: if(count_lines == TRUE && input_line_pointer[-1] == '\n') ! 702: bump_line_counters (); ! 703: ! 704: /* ! 705: * We expect a "well-formed" assembler statement. This means it was ! 706: * processed by app or produced by a compiler where the file started ! 707: * with a leading "#APP\n". A "well-formed" statement allows zero ! 708: * or one leading white space characters. ! 709: */ ! 710: c = *input_line_pointer; ! 711: input_line_pointer++; ! 712: if(c == '\t' || c == ' ' || c=='\f'){ ! 713: c = *input_line_pointer; ! 714: input_line_pointer++; ! 715: } ! 716: know(c != ' '); /* No further leading whitespace. */ ! 717: /* ! 718: * c contains the 1st significant character, *input_line_pointer ! 719: * points after that character. ! 720: */ ! 721: ! 722: /* ! 723: * look for the begining of a name which could be one of the ! 724: * following assembly statements: ! 725: * A pseudo opcode and locical end of line ! 726: * A macro to be expanded and locical end of line ! 727: * A machine opcode and locical end of line ! 728: * A user-defined label (name not digit)(no end of line needed) ! 729: * At NeXT labels can be enclosed in ""'s so that Objective-C like ! 730: * names (with spaces and colons) can be part of a name, the ! 731: * routine get_symbol_end() knows about this. ! 732: */ ! 733: if(is_name_beginner(c) || c == '"'){ ! 734: if( c == '"') ! 735: s = input_line_pointer--; ! 736: else ! 737: s = --input_line_pointer; ! 738: after_name = get_symbol_end(); /* name's delimiter */ ! 739: after_name_pointer = input_line_pointer; ! 740: /* ! 741: * after_name is the character after symbol. That character's ! 742: * place in the input line is now '\0',done by get_symbol_end(). ! 743: * s points to the beginning of the symbol (in the case of a ! 744: * pseudo-op, *s == '.'). *input_line_pointer == '\0' where ! 745: * after_name was. after_name_pointer is recorded so it their ! 746: * is an error after the line has been restored the '\0' can ! 747: * be reset and the name printed. ! 748: */ ! 749: ! 750: /* ! 751: * Look for a name that should be a pseudo op. That is it is ! 752: * not a user defined label or an assignment to a symbol name. ! 753: * This must be done so such thing as ".foo:" and ".bar=1" are ! 754: * not mistaken for illegal pseudo ops and that something like ! 755: * ".long: .long 1" creates a symbol named ".long". ! 756: */ ! 757: if(*s == '.' && ! 758: (after_name != ':' && ! 759: after_name != '=' && ! 760: !((after_name == ' ' || after_name == '\t') && ! 761: input_line_pointer[1] == '=') ) ){ ! 762: /* ! 763: * Lookup what should be a pseudo op and then restore the ! 764: * line. ! 765: */ ! 766: pop = (pseudo_typeS *)hash_find(po_hash, s+1); ! 767: *input_line_pointer = after_name; ! 768: ! 769: /* ! 770: * A pseudo op must be followed by character that is not ! 771: * part of a name so it can be parsed. If their is a first ! 772: * argument that could start with a character in a name then ! 773: * one "well formed space" (space or a tab) must follow the ! 774: * pseudo op (otherwise the space is optional). ! 775: */ ! 776: if(after_name == ' ' || after_name == '\t') ! 777: input_line_pointer++; ! 778: ! 779: /* ! 780: * Now the current state of the line is the after_name has ! 781: * been placed back in the line (the line is restored) and ! 782: * input_line_pointer is at the start of the first argument ! 783: * of the pseudo op (if any). ! 784: */ ! 785: if(the_cond_state.ignore){ ! 786: /* ! 787: * When ignoring a block of code during conditional ! 788: * assembly we can't ignore .if, .else, and .endif ! 789: * pseudo ops. ! 790: */ ! 791: if(pop != NULL && ! 792: ( (pop->poc_handler == s_if) || ! 793: (pop->poc_handler == s_elseif) || ! 794: (pop->poc_handler == s_else) || ! 795: (pop->poc_handler == s_endif) ) ) ! 796: (*pop->poc_handler)(pop->poc_val); ! 797: else ! 798: totally_ignore_line(); ! 799: } ! 800: else if(macro_name){ ! 801: /* ! 802: * When defining a macro we can't ignore .endmacro ! 803: * pseudo ops. ! 804: */ ! 805: if(pop != NULL && ! 806: pop->poc_handler == s_endmacro) ! 807: (*pop->poc_handler)(pop->poc_val); ! 808: else ! 809: add_to_macro_definition(start_of_line); ! 810: } ! 811: else{ ! 812: if(pop != NULL) ! 813: (*pop->poc_handler)(pop->poc_val); ! 814: else{ ! 815: after_name = *after_name_pointer; ! 816: *after_name_pointer = '\0'; ! 817: /* ! 818: * If macros are on see if this is a use of a macro ! 819: * otherwise it is an unknown pseudo op. ! 820: */ ! 821: if(macros_on == TRUE && ! 822: (the_macro = hash_find(ma_hash, s)) != NULL){ ! 823: *after_name_pointer = after_name; ! 824: expand_macro(the_macro); ! 825: } ! 826: else{ ! 827: as_warn ("Unknown pseudo-op: %s", s); ! 828: *after_name_pointer = after_name; ! 829: ignore_rest_of_line(); ! 830: } ! 831: } ! 832: } ! 833: continue; ! 834: ! 835: } /* if(*s == '.' && ... ) */ ! 836: ! 837: /* ! 838: * If we are in a conditional and the state is that we are now ! 839: * not including lines to be assembled then ignore the line. ! 840: */ ! 841: if(the_cond_state.ignore){ ! 842: *input_line_pointer = after_name; ! 843: totally_ignore_line(); ! 844: } ! 845: /* ! 846: * If we are in the state of defining a macro then take the line ! 847: * for the macro definition. ! 848: */ ! 849: else if(macro_name != NULL){ ! 850: *input_line_pointer = after_name; ! 851: add_to_macro_definition(start_of_line); ! 852: } ! 853: /* ! 854: * Look for a user defined label. ! 855: */ ! 856: else if(after_name == ':'){ ! 857: colon(s); ! 858: #ifdef I860 ! 859: /* ! 860: * Intel :: feature, which makes the label global if ! 861: * followed by two "::"'s . This is ifdef'ed in so their ! 862: * is no else cause thus the slightly odd logic. ! 863: */ ! 864: if(input_line_pointer[1] == ':'){ ! 865: struct symbol *symbolP; ! 866: ! 867: symbolP = symbol_find_or_make(s); ! 868: symbolP->sy_type |= N_EXT; /* make symbol name global */ ! 869: *input_line_pointer = ':'; /* Restore first ':' */ ! 870: input_line_pointer++; /* step over first ':' */ ! 871: } ! 872: #endif ! 873: /* put ':' back for error messages and step over it */ ! 874: *input_line_pointer = ':'; ! 875: input_line_pointer++; ! 876: } ! 877: /* ! 878: * Parse the assignment to a symbol. The syntax for this is ! 879: * <symbol><equal><expression>. ! 880: */ ! 881: else if(after_name == '=' || ! 882: ((after_name == ' ' || after_name == '\t') && ! 883: input_line_pointer[1] == '=')){ ! 884: equals(s); ! 885: demand_empty_rest_of_line(); ! 886: } ! 887: /* ! 888: * If macros are on see if this is a use of a macro. ! 889: */ ! 890: else if(macros_on == TRUE && ! 891: (the_macro = hash_find(ma_hash, s)) != NULL){ ! 892: *input_line_pointer = after_name; ! 893: expand_macro(the_macro); ! 894: } ! 895: /* ! 896: * Now assume it is a machine instruction and if not it ! 897: * will be handled as an error. Machine instructions must be ! 898: * one to a line. ! 899: */ ! 900: else{ ! 901: *input_line_pointer = after_name; ! 902: while(is_end_of_line[(int)*input_line_pointer] == FALSE) ! 903: input_line_pointer ++; ! 904: end_of_line = *input_line_pointer; ! 905: *input_line_pointer = '\0'; ! 906: md_assemble(s); ! 907: *input_line_pointer = end_of_line; ! 908: input_line_pointer++; ! 909: } ! 910: /* ! 911: * At this point we have parsed all things that could have ! 912: * started with a name. Since one of these things (user defined ! 913: * lables could appear more than once on a line we do a continue ! 914: * here and start parsing as if at the begining of another ! 915: * logicial line. ! 916: */ ! 917: continue; ! 918: ! 919: } /* if(is_name_beginner(c) || c == '"') */ ! 920: ! 921: /* empty statement */ ! 922: if(is_end_of_line[(int)c]) ! 923: continue; ! 924: ! 925: /* ! 926: * If we are in a conditional and the state is that we are now ! 927: * not including lines to be assembled then ignore the line. ! 928: */ ! 929: if(the_cond_state.ignore){ ! 930: totally_ignore_line(); ! 931: continue; ! 932: } ! 933: ! 934: /* ! 935: * If we are in the state of defining a macro then take the line ! 936: * for the macro definition. ! 937: */ ! 938: if(macro_name != NULL){ ! 939: add_to_macro_definition(start_of_line); ! 940: continue; ! 941: } ! 942: ! 943: /* local label ("4:") */ ! 944: if(isdigit(c)){ ! 945: digit_value = c - '0'; ! 946: if(*input_line_pointer++ == ':' ){ ! 947: local_colon(digit_value); ! 948: } ! 949: else{ ! 950: as_warn("Spurious digit %d.", digit_value); ! 951: input_line_pointer--; ! 952: ignore_rest_of_line(); ! 953: } ! 954: continue; ! 955: } ! 956: ! 957: /* ! 958: * The only full line comment that should make it here is the first ! 959: * of the pair of "#APP\n ... #NO_APP\n" that the compiler uses to ! 960: * wrap around asm() statements. If that is the case then ! 961: * parse_line_comment() creates a buffer with those lines in it and ! 962: * calls parse_a_buffer() with that buffer. Then returns here ! 963: * skiping over that part of the current buffer. ! 964: */ ! 965: if(c != '\0' && strchr(md_line_comment_chars, c) != NULL){ ! 966: parse_line_comment(&buffer); ! 967: continue; ! 968: } ! 969: ! 970: as_warn("Junk character %d.",c); ! 971: ignore_rest_of_line(); ! 972: ! 973: } /* while(input_line_pointer < buffer_limit) */ ! 974: } ! 975: ! 976: /* ! 977: * parse_line_comment() parses a line comment for parse_a_buffer(). Since ! 978: * parse_a_buffer() only operates on "well formed" assembly the only legal ! 979: * line comment that should appear is a "#APP\n ... #NO_APP\n" pair which ! 980: * tells us to scrub the characters between them and then parse them. ! 981: */ ! 982: static ! 983: void ! 984: parse_line_comment( ! 985: char **buffer) ! 986: { ! 987: char *s; ! 988: char *ends; ! 989: ! 990: char *new_buf; ! 991: char *new_tmp; ! 992: int new_length; ! 993: ! 994: char *tmp_buf; ! 995: char *old_input_line_pointer; ! 996: char *old_buffer_limit; ! 997: ! 998: ! 999: /* parse_a_buffer should never see any line comment if app is on */ ! 1000: know(preprocess == FALSE); ! 1001: ! 1002: s = input_line_pointer; ! 1003: /* This must be a #APP\n line comment if not ignore it */ ! 1004: if(strncmp(s,"APP\n",4) != 0) ! 1005: return; ! 1006: ! 1007: if(count_lines == TRUE) ! 1008: bump_line_counters(); ! 1009: s += sizeof("APP\n") - 1; ! 1010: ! 1011: /* ! 1012: * Search for the matching #NO_APP\n in this buffer, if it is found ! 1013: * in this buffer the un-scrubed characters between the "#APP\n" and ! 1014: * "#NO_APP\n" start where s is pointing to and end where ends is ! 1015: * pointing to. ! 1016: */ ! 1017: ends = strstr(s, "#NO_APP\n"); ! 1018: ! 1019: tmp_buf = NULL; ! 1020: if(ends == NULL){ ! 1021: /* The matching #NO_APP\n for the #APP\n wasn't in this buffer. */ ! 1022: int tmp_len; ! 1023: int num; ! 1024: ! 1025: /* ! 1026: * First create a temporary place (tmp_buf of size tmp_len) to ! 1027: * collect the un-scrubbed characters between the "#APP\n" and the ! 1028: * "#NO_APP\n" (or end of file) when we find it in some buffer. ! 1029: */ ! 1030: tmp_len = buffer_limit - s; ! 1031: tmp_buf = xmalloc(tmp_len); ! 1032: ! 1033: /* ! 1034: * Copy the end of the buffer that contains the first part of ! 1035: * the un-scrubbed contents starting just after the "#APP\n". ! 1036: * This is so the the current buffer (buffer) can be used to ! 1037: * collect the the rest of the un-scrubbed contents and to find ! 1038: * the matching "#NO_APP\n". ! 1039: */ ! 1040: memcpy(tmp_buf, s, tmp_len); ! 1041: ! 1042: /* ! 1043: * This loop collects the remaining un-scrubed contents between ! 1044: * "#APP\n" and the "#NO_APP\n" into tmp_buf (adjusting tmp_len) ! 1045: * and looks for the matching "#NO_APP\n". ! 1046: */ ! 1047: do{ ! 1048: buffer_limit = input_scrub_next_buffer(buffer); ! 1049: /* ! 1050: * We treat runing into the end of the file as if it was the ! 1051: * "#NO_APP" we were looking for. ! 1052: */ ! 1053: if(buffer_limit == NULL) ! 1054: break; ! 1055: ! 1056: ends = strstr(*buffer, "#NO_APP\n"); ! 1057: if(ends != NULL) ! 1058: num = ends - *buffer; ! 1059: else ! 1060: num = buffer_limit - *buffer; ! 1061: ! 1062: tmp_buf = xrealloc(tmp_buf, tmp_len + num); ! 1063: memcpy(tmp_buf + tmp_len, *buffer, num); ! 1064: tmp_len += num; ! 1065: }while(ends == NULL); ! 1066: ! 1067: /* ! 1068: * Now set up buffer, buffer_limit and input_line_pointer be past ! 1069: * all the characters of the "#APP\n ... #NO_APP\n" set so that ! 1070: * when we return parsing will be picked up from their. ! 1071: */ ! 1072: if(ends != NULL) ! 1073: input_line_pointer = ends + sizeof("#NO_APP\n") - 1; ! 1074: else{ ! 1075: input_line_pointer = *buffer; ! 1076: buffer_limit = *buffer; ! 1077: } ! 1078: ! 1079: /* ! 1080: * Now set s to the start, and ends to the end of the un-scrubed ! 1081: * contents of the collected characters between the "#APP\n" and ! 1082: * "#NO_APP\n" pair. ! 1083: */ ! 1084: s = tmp_buf; ! 1085: ends = s + tmp_len; ! 1086: } ! 1087: else{ ! 1088: /* ! 1089: * The matching "#NO_APP\n" was in the buffer as we were called so ! 1090: * s is the start, and ends is the end of the un-scrubed contents ! 1091: * of the characters between the "#APP\n" and "#NO_APP\n" pair. ! 1092: * Now to set up buffer, buffer_limit and input_line_pointer be past ! 1093: * all the characters of the "#APP\n ... #NO_APP\n" set so that ! 1094: * when we return parsing will be picked up from their all that has ! 1095: * to be done is move the input_line_pointer past the "#NO_APP\n". ! 1096: */ ! 1097: input_line_pointer = ends + sizeof("#NO_APP\n") - 1; ! 1098: } ! 1099: ! 1100: /* ! 1101: * Now that we have the un-scrubed characters beween s and ends setup ! 1102: * to scrub them into a new buffer (new_buf of size new_length to ! 1103: * new_tmp). ! 1104: */ ! 1105: new_length = 100; ! 1106: new_buf = xmalloc(new_length); ! 1107: new_tmp = new_buf; ! 1108: *new_tmp++ = '\n'; /* place leading \n in buffer for parse_a_buffer */ ! 1109: ! 1110: scrub_string = s; ! 1111: scrub_last_string = ends; ! 1112: for(;;){ ! 1113: int c; ! 1114: ! 1115: c = do_scrub_next_char(scrub_from_string, scrub_to_string); ! 1116: if(c == EOF) ! 1117: break; ! 1118: *new_tmp++ = c; ! 1119: if(new_tmp == new_buf + new_length){ ! 1120: new_buf = xrealloc(new_buf, new_length + 100); ! 1121: new_tmp = new_buf + new_length; ! 1122: new_length += 100; ! 1123: } ! 1124: } ! 1125: *new_tmp = '\n'; /* place trailing \n in buffer for parse_a_buffer */ ! 1126: ! 1127: /* ! 1128: * If we used a temporary buffer to collect the un-scrubbed characters ! 1129: * it is no longer needed and can be free()'ed. ! 1130: */ ! 1131: if(tmp_buf != NULL) ! 1132: free(tmp_buf); ! 1133: ! 1134: /* ! 1135: * Now we are ready to recursively call parse_a_buffer() with our buffer ! 1136: * of scrubed characters. So save the state of parse_a_buffer() and set ! 1137: * it up with our buffer of scrubed characters. ! 1138: */ ! 1139: old_input_line_pointer = input_line_pointer; ! 1140: old_buffer_limit = buffer_limit; ! 1141: ! 1142: input_line_pointer = new_buf; ! 1143: buffer_limit = new_tmp; ! 1144: parse_a_buffer(new_buf); ! 1145: ! 1146: /* ! 1147: * Free the buffer that held the scrubbed characters ! 1148: */ ! 1149: free(new_buf); ! 1150: ! 1151: /* ! 1152: * After coming back from our recursive call parse_a_buffer() we want ! 1153: * resume parsing after the "#NO_APP\n". So bump the line counters ! 1154: * for the "#NO_APP\n" and restore the state so we can return to ! 1155: * parse_a_buffer(). ! 1156: */ ! 1157: if(count_lines == TRUE) ! 1158: bump_line_counters(); ! 1159: input_line_pointer = old_input_line_pointer; ! 1160: buffer_limit = old_buffer_limit; ! 1161: ! 1162: return; ! 1163: } ! 1164: ! 1165: /* ! 1166: * s_abort() implements the pseudo op: ! 1167: * .abort [ "abort_string" ] ! 1168: */ ! 1169: static ! 1170: void ! 1171: s_abort( ! 1172: int value) ! 1173: { ! 1174: char *p; ! 1175: ! 1176: p = input_line_pointer; ! 1177: while(is_end_of_line[(int)*p] == FALSE) ! 1178: p++; ! 1179: *p = '\0'; ! 1180: ! 1181: as_fatal(".abort %s detected. Assembly stopping.", input_line_pointer); ! 1182: } ! 1183: ! 1184: #if !defined(I860) /* i860 has it's own align and org */ ! 1185: /* ! 1186: * s_align() implements the pseudo op ! 1187: * .align expression [ , fill_expression ] ! 1188: */ ! 1189: static ! 1190: void ! 1191: s_align( ! 1192: int value) ! 1193: { ! 1194: int temp; ! 1195: long temp_fill; ! 1196: ! 1197: temp = get_absolute_expression(); ! 1198: #define MAX_ALIGNMENT (15) ! 1199: if(temp > MAX_ALIGNMENT) ! 1200: as_warn("Alignment too large: %d. assumed.", temp = MAX_ALIGNMENT); ! 1201: else if(temp < 0){ ! 1202: as_warn("Alignment negative. 0 assumed."); ! 1203: temp = 0; ! 1204: } ! 1205: if(*input_line_pointer == ','){ ! 1206: input_line_pointer ++; ! 1207: temp_fill = get_absolute_expression (); ! 1208: } ! 1209: else ! 1210: temp_fill = 0; ! 1211: ! 1212: /* Only make a frag if we HAVE to. . . */ ! 1213: if(temp != 0) ! 1214: frag_align(temp, (int)temp_fill); ! 1215: ! 1216: /* ! 1217: * If this alignment is larger than any previous alignment then this ! 1218: * becomes the section's alignment. ! 1219: */ ! 1220: if(frchain_now->frch_section.align < temp) ! 1221: frchain_now->frch_section.align = temp; ! 1222: ! 1223: demand_empty_rest_of_line(); ! 1224: } ! 1225: #endif /* !defined(I860) i860 has it's own align and org */ ! 1226: ! 1227: /* ! 1228: * s_comm() implements the pseudo op: ! 1229: * .comm name , expression ! 1230: */ ! 1231: static ! 1232: void ! 1233: s_comm( ! 1234: int value) ! 1235: { ! 1236: char *name; ! 1237: char c; ! 1238: char *p; ! 1239: int temp; ! 1240: symbolS *symbolP; ! 1241: ! 1242: if(*input_line_pointer == '"') ! 1243: name = input_line_pointer + 1; ! 1244: else ! 1245: name = input_line_pointer; ! 1246: c = get_symbol_end(); ! 1247: /* just after name is now '\0' */ ! 1248: p = input_line_pointer; ! 1249: *p = c; ! 1250: SKIP_WHITESPACE(); ! 1251: if(*input_line_pointer != ','){ ! 1252: as_warn("Expected comma after symbol-name"); ! 1253: ignore_rest_of_line(); ! 1254: return; ! 1255: } ! 1256: input_line_pointer++; /* skip ',' */ ! 1257: if((temp = get_absolute_expression ()) < 0){ ! 1258: as_warn(".COMMon length (%d.) <0! Ignored.", temp); ! 1259: ignore_rest_of_line(); ! 1260: return; ! 1261: } ! 1262: *p = 0; ! 1263: symbolP = symbol_find_or_make(name); ! 1264: *p = c; ! 1265: if((symbolP->sy_type & N_TYPE) != N_UNDF || ! 1266: symbolP->sy_other != 0 || ! 1267: symbolP->sy_desc != 0) { ! 1268: as_warn("Ignoring attempt to re-define symbol"); ! 1269: ignore_rest_of_line(); ! 1270: return; ! 1271: } ! 1272: if(symbolP->sy_value != 0){ ! 1273: if(symbolP->sy_value != temp) ! 1274: as_warn("Length of .comm \"%s\" is already %ld. Not changed " ! 1275: "to %d.", symbolP->sy_name, symbolP->sy_value, temp); ! 1276: } ! 1277: else{ ! 1278: symbolP -> sy_value = temp; ! 1279: symbolP -> sy_type |= N_EXT; ! 1280: } ! 1281: know(symbolP->sy_frag == &zero_address_frag); ! 1282: demand_empty_rest_of_line(); ! 1283: } ! 1284: ! 1285: /* ! 1286: * s_desc() implements the pseudo op: ! 1287: * .desc name , expression ! 1288: * sets the n_desc field of a symbol. ! 1289: */ ! 1290: static ! 1291: void ! 1292: s_desc( ! 1293: int value) ! 1294: { ! 1295: char *name; ! 1296: char c; ! 1297: char *p; ! 1298: symbolS *symbolP; ! 1299: int temp; ! 1300: ! 1301: if(*input_line_pointer == '"') ! 1302: name = input_line_pointer + 1; ! 1303: else ! 1304: name = input_line_pointer; ! 1305: c = get_symbol_end(); ! 1306: p = input_line_pointer; ! 1307: symbolP = symbol_table_lookup(name); ! 1308: *p = c; ! 1309: SKIP_WHITESPACE(); ! 1310: if(*input_line_pointer != ','){ ! 1311: *p = 0; ! 1312: as_warn("Expected comma after name \"%s\"", name); ! 1313: *p = c; ! 1314: ignore_rest_of_line(); ! 1315: } ! 1316: else{ ! 1317: input_line_pointer++; ! 1318: temp = get_absolute_expression(); ! 1319: *p = 0; ! 1320: symbolP = symbol_find_or_make(name); ! 1321: *p = c; ! 1322: symbolP->sy_desc = temp; ! 1323: } ! 1324: demand_empty_rest_of_line(); ! 1325: } ! 1326: ! 1327: /* ! 1328: * s_file() implements the pseudo op: ! 1329: * .file name [ level_number ] ! 1330: * the level number is generated by /lib/cpp and is just ignored. ! 1331: */ ! 1332: static ! 1333: void ! 1334: s_file( ! 1335: int value) ! 1336: { ! 1337: char *s; ! 1338: int length; ! 1339: struct symbol *symbolP; ! 1340: ! 1341: /* Some assemblers tolerate immediately following '"' */ ! 1342: if((s = demand_copy_string(&length))){ ! 1343: SKIP_WHITESPACE(); ! 1344: if(*input_line_pointer >= '0' && *input_line_pointer <= '9'){ ! 1345: while(*input_line_pointer >= '0' && ! 1346: *input_line_pointer <= '9') ! 1347: input_line_pointer++; ! 1348: } ! 1349: new_logical_line(s, -1); ! 1350: demand_empty_rest_of_line(); ! 1351: ! 1352: /* ! 1353: * This is to generate stabs for debugging assembly code. ! 1354: * See the comments about stabs in read_a_source_file() ! 1355: * for a description of what is going on here. ! 1356: */ ! 1357: if(flagseen['g'] && frchain_now->frch_nsect == text_nsect){ ! 1358: symbolP = symbol_new( ! 1359: logical_input_file, ! 1360: 132 /* N_SOL */, ! 1361: text_nsect, ! 1362: 0, ! 1363: obstack_next_free(&frags) - frag_now->fr_literal, ! 1364: frag_now); ! 1365: } ! 1366: } ! 1367: } ! 1368: ! 1369: /* ! 1370: * s_fill() implements the pseudo op: ! 1371: * .fill repeat_expression , fill_size , fill_expression ! 1372: */ ! 1373: static ! 1374: void ! 1375: s_fill( ! 1376: int value) ! 1377: { ! 1378: long temp_repeat; ! 1379: long temp_size; ! 1380: long temp_fill; ! 1381: char *p; ! 1382: ! 1383: if(get_absolute_expression_and_terminator(&temp_repeat) != ','){ ! 1384: input_line_pointer--; /* Backup over what was not a ','. */ ! 1385: as_warn("Expect comma after rep-size in .fill"); ! 1386: ignore_rest_of_line(); ! 1387: return; ! 1388: } ! 1389: if(get_absolute_expression_and_terminator(&temp_size) != ','){ ! 1390: input_line_pointer--; /* Backup over what was not a ','. */ ! 1391: as_warn("Expected comma after size in .fill"); ! 1392: ignore_rest_of_line(); ! 1393: return; ! 1394: } ! 1395: /* ! 1396: * This is to be compatible with BSD 4.2 AS, not for any rational ! 1397: * reason. ! 1398: */ ! 1399: #define BSD_FILL_SIZE_CROCK_8 (8) ! 1400: if(temp_size > BSD_FILL_SIZE_CROCK_8){ ! 1401: as_warn(".fill size clamped to %d.", BSD_FILL_SIZE_CROCK_8); ! 1402: temp_size = BSD_FILL_SIZE_CROCK_8 ; ! 1403: } ! 1404: if(temp_size < 0){ ! 1405: as_warn("Size negative: .fill ignored."); ! 1406: temp_size = 0; ! 1407: } ! 1408: /* ! 1409: * bug fix, if md_number_to_chars() is called with something other than ! 1410: * 1,2 or 4 it calls abort(). So we don't let the size be something ! 1411: * like 3. Bug #13017. ! 1412: */ ! 1413: else if(temp_size != 0 && ! 1414: temp_size != 1 && ! 1415: temp_size != 2 && ! 1416: temp_size != 4){ ! 1417: as_warn("Repeat must be 0,1,2 or 4, .fill ignored"); ! 1418: temp_size = 0; ! 1419: } ! 1420: else if(temp_repeat <= 0){ ! 1421: as_warn("Repeat < 0, .fill ignored"); ! 1422: temp_size = 0; ! 1423: } ! 1424: temp_fill = get_absolute_expression(); ! 1425: /* ! 1426: * Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes) ! 1427: * but emits no error message because it seems a legal thing to do. ! 1428: * It is a degenerate case of .fill but could be emitted by a compiler. ! 1429: */ ! 1430: if(temp_size != 0){ ! 1431: p = frag_var(rs_fill, ! 1432: (int)temp_size, ! 1433: (int)temp_size, ! 1434: (relax_substateT)0, ! 1435: (symbolS *)0, ! 1436: temp_repeat, ! 1437: (char *)0); ! 1438: memset(p, '\0', (int)temp_size); ! 1439: /* ! 1440: * The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX ! 1441: * flavoured AS. The following bizzare behaviour is to be ! 1442: * compatible with above. I guess they tried to take up to 8 ! 1443: * bytes from a 4-byte expression and they forgot to sign extend. ! 1444: */ ! 1445: #define BSD_FILL_SIZE_CROCK_4 (4) ! 1446: md_number_to_chars(p, ! 1447: temp_fill, ! 1448: temp_size > BSD_FILL_SIZE_CROCK_4 ? ! 1449: BSD_FILL_SIZE_CROCK_4 : (int)temp_size); ! 1450: } ! 1451: demand_empty_rest_of_line(); ! 1452: } ! 1453: ! 1454: /* ! 1455: * s_globl() implements the pseudo op: ! 1456: * .globl name [ , name ] ! 1457: */ ! 1458: void ! 1459: s_globl( ! 1460: int value) ! 1461: { ! 1462: char *name; ! 1463: int c; ! 1464: symbolS *symbolP; ! 1465: ! 1466: do{ ! 1467: if(*input_line_pointer == '"') ! 1468: name = input_line_pointer + 1; ! 1469: else ! 1470: name = input_line_pointer; ! 1471: c = get_symbol_end(); ! 1472: symbolP = symbol_find_or_make(name); ! 1473: *input_line_pointer = c; ! 1474: SKIP_WHITESPACE(); ! 1475: symbolP->sy_type |= N_EXT; ! 1476: if(c == ','){ ! 1477: input_line_pointer++; ! 1478: SKIP_WHITESPACE(); ! 1479: if(*input_line_pointer == '\n') ! 1480: c = '\n'; ! 1481: } ! 1482: }while(c == ','); ! 1483: demand_empty_rest_of_line(); ! 1484: } ! 1485: ! 1486: /* ! 1487: * s_private_extern() implements the pseudo op: ! 1488: * .private_extern name [ , name ] ! 1489: */ ! 1490: static ! 1491: void ! 1492: s_private_extern( ! 1493: int value) ! 1494: { ! 1495: char *name; ! 1496: int c; ! 1497: symbolS *symbolP; ! 1498: ! 1499: if(!flagseen['k']) ! 1500: as_fatal("incompatible feature used: .private_extern (must specify " ! 1501: "\"-dynamic\" to be used)"); ! 1502: do{ ! 1503: if(*input_line_pointer == '"') ! 1504: name = input_line_pointer + 1; ! 1505: else ! 1506: name = input_line_pointer; ! 1507: c = get_symbol_end(); ! 1508: symbolP = symbol_find_or_make(name); ! 1509: *input_line_pointer = c; ! 1510: SKIP_WHITESPACE(); ! 1511: symbolP->sy_type |= N_EXT; ! 1512: symbolP->sy_type |= N_PEXT; ! 1513: if(c == ','){ ! 1514: input_line_pointer++; ! 1515: SKIP_WHITESPACE(); ! 1516: if(*input_line_pointer == '\n') ! 1517: c = '\n'; ! 1518: } ! 1519: }while(c == ','); ! 1520: demand_empty_rest_of_line(); ! 1521: } ! 1522: ! 1523: /* ! 1524: * s_indirect_symbol() implements the pseudo op: ! 1525: * .indirect_symbol name ! 1526: */ ! 1527: static ! 1528: void ! 1529: s_indirect_symbol( ! 1530: int value) ! 1531: { ! 1532: char *name; ! 1533: int c; ! 1534: unsigned long section_type; ! 1535: ! 1536: if(!flagseen['k']) ! 1537: as_fatal("incompatible feature used: .indirect_symbol (must " ! 1538: "specify \"-dynamic\" to be used)"); ! 1539: if(frchain_now == NULL){ ! 1540: know(flagseen['n']); ! 1541: as_fatal("with -n a section directive must be seen before assembly " ! 1542: "can begin"); ! 1543: } ! 1544: section_type = frchain_now->frch_section.flags & SECTION_TYPE; ! 1545: if(section_type != S_NON_LAZY_SYMBOL_POINTERS && ! 1546: section_type != S_LAZY_SYMBOL_POINTERS && ! 1547: section_type != S_SYMBOL_STUBS){ ! 1548: as_warn("indirect symbol not in a symbol pointer or stub section, " ! 1549: ".indirect_symbol ignored"); ! 1550: ignore_rest_of_line(); ! 1551: return; ! 1552: } ! 1553: ! 1554: if(*input_line_pointer == '"') ! 1555: name = input_line_pointer + 1; ! 1556: else ! 1557: name = input_line_pointer; ! 1558: c = get_symbol_end(); ! 1559: indirect_symbol_new(name, ! 1560: frag_now, ! 1561: obstack_next_free(&frags) - frag_now->fr_literal); ! 1562: *input_line_pointer = c; ! 1563: ! 1564: demand_empty_rest_of_line(); ! 1565: } ! 1566: ! 1567: /* ! 1568: * s_lcomm() implements the pseudo op: ! 1569: * .lcomm name , size_expression [ , align_expression ] ! 1570: */ ! 1571: static ! 1572: void ! 1573: s_lcomm( ! 1574: int value) ! 1575: { ! 1576: char *name; ! 1577: char c; ! 1578: char *p; ! 1579: int size; ! 1580: symbolS *symbolP; ! 1581: int align; ! 1582: static frchainS *bss = NULL; ! 1583: ! 1584: if(*input_line_pointer == '"') ! 1585: name = input_line_pointer + 1; ! 1586: else ! 1587: name = input_line_pointer; ! 1588: c = get_symbol_end(); ! 1589: p = input_line_pointer; ! 1590: *p = c; ! 1591: SKIP_WHITESPACE(); ! 1592: if(*input_line_pointer != ','){ ! 1593: as_warn("Expected comma after name"); ! 1594: ignore_rest_of_line(); ! 1595: return; ! 1596: } ! 1597: input_line_pointer ++; ! 1598: if((size = get_absolute_expression()) < 0){ ! 1599: as_warn("BSS length (%d.) <0! Ignored.", size); ! 1600: ignore_rest_of_line(); ! 1601: return; ! 1602: } ! 1603: #define MAX_ALIGNMENT (15) ! 1604: align = 0; ! 1605: if(*input_line_pointer == ','){ ! 1606: input_line_pointer++; ! 1607: align = get_absolute_expression(); ! 1608: if(align > MAX_ALIGNMENT){ ! 1609: as_warn("Alignment too large: %d. assumed.", MAX_ALIGNMENT); ! 1610: align = MAX_ALIGNMENT; ! 1611: } ! 1612: else if(align < 0){ ! 1613: as_warn("Alignment negative. 0 assumed."); ! 1614: align = 0; ! 1615: } ! 1616: } ! 1617: *p = 0; ! 1618: symbolP = symbol_find_or_make(name); ! 1619: *p = c; ! 1620: ! 1621: if((symbolP->sy_type & N_TYPE) == N_UNDF && symbolP->sy_value == 0){ ! 1622: if(bss == NULL){ ! 1623: bss = section_new(SEG_DATA, SECT_BSS, S_ZEROFILL, 0, 0); ! 1624: bss->frch_root = xmalloc(SIZEOF_STRUCT_FRAG); ! 1625: memset(bss->frch_root, '\0', SIZEOF_STRUCT_FRAG); ! 1626: bss->frch_last = bss->frch_root; ! 1627: } ! 1628: bss->frch_root->fr_address = round(bss->frch_root->fr_address, ! 1629: 1 << align); ! 1630: symbolP->sy_value = bss->frch_root->fr_address; ! 1631: symbolP->sy_type = N_SECT; ! 1632: symbolP->sy_other = bss->frch_nsect; ! 1633: symbolP->sy_frag = bss->frch_root; ! 1634: bss->frch_root->fr_address += size; ! 1635: /* ! 1636: * If this alignment is larger than any previous alignment then this ! 1637: * becomes the section's alignment. ! 1638: */ ! 1639: if(bss->frch_section.align < align) ! 1640: bss->frch_section.align = align; ! 1641: } ! 1642: else ! 1643: as_warn("Ignoring attempt to re-define symbol."); ! 1644: demand_empty_rest_of_line(); ! 1645: } ! 1646: ! 1647: /* ! 1648: * s_line() implements the pseudo op: ! 1649: * .line line_number ! 1650: */ ! 1651: void ! 1652: s_line( ! 1653: int value) ! 1654: { ! 1655: /* ! 1656: * Assume delimiter is part of expression. BSD4.2 as fails with ! 1657: * delightful bug, so we are not being incompatible here. ! 1658: */ ! 1659: /* ! 1660: * Since the assembler bumps it's line counters at the end of a line ! 1661: * and it is the case that the .line is on it's own line what the ! 1662: * intent is that the line number is for the next line. Thus ! 1663: * the -1 . This is the way cpp'ed assembler files work which is the ! 1664: * common case. ! 1665: */ ! 1666: new_logical_line((char *)NULL, (int)(get_absolute_expression()) - 1); ! 1667: demand_empty_rest_of_line(); ! 1668: } ! 1669: ! 1670: /* ! 1671: * s_lsym() implements the pseudo op: ! 1672: * .lsym name , expression ! 1673: */ ! 1674: static ! 1675: void ! 1676: s_lsym( ! 1677: int value) ! 1678: { ! 1679: char *name; ! 1680: char c; ! 1681: char *p; ! 1682: segT segment; ! 1683: expressionS exp; ! 1684: symbolS *symbolP; ! 1685: ! 1686: /* we permit ANY expression: BSD4.2 demands constants */ ! 1687: if(*input_line_pointer == '"') ! 1688: name = input_line_pointer + 1; ! 1689: else ! 1690: name = input_line_pointer; ! 1691: c = get_symbol_end(); ! 1692: p = input_line_pointer; ! 1693: *p = c; ! 1694: SKIP_WHITESPACE(); ! 1695: if(*input_line_pointer != ','){ ! 1696: *p = 0; ! 1697: as_warn("Expected comma after name \"%s\"", name); ! 1698: *p = c; ! 1699: ignore_rest_of_line(); ! 1700: return; ! 1701: } ! 1702: input_line_pointer++; ! 1703: segment = expression(&exp); ! 1704: if(segment != SEG_ABSOLUTE && segment != SEG_SECT){ ! 1705: /* this warning still need fixing */ ! 1706: as_warn("Bad expression: %s", seg_name[(int)segment]); ! 1707: ignore_rest_of_line(); ! 1708: return; ! 1709: } ! 1710: know(segment == SEG_ABSOLUTE || segment == SEG_SECT); ! 1711: *p = 0; ! 1712: if(segment == SEG_SECT) ! 1713: symbolP = symbol_new(name, ! 1714: N_SECT, ! 1715: frchain_now->frch_nsect, ! 1716: 0, ! 1717: (valueT)(exp.X_add_number), ! 1718: &zero_address_frag); ! 1719: else ! 1720: symbolP = symbol_new(name, ! 1721: N_ABS, ! 1722: 0, ! 1723: 0, ! 1724: (valueT)(exp.X_add_number), ! 1725: &zero_address_frag); ! 1726: *p = c; ! 1727: demand_empty_rest_of_line(); ! 1728: } ! 1729: ! 1730: #if !defined(I860) /* i860 has it's own align and org */ ! 1731: /* ! 1732: * s_org() implements the pseudo op: ! 1733: * .org expression ! 1734: */ ! 1735: static ! 1736: void ! 1737: s_org( ! 1738: int value) ! 1739: { ! 1740: segT segment; ! 1741: expressionS exp; ! 1742: long temp_fill; ! 1743: char *p; ! 1744: ! 1745: /* ! 1746: * Don't believe the documentation of BSD 4.2 AS. ! 1747: * There is no such thing as a sub-segment-relative origin. ! 1748: * Any absolute origin is given a warning, then assumed to be ! 1749: * segment-relative. ! 1750: * Any segmented origin expression ("foo+42") had better be in the right ! 1751: * segment or the .org is ignored. ! 1752: * ! 1753: * BSD 4.2 AS warns if you try to .org backwards. We cannot because we ! 1754: * never know sub-segment sizes when we are reading code. ! 1755: * BSD will crash trying to emit -ve numbers of filler bytes in certain ! 1756: * .orgs. We don't crash, but see as-write for that code. ! 1757: */ ! 1758: segment = get_known_segmented_expression(&exp); ! 1759: if(*input_line_pointer == ','){ ! 1760: input_line_pointer ++; ! 1761: temp_fill = get_absolute_expression (); ! 1762: } ! 1763: else ! 1764: temp_fill = 0; ! 1765: if((segment != SEG_SECT || ! 1766: exp.X_add_symbol->sy_other != frchain_now->frch_nsect) && ! 1767: segment != SEG_ABSOLUTE) ! 1768: as_warn("Illegal expression. current section assumed."); ! 1769: p = frag_var(rs_org, ! 1770: 1, ! 1771: 1, ! 1772: (relax_substateT)0, ! 1773: exp.X_add_symbol, ! 1774: exp.X_add_number, ! 1775: (char *)0); ! 1776: *p = temp_fill; ! 1777: demand_empty_rest_of_line(); ! 1778: } ! 1779: #endif /* !defined(I860) i860 has it's own align and org */ ! 1780: ! 1781: /* ! 1782: * s_set() implements the pseudo op: ! 1783: * .set name , expression ! 1784: */ ! 1785: static ! 1786: void ! 1787: s_set( ! 1788: int value) ! 1789: { ! 1790: char *name; ! 1791: char delim; ! 1792: char *end_name; ! 1793: symbolS *symbolP; ! 1794: ! 1795: if( * input_line_pointer == '"') ! 1796: name = input_line_pointer + 1; ! 1797: else ! 1798: name = input_line_pointer; ! 1799: delim = get_symbol_end(); ! 1800: end_name = input_line_pointer; ! 1801: *end_name = delim; ! 1802: SKIP_WHITESPACE(); ! 1803: if(*input_line_pointer != ','){ ! 1804: *end_name = 0; ! 1805: as_warn("Expected comma after name \"%s\"", name); ! 1806: *end_name = delim; ! 1807: ignore_rest_of_line(); ! 1808: return; ! 1809: } ! 1810: input_line_pointer++; ! 1811: *end_name = 0; ! 1812: if(name[0] == '.' && name[1] == '\0'){ ! 1813: /* Turn 'set . , mumble' into a .org mumble */ ! 1814: segT segment; ! 1815: expressionS exp; ! 1816: char *ptr; ! 1817: ! 1818: segment = get_known_segmented_expression(&exp); ! 1819: if((segment != SEG_SECT || ! 1820: exp.X_add_symbol->sy_other != frchain_now->frch_nsect) && ! 1821: segment != SEG_ABSOLUTE) ! 1822: as_warn("Illegal expression. current section assumed."); ! 1823: ptr = frag_var(rs_org, ! 1824: 1, ! 1825: 1, ! 1826: (relax_substateT)0, ! 1827: exp.X_add_symbol, ! 1828: exp.X_add_number, ! 1829: (char *)0); ! 1830: *ptr = 0; ! 1831: *end_name = delim; ! 1832: return; ! 1833: } ! 1834: symbolP = symbol_find_or_make(name); ! 1835: *end_name = delim; ! 1836: pseudo_set(symbolP); ! 1837: demand_empty_rest_of_line(); ! 1838: } ! 1839: ! 1840: /* ! 1841: * s_abs() implements the pseudo op: ! 1842: * .abs name , expression ! 1843: * which sets symbol to 1 or 0 depending on if the expression is an absolute ! 1844: * expression. This is intended for use in macros. ! 1845: */ ! 1846: void ! 1847: s_abs( ! 1848: int value) ! 1849: { ! 1850: char *name; ! 1851: char c; ! 1852: char *p; ! 1853: segT segment; ! 1854: expressionS exp; ! 1855: symbolS *symbolP; ! 1856: ! 1857: if(*input_line_pointer == '"') ! 1858: name = input_line_pointer + 1; ! 1859: else ! 1860: name = input_line_pointer; ! 1861: c = get_symbol_end(); ! 1862: p = input_line_pointer; ! 1863: *p = c; ! 1864: SKIP_WHITESPACE(); ! 1865: if(*input_line_pointer != ','){ ! 1866: *p = 0; ! 1867: as_warn("Expected comma after name \"%s\"", name); ! 1868: *p = c; ! 1869: ignore_rest_of_line(); ! 1870: return; ! 1871: } ! 1872: input_line_pointer++; ! 1873: *p = 0; ! 1874: segment = expression(&exp); ! 1875: symbolP = symbol_find_or_make(name); ! 1876: symbolP->sy_type = N_ABS; ! 1877: symbolP->sy_other = 0; /* NO_SECT */ ! 1878: symbolP->sy_frag = &zero_address_frag; ! 1879: if(segment == SEG_ABSOLUTE) ! 1880: symbolP->sy_value = 1; ! 1881: else ! 1882: symbolP->sy_value = 0; ! 1883: *p = c; ! 1884: totally_ignore_line(); ! 1885: } ! 1886: ! 1887: /* ! 1888: * s_space() implements the pseudo op: ! 1889: * .space repeat_expression [ , fill_expression ] ! 1890: */ ! 1891: void ! 1892: s_space( ! 1893: int value) ! 1894: { ! 1895: long temp_repeat; ! 1896: long temp_fill; ! 1897: char *p; ! 1898: ! 1899: /* Just like .fill, but temp_size = 1 */ ! 1900: if(get_absolute_expression_and_terminator(&temp_repeat) == ','){ ! 1901: temp_fill = get_absolute_expression(); ! 1902: } ! 1903: else{ ! 1904: input_line_pointer--; /* Backup over what was not a ','. */ ! 1905: temp_fill = 0; ! 1906: } ! 1907: if(temp_repeat <= 0){ ! 1908: as_warn("Repeat < 0, .space ignored"); ! 1909: ignore_rest_of_line(); ! 1910: return; ! 1911: } ! 1912: p = frag_var(rs_fill, ! 1913: 1, ! 1914: 1, ! 1915: (relax_substateT)0, ! 1916: (symbolS *)0, ! 1917: temp_repeat, ! 1918: (char *)0); ! 1919: *p = temp_fill; ! 1920: demand_empty_rest_of_line(); ! 1921: } ! 1922: ! 1923: static ! 1924: unsigned long ! 1925: s_builtin_section( ! 1926: const struct builtin_section *s) ! 1927: { ! 1928: frchainS *frcP; ! 1929: ! 1930: if(!flagseen['k']){ ! 1931: if((s->flags & SECTION_TYPE) == S_NON_LAZY_SYMBOL_POINTERS || ! 1932: (s->flags & SECTION_TYPE) == S_LAZY_SYMBOL_POINTERS || ! 1933: (s->flags & SECTION_TYPE) == S_SYMBOL_STUBS || ! 1934: (s->flags & SECTION_TYPE) == S_MOD_INIT_FUNC_POINTERS || ! 1935: (s->flags & SECTION_ATTRIBUTES) != 0) ! 1936: as_fatal("incompatible feature used: directive .%s (must " ! 1937: "specify \"-dynamic\" to be used)", s->directive); ! 1938: } ! 1939: /* ! 1940: * If we allowed to use the new features that are incompatible with 3.2 ! 1941: * and this is the text section (which relys on the fact that the text ! 1942: * section is first in the built in sections list) then add the ! 1943: * S_ATTR_PURE_INSTRUCTIONS to the section attributes. ! 1944: */ ! 1945: if(flagseen['k'] && s == builtin_sections){ ! 1946: frcP = section_new(s->segname, s->sectname, ! 1947: s->flags & SECTION_TYPE, ! 1948: (s->flags & SECTION_ATTRIBUTES) | ! 1949: S_ATTR_PURE_INSTRUCTIONS, ! 1950: s->sizeof_stub); ! 1951: } ! 1952: else{ ! 1953: frcP = section_new(s->segname, s->sectname, ! 1954: s->flags & SECTION_TYPE, ! 1955: s->flags & SECTION_ATTRIBUTES, ! 1956: s->sizeof_stub); ! 1957: } ! 1958: if(frcP->frch_section.align < s->default_align) ! 1959: frcP->frch_section.align = s->default_align; ! 1960: return(frcP->frch_nsect); ! 1961: } ! 1962: ! 1963: /* ! 1964: * s_section() implements the pseudo op: ! 1965: * .section segname , sectname [[[ , type ] , attribute] , sizeof_stub] ! 1966: */ ! 1967: static ! 1968: void ! 1969: s_section( ! 1970: int value) ! 1971: { ! 1972: char *segname, *sectname, *typename; ! 1973: char c, d, e, *p, *q, *r; ! 1974: struct type_name *type_name; ! 1975: unsigned long type, attribute; ! 1976: struct section s; ! 1977: frchainS *frcP; ! 1978: unsigned long sizeof_stub; ! 1979: ! 1980: struct attribute_name *attribute_name; ! 1981: char *attributename, *sizeof_stub_name, f, g, *t, *u, *endp; ! 1982: ! 1983: segname = input_line_pointer; ! 1984: do{ ! 1985: c = *input_line_pointer++ ; ! 1986: }while(c != ',' && c != '\0' && c != '\n'); ! 1987: if(c != ','){ ! 1988: as_warn("Expected comma after segment-name"); ! 1989: ignore_rest_of_line(); ! 1990: return; ! 1991: } ! 1992: p = input_line_pointer - 1; ! 1993: ! 1994: sectname = input_line_pointer; ! 1995: do{ ! 1996: d = *input_line_pointer++ ; ! 1997: }while(d != ',' && d != '\0' && d != '\n'); ! 1998: if(p + 1 == input_line_pointer){ ! 1999: as_warn("Expected section-name after comma"); ! 2000: ignore_rest_of_line(); ! 2001: return; ! 2002: } ! 2003: q = input_line_pointer - 1; ! 2004: ! 2005: *p = 0; ! 2006: if(strlen(segname) > sizeof(s.segname)){ ! 2007: as_warn("segment-name: %s too long (maximum %ld characters)", ! 2008: segname, sizeof(s.segname)); ! 2009: ignore_rest_of_line(); ! 2010: *p = c; ! 2011: return; ! 2012: } ! 2013: ! 2014: *q = 0; ! 2015: if(strlen(sectname) > sizeof(s.sectname)){ ! 2016: as_warn("section-name: %s too long (maximum %ld characters)", ! 2017: sectname, sizeof(s.sectname)); ! 2018: ignore_rest_of_line(); ! 2019: return; ! 2020: } ! 2021: /* ! 2022: * Now see if the optional section type is present. ! 2023: */ ! 2024: type = 0; ! 2025: type_name = type_names; ! 2026: attribute = 0; ! 2027: attribute_name = attribute_names; ! 2028: sizeof_stub = 0; ! 2029: if(d == ','){ ! 2030: typename = input_line_pointer; ! 2031: do{ ! 2032: e = *input_line_pointer++ ; ! 2033: } ! 2034: while(e != ',' && e != '\0' && e != '\n'); ! 2035: r = input_line_pointer - 1; ! 2036: *r = 0; ! 2037: for(type_name = type_names; type_name->name != NULL; type_name++) ! 2038: if(strcmp(type_name->name, typename) == 0) ! 2039: break; ! 2040: if(type_name->name == NULL){ ! 2041: as_warn("unknown section type: %s", typename); ! 2042: ignore_rest_of_line(); ! 2043: return; ! 2044: } ! 2045: *r = e; ! 2046: type = type_name->type; ! 2047: /* ! 2048: * Now see if the optional section attribute is present. ! 2049: */ ! 2050: if(e == ','){ ! 2051: attributename = input_line_pointer; ! 2052: do{ ! 2053: f = *input_line_pointer++ ; ! 2054: }while(f != ',' && f != '\0' && f != '\n'); ! 2055: t = input_line_pointer - 1; ! 2056: *t = 0; ! 2057: for(attribute_name = attribute_names; ! 2058: attribute_name->name != NULL; ! 2059: attribute_name++) ! 2060: if(strcmp(attribute_name->name, attributename) == 0) ! 2061: break; ! 2062: if(attribute_name->name == NULL){ ! 2063: as_warn("unknown section attribute: %s", attributename); ! 2064: ignore_rest_of_line(); ! 2065: return; ! 2066: } ! 2067: *t = f; ! 2068: attribute = attribute_name->attribute; ! 2069: ! 2070: /* ! 2071: * Now get the section stub size if this is a stub section. ! 2072: */ ! 2073: if(type == S_SYMBOL_STUBS){ ! 2074: if(f == ','){ ! 2075: sizeof_stub_name = input_line_pointer; ! 2076: do{ ! 2077: g = *input_line_pointer++ ; ! 2078: }while(g != '\0' && g != '\n'); ! 2079: u = input_line_pointer - 1; ! 2080: *u = 0; ! 2081: sizeof_stub = strtoul(sizeof_stub_name, &endp, 0); ! 2082: if(*endp != '\0'){ ! 2083: as_warn("size of stub section: %s not a proper " ! 2084: "number", sizeof_stub_name); ! 2085: ignore_rest_of_line(); ! 2086: return; ! 2087: } ! 2088: *u = g; ! 2089: } ! 2090: else{ ! 2091: as_warn("missing size of stub section (%s,%s)", segname, ! 2092: sectname); ! 2093: ignore_rest_of_line(); ! 2094: return; ! 2095: } ! 2096: } ! 2097: } ! 2098: else if(type == S_SYMBOL_STUBS){ ! 2099: as_warn("missing size of stub section (%s,%s)", segname, ! 2100: sectname); ! 2101: ignore_rest_of_line(); ! 2102: return; ! 2103: } ! 2104: } ! 2105: input_line_pointer--; ! 2106: ! 2107: if(!flagseen['k']){ ! 2108: if(type == S_NON_LAZY_SYMBOL_POINTERS || ! 2109: type == S_LAZY_SYMBOL_POINTERS || ! 2110: type == S_SYMBOL_STUBS || ! 2111: type == S_MOD_INIT_FUNC_POINTERS) ! 2112: as_fatal("incompatible feature used: section type %s (must " ! 2113: "specify \"-dynamic\" to be " ! 2114: "used)", type_name->name); ! 2115: if(attribute != 0) ! 2116: as_fatal("incompatible feature used: section attribute %s " ! 2117: "(must specify \"-dynamic\" to be used)", ! 2118: attribute_name->name); ! 2119: } ! 2120: ! 2121: frcP = section_new(segname, sectname, type, attribute, sizeof_stub); ! 2122: *p = c; ! 2123: *q = d; ! 2124: demand_empty_rest_of_line(); ! 2125: } ! 2126: ! 2127: /* ! 2128: * s_zerofill() implements the pseudo op: ! 2129: * .zerofill segname , sectname [, symbolname , size_expression [ , align]] ! 2130: */ ! 2131: static ! 2132: void ! 2133: s_zerofill( ! 2134: int value) ! 2135: { ! 2136: char *segname, *sectname, c, d, *p, *q, *name; ! 2137: struct section s; ! 2138: frchainS *frcP; ! 2139: symbolS *symbolP; ! 2140: int size, align; ! 2141: ! 2142: segname = input_line_pointer; ! 2143: do{ ! 2144: c = *input_line_pointer++ ; ! 2145: }while(c != ',' && c != '\0' && c != '\n'); ! 2146: if(c != ','){ ! 2147: as_warn("Expected comma after segment-name"); ! 2148: ignore_rest_of_line(); ! 2149: return; ! 2150: } ! 2151: p = input_line_pointer - 1; ! 2152: ! 2153: sectname = input_line_pointer; ! 2154: do{ ! 2155: d = *input_line_pointer++ ; ! 2156: }while(d != ',' && d != '\0' && d != '\n'); ! 2157: if(p + 1 == input_line_pointer){ ! 2158: as_warn("Expected section-name after comma"); ! 2159: ignore_rest_of_line(); ! 2160: return; ! 2161: } ! 2162: q = input_line_pointer - 1; ! 2163: ! 2164: *p = 0; ! 2165: if(strlen(segname) > sizeof(s.segname)){ ! 2166: as_warn("segment-name: %s too long (maximum %ld characters)", ! 2167: segname, sizeof(s.segname)); ! 2168: ignore_rest_of_line(); ! 2169: *p = c; ! 2170: return; ! 2171: } ! 2172: ! 2173: *q = 0; ! 2174: if(strlen(sectname) > sizeof(s.sectname)){ ! 2175: as_warn("section-name: %s too long (maximum %ld characters)", ! 2176: sectname, sizeof(s.sectname)); ! 2177: ignore_rest_of_line(); ! 2178: *p = c; ! 2179: *q = d; ! 2180: return; ! 2181: } ! 2182: ! 2183: frcP = section_new(segname, sectname, S_ZEROFILL, 0, 0); ! 2184: if(frcP->frch_root == NULL){ ! 2185: frcP->frch_root = xmalloc(SIZEOF_STRUCT_FRAG); ! 2186: frcP->frch_last = frcP->frch_root; ! 2187: memset(frcP->frch_root, '\0', SIZEOF_STRUCT_FRAG); ! 2188: } ! 2189: *p = c; ! 2190: *q = d; ! 2191: /* ! 2192: * If this is the end of the line all that was wanted was to create the ! 2193: * the section which is now done, so return. ! 2194: */ ! 2195: if(d != ',') ! 2196: return; ! 2197: ! 2198: if(*input_line_pointer == '"') ! 2199: name = input_line_pointer + 1; ! 2200: else ! 2201: name = input_line_pointer; ! 2202: c = get_symbol_end(); ! 2203: p = input_line_pointer; ! 2204: *p = c; ! 2205: SKIP_WHITESPACE(); ! 2206: if(*input_line_pointer != ','){ ! 2207: as_warn("Expected comma after symbol-name"); ! 2208: ignore_rest_of_line(); ! 2209: return; ! 2210: } ! 2211: input_line_pointer ++; ! 2212: if((size = get_absolute_expression()) < 0){ ! 2213: as_warn("zerofill size (%d.) <0! Ignored.", size); ! 2214: ignore_rest_of_line(); ! 2215: return; ! 2216: } ! 2217: align = 0; ! 2218: if(*input_line_pointer == ','){ ! 2219: input_line_pointer++; ! 2220: align = get_absolute_expression(); ! 2221: if(align > MAX_ALIGNMENT){ ! 2222: as_warn("Alignment too large: %d. assumed.", MAX_ALIGNMENT); ! 2223: align = MAX_ALIGNMENT; ! 2224: } ! 2225: else if(align < 0){ ! 2226: as_warn("Alignment negative. 0 assumed."); ! 2227: align = 0; ! 2228: } ! 2229: } ! 2230: *p = 0; ! 2231: symbolP = symbol_find_or_make(name); ! 2232: *p = c; ! 2233: ! 2234: if((symbolP->sy_type & N_TYPE) == N_UNDF && symbolP->sy_value == 0){ ! 2235: frcP->frch_root->fr_address = round(frcP->frch_root->fr_address, ! 2236: 1 << align); ! 2237: symbolP->sy_value = frcP->frch_root->fr_address; ! 2238: symbolP->sy_type = N_SECT | (symbolP->sy_type & N_EXT); ! 2239: symbolP->sy_other = frcP->frch_nsect; ! 2240: symbolP->sy_frag = frcP->frch_root; ! 2241: frcP->frch_root->fr_address += size; ! 2242: } ! 2243: else ! 2244: as_warn("Ignoring attempt to re-define symbol."); ! 2245: ! 2246: demand_empty_rest_of_line(); ! 2247: } ! 2248: ! 2249: /* ! 2250: * s_reference() implements the pseudo op: ! 2251: * .reference name ! 2252: */ ! 2253: static ! 2254: void ! 2255: s_reference( ! 2256: int value) ! 2257: { ! 2258: char *name; ! 2259: char c; ! 2260: char *p; ! 2261: symbolS *symbolP; ! 2262: ! 2263: if(* input_line_pointer == '"') ! 2264: name = input_line_pointer + 1; ! 2265: else ! 2266: name = input_line_pointer; ! 2267: c = get_symbol_end(); ! 2268: p = input_line_pointer; ! 2269: ! 2270: *p = 0; ! 2271: symbolP = symbol_find_or_make(name); ! 2272: *p = c; ! 2273: demand_empty_rest_of_line(); ! 2274: } ! 2275: ! 2276: /* ! 2277: * s_lazy_reference() implements the pseudo op: ! 2278: * .lazy_reference name ! 2279: */ ! 2280: static ! 2281: void ! 2282: s_lazy_reference( ! 2283: int value) ! 2284: { ! 2285: char *name; ! 2286: char c; ! 2287: char *p; ! 2288: symbolS *symbolP; ! 2289: ! 2290: if(!flagseen['k']) ! 2291: as_fatal("incompatible feature used: .lazy_reference (must specify " ! 2292: "\"-dynamic\" to be used)"); ! 2293: ! 2294: if(* input_line_pointer == '"') ! 2295: name = input_line_pointer + 1; ! 2296: else ! 2297: name = input_line_pointer; ! 2298: c = get_symbol_end(); ! 2299: p = input_line_pointer; ! 2300: ! 2301: *p = 0; ! 2302: symbolP = symbol_find_or_make(name); ! 2303: if((symbolP->sy_type & N_TYPE) == N_UNDF && symbolP->sy_value == 0) ! 2304: symbolP->sy_desc |= REFERENCE_FLAG_UNDEFINED_LAZY; ! 2305: *p = c; ! 2306: demand_empty_rest_of_line(); ! 2307: } ! 2308: ! 2309: /* ! 2310: * s_include() implements the pseudo op: ! 2311: * .include "filename" ! 2312: */ ! 2313: static ! 2314: void ! 2315: s_include( ! 2316: int value) ! 2317: { ! 2318: char *filename; ! 2319: int length; ! 2320: symbolS *symbolP; ! 2321: ! 2322: /* Some assemblers tolerate immediately following '"' */ ! 2323: if((filename = demand_copy_string( & length ) )) { ! 2324: demand_empty_rest_of_line(); ! 2325: read_an_include_file(filename); ! 2326: } ! 2327: ! 2328: /* ! 2329: * This is to generate stabs for debugging assembly code. ! 2330: * See the second comment about stabs in read_a_source_file() ! 2331: * for a description of what is going on here ! 2332: */ ! 2333: if(flagseen['g'] && frchain_now->frch_nsect == text_nsect){ ! 2334: symbolP = symbol_new( ! 2335: physical_input_file, ! 2336: 132 /* N_SOL */, ! 2337: text_nsect, ! 2338: 0, ! 2339: obstack_next_free(&frags) - frag_now->fr_literal, ! 2340: frag_now); ! 2341: } ! 2342: } ! 2343: ! 2344: /* ! 2345: * demand_empty_rest_of_line() checks to make sure we are at the end of a line ! 2346: * and if not ignores the rest of the line. ! 2347: * This is global so machine dependent pseudo-ops can use this. ! 2348: */ ! 2349: void ! 2350: demand_empty_rest_of_line( ! 2351: void) ! 2352: { ! 2353: SKIP_WHITESPACE(); ! 2354: if(is_end_of_line[(int)*input_line_pointer]) ! 2355: input_line_pointer++; ! 2356: else ! 2357: ignore_rest_of_line(); ! 2358: } ! 2359: ! 2360: /* ! 2361: * ignore_rest_of_line() advances input_line_pointer to the next line and if ! 2362: * there is anything left on the current line print a warning. ! 2363: * This is global so machine dependent pseudo-ops can use this. ! 2364: */ ! 2365: void ! 2366: ignore_rest_of_line( ! 2367: void) ! 2368: { ! 2369: if(!is_end_of_line[(int)*input_line_pointer]){ ! 2370: as_warn("Rest of line ignored. 1st junk character valued %d (%c).", ! 2371: *input_line_pointer, *input_line_pointer); ! 2372: while(input_line_pointer < buffer_limit && ! 2373: !is_end_of_line[(int)*input_line_pointer]) ! 2374: input_line_pointer++; ! 2375: } ! 2376: input_line_pointer++; /* Return pointing just after end-of-line. */ ! 2377: know(is_end_of_line[(int)(input_line_pointer[-1])]); ! 2378: } ! 2379: ! 2380: /* ! 2381: * stab() ! 2382: * ! 2383: * Handle .stabX directives, which used to be open-coded. ! 2384: * So much creeping featurism overloaded the semantics that we decided ! 2385: * to put all .stabX thinking in one place. Here. ! 2386: * ! 2387: * We try to make any .stabX directive legal. Other people's AS will often ! 2388: * do assembly-time consistency checks: eg assigning meaning to n_type bits ! 2389: * and "protecting" you from setting them to certain values. (They also zero ! 2390: * certain bits before emitting symbols. Tut tut.) ! 2391: * ! 2392: * If an expression is not absolute we either gripe or use the relocation ! 2393: * information. Other people's assemblers silently forget information they ! 2394: * don't need and invent information they need that you didn't supply. ! 2395: * ! 2396: * .stabX directives always make a symbol table entry. It may be junk if ! 2397: * the rest of your .stabX directive is malformed. ! 2398: */ ! 2399: static ! 2400: void ! 2401: stab( ! 2402: int what) /* d == .stabd, n == .stabn, and s == .stabs */ ! 2403: { ! 2404: symbolS *symbolP; ! 2405: char *string; ! 2406: int saved_type; ! 2407: int length; ! 2408: int goof; /* TRUE if we have aborted. */ ! 2409: long longint; ! 2410: ! 2411: saved_type = 0; ! 2412: /* ! 2413: * Enter with input_line_pointer pointing past .stabX and any following ! 2414: * whitespace. ! 2415: */ ! 2416: goof = FALSE; ! 2417: if(what == 's'){ ! 2418: string = demand_copy_C_string(&length); ! 2419: SKIP_WHITESPACE(); ! 2420: if(*input_line_pointer == ',') ! 2421: input_line_pointer ++; ! 2422: else{ ! 2423: as_warn("I need a comma after symbol's name"); ! 2424: goof = TRUE; ! 2425: } ! 2426: } ! 2427: else ! 2428: string = ""; ! 2429: ! 2430: /* ! 2431: * Input_line_pointer->after ','. String -> symbol name. ! 2432: */ ! 2433: if(!goof){ ! 2434: symbolP = symbol_new(string, 0,0,0,0,(struct frag *)0); ! 2435: switch(what){ ! 2436: case 'd': ! 2437: symbolP->sy_name = NULL; /* .stabd feature. */ ! 2438: symbolP->sy_value = obstack_next_free(&frags) - ! 2439: frag_now->fr_literal; ! 2440: symbolP->sy_frag = frag_now; ! 2441: break; ! 2442: ! 2443: case 'n': ! 2444: case 's': ! 2445: symbolP->sy_frag = &zero_address_frag; ! 2446: break; ! 2447: ! 2448: default: ! 2449: BAD_CASE( what ); ! 2450: break; ! 2451: } ! 2452: if(get_absolute_expression_and_terminator(&longint) == ','){ ! 2453: saved_type = longint; ! 2454: symbolP->sy_type = longint; ! 2455: } ! 2456: else{ ! 2457: as_warn("I want a comma after the n_type expression"); ! 2458: goof = TRUE; ! 2459: input_line_pointer--; /* Backup over a non-',' char. */ ! 2460: } ! 2461: } ! 2462: ! 2463: if(!goof){ ! 2464: if(get_absolute_expression_and_terminator(&longint) == ',') ! 2465: symbolP->sy_other = longint; ! 2466: else { ! 2467: as_warn("I want a comma after the n_other expression"); ! 2468: goof = TRUE; ! 2469: input_line_pointer--; /* Backup over a non-',' char. */ ! 2470: } ! 2471: } ! 2472: ! 2473: if(!goof){ ! 2474: symbolP->sy_desc = get_absolute_expression(); ! 2475: if(what == 's' || what == 'n'){ ! 2476: if(*input_line_pointer != ','){ ! 2477: as_warn( "I want a comma after the n_desc expression" ); ! 2478: goof = TRUE; ! 2479: } ! 2480: else ! 2481: input_line_pointer ++; ! 2482: } ! 2483: } ! 2484: ! 2485: if((!goof) && (what=='s' || what=='n')){ ! 2486: pseudo_set(symbolP); ! 2487: symbolP->sy_type = saved_type; ! 2488: } ! 2489: else if(!goof){ ! 2490: /* for stabd the sy_other (n_sect) gets set to the current section*/ ! 2491: symbolP->sy_other = frchain_now->frch_nsect; ! 2492: } ! 2493: if(goof) ! 2494: ignore_rest_of_line(); ! 2495: else ! 2496: demand_empty_rest_of_line(); ! 2497: } ! 2498: ! 2499: /* ! 2500: * pseudo_set() ! 2501: * ! 2502: * In: Pointer to a symbol. ! 2503: * Input_line_pointer -> expression. ! 2504: * ! 2505: * Out: Input_line_pointer -> just after any whitespace after expression. ! 2506: * Tried to set symbol to value of expression. ! 2507: * Will change sy_type, sy_value, sy_frag; ! 2508: *(old ->> May set need_pass_2 == TRUE. <<-- commented out by GNU below it ! 2509: * uses symbolP->sy_forward = exp.X_add_symbol;) ! 2510: */ ! 2511: static ! 2512: void ! 2513: pseudo_set( ! 2514: symbolS *symbolP) ! 2515: { ! 2516: expressionS exp; ! 2517: segT segment; ! 2518: int ext; ! 2519: ! 2520: know(symbolP); /* NULL pointer is logic error. */ ! 2521: ext = (symbolP->sy_type & N_EXT); ! 2522: segment = expression(&exp); ! 2523: ! 2524: switch(segment){ ! 2525: case SEG_BIG: ! 2526: as_warn("%s number illegal. Absolute 0 assumed.", ! 2527: exp.X_add_number > 0 ? "Bignum" : "Floating-Point"); ! 2528: symbolP->sy_type = N_ABS | ext; ! 2529: symbolP->sy_other = 0; /* NO_SECT */ ! 2530: symbolP->sy_value = 0; ! 2531: symbolP->sy_frag = &zero_address_frag; ! 2532: break; ! 2533: ! 2534: case SEG_NONE: ! 2535: as_warn("No expression: Using absolute 0"); ! 2536: symbolP->sy_type = N_ABS | ext; ! 2537: symbolP->sy_other = 0; /* NO_SECT */ ! 2538: symbolP->sy_value = 0; ! 2539: symbolP->sy_frag = &zero_address_frag; ! 2540: break; ! 2541: ! 2542: case SEG_DIFFSECT: ! 2543: if(exp.X_add_symbol && exp.X_subtract_symbol && ! 2544: exp.X_add_symbol->sy_other == exp.X_subtract_symbol->sy_other) ! 2545: exp.X_add_number += exp.X_add_symbol->sy_value - ! 2546: exp.X_subtract_symbol->sy_value; ! 2547: else ! 2548: as_warn("Complex expression. Absolute segment assumed." ); ! 2549: /* fall through */ ! 2550: ! 2551: case SEG_ABSOLUTE: ! 2552: symbolP->sy_type = N_ABS | ext; ! 2553: symbolP->sy_other = 0; /* NO_SECT */ ! 2554: symbolP->sy_value = exp.X_add_number; ! 2555: symbolP->sy_frag = &zero_address_frag; ! 2556: break; ! 2557: ! 2558: case SEG_SECT: ! 2559: symbolP->sy_type = N_SECT | ext; ! 2560: symbolP->sy_other = exp.X_add_symbol->sy_other; ! 2561: symbolP->sy_value = exp.X_add_number + exp.X_add_symbol->sy_value; ! 2562: symbolP->sy_frag = exp.X_add_symbol->sy_frag; ! 2563: break; ! 2564: ! 2565: case SEG_UNKNOWN: ! 2566: symbolP->sy_forward = exp.X_add_symbol; ! 2567: /* commented out by GNU */ ! 2568: /* as_warn("unknown symbol"); */ ! 2569: /* need_pass_2 = TRUE; */ ! 2570: break; ! 2571: ! 2572: default: ! 2573: BAD_CASE(segment); ! 2574: break; ! 2575: } ! 2576: } ! 2577: ! 2578: /* ! 2579: * cons() ! 2580: * ! 2581: * CONStruct more frag of .bytes, or .words etc. ! 2582: * This understands EXPRESSIONS, as opposed to big_cons(). ! 2583: * ! 2584: * Bug (?) ! 2585: * ! 2586: * This has a split personality. We use expression() to read the ! 2587: * value. We can detect if the value won't fit in a byte or word. ! 2588: * But we can't detect if expression() discarded significant digits ! 2589: * in the case of a long. Not worth the crocks required to fix it. ! 2590: * ! 2591: * Worker function to do .byte, .short, .long, statements. ! 2592: * This clobbers input_line_pointer, checks end-of-line. ! 2593: */ ! 2594: void ! 2595: cons( ! 2596: int nbytes) /* nbytes == 1 for .byte, 2 for .word, 4 for .long */ ! 2597: { ! 2598: char c; ! 2599: long mask; /* high-order bits to truncate */ ! 2600: long unmask; /* what bits we will store */ ! 2601: long get; /* the bits of the expression we get */ ! 2602: long use; /* the bits of the expression after truncation */ ! 2603: char *p; /* points into the frag */ ! 2604: segT segment; ! 2605: expressionS exp; ! 2606: ! 2607: /* ! 2608: * Input_line_pointer -> 1st char after pseudo-op-code and could legally ! 2609: * be a end-of-line. (Or, less legally an eof - which we cope with.) ! 2610: */ ! 2611: if(nbytes >= sizeof(long int)) ! 2612: mask = 0; ! 2613: else ! 2614: mask = ~0 << (BITS_PER_CHAR * nbytes); /* Don't store these bits. */ ! 2615: unmask = ~mask; /* Do store these bits. */ ! 2616: ! 2617: /* ! 2618: * The following awkward logic is to parse ZERO or more expressions, ! 2619: * comma seperated. Recall an expression includes its leading & ! 2620: * trailing blanks. We fake a leading ',' if there is (supposed to ! 2621: * be) a 1st expression, and keep demanding 1 expression for each ','. ! 2622: */ ! 2623: if(is_it_end_of_statement()){ ! 2624: c = 0; /* Skip loop. */ ! 2625: input_line_pointer++; /* Matches end-of-loop 'correction'. */ ! 2626: } ! 2627: else ! 2628: c = ','; /* Do loop. */ ! 2629: ! 2630: while(c == ','){ ! 2631: segment = expression(&exp); /* At least scan over the expression */ ! 2632: ! 2633: if(segment == SEG_DIFFSECT && exp.X_add_symbol == NULL){ ! 2634: as_warn("Subtracting symbol \"%s\"(segment\"%s\") is too " ! 2635: "hard. Absolute segment assumed.", ! 2636: exp.X_subtract_symbol->sy_name, ! 2637: seg_name[(int)N_TYPE_seg[ ! 2638: exp.X_subtract_symbol->sy_type & N_TYPE]]); ! 2639: segment = SEG_ABSOLUTE; ! 2640: /* Leave exp .X_add_number alone. */ ! 2641: } ! 2642: p = frag_more(nbytes); ! 2643: switch(segment){ ! 2644: case SEG_BIG: ! 2645: as_warn("%s number illegal. Absolute 0 assumed.", ! 2646: exp.X_add_number > 0 ? "Bignum" : "Floating-Point"); ! 2647: md_number_to_chars(p, (long)0, nbytes); ! 2648: break; ! 2649: ! 2650: case SEG_NONE: ! 2651: as_warn("0 assumed for missing expression"); ! 2652: exp.X_add_number = 0; ! 2653: know(exp.X_add_symbol == NULL); ! 2654: /* fall into SEG_ABSOLUTE */ ! 2655: ! 2656: case SEG_ABSOLUTE: ! 2657: get = exp.X_add_number; ! 2658: use = get & unmask; ! 2659: if((get & mask) && (get & mask) != mask){ ! 2660: /* Leading bits contain both 0s & 1s. */ ! 2661: as_warn("Value x%x truncated to x%x.", (unsigned int)get, ! 2662: (unsigned int)use); ! 2663: } ! 2664: /* put bytes in right order. */ ! 2665: md_number_to_chars(p, use, nbytes); ! 2666: break; ! 2667: ! 2668: case SEG_DIFFSECT: ! 2669: case SEG_UNKNOWN: ! 2670: case SEG_SECT: ! 2671: fix_new(frag_now, ! 2672: p - frag_now->fr_literal, ! 2673: nbytes, ! 2674: exp.X_add_symbol, ! 2675: exp.X_subtract_symbol, ! 2676: exp.X_add_number, ! 2677: 0, ! 2678: 0, ! 2679: 0); ! 2680: break; ! 2681: ! 2682: default: ! 2683: BAD_CASE(segment); ! 2684: break; ! 2685: } /* switch(segment) */ ! 2686: c = *input_line_pointer++; ! 2687: } /* while(c==',') */ ! 2688: input_line_pointer--; /* Put terminator back into stream. */ ! 2689: demand_empty_rest_of_line(); ! 2690: } ! 2691: ! 2692: #ifdef M68K /* we allow big cons only on the 68k machines */ ! 2693: /* ! 2694: * big_cons() ! 2695: * ! 2696: * CONStruct more frag(s) of .quads, or .octa etc. ! 2697: * Makes 0 or more new frags. ! 2698: * This understands only bignums, not expressions. Cons() understands ! 2699: * expressions. ! 2700: * ! 2701: * Constants recognised are '0...'(octal) '0x...'(hex) '...'(decimal). ! 2702: * ! 2703: * This creates objects with struct obstack_control objs, destroying ! 2704: * any context objs held about a partially completed object. Beware! ! 2705: * ! 2706: * ! 2707: * I think it sucks to have 2 different types of integers, with 2 ! 2708: * routines to read them, store them etc. ! 2709: * It would be nicer to permit bignums in expressions and only ! 2710: * complain if the result overflowed. However, due to "efficiency"... ! 2711: * ! 2712: * Worker function to do .quad and .octa statements. ! 2713: * This clobbers input_line_pointer, checks end-of-line. ! 2714: */ ! 2715: void ! 2716: big_cons( ! 2717: int nbytes) /* 8 == .quad, 16 == .octa ... */ ! 2718: { ! 2719: char c; /* input_line_pointer -> c. */ ! 2720: int radix; ! 2721: long length;/* Number of chars in an object. */ ! 2722: int digit; /* Value of 1 digit. */ ! 2723: int carry; /* For multi-precision arithmetic. */ ! 2724: int work; /* For multi-precision arithmetic. */ ! 2725: char *p,*q; /* For multi-precision arithmetic. */ ! 2726: int i; ! 2727: ! 2728: /* ! 2729: * The following awkward logic is to parse ZERO or more strings, ! 2730: * comma seperated. Recall an expression includes its leading & ! 2731: * trailing blanks. We fake a leading ',' if there is (supposed to ! 2732: * be) a 1st expression, and keep demanding 1 expression for each ','. ! 2733: */ ! 2734: if(is_it_end_of_statement()){ ! 2735: c = 0; /* Skip loop. */ ! 2736: } ! 2737: else{ ! 2738: c = ','; /* Do loop. */ ! 2739: --input_line_pointer; ! 2740: } ! 2741: while(c == ','){ ! 2742: ++input_line_pointer; ! 2743: SKIP_WHITESPACE(); ! 2744: c = *input_line_pointer; ! 2745: /* c contains 1st non-blank char of what we hope is a number */ ! 2746: if(c == '0'){ ! 2747: c = *++input_line_pointer; ! 2748: if(c == 'x' || c=='X'){ ! 2749: c = *++input_line_pointer; ! 2750: radix = 16; ! 2751: } ! 2752: else{ ! 2753: radix = 8; ! 2754: } ! 2755: } ! 2756: else{ ! 2757: radix = 10; ! 2758: } ! 2759: /* ! 2760: * This feature (?) is here to stop people worrying about ! 2761: * mysterious zero constants: which is what they get when ! 2762: * they completely omit digits. ! 2763: */ ! 2764: if(hex_value[(int)c] >= radix){ ! 2765: as_warn("Missing digits. 0 assumed."); ! 2766: } ! 2767: bignum_high = bignum_low - 1; /* Start constant with 0 chars. */ ! 2768: for( ; ! 2769: (digit = hex_value[(int)c]) < radix; ! 2770: c = *++input_line_pointer){ ! 2771: /* Multiply existing number by radix, then add digit. */ ! 2772: carry = digit; ! 2773: for(p = bignum_low; p <= bignum_high; p++){ ! 2774: work = (*p & MASK_CHAR) * radix + carry; ! 2775: *p = work & MASK_CHAR; ! 2776: carry = work >> BITS_PER_CHAR; ! 2777: } ! 2778: if(carry){ ! 2779: grow_bignum(); ! 2780: *bignum_high = carry & MASK_CHAR; ! 2781: know((carry & ~ MASK_CHAR) == 0); ! 2782: } ! 2783: } ! 2784: length = bignum_high - bignum_low + 1; ! 2785: if(length > nbytes){ ! 2786: as_warn("Most significant bits truncated in integer constant."); ! 2787: } ! 2788: else{ ! 2789: long leading_zeroes; ! 2790: ! 2791: for(leading_zeroes = nbytes - length; ! 2792: leading_zeroes; ! 2793: leading_zeroes--){ ! 2794: grow_bignum(); ! 2795: *bignum_high = 0; ! 2796: } ! 2797: } ! 2798: p = frag_more(nbytes); ! 2799: if(md_target_byte_sex == BIG_ENDIAN_BYTE_SEX){ ! 2800: q = (char *)bignum_low; ! 2801: for(i = nbytes - 1; i >= 0; i--) ! 2802: *p++ = q[i]; ! 2803: } ! 2804: else{ ! 2805: memcpy(p, bignum_low, (int)nbytes); ! 2806: } ! 2807: /* C contains character after number. */ ! 2808: SKIP_WHITESPACE(); ! 2809: c = *input_line_pointer; ! 2810: /* C contains 1st non-blank character after number. */ ! 2811: } ! 2812: demand_empty_rest_of_line(); ! 2813: } ! 2814: ! 2815: /* ! 2816: * grow_bignum() extends bignum (that is adjust bignum_low, bignum_high and ! 2817: * bignum_limit). ! 2818: */ ! 2819: static ! 2820: void ! 2821: grow_bignum( ! 2822: void) ! 2823: { ! 2824: long length; ! 2825: ! 2826: bignum_high++; ! 2827: if(bignum_high >= bignum_limit) ! 2828: { ! 2829: length = bignum_limit - bignum_low; ! 2830: bignum_low = xrealloc(bignum_low, length + length); ! 2831: bignum_high = bignum_low + length; ! 2832: bignum_limit = bignum_low + length + length; ! 2833: } ! 2834: } ! 2835: #endif /* M68K we allow big cons only on the 68k machines */ ! 2836: ! 2837: /* ! 2838: * float_cons() ! 2839: * ! 2840: * CONStruct some more frag chars of .floats .ffloats etc. ! 2841: * Makes 0 or more new frags. ! 2842: * This understands only floating literals, not expressions. Sorry. ! 2843: * ! 2844: * A floating constant is defined by atof_generic(), except it is preceded ! 2845: * by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its ! 2846: * reading, I decided to be incompatible. This always tries to give you ! 2847: * rounded bits to the precision of the pseudo-op. Former AS did premature ! 2848: * truncatation, restored noisy bits instead of trailing 0s AND gave you ! 2849: * a choice of 2 flavours of noise according to which of 2 floating-point ! 2850: * scanners you directed AS to use. ! 2851: * ! 2852: * In: input_line_pointer -> whitespace before, or '0' of flonum. ! 2853: * ! 2854: * Worker function to do .double, .float, .single statements. ! 2855: * This clobbers input_line-pointer, checks end-of-line. ! 2856: */ ! 2857: void ! 2858: float_cons( ! 2859: int float_type) /* 'f':.ffloat ... 'F':.float ... */ ! 2860: { ! 2861: char *p; ! 2862: char c; ! 2863: int length; /* Number of chars in an object. */ ! 2864: char *err; /* Error from scanning floating literal. */ ! 2865: char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT]; ! 2866: ! 2867: /* ! 2868: * The following awkward logic is to parse ZERO or more strings, ! 2869: * comma seperated. Recall an expression includes its leading & ! 2870: * trailing blanks. We fake a leading ',' if there is (supposed to ! 2871: * be) a 1st expression, and keep demanding 1 expression for each ','. ! 2872: */ ! 2873: if(is_it_end_of_statement()){ ! 2874: c = 0; /* Skip loop. */ ! 2875: ++input_line_pointer; /* -> past termintor. */ ! 2876: } ! 2877: else{ ! 2878: c = ','; /* Do loop. */ ! 2879: } ! 2880: while(c == ','){ ! 2881: /* input_line_pointer -> 1st char of a flonum (we hope!). */ ! 2882: SKIP_WHITESPACE(); ! 2883: /* ! 2884: * Skip any 0{letter} that may be present. Don't even check if the ! 2885: * letter is legal. Someone may invent a "z" format and this routine ! 2886: * has no use for such information. Lusers beware: you get ! 2887: * diagnostics if your input is ill-conditioned. ! 2888: */ ! 2889: if(input_line_pointer[0] == '0' && isalpha(input_line_pointer[1])) ! 2890: input_line_pointer+=2; ! 2891: ! 2892: err = md_atof(float_type, temp, &length); ! 2893: know(length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT); ! 2894: know(length > 0); ! 2895: if(*err != '\0'){ ! 2896: as_warn( "Bad floating literal: %s", err); ! 2897: ignore_rest_of_line(); ! 2898: /* Input_line_pointer -> just after end-of-line. */ ! 2899: c = 0; /* Break out of loop. */ ! 2900: } ! 2901: else{ ! 2902: p = frag_more(length); ! 2903: memcpy(p, temp, length); ! 2904: SKIP_WHITESPACE(); ! 2905: c = *input_line_pointer ++; ! 2906: /* C contains 1st non-white character after number. */ ! 2907: /* input_line_pointer -> just after terminator (c). */ ! 2908: } ! 2909: } ! 2910: --input_line_pointer; /* -> terminator (is not ','). */ ! 2911: demand_empty_rest_of_line(); ! 2912: } ! 2913: ! 2914: /* ! 2915: * stringer() ! 2916: * ! 2917: * We read 0 or more ',' seperated, double-quoted strings. ! 2918: * ! 2919: * Worker function to do .ascii etc statements. ! 2920: * Checks end-of-line. ! 2921: */ ! 2922: void ! 2923: stringer( ! 2924: int append_zero) /* 0: don't append '\0', else 1 */ ! 2925: { ! 2926: int c; ! 2927: ! 2928: /* ! 2929: * The following awkward logic is to parse ZERO or more strings, ! 2930: * comma seperated. Recall a string expression includes spaces ! 2931: * before the opening '\"' and spaces after the closing '\"'. ! 2932: * We fake a leading ',' if there is (supposed to be) ! 2933: * a 1st, expression. We keep demanding expressions for each ! 2934: * ','. ! 2935: */ ! 2936: if(is_it_end_of_statement()){ ! 2937: c = 0; /* Skip loop. */ ! 2938: ++ input_line_pointer; /* Compensate for end of loop. */ ! 2939: } ! 2940: else{ ! 2941: c = ','; /* Do loop. */ ! 2942: } ! 2943: for( ; c == ','; c = *input_line_pointer++){ ! 2944: SKIP_WHITESPACE(); ! 2945: if(*input_line_pointer == '\"'){ ! 2946: ++input_line_pointer; /* -> 1st char of string. */ ! 2947: while((c = next_char_of_string()) >= 0){ ! 2948: FRAG_APPEND_1_CHAR(c); ! 2949: } ! 2950: if(append_zero){ ! 2951: FRAG_APPEND_1_CHAR(0); ! 2952: } ! 2953: know(input_line_pointer[-1] == '\"'); ! 2954: } ! 2955: else{ ! 2956: as_warn("Expected \"-ed string"); ! 2957: } ! 2958: SKIP_WHITESPACE(); ! 2959: } ! 2960: --input_line_pointer; ! 2961: demand_empty_rest_of_line(); ! 2962: } ! 2963: ! 2964: /* ! 2965: * next_char_of_string() is used by stringer() and demand_copy_string() and ! 2966: * returns the next character from input_line_pointer that is in the string or ! 2967: * -1 for the trailing " character. This routine handles escaped characters ! 2968: * like \b, \f, etc. ! 2969: */ ! 2970: static ! 2971: int ! 2972: next_char_of_string( ! 2973: void) ! 2974: { ! 2975: int c; ! 2976: long number, i; ! 2977: ! 2978: c = *input_line_pointer++; ! 2979: /* make sure the 0xff char is not returned as -1 */ ! 2980: c = (c & MASK_CHAR); ! 2981: switch(c){ ! 2982: case '\"': ! 2983: c = -1; ! 2984: break; ! 2985: ! 2986: case '\\': ! 2987: c = *input_line_pointer++; ! 2988: switch(c){ ! 2989: case 'b': ! 2990: c = '\b'; ! 2991: break; ! 2992: case 'f': ! 2993: c = '\f'; ! 2994: break; ! 2995: case 'n': ! 2996: c = '\n'; ! 2997: break; ! 2998: case 'r': ! 2999: c = '\r'; ! 3000: break; ! 3001: case 't': ! 3002: c = '\t'; ! 3003: break; ! 3004: case '\\': ! 3005: case '"': ! 3006: break; /* As itself. */ ! 3007: case '0': ! 3008: case '1': ! 3009: case '2': ! 3010: case '3': ! 3011: case '4': ! 3012: case '5': ! 3013: case '6': ! 3014: case '7': ! 3015: case '8': ! 3016: case '9': ! 3017: for(i = 0, number = 0; ! 3018: i < 3 && isdigit(c) && c < '8'; ! 3019: i++, c = *input_line_pointer++) ! 3020: number = number * 8 + c - '0'; ! 3021: c = number; ! 3022: --input_line_pointer; ! 3023: break; ! 3024: case '\n': ! 3025: /* To be compatible with BSD 4.2 as: give the user a linefeed */ ! 3026: c = '\n'; ! 3027: break; ! 3028: ! 3029: default: ! 3030: as_warn( "Bad escaped character in string, '?' assumed" ); ! 3031: c = '?'; ! 3032: break; ! 3033: } ! 3034: break; ! 3035: default: ! 3036: break; ! 3037: } ! 3038: return(c); ! 3039: } ! 3040: ! 3041: /* ! 3042: * get_segmented_expression() is passed an expression to fill in and return that ! 3043: * is anything except a bignum or a missing expression. ! 3044: */ ! 3045: static ! 3046: segT ! 3047: get_segmented_expression( ! 3048: expressionS *expP) ! 3049: { ! 3050: segT retval; ! 3051: ! 3052: retval = expression(expP); ! 3053: if(retval == SEG_NONE || retval == SEG_BIG){ ! 3054: as_warn("Expected address expression: absolute 0 assumed"); ! 3055: retval = expP->X_seg = SEG_ABSOLUTE; ! 3056: expP->X_add_number = 0; ! 3057: expP->X_add_symbol = NULL; ! 3058: expP->X_subtract_symbol = NULL; ! 3059: } ! 3060: return(retval); /* SEG_ ABSOLUTE,UNKNOWN,SECT */ ! 3061: } ! 3062: ! 3063: /* ! 3064: * get_known_segmented_expression() is passed an expression to fill in and ! 3065: * return that is anything except an unknown, bignum or a missing expression. ! 3066: */ ! 3067: segT ! 3068: get_known_segmented_expression( ! 3069: expressionS *expP) ! 3070: { ! 3071: segT retval; ! 3072: char *name1; ! 3073: char *name2; ! 3074: ! 3075: retval = get_segmented_expression(expP); ! 3076: if(retval == SEG_UNKNOWN){ ! 3077: name1 = expP->X_add_symbol ? ! 3078: expP->X_add_symbol->sy_name : ""; ! 3079: name2 = expP->X_subtract_symbol ? ! 3080: expP->X_subtract_symbol->sy_name : ""; ! 3081: if(name1 && name2){ ! 3082: as_warn("Symbols \"%s\" \"%s\" are undefined: absolute 0 " ! 3083: "assumed.", name1, name2); ! 3084: } ! 3085: else{ ! 3086: as_warn("Symbol \"%s\" undefined: absolute 0 assumed.", ! 3087: name1 ? name1 : name2); ! 3088: } ! 3089: retval = SEG_ABSOLUTE; ! 3090: expP->X_seg = SEG_ABSOLUTE; ! 3091: expP->X_add_number = 0; ! 3092: expP->X_add_symbol = NULL; ! 3093: expP->X_subtract_symbol = NULL; ! 3094: } ! 3095: know(retval == SEG_ABSOLUTE || ! 3096: retval == SEG_SECT || ! 3097: retval == SEG_DIFFSECT); ! 3098: return(retval); ! 3099: } ! 3100: ! 3101: /* ! 3102: * get_absolute_expression() gets an absolute expression and returns the value ! 3103: * of that expression. ! 3104: */ ! 3105: long ! 3106: get_absolute_expression( ! 3107: void) ! 3108: { ! 3109: expressionS exp; ! 3110: segT s; ! 3111: ! 3112: s = expression(&exp); ! 3113: if(s != SEG_ABSOLUTE){ ! 3114: /* is this right? if not absolute: no message and return 0 */ ! 3115: if(s != SEG_NONE){ ! 3116: as_warn("Bad Absolute Expression, absolute 0 assumed."); ! 3117: } ! 3118: exp.X_add_number = 0; ! 3119: } ! 3120: return(exp.X_add_number); ! 3121: } ! 3122: ! 3123: /* ! 3124: * get_absolute_expression_and_terminator() gets an absolute expression and ! 3125: * returning the value of that expression indirectly through val_pointer and ! 3126: * returns the terminator. ! 3127: */ ! 3128: static ! 3129: char /* return terminator */ ! 3130: get_absolute_expression_and_terminator( ! 3131: long *val_pointer) /* return value of expression */ ! 3132: { ! 3133: *val_pointer = get_absolute_expression(); ! 3134: return(*input_line_pointer++); ! 3135: } ! 3136: ! 3137: /* ! 3138: * demand_copy_C_string() ! 3139: * ! 3140: * Like demand_copy_string, but return NULL if the string contains any '\0's. ! 3141: * Give a warning if that happens. ! 3142: */ ! 3143: static ! 3144: char * ! 3145: demand_copy_C_string( ! 3146: int *len_pointer) ! 3147: { ! 3148: char *s; ! 3149: int len; ! 3150: ! 3151: if((s = demand_copy_string(len_pointer))){ ! 3152: for(len = *len_pointer; len > 0; len--){ ! 3153: if(*s == '\0'){ ! 3154: s = 0; ! 3155: len = 1; ! 3156: *len_pointer = 0; ! 3157: as_warn("This string may not contain \'\\0\'"); ! 3158: } ! 3159: } ! 3160: } ! 3161: return(s); ! 3162: } ! 3163: ! 3164: /* ! 3165: * demand_copy_string() ! 3166: * ! 3167: * Demand string, but return a safe (=private) copy of the string. ! 3168: * Return NULL if we can't read a string here. ! 3169: */ ! 3170: static ! 3171: char * ! 3172: demand_copy_string( ! 3173: int *lenP) ! 3174: { ! 3175: int c; ! 3176: int len; ! 3177: char *retval; ! 3178: ! 3179: len = 0; ! 3180: SKIP_WHITESPACE(); ! 3181: if(*input_line_pointer == '\"'){ ! 3182: input_line_pointer++; /* Skip opening quote. */ ! 3183: while((c = next_char_of_string()) >= 0){ ! 3184: obstack_1grow(¬es, c); ! 3185: len++; ! 3186: } ! 3187: /* ! 3188: * This next line is so demand_copy_C_string will return a null ! 3189: * termanated string. ! 3190: */ ! 3191: obstack_1grow(¬es, '\0'); ! 3192: retval = obstack_finish(¬es); ! 3193: } ! 3194: else{ ! 3195: as_warn("Missing string"); ! 3196: retval = NULL; ! 3197: ignore_rest_of_line(); ! 3198: } ! 3199: *lenP = len; ! 3200: return(retval); ! 3201: } ! 3202: ! 3203: /* ! 3204: * is_it_end_of_statement() ! 3205: * ! 3206: * In: Input_line_pointer -> next character. ! 3207: * ! 3208: * Do: Skip input_line_pointer over all whitespace. ! 3209: * ! 3210: * Out: TRUE if input_line_pointer -> end-of-line. ! 3211: */ ! 3212: static ! 3213: int ! 3214: is_it_end_of_statement( ! 3215: void) ! 3216: { ! 3217: SKIP_WHITESPACE(); ! 3218: return(is_end_of_line[(int)*input_line_pointer]); ! 3219: } ! 3220: ! 3221: /* ! 3222: * equals() implements the assembly statement: ! 3223: * x = expression ! 3224: */ ! 3225: static ! 3226: void ! 3227: equals( ! 3228: char *sym_name) ! 3229: { ! 3230: struct symbol *symbolP; ! 3231: segT segment; ! 3232: expressionS exp; ! 3233: char *p; ! 3234: ! 3235: /* Turn '. = mumble' into a .org mumble */ ! 3236: if(sym_name[0]=='.' && sym_name[1]=='\0'){ ! 3237: if(input_line_pointer[1] == '=') ! 3238: input_line_pointer += 2; ! 3239: else ! 3240: *input_line_pointer++ = '='; /* Put it back */ ! 3241: if(*input_line_pointer==' ' || *input_line_pointer=='\t') ! 3242: input_line_pointer++; ! 3243: segment = get_known_segmented_expression(&exp); ! 3244: if((segment != SEG_SECT || ! 3245: exp.X_add_symbol->sy_other != frchain_now->frch_nsect) && ! 3246: segment != SEG_ABSOLUTE) ! 3247: as_warn("Illegal expression. current section assumed."); ! 3248: p = frag_var(rs_org, ! 3249: 1, ! 3250: 1, ! 3251: (relax_substateT)0, ! 3252: exp.X_add_symbol, ! 3253: exp.X_add_number, ! 3254: (char *)0); ! 3255: *p = 0; ! 3256: return; ! 3257: } ! 3258: ! 3259: symbolP = symbol_find_or_make(sym_name); ! 3260: if(input_line_pointer[1] == '=') ! 3261: input_line_pointer += 2; ! 3262: else ! 3263: *input_line_pointer++ = '='; /* Put it back */ ! 3264: if(*input_line_pointer==' ' || *input_line_pointer=='\t') ! 3265: input_line_pointer++; ! 3266: pseudo_set(symbolP); ! 3267: } ! 3268: ! 3269: /* ! 3270: * s_if() implements the pseudo op: ! 3271: * .if expression ! 3272: * that does conditional assembly using assembler defined expressions. ! 3273: */ ! 3274: static ! 3275: void ! 3276: s_if( ! 3277: int value) ! 3278: { ! 3279: if(if_depth >= MAX_IF_DEPTH) ! 3280: as_fatal("You can't nest if's more than %d levels deep", ! 3281: MAX_IF_DEPTH); ! 3282: last_states[if_depth++] = the_cond_state; ! 3283: the_cond_state.the_cond = if_cond; ! 3284: if(the_cond_state.ignore) ! 3285: totally_ignore_line(); ! 3286: else{ ! 3287: the_cond_state.cond_met = get_absolute_expression(); ! 3288: the_cond_state.ignore = !the_cond_state.cond_met; ! 3289: demand_empty_rest_of_line(); ! 3290: } ! 3291: } ! 3292: ! 3293: /* ! 3294: * s_elseif() implements the pseudo op: ! 3295: * .elseif expression ! 3296: * that does conditional assembly using assembler defined expressions. ! 3297: */ ! 3298: static ! 3299: void ! 3300: s_elseif( ! 3301: int value) ! 3302: { ! 3303: int last_ignore_state; ! 3304: ! 3305: if(the_cond_state.the_cond != if_cond && ! 3306: the_cond_state.the_cond != elseif_cond) ! 3307: as_fatal("Encountered a .elseif that doesn't follow a .if or an " ! 3308: ".elseif"); ! 3309: the_cond_state.the_cond = elseif_cond; ! 3310: ! 3311: last_ignore_state = FALSE; ! 3312: if(if_depth) ! 3313: last_ignore_state = last_states[if_depth-1].ignore; ! 3314: if(last_ignore_state || the_cond_state.cond_met){ ! 3315: the_cond_state.ignore = TRUE; ! 3316: totally_ignore_line(); ! 3317: } ! 3318: else{ ! 3319: the_cond_state.cond_met = get_absolute_expression(); ! 3320: the_cond_state.ignore = !the_cond_state.cond_met; ! 3321: demand_empty_rest_of_line(); ! 3322: } ! 3323: } ! 3324: ! 3325: /* ! 3326: * s_else() implements the pseudo op: ! 3327: * .else ! 3328: * that does conditional assembly using assembler defined expressions. ! 3329: */ ! 3330: static ! 3331: void ! 3332: s_else( ! 3333: int value) ! 3334: { ! 3335: int last_ignore_state; ! 3336: ! 3337: if(the_cond_state.the_cond != if_cond && ! 3338: the_cond_state.the_cond != elseif_cond) ! 3339: as_fatal("Encountered a .else that doesn't follow a .if or an " ! 3340: ".elseif"); ! 3341: the_cond_state.the_cond = else_cond; ! 3342: last_ignore_state = FALSE; ! 3343: if(if_depth) ! 3344: last_ignore_state = last_states[if_depth-1].ignore; ! 3345: if(last_ignore_state || the_cond_state.cond_met) ! 3346: the_cond_state.ignore = TRUE; ! 3347: else ! 3348: the_cond_state.ignore = FALSE; ! 3349: demand_empty_rest_of_line(); ! 3350: } ! 3351: ! 3352: /* ! 3353: * s_endif() implements the pseudo op: ! 3354: * .endif ! 3355: * that does conditional assembly using assembler defined expressions. ! 3356: */ ! 3357: static ! 3358: void ! 3359: s_endif( ! 3360: int value) ! 3361: { ! 3362: if((the_cond_state.the_cond == no_cond) || (if_depth == 0)) ! 3363: as_fatal("Encountered a .endif that doesn't follow a .if or .else"); ! 3364: the_cond_state = last_states[--if_depth]; ! 3365: demand_empty_rest_of_line(); ! 3366: } ! 3367: ! 3368: /* ! 3369: * totally_ignore_line() ignores lines during conditional assembly. ! 3370: */ ! 3371: void ! 3372: totally_ignore_line( ! 3373: void) ! 3374: { ! 3375: if(!is_end_of_line[(int)*input_line_pointer]){ ! 3376: while(input_line_pointer < buffer_limit && ! 3377: !is_end_of_line[(int)*input_line_pointer]){ ! 3378: input_line_pointer ++; ! 3379: } ! 3380: } ! 3381: input_line_pointer++; /* Return pointing just after end-of-line. */ ! 3382: know(is_end_of_line[(int)(input_line_pointer[-1])]); ! 3383: } ! 3384: ! 3385: /* ! 3386: * s_macros_on() implements the pseudo op: ! 3387: * .macros_on ! 3388: */ ! 3389: static ! 3390: void ! 3391: s_macros_on( ! 3392: int value) ! 3393: { ! 3394: macros_on = TRUE; ! 3395: demand_empty_rest_of_line(); ! 3396: } ! 3397: ! 3398: /* ! 3399: * s_macros_off() implements the pseudo op: ! 3400: * .macros_off ! 3401: */ ! 3402: void ! 3403: s_macros_off( ! 3404: int value) ! 3405: { ! 3406: macros_on = FALSE; ! 3407: demand_empty_rest_of_line(); ! 3408: } ! 3409: ! 3410: /* ! 3411: * s_macro() implements the pseudo op: ! 3412: * .macro macro_name ! 3413: * that defines a macro. ! 3414: */ ! 3415: void ! 3416: s_macro( ! 3417: int value) ! 3418: { ! 3419: int c; ! 3420: pseudo_typeS *pop; ! 3421: ! 3422: if(macro_name) ! 3423: as_warn("Can't define a macro inside another macro definition"); ! 3424: else{ ! 3425: SKIP_WHITESPACE(); ! 3426: while(is_part_of_name(c = *input_line_pointer ++)) ! 3427: obstack_1grow (¯os, c); ! 3428: obstack_1grow(¯os, '\0'); ! 3429: --input_line_pointer; ! 3430: macro_name = obstack_finish(¯os); ! 3431: if(macro_name == "") ! 3432: as_warn("Missing name of macro"); ! 3433: if(*macro_name == '.'){ ! 3434: pop = (pseudo_typeS *)hash_find(po_hash, macro_name + 1); ! 3435: if(pop != NULL) ! 3436: as_warn("Pseudo-op name: %s can't be a macro name", ! 3437: macro_name); ! 3438: } ! 3439: } ! 3440: totally_ignore_line(); ! 3441: } ! 3442: ! 3443: /* ! 3444: * s_endmacro() implements the pseudo op: ! 3445: * .endmacro ! 3446: * which is the end of a macro definition. ! 3447: */ ! 3448: void ! 3449: s_endmacro( ! 3450: int value) ! 3451: { ! 3452: char *errorString; ! 3453: ! 3454: if(!macro_name){ ! 3455: as_warn ("This .endmacro does not match with a preceeding .macro"); ! 3456: ignore_rest_of_line(); ! 3457: } ! 3458: else{ ! 3459: obstack_1grow(¯os, '\0'); ! 3460: errorString = hash_insert(ma_hash, macro_name, ! 3461: obstack_finish(¯os)); ! 3462: if(*errorString) ! 3463: as_warn("The macro named \"%s\" is already defined", ! 3464: macro_name); ! 3465: macro_name = FALSE; ! 3466: } ! 3467: } ! 3468: ! 3469: /* ! 3470: * macro_begin() initializes macros. ! 3471: */ ! 3472: static ! 3473: void ! 3474: macro_begin( ! 3475: void) ! 3476: { ! 3477: ma_hash = hash_new(); ! 3478: obstack_begin(¯os, 5000); ! 3479: } ! 3480: ! 3481: /* ! 3482: * add_to_macro_definition() is called after a .macro to store the contents of ! 3483: * a macro into the obstack. ! 3484: */ ! 3485: void ! 3486: add_to_macro_definition( ! 3487: char *char_pointer) ! 3488: { ! 3489: char c; ! 3490: ! 3491: do{ ! 3492: c = *char_pointer ++; ! 3493: know(c != '\0'); ! 3494: obstack_1grow(¯os, c); ! 3495: }while((c != ':') && !(is_end_of_line[(int)c])); ! 3496: if(char_pointer > input_line_pointer) ! 3497: input_line_pointer = char_pointer; ! 3498: } ! 3499: ! 3500: /* ! 3501: * expand_macro() is called to expand macros. ! 3502: */ ! 3503: static ! 3504: void ! 3505: expand_macro( ! 3506: char *macro_contents) ! 3507: { ! 3508: char *buffer; ! 3509: char c; ! 3510: int index, nargs; ! 3511: char *last_buffer_limit; ! 3512: int last_count_lines; ! 3513: char *last_input_line_pointer; ! 3514: char *arguments [10]; /* at most 10 arguments, each is substituted */ ! 3515: ! 3516: if(macro_depth >= MAX_MACRO_DEPTH) ! 3517: as_fatal("You can't nest macro's more than %d levels deep", ! 3518: MAX_MACRO_DEPTH); ! 3519: macro_depth++; ! 3520: ! 3521: /* copy each argument to a object in the macro obstack */ ! 3522: nargs = 0; ! 3523: for(index = 0; index < 10; index ++){ ! 3524: if(*input_line_pointer == ' ') ! 3525: ++input_line_pointer; ! 3526: know(*input_line_pointer != ' '); ! 3527: c = *input_line_pointer; ! 3528: if(is_end_of_line[(int)c]) ! 3529: arguments[index] = NULL; ! 3530: else{ ! 3531: int parenthesis_depth = 0; ! 3532: do{ ! 3533: c = *input_line_pointer++; ! 3534: if(parenthesis_depth){ ! 3535: if(c == ')') ! 3536: parenthesis_depth --; ! 3537: } ! 3538: else{ ! 3539: if(c == '(') ! 3540: parenthesis_depth ++; ! 3541: else ! 3542: if(is_end_of_line[(int)c] || ! 3543: (c == ' ') || (c == ',')) ! 3544: break; ! 3545: } ! 3546: know(c != '\0'); ! 3547: if(is_end_of_line[(int)c]) ! 3548: as_warn("missmatched parenthesis"); ! 3549: obstack_1grow(¯os, c); ! 3550: }while(1); ! 3551: obstack_1grow(¯os, '\0'); ! 3552: arguments[index] = obstack_finish(¯os); ! 3553: nargs++; ! 3554: if(is_end_of_line[(int)c]) ! 3555: --input_line_pointer; ! 3556: else if(c == ' ') ! 3557: if(*input_line_pointer == ',') ! 3558: input_line_pointer++; ! 3559: } ! 3560: } ! 3561: if(!is_end_of_line[(int)c]){ ! 3562: as_warn("More than 10 arguments not allowed for macros"); ! 3563: ignore_rest_of_line(); ! 3564: } ! 3565: /* ! 3566: * Build a buffer containing the macro contents with arguments ! 3567: * substituted ! 3568: */ ! 3569: obstack_1grow(¯os, '\n'); ! 3570: while((c = *macro_contents++)){ ! 3571: if(c == '$'){ ! 3572: if((*macro_contents >= '0') && (*macro_contents <= '9')){ ! 3573: index = *macro_contents++ - '0'; ! 3574: last_input_line_pointer = macro_contents; ! 3575: macro_contents = arguments[index]; ! 3576: if(macro_contents){ ! 3577: while ((c = * macro_contents ++)) ! 3578: obstack_1grow (¯os, c); ! 3579: } ! 3580: macro_contents = last_input_line_pointer; ! 3581: continue; ! 3582: } ! 3583: else if (*macro_contents == 'n'){ ! 3584: macro_contents++ ; ! 3585: obstack_1grow(¯os, nargs + '0'); ! 3586: continue; ! 3587: } ! 3588: } ! 3589: obstack_1grow (¯os, c); ! 3590: } ! 3591: obstack_1grow (¯os, '\n'); ! 3592: obstack_1grow (¯os, '\0'); ! 3593: last_buffer_limit = buffer_limit; ! 3594: last_count_lines = count_lines; ! 3595: last_input_line_pointer = input_line_pointer; ! 3596: buffer_limit = obstack_next_free (¯os) - 1; ! 3597: buffer = obstack_finish (¯os); ! 3598: count_lines = FALSE; ! 3599: /* ! 3600: printf("expanded macro: %s", buffer + 1); ! 3601: */ ! 3602: parse_a_buffer(buffer + 1); ! 3603: obstack_free (¯os, buffer); ! 3604: for(index = 9; index >= 0; index --) ! 3605: if(arguments[index]) ! 3606: obstack_free(¯os, arguments[index]); ! 3607: buffer_limit = last_buffer_limit; ! 3608: count_lines = last_count_lines; ! 3609: input_line_pointer = last_input_line_pointer; ! 3610: macro_depth--; ! 3611: } ! 3612: ! 3613: /* ! 3614: * s_dump() implements the pseudo op: ! 3615: * .dump filename ! 3616: * that does a quick binary dump of symbol tables. ! 3617: */ ! 3618: static ! 3619: void ! 3620: s_dump( ! 3621: int value) ! 3622: { ! 3623: char *filename; ! 3624: int length; ! 3625: static char null_string[] = ""; ! 3626: ! 3627: if((filename = demand_copy_string(&length))){ ! 3628: demand_empty_rest_of_line(); ! 3629: if((dump_fp = fopen(filename, "w+"))){ ! 3630: hash_apply(ma_hash, write_macro); ! 3631: fwrite(null_string, 1, 1, dump_fp); ! 3632: hash_apply(sy_hash, write_symbol); ! 3633: fwrite(null_string, 1, 1, dump_fp); ! 3634: fclose(dump_fp); ! 3635: } ! 3636: else ! 3637: as_warn("couldn't write to dump file: \"%s\"", filename); ! 3638: } ! 3639: } ! 3640: ! 3641: /* ! 3642: * write_macro() used by hash_apply indirectly through s_dump() to write one ! 3643: * macro. ! 3644: */ ! 3645: static ! 3646: char * ! 3647: write_macro( ! 3648: char *string, ! 3649: char *value) ! 3650: { ! 3651: know(string); ! 3652: know(value); ! 3653: know(strlen(string)); ! 3654: fwrite(string, (strlen(string) + 1), 1, dump_fp); ! 3655: fwrite(value, (strlen(value) + 1), 1, dump_fp); ! 3656: return(NULL); ! 3657: } ! 3658: ! 3659: /* ! 3660: * write_symbol() used by hash_apply indirectly through s_dump() to write one ! 3661: * N_ABS symbol and its value. ! 3662: */ ! 3663: static ! 3664: char * ! 3665: write_symbol( ! 3666: char *string, ! 3667: char *value) ! 3668: { ! 3669: symbolS *symbolP; ! 3670: ! 3671: symbolP = (symbolS *)value; ! 3672: know(symbolP); ! 3673: if(((symbolP->sy_type) & N_TYPE) == N_ABS){ ! 3674: know(string); ! 3675: know(strlen(string)); ! 3676: fwrite(string, (strlen(string) + 1), 1, dump_fp); ! 3677: fwrite(&(symbolP -> sy_value), 4, 1, dump_fp); ! 3678: } ! 3679: return(NULL); ! 3680: } ! 3681: ! 3682: /* ! 3683: * s_load() implements the pseudo op: ! 3684: * .load filename ! 3685: * that does a quick binary load of symbol tables. ! 3686: */ ! 3687: static ! 3688: void ! 3689: s_load( ! 3690: int value) ! 3691: { ! 3692: char *char_pointer; ! 3693: char *filename; ! 3694: int length; ! 3695: char the_char; ! 3696: symbolS *the_symbol; ! 3697: symbolS *temp_symbol_lastP; ! 3698: static symbolS *dump_symbol_lastP; ! 3699: ! 3700: if((filename = demand_copy_string(&length))){ ! 3701: demand_empty_rest_of_line(); ! 3702: if((dump_fp = fopen(filename, "r+"))){ ! 3703: do{ ! 3704: do{ ! 3705: the_char = getc(dump_fp); ! 3706: obstack_1grow(¯os, the_char); ! 3707: }while(the_char); ! 3708: char_pointer = obstack_finish (¯os); ! 3709: if(!(*char_pointer)) ! 3710: break; ! 3711: do{ ! 3712: the_char = getc(dump_fp); ! 3713: obstack_1grow(¯os, the_char); ! 3714: }while(the_char); ! 3715: if(*hash_insert(ma_hash, char_pointer, ! 3716: obstack_finish(¯os))) ! 3717: as_warn("a macro named \"%s\" encountered in a .load " ! 3718: "is already defined", char_pointer); ! 3719: }while(1); ! 3720: /* ! 3721: * We don't want to link in symbols that were loaded so they ! 3722: * don't go out in the object file. Instead these symbols ! 3723: * should go out in the object file that did the .dump . ! 3724: */ ! 3725: temp_symbol_lastP = symbol_lastP; ! 3726: symbol_lastP = dump_symbol_lastP; ! 3727: do{ ! 3728: do{ ! 3729: the_char = getc(dump_fp); ! 3730: obstack_1grow(¯os, the_char); ! 3731: }while(the_char); ! 3732: char_pointer = obstack_base(¯os); ! 3733: obstack_next_free(¯os) = char_pointer; ! 3734: if(!(*char_pointer)) ! 3735: break; ! 3736: the_symbol = symbol_find_or_make(char_pointer); ! 3737: the_symbol->sy_type = N_ABS; ! 3738: char_pointer = (char *)&the_symbol->sy_value; ! 3739: *char_pointer++ = getc(dump_fp); ! 3740: *char_pointer++ = getc(dump_fp); ! 3741: *char_pointer++ = getc(dump_fp); ! 3742: *char_pointer++ = getc(dump_fp); ! 3743: the_symbol->sy_frag = &zero_address_frag; ! 3744: }while(1); ! 3745: dump_symbol_lastP = symbol_lastP; ! 3746: symbol_lastP = temp_symbol_lastP; ! 3747: fclose(dump_fp); ! 3748: } ! 3749: else ! 3750: as_fatal("Couldn't find the dump file: \"%s\"", filename); ! 3751: } ! 3752: } ! 3753: ! 3754: #ifdef SPARC ! 3755: ! 3756: /* Special stuff to allow assembly of Sun assembler sources ! 3757: This unfortunatley needs to be here instead of sparc.c because it ! 3758: uses the hash tables defined here. ! 3759: see also sparc.c for pseudo_table entries ! 3760: */ ! 3761: ! 3762: /* Handle the SUN sparc assembler .seg directive. .seg should only occur with ! 3763: either a ".text" or ".data" argument. Call .text or .data accordingly ! 3764: */ ! 3765: void ! 3766: s_seg (ignore) ! 3767: int ignore; ! 3768: { ! 3769: pseudo_typeS *ps_t; ! 3770: char s[32]; ! 3771: ! 3772: printf("S_SEG\n"); ! 3773: ! 3774: if (strncmp (input_line_pointer, "\"text\"", 6) == 0) ! 3775: { ! 3776: input_line_pointer += 6; ! 3777: /* relies on .text being first section */ ! 3778: (void)s_builtin_section(builtin_sections); ! 3779: demand_empty_rest_of_line(); ! 3780: return; ! 3781: } ! 3782: if (strncmp (input_line_pointer, "\"data\"", 6) == 0) ! 3783: { ! 3784: /* copy the argument */ ! 3785: input_line_pointer++; ! 3786: strncpy(s, input_line_pointer, 4); ! 3787: input_line_pointer += 5; ! 3788: /* find the section table index for .data */ ! 3789: ps_t = (pseudo_typeS *) hash_find(po_hash, s); ! 3790: ! 3791: if (ps_t == 0) ! 3792: as_bad ("invalid .seg argument"); ! 3793: ! 3794: printf("INDEX %s, %d\n", s, ps_t->poc_val); ! 3795: ! 3796: s_builtin_section ((const struct builtin_section *)ps_t->poc_val); ! 3797: demand_empty_rest_of_line(); ! 3798: return; ! 3799: } ! 3800: as_bad ("Unknown segment type"); ! 3801: demand_empty_rest_of_line (); ! 3802: } ! 3803: ! 3804: #endif /* SPARC */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.