1 /* tc-w65.c -- Assemble code for the W65816
2 Copyright 1995, 1998, 2000, 2001, 2002, 2005
3 Free Software Foundation, Inc.
4
5 This file is part of GAS, the GNU Assembler.
6
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)
10 any later version.
11
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.
16
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 the Free
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22 /* Written By Steve Chamberlain <sac@cygnus.com>. */
23
24 #include <stdio.h>
25 #include "as.h"
26 #include "bfd.h"
27 #include "subsegs.h"
28 #define DEFINE_TABLE
29 #include "../opcodes/w65-opc.h"
30
31 const char comment_chars[] = "!";
32 const char line_separator_chars[] = ";";
33 const char line_comment_chars[] = "!#";
34
35 /* This table describes all the machine specific pseudo-ops the assembler
36 has to support. The fields are:
37
38 pseudo-op name without dot
39 function to call to execute this pseudo-op
40 Integer arg to pass to the function. */
41
42 #define OP_BCC 0x90
43 #define OP_BCS 0xB0
44 #define OP_BEQ 0xF0
45 #define OP_BMI 0x30
46 #define OP_BNE 0xD0
47 #define OP_BPL 0x10
48 #define OP_BRA 0x80
49 #define OP_BRL 0x82
50 #define OP_BVC 0x50
51 #define OP_BVS 0x70
52
53 static int M; /* M flag. */
54 static int X; /* X flag. */
55
56 /* This function is called once, at assembler startup time. This
57 should set up all the tables, etc that the MD part of the assembler
58 needs. */
59
60 static void
s_longa(int xmode)61 s_longa (int xmode)
62 {
63 int *p = xmode ? &X : &M;
64
65 while (*input_line_pointer == ' ')
66 input_line_pointer++;
67 if (strncmp (input_line_pointer, "on", 2) == 0)
68 {
69 input_line_pointer += 2;
70 *p = 0;
71 }
72 else if (strncmp (input_line_pointer, "off", 3) == 0)
73 {
74 *p = 1;
75 input_line_pointer += 3;
76 }
77 else
78 as_bad (_("need on or off."));
79 demand_empty_rest_of_line ();
80 }
81
82 const pseudo_typeS md_pseudo_table[] =
83 {
84 {"int", cons, 2},
85 {"word", cons, 2},
86 {"longa", s_longa, 0},
87 {"longi", s_longa, 1},
88 {0, 0, 0}
89 };
90
91 const char EXP_CHARS[] = "eE";
92
93 /* Chars that mean this number is a floating point constant. */
94 /* As in 0f12.456 */
95 /* or 0d1.2345e12 */
96 const char FLT_CHARS[] = "rRsSfFdDxXpP";
97
98 /* Opcode mnemonics */
99 static struct hash_control *opcode_hash_control;
100
101 #define C(a, b) ENCODE_RELAX(a,b)
102 #define ENCODE_RELAX(what, length) (((what) << 2) + (length))
103
104 #define GET_WHAT(x) (((x) >> 2))
105
106 #define BYTE_DISP 1
107 #define WORD_DISP 2
108 #define UNDEF_BYTE_DISP 0
109 #define UNDEF_WORD_DISP 3
110 #define COND_BRANCH 1
111 #define UNCOND_BRANCH 2
112 #define END 3
113
114 #define BYTE_F 127 /* How far we can branch forwards. */
115 #define BYTE_B -126 /* How far we can branch backwards. */
116 #define WORD_F 32767
117 #define WORD_B 32768
118
119 relax_typeS md_relax_table[C (END, 0)] =
120 {
121 { 0, 0, 0, 0 },
122 { 0, 0, 0, 0 },
123 { 0, 0, 0, 0 },
124 { 0, 0, 0, 0 },
125
126 /* COND_BRANCH */
127 { 0, 0, 0, 0 }, /* UNDEF_BYTE_DISP */
128 { BYTE_F, BYTE_B, 2, C (COND_BRANCH, WORD_DISP) }, /* BYTE_DISP */
129 { WORD_F, WORD_B, 5, 0 }, /* WORD_DISP */
130 { 0, 0, 5, 0 }, /* UNDEF_WORD_DISP */
131
132 /* UNCOND_BRANCH */
133 { 0, 0, 0, 0 }, /* UNDEF_BYTE_DISP */
134 { BYTE_F, BYTE_B, 2, C (UNCOND_BRANCH, WORD_DISP) }, /* BYTE_DISP */
135 { WORD_F, WORD_B, 3, 0 }, /* WORD_DISP */
136 { 0, 0, 3, 0 } /* UNDEF_WORD_DISP */
137 };
138
139 void
md_begin(void)140 md_begin (void)
141 {
142 const struct opinfo *opcode;
143 char *prev_name = "";
144
145 opcode_hash_control = hash_new ();
146
147 /* Insert unique names into hash table. */
148 for (opcode = optable; opcode->name; opcode++)
149 {
150 if (strcmp (prev_name, opcode->name))
151 {
152 prev_name = opcode->name;
153 hash_insert (opcode_hash_control, opcode->name, (char *) opcode);
154 }
155 }
156
157 flag_signed_overflow_ok = 1;
158 }
159
160 static expressionS immediate; /* Absolute expression. */
161 static expressionS immediate1; /* Absolute expression. */
162 int expr_size;
163 int expr_shift;
164 int tc_cons_reloc;
165
166 void
w65_expression(expressionS * dest)167 w65_expression (expressionS *dest)
168 {
169 expr_size = 0;
170 expr_shift = 0;
171 tc_cons_reloc = 0;
172 while (*input_line_pointer == ' ')
173 input_line_pointer++;
174
175 if (*input_line_pointer == '<')
176 {
177 expr_size = 1;
178 input_line_pointer++;
179 }
180 else if (*input_line_pointer == '>')
181 {
182 expr_shift = 1;
183 input_line_pointer++;
184 }
185 else if (*input_line_pointer == '^')
186 {
187 expr_shift = 2;
188 input_line_pointer++;
189 }
190
191 expr (0, dest);
192 }
193
194 int amode;
195
196 static char *
parse_exp(char * s)197 parse_exp (char *s)
198 {
199 char *save;
200 char *new;
201
202 save = input_line_pointer;
203 input_line_pointer = s;
204 w65_expression (&immediate);
205 if (immediate.X_op == O_absent)
206 as_bad (_("missing operand"));
207 new = input_line_pointer;
208 input_line_pointer = save;
209 return new;
210 }
211
212 static char *
get_operands(const struct opinfo * info,char * ptr)213 get_operands (const struct opinfo *info, char *ptr)
214 {
215 int override_len = 0;
216 int bytes = 0;
217
218 while (*ptr == ' ')
219 ptr++;
220
221 if (ptr[0] == '#')
222 {
223 ptr++;
224 switch (info->amode)
225 {
226 case ADDR_IMMTOI:
227 bytes = X ? 1 : 2;
228 amode = ADDR_IMMTOI;
229 break;
230 case ADDR_IMMTOA:
231 bytes = M ? 1 : 2;
232 amode = ADDR_IMMTOA;
233 break;
234 case ADDR_IMMCOP:
235 bytes = 1;
236 amode = ADDR_IMMCOP;
237 break;
238 case ADDR_DIR:
239 bytes = 2;
240 amode = ADDR_ABS;
241 break;
242 default:
243 abort ();
244 break;
245 }
246 ptr = parse_exp (ptr);
247 }
248 else if (ptr[0] == '!')
249 {
250 ptr = parse_exp (ptr + 1);
251 if (ptr[0] == ',')
252 {
253 if (ptr[1] == 'y')
254 {
255 amode = ADDR_ABS_IDX_Y;
256 bytes = 2;
257 ptr += 2;
258 }
259 else if (ptr[1] == 'x')
260 {
261 amode = ADDR_ABS_IDX_X;
262 bytes = 2;
263 ptr += 2;
264 }
265 else
266 as_bad (_("syntax error after <exp"));
267 }
268 else
269 {
270 amode = ADDR_ABS;
271 bytes = 2;
272 }
273 }
274 else if (ptr[0] == '>')
275 {
276 ptr = parse_exp (ptr + 1);
277 if (ptr[0] == ',' && ptr[1] == 'x')
278 {
279 amode = ADDR_ABS_LONG_IDX_X;
280 bytes = 3;
281 ptr += 2;
282 }
283 else
284 {
285 amode = ADDR_ABS_LONG;
286 bytes = 3;
287 }
288 }
289 else if (ptr[0] == '<')
290 {
291 ptr = parse_exp (ptr + 1);
292 if (ptr[0] == ',')
293 {
294 if (ptr[1] == 'y')
295 {
296 amode = ADDR_DIR_IDX_Y;
297 ptr += 2;
298 bytes = 2;
299 }
300 else if (ptr[1] == 'x')
301 {
302 amode = ADDR_DIR_IDX_X;
303 ptr += 2;
304 bytes = 2;
305 }
306 else
307 as_bad (_("syntax error after <exp"));
308 }
309 else
310 {
311 amode = ADDR_DIR;
312 bytes = 1;
313 }
314 }
315 else if (ptr[0] == 'a')
316 amode = ADDR_ACC;
317 else if (ptr[0] == '(')
318 {
319 /* Look for (exp),y
320 (<exp),y
321 (exp,x)
322 (<exp,x)
323 (exp)
324 (!exp)
325 (exp)
326 (<exp)
327 (exp,x)
328 (!exp,x)
329 (exp,s)
330 (exp,s),y */
331
332 ptr++;
333 if (ptr[0] == '<')
334 {
335 override_len = 1;
336 ptr++;
337 }
338 else if (ptr[0] == '!')
339 {
340 override_len = 2;
341 ptr++;
342 }
343 else if (ptr[0] == '>')
344 {
345 override_len = 3;
346 ptr++;
347 }
348 else
349 override_len = 0;
350
351 ptr = parse_exp (ptr);
352
353 if (ptr[0] == ',')
354 {
355 ptr++;
356 if (ptr[0] == 'x' && ptr[1] == ')')
357 {
358 ptr += 2;
359
360 if (override_len == 1)
361 {
362 amode = ADDR_DIR_IDX_IND_X;
363 bytes = 2;
364 }
365 else
366 {
367 amode = ADDR_ABS_IND_IDX;
368 bytes = 2;
369 }
370 }
371 else if (ptr[0] == 's' && ptr[1] == ')'
372 && ptr[2] == ',' && ptr[3] == 'y')
373 {
374 amode = ADDR_STACK_REL_INDX_IDX;
375 bytes = 1;
376 ptr += 4;
377 }
378 }
379 else if (ptr[0] == ')')
380 {
381 if (ptr[1] == ',' && ptr[2] == 'y')
382 {
383 amode = ADDR_DIR_IND_IDX_Y;
384 ptr += 3;
385 bytes = 2;
386 }
387 else
388 {
389 if (override_len == 1)
390 {
391 amode = ADDR_DIR_IND;
392 bytes = 1;
393 }
394 else
395 {
396 amode = ADDR_ABS_IND;
397 bytes = 2;
398 }
399 ptr++;
400 }
401 }
402 }
403 else if (ptr[0] == '[')
404 {
405 ptr = parse_exp (ptr + 1);
406
407 if (ptr[0] == ']')
408 {
409 ptr++;
410 if (ptr[0] == ',' && ptr[1] == 'y')
411 {
412 bytes = 1;
413 amode = ADDR_DIR_IND_IDX_Y_LONG;
414 ptr += 2;
415 }
416 else
417 {
418 if (info->code == O_jmp)
419 {
420 bytes = 2;
421 amode = ADDR_ABS_IND_LONG;
422 }
423 else
424 {
425 bytes = 1;
426 amode = ADDR_DIR_IND_LONG;
427 }
428 }
429 }
430 }
431 else
432 {
433 ptr = parse_exp (ptr);
434 if (ptr[0] == ',')
435 {
436 if (ptr[1] == 'y')
437 {
438 if (override_len == 1)
439 {
440 bytes = 1;
441 amode = ADDR_DIR_IDX_Y;
442 }
443 else
444 {
445 amode = ADDR_ABS_IDX_Y;
446 bytes = 2;
447 }
448 ptr += 2;
449 }
450 else if (ptr[1] == 'x')
451 {
452 if (override_len == 1)
453 {
454 amode = ADDR_DIR_IDX_X;
455 bytes = 1;
456 }
457 else
458 {
459 amode = ADDR_ABS_IDX_X;
460 bytes = 2;
461 }
462 ptr += 2;
463 }
464 else if (ptr[1] == 's')
465 {
466 bytes = 1;
467 amode = ADDR_STACK_REL;
468 ptr += 2;
469 }
470 else
471 {
472 bytes = 1;
473 immediate1 = immediate;
474 ptr = parse_exp (ptr + 1);
475 amode = ADDR_BLOCK_MOVE;
476 }
477 }
478 else
479 {
480 switch (info->amode)
481 {
482 case ADDR_PC_REL:
483 amode = ADDR_PC_REL;
484 bytes = 1;
485 break;
486 case ADDR_PC_REL_LONG:
487 amode = ADDR_PC_REL_LONG;
488 bytes = 2;
489 break;
490 default:
491 if (override_len == 1)
492 {
493 amode = ADDR_DIR;
494 bytes = 1;
495 }
496 else if (override_len == 3)
497 {
498 bytes = 3;
499 amode = ADDR_ABS_LONG;
500 }
501 else
502 {
503 amode = ADDR_ABS;
504 bytes = 2;
505 }
506 }
507 }
508 }
509
510 switch (bytes)
511 {
512 case 1:
513 switch (expr_shift)
514 {
515 case 0:
516 if (amode == ADDR_DIR)
517 tc_cons_reloc = R_W65_DP;
518 else
519 tc_cons_reloc = R_W65_ABS8;
520 break;
521 case 1:
522 tc_cons_reloc = R_W65_ABS8S8;
523 break;
524 case 2:
525 tc_cons_reloc = R_W65_ABS8S16;
526 break;
527 }
528 break;
529 case 2:
530 switch (expr_shift)
531 {
532 case 0:
533 tc_cons_reloc = R_W65_ABS16;
534 break;
535 case 1:
536 tc_cons_reloc = R_W65_ABS16S8;
537 break;
538 case 2:
539 tc_cons_reloc = R_W65_ABS16S16;
540 break;
541 }
542 }
543 return ptr;
544 }
545
546 /* Passed a pointer to a list of opcodes which use different
547 addressing modes, return the opcode which matches the opcodes
548 provided. */
549
550 static const struct opinfo *
get_specific(const struct opinfo * opcode)551 get_specific (const struct opinfo *opcode)
552 {
553 int ocode = opcode->code;
554
555 for (; opcode->code == ocode; opcode++)
556 if (opcode->amode == amode)
557 return opcode;
558
559 return 0;
560 }
561
562 /* Now we know what sort of opcodes it is, let's build the bytes. */
563
564 static void
build_Mytes(const struct opinfo * opcode)565 build_Mytes (const struct opinfo *opcode)
566 {
567 int size;
568 int type;
569 int pcrel;
570 char *output;
571
572 if (opcode->amode == ADDR_IMPLIED)
573 output = frag_more (1);
574
575 else if (opcode->amode == ADDR_PC_REL)
576 {
577 int type;
578
579 /* This is a relaxable insn, so we do some special handling. */
580 type = opcode->val == OP_BRA ? UNCOND_BRANCH : COND_BRANCH;
581 output = frag_var (rs_machine_dependent,
582 md_relax_table[C (type, WORD_DISP)].rlx_length,
583 md_relax_table[C (type, BYTE_DISP)].rlx_length,
584 C (type, UNDEF_BYTE_DISP),
585 immediate.X_add_symbol,
586 immediate.X_add_number,
587 0);
588 }
589 else
590 {
591 switch (opcode->amode)
592 {
593 GETINFO (size, type, pcrel);
594 default:
595 abort ();
596 }
597
598 /* If something special was done in the expression modify the
599 reloc type. */
600 if (tc_cons_reloc)
601 type = tc_cons_reloc;
602
603 /* 1 byte for the opcode + the bytes for the addrmode. */
604 output = frag_more (size + 1);
605
606 if (opcode->amode == ADDR_BLOCK_MOVE)
607 {
608 /* Two relocs for this one. */
609 fix_new_exp (frag_now,
610 output + 1 - frag_now->fr_literal,
611 1,
612 &immediate,
613 0,
614 R_W65_ABS8S16);
615
616 fix_new_exp (frag_now,
617 output + 2 - frag_now->fr_literal,
618 1,
619 &immediate1,
620 0,
621 R_W65_ABS8S16);
622 }
623 else if (type >= 0
624 && opcode->amode != ADDR_IMPLIED
625 && opcode->amode != ADDR_ACC
626 && opcode->amode != ADDR_STACK)
627 {
628 fix_new_exp (frag_now,
629 output + 1 - frag_now->fr_literal,
630 size,
631 &immediate,
632 pcrel,
633 type);
634 }
635 }
636 output[0] = opcode->val;
637 }
638
639 /* This is the guts of the machine-dependent assembler. STR points to
640 a machine dependent instruction. This function is supposed to emit
641 the frags/bytes it assembles to. */
642
643 void
md_assemble(char * str)644 md_assemble (char *str)
645 {
646 const struct opinfo *opcode;
647 char name[20];
648
649 /* Drop leading whitespace */
650 while (*str == ' ')
651 str++;
652
653 /* All opcodes are three letters. */
654 name[0] = str[0];
655 name[1] = str[1];
656 name[2] = str[2];
657 name[3] = 0;
658
659 tc_cons_reloc = 0;
660 str += 3;
661 opcode = (struct opinfo *) hash_find (opcode_hash_control, name);
662
663 if (opcode == NULL)
664 {
665 as_bad (_("unknown opcode"));
666 return;
667 }
668
669 if (opcode->amode != ADDR_IMPLIED
670 && opcode->amode != ADDR_STACK)
671 {
672 get_operands (opcode, str);
673 opcode = get_specific (opcode);
674 }
675
676 if (opcode == 0)
677 {
678 /* Couldn't find an opcode which matched the operands. */
679
680 char *where = frag_more (1);
681
682 where[0] = 0x0;
683 where[1] = 0x0;
684 as_bad (_("invalid operands for opcode"));
685 return;
686 }
687
688 build_Mytes (opcode);
689 }
690
691 symbolS *
md_undefined_symbol(char * name ATTRIBUTE_UNUSED)692 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
693 {
694 return 0;
695 }
696
697 /* Various routines to kill one day. */
698 /* Equal to MAX_PRECISION in atof-ieee.c. */
699 #define MAX_LITTLENUMS 6
700
701 /* Turn a string in input_line_pointer into a floating point constant
702 of type TYPE, and store the appropriate bytes in *LITP. The number
703 of LITTLENUMS emitted is stored in *SIZEP. An error message is
704 returned, or NULL on OK. */
705
706 char *
md_atof(int type,char * litP,int * sizeP)707 md_atof (int type, char *litP, int *sizeP)
708 {
709 int prec;
710 LITTLENUM_TYPE words[MAX_LITTLENUMS];
711 LITTLENUM_TYPE *wordP;
712 char *t;
713
714 switch (type)
715 {
716 case 'f':
717 case 'F':
718 case 's':
719 case 'S':
720 prec = 2;
721 break;
722
723 case 'd':
724 case 'D':
725 case 'r':
726 case 'R':
727 prec = 4;
728 break;
729
730 case 'x':
731 case 'X':
732 prec = 6;
733 break;
734
735 case 'p':
736 case 'P':
737 prec = 6;
738 break;
739
740 default:
741 *sizeP = 0;
742 return _("Bad call to MD_NTOF()");
743 }
744 t = atof_ieee (input_line_pointer, type, words);
745 if (t)
746 input_line_pointer = t;
747
748 *sizeP = prec * sizeof (LITTLENUM_TYPE);
749 for (wordP = words + prec - 1; prec--;)
750 {
751 md_number_to_chars (litP, (valueT) (*wordP--), sizeof (LITTLENUM_TYPE));
752 litP += sizeof (LITTLENUM_TYPE);
753 }
754 return 0;
755 }
756
757 int
md_parse_option(int c ATTRIBUTE_UNUSED,char * a ATTRIBUTE_UNUSED)758 md_parse_option (int c ATTRIBUTE_UNUSED, char *a ATTRIBUTE_UNUSED)
759 {
760 return 0;
761 }
762
763 /* Called after relaxing, change the frags so they know how big they
764 are. */
765
766 void
md_convert_frag(object_headers * headers ATTRIBUTE_UNUSED,segT seg ATTRIBUTE_UNUSED,fragS * fragP)767 md_convert_frag (object_headers *headers ATTRIBUTE_UNUSED,
768 segT seg ATTRIBUTE_UNUSED,
769 fragS *fragP)
770 {
771 int disp_size = 0;
772 int inst_size = 0;
773 unsigned char *buffer =
774 (unsigned char *) (fragP->fr_fix + fragP->fr_literal);
775
776 switch (fragP->fr_subtype)
777 {
778 case C (COND_BRANCH, BYTE_DISP):
779 case C (UNCOND_BRANCH, BYTE_DISP):
780 disp_size = 1;
781 inst_size = 1;
782 break;
783
784 /* Conditional branches to a known 16 bit displacement. */
785 case C (COND_BRANCH, WORD_DISP):
786 switch (buffer[0])
787 {
788 case OP_BCC:
789 case OP_BCS:
790 case OP_BEQ:
791 case OP_BMI:
792 case OP_BNE:
793 case OP_BPL:
794 case OP_BVS:
795 case OP_BVC:
796 /* Invert the sense of the test. */
797 buffer[0] ^= 0x20;
798 buffer[1] = 3; /* Jump over following brl. */
799 buffer[2] = OP_BRL;
800 buffer[3] = 0;
801 buffer[4] = 0;
802 disp_size = 2;
803 inst_size = 3;
804 break;
805 default:
806 abort ();
807 }
808 break;
809 case C (UNCOND_BRANCH, WORD_DISP):
810 /* Unconditional branches to a known 16 bit displacement. */
811
812 switch (buffer[0])
813 {
814 case OP_BRA:
815 buffer[0] = OP_BRL;
816 disp_size = 2;
817 inst_size = 1;
818 break;
819 default:
820 abort ();
821 }
822 break;
823 /* Got to create a branch over a reloc here. */
824 case C (COND_BRANCH, UNDEF_WORD_DISP):
825 buffer[0] ^= 0x20; /* Invert test. */
826 buffer[1] = 3;
827 buffer[2] = OP_BRL;
828 buffer[3] = 0;
829 buffer[4] = 0;
830 fix_new (fragP,
831 fragP->fr_fix + 3,
832 4,
833 fragP->fr_symbol,
834 fragP->fr_offset,
835 0,
836 R_W65_PCR16);
837
838 fragP->fr_fix += disp_size + inst_size;
839 fragP->fr_var = 0;
840 break;
841 case C (UNCOND_BRANCH, UNDEF_WORD_DISP):
842 buffer[0] = OP_BRL;
843 buffer[1] = 0;
844 buffer[2] = 0;
845 fix_new (fragP,
846 fragP->fr_fix + 1,
847 4,
848 fragP->fr_symbol,
849 fragP->fr_offset,
850 0,
851 R_W65_PCR16);
852
853 fragP->fr_fix += disp_size + inst_size;
854 fragP->fr_var = 0;
855 break;
856 default:
857 abort ();
858 }
859 if (inst_size)
860 {
861 /* Get the address of the end of the instruction. */
862 int next_inst = (fragP->fr_fix + fragP->fr_address
863 + disp_size + inst_size);
864 int targ_addr = (S_GET_VALUE (fragP->fr_symbol) +
865 fragP->fr_offset);
866 int disp = targ_addr - next_inst;
867
868 md_number_to_chars ((char *) buffer + inst_size, disp, disp_size);
869 fragP->fr_fix += disp_size + inst_size;
870 fragP->fr_var = 0;
871 }
872 }
873
874 valueT
md_section_align(segT seg,valueT size)875 md_section_align (segT seg, valueT size)
876 {
877 return ((size + (1 << section_alignment[(int) seg]) - 1)
878 & (-1 << section_alignment[(int) seg]));
879 }
880
881 void
md_apply_fix(fixS * fixP,valueT * valP,segT seg ATTRIBUTE_UNUSED)882 md_apply_fix (fixS *fixP, valueT * valP, segT seg ATTRIBUTE_UNUSED)
883 {
884 long val = * (long *) valP;
885 char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
886 int addr = fixP->fx_frag->fr_address + fixP->fx_where;
887
888 if (fixP->fx_r_type == 0)
889 {
890 if (fixP->fx_size == 1)
891 fixP->fx_r_type = R_W65_ABS8;
892 else
893 fixP->fx_r_type = R_W65_ABS16;
894 }
895
896 switch (fixP->fx_r_type)
897 {
898 case R_W65_ABS8S16:
899 val >>= 8;
900 case R_W65_ABS8S8:
901 val >>= 8;
902 case R_W65_ABS8:
903 *buf++ = val;
904 break;
905 case R_W65_ABS16S16:
906 val >>= 8;
907 case R_W65_ABS16S8:
908 val >>= 8;
909 case R_W65_ABS16:
910 *buf++ = val >> 0;
911 *buf++ = val >> 8;
912 break;
913 case R_W65_ABS24:
914 *buf++ = val >> 0;
915 *buf++ = val >> 8;
916 *buf++ = val >> 16;
917 break;
918 case R_W65_PCR8:
919 *buf++ = val - addr - 1;
920 break;
921 case R_W65_PCR16:
922 val = val - addr - 1;
923 *buf++ = val;
924 *buf++ = val >> 8;
925 break;
926 case R_W65_DP:
927 *buf++ = val;
928 break;
929
930 default:
931 abort ();
932 }
933
934 if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
935 fixP->fx_done = 1;
936 }
937
938 /* Put number into target byte order. */
939
940 void
md_number_to_chars(char * ptr,valueT use,int nbytes)941 md_number_to_chars (char *ptr, valueT use, int nbytes)
942 {
943 number_to_chars_littleendian (ptr, use, nbytes);
944 }
945
946 long
md_pcrel_from(fixS * fixP)947 md_pcrel_from (fixS *fixP)
948 {
949 int gap = fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address - 1;
950 return gap;
951 }
952
953 void
tc_coff_symbol_emit_hook(symbolS * x ATTRIBUTE_UNUSED)954 tc_coff_symbol_emit_hook (symbolS *x ATTRIBUTE_UNUSED)
955 {
956 }
957
958 short
tc_coff_fix2rtype(fixS * fix_ptr)959 tc_coff_fix2rtype (fixS *fix_ptr)
960 {
961 return fix_ptr->fx_r_type;
962 }
963
964 void
tc_reloc_mangle(fixS * fix_ptr,struct internal_reloc * intr,bfd_vma base)965 tc_reloc_mangle (fixS *fix_ptr,
966 struct internal_reloc *intr,
967 bfd_vma base)
968
969 {
970 symbolS *symbol_ptr;
971
972 symbol_ptr = fix_ptr->fx_addsy;
973
974 /* If this relocation is attached to a symbol then it's ok
975 to output it */
976 if (fix_ptr->fx_r_type == RELOC_32)
977 {
978 /* Cons likes to create reloc32's whatever the size of the reloc. */
979 switch (fix_ptr->fx_size)
980 {
981 case 2:
982 intr->r_type = R_IMM16;
983 break;
984 case 1:
985 intr->r_type = R_IMM8;
986 break;
987 default:
988 abort ();
989 }
990 }
991 else
992 {
993 if (fix_ptr->fx_size == 4)
994 intr->r_type = R_W65_ABS24;
995 else
996 intr->r_type = fix_ptr->fx_r_type;
997 }
998
999 intr->r_vaddr = fix_ptr->fx_frag->fr_address + fix_ptr->fx_where + base;
1000 intr->r_offset = fix_ptr->fx_offset;
1001
1002 /* Turn the segment of the symbol into an offset. */
1003 if (symbol_ptr)
1004 {
1005 symbolS *dot;
1006
1007 dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
1008 if (dot)
1009 {
1010 intr->r_offset += S_GET_VALUE (symbol_ptr);
1011 intr->r_symndx = dot->sy_number;
1012 }
1013 else
1014 intr->r_symndx = symbol_ptr->sy_number;
1015 }
1016 else
1017 intr->r_symndx = -1;
1018 }
1019
1020 int
tc_coff_sizemachdep(fragS * frag)1021 tc_coff_sizemachdep (fragS *frag)
1022 {
1023 return md_relax_table[frag->fr_subtype].rlx_length;
1024 }
1025
1026 /* Called just before address relaxation, return the length by which a
1027 fragment must grow to reach it's destination. */
1028
1029 int
md_estimate_size_before_relax(fragS * fragP,segT segment_type)1030 md_estimate_size_before_relax (fragS *fragP, segT segment_type)
1031 {
1032 int what;
1033
1034 switch (fragP->fr_subtype)
1035 {
1036 default:
1037 abort ();
1038
1039 case C (COND_BRANCH, UNDEF_BYTE_DISP):
1040 case C (UNCOND_BRANCH, UNDEF_BYTE_DISP):
1041 what = GET_WHAT (fragP->fr_subtype);
1042 /* Used to be a branch to somewhere which was unknown. */
1043 if (S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
1044 /* Got a symbol and it's defined in this segment, become byte
1045 sized - maybe it will fix up. */
1046 fragP->fr_subtype = C (what, BYTE_DISP);
1047 else
1048 /* Its got a segment, but its not ours, so it will always be
1049 long. */
1050 fragP->fr_subtype = C (what, UNDEF_WORD_DISP);
1051 break;
1052
1053 case C (COND_BRANCH, BYTE_DISP):
1054 case C (COND_BRANCH, WORD_DISP):
1055 case C (COND_BRANCH, UNDEF_WORD_DISP):
1056 case C (UNCOND_BRANCH, BYTE_DISP):
1057 case C (UNCOND_BRANCH, WORD_DISP):
1058 case C (UNCOND_BRANCH, UNDEF_WORD_DISP):
1059 /* When relaxing a section for the second time, we don't need to
1060 do anything besides return the current size. */
1061 break;
1062 }
1063
1064 fragP->fr_var = md_relax_table[fragP->fr_subtype].rlx_length;
1065 return fragP->fr_var;
1066 }
1067
1068 const char *md_shortopts = "";
1069 struct option md_longopts[] =
1070 {
1071 #define OPTION_RELAX (OPTION_MD_BASE)
1072 {NULL, no_argument, NULL, 0}
1073 };
1074
1075 void
md_show_usage(FILE * stream ATTRIBUTE_UNUSED)1076 md_show_usage (FILE *stream ATTRIBUTE_UNUSED)
1077 {
1078 }
1079
1080 size_t md_longopts_size = sizeof (md_longopts);
1081