switch (r_type)
{
- case R_CR16_IMM4:
- case R_CR16_IMM20:
- case R_CR16_ABS20:
- break;
-
- case R_CR16_IMM8:
- case R_CR16_IMM16:
- case R_CR16_IMM32:
- case R_CR16_IMM32a:
- case R_CR16_REGREL4:
- case R_CR16_REGREL4a:
- case R_CR16_REGREL14:
- case R_CR16_REGREL14a:
- case R_CR16_REGREL16:
- case R_CR16_REGREL20:
- case R_CR16_REGREL20a:
- case R_CR16_GOT_REGREL20:
- case R_CR16_GOTC_REGREL20:
- case R_CR16_ABS24:
- case R_CR16_DISP16:
- case R_CR16_DISP24:
- /* 'hit_data' is relative to the start of the instruction, not the
- relocation offset. Advance it to account for the exact offset. */
- hit_data += 2;
- break;
-
- case R_CR16_NONE:
- return bfd_reloc_ok;
- break;
-
- case R_CR16_DISP4:
- if (is_local)
+ case R_CR16_IMM4:
+ case R_CR16_IMM20:
+ case R_CR16_ABS20:
+ break;
+
+ case R_CR16_IMM8:
+ case R_CR16_IMM16:
+ case R_CR16_IMM32:
+ case R_CR16_IMM32a:
+ case R_CR16_REGREL4:
+ case R_CR16_REGREL4a:
+ case R_CR16_REGREL14:
+ case R_CR16_REGREL14a:
+ case R_CR16_REGREL16:
+ case R_CR16_REGREL20:
+ case R_CR16_REGREL20a:
+ case R_CR16_GOT_REGREL20:
+ case R_CR16_GOTC_REGREL20:
+ case R_CR16_ABS24:
+ case R_CR16_DISP16:
+ case R_CR16_DISP24:
+ /* 'hit_data' is relative to the start of the instruction, not the
+ relocation offset. Advance it to account for the exact offset. */
+ hit_data += 2;
+ break;
+
+ case R_CR16_NONE:
+ return bfd_reloc_ok;
+ break;
+
+ case R_CR16_DISP4:
+ if (is_local)
Rvalue += -1;
- break;
+ break;
- case R_CR16_DISP8:
- case R_CR16_DISP24a:
- if (is_local)
+ case R_CR16_DISP8:
+ case R_CR16_DISP24a:
+ if (is_local)
Rvalue -= -1;
- break;
+ break;
- case R_CR16_SWITCH8:
- case R_CR16_SWITCH16:
- case R_CR16_SWITCH32:
- /* We only care about the addend, where the difference between
- expressions is kept. */
- Rvalue = 0;
+ case R_CR16_SWITCH8:
+ case R_CR16_SWITCH16:
+ case R_CR16_SWITCH32:
+ /* We only care about the addend, where the difference between
+ expressions is kept. */
+ Rvalue = 0;
- default:
- break;
+ default:
+ break;
}
if (howto->pc_relative)
/* For GOT and GOTC relocs no boundary checks applied. */
if (!((r_type == R_CR16_GOT_REGREL20)
- || (r_type == R_CR16_GOTC_REGREL20)))
+ || (r_type == R_CR16_GOTC_REGREL20)))
{
if (((bfd_vma) check & ~reloc_bits) != 0
&& (((bfd_vma) check & ~reloc_bits)
- != (-(bfd_vma) 1 & ~reloc_bits)))
+ != (-(bfd_vma) 1 & ~reloc_bits)))
{
/* The above right shift is incorrect for a signed
value. See if turning on the upper bits fixes the
overflow. */
if (howto->rightshift && (bfd_signed_vma) Rvalue < 0)
{
- check |= ((bfd_vma) - 1
- & ~((bfd_vma) - 1
- >> howto->rightshift));
+ check |= ((bfd_vma) -1
+ & ~((bfd_vma) -1 >> howto->rightshift));
if (((bfd_vma) check & ~reloc_bits)
!= (-(bfd_vma) 1 & ~reloc_bits))
- return bfd_reloc_overflow;
+ return bfd_reloc_overflow;
}
else
return bfd_reloc_overflow;
switch (howto->size)
{
- case 0:
- if (r_type == R_CR16_DISP8)
- {
- Rvalue1 = bfd_get_16 (input_bfd, hit_data);
- Rvalue = ((Rvalue1 & 0xf000) | ((Rvalue << 4) & 0xf00)
- | (Rvalue1 & 0x00f0) | (Rvalue & 0xf));
- bfd_put_16 (input_bfd, Rvalue, hit_data);
- }
- else if (r_type == R_CR16_IMM4)
- {
- Rvalue1 = bfd_get_16 (input_bfd, hit_data);
- Rvalue = (((Rvalue1 & 0xff) << 8) | ((Rvalue << 4) & 0xf0)
- | ((Rvalue1 & 0x0f00) >> 8));
- bfd_put_16 (input_bfd, Rvalue, hit_data);
- }
- else if (r_type == R_CR16_DISP4)
- {
- Rvalue1 = bfd_get_16 (input_bfd, hit_data);
- Rvalue = (Rvalue1 | ((Rvalue & 0xf) << 4));
- bfd_put_16 (input_bfd, Rvalue, hit_data);
- }
- else
- {
- bfd_put_8 (input_bfd, (unsigned char) Rvalue, hit_data);
- }
- break;
-
- case 1:
- if (r_type == R_CR16_DISP16)
- {
- Rvalue |= (bfd_get_16 (input_bfd, hit_data));
- Rvalue = ((Rvalue & 0xfffe) | ((Rvalue >> 16) & 0x1));
- }
- if (r_type == R_CR16_IMM16)
- {
- Rvalue1 = bfd_get_16 (input_bfd, hit_data);
-
- /* Add or subtract the offset value. */
- if (Rvalue1 & 0x8000)
- Rvalue -= (~Rvalue1 + 1) & 0xffff;
- else
- Rvalue += Rvalue1;
+ case 0:
+ if (r_type == R_CR16_DISP8)
+ {
+ Rvalue1 = bfd_get_16 (input_bfd, hit_data);
+ Rvalue = ((Rvalue1 & 0xf000) | ((Rvalue << 4) & 0xf00)
+ | (Rvalue1 & 0x00f0) | (Rvalue & 0xf));
+ bfd_put_16 (input_bfd, Rvalue, hit_data);
+ }
+ else if (r_type == R_CR16_IMM4)
+ {
+ Rvalue1 = bfd_get_16 (input_bfd, hit_data);
+ Rvalue = (((Rvalue1 & 0xff) << 8) | ((Rvalue << 4) & 0xf0)
+ | ((Rvalue1 & 0x0f00) >> 8));
+ bfd_put_16 (input_bfd, Rvalue, hit_data);
+ }
+ else if (r_type == R_CR16_DISP4)
+ {
+ Rvalue1 = bfd_get_16 (input_bfd, hit_data);
+ Rvalue = (Rvalue1 | ((Rvalue & 0xf) << 4));
+ bfd_put_16 (input_bfd, Rvalue, hit_data);
+ }
+ else
+ {
+ bfd_put_8 (input_bfd, (unsigned char) Rvalue, hit_data);
+ }
+ break;
+
+ case 1:
+ if (r_type == R_CR16_DISP16)
+ {
+ Rvalue |= (bfd_get_16 (input_bfd, hit_data));
+ Rvalue = ((Rvalue & 0xfffe) | ((Rvalue >> 16) & 0x1));
+ }
+ if (r_type == R_CR16_IMM16)
+ {
+ Rvalue1 = bfd_get_16 (input_bfd, hit_data);
+
+ Rvalue1 = (Rvalue1 ^ 0x8000) - 0x8000;
+ Rvalue += Rvalue1;
- /* Check for range. */
- if ((long) Rvalue > 0xffff || (long) Rvalue < 0x0)
- return bfd_reloc_overflow;
- }
+ /* Check for range. */
+ if (Rvalue > 0xffff)
+ return bfd_reloc_overflow;
+ }
- bfd_put_16 (input_bfd, Rvalue, hit_data);
- break;
+ bfd_put_16 (input_bfd, Rvalue, hit_data);
+ break;
- case 2:
- if ((r_type == R_CR16_ABS20) || (r_type == R_CR16_IMM20))
- {
- Rvalue1 = (bfd_get_16 (input_bfd, hit_data + 2)
- | (((bfd_get_16 (input_bfd, hit_data) & 0xf) <<16)));
+ case 2:
+ if ((r_type == R_CR16_ABS20) || (r_type == R_CR16_IMM20))
+ {
+ Rvalue1 = (bfd_get_16 (input_bfd, hit_data + 2)
+ | (((bfd_get_16 (input_bfd, hit_data) & 0xf) << 16)));
- /* Add or subtract the offset value. */
- if (Rvalue1 & 0x80000)
- Rvalue -= (~Rvalue1 + 1) & 0xfffff;
- else
- Rvalue += Rvalue1;
+ Rvalue1 = (Rvalue1 ^ 0x80000) - 0x80000;
+ Rvalue += Rvalue1;
- /* Check for range. */
- if ((long) Rvalue > 0xfffff || (long) Rvalue < 0x0)
- return bfd_reloc_overflow;
-
- bfd_put_16 (input_bfd, ((bfd_get_16 (input_bfd, hit_data) & 0xfff0)
- | ((Rvalue >> 16) & 0xf)), hit_data);
- bfd_put_16 (input_bfd, (Rvalue) & 0xffff, hit_data + 2);
- }
- else if (r_type == R_CR16_GOT_REGREL20)
- {
- asection *sgot = elf_hash_table (info)->sgot;
-
- if (h != NULL)
- {
- bfd_vma off;
-
- off = h->got.offset;
- BFD_ASSERT (off != (bfd_vma) -1);
-
- if (! elf_hash_table (info)->dynamic_sections_created
- || SYMBOL_REFERENCES_LOCAL (info, h))
- /* This is actually a static link, or it is a
- -Bsymbolic link and the symbol is defined
- locally, or the symbol was forced to be local
- because of a version file. We must initialize
- this entry in the global offset table.
- When doing a dynamic link, we create a .rela.got
- relocation entry to initialize the value. This
- is done in the finish_dynamic_symbol routine. */
- bfd_put_32 (output_bfd, Rvalue, sgot->contents + off);
-
- Rvalue = sgot->output_offset + off;
- }
- else
- {
- bfd_vma off;
+ /* Check for range. */
+ if (Rvalue > 0xfffff)
+ return bfd_reloc_overflow;
- off = elf_local_got_offsets (input_bfd)[symndx];
- bfd_put_32 (output_bfd,Rvalue, sgot->contents + off);
+ bfd_put_16 (input_bfd, ((bfd_get_16 (input_bfd, hit_data) & 0xfff0)
+ | ((Rvalue >> 16) & 0xf)), hit_data);
+ bfd_put_16 (input_bfd, (Rvalue) & 0xffff, hit_data + 2);
+ }
+ else if (r_type == R_CR16_GOT_REGREL20)
+ {
+ asection *sgot = elf_hash_table (info)->sgot;
+ bfd_vma off;
+
+ if (h != NULL)
+ {
+ off = h->got.offset;
+ BFD_ASSERT (off != (bfd_vma) -1);
+
+ if (! elf_hash_table (info)->dynamic_sections_created
+ || SYMBOL_REFERENCES_LOCAL (info, h))
+ /* This is actually a static link, or it is a
+ -Bsymbolic link and the symbol is defined
+ locally, or the symbol was forced to be local
+ because of a version file. We must initialize
+ this entry in the global offset table.
+ When doing a dynamic link, we create a .rela.got
+ relocation entry to initialize the value. This
+ is done in the finish_dynamic_symbol routine. */
+ bfd_put_32 (output_bfd, Rvalue, sgot->contents + off);
+ }
+ else
+ {
+ off = elf_local_got_offsets (input_bfd)[symndx];
+ bfd_put_32 (output_bfd, Rvalue, sgot->contents + off);
+ }
+
+ Rvalue = sgot->output_offset + off;
+ Rvalue += addend;
+
+ /* REVISIT: if ((long) Rvalue > 0xffffff ||
+ (long) Rvalue < -0x800000). */
+ if (Rvalue > 0xffffff)
+ return bfd_reloc_overflow;
- Rvalue = sgot->output_offset + off;
- }
- Rvalue += addend;
+ bfd_put_16 (input_bfd, (bfd_get_16 (input_bfd, hit_data))
+ | (((Rvalue >> 16) & 0xf) << 8), hit_data);
+ bfd_put_16 (input_bfd, (Rvalue) & 0xffff, hit_data + 2);
- /* REVISIT: if ((long) Rvalue > 0xffffff ||
- (long) Rvalue < -0x800000). */
- if ((long) Rvalue > 0xffffff || (long) Rvalue < 0)
- return bfd_reloc_overflow;
+ }
+ else if (r_type == R_CR16_GOTC_REGREL20)
+ {
+ asection *sgot = elf_hash_table (info)->sgot;
+ bfd_vma off;
+
+ if (h != NULL)
+ {
+ off = h->got.offset;
+ BFD_ASSERT (off != (bfd_vma) -1);
+
+ Rvalue >>= 1; /* For code symbols. */
+
+ if (! elf_hash_table (info)->dynamic_sections_created
+ || SYMBOL_REFERENCES_LOCAL (info, h))
+ /* This is actually a static link, or it is a
+ -Bsymbolic link and the symbol is defined
+ locally, or the symbol was forced to be local
+ because of a version file. We must initialize
+ this entry in the global offset table.
+ When doing a dynamic link, we create a .rela.got
+ relocation entry to initialize the value. This
+ is done in the finish_dynamic_symbol routine. */
+ bfd_put_32 (output_bfd, Rvalue, sgot->contents + off);
+ }
+ else
+ {
+ off = elf_local_got_offsets (input_bfd)[symndx];
+ Rvalue >>= 1;
+ bfd_put_32 (output_bfd, Rvalue, sgot->contents + off);
+ }
+ Rvalue = sgot->output_offset + off;
+ Rvalue += addend;
- bfd_put_16 (input_bfd, (bfd_get_16 (input_bfd, hit_data))
- | (((Rvalue >> 16) & 0xf) << 8), hit_data);
- bfd_put_16 (input_bfd, (Rvalue) & 0xffff, hit_data + 2);
+ /* Check if any value in DISP. */
+ Rvalue1 = bfd_get_32 (input_bfd, hit_data);
+ Rvalue1 = ((Rvalue1 >> 16) | ((Rvalue1 & 0xfff) >> 8 << 16));
- }
- else if (r_type == R_CR16_GOTC_REGREL20)
- {
- asection *sgot = elf_hash_table (info)->sgot;
+ Rvalue1 = (Rvalue1 ^ 0x80000) - 0x80000;
+ Rvalue += Rvalue1;
- if (h != NULL)
- {
- bfd_vma off;
+ /* Check for range. */
+ /* REVISIT: if ((long) Rvalue > 0xffffff
+ || (long) Rvalue < -0x800000). */
+ if (Rvalue > 0xffffff)
+ return bfd_reloc_overflow;
- off = h->got.offset;
- BFD_ASSERT (off != (bfd_vma) -1);
+ bfd_put_16 (input_bfd, (bfd_get_16 (input_bfd, hit_data))
+ | (((Rvalue >> 16) & 0xf) << 8), hit_data);
+ bfd_put_16 (input_bfd, (Rvalue) & 0xffff, hit_data + 2);
+ }
+ else
+ {
+ if (r_type == R_CR16_ABS24)
+ {
+ Rvalue1 = bfd_get_32 (input_bfd, hit_data);
+ Rvalue1 = ((Rvalue1 >> 16)
+ | ((Rvalue1 & 0xfff) >> 8 << 16)
+ | ((Rvalue1 & 0xf) << 20));
- Rvalue >>=1; /* For code symbols. */
+ Rvalue1 = (Rvalue1 ^ 0x800000) - 0x800000;
+ Rvalue += Rvalue1;
- if (! elf_hash_table (info)->dynamic_sections_created
- || SYMBOL_REFERENCES_LOCAL (info, h))
- /* This is actually a static link, or it is a
- -Bsymbolic link and the symbol is defined
- locally, or the symbol was forced to be local
- because of a version file. We must initialize
- this entry in the global offset table.
- When doing a dynamic link, we create a .rela.got
- relocation entry to initialize the value. This
- is done in the finish_dynamic_symbol routine. */
- bfd_put_32 (output_bfd, Rvalue, sgot->contents + off);
+ /* Check for Range. */
+ if (Rvalue > 0xffffff)
+ return bfd_reloc_overflow;
- Rvalue = sgot->output_offset + off;
- }
- else
- {
- bfd_vma off;
+ Rvalue = ((((Rvalue >> 20) & 0xf) | (((Rvalue >> 16) & 0xf)<<8)
+ | (bfd_get_32 (input_bfd, hit_data) & 0xf0f0))
+ | ((Rvalue & 0xffff) << 16));
+ }
+ else if (r_type == R_CR16_DISP24)
+ {
+ Rvalue = ((((Rvalue >> 20)& 0xf) | (((Rvalue >>16) & 0xf)<<8)
+ | (bfd_get_16 (input_bfd, hit_data)))
+ | (((Rvalue & 0xfffe) | ((Rvalue >> 24) & 0x1)) << 16));
+ }
+ else if ((r_type == R_CR16_IMM32) || (r_type == R_CR16_IMM32a))
+ {
+ Rvalue1 = bfd_get_32 (input_bfd, hit_data);
+ Rvalue1 = (((Rvalue1 >> 16) & 0xffff)
+ | ((Rvalue1 & 0xffff) << 16));
- off = elf_local_got_offsets (input_bfd)[symndx];
- Rvalue >>= 1;
- bfd_put_32 (output_bfd,Rvalue, sgot->contents + off);
- Rvalue = sgot->output_offset + off;
- }
+ Rvalue1 = (Rvalue1 ^ 0x80000000) - 0x80000000;
+ Rvalue += Rvalue1;
- Rvalue += addend;
+ /* Check for range. */
+ if (Rvalue > 0xffffffff)
+ return bfd_reloc_overflow;
- /* Check if any value in DISP. */
- Rvalue1 =((bfd_get_32 (input_bfd, hit_data) >>16)
- | (((bfd_get_32 (input_bfd, hit_data) & 0xfff) >> 8) <<16));
+ Rvalue = (((Rvalue >> 16) & 0xffff) | (Rvalue & 0xffff) << 16);
+ }
+ else if (r_type == R_CR16_DISP24a)
+ {
+ Rvalue = (((Rvalue & 0xfffffe) | (Rvalue >> 23)));
+ Rvalue = (((Rvalue >> 16) & 0xff) | ((Rvalue & 0xffff) << 16)
+ | bfd_get_32 (input_bfd, hit_data));
+ }
+ else if ((r_type == R_CR16_REGREL20)
+ || (r_type == R_CR16_REGREL20a))
+ {
+ Rvalue1 = bfd_get_32 (input_bfd, hit_data);
+ Rvalue1 = (((Rvalue1 >> 16) & 0xffff)
+ | ((Rvalue1 & 0xfff) >> 8 << 16));
- /* Add or subtract the offset value. */
- if (Rvalue1 & 0x80000)
- Rvalue -= (~Rvalue1 + 1) & 0xfffff;
- else
- Rvalue += Rvalue1;
+ Rvalue1 = (Rvalue1 ^ 0x80000) - 0x80000;
+ Rvalue += Rvalue1;
/* Check for range. */
- /* REVISIT: if ((long) Rvalue > 0xffffff
- || (long) Rvalue < -0x800000). */
- if ((long) Rvalue > 0xffffff || (long) Rvalue < 0)
- return bfd_reloc_overflow;
-
- bfd_put_16 (input_bfd, (bfd_get_16 (input_bfd, hit_data))
- | (((Rvalue >> 16) & 0xf) << 8), hit_data);
- bfd_put_16 (input_bfd, (Rvalue) & 0xffff, hit_data + 2);
- }
- else
- {
- if (r_type == R_CR16_ABS24)
- {
- Rvalue1 = ((bfd_get_32 (input_bfd, hit_data) >> 16)
- | (((bfd_get_32 (input_bfd, hit_data) & 0xfff) >> 8) <<16)
- | (((bfd_get_32 (input_bfd, hit_data) & 0xf) <<20)));
-
- /* Add or subtract the offset value. */
- if (Rvalue1 & 0x800000)
- Rvalue -= (~Rvalue1 + 1) & 0xffffff;
- else
- Rvalue += Rvalue1;
-
- /* Check for Range. */
- if ((long) Rvalue > 0xffffff || (long) Rvalue < 0x0)
- return bfd_reloc_overflow;
-
- Rvalue = ((((Rvalue >> 20) & 0xf) | (((Rvalue >> 16) & 0xf)<<8)
- | (bfd_get_32 (input_bfd, hit_data) & 0xf0f0))
- | ((Rvalue & 0xffff) << 16));
- }
- else if (r_type == R_CR16_DISP24)
- {
- Rvalue = ((((Rvalue >> 20)& 0xf) | (((Rvalue >>16) & 0xf)<<8)
- | (bfd_get_16 (input_bfd, hit_data)))
- | (((Rvalue & 0xfffe) | ((Rvalue >> 24) & 0x1)) << 16));
- }
- else if ((r_type == R_CR16_IMM32) || (r_type == R_CR16_IMM32a))
- {
- Rvalue1 =((((bfd_get_32 (input_bfd, hit_data)) >> 16) &0xffff)
- | (((bfd_get_32 (input_bfd, hit_data)) &0xffff)) << 16);
-
- /* Add or subtract the offset value. */
- if (Rvalue1 & 0x80000000)
- Rvalue -= (~Rvalue1 + 1) & 0xffffffff;
- else
- Rvalue += Rvalue1;
-
- /* Check for range. */
- if (Rvalue > 0xffffffff || (long) Rvalue < 0x0)
- return bfd_reloc_overflow;
-
- Rvalue = (((Rvalue >> 16)& 0xffff) | (Rvalue & 0xffff) << 16);
- }
- else if (r_type == R_CR16_DISP24a)
- {
- Rvalue = (((Rvalue & 0xfffffe) | (Rvalue >> 23)));
- Rvalue = ((Rvalue >> 16) & 0xff) | ((Rvalue & 0xffff) << 16)
- | (bfd_get_32 (input_bfd, hit_data));
- }
- else if ((r_type == R_CR16_REGREL20)
- || (r_type == R_CR16_REGREL20a))
- {
- Rvalue1 = ((bfd_get_32 (input_bfd, hit_data) >> 16)
- | (((bfd_get_32 (input_bfd, hit_data) & 0xfff) >> 8) <<16));
- /* Add or subtract the offset value. */
- if (Rvalue1 & 0x80000)
- Rvalue -= (~Rvalue1 + 1) & 0xfffff;
- else
- Rvalue += Rvalue1;
-
- /* Check for range. */
- if ((long) Rvalue > 0xfffff || (long) Rvalue < 0x0)
- return bfd_reloc_overflow;
-
- Rvalue = (((((Rvalue >> 20)& 0xf) | (((Rvalue >>16) & 0xf)<<8)
- | ((Rvalue & 0xffff) << 16)))
- | (bfd_get_32 (input_bfd, hit_data) & 0xf0ff));
-
- }
- else if (r_type == R_CR16_NUM32)
- {
- Rvalue1 = (bfd_get_32 (input_bfd, hit_data));
-
- /* Add or subtract the offset value */
- if (Rvalue1 & 0x80000000)
- Rvalue -= (~Rvalue1 + 1) & 0xffffffff;
- else
- Rvalue += Rvalue1;
-
- /* Check for Ranga */
- if (Rvalue > 0xffffffff)
- return bfd_reloc_overflow;
- }
-
- bfd_put_32 (input_bfd, Rvalue, hit_data);
- }
- break;
-
- default:
- return bfd_reloc_notsupported;
+ if (Rvalue > 0xfffff)
+ return bfd_reloc_overflow;
+
+ Rvalue = (((((Rvalue >> 20) & 0xf) | (((Rvalue >> 16) & 0xf) << 8)
+ | ((Rvalue & 0xffff) << 16)))
+ | (bfd_get_32 (input_bfd, hit_data) & 0xf0ff));
+
+ }
+ else if (r_type == R_CR16_NUM32)
+ {
+ Rvalue1 = (bfd_get_32 (input_bfd, hit_data));
+
+ Rvalue1 = (Rvalue1 ^ 0x80000000) - 0x80000000;
+ Rvalue += Rvalue1;
+
+ /* Check for Range. */
+ if (Rvalue > 0xffffffff)
+ return bfd_reloc_overflow;
+ }
+
+ bfd_put_32 (input_bfd, Rvalue, hit_data);
+ }
+ break;
+
+ default:
+ return bfd_reloc_notsupported;
}
return bfd_reloc_ok;
for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
/* Get the new reloc address. */
if ((irel->r_offset > addr && irel->r_offset < toaddr))
- irel->r_offset -= count;
+ irel->r_offset -= count;
/* Adjust the local symbols defined in this section. */
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
if (ELF32_R_TYPE (irel->r_info) != (int) R_CR16_SWITCH8
&& ELF32_R_TYPE (irel->r_info) != (int) R_CR16_SWITCH16
&& ELF32_R_TYPE (irel->r_info) != (int) R_CR16_SWITCH32)
- continue;
+ continue;
r_symndx = ELF32_R_SYM (irel->r_info);
rsym = (Elf_Internal_Sym *) symtab_hdr->contents + r_symndx;
/* Now adjust the global symbols defined in this section. */
symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
- - symtab_hdr->sh_info);
+ - symtab_hdr->sh_info);
sym_hashes = start_hashes = elf_sym_hashes (abfd);
end_hashes = sym_hashes + symcount;
}
if ((sym_hash->root.type == bfd_link_hash_defined
- || sym_hash->root.type == bfd_link_hash_defweak)
+ || sym_hash->root.type == bfd_link_hash_defweak)
&& sym_hash->root.u.def.section == sec
&& sym_hash->root.u.def.value > addr
&& sym_hash->root.u.def.value < toaddr)
switch (r)
{
- case bfd_reloc_overflow:
- (*info->callbacks->reloc_overflow)
- (info, (h ? &h->root : NULL), name, howto->name,
- (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
- break;
-
- case bfd_reloc_undefined:
- (*info->callbacks->undefined_symbol)
- (info, name, input_bfd, input_section, rel->r_offset, TRUE);
- break;
-
- case bfd_reloc_outofrange:
- msg = _("internal error: out of range error");
- goto common_error;
-
- case bfd_reloc_notsupported:
- msg = _("internal error: unsupported relocation error");
- goto common_error;
-
- case bfd_reloc_dangerous:
- msg = _("internal error: dangerous error");
- goto common_error;
-
- default:
- msg = _("internal error: unknown error");
- /* Fall through. */
-
- common_error:
- (*info->callbacks->warning) (info, msg, name, input_bfd,
- input_section, rel->r_offset);
- break;
+ case bfd_reloc_overflow:
+ (*info->callbacks->reloc_overflow)
+ (info, (h ? &h->root : NULL), name, howto->name,
+ (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
+ break;
+
+ case bfd_reloc_undefined:
+ (*info->callbacks->undefined_symbol)
+ (info, name, input_bfd, input_section, rel->r_offset, TRUE);
+ break;
+
+ case bfd_reloc_outofrange:
+ msg = _("internal error: out of range error");
+ goto common_error;
+
+ case bfd_reloc_notsupported:
+ msg = _("internal error: unsupported relocation error");
+ goto common_error;
+
+ case bfd_reloc_dangerous:
+ msg = _("internal error: dangerous error");
+ goto common_error;
+
+ default:
+ msg = _("internal error: unknown error");
+ /* Fall through. */
+
+ common_error:
+ (*info->callbacks->warning) (info, msg, name, input_bfd,
+ input_section, rel->r_offset);
+ break;
}
}
}
}
if (! elf32_cr16_relocate_section (output_bfd, link_info, input_bfd,
- input_section, data, internal_relocs,
- isymbuf, sections))
+ input_section, data, internal_relocs,
+ isymbuf, sections))
goto error_return;
free (sections);
{
switch (flags)
{
- case EM_CR16:
- default:
+ case EM_CR16:
+ default:
return bfd_mach_cr16;
}
}
unsigned long val;
switch (bfd_get_mach (abfd))
{
- default:
- case bfd_mach_cr16:
- val = EM_CR16;
- break;
+ default:
+ case bfd_mach_cr16:
+ val = EM_CR16;
+ break;
}
elf_elfheader (abfd)->e_flags |= val;
return _bfd_elf_final_write_processing (abfd);
{
if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
bfd_get_mach (ibfd)))
- return FALSE;
- }
+ return FALSE;
+ }
return TRUE;
}
unsigned int code;
/* Get the opcode. */
- code = (unsigned int) bfd_get_32 (abfd, contents + irel->r_offset);
+ code = (unsigned int) bfd_get_32 (abfd,
+ contents + irel->r_offset);
/* Verify it's a 'bcond' and fix the opcode. */
if ((code & 0xffff) == 0x0010)
- bfd_put_16 (abfd, 0x1800 | ((0xf & (code >> 20)) << 4), contents + irel->r_offset);
+ bfd_put_16 (abfd, 0x1800 | ((0xf & (code >> 20)) << 4),
+ contents + irel->r_offset);
else
continue;
/* Delete two bytes of data. */
if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec,
- irel->r_offset + 2, 2))
+ irel->r_offset + 2, 2))
goto error_return;
/* That will change things, so, we should relax again.
unsigned short code;
/* Get the opcode. */
- code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
+ code = bfd_get_16 (abfd, contents + irel->r_offset);
/* Verify it's a 'bcond' and fix the opcode. */
if ((code & 0xff0f) == 0x1800)
/* Delete two bytes of data. */
if (!elf32_cr16_relax_delete_bytes (link_info, abfd, sec,
- irel->r_offset + 2, 2))
+ irel->r_offset + 2, 2))
goto error_return;
/* That will change things, so, we should relax again.
bfd_vma value1 = 0;
/* Get the existing value from the mcode */
- value1 = ((bfd_get_32 (abfd, contents + irel->r_offset + 2) >> 16)
- |(((bfd_get_32 (abfd, contents + irel->r_offset + 2) & 0xffff) << 16)));
+ value1 = bfd_get_32 (abfd, contents + irel->r_offset + 2);
+ value1 = (value1 >> 16) | ((value1 & 0xffff) << 16);
/* See if the value will fit in 20 bits. */
if ((long) (value + value1) < 0xfffff && (long) (value + value1) > 0)
unsigned short code;
/* Get the opcode. */
- code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
+ code = bfd_get_16 (abfd, contents + irel->r_offset);
/* Verify it's a 'arithmetic ADDD or MOVD instruction'.
For ADDD and MOVD only, convert to IMM32 -> IMM20. */
if (((code & 0xfff0) == 0x0070) || ((code & 0xfff0) == 0x0020))
- is_add_mov = 1;
+ is_add_mov = 1;
if (is_add_mov)
{
place the 16-20bits (ie 4 bit) in new opcode,
as the 0xffffxxxx, the higher 2 byte values removed. */
if (value1 & 0x80000000)
- bfd_put_8 (abfd, (0x0f | (bfd_get_8(abfd, contents + irel->r_offset))), contents + irel->r_offset);
+ bfd_put_8 (abfd,
+ (0x0f | (bfd_get_8 (abfd,
+ contents + irel->r_offset))),
+ contents + irel->r_offset);
else
- bfd_put_8 (abfd, (((value1 >> 16)&0xf) | (bfd_get_8(abfd, contents + irel->r_offset))), contents + irel->r_offset);
+ bfd_put_8 (abfd,
+ (((value1 >> 16) & 0xf)
+ | (bfd_get_8 (abfd,
+ contents + irel->r_offset))),
+ contents + irel->r_offset);
/* Fix the relocation's type. */
irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
unsigned short code;
/* Get the opcode. */
- code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
+ code = bfd_get_16 (abfd, contents + irel->r_offset);
/* Note that we've changed the relocs, section contents, etc. */
elf_section_data (sec)->relocs = internal_relocs;
place the 12-16bits (ie 4 bit) in new opcode,
as the 0xfffffxxx, the higher 2 byte values removed. */
if (value1 & 0x80000000)
- bfd_put_8 (abfd, (0x0f | (bfd_get_8(abfd, contents + irel->r_offset))), contents + irel->r_offset);
+ bfd_put_8 (abfd,
+ (0x0f | (bfd_get_8 (abfd,
+ contents + irel->r_offset))),
+ contents + irel->r_offset);
else
bfd_put_16 (abfd, value1, contents + irel->r_offset + 2);
if (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_IMM20)
{
- value1 |= ((bfd_get_16 (abfd, contents + irel->r_offset + 1) & 0xf000) << 0x4);
+ value1 |= ((bfd_get_16 (abfd, contents + irel->r_offset + 1)
+ & 0xf000) << 0x4);
}
/* See if the value will fit in 4 bits. */
unsigned short code;
/* Get the opcode. */
- code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
+ code = bfd_get_16 (abfd, contents + irel->r_offset);
/* Note that we've changed the relocs, section contents, etc. */
elf_section_data (sec)->relocs = internal_relocs;
bfd_put_8 (abfd, 0x60, contents + irel->r_offset);
else /* For addd imm20. */
bfd_put_8 (abfd, 0x54, contents + irel->r_offset);
- bfd_put_8 (abfd, (code & 0xf0) >> 4, contents + irel->r_offset + 1);
+ bfd_put_8 (abfd, (code & 0xf0) >> 4,
+ contents + irel->r_offset + 1);
}
else
{
if (! link_info->keep_memory)
free (isymbuf);
else
- /* Cache the symbols for elf_link_input_bfd. */
- symtab_hdr->contents = (unsigned char *) isymbuf;
+ /* Cache the symbols for elf_link_input_bfd. */
+ symtab_hdr->contents = (unsigned char *) isymbuf;
}
if (contents != NULL
if (! link_info->keep_memory)
free (contents);
else
- /* Cache the section contents for elf_link_input_bfd. */
- elf_section_data (sec)->this_hdr.contents = contents;
+ /* Cache the section contents for elf_link_input_bfd. */
+ elf_section_data (sec)->this_hdr.contents = contents;
}
continue;
}
- if ((s->flags & SEC_HAS_CONTENTS) == 0)
- continue;
+ if ((s->flags & SEC_HAS_CONTENTS) == 0)
+ continue;
/* Allocate memory for the section contents. We use bfd_zalloc
here in case unused entries are not reclaimed before the
bfd_elf32_swap_reloca_out (output_bfd, &rel,
(bfd_byte *) ((Elf32_External_Rela *) s->contents
+ s->reloc_count));
- ++ s->reloc_count;
+ ++ s->reloc_count;
}
/* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
asection *targetsec;
/* We are going to write a four byte longword into the runtime
- reloc section. The longword will be the address in the data
- section which must be relocated. It is followed by the name
- of the target section NUL-padded or truncated to 8
- characters. */
+ reloc section. The longword will be the address in the data
+ section which must be relocated. It is followed by the name
+ of the target section NUL-padded or truncated to 8
+ characters. */
/* We can only relocate absolute longword relocs at run time. */
if (!((ELF32_R_TYPE (irel->r_info) == (int) R_CR16_NUM32a)
- || (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_NUM32)))
+ || (ELF32_R_TYPE (irel->r_info) == (int) R_CR16_NUM32)))
{
*errmsg = _("unsupported relocation type");
bfd_set_error (bfd_error_bad_value);
memset (p + 4, 0, 4);
if ((ELF32_R_TYPE (irel->r_info) == (int) R_CR16_NUM32a)
&& (targetsec != NULL) )
- strncpy ((char *) p + 4, targetsec->output_section->name, 4);
+ strncpy ((char *) p + 4, targetsec->output_section->name, 4);
}
if (symtab_hdr->contents != (unsigned char *) isymbuf)
projects / binutils-gdb.git / commitdiff