View | Details | Raw Unified | Return to bug 13320 | Differences between
and this patch

Collapse All | Expand All

(-)a/gold/arm.cc (-33 / +157 lines)
Lines 492-498 class Reloc_stub : public Stub Link Here
492
  // the branch target is a thumb instruction.  TARGET is used for look
492
  // the branch target is a thumb instruction.  TARGET is used for look
493
  // up ARM-specific linker settings.
493
  // up ARM-specific linker settings.
494
  static Stub_type
494
  static Stub_type
495
  stub_type_for_reloc(unsigned int r_type, Arm_address branch_address,
495
  stub_type_for_reloc(unsigned int r_type, const Sized_symbol<32>* gsym,
496
		      Arm_address branch_address,
496
		      Arm_address branch_target, bool target_is_thumb);
497
		      Arm_address branch_target, bool target_is_thumb);
497
498
498
  // Reloc_stub key.  A key is logically a triplet of a stub type, a symbol
499
  // Reloc_stub key.  A key is logically a triplet of a stub type, a symbol
Lines 2699-2705 class Target_arm : public Sized_target<32, big_endian> Link Here
2699
2700
2700
  // Create a PLT entry for a global symbol.
2701
  // Create a PLT entry for a global symbol.
2701
  void
2702
  void
2702
  make_plt_entry(Symbol_table*, Layout*, Symbol*);
2703
  make_plt_entry(Symbol_table*, Layout*, Symbol*, bool, bool);
2703
2704
2704
  // Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
2705
  // Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
2705
  void
2706
  void
