int _bfd_sh64_crange_qsort_cmpl (const void *p1, const void *p2) { bfd_vma a1 = (bfd_vma) bfd_getl32 (p1); bfd_vma a2 = (bfd_vma) bfd_getl32 (p2); /* Preserve order if there's ambiguous contents. */ if (a1 == a2) return (char *) p1 - (char *) p2; return a1 - a2; }
int _bfd_sh64_crange_bsearch_cmpl (const void *p1, const void *p2) { bfd_vma a1 = *(bfd_vma *) p1; bfd_vma a2 = (bfd_vma) bfd_getl32 (p2); bfd_size_type size = (bfd_size_type) bfd_getl32 (SH64_CRANGE_CR_SIZE_OFFSET + (char *) p2); if (a1 >= a2 + size) return 1; if (a1 < a2) return -1; return 0; }
int print_insn_ft32 (bfd_vma addr, struct disassemble_info *info) { int status; stream = info->stream; bfd_byte buffer[4]; unsigned int iword; const ft32_opc_info_t *oo; fpr = info->fprintf_func; if ((status = info->read_memory_func (addr, buffer, 4, info))) goto fail; iword = bfd_getl32 (buffer); for (oo = ft32_opc_info; oo->name; oo++) if ((iword & oo->mask) == oo->bits) break; if (oo->name) { int f = oo->fields; int imm; fpr (stream, "%08x %s", iword, oo->name); if (oo->dw) { fpr (stream, ".%c ", "bsl"[(iword >> FT32_FLD_DW_BIT) & 3]); }
int print_insn_i960 (bfd_vma memaddr, struct disassemble_info *info_arg) { unsigned int word1, word2 = 0xdeadbeef; bfd_byte buffer[8]; int status; info = info_arg; stream = info->stream; /* Read word1. Only read word2 if the instruction needs it, to prevent reading past the end of a section. */ status = (*info->read_memory_func) (memaddr, (bfd_byte *) buffer, 4, info); if (status != 0) { (*info->memory_error_func) (status, memaddr, info); return -1; } word1 = bfd_getl32 (buffer); /* Divide instruction set into classes based on high 4 bits of opcode. */ switch ( (word1 >> 28) & 0xf ) { default: break; case 0x8: case 0x9: case 0xa: case 0xb: case 0xc: /* Read word2. */ status = (*info->read_memory_func) (memaddr + 4, (bfd_byte *) (buffer + 4), 4, info); if (status != 0) { (*info->memory_error_func) (status, memaddr, info); return -1; } word2 = bfd_getl32 (buffer + 4); break; } return pinsn( memaddr, word1, word2 ); }
/* print_insn_pru is the main disassemble function for PRU. */ int print_insn_pru (bfd_vma address, disassemble_info *info) { bfd_byte buffer[INSNLEN]; int status; status = (*info->read_memory_func) (address, buffer, INSNLEN, info); if (status == 0) { unsigned long insn; insn = (unsigned long) bfd_getl32 (buffer); status = pru_disassemble (address, insn, info); } else { (*info->memory_error_func) (status, address, info); status = -1; } return status; }
int print_insn_nios2(bfd_vma address, disassemble_info *info) { /* buffer into which the instruction bytes are written */ bfd_byte buffer[INSNLEN]; /* used to indicate return status from function calls */ int status; assert(info != NULL); status = (*info->read_memory_func) (address, buffer, INSNLEN, info); if (status == 0) { unsigned long insn; insn = (unsigned long) bfd_getl32(buffer); status = nios2_disassemble(address, insn, info); } else { (*info->memory_error_func) (status, address, info); status = -1; } return status; }
static int print_insn_nios2 (bfd_vma address, disassemble_info *info, enum bfd_endian endianness) { bfd_byte buffer[INSNLEN]; int status; status = (*info->read_memory_func) (address, buffer, INSNLEN, info); if (status == 0) { unsigned long insn; if (endianness == BFD_ENDIAN_BIG) insn = (unsigned long) bfd_getb32 (buffer); else insn = (unsigned long) bfd_getl32 (buffer); return nios2_disassemble (address, insn, info); } /* We might have a 16-bit R2 instruction at the end of memory. Try that. */ if (info->mach == bfd_mach_nios2r2) { status = (*info->read_memory_func) (address, buffer, 2, info); if (status == 0) { unsigned long insn; if (endianness == BFD_ENDIAN_BIG) insn = (unsigned long) bfd_getb16 (buffer); else insn = (unsigned long) bfd_getl16 (buffer); return nios2_disassemble (address, insn, info); } } /* If we got here, we couldn't read anything. */ (*info->memory_error_func) (status, address, info); return -1; }
static int print_insn_nios2 (bfd_vma address, disassemble_info *info, enum bfd_endian endianness) { bfd_byte buffer[INSNLEN]; int status; status = (*info->read_memory_func) (address, buffer, INSNLEN, info); if (status == 0) { unsigned long insn; if (endianness == BFD_ENDIAN_BIG) insn = (unsigned long) bfd_getb32 (buffer); else insn = (unsigned long) bfd_getl32 (buffer); status = nios2_disassemble (address, insn, info); } else { (*info->memory_error_func) (status, address, info); status = -1; } return status; }
int print_insn_moxie (bfd_vma addr, struct disassemble_info * info) { int length = 2; int status; stream = info->stream; const moxie_opc_info_t * opcode; bfd_byte buffer[4]; unsigned short iword; fpr = info->fprintf_func; if ((status = info->read_memory_func (addr, buffer, 2, info))) goto fail; if (info->endian == BFD_ENDIAN_BIG) iword = bfd_getb16 (buffer); else iword = bfd_getl16 (buffer); /* Form 1 instructions have the high bit set to 0. */ if ((iword & (1<<15)) == 0) { /* Extract the Form 1 opcode. */ opcode = &moxie_form1_opc_info[iword >> 8]; switch (opcode->itype) { case MOXIE_F1_NARG: fpr (stream, "%s", opcode->name); break; case MOXIE_F1_A: fpr (stream, "%s\t%s", opcode->name, reg_names[OP_A(iword)]); break; case MOXIE_F1_AB: fpr (stream, "%s\t%s, %s", opcode->name, reg_names[OP_A(iword)], reg_names[OP_B(iword)]); break; case MOXIE_F1_A4: { unsigned imm; if ((status = info->read_memory_func (addr + 2, buffer, 4, info))) goto fail; if (info->endian == BFD_ENDIAN_BIG) imm = bfd_getb32 (buffer); else imm = bfd_getl32 (buffer); fpr (stream, "%s\t%s, 0x%x", opcode->name, reg_names[OP_A(iword)], imm); length = 6; } break; case MOXIE_F1_4: { unsigned imm; if ((status = info->read_memory_func (addr + 2, buffer, 4, info))) goto fail; if (info->endian == BFD_ENDIAN_BIG) imm = bfd_getb32 (buffer); else imm = bfd_getl32 (buffer); fpr (stream, "%s\t0x%x", opcode->name, imm); length = 6; } break; case MOXIE_F1_M: { unsigned imm; if ((status = info->read_memory_func (addr + 2, buffer, 4, info))) goto fail; if (info->endian == BFD_ENDIAN_BIG) imm = bfd_getb32 (buffer); else imm = bfd_getl32 (buffer); fpr (stream, "%s\t", opcode->name); info->print_address_func ((bfd_vma) imm, info); length = 6; } break; case MOXIE_F1_AiB: fpr (stream, "%s\t(%s), %s", opcode->name, reg_names[OP_A(iword)], reg_names[OP_B(iword)]); break; case MOXIE_F1_ABi: fpr (stream, "%s\t%s, (%s)", opcode->name, reg_names[OP_A(iword)], reg_names[OP_B(iword)]); break; case MOXIE_F1_4A: { unsigned imm; if ((status = info->read_memory_func (addr + 2, buffer, 4, info))) goto fail; if (info->endian == BFD_ENDIAN_BIG) imm = bfd_getb32 (buffer); else imm = bfd_getl32 (buffer); fpr (stream, "%s\t0x%x, %s", opcode->name, imm, reg_names[OP_A(iword)]); length = 6; } break; case MOXIE_F1_AiB4: { unsigned imm; if ((status = info->read_memory_func (addr+2, buffer, 4, info))) goto fail; if (info->endian == BFD_ENDIAN_BIG) imm = bfd_getb32 (buffer); else imm = bfd_getl32 (buffer); fpr (stream, "%s\t0x%x(%s), %s", opcode->name, imm, reg_names[OP_A(iword)], reg_names[OP_B(iword)]); length = 6; } break; case MOXIE_F1_ABi4: { unsigned imm; if ((status = info->read_memory_func (addr+2, buffer, 4, info))) goto fail; if (info->endian == BFD_ENDIAN_BIG) imm = bfd_getb32 (buffer); else imm = bfd_getl32 (buffer); fpr (stream, "%s\t%s, 0x%x(%s)", opcode->name, reg_names[OP_A(iword)], imm, reg_names[OP_B(iword)]); length = 6; } break; case MOXIE_BAD: fpr (stream, "bad"); break; default: abort(); } }
/* Insert the addend/value into the instruction or data object being relocated. */ bfd_reloc_status_type _bfd_aarch64_elf_put_addend (bfd *abfd, bfd_byte *address, bfd_reloc_code_real_type r_type, reloc_howto_type *howto, bfd_signed_vma addend) { bfd_reloc_status_type status = bfd_reloc_ok; bfd_signed_vma old_addend = addend; bfd_vma contents; int size; size = bfd_get_reloc_size (howto); switch (size) { case 2: contents = bfd_get_16 (abfd, address); break; case 4: if (howto->src_mask != 0xffffffff) /* Must be 32-bit instruction, always little-endian. */ contents = bfd_getl32 (address); else /* Must be 32-bit data (endianness dependent). */ contents = bfd_get_32 (abfd, address); break; case 8: contents = bfd_get_64 (abfd, address); break; default: abort (); } switch (howto->complain_on_overflow) { case complain_overflow_dont: break; case complain_overflow_signed: status = aarch64_signed_overflow (addend, howto->bitsize + howto->rightshift); break; case complain_overflow_unsigned: status = aarch64_unsigned_overflow (addend, howto->bitsize + howto->rightshift); break; case complain_overflow_bitfield: default: abort (); } addend >>= howto->rightshift; switch (r_type) { case BFD_RELOC_AARCH64_JUMP26: case BFD_RELOC_AARCH64_CALL26: contents = reencode_branch_ofs_26 (contents, addend); break; case BFD_RELOC_AARCH64_BRANCH19: contents = reencode_cond_branch_ofs_19 (contents, addend); break; case BFD_RELOC_AARCH64_TSTBR14: contents = reencode_tst_branch_ofs_14 (contents, addend); break; case BFD_RELOC_AARCH64_LD_LO19_PCREL: case BFD_RELOC_AARCH64_GOT_LD_PREL19: if (old_addend & ((1 << howto->rightshift) - 1)) return bfd_reloc_overflow; contents = reencode_ld_lit_ofs_19 (contents, addend); break; case BFD_RELOC_AARCH64_TLSDESC_CALL: break; case BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21: case BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21: case BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21: case BFD_RELOC_AARCH64_ADR_GOT_PAGE: case BFD_RELOC_AARCH64_ADR_LO21_PCREL: case BFD_RELOC_AARCH64_ADR_HI21_PCREL: case BFD_RELOC_AARCH64_ADR_HI21_NC_PCREL: contents = reencode_adr_imm (contents, addend); break; case BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC: case BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_LO12: case BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_HI12: case BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_LO12_NC: case BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC: case BFD_RELOC_AARCH64_ADD_LO12: /* Corresponds to: add rd, rn, #uimm12 to provide the low order 12 bits of the page offset following BFD_RELOC_AARCH64_ADR_HI21_PCREL which computes the (pc-relative) page base. */ contents = reencode_add_imm (contents, addend); break; case BFD_RELOC_AARCH64_LDST8_LO12: case BFD_RELOC_AARCH64_LDST16_LO12: case BFD_RELOC_AARCH64_LDST32_LO12: case BFD_RELOC_AARCH64_LDST64_LO12: case BFD_RELOC_AARCH64_LDST128_LO12: case BFD_RELOC_AARCH64_TLSDESC_LD64_LO12_NC: case BFD_RELOC_AARCH64_TLSDESC_LD32_LO12_NC: case BFD_RELOC_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC: case BFD_RELOC_AARCH64_TLSIE_LD32_GOTTPREL_LO12_NC: case BFD_RELOC_AARCH64_LD64_GOT_LO12_NC: case BFD_RELOC_AARCH64_LD32_GOT_LO12_NC: if (old_addend & ((1 << howto->rightshift) - 1)) return bfd_reloc_overflow; /* Used for ldr*|str* rt, [rn, #uimm12] to provide the low order 12 bits of the page offset following BFD_RELOC_AARCH64_ADR_HI21_PCREL which computes the (pc-relative) page base. */ contents = reencode_ldst_pos_imm (contents, addend); break; /* Group relocations to create high bits of a 16, 32, 48 or 64 bit signed data or abs address inline. Will change instruction to MOVN or MOVZ depending on sign of calculated value. */ case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G2: case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1: case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1_NC: case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0: case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0_NC: case BFD_RELOC_AARCH64_MOVW_G0_S: case BFD_RELOC_AARCH64_MOVW_G1_S: case BFD_RELOC_AARCH64_MOVW_G2_S: /* NOTE: We can only come here with movz or movn. */ if (addend < 0) { /* Force use of MOVN. */ addend = ~addend; contents = reencode_movzn_to_movn (contents); } else { /* Force use of MOVZ. */ contents = reencode_movzn_to_movz (contents); } /* fall through */ /* Group relocations to create a 16, 32, 48 or 64 bit unsigned data or abs address inline. */ case BFD_RELOC_AARCH64_MOVW_G0: case BFD_RELOC_AARCH64_MOVW_G0_NC: case BFD_RELOC_AARCH64_MOVW_G1: case BFD_RELOC_AARCH64_MOVW_G1_NC: case BFD_RELOC_AARCH64_MOVW_G2: case BFD_RELOC_AARCH64_MOVW_G2_NC: case BFD_RELOC_AARCH64_MOVW_G3: contents = reencode_movw_imm (contents, addend); break; default: /* Repack simple data */ if (howto->dst_mask & (howto->dst_mask + 1)) return bfd_reloc_notsupported; contents = ((contents & ~howto->dst_mask) | (addend & howto->dst_mask)); break; } switch (size) { case 2: bfd_put_16 (abfd, contents, address); break; case 4: if (howto->dst_mask != 0xffffffff) /* must be 32-bit instruction, always little-endian */ bfd_putl32 (contents, address); else /* must be 32-bit data (endianness dependent) */ bfd_put_32 (abfd, contents, address); break; case 8: bfd_put_64 (abfd, contents, address); break; default: abort (); } return status; }
int _bfd_vms_slurp_gsd (bfd * abfd, int objtype) { int gsd_type, gsd_size; asection *section; unsigned char *vms_rec; flagword new_flags, old_flags; char *name; asymbol *symbol; vms_symbol_entry *entry; unsigned long base_addr; unsigned long align_addr; static unsigned int psect_idx = 0; #if VMS_DEBUG vms_debug (2, "GSD/EGSD (%d/%x)\n", objtype, objtype); #endif switch (objtype) { case EOBJ_S_C_EGSD: PRIV (vms_rec) += 8; /* Skip type, size, l_temp. */ PRIV (rec_size) -= 8; break; case OBJ_S_C_GSD: PRIV (vms_rec) += 1; PRIV (rec_size) -= 1; break; default: return -1; } /* Calculate base address for each section. */ base_addr = 0L; abfd->symcount = 0; while (PRIV (rec_size) > 0) { vms_rec = PRIV (vms_rec); if (objtype == OBJ_S_C_GSD) gsd_type = vms_rec[0]; else { _bfd_vms_get_header_values (abfd, vms_rec, &gsd_type, &gsd_size); gsd_type += EVAX_OFFSET; } #if VMS_DEBUG vms_debug (3, "gsd_type %d\n", gsd_type); #endif switch (gsd_type) { case GSD_S_C_PSC: { /* Program section definition. */ asection *old_section = 0; #if VMS_DEBUG vms_debug (4, "GSD_S_C_PSC\n"); #endif /* If this section isn't a bfd section. */ if (PRIV (is_vax) && (psect_idx < (abfd->section_count - 1))) { /* Check for temporary section from TIR record. */ if (psect_idx < PRIV (section_count)) old_section = PRIV (sections)[psect_idx]; else old_section = 0; } name = _bfd_vms_save_counted_string (vms_rec + 8); section = bfd_make_section (abfd, name); if (!section) { (*_bfd_error_handler) (_("bfd_make_section (%s) failed"), name); return -1; } old_flags = bfd_getl16 (vms_rec + 2); section->size = bfd_getl32 (vms_rec + 4); /* allocation */ new_flags = vms_secflag_by_name (abfd, vax_section_flags, name, section->size > 0); if (old_flags & EGPS_S_V_REL) new_flags |= SEC_RELOC; if (old_flags & GPS_S_M_OVR) new_flags |= SEC_IS_COMMON; if (!bfd_set_section_flags (abfd, section, new_flags)) { (*_bfd_error_handler) (_("bfd_set_section_flags (%s, %x) failed"), name, new_flags); return -1; } section->alignment_power = vms_rec[1]; align_addr = (1 << section->alignment_power); if ((base_addr % align_addr) != 0) base_addr += (align_addr - (base_addr % align_addr)); section->vma = (bfd_vma)base_addr; base_addr += section->size; /* Global section is common symbol. */ if (old_flags & GPS_S_M_GBL) { entry = _bfd_vms_enter_symbol (abfd, name); if (entry == NULL) { bfd_set_error (bfd_error_no_memory); return -1; } symbol = entry->symbol; symbol->value = 0; symbol->section = section; symbol->flags = (BSF_GLOBAL | BSF_SECTION_SYM | BSF_OLD_COMMON); } /* Copy saved contents if old_section set. */ if (old_section != 0) { section->contents = old_section->contents; if (section->size < old_section->size) { (*_bfd_error_handler) (_("Size mismatch section %s=%lx, %s=%lx"), old_section->name, (unsigned long) old_section->size, section->name, (unsigned long) section->size); return -1; } else if (section->size > old_section->size) { section->contents = bfd_realloc (old_section->contents, section->size); if (section->contents == NULL) { bfd_set_error (bfd_error_no_memory); return -1; } } } else { section->contents = bfd_zmalloc (section->size); if (section->contents == NULL) { bfd_set_error (bfd_error_no_memory); return -1; } } #if VMS_DEBUG vms_debug (4, "gsd psc %d (%s, flags %04x=%s) ", section->index, name, old_flags, flag2str (gpsflagdesc, old_flags)); vms_debug (4, "%d bytes at 0x%08lx (mem %p)\n", section->size, section->vma, section->contents); #endif gsd_size = vms_rec[8] + 9; psect_idx++; } break; case GSD_S_C_EPM: case GSD_S_C_EPMW: #if VMS_DEBUG vms_debug (4, "gsd epm\n"); #endif /* Fall through. */ case GSD_S_C_SYM: case GSD_S_C_SYMW: { int name_offset = 0, value_offset = 0; /* Symbol specification (definition or reference). */ #if VMS_DEBUG vms_debug (4, "GSD_S_C_SYM(W)\n"); #endif old_flags = bfd_getl16 (vms_rec + 2); new_flags = BSF_NO_FLAGS; if (old_flags & GSY_S_M_WEAK) new_flags |= BSF_WEAK; switch (gsd_type) { case GSD_S_C_EPM: name_offset = 11; value_offset = 5; new_flags |= BSF_FUNCTION; break; case GSD_S_C_EPMW: name_offset = 12; value_offset = 6; new_flags |= BSF_FUNCTION; break; case GSD_S_C_SYM: if (old_flags & GSY_S_M_DEF) /* Symbol definition. */ name_offset = 9; else name_offset = 4; value_offset = 5; break; case GSD_S_C_SYMW: if (old_flags & GSY_S_M_DEF) /* Symbol definition. */ name_offset = 10; else name_offset = 5; value_offset = 6; break; } /* Save symbol in vms_symbol_table. */ entry = _bfd_vms_enter_symbol (abfd, _bfd_vms_save_counted_string (vms_rec + name_offset)); if (entry == NULL) { bfd_set_error (bfd_error_no_memory); return -1; } symbol = entry->symbol; if (old_flags & GSY_S_M_DEF) { /* Symbol definition. */ int psect; symbol->value = bfd_getl32 (vms_rec + value_offset); if ((gsd_type == GSD_S_C_SYMW) || (gsd_type == GSD_S_C_EPMW)) psect = bfd_getl16 (vms_rec + value_offset - 2); else psect = vms_rec[value_offset-1]; symbol->section = (asection *)(unsigned long)psect; #if VMS_DEBUG vms_debug (4, "gsd sym def #%d (%s, %ld, %04x=%s)\n", abfd->symcount, symbol->name, (long)symbol->section, old_flags, flag2str(gsyflagdesc, old_flags)); #endif } else { /* Symbol reference. */ #if VMS_DEBUG vms_debug (4, "gsd sym ref #%d (%s, %04x=%s)\n", abfd->symcount, symbol->name, old_flags, flag2str (gsyflagdesc, old_flags)); #endif symbol->section = (asection *)(unsigned long)-1; } gsd_size = vms_rec[name_offset] + name_offset + 1; symbol->flags = new_flags; } break; case GSD_S_C_PRO: case GSD_S_C_PROW: #if VMS_DEBUG vms_debug (4, "gsd pro\n"); #endif break; case GSD_S_C_IDC: #if VMS_DEBUG vms_debug (4, "gsd idc\n"); #endif break; case GSD_S_C_ENV: #if VMS_DEBUG vms_debug (4, "gsd env\n"); #endif break; case GSD_S_C_LSY: #if VMS_DEBUG vms_debug (4, "gsd lsy\n"); #endif break; case GSD_S_C_LEPM: #if VMS_DEBUG vms_debug (4, "gsd lepm\n"); #endif break; case GSD_S_C_LPRO: #if VMS_DEBUG vms_debug (4, "gsd lpro\n"); #endif break; case GSD_S_C_SPSC: #if VMS_DEBUG vms_debug (4, "gsd spsc\n"); #endif break; case GSD_S_C_SYMV: #if VMS_DEBUG vms_debug (4, "gsd symv\n"); #endif break; case GSD_S_C_EPMV: #if VMS_DEBUG vms_debug (4, "gsd epmv\n"); #endif break; case GSD_S_C_PROV: #if VMS_DEBUG vms_debug (4, "gsd prov\n"); #endif break; case EGSD_S_C_PSC + EVAX_OFFSET: { /* Program section definition. */ name = _bfd_vms_save_counted_string (vms_rec + EGPS_S_B_NAMLNG); section = bfd_make_section (abfd, name); if (!section) return -1; old_flags = bfd_getl16 (vms_rec + EGPS_S_W_FLAGS); section->size = bfd_getl32 (vms_rec + EGPS_S_L_ALLOC); new_flags = vms_secflag_by_name (abfd, evax_section_flags, name, section->size > 0); if (old_flags & EGPS_S_V_REL) new_flags |= SEC_RELOC; if (!bfd_set_section_flags (abfd, section, new_flags)) return -1; section->alignment_power = vms_rec[EGPS_S_B_ALIGN]; align_addr = (1 << section->alignment_power); if ((base_addr % align_addr) != 0) base_addr += (align_addr - (base_addr % align_addr)); section->vma = (bfd_vma)base_addr; base_addr += section->size; section->contents = bfd_zmalloc (section->size); if (section->contents == NULL) return -1; section->filepos = (unsigned int)-1; #if VMS_DEBUG vms_debug (4, "EGSD P-section %d (%s, flags %04x=%s) ", section->index, name, old_flags, flag2str(gpsflagdesc, old_flags)); vms_debug (4, "%d bytes at 0x%08lx (mem %p)\n", section->size, section->vma, section->contents); #endif } break; case EGSD_S_C_SYM + EVAX_OFFSET: { /* Global symbol specification (definition or reference). */ symbol = bfd_make_empty_symbol (abfd); if (symbol == 0) return -1; old_flags = bfd_getl16 (vms_rec + EGSY_S_W_FLAGS); new_flags = BSF_NO_FLAGS; if (old_flags & EGSY_S_V_WEAK) new_flags |= BSF_WEAK; if (old_flags & EGSY_S_V_DEF) { /* Symbol definition. */ if (old_flags & EGSY_S_V_NORM) new_flags |= BSF_FUNCTION; symbol->name = _bfd_vms_save_counted_string (vms_rec + ESDF_S_B_NAMLNG); symbol->value = bfd_getl64 (vms_rec + ESDF_S_L_VALUE); symbol->section = (asection *)(unsigned long) bfd_getl32 (vms_rec + ESDF_S_L_PSINDX); #if VMS_DEBUG vms_debug (4, "EGSD sym def #%d (%s, %ld, %04x=%s)\n", abfd->symcount, symbol->name, (long)symbol->section, old_flags, flag2str (gsyflagdesc, old_flags)); #endif } else { /* Symbol reference. */ symbol->name = _bfd_vms_save_counted_string (vms_rec + ESRF_S_B_NAMLNG); #if VMS_DEBUG vms_debug (4, "EGSD sym ref #%d (%s, %04x=%s)\n", abfd->symcount, symbol->name, old_flags, flag2str (gsyflagdesc, old_flags)); #endif symbol->section = (asection *)(unsigned long)-1; } symbol->flags = new_flags; /* Register symbol in VMS symbol table. */ entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table), symbol->name, TRUE, FALSE); if (entry == NULL) { bfd_set_error (bfd_error_no_memory); return -1; } if (entry->symbol != NULL) { /* FIXME ?, DEC C generates this. */ #if VMS_DEBUG vms_debug (4, "EGSD_S_C_SYM: duplicate \"%s\"\n", symbol->name); #endif } else { entry->symbol = symbol; PRIV (gsd_sym_count)++; abfd->symcount++; } } break; case EGSD_S_C_SYMG + EVAX_OFFSET: { /* Universal symbol specification (definition). */ symbol = bfd_make_empty_symbol (abfd); if (symbol == 0) return -1; old_flags = bfd_getl16 (vms_rec + EGST_S_W_FLAGS); new_flags = BSF_NO_FLAGS; if (old_flags & EGSY_S_V_WEAK) new_flags |= BSF_WEAK; if (old_flags & EGSY_S_V_DEF) /* symbol definition */ { if (old_flags & EGSY_S_V_NORM) new_flags |= BSF_FUNCTION; symbol->name = _bfd_vms_save_counted_string (vms_rec + EGST_S_B_NAMLNG); /* For BSF_FUNCTION symbols, the entry point is in LP_1 and the descriptor in LP_2. For other symbols, the unique value is in LP_2. */ symbol->value = bfd_getl64 (vms_rec + EGST_S_Q_LP_2); /* Adding this offset is necessary in order for GDB to read the DWARF-2 debug info from shared libraries. */ if (abfd->flags & DYNAMIC && strstr (symbol->name, "$DWARF2.DEBUG") != 0) symbol->value += PRIV (symvva); } else /* symbol reference */ (*_bfd_error_handler) ("Invalid EGST reference"); symbol->flags = new_flags; if (register_universal_symbol (abfd, symbol, old_flags) < 0) return -1; /* Make a second symbol for the entry point. */ if (symbol->flags & BSF_FUNCTION) { asymbol *en_sym; char *name = bfd_alloc (abfd, strlen (symbol->name) + 5); en_sym = bfd_make_empty_symbol (abfd); if (en_sym == 0) return -1; strcpy (name, symbol->name); strcat (name, "..en"); en_sym->name = name; en_sym->value = bfd_getl64 (vms_rec + EGST_S_Q_LP_1); if (register_universal_symbol (abfd, en_sym, old_flags) < 0) return -1; } } break; case EGSD_S_C_IDC + EVAX_OFFSET: break; default: (*_bfd_error_handler) (_("Unknown GSD/EGSD subtype %d"), gsd_type); bfd_set_error (bfd_error_bad_value); return -1; } PRIV (rec_size) -= gsd_size; PRIV (vms_rec) += gsd_size; } if (abfd->symcount > 0) abfd->flags |= HAS_SYMS; return 0; }
/* Process GSD/EGSD record. * Return 0 on success, -1 on error. */ int _bfd_vms_slurp_gsd(bfd * abfd, int objtype) { #if defined(VMS_DEBUG) && VMS_DEBUG static struct flagdescstruct gpsflagdesc[] = { { "PIC", 0x0001 }, { "LIB", 0x0002 }, { "OVR", 0x0004 }, { "REL", 0x0008 }, { "GBL", 0x0010 }, { "SHR", 0x0020 }, { "EXE", 0x0040 }, { "RD", 0x0080 }, { "WRT", 0x0100 }, { "VEC", 0x0200 }, { "NOMOD", 0x0400 }, { "COM", 0x0800 }, { NULL, 0 } }; static struct flagdescstruct gsyflagdesc[] = { { "WEAK", 0x0001 }, { "DEF", 0x0002 }, { "UNI", 0x0004 }, { "REL", 0x0008 }, { "COMM", 0x0010 }, { "VECEP", 0x0020 }, { "NORM", 0x0040 }, { NULL, 0 } }; #endif /* VMS_DEBUG */ int gsd_type, gsd_size; asection *section; unsigned char *vms_rec; flagword new_flags, old_flags; char *name; asymbol *symbol; vms_symbol_entry *entry; unsigned long base_addr; unsigned long align_addr; static unsigned int psect_idx = 0; gsd_size = 0; #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug(2, "GSD/EGSD (%d/%x)\n", objtype, objtype); #endif /* VMS_DEBUG */ switch (objtype) { case EOBJ_S_C_EGSD: PRIV(vms_rec) += 8; /* Skip type, size, l_temp. */ PRIV(rec_size) -= 8; break; case OBJ_S_C_GSD: PRIV(vms_rec) += 1; PRIV(rec_size) -= 1; break; default: return -1; } /* Calculate base address for each section: */ base_addr = 0L; abfd->symcount = 0; while (PRIV(rec_size) > 0) { vms_rec = PRIV(vms_rec); if (objtype == OBJ_S_C_GSD) gsd_type = *vms_rec; else { _bfd_vms_get_header_values(abfd, vms_rec, &gsd_type, &gsd_size); gsd_type += EVAX_OFFSET; } #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug (3, "gsd_type %d\n", gsd_type); #endif switch (gsd_type) { case GSD_S_C_PSC: { /* Program section definition. */ asection *old_section = 0; #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug (4, "GSD_S_C_PSC\n"); #endif /* If this section isn't a bfd section. */ if (PRIV (is_vax) && (psect_idx < (abfd->section_count-1))) { /* Check for temporary section from TIR record. */ if (psect_idx < PRIV (section_count)) old_section = PRIV (sections)[psect_idx]; else old_section = 0; } name = _bfd_vms_save_counted_string (vms_rec + 8); section = bfd_make_section (abfd, name); if (!section) { (*_bfd_error_handler) (_("bfd_make_section (%s) failed"), name); return -1; } old_flags = bfd_getl16 (vms_rec + 2); section->size = bfd_getl32 (vms_rec + 4); /* allocation */ new_flags = vms_secflag_by_name (abfd, vax_section_flags, name, section->size > 0); if (old_flags & EGPS_S_V_REL) new_flags |= SEC_RELOC; if (old_flags & GPS_S_M_OVR) new_flags |= SEC_IS_COMMON; if (!bfd_set_section_flags (abfd, section, new_flags)) { (*_bfd_error_handler) (_("bfd_set_section_flags (%s, %x) failed"), name, new_flags); return -1; } section->alignment_power = vms_rec[1]; align_addr = (1 << section->alignment_power); if ((base_addr % align_addr) != 0) base_addr += (align_addr - (base_addr % align_addr)); section->vma = (bfd_vma)base_addr; base_addr += section->size; /* Global section is common symbol. */ if (old_flags & GPS_S_M_GBL) { entry = _bfd_vms_enter_symbol (abfd, name); if (entry == NULL) { bfd_set_error (bfd_error_no_memory); return -1; } symbol = entry->symbol; symbol->value = 0; symbol->section = section; symbol->flags = (BSF_GLOBAL | BSF_SECTION_SYM | BSF_OLD_COMMON); } /* Copy saved contents if old_section set. */ if (old_section != 0) { section->contents = old_section->contents; if (section->size < old_section->size) { (*_bfd_error_handler) (_("Size mismatch section %s=%lx, %s=%lx"), old_section->name, (unsigned long) old_section->size, section->name, (unsigned long) section->size); return -1; } else if (section->size > old_section->size) { section->contents = (unsigned char *)bfd_realloc(old_section->contents, section->size); if (section->contents == NULL) { bfd_set_error (bfd_error_no_memory); return -1; } } } else { section->contents = (unsigned char *)bfd_zmalloc(section->size); if (section->contents == NULL) { bfd_set_error (bfd_error_no_memory); return -1; } } #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug (4, "gsd psc %d (%s, flags %04x=%s) ", section->index, name, old_flags, flag2str (gpsflagdesc, old_flags)); vms_debug (4, "%d bytes at 0x%08lx (mem %p)\n", section->size, section->vma, section->contents); #endif /* VMS_DEBUG */ gsd_size = vms_rec[8] + 9; psect_idx++; } break; case GSD_S_C_EPM: case GSD_S_C_EPMW: #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug (4, "gsd epm\n"); #endif /* Fall through. */ case GSD_S_C_SYM: case GSD_S_C_SYMW: { int name_offset = 0, value_offset = 0; /* Symbol specification (definition or reference). */ #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug(4, "GSD_S_C_SYM(W)\n"); #endif old_flags = bfd_getl16 (vms_rec + 2); new_flags = BSF_NO_FLAGS; if (old_flags & GSY_S_M_WEAK) new_flags |= BSF_WEAK; switch (gsd_type) { case GSD_S_C_EPM: name_offset = 11; value_offset = 5; new_flags |= BSF_FUNCTION; break; case GSD_S_C_EPMW: name_offset = 12; value_offset = 6; new_flags |= BSF_FUNCTION; break; case GSD_S_C_SYM: if (old_flags & GSY_S_M_DEF) /* Symbol definition. */ name_offset = 9; else name_offset = 4; value_offset = 5; break; case GSD_S_C_SYMW: if (old_flags & GSY_S_M_DEF) /* Symbol definition. */ name_offset = 10; else name_offset = 5; value_offset = 6; break; default: break; } /* end "switch (gsd_type)" */ /* Save symbol in vms_symbol_table: */ entry = _bfd_vms_enter_symbol(abfd, _bfd_vms_save_counted_string(vms_rec + name_offset)); if (entry == NULL) { bfd_set_error (bfd_error_no_memory); return -1; } symbol = entry->symbol; if (old_flags & GSY_S_M_DEF) { /* Symbol definition. */ int psect; symbol->value = bfd_getl32 (vms_rec + value_offset); if ((gsd_type == GSD_S_C_SYMW) || (gsd_type == GSD_S_C_EPMW)) psect = bfd_getl16 (vms_rec + value_offset - 2); else psect = vms_rec[value_offset-1]; symbol->section = (asection *) (size_t) psect; #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug (4, "gsd sym def #%d (%s, %d [%p], %04x=%s)\n", abfd->symcount, symbol->name, (int)symbol->section, symbol->section, old_flags, flag2str (gsyflagdesc, old_flags)); #endif } else { /* Symbol reference. */ symbol->section = bfd_make_section (abfd, BFD_UND_SECTION_NAME); #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug (4, "gsd sym ref #%d (%s, %s [%p], %04x=%s)\n", abfd->symcount, symbol->name, symbol->section->name, symbol->section, old_flags, flag2str (gsyflagdesc, old_flags)); #endif } gsd_size = vms_rec[name_offset] + name_offset + 1; symbol->flags = new_flags; } break; case GSD_S_C_PRO: case GSD_S_C_PROW: #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug (4, "gsd pro\n"); #endif break; case GSD_S_C_IDC: #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug (4, "gsd idc\n"); #endif break; case GSD_S_C_ENV: #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug (4, "gsd env\n"); #endif break; case GSD_S_C_LSY: #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug (4, "gsd lsy\n"); #endif break; case GSD_S_C_LEPM: #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug (4, "gsd lepm\n"); #endif break; case GSD_S_C_LPRO: #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug (4, "gsd lpro\n"); #endif break; case GSD_S_C_SPSC: #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug (4, "gsd spsc\n"); #endif break; case GSD_S_C_SYMV: #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug (4, "gsd symv\n"); #endif break; case GSD_S_C_EPMV: #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug (4, "gsd epmv\n"); #endif break; case GSD_S_C_PROV: #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug (4, "gsd prov\n"); #endif break; case EGSD_S_C_PSC + EVAX_OFFSET: { /* Program section definition. */ name = _bfd_vms_save_counted_string (vms_rec + 12); section = bfd_make_section (abfd, name); if (!section) return -1; old_flags = bfd_getl16 (vms_rec + 6); section->size = bfd_getl32 (vms_rec + 8); /* Allocation. */ new_flags = vms_secflag_by_name (abfd, evax_section_flags, name, section->size > 0); if (old_flags & EGPS_S_V_REL) new_flags |= SEC_RELOC; if (!bfd_set_section_flags (abfd, section, new_flags)) return -1; section->alignment_power = vms_rec[4]; align_addr = (1 << section->alignment_power); if ((base_addr % align_addr) != 0) base_addr += (align_addr - (base_addr % align_addr)); section->vma = (bfd_vma)base_addr; base_addr += section->size; section->contents = (unsigned char *)bfd_zmalloc(section->size); if (section->contents == NULL) return -1; #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug (4, "egsd psc %d (%s, flags %04x=%s) ", section->index, name, old_flags, flag2str (gpsflagdesc, old_flags)); vms_debug (4, "%d bytes at 0x%08lx (mem %p)\n", section->size, section->vma, section->contents); #endif } break; case EGSD_S_C_SYM + EVAX_OFFSET: { /* Symbol specification (definition or reference). */ symbol = bfd_make_empty_symbol (abfd); if (symbol == 0) return -1; old_flags = bfd_getl16 (vms_rec + 6); new_flags = BSF_NO_FLAGS; if (old_flags & EGSY_S_V_WEAK) new_flags |= BSF_WEAK; if (vms_rec[6] & EGSY_S_V_DEF) { /* Symbol definition. */ symbol->name = _bfd_vms_save_counted_string (vms_rec + 32); if (old_flags & EGSY_S_V_NORM) /* Proc def. */ new_flags |= BSF_FUNCTION; symbol->value = bfd_getl64 (vms_rec + 8); symbol->section = (asection *) ((unsigned long) bfd_getl32 (vms_rec + 28)); #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug (4, "egsd sym def #%d (%s, %d, %04x=%s)\n", abfd->symcount, symbol->name, (int) symbol->section, old_flags, flag2str (gsyflagdesc, old_flags)); #endif } else { /* Symbol reference. */ symbol->name = _bfd_vms_save_counted_string (vms_rec + 8); #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug (4, "egsd sym ref #%d (%s, %04x=%s)\n", abfd->symcount, symbol->name, old_flags, flag2str (gsyflagdesc, old_flags)); #endif symbol->section = bfd_make_section (abfd, BFD_UND_SECTION_NAME); } symbol->flags = new_flags; /* Save symbol in vms_symbol_table: */ entry = (vms_symbol_entry *)bfd_hash_lookup(PRIV(vms_symbol_table), symbol->name, TRUE, FALSE); if (entry == NULL) { bfd_set_error(bfd_error_no_memory); return -1; } if (entry->symbol != NULL) { /* FIXME ?, DEC C generates this. */ #if defined(VMS_DEBUG) && VMS_DEBUG vms_debug(4, "EGSD_S_C_SYM: duplicate \"%s\"\n", symbol->name); #endif /* VMS_DEBUG */ } else { entry->symbol = symbol; PRIV(gsd_sym_count)++; abfd->symcount++; } } break; case EGSD_S_C_IDC + EVAX_OFFSET: break; default: (*_bfd_error_handler)(_("unknown gsd/egsd subtype %d"), gsd_type); bfd_set_error(bfd_error_bad_value); return -1; } PRIV(rec_size) -= gsd_size; PRIV(vms_rec) += gsd_size; } if (abfd->symcount > 0) abfd->flags |= HAS_SYMS; return 0; }
static void download (char *target_name, char *args, int from_tty, void (*write_routine) (bfd *from_bfd, asection *from_sec, file_ptr from_addr, bfd_vma to_addr, int len), void (*start_routine) (bfd_vma entry)) { struct cleanup *old_chain; asection *section; bfd *pbfd; bfd_vma entry; int i; #define WRITESIZE 1024 char *filename; int quiet; int nostart; quiet = 0; nostart = 0; filename = NULL; while (*args != '\000') { char *arg; while (isspace (*args)) args++; arg = args; while ((*args != '\000') && !isspace (*args)) args++; if (*args != '\000') *args++ = '\000'; if (*arg != '-') filename = arg; else if (strncmp (arg, "-quiet", strlen (arg)) == 0) quiet = 1; else if (strncmp (arg, "-nostart", strlen (arg)) == 0) nostart = 1; else error ("unknown option `%s'", arg); } if (!filename) filename = get_exec_file (1); pbfd = bfd_openr (filename, gnutarget); if (pbfd == NULL) { perror_with_name (filename); return; } old_chain = make_cleanup_bfd_close (pbfd); if (!bfd_check_format (pbfd, bfd_object)) error ("\"%s\" is not an object file: %s", filename, bfd_errmsg (bfd_get_error ())); for (section = pbfd->sections; section; section = section->next) { if (bfd_get_section_flags (pbfd, section) & SEC_LOAD) { bfd_vma section_address; bfd_size_type section_size; file_ptr fptr; const char *section_name; section_name = bfd_get_section_name (pbfd, section); section_address = bfd_get_section_vma (pbfd, section); /* Adjust sections from a.out files, since they don't carry their addresses with. */ if (bfd_get_flavour (pbfd) == bfd_target_aout_flavour) { if (strcmp (section_name, ".text") == 0) section_address = bfd_get_start_address (pbfd); else if (strcmp (section_name, ".data") == 0) { /* Read the first 8 bytes of the data section. There should be the string 'DaTa' followed by a word containing the actual section address. */ struct data_marker { char signature[4]; /* 'DaTa' */ unsigned char sdata[4]; /* &sdata */ } marker; bfd_get_section_contents (pbfd, section, &marker, 0, sizeof (marker)); if (strncmp (marker.signature, "DaTa", 4) == 0) { if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) section_address = bfd_getb32 (marker.sdata); else section_address = bfd_getl32 (marker.sdata); } } } section_size = bfd_get_section_size_before_reloc (section); if (!quiet) printf_filtered ("[Loading section %s at 0x%x (%d bytes)]\n", bfd_get_section_name (pbfd, section), section_address, section_size); fptr = 0; while (section_size > 0) { int count; static char inds[] = "|/-\\"; static int k = 0; QUIT; count = min (section_size, WRITESIZE); write_routine (pbfd, section, fptr, section_address, count); if (!quiet) { printf_unfiltered ("\r%c", inds[k++ % 4]); gdb_flush (gdb_stdout); } section_address += count; fptr += count; section_size -= count; } } } if (!nostart) { entry = bfd_get_start_address (pbfd); if (!quiet) printf_unfiltered ("[Starting %s at 0x%x]\n", filename, entry); start_routine (entry); } do_cleanups (old_chain); }