1 /* tc-pdp11.c - pdp11-specific -
2 Copyright 2001, 2002, 2004 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 */