Lines 3917-3923 Arm_relocate_functions<big_endian>::arm_branch_common( Link Here
3917
      Valtype unadjusted_branch_target = psymval->value(object, 0);
3918
      Valtype unadjusted_branch_target = psymval->value(object, 0);
3918
3919
3919
      Stub_type stub_type =
3920
      Stub_type stub_type =
3920
	Reloc_stub::stub_type_for_reloc(r_type, address,
3921
	Reloc_stub::stub_type_for_reloc(r_type, gsym, address,
3921
					unadjusted_branch_target,
3922
					unadjusted_branch_target,
3922
					(thumb_bit != 0));
3923
					(thumb_bit != 0));
3923
      if (stub_type != arm_stub_none)
3924
      if (stub_type != arm_stub_none)
Lines 4037-4042 Arm_relocate_functions<big_endian>::thumb_branch_common( Link Here
4037
  int32_t addend = This::thumb32_branch_offset(upper_insn, lower_insn);
4038
  int32_t addend = This::thumb32_branch_offset(upper_insn, lower_insn);
4038
  Arm_address branch_target = psymval->value(object, addend);
4039
  Arm_address branch_target = psymval->value(object, addend);
4039
4040
4041
  // For direct Thumb jumps to PLT entries, adjust the branch target
4042
  // address to be the Thumb stub in the PLT entry.
4043
  if (r_type == elfcpp::R_ARM_THM_JUMP24
4044
      && gsym->has_plt_offset())
4045
    {
4046
      branch_target -= 4;		// XXX: hard-coded constant
4047
      thumb_bit = 1;
4048
    }
4049
4040
  // For BLX, bit 1 of target address comes from bit 1 of base address.
4050
  // For BLX, bit 1 of target address comes from bit 1 of base address.
4041
  bool may_use_blx = arm_target->may_use_v5t_interworking();
4051
  bool may_use_blx = arm_target->may_use_v5t_interworking();
4042
  if (thumb_bit == 0 && may_use_blx)
4052
  if (thumb_bit == 0 && may_use_blx)
Lines 4045-4063 Arm_relocate_functions<big_endian>::thumb_branch_common( Link Here
4045
  int32_t branch_offset = branch_target - address;
4055
  int32_t branch_offset = branch_target - address;
4046
4056
4047
  // We need a stub if the branch offset is too large or if we need
4057
  // We need a stub if the branch offset is too large or if we need
4048
  // to switch mode.
4058
  // to switch mode.  If we are jumping to a PLT entry, however, we
4059
  // can use the Thumb stub in the PLT enetry itself rather than
4060
  // creating a separate, out-of-line stub.
4049
  bool thumb2 = arm_target->using_thumb2();
4061
  bool thumb2 = arm_target->using_thumb2();
4050
  if (!parameters->options().relocatable()
4062
  if (!parameters->options().relocatable()
4051
      && ((!thumb2 && Bits<23>::has_overflow32(branch_offset))
4063
      && ((!thumb2 && Bits<23>::has_overflow32(branch_offset))
4052
	  || (thumb2 && Bits<25>::has_overflow32(branch_offset))
4064
	  || (thumb2 && Bits<25>::has_overflow32(branch_offset))
4053
	  || ((thumb_bit == 0)
4065
	  || ((thumb_bit == 0)
4054
	      && (((r_type == elfcpp::R_ARM_THM_CALL) && !may_use_blx)
4066
	      && (((r_type == elfcpp::R_ARM_THM_CALL) && !may_use_blx)
4055
		  || r_type == elfcpp::R_ARM_THM_JUMP24))))
4067
		  || (r_type == elfcpp::R_ARM_THM_JUMP24
4068
		      && !gsym->has_plt_offset())))))
4056
    {
4069
    {
4057
      Arm_address unadjusted_branch_target = psymval->value(object, 0);
4070
      Arm_address unadjusted_branch_target = psymval->value(object, 0);
4058
4071
4072
      // If we're branching to a PLT entry, force a switch to ARM mode.
4073
      // This ensues that any stub we might have considered necessary
4074
      // while scanning relocs is found.  It's also going to be more
4075
      // efficient, since we don't go Thumb -> ARM -> Thumb -> ARM.
4076
      if (gsym->has_plt_offset())
4077
	thumb_bit = 0;
4078
4059
      Stub_type stub_type =
4079
      Stub_type stub_type =
4060
	Reloc_stub::stub_type_for_reloc(r_type, address,
4080
	Reloc_stub::stub_type_for_reloc(r_type, gsym, address,
4061
					unadjusted_branch_target,
4081
					unadjusted_branch_target,
4062
					(thumb_bit != 0));
4082
					(thumb_bit != 0));
4063
4083
Lines 4405-4410 Reloc_stub::Key::name() const Link Here
4405
Stub_type
4425
Stub_type
4406
Reloc_stub::stub_type_for_reloc(
4426
Reloc_stub::stub_type_for_reloc(
4407
   unsigned int r_type,
4427
   unsigned int r_type,
4428
   const Sized_symbol<32>* gsym,
4408
   Arm_address location,
4429
   Arm_address location,
4409
   Arm_address destination,
4430
   Arm_address destination,
4410
   bool target_is_thumb)
4431
   bool target_is_thumb)
Lines 4445-4452 Reloc_stub::stub_type_for_reloc( Link Here
4445
      // base address (instruction address + 4).
4466
      // base address (instruction address + 4).
4446
      if ((r_type == elfcpp::R_ARM_THM_CALL) && may_use_blx && !target_is_thumb)
4467
      if ((r_type == elfcpp::R_ARM_THM_CALL) && may_use_blx && !target_is_thumb)
4447
	destination = Bits<32>::bit_select32(destination, location, 0x2);
4468
	destination = Bits<32>::bit_select32(destination, location, 0x2);
4469
4470
      bool use_plt = (gsym && gsym->has_plt_offset());
4471
      if (r_type == elfcpp::R_ARM_THM_JUMP24 && use_plt)
4472
	destination -= 4;
4473
4448
      branch_offset = static_cast<int64_t>(destination) - location;
4474
      branch_offset = static_cast<int64_t>(destination) - location;
4449
	
4475
4450
      // Handle cases where:
4476
      // Handle cases where:
4451
      // - this call goes too far (different Thumb/Thumb2 max
4477
      // - this call goes too far (different Thumb/Thumb2 max
4452
      //   distance)
4478
      //   distance)
Lines 4460-4466 Reloc_stub::stub_type_for_reloc( Link Here
4460
		  || (branch_offset < THM2_MAX_BWD_BRANCH_OFFSET)))
4486
		  || (branch_offset < THM2_MAX_BWD_BRANCH_OFFSET)))
4461
	  || ((!target_is_thumb)
4487
	  || ((!target_is_thumb)
4462
	      && (((r_type == elfcpp::R_ARM_THM_CALL) && !may_use_blx)
4488
	      && (((r_type == elfcpp::R_ARM_THM_CALL) && !may_use_blx)
4463
		  || (r_type == elfcpp::R_ARM_THM_JUMP24))))
4489
		  || (r_type == elfcpp::R_ARM_THM_JUMP24))
4490
	      && !use_plt))
4464
	{
4491
	{
4465
	  if (target_is_thumb)
4492
	  if (target_is_thumb)
4466
	    {
4493
	    {
Lines 7187-7193 class Output_data_plt_arm : public Output_section_data Link Here
7187
7214
7188
  // Add an entry to the PLT.
7215
  // Add an entry to the PLT.
7189
  void
7216
  void
7190
  add_entry(Symbol* gsym);
7217
  add_entry(Symbol* gsym, bool, bool);
7218
7219
  // Calculate offsets for PLT entries.
7220
  void
7221
  calculate_offsets(bool);
7191
7222
7192
  // Return the .rel.plt section data.
7223
  // Return the .rel.plt section data.
7193
  const Reloc_section*
7224
  const Reloc_section*
Lines 7197-7203 class Output_data_plt_arm : public Output_section_data Link Here
7197
  // Return the number of PLT entries.
7228
  // Return the number of PLT entries.
7198
  unsigned int
7229
  unsigned int
7199
  entry_count() const
7230
  entry_count() const
7200
  { return this->count_; }
7231
  { return this->info_.size(); }
7201
7232
7202
  // Return the offset of the first non-reserved PLT entry.
7233
  // Return the offset of the first non-reserved PLT entry.
7203
  static unsigned int
7234
  static unsigned int
Lines 7225-7248 class Output_data_plt_arm : public Output_section_data Link Here
7225
  // Template for subsequent PLT entries. 
7256
  // Template for subsequent PLT entries. 
7226
  static const uint32_t plt_entry[3];
7257
  static const uint32_t plt_entry[3];
7227
7258
7259
  // Template for Thumb stub in PLT entries.
7260
  static const uint16_t thumb_plt_entry_stub[2];
7261
7228
  // Set the final size.
7262
  // Set the final size.
7229
  void
7263
  void
7230
  set_final_data_size()
7264
  set_final_data_size()
7231
  {
7265
  { gold_assert(this->total_size_ != 0);
7232
    this->set_data_size(sizeof(first_plt_entry)
7266
    this->set_data_size(this->total_size_); }
7233
			+ this->count_ * sizeof(plt_entry));
7234
  }
7235
7267
7236
  // Write out the PLT data.
7268
  // Write out the PLT data.
7237
  void
7269
  void
7238
  do_write(Output_file*);
7270
  do_write(Output_file*);
7239
7271
7272
  // Information about where PLT entries are referenced from.
7273
  struct plt_reference
7274
  {
7275
    plt_reference()
7276
      : from_thumb_calls_(false),
7277
	from_thumb_jumps_(false),
7278
	needs_thumb_stub_(false)
7279
    { }
7280
7281
    plt_reference(bool from_thumb_calls, bool from_thumb_jumps)
7282
      : from_thumb_calls_(from_thumb_calls),
7283
	from_thumb_jumps_(from_thumb_jumps),
7284
	needs_thumb_stub_(false)
7285
    { }
7286
7287
    bool from_thumb_calls_;
7288
    bool from_thumb_jumps_;
7289
    bool needs_thumb_stub_;
7290
  };
7291
7240
  // The reloc section.
7292
  // The reloc section.
7241
  Reloc_section* rel_;
7293
  Reloc_section* rel_;
7242
  // The .got.plt section.
7294
  // The .got.plt section.
7243
  Output_data_space* got_plt_;
7295
  Output_data_space* got_plt_;
7244
  // The number of PLT entries.
7296
  // Collected information for determining necessity of Thumb stubs.
7245
  unsigned int count_;
7297
  typedef Unordered_map<Symbol *, plt_reference> Thumb_stub_map;
7298
  Thumb_stub_map info_;
7299
  // Total size in bytes of all the entries.
7300
  size_t total_size_;
7246
};
7301
};
7247
7302
7248
// Create the PLT section.  The ordinary .got section is an argument,
7303
// Create the PLT section.  The ordinary .got section is an argument,
Lines 7252-7258 class Output_data_plt_arm : public Output_section_data Link Here
7252
template<bool big_endian>
7307
template<bool big_endian>
7253
Output_data_plt_arm<big_endian>::Output_data_plt_arm(Layout* layout,
7308
Output_data_plt_arm<big_endian>::Output_data_plt_arm(Layout* layout,
7254
						     Output_data_space* got_plt)
7309
						     Output_data_space* got_plt)
7255
  : Output_section_data(4), got_plt_(got_plt), count_(0)
7310
  : Output_section_data(4), got_plt_(got_plt)
7256
{
7311
{
7257
  this->rel_ = new Reloc_section(false);
7312
  this->rel_ = new Reloc_section(false);
7258
  layout->add_output_section_data(".rel.plt", elfcpp::SHT_REL,
7313
  layout->add_output_section_data(".rel.plt", elfcpp::SHT_REL,
Lines 7271-7286 Output_data_plt_arm<big_endian>::do_adjust_output_section(Output_section* os) Link Here
7271
7326
7272
template<bool big_endian>
7327
template<bool big_endian>
7273
void
7328
void
7274
Output_data_plt_arm<big_endian>::add_entry(Symbol* gsym)
7329
Output_data_plt_arm<big_endian>::add_entry(Symbol* gsym,
7330
					   bool from_thumb_call,
7331
					   bool from_thumb_jump)
7275
{
7332
{
7276
  gold_assert(!gsym->has_plt_offset());
7333
  gold_assert(!gsym->has_plt_offset());
7277
7334
7278
  // Note that when setting the PLT offset we skip the initial
7335
  // We want to record information about how the PLT entries are
7279
  // reserved PLT entry.
7336
  // referenced.  We'll use this information in do_finalize_sections to
7280
  gsym->set_plt_offset((this->count_) * sizeof(plt_entry)
7337
  // assign offsets to all the symbols.
7281
		       + sizeof(first_plt_entry));
7338
  typename Thumb_stub_map::iterator it = this->info_.find(gsym);
7339
  if (it != this->info_.end())
7340
    {
7341
      it->second.from_thumb_calls_
7342
	= it->second.from_thumb_calls_ || from_thumb_call;
7343
      it->second.from_thumb_jumps_
7344
	= it->second.from_thumb_jumps_ || from_thumb_jump;
7345
      return;
7346
    }
7282
7347
7283
  ++this->count_;
7348
  struct plt_reference pr(from_thumb_call, from_thumb_jump);
7349
  this->info_[gsym] = pr;
7284
7350
7285
  section_offset_type got_offset = this->got_plt_->current_data_size();
7351
  section_offset_type got_offset = this->got_plt_->current_data_size();
7286
7352
Lines 7299-7304 Output_data_plt_arm<big_endian>::add_entry(Symbol* gsym) Link Here
7299
  // appear in the relocations.
7365
  // appear in the relocations.
7300
}
7366
}
7301
7367
7368
// Calculate offsets for all the PLT symbols.
7369
7370
template<bool big_endian>
7371
void
7372
Output_data_plt_arm<big_endian>::calculate_offsets(bool may_use_blx)
7373
{
7374
  size_t offset = sizeof(first_plt_entry);
7375
7376
  for(typename Thumb_stub_map::iterator it = this->info_.begin();
7377
      it != this->info_.end();
7378
      ++it, offset += sizeof(plt_entry))
7379
    {
7380
      Symbol *sym = it->first;
7381
      bool needs_thumb_stub = (it->second.from_thumb_calls_
7382
			       || (!may_use_blx
7383
				   && it->second.from_thumb_jumps_));
7384
      it->second.needs_thumb_stub_ = needs_thumb_stub;
7385
7386
      // Note that when setting the PLT offset we skip the initial
7387
      // reserved PLT entry.
7388
      //
7389
      // Make the entry point to the start of the ARM code, rather than
7390
      // the Thumb stub.
7391
      if (needs_thumb_stub)
7392
	offset += sizeof(thumb_plt_entry_stub);
7393
      sym->set_plt_offset(offset);
7394
    }
7395
7396
  this->total_size_ = offset;
7397
}
7398
7302
// ARM PLTs.
7399
// ARM PLTs.
7303
// FIXME:  This is not very flexible.  Right now this has only been tested
7400
// FIXME:  This is not very flexible.  Right now this has only been tested
7304
// on armv5te.  If we are to support additional architecture features like
7401
// on armv5te.  If we are to support additional architecture features like
Lines 7325-7330 const uint32_t Output_data_plt_arm<big_endian>::plt_entry[3] = Link Here
7325
  0xe5bcf000,	// ldr   pc, [ip, #0xNNN]!
7422
  0xe5bcf000,	// ldr   pc, [ip, #0xNNN]!
7326
};
7423
};
7327
7424
7425
// Thumb stub for PLT entries.
7426
7427
template<bool big_endian>
7428
const uint16_t Output_data_plt_arm<big_endian>::thumb_plt_entry_stub[2] =
7429
{
7430
  0x4778,	// bx pc
7431
  0x46c0	// nop
7432
};
7433
7328
// Write out the PLT.  This uses the hand-coded instructions above,
7434
// Write out the PLT.  This uses the hand-coded instructions above,
7329
// and adjusts them as needed.  This is all specified by the arm ELF
7435
// and adjusts them as needed.  This is all specified by the arm ELF
7330
// Processor Supplement.
7436
// Processor Supplement.
Lines 7363-7382 Output_data_plt_arm<big_endian>::do_write(Output_file* of) Link Here
7363
  memset(got_pov, 0, 12);
7469
  memset(got_pov, 0, 12);
7364
  got_pov += 12;
7470
  got_pov += 12;
7365
7471
7472
  // Write the rest of the PLT entries.
7366
  const int rel_size = elfcpp::Elf_sizes<32>::rel_size;
7473
  const int rel_size = elfcpp::Elf_sizes<32>::rel_size;
7367
  unsigned int plt_offset = sizeof(first_plt_entry);
7474
  unsigned int plt_offset = sizeof(first_plt_entry);
7368
  unsigned int plt_rel_offset = 0;
7475
  unsigned int plt_rel_offset = 0;
7369
  unsigned int got_offset = 12;
7476
  unsigned int got_offset = 12;
7370
  const unsigned int count = this->count_;
7477
  for (typename Thumb_stub_map::const_iterator it = this->info_.begin();
7371
  for (unsigned int i = 0;
7478
       it != this->info_.end();
7372
       i < count;
7479
       ++it,
7373
       ++i,
7374
	 pov += sizeof(plt_entry),
7480
	 pov += sizeof(plt_entry),
7375
	 got_pov += 4,
7481
	 got_pov += 4,
7376
	 plt_offset += sizeof(plt_entry),
7482
	 plt_offset += sizeof(plt_entry),
7377
	 plt_rel_offset += rel_size,
7483
	 plt_rel_offset += rel_size,
7378
	 got_offset += 4)
7484
	 got_offset += 4)
7379
    {
7485
    {
7486
      // Write the thumb stub first if necessary.
7487
      if (it->second.needs_thumb_stub_)
7488
	{
7489
	  elfcpp::Swap<16, big_endian>::writeval(pov,
7490
						 thumb_plt_entry_stub[0]);
7491
	  elfcpp::Swap<16, big_endian>::writeval(pov + 2,
7492
						 thumb_plt_entry_stub[1]);
7493
	  pov += sizeof(thumb_plt_entry_stub);
7494
	  plt_offset += sizeof(thumb_plt_entry_stub);
7495
	}
7496
7380
      // Set and adjust the PLT entry itself.
7497
      // Set and adjust the PLT entry itself.
7381
      int32_t offset = ((got_address + got_offset)
7498
      int32_t offset = ((got_address + got_offset)
7382
			 - (plt_address + plt_offset + 8));
7499
			 - (plt_address + plt_offset + 8));
Lines 7405-7411 Output_data_plt_arm<big_endian>::do_write(Output_file* of) Link Here
7405
template<bool big_endian>
7522
template<bool big_endian>
7406
void
7523
void
7407
Target_arm<big_endian>::make_plt_entry(Symbol_table* symtab, Layout* layout,
7524
Target_arm<big_endian>::make_plt_entry(Symbol_table* symtab, Layout* layout,
7408
				       Symbol* gsym)
7525
				       Symbol* gsym, bool from_thumb_call,
7526
				       bool from_thumb_jump)
7409
{
7527
{
7410
  if (gsym->has_plt_offset())
7528
  if (gsym->has_plt_offset())
7411
    return;
7529
    return;
Lines 7421-7427 Target_arm<big_endian>::make_plt_entry(Symbol_table* symtab, Layout* layout, Link Here
7421
				       | elfcpp::SHF_EXECINSTR),
7539
				       | elfcpp::SHF_EXECINSTR),
7422
				      this->plt_, ORDER_PLT, false);
7540
				      this->plt_, ORDER_PLT, false);
7423
    }
7541
    }
7424
  this->plt_->add_entry(gsym);
7542
  this->plt_->add_entry(gsym, from_thumb_call, from_thumb_jump);
7425
}
7543
}
7426
7544
7427
// Return the number of entries in the PLT.
7545
// Return the number of entries in the PLT.
Lines 8156-8162 Target_arm<big_endian>::Scan::global(Symbol_table* symtab, Link Here
8156
        // Make a PLT entry if necessary.
8274
        // Make a PLT entry if necessary.
8157
        if (this->symbol_needs_plt_entry(gsym))
8275
        if (this->symbol_needs_plt_entry(gsym))
8158
          {
8276
          {
8159
            target->make_plt_entry(symtab, layout, gsym);
8277
            target->make_plt_entry(symtab, layout, gsym, false, false);
8160
            // Since this is not a PC-relative relocation, we may be
8278
            // Since this is not a PC-relative relocation, we may be
8161
            // taking the address of a function. In that case we need to
8279
            // taking the address of a function. In that case we need to
8162
            // set the entry in the dynamic symbol table to the address of
8280
            // set the entry in the dynamic symbol table to the address of
Lines 8295-8301 Target_arm<big_endian>::Scan::global(Symbol_table* symtab, Link Here
8295
	  && !gsym->is_from_dynobj()
8413
	  && !gsym->is_from_dynobj()
8296
	  && !gsym->is_preemptible())
8414
	  && !gsym->is_preemptible())
8297
	break;
8415
	break;
8298
      target->make_plt_entry(symtab, layout, gsym);
8416
      target->make_plt_entry(symtab, layout, gsym,
8417
			     r_type == elfcpp::R_ARM_THM_CALL,
8418
			     (r_type == elfcpp::R_ARM_THM_JUMP24
8419
			      || r_type == elfcpp::R_ARM_THM_JUMP19));
8299
      break;
8420
      break;
8300
8421
8301
    case elfcpp::R_ARM_GOT_BREL:
8422
    case elfcpp::R_ARM_GOT_BREL:
Lines 8589-8594 Target_arm<big_endian>::do_finalize_sections( Link Here
8589
    gold_error(_("unable to provide V4BX reloc interworking fix up; "
8710
    gold_error(_("unable to provide V4BX reloc interworking fix up; "
8590
	         "the target profile does not support BX instruction"));
8711
	         "the target profile does not support BX instruction"));
8591
8712
8713
  if (this->plt_ != NULL)
8714
    this->plt_->calculate_offsets(this->may_use_v5t_interworking());
8715
8592
  // Fill in some more dynamic tags.
8716
  // Fill in some more dynamic tags.
8593
  const Reloc_section* rel_plt = (this->plt_ == NULL
8717
  const Reloc_section* rel_plt = (this->plt_ == NULL
8594
				  ? NULL
8718
				  ? NULL
Lines 10907-10913 Target_arm<big_endian>::scan_reloc_for_stub( Link Here
10907
	  symval.set_output_value(this->plt_section()->address()
11031
	  symval.set_output_value(this->plt_section()->address()
10908
				  + gsym->plt_offset());
11032
				  + gsym->plt_offset());
10909
	  psymval = &symval;
11033
	  psymval = &symval;
10910
	  target_is_thumb = false;
11034
	  target_is_thumb = 0;
10911
	}
11035
	}
10912
      else if (gsym->is_undefined())
11036
      else if (gsym->is_undefined())
10913
	// There is no need to generate a stub symbol is undefined.
11037
	// There is no need to generate a stub symbol is undefined.
Lines 10968-10974 Target_arm<big_endian>::scan_reloc_for_stub( Link Here
10968
11092
10969
  Reloc_stub* stub = NULL;
11093
  Reloc_stub* stub = NULL;
10970
  Stub_type stub_type =
11094
  Stub_type stub_type =
10971
    Reloc_stub::stub_type_for_reloc(r_type, address, destination,
11095
    Reloc_stub::stub_type_for_reloc(r_type, gsym, address, destination,
10972
				    target_is_thumb);
11096
				    target_is_thumb);
10973
  if (stub_type != arm_stub_none)
11097
  if (stub_type != arm_stub_none)
10974
    {
11098
    {

Return to bug 13320