1 /* tc-ip2k.c -- Assembler for the Scenix IP2xxx.
2 Copyright (C) 2000-2021 Free Software Foundation, Inc.
3
4 This file is part of GAS, the GNU Assembler.
5
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 3, or (at your option)
9 any later version.
10
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.
15
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, 51 Franklin Street - Fifth Floor,
19 Boston, MA 02110-1301, USA. */
20
21 #include "as.h"
22 #include "subsegs.h"
23 #include "symcat.h"
24 #include "opcodes/ip2k-desc.h"
25 #include "opcodes/ip2k-opc.h"
26 #include "cgen.h"
27 #include "elf/common.h"
28 #include "elf/ip2k.h"
29
30 /* Structure to hold all of the different components describing
31 an individual instruction. */
32 typedef struct
33 {
34 const CGEN_INSN * insn;
35 const CGEN_INSN * orig_insn;
36 CGEN_FIELDS fields;
37 #if CGEN_INT_INSN_P
38 CGEN_INSN_INT buffer [1];
39 #define INSN_VALUE(buf) (*(buf))
40 #else
41 unsigned char buffer [CGEN_MAX_INSN_SIZE];
42 #define INSN_VALUE(buf) (buf)
43 #endif
44 char * addr;
45 fragS * frag;
46 int num_fixups;
47 fixS * fixups [GAS_CGEN_MAX_FIXUPS];
48 int indices [MAX_OPERAND_INSTANCES];
49 }
50 ip2k_insn;
51
52 const char comment_chars[] = ";";
53 const char line_comment_chars[] = "#";
54 const char line_separator_chars[] = "";
55 const char EXP_CHARS[] = "eE";
56 const char FLT_CHARS[] = "dD";
57
58 /* Flag to detect when switching to code section where insn alignment is
59 implied. */
60 static int force_code_align = 0;
61
62 /* Mach selected from command line. */
63 static int ip2k_mach = 0;
64 static unsigned ip2k_mach_bitmask = 0;
65
66
67 static void
ip2k_elf_section_rtn(int i)68 ip2k_elf_section_rtn (int i)
69 {
70 obj_elf_section(i);
71
72 if (force_code_align)
73 {
74 do_align (1, NULL, 0, 0);
75 force_code_align = 0;
76 }
77 }
78
79 static void
ip2k_elf_section_text(int i)80 ip2k_elf_section_text (int i)
81 {
82 obj_elf_text(i);
83
84 do_align (1, NULL, 0, 0);
85 force_code_align = 0;
86 }
87
88 /* The target specific pseudo-ops which we support. */
89 const pseudo_typeS md_pseudo_table[] =
90 {
91 { "text", ip2k_elf_section_text, 0 },
92 { "sect", ip2k_elf_section_rtn, 0 },
93 { NULL, NULL, 0 }
94 };
95
96
97
98 enum options
99 {
100 OPTION_CPU_IP2022 = OPTION_MD_BASE,
101 OPTION_CPU_IP2022EXT
102 };
103
104 struct option md_longopts[] =
105 {
106 { "mip2022", no_argument, NULL, OPTION_CPU_IP2022 },
107 { "mip2022ext", no_argument, NULL, OPTION_CPU_IP2022EXT },
108 { NULL, no_argument, NULL, 0 },
109 };
110 size_t md_longopts_size = sizeof (md_longopts);
111
112 const char * md_shortopts = "";
113
114 int
md_parse_option(int c ATTRIBUTE_UNUSED,const char * arg ATTRIBUTE_UNUSED)115 md_parse_option (int c ATTRIBUTE_UNUSED, const char * arg ATTRIBUTE_UNUSED)
116 {
117 switch (c)
118 {
119 case OPTION_CPU_IP2022:
120 ip2k_mach = bfd_mach_ip2022;
121 ip2k_mach_bitmask = 1 << MACH_IP2022;
122 break;
123
124 case OPTION_CPU_IP2022EXT:
125 ip2k_mach = bfd_mach_ip2022ext;
126 ip2k_mach_bitmask = 1 << MACH_IP2022EXT;
127 break;
128
129 default:
130 return 0;
131 }
132
133 return 1;
134 }
135
136 void
md_show_usage(FILE * stream)137 md_show_usage (FILE * stream)
138 {
139 fprintf (stream, _("IP2K specific command line options:\n"));
140 fprintf (stream, _(" -mip2022 restrict to IP2022 insns \n"));
141 fprintf (stream, _(" -mip2022ext permit extended IP2022 insn\n"));
142 }
143
144
145 void
md_begin(void)146 md_begin (void)
147 {
148 /* Initialize the `cgen' interface. */
149
150 /* Set the machine number and endian. */
151 gas_cgen_cpu_desc = ip2k_cgen_cpu_open (CGEN_CPU_OPEN_MACHS,
152 ip2k_mach_bitmask,
153 CGEN_CPU_OPEN_ENDIAN,
154 CGEN_ENDIAN_BIG,
155 CGEN_CPU_OPEN_END);
156 ip2k_cgen_init_asm (gas_cgen_cpu_desc);
157
158 /* This is a callback from cgen to gas to parse operands. */
159 cgen_set_parse_operand_fn (gas_cgen_cpu_desc, gas_cgen_parse_operand);
160
161 /* Set the machine type. */
162 bfd_default_set_arch_mach (stdoutput, bfd_arch_ip2k, ip2k_mach);
163
164 literal_prefix_dollar_hex = true;
165 }
166
167
168 void
md_assemble(char * str)169 md_assemble (char * str)
170 {
171 ip2k_insn insn;
172 char * errmsg;
173
174 /* Initialize GAS's cgen interface for a new instruction. */
175 gas_cgen_init_parse ();
176
177 insn.insn = ip2k_cgen_assemble_insn
178 (gas_cgen_cpu_desc, str, & insn.fields, insn.buffer, & errmsg);
179
180 if (!insn.insn)
181 {
182 as_bad ("%s", errmsg);
183 return;
184 }
185
186 /* Check for special relocation required by SKIP instructions. */
187 if (CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_SKIPA))
188 /* Unconditional skip has a 1-bit relocation of the current pc, so
189 that we emit either sb pcl.0 or snb pcl.0 depending on whether
190 the PCL (pc + 2) >> 1 is odd or even. */
191 {
192 enum cgen_parse_operand_result result_type;
193 bfd_vma value;
194 const char *curpc_plus_2 = ".+2";
195 const char *err;
196
197 err = cgen_parse_address (gas_cgen_cpu_desc, & curpc_plus_2,
198 IP2K_OPERAND_ADDR16CJP,
199 BFD_RELOC_IP2K_PC_SKIP,
200 & result_type, & value);
201 if (err)
202 {
203 as_bad ("%s", err);
204 return;
205 }
206 }
207
208 /* Doesn't really matter what we pass for RELAX_P here. */
209 gas_cgen_finish_insn (insn.insn, insn.buffer,
210 CGEN_FIELDS_BITSIZE (& insn.fields), 1, NULL);
211 }
212
213 valueT
md_section_align(segT segment,valueT size)214 md_section_align (segT segment, valueT size)
215 {
216 int align = bfd_section_alignment (segment);
217
218 return ((size + (1 << align) - 1) & -(1 << align));
219 }
220
221
222 symbolS *
md_undefined_symbol(char * name ATTRIBUTE_UNUSED)223 md_undefined_symbol (char * name ATTRIBUTE_UNUSED)
224 {
225 return 0;
226 }
227
228 int
md_estimate_size_before_relax(fragS * fragP ATTRIBUTE_UNUSED,segT segment ATTRIBUTE_UNUSED)229 md_estimate_size_before_relax (fragS * fragP ATTRIBUTE_UNUSED,
230 segT segment ATTRIBUTE_UNUSED)
231 {
232 as_fatal (_("relaxation not supported\n"));
233 return 1;
234 }
235
236
237 /* *fragP has been relaxed to its final size, and now needs to have
238 the bytes inside it modified to conform to the new size.
239
240 Called after relaxation is finished.
241 fragP->fr_type == rs_machine_dependent.
242 fragP->fr_subtype is the subtype of what the address relaxed to. */
243
244 void
md_convert_frag(bfd * abfd ATTRIBUTE_UNUSED,segT sec ATTRIBUTE_UNUSED,fragS * fragP ATTRIBUTE_UNUSED)245 md_convert_frag (bfd * abfd ATTRIBUTE_UNUSED,
246 segT sec ATTRIBUTE_UNUSED,
247 fragS * fragP ATTRIBUTE_UNUSED)
248 {
249 }
250
251
252 /* Functions concerning relocs. */
253
254 long
md_pcrel_from(fixS * fixP ATTRIBUTE_UNUSED)255 md_pcrel_from (fixS *fixP ATTRIBUTE_UNUSED)
256 {
257 abort ();
258 }
259
260
261 /* Return the bfd reloc type for OPERAND of INSN at fixup FIXP.
262 Returns BFD_RELOC_NONE if no reloc type can be found.
263 *FIXP may be modified if desired. */
264
265 bfd_reloc_code_real_type
md_cgen_lookup_reloc(const CGEN_INSN * insn ATTRIBUTE_UNUSED,const CGEN_OPERAND * operand,fixS * fixP ATTRIBUTE_UNUSED)266 md_cgen_lookup_reloc (const CGEN_INSN * insn ATTRIBUTE_UNUSED,
267 const CGEN_OPERAND * operand,
268 fixS * fixP ATTRIBUTE_UNUSED)
269 {
270 bfd_reloc_code_real_type result;
271
272 result = BFD_RELOC_NONE;
273
274 switch (operand->type)
275 {
276 case IP2K_OPERAND_FR:
277 case IP2K_OPERAND_ADDR16L:
278 case IP2K_OPERAND_ADDR16H:
279 case IP2K_OPERAND_LIT8:
280 /* These may have been processed at parse time. */
281 if (fixP->fx_cgen.opinfo != 0)
282 result = fixP->fx_cgen.opinfo;
283 fixP->fx_no_overflow = 1;
284 break;
285
286 case IP2K_OPERAND_ADDR16CJP:
287 result = fixP->fx_cgen.opinfo;
288 if (result == 0 || result == BFD_RELOC_NONE)
289 result = BFD_RELOC_IP2K_ADDR16CJP;
290 fixP->fx_no_overflow = 1;
291 break;
292
293 case IP2K_OPERAND_ADDR16P:
294 result = BFD_RELOC_IP2K_PAGE3;
295 fixP->fx_no_overflow = 1;
296 break;
297
298 default:
299 result = BFD_RELOC_NONE;
300 break;
301 }
302
303 return result;
304 }
305
306
307 /* Write a value out to the object file, using the appropriate endianness. */
308
309 void
md_number_to_chars(char * buf,valueT val,int n)310 md_number_to_chars (char * buf, valueT val, int n)
311 {
312 number_to_chars_bigendian (buf, val, n);
313 }
314
315 const char *
md_atof(int type,char * litP,int * sizeP)316 md_atof (int type, char * litP, int * sizeP)
317 {
318 return ieee_md_atof (type, litP, sizeP, true);
319 }
320
321
322 /* See whether we need to force a relocation into the output file.
323 Force most of them, since the linker's bfd relocation engine
324 understands range limits better than gas' cgen fixup engine.
325 Consider the case of a fixup intermediate value being larger than
326 the instruction it will be eventually encoded within. */
327
328 int
ip2k_force_relocation(fixS * fix)329 ip2k_force_relocation (fixS * fix)
330 {
331 switch (fix->fx_r_type)
332 {
333 case BFD_RELOC_IP2K_FR9:
334 case BFD_RELOC_IP2K_FR_OFFSET:
335 case BFD_RELOC_IP2K_BANK:
336 case BFD_RELOC_IP2K_ADDR16CJP:
337 case BFD_RELOC_IP2K_PAGE3:
338 case BFD_RELOC_IP2K_LO8DATA:
339 case BFD_RELOC_IP2K_HI8DATA:
340 case BFD_RELOC_IP2K_EX8DATA:
341 case BFD_RELOC_IP2K_LO8INSN:
342 case BFD_RELOC_IP2K_HI8INSN:
343 case BFD_RELOC_IP2K_PC_SKIP:
344 case BFD_RELOC_IP2K_TEXT:
345 return 1;
346
347 case BFD_RELOC_16:
348 if (fix->fx_subsy && S_IS_DEFINED (fix->fx_subsy)
349 && fix->fx_addsy && S_IS_DEFINED (fix->fx_addsy)
350 && (S_GET_SEGMENT (fix->fx_addsy)->flags & SEC_CODE))
351 {
352 fix->fx_r_type = BFD_RELOC_IP2K_TEXT;
353 return 0;
354 }
355 break;
356
357 default:
358 break;
359 }
360
361 return generic_force_reloc (fix);
362 }
363
364 void
ip2k_apply_fix(fixS * fixP,valueT * valueP,segT seg)365 ip2k_apply_fix (fixS *fixP, valueT *valueP, segT seg)
366 {
367 if (fixP->fx_r_type == BFD_RELOC_IP2K_TEXT
368 && ! fixP->fx_addsy
369 && ! fixP->fx_subsy)
370 {
371 *valueP = ((int)(* valueP)) / 2;
372 fixP->fx_r_type = BFD_RELOC_16;
373 }
374 else if (fixP->fx_r_type == BFD_RELOC_UNUSED + IP2K_OPERAND_FR)
375 {
376 /* Must be careful when we are fixing up an FR. We could be
377 fixing up an offset to (SP) or (DP) in which case we don't
378 want to step on the top 2 bits of the FR operand. The
379 gas_cgen_md_apply_fix doesn't know any better and overwrites
380 the entire operand. We counter this by adding the bits
381 to the new value. */
382 char *where = fixP->fx_frag->fr_literal + fixP->fx_where;
383
384 /* Canonical name, since used a lot. */
385 CGEN_CPU_DESC cd = gas_cgen_cpu_desc;
386 CGEN_INSN_INT insn_value
387 = cgen_get_insn_value (cd, (unsigned char *) where,
388 CGEN_INSN_BITSIZE (fixP->fx_cgen.insn),
389 gas_cgen_cpu_desc->insn_endian);
390 /* Preserve (DP) or (SP) specification. */
391 *valueP += (insn_value & 0x180);
392 }
393
394 gas_cgen_md_apply_fix (fixP, valueP, seg);
395 }
396
397 int
ip2k_elf_section_flags(flagword flags,bfd_vma attr ATTRIBUTE_UNUSED,int type ATTRIBUTE_UNUSED)398 ip2k_elf_section_flags (flagword flags,
399 bfd_vma attr ATTRIBUTE_UNUSED,
400 int type ATTRIBUTE_UNUSED)
401 {
402 /* This is used to detect when the section changes to an executable section.
403 This function is called by the elf section processing. When we note an
404 executable section specifier we set an internal flag to denote when
405 word alignment should be forced. */
406 if (flags & SEC_CODE)
407 force_code_align = 1;
408
409 return flags;
410 }
411
412