/src/binutils-gdb/bfd/mach-o-arm.c

Source (jump to first uncovered line)
/* ARM Mach-O support for BFD.
   Copyright (C) 2015-2023 Free Software Foundation, Inc.

   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 3 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., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */

#include "sysdep.h"
#include "bfd.h"
#include "libbfd.h"
#include "libiberty.h"
#include "mach-o.h"
#include "mach-o/arm.h"

#define bfd_mach_o_object_p bfd_mach_o_arm_object_p
#define bfd_mach_o_core_p bfd_mach_o_arm_core_p
#define bfd_mach_o_mkobject bfd_mach_o_arm_mkobject

#define bfd_mach_o_canonicalize_one_reloc bfd_mach_o_arm_canonicalize_one_reloc
#define bfd_mach_o_swap_reloc_out  NULL
#define bfd_mach_o_bfd_reloc_type_lookup bfd_mach_o_arm_bfd_reloc_type_lookup
#define bfd_mach_o_bfd_reloc_name_lookup bfd_mach_o_arm_bfd_reloc_name_lookup

#define bfd_mach_o_print_thread NULL
#define bfd_mach_o_tgt_seg_table NULL
#define bfd_mach_o_section_type_valid_for_tgt NULL

static bfd_cleanup
bfd_mach_o_arm_object_p (bfd *abfd)
{
  return bfd_mach_o_header_p (abfd, 0, 0, BFD_MACH_O_CPU_TYPE_ARM);
}

static bfd_cleanup
bfd_mach_o_arm_core_p (bfd *abfd)
{
  return bfd_mach_o_header_p (abfd, 0,
            BFD_MACH_O_MH_CORE, BFD_MACH_O_CPU_TYPE_ARM);
}

static bool
bfd_mach_o_arm_mkobject (bfd *abfd)
{
  bfd_mach_o_data_struct *mdata;

  if (!bfd_mach_o_mkobject_init (abfd))
    return false;

  mdata = bfd_mach_o_get_data (abfd);
  mdata->header.magic = BFD_MACH_O_MH_MAGIC;
  mdata->header.cputype = BFD_MACH_O_CPU_TYPE_ARM;
  mdata->header.cpusubtype = BFD_MACH_O_CPU_SUBTYPE_ARM_ALL;
  mdata->header.byteorder = BFD_ENDIAN_LITTLE;
  mdata->header.version = 1;

  return true;
}

