darkkirb/old-cross-binutils
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
old-cross-binutils/bfd/elf32-hppa.c

2713 lines
82 KiB
C
Raw Normal View History

checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
/* BFD back-end for HP PA-RISC ELF files.
Copyright (C) 1990-1991 Free Software Foundation, Inc.
Written by
updates from Utah
1993-06-03 20:55:48 +00:00
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
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:
updates from Utah
1993-06-03 20:55:48 +00:00
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
Center for Software Science
Department of Computer Science
University of Utah
*/
#include "elf32-hppa.h"
updates from Utah
1993-06-03 20:55:48 +00:00
#include "libhppa.h"
#include "aout/aout64.h"
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
/* ELF/PA relocation howto entries */
updates from Utah
1993-06-03 20:55:48 +00:00
static bfd_reloc_status_type hppa_elf_reloc ();
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
updates from Utah
1993-06-03 20:55:48 +00:00
reloc_howto_type elf_hppa_howto_table[ELF_HOWTO_TABLE_SIZE] =
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
{
updates from Utah
1993-06-03 20:55:48 +00:00
/* '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, false, true, hppa_elf_reloc, "R_HPPA_NONE"},
{R_HPPA_32, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_32"},
{R_HPPA_11, 0, 3, 11, false, 0, false, true, hppa_elf_reloc, "R_HPPA_11"},
{R_HPPA_14, 0, 3, 14, false, 0, false, true, hppa_elf_reloc, "R_HPPA_14"},
{R_HPPA_17, 0, 3, 17, false, 0, false, true, hppa_elf_reloc, "R_HPPA_17"},
{R_HPPA_L21, 0, 3, 21, false, 0, false, true, hppa_elf_reloc, "R_HPPA_L21"},
{R_HPPA_R11, 0, 3, 11, false, 0, false, true, hppa_elf_reloc, "R_HPPA_R11"},
{R_HPPA_R14, 0, 3, 14, false, 0, false, true, hppa_elf_reloc, "R_HPPA_R14"},
{R_HPPA_R17, 0, 3, 17, false, 0, false, true, hppa_elf_reloc, "R_HPPA_R17"},
{R_HPPA_LS21, 0, 3, 21, false, 0, false, true, hppa_elf_reloc, "R_HPPA_LS21"},
{R_HPPA_RS11, 0, 3, 11, false, 0, false, true, hppa_elf_reloc, "R_HPPA_RS11"},
{R_HPPA_RS14, 0, 3, 14, false, 0, false, true, hppa_elf_reloc, "R_HPPA_RS14"},
{R_HPPA_RS17, 0, 3, 17, false, 0, false, true, hppa_elf_reloc, "R_HPPA_RS17"},
{R_HPPA_LD21, 0, 3, 21, false, 0, false, true, hppa_elf_reloc, "R_HPPA_LD21"},
{R_HPPA_RD11, 0, 3, 11, false, 0, false, true, hppa_elf_reloc, "R_HPPA_RD11"},
{R_HPPA_RD14, 0, 3, 14, false, 0, false, true, hppa_elf_reloc, "R_HPPA_RD14"},
{R_HPPA_RD17, 0, 3, 17, false, 0, false, true, hppa_elf_reloc, "R_HPPA_RD17"},
{R_HPPA_LR21, 0, 3, 21, false, 0, false, true, hppa_elf_reloc, "R_HPPA_LR21"},
{R_HPPA_RR14, 0, 3, 14, false, 0, false, true, hppa_elf_reloc, "R_HPPA_RR14"},
{R_HPPA_RR17, 0, 3, 17, false, 0, false, true, hppa_elf_reloc, "R_HPPA_RR17"},
/* 9.3.5. GOTOFF address relocation types */
{R_HPPA_GOTOFF_11, 0, 3, 11, false, 0, false, true, hppa_elf_reloc, "R_HPPA_GOTOFF_11"},
{R_HPPA_GOTOFF_14, 0, 3, 14, false, 0, false, true, hppa_elf_reloc, "R_HPPA_GOTOFF_14"},
{R_HPPA_GOTOFF_L21, 0, 3, 21, false, 0, false, true, hppa_elf_reloc, "R_HPPA_GOTOFF_L21"},
{R_HPPA_GOTOFF_R11, 0, 3, 11, false, 0, false, true, hppa_elf_reloc, "R_HPPA_GOTOFF_R11"},
{R_HPPA_GOTOFF_R14, 0, 3, 14, false, 0, false, true, hppa_elf_reloc, "R_HPPA_GOTOFF_R14"},
{R_HPPA_GOTOFF_LS21, 0, 3, 21, false, 0, false, true, hppa_elf_reloc, "R_HPPA_GOTOFF_LS21"},
{R_HPPA_GOTOFF_RS11, 0, 3, 11, false, 0, false, true, hppa_elf_reloc, "R_HPPA_GOTOFF_RS11"},
{R_HPPA_GOTOFF_RS14, 0, 3, 14, false, 0, false, true, hppa_elf_reloc, "R_HPPA_GOTOFF_RS14"},
{R_HPPA_GOTOFF_LD21, 0, 3, 21, false, 0, false, true, hppa_elf_reloc, "R_HPPA_GOTOFF_LD21"},
{R_HPPA_GOTOFF_RD11, 0, 3, 11, false, 0, false, true, hppa_elf_reloc, "R_HPPA_GOTOFF_RD11"},
{R_HPPA_GOTOFF_RD14, 0, 3, 14, false, 0, false, true, hppa_elf_reloc, "R_HPPA_GOTOFF_RD14"},
{R_HPPA_GOTOFF_LR21, 0, 3, 21, false, 0, false, true, hppa_elf_reloc, "R_HPPA_GOTOFF_LR21"},
{R_HPPA_GOTOFF_RR14, 0, 3, 14, false, 0, false, true, hppa_elf_reloc, "R_HPPA_GOTOFF_RR14"},
/* 9.3.6. Absolute call relocation types */
{R_HPPA_ABS_CALL_11, 0, 3, 11, false, 0, false, true, hppa_elf_reloc, "R_HPPA_ABS_CALL_11"},
{R_HPPA_ABS_CALL_14, 0, 3, 14, false, 0, false, true, hppa_elf_reloc, "R_HPPA_ABS_CALL_14"},
{R_HPPA_ABS_CALL_17, 0, 3, 17, false, 0, false, true, hppa_elf_reloc, "R_HPPA_ABS_CALL_17"},
{R_HPPA_ABS_CALL_L21, 0, 3, 21, false, 0, false, true, hppa_elf_reloc, "R_HPPA_ABS_CALL_L21"},
{R_HPPA_ABS_CALL_R11, 0, 3, 11, false, 0, false, true, hppa_elf_reloc, "R_HPPA_ABS_CALL_R11"},
{R_HPPA_ABS_CALL_R14, 0, 3, 14, false, 0, false, true, hppa_elf_reloc, "R_HPPA_ABS_CALL_R14"},
{R_HPPA_ABS_CALL_R17, 0, 3, 17, false, 0, false, true, hppa_elf_reloc, "R_HPPA_ABS_CALL_R17"},
{R_HPPA_ABS_CALL_LS21, 0, 3, 21, false, 0, false, true, hppa_elf_reloc, "R_HPPA_ABS_CALL_LS21"},
{R_HPPA_ABS_CALL_RS11, 0, 3, 11, false, 0, false, true, hppa_elf_reloc, "R_HPPA_ABS_CALL_RS11"},
{R_HPPA_ABS_CALL_RS14, 0, 3, 14, false, 0, false, true, hppa_elf_reloc, "R_HPPA_ABS_CALL_RS14"},
{R_HPPA_ABS_CALL_RS17, 0, 3, 17, false, 0, false, true, hppa_elf_reloc, "R_HPPA_ABS_CALL_RS17"},
{R_HPPA_ABS_CALL_LD21, 0, 3, 21, false, 0, false, true, hppa_elf_reloc, "R_HPPA_ABS_CALL_LD21"},
{R_HPPA_ABS_CALL_RD11, 0, 3, 11, false, 0, false, true, hppa_elf_reloc, "R_HPPA_ABS_CALL_RD11"},
{R_HPPA_ABS_CALL_RD14, 0, 3, 14, false, 0, false, true, hppa_elf_reloc, "R_HPPA_ABS_CALL_RD14"},
{R_HPPA_ABS_CALL_RD17, 0, 3, 17, false, 0, false, true, hppa_elf_reloc, "R_HPPA_ABS_CALL_RD17"},
{R_HPPA_ABS_CALL_LR21, 0, 3, 21, false, 0, false, true, hppa_elf_reloc, "R_HPPA_ABS_CALL_LR21"},
{R_HPPA_ABS_CALL_RR14, 0, 3, 14, false, 0, false, true, hppa_elf_reloc, "R_HPPA_ABS_CALL_RR14"},
{R_HPPA_ABS_CALL_RR17, 0, 3, 17, false, 0, false, true, 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, false, true, hppa_elf_reloc, "R_HPPA_PCREL_CALL_11"},
{R_HPPA_PCREL_CALL_14, 0, 3, 14, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PCREL_CALL_14"},
{R_HPPA_PCREL_CALL_17, 0, 3, 17, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PCREL_CALL_17"},
{R_HPPA_PCREL_CALL_12, 0, 3, 12, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PCREL_CALL_12"},
{R_HPPA_PCREL_CALL_L21, 0, 3, 21, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PCREL_CALL_L21"},
{R_HPPA_PCREL_CALL_R11, 0, 3, 11, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PCREL_CALL_R11"},
{R_HPPA_PCREL_CALL_R14, 0, 3, 14, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PCREL_CALL_R14"},
{R_HPPA_PCREL_CALL_R17, 0, 3, 17, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PCREL_CALL_R17"},
{R_HPPA_PCREL_CALL_LS21, 0, 3, 21, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PCREL_CALL_LS21"},
{R_HPPA_PCREL_CALL_RS11, 0, 3, 11, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RS11"},
{R_HPPA_PCREL_CALL_RS14, 0, 3, 14, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RS14"},
{R_HPPA_PCREL_CALL_RS17, 0, 3, 17, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RS17"},
{R_HPPA_PCREL_CALL_LD21, 0, 3, 21, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PCREL_CALL_LD21"},
{R_HPPA_PCREL_CALL_RD11, 0, 3, 11, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RD11"},
{R_HPPA_PCREL_CALL_RD14, 0, 3, 14, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RD14"},
{R_HPPA_PCREL_CALL_RD17, 0, 3, 17, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RD17"},
{R_HPPA_PCREL_CALL_LR21, 0, 3, 21, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PCREL_CALL_LR21"},
{R_HPPA_PCREL_CALL_RR14, 0, 3, 14, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RR14"},
{R_HPPA_PCREL_CALL_RR17, 0, 3, 17, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RR17"},
/* 9.3.8. Plabel relocation types */
{R_HPPA_PLABEL_32, 0, 3, 32, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PLABEL_32"},
{R_HPPA_PLABEL_11, 0, 3, 11, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PLABEL_11"},
{R_HPPA_PLABEL_14, 0, 3, 14, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PLABEL_14"},
{R_HPPA_PLABEL_L21, 0, 3, 21, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PLABEL_L21"},
{R_HPPA_PLABEL_R11, 0, 3, 11, true, 0, false, true, hppa_elf_reloc, "R_HPPA_PLABEL_R11"},
{R_HPPA_PLABEL_R14, 0, 3, 14, true, 0, false, true, 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, false, true, hppa_elf_reloc, "R_HPPA_DLT_32"},
{R_HPPA_DLT_11, 0, 3, 11, true, 0, false, true, hppa_elf_reloc, "R_HPPA_DLT_11"},
{R_HPPA_DLT_14, 0, 3, 14, true, 0, false, true, hppa_elf_reloc, "R_HPPA_DLT_14"},
{R_HPPA_DLT_L21, 0, 3, 21, true, 0, false, true, hppa_elf_reloc, "R_HPPA_DLT_L21"},
{R_HPPA_DLT_R11, 0, 3, 11, true, 0, false, true, hppa_elf_reloc, "R_HPPA_DLT_R11"},
{R_HPPA_DLT_R14, 0, 3, 14, true, 0, false, true, hppa_elf_reloc, "R_HPPA_DLT_R14"},
/* 9.3.10. Relocations for unwinder tables */
{R_HPPA_UNWIND_ENTRY, 0, 3, 32, true, 0, false, true, hppa_elf_reloc, "R_HPPA_UNWIND_ENTRY"},
{R_HPPA_UNWIND_ENTRIES, 0, 3, 32, true, 0, false, true, hppa_elf_reloc, "R_HPPA_UNWIND_ENTRIES"},
/* 9.3.11. Relocation types for complex expressions */
{R_HPPA_PUSH_CONST, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_PUSH_CONST"},
{R_HPPA_PUSH_PC, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_PUSH_PC"},
{R_HPPA_PUSH_SYM, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_PUSH_SYM"},
{R_HPPA_PUSH_GOTOFF, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_PUSH_GOTOFF"},
{R_HPPA_PUSH_ABS_CALL, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_PUSH_ABS_CALL"},
{R_HPPA_PUSH_PCREL_CALL, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_PUSH_PCREL_CALL"},
{R_HPPA_PUSH_PLABEL, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_PUSH_PLABEL"},
{R_HPPA_MAX, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_MAX"},
{R_HPPA_MIN, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_MIN"},
{R_HPPA_ADD, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_ADD"},
{R_HPPA_SUB, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_SUB"},
{R_HPPA_MULT, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_MULT"},
{R_HPPA_DIV, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_DIV"},
{R_HPPA_MOD, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_MOD"},
{R_HPPA_AND, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_AND"},
{R_HPPA_OR, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_OR"},
{R_HPPA_XOR, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_XOR"},
{R_HPPA_NOT, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_NOT"},
{R_HPPA_LSHIFT, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_LSHIFT"},
{R_HPPA_ARITH_RSHIFT, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_ARITH_RSHIFT"},
{R_HPPA_LOGIC_RSHIFT, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_LOGIC_RSHIFT"},
{R_HPPA_EXPR_F, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_L"},
{R_HPPA_EXPR_L, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_EXPR_L"},
{R_HPPA_EXPR_R, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_EXPR_R"},
{R_HPPA_EXPR_LS, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_EXPR_LS"},
{R_HPPA_EXPR_RS, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_EXPR_RS"},
{R_HPPA_EXPR_LD, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_EXPR_LD"},
{R_HPPA_EXPR_RD, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_EXPR_RD"},
{R_HPPA_EXPR_LR, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_EXPR_LR"},
{R_HPPA_EXPR_RR, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_EXPR_RR"},
{R_HPPA_EXPR_32, 0, 3, 32, false, 0, false, true, hppa_elf_reloc, "R_HPPA_EXPR_32"},
{R_HPPA_EXPR_21, 0, 3, 21, false, 0, false, true, hppa_elf_reloc, "R_HPPA_EXPR_21"},
{R_HPPA_EXPR_11, 0, 3, 11, false, 0, false, true, hppa_elf_reloc, "R_HPPA_EXPR_11"},
{R_HPPA_EXPR_14, 0, 3, 14, false, 0, false, true, hppa_elf_reloc, "R_HPPA_EXPR_14"},
{R_HPPA_EXPR_17, 0, 3, 17, false, 0, false, true, hppa_elf_reloc, "R_HPPA_EXPR_17"},
{R_HPPA_EXPR_12, 0, 3, 12, false, 0, false, true, hppa_elf_reloc, "R_HPPA_EXPR_12"},
{R_HPPA_UNIMPLEMENTED, 0, 0, 0, false, 0, false, false, NULL, "R_HPPA_UNIMPLEMENTED"},
};
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
updates from Utah
1993-06-03 20:55:48 +00:00
static symext_chainS *symext_rootP = NULL;
static symext_chainS *symext_lastP = NULL;
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
updates from Utah
1993-06-03 20:55:48 +00:00
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;
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
}
static unsigned long
updates from Utah
1993-06-03 20:55:48 +00:00
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)
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
{
updates from Utah
1993-06-03 20:55:48 +00:00
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_format, 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);
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
updates from Utah
1993-06-03 20:55:48 +00:00
return hppa_elf_rebuild_insn (abfd, insn, sym_value >> 2, r_type, r_field, r_format);
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
updates from Utah
1993-06-03 20:55:48 +00:00
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;
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
}
updates from Utah
1993-06-03 20:55:48 +00:00
}
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
}
static void
updates from Utah
1993-06-03 20:55:48 +00:00
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)
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
{
updates from Utah
1993-06-03 20:55:48 +00:00
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 fsize;
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);
hit_data += sizeof (unsigned long);
end_offset = bfd_get_32 (abfd, hit_data);
/* We could also compute the ending offset for */
/* the 2nd word of the unwind entry by */
/* retrieving the st_size field of the Elf_Sym */
/* structure stored with this symbol. We can */
/* get it with: */
/* e = (elf_symbol_type *)symp */
/* fsize = e->internal_elf_sym.st_size */
fsize = end_offset - start_offset;
relocated_value = hppa_field_adjust (sym_value, fsize, r_field);
bfd_put_32 (abfd, relocated_value, 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 += fsize + start_offset - end_offset;
}
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
}
updates from Utah
1993-06-03 20:55:48 +00:00
break;
default:
fprintf (stderr,
"Unrecognized relocation type 0x%02x (fmt=%x,field=%x)\n",
r_type, r_format, r_field);
}
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
}
/* Provided the symbol, returns the value reffed */
updates from Utah
1993-06-03 20:55:48 +00:00
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);
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
}
/* 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
updates from Utah
1993-06-03 20:55:48 +00:00
hppa_elf_gen_reloc_error (base_type, fmt, field)
elf32_hppa_reloc_type base_type;
int fmt;
int field;
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
{
updates from Utah
1993-06-03 20:55:48 +00:00
fprintf (stderr, "undefined relocation: base=0x%x,fmt=0x%x,field=0x%x\n",
base_type, fmt, field);
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
}
updates from Utah
1993-06-03 20:55:48 +00:00
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;
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
{
#define UNDEFINED hppa_elf_gen_reloc_error(base_type,format,field);
updates from Utah
1993-06-03 20:55:48 +00:00
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:
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
default:
updates from Utah
1993-06-03 20:55:48 +00:00
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;
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
}
updates from Utah
1993-06-03 20:55:48 +00:00
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;
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
}
updates from Utah
1993-06-03 20:55:48 +00:00
#undef final_type
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
/* 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
updates from Utah
1993-06-03 20:55:48 +00:00
hppa_elf_insn2fmt (type, insn)
elf32_hppa_reloc_type type;
unsigned long insn;
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
{
updates from Utah
1993-06-03 20:55:48 +00:00
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;
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
}
updates from Utah
1993-06-03 20:55:48 +00:00
}
return fmt;
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
}
/* this function is in charge of performing all the HP PA relocations */
updates from Utah
1993-06-03 20:55:48 +00:00
static long global_value = 0;
static long GOT_value = 0; /* XXX: need to calculate this! For HPUX, GOT == DP */
static asymbol *global_symbol = (asymbol *) NULL;
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
static bfd_reloc_status_type
updates from Utah
1993-06-03 20:55:48 +00:00
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_symbol == (asymbol *) NULL)
{
struct elf32_backend_data *bed
= (struct elf32_backend_data *) abfd->xvec->backend_data;
if (bed && bed->global_sym)
{
asymbol *gsym = &bed->global_sym->symbol;
global_value
= gsym->value
+ gsym->section->output_section->vma
+ gsym->section->output_offset;
GOT_value = global_value; /* XXX: For HP-UX, GOT==DP */
global_symbol = gsym;
}
}
/* 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);
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);
}
struct elf_reloc_map
{
unsigned char bfd_reloc_val;
unsigned char elf_reloc_val;
};
static CONST struct elf_reloc_map elf_hppa_reloc_map[] =
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
{
updates from Utah
1993-06-03 20:55:48 +00:00
{BFD_RELOC_NONE, R_HPPA_NONE,},
{BFD_RELOC_HPPA_32, R_HPPA_32,},
{BFD_RELOC_HPPA_11, R_HPPA_11,},
{BFD_RELOC_HPPA_14, R_HPPA_14,},
{BFD_RELOC_HPPA_17, R_HPPA_17,},
{BFD_RELOC_HPPA_L21, R_HPPA_L21,},
{BFD_RELOC_HPPA_R11, R_HPPA_R11,},
{BFD_RELOC_HPPA_R14, R_HPPA_R14,},
{BFD_RELOC_HPPA_R17, R_HPPA_R17,},
{BFD_RELOC_HPPA_LS21, R_HPPA_LS21,},
{BFD_RELOC_HPPA_RS11, R_HPPA_RS11,},
{BFD_RELOC_HPPA_RS14, R_HPPA_RS14,},
{BFD_RELOC_HPPA_RS17, R_HPPA_RS17,},
{BFD_RELOC_HPPA_LD21, R_HPPA_LD21,},
{BFD_RELOC_HPPA_RD11, R_HPPA_RD11,},
{BFD_RELOC_HPPA_RD14, R_HPPA_RD14,},
{BFD_RELOC_HPPA_RD17, R_HPPA_RD17,},
{BFD_RELOC_HPPA_LR21, R_HPPA_LR21,},
{BFD_RELOC_HPPA_RR14, R_HPPA_RR14,},
{BFD_RELOC_HPPA_RR17, R_HPPA_RR17,},
{BFD_RELOC_HPPA_GOTOFF_11, R_HPPA_GOTOFF_11,},
{BFD_RELOC_HPPA_GOTOFF_14, R_HPPA_GOTOFF_14,},
{BFD_RELOC_HPPA_GOTOFF_L21, R_HPPA_GOTOFF_L21,},
{BFD_RELOC_HPPA_GOTOFF_R11, R_HPPA_GOTOFF_R11,},
{BFD_RELOC_HPPA_GOTOFF_R14, R_HPPA_GOTOFF_R14,},
{BFD_RELOC_HPPA_GOTOFF_LS21, R_HPPA_GOTOFF_LS21,},
{BFD_RELOC_HPPA_GOTOFF_RS11, R_HPPA_GOTOFF_RS11,},
{BFD_RELOC_HPPA_GOTOFF_RS14, R_HPPA_GOTOFF_RS14,},
{BFD_RELOC_HPPA_GOTOFF_LD21, R_HPPA_GOTOFF_LD21,},
{BFD_RELOC_HPPA_GOTOFF_RD11, R_HPPA_GOTOFF_RD11,},
{BFD_RELOC_HPPA_GOTOFF_RD14, R_HPPA_GOTOFF_RD14,},
{BFD_RELOC_HPPA_GOTOFF_LR21, R_HPPA_GOTOFF_LR21,},
{BFD_RELOC_HPPA_GOTOFF_RR14, R_HPPA_GOTOFF_RR14,},
{BFD_RELOC_HPPA_ABS_CALL_11, R_HPPA_ABS_CALL_11,},
{BFD_RELOC_HPPA_ABS_CALL_14, R_HPPA_ABS_CALL_14,},
{BFD_RELOC_HPPA_ABS_CALL_17, R_HPPA_ABS_CALL_17,},
{BFD_RELOC_HPPA_ABS_CALL_L21, R_HPPA_ABS_CALL_L21,},
{BFD_RELOC_HPPA_ABS_CALL_R11, R_HPPA_ABS_CALL_R11,},
{BFD_RELOC_HPPA_ABS_CALL_R14, R_HPPA_ABS_CALL_R14,},
{BFD_RELOC_HPPA_ABS_CALL_R17, R_HPPA_ABS_CALL_R17,},
{BFD_RELOC_HPPA_ABS_CALL_LS21, R_HPPA_ABS_CALL_LS21,},
{BFD_RELOC_HPPA_ABS_CALL_RS11, R_HPPA_ABS_CALL_RS11,},
{BFD_RELOC_HPPA_ABS_CALL_RS14, R_HPPA_ABS_CALL_RS14,},
{BFD_RELOC_HPPA_ABS_CALL_RS17, R_HPPA_ABS_CALL_RS17,},
{BFD_RELOC_HPPA_ABS_CALL_LD21, R_HPPA_ABS_CALL_LD21,},
{BFD_RELOC_HPPA_ABS_CALL_RD11, R_HPPA_ABS_CALL_RD11,},
{BFD_RELOC_HPPA_ABS_CALL_RD14, R_HPPA_ABS_CALL_RD14,},
{BFD_RELOC_HPPA_ABS_CALL_RD17, R_HPPA_ABS_CALL_RD17,},
{BFD_RELOC_HPPA_ABS_CALL_LR21, R_HPPA_ABS_CALL_LR21,},
{BFD_RELOC_HPPA_ABS_CALL_RR14, R_HPPA_ABS_CALL_RR14,},
{BFD_RELOC_HPPA_ABS_CALL_RR17, R_HPPA_ABS_CALL_RR17,},
{BFD_RELOC_HPPA_PCREL_CALL_11, R_HPPA_PCREL_CALL_11,},
{BFD_RELOC_HPPA_PCREL_CALL_14, R_HPPA_PCREL_CALL_14,},
{BFD_RELOC_HPPA_PCREL_CALL_17, R_HPPA_PCREL_CALL_17,},
{BFD_RELOC_HPPA_PCREL_CALL_12, R_HPPA_PCREL_CALL_12,},
{BFD_RELOC_HPPA_PCREL_CALL_L21, R_HPPA_PCREL_CALL_L21,},
{BFD_RELOC_HPPA_PCREL_CALL_R11, R_HPPA_PCREL_CALL_R11,},
{BFD_RELOC_HPPA_PCREL_CALL_R14, R_HPPA_PCREL_CALL_R14,},
{BFD_RELOC_HPPA_PCREL_CALL_R17, R_HPPA_PCREL_CALL_R17,},
{BFD_RELOC_HPPA_PCREL_CALL_LS21, R_HPPA_PCREL_CALL_LS21,},
{BFD_RELOC_HPPA_PCREL_CALL_RS11, R_HPPA_PCREL_CALL_RS11,},
{BFD_RELOC_HPPA_PCREL_CALL_RS14, R_HPPA_PCREL_CALL_RS14,},
{BFD_RELOC_HPPA_PCREL_CALL_RS17, R_HPPA_PCREL_CALL_RS17,},
{BFD_RELOC_HPPA_PCREL_CALL_LD21, R_HPPA_PCREL_CALL_LD21,},
{BFD_RELOC_HPPA_PCREL_CALL_RD11, R_HPPA_PCREL_CALL_RD11,},
{BFD_RELOC_HPPA_PCREL_CALL_RD14, R_HPPA_PCREL_CALL_RD14,},
{BFD_RELOC_HPPA_PCREL_CALL_RD17, R_HPPA_PCREL_CALL_RD17,},
{BFD_RELOC_HPPA_PCREL_CALL_LR21, R_HPPA_PCREL_CALL_LR21,},
{BFD_RELOC_HPPA_PCREL_CALL_RR14, R_HPPA_PCREL_CALL_RR14,},
{BFD_RELOC_HPPA_PCREL_CALL_RR17, R_HPPA_PCREL_CALL_RR17,},
{BFD_RELOC_HPPA_PLABEL_32, R_HPPA_PLABEL_32,},
{BFD_RELOC_HPPA_PLABEL_11, R_HPPA_PLABEL_11,},
{BFD_RELOC_HPPA_PLABEL_14, R_HPPA_PLABEL_14,},
{BFD_RELOC_HPPA_PLABEL_L21, R_HPPA_PLABEL_L21,},
{BFD_RELOC_HPPA_PLABEL_R11, R_HPPA_PLABEL_R11,},
{BFD_RELOC_HPPA_PLABEL_R14, R_HPPA_PLABEL_R14,},
{BFD_RELOC_HPPA_DLT_32, R_HPPA_DLT_32,},
{BFD_RELOC_HPPA_DLT_11, R_HPPA_DLT_11,},
{BFD_RELOC_HPPA_DLT_14, R_HPPA_DLT_14,},
{BFD_RELOC_HPPA_DLT_L21, R_HPPA_DLT_L21,},
{BFD_RELOC_HPPA_DLT_R11, R_HPPA_DLT_R11,},
{BFD_RELOC_HPPA_DLT_R14, R_HPPA_DLT_R14,},
{BFD_RELOC_HPPA_UNWIND_ENTRY, R_HPPA_UNWIND_ENTRY,},
{BFD_RELOC_HPPA_UNWIND_ENTRIES, R_HPPA_UNWIND_ENTRIES,},
};
static reloc_howto_type *
elf_hppa_reloc_type_lookup (arch, code)
bfd_arch_info_type *arch;
bfd_reloc_code_real_type code;
{
int i;
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
elf32_symbol_type * symbolP AND
int sym_idx)
{
symext_chainS *symextP;
unsigned int arg_reloc;
if (!(symbolP->symbol.flags & BSF_FUNCTION))
return;
if (!((symbolP->symbol.flags & BSF_EXPORT) ||
(symbolP->symbol.flags & BSF_GLOBAL)))
return;
arg_reloc = symbolP->tc_data.hppa_arg_reloc;
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];
}
}
static symext_entryS *symextn_contents = NULL;
static unsigned int symextn_contents_real_size = 0;
void
DEFUN (elf_hppa_tc_make_sections, (abfd, ignored),
bfd * abfd AND
PTR ignored)
{
symext_chainS *symextP;
symext_entryS *outbound_symexts;
int size;
int n;
int i;
extern char *stub_section_contents; /* forward declaration */
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:
{
elf32_symbol_type *esymP = (elf32_symbol_type *) sym;
retval = (symext_entryS) esymP->tc_data.hppa_arg_reloc;
break;
}
}
return retval;
}
typedef struct Elf32_hppa_Stub_description_struct
{
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_description;
typedef struct Elf32_hppa_Stub_list_struct
{
Elf32_hppa_Stub_description *stub;
struct Elf32_hppa_Stub_list_struct *next;
} Elf32_hppa_Stub_list;
static Elf32_hppa_Stub_list *elf_hppa_stub_rootP = NULL;
/* 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_list *stubP;
for (stubP = elf_hppa_stub_rootP; stubP; stubP = stubP->next)
{
if (stubP->stub->this_bfd == abfd
&& stubP->stub->stub_sec == stub_sec)
return stubP->stub;
}
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));
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;
return stub;
}
static void
add_stub (stub)
Elf32_hppa_Stub_description *stub;
{
Elf32_hppa_Stub_list *new_entry;
new_entry = (Elf32_hppa_Stub_list *) bfd_zalloc (stub->this_bfd, sizeof (Elf32_hppa_Stub_list));
if (new_entry)
{
new_entry->stub = stub;
if (elf_hppa_stub_rootP)
{
new_entry->next = elf_hppa_stub_rootP;
elf_hppa_stub_rootP = new_entry;
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
}
updates from Utah
1993-06-03 20:55:48 +00:00
else
{
new_entry->next = (Elf32_hppa_Stub_list *) NULL;
elf_hppa_stub_rootP = new_entry;
}
}
else
{
bfd_error = no_memory;
bfd_perror ("add_stub");
}
}
#define ARGUMENTS 0
#define RETURN_VALUE 1
#define NO_ARG_RELOC 0
#define R_TO_FR 1
#define FR_TO_R 2
#define ARG_RELOC_ERR 3
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
updates from Utah
1993-06-03 20:55:48 +00:00
#define ARG0 0
#define ARG1 1
#define ARG2 2
#define ARG3 3
#define RETVAL 4
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
updates from Utah
1993-06-03 20:55:48 +00:00
#define AR_NO 0
#define AR_GR 1
#define AR_FR 2
#define AR_FU 3
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
updates from Utah
1993-06-03 20:55:48 +00:00
static CONST char *CONST reloc_type_strings[] =
{
"NONE", "GR->FR", "FR->GR", "ERROR"
};
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
updates from Utah
1993-06-03 20:55:48 +00:00
static CONST char mismatches[4][4] =
{ /* CALLEE NONE CALLEE GR CALLEE FR CALLEE FU */
/* CALLER NONE */
{NO_ARG_RELOC, NO_ARG_RELOC, NO_ARG_RELOC, NO_ARG_RELOC},
/* CALLER GR */
{NO_ARG_RELOC, NO_ARG_RELOC, R_TO_FR, R_TO_FR},
/* CALLER FR */
{NO_ARG_RELOC, FR_TO_R, NO_ARG_RELOC, NO_ARG_RELOC},
/* CALLER FU */
{NO_ARG_RELOC, FR_TO_R, NO_ARG_RELOC, NO_ARG_RELOC},
};
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
updates from Utah
1993-06-03 20:55:48 +00:00
static CONST char retval_mismatches[4][4] =
{ /* CALLEE NONE CALLEE GR CALLEE FR CALLEE FU */
/* CALLER NONE */
{NO_ARG_RELOC, NO_ARG_RELOC, NO_ARG_RELOC, NO_ARG_RELOC},
/* CALLER GR */
{NO_ARG_RELOC, NO_ARG_RELOC, R_TO_FR, R_TO_FR},
/* CALLER FR */
{NO_ARG_RELOC, FR_TO_R, NO_ARG_RELOC, NO_ARG_RELOC},
/* CALLER FU */
{NO_ARG_RELOC, FR_TO_R, NO_ARG_RELOC, 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
#include "hppa_stubs.h"
#define NEW_INSTRUCTION(desc,insn) \
*((desc)->stub_secp)++ = (insn); \
(desc)->real_size += sizeof(int); \
bfd_set_section_size((desc)->this_bfd,(desc)->stub_sec,(desc)->real_size);
void
hppa_elf_stub_finish (output_bfd)
bfd *output_bfd;
{
extern bfd_error_vector_type bfd_error_vector;
Elf32_hppa_Stub_list *stub_list = elf_hppa_stub_rootP;
/* All the stubs have been built. Finish up building */
/* stub section. Apply relocations to the section. */
for (; stub_list; stub_list = stub_list->next)
{
if (stub_list->stub->real_size)
{
bfd *stub_bfd = stub_list->stub->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->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->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->stub_contents,
0,
stub_list->stub->real_size);
free (reloc_vector);
}
}
}
void
hppa_elf_stub_branch_reloc (stub_desc, /* the bfd */
output_bfd, /* the output bfd */
stub_sym, /* the stub symbol */
offset) /* the offset within the stub buffer (pre-calculated) */
Elf32_hppa_Stub_description *stub_desc;
bfd *output_bfd;
asymbol *stub_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] = stub_sym;
relent.howto = bfd_reloc_type_lookup (stub_desc->this_bfd, R_HPPA_ABS_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));
}
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;
asection *output_text_section = bfd_get_section_by_name (output_bfd, ".text");
int i;
char stub_sym_name[128];
if (!stub_sec)
{
BFD_ASSERT (stub_desc == NULL);
stub_sec = bfd_make_section (abfd, ".hppa_linker_stubs");
bfd_set_section_flags (output_bfd,
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 (output_bfd, stub_sec, 2);
stub_desc = new_stub (abfd, stub_sec);
add_stub (stub_desc);
}
/* make sure we have a stub descriptor structure */
if (!stub_desc)
{
stub_desc = new_stub (abfd, stub_sec);
add_stub (stub_desc);
}
/* 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);
/* create a symbol to point to this stub */
stub_sym = bfd_make_empty_symbol (abfd);
sprintf (stub_sym_name,
"_stub_%s_%02d_%02d_%02d_%02d_%02d\000",
reloc_entry->sym_ptr_ptr[0]->name,
stub_types[0], stub_types[1], stub_types[2], stub_types[3], stub_types[4]);
stub_sym->name = bfd_zalloc (output_bfd, 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;
/* 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_desc, 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_desc, LDWS_M8SP_ARG0);
NEW_INSTRUCTION (stub_desc, FSTWS_FARG0_M8SP);
break;
case ARG1:
NEW_INSTRUCTION (stub_desc, LDWS_M8SP_ARG1);
NEW_INSTRUCTION (stub_desc, FSTWS_FARG1_M8SP);
break;
case ARG2:
NEW_INSTRUCTION (stub_desc, LDWS_M8SP_ARG1);
NEW_INSTRUCTION (stub_desc, FSTWS_FARG1_M8SP);
break;
case ARG3:
NEW_INSTRUCTION (stub_desc, LDWS_M8SP_ARG1);
NEW_INSTRUCTION (stub_desc, FSTWS_FARG1_M8SP);
break;
}
break;
case FR_TO_R:
switch (i)
{
case ARG0:
NEW_INSTRUCTION (stub_desc, FLDWS_M8SP_FARG0);
NEW_INSTRUCTION (stub_desc, STWS_ARG0_M8SP);
break;
case ARG1:
NEW_INSTRUCTION (stub_desc, FLDWS_M8SP_FARG1);
NEW_INSTRUCTION (stub_desc, STWS_ARG1_M8SP);
break;
case ARG2:
NEW_INSTRUCTION (stub_desc, FLDWS_M8SP_FARG1);
NEW_INSTRUCTION (stub_desc, STWS_ARG1_M8SP);
break;
case ARG3:
NEW_INSTRUCTION (stub_desc, FLDWS_M8SP_FARG1);
NEW_INSTRUCTION (stub_desc, STWS_ARG1_M8SP);
break;
}
break;
}
}
}
/* generate the branch to the target routine */
NEW_INSTRUCTION (stub_desc, STW_RP_M8SP); /* First, save the return address */
NEW_INSTRUCTION (stub_desc, BL_XXX_RP); /* set up a branch to the function */
/* Fix the branch to the function. We can do this with a relocation. */
hppa_elf_stub_branch_reloc (stub_desc,
output_bfd, /* the output bfd */
stub_sym, /* the stub symbol */
(int) stub_desc->stub_secp - (int) stub_desc->stub_contents - 4); /* the offset within the stub buffer */
NEW_INSTRUCTION (stub_desc, NOP);
/* generate the code to move the return value around */
i = RETVAL;
if (stub_types[i] != NO_ARG_RELOC)
{
/* A stub is needed */
switch (stub_types[i])
{
case R_TO_FR:
NEW_INSTRUCTION (stub_desc, LDWS_M8SP_RET0);
NEW_INSTRUCTION (stub_desc, FSTWS_FRET0_M8SP);
break;
case FR_TO_R:
NEW_INSTRUCTION (stub_desc, FLDWS_M8SP_FRET0);
NEW_INSTRUCTION (stub_desc, STWS_RET0_M8SP);
break;
}
}
/* generate the ending common section for all stubs */
NEW_INSTRUCTION (stub_desc, LDW_M8SP_RP); /* restore return address */
NEW_INSTRUCTION (stub_desc, SUBI_8_SP);
/* XXX: can we assume this is a save return? */
NEW_INSTRUCTION (stub_desc, BV_N_0RP);
return stub_sym;
}
int
hppa_elf_arg_reloc_needed_p (abfd, reloc_entry, stub_types)
bfd *abfd;
arelent *reloc_entry;
int stub_types[5];
{
int i;
/* 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 caller_ar = (symext_entryS) ELF32_HPPA_R_ARG_RELOC (reloc_entry->addend);
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_FU;
caller_loc[ARG1] = AR_NO;
}
if (caller_loc[ARG2] == AR_FU || caller_loc[ARG3] == AR_FU)
{
caller_loc[ARG2] = AR_FU;
caller_loc[ARG3] = AR_NO;
}
if (callee_loc[ARG0] == AR_FU || callee_loc[ARG1] == AR_FU)
{
callee_loc[ARG0] = AR_FU;
callee_loc[ARG1] = AR_NO;
}
if (callee_loc[ARG2] == AR_FU || callee_loc[ARG3] == AR_FU)
{
callee_loc[ARG2] = AR_FU;
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);
/* XXX for now, just report a */
/* warning */
/* But, when we start building stubs, here are the steps involved: */
/* 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_ABS_CALL to the stub routine. */
if (stub_types[0]
|| stub_types[1]
|| stub_types[2]
|| stub_types[3]
|| stub_types[4])
{
#ifdef DETECT_STUBS
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]]);
}
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
}
updates from Utah
1993-06-03 20:55:48 +00:00
fprintf (stderr, "\n");
#endif
return 1;
}
}
}
return 0;
}
asymbol *
hppa_elf_stub_check (abfd, output_bfd, reloc_entry)
bfd *abfd;
bfd *output_bfd;
arelent *reloc_entry;
{
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 */
if (hppa_elf_arg_reloc_needed_p (abfd, reloc_entry, stub_types))
{
/* generate a stub */
return hppa_elf_build_arg_reloc_stub (abfd, output_bfd, reloc_entry, stub_types);
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
}
updates from Utah
1993-06-03 20:55:48 +00:00
break;
default:
break;
}
return reloc_entry->sym_ptr_ptr[0];
}
#define STUB_SYM_BUFFER_INC 5
asymbol *
hppa_look_for_stubs_in_section (abfd, output_bfd, asec, syms, new_sym_cnt)
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
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
updates from Utah
1993-06-03 20:55:48 +00:00
arelent *rle = reloc_vector[i];
switch (rle->howto->type)
{
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
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 */
updates from Utah
1993-06-03 20:55:48 +00:00
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
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 */
updates from Utah
1993-06-03 20:55:48 +00:00
case R_HPPA_PCREL_CALL_12: /* Symbol - PC + Addend 12 */
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
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 */
updates from Utah
1993-06-03 20:55:48 +00:00
case R_HPPA_PCREL_CALL_RR17: /* RR(Symbol - PC, Addend) 17 */
if (hppa_elf_arg_reloc_needed_p (abfd, rle, stub_types))
{
/* generate a stub */
/* keep track of the new symbol */
if (new_cnt == new_max)
{
new_max += STUB_SYM_BUFFER_INC;
new_syms = (asymbol *) realloc (new_syms, new_max * sizeof (asymbol));
}
new_syms[new_cnt++] = *(hppa_elf_build_arg_reloc_stub (abfd, output_bfd, rle, stub_types));
}
break;
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
updates from Utah
1993-06-03 20:55:48 +00:00
default:
break;
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
updates from Utah
1993-06-03 20:55:48 +00:00
}
}
}
*new_sym_cnt = new_cnt;
return new_syms;
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
}
updates from Utah
1993-06-03 20:55:48 +00:00
int
hppa_look_for_stubs (abfd, output_bfd)
bfd *abfd;
bfd *output_bfd;
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
{
updates from Utah
1993-06-03 20:55:48 +00:00
/* bfd_map_over_sections(abfd,hppa_look_for_stubs_in_section,(PTR)output_bfd,NULL); */
}
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
updates from Utah
1993-06-03 20:55:48 +00:00
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);
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
}
fixed up to use elf32-target.h
1993-04-29 15:48:49 +00:00
static void
DEFUN (elf_info_to_howto, (abfd, cache_ptr, dst),
updates from Utah
1993-06-03 20:55:48 +00:00
bfd * abfd AND
arelent * cache_ptr AND
Elf32_Internal_Rela * dst)
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
{
fixed up to use elf32-target.h
1993-04-29 15:48:49 +00:00
abort ();
}
checkpoint hppa-elf code from Utah (Sanitize out until it's cleaned up & working)
1993-04-28 22:55:25 +00:00
updates from Utah
1993-06-03 20:55:48 +00:00
#define TARGET_BIG_SYM bfd_elf32_hppa_vec
fixed up to use elf32-target.h
1993-04-29 15:48:49 +00:00
#define TARGET_BIG_NAME "elf32-hppa"
#define ELF_ARCH bfd_arch_hppa
#include "elf32-target.h"
Reference in a new issue Copy permalink