1
/* tc-mn10300.c -- Assembler code for the Matsushita 10300
2
Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3
Free Software Foundation, Inc.
5
This file is part of GAS, the GNU Assembler.
7
GAS is free software; you can redistribute it and/or modify
8
it under the terms of the GNU General Public License as published by
9
the Free Software Foundation; either version 2, or (at your option)
12
GAS is distributed in the hope that it will be useful,
13
but WITHOUT ANY WARRANTY; without even the implied warranty of
14
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15
GNU General Public License for more details.
17
You should have received a copy of the GNU General Public License
18
along with GAS; see the file COPYING. If not, write to
19
the Free Software Foundation, 59 Temple Place - Suite 330,
20
Boston, MA 02111-1307, USA. */
24
#include "safe-ctype.h"
26
#include "opcode/mn10300.h"
27
#include "dwarf2dbg.h"
29
/* Structure to hold information about predefined registers. */
36
/* Generic assembler global variables which must be defined by all
39
/* Characters which always start a comment. */
40
const char comment_chars[] = "#";
42
/* Characters which start a comment at the beginning of a line. */
43
const char line_comment_chars[] = ";#";
45
/* Characters which may be used to separate multiple commands on a
47
const char line_separator_chars[] = ";";
49
/* Characters which are used to indicate an exponent in a floating
51
const char EXP_CHARS[] = "eE";
53
/* Characters which mean that a number is a floating point constant,
55
const char FLT_CHARS[] = "dD";
57
const relax_typeS md_relax_table[] = {
60
{0x7fff, -0x8000, 5, 2},
61
{0x7fffffff, -0x80000000, 7, 0},
63
/* bCC relaxing (uncommon cases) */
65
{0x7fff, -0x8000, 6, 5},
66
{0x7fffffff, -0x80000000, 8, 0},
69
{0x7fff, -0x8000, 5, 7},
70
{0x7fffffff, -0x80000000, 7, 0},
73
{0x7fff, -0x8000, 4, 9},
74
{0x7fffffff, -0x80000000, 6, 0},
78
{0x7fff, -0x8000, 3, 12},
79
{0x7fffffff, -0x80000000, 5, 0},
83
{0x7fff, -0x8000, 6, 15},
84
{0x7fffffff, -0x80000000, 8, 0},
88
/* Local functions. */
89
static void mn10300_insert_operand PARAMS ((unsigned long *, unsigned long *,
90
const struct mn10300_operand *,
91
offsetT, char *, unsigned,
93
static unsigned long check_operand PARAMS ((unsigned long,
94
const struct mn10300_operand *,
96
static int reg_name_search PARAMS ((const struct reg_name *, int, const char *));
97
static bfd_boolean data_register_name PARAMS ((expressionS *expressionP));
98
static bfd_boolean address_register_name PARAMS ((expressionS *expressionP));
99
static bfd_boolean other_register_name PARAMS ((expressionS *expressionP));
100
static bfd_boolean r_register_name PARAMS ((expressionS *expressionP));
101
static bfd_boolean xr_register_name PARAMS ((expressionS *expressionP));
102
static void set_arch_mach PARAMS ((int));
104
/* Set linkrelax here to avoid fixups in most sections. */
107
static int current_machine;
110
#define MAX_INSN_FIXUPS (5)
115
bfd_reloc_code_real_type reloc;
117
struct mn10300_fixup fixups[MAX_INSN_FIXUPS];
120
/* We must store the value of each register operand so that we can
121
verify that certain registers do not match. */
122
int mn10300_reg_operands[MN10300_MAX_OPERANDS];
124
const char *md_shortopts = "";
125
struct option md_longopts[] = {
126
{NULL, no_argument, NULL, 0}
128
size_t md_longopts_size = sizeof (md_longopts);
130
/* The target specific pseudo-ops which we support. */
131
const pseudo_typeS md_pseudo_table[] =
133
{ "am30", set_arch_mach, AM30 },
134
{ "am33", set_arch_mach, AM33 },
135
{ "am33_2", (void (*) PARAMS ((int))) set_arch_mach, AM33_2 },
136
{ "mn10300", set_arch_mach, MN103 },
140
#define HAVE_AM33_2 (current_machine == AM33_2)
141
#define HAVE_AM33 (current_machine == AM33 || HAVE_AM33_2)
142
#define HAVE_AM30 (current_machine == AM30)
144
/* Opcode hash table. */
145
static struct hash_control *mn10300_hash;
147
/* This table is sorted. Suitable for searching by a binary search. */
148
static const struct reg_name data_registers[] =
155
#define DATA_REG_NAME_CNT \
156
(sizeof (data_registers) / sizeof (struct reg_name))
158
static const struct reg_name address_registers[] =
166
#define ADDRESS_REG_NAME_CNT \
167
(sizeof (address_registers) / sizeof (struct reg_name))
169
static const struct reg_name r_registers[] =
213
#define R_REG_NAME_CNT \
214
(sizeof (r_registers) / sizeof (struct reg_name))
216
static const struct reg_name xr_registers[] =
241
#define XR_REG_NAME_CNT \
242
(sizeof (xr_registers) / sizeof (struct reg_name))
244
/* We abuse the `value' field, that would be otherwise unused, to
245
encode the architecture on which (access to) the register was
246
introduced. FIXME: we should probably warn when we encounter a
247
register name when assembling for an architecture that doesn't
248
support it, before parsing it as a symbol name. */
249
static const struct reg_name other_registers[] =
258
#define OTHER_REG_NAME_CNT \
259
(sizeof (other_registers) / sizeof (struct reg_name))
261
static const struct reg_name float_registers[] =
297
#define FLOAT_REG_NAME_CNT \
298
(sizeof (float_registers) / sizeof (struct reg_name))
300
static const struct reg_name double_registers[] =
320
#define DOUBLE_REG_NAME_CNT \
321
(sizeof (double_registers) / sizeof (struct reg_name))
324
/* reg_name_search does a binary search of the given register table
325
to see if "name" is a valid regiter name. Returns the register
326
number from the array on success, or -1 on failure. */
329
reg_name_search (regs, regcount, name)
330
const struct reg_name *regs;
334
int middle, low, high;
342
middle = (low + high) / 2;
343
cmp = strcasecmp (name, regs[middle].name);
349
return regs[middle].value;
355
/* Summary of register_name().
357
* in: Input_line_pointer points to 1st char of operand.
359
* out: An expressionS.
360
* The operand may have been a register: in this case, X_op == O_register,
361
* X_add_number is set to the register number, and truth is returned.
362
* Input_line_pointer->(next non-blank) char after operand, or is in
363
* its original state.
367
r_register_name (expressionP)
368
expressionS *expressionP;
375
/* Find the spelling of the operand. */
376
start = name = input_line_pointer;
378
c = get_symbol_end ();
379
reg_number = reg_name_search (r_registers, R_REG_NAME_CNT, name);
381
/* Put back the delimiting char. */
382
*input_line_pointer = c;
384
/* Look to see if it's in the register table. */
387
expressionP->X_op = O_register;
388
expressionP->X_add_number = reg_number;
390
/* Make the rest nice. */
391
expressionP->X_add_symbol = NULL;
392
expressionP->X_op_symbol = NULL;
397
/* Reset the line as if we had not done anything. */
398
input_line_pointer = start;
402
/* Summary of register_name().
404
* in: Input_line_pointer points to 1st char of operand.
406
* out: An expressionS.
407
* The operand may have been a register: in this case, X_op == O_register,
408
* X_add_number is set to the register number, and truth is returned.
409
* Input_line_pointer->(next non-blank) char after operand, or is in
410
* its original state.
414
xr_register_name (expressionP)
415
expressionS *expressionP;
422
/* Find the spelling of the operand. */
423
start = name = input_line_pointer;
425
c = get_symbol_end ();
426
reg_number = reg_name_search (xr_registers, XR_REG_NAME_CNT, name);
428
/* Put back the delimiting char. */
429
*input_line_pointer = c;
431
/* Look to see if it's in the register table. */
434
expressionP->X_op = O_register;
435
expressionP->X_add_number = reg_number;
437
/* Make the rest nice. */
438
expressionP->X_add_symbol = NULL;
439
expressionP->X_op_symbol = NULL;
444
/* Reset the line as if we had not done anything. */
445
input_line_pointer = start;
449
/* Summary of register_name().
451
* in: Input_line_pointer points to 1st char of operand.
453
* out: An expressionS.
454
* The operand may have been a register: in this case, X_op == O_register,
455
* X_add_number is set to the register number, and truth is returned.
456
* Input_line_pointer->(next non-blank) char after operand, or is in
457
* its original state.
461
data_register_name (expressionP)
462
expressionS *expressionP;
469
/* Find the spelling of the operand. */
470
start = name = input_line_pointer;
472
c = get_symbol_end ();
473
reg_number = reg_name_search (data_registers, DATA_REG_NAME_CNT, name);
475
/* Put back the delimiting char. */
476
*input_line_pointer = c;
478
/* Look to see if it's in the register table. */
481
expressionP->X_op = O_register;
482
expressionP->X_add_number = reg_number;
484
/* Make the rest nice. */
485
expressionP->X_add_symbol = NULL;
486
expressionP->X_op_symbol = NULL;
491
/* Reset the line as if we had not done anything. */
492
input_line_pointer = start;
496
/* Summary of register_name().
498
* in: Input_line_pointer points to 1st char of operand.
500
* out: An expressionS.
501
* The operand may have been a register: in this case, X_op == O_register,
502
* X_add_number is set to the register number, and truth is returned.
503
* Input_line_pointer->(next non-blank) char after operand, or is in
504
* its original state.
508
address_register_name (expressionP)
509
expressionS *expressionP;
516
/* Find the spelling of the operand. */
517
start = name = input_line_pointer;
519
c = get_symbol_end ();
520
reg_number = reg_name_search (address_registers, ADDRESS_REG_NAME_CNT, name);
522
/* Put back the delimiting char. */
523
*input_line_pointer = c;
525
/* Look to see if it's in the register table. */
528
expressionP->X_op = O_register;
529
expressionP->X_add_number = reg_number;
531
/* Make the rest nice. */
532
expressionP->X_add_symbol = NULL;
533
expressionP->X_op_symbol = NULL;
538
/* Reset the line as if we had not done anything. */
539
input_line_pointer = start;
543
/* Summary of register_name().
545
* in: Input_line_pointer points to 1st char of operand.
547
* out: An expressionS.
548
* The operand may have been a register: in this case, X_op == O_register,
549
* X_add_number is set to the register number, and truth is returned.
550
* Input_line_pointer->(next non-blank) char after operand, or is in
551
* its original state.
555
other_register_name (expressionP)
556
expressionS *expressionP;
563
/* Find the spelling of the operand. */
564
start = name = input_line_pointer;
566
c = get_symbol_end ();
567
reg_number = reg_name_search (other_registers, OTHER_REG_NAME_CNT, name);
569
/* Put back the delimiting char. */
570
*input_line_pointer = c;
572
/* Look to see if it's in the register table. */
574
|| (reg_number == AM33 && HAVE_AM33))
576
expressionP->X_op = O_register;
577
expressionP->X_add_number = 0;
579
/* Make the rest nice. */
580
expressionP->X_add_symbol = NULL;
581
expressionP->X_op_symbol = NULL;
586
/* Reset the line as if we had not done anything. */
587
input_line_pointer = start;
591
static bfd_boolean double_register_name PARAMS ((expressionS *));
592
static bfd_boolean float_register_name PARAMS ((expressionS *));
594
/* Summary of float_register_name:
596
in: Input_line_pointer points to 1st char of operand.
599
The operand may have been a register: in this case, X_op == O_register,
600
X_add_number is set to the register number, and truth is returned.
601
Input_line_pointer->(next non-blank) char after operand, or is in
602
its original state. */
605
float_register_name (expressionP)
606
expressionS *expressionP;
613
/* Find the spelling of the operand. */
614
start = name = input_line_pointer;
616
c = get_symbol_end ();
617
reg_number = reg_name_search (float_registers, FLOAT_REG_NAME_CNT, name);
619
/* Put back the delimiting char. */
620
* input_line_pointer = c;
622
/* Look to see if it's in the register table. */
625
expressionP->X_op = O_register;
626
expressionP->X_add_number = reg_number;
628
/* Make the rest nice. */
629
expressionP->X_add_symbol = NULL;
630
expressionP->X_op_symbol = NULL;
635
/* Reset the line as if we had not done anything. */
636
input_line_pointer = start;
640
/* Summary of double_register_name:
642
in: Input_line_pointer points to 1st char of operand.
645
The operand may have been a register: in this case, X_op == O_register,
646
X_add_number is set to the register number, and truth is returned.
647
Input_line_pointer->(next non-blank) char after operand, or is in
648
its original state. */
651
double_register_name (expressionP)
652
expressionS *expressionP;
659
/* Find the spelling of the operand. */
660
start = name = input_line_pointer;
662
c = get_symbol_end ();
663
reg_number = reg_name_search (double_registers, DOUBLE_REG_NAME_CNT, name);
665
/* Put back the delimiting char. */
666
* input_line_pointer = c;
668
/* Look to see if it's in the register table. */
671
expressionP->X_op = O_register;
672
expressionP->X_add_number = reg_number;
674
/* Make the rest nice. */
675
expressionP->X_add_symbol = NULL;
676
expressionP->X_op_symbol = NULL;
681
/* Reset the line as if we had not done anything. */
682
input_line_pointer = start;
687
md_show_usage (stream)
690
fprintf (stream, _("MN10300 options:\n\
695
md_parse_option (c, arg)
696
int c ATTRIBUTE_UNUSED;
697
char *arg ATTRIBUTE_UNUSED;
703
md_undefined_symbol (name)
704
char *name ATTRIBUTE_UNUSED;
710
md_atof (type, litp, sizep)
716
LITTLENUM_TYPE words[4];
732
return "bad call to md_atof";
735
t = atof_ieee (input_line_pointer, type, words);
737
input_line_pointer = t;
741
for (i = prec - 1; i >= 0; i--)
743
md_number_to_chars (litp, (valueT) words[i], 2);
751
md_convert_frag (abfd, sec, fragP)
752
bfd *abfd ATTRIBUTE_UNUSED;
756
static unsigned long label_count = 0;
759
subseg_change (sec, 0);
760
if (fragP->fr_subtype == 0)
762
fix_new (fragP, fragP->fr_fix + 1, 1, fragP->fr_symbol,
763
fragP->fr_offset + 1, 1, BFD_RELOC_8_PCREL);
767
else if (fragP->fr_subtype == 1)
769
/* Reverse the condition of the first branch. */
770
int offset = fragP->fr_fix;
771
int opcode = fragP->fr_literal[offset] & 0xff;
808
fragP->fr_literal[offset] = opcode;
810
/* Create a fixup for the reversed conditional branch. */
811
sprintf (buf, ".%s_%ld", FAKE_LABEL_NAME, label_count++);
812
fix_new (fragP, fragP->fr_fix + 1, 1,
813
symbol_new (buf, sec, 0, fragP->fr_next),
814
fragP->fr_offset + 1, 1, BFD_RELOC_8_PCREL);
816
/* Now create the unconditional branch + fixup to the
818
fragP->fr_literal[offset + 2] = 0xcc;
819
fix_new (fragP, fragP->fr_fix + 3, 2, fragP->fr_symbol,
820
fragP->fr_offset + 1, 1, BFD_RELOC_16_PCREL);
824
else if (fragP->fr_subtype == 2)
826
/* Reverse the condition of the first branch. */
827
int offset = fragP->fr_fix;
828
int opcode = fragP->fr_literal[offset] & 0xff;
865
fragP->fr_literal[offset] = opcode;
867
/* Create a fixup for the reversed conditional branch. */
868
sprintf (buf, ".%s_%ld", FAKE_LABEL_NAME, label_count++);
869
fix_new (fragP, fragP->fr_fix + 1, 1,
870
symbol_new (buf, sec, 0, fragP->fr_next),
871
fragP->fr_offset + 1, 1, BFD_RELOC_8_PCREL);
873
/* Now create the unconditional branch + fixup to the
875
fragP->fr_literal[offset + 2] = 0xdc;
876
fix_new (fragP, fragP->fr_fix + 3, 4, fragP->fr_symbol,
877
fragP->fr_offset + 1, 1, BFD_RELOC_32_PCREL);
881
else if (fragP->fr_subtype == 3)
883
fix_new (fragP, fragP->fr_fix + 2, 1, fragP->fr_symbol,
884
fragP->fr_offset + 2, 1, BFD_RELOC_8_PCREL);
888
else if (fragP->fr_subtype == 4)
890
/* Reverse the condition of the first branch. */
891
int offset = fragP->fr_fix;
892
int opcode = fragP->fr_literal[offset + 1] & 0xff;
911
fragP->fr_literal[offset + 1] = opcode;
913
/* Create a fixup for the reversed conditional branch. */
914
sprintf (buf, ".%s_%ld", FAKE_LABEL_NAME, label_count++);
915
fix_new (fragP, fragP->fr_fix + 2, 1,
916
symbol_new (buf, sec, 0, fragP->fr_next),
917
fragP->fr_offset + 2, 1, BFD_RELOC_8_PCREL);
919
/* Now create the unconditional branch + fixup to the
921
fragP->fr_literal[offset + 3] = 0xcc;
922
fix_new (fragP, fragP->fr_fix + 4, 2, fragP->fr_symbol,
923
fragP->fr_offset + 1, 1, BFD_RELOC_16_PCREL);
927
else if (fragP->fr_subtype == 5)
929
/* Reverse the condition of the first branch. */
930
int offset = fragP->fr_fix;
931
int opcode = fragP->fr_literal[offset + 1] & 0xff;
947
fragP->fr_literal[offset + 1] = opcode;
949
/* Create a fixup for the reversed conditional branch. */
950
sprintf (buf, ".%s_%ld", FAKE_LABEL_NAME, label_count++);
951
fix_new (fragP, fragP->fr_fix + 2, 1,
952
symbol_new (buf, sec, 0, fragP->fr_next),
953
fragP->fr_offset + 2, 1, BFD_RELOC_8_PCREL);
955
/* Now create the unconditional branch + fixup to the
957
fragP->fr_literal[offset + 3] = 0xdc;
958
fix_new (fragP, fragP->fr_fix + 4, 4, fragP->fr_symbol,
959
fragP->fr_offset + 1, 1, BFD_RELOC_32_PCREL);
963
else if (fragP->fr_subtype == 6)
965
int offset = fragP->fr_fix;
966
fragP->fr_literal[offset] = 0xcd;
967
fix_new (fragP, fragP->fr_fix + 1, 2, fragP->fr_symbol,
968
fragP->fr_offset + 1, 1, BFD_RELOC_16_PCREL);
972
else if (fragP->fr_subtype == 7)
974
int offset = fragP->fr_fix;
975
fragP->fr_literal[offset] = 0xdd;
976
fragP->fr_literal[offset + 5] = fragP->fr_literal[offset + 3];
977
fragP->fr_literal[offset + 6] = fragP->fr_literal[offset + 4];
979
fix_new (fragP, fragP->fr_fix + 1, 4, fragP->fr_symbol,
980
fragP->fr_offset + 1, 1, BFD_RELOC_32_PCREL);
984
else if (fragP->fr_subtype == 8)
986
int offset = fragP->fr_fix;
987
fragP->fr_literal[offset] = 0xfa;
988
fragP->fr_literal[offset + 1] = 0xff;
989
fix_new (fragP, fragP->fr_fix + 2, 2, fragP->fr_symbol,
990
fragP->fr_offset + 2, 1, BFD_RELOC_16_PCREL);
994
else if (fragP->fr_subtype == 9)
996
int offset = fragP->fr_fix;
997
fragP->fr_literal[offset] = 0xfc;
998
fragP->fr_literal[offset + 1] = 0xff;
1000
fix_new (fragP, fragP->fr_fix + 2, 4, fragP->fr_symbol,
1001
fragP->fr_offset + 2, 1, BFD_RELOC_32_PCREL);
1005
else if (fragP->fr_subtype == 10)
1007
fragP->fr_literal[fragP->fr_fix] = 0xca;
1008
fix_new (fragP, fragP->fr_fix + 1, 1, fragP->fr_symbol,
1009
fragP->fr_offset + 1, 1, BFD_RELOC_8_PCREL);
1013
else if (fragP->fr_subtype == 11)
1015
int offset = fragP->fr_fix;
1016
fragP->fr_literal[offset] = 0xcc;
1018
fix_new (fragP, fragP->fr_fix + 1, 4, fragP->fr_symbol,
1019
fragP->fr_offset + 1, 1, BFD_RELOC_16_PCREL);
1023
else if (fragP->fr_subtype == 12)
1025
int offset = fragP->fr_fix;
1026
fragP->fr_literal[offset] = 0xdc;
1028
fix_new (fragP, fragP->fr_fix + 1, 4, fragP->fr_symbol,
1029
fragP->fr_offset + 1, 1, BFD_RELOC_32_PCREL);
1033
else if (fragP->fr_subtype == 13)
1035
fix_new (fragP, fragP->fr_fix + 2, 1, fragP->fr_symbol,
1036
fragP->fr_offset + 2, 1, BFD_RELOC_8_PCREL);
1040
else if (fragP->fr_subtype == 14)
1042
/* Reverse the condition of the first branch. */
1043
int offset = fragP->fr_fix;
1044
int opcode = fragP->fr_literal[offset + 1] & 0xff;
1093
fragP->fr_literal[offset + 1] = opcode;
1095
/* Create a fixup for the reversed conditional branch. */
1096
sprintf (buf, ".%s_%ld", FAKE_LABEL_NAME, label_count++);
1097
fix_new (fragP, fragP->fr_fix + 2, 1,
1098
symbol_new (buf, sec, 0, fragP->fr_next),
1099
fragP->fr_offset + 2, 1, BFD_RELOC_8_PCREL);
1101
/* Now create the unconditional branch + fixup to the
1103
fragP->fr_literal[offset + 3] = 0xcc;
1104
fix_new (fragP, fragP->fr_fix + 4, 2, fragP->fr_symbol,
1105
fragP->fr_offset + 1, 1, BFD_RELOC_16_PCREL);
1109
else if (fragP->fr_subtype == 15)
1111
/* Reverse the condition of the first branch. */
1112
int offset = fragP->fr_fix;
1113
int opcode = fragP->fr_literal[offset + 1] & 0xff;
1162
fragP->fr_literal[offset + 1] = opcode;
1164
/* Create a fixup for the reversed conditional branch. */
1165
sprintf (buf, ".%s_%ld", FAKE_LABEL_NAME, label_count++);
1166
fix_new (fragP, fragP->fr_fix + 2, 1,
1167
symbol_new (buf, sec, 0, fragP->fr_next),
1168
fragP->fr_offset + 2, 1, BFD_RELOC_8_PCREL);
1170
/* Now create the unconditional branch + fixup to the
1172
fragP->fr_literal[offset + 3] = 0xdc;
1173
fix_new (fragP, fragP->fr_fix + 4, 4, fragP->fr_symbol,
1174
fragP->fr_offset + 1, 1, BFD_RELOC_32_PCREL);
1183
md_section_align (seg, addr)
1187
int align = bfd_get_section_alignment (stdoutput, seg);
1188
return ((addr + (1 << align) - 1) & (-1 << align));
1194
char *prev_name = "";
1195
register const struct mn10300_opcode *op;
1197
mn10300_hash = hash_new ();
1199
/* Insert unique names into hash table. The MN10300 instruction set
1200
has many identical opcode names that have different opcodes based
1201
on the operands. This hash table then provides a quick index to
1202
the first opcode with a particular name in the opcode table. */
1204
op = mn10300_opcodes;
1207
if (strcmp (prev_name, op->name))
1209
prev_name = (char *) op->name;
1210
hash_insert (mn10300_hash, op->name, (char *) op);
1215
/* Set the default machine type. */
1217
if (!bfd_set_arch_mach (stdoutput, bfd_arch_mn10300, AM33_2))
1218
as_warn (_("could not set architecture and machine"));
1220
current_machine = AM33_2;
1222
if (!bfd_set_arch_mach (stdoutput, bfd_arch_mn10300, MN103))
1223
as_warn (_("could not set architecture and machine"));
1225
current_machine = MN103;
1229
static symbolS *GOT_symbol;
1231
static inline int mn10300_check_fixup PARAMS ((struct mn10300_fixup *));
1232
static inline int mn10300_PIC_related_p PARAMS ((symbolS *));
1235
mn10300_PIC_related_p (sym)
1243
if (sym == GOT_symbol)
1246
exp = symbol_get_value_expression (sym);
1248
return (exp->X_op == O_PIC_reloc
1249
|| mn10300_PIC_related_p (exp->X_add_symbol)
1250
|| mn10300_PIC_related_p (exp->X_op_symbol));
1254
mn10300_check_fixup (fixup)
1255
struct mn10300_fixup *fixup;
1257
expressionS *exp = &fixup->exp;
1263
case O_subtract: /* If we're sufficiently unlucky that the label
1264
and the expression that references it happen
1265
to end up in different frags, the subtract
1266
won't be simplified within expression(). */
1267
/* The PIC-related operand must be the first operand of a sum. */
1268
if (exp != &fixup->exp || mn10300_PIC_related_p (exp->X_op_symbol))
1271
if (exp->X_add_symbol && exp->X_add_symbol == GOT_symbol)
1272
fixup->reloc = BFD_RELOC_32_GOT_PCREL;
1274
exp = symbol_get_value_expression (exp->X_add_symbol);
1278
if (exp->X_add_symbol && exp->X_add_symbol == GOT_symbol)
1279
fixup->reloc = BFD_RELOC_32_GOT_PCREL;
1283
fixup->reloc = exp->X_md;
1284
exp->X_op = O_symbol;
1285
if (fixup->reloc == BFD_RELOC_32_PLT_PCREL
1286
&& fixup->opindex >= 0
1287
&& (mn10300_operands[fixup->opindex].flags
1288
& MN10300_OPERAND_RELAX))
1293
return (mn10300_PIC_related_p (exp->X_add_symbol)
1294
|| mn10300_PIC_related_p (exp->X_op_symbol));
1301
mn10300_cons_fix_new (frag, off, size, exp)
1306
struct mn10300_fixup fixup;
1310
fixup.reloc = BFD_RELOC_UNUSED;
1312
mn10300_check_fixup (&fixup);
1314
if (fixup.reloc == BFD_RELOC_MN10300_GOT32)
1318
fixup.reloc = BFD_RELOC_MN10300_GOT16;
1322
fixup.reloc = BFD_RELOC_MN10300_GOT24;
1331
else if (fixup.reloc == BFD_RELOC_UNUSED)
1335
fixup.reloc = BFD_RELOC_8;
1339
fixup.reloc = BFD_RELOC_16;
1343
fixup.reloc = BFD_RELOC_24;
1347
fixup.reloc = BFD_RELOC_32;
1356
as_bad (_("unsupported BFD relocation size %u"), size);
1357
fixup.reloc = BFD_RELOC_UNUSED;
1360
fix_new_exp (frag, off, size, &fixup.exp, 0, fixup.reloc);
1368
struct mn10300_opcode *opcode;
1369
struct mn10300_opcode *next_opcode;
1370
const unsigned char *opindex_ptr;
1371
int next_opindex, relaxable;
1372
unsigned long insn, extension, size = 0;
1377
/* Get the opcode. */
1378
for (s = str; *s != '\0' && !ISSPACE (*s); s++)
1383
/* Find the first opcode with the proper name. */
1384
opcode = (struct mn10300_opcode *) hash_find (mn10300_hash, str);
1387
as_bad (_("Unrecognized opcode: `%s'"), str);
1392
while (ISSPACE (*str))
1395
input_line_pointer = str;
1402
int extra_shift = 0;
1404
errmsg = _("Invalid opcode/operands");
1406
/* Reset the array of register operands. */
1407
memset (mn10300_reg_operands, -1, sizeof (mn10300_reg_operands));
1413
insn = opcode->opcode;
1416
/* If the instruction is not available on the current machine
1417
then it can not possibly match. */
1419
&& !(opcode->machine == AM33_2 && HAVE_AM33_2)
1420
&& !(opcode->machine == AM33 && HAVE_AM33)
1421
&& !(opcode->machine == AM30 && HAVE_AM30))
1424
for (op_idx = 1, opindex_ptr = opcode->operands;
1426
opindex_ptr++, op_idx++)
1428
const struct mn10300_operand *operand;
1431
if (next_opindex == 0)
1433
operand = &mn10300_operands[*opindex_ptr];
1437
operand = &mn10300_operands[next_opindex];
1441
while (*str == ' ' || *str == ',')
1444
if (operand->flags & MN10300_OPERAND_RELAX)
1447
/* Gather the operand. */
1448
hold = input_line_pointer;
1449
input_line_pointer = str;
1451
if (operand->flags & MN10300_OPERAND_PAREN)
1453
if (*input_line_pointer != ')' && *input_line_pointer != '(')
1455
input_line_pointer = hold;
1459
input_line_pointer++;
1462
/* See if we can match the operands. */
1463
else if (operand->flags & MN10300_OPERAND_DREG)
1465
if (!data_register_name (&ex))
1467
input_line_pointer = hold;
1472
else if (operand->flags & MN10300_OPERAND_AREG)
1474
if (!address_register_name (&ex))
1476
input_line_pointer = hold;
1481
else if (operand->flags & MN10300_OPERAND_SP)
1483
char *start = input_line_pointer;
1484
char c = get_symbol_end ();
1486
if (strcasecmp (start, "sp") != 0)
1488
*input_line_pointer = c;
1489
input_line_pointer = hold;
1493
*input_line_pointer = c;
1496
else if (operand->flags & MN10300_OPERAND_RREG)
1498
if (!r_register_name (&ex))
1500
input_line_pointer = hold;
1505
else if (operand->flags & MN10300_OPERAND_XRREG)
1507
if (!xr_register_name (&ex))
1509
input_line_pointer = hold;
1514
else if (operand->flags & MN10300_OPERAND_FSREG)
1516
if (!float_register_name (&ex))
1518
input_line_pointer = hold;
1523
else if (operand->flags & MN10300_OPERAND_FDREG)
1525
if (!double_register_name (&ex))
1527
input_line_pointer = hold;
1532
else if (operand->flags & MN10300_OPERAND_FPCR)
1534
char *start = input_line_pointer;
1535
char c = get_symbol_end ();
1537
if (strcasecmp (start, "fpcr") != 0)
1539
*input_line_pointer = c;
1540
input_line_pointer = hold;
1544
*input_line_pointer = c;
1547
else if (operand->flags & MN10300_OPERAND_USP)
1549
char *start = input_line_pointer;
1550
char c = get_symbol_end ();
1552
if (strcasecmp (start, "usp") != 0)
1554
*input_line_pointer = c;
1555
input_line_pointer = hold;
1559
*input_line_pointer = c;
1562
else if (operand->flags & MN10300_OPERAND_SSP)
1564
char *start = input_line_pointer;
1565
char c = get_symbol_end ();
1567
if (strcasecmp (start, "ssp") != 0)
1569
*input_line_pointer = c;
1570
input_line_pointer = hold;
1574
*input_line_pointer = c;
1577
else if (operand->flags & MN10300_OPERAND_MSP)
1579
char *start = input_line_pointer;
1580
char c = get_symbol_end ();
1582
if (strcasecmp (start, "msp") != 0)
1584
*input_line_pointer = c;
1585
input_line_pointer = hold;
1589
*input_line_pointer = c;
1592
else if (operand->flags & MN10300_OPERAND_PC)
1594
char *start = input_line_pointer;
1595
char c = get_symbol_end ();
1597
if (strcasecmp (start, "pc") != 0)
1599
*input_line_pointer = c;
1600
input_line_pointer = hold;
1604
*input_line_pointer = c;
1607
else if (operand->flags & MN10300_OPERAND_EPSW)
1609
char *start = input_line_pointer;
1610
char c = get_symbol_end ();
1612
if (strcasecmp (start, "epsw") != 0)
1614
*input_line_pointer = c;
1615
input_line_pointer = hold;
1619
*input_line_pointer = c;
1622
else if (operand->flags & MN10300_OPERAND_PLUS)
1624
if (*input_line_pointer != '+')
1626
input_line_pointer = hold;
1630
input_line_pointer++;
1633
else if (operand->flags & MN10300_OPERAND_PSW)
1635
char *start = input_line_pointer;
1636
char c = get_symbol_end ();
1638
if (strcasecmp (start, "psw") != 0)
1640
*input_line_pointer = c;
1641
input_line_pointer = hold;
1645
*input_line_pointer = c;
1648
else if (operand->flags & MN10300_OPERAND_MDR)
1650
char *start = input_line_pointer;
1651
char c = get_symbol_end ();
1653
if (strcasecmp (start, "mdr") != 0)
1655
*input_line_pointer = c;
1656
input_line_pointer = hold;
1660
*input_line_pointer = c;
1663
else if (operand->flags & MN10300_OPERAND_REG_LIST)
1665
unsigned int value = 0;
1666
if (*input_line_pointer != '[')
1668
input_line_pointer = hold;
1674
input_line_pointer++;
1676
/* We used to reject a null register list here; however,
1677
we accept it now so the compiler can emit "call"
1678
instructions for all calls to named functions.
1680
The linker can then fill in the appropriate bits for the
1681
register list and stack size or change the instruction
1682
into a "calls" if using "call" is not profitable. */
1683
while (*input_line_pointer != ']')
1688
if (*input_line_pointer == ',')
1689
input_line_pointer++;
1691
start = input_line_pointer;
1692
c = get_symbol_end ();
1694
if (strcasecmp (start, "d2") == 0)
1697
*input_line_pointer = c;
1699
else if (strcasecmp (start, "d3") == 0)
1702
*input_line_pointer = c;
1704
else if (strcasecmp (start, "a2") == 0)
1707
*input_line_pointer = c;
1709
else if (strcasecmp (start, "a3") == 0)
1712
*input_line_pointer = c;
1714
else if (strcasecmp (start, "other") == 0)
1717
*input_line_pointer = c;
1720
&& strcasecmp (start, "exreg0") == 0)
1723
*input_line_pointer = c;
1726
&& strcasecmp (start, "exreg1") == 0)
1729
*input_line_pointer = c;
1732
&& strcasecmp (start, "exother") == 0)
1735
*input_line_pointer = c;
1738
&& strcasecmp (start, "all") == 0)
1741
*input_line_pointer = c;
1745
input_line_pointer = hold;
1750
input_line_pointer++;
1751
mn10300_insert_operand (&insn, &extension, operand,
1752
value, (char *) NULL, 0, 0);
1756
else if (data_register_name (&ex))
1758
input_line_pointer = hold;
1762
else if (address_register_name (&ex))
1764
input_line_pointer = hold;
1768
else if (other_register_name (&ex))
1770
input_line_pointer = hold;
1774
else if (HAVE_AM33 && r_register_name (&ex))
1776
input_line_pointer = hold;
1780
else if (HAVE_AM33 && xr_register_name (&ex))
1782
input_line_pointer = hold;
1786
else if (HAVE_AM33_2 && float_register_name (&ex))
1788
input_line_pointer = hold;
1792
else if (HAVE_AM33_2 && double_register_name (&ex))
1794
input_line_pointer = hold;
1798
else if (*str == ')' || *str == '(')
1800
input_line_pointer = hold;
1812
errmsg = _("illegal operand");
1815
errmsg = _("missing operand");
1821
mask = MN10300_OPERAND_DREG | MN10300_OPERAND_AREG;
1823
mask |= MN10300_OPERAND_RREG | MN10300_OPERAND_XRREG;
1825
mask |= MN10300_OPERAND_FSREG | MN10300_OPERAND_FDREG;
1826
if ((operand->flags & mask) == 0)
1828
input_line_pointer = hold;
1833
if (opcode->format == FMT_D1 || opcode->format == FMT_S1)
1835
else if (opcode->format == FMT_D2
1836
|| opcode->format == FMT_D4
1837
|| opcode->format == FMT_S2
1838
|| opcode->format == FMT_S4
1839
|| opcode->format == FMT_S6
1840
|| opcode->format == FMT_D5)
1842
else if (opcode->format == FMT_D7)
1844
else if (opcode->format == FMT_D8 || opcode->format == FMT_D9)
1849
mn10300_insert_operand (&insn, &extension, operand,
1850
ex.X_add_number, (char *) NULL,
1853
/* And note the register number in the register array. */
1854
mn10300_reg_operands[op_idx - 1] = ex.X_add_number;
1859
/* If this operand can be promoted, and it doesn't
1860
fit into the allocated bitfield for this insn,
1861
then promote it (ie this opcode does not match). */
1863
& (MN10300_OPERAND_PROMOTE | MN10300_OPERAND_RELAX)
1864
&& !check_operand (insn, operand, ex.X_add_number))
1866
input_line_pointer = hold;
1871
mn10300_insert_operand (&insn, &extension, operand,
1872
ex.X_add_number, (char *) NULL,
1877
/* If this operand can be promoted, then this opcode didn't
1878
match since we can't know if it needed promotion! */
1879
if (operand->flags & MN10300_OPERAND_PROMOTE)
1881
input_line_pointer = hold;
1886
/* We need to generate a fixup for this expression. */
1887
if (fc >= MAX_INSN_FIXUPS)
1888
as_fatal (_("too many fixups"));
1889
fixups[fc].exp = ex;
1890
fixups[fc].opindex = *opindex_ptr;
1891
fixups[fc].reloc = BFD_RELOC_UNUSED;
1892
if (mn10300_check_fixup (& fixups[fc]))
1899
str = input_line_pointer;
1900
input_line_pointer = hold;
1902
while (*str == ' ' || *str == ',')
1907
/* Make sure we used all the operands! */
1911
/* If this instruction has registers that must not match, verify
1912
that they do indeed not match. */
1913
if (opcode->no_match_operands)
1917
/* Look at each operand to see if it's marked. */
1918
for (i = 0; i < MN10300_MAX_OPERANDS; i++)
1920
if ((1 << i) & opcode->no_match_operands)
1924
/* operand I is marked. Check that it does not match any
1925
operands > I which are marked. */
1926
for (j = i + 1; j < MN10300_MAX_OPERANDS; j++)
1928
if (((1 << j) & opcode->no_match_operands)
1929
&& mn10300_reg_operands[i] == mn10300_reg_operands[j])
1931
errmsg = _("Invalid register specification.");
1943
next_opcode = opcode + 1;
1944
if (!strcmp (next_opcode->name, opcode->name))
1946
opcode = next_opcode;
1950
as_bad ("%s", errmsg);
1956
while (ISSPACE (*str))
1960
as_bad (_("junk at end of line: `%s'"), str);
1962
input_line_pointer = str;
1964
/* Determine the size of the instruction. */
1965
if (opcode->format == FMT_S0)
1968
if (opcode->format == FMT_S1 || opcode->format == FMT_D0)
1971
if (opcode->format == FMT_S2 || opcode->format == FMT_D1)
1974
if (opcode->format == FMT_D6)
1977
if (opcode->format == FMT_D7 || opcode->format == FMT_D10)
1980
if (opcode->format == FMT_D8)
1983
if (opcode->format == FMT_D9)
1986
if (opcode->format == FMT_S4)
1989
if (opcode->format == FMT_S6 || opcode->format == FMT_D5)
1992
if (opcode->format == FMT_D2)
1995
if (opcode->format == FMT_D3)
1998
if (opcode->format == FMT_D4)
2001
if (relaxable && fc > 0)
2005
/* We want to anchor the line info to the previous frag (if
2006
there isn't one, create it), so that, when the insn is
2007
resized, we still get the right address for the beginning of
2010
dwarf2_emit_insn (0);
2015
/* Handle bra specially. Basically treat it like jmp so
2016
that we automatically handle 8, 16 and 32 bit offsets
2017
correctly as well as jumps to an undefined address.
2019
It is also important to not treat it like other bCC
2020
instructions since the long forms of bra is different
2021
from other bCC instructions. */
2022
if (opcode->opcode == 0xca00)
2034
else if (size == 3 && opcode->opcode == 0xcc0000)
2036
else if (size == 3 && (opcode->opcode & 0xfff000) == 0xf8d000)
2038
/* bCC (uncommon cases) */
2042
f = frag_var (rs_machine_dependent, 8, 8 - size, type,
2043
fixups[0].exp.X_add_symbol,
2044
fixups[0].exp.X_add_number,
2045
(char *)fixups[0].opindex);
2047
/* This is pretty hokey. We basically just care about the
2048
opcode, so we have to write out the first word big endian.
2050
The exception is "call", which has two operands that we
2053
The first operand (the register list) happens to be in the
2054
first instruction word, and will be in the right place if
2055
we output the first word in big endian mode.
2057
The second operand (stack size) is in the extension word,
2058
and we want it to appear as the first character in the extension
2059
word (as it appears in memory). Luckily, writing the extension
2060
word in big endian format will do what we want. */
2061
number_to_chars_bigendian (f, insn, size > 4 ? 4 : size);
2064
number_to_chars_bigendian (f + 4, extension, 4);
2065
number_to_chars_bigendian (f + 8, 0, size - 8);
2068
number_to_chars_bigendian (f + 4, extension, size - 4);
2072
/* Allocate space for the instruction. */
2073
f = frag_more (size);
2075
/* Fill in bytes for the instruction. Note that opcode fields
2076
are written big-endian, 16 & 32bit immediates are written
2077
little endian. Egad. */
2078
if (opcode->format == FMT_S0
2079
|| opcode->format == FMT_S1
2080
|| opcode->format == FMT_D0
2081
|| opcode->format == FMT_D6
2082
|| opcode->format == FMT_D7
2083
|| opcode->format == FMT_D10
2084
|| opcode->format == FMT_D1)
2086
number_to_chars_bigendian (f, insn, size);
2088
else if (opcode->format == FMT_S2
2089
&& opcode->opcode != 0xdf0000
2090
&& opcode->opcode != 0xde0000)
2092
/* A format S2 instruction that is _not_ "ret" and "retf". */
2093
number_to_chars_bigendian (f, (insn >> 16) & 0xff, 1);
2094
number_to_chars_littleendian (f + 1, insn & 0xffff, 2);
2096
else if (opcode->format == FMT_S2)
2098
/* This must be a ret or retf, which is written entirely in
2099
big-endian format. */
2100
number_to_chars_bigendian (f, insn, 3);
2102
else if (opcode->format == FMT_S4
2103
&& opcode->opcode != 0xdc000000)
2105
/* This must be a format S4 "call" instruction. What a pain. */
2106
unsigned long temp = (insn >> 8) & 0xffff;
2107
number_to_chars_bigendian (f, (insn >> 24) & 0xff, 1);
2108
number_to_chars_littleendian (f + 1, temp, 2);
2109
number_to_chars_bigendian (f + 3, insn & 0xff, 1);
2110
number_to_chars_bigendian (f + 4, extension & 0xff, 1);
2112
else if (opcode->format == FMT_S4)
2114
/* This must be a format S4 "jmp" instruction. */
2115
unsigned long temp = ((insn & 0xffffff) << 8) | (extension & 0xff);
2116
number_to_chars_bigendian (f, (insn >> 24) & 0xff, 1);
2117
number_to_chars_littleendian (f + 1, temp, 4);
2119
else if (opcode->format == FMT_S6)
2121
unsigned long temp = ((insn & 0xffffff) << 8)
2122
| ((extension >> 16) & 0xff);
2123
number_to_chars_bigendian (f, (insn >> 24) & 0xff, 1);
2124
number_to_chars_littleendian (f + 1, temp, 4);
2125
number_to_chars_bigendian (f + 5, (extension >> 8) & 0xff, 1);
2126
number_to_chars_bigendian (f + 6, extension & 0xff, 1);
2128
else if (opcode->format == FMT_D2
2129
&& opcode->opcode != 0xfaf80000
2130
&& opcode->opcode != 0xfaf00000
2131
&& opcode->opcode != 0xfaf40000)
2133
/* A format D2 instruction where the 16bit immediate is
2134
really a single 16bit value, not two 8bit values. */
2135
number_to_chars_bigendian (f, (insn >> 16) & 0xffff, 2);
2136
number_to_chars_littleendian (f + 2, insn & 0xffff, 2);
2138
else if (opcode->format == FMT_D2)
2140
/* A format D2 instruction where the 16bit immediate
2141
is really two 8bit immediates. */
2142
number_to_chars_bigendian (f, insn, 4);
2144
else if (opcode->format == FMT_D3)
2146
number_to_chars_bigendian (f, (insn >> 16) & 0xffff, 2);
2147
number_to_chars_littleendian (f + 2, insn & 0xffff, 2);
2148
number_to_chars_bigendian (f + 4, extension & 0xff, 1);
2150
else if (opcode->format == FMT_D4)
2152
unsigned long temp = ((insn & 0xffff) << 16) | (extension & 0xffff);
2154
number_to_chars_bigendian (f, (insn >> 16) & 0xffff, 2);
2155
number_to_chars_littleendian (f + 2, temp, 4);
2157
else if (opcode->format == FMT_D5)
2159
unsigned long temp = (((insn & 0xffff) << 16)
2160
| ((extension >> 8) & 0xffff));
2162
number_to_chars_bigendian (f, (insn >> 16) & 0xffff, 2);
2163
number_to_chars_littleendian (f + 2, temp, 4);
2164
number_to_chars_bigendian (f + 6, extension & 0xff, 1);
2166
else if (opcode->format == FMT_D8)
2168
unsigned long temp = ((insn & 0xff) << 16) | (extension & 0xffff);
2170
number_to_chars_bigendian (f, (insn >> 8) & 0xffffff, 3);
2171
number_to_chars_bigendian (f + 3, (temp & 0xff), 1);
2172
number_to_chars_littleendian (f + 4, temp >> 8, 2);
2174
else if (opcode->format == FMT_D9)
2176
unsigned long temp = ((insn & 0xff) << 24) | (extension & 0xffffff);
2178
number_to_chars_bigendian (f, (insn >> 8) & 0xffffff, 3);
2179
number_to_chars_littleendian (f + 3, temp, 4);
2182
/* Create any fixups. */
2183
for (i = 0; i < fc; i++)
2185
const struct mn10300_operand *operand;
2187
operand = &mn10300_operands[fixups[i].opindex];
2188
if (fixups[i].reloc != BFD_RELOC_UNUSED
2189
&& fixups[i].reloc != BFD_RELOC_32_GOT_PCREL
2190
&& fixups[i].reloc != BFD_RELOC_32_GOTOFF
2191
&& fixups[i].reloc != BFD_RELOC_32_PLT_PCREL
2192
&& fixups[i].reloc != BFD_RELOC_MN10300_GOT32)
2194
reloc_howto_type *reloc_howto;
2199
reloc_howto = bfd_reloc_type_lookup (stdoutput,
2205
size = bfd_get_reloc_size (reloc_howto);
2207
if (size < 1 || size > 4)
2211
fixP = fix_new_exp (frag_now, f - frag_now->fr_literal + offset,
2212
size, &fixups[i].exp,
2213
reloc_howto->pc_relative,
2218
int reloc, pcrel, reloc_size, offset;
2221
reloc = BFD_RELOC_NONE;
2222
if (fixups[i].reloc != BFD_RELOC_UNUSED)
2223
reloc = fixups[i].reloc;
2224
/* How big is the reloc? Remember SPLIT relocs are
2225
implicitly 32bits. */
2226
if ((operand->flags & MN10300_OPERAND_SPLIT) != 0)
2228
else if ((operand->flags & MN10300_OPERAND_24BIT) != 0)
2231
reloc_size = operand->bits;
2233
/* Is the reloc pc-relative? */
2234
pcrel = (operand->flags & MN10300_OPERAND_PCREL) != 0;
2235
if (reloc != BFD_RELOC_NONE)
2236
pcrel = bfd_reloc_type_lookup (stdoutput, reloc)->pc_relative;
2238
offset = size - (reloc_size + operand->shift) / 8;
2240
/* Choose a proper BFD relocation type. */
2241
if (reloc != BFD_RELOC_NONE)
2245
if (reloc_size == 32)
2246
reloc = BFD_RELOC_32_PCREL;
2247
else if (reloc_size == 16)
2248
reloc = BFD_RELOC_16_PCREL;
2249
else if (reloc_size == 8)
2250
reloc = BFD_RELOC_8_PCREL;
2256
if (reloc_size == 32)
2257
reloc = BFD_RELOC_32;
2258
else if (reloc_size == 16)
2259
reloc = BFD_RELOC_16;
2260
else if (reloc_size == 8)
2261
reloc = BFD_RELOC_8;
2266
/* Convert the size of the reloc into what fix_new_exp wants. */
2267
reloc_size = reloc_size / 8;
2268
if (reloc_size == 8)
2270
else if (reloc_size == 16)
2272
else if (reloc_size == 32)
2275
fixP = fix_new_exp (frag_now, f - frag_now->fr_literal + offset,
2276
reloc_size, &fixups[i].exp, pcrel,
2277
((bfd_reloc_code_real_type) reloc));
2280
fixP->fx_offset += offset;
2284
dwarf2_emit_insn (size);
2288
/* If while processing a fixup, a reloc really needs to be created
2289
then it is done here. */
2292
tc_gen_reloc (seg, fixp)
2293
asection *seg ATTRIBUTE_UNUSED;
2297
reloc = (arelent *) xmalloc (sizeof (arelent));
2299
reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
2300
if (reloc->howto == (reloc_howto_type *) NULL)
2302
as_bad_where (fixp->fx_file, fixp->fx_line,
2303
_("reloc %d not supported by object file format"),
2304
(int) fixp->fx_r_type);
2307
reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
2310
&& S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
2312
fixp->fx_offset -= S_GET_VALUE (fixp->fx_subsy);
2316
if (fixp->fx_addsy && fixp->fx_subsy)
2318
reloc->sym_ptr_ptr = NULL;
2320
/* If we got a difference between two symbols, and the
2321
subtracted symbol is in the current section, use a
2322
PC-relative relocation. If both symbols are in the same
2323
section, the difference would have already been simplified
2325
if (S_GET_SEGMENT (fixp->fx_subsy) == seg)
2327
reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
2328
*reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2329
reloc->addend = (reloc->address - S_GET_VALUE (fixp->fx_subsy)
2332
switch (fixp->fx_r_type)
2335
reloc->howto = bfd_reloc_type_lookup (stdoutput,
2340
reloc->howto = bfd_reloc_type_lookup (stdoutput,
2341
BFD_RELOC_16_PCREL);
2345
reloc->howto = bfd_reloc_type_lookup (stdoutput,
2346
BFD_RELOC_24_PCREL);
2350
reloc->howto = bfd_reloc_type_lookup (stdoutput,
2351
BFD_RELOC_32_PCREL);
2355
/* Try to compute the absolute value below. */
2360
if ((S_GET_SEGMENT (fixp->fx_addsy) != S_GET_SEGMENT (fixp->fx_subsy))
2361
|| S_GET_SEGMENT (fixp->fx_addsy) == undefined_section)
2363
as_bad_where (fixp->fx_file, fixp->fx_line,
2364
"Difference of symbols in different sections is not supported");
2368
char *fixpos = fixp->fx_where + fixp->fx_frag->fr_literal;
2370
reloc->addend = (S_GET_VALUE (fixp->fx_addsy)
2371
- S_GET_VALUE (fixp->fx_subsy) + fixp->fx_offset);
2373
switch (fixp->fx_r_type)
2376
md_number_to_chars (fixpos, reloc->addend, 1);
2380
md_number_to_chars (fixpos, reloc->addend, 2);
2384
md_number_to_chars (fixpos, reloc->addend, 3);
2388
md_number_to_chars (fixpos, reloc->addend, 4);
2392
reloc->sym_ptr_ptr = (asymbol **) &bfd_abs_symbol;
2397
if (reloc->sym_ptr_ptr)
2398
free (reloc->sym_ptr_ptr);
2404
reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
2405
*reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2406
reloc->addend = fixp->fx_offset;
2412
md_estimate_size_before_relax (fragp, seg)
2416
if (fragp->fr_subtype == 6
2417
&& (!S_IS_DEFINED (fragp->fr_symbol)
2418
|| seg != S_GET_SEGMENT (fragp->fr_symbol)))
2419
fragp->fr_subtype = 7;
2420
else if (fragp->fr_subtype == 8
2421
&& (!S_IS_DEFINED (fragp->fr_symbol)
2422
|| seg != S_GET_SEGMENT (fragp->fr_symbol)))
2423
fragp->fr_subtype = 9;
2424
else if (fragp->fr_subtype == 10
2425
&& (!S_IS_DEFINED (fragp->fr_symbol)
2426
|| seg != S_GET_SEGMENT (fragp->fr_symbol)))
2427
fragp->fr_subtype = 12;
2429
if (fragp->fr_subtype == 13)
2431
if (fragp->fr_subtype >= sizeof (md_relax_table) / sizeof (md_relax_table[0]))
2434
return md_relax_table[fragp->fr_subtype].rlx_length;
2438
md_pcrel_from (fixp)
2441
if (fixp->fx_addsy != (symbolS *) NULL && !S_IS_DEFINED (fixp->fx_addsy))
2443
/* The symbol is undefined. Let the linker figure it out. */
2446
return fixp->fx_frag->fr_address + fixp->fx_where;
2450
md_apply_fix3 (fixP, valP, seg)
2455
char * fixpos = fixP->fx_where + fixP->fx_frag->fr_literal;
2457
int value = (int) * valP;
2459
assert (fixP->fx_r_type < BFD_RELOC_UNUSED);
2461
/* This should never happen. */
2462
if (seg->flags & SEC_ALLOC)
2465
/* The value we are passed in *valuep includes the symbol values.
2466
Since we are using BFD_ASSEMBLER, if we are doing this relocation
2467
the code in write.c is going to call bfd_install_relocation, which
2468
is also going to use the symbol value. That means that if the
2469
reloc is fully resolved we want to use *valuep since
2470
bfd_install_relocation is not being used.
2472
However, if the reloc is not fully resolved we do not want to use
2473
*valuep, and must use fx_offset instead. However, if the reloc
2474
is PC relative, we do want to use *valuep since it includes the
2475
result of md_pcrel_from. */
2476
if (fixP->fx_addsy != (symbolS *) NULL && ! fixP->fx_pcrel)
2477
value = fixP->fx_offset;
2479
/* If the fix is relative to a symbol which is not defined, or not
2480
in the same segment as the fix, we cannot resolve it here. */
2481
if (fixP->fx_addsy != NULL
2482
&& (! S_IS_DEFINED (fixP->fx_addsy)
2483
|| (S_GET_SEGMENT (fixP->fx_addsy) != seg)))
2489
switch (fixP->fx_r_type)
2492
case BFD_RELOC_8_PCREL:
2497
case BFD_RELOC_16_PCREL:
2502
case BFD_RELOC_32_PCREL:
2506
case BFD_RELOC_VTABLE_INHERIT:
2507
case BFD_RELOC_VTABLE_ENTRY:
2511
case BFD_RELOC_NONE:
2513
as_bad_where (fixP->fx_file, fixP->fx_line,
2514
_("Bad relocation fixup type (%d)"), fixP->fx_r_type);
2517
md_number_to_chars (fixpos, value, size);
2519
/* If a symbol remains, pass the fixup, as a reloc, onto the linker. */
2520
if (fixP->fx_addsy == NULL)
2524
/* Return zero if the fixup in fixp should be left alone and not
2528
mn10300_fix_adjustable (fixp)
2531
if (! TC_RELOC_RTSYM_LOC_FIXUP (fixp))
2534
if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2535
|| fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
2538
/* Do not adjust relocations involving symbols in code sections,
2539
because it breaks linker relaxations. This could be fixed in the
2540
linker, but this fix is simpler, and it pretty much only affects
2541
object size a little bit. */
2542
if (S_GET_SEGMENT (fixp->fx_addsy)->flags & SEC_CODE)
2548
/* Insert an operand value into an instruction. */
2551
mn10300_insert_operand (insnp, extensionp, operand, val, file, line, shift)
2552
unsigned long *insnp;
2553
unsigned long *extensionp;
2554
const struct mn10300_operand *operand;
2560
/* No need to check 32bit operands for a bit. Note that
2561
MN10300_OPERAND_SPLIT is an implicit 32bit operand. */
2562
if (operand->bits != 32
2563
&& (operand->flags & MN10300_OPERAND_SPLIT) == 0)
2569
bits = operand->bits;
2570
if (operand->flags & MN10300_OPERAND_24BIT)
2573
if ((operand->flags & MN10300_OPERAND_SIGNED) != 0)
2575
max = (1 << (bits - 1)) - 1;
2576
min = - (1 << (bits - 1));
2580
max = (1 << bits) - 1;
2586
if (test < (offsetT) min || test > (offsetT) max)
2589
_("operand out of range (%s not between %ld and %ld)");
2592
sprint_value (buf, test);
2593
if (file == (char *) NULL)
2594
as_warn (err, buf, min, max);
2596
as_warn_where (file, line, err, buf, min, max);
2600
if ((operand->flags & MN10300_OPERAND_SPLIT) != 0)
2602
*insnp |= (val >> (32 - operand->bits)) & ((1 << operand->bits) - 1);
2603
*extensionp |= ((val & ((1 << (32 - operand->bits)) - 1))
2606
else if ((operand->flags & MN10300_OPERAND_24BIT) != 0)
2608
*insnp |= (val >> (24 - operand->bits)) & ((1 << operand->bits) - 1);
2609
*extensionp |= ((val & ((1 << (24 - operand->bits)) - 1))
2612
else if ((operand->flags & (MN10300_OPERAND_FSREG | MN10300_OPERAND_FDREG)))
2614
/* See devo/opcodes/m10300-opc.c just before #define FSM0 for an
2615
explanation of these variables. Note that FMT-implied shifts
2616
are not taken into account for FP registers. */
2617
unsigned long mask_low, mask_high;
2618
int shl_low, shr_high, shl_high;
2620
switch (operand->bits)
2623
/* Handle regular FP registers. */
2624
if (operand->shift >= 0)
2626
/* This is an `m' register. */
2627
shl_low = operand->shift;
2628
shl_high = 8 + (8 & shl_low) + (shl_low & 4) / 4;
2632
/* This is an `n' register. */
2633
shl_low = -operand->shift;
2634
shl_high = shl_low / 4;
2643
/* Handle accumulators. */
2644
shl_low = -operand->shift;
2654
*insnp |= ((((val & mask_high) >> shr_high) << shl_high)
2655
| ((val & mask_low) << shl_low));
2657
else if ((operand->flags & MN10300_OPERAND_EXTENDED) == 0)
2659
*insnp |= (((long) val & ((1 << operand->bits) - 1))
2660
<< (operand->shift + shift));
2662
if ((operand->flags & MN10300_OPERAND_REPEATED) != 0)
2663
*insnp |= (((long) val & ((1 << operand->bits) - 1))
2664
<< (operand->shift + shift + operand->bits));
2668
*extensionp |= (((long) val & ((1 << operand->bits) - 1))
2669
<< (operand->shift + shift));
2671
if ((operand->flags & MN10300_OPERAND_REPEATED) != 0)
2672
*extensionp |= (((long) val & ((1 << operand->bits) - 1))
2673
<< (operand->shift + shift + operand->bits));
2677
static unsigned long
2678
check_operand (insn, operand, val)
2679
unsigned long insn ATTRIBUTE_UNUSED;
2680
const struct mn10300_operand *operand;
2683
/* No need to check 32bit operands for a bit. Note that
2684
MN10300_OPERAND_SPLIT is an implicit 32bit operand. */
2685
if (operand->bits != 32
2686
&& (operand->flags & MN10300_OPERAND_SPLIT) == 0)
2692
bits = operand->bits;
2693
if (operand->flags & MN10300_OPERAND_24BIT)
2696
if ((operand->flags & MN10300_OPERAND_SIGNED) != 0)
2698
max = (1 << (bits - 1)) - 1;
2699
min = - (1 << (bits - 1));
2703
max = (1 << bits) - 1;
2709
if (test < (offsetT) min || test > (offsetT) max)
2718
set_arch_mach (mach)
2721
if (!bfd_set_arch_mach (stdoutput, bfd_arch_mn10300, mach))
2722
as_warn (_("could not set architecture and machine"));
2724
current_machine = mach;
2727
static inline char * mn10300_end_of_match PARAMS ((char *, char *));
2729
static inline char *
2730
mn10300_end_of_match (cont, what)
2733
int len = strlen (what);
2735
if (strncmp (cont, what, strlen (what)) == 0
2736
&& ! is_part_of_name (cont[len]))
2743
mn10300_parse_name (name, exprP, nextcharP)
2748
char *next = input_line_pointer;
2753
exprP->X_op_symbol = NULL;
2755
if (strcmp (name, GLOBAL_OFFSET_TABLE_NAME) == 0)
2758
GOT_symbol = symbol_find_or_make (name);
2760
exprP->X_add_symbol = GOT_symbol;
2762
/* If we have an absolute symbol or a reg,
2763
then we know its value now. */
2764
segment = S_GET_SEGMENT (exprP->X_add_symbol);
2765
if (segment == absolute_section)
2767
exprP->X_op = O_constant;
2768
exprP->X_add_number = S_GET_VALUE (exprP->X_add_symbol);
2769
exprP->X_add_symbol = NULL;
2771
else if (segment == reg_section)
2773
exprP->X_op = O_register;
2774
exprP->X_add_number = S_GET_VALUE (exprP->X_add_symbol);
2775
exprP->X_add_symbol = NULL;
2779
exprP->X_op = O_symbol;
2780
exprP->X_add_number = 0;
2786
exprP->X_add_symbol = symbol_find_or_make (name);
2788
if (*nextcharP != '@')
2790
else if ((next_end = mn10300_end_of_match (next + 1, "GOTOFF")))
2791
reloc_type = BFD_RELOC_32_GOTOFF;
2792
else if ((next_end = mn10300_end_of_match (next + 1, "GOT")))
2793
reloc_type = BFD_RELOC_MN10300_GOT32;
2794
else if ((next_end = mn10300_end_of_match (next + 1, "PLT")))
2795
reloc_type = BFD_RELOC_32_PLT_PCREL;
2799
*input_line_pointer = *nextcharP;
2800
input_line_pointer = next_end;
2801
*nextcharP = *input_line_pointer;
2802
*input_line_pointer = '\0';
2804
exprP->X_op = O_PIC_reloc;
2805
exprP->X_add_number = 0;
2806
exprP->X_md = reloc_type;
added
removed
gas/config/tc-mn10300.c