static reloc_howto_type arm_howto_table[]=
{
  /* 0 */
  HOWTO (BFD_RELOC_32, 0, 4, 32, false, 0,
   complain_overflow_bitfield,
   NULL, "32",
   false, 0xffffffff, 0xffffffff, false),
  HOWTO (BFD_RELOC_16, 0, 2, 16, false, 0,
   complain_overflow_bitfield,
   NULL, "16",
   false, 0xffff, 0xffff, false),
  HOWTO (BFD_RELOC_8, 0, 1, 8, false, 0,
   complain_overflow_bitfield,
   NULL, "8",
   false, 0xff, 0xff, false),
  HOWTO (BFD_RELOC_32_PCREL, 0, 4, 32, true, 0,
   complain_overflow_bitfield,
   NULL, "DISP32",
   false, 0xffffffff, 0xffffffff, true),
  /* 4 */
  HOWTO (BFD_RELOC_16_PCREL, 0, 2, 16, true, 0,
   complain_overflow_bitfield,
   NULL, "DISP16",
   false, 0xffff, 0xffff, true),
  HOWTO (BFD_RELOC_MACH_O_SECTDIFF, 0, 4, 32, false, 0,
   complain_overflow_bitfield,
   NULL, "SECTDIFF_32",
   false, 0xffffffff, 0xffffffff, false),
  HOWTO (BFD_RELOC_MACH_O_LOCAL_SECTDIFF, 0, 4, 32, false, 0,
   complain_overflow_bitfield,
   NULL, "LSECTDIFF_32",
   false, 0xffffffff, 0xffffffff, false),
  HOWTO (BFD_RELOC_MACH_O_PAIR, 0, 4, 32, false, 0,
   complain_overflow_bitfield,
   NULL, "PAIR_32",
   false, 0xffffffff, 0xffffffff, false),
  /* 8 */
  HOWTO (BFD_RELOC_MACH_O_SECTDIFF, 0, 2, 16, false, 0,
   complain_overflow_bitfield,
   NULL, "SECTDIFF_16",
   false, 0xffff, 0xffff, false),
  HOWTO (BFD_RELOC_MACH_O_LOCAL_SECTDIFF, 0, 2, 16, false, 0,
   complain_overflow_bitfield,
   NULL, "LSECTDIFF_16",
   false, 0xffff, 0xffff, false),
  HOWTO (BFD_RELOC_MACH_O_PAIR, 0, 2, 16, false, 0,
   complain_overflow_bitfield,
   NULL, "PAIR_16",
   false, 0xffff, 0xffff, false),
  HOWTO (BFD_RELOC_ARM_PCREL_CALL, 2, 4, 24, true, 0,
   complain_overflow_signed,
   NULL, "BR24",
   false, 0x00ffffff, 0x00ffffff, true),
  /* 12 */
  HOWTO (BFD_RELOC_ARM_MOVW, 0, 4, 16, false, 0,
   complain_overflow_dont,
   NULL, "MOVW",
   false, 0x000f0fff, 0x000f0fff, false),
  HOWTO (BFD_RELOC_MACH_O_PAIR, 0, 4, 16, false, 0,
   complain_overflow_bitfield,
   NULL, "PAIR_W",
   false, 0x000f0fff, 0x000f0fff, false),
  HOWTO (BFD_RELOC_ARM_MOVT, 0, 4, 16, false, 0,
   complain_overflow_bitfield,
   NULL, "MOVT",
   false, 0x000f0fff, 0x000f0fff, false),
  HOWTO (BFD_RELOC_MACH_O_PAIR, 0, 4, 16, false, 0,
   complain_overflow_bitfield,
   NULL, "PAIR_T",
   false, 0x000f0fff, 0x000f0fff, false),
  /* 16 */
  HOWTO (BFD_RELOC_THUMB_PCREL_BLX, 2, 4, 24, true, 0,
   complain_overflow_signed,
   NULL, "TBR22",
   false, 0x07ff2fff, 0x07ff2fff, true)
};

