/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:26

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	4.52k	{
44	4.52k	return bfd_mach_o_header_p (abfd, 0, 0, BFD_MACH_O_CPU_TYPE_ARM);
45	4.52k	}
46
47		static bfd_cleanup
48		bfd_mach_o_arm_core_p (bfd *abfd)
49	217	{
50	217	return bfd_mach_o_header_p (abfd, 0,
51	217	BFD_MACH_O_MH_CORE, BFD_MACH_O_CPU_TYPE_ARM);
52	217	}
53
54		static bool
55		bfd_mach_o_arm_mkobject (bfd *abfd)
56	6	{
57	6	bfd_mach_o_data_struct *mdata;
58
59	6	if (!bfd_mach_o_mkobject_init (abfd))
60	0	return false;
61
62	6	mdata = bfd_mach_o_get_data (abfd);
63	6	mdata->header.magic = BFD_MACH_O_MH_MAGIC;
64	6	mdata->header.cputype = BFD_MACH_O_CPU_TYPE_ARM;
65	6	mdata->header.cpusubtype = BFD_MACH_O_CPU_SUBTYPE_ARM_ALL;
66	6	mdata->header.byteorder = BFD_ENDIAN_LITTLE;
67	6	mdata->header.version = 1;
68
69	6	return true;
70	6	}
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	0	{
156	0	bfd_mach_o_reloc_info reloc;
157
158	0	if (!bfd_mach_o_pre_canonicalize_one_reloc (abfd, raw, &reloc, res, syms))
159	0	return false;
160
161	0	if (reloc.r_scattered)
162	0	{
163	0	switch (reloc.r_type)
164	0	{
165	0	case BFD_MACH_O_ARM_RELOC_PAIR:
166		/* PR 21813: Check for a corrupt PAIR reloc at the start. */
167	0	if (res == res_base)
168	0	{
169	0	_bfd_error_handler (_("malformed mach-o ARM reloc pair: "
170	0	"reloc is first reloc"));
171	0	return false;
172	0	}
173	0	if (reloc.r_length == 2)
174	0	{
175	0	res->howto = &arm_howto_table[7];
176	0	res->address = res[-1].address;
177	0	return true;
178	0	}
179	0	else if (reloc.r_length == 1)
180	0	{
181	0	res->howto = &arm_howto_table[10];
182	0	res->address = res[-1].address;
183	0	return true;
184	0	}
185	0	_bfd_error_handler (_("malformed mach-o ARM reloc pair: "
186	0	"invalid length: %d"), reloc.r_length);
187	0	return false;
188
189	0	case BFD_MACH_O_ARM_RELOC_SECTDIFF:
190	0	if (reloc.r_length == 2)
191	0	{
192	0	res->howto = &arm_howto_table[5];
193	0	return true;
194	0	}
195	0	else if (reloc.r_length == 1)
196	0	{
197	0	res->howto = &arm_howto_table[8];
198	0	return true;
199	0	}
200	0	_bfd_error_handler (_("malformed mach-o ARM sectdiff reloc: "
201	0	"invalid length: %d"), reloc.r_length);
202	0	return false;
203
204	0	case BFD_MACH_O_ARM_RELOC_LOCAL_SECTDIFF:
205	0	if (reloc.r_length == 2)
206	0	{
207	0	res->howto = &arm_howto_table[6];
208	0	return true;
209	0	}
210	0	else if (reloc.r_length == 1)
211	0	{
212	0	res->howto = &arm_howto_table[9];
213	0	return true;
214	0	}
215	0	_bfd_error_handler (_("malformed mach-o ARM local sectdiff reloc: "
216	0	"invalid length: %d"),
217	0	reloc.r_length);
218	0	return false;
219
220	0	case BFD_MACH_O_ARM_RELOC_HALF_SECTDIFF:
221	0	switch (reloc.r_length)
222	0	{
223	0	case 2: /* :lower16: for movw arm. */
224	0	res->howto = &arm_howto_table[12];
225	0	return true;
226	0	case 3: /* :upper16: for movt arm. */
227	0	res->howto = &arm_howto_table[14];
228	0	return true;
229	0	}
230	0	_bfd_error_handler (_("malformed mach-o ARM half sectdiff reloc: "
231	0	"invalid length: %d"),
232	0	reloc.r_length);
233	0	return false;
234
235	0	default:
236	0	break;
237	0	}
238	0	}
239	0	else
240	0	{
241	0	switch (reloc.r_type)
242	0	{
243	0	case BFD_MACH_O_ARM_RELOC_VANILLA:
244	0	switch ((reloc.r_length << 1) \| reloc.r_pcrel)
245	0	{
246	0	case 0: /* len = 0, pcrel = 0 */
247	0	res->howto = &arm_howto_table[2];
248	0	return true;
249	0	case 2: /* len = 1, pcrel = 0 */
250	0	res->howto = &arm_howto_table[1];
251	0	return true;
252	0	case 3: /* len = 1, pcrel = 1 */
253	0	res->howto = &arm_howto_table[4];
254	0	return true;
255	0	case 4: /* len = 2, pcrel = 0 */
256	0	res->howto = &arm_howto_table[0];
257	0	return true;
258	0	case 5: /* len = 2, pcrel = 1 */
259	0	res->howto = &arm_howto_table[3];
260	0	return true;
261	0	default:
262	0	_bfd_error_handler (_("malformed mach-o ARM vanilla reloc: "
263	0	"invalid length: %d (pcrel: %d)"),
264	0	reloc.r_length, reloc.r_pcrel);
265	0	return false;
266	0	}
267	0	break;
268
269	0	case BFD_MACH_O_ARM_RELOC_BR24:
270	0	if (reloc.r_length == 2 && reloc.r_pcrel == 1)
271	0	{
272	0	res->howto = &arm_howto_table[11];
273	0	return true;
274	0	}
275	0	break;
276
277	0	case BFD_MACH_O_THUMB_RELOC_BR22:
278	0	if (reloc.r_length == 2 && reloc.r_pcrel == 1)
279	0	{
280	0	res->howto = &arm_howto_table[16];
281	0	return true;
282	0	}
283	0	break;
284
285	0	case BFD_MACH_O_ARM_RELOC_HALF:
286	0	if (reloc.r_pcrel == 0)
287	0	switch (reloc.r_length)
288	0	{
289	0	case 0: /* :lower16: for movw arm. */
290	0	res->howto = &arm_howto_table[12];
291	0	return true;
292	0	case 1: /* :upper16: for movt arm. */
293	0	res->howto = &arm_howto_table[14];
294	0	return true;
295	0	}
296	0	break;
297
298	0	case BFD_MACH_O_ARM_RELOC_PAIR:
299	0	if (res == res_base)
300	0	{
301	0	_bfd_error_handler (_("malformed mach-o ARM reloc pair: "
302	0	"reloc is first reloc"));
303	0	return false;
304	0	}
305	0	if (res[-1].howto == &arm_howto_table[12]
306	0	&& 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	0	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	0	break;
326
327	0	default:
328	0	break;
329	0	}
330	0	}
331
332	0	_bfd_error_handler (_("malformed mach-o ARM reloc: "
333	0	"unknown reloc type: %d"), reloc.r_length);
334	0	return false;
335	0	}
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"