1 /* tc-pdp11.c - pdp11-specific -
2 Copyright 2001, 2002, 2004, 2005 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 "safe-ctype.h"
30 #include "opcode/pdp11.h"
32 static int set_option
PARAMS ((char *arg
));
33 static int set_cpu_model
PARAMS ((char *arg
));
34 static int set_machine_model
PARAMS ((char *arg
));
36 extern int flonum_gen2vax
PARAMS ((char format_letter
, FLONUM_TYPE
* f
,
37 LITTLENUM_TYPE
* words
));
43 * A representation for PDP-11 machine code.
49 int additional
; /* is there an additional word? */
50 int word
; /* additional word, if any */
53 bfd_reloc_code_real_type type
;
60 * Instruction set extensions.
62 * If you change this from an array to something else, please update
63 * the "PDP-11 instruction set extensions" comment in pdp11.h.
65 int pdp11_extension
[PDP11_EXT_NUM
];
74 int asm_option
[ASM_OPT_NUM
];
76 /* These chars start a comment anywhere in a source file (except inside
78 const char comment_chars
[] = "#/";
80 /* These chars only start a comment at the beginning of a line. */
81 const char line_comment_chars
[] = "#/";
83 const char line_separator_chars
[] = ";";
85 /* Chars that can be used to separate mant from exp in floating point nums */
86 const char EXP_CHARS
[] = "eE";
88 /* Chars that mean this number is a floating point constant */
90 /* or 0H1.234E-12 (see exp chars above) */
91 const char FLT_CHARS
[] = "dDfF";
93 void pseudo_even (int);
94 void pseudo_bss (int);
96 const pseudo_typeS md_pseudo_table
[] =
98 { "bss", pseudo_bss
, 0 },
99 { "even", pseudo_even
, 0 },
106 static int first
= 1;
110 set_option ("all-extensions");
116 static struct hash_control
*insn_hash
= NULL
;
125 insn_hash
= hash_new ();
126 if (insn_hash
== NULL
)
127 as_fatal ("Virtual memory exhausted");
129 for (i
= 0; i
< pdp11_num_opcodes
; i
++)
130 hash_insert (insn_hash
, pdp11_opcodes
[i
].name
, (PTR
)(pdp11_opcodes
+ i
));
131 for (i
= 0; i
< pdp11_num_aliases
; i
++)
132 hash_insert (insn_hash
, pdp11_aliases
[i
].name
, (PTR
)(pdp11_aliases
+ i
));
136 md_number_to_chars (con
, value
, nbytes
)
141 /* On a PDP-11, 0x1234 is stored as "\x12\x34", and
142 * 0x12345678 is stored as "\x56\x78\x12\x34". It's
143 * anyones guess what 0x123456 would be stored like.
151 con
[0] = value
& 0xff;
154 con
[0] = value
& 0xff;
155 con
[1] = (value
>> 8) & 0xff;
158 con
[0] = (value
>> 16) & 0xff;
159 con
[1] = (value
>> 24) & 0xff;
160 con
[2] = value
& 0xff;
161 con
[3] = (value
>> 8) & 0xff;
168 /* Fix up some data or instructions after we find out the value of a symbol
169 that they reference. Knows about order of bytes in address. */
172 md_apply_fix3 (fixP
, valP
, seg
)
175 segT seg ATTRIBUTE_UNUSED
;
184 buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
185 size
= fixP
->fx_size
;
186 code
= md_chars_to_number (buf
, size
);
188 switch (fixP
->fx_r_type
)
191 case BFD_RELOC_16_PCREL
:
195 case BFD_RELOC_PDP11_DISP_8_PCREL
:
199 case BFD_RELOC_PDP11_DISP_6_PCREL
:
205 BAD_CASE (fixP
->fx_r_type
);
208 if (fixP
->fx_addsy
!= NULL
)
209 val
+= symbol_get_bfdsym (fixP
->fx_addsy
)->section
->vma
;
210 /* *value += fixP->fx_addsy->bsym->section->vma; */
213 code
|= (val
>> shift
) & mask
;
214 number_to_chars_littleendian (buf
, code
, size
);
216 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_pcrel
== 0)
221 md_chars_to_number (con
, nbytes
)
222 unsigned char con
[]; /* Low order byte 1st. */
223 int nbytes
; /* Number of bytes in the input. */
225 /* On a PDP-11, 0x1234 is stored as "\x12\x34", and
226 * 0x12345678 is stored as "\x56\x78\x12\x34". It's
227 * anyones guess what 0x123456 would be stored like.
237 return (con
[1] << BITS_PER_CHAR
) | con
[0];
240 (((con
[1] << BITS_PER_CHAR
) | con
[0]) << (2 * BITS_PER_CHAR
)) |
241 ((con
[3] << BITS_PER_CHAR
) | con
[2]);
249 skip_whitespace (char *str
)
251 while (*str
== ' ' || *str
== '\t')
257 find_whitespace (char *str
)
259 while (*str
!= ' ' && *str
!= '\t' && *str
!= 0)
265 parse_reg (char *str
, struct pdp11_code
*operand
)
267 str
= skip_whitespace (str
);
268 if (TOLOWER (*str
) == 'r')
273 case '0': case '1': case '2': case '3':
274 case '4': case '5': case '6': case '7':
275 operand
->code
= *str
- '0';
279 operand
->error
= "Bad register name";
283 else if (strncmp (str
, "sp", 2) == 0 ||
284 strncmp (str
, "SP", 2) == 0)
289 else if (strncmp (str
, "pc", 2) == 0 ||
290 strncmp (str
, "PC", 2) == 0)
297 operand
->error
= "Bad register name";
305 parse_ac5 (char *str
, struct pdp11_code
*operand
)
307 str
= skip_whitespace (str
);
308 if (strncmp (str
, "fr", 2) == 0 ||
309 strncmp (str
, "FR", 2) == 0 ||
310 strncmp (str
, "ac", 2) == 0 ||
311 strncmp (str
, "AC", 2) == 0)
316 case '0': case '1': case '2': case '3':
318 operand
->code
= *str
- '0';
322 operand
->error
= "Bad register name";
328 operand
->error
= "Bad register name";
336 parse_ac (char *str
, struct pdp11_code
*operand
)
338 str
= parse_ac5 (str
, operand
);
339 if (!operand
->error
&& operand
->code
> 3)
341 operand
->error
= "Bad register name";
349 parse_expression (char *str
, struct pdp11_code
*operand
)
351 char *save_input_line_pointer
;
354 save_input_line_pointer
= input_line_pointer
;
355 input_line_pointer
= str
;
356 seg
= expression (&operand
->reloc
.exp
);
359 input_line_pointer
= save_input_line_pointer
;
360 operand
->error
= "Error in expression";
364 str
= input_line_pointer
;
365 input_line_pointer
= save_input_line_pointer
;
367 operand
->reloc
.pc_rel
= 0;
373 parse_op_no_deferred (char *str
, struct pdp11_code
*operand
)
375 LITTLENUM_TYPE literal_float
[2];
377 str
= skip_whitespace (str
);
381 case '(': /* (rn) and (rn)+ */
382 str
= parse_reg (str
+ 1, operand
);
385 str
= skip_whitespace (str
);
388 operand
->error
= "Missing ')'";
394 operand
->code
|= 020;
399 operand
->code
|= 010;
403 case '#': /* immediate */
405 str
= parse_expression (str
+ 1, operand
);
408 operand
->additional
= TRUE
;
409 operand
->word
= operand
->reloc
.exp
.X_add_number
;
410 switch (operand
->reloc
.exp
.X_op
)
417 operand
->reloc
.type
= BFD_RELOC_16
;
418 operand
->reloc
.pc_rel
= 0;
421 if (operand
->reloc
.exp
.X_add_number
> 0)
423 operand
->error
= "Error in expression";
426 /* it's a floating literal... */
427 know (operand
->reloc
.exp
.X_add_number
< 0);
428 flonum_gen2vax ('f', &generic_floating_point_number
, literal_float
);
429 operand
->word
= literal_float
[0];
430 if (literal_float
[1] != 0)
431 as_warn (_("Low order bits truncated in immediate float operand"));
434 operand
->error
= "Error in expression";
440 default: /* label, d(rn), -(rn) */
444 if (strncmp (str
, "-(", 2) == 0) /* -(rn) */
446 str
= parse_reg (str
+ 2, operand
);
449 str
= skip_whitespace (str
);
452 operand
->error
= "Missing ')'";
455 operand
->code
|= 040;
460 str
= parse_expression (str
, operand
);
464 str
= skip_whitespace (str
);
466 if (*str
!= '(') /* label */
468 if (operand
->reloc
.exp
.X_op
!= O_symbol
)
470 operand
->error
= "Label expected";
474 operand
->additional
= 1;
476 operand
->reloc
.type
= BFD_RELOC_16_PCREL
;
477 operand
->reloc
.pc_rel
= 1;
482 str
= parse_reg (str
, operand
);
486 str
= skip_whitespace (str
);
490 operand
->error
= "Missing ')'";
495 operand
->additional
= TRUE
;
496 operand
->code
|= 060;
497 switch (operand
->reloc
.exp
.X_op
)
501 operand
->reloc
.pc_rel
= 1;
504 if ((operand
->code
& 7) == 7)
506 operand
->reloc
.pc_rel
= 1;
507 operand
->word
= operand
->reloc
.exp
.X_add_number
;
511 operand
->word
= operand
->reloc
.exp
.X_add_number
;
515 BAD_CASE (operand
->reloc
.exp
.X_op
);
525 parse_op_noreg (char *str
, struct pdp11_code
*operand
)
527 str
= skip_whitespace (str
);
528 operand
->error
= NULL
;
530 if (*str
== '@' || *str
== '*')
532 str
= parse_op_no_deferred (str
+ 1, operand
);
535 operand
->code
|= 010;
538 str
= parse_op_no_deferred (str
, operand
);
544 parse_op (char *str
, struct pdp11_code
*operand
)
546 str
= skip_whitespace (str
);
548 str
= parse_reg (str
, operand
);
552 operand
->error
= NULL
;
553 parse_ac5 (str
, operand
);
556 operand
->error
= "Float AC not legal as integer operand";
560 return parse_op_noreg (str
, operand
);
564 parse_fop (char *str
, struct pdp11_code
*operand
)
566 str
= skip_whitespace (str
);
568 str
= parse_ac5 (str
, operand
);
572 operand
->error
= NULL
;
573 parse_reg (str
, operand
);
576 operand
->error
= "General register not legal as float operand";
580 return parse_op_noreg (str
, operand
);
584 parse_separator (char *str
, int *error
)
586 str
= skip_whitespace (str
);
587 *error
= (*str
!= ',');
594 md_assemble (instruction_string
)
595 char *instruction_string
;
597 const struct pdp11_opcode
*op
;
598 struct pdp11_code insn
, op1
, op2
;
606 str
= skip_whitespace (instruction_string
);
607 p
= find_whitespace (str
);
610 as_bad ("No instruction found");
616 op
= (struct pdp11_opcode
*)hash_find (insn_hash
, str
);
620 as_bad (_("Unknown instruction '%s'"), str
);
624 if (!pdp11_extension
[op
->extension
])
626 as_warn ("Unsupported instruction set extension: %s", op
->name
);
631 insn
.code
= op
->opcode
;
632 insn
.reloc
.type
= BFD_RELOC_NONE
;
634 op1
.additional
= FALSE
;
635 op1
.reloc
.type
= BFD_RELOC_NONE
;
637 op2
.additional
= FALSE
;
638 op2
.reloc
.type
= BFD_RELOC_NONE
;
645 case PDP11_OPCODE_NO_OPS
:
646 str
= skip_whitespace (str
);
651 case PDP11_OPCODE_IMM3
:
652 case PDP11_OPCODE_IMM6
:
653 case PDP11_OPCODE_IMM8
:
654 str
= skip_whitespace (str
);
655 if (*str
== '#' || *str
== '$')
657 str
= parse_expression (str
, &op1
);
660 if (op1
.reloc
.exp
.X_op
!= O_constant
|| op1
.reloc
.type
!= BFD_RELOC_NONE
)
662 op1
.error
= "operand is not an absolute constant";
667 case PDP11_OPCODE_IMM3
:
668 if (op1
.reloc
.exp
.X_add_number
& ~7)
670 op1
.error
= "3-bit immediate out of range";
674 case PDP11_OPCODE_IMM6
:
675 if (op1
.reloc
.exp
.X_add_number
& ~0x3f)
677 op1
.error
= "6-bit immediate out of range";
681 case PDP11_OPCODE_IMM8
:
682 if (op1
.reloc
.exp
.X_add_number
& ~0xff)
684 op1
.error
= "8-bit immediate out of range";
689 insn
.code
|= op1
.reloc
.exp
.X_add_number
;
692 case PDP11_OPCODE_DISPL
:
695 new = parse_expression (str
, &op1
);
697 op1
.reloc
.pc_rel
= 1;
698 op1
.reloc
.type
= BFD_RELOC_PDP11_DISP_8_PCREL
;
699 if (op1
.reloc
.exp
.X_op
!= O_symbol
)
701 op1
.error
= "Symbol expected";
704 if (op1
.code
& ~0xff)
706 err
= "8-bit displacement out of range";
710 insn
.code
|= op1
.code
;
711 insn
.reloc
= op1
.reloc
;
715 case PDP11_OPCODE_REG
:
716 str
= parse_reg (str
, &op1
);
719 insn
.code
|= op1
.code
;
722 case PDP11_OPCODE_OP
:
723 str
= parse_op (str
, &op1
);
726 insn
.code
|= op1
.code
;
731 case PDP11_OPCODE_FOP
:
732 str
= parse_fop (str
, &op1
);
735 insn
.code
|= op1
.code
;
740 case PDP11_OPCODE_REG_OP
:
741 str
= parse_reg (str
, &op2
);
744 insn
.code
|= op2
.code
<< 6;
745 str
= parse_separator (str
, &error
);
748 op2
.error
= "Missing ','";
751 str
= parse_op (str
, &op1
);
754 insn
.code
|= op1
.code
;
759 case PDP11_OPCODE_REG_OP_REV
:
760 str
= parse_op (str
, &op1
);
763 insn
.code
|= op1
.code
;
766 str
= parse_separator (str
, &error
);
769 op2
.error
= "Missing ','";
772 str
= parse_reg (str
, &op2
);
775 insn
.code
|= op2
.code
<< 6;
778 case PDP11_OPCODE_AC_FOP
:
779 str
= parse_ac (str
, &op2
);
782 insn
.code
|= op2
.code
<< 6;
783 str
= parse_separator (str
, &error
);
786 op1
.error
= "Missing ','";
789 str
= parse_fop (str
, &op1
);
792 insn
.code
|= op1
.code
;
797 case PDP11_OPCODE_FOP_AC
:
798 str
= parse_fop (str
, &op1
);
801 insn
.code
|= op1
.code
;
804 str
= parse_separator (str
, &error
);
807 op1
.error
= "Missing ','";
810 str
= parse_ac (str
, &op2
);
813 insn
.code
|= op2
.code
<< 6;
816 case PDP11_OPCODE_AC_OP
:
817 str
= parse_ac (str
, &op2
);
820 insn
.code
|= op2
.code
<< 6;
821 str
= parse_separator (str
, &error
);
824 op1
.error
= "Missing ','";
827 str
= parse_op (str
, &op1
);
830 insn
.code
|= op1
.code
;
835 case PDP11_OPCODE_OP_AC
:
836 str
= parse_op (str
, &op1
);
839 insn
.code
|= op1
.code
;
842 str
= parse_separator (str
, &error
);
845 op1
.error
= "Missing ','";
848 str
= parse_ac (str
, &op2
);
851 insn
.code
|= op2
.code
<< 6;
854 case PDP11_OPCODE_OP_OP
:
855 str
= parse_op (str
, &op1
);
858 insn
.code
|= op1
.code
<< 6;
861 str
= parse_separator (str
, &error
);
864 op2
.error
= "Missing ','";
867 str
= parse_op (str
, &op2
);
870 insn
.code
|= op2
.code
;
875 case PDP11_OPCODE_REG_DISPL
:
878 str
= parse_reg (str
, &op2
);
881 insn
.code
|= op2
.code
<< 6;
882 str
= parse_separator (str
, &error
);
885 op1
.error
= "Missing ','";
888 new = parse_expression (str
, &op1
);
890 op1
.reloc
.pc_rel
= 1;
891 op1
.reloc
.type
= BFD_RELOC_PDP11_DISP_6_PCREL
;
892 if (op1
.reloc
.exp
.X_op
!= O_symbol
)
894 op1
.error
= "Symbol expected";
897 if (op1
.code
& ~0x3f)
899 err
= "6-bit displacement out of range";
903 insn
.code
|= op1
.code
;
904 insn
.reloc
= op1
.reloc
;
918 str
= skip_whitespace (str
);
920 err
= "Too many operands";
932 to
= frag_more (size
);
934 md_number_to_chars (to
, insn
.code
, 2);
935 if (insn
.reloc
.type
!= BFD_RELOC_NONE
)
936 fix_new_exp (frag_now
, to
- frag_now
->fr_literal
, 2,
937 &insn
.reloc
.exp
, insn
.reloc
.pc_rel
, insn
.reloc
.type
);
942 md_number_to_chars (to
, op1
.word
, 2);
943 if (op1
.reloc
.type
!= BFD_RELOC_NONE
)
944 fix_new_exp (frag_now
, to
- frag_now
->fr_literal
, 2,
945 &op1
.reloc
.exp
, op1
.reloc
.pc_rel
, op1
.reloc
.type
);
951 md_number_to_chars (to
, op2
.word
, 2);
952 if (op2
.reloc
.type
!= BFD_RELOC_NONE
)
953 fix_new_exp (frag_now
, to
- frag_now
->fr_literal
, 2,
954 &op2
.reloc
.exp
, op2
.reloc
.pc_rel
, op2
.reloc
.type
);
960 md_estimate_size_before_relax (fragP
, segment
)
961 fragS
*fragP ATTRIBUTE_UNUSED
;
962 segT segment ATTRIBUTE_UNUSED
;
968 md_convert_frag (headers
, seg
, fragP
)
969 bfd
*headers ATTRIBUTE_UNUSED
;
970 segT seg ATTRIBUTE_UNUSED
;
971 fragS
*fragP ATTRIBUTE_UNUSED
;
975 int md_short_jump_size
= 2;
976 int md_long_jump_size
= 4;
979 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
980 char *ptr ATTRIBUTE_UNUSED
;
981 addressT from_addr ATTRIBUTE_UNUSED
;
982 addressT to_addr ATTRIBUTE_UNUSED
;
983 fragS
*frag ATTRIBUTE_UNUSED
;
984 symbolS
*to_symbol ATTRIBUTE_UNUSED
;
989 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
990 char *ptr ATTRIBUTE_UNUSED
;
991 addressT from_addr ATTRIBUTE_UNUSED
;
992 addressT to_addr ATTRIBUTE_UNUSED
;
993 fragS
*frag ATTRIBUTE_UNUSED
;
994 symbolS
*to_symbol ATTRIBUTE_UNUSED
;
1004 if (strcmp (arg
, "all-extensions") == 0 ||
1005 strcmp (arg
, "all") == 0)
1007 memset (pdp11_extension
, ~0, sizeof pdp11_extension
);
1008 pdp11_extension
[PDP11_NONE
] = 0;
1011 else if (strcmp (arg
, "no-extensions") == 0)
1013 memset (pdp11_extension
, 0, sizeof pdp11_extension
);
1014 pdp11_extension
[PDP11_BASIC
] = 1;
1018 if (strncmp (arg
, "no-", 3) == 0)
1024 if (strcmp (arg
, "cis") == 0) /* commersial instructions */
1025 pdp11_extension
[PDP11_CIS
] = yes
;
1026 else if (strcmp (arg
, "csm") == 0) /* call supervisor mode */
1027 pdp11_extension
[PDP11_CSM
] = yes
;
1028 else if (strcmp (arg
, "eis") == 0) /* extended instruction set */
1029 pdp11_extension
[PDP11_EIS
] = pdp11_extension
[PDP11_LEIS
] = yes
;
1030 else if (strcmp (arg
, "fis") == 0 || /* KEV11 floating-point */
1031 strcmp (arg
, "kev11") == 0 ||
1032 strcmp (arg
, "kev-11") == 0)
1033 pdp11_extension
[PDP11_FIS
] = yes
;
1034 else if (strcmp (arg
, "fpp") == 0 || /* FP-11 floating-point */
1035 strcmp (arg
, "fpu") == 0 ||
1036 strcmp (arg
, "fp11") == 0 ||
1037 strcmp (arg
, "fp-11") == 0 ||
1038 strcmp (arg
, "fpj11") == 0 ||
1039 strcmp (arg
, "fp-j11") == 0 ||
1040 strcmp (arg
, "fpj-11") == 0)
1041 pdp11_extension
[PDP11_FPP
] = yes
;
1042 else if (strcmp (arg
, "limited-eis") == 0) /* limited extended insns */
1044 pdp11_extension
[PDP11_LEIS
] = yes
;
1045 if (!pdp11_extension
[PDP11_LEIS
])
1046 pdp11_extension
[PDP11_EIS
] = 0;
1048 else if (strcmp (arg
, "mfpt") == 0) /* move from processor type */
1049 pdp11_extension
[PDP11_MFPT
] = yes
;
1050 else if (strncmp (arg
, "mproc", 5) == 0 || /* multiprocessor insns: */
1051 strncmp (arg
, "multiproc", 9) == 0 ) /* TSTSET, WRTLCK */
1052 pdp11_extension
[PDP11_MPROC
] = yes
;
1053 else if (strcmp (arg
, "mxps") == 0) /* move from/to proc status */
1054 pdp11_extension
[PDP11_MXPS
] = yes
;
1055 else if (strcmp (arg
, "pic") == 0) /* position-independent code */
1056 asm_option
[ASM_OPT_PIC
] = yes
;
1057 else if (strcmp (arg
, "spl") == 0) /* set priority level */
1058 pdp11_extension
[PDP11_SPL
] = yes
;
1059 else if (strcmp (arg
, "ucode") == 0 || /* microcode instructions: */
1060 strcmp (arg
, "microcode") == 0) /* LDUB, MED, XFC */
1061 pdp11_extension
[PDP11_UCODE
] = yes
;
1080 if (strchr ("abdx", model
[-1]) == NULL
)
1083 if (model
[-1] == 'd')
1085 if (arg
[0] == 'f' ||
1089 else if (model
[-1] == 'x')
1098 if (strncmp (arg
, "11", 2) != 0)
1108 /* allow up to two revision letters */
1116 set_option ("no-extensions");
1118 if (strncmp (buf
, "a", 1) == 0) /* KA11 (11/15/20) */
1119 return 1; /* no extensions */
1121 else if (strncmp (buf
, "b", 1) == 0) /* KB11 (11/45/50/55/70) */
1122 return set_option ("eis") &&
1125 else if (strncmp (buf
, "da", 2) == 0) /* KD11-A (11/35/40) */
1126 return set_option ("limited-eis");
1128 else if (strncmp (buf
, "db", 2) == 0 || /* KD11-B (11/05/10) */
1129 strncmp (buf
, "dd", 2) == 0) /* KD11-D (11/04) */
1130 return 1; /* no extensions */
1132 else if (strncmp (buf
, "de", 2) == 0) /* KD11-E (11/34) */
1133 return set_option ("eis") &&
1134 set_option ("mxps");
1136 else if (strncmp (buf
, "df", 2) == 0 || /* KD11-F (11/03) */
1137 strncmp (buf
, "dh", 2) == 0 || /* KD11-H (11/03) */
1138 strncmp (buf
, "dq", 2) == 0) /* KD11-Q (11/03) */
1139 return set_option ("limited-eis") &&
1140 set_option ("mxps");
1142 else if (strncmp (buf
, "dk", 2) == 0) /* KD11-K (11/60) */
1143 return set_option ("eis") &&
1144 set_option ("mxps") &&
1145 set_option ("ucode");
1147 else if (strncmp (buf
, "dz", 2) == 0) /* KD11-Z (11/44) */
1148 return set_option ("csm") &&
1149 set_option ("eis") &&
1150 set_option ("mfpt") &&
1151 set_option ("mxps") &&
1154 else if (strncmp (buf
, "f", 1) == 0) /* F11 (11/23/24) */
1155 return set_option ("eis") &&
1156 set_option ("mfpt") &&
1157 set_option ("mxps");
1159 else if (strncmp (buf
, "j", 1) == 0) /* J11 (11/53/73/83/84/93/94)*/
1160 return set_option ("csm") &&
1161 set_option ("eis") &&
1162 set_option ("mfpt") &&
1163 set_option ("multiproc") &&
1164 set_option ("mxps") &&
1167 else if (strncmp (buf
, "t", 1) == 0) /* T11 (11/21) */
1168 return set_option ("limited-eis") &&
1169 set_option ("mxps");
1176 set_machine_model (arg
)
1179 if (strncmp (arg
, "pdp-11/", 7) != 0 &&
1180 strncmp (arg
, "pdp11/", 6) != 0 &&
1181 strncmp (arg
, "11/", 3) != 0)
1184 if (strncmp (arg
, "pdp", 3) == 0)
1188 if (strncmp (arg
, "11/", 3) == 0)
1191 if (strcmp (arg
, "03") == 0) /* 11/03 */
1192 return set_cpu_model ("kd11f"); /* KD11-F */
1194 else if (strcmp (arg
, "04") == 0) /* 11/04 */
1195 return set_cpu_model ("kd11d"); /* KD11-D */
1197 else if (strcmp (arg
, "05") == 0 || /* 11/05 or 11/10 */
1198 strcmp (arg
, "10") == 0)
1199 return set_cpu_model ("kd11b"); /* KD11-B */
1201 else if (strcmp (arg
, "15") == 0 || /* 11/15 or 11/20 */
1202 strcmp (arg
, "20") == 0)
1203 return set_cpu_model ("ka11"); /* KA11 */
1205 else if (strcmp (arg
, "21") == 0) /* 11/21 */
1206 return set_cpu_model ("t11"); /* T11 */
1208 else if (strcmp (arg
, "23") == 0 || /* 11/23 or 11/24 */
1209 strcmp (arg
, "24") == 0)
1210 return set_cpu_model ("f11"); /* F11 */
1212 else if (strcmp (arg
, "34") == 0 || /* 11/34 or 11/34a */
1213 strcmp (arg
, "34a") == 0)
1214 return set_cpu_model ("kd11e"); /* KD11-E */
1216 else if (strcmp (arg
, "35") == 0 || /* 11/35 or 11/40 */
1217 strcmp (arg
, "40") == 0)
1218 return set_cpu_model ("kd11da"); /* KD11-A */
1220 else if (strcmp (arg
, "44") == 0) /* 11/44 */
1221 return set_cpu_model ("kd11dz"); /* KD11-Z */
1223 else if (strcmp (arg
, "45") == 0 || /* 11/45/50/55/70 */
1224 strcmp (arg
, "50") == 0 ||
1225 strcmp (arg
, "55") == 0 ||
1226 strcmp (arg
, "70") == 0)
1227 return set_cpu_model ("kb11"); /* KB11 */
1229 else if (strcmp (arg
, "60") == 0) /* 11/60 */
1230 return set_cpu_model ("kd11k"); /* KD11-K */ /* FPP? */
1232 else if (strcmp (arg
, "53") == 0 || /* 11/53/73/83/84/93/94 */
1233 strcmp (arg
, "73") == 0 ||
1234 strcmp (arg
, "83") == 0 ||
1235 strcmp (arg
, "84") == 0 ||
1236 strcmp (arg
, "93") == 0 ||
1237 strcmp (arg
, "94") == 0)
1238 return set_cpu_model ("j11") && /* J11 */
1239 set_option ("fpp"); /* All J11 machines come */
1240 /* with FPP installed. */
1245 const char *md_shortopts
= "m:";
1247 struct option md_longopts
[] =
1249 #define OPTION_CPU 257
1250 { "cpu", required_argument
, NULL
, OPTION_CPU
},
1251 #define OPTION_MACHINE 258
1252 { "machine", required_argument
, NULL
, OPTION_MACHINE
},
1253 #define OPTION_PIC 259
1254 { "pic", no_argument
, NULL
, OPTION_PIC
},
1255 { NULL
, no_argument
, NULL
, 0 }
1258 size_t md_longopts_size
= sizeof (md_longopts
);
1262 * Invocation line includes a switch not recognized by the base assembler.
1263 * See if it's a processor-specific option.
1267 md_parse_option (c
, arg
)
1276 if (set_option (arg
))
1278 if (set_cpu_model (arg
))
1280 if (set_machine_model (arg
))
1285 if (set_cpu_model (arg
))
1289 case OPTION_MACHINE
:
1290 if (set_machine_model (arg
))
1295 if (set_option ("pic"))
1307 One possible way of parsing options.
1318 const char *pattern;
1320 const char *description;
1323 static struct options extension_opts[] =
1325 { "Ncsm", OPTION_CSM,
1326 "allow (disallow) CSM instruction" },
1327 { "Ncis", OPTION_CIS,
1328 "allow (disallow) commersial instruction set" },
1329 { "Neis", OPTION_EIS,
1330 "allow (disallow) extended instruction set" },
1332 { "all-extensions", OPTION_ALL_EXTENSIONS,
1333 "allow all instruction set extensions\n\
1334 (this is the default)" },
1335 { "no-extensions", OPTION_NO_EXTENSIONS,
1336 "disallow all instruction set extensions" },
1337 { "pic", OPTION_PIC,
1338 "position-independent code" },
1341 static struct options cpu_opts[] =
1343 { "Ka_11_*", OPTION_KA11, "KA11 CPU. ..." },
1344 { "Kb_11_*", OPTION_KB11, "KB11 CPU. ..." },
1345 { "Kd_11_a*", OPTION_KD11A, "KD11-A CPU. ..." },
1346 { "Kd_11_b*", OPTION_KD11B, "KD11-B CPU. ..." },
1347 { "Kd_11_d*", OPTION_KD11D, "KD11-D CPU. ..." },
1348 { "Kd_11_e*", OPTION_KD11E, "KD11-E CPU. ..." },
1349 { "Kd_11_f*", OPTION_KD11F, "KD11-F CPU. ..." },
1350 { "Kd_11_h*", OPTION_KD11H, "KD11-H CPU. ..." },
1351 { "Kd_11_q*", OPTION_KD11Q, "KD11-Q CPU. ..." },
1352 { "Kd_11_z*", OPTION_KD11Z, "KD11-Z CPU. ..." },
1353 { "Df_11_*", OPTION_F11, "F11 CPU. ..." },
1354 { "Dj_11_*", OPTION_J11, "J11 CPU. ..." },
1355 { "Dt_11_*", OPTION_T11, "T11 CPU. ..." },
1358 static struct options model_opts[] =
1360 { "P03", OPTION_PDP11_03, "same as ..." },
1361 { "P04", OPTION_PDP11_04, "same as ..." },
1362 { "P05", OPTION_PDP11_05, "same as ..." },
1363 { "P10", OPTION_PDP11_10, "same as ..." },
1364 { "P15", OPTION_PDP11_15, "same as ..." },
1365 { "P20", OPTION_PDP11_20, "same as ..." },
1366 { "P21", OPTION_PDP11_21, "same as ..." },
1367 { "P24", OPTION_PDP11_24, "same as ..." },
1368 { "P34", OPTION_PDP11_34, "same as ..." },
1369 { "P34a", OPTION_PDP11_34A, "same as ..." },
1370 { "P40", OPTION_PDP11_40, "same as ..." },
1371 { "P44", OPTION_PDP11_44, "same as ..." },
1372 { "P45", OPTION_PDP11_45, "same as ..." },
1373 { "P50", OPTION_PDP11_50, "same as ..." },
1374 { "P53", OPTION_PDP11_53, "same as ..." },
1375 { "P55", OPTION_PDP11_55, "same as ..." },
1376 { "P60", OPTION_PDP11_60, "same as ..." },
1377 { "P70", OPTION_PDP11_70, "same as ..." },
1378 { "P73", OPTION_PDP11_73, "same as ..." },
1379 { "P83", OPTION_PDP11_83, "same as ..." },
1380 { "P84", OPTION_PDP11_84, "same as ..." },
1381 { "P93", OPTION_PDP11_93, "same as ..." },
1382 { "P94", OPTION_PDP11_94, "same as ..." },
1388 struct options *opts;
1392 { "PDP-11 instruction set extentions",
1394 sizeof extension_opts / sizeof extension_opts[0] },
1395 { "PDP-11 CPU model options",
1397 sizeof cpu_opts / sizeof cpu_opts[0] },
1398 { "PDP-11 machine model options",
1400 sizeof model_opts / sizeof model_opts[0] },
1404 parse_match (char *arg, char *pattern)
1413 if (strncmp (arg, "no-") == 0)
1426 if (strncmp (arg, "kd", 2) == 0)
1431 if (strncmp (arg, "pdp-11/", 7) == 0)
1433 else if (strncmp (arg, "pdp11/", 6) == 0)
1435 else if (strncmp (arg, "11/", 3) == 0)
1451 if (*arg++ != pattern[-1])
1460 fprint_opt (stream, pattern)
1462 const char *pattern;
1471 n += fprintf (stream, "(no-)");
1475 n += fprintf (stream, "k");
1479 n += fprintf (stream "11/");
1488 fputc (pattern[-1], stream);
1497 parse_option (char *arg)
1501 for (i = 0; i < sizeof all_opts / sizeof all_opts[0]; i++)
1503 for (j = 0; j < all_opts[i].num; j++)
1505 if (parse_match (arg, all_opts[i].opts[j].pattern))
1507 set_option (all_opts[i].opts[j].opt);
1517 fprint_space (stream, n)
1522 fputc (' ', stream);
1526 md_show_usage (stream)
1531 for (i = 0; i < sizeof all_opts / sizeof all_opts[0]; i++)
1533 fprintf (stream "\n%s:\n\n", all_opts[i].title);
1535 for (j = 0; j < all_opts[i].num; j++)
1537 fprintf (stream, "-m");
1538 n = fprintf_opt (stream, all_opts[i].opts[j].pattern);
1539 fprint_space (stream, 22 - n);
1540 fprintf (stream, "%s\n", all_opts[i].opts[j].description);
1547 md_show_usage (stream
)
1552 PDP-11 instruction set extentions:\n\
1554 -m(no-)cis allow (disallow) commersial instruction set\n\
1555 -m(no-)csm allow (disallow) CSM instruction\n\
1556 -m(no-)eis allow (disallow) full extended instruction set\n\
1557 -m(no-)fis allow (disallow) KEV11 floating-point instructions\n\
1558 -m(no-)fpp allow (disallow) FP-11 floating-point instructions\n\
1559 -m(no-)fpu allow (disallow) FP-11 floating-point instructions\n\
1560 -m(no-)limited-eis allow (disallow) limited extended instruction set\n\
1561 -m(no-)mfpt allow (disallow) processor type instruction\n\
1562 -m(no-)multiproc allow (disallow) multiprocessor instructions\n\
1563 -m(no-)mxps allow (disallow) processor status instructions\n\
1564 -m(no-)spl allow (disallow) SPL instruction\n\
1565 -m(no-)ucode allow (disallow) microcode instructions\n\
1566 -mall-extensions allow all instruction set extensions\n\
1567 (this is the default)\n\
1568 -mno-extentions disallow all instruction set extensions\n\
1569 -pic generate position-indepenent code\n\
1571 PDP-11 CPU model options:\n\
1573 -mka11* KA11 CPU. base line instruction set only\n\
1574 -mkb11* KB11 CPU. enable full EIS and SPL\n\
1575 -mkd11a* KD11-A CPU. enable limited EIS\n\
1576 -mkd11b* KD11-B CPU. base line instruction set only\n\
1577 -mkd11d* KD11-D CPU. base line instruction set only\n\
1578 -mkd11e* KD11-E CPU. enable full EIS, MTPS, and MFPS\n\
1579 -mkd11f* KD11-F CPU. enable limited EIS, MTPS, and MFPS\n\
1580 -mkd11h* KD11-H CPU. enable limited EIS, MTPS, and MFPS\n\
1581 -mkd11q* KD11-Q CPU. enable limited EIS, MTPS, and MFPS\n\
1582 -mkd11k* KD11-K CPU. enable full EIS, MTPS, MFPS, LDUB, MED,\n\
1584 -mkd11z* KD11-Z CPU. enable full EIS, MTPS, MFPS, MFPT, SPL,\n\
1586 -mf11* F11 CPU. enable full EIS, MFPS, MTPS, and MFPT\n\
1587 -mj11* J11 CPU. enable full EIS, MTPS, MFPS, MFPT, SPL,\n\
1588 CSM, TSTSET, and WRTLCK\n\
1589 -mt11* T11 CPU. enable limited EIS, MTPS, and MFPS\n\
1591 PDP-11 machine model options:\n\
1593 -m11/03 same as -mkd11f\n\
1594 -m11/04 same as -mkd11d\n\
1595 -m11/05 same as -mkd11b\n\
1596 -m11/10 same as -mkd11b\n\
1597 -m11/15 same as -mka11\n\
1598 -m11/20 same as -mka11\n\
1599 -m11/21 same as -mt11\n\
1600 -m11/23 same as -mf11\n\
1601 -m11/24 same as -mf11\n\
1602 -m11/34 same as -mkd11e\n\
1603 -m11/34a same as -mkd11e -mfpp\n\
1604 -m11/35 same as -mkd11a\n\
1605 -m11/40 same as -mkd11a\n\
1606 -m11/44 same as -mkd11z\n\
1607 -m11/45 same as -mkb11\n\
1608 -m11/50 same as -mkb11\n\
1609 -m11/53 same as -mj11\n\
1610 -m11/55 same as -mkb11\n\
1611 -m11/60 same as -mkd11k\n\
1612 -m11/70 same as -mkb11\n\
1613 -m11/73 same as -mj11\n\
1614 -m11/83 same as -mj11\n\
1615 -m11/84 same as -mj11\n\
1616 -m11/93 same as -mj11\n\
1617 -m11/94 same as -mj11\n\
1622 md_undefined_symbol (name
)
1623 char *name ATTRIBUTE_UNUSED
;
1629 md_section_align (segment
, size
)
1630 segT segment ATTRIBUTE_UNUSED
;
1633 return (size
+ 1) & ~1;
1637 md_pcrel_from (fixP
)
1640 return fixP
->fx_frag
->fr_address
+ fixP
->fx_where
+ fixP
->fx_size
;
1643 /* Translate internal representation of relocation info to BFD target
1646 tc_gen_reloc (section
, fixp
)
1647 asection
*section ATTRIBUTE_UNUSED
;
1651 bfd_reloc_code_real_type code
;
1653 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
1655 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
1656 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
1657 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
1659 /* This is taken account for in md_apply_fix3(). */
1660 reloc
->addend
= -symbol_get_bfdsym (fixp
->fx_addsy
)->section
->vma
;
1662 switch (fixp
->fx_r_type
)
1666 code
= BFD_RELOC_16_PCREL
;
1668 code
= BFD_RELOC_16
;
1671 case BFD_RELOC_16_PCREL
:
1672 code
= BFD_RELOC_16_PCREL
;
1676 BAD_CASE (fixp
->fx_r_type
);
1680 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
1682 if (reloc
->howto
== NULL
)
1684 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1685 "Can not represent %s relocation in this object file format",
1686 bfd_get_reloc_code_name (code
));
1695 int c ATTRIBUTE_UNUSED
;
1699 temp
= get_absolute_expression ();
1700 subseg_set (bss_section
, temp
);
1701 demand_empty_rest_of_line ();
1706 int c ATTRIBUTE_UNUSED
;
1708 int alignment
= 1; /* 2^1 */
1709 frag_align (alignment
, 0, 1);
1710 record_alignment (now_seg
, alignment
);
1713 /* end of tc-pdp11.c */