static bool
bfd_mach_o_arm_canonicalize_one_reloc (bfd *       abfd,
               struct mach_o_reloc_info_external * raw,
               arelent *   res,
               asymbol **  syms,
               arelent *   res_base)
{
  bfd_mach_o_reloc_info reloc;

  if (!bfd_mach_o_pre_canonicalize_one_reloc (abfd, raw, &reloc, res, syms))
    return false;

  if (reloc.r_scattered)
    {
      switch (reloc.r_type)
  {
  case BFD_MACH_O_ARM_RELOC_PAIR:
    /* PR 21813: Check for a corrupt PAIR reloc at the start.  */
    if (res == res_base)
      {
        _bfd_error_handler (_("malformed mach-o ARM reloc pair: "
            "reloc is first reloc"));
        return false;
      }
    if (reloc.r_length == 2)
      {
        res->howto = &arm_howto_table[7];
        res->address = res[-1].address;
        return true;
      }
    else if (reloc.r_length == 1)
      {
        res->howto = &arm_howto_table[10];
        res->address = res[-1].address;
        return true;
      }
    _bfd_error_handler (_("malformed mach-o ARM reloc pair: "
        "invalid length: %d"), reloc.r_length);
    return false;

  case BFD_MACH_O_ARM_RELOC_SECTDIFF:
    if (reloc.r_length == 2)
      {
        res->howto = &arm_howto_table[5];
        return true;
      }
    else if (reloc.r_length == 1)
      {
        res->howto = &arm_howto_table[8];
        return true;
      }
    _bfd_error_handler (_("malformed mach-o ARM sectdiff reloc: "
        "invalid length: %d"), reloc.r_length);
    return false;

  case BFD_MACH_O_ARM_RELOC_LOCAL_SECTDIFF:
    if (reloc.r_length == 2)
      {
        res->howto = &arm_howto_table[6];
        return true;
      }
    else if (reloc.r_length == 1)
      {
        res->howto = &arm_howto_table[9];
        return true;
      }
    _bfd_error_handler (_("malformed mach-o ARM local sectdiff reloc: "
        "invalid length: %d"),
            reloc.r_length);
    return false;

  case BFD_MACH_O_ARM_RELOC_HALF_SECTDIFF:
    switch (reloc.r_length)
      {
      case 2: /* :lower16: for movw arm.  */
        res->howto = &arm_howto_table[12];
        return true;
      case 3: /* :upper16: for movt arm.  */
        res->howto = &arm_howto_table[14];
        return true;
      }
    _bfd_error_handler (_("malformed mach-o ARM half sectdiff reloc: "
        "invalid length: %d"),
            reloc.r_length);
    return false;

  default:
    break;
  }
    }
  else
    {
      switch (reloc.r_type)
  {
  case BFD_MACH_O_ARM_RELOC_VANILLA:
    switch ((reloc.r_length << 1) | reloc.r_pcrel)
      {
      case 0: /* len = 0, pcrel = 0  */
        res->howto = &arm_howto_table[2];
        return true;
      case 2: /* len = 1, pcrel = 0  */
        res->howto = &arm_howto_table[1];
        return true;
      case 3: /* len = 1, pcrel = 1  */
        res->howto = &arm_howto_table[4];
        return true;
      case 4: /* len = 2, pcrel = 0  */
        res->howto = &arm_howto_table[0];
        return true;
      case 5: /* len = 2, pcrel = 1  */
        res->howto = &arm_howto_table[3];
        return true;
      default:
        _bfd_error_handler (_("malformed mach-o ARM vanilla reloc: "
            "invalid length: %d (pcrel: %d)"),
          reloc.r_length, reloc.r_pcrel);
        return false;
      }
    break;

  case BFD_MACH_O_ARM_RELOC_BR24:
    if (reloc.r_length == 2 && reloc.r_pcrel == 1)
      {
        res->howto = &arm_howto_table[11];
        return true;
      }
    break;

  case BFD_MACH_O_THUMB_RELOC_BR22:
    if (reloc.r_length == 2 && reloc.r_pcrel == 1)
      {
        res->howto = &arm_howto_table[16];
        return true;
      }
    break;

  case BFD_MACH_O_ARM_RELOC_HALF:
    if (reloc.r_pcrel == 0)
      switch (reloc.r_length)
        {
        case 0: /* :lower16: for movw arm.  */
    res->howto = &arm_howto_table[12];
    return true;
        case 1: /* :upper16: for movt arm.  */
    res->howto = &arm_howto_table[14];
    return true;
        }
    break;

  case BFD_MACH_O_ARM_RELOC_PAIR:
    if (res == res_base)
      {
        _bfd_error_handler (_("malformed mach-o ARM reloc pair: "
            "reloc is first reloc"));
        return false;
      }
    if (res[-1].howto == &arm_howto_table[12]
        && reloc.r_length == 0)
      {
        /* Pair for :lower16: of movw arm.  */
        res->howto = &arm_howto_table[13];
        /* This reloc contains the other half in its r_address field.  */
        res[-1].addend += (res->address & 0xffff) << 16;
        res->address = res[-1].address;
        return true;
      }
    else if (res[-1].howto == &arm_howto_table[14]
       && reloc.r_length == 1)
      {
        /* Pair for :upper16: of movt arm.  */
        res->howto = &arm_howto_table[15];
        /* This reloc contains the other half in its r_address field.  */
        res[-1].addend += res->address & 0xffff;
        res->address = res[-1].address;
        return true;
      }
    break;

  default:
    break;
  }
    }

  _bfd_error_handler (_("malformed mach-o ARM reloc: "
      "unknown reloc type: %d"), reloc.r_length);
  return false;
}

static reloc_howto_type *
bfd_mach_o_arm_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
              bfd_reloc_code_real_type code)
{
  unsigned int i;

  for (i = 0; i < sizeof (arm_howto_table) / sizeof (*arm_howto_table); i++)
    if (code == arm_howto_table[i].type)
      return &arm_howto_table[i];
  return NULL;
}

