1 /* tc-pdp11.c - pdp11-specific -
2 Copyright (C) 2001 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 Apparently unused functions:
23 md_estimate_size_before_relax
29 #include "opcode/pdp11.h"
31 static int set_option
PARAMS ((char *arg
));
32 static int set_cpu_model
PARAMS ((char *arg
));
33 static int set_machine_model
PARAMS ((char *arg
));
39 * A representation for PDP-11 machine code.
45 int additional
; /* is there an additional word? */
46 int word
; /* additional word, if any */
49 bfd_reloc_code_real_type type
;
56 * Instruction set extensions.
58 * If you change this from an array to something else, please update
59 * the "PDP-11 instruction set extensions" comment in pdp11.h.
61 int pdp11_extension
[PDP11_EXT_NUM
];
70 int asm_option
[ASM_OPT_NUM
];
72 /* These chars start a comment anywhere in a source file (except inside
74 CONST
char comment_chars
[] = "#/";
76 /* These chars only start a comment at the beginning of a line. */
77 CONST
char line_comment_chars
[] = "#/";
79 CONST
char line_separator_chars
[] = ";";
81 /* Chars that can be used to separate mant from exp in floating point nums */
82 CONST
char EXP_CHARS
[] = "eE";
84 /* Chars that mean this number is a floating point constant */
86 /* or 0H1.234E-12 (see exp chars above) */
87 CONST
char FLT_CHARS
[] = "dDfFgGhH";
89 void pseudo_even (int);
90 void pseudo_bss (int);
92 CONST pseudo_typeS md_pseudo_table
[] =
94 { "bss", pseudo_bss
, 0 },
95 { "even", pseudo_even
, 0 },
102 static int first
= 1;
106 set_option ("all-extensions");
112 static struct hash_control
*insn_hash
= NULL
;
121 insn_hash
= hash_new ();
122 if (insn_hash
== NULL
)
123 as_fatal ("Virtual memory exhausted");
125 for (i
= 0; i
< pdp11_num_opcodes
; i
++)
126 hash_insert (insn_hash
, pdp11_opcodes
[i
].name
, (PTR
)(pdp11_opcodes
+ i
));
127 for (i
= 0; i
< pdp11_num_aliases
; i
++)
128 hash_insert (insn_hash
, pdp11_aliases
[i
].name
, (PTR
)(pdp11_aliases
+ i
));
132 md_number_to_chars (con
, value
, nbytes
)
137 /* On a PDP-11, 0x1234 is stored as "\x12\x34", and
138 * 0x12345678 is stored as "\x56\x78\x12\x34". It's
139 * anyones guess what 0x123456 would be stored like.
147 con
[0] = value
& 0xff;
150 con
[0] = value
& 0xff;
151 con
[1] = (value
>> 8) & 0xff;
154 con
[0] = (value
>> 16) & 0xff;
155 con
[1] = (value
>> 24) & 0xff;
156 con
[2] = value
& 0xff;
157 con
[3] = (value
>> 8) & 0xff;
164 /* Fix up some data or instructions after we find out the value of a symbol
165 that they reference. */
167 int /* Knows about order of bytes in address. */
168 md_apply_fix (fixP
, value
)
178 buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
179 size
= fixP
->fx_size
;
180 code
= md_chars_to_number (buf
, size
);
182 switch (fixP
->fx_r_type
)
185 case BFD_RELOC_16_PCREL
:
189 case BFD_RELOC_PDP11_DISP_8_PCREL
:
193 case BFD_RELOC_PDP11_DISP_6_PCREL
:
198 BAD_CASE (fixP
->fx_r_type
);
201 if (fixP
->fx_addsy
!= NULL
)
202 *value
+= symbol_get_bfdsym (fixP
->fx_addsy
)->section
->vma
;
203 /* *value += fixP->fx_addsy->bsym->section->vma; */
206 code
|= (*value
>> shift
) & mask
;
207 number_to_chars_littleendian (buf
, code
, size
);
212 md_chars_to_number (con
, nbytes
)
213 unsigned char con
[]; /* Low order byte 1st. */
214 int nbytes
; /* Number of bytes in the input. */
216 /* On a PDP-11, 0x1234 is stored as "\x12\x34", and
217 * 0x12345678 is stored as "\x56\x78\x12\x34". It's
218 * anyones guess what 0x123456 would be stored like.
228 return (con
[1] << BITS_PER_CHAR
) | con
[0];
231 (((con
[1] << BITS_PER_CHAR
) | con
[0]) << (2 * BITS_PER_CHAR
)) |
232 ((con
[3] << BITS_PER_CHAR
) | con
[2]);
240 skip_whitespace (char *str
)
242 while (*str
== ' ' || *str
== '\t')
248 find_whitespace (char *str
)
250 while (*str
!= ' ' && *str
!= '\t' && *str
!= 0)
264 parse_reg (char *str
, struct pdp11_code
*operand
)
266 str
= skip_whitespace (str
);
267 if (mklower (*str
) == 'r')
272 case '0': case '1': case '2': case '3':
273 case '4': case '5': case '6': case '7':
274 operand
->code
= *str
- '0';
278 operand
->error
= "Bad register name";
282 else if (strncmp (str
, "sp", 2) == 0 ||
283 strncmp (str
, "SP", 2) == 0)
288 else if (strncmp (str
, "pc", 2) == 0 ||
289 strncmp (str
, "PC", 2) == 0)
296 operand
->error
= "Bad register name";
304 parse_ac (char *str
, struct pdp11_code
*operand
)
306 str
= skip_whitespace (str
);
307 if (strncmp (str
, "fr", 2) == 0 ||
308 strncmp (str
, "FR", 2) == 0 ||
309 strncmp (str
, "ac", 2) == 0 ||
310 strncmp (str
, "AC", 2) == 0)
315 case '0': case '1': case '2': case '3':
316 operand
->code
= *str
- '0';
320 operand
->error
= "Bad register name";
326 operand
->error
= "Bad register name";
334 parse_expression (char *str
, struct pdp11_code
*operand
)
336 char *save_input_line_pointer
;
339 save_input_line_pointer
= input_line_pointer
;
340 input_line_pointer
= str
;
341 seg
= expression (&operand
->reloc
.exp
);
344 input_line_pointer
= save_input_line_pointer
;
345 operand
->error
= "Error in expression";
349 str
= input_line_pointer
;
350 input_line_pointer
= save_input_line_pointer
;
352 operand
->reloc
.pc_rel
= 0;
354 if (operand
->reloc
.exp
.X_op
== O_constant
)
360 /* FIXME: buffer overflow! */
364 sprintf (buf
, "%ld", operand
->reloc
.exp
.X_add_number
);
365 operand
->reloc
.exp
.X_add_number
= strtol (buf
, &end
, 8);
373 parse_op_no_deferred (char *str
, struct pdp11_code
*operand
)
375 str
= skip_whitespace (str
);
379 case '(': /* (rn) and (rn)+ */
380 str
= parse_reg (str
+ 1, operand
);
383 str
= skip_whitespace (str
);
386 operand
->error
= "Missing ')'";
392 operand
->code
|= 020;
397 operand
->code
|= 010;
401 case '#': /* immediate */
403 str
= parse_expression (str
+ 1, operand
);
406 operand
->additional
= TRUE
;
407 operand
->word
= operand
->reloc
.exp
.X_add_number
;
408 switch (operand
->reloc
.exp
.X_op
)
415 operand
->reloc
.type
= BFD_RELOC_16
;
416 operand
->reloc
.pc_rel
= 0;
419 operand
->error
= "Error in expression";
425 default: /* label, d(rn), -(rn) */
429 if (strncmp (str
, "-(", 2) == 0) /* -(rn) */
431 str
= parse_reg (str
+ 2, operand
);
434 str
= skip_whitespace (str
);
437 operand
->error
= "Missing ')'";
440 operand
->code
|= 040;
445 str
= parse_expression (str
, operand
);
449 str
= skip_whitespace (str
);
451 if (*str
!= '(') /* label */
453 if (operand
->reloc
.exp
.X_op
!= O_symbol
)
455 operand
->error
= "Label expected";
459 operand
->additional
= 1;
461 operand
->reloc
.type
= BFD_RELOC_16_PCREL
;
462 operand
->reloc
.pc_rel
= 1;
467 str
= parse_reg (str
, operand
);
471 str
= skip_whitespace (str
);
475 operand
->error
= "Missing ')'";
480 operand
->additional
= TRUE
;
481 operand
->code
|= 060;
482 switch (operand
->reloc
.exp
.X_op
)
486 operand
->reloc
.pc_rel
= 1;
489 if ((operand
->code
& 7) == 7)
491 operand
->reloc
.pc_rel
= 1;
492 operand
->word
= operand
->reloc
.exp
.X_add_number
;
496 operand
->word
= operand
->reloc
.exp
.X_add_number
;
500 BAD_CASE (operand
->reloc
.exp
.X_op
);
510 parse_op (char *str
, struct pdp11_code
*operand
)
512 str
= skip_whitespace (str
);
514 str
= parse_reg (str
, operand
);
517 operand
->error
= NULL
;
519 if (*str
== '@' || *str
== '*')
521 str
= parse_op_no_deferred (str
+ 1, operand
);
524 operand
->code
|= 010;
527 str
= parse_op_no_deferred (str
, operand
);
533 parse_separator (char *str
, int *error
)
535 str
= skip_whitespace (str
);
536 *error
= (*str
!= ',');
543 md_assemble (instruction_string
)
544 char *instruction_string
;
546 CONST
struct pdp11_opcode
*op
;
547 struct pdp11_code insn
, op1
, op2
;
555 str
= skip_whitespace (instruction_string
);
556 p
= find_whitespace (str
);
559 as_bad ("No instruction found");
565 op
= (struct pdp11_opcode
*)hash_find (insn_hash
, str
);
571 op1
.additional
= FALSE
;
572 op1
.reloc
.type
= BFD_RELOC_NONE
;
575 str
= parse_expression (str
, &op1
);
583 char *to
= frag_more (2);
585 md_number_to_chars (to
, op1
.code
, 2);
586 if (insn
.reloc
.type
!= BFD_RELOC_NONE
)
587 fix_new_exp (frag_now
, to
- frag_now
->fr_literal
, 2,
588 &insn
.reloc
.exp
, insn
.reloc
.pc_rel
, insn
.reloc
.type
);
591 as_warn ("Unknown instruction");
597 if (!pdp11_extension
[op
->extension
])
599 as_warn ("Unsupported instruction set extension: %s", op
->name
);
604 insn
.code
= op
->opcode
;
605 insn
.reloc
.type
= BFD_RELOC_NONE
;
607 op1
.additional
= FALSE
;
608 op1
.reloc
.type
= BFD_RELOC_NONE
;
610 op2
.additional
= FALSE
;
611 op2
.reloc
.type
= BFD_RELOC_NONE
;
618 case PDP11_OPCODE_NO_OPS
:
619 str
= skip_whitespace (str
);
624 case PDP11_OPCODE_IMM3
:
625 case PDP11_OPCODE_IMM6
:
626 case PDP11_OPCODE_IMM8
:
627 str
= skip_whitespace (str
);
628 if (*str
== '#' || *str
== '$')
630 str
= parse_expression (str
, &op1
);
635 case PDP11_OPCODE_IMM3
:
638 op1
.error
= "3-bit immediate out of range";
642 case PDP11_OPCODE_IMM6
:
643 if (op1
.code
& ~0x3f)
645 op1
.error
= "6-bit immediate out of range";
649 case PDP11_OPCODE_IMM8
:
650 if (op1
.code
& ~0xff)
652 op1
.error
= "8-bit immediate out of range";
657 insn
.code
|= op1
.code
;
660 case PDP11_OPCODE_DISPL
:
663 new = parse_expression (str
, &op1
);
665 op1
.reloc
.pc_rel
= 1;
666 op1
.reloc
.type
= BFD_RELOC_PDP11_DISP_8_PCREL
;
667 if (op1
.reloc
.exp
.X_op
!= O_symbol
)
669 op1
.error
= "Symbol expected";
672 if (op1
.code
& ~0xff)
674 err
= "8-bit displacement out of range";
678 insn
.code
|= op1
.code
;
679 insn
.reloc
= op1
.reloc
;
683 case PDP11_OPCODE_REG
:
684 str
= parse_reg (str
, &op1
);
687 insn
.code
|= op1
.code
;
690 case PDP11_OPCODE_OP
:
691 str
= parse_op (str
, &op1
);
694 insn
.code
|= op1
.code
;
699 case PDP11_OPCODE_REG_OP
:
700 str
= parse_reg (str
, &op2
);
703 insn
.code
|= op2
.code
<< 6;
704 str
= parse_separator (str
, &error
);
707 op2
.error
= "Missing ','";
710 str
= parse_op (str
, &op1
);
713 insn
.code
|= op1
.code
;
718 case PDP11_OPCODE_REG_OP_REV
:
719 str
= parse_op (str
, &op1
);
722 insn
.code
|= op1
.code
;
725 str
= parse_separator (str
, &error
);
728 op2
.error
= "Missing ','";
731 str
= parse_reg (str
, &op2
);
734 insn
.code
|= op2
.code
<< 6;
737 case PDP11_OPCODE_AC_OP
:
738 str
= parse_ac (str
, &op2
);
741 insn
.code
|= op2
.code
<< 6;
742 str
= parse_separator (str
, &error
);
745 op1
.error
= "Missing ','";
748 str
= parse_op (str
, &op1
);
751 insn
.code
|= op1
.code
;
756 case PDP11_OPCODE_OP_OP
:
757 str
= parse_op (str
, &op1
);
760 insn
.code
|= op1
.code
<< 6;
763 str
= parse_separator (str
, &error
);
766 op2
.error
= "Missing ','";
769 str
= parse_op (str
, &op2
);
772 insn
.code
|= op2
.code
;
777 case PDP11_OPCODE_REG_DISPL
:
780 str
= parse_reg (str
, &op2
);
783 insn
.code
|= op2
.code
<< 6;
784 str
= parse_separator (str
, &error
);
787 op1
.error
= "Missing ','";
790 new = parse_expression (str
, &op1
);
792 op1
.reloc
.pc_rel
= 1;
793 op1
.reloc
.type
= BFD_RELOC_PDP11_DISP_6_PCREL
;
794 if (op1
.reloc
.exp
.X_op
!= O_symbol
)
796 op1
.error
= "Symbol expected";
799 if (op1
.code
& ~0x3f)
801 err
= "6-bit displacement out of range";
805 insn
.code
|= op1
.code
;
806 insn
.reloc
= op1
.reloc
;
820 str
= skip_whitespace (str
);
822 err
= "Too many operands";
834 to
= frag_more (size
);
836 md_number_to_chars (to
, insn
.code
, 2);
837 if (insn
.reloc
.type
!= BFD_RELOC_NONE
)
838 fix_new_exp (frag_now
, to
- frag_now
->fr_literal
, 2,
839 &insn
.reloc
.exp
, insn
.reloc
.pc_rel
, insn
.reloc
.type
);
844 md_number_to_chars (to
, op1
.word
, 2);
845 if (op1
.reloc
.type
!= BFD_RELOC_NONE
)
846 fix_new_exp (frag_now
, to
- frag_now
->fr_literal
, 2,
847 &op1
.reloc
.exp
, op1
.reloc
.pc_rel
, op1
.reloc
.type
);
853 md_number_to_chars (to
, op2
.word
, 2);
854 if (op2
.reloc
.type
!= BFD_RELOC_NONE
)
855 fix_new_exp (frag_now
, to
- frag_now
->fr_literal
, 2,
856 &op2
.reloc
.exp
, op2
.reloc
.pc_rel
, op2
.reloc
.type
);
862 md_estimate_size_before_relax (fragP
, segment
)
863 fragS
*fragP ATTRIBUTE_UNUSED
;
864 segT segment ATTRIBUTE_UNUSED
;
870 md_convert_frag (headers
, seg
, fragP
)
871 bfd
*headers ATTRIBUTE_UNUSED
;
872 segT seg ATTRIBUTE_UNUSED
;
873 fragS
*fragP ATTRIBUTE_UNUSED
;
877 CONST
int md_short_jump_size
= 2;
878 CONST
int md_long_jump_size
= 4;
881 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
882 char *ptr ATTRIBUTE_UNUSED
;
883 addressT from_addr ATTRIBUTE_UNUSED
;
884 addressT to_addr ATTRIBUTE_UNUSED
;
885 fragS
*frag ATTRIBUTE_UNUSED
;
886 symbolS
*to_symbol ATTRIBUTE_UNUSED
;
891 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
892 char *ptr ATTRIBUTE_UNUSED
;
893 addressT from_addr ATTRIBUTE_UNUSED
;
894 addressT to_addr ATTRIBUTE_UNUSED
;
895 fragS
*frag ATTRIBUTE_UNUSED
;
896 symbolS
*to_symbol ATTRIBUTE_UNUSED
;
906 if (strcmp (arg
, "all-extensions") == 0 ||
907 strcmp (arg
, "all") == 0)
909 memset (pdp11_extension
, ~0, sizeof pdp11_extension
);
910 pdp11_extension
[PDP11_NONE
] = 0;
913 else if (strcmp (arg
, "no-extensions") == 0)
915 memset (pdp11_extension
, 0, sizeof pdp11_extension
);
916 pdp11_extension
[PDP11_BASIC
] = 1;
920 if (strncmp (arg
, "no-", 3) == 0)
926 if (strcmp (arg
, "cis") == 0) /* commersial instructions */
927 pdp11_extension
[PDP11_CIS
] = yes
;
928 else if (strcmp (arg
, "csm") == 0) /* call supervisor mode */
929 pdp11_extension
[PDP11_CSM
] = yes
;
930 else if (strcmp (arg
, "eis") == 0) /* extended instruction set */
931 pdp11_extension
[PDP11_EIS
] = pdp11_extension
[PDP11_LEIS
] = yes
;
932 else if (strcmp (arg
, "fis") == 0 || /* KEV11 floating-point */
933 strcmp (arg
, "kev11") == 0 ||
934 strcmp (arg
, "kev-11") == 0)
935 pdp11_extension
[PDP11_FIS
] = yes
;
936 else if (strcmp (arg
, "fpp") == 0 || /* FP-11 floating-point */
937 strcmp (arg
, "fpu") == 0 ||
938 strcmp (arg
, "fp11") == 0 ||
939 strcmp (arg
, "fp-11") == 0 ||
940 strcmp (arg
, "fpj11") == 0 ||
941 strcmp (arg
, "fp-j11") == 0 ||
942 strcmp (arg
, "fpj-11") == 0)
943 pdp11_extension
[PDP11_FPP
] = yes
;
944 else if (strcmp (arg
, "limited-eis") == 0) /* limited extended insns */
946 pdp11_extension
[PDP11_LEIS
] = yes
;
947 if (!pdp11_extension
[PDP11_LEIS
])
948 pdp11_extension
[PDP11_EIS
] = 0;
950 else if (strcmp (arg
, "mfpt") == 0) /* move from processor type */
951 pdp11_extension
[PDP11_MFPT
] = yes
;
952 else if (strncmp (arg
, "mproc", 5) == 0 || /* multiprocessor insns: */
953 strncmp (arg
, "multiproc", 9) == 0 ) /* TSTSET, WRTLCK */
954 pdp11_extension
[PDP11_MPROC
] = yes
;
955 else if (strcmp (arg
, "mxps") == 0) /* move from/to proc status */
956 pdp11_extension
[PDP11_MXPS
] = yes
;
957 else if (strcmp (arg
, "pic") == 0) /* position-independent code */
958 asm_option
[ASM_OPT_PIC
] = yes
;
959 else if (strcmp (arg
, "spl") == 0) /* set priority level */
960 pdp11_extension
[PDP11_SPL
] = yes
;
961 else if (strcmp (arg
, "ucode") == 0 || /* microcode instructions: */
962 strcmp (arg
, "microcode") == 0) /* LDUB, MED, XFC */
963 pdp11_extension
[PDP11_UCODE
] = yes
;
982 if (strchr ("abdx", model
[-1]) == NULL
)
985 if (model
[-1] == 'd')
991 else if (model
[-1] == 'x')
1000 if (strncmp (arg
, "11", 2) != 0)
1010 /* allow up to two revision letters */
1018 set_option ("no-extensions");
1020 if (strncmp (buf
, "a", 1) == 0) /* KA11 (11/15/20) */
1021 return 1; /* no extensions */
1023 else if (strncmp (buf
, "b", 1) == 0) /* KB11 (11/45/50/55/70) */
1024 return set_option ("eis") &&
1027 else if (strncmp (buf
, "da", 2) == 0) /* KD11-A (11/35/40) */
1028 return set_option ("limited-eis");
1030 else if (strncmp (buf
, "db", 2) == 0 || /* KD11-B (11/05/10) */
1031 strncmp (buf
, "dd", 2) == 0) /* KD11-D (11/04) */
1032 return 1; /* no extensions */
1034 else if (strncmp (buf
, "de", 2) == 0) /* KD11-E (11/34) */
1035 return set_option ("eis") &&
1036 set_option ("mxps");
1038 else if (strncmp (buf
, "df", 2) == 0 || /* KD11-F (11/03) */
1039 strncmp (buf
, "dh", 2) == 0 || /* KD11-H (11/03) */
1040 strncmp (buf
, "dq", 2) == 0) /* KD11-Q (11/03) */
1041 return set_option ("limited-eis") &&
1042 set_option ("mxps");
1044 else if (strncmp (buf
, "dk", 2) == 0) /* KD11-K (11/60) */
1045 return set_option ("eis") &&
1046 set_option ("mxps") &&
1047 set_option ("ucode");
1049 else if (strncmp (buf
, "dz", 2) == 0) /* KD11-Z (11/44) */
1050 return set_option ("csm") &&
1051 set_option ("eis") &&
1052 set_option ("mfpt") &&
1053 set_option ("mxps") &&
1056 else if (strncmp (buf
, "f", 1) == 0) /* F11 (11/23/24) */
1057 return set_option ("eis") &&
1058 set_option ("mfpt") &&
1059 set_option ("mxps");
1061 else if (strncmp (buf
, "j", 1) == 0) /* J11 (11/53/73/83/84/93/94)*/
1062 return set_option ("csm") &&
1063 set_option ("eis") &&
1064 set_option ("mfpt") &&
1065 set_option ("multiproc") &&
1066 set_option ("mxps") &&
1069 else if (strncmp (buf
, "t", 1) == 0) /* T11 (11/21) */
1070 return set_option ("limited-eis") &&
1071 set_option ("mxps");
1078 set_machine_model (arg
)
1081 if (strncmp (arg
, "pdp-11/", 7) != 0 &&
1082 strncmp (arg
, "pdp11/", 6) != 0 &&
1083 strncmp (arg
, "11/", 3) != 0)
1086 if (strncmp (arg
, "pdp", 3) == 0)
1090 if (strncmp (arg
, "11/", 3) == 0)
1093 if (strcmp (arg
, "03") == 0) /* 11/03 */
1094 return set_cpu_model ("kd11f"); /* KD11-F */
1096 else if (strcmp (arg
, "04") == 0) /* 11/04 */
1097 return set_cpu_model ("kd11d"); /* KD11-D */
1099 else if (strcmp (arg
, "05") == 0 || /* 11/05 or 11/10 */
1100 strcmp (arg
, "10") == 0)
1101 return set_cpu_model ("kd11b"); /* KD11-B */
1103 else if (strcmp (arg
, "15") == 0 || /* 11/15 or 11/20 */
1104 strcmp (arg
, "20") == 0)
1105 return set_cpu_model ("ka11"); /* KA11 */
1107 else if (strcmp (arg
, "21") == 0) /* 11/21 */
1108 return set_cpu_model ("t11"); /* T11 */
1110 else if (strcmp (arg
, "23") == 0 || /* 11/23 or 11/24 */
1111 strcmp (arg
, "24") == 0)
1112 return set_cpu_model ("f11"); /* F11 */
1114 else if (strcmp (arg
, "34") == 0 || /* 11/34 or 11/34a */
1115 strcmp (arg
, "34a") == 0)
1116 return set_cpu_model ("kd11e"); /* KD11-E */
1118 else if (strcmp (arg
, "35") == 0 || /* 11/35 or 11/40 */
1119 strcmp (arg
, "40") == 0)
1120 return set_cpu_model ("kd11da"); /* KD11-A */
1122 else if (strcmp (arg
, "44") == 0) /* 11/44 */
1123 return set_cpu_model ("kd11dz"); /* KD11-Z */
1125 else if (strcmp (arg
, "45") == 0 || /* 11/45/50/55/70 */
1126 strcmp (arg
, "50") == 0 ||
1127 strcmp (arg
, "55") == 0 ||
1128 strcmp (arg
, "70") == 0)
1129 return set_cpu_model ("kb11"); /* KB11 */
1131 else if (strcmp (arg
, "60") == 0) /* 11/60 */
1132 return set_cpu_model ("kd11k"); /* KD11-K */ /* FPP? */
1134 else if (strcmp (arg
, "53") == 0 || /* 11/53/73/83/84/93/94 */
1135 strcmp (arg
, "73") == 0 ||
1136 strcmp (arg
, "83") == 0 ||
1137 strcmp (arg
, "84") == 0 ||
1138 strcmp (arg
, "93") == 0 ||
1139 strcmp (arg
, "94") == 0)
1140 return set_cpu_model ("j11") && /* J11 */
1141 set_option ("fpp"); /* All J11 machines come */
1142 /* with FPP installed. */
1147 CONST
char *md_shortopts
= "m:";
1149 struct option md_longopts
[] =
1151 #define OPTION_CPU 257
1152 { "cpu", required_argument
, NULL
, OPTION_CPU
},
1153 #define OPTION_MACHINE 258
1154 { "machine", required_argument
, NULL
, OPTION_MACHINE
},
1155 #define OPTION_PIC 259
1156 { "pic", no_argument
, NULL
, OPTION_PIC
},
1157 { NULL
, no_argument
, NULL
, 0 }
1160 size_t md_longopts_size
= sizeof(md_longopts
);
1164 * Invocation line includes a switch not recognized by the base assembler.
1165 * See if it's a processor-specific option.
1169 md_parse_option (c
, arg
)
1178 if (set_option (arg
))
1180 if (set_cpu_model (arg
))
1182 if (set_machine_model (arg
))
1187 if (set_cpu_model (arg
))
1191 case OPTION_MACHINE
:
1192 if (set_machine_model (arg
))
1197 if (set_option ("pic"))
1205 as_bad ("unrecognized option `-%c%s'", c
, arg
? arg
: "");
1211 One possible way of parsing options.
1222 CONST char *pattern;
1224 CONST char *description;
1227 static struct options extension_opts[] =
1229 { "Ncsm", OPTION_CSM,
1230 "allow (disallow) CSM instruction" },
1231 { "Ncis", OPTION_CIS,
1232 "allow (disallow) commersial instruction set" },
1233 { "Neis", OPTION_EIS,
1234 "allow (disallow) extended instruction set" },
1236 { "all-extensions", OPTION_ALL_EXTENSIONS,
1237 "allow all instruction set extensions\n\
1238 (this is the default)" },
1239 { "no-extensions", OPTION_NO_EXTENSIONS,
1240 "disallow all instruction set extensions" },
1241 { "pic", OPTION_PIC,
1242 "position-independent code" },
1245 static struct options cpu_opts[] =
1247 { "Ka_11_*", OPTION_KA11, "KA11 CPU. ..." },
1248 { "Kb_11_*", OPTION_KB11, "KB11 CPU. ..." },
1249 { "Kd_11_a*", OPTION_KD11A, "KD11-A CPU. ..." },
1250 { "Kd_11_b*", OPTION_KD11B, "KD11-B CPU. ..." },
1251 { "Kd_11_d*", OPTION_KD11D, "KD11-D CPU. ..." },
1252 { "Kd_11_e*", OPTION_KD11E, "KD11-E CPU. ..." },
1253 { "Kd_11_f*", OPTION_KD11F, "KD11-F CPU. ..." },
1254 { "Kd_11_h*", OPTION_KD11H, "KD11-H CPU. ..." },
1255 { "Kd_11_q*", OPTION_KD11Q, "KD11-Q CPU. ..." },
1256 { "Kd_11_z*", OPTION_KD11Z, "KD11-Z CPU. ..." },
1257 { "Df_11_*", OPTION_F11, "F11 CPU. ..." },
1258 { "Dj_11_*", OPTION_J11, "J11 CPU. ..." },
1259 { "Dt_11_*", OPTION_T11, "T11 CPU. ..." },
1262 static struct options model_opts[] =
1264 { "P03", OPTION_PDP11_03, "same as ..." },
1265 { "P04", OPTION_PDP11_04, "same as ..." },
1266 { "P05", OPTION_PDP11_05, "same as ..." },
1267 { "P10", OPTION_PDP11_10, "same as ..." },
1268 { "P15", OPTION_PDP11_15, "same as ..." },
1269 { "P20", OPTION_PDP11_20, "same as ..." },
1270 { "P21", OPTION_PDP11_21, "same as ..." },
1271 { "P24", OPTION_PDP11_24, "same as ..." },
1272 { "P34", OPTION_PDP11_34, "same as ..." },
1273 { "P34a", OPTION_PDP11_34A, "same as ..." },
1274 { "P40", OPTION_PDP11_40, "same as ..." },
1275 { "P44", OPTION_PDP11_44, "same as ..." },
1276 { "P45", OPTION_PDP11_45, "same as ..." },
1277 { "P50", OPTION_PDP11_50, "same as ..." },
1278 { "P53", OPTION_PDP11_53, "same as ..." },
1279 { "P55", OPTION_PDP11_55, "same as ..." },
1280 { "P60", OPTION_PDP11_60, "same as ..." },
1281 { "P70", OPTION_PDP11_70, "same as ..." },
1282 { "P73", OPTION_PDP11_73, "same as ..." },
1283 { "P83", OPTION_PDP11_83, "same as ..." },
1284 { "P84", OPTION_PDP11_84, "same as ..." },
1285 { "P93", OPTION_PDP11_93, "same as ..." },
1286 { "P94", OPTION_PDP11_94, "same as ..." },
1292 struct options *opts;
1296 { "PDP-11 instruction set extentions",
1298 sizeof extension_opts / sizeof extension_opts[0] },
1299 { "PDP-11 CPU model options",
1301 sizeof cpu_opts / sizeof cpu_opts[0] },
1302 { "PDP-11 machine model options",
1304 sizeof model_opts / sizeof model_opts[0] },
1308 parse_match (char *arg, char *pattern)
1317 if (strncmp (arg, "no-") == 0)
1330 if (strncmp (arg, "kd", 2) == 0)
1335 if (strncmp (arg, "pdp-11/", 7) == 0)
1337 else if (strncmp (arg, "pdp11/", 6) == 0)
1339 else if (strncmp (arg, "11/", 3) == 0)
1355 if (*arg++ != pattern[-1])
1364 fprint_opt (stream, pattern)
1366 CONST char *pattern;
1375 n += fprintf (stream, "(no-)");
1379 n += fprintf (stream, "k");
1383 n += fprintf (stream "11/");
1392 fputc (pattern[-1], stream);
1401 parse_option (char *arg)
1405 for (i = 0; i < sizeof all_opts / sizeof all_opts[0]; i++)
1407 for (j = 0; j < all_opts[i].num; j++)
1409 if (parse_match (arg, all_opts[i].opts[j].pattern))
1411 set_option (all_opts[i].opts[j].opt);
1421 fprint_space (stream, n)
1426 fputc (' ', stream);
1430 md_show_usage (stream)
1435 for (i = 0; i < sizeof all_opts / sizeof all_opts[0]; i++)
1437 fprintf (stream "\n%s:\n\n", all_opts[i].title);
1439 for (j = 0; j < all_opts[i].num; j++)
1441 fprintf (stream, "-m");
1442 n = fprintf_opt (stream, all_opts[i].opts[j].pattern);
1443 fprint_space (stream, 22 - n);
1444 fprintf (stream, "%s\n", all_opts[i].opts[j].description);
1451 md_show_usage (stream
)
1456 PDP-11 instruction set extentions:\n\
1458 -m(no-)cis allow (disallow) commersial instruction set\n\
1459 -m(no-)csm allow (disallow) CSM instruction\n\
1460 -m(no-)eis allow (disallow) full extended instruction set\n\
1461 -m(no-)fis allow (disallow) KEV11 floating-point instructions\n\
1462 -m(no-)fpp allow (disallow) FP-11 floating-point instructions\n\
1463 -m(no-)fpu allow (disallow) FP-11 floating-point instructions\n\
1464 -m(no-)limited-eis allow (disallow) limited extended instruction set\n\
1465 -m(no-)mfpt allow (disallow) processor type instruction\n\
1466 -m(no-)multiproc allow (disallow) multiprocessor instructions\n\
1467 -m(no-)mxps allow (disallow) processor status instructions\n\
1468 -m(no-)spl allow (disallow) SPL instruction\n\
1469 -m(no-)ucode allow (disallow) microcode instructions\n\
1470 -mall-extensions allow all instruction set extensions\n\
1471 (this is the default)\n\
1472 -mno-extentions disallow all instruction set extensions\n\
1473 -pic generate position-indepenent code\n\
1475 PDP-11 CPU model options:\n\
1477 -mka11* KA11 CPU. base line instruction set only\n\
1478 -mkb11* KB11 CPU. enable full EIS and SPL\n\
1479 -mkd11a* KD11-A CPU. enable limited EIS\n\
1480 -mkd11b* KD11-B CPU. base line instruction set only\n\
1481 -mkd11d* KD11-D CPU. base line instruction set only\n\
1482 -mkd11e* KD11-E CPU. enable full EIS, MTPS, and MFPS\n\
1483 -mkd11f* KD11-F CPU. enable limited EIS, MTPS, and MFPS\n\
1484 -mkd11h* KD11-H CPU. enable limited EIS, MTPS, and MFPS\n\
1485 -mkd11q* KD11-Q CPU. enable limited EIS, MTPS, and MFPS\n\
1486 -mkd11k* KD11-K CPU. enable full EIS, MTPS, MFPS, LDUB, MED,\n\
1488 -mkd11z* KD11-Z CPU. enable full EIS, MTPS, MFPS, MFPT, SPL,\n\
1490 -mf11* F11 CPU. enable full EIS, MFPS, MTPS, and MFPT\n\
1491 -mj11* J11 CPU. enable full EIS, MTPS, MFPS, MFPT, SPL,\n\
1492 CSM, TSTSET, and WRTLCK\n\
1493 -mt11* T11 CPU. enable limited EIS, MTPS, and MFPS\n\
1495 PDP-11 machine model options:\n\
1497 -m11/03 same as -mkd11f\n\
1498 -m11/04 same as -mkd11d\n\
1499 -m11/05 same as -mkd11b\n\
1500 -m11/10 same as -mkd11b\n\
1501 -m11/15 same as -mka11\n\
1502 -m11/20 same as -mka11\n\
1503 -m11/21 same as -mt11\n\
1504 -m11/23 same as -mf11\n\
1505 -m11/24 same as -mf11\n\
1506 -m11/34 same as -mkd11e\n\
1507 -m11/34a same as -mkd11e -mfpp\n\
1508 -m11/35 same as -mkd11a\n\
1509 -m11/40 same as -mkd11a\n\
1510 -m11/44 same as -mkd11z\n\
1511 -m11/45 same as -mkb11\n\
1512 -m11/50 same as -mkb11\n\
1513 -m11/53 same as -mj11\n\
1514 -m11/55 same as -mkb11\n\
1515 -m11/60 same as -mkd11k\n\
1516 -m11/70 same as -mkb11\n\
1517 -m11/73 same as -mj11\n\
1518 -m11/83 same as -mj11\n\
1519 -m11/84 same as -mj11\n\
1520 -m11/93 same as -mj11\n\
1521 -m11/94 same as -mj11\n\
1526 md_undefined_symbol (name
)
1527 char *name ATTRIBUTE_UNUSED
;
1533 md_section_align (segment
, size
)
1534 segT segment ATTRIBUTE_UNUSED
;
1537 return (size
+ 1) & ~1;
1541 md_pcrel_from (fixP
)
1544 return fixP
->fx_frag
->fr_address
+ fixP
->fx_where
+ fixP
->fx_size
;
1547 /* Translate internal representation of relocation info to BFD target
1550 tc_gen_reloc (section
, fixp
)
1551 asection
*section ATTRIBUTE_UNUSED
;
1555 bfd_reloc_code_real_type code
;
1557 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
1559 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
1560 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
1561 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
1563 /* this is taken account for in md_apply_fix() */
1564 reloc
->addend
= -symbol_get_bfdsym (fixp
->fx_addsy
)->section
->vma
;
1566 switch (fixp
->fx_r_type
)
1570 code
= BFD_RELOC_16_PCREL
;
1572 code
= BFD_RELOC_16
;
1575 case BFD_RELOC_16_PCREL
:
1576 code
= BFD_RELOC_16_PCREL
;
1580 BAD_CASE (fixp
->fx_r_type
);
1584 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
1586 if (reloc
->howto
== NULL
)
1588 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1589 "Can not represent %s relocation in this object file format",
1590 bfd_get_reloc_code_name (code
));
1599 int c ATTRIBUTE_UNUSED
;
1603 temp
= get_absolute_expression ();
1604 subseg_set (bss_section
, temp
);
1605 demand_empty_rest_of_line ();
1610 int c ATTRIBUTE_UNUSED
;
1612 int alignment
= 1; /* 2^1 */
1613 frag_align (alignment
, 0, 1);
1614 record_alignment (now_seg
, alignment
);
1617 /* end of tc-pdp11.c */