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

Source
/* ARM Mach-O support for BFD.
   Copyright (C) 2015-2026 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: 2026-04-04 08:16

Line	Count	Source
1		/* ARM Mach-O support for BFD.
2		Copyright (C) 2015-2026 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	111k	{
44	111k	return bfd_mach_o_header_p (abfd, 0, 0, BFD_MACH_O_CPU_TYPE_ARM);
45	111k	}
46
47		static bfd_cleanup
48		bfd_mach_o_arm_core_p (bfd *abfd)
49	10.6k	{
50	10.6k	return bfd_mach_o_header_p (abfd, 0,
51	10.6k	BFD_MACH_O_MH_CORE, BFD_MACH_O_CPU_TYPE_ARM);
52	10.6k	}
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	7.58k	{
156	7.58k	bfd_mach_o_reloc_info reloc;
157
158	7.58k	if (!bfd_mach_o_pre_canonicalize_one_reloc (abfd, raw, &reloc, res, syms))
159	1.27k	return false;
160
161	6.30k	if (reloc.r_scattered)
162	2.42k	{
163	2.42k	switch (reloc.r_type)
164	2.42k	{
165	51	case BFD_MACH_O_ARM_RELOC_PAIR:
166		/* PR 21813: Check for a corrupt PAIR reloc at the start. */
167	51	if (res == res_base)
168	5	{
169	5	_bfd_error_handler (_("malformed mach-o ARM reloc pair: "
170	5	"reloc is first reloc"));
171	5	return false;
172	5	}
173	46	if (reloc.r_length == 2)
174	38	{
175	38	res->howto = &arm_howto_table[7];
176	38	res->address = res[-1].address;
177	38	return true;
178	38	}
179	8	else if (reloc.r_length == 1)
180	6	{
181	6	res->howto = &arm_howto_table[10];
182	6	res->address = res[-1].address;
183	6	return true;
184	6	}
185	2	_bfd_error_handler (_("malformed mach-o ARM reloc pair: "
186	2	"invalid length: %d"), reloc.r_length);
187	2	return false;
188
189	122	case BFD_MACH_O_ARM_RELOC_SECTDIFF:
190	122	if (reloc.r_length == 2)
191	96	{
192	96	res->howto = &arm_howto_table[5];
193	96	return true;
194	96	}
195	26	else if (reloc.r_length == 1)
196	15	{
197	15	res->howto = &arm_howto_table[8];
198	15	return true;
199	15	}
200	11	_bfd_error_handler (_("malformed mach-o ARM sectdiff reloc: "
201	11	"invalid length: %d"), reloc.r_length);
202	11	return false;
203
204	88	case BFD_MACH_O_ARM_RELOC_LOCAL_SECTDIFF:
205	88	if (reloc.r_length == 2)
206	41	{
207	41	res->howto = &arm_howto_table[6];
208	41	return true;
209	41	}
210	47	else if (reloc.r_length == 1)
211	35	{
212	35	res->howto = &arm_howto_table[9];
213	35	return true;
214	35	}
215	12	_bfd_error_handler (_("malformed mach-o ARM local sectdiff reloc: "
216	12	"invalid length: %d"),
217	12	reloc.r_length);
218	12	return false;
219
220	52	case BFD_MACH_O_ARM_RELOC_HALF_SECTDIFF:
221	52	switch (reloc.r_length)
222	52	{
223	10	case 2: /* :lower16: for movw arm. */
224	10	res->howto = &arm_howto_table[12];
225	10	return true;
226	36	case 3: /* :upper16: for movt arm. */
227	36	res->howto = &arm_howto_table[14];
228	36	return true;
229	52	}
230	6	_bfd_error_handler (_("malformed mach-o ARM half sectdiff reloc: "
231	6	"invalid length: %d"),
232	6	reloc.r_length);
233	6	return false;
234
235	2.11k	default:
236	2.11k	break;
237	2.42k	}
238	2.42k	}
239	3.88k	else
240	3.88k	{
241	3.88k	switch (reloc.r_type)
242	3.88k	{
243	2.65k	case BFD_MACH_O_ARM_RELOC_VANILLA:
244	2.65k	switch ((reloc.r_length << 1) \| reloc.r_pcrel)
245	2.65k	{
246	1.49k	case 0: /* len = 0, pcrel = 0 */
247	1.49k	res->howto = &arm_howto_table[2];
248	1.49k	return true;
249	120	case 2: /* len = 1, pcrel = 0 */
250	120	res->howto = &arm_howto_table[1];
251	120	return true;
252	331	case 3: /* len = 1, pcrel = 1 */
253	331	res->howto = &arm_howto_table[4];
254	331	return true;
255	266	case 4: /* len = 2, pcrel = 0 */
256	266	res->howto = &arm_howto_table[0];
257	266	return true;
258	15	case 5: /* len = 2, pcrel = 1 */
259	15	res->howto = &arm_howto_table[3];
260	15	return true;
261	428	default:
262	428	_bfd_error_handler (_("malformed mach-o ARM vanilla reloc: "
263	428	"invalid length: %d (pcrel: %d)"),
264	428	reloc.r_length, reloc.r_pcrel);
265	428	return false;
266	2.65k	}
267	0	break;
268
269	74	case BFD_MACH_O_ARM_RELOC_BR24:
270	74	if (reloc.r_length == 2 && reloc.r_pcrel == 1)
271	7	{
272	7	res->howto = &arm_howto_table[11];
273	7	return true;
274	7	}
275	67	break;
276
277	73	case BFD_MACH_O_THUMB_RELOC_BR22:
278	73	if (reloc.r_length == 2 && reloc.r_pcrel == 1)
279	15	{
280	15	res->howto = &arm_howto_table[16];
281	15	return true;
282	15	}
283	58	break;
284
285	58	case BFD_MACH_O_ARM_RELOC_HALF:
286	53	if (reloc.r_pcrel == 0)
287	38	switch (reloc.r_length)
288	38	{
289	28	case 0: /* :lower16: for movw arm. */
290	28	res->howto = &arm_howto_table[12];
291	28	return true;
292	6	case 1: /* :upper16: for movt arm. */
293	6	res->howto = &arm_howto_table[14];
294	6	return true;
295	38	}
296	19	break;
297
298	54	case BFD_MACH_O_ARM_RELOC_PAIR:
299	54	if (res == res_base)
300	43	{
301	43	_bfd_error_handler (_("malformed mach-o ARM reloc pair: "
302	43	"reloc is first reloc"));
303	43	return false;
304	43	}
305	11	if (res[-1].howto == &arm_howto_table[12]
306	1	&& reloc.r_length == 0)
307	0	{
308		/* Pair for :lower16: of movw arm. */
309	0	res->howto = &arm_howto_table[13];
310		/* This reloc contains the other half in its r_address field. */
311	0	res[-1].addend += (res->address & 0xffff) << 16;
312	0	res->address = res[-1].address;
313	0	return true;
314	0	}
315	11	else if (res[-1].howto == &arm_howto_table[14]
316	0	&& reloc.r_length == 1)
317	0	{
318		/* Pair for :upper16: of movt arm. */
319	0	res->howto = &arm_howto_table[15];
320		/* This reloc contains the other half in its r_address field. */
321	0	res[-1].addend += res->address & 0xffff;
322	0	res->address = res[-1].address;
323	0	return true;
324	0	}
325	11	break;
326
327	978	default:
328	978	break;
329	3.88k	}
330	3.88k	}
331
332	3.24k	_bfd_error_handler (_("malformed mach-o ARM reloc: "
333	3.24k	"unknown reloc type: %d"), reloc.r_length);
334	3.24k	return false;
335	6.30k	}
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		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"