mirror of
https://github.com/darlinghq/darling-gdb.git
synced 2024-12-04 18:36:32 +00:00
3474 lines
105 KiB
C
3474 lines
105 KiB
C
/* BFD back-end for HP PA-RISC ELF files.
|
|
Copyright (C) 1990-1991 Free Software Foundation, Inc.
|
|
|
|
Written by
|
|
|
|
Center for Software Science
|
|
Department of Computer Science
|
|
University of Utah
|
|
|
|
This file is part of BFD, the Binary File Descriptor library.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|
|
|
#include "bfd.h"
|
|
#include "sysdep.h"
|
|
#include "libbfd.h"
|
|
#include "obstack.h"
|
|
#include "libelf.h"
|
|
|
|
/* ELF32/HPPA relocation support
|
|
|
|
This file contains ELF32/HPPA relocation support as specified
|
|
in the Stratus FTX/Golf Object File Format (SED-1762) dated
|
|
November 19, 1992.
|
|
*/
|
|
|
|
/*
|
|
Written by:
|
|
|
|
Center for Software Science
|
|
Department of Computer Science
|
|
University of Utah
|
|
*/
|
|
|
|
#include "elf32-hppa.h"
|
|
#include "libhppa.h"
|
|
#include "aout/aout64.h"
|
|
#include "hppa_stubs.h"
|
|
|
|
/* ELF/PA relocation howto entries */
|
|
|
|
static bfd_reloc_status_type hppa_elf_reloc ();
|
|
|
|
static reloc_howto_type elf_hppa_howto_table[ELF_HOWTO_TABLE_SIZE] =
|
|
{
|
|
/* 'bitpos' and 'abs' are obsolete */
|
|
/* type rs sz bsz pcrel bpos abs ovrf sf name */
|
|
/* 9.3.4. Address relocation types */
|
|
{R_HPPA_NONE, 0, 3, 19, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_NONE"},
|
|
{R_HPPA_32, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_32"},
|
|
{R_HPPA_11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_11"},
|
|
{R_HPPA_14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_14"},
|
|
{R_HPPA_17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_17"},
|
|
{R_HPPA_L21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_L21"},
|
|
{R_HPPA_R11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_R11"},
|
|
{R_HPPA_R14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_R14"},
|
|
{R_HPPA_R17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_R17"},
|
|
{R_HPPA_LS21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_LS21"},
|
|
{R_HPPA_RS11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RS11"},
|
|
{R_HPPA_RS14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RS14"},
|
|
{R_HPPA_RS17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RS17"},
|
|
{R_HPPA_LD21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_LD21"},
|
|
{R_HPPA_RD11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RD11"},
|
|
{R_HPPA_RD14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RD14"},
|
|
{R_HPPA_RD17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RD17"},
|
|
{R_HPPA_LR21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_LR21"},
|
|
{R_HPPA_RR14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RR14"},
|
|
{R_HPPA_RR17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RR17"},
|
|
/* 9.3.5. GOTOFF address relocation types */
|
|
{R_HPPA_GOTOFF_11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_11"},
|
|
{R_HPPA_GOTOFF_14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_14"},
|
|
{R_HPPA_GOTOFF_L21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_L21"},
|
|
{R_HPPA_GOTOFF_R11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_R11"},
|
|
{R_HPPA_GOTOFF_R14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_R14"},
|
|
{R_HPPA_GOTOFF_LS21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_LS21"},
|
|
{R_HPPA_GOTOFF_RS11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_RS11"},
|
|
{R_HPPA_GOTOFF_RS14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_RS14"},
|
|
{R_HPPA_GOTOFF_LD21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_LD21"},
|
|
{R_HPPA_GOTOFF_RD11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_RD11"},
|
|
{R_HPPA_GOTOFF_RD14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_RD14"},
|
|
{R_HPPA_GOTOFF_LR21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_LR21"},
|
|
{R_HPPA_GOTOFF_RR14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_RR14"},
|
|
/* 9.3.6. Absolute call relocation types */
|
|
{R_HPPA_ABS_CALL_11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_11"},
|
|
{R_HPPA_ABS_CALL_14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_14"},
|
|
{R_HPPA_ABS_CALL_17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_17"},
|
|
{R_HPPA_ABS_CALL_L21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_L21"},
|
|
{R_HPPA_ABS_CALL_R11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_R11"},
|
|
{R_HPPA_ABS_CALL_R14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_R14"},
|
|
{R_HPPA_ABS_CALL_R17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_R17"},
|
|
{R_HPPA_ABS_CALL_LS21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_LS21"},
|
|
{R_HPPA_ABS_CALL_RS11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RS11"},
|
|
{R_HPPA_ABS_CALL_RS14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RS14"},
|
|
{R_HPPA_ABS_CALL_RS17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RS17"},
|
|
{R_HPPA_ABS_CALL_LD21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_LD21"},
|
|
{R_HPPA_ABS_CALL_RD11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RD11"},
|
|
{R_HPPA_ABS_CALL_RD14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RD14"},
|
|
{R_HPPA_ABS_CALL_RD17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RD17"},
|
|
{R_HPPA_ABS_CALL_LR21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_LR21"},
|
|
{R_HPPA_ABS_CALL_RR14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RR14"},
|
|
{R_HPPA_ABS_CALL_RR17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RR17"},
|
|
/* 9.3.7. PC-relative call relocation types */
|
|
{R_HPPA_PCREL_CALL_11, 0, 3, 11, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_11"},
|
|
{R_HPPA_PCREL_CALL_14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_14"},
|
|
{R_HPPA_PCREL_CALL_17, 0, 3, 17, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_17"},
|
|
{R_HPPA_PCREL_CALL_12, 0, 3, 12, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_12"},
|
|
{R_HPPA_PCREL_CALL_L21, 0, 3, 21, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_L21"},
|
|
{R_HPPA_PCREL_CALL_R11, 0, 3, 11, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_R11"},
|
|
{R_HPPA_PCREL_CALL_R14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_R14"},
|
|
{R_HPPA_PCREL_CALL_R17, 0, 3, 17, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_R17"},
|
|
{R_HPPA_PCREL_CALL_LS21, 0, 3, 21, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_LS21"},
|
|
{R_HPPA_PCREL_CALL_RS11, 0, 3, 11, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RS11"},
|
|
{R_HPPA_PCREL_CALL_RS14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RS14"},
|
|
{R_HPPA_PCREL_CALL_RS17, 0, 3, 17, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RS17"},
|
|
{R_HPPA_PCREL_CALL_LD21, 0, 3, 21, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_LD21"},
|
|
{R_HPPA_PCREL_CALL_RD11, 0, 3, 11, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RD11"},
|
|
{R_HPPA_PCREL_CALL_RD14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RD14"},
|
|
{R_HPPA_PCREL_CALL_RD17, 0, 3, 17, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RD17"},
|
|
{R_HPPA_PCREL_CALL_LR21, 0, 3, 21, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_LR21"},
|
|
{R_HPPA_PCREL_CALL_RR14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RR14"},
|
|
{R_HPPA_PCREL_CALL_RR17, 0, 3, 17, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RR17"},
|
|
|
|
/* 9.3.8. Plabel relocation types */
|
|
{R_HPPA_PLABEL_32, 0, 3, 32, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PLABEL_32"},
|
|
{R_HPPA_PLABEL_11, 0, 3, 11, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PLABEL_11"},
|
|
{R_HPPA_PLABEL_14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PLABEL_14"},
|
|
{R_HPPA_PLABEL_L21, 0, 3, 21, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PLABEL_L21"},
|
|
{R_HPPA_PLABEL_R11, 0, 3, 11, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PLABEL_R11"},
|
|
{R_HPPA_PLABEL_R14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PLABEL_R14"},
|
|
|
|
/* 9.3.9. Data linkage table (DLT) relocation types */
|
|
{R_HPPA_DLT_32, 0, 3, 32, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_DLT_32"},
|
|
{R_HPPA_DLT_11, 0, 3, 11, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_DLT_11"},
|
|
{R_HPPA_DLT_14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_DLT_14"},
|
|
{R_HPPA_DLT_L21, 0, 3, 21, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_DLT_L21"},
|
|
{R_HPPA_DLT_R11, 0, 3, 11, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_DLT_R11"},
|
|
{R_HPPA_DLT_R14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_DLT_R14"},
|
|
|
|
/* 9.3.10. Relocations for unwinder tables */
|
|
{R_HPPA_UNWIND_ENTRY, 0, 3, 32, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_UNWIND_ENTRY"},
|
|
{R_HPPA_UNWIND_ENTRIES, 0, 3, 32, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_UNWIND_ENTRIES"},
|
|
|
|
/* 9.3.11. Relocation types for complex expressions */
|
|
{R_HPPA_PUSH_CONST, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_CONST"},
|
|
{R_HPPA_PUSH_PC, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_PC"},
|
|
{R_HPPA_PUSH_SYM, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_SYM"},
|
|
{R_HPPA_PUSH_GOTOFF, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_GOTOFF"},
|
|
{R_HPPA_PUSH_ABS_CALL, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_ABS_CALL"},
|
|
{R_HPPA_PUSH_PCREL_CALL, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_PCREL_CALL"},
|
|
{R_HPPA_PUSH_PLABEL, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_PLABEL"},
|
|
{R_HPPA_MAX, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_MAX"},
|
|
{R_HPPA_MIN, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_MIN"},
|
|
{R_HPPA_ADD, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ADD"},
|
|
{R_HPPA_SUB, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_SUB"},
|
|
{R_HPPA_MULT, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_MULT"},
|
|
{R_HPPA_DIV, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_DIV"},
|
|
{R_HPPA_MOD, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_MOD"},
|
|
{R_HPPA_AND, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_AND"},
|
|
{R_HPPA_OR, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_OR"},
|
|
{R_HPPA_XOR, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_XOR"},
|
|
{R_HPPA_NOT, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_NOT"},
|
|
{R_HPPA_LSHIFT, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_LSHIFT"},
|
|
{R_HPPA_ARITH_RSHIFT, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ARITH_RSHIFT"},
|
|
{R_HPPA_LOGIC_RSHIFT, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_LOGIC_RSHIFT"},
|
|
{R_HPPA_EXPR_F, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_L"},
|
|
{R_HPPA_EXPR_L, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_L"},
|
|
{R_HPPA_EXPR_R, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_R"},
|
|
{R_HPPA_EXPR_LS, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_LS"},
|
|
{R_HPPA_EXPR_RS, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_RS"},
|
|
{R_HPPA_EXPR_LD, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_LD"},
|
|
{R_HPPA_EXPR_RD, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_RD"},
|
|
{R_HPPA_EXPR_LR, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_LR"},
|
|
{R_HPPA_EXPR_RR, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_RR"},
|
|
|
|
{R_HPPA_EXPR_32, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_32"},
|
|
{R_HPPA_EXPR_21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_21"},
|
|
{R_HPPA_EXPR_11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_11"},
|
|
{R_HPPA_EXPR_14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_14"},
|
|
{R_HPPA_EXPR_17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_17"},
|
|
{R_HPPA_EXPR_12, 0, 3, 12, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_12"},
|
|
{R_HPPA_STUB_CALL_17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_STUB_CALL_17"},
|
|
{R_HPPA_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont, NULL, "R_HPPA_UNIMPLEMENTED"},
|
|
};
|
|
|
|
static symext_chainS *symext_rootP;
|
|
static symext_chainS *symext_lastP;
|
|
|
|
static unsigned long
|
|
DEFUN (hppa_elf_rebuild_insn, (abfd, insn, value, r_type, r_field, r_format),
|
|
bfd * abfd AND
|
|
unsigned long insn AND
|
|
unsigned long value AND
|
|
unsigned short r_type AND
|
|
unsigned short r_field AND
|
|
unsigned short r_format)
|
|
{
|
|
unsigned long const_part; /* part of the instruction that does not change */
|
|
unsigned long rebuilt_part;
|
|
|
|
switch (r_format)
|
|
{
|
|
case 11:
|
|
{
|
|
unsigned w1, w;
|
|
|
|
const_part = insn & 0xffffe002;
|
|
dis_assemble_12 (value, &w1, &w);
|
|
rebuilt_part = (w1 << 2) | w;
|
|
return const_part | rebuilt_part;
|
|
}
|
|
|
|
case 12:
|
|
{
|
|
unsigned w1, w;
|
|
|
|
const_part = insn & 0xffffe002;
|
|
dis_assemble_12 (value, &w1, &w);
|
|
rebuilt_part = (w1 << 2) | w;
|
|
return const_part | rebuilt_part;
|
|
}
|
|
|
|
case 14:
|
|
const_part = insn & 0xffffc000;
|
|
low_sign_unext (value, 14, &rebuilt_part);
|
|
return const_part | rebuilt_part;
|
|
|
|
case 17:
|
|
{
|
|
unsigned w1, w2, w;
|
|
|
|
const_part = insn & 0xffe0e002;
|
|
dis_assemble_17 (value, &w1, &w2, &w);
|
|
rebuilt_part = (w2 << 2) | (w1 << 16) | w;
|
|
return const_part | rebuilt_part;
|
|
}
|
|
|
|
case 21:
|
|
const_part = insn & 0xffe00000;
|
|
dis_assemble_21 (value, &rebuilt_part);
|
|
return const_part | rebuilt_part;
|
|
|
|
case 32:
|
|
const_part = 0;
|
|
return value;
|
|
|
|
default:
|
|
fprintf (stderr, "Relocation problem : ");
|
|
fprintf (stderr,
|
|
"Unrecognized reloc type %d (fmt=%d,fld=%d), in module %s\n",
|
|
r_type, r_format, r_field, abfd->filename);
|
|
}
|
|
return insn;
|
|
}
|
|
|
|
static unsigned long
|
|
DEFUN (hppa_elf_relocate_insn,
|
|
(abfd, input_sect,
|
|
insn, address, symp, sym_value, r_addend,
|
|
r_type, r_format, r_field, pcrel),
|
|
bfd * abfd AND
|
|
asection * input_sect AND
|
|
unsigned long insn AND
|
|
unsigned long address AND
|
|
asymbol * symp AND
|
|
long sym_value AND
|
|
long r_addend AND
|
|
unsigned short r_type AND
|
|
unsigned short r_format AND
|
|
unsigned short r_field AND
|
|
unsigned char pcrel)
|
|
{
|
|
unsigned char opcode = get_opcode (insn);
|
|
long constant_value;
|
|
unsigned arg_reloc;
|
|
|
|
switch (opcode)
|
|
{
|
|
case LDO:
|
|
case LDB:
|
|
case LDH:
|
|
case LDW:
|
|
case LDWM:
|
|
case STB:
|
|
case STH:
|
|
case STW:
|
|
case STWM:
|
|
constant_value = ELF32_HPPA_R_CONSTANT (r_addend);
|
|
BFD_ASSERT (r_format == 14);
|
|
|
|
if (pcrel)
|
|
sym_value -= address;
|
|
sym_value = hppa_field_adjust (sym_value, constant_value, r_field);
|
|
return hppa_elf_rebuild_insn (abfd, insn, sym_value, r_type, r_field, r_format);
|
|
|
|
case COMICLR:
|
|
case SUBI: /* case SUBIO: */
|
|
case ADDIT: /* case ADDITO: */
|
|
case ADDI: /* case ADDIO: */
|
|
BFD_ASSERT (r_format == 11);
|
|
|
|
constant_value = ((insn & 0x1) << 10) | ((insn & 0xffe) >> 1);
|
|
sym_value = hppa_field_adjust (sym_value, constant_value, r_field);
|
|
return hppa_elf_rebuild_insn (abfd, insn, sym_value, r_type, r_field, r_format);
|
|
|
|
case LDIL:
|
|
case ADDIL:
|
|
BFD_ASSERT (r_format == 21);
|
|
|
|
constant_value = assemble_21 (insn);
|
|
constant_value += ELF32_HPPA_R_CONSTANT (r_addend);
|
|
sym_value = hppa_field_adjust (sym_value, constant_value, r_field);
|
|
return hppa_elf_rebuild_insn (abfd, insn, sym_value, r_type, r_field, r_format);
|
|
|
|
case BL:
|
|
case BE:
|
|
case BLE:
|
|
arg_reloc = ELF32_HPPA_R_ARG_RELOC (r_addend);
|
|
|
|
BFD_ASSERT (r_format == 17);
|
|
|
|
/* XXX computing constant_value is not needed??? */
|
|
constant_value = assemble_17 ((insn & 0x001f0000) >> 16,
|
|
(insn & 0x00001ffc) >> 2,
|
|
insn & 1);
|
|
/* @@ Assumes only 32 bits. */
|
|
constant_value = (constant_value << 15) >> 15;
|
|
if (pcrel)
|
|
{
|
|
sym_value -=
|
|
address + input_sect->output_offset
|
|
+ input_sect->output_section->vma;
|
|
sym_value = hppa_field_adjust (sym_value, -8, r_field);
|
|
}
|
|
else
|
|
sym_value = hppa_field_adjust (sym_value, constant_value, r_field);
|
|
|
|
return hppa_elf_rebuild_insn (abfd, insn, sym_value >> 2, r_type, r_field, r_format);
|
|
|
|
default:
|
|
if (opcode == 0)
|
|
{
|
|
BFD_ASSERT (r_format == 32);
|
|
constant_value = insn;
|
|
constant_value += ELF32_HPPA_R_CONSTANT (r_addend);
|
|
|
|
return hppa_field_adjust (sym_value, constant_value, r_field);
|
|
}
|
|
else
|
|
{
|
|
fprintf (stderr,
|
|
"Unrecognized opcode 0x%02x (fmt=%x,field=%x)\n",
|
|
opcode, r_format, r_field);
|
|
return insn;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
DEFUN (hppa_elf_relocate_unwind_table,
|
|
(abfd, input_sect,
|
|
data, address, symp, sym_value, r_addend,
|
|
r_type, r_format, r_field, pcrel),
|
|
bfd * abfd AND
|
|
asection * input_sect AND
|
|
PTR data AND
|
|
unsigned long address AND
|
|
asymbol * symp AND
|
|
long sym_value AND
|
|
long r_addend AND
|
|
unsigned short r_type AND
|
|
unsigned short r_format AND
|
|
unsigned short r_field AND
|
|
unsigned char pcrel)
|
|
{
|
|
bfd_byte *hit_data = address + (bfd_byte *) (data);
|
|
long start_offset;
|
|
long end_offset;
|
|
long relocated_value;
|
|
int i;
|
|
|
|
BFD_ASSERT (r_format == 32);
|
|
BFD_ASSERT (r_field == e_fsel);
|
|
switch (r_type)
|
|
{
|
|
case R_HPPA_UNWIND_ENTRY:
|
|
start_offset = bfd_get_32 (abfd, hit_data);
|
|
relocated_value = hppa_field_adjust (sym_value, start_offset, r_field);
|
|
bfd_put_32 (abfd, relocated_value, hit_data);
|
|
|
|
hit_data += sizeof (unsigned long);
|
|
end_offset = bfd_get_32 (abfd, hit_data);
|
|
relocated_value = hppa_field_adjust (sym_value, end_offset, r_field);
|
|
bfd_put_32 (abfd, relocated_value, hit_data);
|
|
break;
|
|
|
|
case R_HPPA_UNWIND_ENTRIES:
|
|
for (i = 0; i < r_addend; i++, hit_data += 3 * sizeof (unsigned long))
|
|
{
|
|
unsigned int adjustment;
|
|
start_offset = bfd_get_32 (abfd, hit_data);
|
|
/* Stuff the symbol value into the first word */
|
|
/* of the unwind descriptor */
|
|
bfd_put_32 (abfd, sym_value, hit_data);
|
|
adjustment = sym_value - start_offset;
|
|
|
|
hit_data += sizeof (unsigned long);
|
|
end_offset = adjustment + bfd_get_32 (abfd, hit_data);
|
|
bfd_put_32 (abfd, end_offset, hit_data);
|
|
|
|
/* If this is not the last unwind entry, */
|
|
/* adjust the symbol value. */
|
|
if (i + 1 < r_addend)
|
|
{
|
|
start_offset = bfd_get_32 (abfd, hit_data + 3 * sizeof (unsigned long));
|
|
sym_value = start_offset + adjustment;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
fprintf (stderr,
|
|
"Unrecognized relocation type 0x%02x (fmt=%x,field=%x)\n",
|
|
r_type, r_format, r_field);
|
|
}
|
|
}
|
|
|
|
/* Provided the symbol, returns the value reffed */
|
|
static long
|
|
get_symbol_value (symbol)
|
|
asymbol *symbol;
|
|
{
|
|
long relocation = 0;
|
|
|
|
if (symbol == (asymbol *) NULL)
|
|
relocation = 0;
|
|
else if (symbol->section == &bfd_com_section)
|
|
{
|
|
relocation = 0;
|
|
}
|
|
else
|
|
{
|
|
relocation = symbol->value +
|
|
symbol->section->output_section->vma +
|
|
symbol->section->output_offset;
|
|
}
|
|
|
|
return (relocation);
|
|
}
|
|
|
|
/* This function provides a pretty straight-forward mapping between a */
|
|
/* base relocation type, format and field into the relocation type */
|
|
/* that will be emitted in an object file. The only wrinkle in the */
|
|
/* mapping is that when the T, TR, TL, P, PR, or PL expression */
|
|
/* prefixes are involved, the type gets promoted to a *_GOTOFF_* */
|
|
/* relocation (in the case of T, TR, and TL) or a PLABEL relocation */
|
|
/* (in the case of P, PR, and PL). */
|
|
|
|
/* NOTE: XXX the T, TR, TL, P, PR, and PL expression prefixes are not */
|
|
/* handled yet. */
|
|
|
|
static void
|
|
hppa_elf_gen_reloc_error (base_type, fmt, field)
|
|
elf32_hppa_reloc_type base_type;
|
|
int fmt;
|
|
int field;
|
|
{
|
|
fprintf (stderr, "undefined relocation: base=0x%x,fmt=0x%x,field=0x%x\n",
|
|
base_type, fmt, field);
|
|
}
|
|
|
|
elf32_hppa_reloc_type **
|
|
hppa_elf_gen_reloc_type (abfd, base_type, format, field)
|
|
bfd *abfd;
|
|
elf32_hppa_reloc_type base_type;
|
|
int format;
|
|
int field;
|
|
{
|
|
#define UNDEFINED hppa_elf_gen_reloc_error(base_type,format,field)
|
|
|
|
elf32_hppa_reloc_type *finaltype;
|
|
elf32_hppa_reloc_type **final_types;
|
|
int i;
|
|
|
|
final_types = (elf32_hppa_reloc_type **) bfd_alloc_by_size_t (abfd, sizeof (elf32_hppa_reloc_type *) * 2);
|
|
BFD_ASSERT (final_types != 0);
|
|
|
|
finaltype = (elf32_hppa_reloc_type *) bfd_alloc_by_size_t (abfd, sizeof (elf32_hppa_reloc_type));
|
|
BFD_ASSERT (finaltype != 0);
|
|
|
|
final_types[0] = finaltype;
|
|
final_types[1] = NULL;
|
|
|
|
#define final_type finaltype[0]
|
|
|
|
final_type = base_type;
|
|
|
|
switch (base_type)
|
|
{
|
|
case R_HPPA:
|
|
switch (format)
|
|
{
|
|
case 11:
|
|
switch (field)
|
|
{
|
|
case e_fsel:
|
|
final_type = R_HPPA_11;
|
|
break;
|
|
case e_rsel:
|
|
final_type = R_HPPA_R11;
|
|
break;
|
|
case e_rssel:
|
|
final_type = R_HPPA_RS11;
|
|
break;
|
|
case e_rdsel:
|
|
final_type = R_HPPA_RD11;
|
|
break;
|
|
|
|
case e_psel:
|
|
final_type = R_HPPA_PLABEL_11;
|
|
break;
|
|
case e_rpsel:
|
|
final_type = R_HPPA_PLABEL_R11;
|
|
break;
|
|
case e_lpsel:
|
|
case e_tsel:
|
|
case e_ltsel:
|
|
case e_rtsel:
|
|
|
|
case e_lsel:
|
|
case e_lrsel:
|
|
case e_lssel:
|
|
case e_rrsel:
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case 12:
|
|
UNDEFINED;
|
|
break;
|
|
case 14:
|
|
switch (field)
|
|
{
|
|
case e_rsel:
|
|
final_type = R_HPPA_R14;
|
|
break;
|
|
case e_rssel:
|
|
final_type = R_HPPA_RS14;
|
|
break;
|
|
case e_rdsel:
|
|
final_type = R_HPPA_RD14;
|
|
break;
|
|
case e_rrsel:
|
|
final_type = R_HPPA_RR14;
|
|
break;
|
|
|
|
case e_psel:
|
|
final_type = R_HPPA_PLABEL_14;
|
|
break;
|
|
case e_rpsel:
|
|
final_type = R_HPPA_PLABEL_R14;
|
|
break;
|
|
case e_lpsel:
|
|
case e_tsel:
|
|
case e_ltsel:
|
|
case e_rtsel:
|
|
|
|
case e_fsel:
|
|
case e_lsel:
|
|
case e_lssel:
|
|
case e_ldsel:
|
|
case e_lrsel:
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case 17:
|
|
switch (field)
|
|
{
|
|
case e_fsel:
|
|
final_type = R_HPPA_17;
|
|
break;
|
|
case e_rsel:
|
|
final_type = R_HPPA_R17;
|
|
break;
|
|
case e_rssel:
|
|
final_type = R_HPPA_RS17;
|
|
break;
|
|
case e_rdsel:
|
|
final_type = R_HPPA_RD17;
|
|
break;
|
|
case e_rrsel:
|
|
final_type = R_HPPA_RR17;
|
|
break;
|
|
case e_lsel:
|
|
case e_lssel:
|
|
case e_ldsel:
|
|
case e_lrsel:
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case 21:
|
|
switch (field)
|
|
{
|
|
case e_lsel:
|
|
final_type = R_HPPA_L21;
|
|
break;
|
|
case e_lssel:
|
|
final_type = R_HPPA_LS21;
|
|
break;
|
|
case e_ldsel:
|
|
final_type = R_HPPA_LD21;
|
|
break;
|
|
case e_lrsel:
|
|
final_type = R_HPPA_LR21;
|
|
break;
|
|
case e_lpsel:
|
|
final_type = R_HPPA_PLABEL_L21;
|
|
break;
|
|
case e_rsel:
|
|
case e_rssel:
|
|
case e_rdsel:
|
|
case e_rrsel:
|
|
case e_fsel:
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case 32:
|
|
switch (field)
|
|
{
|
|
case e_fsel:
|
|
final_type = R_HPPA_32;
|
|
break;
|
|
case e_psel:
|
|
final_type = R_HPPA_PLABEL_32;
|
|
break;
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case R_HPPA_GOTOFF:
|
|
switch (format)
|
|
{
|
|
case 11:
|
|
switch (field)
|
|
{
|
|
case e_rsel:
|
|
final_type = R_HPPA_GOTOFF_R11;
|
|
break;
|
|
case e_rssel:
|
|
final_type = R_HPPA_GOTOFF_RS11;
|
|
break;
|
|
case e_rdsel:
|
|
final_type = R_HPPA_GOTOFF_RD11;
|
|
break;
|
|
case e_fsel:
|
|
final_type = R_HPPA_GOTOFF_11;
|
|
break;
|
|
case e_lsel:
|
|
case e_lrsel:
|
|
case e_lssel:
|
|
case e_rrsel:
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case 12:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
case 14:
|
|
switch (field)
|
|
{
|
|
case e_rsel:
|
|
final_type = R_HPPA_GOTOFF_R14;
|
|
break;
|
|
case e_rssel:
|
|
final_type = R_HPPA_GOTOFF_RS14;
|
|
break;
|
|
case e_rdsel:
|
|
final_type = R_HPPA_GOTOFF_RD14;
|
|
break;
|
|
case e_rrsel:
|
|
final_type = R_HPPA_GOTOFF_RR14;
|
|
break;
|
|
case e_fsel:
|
|
final_type = R_HPPA_GOTOFF_14;
|
|
break;
|
|
case e_lsel:
|
|
case e_lssel:
|
|
case e_ldsel:
|
|
case e_lrsel:
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case 17:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
case 21:
|
|
switch (field)
|
|
{
|
|
case e_lsel:
|
|
final_type = R_HPPA_GOTOFF_L21;
|
|
break;
|
|
case e_lssel:
|
|
final_type = R_HPPA_GOTOFF_LS21;
|
|
break;
|
|
case e_ldsel:
|
|
final_type = R_HPPA_GOTOFF_LD21;
|
|
break;
|
|
case e_lrsel:
|
|
final_type = R_HPPA_GOTOFF_LR21;
|
|
break;
|
|
case e_rsel:
|
|
case e_rssel:
|
|
case e_rdsel:
|
|
case e_rrsel:
|
|
case e_fsel:
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case 32:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case R_HPPA_PCREL_CALL:
|
|
switch (format)
|
|
{
|
|
case 11:
|
|
switch (field)
|
|
{
|
|
case e_rsel:
|
|
final_type = R_HPPA_PCREL_CALL_R11;
|
|
break;
|
|
case e_rssel:
|
|
final_type = R_HPPA_PCREL_CALL_RS11;
|
|
break;
|
|
case e_rdsel:
|
|
final_type = R_HPPA_PCREL_CALL_RD11;
|
|
break;
|
|
case e_fsel:
|
|
final_type = R_HPPA_PCREL_CALL_11;
|
|
break;
|
|
case e_lsel:
|
|
case e_lrsel:
|
|
case e_lssel:
|
|
case e_rrsel:
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case 12:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
case 14:
|
|
switch (field)
|
|
{
|
|
case e_rsel:
|
|
final_type = R_HPPA_PCREL_CALL_R14;
|
|
break;
|
|
case e_rssel:
|
|
final_type = R_HPPA_PCREL_CALL_RS14;
|
|
break;
|
|
case e_rdsel:
|
|
final_type = R_HPPA_PCREL_CALL_RD14;
|
|
break;
|
|
case e_rrsel:
|
|
final_type = R_HPPA_PCREL_CALL_RR14;
|
|
break;
|
|
case e_fsel:
|
|
final_type = R_HPPA_PCREL_CALL_14;
|
|
break;
|
|
case e_lsel:
|
|
case e_lssel:
|
|
case e_ldsel:
|
|
case e_lrsel:
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case 17:
|
|
switch (field)
|
|
{
|
|
case e_rsel:
|
|
final_type = R_HPPA_PCREL_CALL_R17;
|
|
break;
|
|
case e_rssel:
|
|
final_type = R_HPPA_PCREL_CALL_RS17;
|
|
break;
|
|
case e_rdsel:
|
|
final_type = R_HPPA_PCREL_CALL_RD17;
|
|
break;
|
|
case e_rrsel:
|
|
final_type = R_HPPA_PCREL_CALL_RR17;
|
|
break;
|
|
case e_fsel:
|
|
final_type = R_HPPA_PCREL_CALL_17;
|
|
break;
|
|
case e_lsel:
|
|
case e_lssel:
|
|
case e_ldsel:
|
|
case e_lrsel:
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case 21:
|
|
switch (field)
|
|
{
|
|
case e_lsel:
|
|
final_type = R_HPPA_PCREL_CALL_L21;
|
|
break;
|
|
case e_lssel:
|
|
final_type = R_HPPA_PCREL_CALL_LS21;
|
|
break;
|
|
case e_ldsel:
|
|
final_type = R_HPPA_PCREL_CALL_LD21;
|
|
break;
|
|
case e_lrsel:
|
|
final_type = R_HPPA_PCREL_CALL_LR21;
|
|
break;
|
|
case e_rsel:
|
|
case e_rssel:
|
|
case e_rdsel:
|
|
case e_rrsel:
|
|
case e_fsel:
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case 32:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case R_HPPA_PLABEL:
|
|
switch (format)
|
|
{
|
|
case 11:
|
|
switch (field)
|
|
{
|
|
case e_fsel:
|
|
final_type = R_HPPA_PLABEL_11;
|
|
break;
|
|
case e_rsel:
|
|
final_type = R_HPPA_PLABEL_R11;
|
|
break;
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case 14:
|
|
switch (field)
|
|
{
|
|
case e_fsel:
|
|
final_type = R_HPPA_PLABEL_14;
|
|
break;
|
|
case e_rsel:
|
|
final_type = R_HPPA_PLABEL_R14;
|
|
break;
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case 21:
|
|
switch (field)
|
|
{
|
|
case e_lsel:
|
|
final_type = R_HPPA_PLABEL_L21;
|
|
break;
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case 32:
|
|
switch (field)
|
|
{
|
|
case e_fsel:
|
|
final_type = R_HPPA_PLABEL_32;
|
|
break;
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
case R_HPPA_ABS_CALL:
|
|
switch (format)
|
|
{
|
|
case 11:
|
|
switch (field)
|
|
{
|
|
case e_rsel:
|
|
final_type = R_HPPA_ABS_CALL_R11;
|
|
break;
|
|
case e_rssel:
|
|
final_type = R_HPPA_ABS_CALL_RS11;
|
|
break;
|
|
case e_rdsel:
|
|
final_type = R_HPPA_ABS_CALL_RD11;
|
|
break;
|
|
case e_fsel:
|
|
final_type = R_HPPA_ABS_CALL_11;
|
|
break;
|
|
case e_lsel:
|
|
case e_lrsel:
|
|
case e_lssel:
|
|
case e_rrsel:
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case 12:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
case 14:
|
|
switch (field)
|
|
{
|
|
case e_rsel:
|
|
final_type = R_HPPA_ABS_CALL_R14;
|
|
break;
|
|
case e_rssel:
|
|
final_type = R_HPPA_ABS_CALL_RS14;
|
|
break;
|
|
case e_rdsel:
|
|
final_type = R_HPPA_ABS_CALL_RD14;
|
|
break;
|
|
case e_rrsel:
|
|
final_type = R_HPPA_ABS_CALL_RR14;
|
|
break;
|
|
case e_fsel:
|
|
final_type = R_HPPA_ABS_CALL_14;
|
|
break;
|
|
case e_lsel:
|
|
case e_lssel:
|
|
case e_ldsel:
|
|
case e_lrsel:
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case 17:
|
|
switch (field)
|
|
{
|
|
case e_rsel:
|
|
final_type = R_HPPA_ABS_CALL_R17;
|
|
break;
|
|
case e_rssel:
|
|
final_type = R_HPPA_ABS_CALL_RS17;
|
|
break;
|
|
case e_rdsel:
|
|
final_type = R_HPPA_ABS_CALL_RD17;
|
|
break;
|
|
case e_rrsel:
|
|
final_type = R_HPPA_ABS_CALL_RR17;
|
|
break;
|
|
case e_fsel:
|
|
final_type = R_HPPA_ABS_CALL_17;
|
|
break;
|
|
case e_lsel:
|
|
case e_lssel:
|
|
case e_ldsel:
|
|
case e_lrsel:
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case 21:
|
|
switch (field)
|
|
{
|
|
case e_lsel:
|
|
final_type = R_HPPA_ABS_CALL_L21;
|
|
break;
|
|
case e_lssel:
|
|
final_type = R_HPPA_ABS_CALL_LS21;
|
|
break;
|
|
case e_ldsel:
|
|
final_type = R_HPPA_ABS_CALL_LD21;
|
|
break;
|
|
case e_lrsel:
|
|
final_type = R_HPPA_ABS_CALL_LR21;
|
|
break;
|
|
case e_rsel:
|
|
case e_rssel:
|
|
case e_rdsel:
|
|
case e_rrsel:
|
|
case e_fsel:
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case 32:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
default:
|
|
UNDEFINED;
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
break;
|
|
case R_HPPA_UNWIND:
|
|
final_type = R_HPPA_UNWIND_ENTRY;
|
|
break;
|
|
case R_HPPA_COMPLEX:
|
|
case R_HPPA_COMPLEX_PCREL_CALL:
|
|
case R_HPPA_COMPLEX_ABS_CALL:
|
|
final_types = (elf32_hppa_reloc_type **) bfd_alloc_by_size_t (abfd, sizeof (elf32_hppa_reloc_type *) * 6);
|
|
BFD_ASSERT (final_types != 0);
|
|
|
|
finaltype = (elf32_hppa_reloc_type *) bfd_alloc_by_size_t (abfd, sizeof (elf32_hppa_reloc_type) * 5);
|
|
BFD_ASSERT (finaltype != 0);
|
|
|
|
for (i = 0; i < 5; i++)
|
|
final_types[i] = &finaltype[i];
|
|
|
|
final_types[5] = NULL;
|
|
|
|
finaltype[0] = R_HPPA_PUSH_SYM;
|
|
|
|
if (base_type == R_HPPA_COMPLEX)
|
|
finaltype[1] = R_HPPA_PUSH_SYM;
|
|
else if (base_type == R_HPPA_COMPLEX_PCREL_CALL)
|
|
finaltype[1] = R_HPPA_PUSH_PCREL_CALL;
|
|
else /* base_type == R_HPPA_COMPLEX_ABS_CALL */
|
|
finaltype[1] = R_HPPA_PUSH_ABS_CALL;
|
|
|
|
finaltype[2] = R_HPPA_SUB;
|
|
|
|
switch (field)
|
|
{
|
|
case e_fsel:
|
|
finaltype[3] = R_HPPA_EXPR_F;
|
|
break;
|
|
case e_lsel:
|
|
finaltype[3] = R_HPPA_EXPR_L;
|
|
break;
|
|
case e_rsel:
|
|
finaltype[3] = R_HPPA_EXPR_R;
|
|
break;
|
|
case e_lssel:
|
|
finaltype[3] = R_HPPA_EXPR_LS;
|
|
break;
|
|
case e_rssel:
|
|
finaltype[3] = R_HPPA_EXPR_RS;
|
|
break;
|
|
case e_ldsel:
|
|
finaltype[3] = R_HPPA_EXPR_LD;
|
|
break;
|
|
case e_rdsel:
|
|
finaltype[3] = R_HPPA_EXPR_RD;
|
|
break;
|
|
case e_lrsel:
|
|
finaltype[3] = R_HPPA_EXPR_LR;
|
|
break;
|
|
case e_rrsel:
|
|
finaltype[3] = R_HPPA_EXPR_RR;
|
|
break;
|
|
}
|
|
|
|
switch (format)
|
|
{
|
|
case 11:
|
|
finaltype[4] = R_HPPA_EXPR_11;
|
|
break;
|
|
case 12:
|
|
finaltype[4] = R_HPPA_EXPR_12;
|
|
break;
|
|
case 14:
|
|
finaltype[4] = R_HPPA_EXPR_14;
|
|
break;
|
|
case 17:
|
|
finaltype[4] = R_HPPA_EXPR_17;
|
|
break;
|
|
case 21:
|
|
finaltype[4] = R_HPPA_EXPR_21;
|
|
break;
|
|
case 32:
|
|
finaltype[4] = R_HPPA_EXPR_32;
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
final_type = base_type;
|
|
break;
|
|
}
|
|
|
|
return final_types;
|
|
}
|
|
|
|
#undef final_type
|
|
|
|
/* 12.4.4. Derive format from instruction
|
|
|
|
Given a machine instruction, this function determines its format.
|
|
The format can be determined solely from looking at the first six
|
|
bits (the major opcode) of the instruction. Several major opcodes
|
|
map to the same format. Opcodes which do not map to a known format
|
|
should probably be reported as an error. */
|
|
|
|
unsigned char
|
|
hppa_elf_insn2fmt (type, insn)
|
|
elf32_hppa_reloc_type type;
|
|
unsigned long insn;
|
|
{
|
|
unsigned char fmt = 0; /* XXX: is this a proper default? */
|
|
unsigned char op = get_opcode (insn);
|
|
|
|
if (type == R_HPPA_NONE)
|
|
fmt = 0;
|
|
else
|
|
{
|
|
switch (op)
|
|
{
|
|
case ADDI:
|
|
case ADDIT:
|
|
case SUBI:
|
|
fmt = 11;
|
|
break;
|
|
case MOVB:
|
|
case MOVIB:
|
|
case COMBT:
|
|
case COMBF:
|
|
case COMIBT:
|
|
case COMIBF:
|
|
case ADDBT:
|
|
case ADDBF:
|
|
case ADDIBT:
|
|
case ADDIBF:
|
|
case BVB:
|
|
case BB:
|
|
fmt = 12;
|
|
break;
|
|
case LDO:
|
|
case LDB:
|
|
case LDH:
|
|
case LDW:
|
|
case LDWM:
|
|
case STB:
|
|
case STH:
|
|
case STW:
|
|
case STWM:
|
|
fmt = 14;
|
|
break;
|
|
case BL:
|
|
case BE:
|
|
case BLE:
|
|
fmt = 17;
|
|
break;
|
|
case LDIL:
|
|
case ADDIL:
|
|
fmt = 21;
|
|
break;
|
|
default:
|
|
fmt = 32;
|
|
break;
|
|
}
|
|
|
|
}
|
|
return fmt;
|
|
}
|
|
|
|
/* this function is in charge of performing all the HP PA relocations */
|
|
static long global_value;
|
|
static long GOT_value; /* XXX: need to calculate this! For HPUX, GOT == DP */
|
|
static asymbol *global_symbol;
|
|
static int global_sym_defined;
|
|
|
|
static bfd_reloc_status_type
|
|
DEFUN (hppa_elf_reloc, (abfd, reloc_entry, symbol_in, data, input_section, output_bfd),
|
|
bfd * abfd AND
|
|
arelent * reloc_entry AND
|
|
asymbol * symbol_in AND
|
|
PTR data AND
|
|
asection * input_section AND
|
|
bfd * output_bfd)
|
|
{
|
|
unsigned long insn;
|
|
long sym_value = 0;
|
|
|
|
unsigned long addr = reloc_entry->address; /*+ input_section->vma*/
|
|
bfd_byte *hit_data = addr + (bfd_byte *) (data);
|
|
unsigned short r_type = reloc_entry->howto->type & 0xFF;
|
|
unsigned short r_field = e_fsel;
|
|
boolean r_pcrel = reloc_entry->howto->pc_relative;
|
|
|
|
/* howto->bitsize contains the format (11, 14, 21, etc) information */
|
|
unsigned r_format = reloc_entry->howto->bitsize;
|
|
long r_addend = reloc_entry->addend;
|
|
|
|
|
|
if (output_bfd)
|
|
{
|
|
/* Partial linking - do nothing */
|
|
reloc_entry->address += input_section->output_offset;
|
|
return bfd_reloc_ok;
|
|
}
|
|
|
|
if (symbol_in && symbol_in->section == &bfd_und_section)
|
|
return bfd_reloc_undefined;
|
|
|
|
/* Check for stubs that might be required. */
|
|
/* symbol_in = hppa_elf_stub_check (abfd, input_section->output_section->owner, reloc_entry); */
|
|
|
|
sym_value = get_symbol_value (symbol_in);
|
|
|
|
/* compute value of $global$ if it is there. */
|
|
|
|
if (!global_sym_defined)
|
|
{
|
|
if (global_symbol)
|
|
{
|
|
global_value = (global_symbol->value
|
|
+ global_symbol->section->output_section->vma
|
|
+ global_symbol->section->output_offset);
|
|
GOT_value = global_value; /* XXX: For HP-UX, GOT==DP */
|
|
global_sym_defined++;
|
|
}
|
|
}
|
|
|
|
/* get the instruction word */
|
|
insn = bfd_get_32 (abfd, hit_data);
|
|
|
|
/* relocate the value based on the relocation type */
|
|
|
|
/* basic_type_1: relocation is relative to $global$ */
|
|
/* basic_type_2: relocation is relative to the current GOT */
|
|
/* basic_type_3: relocation is an absolute call */
|
|
/* basic_type_4: relocation is an PC-relative call */
|
|
/* basic_type_5: relocation is plabel reference */
|
|
/* basic_type_6: relocation is an unwind table relocation */
|
|
/* extended_type: unimplemented */
|
|
|
|
switch (r_type)
|
|
{
|
|
case R_HPPA_NONE:
|
|
break;
|
|
case R_HPPA_32: /* Symbol + Addend 32 */
|
|
r_field = e_fsel;
|
|
goto do_basic_type_1;
|
|
case R_HPPA_11: /* Symbol + Addend 11 */
|
|
r_field = e_fsel;
|
|
goto do_basic_type_1;
|
|
case R_HPPA_14: /* Symbol + Addend 14 */
|
|
r_field = e_fsel;
|
|
goto do_basic_type_1;
|
|
case R_HPPA_17: /* Symbol + Addend 17 */
|
|
r_field = e_fsel;
|
|
goto do_basic_type_1;
|
|
case R_HPPA_L21: /* L (Symbol, Addend) 21 */
|
|
r_field = e_lsel;
|
|
goto do_basic_type_1;
|
|
case R_HPPA_R11: /* R (Symbol, Addend) 11 */
|
|
r_field = e_rsel;
|
|
goto do_basic_type_1;
|
|
case R_HPPA_R14: /* R (Symbol, Addend) 14 */
|
|
r_field = e_rsel;
|
|
goto do_basic_type_1;
|
|
case R_HPPA_R17: /* R (Symbol, Addend) 17 */
|
|
r_field = e_rsel;
|
|
goto do_basic_type_1;
|
|
case R_HPPA_LS21: /* LS(Symbol, Addend) 21 */
|
|
r_field = e_lssel;
|
|
goto do_basic_type_1;
|
|
case R_HPPA_RS11: /* RS(Symbol, Addend) 11 */
|
|
r_field = e_rssel;
|
|
goto do_basic_type_1;
|
|
case R_HPPA_RS14: /* RS(Symbol, Addend) 14 */
|
|
r_field = e_rssel;
|
|
goto do_basic_type_1;
|
|
case R_HPPA_RS17: /* RS(Symbol, Addend) 17 */
|
|
r_field = e_ldsel;
|
|
goto do_basic_type_1;
|
|
case R_HPPA_LD21: /* LD(Symbol, Addend) 21 */
|
|
r_field = e_ldsel;
|
|
goto do_basic_type_1;
|
|
case R_HPPA_RD11: /* RD(Symbol, Addend) 11 */
|
|
r_field = e_rdsel;
|
|
goto do_basic_type_1;
|
|
case R_HPPA_RD14: /* RD(Symbol, Addend) 14 */
|
|
r_field = e_rdsel;
|
|
goto do_basic_type_1;
|
|
case R_HPPA_RD17: /* RD(Symbol, Addend) 17 */
|
|
r_field = e_rdsel;
|
|
goto do_basic_type_1;
|
|
case R_HPPA_LR21: /* LR(Symbol, Addend) 21 */
|
|
r_field = e_lrsel;
|
|
goto do_basic_type_1;
|
|
case R_HPPA_RR14: /* RR(Symbol, Addend) 14 */
|
|
r_field = e_rrsel;
|
|
goto do_basic_type_1;
|
|
case R_HPPA_RR17: /* RR(Symbol, Addend) 17 */
|
|
r_field = e_rrsel;
|
|
|
|
do_basic_type_1:
|
|
insn = hppa_elf_relocate_insn (abfd, input_section, insn, addr,
|
|
symbol_in, sym_value, r_addend,
|
|
r_type, r_format, r_field, r_pcrel);
|
|
break;
|
|
|
|
case R_HPPA_GOTOFF_11: /* Symbol - GOT + Addend 11 */
|
|
r_field = e_fsel;
|
|
goto do_basic_type_2;
|
|
case R_HPPA_GOTOFF_14: /* Symbol - GOT + Addend 14 */
|
|
r_field = e_fsel;
|
|
goto do_basic_type_2;
|
|
case R_HPPA_GOTOFF_L21: /* L (Sym - GOT, Addend) 21 */
|
|
r_field = e_lsel;
|
|
goto do_basic_type_2;
|
|
case R_HPPA_GOTOFF_R11: /* R (Sym - GOT, Addend) 11 */
|
|
r_field = e_rsel;
|
|
goto do_basic_type_2;
|
|
case R_HPPA_GOTOFF_R14: /* R (Sym - GOT, Addend) 14 */
|
|
r_field = e_rsel;
|
|
goto do_basic_type_2;
|
|
case R_HPPA_GOTOFF_LS21: /* LS(Sym - GOT, Addend) 21 */
|
|
r_field = e_lssel;
|
|
goto do_basic_type_2;
|
|
case R_HPPA_GOTOFF_RS11: /* RS(Sym - GOT, Addend) 11 */
|
|
r_field = e_rssel;
|
|
goto do_basic_type_2;
|
|
case R_HPPA_GOTOFF_RS14: /* RS(Sym - GOT, Addend) 14 */
|
|
r_field = e_rssel;
|
|
goto do_basic_type_2;
|
|
case R_HPPA_GOTOFF_LD21: /* LD(Sym - GOT, Addend) 21 */
|
|
r_field = e_ldsel;
|
|
goto do_basic_type_2;
|
|
case R_HPPA_GOTOFF_RD11: /* RD(Sym - GOT, Addend) 11 */
|
|
r_field = e_rdsel;
|
|
goto do_basic_type_2;
|
|
case R_HPPA_GOTOFF_RD14: /* RD(Sym - GOT, Addend) 14 */
|
|
r_field = e_rdsel;
|
|
goto do_basic_type_2;
|
|
case R_HPPA_GOTOFF_LR21: /* LR(Sym - GOT, Addend) 21 */
|
|
r_field = e_lrsel;
|
|
goto do_basic_type_2;
|
|
case R_HPPA_GOTOFF_RR14: /* RR(Sym - GOT, Addend) 14 */
|
|
r_field = e_rrsel;
|
|
do_basic_type_2:
|
|
sym_value -= GOT_value;
|
|
insn = hppa_elf_relocate_insn (abfd, input_section, insn, addr,
|
|
symbol_in, sym_value, r_addend,
|
|
r_type, r_format, r_field, r_pcrel);
|
|
break;
|
|
|
|
case R_HPPA_ABS_CALL_11: /* Symbol + Addend 11 */
|
|
r_field = e_fsel;
|
|
goto do_basic_type_3;
|
|
case R_HPPA_ABS_CALL_14: /* Symbol + Addend 14 */
|
|
r_field = e_fsel;
|
|
goto do_basic_type_3;
|
|
case R_HPPA_ABS_CALL_17: /* Symbol + Addend 17 */
|
|
r_field = e_fsel;
|
|
goto do_basic_type_3;
|
|
case R_HPPA_ABS_CALL_L21: /* L (Symbol, Addend) 21 */
|
|
r_field = e_lsel;
|
|
goto do_basic_type_3;
|
|
case R_HPPA_ABS_CALL_R11: /* R (Symbol, Addend) 11 */
|
|
r_field = e_rsel;
|
|
goto do_basic_type_3;
|
|
case R_HPPA_ABS_CALL_R14: /* R (Symbol, Addend) 14 */
|
|
r_field = e_rsel;
|
|
goto do_basic_type_3;
|
|
case R_HPPA_ABS_CALL_R17: /* R (Symbol, Addend) 17 */
|
|
r_field = e_rsel;
|
|
goto do_basic_type_3;
|
|
case R_HPPA_ABS_CALL_LS21: /* LS(Symbol, Addend) 21 */
|
|
r_field = e_lssel;
|
|
goto do_basic_type_3;
|
|
case R_HPPA_ABS_CALL_RS11: /* RS(Symbol, Addend) 11 */
|
|
r_field = e_lssel;
|
|
goto do_basic_type_3;
|
|
case R_HPPA_ABS_CALL_RS14: /* RS(Symbol, Addend) 14 */
|
|
r_field = e_rssel;
|
|
goto do_basic_type_3;
|
|
case R_HPPA_ABS_CALL_RS17: /* RS(Symbol, Addend) 17 */
|
|
r_field = e_rssel;
|
|
goto do_basic_type_3;
|
|
case R_HPPA_ABS_CALL_LD21: /* LD(Symbol, Addend) 21 */
|
|
r_field = e_ldsel;
|
|
goto do_basic_type_3;
|
|
case R_HPPA_ABS_CALL_RD11: /* RD(Symbol, Addend) 11 */
|
|
r_field = e_rdsel;
|
|
goto do_basic_type_3;
|
|
case R_HPPA_ABS_CALL_RD14: /* RD(Symbol, Addend) 14 */
|
|
r_field = e_rdsel;
|
|
goto do_basic_type_3;
|
|
case R_HPPA_ABS_CALL_RD17: /* RD(Symbol, Addend) 17 */
|
|
r_field = e_rdsel;
|
|
goto do_basic_type_3;
|
|
case R_HPPA_ABS_CALL_LR21: /* LR(Symbol, Addend) 21 */
|
|
r_field = e_lrsel;
|
|
goto do_basic_type_3;
|
|
case R_HPPA_ABS_CALL_RR14: /* RR(Symbol, Addend) 14 */
|
|
r_field = e_rrsel;
|
|
goto do_basic_type_3;
|
|
case R_HPPA_ABS_CALL_RR17: /* RR(Symbol, Addend) 17 */
|
|
r_field = e_rrsel;
|
|
do_basic_type_3:
|
|
insn = hppa_elf_relocate_insn (abfd, input_section, insn, addr,
|
|
symbol_in, sym_value, r_addend,
|
|
r_type, r_format, r_field, r_pcrel);
|
|
break;
|
|
|
|
case R_HPPA_PCREL_CALL_11: /* Symbol - PC + Addend 11 */
|
|
r_field = e_fsel;
|
|
goto do_basic_type_4;
|
|
case R_HPPA_PCREL_CALL_14: /* Symbol - PC + Addend 14 */
|
|
r_field = e_fsel;
|
|
goto do_basic_type_4;
|
|
case R_HPPA_PCREL_CALL_17: /* Symbol - PC + Addend 17 */
|
|
r_field = e_fsel;
|
|
goto do_basic_type_4;
|
|
case R_HPPA_PCREL_CALL_L21:/* L (Symbol - PC, Addend) 21 */
|
|
r_field = e_lsel;
|
|
goto do_basic_type_4;
|
|
case R_HPPA_PCREL_CALL_R11:/* R (Symbol - PC, Addend) 11 */
|
|
r_field = e_rsel;
|
|
goto do_basic_type_4;
|
|
case R_HPPA_PCREL_CALL_R14:/* R (Symbol - PC, Addend) 14 */
|
|
r_field = e_rsel;
|
|
goto do_basic_type_4;
|
|
case R_HPPA_PCREL_CALL_R17:/* R (Symbol - PC, Addend) 17 */
|
|
r_field = e_rsel;
|
|
goto do_basic_type_4;
|
|
case R_HPPA_PCREL_CALL_LS21: /* LS(Symbol - PC, Addend) 21 */
|
|
r_field = e_lssel;
|
|
goto do_basic_type_4;
|
|
case R_HPPA_PCREL_CALL_RS11: /* RS(Symbol - PC, Addend) 11 */
|
|
r_field = e_rssel;
|
|
goto do_basic_type_4;
|
|
case R_HPPA_PCREL_CALL_RS14: /* RS(Symbol - PC, Addend) 14 */
|
|
r_field = e_rssel;
|
|
goto do_basic_type_4;
|
|
case R_HPPA_PCREL_CALL_RS17: /* RS(Symbol - PC, Addend) 17 */
|
|
r_field = e_rssel;
|
|
goto do_basic_type_4;
|
|
case R_HPPA_PCREL_CALL_LD21: /* LD(Symbol - PC, Addend) 21 */
|
|
r_field = e_ldsel;
|
|
goto do_basic_type_4;
|
|
case R_HPPA_PCREL_CALL_RD11: /* RD(Symbol - PC, Addend) 11 */
|
|
r_field = e_rdsel;
|
|
goto do_basic_type_4;
|
|
case R_HPPA_PCREL_CALL_RD14: /* RD(Symbol - PC, Addend) 14 */
|
|
r_field = e_rdsel;
|
|
goto do_basic_type_4;
|
|
case R_HPPA_PCREL_CALL_RD17: /* RD(Symbol - PC, Addend) 17 */
|
|
r_field = e_rdsel;
|
|
goto do_basic_type_4;
|
|
case R_HPPA_PCREL_CALL_LR21: /* LR(Symbol - PC, Addend) 21 */
|
|
r_field = e_lrsel;
|
|
goto do_basic_type_4;
|
|
case R_HPPA_PCREL_CALL_RR14: /* RR(Symbol - PC, Addend) 14 */
|
|
r_field = e_rrsel;
|
|
goto do_basic_type_4;
|
|
case R_HPPA_PCREL_CALL_RR17: /* RR(Symbol - PC, Addend) 17 *//* #69 */
|
|
r_field = e_rrsel;
|
|
do_basic_type_4:
|
|
insn = hppa_elf_relocate_insn (abfd, input_section, insn, addr,
|
|
symbol_in, sym_value, r_addend,
|
|
r_type, r_format, r_field, r_pcrel);
|
|
break;
|
|
|
|
case R_HPPA_PLABEL_32:
|
|
case R_HPPA_PLABEL_11:
|
|
case R_HPPA_PLABEL_14:
|
|
r_field = e_fsel;
|
|
goto do_basic_type_5;
|
|
case R_HPPA_PLABEL_L21:
|
|
r_field = e_lsel;
|
|
goto do_basic_type_5;
|
|
case R_HPPA_PLABEL_R11:
|
|
case R_HPPA_PLABEL_R14:
|
|
r_field = e_rsel;
|
|
do_basic_type_5:
|
|
insn = hppa_elf_relocate_insn (abfd, input_section, insn, addr,
|
|
symbol_in, sym_value, r_addend,
|
|
r_type, r_format, r_field, r_pcrel);
|
|
break;
|
|
|
|
case R_HPPA_UNWIND_ENTRY:
|
|
case R_HPPA_UNWIND_ENTRIES:
|
|
hppa_elf_relocate_unwind_table (abfd, input_section, data, addr,
|
|
symbol_in, sym_value, r_addend,
|
|
r_type, r_format, r_field, r_pcrel);
|
|
return (bfd_reloc_ok);
|
|
|
|
case R_HPPA_PUSH_CONST: /* push Addend - - */
|
|
case R_HPPA_PUSH_PC: /* push PC + Addend - - */
|
|
case R_HPPA_PUSH_SYM: /* push Symbol + Addend - - */
|
|
case R_HPPA_PUSH_GOTOFF: /* push Symbol - GOT + Addend - - */
|
|
case R_HPPA_PUSH_ABS_CALL: /* push Symbol + Addend - - */
|
|
case R_HPPA_PUSH_PCREL_CALL: /* push Symbol - PC + Addend - - */
|
|
case R_HPPA_PUSH_PLABEL: /* [TBD] - - */
|
|
case R_HPPA_MAX: /* pop A and B, push max(B,A) - - */
|
|
case R_HPPA_MIN: /* pop A and B, push min(B,A) - - */
|
|
case R_HPPA_ADD: /* pop A and B, push B + A - - */
|
|
case R_HPPA_SUB: /* pop A and B, push B - A - - */
|
|
case R_HPPA_MULT: /* pop A and B, push B * A - - */
|
|
case R_HPPA_DIV: /* pop A and B, push B / A - - */
|
|
case R_HPPA_MOD: /* pop A and B, push B % A - - */
|
|
case R_HPPA_AND: /* pop A and B, push B & A - - */
|
|
case R_HPPA_OR: /* pop A and B, push B | A - - */
|
|
case R_HPPA_XOR: /* pop A and B, push B ^ A - - */
|
|
case R_HPPA_NOT: /* pop A, push ~A - - */
|
|
case R_HPPA_LSHIFT: /* pop A, push A << Addend - - */
|
|
case R_HPPA_ARITH_RSHIFT: /* pop A, push A >> Addend - - */
|
|
case R_HPPA_LOGIC_RSHIFT: /* pop A, push A >> Addend - - */
|
|
case R_HPPA_EXPR_F: /* pop A, push A + Addend L - */
|
|
case R_HPPA_EXPR_L: /* pop A, push L(A,Addend) L - */
|
|
case R_HPPA_EXPR_R: /* pop A, push R(A,Addend) R - */
|
|
case R_HPPA_EXPR_LS: /* pop A, push LS(A,Addend) LS - */
|
|
case R_HPPA_EXPR_RS: /* pop A, push RS(A,Addend) RS - */
|
|
case R_HPPA_EXPR_LD: /* pop A, push LD(A,Addend) LD - */
|
|
case R_HPPA_EXPR_RD: /* pop A, push RD(A,Addend) RD - */
|
|
case R_HPPA_EXPR_LR: /* pop A, push LR(A,Addend) LR - */
|
|
case R_HPPA_EXPR_RR: /* pop A, push RR(A,Addend) RR - */
|
|
|
|
case R_HPPA_EXPR_32: /* pop - 32 */
|
|
case R_HPPA_EXPR_21: /* pop - 21 */
|
|
case R_HPPA_EXPR_11: /* pop - 11 */
|
|
case R_HPPA_EXPR_14: /* pop - 14 */
|
|
case R_HPPA_EXPR_17: /* pop - 17 */
|
|
case R_HPPA_EXPR_12: /* pop - 12 */
|
|
fprintf (stderr, "Relocation problem: ");
|
|
fprintf (stderr, "Unimplemented reloc type %d, in module %s\n",
|
|
r_type, abfd->filename);
|
|
return (bfd_reloc_notsupported);
|
|
case R_HPPA_STUB_CALL_17:
|
|
/* yes, a branch to a long branch stub. Change instruction to a BLE */
|
|
/* or BLE,N */
|
|
if ( *(unsigned *)hit_data & 2 )
|
|
insn = BLE_N_XXX_0_0;
|
|
else
|
|
insn = BLE_XXX_0_0;
|
|
bfd_put_32 (abfd, insn, hit_data);
|
|
r_type = R_HPPA_ABS_CALL_17;
|
|
r_pcrel = 0;
|
|
insn = hppa_elf_relocate_insn (abfd, input_section, insn, addr,
|
|
symbol_in, sym_value, r_addend,
|
|
r_type, r_format, r_field, r_pcrel);
|
|
break;
|
|
|
|
default:
|
|
fprintf (stderr, "Relocation problem : ");
|
|
fprintf (stderr, "Unrecognized reloc type %d, in module %s\n",
|
|
r_type, abfd->filename);
|
|
return (bfd_reloc_dangerous);
|
|
}
|
|
|
|
/* update the instruction word */
|
|
bfd_put_32 (abfd, insn, hit_data);
|
|
|
|
return (bfd_reloc_ok);
|
|
|
|
}
|
|
|
|
static reloc_howto_type *
|
|
elf_hppa_reloc_type_lookup (arch, code)
|
|
bfd_arch_info_type *arch;
|
|
bfd_reloc_code_real_type code;
|
|
{
|
|
if ((int) code < (int) R_HPPA_UNIMPLEMENTED)
|
|
{
|
|
BFD_ASSERT ((int) elf_hppa_howto_table[(int) code].type == (int) code);
|
|
return &elf_hppa_howto_table[(int) code];
|
|
}
|
|
|
|
return (reloc_howto_type *) 0;
|
|
}
|
|
|
|
#define bfd_elf32_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
|
|
|
|
|
|
void
|
|
DEFUN (elf_hppa_tc_symbol, (abfd, symbolP, sym_idx),
|
|
bfd * abfd AND
|
|
elf_symbol_type * symbolP AND
|
|
int sym_idx)
|
|
{
|
|
symext_chainS *symextP;
|
|
unsigned int arg_reloc;
|
|
|
|
/* Only functions can have argument relocations. */
|
|
if (!(symbolP->symbol.flags & BSF_FUNCTION))
|
|
return;
|
|
|
|
arg_reloc = symbolP->tc_data.hppa_arg_reloc;
|
|
|
|
/* If there are no argument relocation bits, then no relocation is
|
|
necessary. Do not add this to the symextn section. */
|
|
if (arg_reloc == 0)
|
|
return;
|
|
|
|
symextP = (symext_chainS *) bfd_alloc (abfd, sizeof (symext_chainS) * 2);
|
|
|
|
symextP[0].entry = ELF32_HPPA_SX_WORD (HPPA_SXT_SYMNDX, sym_idx);
|
|
symextP[0].next = &symextP[1];
|
|
|
|
symextP[1].entry = ELF32_HPPA_SX_WORD (HPPA_SXT_ARG_RELOC, arg_reloc);
|
|
symextP[1].next = NULL;
|
|
|
|
if (symext_rootP == NULL)
|
|
{
|
|
symext_rootP = &symextP[0];
|
|
symext_lastP = &symextP[1];
|
|
}
|
|
else
|
|
{
|
|
symext_lastP->next = &symextP[0];
|
|
symext_lastP = &symextP[1];
|
|
}
|
|
}
|
|
|
|
/* Accessor function for the list of symbol extension records. */
|
|
symext_chainS *elf32_hppa_get_symextn_chain()
|
|
{
|
|
return symext_rootP;
|
|
}
|
|
|
|
static symext_entryS *symextn_contents;
|
|
static unsigned int symextn_contents_real_size;
|
|
|
|
void
|
|
DEFUN (elf_hppa_tc_make_sections, (abfd, ignored),
|
|
bfd * abfd AND
|
|
PTR ignored)
|
|
{
|
|
symext_chainS *symextP;
|
|
int size;
|
|
int n;
|
|
int i;
|
|
void hppa_elf_stub_finish (); /* forward declaration */
|
|
asection *symextn_sec;
|
|
|
|
hppa_elf_stub_finish (abfd);
|
|
|
|
if (symext_rootP == NULL)
|
|
return;
|
|
|
|
for (n = 0, symextP = symext_rootP; symextP; symextP = symextP->next, ++n)
|
|
;
|
|
|
|
size = sizeof (symext_entryS) * n;
|
|
symextn_sec = bfd_get_section_by_name (abfd, SYMEXTN_SECTION_NAME);
|
|
if (symextn_sec == (asection *) 0)
|
|
{
|
|
symextn_sec = bfd_make_section (abfd, SYMEXTN_SECTION_NAME);
|
|
bfd_set_section_flags (abfd,
|
|
symextn_sec,
|
|
SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC | SEC_CODE | SEC_READONLY);
|
|
symextn_sec->output_section = symextn_sec;
|
|
symextn_sec->output_offset = 0;
|
|
bfd_set_section_alignment (abfd, symextn_sec, 2);
|
|
}
|
|
symextn_contents = (symext_entryS *) bfd_alloc (abfd, size);
|
|
|
|
for (i = 0, symextP = symext_rootP; symextP; symextP = symextP->next, ++i)
|
|
symextn_contents[i] = symextP->entry;
|
|
symextn_contents_real_size = size;
|
|
bfd_set_section_size (abfd, symextn_sec, symextn_contents_real_size);
|
|
|
|
return;
|
|
}
|
|
|
|
/* Support for HP PA-RISC stub generation.
|
|
|
|
Written by
|
|
|
|
Center for Software Science
|
|
Department of Computer Science
|
|
University of Utah
|
|
|
|
*/
|
|
|
|
/*
|
|
HP-PA calling conventions state:
|
|
|
|
1. an argument relocation stub is required whenever the callee and
|
|
caller argument relocation bits do not match exactly. The exception
|
|
to this rule is if either the caller or callee argument relocation
|
|
bit are 00 (do not relocate).
|
|
|
|
2. The linker can optionally add a symbol record for the stub so that
|
|
the stub can be reused. The symbol record will be the same as the
|
|
original export symbol record, except that the relocation bits will
|
|
reflect the input of the stub, the type would be STUB and the symbol
|
|
value will be the location of the relocation stub.
|
|
|
|
Other notes:
|
|
|
|
Stubs can be inserted *before* the section of the caller. The stubs
|
|
can be treated as calls to code that manipulates the arguments.
|
|
|
|
*/
|
|
|
|
typedef enum
|
|
{
|
|
HPPA_STUB_ILLEGAL,
|
|
HPPA_STUB_ARG_RELOC,
|
|
HPPA_STUB_LONG_BRANCH
|
|
} hppa_stub_type;
|
|
|
|
symext_entryS
|
|
elf32_hppa_get_sym_extn (abfd, sym, type)
|
|
bfd *abfd;
|
|
asymbol *sym;
|
|
int type;
|
|
{
|
|
/* This function finds the symbol extension record of the */
|
|
/* specified type for the specified symbol. It returns the */
|
|
/* value of the symbol extension record. */
|
|
symext_entryS retval;
|
|
|
|
switch (type)
|
|
{
|
|
case HPPA_SXT_NULL:
|
|
retval = (symext_entryS) 0;
|
|
break;
|
|
case HPPA_SXT_SYMNDX:
|
|
retval = (symext_entryS) 0; /* XXX: need to fix this */
|
|
break;
|
|
case HPPA_SXT_ARG_RELOC:
|
|
{
|
|
elf_symbol_type *esymP = (elf_symbol_type *) sym;
|
|
|
|
retval = (symext_entryS) esymP->tc_data.hppa_arg_reloc;
|
|
break;
|
|
}
|
|
/* This should never happen. */
|
|
default:
|
|
abort();
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
typedef struct elf32_hppa_stub_name_list_struct
|
|
{
|
|
/* name of this stub */
|
|
asymbol *sym;
|
|
/* stub description for this stub */
|
|
struct elf32_hppa_stub_description_struct *stub_desc;
|
|
/* pointer into stub contents */
|
|
int *stub_secp;
|
|
/* size of this stub */
|
|
unsigned size;
|
|
/* next stub name entry */
|
|
struct elf32_hppa_stub_name_list_struct *next;
|
|
} elf32_hppa_stub_name_list;
|
|
|
|
typedef struct elf32_hppa_stub_description_struct
|
|
{
|
|
struct elf32_hppa_stub_description_struct *next;
|
|
bfd *this_bfd; /* bfd to which this stub applies */
|
|
asection *stub_sec; /* stub section for this bfd */
|
|
unsigned relocs_allocated_cnt; /* count of relocations for this stub section */
|
|
unsigned real_size;
|
|
unsigned allocated_size;
|
|
int *stub_secp; /* pointer to the next available location in the buffer */
|
|
char *stub_contents; /* contents of the stubs for this bfd */
|
|
elf32_hppa_stub_name_list *stub_listP;
|
|
}
|
|
elf32_hppa_stub_description;
|
|
|
|
static elf32_hppa_stub_description *elf_hppa_stub_rootP;
|
|
|
|
/* Locate the stub section information for the given bfd. */
|
|
static elf32_hppa_stub_description *
|
|
find_stubs (abfd, stub_sec)
|
|
bfd *abfd;
|
|
asection *stub_sec;
|
|
{
|
|
elf32_hppa_stub_description *stubP;
|
|
|
|
for (stubP = elf_hppa_stub_rootP; stubP; stubP = stubP->next)
|
|
{
|
|
if (stubP->this_bfd == abfd
|
|
&& stubP->stub_sec == stub_sec)
|
|
return stubP;
|
|
}
|
|
|
|
return (elf32_hppa_stub_description *) NULL;
|
|
}
|
|
|
|
static elf32_hppa_stub_description *
|
|
new_stub (abfd, stub_sec)
|
|
bfd *abfd;
|
|
asection *stub_sec;
|
|
{
|
|
elf32_hppa_stub_description *stub = find_stubs (abfd, stub_sec);
|
|
|
|
if (stub)
|
|
return stub;
|
|
|
|
stub = (elf32_hppa_stub_description *) bfd_zalloc (abfd, sizeof (elf32_hppa_stub_description));
|
|
if (stub)
|
|
{
|
|
stub->this_bfd = abfd;
|
|
stub->stub_sec = stub_sec;
|
|
stub->real_size = 0;
|
|
stub->allocated_size = 0;
|
|
stub->stub_contents = NULL;
|
|
stub->stub_secp = NULL;
|
|
|
|
stub->next = elf_hppa_stub_rootP;
|
|
elf_hppa_stub_rootP = stub;
|
|
}
|
|
else
|
|
{
|
|
bfd_error = no_memory;
|
|
bfd_perror ("new_stub");
|
|
}
|
|
|
|
return stub;
|
|
}
|
|
|
|
/* Locate the stub by the given name. */
|
|
static elf32_hppa_stub_name_list *
|
|
find_stub_by_name (abfd, stub_sec, name)
|
|
bfd *abfd;
|
|
asection *stub_sec;
|
|
char *name;
|
|
{
|
|
elf32_hppa_stub_description *stub = find_stubs (abfd, stub_sec);
|
|
|
|
if (stub)
|
|
{
|
|
elf32_hppa_stub_name_list *name_listP;
|
|
|
|
for (name_listP = stub->stub_listP; name_listP; name_listP = name_listP->next)
|
|
{
|
|
if (!strcmp (name_listP->sym->name, name))
|
|
return name_listP;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Locate the stub by the given name. */
|
|
static elf32_hppa_stub_name_list *
|
|
add_stub_by_name(abfd, stub_sec, sym)
|
|
bfd *abfd;
|
|
asection *stub_sec;
|
|
asymbol *sym;
|
|
{
|
|
elf32_hppa_stub_description *stub = find_stubs (abfd, stub_sec);
|
|
elf32_hppa_stub_name_list *stub_entry;
|
|
|
|
if (!stub)
|
|
stub = new_stub(abfd, stub_sec);
|
|
|
|
if (stub)
|
|
{
|
|
stub_entry = (elf32_hppa_stub_name_list *)
|
|
bfd_zalloc (abfd, sizeof (elf32_hppa_stub_name_list));
|
|
|
|
if (stub_entry)
|
|
{
|
|
stub_entry->size = 0;
|
|
stub_entry->sym = sym;
|
|
stub_entry->stub_desc = stub;
|
|
/* First byte of this stub is the pointer to
|
|
the next available location in the stub buffer. */
|
|
stub_entry->stub_secp = stub->stub_secp;
|
|
if (stub->stub_listP)
|
|
stub_entry->next = stub->stub_listP;
|
|
else
|
|
stub_entry->next = NULL;
|
|
stub->stub_listP = stub_entry;
|
|
return stub_entry;
|
|
}
|
|
else
|
|
{
|
|
bfd_error = no_memory;
|
|
bfd_perror("add_stub_by_name");
|
|
}
|
|
}
|
|
|
|
return (elf32_hppa_stub_name_list *)NULL;
|
|
}
|
|
|
|
#define ARGUMENTS 0
|
|
#define RETURN_VALUE 1
|
|
|
|
#define NO_ARG_RELOC 0
|
|
#define R_TO_FR 1
|
|
#define R01_TO_FR 2
|
|
#define R23_TO_FR 3
|
|
#define FR_TO_R 4
|
|
#define FR_TO_R01 5
|
|
#define FR_TO_R23 6
|
|
#define ARG_RELOC_ERR 7
|
|
|
|
#define ARG0 0
|
|
#define ARG1 1
|
|
#define ARG2 2
|
|
#define ARG3 3
|
|
#define RETVAL 4
|
|
|
|
#define AR_NO 0
|
|
#define AR_GR 1
|
|
#define AR_FR 2
|
|
#define AR_FU 3
|
|
/* FP register in arg0/arg1. This value can only appear in the arg0 location. */
|
|
#define AR_DBL01 4
|
|
/* FP register in arg2/arg3. This value can only appear in the arg2 location. */
|
|
#define AR_DBL23 5
|
|
|
|
#define AR_WARN(type,loc) \
|
|
fprintf(stderr,"WARNING: Illegal argument relocation: %s for %s\n", \
|
|
reloc_type_strings[type],reloc_loc_strings[loc])
|
|
|
|
static CONST char *CONST reloc_type_strings[] =
|
|
{
|
|
"NONE", "GR->FR", "GR0,GR1->FR1", "GR2,GR3->FR3", "FR->GR", "FR->GR0,GR1", "FR->GR2,GR3", "ERROR"
|
|
};
|
|
|
|
static CONST char *CONST reloc_loc_strings[] =
|
|
{
|
|
"ARG0", "ARG1", "ARG2", "ARG3", "RETVAL"
|
|
};
|
|
|
|
static CONST char mismatches[6][6] =
|
|
{ /* CALLEE NONE CALLEE GR CALLEE FR CALLEE FU CALLEE DBL01 CALLEE DBL23 */
|
|
/* CALLER NONE */
|
|
{NO_ARG_RELOC, NO_ARG_RELOC, NO_ARG_RELOC, ARG_RELOC_ERR, NO_ARG_RELOC, NO_ARG_RELOC},
|
|
/* CALLER GR */
|
|
{NO_ARG_RELOC, NO_ARG_RELOC, R_TO_FR, ARG_RELOC_ERR, R01_TO_FR, ARG_RELOC_ERR},
|
|
/* CALLER FR */
|
|
{NO_ARG_RELOC, FR_TO_R, NO_ARG_RELOC, ARG_RELOC_ERR, ARG_RELOC_ERR},
|
|
/* CALLER FU */
|
|
{ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR},
|
|
/* CALLER DBL01 */
|
|
{NO_ARG_RELOC, FR_TO_R01, NO_ARG_RELOC, ARG_RELOC_ERR, NO_ARG_RELOC, ARG_RELOC_ERR},
|
|
/* CALLER DBL23 */
|
|
{NO_ARG_RELOC, FR_TO_R23, NO_ARG_RELOC, ARG_RELOC_ERR, ARG_RELOC_ERR, NO_ARG_RELOC},
|
|
};
|
|
|
|
static CONST char retval_mismatches[6][6] =
|
|
{ /* CALLEE NONE CALLEE GR CALLEE FR CALLEE FU CALLEE DBL01 CALLEE DBL23 */
|
|
/* CALLER NONE */
|
|
{NO_ARG_RELOC, NO_ARG_RELOC, NO_ARG_RELOC, ARG_RELOC_ERR, NO_ARG_RELOC, NO_ARG_RELOC},
|
|
/* CALLER GR */
|
|
{NO_ARG_RELOC, NO_ARG_RELOC, FR_TO_R, ARG_RELOC_ERR, FR_TO_R01, ARG_RELOC_ERR},
|
|
/* CALLER FR */
|
|
{NO_ARG_RELOC, R_TO_FR, NO_ARG_RELOC, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR},
|
|
/* CALLER FU */
|
|
{ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR},
|
|
/* CALLER DBL01 */
|
|
{NO_ARG_RELOC, R01_TO_FR, NO_ARG_RELOC, ARG_RELOC_ERR, NO_ARG_RELOC, ARG_RELOC_ERR},
|
|
/* CALLER DBL23 */
|
|
{NO_ARG_RELOC, R23_TO_FR, NO_ARG_RELOC, ARG_RELOC_ERR, ARG_RELOC_ERR, NO_ARG_RELOC},
|
|
};
|
|
|
|
static int
|
|
type_of_mismatch (caller_bits, callee_bits, type)
|
|
int caller_bits;
|
|
int callee_bits;
|
|
int type;
|
|
{
|
|
switch (type)
|
|
{
|
|
case ARGUMENTS:
|
|
return mismatches[caller_bits][callee_bits];
|
|
case RETURN_VALUE:
|
|
return retval_mismatches[caller_bits][callee_bits];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#define EXTRACT_ARBITS(ar,which) ((ar) >> (8-(which*2))) & 3
|
|
|
|
#define NEW_INSTRUCTION(entry,insn) \
|
|
*((entry)->stub_desc->stub_secp)++ = (insn); \
|
|
(entry)->stub_desc->real_size += sizeof(int); \
|
|
(entry)->size += sizeof(int); \
|
|
bfd_set_section_size((entry)->stub_desc->this_bfd, \
|
|
(entry)->stub_desc->stub_sec, \
|
|
(entry)->stub_desc->real_size);
|
|
|
|
#define CURRENT_STUB_OFFSET(entry) \
|
|
((int)(entry)->stub_desc->stub_secp - (int)(entry)->stub_desc->stub_contents - 4)
|
|
|
|
static boolean stubs_finished = false;
|
|
|
|
void
|
|
hppa_elf_stub_finish (output_bfd)
|
|
bfd *output_bfd;
|
|
{
|
|
extern bfd_error_vector_type bfd_error_vector;
|
|
elf32_hppa_stub_description *stub_list = elf_hppa_stub_rootP;
|
|
/* All the stubs have been built. Finish up building */
|
|
/* stub section. Apply relocations to the section. */
|
|
|
|
if ( stubs_finished )
|
|
return;
|
|
|
|
for (; stub_list; stub_list = stub_list->next)
|
|
{
|
|
if (stub_list->real_size)
|
|
{
|
|
bfd *stub_bfd = stub_list->this_bfd;
|
|
asection *stub_sec = bfd_get_section_by_name (stub_bfd, ".hppa_linker_stubs");
|
|
bfd_size_type reloc_size;
|
|
arelent **reloc_vector;
|
|
|
|
BFD_ASSERT (stub_sec == stub_list->stub_sec);
|
|
reloc_size = bfd_get_reloc_upper_bound (stub_bfd, stub_sec);
|
|
reloc_vector = (arelent **) alloca (reloc_size);
|
|
|
|
BFD_ASSERT (stub_sec);
|
|
|
|
/* We are not relaxing the section, so just copy the size info */
|
|
stub_sec->_cooked_size = stub_sec->_raw_size;
|
|
stub_sec->reloc_done = true;
|
|
|
|
|
|
if (bfd_canonicalize_reloc (stub_bfd,
|
|
stub_sec,
|
|
reloc_vector,
|
|
output_bfd->outsymbols))
|
|
{
|
|
arelent **parent;
|
|
for (parent = reloc_vector; *parent != (arelent *) NULL;
|
|
parent++)
|
|
{
|
|
bfd_reloc_status_type r =
|
|
bfd_perform_relocation (stub_bfd,
|
|
*parent,
|
|
stub_list->stub_contents,
|
|
stub_sec, 0);
|
|
|
|
|
|
if (r != bfd_reloc_ok)
|
|
{
|
|
switch (r)
|
|
{
|
|
case bfd_reloc_undefined:
|
|
bfd_error_vector.undefined_symbol (*parent, NULL);
|
|
break;
|
|
case bfd_reloc_dangerous:
|
|
bfd_error_vector.reloc_dangerous (*parent, NULL);
|
|
break;
|
|
case bfd_reloc_outofrange:
|
|
case bfd_reloc_overflow:
|
|
bfd_error_vector.reloc_value_truncated (*parent, NULL);
|
|
break;
|
|
default:
|
|
abort ();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bfd_set_section_contents (output_bfd,
|
|
stub_sec,
|
|
stub_list->stub_contents,
|
|
0,
|
|
stub_list->real_size);
|
|
|
|
free (reloc_vector);
|
|
}
|
|
}
|
|
stubs_finished = true;
|
|
}
|
|
|
|
void
|
|
hppa_elf_stub_branch_reloc (stub_desc, /* the bfd */
|
|
output_bfd, /* the output bfd */
|
|
target_sym, /* the target symbol */
|
|
offset) /* the offset within the stub buffer (pre-calculated) */
|
|
elf32_hppa_stub_description *stub_desc;
|
|
bfd *output_bfd;
|
|
asymbol *target_sym;
|
|
int offset;
|
|
{
|
|
/* Allocate a new relocation entry. */
|
|
arelent relent;
|
|
int size;
|
|
|
|
if (stub_desc->relocs_allocated_cnt == stub_desc->stub_sec->reloc_count)
|
|
{
|
|
if (stub_desc->stub_sec->relocation == NULL)
|
|
{
|
|
stub_desc->relocs_allocated_cnt = STUB_RELOC_INCR;
|
|
size = sizeof (arelent) * stub_desc->relocs_allocated_cnt;
|
|
stub_desc->stub_sec->relocation = (arelent *) zalloc (size);
|
|
}
|
|
else
|
|
{
|
|
stub_desc->relocs_allocated_cnt += STUB_RELOC_INCR;
|
|
size = sizeof (arelent) * stub_desc->relocs_allocated_cnt;
|
|
stub_desc->stub_sec->relocation = (arelent *) realloc (stub_desc->stub_sec->relocation,
|
|
size);
|
|
}
|
|
}
|
|
|
|
/* Fill in the details. */
|
|
relent.address = offset;
|
|
relent.addend = 0;
|
|
relent.sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd, sizeof (asymbol *));
|
|
BFD_ASSERT (relent.sym_ptr_ptr);
|
|
|
|
relent.sym_ptr_ptr[0] = target_sym;
|
|
relent.howto = bfd_reloc_type_lookup (stub_desc->this_bfd, R_HPPA_PCREL_CALL_17);
|
|
|
|
/* Save it in the array of relocations for the stub section. */
|
|
|
|
memcpy (&stub_desc->stub_sec->relocation[stub_desc->stub_sec->reloc_count++],
|
|
&relent,
|
|
sizeof (arelent));
|
|
}
|
|
|
|
void
|
|
hppa_elf_stub_reloc (stub_desc, /* the bfd */
|
|
output_bfd, /* the output bfd */
|
|
target_sym, /* the target symbol */
|
|
offset, /* the offset within the stub buffer (pre-calculated) */
|
|
type)
|
|
elf32_hppa_stub_description *stub_desc;
|
|
bfd *output_bfd;
|
|
asymbol *target_sym;
|
|
int offset;
|
|
elf32_hppa_reloc_type type;
|
|
{
|
|
/* Allocate a new relocation entry. */
|
|
arelent relent;
|
|
int size;
|
|
Elf_Internal_Shdr *rela_hdr;
|
|
|
|
if (stub_desc->relocs_allocated_cnt == stub_desc->stub_sec->reloc_count)
|
|
{
|
|
if (stub_desc->stub_sec->relocation == NULL)
|
|
{
|
|
stub_desc->relocs_allocated_cnt = STUB_RELOC_INCR;
|
|
size = sizeof (arelent) * stub_desc->relocs_allocated_cnt;
|
|
stub_desc->stub_sec->relocation = (arelent *) zalloc (size);
|
|
}
|
|
else
|
|
{
|
|
stub_desc->relocs_allocated_cnt += STUB_RELOC_INCR;
|
|
size = sizeof (arelent) * stub_desc->relocs_allocated_cnt;
|
|
stub_desc->stub_sec->relocation = (arelent *) realloc (stub_desc->stub_sec->relocation,
|
|
size);
|
|
}
|
|
}
|
|
|
|
rela_hdr = &elf_section_data(stub_desc->stub_sec)->rel_hdr;
|
|
rela_hdr->sh_size += sizeof(Elf32_External_Rela);
|
|
|
|
/* Fill in the details. */
|
|
relent.address = offset;
|
|
relent.addend = 0;
|
|
relent.sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd, sizeof (asymbol *));
|
|
BFD_ASSERT (relent.sym_ptr_ptr);
|
|
|
|
relent.sym_ptr_ptr[0] = target_sym;
|
|
relent.howto = bfd_reloc_type_lookup (stub_desc->this_bfd, type);
|
|
|
|
/* Save it in the array of relocations for the stub section. */
|
|
|
|
memcpy (&stub_desc->stub_sec->relocation[stub_desc->stub_sec->reloc_count++],
|
|
&relent,
|
|
sizeof (arelent));
|
|
}
|
|
|
|
asymbol *
|
|
hppa_elf_build_arg_reloc_stub (abfd, output_bfd, reloc_entry, stub_types)
|
|
bfd *abfd;
|
|
bfd *output_bfd;
|
|
arelent *reloc_entry;
|
|
int stub_types[5];
|
|
{
|
|
asection *stub_sec = bfd_get_section_by_name (abfd, ".hppa_linker_stubs");
|
|
elf32_hppa_stub_description *stub_desc = find_stubs (abfd, stub_sec);
|
|
asymbol *stub_sym = NULL;
|
|
asymbol *target_sym = reloc_entry->sym_ptr_ptr[0];
|
|
asection *output_text_section = bfd_get_section_by_name (output_bfd, ".text");
|
|
int i;
|
|
char stub_sym_name[128];
|
|
elf32_hppa_stub_name_list *stub_entry;
|
|
|
|
if (!stub_sec)
|
|
{
|
|
BFD_ASSERT (stub_desc == NULL);
|
|
stub_sec = bfd_make_section (abfd, ".hppa_linker_stubs");
|
|
bfd_set_section_flags (abfd,
|
|
stub_sec,
|
|
SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_READONLY);
|
|
stub_sec->output_section = output_text_section->output_section;
|
|
stub_sec->output_offset = 0;
|
|
bfd_set_section_alignment (abfd, stub_sec, 2);
|
|
stub_desc = new_stub (abfd, stub_sec);
|
|
}
|
|
|
|
/* make sure we have a stub descriptor structure */
|
|
|
|
if (!stub_desc)
|
|
stub_desc = new_stub (abfd, stub_sec);
|
|
|
|
/* allocate some space to write the stub */
|
|
|
|
if (!stub_desc->stub_contents)
|
|
{
|
|
stub_desc->allocated_size = STUB_BUFFER_INCR;
|
|
stub_desc->stub_contents = (char *) xmalloc (STUB_BUFFER_INCR);
|
|
}
|
|
else if ((stub_desc->allocated_size - stub_desc->real_size) < STUB_MAX_SIZE)
|
|
{
|
|
stub_desc->allocated_size = stub_desc->allocated_size + STUB_BUFFER_INCR;
|
|
stub_desc->stub_contents = (char *) xrealloc (stub_desc->stub_contents,
|
|
stub_desc->allocated_size);
|
|
}
|
|
|
|
stub_desc->stub_secp = (int *) (stub_desc->stub_contents + stub_desc->real_size);
|
|
|
|
sprintf (stub_sym_name,
|
|
"_stub_%s_%02d_%02d_%02d_%02d_%02d",
|
|
reloc_entry->sym_ptr_ptr[0]->name,
|
|
stub_types[0], stub_types[1], stub_types[2], stub_types[3], stub_types[4]);
|
|
stub_entry = find_stub_by_name(abfd, stub_sec, stub_sym_name);
|
|
|
|
if (stub_entry)
|
|
{
|
|
stub_sym = stub_entry->sym;
|
|
/* redirect the original relocation from the old symbol (a function) */
|
|
/* to the stub (the stub calls the function). */
|
|
/* XXX do we need to change the relocation type? */
|
|
reloc_entry->sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd, sizeof (asymbol *));
|
|
reloc_entry->sym_ptr_ptr[0] = stub_sym;
|
|
}
|
|
else
|
|
{
|
|
/* Stub does not already exist. Create a new stub. */
|
|
/* Create a new symbol to point to this stub */
|
|
stub_sym = bfd_make_empty_symbol (abfd);
|
|
stub_sym->name = bfd_zalloc (abfd, strlen (stub_sym_name) + 1);
|
|
strcpy ((char *) stub_sym->name, stub_sym_name);
|
|
stub_sym->value = (int) stub_desc->stub_secp - (int) stub_desc->stub_contents;
|
|
stub_sym->section = stub_sec;
|
|
stub_sym->flags = BSF_LOCAL | BSF_FUNCTION;
|
|
stub_entry = add_stub_by_name(abfd, stub_sec, stub_sym);
|
|
|
|
/* redirect the original relocation from the old symbol (a function) */
|
|
/* to the stub (the stub calls the function). */
|
|
/* XXX do we need to change the relocation type? */
|
|
reloc_entry->sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd, sizeof (asymbol *));
|
|
reloc_entry->sym_ptr_ptr[0] = stub_sym;
|
|
|
|
/* generate the beginning common section for all stubs */
|
|
|
|
NEW_INSTRUCTION (stub_entry, ADDI_8_SP);
|
|
|
|
/* generate the code to move the arguments around */
|
|
for (i = ARG0; i < ARG3; i++)
|
|
{
|
|
if (stub_types[i] != NO_ARG_RELOC)
|
|
{
|
|
/* A stub is needed */
|
|
switch (stub_types[i])
|
|
{
|
|
case R_TO_FR:
|
|
switch (i)
|
|
{
|
|
case ARG0:
|
|
NEW_INSTRUCTION (stub_entry, STWS_ARG0_M8SP);
|
|
NEW_INSTRUCTION (stub_entry, FLDWS_M8SP_FARG0);
|
|
break;
|
|
case ARG1:
|
|
NEW_INSTRUCTION (stub_entry, STWS_ARG1_M8SP);
|
|
NEW_INSTRUCTION (stub_entry, FLDWS_M8SP_FARG1);
|
|
break;
|
|
case ARG2:
|
|
NEW_INSTRUCTION (stub_entry, STWS_ARG2_M8SP);
|
|
NEW_INSTRUCTION (stub_entry, FLDWS_M8SP_FARG2);
|
|
break;
|
|
case ARG3:
|
|
NEW_INSTRUCTION (stub_entry, STWS_ARG3_M8SP);
|
|
NEW_INSTRUCTION (stub_entry, FLDWS_M8SP_FARG3);
|
|
break;
|
|
}
|
|
continue;
|
|
|
|
case R01_TO_FR:
|
|
switch (i)
|
|
{
|
|
case ARG0:
|
|
NEW_INSTRUCTION(stub_entry, STWS_ARG0_M4SP);
|
|
NEW_INSTRUCTION(stub_entry, STWS_ARG1_M8SP);
|
|
NEW_INSTRUCTION(stub_entry, FLDDS_M8SP_FARG1);
|
|
break;
|
|
default:
|
|
AR_WARN(stub_types[i],i);
|
|
break;
|
|
}
|
|
continue;
|
|
|
|
case R23_TO_FR:
|
|
switch (i)
|
|
{
|
|
case ARG2:
|
|
NEW_INSTRUCTION(stub_entry, STWS_ARG2_M4SP);
|
|
NEW_INSTRUCTION(stub_entry, STWS_ARG3_M8SP);
|
|
NEW_INSTRUCTION(stub_entry, FLDDS_M8SP_FARG3);
|
|
break;
|
|
default:
|
|
AR_WARN(stub_types[i],i);
|
|
break;
|
|
}
|
|
continue;
|
|
|
|
case FR_TO_R:
|
|
switch (i)
|
|
{
|
|
case ARG0:
|
|
NEW_INSTRUCTION (stub_entry, FSTWS_FARG0_M8SP);
|
|
NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG0);
|
|
break;
|
|
case ARG1:
|
|
NEW_INSTRUCTION (stub_entry, FSTWS_FARG1_M8SP);
|
|
NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG1);
|
|
break;
|
|
case ARG2:
|
|
NEW_INSTRUCTION (stub_entry, FSTWS_FARG2_M8SP);
|
|
NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG2);
|
|
break;
|
|
case ARG3:
|
|
NEW_INSTRUCTION (stub_entry, FSTWS_FARG3_M8SP);
|
|
NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG3);
|
|
break;
|
|
}
|
|
continue;
|
|
|
|
case FR_TO_R01:
|
|
switch (i)
|
|
{
|
|
case ARG0:
|
|
NEW_INSTRUCTION(stub_entry, FSTDS_FARG1_M8SP);
|
|
NEW_INSTRUCTION(stub_entry, LDWS_M4SP_ARG0);
|
|
NEW_INSTRUCTION(stub_entry, LDWS_M8SP_ARG1);
|
|
break;
|
|
default:
|
|
AR_WARN(stub_types[i],i);
|
|
break;
|
|
}
|
|
continue;
|
|
|
|
case FR_TO_R23:
|
|
switch (i)
|
|
{
|
|
case ARG2:
|
|
NEW_INSTRUCTION(stub_entry, FSTDS_FARG3_M8SP);
|
|
NEW_INSTRUCTION(stub_entry, LDWS_M4SP_ARG2);
|
|
NEW_INSTRUCTION(stub_entry, LDWS_M8SP_ARG3);
|
|
break;
|
|
default:
|
|
AR_WARN(stub_types[i],i);
|
|
break;
|
|
}
|
|
continue;
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
NEW_INSTRUCTION (stub_entry, ADDI_M8_SP);
|
|
|
|
/* generate the branch to the target routine */
|
|
NEW_INSTRUCTION (stub_entry, STW_RP_M8SP); /* First, save the return address */
|
|
|
|
/* Branch to the target function. */
|
|
/* (Make it a long call, so we do not */
|
|
/* have to worry about generating a */
|
|
/* long call stub.) */
|
|
NEW_INSTRUCTION(stub_entry, LDIL_XXX_31);
|
|
hppa_elf_stub_reloc (stub_entry->stub_desc,
|
|
abfd, /* the output bfd */
|
|
target_sym, /* the target symbol */
|
|
CURRENT_STUB_OFFSET(stub_entry), /* offset in stub buffer */
|
|
R_HPPA_L21);
|
|
NEW_INSTRUCTION(stub_entry,BLE_XXX_0_31);
|
|
hppa_elf_stub_reloc (stub_entry->stub_desc,
|
|
abfd, /* the output bfd */
|
|
target_sym, /* the target symbol */
|
|
CURRENT_STUB_OFFSET(stub_entry), /* offset in stub buffer */
|
|
R_HPPA_ABS_CALL_R17);
|
|
NEW_INSTRUCTION(stub_entry,COPY_31_2);
|
|
|
|
/* generate the code to move the return value around */
|
|
|
|
NEW_INSTRUCTION (stub_entry, LDW_M8SP_RP); /* restore return address */
|
|
|
|
i = RETVAL;
|
|
if (stub_types[i] != NO_ARG_RELOC)
|
|
{
|
|
/* A stub is needed */
|
|
switch (stub_types[i])
|
|
{
|
|
case R_TO_FR:
|
|
NEW_INSTRUCTION (stub_entry, STWS_RET0_M8SP);
|
|
NEW_INSTRUCTION (stub_entry, FLDWS_M8SP_FRET0);
|
|
break;
|
|
|
|
case FR_TO_R:
|
|
NEW_INSTRUCTION (stub_entry, FSTWS_FRET0_M8SP);
|
|
NEW_INSTRUCTION (stub_entry, LDWS_M4SP_RET0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* generate the ending common section for all stubs */
|
|
|
|
/* XXX: can we assume this is a save return? */
|
|
NEW_INSTRUCTION (stub_entry, BV_N_0RP);
|
|
}
|
|
|
|
return stub_sym;
|
|
}
|
|
|
|
int
|
|
hppa_elf_arg_reloc_needed_p (abfd, reloc_entry, stub_types, caller_ar)
|
|
bfd *abfd;
|
|
arelent *reloc_entry;
|
|
int stub_types[5];
|
|
symext_entryS caller_ar;
|
|
{
|
|
/* If the symbol is still undefined, there is */
|
|
/* no way to know if a stub is required. */
|
|
|
|
if (reloc_entry->sym_ptr_ptr[0] && reloc_entry->sym_ptr_ptr[0]->section != &bfd_und_section)
|
|
{
|
|
symext_entryS callee_ar = elf32_hppa_get_sym_extn (abfd,
|
|
reloc_entry->sym_ptr_ptr[0],
|
|
HPPA_SXT_ARG_RELOC);
|
|
|
|
/* Now, determine if a stub is */
|
|
/* required. A stub is required if they the callee and caller */
|
|
/* argument relocation bits are both nonzero and not equal. */
|
|
|
|
if (caller_ar && callee_ar)
|
|
{
|
|
/* Both are non-zero, we need to do further checking. */
|
|
/* First, check if there is a return value relocation to be done */
|
|
int caller_loc[5];
|
|
int callee_loc[5];
|
|
|
|
callee_loc[RETVAL] = EXTRACT_ARBITS (callee_ar, RETVAL);
|
|
caller_loc[RETVAL] = EXTRACT_ARBITS (caller_ar, RETVAL);
|
|
callee_loc[ARG0] = EXTRACT_ARBITS (callee_ar, ARG0);
|
|
caller_loc[ARG0] = EXTRACT_ARBITS (caller_ar, ARG0);
|
|
callee_loc[ARG1] = EXTRACT_ARBITS (callee_ar, ARG1);
|
|
caller_loc[ARG1] = EXTRACT_ARBITS (caller_ar, ARG1);
|
|
callee_loc[ARG2] = EXTRACT_ARBITS (callee_ar, ARG2);
|
|
caller_loc[ARG2] = EXTRACT_ARBITS (caller_ar, ARG2);
|
|
callee_loc[ARG3] = EXTRACT_ARBITS (callee_ar, ARG3);
|
|
caller_loc[ARG3] = EXTRACT_ARBITS (caller_ar, ARG3);
|
|
|
|
/* Check some special combinations. For */
|
|
/* example, if FU appears in ARG1 or ARG3, we */
|
|
/* can move it to ARG0 or ARG2, respectively. */
|
|
|
|
if (caller_loc[ARG0] == AR_FU || caller_loc[ARG1] == AR_FU)
|
|
{
|
|
caller_loc[ARG0] = AR_DBL01;
|
|
caller_loc[ARG1] = AR_NO;
|
|
}
|
|
if (caller_loc[ARG2] == AR_FU || caller_loc[ARG3] == AR_FU)
|
|
{
|
|
caller_loc[ARG2] = AR_DBL23;
|
|
caller_loc[ARG3] = AR_NO;
|
|
}
|
|
if (callee_loc[ARG0] == AR_FU || callee_loc[ARG1] == AR_FU)
|
|
{
|
|
callee_loc[ARG0] = AR_DBL01;
|
|
callee_loc[ARG1] = AR_NO;
|
|
}
|
|
if (callee_loc[ARG2] == AR_FU || callee_loc[ARG3] == AR_FU)
|
|
{
|
|
callee_loc[ARG2] = AR_DBL23;
|
|
callee_loc[ARG3] = AR_NO;
|
|
}
|
|
|
|
stub_types[ARG0] = type_of_mismatch (caller_loc[ARG0], callee_loc[ARG0], ARGUMENTS);
|
|
stub_types[ARG1] = type_of_mismatch (caller_loc[ARG1], callee_loc[ARG1], ARGUMENTS);
|
|
stub_types[ARG2] = type_of_mismatch (caller_loc[ARG2], callee_loc[ARG2], ARGUMENTS);
|
|
stub_types[ARG3] = type_of_mismatch (caller_loc[ARG3], callee_loc[ARG3], ARGUMENTS);
|
|
stub_types[RETVAL] = type_of_mismatch (caller_loc[RETVAL], callee_loc[RETVAL], RETURN_VALUE);
|
|
|
|
/* Steps involved in building stubs: */
|
|
/* 1. Determine what argument registers need to relocated. This */
|
|
/* step is already done here. */
|
|
/* 2. Build the appropriate stub in the .hppa_linker_stubs section. */
|
|
/* This section should never appear in an object file. It is */
|
|
/* only used internally. The output_section of the */
|
|
/* .hppa_linker_stubs section is the .text section of the */
|
|
/* executable. */
|
|
/* 3. Build a symbol that is used (internally only) as the entry */
|
|
/* point of the stub. */
|
|
/* 4. Change the instruction of the original branch into a branch to */
|
|
/* the stub routine. */
|
|
/* 5. Build a relocation entry for the instruction of the original */
|
|
/* branch to be R_HPPA_PCREL_CALL to the stub routine. */
|
|
|
|
|
|
if (stub_types[0]
|
|
|| stub_types[1]
|
|
|| stub_types[2]
|
|
|| stub_types[3]
|
|
|| stub_types[4])
|
|
{
|
|
#ifdef DETECT_STUBS
|
|
int i;
|
|
|
|
fprintf (stderr, "Stub needed for %s @ %s+0x%x: callee/caller ar=0x%x/0x%x ",
|
|
reloc_entry->sym_ptr_ptr[0]->name,
|
|
abfd->filename, reloc_entry->address,
|
|
callee_ar, caller_ar);
|
|
for (i = ARG0; i < RETVAL; i++)
|
|
{
|
|
if (stub_types[i] != NO_ARG_RELOC)
|
|
{
|
|
fprintf (stderr, "%s%d: %s ",
|
|
i == RETVAL ? "ret" : "arg",
|
|
i == RETVAL ? 0 : i,
|
|
reloc_type_strings[stub_types[i]]);
|
|
}
|
|
}
|
|
fprintf (stderr, "\n");
|
|
#endif
|
|
return 1;
|
|
}
|
|
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
asymbol *
|
|
hppa_elf_build_long_branch_stub (abfd, output_bfd, reloc_entry, symbol, data)
|
|
bfd *abfd;
|
|
bfd *output_bfd;
|
|
arelent *reloc_entry;
|
|
asymbol *symbol;
|
|
unsigned *data;
|
|
{
|
|
asection *stub_sec = bfd_get_section_by_name (abfd, ".hppa_linker_stubs");
|
|
elf32_hppa_stub_description *stub_desc = find_stubs (abfd, stub_sec);
|
|
asymbol *stub_sym = NULL;
|
|
asymbol *target_sym = reloc_entry->sym_ptr_ptr[0];
|
|
asection *output_text_section = bfd_get_section_by_name (output_bfd, ".text");
|
|
char stub_sym_name[128];
|
|
int milli = false;
|
|
elf32_hppa_stub_name_list *stub_entry;
|
|
|
|
if (!stub_sec)
|
|
{
|
|
BFD_ASSERT (stub_desc == NULL);
|
|
stub_sec = bfd_make_section (abfd, ".hppa_linker_stubs");
|
|
bfd_set_section_flags (abfd,
|
|
stub_sec,
|
|
SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_READONLY);
|
|
stub_sec->output_section = output_text_section->output_section;
|
|
stub_sec->output_offset = 0;
|
|
/* set up the ELF section header for this new section. */
|
|
/* This is basically the same processing as elf_make_sections() */
|
|
/* (elf_make_sections() is static so it is not accessible from */
|
|
/* here.) */
|
|
|
|
{
|
|
Elf_Internal_Shdr *this_hdr;
|
|
this_hdr = &elf_section_data (stub_sec)->this_hdr;
|
|
|
|
this_hdr->sh_addr = stub_sec->vma;
|
|
this_hdr->sh_size = stub_sec->_raw_size;
|
|
/* contents already set by elf_set_section_contents */
|
|
|
|
if (stub_sec->flags & SEC_RELOC)
|
|
{
|
|
/* emit a reloc section, and thus strtab and symtab... */
|
|
Elf_Internal_Shdr *rela_hdr;
|
|
int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
|
|
|
|
rela_hdr = &elf_section_data (stub_sec)->rel_hdr;
|
|
|
|
/* orelocation has the data, reloc_count has the count... */
|
|
if (use_rela_p)
|
|
{
|
|
rela_hdr->sh_type = SHT_RELA;
|
|
rela_hdr->sh_entsize = sizeof (Elf32_External_Rela);
|
|
}
|
|
else
|
|
/* REL relocations */
|
|
{
|
|
rela_hdr->sh_type = SHT_REL;
|
|
rela_hdr->sh_entsize = sizeof (Elf32_External_Rel);
|
|
}
|
|
rela_hdr->sh_flags = 0;
|
|
rela_hdr->sh_addr = 0;
|
|
rela_hdr->sh_offset = 0;
|
|
rela_hdr->sh_addralign = 0;
|
|
rela_hdr->size = 0;
|
|
}
|
|
if (stub_sec->flags & SEC_ALLOC)
|
|
{
|
|
this_hdr->sh_flags |= SHF_ALLOC;
|
|
if (stub_sec->flags & SEC_LOAD)
|
|
{
|
|
/* @@ Do something with sh_type? */
|
|
}
|
|
}
|
|
if (!(stub_sec->flags & SEC_READONLY))
|
|
this_hdr->sh_flags |= SHF_WRITE;
|
|
|
|
if (stub_sec->flags & SEC_CODE)
|
|
this_hdr->sh_flags |= SHF_EXECINSTR;
|
|
}
|
|
|
|
bfd_set_section_alignment (abfd, stub_sec, 2);
|
|
stub_desc = new_stub (abfd, stub_sec);
|
|
}
|
|
|
|
if (!stub_desc)
|
|
stub_desc = new_stub (abfd, stub_sec);
|
|
|
|
/* allocate some space to write the stub */
|
|
|
|
if (!stub_desc->stub_contents)
|
|
{
|
|
stub_desc->allocated_size = STUB_BUFFER_INCR;
|
|
stub_desc->stub_contents = (char *) malloc (STUB_BUFFER_INCR);
|
|
}
|
|
else if ((stub_desc->allocated_size - stub_desc->real_size) < STUB_MAX_SIZE)
|
|
{
|
|
stub_desc->allocated_size = stub_desc->allocated_size + STUB_BUFFER_INCR;
|
|
stub_desc->stub_contents = (char *) realloc (stub_desc->stub_contents,
|
|
stub_desc->allocated_size);
|
|
}
|
|
|
|
stub_desc->stub_secp = (int *) (stub_desc->stub_contents + stub_desc->real_size);
|
|
|
|
sprintf (stub_sym_name,
|
|
"_lb_stub_%s", reloc_entry->sym_ptr_ptr[0]->name);
|
|
stub_entry = find_stub_by_name(abfd, stub_sec, stub_sym_name);
|
|
|
|
if (stub_entry)
|
|
{
|
|
stub_sym = stub_entry->sym;
|
|
/* redirect the original relocation from the old symbol (a function) */
|
|
/* to the stub (the stub calls the function). */
|
|
/* XXX do we need to change the relocation type? */
|
|
reloc_entry->sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd, sizeof (asymbol *));
|
|
reloc_entry->sym_ptr_ptr[0] = stub_sym;
|
|
reloc_entry->howto = bfd_reloc_type_lookup (abfd, R_HPPA_STUB_CALL_17);
|
|
}
|
|
else
|
|
{
|
|
/* Stub does not already exist. Create a new stub. */
|
|
/* create a symbol to point to this stub */
|
|
stub_sym = bfd_make_empty_symbol (abfd);
|
|
stub_sym->name = bfd_zalloc (abfd, strlen (stub_sym_name) + 1);
|
|
strcpy ((char *) stub_sym->name, stub_sym_name);
|
|
stub_sym->value = (int) stub_desc->stub_secp - (int) stub_desc->stub_contents;
|
|
stub_sym->section = stub_sec;
|
|
stub_sym->flags = BSF_LOCAL | BSF_FUNCTION;
|
|
stub_entry = add_stub_by_name(abfd, stub_sec, stub_sym);
|
|
|
|
/* redirect the original relocation from the old symbol (a function) */
|
|
/* to the stub (the stub calls the function). */
|
|
/* XXX do we need to change the relocation type? */
|
|
reloc_entry->sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd, sizeof (asymbol *));
|
|
reloc_entry->sym_ptr_ptr[0] = stub_sym;
|
|
reloc_entry->howto = bfd_reloc_type_lookup (abfd, R_HPPA_STUB_CALL_17);
|
|
|
|
/* Build the stub */
|
|
|
|
/* A millicode call? */
|
|
/* If so, the return address comes in on r31 rather than r2 (rp) so a */
|
|
/* slightly different code sequence is needed. */
|
|
if ( ((*data & 0x03e00000) >> 21) == 31 )
|
|
milli = true;
|
|
|
|
/* 1. initialization for the call. */
|
|
|
|
NEW_INSTRUCTION(stub_entry, LDSID_31_RP);
|
|
NEW_INSTRUCTION(stub_entry, MTSP_RP_SR0);
|
|
if ( !milli )
|
|
{
|
|
NEW_INSTRUCTION(stub_entry, COPY_31_2);
|
|
|
|
NEW_INSTRUCTION(stub_entry, LDIL_XXX_31);
|
|
hppa_elf_stub_reloc (stub_desc,
|
|
abfd, /* the output bfd */
|
|
target_sym, /* the target symbol */
|
|
CURRENT_STUB_OFFSET(stub_entry), /* offset in stub buffer */
|
|
R_HPPA_L21);
|
|
|
|
/* 2. Make the call. */
|
|
|
|
NEW_INSTRUCTION(stub_entry,BE_N_XXX_0_31);
|
|
hppa_elf_stub_reloc (stub_desc,
|
|
abfd, /* the output bfd */
|
|
target_sym, /* the target symbol */
|
|
CURRENT_STUB_OFFSET(stub_entry), /* offset in stub buffer */
|
|
R_HPPA_ABS_CALL_R17);
|
|
/* 3. Branch back to the original location. */
|
|
/* (accomplished with the COPY_31_2 instruction) */
|
|
}
|
|
else
|
|
{
|
|
NEW_INSTRUCTION(stub_entry, STW_31_M24SP);
|
|
NEW_INSTRUCTION(stub_entry, LDIL_XXX_RP);
|
|
hppa_elf_stub_reloc (stub_desc,
|
|
abfd, /* the output bfd */
|
|
target_sym, /* the target symbol */
|
|
CURRENT_STUB_OFFSET(stub_entry), /* offset in stub buffer */
|
|
R_HPPA_L21);
|
|
|
|
/* 2. Make the call. */
|
|
|
|
NEW_INSTRUCTION(stub_entry,BLE_XXX_0_RP);
|
|
hppa_elf_stub_reloc (stub_desc,
|
|
abfd, /* the output bfd */
|
|
target_sym, /* the target symbol */
|
|
CURRENT_STUB_OFFSET(stub_entry), /* offset in stub buffer */
|
|
R_HPPA_ABS_CALL_R17);
|
|
NEW_INSTRUCTION(stub_entry,COPY_31_2);
|
|
|
|
/* 3. Branch back to the original location. */
|
|
NEW_INSTRUCTION(stub_entry, LDW_M24SP_RP);
|
|
NEW_INSTRUCTION(stub_entry, BV_N_0RP);
|
|
}
|
|
}
|
|
|
|
return stub_sym;
|
|
}
|
|
|
|
int
|
|
hppa_elf_long_branch_needed_p (abfd, asec, reloc_entry, symbol, insn)
|
|
bfd *abfd;
|
|
asection *asec;
|
|
arelent *reloc_entry;
|
|
asymbol *symbol;
|
|
unsigned insn;
|
|
{
|
|
long sym_value = get_symbol_value(symbol);
|
|
int fmt = reloc_entry->howto->bitsize;
|
|
unsigned char op = get_opcode(insn);
|
|
unsigned raddr;
|
|
|
|
#define too_far(val,num_bits) ((int)(val) > (1<<(num_bits))-1) || ((int)(val) < (-1<<(num_bits)))
|
|
|
|
BFD_ASSERT(fmt == hppa_elf_insn2fmt(reloc_entry->howto->type,insn));
|
|
|
|
switch (op)
|
|
{
|
|
case BL:
|
|
raddr =
|
|
reloc_entry->address + asec->output_offset + asec->output_section->vma;
|
|
if ( too_far(sym_value - raddr,fmt+1) )
|
|
{
|
|
#ifdef DETECT_STUBS
|
|
fprintf(stderr,"long_branch needed on BL insn: abfd=%s,sym=%s,distance=0x%x\n",abfd->filename,symbol->name,sym_value - reloc_entry->address);
|
|
#endif
|
|
return 1;
|
|
}
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
asymbol *
|
|
hppa_elf_stub_check (abfd, output_bfd, input_section, reloc_entry, symbol, hit_data)
|
|
bfd *abfd;
|
|
bfd *output_bfd;
|
|
asection *input_section;
|
|
arelent *reloc_entry;
|
|
asymbol *symbol;
|
|
bfd_byte *hit_data;
|
|
{
|
|
int stub_types[5];
|
|
|
|
switch (reloc_entry->howto->type)
|
|
{
|
|
case R_HPPA_ABS_CALL_11: /* Symbol + Addend 11 */
|
|
case R_HPPA_ABS_CALL_14: /* Symbol + Addend 14 */
|
|
case R_HPPA_ABS_CALL_17: /* Symbol + Addend 17 */
|
|
case R_HPPA_ABS_CALL_L21: /* L (Symbol, Addend) 21 */
|
|
case R_HPPA_ABS_CALL_R11: /* R (Symbol, Addend) 11 */
|
|
case R_HPPA_ABS_CALL_R14: /* R (Symbol, Addend) 14 */
|
|
case R_HPPA_ABS_CALL_R17: /* R (Symbol, Addend) 17 */
|
|
case R_HPPA_ABS_CALL_LS21: /* LS(Symbol, Addend) 21 */
|
|
case R_HPPA_ABS_CALL_RS11: /* RS(Symbol, Addend) 11 */
|
|
case R_HPPA_ABS_CALL_RS14: /* RS(Symbol, Addend) 14 */
|
|
case R_HPPA_ABS_CALL_RS17: /* RS(Symbol, Addend) 17 */
|
|
case R_HPPA_ABS_CALL_LD21: /* LD(Symbol, Addend) 21 */
|
|
case R_HPPA_ABS_CALL_RD11: /* RD(Symbol, Addend) 11 */
|
|
case R_HPPA_ABS_CALL_RD14: /* RD(Symbol, Addend) 14 */
|
|
case R_HPPA_ABS_CALL_RD17: /* RD(Symbol, Addend) 17 */
|
|
case R_HPPA_ABS_CALL_LR21: /* LR(Symbol, Addend) 21 */
|
|
case R_HPPA_ABS_CALL_RR14: /* RR(Symbol, Addend) 14 */
|
|
case R_HPPA_ABS_CALL_RR17: /* RR(Symbol, Addend) 17 */
|
|
|
|
case R_HPPA_PCREL_CALL_11: /* Symbol - PC + Addend 11 */
|
|
case R_HPPA_PCREL_CALL_14: /* Symbol - PC + Addend 14 */
|
|
case R_HPPA_PCREL_CALL_17: /* Symbol - PC + Addend 17 */
|
|
case R_HPPA_PCREL_CALL_12: /* Symbol - PC + Addend 12 */
|
|
case R_HPPA_PCREL_CALL_L21: /* L (Symbol - PC, Addend) 21 */
|
|
case R_HPPA_PCREL_CALL_R11: /* R (Symbol - PC, Addend) 11 */
|
|
case R_HPPA_PCREL_CALL_R14: /* R (Symbol - PC, Addend) 14 */
|
|
case R_HPPA_PCREL_CALL_R17: /* R (Symbol - PC, Addend) 17 */
|
|
case R_HPPA_PCREL_CALL_LS21: /* LS(Symbol - PC, Addend) 21 */
|
|
case R_HPPA_PCREL_CALL_RS11: /* RS(Symbol - PC, Addend) 11 */
|
|
case R_HPPA_PCREL_CALL_RS14: /* RS(Symbol - PC, Addend) 14 */
|
|
case R_HPPA_PCREL_CALL_RS17: /* RS(Symbol - PC, Addend) 17 */
|
|
case R_HPPA_PCREL_CALL_LD21: /* LD(Symbol - PC, Addend) 21 */
|
|
case R_HPPA_PCREL_CALL_RD11: /* RD(Symbol - PC, Addend) 11 */
|
|
case R_HPPA_PCREL_CALL_RD14: /* RD(Symbol - PC, Addend) 14 */
|
|
case R_HPPA_PCREL_CALL_RD17: /* RD(Symbol - PC, Addend) 17 */
|
|
case R_HPPA_PCREL_CALL_LR21: /* LR(Symbol - PC, Addend) 21 */
|
|
case R_HPPA_PCREL_CALL_RR14: /* RR(Symbol - PC, Addend) 14 */
|
|
case R_HPPA_PCREL_CALL_RR17: /* RR(Symbol - PC, Addend) 17 */
|
|
{
|
|
symext_entryS caller_ar = (symext_entryS) ELF32_HGPPA_R_ARG_RELOC (reloc_entry->addend);
|
|
if (hppa_elf_arg_reloc_needed_p (abfd, reloc_entry, stub_types, caller_ar))
|
|
{
|
|
/* generate a stub */
|
|
return hppa_elf_build_arg_reloc_stub (abfd, output_bfd,
|
|
reloc_entry, stub_types);
|
|
}
|
|
if (hppa_elf_long_branch_needed_p (abfd, input_section, reloc_entry,
|
|
symbol, *(unsigned *)hit_data))
|
|
{
|
|
/* generate a stub */
|
|
return hppa_elf_build_long_branch_stub (abfd, output_bfd,
|
|
reloc_entry, symbol,
|
|
(unsigned *)hit_data);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return reloc_entry->sym_ptr_ptr[0];
|
|
}
|
|
|
|
#define STUB_SYM_BUFFER_INC 5
|
|
|
|
asymbol *
|
|
hppa_look_for_stubs_in_section (stub_bfd, abfd, output_bfd, asec, syms, new_sym_cnt)
|
|
bfd *stub_bfd;
|
|
bfd *abfd;
|
|
bfd *output_bfd;
|
|
asection *asec;
|
|
asymbol **syms;
|
|
int *new_sym_cnt;
|
|
{
|
|
int i;
|
|
int stub_types[5];
|
|
asymbol *new_syms = (asymbol *) NULL;
|
|
int new_cnt = 0;
|
|
int new_max = 0;
|
|
|
|
/* Relocations are in different places depending on whether this is
|
|
an output section or an input section. Also, the relocations are
|
|
in different forms. Sigh. Luckily, we have
|
|
bfd_canonicalize_reloc() to straighten this out for us. */
|
|
|
|
/* if ( asec->orelocation || asec->relocation ) { */
|
|
if (asec->reloc_count > 0)
|
|
{
|
|
arelent **reloc_vector = (arelent **) alloca (asec->reloc_count * (sizeof (arelent *) + 1));
|
|
|
|
bfd_canonicalize_reloc (abfd, asec, reloc_vector, syms);
|
|
for (i = 0; i < asec->reloc_count; i++)
|
|
{
|
|
#if 0
|
|
arelent *rle;
|
|
|
|
if ( asec->orelocation )
|
|
rle = asec->orelocation[i];
|
|
else
|
|
rle = asec->relocation+i;
|
|
#endif
|
|
|
|
arelent *rle = reloc_vector[i];
|
|
|
|
switch (rle->howto->type)
|
|
{
|
|
case R_HPPA_ABS_CALL_11: /* Symbol + Addend 11 */
|
|
case R_HPPA_ABS_CALL_14: /* Symbol + Addend 14 */
|
|
case R_HPPA_ABS_CALL_17: /* Symbol + Addend 17 */
|
|
case R_HPPA_ABS_CALL_L21: /* L (Symbol, Addend) 21 */
|
|
case R_HPPA_ABS_CALL_R11: /* R (Symbol, Addend) 11 */
|
|
case R_HPPA_ABS_CALL_R14: /* R (Symbol, Addend) 14 */
|
|
case R_HPPA_ABS_CALL_R17: /* R (Symbol, Addend) 17 */
|
|
case R_HPPA_ABS_CALL_LS21: /* LS(Symbol, Addend) 21 */
|
|
case R_HPPA_ABS_CALL_RS11: /* RS(Symbol, Addend) 11 */
|
|
case R_HPPA_ABS_CALL_RS14: /* RS(Symbol, Addend) 14 */
|
|
case R_HPPA_ABS_CALL_RS17: /* RS(Symbol, Addend) 17 */
|
|
case R_HPPA_ABS_CALL_LD21: /* LD(Symbol, Addend) 21 */
|
|
case R_HPPA_ABS_CALL_RD11: /* RD(Symbol, Addend) 11 */
|
|
case R_HPPA_ABS_CALL_RD14: /* RD(Symbol, Addend) 14 */
|
|
case R_HPPA_ABS_CALL_RD17: /* RD(Symbol, Addend) 17 */
|
|
case R_HPPA_ABS_CALL_LR21: /* LR(Symbol, Addend) 21 */
|
|
case R_HPPA_ABS_CALL_RR14: /* RR(Symbol, Addend) 14 */
|
|
case R_HPPA_ABS_CALL_RR17: /* RR(Symbol, Addend) 17 */
|
|
|
|
case R_HPPA_PCREL_CALL_11: /* Symbol - PC + Addend 11 */
|
|
case R_HPPA_PCREL_CALL_14: /* Symbol - PC + Addend 14 */
|
|
case R_HPPA_PCREL_CALL_17: /* Symbol - PC + Addend 17 */
|
|
case R_HPPA_PCREL_CALL_12: /* Symbol - PC + Addend 12 */
|
|
case R_HPPA_PCREL_CALL_L21: /* L (Symbol - PC, Addend) 21 */
|
|
case R_HPPA_PCREL_CALL_R11: /* R (Symbol - PC, Addend) 11 */
|
|
case R_HPPA_PCREL_CALL_R14: /* R (Symbol - PC, Addend) 14 */
|
|
case R_HPPA_PCREL_CALL_R17: /* R (Symbol - PC, Addend) 17 */
|
|
case R_HPPA_PCREL_CALL_LS21: /* LS(Symbol - PC, Addend) 21 */
|
|
case R_HPPA_PCREL_CALL_RS11: /* RS(Symbol - PC, Addend) 11 */
|
|
case R_HPPA_PCREL_CALL_RS14: /* RS(Symbol - PC, Addend) 14 */
|
|
case R_HPPA_PCREL_CALL_RS17: /* RS(Symbol - PC, Addend) 17 */
|
|
case R_HPPA_PCREL_CALL_LD21: /* LD(Symbol - PC, Addend) 21 */
|
|
case R_HPPA_PCREL_CALL_RD11: /* RD(Symbol - PC, Addend) 11 */
|
|
case R_HPPA_PCREL_CALL_RD14: /* RD(Symbol - PC, Addend) 14 */
|
|
case R_HPPA_PCREL_CALL_RD17: /* RD(Symbol - PC, Addend) 17 */
|
|
case R_HPPA_PCREL_CALL_LR21: /* LR(Symbol - PC, Addend) 21 */
|
|
case R_HPPA_PCREL_CALL_RR14: /* RR(Symbol - PC, Addend) 14 */
|
|
case R_HPPA_PCREL_CALL_RR17: /* RR(Symbol - PC, Addend) 17 */
|
|
{
|
|
symext_entryS caller_ar = (symext_entryS) ELF32_HPPA_R_ARG_RELOC (rle->addend);
|
|
if (hppa_elf_arg_reloc_needed_p (abfd, rle, stub_types,
|
|
caller_ar))
|
|
{
|
|
/* generate a stub */
|
|
/* keep track of the new symbol */
|
|
asymbol *r;
|
|
|
|
if (new_cnt == new_max)
|
|
{
|
|
new_max += STUB_SYM_BUFFER_INC;
|
|
new_syms = (asymbol *) realloc (new_syms, new_max * sizeof (asymbol));
|
|
}
|
|
r = hppa_elf_build_arg_reloc_stub (stub_bfd, output_bfd,
|
|
rle, stub_types);
|
|
new_syms[new_cnt++] = *r;
|
|
}
|
|
/* We need to retrieve the section contents to check for
|
|
plabel stubs. */
|
|
{
|
|
unsigned insn;
|
|
|
|
bfd_get_section_contents (abfd, asec, &insn, rle->address,
|
|
sizeof(insn));
|
|
if (hppa_elf_long_branch_needed_p (abfd, asec, rle,
|
|
rle->sym_ptr_ptr[0],
|
|
insn))
|
|
{
|
|
/* generate a stub */
|
|
/* keep track of the new symbol */
|
|
asymbol *r;
|
|
|
|
if (new_cnt == new_max)
|
|
{
|
|
new_max += STUB_SYM_BUFFER_INC;
|
|
new_syms = (asymbol *) realloc (new_syms, (new_max * sizeof (asymbol)));
|
|
}
|
|
r = hppa_elf_build_long_branch_stub (stub_bfd,
|
|
output_bfd,
|
|
rle,
|
|
rle->sym_ptr_ptr[0],
|
|
&insn);
|
|
new_syms[new_cnt++] = *r;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
/* Plabels are designed to allow code pointers to be
|
|
passed between spaces. These relocations correspond
|
|
to the P%, LP%, and RP% field selectors. */
|
|
|
|
case R_HPPA_PLABEL_32: /* F(Plabel(Symbol,Addend),0) 32 */
|
|
case R_HPPA_PLABEL_11: /* F(Plabel(Symbol,Addend),0) 11 */
|
|
case R_HPPA_PLABEL_14: /* F(Plabel(Symbol,Addend),0) 14 */
|
|
case R_HPPA_PLABEL_L21: /* L(Plabel(Symbol,Addend),0) 21 */
|
|
case R_HPPA_PLABEL_R11: /* R(Plabel(Symbol,Addend),0) 11 */
|
|
case R_HPPA_PLABEL_R14: /* R(Plabel(Symbol,Addend),0) 14 */
|
|
/* We need to retrieve the section contents to check for
|
|
long branch stubs. */
|
|
{
|
|
/* On a plabel relocation, assume the arguments of the
|
|
caller are set up in general registers. */
|
|
/* 0x155 = ARGW0=CR,ARGW1=GR,ARGW2=GR,RETVAL=GR */
|
|
symext_entryS caller_ar = (symext_entryS) 0x155;
|
|
|
|
if (hppa_elf_arg_reloc_needed_p (abfd, rle, stub_types,
|
|
caller_ar))
|
|
{
|
|
/* generate a plabel stub */
|
|
/* keep track of the new symbol */
|
|
asymbol *r;
|
|
|
|
if (new_cnt == new_max)
|
|
{
|
|
new_max += STUB_SYM_BUFFER_INC;
|
|
new_syms = (asymbol *) realloc (new_syms,
|
|
(new_max
|
|
* sizeof (asymbol)));
|
|
}
|
|
r = hppa_elf_build_arg_reloc_stub (stub_bfd,
|
|
output_bfd,
|
|
rle,
|
|
stub_types);
|
|
new_syms[new_cnt++] = *r;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
|
|
}
|
|
}
|
|
}
|
|
*new_sym_cnt = new_cnt;
|
|
return new_syms;
|
|
}
|
|
|
|
|
|
char *linker_stubs = NULL;
|
|
int linker_stubs_size = 0;
|
|
int linker_stubs_max_size = 0;
|
|
#define STUB_ALLOC_INCR 100
|
|
|
|
boolean
|
|
DEFUN (hppa_elf_set_section_contents, (abfd, section, location, offset, count),
|
|
bfd * abfd AND
|
|
sec_ptr section AND
|
|
PTR location AND
|
|
file_ptr offset AND
|
|
bfd_size_type count)
|
|
{
|
|
if ( strcmp(section->name, ".hppa_linker_stubs") == 0 )
|
|
{
|
|
if ( linker_stubs_max_size < offset + count )
|
|
{
|
|
linker_stubs_max_size = offset + count + STUB_ALLOC_INCR;
|
|
linker_stubs = (char *)realloc(linker_stubs, linker_stubs_max_size);
|
|
}
|
|
|
|
if ( offset + count > linker_stubs_size )
|
|
linker_stubs_size = offset + count;
|
|
|
|
memcpy(linker_stubs + offset,location,count);
|
|
return (true);
|
|
}
|
|
else
|
|
return bfd_elf32_set_section_contents (abfd, section, location,
|
|
offset, count);
|
|
}
|
|
|
|
boolean
|
|
DEFUN (hppa_elf_get_section_contents, (abfd, section, location, offset, count),
|
|
bfd * abfd AND
|
|
sec_ptr section AND
|
|
PTR location AND
|
|
file_ptr offset AND
|
|
bfd_size_type count)
|
|
{
|
|
/* if this is the linker stub section, then we have the */
|
|
/* section contents in memory rather than on disk. */
|
|
if (strcmp (section->name, ".hppa_linker_stubs") == 0)
|
|
{
|
|
elf32_hppa_stub_description *stub_desc = find_stubs (abfd, section);
|
|
|
|
if (count == 0)
|
|
return true;
|
|
if ((bfd_size_type) (offset + count) > section->_raw_size)
|
|
return (false); /* on error */
|
|
if ((bfd_size_type) (offset + count) > stub_desc->real_size)
|
|
return (false); /* on error */
|
|
|
|
memcpy (location, stub_desc->stub_contents + offset, count);
|
|
return (true);
|
|
}
|
|
/* if this is the symbol extension section, then we have the */
|
|
/* section contents in memory rather than on disk. */
|
|
else if (strcmp (section->name, ".hppa_symextn") == 0)
|
|
{
|
|
if (count == 0)
|
|
return true;
|
|
if ((bfd_size_type) (offset + count) > section->_raw_size)
|
|
return (false); /* on error */
|
|
if ((bfd_size_type) (offset + count) > symextn_contents_real_size)
|
|
return (false); /* on error */
|
|
|
|
memcpy (location, symextn_contents + offset, count);
|
|
return (true);
|
|
}
|
|
else
|
|
return bfd_generic_get_section_contents (abfd, section, location, offset,
|
|
count);
|
|
}
|
|
|
|
static void
|
|
DEFUN (elf_info_to_howto, (abfd, cache_ptr, dst),
|
|
bfd * abfd AND
|
|
arelent * cache_ptr AND
|
|
Elf32_Internal_Rela * dst)
|
|
{
|
|
BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_HPPA_UNIMPLEMENTED);
|
|
cache_ptr->howto = &elf_hppa_howto_table[ELF32_R_TYPE(dst->r_info)];
|
|
}
|
|
|
|
static void
|
|
DEFUN (elf32_hppa_backend_symbol_processing, (abfd, sym),
|
|
bfd * abfd AND
|
|
asymbol * sym)
|
|
{
|
|
/* Is this a definition of $global$? If so, keep it because it will be
|
|
needed if any relocations are performed. */
|
|
|
|
if (!strcmp (sym->name, "$global$")
|
|
&& sym->section != &bfd_und_section)
|
|
{
|
|
global_symbol = sym;
|
|
}
|
|
}
|
|
|
|
#define elf_backend_symbol_processing elf32_hppa_backend_symbol_processing
|
|
|
|
struct elf32_hppa_symextn_map_struct
|
|
{
|
|
int old_index;
|
|
bfd *bfd;
|
|
asymbol *sym;
|
|
int new_index;
|
|
};
|
|
|
|
static struct elf32_hppa_symextn_map_struct *elf32_hppa_symextn_map;
|
|
static int elf32_hppa_symextn_map_size;
|
|
|
|
static boolean
|
|
DEFUN (elf32_hppa_backend_symbol_table_processing, (abfd, esyms,symcnt),
|
|
bfd * abfd AND
|
|
elf_symbol_type *esyms AND
|
|
int symcnt)
|
|
{
|
|
Elf32_Internal_Shdr *symextn_hdr = bfd_elf_find_section (abfd, SYMEXTN_SECTION_NAME);
|
|
int i;
|
|
int current_sym_idx = 0;
|
|
|
|
/* If the symbol extension section does not exist, all the symbol */
|
|
/* all the symbol extension information is assumed to be zero. */
|
|
|
|
if ( symextn_hdr == NULL )
|
|
{
|
|
for ( i = 0; i < symcnt; i++ )
|
|
{
|
|
esyms[i].tc_data.hppa_arg_reloc = 0;
|
|
}
|
|
return (true);
|
|
}
|
|
|
|
/* allocate a buffer of the appropriate size for the symextn section */
|
|
|
|
symextn_hdr->contents = bfd_zalloc(abfd,symextn_hdr->sh_size);
|
|
symextn_hdr->size = symextn_hdr->sh_size;
|
|
|
|
/* read in the symextn section */
|
|
|
|
if (bfd_seek (abfd, symextn_hdr->sh_offset, SEEK_SET) == -1)
|
|
{
|
|
bfd_error = system_call_error;
|
|
return (false);
|
|
}
|
|
if (bfd_read ((PTR) symextn_hdr->contents, 1, symextn_hdr->size, abfd)
|
|
!= symextn_hdr->size)
|
|
{
|
|
free ((PTR)symextn_hdr->contents);
|
|
bfd_error = system_call_error;
|
|
return (false);
|
|
}
|
|
|
|
/* parse the entries, updating the symtab entries as we go */
|
|
|
|
for ( i = 0; i < symextn_hdr->size / sizeof(symext_entryS); i++ )
|
|
{
|
|
symext_entryS *seP = ((symext_entryS *)symextn_hdr->contents) + i;
|
|
int se_value = ELF32_HPPA_SX_VAL(*seP);
|
|
int se_type = ELF32_HPPA_SX_TYPE(*seP);
|
|
|
|
switch ( se_type )
|
|
{
|
|
case HPPA_SXT_NULL:
|
|
break;
|
|
|
|
case HPPA_SXT_SYMNDX:
|
|
if ( se_value >= symcnt )
|
|
{
|
|
bfd_error = bad_value;
|
|
bfd_perror("elf32_hppa_backend_symbol_table_processing -- symbol index");
|
|
return (false);
|
|
}
|
|
current_sym_idx = se_value - 1;
|
|
break;
|
|
|
|
case HPPA_SXT_ARG_RELOC:
|
|
esyms[current_sym_idx].tc_data.hppa_arg_reloc = se_value;
|
|
break;
|
|
|
|
default:
|
|
bfd_error = bad_value;
|
|
bfd_perror("elf32_hppa_backend_symbol_table_processing");
|
|
return (false);
|
|
}
|
|
}
|
|
return (true);
|
|
}
|
|
|
|
#define elf_backend_symbol_table_processing elf32_hppa_backend_symbol_table_processing
|
|
|
|
static boolean
|
|
DEFUN (elf32_hppa_backend_section_processing, (abfd, secthdr),
|
|
bfd * abfd AND
|
|
Elf32_Internal_Shdr *secthdr)
|
|
{
|
|
int i,j,k;
|
|
|
|
if ( secthdr->sh_type == SHT_HPPA_SYMEXTN )
|
|
{
|
|
for ( i = 0; i < secthdr->size / sizeof(symext_entryS); i++ )
|
|
{
|
|
symext_entryS *seP = ((symext_entryS *)secthdr->contents) + i;
|
|
int se_value = ELF32_HPPA_SX_VAL(*seP);
|
|
int se_type = ELF32_HPPA_SX_TYPE(*seP);
|
|
|
|
switch ( se_type )
|
|
{
|
|
case HPPA_SXT_NULL:
|
|
break;
|
|
|
|
case HPPA_SXT_SYMNDX:
|
|
for ( j = 0; j < abfd->symcount; j++ )
|
|
{
|
|
/* locate the map entry for this symbol, if there is one. */
|
|
/* modify the symbol extension section symbol index entry */
|
|
/* to reflect the new symbol table index */
|
|
|
|
for ( k = 0; k < elf32_hppa_symextn_map_size; k++ )
|
|
{
|
|
if ( elf32_hppa_symextn_map[k].old_index == se_value
|
|
&& elf32_hppa_symextn_map[k].bfd == abfd->outsymbols[j]->the_bfd
|
|
&& elf32_hppa_symextn_map[k].sym == abfd->outsymbols[j] )
|
|
{
|
|
bfd_put_32(abfd,
|
|
ELF32_HPPA_SX_WORD (HPPA_SXT_SYMNDX, j),
|
|
(char *)seP);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case HPPA_SXT_ARG_RELOC:
|
|
break;
|
|
|
|
default:
|
|
bfd_error = bad_value;
|
|
bfd_perror("elf32_hppa_backend_section_processing");
|
|
return (false);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#define elf_backend_section_processing elf32_hppa_backend_section_processing
|
|
|
|
static boolean
|
|
DEFUN (elf32_hppa_backend_section_from_shdr, (abfd, hdr, name),
|
|
bfd * abfd AND
|
|
Elf32_Internal_Shdr *hdr AND
|
|
char * name)
|
|
{
|
|
asection *newsect;
|
|
|
|
if ( hdr->sh_type == SHT_HPPA_SYMEXTN )
|
|
{
|
|
BFD_ASSERT ( strcmp(name,".hppa_symextn") == 0 );
|
|
|
|
/* Bits that get saved. This one is real. */
|
|
if (!hdr->rawdata)
|
|
{
|
|
newsect = bfd_make_section (abfd, name);
|
|
if (newsect != NULL)
|
|
{
|
|
newsect->vma = hdr->sh_addr;
|
|
newsect->_raw_size = hdr->sh_size;
|
|
newsect->filepos = hdr->sh_offset; /* so we can read back the bits */
|
|
newsect->flags |= SEC_HAS_CONTENTS;
|
|
newsect->alignment_power = hdr->sh_addralign;
|
|
|
|
if (hdr->sh_flags & SHF_ALLOC)
|
|
{
|
|
newsect->flags |= SEC_ALLOC;
|
|
newsect->flags |= SEC_LOAD;
|
|
}
|
|
|
|
if (!(hdr->sh_flags & SHF_WRITE))
|
|
newsect->flags |= SEC_READONLY;
|
|
|
|
if (hdr->sh_flags & SHF_EXECINSTR)
|
|
newsect->flags |= SEC_CODE; /* FIXME: may only contain SOME code */
|
|
else
|
|
newsect->flags |= SEC_DATA;
|
|
|
|
hdr->rawdata = (void *) newsect;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
#define elf_backend_section_from_shdr elf32_hppa_backend_section_from_shdr
|
|
|
|
static boolean
|
|
DEFUN (elf32_hppa_backend_fake_sections, (abfd, secthdr, asect),
|
|
bfd * abfd AND
|
|
Elf_Internal_Shdr *secthdr AND
|
|
asection *asect)
|
|
{
|
|
|
|
if ( strcmp(asect->name, ".hppa_symextn") == 0 )
|
|
{
|
|
secthdr->sh_type = SHT_HPPA_SYMEXTN;
|
|
secthdr->sh_flags = 0;
|
|
secthdr->sh_info = elf_section_data(asect)->rel_hdr.sh_link;
|
|
secthdr->sh_link = elf_onesymtab(abfd);
|
|
return true;
|
|
}
|
|
|
|
if (!strcmp (asect->name, ".hppa_unwind"))
|
|
{
|
|
secthdr->sh_type = SHT_PROGBITS;
|
|
/* Unwind descriptors are not part of the program memory image. */
|
|
secthdr->sh_flags = 0;
|
|
secthdr->sh_info = 0;
|
|
secthdr->sh_link = 0;
|
|
secthdr->sh_entsize = 16;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
#define elf_backend_fake_sections elf32_hppa_backend_fake_sections
|
|
|
|
static boolean
|
|
DEFUN (elf32_hppa_backend_section_from_bfd_section, (abfd, hdr, asect),
|
|
bfd *abfd AND
|
|
Elf32_Internal_Shdr *hdr AND
|
|
asection *asect)
|
|
{
|
|
|
|
if ( hdr->sh_type == SHT_HPPA_SYMEXTN )
|
|
{
|
|
if (hdr->rawdata)
|
|
{
|
|
if (((struct sec *) (hdr->rawdata)) == asect)
|
|
{
|
|
BFD_ASSERT( strcmp(asect->name, ".hppa_symextn") == 0 );
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
#define elf_backend_section_from_bfd_section elf32_hppa_backend_section_from_bfd_section
|
|
|
|
#define bfd_generic_get_section_contents hppa_elf_get_section_contents
|
|
#define bfd_elf32_set_section_contents hppa_elf_set_section_contents
|
|
|
|
#define TARGET_BIG_SYM bfd_elf32_hppa_vec
|
|
#define TARGET_BIG_NAME "elf32-hppa"
|
|
#define ELF_ARCH bfd_arch_hppa
|
|
#define ELF_MAXPAGESIZE 0x1000
|
|
|
|
#include "elf32-target.h"
|