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

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	1.65M	{
44	1.65M	return bfd_mach_o_header_p (abfd, 0, 0, BFD_MACH_O_CPU_TYPE_ARM);
45	1.65M	}
46
47		static bfd_cleanup
48		bfd_mach_o_arm_core_p (bfd *abfd)
49	16.4k	{
50	16.4k	return bfd_mach_o_header_p (abfd, 0,
51	16.4k	BFD_MACH_O_MH_CORE, BFD_MACH_O_CPU_TYPE_ARM);
52	16.4k	}
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	2.83M	{
156	2.83M	bfd_mach_o_reloc_info reloc;
157
158	2.83M	if (!bfd_mach_o_pre_canonicalize_one_reloc (abfd, raw, &reloc, res, syms))
159	7.13k	return false;
160
161	2.82M	if (reloc.r_scattered)
162	113k	{
163	113k	switch (reloc.r_type)
164	113k	{
165	458	case BFD_MACH_O_ARM_RELOC_PAIR:
166		/* PR 21813: Check for a corrupt PAIR reloc at the start. */
167	458	if (res == res_base)
168	65	{
169	65	_bfd_error_handler (_("malformed mach-o ARM reloc pair: "
170	65	"reloc is first reloc"));
171	65	return false;
172	65	}
173	393	if (reloc.r_length == 2)
174	133	{
175	133	res->howto = &arm_howto_table[7];
176	133	res->address = res[-1].address;
177	133	return true;
178	133	}
179	260	else if (reloc.r_length == 1)
180	190	{
181	190	res->howto = &arm_howto_table[10];
182	190	res->address = res[-1].address;
183	190	return true;
184	190	}
185	70	_bfd_error_handler (_("malformed mach-o ARM reloc pair: "
186	70	"invalid length: %d"), reloc.r_length);
187	70	return false;
188
189	30.9k	case BFD_MACH_O_ARM_RELOC_SECTDIFF:
190	30.9k	if (reloc.r_length == 2)
191	589	{
192	589	res->howto = &arm_howto_table[5];
193	589	return true;
194	589	}
195	30.3k	else if (reloc.r_length == 1)
196	30.3k	{
197	30.3k	res->howto = &arm_howto_table[8];
198	30.3k	return true;
199	30.3k	}
200	47	_bfd_error_handler (_("malformed mach-o ARM sectdiff reloc: "
201	47	"invalid length: %d"), reloc.r_length);
202	47	return false;
203
204	774	case BFD_MACH_O_ARM_RELOC_LOCAL_SECTDIFF:
205	774	if (reloc.r_length == 2)
206	406	{
207	406	res->howto = &arm_howto_table[6];
208	406	return true;
209	406	}
210	368	else if (reloc.r_length == 1)
211	276	{
212	276	res->howto = &arm_howto_table[9];
213	276	return true;
214	276	}
215	92	_bfd_error_handler (_("malformed mach-o ARM local sectdiff reloc: "
216	92	"invalid length: %d"),
217	92	reloc.r_length);
218	92	return false;
219
220	73.2k	case BFD_MACH_O_ARM_RELOC_HALF_SECTDIFF:
221	73.2k	switch (reloc.r_length)
222	73.2k	{
223	72.8k	case 2: /* :lower16: for movw arm. */
224	72.8k	res->howto = &arm_howto_table[12];
225	72.8k	return true;
226	442	case 3: /* :upper16: for movt arm. */
227	442	res->howto = &arm_howto_table[14];
228	442	return true;
229	73.2k	}
230	20	_bfd_error_handler (_("malformed mach-o ARM half sectdiff reloc: "
231	20	"invalid length: %d"),
232	20	reloc.r_length);
233	20	return false;
234
235	7.79k	default:
236	7.79k	break;
237	113k	}
238	113k	}
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.70M	case 0: /* len = 0, pcrel = 0 */
247	2.70M	res->howto = &arm_howto_table[2];
248	2.70M	return true;
249	647	case 2: /* len = 1, pcrel = 0 */
250	647	res->howto = &arm_howto_table[1];
251	647	return true;
252	819	case 3: /* len = 1, pcrel = 1 */
253	819	res->howto = &arm_howto_table[4];
254	819	return true;
255	802	case 4: /* len = 2, pcrel = 0 */
256	802	res->howto = &arm_howto_table[0];
257	802	return true;
258	598	case 5: /* len = 2, pcrel = 1 */
259	598	res->howto = &arm_howto_table[3];
260	598	return true;
261	960	default:
262	960	_bfd_error_handler (_("malformed mach-o ARM vanilla reloc: "
263	960	"invalid length: %d (pcrel: %d)"),
264	960	reloc.r_length, reloc.r_pcrel);
265	960	return false;
266	2.70M	}
267	0	break;
268
269	543	case BFD_MACH_O_ARM_RELOC_BR24:
270	543	if (reloc.r_length == 2 && reloc.r_pcrel == 1)
271	57	{
272	57	res->howto = &arm_howto_table[11];
273	57	return true;
274	57	}
275	486	break;
276
277	781	case BFD_MACH_O_THUMB_RELOC_BR22:
278	781	if (reloc.r_length == 2 && reloc.r_pcrel == 1)
279	261	{
280	261	res->howto = &arm_howto_table[16];
281	261	return true;
282	261	}
283	520	break;
284
285	580	case BFD_MACH_O_ARM_RELOC_HALF:
286	580	if (reloc.r_pcrel == 0)
287	465	switch (reloc.r_length)
288	465	{
289	358	case 0: /* :lower16: for movw arm. */
290	358	res->howto = &arm_howto_table[12];
291	358	return true;
292	44	case 1: /* :upper16: for movt arm. */
293	44	res->howto = &arm_howto_table[14];
294	44	return true;
295	465	}
296	178	break;
297
298	576	case BFD_MACH_O_ARM_RELOC_PAIR:
299	576	if (res == res_base)
300	253	{
301	253	_bfd_error_handler (_("malformed mach-o ARM reloc pair: "
302	253	"reloc is first reloc"));
303	253	return false;
304	253	}
305	323	if (res[-1].howto == &arm_howto_table[12]
306	323	&& reloc.r_length == 0)
307	23	{
308		/* Pair for :lower16: of movw arm. */
309	23	res->howto = &arm_howto_table[13];
310		/* This reloc contains the other half in its r_address field. */
311	23	res[-1].addend += (res->address & 0xffff) << 16;
312	23	res->address = res[-1].address;
313	23	return true;
314	23	}
315	300	else if (res[-1].howto == &arm_howto_table[14]
316	300	&& reloc.r_length == 1)
317	15	{
318		/* Pair for :upper16: of movt arm. */
319	15	res->howto = &arm_howto_table[15];
320		/* This reloc contains the other half in its r_address field. */
321	15	res[-1].addend += res->address & 0xffff;
322	15	res->address = res[-1].address;
323	15	return true;
324	15	}
325	285	break;
326
327	2.18k	default:
328	2.18k	break;
329	2.70M	}
330	2.70M	}
331
332	11.4k	_bfd_error_handler (_("malformed mach-o ARM reloc: "
333	11.4k	"unknown reloc type: %d"), reloc.r_length);
334	11.4k	return false;
335	2.82M	}
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"