static reloc_howto_type *
bfd_mach_o_arm_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
              const char *name ATTRIBUTE_UNUSED)
{
  return NULL;
}

#define TARGET_NAME   arm_mach_o_vec
#define TARGET_STRING   "mach-o-arm"
#define TARGET_ARCHITECTURE bfd_arch_arm
#define TARGET_PAGESIZE   4096
#define TARGET_BIG_ENDIAN 0
#define TARGET_ARCHIVE    0
#define TARGET_PRIORITY   0
#include "mach-o-target.c"

Coverage Report

Created: 2023-08-28 06:25

Line	Count	Source (jump to first uncovered line)
1		/* ARM Mach-O support for BFD.
2		Copyright (C) 2015-2023 Free Software Foundation, Inc.
3
4		This file is part of BFD, the Binary File Descriptor library.
5
6		This program is free software; you can redistribute it and/or modify
7		it under the terms of the GNU General Public License as published by
8		the Free Software Foundation; either version 3 of the License, or
9		(at your option) any later version.
10
11		This program is distributed in the hope that it will be useful,
12		but WITHOUT ANY WARRANTY; without even the implied warranty of
13		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14		GNU General Public License for more details.
15
16		You should have received a copy of the GNU General Public License
17		along with this program; if not, write to the Free Software
18		Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19		MA 02110-1301, USA. */
20
21		#include "sysdep.h"
22		#include "bfd.h"
23		#include "libbfd.h"
24		#include "libiberty.h"
25		#include "mach-o.h"
26		#include "mach-o/arm.h"
27
28		#define bfd_mach_o_object_p bfd_mach_o_arm_object_p
29		#define bfd_mach_o_core_p bfd_mach_o_arm_core_p
30		#define bfd_mach_o_mkobject bfd_mach_o_arm_mkobject
31
32		#define bfd_mach_o_canonicalize_one_reloc bfd_mach_o_arm_canonicalize_one_reloc
33		#define bfd_mach_o_swap_reloc_out NULL
34		#define bfd_mach_o_bfd_reloc_type_lookup bfd_mach_o_arm_bfd_reloc_type_lookup
35		#define bfd_mach_o_bfd_reloc_name_lookup bfd_mach_o_arm_bfd_reloc_name_lookup
36
37		#define bfd_mach_o_print_thread NULL
38		#define bfd_mach_o_tgt_seg_table NULL
39		#define bfd_mach_o_section_type_valid_for_tgt NULL
40
41		static bfd_cleanup
42		bfd_mach_o_arm_object_p (bfd *abfd)
43	14.4k	{
44	14.4k	return bfd_mach_o_header_p (abfd, 0, 0, BFD_MACH_O_CPU_TYPE_ARM);
45	14.4k	}
46
47		static bfd_cleanup
48		bfd_mach_o_arm_core_p (bfd *abfd)
49	0	{
50	0	return bfd_mach_o_header_p (abfd, 0,
51	0	BFD_MACH_O_MH_CORE, BFD_MACH_O_CPU_TYPE_ARM);
52	0	}
53
54		static bool
55		bfd_mach_o_arm_mkobject (bfd *abfd)
56	0	{
57	0	bfd_mach_o_data_struct *mdata;
58
59	0	if (!bfd_mach_o_mkobject_init (abfd))
60	0	return false;
61
62	0	mdata = bfd_mach_o_get_data (abfd);
63	0	mdata->header.magic = BFD_MACH_O_MH_MAGIC;
64	0	mdata->header.cputype = BFD_MACH_O_CPU_TYPE_ARM;
65	0	mdata->header.cpusubtype = BFD_MACH_O_CPU_SUBTYPE_ARM_ALL;
66	0	mdata->header.byteorder = BFD_ENDIAN_LITTLE;
67	0	mdata->header.version = 1;
68
69	0	return true;
70	0	}
71
72		static reloc_howto_type arm_howto_table[]=
73		{
74		/* 0 */
75		HOWTO (BFD_RELOC_32, 0, 4, 32, false, 0,
76		complain_overflow_bitfield,
77		NULL, "32",
78		false, 0xffffffff, 0xffffffff, false),
79		HOWTO (BFD_RELOC_16, 0, 2, 16, false, 0,
80		complain_overflow_bitfield,
81		NULL, "16",
82		false, 0xffff, 0xffff, false),
83		HOWTO (BFD_RELOC_8, 0, 1, 8, false, 0,
84		complain_overflow_bitfield,
85		NULL, "8",
86		false, 0xff, 0xff, false),
87		HOWTO (BFD_RELOC_32_PCREL, 0, 4, 32, true, 0,
88		complain_overflow_bitfield,
89		NULL, "DISP32",
90		false, 0xffffffff, 0xffffffff, true),
91		/* 4 */
92		HOWTO (BFD_RELOC_16_PCREL, 0, 2, 16, true, 0,
93		complain_overflow_bitfield,
94		NULL, "DISP16",
95		false, 0xffff, 0xffff, true),
96		HOWTO (BFD_RELOC_MACH_O_SECTDIFF, 0, 4, 32, false, 0,
97		complain_overflow_bitfield,
98		NULL, "SECTDIFF_32",
99		false, 0xffffffff, 0xffffffff, false),
100		HOWTO (BFD_RELOC_MACH_O_LOCAL_SECTDIFF, 0, 4, 32, false, 0,
101		complain_overflow_bitfield,
102		NULL, "LSECTDIFF_32",
103		false, 0xffffffff, 0xffffffff, false),
104		HOWTO (BFD_RELOC_MACH_O_PAIR, 0, 4, 32, false, 0,
105		complain_overflow_bitfield,
106		NULL, "PAIR_32",
107		false, 0xffffffff, 0xffffffff, false),
108		/* 8 */
109		HOWTO (BFD_RELOC_MACH_O_SECTDIFF, 0, 2, 16, false, 0,
110		complain_overflow_bitfield,
111		NULL, "SECTDIFF_16",
112		false, 0xffff, 0xffff, false),
113		HOWTO (BFD_RELOC_MACH_O_LOCAL_SECTDIFF, 0, 2, 16, false, 0,
114		complain_overflow_bitfield,
115		NULL, "LSECTDIFF_16",
116		false, 0xffff, 0xffff, false),
117		HOWTO (BFD_RELOC_MACH_O_PAIR, 0, 2, 16, false, 0,
118		complain_overflow_bitfield,
119		NULL, "PAIR_16",
120		false, 0xffff, 0xffff, false),
121		HOWTO (BFD_RELOC_ARM_PCREL_CALL, 2, 4, 24, true, 0,
122		complain_overflow_signed,
123		NULL, "BR24",
124		false, 0x00ffffff, 0x00ffffff, true),
125		/* 12 */
126		HOWTO (BFD_RELOC_ARM_MOVW, 0, 4, 16, false, 0,
127		complain_overflow_dont,
128		NULL, "MOVW",
129		false, 0x000f0fff, 0x000f0fff, false),
130		HOWTO (BFD_RELOC_MACH_O_PAIR, 0, 4, 16, false, 0,
131		complain_overflow_bitfield,
132		NULL, "PAIR_W",
133		false, 0x000f0fff, 0x000f0fff, false),
134		HOWTO (BFD_RELOC_ARM_MOVT, 0, 4, 16, false, 0,
135		complain_overflow_bitfield,
136		NULL, "MOVT",
137		false, 0x000f0fff, 0x000f0fff, false),
138		HOWTO (BFD_RELOC_MACH_O_PAIR, 0, 4, 16, false, 0,
139		complain_overflow_bitfield,
140		NULL, "PAIR_T",
141		false, 0x000f0fff, 0x000f0fff, false),
142		/* 16 */
143		HOWTO (BFD_RELOC_THUMB_PCREL_BLX, 2, 4, 24, true, 0,
144		complain_overflow_signed,
145		NULL, "TBR22",
146		false, 0x07ff2fff, 0x07ff2fff, true)
147		};
148
149		static bool
150		bfd_mach_o_arm_canonicalize_one_reloc (bfd * abfd,
151		struct mach_o_reloc_info_external * raw,
152		arelent * res,
153		asymbol ** syms,
154		arelent * res_base)
155	2.82M	{
156	2.82M	bfd_mach_o_reloc_info reloc;
157
158	2.82M	if (!bfd_mach_o_pre_canonicalize_one_reloc (abfd, raw, &reloc, res, syms))
159	7.02k	return false;
160
161	2.81M	if (reloc.r_scattered)
162	112k	{
163	112k	switch (reloc.r_type)
164	112k	{
165	409	case BFD_MACH_O_ARM_RELOC_PAIR:
166		/* PR 21813: Check for a corrupt PAIR reloc at the start. */
167	409	if (res == res_base)
168	62	{
169	62	_bfd_error_handler (_("malformed mach-o ARM reloc pair: "
170	62	"reloc is first reloc"));
171	62	return false;
172	62	}
173	347	if (reloc.r_length == 2)
174	98	{
175	98	res->howto = &arm_howto_table[7];
176	98	res->address = res[-1].address;
177	98	return true;
178	98	}
179	249	else if (reloc.r_length == 1)
180	187	{
181	187	res->howto = &arm_howto_table[10];
182	187	res->address = res[-1].address;
183	187	return true;
184	187	}
185	62	_bfd_error_handler (_("malformed mach-o ARM reloc pair: "
186	62	"invalid length: %d"), reloc.r_length);
187	62	return false;
188
189	30.7k	case BFD_MACH_O_ARM_RELOC_SECTDIFF:
190	30.7k	if (reloc.r_length == 2)
191	550	{
192	550	res->howto = &arm_howto_table[5];
193	550	return true;
194	550	}
195	30.2k	else if (reloc.r_length == 1)
196	30.1k	{
197	30.1k	res->howto = &arm_howto_table[8];
198	30.1k	return true;
199	30.1k	}
200	36	_bfd_error_handler (_("malformed mach-o ARM sectdiff reloc: "
201	36	"invalid length: %d"), reloc.r_length);
202	36	return false;
203
204	313	case BFD_MACH_O_ARM_RELOC_LOCAL_SECTDIFF:
205	313	if (reloc.r_length == 2)
206	72	{
207	72	res->howto = &arm_howto_table[6];
208	72	return true;
209	72	}
210	241	else if (reloc.r_length == 1)
211	159	{
212	159	res->howto = &arm_howto_table[9];
213	159	return true;
214	159	}
215	82	_bfd_error_handler (_("malformed mach-o ARM local sectdiff reloc: "
216	82	"invalid length: %d"),
217	82	reloc.r_length);
218	82	return false;
219
220	72.9k	case BFD_MACH_O_ARM_RELOC_HALF_SECTDIFF:
221	72.9k	switch (reloc.r_length)
222	72.9k	{
223	72.8k	case 2: /* :lower16: for movw arm. */
224	72.8k	res->howto = &arm_howto_table[12];
225	72.8k	return true;
226	78	case 3: /* :upper16: for movt arm. */
227	78	res->howto = &arm_howto_table[14];
228	78	return true;
229	72.9k	}
230	13	_bfd_error_handler (_("malformed mach-o ARM half sectdiff reloc: "
231	13	"invalid length: %d"),
232	13	reloc.r_length);
233	13	return false;
234
235	7.73k	default:
236	7.73k	break;
237	112k	}
238	112k	}
239	2.70M	else
240	2.70M	{
241	2.70M	switch (reloc.r_type)
242	2.70M	{
243	2.70M	case BFD_MACH_O_ARM_RELOC_VANILLA:
244	2.70M	switch ((reloc.r_length << 1) \| reloc.r_pcrel)
245	2.70M	{
246	2.69M	case 0: /* len = 0, pcrel = 0 */
247	2.69M	res->howto = &arm_howto_table[2];
248	2.69M	return true;
249	622	case 2: /* len = 1, pcrel = 0 */
250	622	res->howto = &arm_howto_table[1];
251	622	return true;
252	678	case 3: /* len = 1, pcrel = 1 */
253	678	res->howto = &arm_howto_table[4];
254	678	return true;
255	488	case 4: /* len = 2, pcrel = 0 */
256	488	res->howto = &arm_howto_table[0];
257	488	return true;
258	592	case 5: /* len = 2, pcrel = 1 */
259	592	res->howto = &arm_howto_table[3];
260	592	return true;
261	950	default:
262	950	_bfd_error_handler (_("malformed mach-o ARM vanilla reloc: "
263	950	"invalid length: %d (pcrel: %d)"),
264	950	reloc.r_length, reloc.r_pcrel);
265	950	return false;
266	2.70M	}
267	0	break;
268
269	519	case BFD_MACH_O_ARM_RELOC_BR24:
270	519	if (reloc.r_length == 2 && reloc.r_pcrel == 1)
271	54	{
272	54	res->howto = &arm_howto_table[11];
273	54	return true;
274	54	}
275	465	break;
276
277	752	case BFD_MACH_O_THUMB_RELOC_BR22:
278	752	if (reloc.r_length == 2 && reloc.r_pcrel == 1)
279	257	{
280	257	res->howto = &arm_howto_table[16];
281	257	return true;
282	257	}
283	495	break;
284
285	553	case BFD_MACH_O_ARM_RELOC_HALF:
286	553	if (reloc.r_pcrel == 0)
287	447	switch (reloc.r_length)
288	447	{
289	348	case 0: /* :lower16: for movw arm. */
290	348	res->howto = &arm_howto_table[12];
291	348	return true;
292	43	case 1: /* :upper16: for movt arm. */
293	43	res->howto = &arm_howto_table[14];
294	43	return true;
295	447	}
296	162	break;
297
298	552	case BFD_MACH_O_ARM_RELOC_PAIR:
299	552	if (res == res_base)
300	248	{
301	248	_bfd_error_handler (_("malformed mach-o ARM reloc pair: "
302	248	"reloc is first reloc"));
303	248	return false;
304	248	}
305	304	if (res[-1].howto == &arm_howto_table[12]
306	304	&& reloc.r_length == 0)
307	22	{
308		/* Pair for :lower16: of movw arm. */
309	22	res->howto = &arm_howto_table[13];
310		/* This reloc contains the other half in its r_address field. */
311	22	res[-1].addend += (res->address & 0xffff) << 16;
312	22	res->address = res[-1].address;
313	22	return true;
314	22	}
315	282	else if (res[-1].howto == &arm_howto_table[14]
316	282	&& reloc.r_length == 1)
317	9	{
318		/* Pair for :upper16: of movt arm. */
319	9	res->howto = &arm_howto_table[15];
320		/* This reloc contains the other half in its r_address field. */
321	9	res[-1].addend += res->address & 0xffff;
322	9	res->address = res[-1].address;
323	9	return true;
324	9	}
325	273	break;
326
327	2.13k	default:
328	2.13k	break;
329	2.70M	}
330	2.70M	}
331
332	11.2k	_bfd_error_handler (_("malformed mach-o ARM reloc: "
333	11.2k	"unknown reloc type: %d"), reloc.r_length);
334	11.2k	return false;
335	2.81M	}
336
337		static reloc_howto_type *
338		bfd_mach_o_arm_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
339		bfd_reloc_code_real_type code)
340	0	{
341	0	unsigned int i;
342
343	0	for (i = 0; i < sizeof (arm_howto_table) / sizeof (*arm_howto_table); i++)
344	0	if (code == arm_howto_table[i].type)
345	0	return &arm_howto_table[i];
346	0	return NULL;
347	0	}
348
349		static reloc_howto_type *
350		bfd_mach_o_arm_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
351		const char *name ATTRIBUTE_UNUSED)
352	0	{
353	0	return NULL;
354	0	}
355
356		#define TARGET_NAME arm_mach_o_vec
357		#define TARGET_STRING "mach-o-arm"
358		#define TARGET_ARCHITECTURE bfd_arch_arm
359		#define TARGET_PAGESIZE 4096
360		#define TARGET_BIG_ENDIAN 0
361		#define TARGET_ARCHIVE 0
362		#define TARGET_PRIORITY 0
363		#include "mach-o-target.c"