void dwarf2_emit_label (symbolS *label) { struct dwarf2_line_info loc; if (!dwarf2_loc_mark_labels) return; if (S_GET_SEGMENT (label) != now_seg) return; if (!(bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE)) return; if (debug_type == DEBUG_DWARF2) dwarf2_where (&loc); else { loc = current; loc_directive_seen = FALSE; } loc.flags |= DWARF2_FLAG_BASIC_BLOCK; current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK | DWARF2_FLAG_PROLOGUE_END | DWARF2_FLAG_EPILOGUE_BEGIN); dwarf2_gen_line_info_1 (label, &loc); }
void s_ifdef (int test_defined) { /* Points to name of symbol. */ char *name; /* Points to symbol. */ symbolS *symbolP; struct conditional_frame cframe; char c; /* Leading whitespace is part of operand. */ SKIP_WHITESPACE (); name = input_line_pointer; if (!is_name_beginner (*name)) { as_bad (_("invalid identifier for \".ifdef\"")); obstack_1grow (&cond_obstack, 0); ignore_rest_of_line (); return; } c = get_symbol_end (); symbolP = symbol_find (name); *input_line_pointer = c; initialize_cframe (&cframe); if (cframe.dead_tree) cframe.ignoring = 1; else { int is_defined; /* Use the same definition of 'defined' as .equiv so that a symbol which has been referenced but not yet given a value/address is considered to be undefined. */ is_defined = symbolP != NULL && S_IS_DEFINED (symbolP) && S_GET_SEGMENT (symbolP) != reg_section; cframe.ignoring = ! (test_defined ^ is_defined); } current_cframe = ((struct conditional_frame *) obstack_copy (&cond_obstack, &cframe, sizeof (cframe))); if (LISTING_SKIP_COND () && cframe.ignoring && (cframe.previous_cframe == NULL || ! cframe.previous_cframe->ignoring)) listing_list (2); demand_empty_rest_of_line (); }
symbolS * section_symbol (segT sec) { segment_info_type *seginfo = seg_info (sec); symbolS *s; if (seginfo == 0) abort (); if (seginfo->sym) return seginfo->sym; #ifndef EMIT_SECTION_SYMBOLS #define EMIT_SECTION_SYMBOLS 1 #endif if (! EMIT_SECTION_SYMBOLS || symbol_table_frozen) { /* Here we know it won't be going into the symbol table. */ s = symbol_create (sec->symbol->name, sec, 0, &zero_address_frag); } else { segT seg; s = symbol_find (sec->symbol->name); /* We have to make sure it is the right symbol when we have multiple sections with the same section name. */ if (s == NULL || ((seg = S_GET_SEGMENT (s)) != sec && seg != undefined_section)) s = symbol_new (sec->symbol->name, sec, 0, &zero_address_frag); else if (seg == undefined_section) { S_SET_SEGMENT (s, sec); symbol_set_frag (s, &zero_address_frag); } } S_CLEAR_EXTERNAL (s); /* Use the BFD section symbol, if possible. */ if (obj_sec_sym_ok_for_reloc (sec)) symbol_set_bfdsym (s, sec->symbol); else symbol_get_bfdsym (s)->flags |= BSF_SECTION_SYM; seginfo->sym = s; return s; }
static INLINE void i386_intel_fold (expressionS *e, symbolS *sym) { if (S_GET_SEGMENT (sym) == absolute_section) { offsetT val = e->X_add_number; *e = *symbol_get_value_expression (sym); e->X_add_number += val; } else { e->X_add_symbol = sym; e->X_op_symbol = NULL; e->X_op = O_symbol; } }
void dwarf2_emit_label (symbolS *label) { struct dwarf2_line_info loc; if (!dwarf2_loc_mark_labels) return; if (S_GET_SEGMENT (label) != now_seg) return; if (!(bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE)) return; if (files_in_use == 0 && debug_type != DEBUG_DWARF2) return; dwarf2_where (&loc); loc.flags |= DWARF2_FLAG_BASIC_BLOCK; dwarf2_gen_line_info_1 (label, &loc); dwarf2_consume_line_info (); }
static INLINE void i386_intel_fold (expressionS *e, symbolS *sym) { expressionS *exp = symbol_get_value_expression (sym); if (S_GET_SEGMENT (sym) == absolute_section) { offsetT val = e->X_add_number; *e = *exp; e->X_add_number += val; } else { if (exp->X_op == O_symbol && strcmp (S_GET_NAME (exp->X_add_symbol), GLOBAL_OFFSET_TABLE_NAME) == 0) sym = exp->X_add_symbol; e->X_add_symbol = sym; e->X_op_symbol = NULL; e->X_op = O_symbol; } }
static int i386_intel_operand (char *operand_string, int got_a_float) { char *saved_input_line_pointer, *buf; segT exp_seg; expressionS exp, *expP; char suffix = 0; int ret; /* Initialize state structure. */ intel_state.op_modifier = O_absent; intel_state.is_mem = 0; intel_state.base = NULL; intel_state.index = NULL; intel_state.seg = NULL; operand_type_set (&intel_state.reloc_types, ~0); gas_assert (!intel_state.in_offset); gas_assert (!intel_state.in_bracket); gas_assert (!intel_state.in_scale); saved_input_line_pointer = input_line_pointer; input_line_pointer = buf = xstrdup (operand_string); /* A '$' followed by an identifier char is an identifier. Otherwise, it's operator '.' followed by an expression. */ if (*buf == '$' && !is_identifier_char (buf[1])) *buf = '.'; intel_syntax = -1; memset (&exp, 0, sizeof(exp)); exp_seg = expression (&exp); ret = i386_intel_simplify (&exp); intel_syntax = 1; SKIP_WHITESPACE (); if (!is_end_of_line[(unsigned char) *input_line_pointer]) { as_bad (_("junk `%s' after expression"), input_line_pointer); ret = 0; } else if (exp.X_op == O_illegal || exp.X_op == O_absent) { as_bad (_("invalid expression")); ret = 0; } input_line_pointer = saved_input_line_pointer; free (buf); gas_assert (!intel_state.in_offset); gas_assert (!intel_state.in_bracket); gas_assert (!intel_state.in_scale); if (!ret) return 0; if (intel_state.op_modifier != O_absent && current_templates->start->base_opcode != 0x8d /* lea */) { i.types[this_operand].bitfield.unspecified = 0; switch (intel_state.op_modifier) { case O_byte_ptr: i.types[this_operand].bitfield.byte = 1; suffix = BYTE_MNEM_SUFFIX; break; case O_word_ptr: i.types[this_operand].bitfield.word = 1; if ((current_templates->start->name[0] == 'l' && current_templates->start->name[2] == 's' && current_templates->start->name[3] == 0) || current_templates->start->base_opcode == 0x62 /* bound */) suffix = BYTE_MNEM_SUFFIX; /* so it will cause an error */ else if (got_a_float == 2) /* "fi..." */ suffix = SHORT_MNEM_SUFFIX; else suffix = WORD_MNEM_SUFFIX; break; case O_dword_ptr: i.types[this_operand].bitfield.dword = 1; if ((current_templates->start->name[0] == 'l' && current_templates->start->name[2] == 's' && current_templates->start->name[3] == 0) || current_templates->start->base_opcode == 0x62 /* bound */) suffix = WORD_MNEM_SUFFIX; else if (flag_code == CODE_16BIT && (current_templates->start->opcode_modifier.jump || current_templates->start->opcode_modifier.jumpdword)) suffix = LONG_DOUBLE_MNEM_SUFFIX; else if (got_a_float == 1) /* "f..." */ suffix = SHORT_MNEM_SUFFIX; else suffix = LONG_MNEM_SUFFIX; break; case O_fword_ptr: i.types[this_operand].bitfield.fword = 1; if (current_templates->start->name[0] == 'l' && current_templates->start->name[2] == 's' && current_templates->start->name[3] == 0) suffix = LONG_MNEM_SUFFIX; else if (!got_a_float) { if (flag_code == CODE_16BIT) add_prefix (DATA_PREFIX_OPCODE); suffix = LONG_DOUBLE_MNEM_SUFFIX; } else suffix = BYTE_MNEM_SUFFIX; /* so it will cause an error */ break; case O_qword_ptr: i.types[this_operand].bitfield.qword = 1; if (current_templates->start->base_opcode == 0x62 /* bound */ || got_a_float == 1) /* "f..." */ suffix = LONG_MNEM_SUFFIX; else suffix = QWORD_MNEM_SUFFIX; break; case O_tbyte_ptr: i.types[this_operand].bitfield.tbyte = 1; if (got_a_float == 1) suffix = LONG_DOUBLE_MNEM_SUFFIX; else suffix = BYTE_MNEM_SUFFIX; /* so it will cause an error */ break; case O_oword_ptr: case O_xmmword_ptr: i.types[this_operand].bitfield.xmmword = 1; suffix = XMMWORD_MNEM_SUFFIX; break; case O_ymmword_ptr: i.types[this_operand].bitfield.ymmword = 1; suffix = YMMWORD_MNEM_SUFFIX; break; case O_far_ptr: suffix = LONG_DOUBLE_MNEM_SUFFIX; /* FALLTHROUGH */ case O_near_ptr: if (!current_templates->start->opcode_modifier.jump && !current_templates->start->opcode_modifier.jumpdword) suffix = got_a_float /* so it will cause an error */ ? BYTE_MNEM_SUFFIX : LONG_DOUBLE_MNEM_SUFFIX; break; default: BAD_CASE (intel_state.op_modifier); break; } if (!i.suffix) i.suffix = suffix; else if (i.suffix != suffix) { as_bad (_("conflicting operand size modifiers")); return 0; } } /* Operands for jump/call need special consideration. */ if (current_templates->start->opcode_modifier.jump || current_templates->start->opcode_modifier.jumpdword || current_templates->start->opcode_modifier.jumpintersegment) { if (i.op[this_operand].regs || intel_state.base || intel_state.index || intel_state.is_mem > 1) i.types[this_operand].bitfield.jumpabsolute = 1; else switch (intel_state.op_modifier) { case O_near_ptr: if (intel_state.seg) i.types[this_operand].bitfield.jumpabsolute = 1; else intel_state.is_mem = 1; break; case O_far_ptr: case O_absent: if (!intel_state.seg) { intel_state.is_mem = 1; if (intel_state.op_modifier == O_absent) break; as_bad (_("cannot infer the segment part of the operand")); return 0; } else if (S_GET_SEGMENT (intel_state.seg) == reg_section) i.types[this_operand].bitfield.jumpabsolute = 1; else { i386_operand_type types; if (i.imm_operands >= MAX_IMMEDIATE_OPERANDS) { as_bad (_("at most %d immediate operands are allowed"), MAX_IMMEDIATE_OPERANDS); return 0; } expP = &im_expressions[i.imm_operands++]; memset (expP, 0, sizeof(*expP)); expP->X_op = O_symbol; expP->X_add_symbol = intel_state.seg; i.op[this_operand].imms = expP; resolve_expression (expP); operand_type_set (&types, ~0); if (!i386_finalize_immediate (S_GET_SEGMENT (intel_state.seg), expP, types, operand_string)) return 0; if (i.operands < MAX_OPERANDS) { this_operand = i.operands++; i.types[this_operand].bitfield.unspecified = 1; } if (suffix == LONG_DOUBLE_MNEM_SUFFIX) i.suffix = 0; intel_state.seg = NULL; intel_state.is_mem = 0; } break; default: i.types[this_operand].bitfield.jumpabsolute = 1; break; } if (i.types[this_operand].bitfield.jumpabsolute) intel_state.is_mem |= 1; } else if (intel_state.seg) intel_state.is_mem |= 1; if (i.op[this_operand].regs) { i386_operand_type temp; /* Register operand. */ if (intel_state.base || intel_state.index || intel_state.seg) { as_bad (_("invalid operand")); return 0; } temp = i.op[this_operand].regs->reg_type; temp.bitfield.baseindex = 0; i.types[this_operand] = operand_type_or (i.types[this_operand], temp); i.types[this_operand].bitfield.unspecified = 0; ++i.reg_operands; } else if (intel_state.base || intel_state.index || intel_state.seg || intel_state.is_mem) { /* Memory operand. */ if (i.mem_operands >= 2 - !current_templates->start->opcode_modifier.isstring) { as_bad (_("too many memory references for `%s'"), current_templates->start->name); return 0; } expP = &disp_expressions[i.disp_operands]; memcpy (expP, &exp, sizeof(exp)); resolve_expression (expP); if (expP->X_op != O_constant || expP->X_add_number || (!intel_state.base && !intel_state.index)) { i.op[this_operand].disps = expP; i.disp_operands++; if (flag_code == CODE_64BIT) { i.types[this_operand].bitfield.disp32 = 1; if (!i.prefix[ADDR_PREFIX]) { i.types[this_operand].bitfield.disp64 = 1; i.types[this_operand].bitfield.disp32s = 1; } } else if (!i.prefix[ADDR_PREFIX] ^ (flag_code == CODE_16BIT)) i.types[this_operand].bitfield.disp32 = 1; else i.types[this_operand].bitfield.disp16 = 1; #if defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT) /* * exp_seg is used only for verification in * i386_finalize_displacement, and we can end up seeing reg_section * here - but we know we removed all registers from the expression * (or error-ed on any remaining ones) in i386_intel_simplify. I * consider the check in i386_finalize_displacement bogus anyway, in * particular because it doesn't allow for expr_section, so I'd * rather see that check (and the similar one in * i386_finalize_immediate) use SEG_NORMAL(), but not being an a.out * expert I can't really say whether that would have other bad side * effects. */ if (OUTPUT_FLAVOR == bfd_target_aout_flavour && exp_seg == reg_section) exp_seg = expP->X_op != O_constant ? undefined_section : absolute_section; #endif if (!i386_finalize_displacement (exp_seg, expP, intel_state.reloc_types, operand_string)) return 0; } if (intel_state.base || intel_state.index) i.types[this_operand].bitfield.baseindex = 1; if (intel_state.seg) { for (;;) { expP = symbol_get_value_expression (intel_state.seg); if (expP->X_op != O_full_ptr) break; intel_state.seg = expP->X_add_symbol; } if (expP->X_op != O_register) { as_bad (_("segment register name expected")); return 0; } if (!i386_regtab[expP->X_add_number].reg_type.bitfield.sreg2 && !i386_regtab[expP->X_add_number].reg_type.bitfield.sreg3) { as_bad (_("invalid use of register")); return 0; } switch (i386_regtab[expP->X_add_number].reg_num) { case 0: i.seg[i.mem_operands] = &es; break; case 1: i.seg[i.mem_operands] = &cs; break; case 2: i.seg[i.mem_operands] = &ss; break; case 3: i.seg[i.mem_operands] = &ds; break; case 4: i.seg[i.mem_operands] = &fs; break; case 5: i.seg[i.mem_operands] = &gs; break; case RegFlat: i.seg[i.mem_operands] = NULL; break; } } /* Swap base and index in 16-bit memory operands like [si+bx]. Since i386_index_check is also used in AT&T mode we have to do that here. */ if (intel_state.base && intel_state.index && intel_state.base->reg_type.bitfield.reg16 && intel_state.index->reg_type.bitfield.reg16 && intel_state.base->reg_num >= 6 && intel_state.index->reg_num < 6) { i.base_reg = intel_state.index; i.index_reg = intel_state.base; } else { i.base_reg = intel_state.base; i.index_reg = intel_state.index; } if (!i386_index_check (operand_string)) return 0; i.types[this_operand].bitfield.mem = 1; ++i.mem_operands; } else { /* Immediate. */ if (i.imm_operands >= MAX_IMMEDIATE_OPERANDS) { as_bad (_("at most %d immediate operands are allowed"), MAX_IMMEDIATE_OPERANDS); return 0; } expP = &im_expressions[i.imm_operands++]; i.op[this_operand].imms = expP; *expP = exp; return i386_finalize_immediate (exp_seg, expP, intel_state.reloc_types, operand_string); } return 1; }
static int i386_intel_simplify (expressionS *e) { const reg_entry *reg = this_operand >= 0 ? i.op[this_operand].regs : NULL; const reg_entry *base = intel_state.base; const reg_entry *index = intel_state.index; int ret; if (!intel_syntax) return 1; switch (e->X_op) { case O_index: if (e->X_add_symbol) { if (!i386_intel_simplify_symbol (e->X_add_symbol) || !i386_intel_check(reg, intel_state.base, intel_state.index)) return 0;; } if (!intel_state.in_offset) ++intel_state.in_bracket; ret = i386_intel_simplify_symbol (e->X_op_symbol); if (!intel_state.in_offset) --intel_state.in_bracket; if (!ret) return 0; if (e->X_add_symbol) e->X_op = O_add; else i386_intel_fold (e, e->X_op_symbol); break; case O_offset: ++intel_state.in_offset; ret = i386_intel_simplify_symbol (e->X_add_symbol); --intel_state.in_offset; if (!ret || !i386_intel_check(reg, base, index)) return 0; i386_intel_fold (e, e->X_add_symbol); return ret; case O_byte_ptr: case O_word_ptr: case O_dword_ptr: case O_fword_ptr: case O_qword_ptr: case O_tbyte_ptr: case O_oword_ptr: case O_xmmword_ptr: case O_ymmword_ptr: case O_near_ptr: case O_far_ptr: if (intel_state.op_modifier == O_absent) intel_state.op_modifier = e->X_op; /* FALLTHROUGH */ case O_short: if (symbol_get_value_expression (e->X_add_symbol)->X_op == O_register) { as_bad (_("invalid use of register")); return 0; } if (!i386_intel_simplify_symbol (e->X_add_symbol)) return 0; i386_intel_fold (e, e->X_add_symbol); break; case O_full_ptr: if (symbol_get_value_expression (e->X_op_symbol)->X_op == O_register) { as_bad (_("invalid use of register")); return 0; } if (!i386_intel_simplify_symbol (e->X_op_symbol) || !i386_intel_check(reg, intel_state.base, intel_state.index)) return 0; if (!intel_state.in_offset) intel_state.seg = e->X_add_symbol; i386_intel_fold (e, e->X_op_symbol); break; case O_register: if (this_operand < 0 || intel_state.in_offset) { as_bad (_("invalid use of register")); return 0; } if (!intel_state.in_bracket) { if (i.op[this_operand].regs) { as_bad (_("invalid use of register")); return 0; } if (i386_regtab[e->X_add_number].reg_type.bitfield.sreg3 && i386_regtab[e->X_add_number].reg_num == RegFlat) { as_bad (_("invalid use of pseudo-register")); return 0; } i.op[this_operand].regs = i386_regtab + e->X_add_number; } else if (!intel_state.base && !intel_state.in_scale) intel_state.base = i386_regtab + e->X_add_number; else if (!intel_state.index) intel_state.index = i386_regtab + e->X_add_number; else { /* esp is invalid as index */ intel_state.index = i386_regtab + REGNAM_EAX + 4; } e->X_op = O_constant; e->X_add_number = 0; return 2; case O_multiply: if (this_operand >= 0 && intel_state.in_bracket) { expressionS *scale = NULL; if (intel_state.index) --scale; if (!intel_state.in_scale++) intel_state.scale_factor = 1; ret = i386_intel_simplify_symbol (e->X_add_symbol); if (ret && !scale && intel_state.index) scale = symbol_get_value_expression (e->X_op_symbol); if (ret) ret = i386_intel_simplify_symbol (e->X_op_symbol); if (ret && !scale && intel_state.index) scale = symbol_get_value_expression (e->X_add_symbol); if (ret && scale && (scale + 1)) { resolve_expression (scale); if (scale->X_op != O_constant || intel_state.index->reg_type.bitfield.reg16) scale->X_add_number = 0; intel_state.scale_factor *= scale->X_add_number; } --intel_state.in_scale; if (!ret) return 0; if (!intel_state.in_scale) switch (intel_state.scale_factor) { case 1: i.log2_scale_factor = 0; break; case 2: i.log2_scale_factor = 1; break; case 4: i.log2_scale_factor = 2; break; case 8: i.log2_scale_factor = 3; break; default: /* esp is invalid as index */ intel_state.index = i386_regtab + REGNAM_EAX + 4; break; } break; } /* FALLTHROUGH */ default: if (e->X_add_symbol && !i386_intel_simplify_symbol (e->X_add_symbol)) return 0; if (e->X_op == O_add || e->X_op == O_subtract) { base = intel_state.base; index = intel_state.index; } if (!i386_intel_check (reg, base, index) || (e->X_op_symbol && !i386_intel_simplify_symbol (e->X_op_symbol)) || !i386_intel_check (reg, e->X_op != O_add ? base : intel_state.base, e->X_op != O_add ? index : intel_state.index)) return 0; break; } if (this_operand >= 0 && e->X_op == O_symbol && !intel_state.in_offset) { segT seg = S_GET_SEGMENT (e->X_add_symbol); if (seg != absolute_section && seg != reg_section && seg != expr_section) intel_state.is_mem |= 2 - !intel_state.in_bracket; } return 1; }
#undef NO_RELOC #include "aout/aout64.h" #include "obstack.h" void obj_aout_frob_symbol (symbolS *sym, int *punt ATTRIBUTE_UNUSED) { flagword flags; asection *sec; int desc, type, other; flags = symbol_get_bfdsym (sym)->flags; desc = aout_symbol (symbol_get_bfdsym (sym))->desc; type = aout_symbol (symbol_get_bfdsym (sym))->type; other = aout_symbol (symbol_get_bfdsym (sym))->other; sec = S_GET_SEGMENT (sym); /* Only frob simple symbols this way right now. */ if (! (type & ~ (N_TYPE | N_EXT))) { if (type == (N_UNDF | N_EXT) && sec == &bfd_abs_section) { sec = bfd_und_section_ptr; S_SET_SEGMENT (sym, sec); } if ((type & N_TYPE) != N_INDR && (type & N_TYPE) != N_SETA && (type & N_TYPE) != N_SETT && (type & N_TYPE) != N_SETD
static int i386_intel_simplify (expressionS *e) { const reg_entry *the_reg = (this_operand >= 0 ? i.op[this_operand].regs : NULL); const reg_entry *base = intel_state.base; const reg_entry *state_index = intel_state.index; int ret; if (!intel_syntax) return 1; switch (e->X_op) { case O_index: if (e->X_add_symbol) { if (!i386_intel_simplify_symbol (e->X_add_symbol) || !i386_intel_check(the_reg, intel_state.base, intel_state.index)) return 0; } if (!intel_state.in_offset) ++intel_state.in_bracket; ret = i386_intel_simplify_symbol (e->X_op_symbol); if (!intel_state.in_offset) --intel_state.in_bracket; if (!ret) return 0; if (e->X_add_symbol) e->X_op = O_add; else i386_intel_fold (e, e->X_op_symbol); break; case O_offset: intel_state.has_offset = 1; ++intel_state.in_offset; ret = i386_intel_simplify_symbol (e->X_add_symbol); --intel_state.in_offset; if (!ret || !i386_intel_check(the_reg, base, state_index)) return 0; i386_intel_fold (e, e->X_add_symbol); return ret; case O_byte_ptr: case O_word_ptr: case O_dword_ptr: case O_fword_ptr: case O_qword_ptr: case O_tbyte_ptr: case O_oword_ptr: case O_xmmword_ptr: case O_ymmword_ptr: case O_zmmword_ptr: case O_near_ptr: case O_far_ptr: if (intel_state.op_modifier == O_absent) intel_state.op_modifier = e->X_op; /* FALLTHROUGH */ case O_short: if (symbol_get_value_expression (e->X_add_symbol)->X_op == O_register) { as_bad (_("invalid use of register")); return 0; } if (!i386_intel_simplify_symbol (e->X_add_symbol)) return 0; i386_intel_fold (e, e->X_add_symbol); break; case O_full_ptr: if (symbol_get_value_expression (e->X_op_symbol)->X_op == O_register) { as_bad (_("invalid use of register")); return 0; } if (!i386_intel_simplify_symbol (e->X_op_symbol) || !i386_intel_check(the_reg, intel_state.base, intel_state.index)) return 0; if (!intel_state.in_offset) intel_state.seg = e->X_add_symbol; i386_intel_fold (e, e->X_op_symbol); break; case O_multiply: if (this_operand >= 0 && intel_state.in_bracket) { expressionS *scale = NULL; int has_index = (intel_state.index != NULL); if (!intel_state.in_scale++) intel_state.scale_factor = 1; ret = i386_intel_simplify_symbol (e->X_add_symbol); if (ret && !has_index && intel_state.index) scale = symbol_get_value_expression (e->X_op_symbol); if (ret) ret = i386_intel_simplify_symbol (e->X_op_symbol); if (ret && !scale && !has_index && intel_state.index) scale = symbol_get_value_expression (e->X_add_symbol); if (ret && scale) { resolve_expression (scale); if (scale->X_op != O_constant || intel_state.index->reg_type.bitfield.reg16) scale->X_add_number = 0; intel_state.scale_factor *= scale->X_add_number; } --intel_state.in_scale; if (!ret) return 0; if (!intel_state.in_scale) switch (intel_state.scale_factor) { case 1: i.log2_scale_factor = 0; break; case 2: i.log2_scale_factor = 1; break; case 4: i.log2_scale_factor = 2; break; case 8: i.log2_scale_factor = 3; break; default: /* esp is invalid as index */ intel_state.index = i386_regtab + REGNAM_EAX + ESP_REG_NUM; break; } break; } goto fallthrough; case O_register: ret = i386_intel_simplify_register (e); if (ret == 2) { gas_assert (e->X_add_number < (unsigned short) -1); e->X_md = (unsigned short) e->X_add_number + 1; e->X_op = O_constant; e->X_add_number = 0; } return ret; case O_constant: if (e->X_md) return i386_intel_simplify_register (e); /* FALLTHROUGH */ default: fallthrough: if (e->X_add_symbol && !i386_intel_simplify_symbol (e->X_add_symbol)) return 0; if (e->X_op == O_add || e->X_op == O_subtract) { base = intel_state.base; state_index = intel_state.index; } if (!i386_intel_check (the_reg, base, state_index) || (e->X_op_symbol && !i386_intel_simplify_symbol (e->X_op_symbol)) || !i386_intel_check (the_reg, (e->X_op != O_add ? base : intel_state.base), (e->X_op != O_add ? state_index : intel_state.index))) return 0; break; } if (this_operand >= 0 && e->X_op == O_symbol && !intel_state.in_offset) { segT seg = S_GET_SEGMENT (e->X_add_symbol); if (seg != absolute_section && seg != reg_section && seg != expr_section) intel_state.is_mem |= 2 - !intel_state.in_bracket; } return 1; }
static void list_symbol_table (void) { extern symbolS *symbol_rootP; int got_some = 0; symbolS *ptr; eject = 1; listing_page (NULL); for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr)) { if (SEG_NORMAL (S_GET_SEGMENT (ptr)) || S_GET_SEGMENT (ptr) == absolute_section) { /* Don't report section symbols. They are not interesting. */ if (symbol_section_p (ptr)) continue; if (S_GET_NAME (ptr)) { char buf[30], fmt[8]; valueT val = S_GET_VALUE (ptr); /* @@ Note that this is dependent on the compilation options, not solely on the target characteristics. */ if (sizeof (val) == 4 && sizeof (int) == 4) sprintf (buf, "%08lx", (unsigned long) val); else if (sizeof (val) <= sizeof (unsigned long)) { sprintf (fmt, "%%0%lulx", (unsigned long) (sizeof (val) * 2)); sprintf (buf, fmt, (unsigned long) val); } #if defined (BFD64) else if (sizeof (val) > 4) sprintf_vma (buf, val); #endif else abort (); if (!got_some) { fprintf (list_file, "DEFINED SYMBOLS\n"); on_page++; got_some = 1; } if (symbol_get_frag (ptr) && symbol_get_frag (ptr)->line) { fprintf (list_file, "%20s:%-5d %s:%s %s\n", symbol_get_frag (ptr)->line->file->filename, symbol_get_frag (ptr)->line->line, segment_name (S_GET_SEGMENT (ptr)), buf, S_GET_NAME (ptr)); } else { fprintf (list_file, "%33s:%s %s\n", segment_name (S_GET_SEGMENT (ptr)), buf, S_GET_NAME (ptr)); } on_page++; listing_page (NULL); } } } if (!got_some) { fprintf (list_file, "NO DEFINED SYMBOLS\n"); on_page++; } emit_line (NULL, "\n"); got_some = 0; for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr)) { if (S_GET_NAME (ptr) && strlen (S_GET_NAME (ptr)) != 0) { if (S_GET_SEGMENT (ptr) == undefined_section) { if (!got_some) { got_some = 1; emit_line (NULL, "UNDEFINED SYMBOLS\n"); } emit_line (NULL, "%s\n", S_GET_NAME (ptr)); } } } if (!got_some) emit_line (NULL, "NO UNDEFINED SYMBOLS\n"); }
int check_eh_frame (expressionS *exp, unsigned int *pnbytes) { struct frame_data { enum frame_state state; int cie_info_ok; struct cie_info cie_info; symbolS *size_end_sym; fragS *loc4_frag; int loc4_fix; int aug_size; int aug_shift; }; static struct frame_data eh_frame_data; static struct frame_data debug_frame_data; struct frame_data *d; /* Don't optimize. */ if (flag_traditional_format) return 0; #ifdef md_allow_eh_opt if (! md_allow_eh_opt) return 0; #endif /* Select the proper section data. */ if (strncmp (segment_name (now_seg), ".eh_frame", 9) == 0 && segment_name (now_seg)[9] != '_') d = &eh_frame_data; else if (strncmp (segment_name (now_seg), ".debug_frame", 12) == 0) d = &debug_frame_data; else return 0; if (d->state >= state_saw_size && S_IS_DEFINED (d->size_end_sym)) { /* We have come to the end of the CIE or FDE. See below where we set saw_size. We must check this first because we may now be looking at the next size. */ d->state = state_idle; } switch (d->state) { case state_idle: if (*pnbytes == 4) { /* This might be the size of the CIE or FDE. We want to know the size so that we don't accidentally optimize across an FDE boundary. We recognize the size in one of two forms: a symbol which will later be defined as a difference, or a subtraction of two symbols. Either way, we can tell when we are at the end of the FDE because the symbol becomes defined (in the case of a subtraction, the end symbol, from which the start symbol is being subtracted). Other ways of describing the size will not be optimized. */ if ((exp->X_op == O_symbol || exp->X_op == O_subtract) && ! S_IS_DEFINED (exp->X_add_symbol)) { d->state = state_saw_size; d->size_end_sym = exp->X_add_symbol; } } break; case state_saw_size: case state_saw_cie_offset: /* Assume whatever form it appears in, it appears atomically. */ d->state = (enum frame_state) (d->state + 1); break; case state_saw_pc_begin: /* Decide whether we should see an augmentation. */ if (! d->cie_info_ok && ! (d->cie_info_ok = get_cie_info (&d->cie_info))) d->state = state_error; else if (d->cie_info.z_augmentation) { d->state = state_seeing_aug_size; d->aug_size = 0; d->aug_shift = 0; } else d->state = state_wait_loc4; break; case state_seeing_aug_size: /* Bytes == -1 means this comes from an leb128 directive. */ if ((int)*pnbytes == -1 && exp->X_op == O_constant) { d->aug_size = exp->X_add_number; d->state = state_skipping_aug; } else if (*pnbytes == 1 && exp->X_op == O_constant) { unsigned char byte = exp->X_add_number; d->aug_size |= (byte & 0x7f) << d->aug_shift; d->aug_shift += 7; if ((byte & 0x80) == 0) d->state = state_skipping_aug; } else d->state = state_error; if (d->state == state_skipping_aug && d->aug_size == 0) d->state = state_wait_loc4; break; case state_skipping_aug: if ((int)*pnbytes < 0) d->state = state_error; else { int left = (d->aug_size -= *pnbytes); if (left == 0) d->state = state_wait_loc4; else if (left < 0) d->state = state_error; } break; case state_wait_loc4: if (*pnbytes == 1 && exp->X_op == O_constant && exp->X_add_number == DW_CFA_advance_loc4) { /* This might be a DW_CFA_advance_loc4. Record the frag and the position within the frag, so that we can change it later. */ frag_grow (1); d->state = state_saw_loc4; d->loc4_frag = frag_now; d->loc4_fix = frag_now_fix (); } break; case state_saw_loc4: d->state = state_wait_loc4; if (*pnbytes != 4) break; if (exp->X_op == O_constant) { /* This is a case which we can optimize. The two symbols being subtracted were in the same frag and the expression was reduced to a constant. We can do the optimization entirely in this function. */ if (exp->X_add_number < 0x40) { d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc | exp->X_add_number; /* No more bytes needed. */ return 1; } else if (exp->X_add_number < 0x100) { d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc1; *pnbytes = 1; } else if (exp->X_add_number < 0x10000) { d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc2; *pnbytes = 2; } } else if (exp->X_op == O_subtract && d->cie_info.code_alignment == 1) { /* This is a case we can optimize. The expression was not reduced, so we can not finish the optimization until the end of the assembly. We set up a variant frag which we handle later. */ frag_var (rs_cfa, 4, 0, 1 << 3, make_expr_symbol (exp), d->loc4_fix, (char *) d->loc4_frag); return 1; } else if ((exp->X_op == O_divide || exp->X_op == O_right_shift) && d->cie_info.code_alignment > 1) { if (symbol_symbolS (exp->X_add_symbol) && symbol_constant_p (exp->X_op_symbol) && S_GET_SEGMENT (exp->X_op_symbol) == absolute_section && ((exp->X_op == O_divide ? *symbol_X_add_number (exp->X_op_symbol) : (offsetT) 1 << *symbol_X_add_number (exp->X_op_symbol)) == (offsetT) d->cie_info.code_alignment)) { expressionS *symval; symval = symbol_get_value_expression (exp->X_add_symbol); if (symval->X_op == O_subtract) { /* This is a case we can optimize as well. The expression was not reduced, so we can not finish the optimization until the end of the assembly. We set up a variant frag which we handle later. */ frag_var (rs_cfa, 4, 0, d->cie_info.code_alignment << 3, make_expr_symbol (symval), d->loc4_fix, (char *) d->loc4_frag); return 1; } } } break; case state_error: /* Just skipping everything. */ break; } return 0; }
static void obj_coff_endef (int ignore ATTRIBUTE_UNUSED) { symbolS *symbolP = NULL; dim_index = 0; if (def_symbol_in_progress == NULL) { as_warn (_(".endef pseudo-op used outside of .def/.endef: ignored.")); demand_empty_rest_of_line (); return; } /* Set the section number according to storage class. */ switch (S_GET_STORAGE_CLASS (def_symbol_in_progress)) { case C_STRTAG: case C_ENTAG: case C_UNTAG: SF_SET_TAG (def_symbol_in_progress); /* Fall through. */ case C_FILE: case C_TPDEF: SF_SET_DEBUG (def_symbol_in_progress); S_SET_SEGMENT (def_symbol_in_progress, fetch_coff_debug_section ()); break; case C_EFCN: SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */ /* Fall through. */ case C_BLOCK: SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing. */ /* Fall through. */ case C_FCN: { const char *name; S_SET_SEGMENT (def_symbol_in_progress, text_section); name = S_GET_NAME (def_symbol_in_progress); if (name[0] == '.' && name[2] == 'f' && name[3] == '\0') { switch (name[1]) { case 'b': /* .bf */ if (! in_function ()) as_warn (_("`%s' symbol without preceding function"), name); /* Will need relocating. */ SF_SET_PROCESS (def_symbol_in_progress); clear_function (); break; #ifdef TE_PE case 'e': /* .ef */ /* The MS compilers output the actual endline, not the function-relative one... we want to match without changing the assembler input. */ SA_SET_SYM_LNNO (def_symbol_in_progress, (SA_GET_SYM_LNNO (def_symbol_in_progress) + coff_line_base)); break; #endif } } } break; #ifdef C_AUTOARG case C_AUTOARG: #endif /* C_AUTOARG */ case C_AUTO: case C_REG: case C_ARG: case C_REGPARM: case C_FIELD: /* According to the COFF documentation: http://osr5doc.sco.com:1996/topics/COFF_SectNumFld.html A special section number (-2) marks symbolic debugging symbols, including structure/union/enumeration tag names, typedefs, and the name of the file. A section number of -1 indicates that the symbol has a value but is not relocatable. Examples of absolute-valued symbols include automatic and register variables, function arguments, and .eos symbols. But from Ian Lance Taylor: http://sources.redhat.com/ml/binutils/2000-08/msg00202.html the actual tools all marked them as section -1. So the GNU COFF assembler follows historical COFF assemblers. However, it causes problems for djgpp http://sources.redhat.com/ml/binutils/2000-08/msg00210.html By defining STRICTCOFF, a COFF port can make the assembler to follow the documented behavior. */ #ifdef STRICTCOFF case C_MOS: case C_MOE: case C_MOU: case C_EOS: #endif SF_SET_DEBUG (def_symbol_in_progress); S_SET_SEGMENT (def_symbol_in_progress, absolute_section); break; #ifndef STRICTCOFF case C_MOS: case C_MOE: case C_MOU: case C_EOS: S_SET_SEGMENT (def_symbol_in_progress, absolute_section); break; #endif case C_EXT: case C_WEAKEXT: #ifdef TE_PE case C_NT_WEAK: #endif case C_STAT: case C_LABEL: /* Valid but set somewhere else (s_comm, s_lcomm, colon). */ break; default: case C_USTATIC: case C_EXTDEF: case C_ULABEL: as_warn (_("unexpected storage class %d"), S_GET_STORAGE_CLASS (def_symbol_in_progress)); break; } /* Now that we have built a debug symbol, try to find if we should merge with an existing symbol or not. If a symbol is C_EFCN or absolute_section or untagged SEG_DEBUG it never merges. We also don't merge labels, which are in a different namespace, nor symbols which have not yet been defined since they are typically unique, nor do we merge tags with non-tags. */ /* Two cases for functions. Either debug followed by definition or definition followed by debug. For definition first, we will merge the debug symbol into the definition. For debug first, the lineno entry MUST point to the definition function or else it will point off into space when obj_crawl_symbol_chain() merges the debug symbol into the real symbol. Therefor, let's presume the debug symbol is a real function reference. */ /* FIXME-SOON If for some reason the definition label/symbol is never seen, this will probably leave an undefined symbol at link time. */ if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL || (streq (bfd_get_section_name (stdoutput, S_GET_SEGMENT (def_symbol_in_progress)), "*DEBUG*") && !SF_GET_TAG (def_symbol_in_progress)) || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section || ! symbol_constant_p (def_symbol_in_progress) || (symbolP = symbol_find (S_GET_NAME (def_symbol_in_progress))) == NULL || SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP)) { /* If it already is at the end of the symbol list, do nothing */ if (def_symbol_in_progress != symbol_lastP) { symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP); symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP, &symbol_lastP); } } else { /* This symbol already exists, merge the newly created symbol into the old one. This is not mandatory. The linker can handle duplicate symbols correctly. But I guess that it save a *lot* of space if the assembly file defines a lot of symbols. [loic] */ /* The debug entry (def_symbol_in_progress) is merged into the previous definition. */ c_symbol_merge (def_symbol_in_progress, symbolP); symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP); def_symbol_in_progress = symbolP; if (SF_GET_FUNCTION (def_symbol_in_progress) || SF_GET_TAG (def_symbol_in_progress) || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_STAT) { /* For functions, and tags, and static symbols, the symbol *must* be where the debug symbol appears. Move the existing symbol to the current place. */ /* If it already is at the end of the symbol list, do nothing. */ if (def_symbol_in_progress != symbol_lastP) { symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP); symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP, &symbol_lastP); } } } if (SF_GET_TAG (def_symbol_in_progress)) { symbolS *oldtag; oldtag = symbol_find (S_GET_NAME (def_symbol_in_progress)); if (oldtag == NULL || ! SF_GET_TAG (oldtag)) tag_insert (S_GET_NAME (def_symbol_in_progress), def_symbol_in_progress); } if (SF_GET_FUNCTION (def_symbol_in_progress)) { know (sizeof (def_symbol_in_progress) <= sizeof (long)); set_function (def_symbol_in_progress); SF_SET_PROCESS (def_symbol_in_progress); if (symbolP == NULL) /* That is, if this is the first time we've seen the function. */ symbol_table_insert (def_symbol_in_progress); } def_symbol_in_progress = NULL; demand_empty_rest_of_line (); }
void coff_frob_symbol (symbolS *symp, int *punt) { static symbolS *last_tagP; static stack *block_stack; static symbolS *set_end; symbolS *next_set_end = NULL; if (symp == &abs_symbol) { *punt = 1; return; } if (current_lineno_sym) coff_add_linesym (NULL); if (!block_stack) block_stack = stack_init (512, sizeof (symbolS*)); #ifdef TE_PE if (S_GET_STORAGE_CLASS (symp) == C_NT_WEAK && ! S_IS_WEAK (symp) && weak_is_altname (S_GET_NAME (symp))) { /* This is a weak alternate symbol. All processing of PECOFFweak symbols is done here, through the alternate. */ symbolS *weakp = symbol_find_noref (weak_altname2name (S_GET_NAME (symp)), 1); assert (weakp); assert (S_GET_NUMBER_AUXILIARY (weakp) == 1); if (! S_IS_WEAK (weakp)) { /* The symbol was turned from weak to strong. Discard altname. */ *punt = 1; return; } else if (symbol_equated_p (weakp)) { /* The weak symbol has an alternate specified; symp is unneeded. */ S_SET_STORAGE_CLASS (weakp, C_NT_WEAK); SA_SET_SYM_TAGNDX (weakp, symbol_get_value_expression (weakp)->X_add_symbol); S_CLEAR_EXTERNAL (symp); *punt = 1; return; } else { /* The weak symbol has been assigned an alternate value. Copy this value to symp, and set symp as weakp's alternate. */ if (S_GET_STORAGE_CLASS (weakp) != C_NT_WEAK) { S_SET_STORAGE_CLASS (symp, S_GET_STORAGE_CLASS (weakp)); S_SET_STORAGE_CLASS (weakp, C_NT_WEAK); } if (S_IS_DEFINED (weakp)) { /* This is a defined weak symbol. Copy value information from the weak symbol itself to the alternate symbol. */ symbol_set_value_expression (symp, symbol_get_value_expression (weakp)); symbol_set_frag (symp, symbol_get_frag (weakp)); S_SET_SEGMENT (symp, S_GET_SEGMENT (weakp)); } else { /* This is an undefined weak symbol. Define the alternate symbol to zero. */ S_SET_VALUE (symp, 0); S_SET_SEGMENT (symp, absolute_section); } S_SET_NAME (symp, weak_uniquify (S_GET_NAME (symp))); S_SET_STORAGE_CLASS (symp, C_EXT); S_SET_VALUE (weakp, 0); S_SET_SEGMENT (weakp, undefined_section); } } #else /* TE_PE */ if (S_IS_WEAK (symp)) S_SET_STORAGE_CLASS (symp, C_WEAKEXT); #endif /* TE_PE */ if (!S_IS_DEFINED (symp) && !S_IS_WEAK (symp) && S_GET_STORAGE_CLASS (symp) != C_STAT) S_SET_STORAGE_CLASS (symp, C_EXT); if (!SF_GET_DEBUG (symp)) { symbolS * real; if (!SF_GET_LOCAL (symp) && !SF_GET_STATICS (symp) && S_GET_STORAGE_CLASS (symp) != C_LABEL && symbol_constant_p (symp) && (real = symbol_find_noref (S_GET_NAME (symp), 1)) && S_GET_STORAGE_CLASS (real) == C_NULL && real != symp) { c_symbol_merge (symp, real); *punt = 1; return; } if (!S_IS_DEFINED (symp) && !SF_GET_LOCAL (symp)) { assert (S_GET_VALUE (symp) == 0); if (S_IS_WEAKREFD (symp)) *punt = 1; else S_SET_EXTERNAL (symp); } else if (S_GET_STORAGE_CLASS (symp) == C_NULL) { if (S_GET_SEGMENT (symp) == text_section && symp != seg_info (text_section)->sym) S_SET_STORAGE_CLASS (symp, C_LABEL); else S_SET_STORAGE_CLASS (symp, C_STAT); } if (SF_GET_PROCESS (symp)) { if (S_GET_STORAGE_CLASS (symp) == C_BLOCK) { if (streq (S_GET_NAME (symp), ".bb")) stack_push (block_stack, (char *) &symp); else { symbolS *begin; begin = *(symbolS **) stack_pop (block_stack); if (begin == 0) as_warn (_("mismatched .eb")); else next_set_end = begin; } } if (coff_last_function == 0 && SF_GET_FUNCTION (symp)) { union internal_auxent *auxp; coff_last_function = symp; if (S_GET_NUMBER_AUXILIARY (symp) < 1) S_SET_NUMBER_AUXILIARY (symp, 1); auxp = SYM_AUXENT (symp); memset (auxp->x_sym.x_fcnary.x_ary.x_dimen, 0, sizeof (auxp->x_sym.x_fcnary.x_ary.x_dimen)); } if (S_GET_STORAGE_CLASS (symp) == C_EFCN) { if (coff_last_function == 0) as_fatal (_("C_EFCN symbol for %s out of scope"), S_GET_NAME (symp)); SA_SET_SYM_FSIZE (coff_last_function, (long) (S_GET_VALUE (symp) - S_GET_VALUE (coff_last_function))); next_set_end = coff_last_function; coff_last_function = 0; } } if (S_IS_EXTERNAL (symp)) S_SET_STORAGE_CLASS (symp, C_EXT); else if (SF_GET_LOCAL (symp)) *punt = 1; if (SF_GET_FUNCTION (symp)) symbol_get_bfdsym (symp)->flags |= BSF_FUNCTION; } /* Double check weak symbols. */ if (S_IS_WEAK (symp) && S_IS_COMMON (symp)) as_bad (_("Symbol `%s' can not be both weak and common"), S_GET_NAME (symp)); if (SF_GET_TAG (symp)) last_tagP = symp; else if (S_GET_STORAGE_CLASS (symp) == C_EOS) next_set_end = last_tagP; #ifdef OBJ_XCOFF /* This is pretty horrible, but we have to set *punt correctly in order to call SA_SET_SYM_ENDNDX correctly. */ if (! symbol_used_in_reloc_p (symp) && ((symbol_get_bfdsym (symp)->flags & BSF_SECTION_SYM) != 0 || (! (S_IS_EXTERNAL (symp) || S_IS_WEAK (symp)) && ! symbol_get_tc (symp)->output && S_GET_STORAGE_CLASS (symp) != C_FILE))) *punt = 1; #endif if (set_end != (symbolS *) NULL && ! *punt && ((symbol_get_bfdsym (symp)->flags & BSF_NOT_AT_END) != 0 || (S_IS_DEFINED (symp) && ! S_IS_COMMON (symp) && (! S_IS_EXTERNAL (symp) || SF_GET_FUNCTION (symp))))) { SA_SET_SYM_ENDNDX (set_end, symp); set_end = NULL; } if (next_set_end != NULL) { if (set_end != NULL) as_warn ("Warning: internal error: forgetting to set endndx of %s", S_GET_NAME (set_end)); set_end = next_set_end; } #ifndef OBJ_XCOFF if (! *punt && S_GET_STORAGE_CLASS (symp) == C_FCN && streq (S_GET_NAME (symp), ".bf")) { if (coff_last_bf != NULL) SA_SET_SYM_ENDNDX (coff_last_bf, symp); coff_last_bf = symp; } #endif if (coffsymbol (symbol_get_bfdsym (symp))->lineno) { int i; struct line_no *lptr; alent *l; lptr = (struct line_no *) coffsymbol (symbol_get_bfdsym (symp))->lineno; for (i = 0; lptr; lptr = lptr->next) i++; lptr = (struct line_no *) coffsymbol (symbol_get_bfdsym (symp))->lineno; /* We need i entries for line numbers, plus 1 for the first entry which BFD will override, plus 1 for the last zero entry (a marker for BFD). */ l = xmalloc ((i + 2) * sizeof (* l)); coffsymbol (symbol_get_bfdsym (symp))->lineno = l; l[i + 1].line_number = 0; l[i + 1].u.sym = NULL; for (; i > 0; i--) { if (lptr->frag) lptr->l.u.offset += lptr->frag->fr_address / OCTETS_PER_BYTE; l[i] = lptr->l; lptr = lptr->next; } } }