1 /* GAS interface for targets using CGEN: Cpu tools GENerator.
2 Copyright (C) 1996-2016 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, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
14 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 the Free Software
18 Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
19
20 #include "as.h"
21 #include <setjmp.h>
22 #include "symcat.h"
23 #include "cgen-desc.h"
24 #include "subsegs.h"
25 #include "cgen.h"
26 #include "dwarf2dbg.h"
27
28 #include "symbols.h"
29 #include "struc-symbol.h"
30
31 #ifdef OBJ_COMPLEX_RELC
32 static expressionS * make_right_shifted_expr
33 (expressionS *, const int, const int);
34
35 static unsigned long gas_cgen_encode_addend
36 (const unsigned long, const unsigned long, const unsigned long, \
37 const unsigned long, const unsigned long, const unsigned long, \
38 const unsigned long);
39
40 static const char * weak_operand_overflow_check
41 (const expressionS *, const CGEN_OPERAND *);
42
43 static void queue_fixup_recursively
44 (const int, const int, expressionS *, \
45 const CGEN_MAYBE_MULTI_IFLD *, const int, const int);
46
47 static int rightshift = 0;
48 #endif
49 static void queue_fixup (int, int, expressionS *);
50
51 /* Opcode table descriptor, must be set by md_begin. */
52
53 CGEN_CPU_DESC gas_cgen_cpu_desc;
54
55 /* Callback to insert a register into the symbol table.
56 A target may choose to let GAS parse the registers.
57 ??? Not currently used. */
58
59 void
cgen_asm_record_register(char * name,int number)60 cgen_asm_record_register (char *name, int number)
61 {
62 /* Use symbol_create here instead of symbol_new so we don't try to
63 output registers into the object file's symbol table. */
64 symbol_table_insert (symbol_create (name, reg_section,
65 number, &zero_address_frag));
66 }
67
68 /* We need to keep a list of fixups. We can't simply generate them as
69 we go, because that would require us to first create the frag, and
70 that would screw up references to ``.''.
71
72 This is used by cpu's with simple operands. It keeps knowledge of what
73 an `expressionS' is and what a `fixup' is out of CGEN which for the time
74 being is preferable.
75
76 OPINDEX is the index in the operand table.
77 OPINFO is something the caller chooses to help in reloc determination. */
78
79 struct fixup
80 {
81 int opindex;
82 int opinfo;
83 expressionS exp;
84 struct cgen_maybe_multi_ifield * field;
85 int msb_field_p;
86 };
87
88 static struct fixup fixups[GAS_CGEN_MAX_FIXUPS];
89 static int num_fixups;
90
91 /* Prepare to parse an instruction.
92 ??? May wish to make this static and delete calls in md_assemble. */
93
94 void
gas_cgen_init_parse(void)95 gas_cgen_init_parse (void)
96 {
97 num_fixups = 0;
98 }
99
100 /* Queue a fixup. */
101
102 static void
queue_fixup(int opindex,int opinfo,expressionS * expP)103 queue_fixup (int opindex, int opinfo, expressionS *expP)
104 {
105 /* We need to generate a fixup for this expression. */
106 if (num_fixups >= GAS_CGEN_MAX_FIXUPS)
107 as_fatal (_("too many fixups"));
108 fixups[num_fixups].exp = *expP;
109 fixups[num_fixups].opindex = opindex;
110 fixups[num_fixups].opinfo = opinfo;
111 ++ num_fixups;
112 }
113
114 /* The following functions allow fixup chains to be stored, retrieved,
115 and swapped. They are a generalization of a pre-existing scheme
116 for storing, restoring and swapping fixup chains that was used by
117 the m32r port. The functionality is essentially the same, only
118 instead of only being able to store a single fixup chain, an entire
119 array of fixup chains can be stored. It is the user's responsibility
120 to keep track of how many fixup chains have been stored and which
121 elements of the array they are in.
122
123 The algorithms used are the same as in the old scheme. Other than the
124 "array-ness" of the whole thing, the functionality is identical to the
125 old scheme.
126
127 gas_cgen_initialize_saved_fixups_array():
128 Sets num_fixups_in_chain to 0 for each element. Call this from
129 md_begin() if you plan to use these functions and you want the
130 fixup count in each element to be set to 0 initially. This is
131 not necessary, but it's included just in case. It performs
132 the same function for each element in the array of fixup chains
133 that gas_init_parse() performs for the current fixups.
134
135 gas_cgen_save_fixups (element):
136 element - element number of the array you wish to store the fixups
137 to. No mechanism is built in for tracking what element
138 was last stored to.
139
140 gas_cgen_restore_fixups (element):
141 element - element number of the array you wish to restore the fixups
142 from.
143
144 gas_cgen_swap_fixups(int element):
145 element - swap the current fixups with those in this element number.
146 */
147
148 struct saved_fixups
149 {
150 struct fixup fixup_chain[GAS_CGEN_MAX_FIXUPS];
151 int num_fixups_in_chain;
152 };
153
154 static struct saved_fixups stored_fixups[MAX_SAVED_FIXUP_CHAINS];
155
156 void
gas_cgen_initialize_saved_fixups_array(void)157 gas_cgen_initialize_saved_fixups_array (void)
158 {
159 int i = 0;
160
161 while (i < MAX_SAVED_FIXUP_CHAINS)
162 stored_fixups[i++].num_fixups_in_chain = 0;
163 }
164
165 void
gas_cgen_save_fixups(int i)166 gas_cgen_save_fixups (int i)
167 {
168 if (i < 0 || i >= MAX_SAVED_FIXUP_CHAINS)
169 {
170 as_fatal ("index into stored_fixups[] out of bounds");
171 return;
172 }
173
174 stored_fixups[i].num_fixups_in_chain = num_fixups;
175 memcpy (stored_fixups[i].fixup_chain, fixups,
176 sizeof (fixups[0]) * num_fixups);
177 num_fixups = 0;
178 }
179
180 void
gas_cgen_restore_fixups(int i)181 gas_cgen_restore_fixups (int i)
182 {
183 if (i < 0 || i >= MAX_SAVED_FIXUP_CHAINS)
184 {
185 as_fatal ("index into stored_fixups[] out of bounds");
186 return;
187 }
188
189 num_fixups = stored_fixups[i].num_fixups_in_chain;
190 memcpy (fixups, stored_fixups[i].fixup_chain,
191 (sizeof (stored_fixups[i].fixup_chain[0])) * num_fixups);
192 stored_fixups[i].num_fixups_in_chain = 0;
193 }
194
195 void
gas_cgen_swap_fixups(int i)196 gas_cgen_swap_fixups (int i)
197 {
198 if (i < 0 || i >= MAX_SAVED_FIXUP_CHAINS)
199 {
200 as_fatal ("index into stored_fixups[] out of bounds");
201 return;
202 }
203
204 if (num_fixups == 0)
205 gas_cgen_restore_fixups (i);
206
207 else if (stored_fixups[i].num_fixups_in_chain == 0)
208 gas_cgen_save_fixups (i);
209
210 else
211 {
212 int tmp;
213 struct fixup tmp_fixup;
214
215 tmp = stored_fixups[i].num_fixups_in_chain;
216 stored_fixups[i].num_fixups_in_chain = num_fixups;
217 num_fixups = tmp;
218
219 for (tmp = GAS_CGEN_MAX_FIXUPS; tmp--;)
220 {
221 tmp_fixup = stored_fixups[i].fixup_chain [tmp];
222 stored_fixups[i].fixup_chain[tmp] = fixups [tmp];
223 fixups [tmp] = tmp_fixup;
224 }
225 }
226 }
227
228 /* Default routine to record a fixup.
229 This is a cover function to fix_new.
230 It exists because we record INSN with the fixup.
231
232 FRAG and WHERE are their respective arguments to fix_new_exp.
233 LENGTH is in bits.
234 OPINFO is something the caller chooses to help in reloc determination.
235
236 At this point we do not use a bfd_reloc_code_real_type for
237 operands residing in the insn, but instead just use the
238 operand index. This lets us easily handle fixups for any
239 operand type. We pick a BFD reloc type in md_apply_fix. */
240
241 fixS *
gas_cgen_record_fixup(fragS * frag,int where,const CGEN_INSN * insn,int length,const CGEN_OPERAND * operand,int opinfo,symbolS * symbol,offsetT offset)242 gas_cgen_record_fixup (fragS *frag, int where, const CGEN_INSN *insn,
243 int length, const CGEN_OPERAND *operand, int opinfo,
244 symbolS *symbol, offsetT offset)
245 {
246 fixS *fixP;
247
248 /* It may seem strange to use operand->attrs and not insn->attrs here,
249 but it is the operand that has a pc relative relocation. */
250 fixP = fix_new (frag, where, length / 8, symbol, offset,
251 CGEN_OPERAND_ATTR_VALUE (operand, CGEN_OPERAND_PCREL_ADDR),
252 (bfd_reloc_code_real_type)
253 ((int) BFD_RELOC_UNUSED
254 + (int) operand->type));
255 fixP->fx_cgen.insn = insn;
256 fixP->fx_cgen.opinfo = opinfo;
257 fixP->fx_cgen.field = NULL;
258 fixP->fx_cgen.msb_field_p = 0;
259
260 return fixP;
261 }
262
263 /* Default routine to record a fixup given an expression.
264 This is a cover function to fix_new_exp.
265 It exists because we record INSN with the fixup.
266
267 FRAG and WHERE are their respective arguments to fix_new_exp.
268 LENGTH is in bits.
269 OPINFO is something the caller chooses to help in reloc determination.
270
271 At this point we do not use a bfd_reloc_code_real_type for
272 operands residing in the insn, but instead just use the
273 operand index. This lets us easily handle fixups for any
274 operand type. We pick a BFD reloc type in md_apply_fix. */
275
276 fixS *
gas_cgen_record_fixup_exp(fragS * frag,int where,const CGEN_INSN * insn,int length,const CGEN_OPERAND * operand,int opinfo,expressionS * exp)277 gas_cgen_record_fixup_exp (fragS *frag, int where, const CGEN_INSN *insn,
278 int length, const CGEN_OPERAND *operand, int opinfo,
279 expressionS *exp)
280 {
281 fixS *fixP;
282
283 /* It may seem strange to use operand->attrs and not insn->attrs here,
284 but it is the operand that has a pc relative relocation. */
285 fixP = fix_new_exp (frag, where, length / 8, exp,
286 CGEN_OPERAND_ATTR_VALUE (operand, CGEN_OPERAND_PCREL_ADDR),
287 (bfd_reloc_code_real_type)
288 ((int) BFD_RELOC_UNUSED
289 + (int) operand->type));
290 fixP->fx_cgen.insn = insn;
291 fixP->fx_cgen.opinfo = opinfo;
292 fixP->fx_cgen.field = NULL;
293 fixP->fx_cgen.msb_field_p = 0;
294
295 return fixP;
296 }
297
298 #ifdef OBJ_COMPLEX_RELC
299 static symbolS *
expr_build_binary(operatorT op,symbolS * s1,symbolS * s2)300 expr_build_binary (operatorT op, symbolS * s1, symbolS * s2)
301 {
302 expressionS e;
303
304 e.X_op = op;
305 e.X_add_symbol = s1;
306 e.X_op_symbol = s2;
307 e.X_add_number = 0;
308 return make_expr_symbol (& e);
309 }
310 #endif
311
312 /* Used for communication between the next two procedures. */
313 static jmp_buf expr_jmp_buf;
314 static int expr_jmp_buf_p;
315
316 /* Callback for cgen interface. Parse the expression at *STRP.
317 The result is an error message or NULL for success (in which case
318 *STRP is advanced past the parsed text).
319 WANT is an indication of what the caller is looking for.
320 If WANT == CGEN_ASM_PARSE_INIT the caller is beginning to try to match
321 a table entry with the insn, reset the queued fixups counter.
322 An enum cgen_parse_operand_result is stored in RESULTP.
323 OPINDEX is the operand's table entry index.
324 OPINFO is something the caller chooses to help in reloc determination.
325 The resulting value is stored in VALUEP. */
326
327 const char *
gas_cgen_parse_operand(CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,enum cgen_parse_operand_type want,const char ** strP,int opindex,int opinfo,enum cgen_parse_operand_result * resultP,bfd_vma * valueP)328 gas_cgen_parse_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
329 enum cgen_parse_operand_type want, const char **strP,
330 int opindex, int opinfo,
331 enum cgen_parse_operand_result *resultP,
332 bfd_vma *valueP)
333 {
334 #ifdef __STDC__
335 /* These are volatile to survive the setjmp. */
336 char * volatile hold;
337 enum cgen_parse_operand_result * volatile resultP_1;
338 volatile int opinfo_1;
339 #else
340 static char *hold;
341 static enum cgen_parse_operand_result *resultP_1;
342 int opinfo_1;
343 #endif
344 const char *errmsg;
345 expressionS exp;
346
347 #ifdef OBJ_COMPLEX_RELC
348 volatile int signed_p = 0;
349 symbolS * stmp = NULL;
350 bfd_reloc_code_real_type reloc_type;
351 const CGEN_OPERAND * operand;
352 fixS dummy_fixup;
353 #endif
354 if (want == CGEN_PARSE_OPERAND_INIT)
355 {
356 gas_cgen_init_parse ();
357 return NULL;
358 }
359
360 resultP_1 = resultP;
361 hold = input_line_pointer;
362 input_line_pointer = (char *) *strP;
363 opinfo_1 = opinfo;
364
365 /* We rely on md_operand to longjmp back to us.
366 This is done via gas_cgen_md_operand. */
367 if (setjmp (expr_jmp_buf) != 0)
368 {
369 expr_jmp_buf_p = 0;
370 input_line_pointer = (char *) hold;
371 *resultP_1 = CGEN_PARSE_OPERAND_RESULT_ERROR;
372 return _("illegal operand");
373 }
374
375 expr_jmp_buf_p = 1;
376 expression (&exp);
377 expr_jmp_buf_p = 0;
378 errmsg = NULL;
379
380 *strP = input_line_pointer;
381 input_line_pointer = hold;
382
383 #ifdef TC_CGEN_PARSE_FIX_EXP
384 opinfo_1 = TC_CGEN_PARSE_FIX_EXP (opinfo_1, & exp);
385 #endif
386
387 /* FIXME: Need to check `want'. */
388
389 switch (exp.X_op)
390 {
391 case O_illegal:
392 errmsg = _("illegal operand");
393 *resultP = CGEN_PARSE_OPERAND_RESULT_ERROR;
394 break;
395 case O_absent:
396 errmsg = _("missing operand");
397 *resultP = CGEN_PARSE_OPERAND_RESULT_ERROR;
398 break;
399 case O_constant:
400 if (want == CGEN_PARSE_OPERAND_SYMBOLIC)
401 goto de_fault;
402 *valueP = exp.X_add_number;
403 *resultP = CGEN_PARSE_OPERAND_RESULT_NUMBER;
404 break;
405 case O_register:
406 *valueP = exp.X_add_number;
407 *resultP = CGEN_PARSE_OPERAND_RESULT_REGISTER;
408 break;
409 de_fault:
410 default:
411 #ifdef OBJ_COMPLEX_RELC
412 /* Look up operand, check to see if there's an obvious
413 overflow (this helps disambiguate some insn parses). */
414 operand = cgen_operand_lookup_by_num (cd, opindex);
415 errmsg = weak_operand_overflow_check (& exp, operand);
416
417 if (! errmsg)
418 {
419 /* Fragment the expression as necessary, and queue a reloc. */
420 memset (& dummy_fixup, 0, sizeof (fixS));
421
422 reloc_type = md_cgen_lookup_reloc (0, operand, & dummy_fixup);
423
424 if (exp.X_op == O_symbol
425 && reloc_type == BFD_RELOC_RELC
426 && exp.X_add_symbol->sy_value.X_op == O_constant
427 && (!exp.X_add_symbol->bsym
428 || (exp.X_add_symbol->bsym->section != expr_section
429 && exp.X_add_symbol->bsym->section != absolute_section
430 && exp.X_add_symbol->bsym->section != undefined_section)))
431 {
432 /* Local labels will have been (eagerly) turned into constants
433 by now, due to the inappropriately deep insight of the
434 expression parser. Unfortunately make_expr_symbol
435 prematurely dives into the symbol evaluator, and in this
436 case it gets a bad answer, so we manually create the
437 expression symbol we want here. */
438 stmp = symbol_create (FAKE_LABEL_NAME, expr_section, 0,
439 & zero_address_frag);
440 symbol_set_value_expression (stmp, & exp);
441 }
442 else
443 stmp = make_expr_symbol (& exp);
444
445 /* If this is a pc-relative RELC operand, we
446 need to subtract "." from the expression. */
447 if (reloc_type == BFD_RELOC_RELC
448 && CGEN_OPERAND_ATTR_VALUE (operand, CGEN_OPERAND_PCREL_ADDR))
449 stmp = expr_build_binary (O_subtract, stmp, expr_build_dot ());
450
451 /* FIXME: this is not a perfect heuristic for figuring out
452 whether an operand is signed: it only works when the operand
453 is an immediate. it's not terribly likely that any other
454 values will be signed relocs, but it's possible. */
455 if (operand && (operand->hw_type == HW_H_SINT))
456 signed_p = 1;
457
458 if (stmp->bsym && (stmp->bsym->section == expr_section)
459 && ! S_IS_LOCAL (stmp))
460 {
461 if (signed_p)
462 stmp->bsym->flags |= BSF_SRELC;
463 else
464 stmp->bsym->flags |= BSF_RELC;
465 }
466
467 /* Now package it all up for the fixup emitter. */
468 exp.X_op = O_symbol;
469 exp.X_op_symbol = 0;
470 exp.X_add_symbol = stmp;
471 exp.X_add_number = 0;
472
473 /* Re-init rightshift quantity, just in case. */
474 rightshift = operand->length;
475 queue_fixup_recursively (opindex, opinfo_1, & exp,
476 (reloc_type == BFD_RELOC_RELC) ?
477 & (operand->index_fields) : 0,
478 signed_p, -1);
479 }
480 * resultP = errmsg
481 ? CGEN_PARSE_OPERAND_RESULT_ERROR
482 : CGEN_PARSE_OPERAND_RESULT_QUEUED;
483 *valueP = 0;
484 #else
485 queue_fixup (opindex, opinfo_1, &exp);
486 *valueP = 0;
487 *resultP = CGEN_PARSE_OPERAND_RESULT_QUEUED;
488 #endif
489 break;
490 }
491
492 return errmsg;
493 }
494
495 /* md_operand handler to catch unrecognized expressions and halt the
496 parsing process so the next entry can be tried.
497
498 ??? This could be done differently by adding code to `expression'. */
499
500 void
gas_cgen_md_operand(expressionS * expressionP ATTRIBUTE_UNUSED)501 gas_cgen_md_operand (expressionS *expressionP ATTRIBUTE_UNUSED)
502 {
503 /* Don't longjmp if we're not called from within cgen_parse_operand(). */
504 if (expr_jmp_buf_p)
505 longjmp (expr_jmp_buf, 1);
506 }
507
508 /* Finish assembling instruction INSN.
509 BUF contains what we've built up so far.
510 LENGTH is the size of the insn in bits.
511 RELAX_P is non-zero if relaxable insns should be emitted as such.
512 Otherwise they're emitted in non-relaxable forms.
513 The "result" is stored in RESULT if non-NULL. */
514
515 void
gas_cgen_finish_insn(const CGEN_INSN * insn,CGEN_INSN_BYTES_PTR buf,unsigned int length,int relax_p,finished_insnS * result)516 gas_cgen_finish_insn (const CGEN_INSN *insn, CGEN_INSN_BYTES_PTR buf,
517 unsigned int length, int relax_p, finished_insnS *result)
518 {
519 int i;
520 int relax_operand;
521 char *f;
522 unsigned int byte_len = length / 8;
523
524 /* ??? Target foo issues various warnings here, so one might want to provide
525 a hook here. However, our caller is defined in tc-foo.c so there
526 shouldn't be a need for a hook. */
527
528 /* Write out the instruction.
529 It is important to fetch enough space in one call to `frag_more'.
530 We use (f - frag_now->fr_literal) to compute where we are and we
531 don't want frag_now to change between calls.
532
533 Relaxable instructions: We need to ensure we allocate enough
534 space for the largest insn. */
535
536 if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED))
537 /* These currently shouldn't get here. */
538 abort ();
539
540 /* Is there a relaxable insn with the relaxable operand needing a fixup? */
541
542 relax_operand = -1;
543 if (relax_p && CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXABLE))
544 {
545 /* Scan the fixups for the operand affected by relaxing
546 (i.e. the branch address). */
547
548 for (i = 0; i < num_fixups; ++i)
549 {
550 if (CGEN_OPERAND_ATTR_VALUE (cgen_operand_lookup_by_num (gas_cgen_cpu_desc, fixups[i].opindex),
551 CGEN_OPERAND_RELAX))
552 {
553 relax_operand = i;
554 break;
555 }
556 }
557 }
558
559 if (relax_operand != -1)
560 {
561 int max_len;
562 fragS *old_frag;
563 expressionS *exp;
564 symbolS *sym;
565 offsetT off;
566
567 #ifdef TC_CGEN_MAX_RELAX
568 max_len = TC_CGEN_MAX_RELAX (insn, byte_len);
569 #else
570 max_len = CGEN_MAX_INSN_SIZE;
571 #endif
572 /* Ensure variable part and fixed part are in same fragment. */
573 /* FIXME: Having to do this seems like a hack. */
574 frag_grow (max_len);
575
576 /* Allocate space for the fixed part. */
577 f = frag_more (byte_len);
578
579 /* Create a relaxable fragment for this instruction. */
580 old_frag = frag_now;
581
582 exp = &fixups[relax_operand].exp;
583 sym = exp->X_add_symbol;
584 off = exp->X_add_number;
585 if (exp->X_op != O_constant && exp->X_op != O_symbol)
586 {
587 /* Handle complex expressions. */
588 sym = make_expr_symbol (exp);
589 off = 0;
590 }
591
592 frag_var (rs_machine_dependent,
593 max_len - byte_len /* max chars */,
594 0 /* variable part already allocated */,
595 /* FIXME: When we machine generate the relax table,
596 machine generate a macro to compute subtype. */
597 1 /* subtype */,
598 sym,
599 off,
600 f);
601
602 /* Record the operand number with the fragment so md_convert_frag
603 can use gas_cgen_md_record_fixup to record the appropriate reloc. */
604 old_frag->fr_cgen.insn = insn;
605 old_frag->fr_cgen.opindex = fixups[relax_operand].opindex;
606 old_frag->fr_cgen.opinfo = fixups[relax_operand].opinfo;
607 if (result)
608 result->frag = old_frag;
609 }
610 else
611 {
612 f = frag_more (byte_len);
613 if (result)
614 result->frag = frag_now;
615 }
616
617 /* If we're recording insns as numbers (rather than a string of bytes),
618 target byte order handling is deferred until now. */
619 #if CGEN_INT_INSN_P
620 cgen_put_insn_value (gas_cgen_cpu_desc, (unsigned char *) f, length, *buf);
621 #else
622 memcpy (f, buf, byte_len);
623 #endif
624
625 /* Emit DWARF2 debugging information. */
626 dwarf2_emit_insn (byte_len);
627
628 /* Create any fixups. */
629 for (i = 0; i < num_fixups; ++i)
630 {
631 fixS *fixP;
632 const CGEN_OPERAND *operand =
633 cgen_operand_lookup_by_num (gas_cgen_cpu_desc, fixups[i].opindex);
634
635 /* Don't create fixups for these. That's done during relaxation.
636 We don't need to test for CGEN_INSN_RELAXED as they can't get here
637 (see above). */
638 if (relax_p
639 && CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXABLE)
640 && CGEN_OPERAND_ATTR_VALUE (operand, CGEN_OPERAND_RELAX))
641 continue;
642
643 #ifndef md_cgen_record_fixup_exp
644 #define md_cgen_record_fixup_exp gas_cgen_record_fixup_exp
645 #endif
646
647 fixP = md_cgen_record_fixup_exp (frag_now, f - frag_now->fr_literal,
648 insn, length, operand,
649 fixups[i].opinfo,
650 &fixups[i].exp);
651 fixP->fx_cgen.field = fixups[i].field;
652 fixP->fx_cgen.msb_field_p = fixups[i].msb_field_p;
653 if (result)
654 result->fixups[i] = fixP;
655 }
656
657 if (result)
658 {
659 result->num_fixups = num_fixups;
660 result->addr = f;
661 }
662 }
663
664 #ifdef OBJ_COMPLEX_RELC
665 /* Queue many fixups, recursively. If the field is a multi-ifield,
666 repeatedly queue its sub-parts, right shifted to fit into the field (we
667 assume here multi-fields represent a left-to-right, MSB0-LSB0
668 reading). */
669
670 static void
queue_fixup_recursively(const int opindex,const int opinfo,expressionS * expP,const CGEN_MAYBE_MULTI_IFLD * field,const int signed_p,const int part_of_multi)671 queue_fixup_recursively (const int opindex,
672 const int opinfo,
673 expressionS * expP,
674 const CGEN_MAYBE_MULTI_IFLD * field,
675 const int signed_p,
676 const int part_of_multi)
677 {
678 if (field && field->count)
679 {
680 int i;
681
682 for (i = 0; i < field->count; ++ i)
683 queue_fixup_recursively (opindex, opinfo, expP,
684 & (field->val.multi[i]), signed_p, i);
685 }
686 else
687 {
688 expressionS * new_exp = expP;
689
690 #ifdef DEBUG
691 printf ("queueing fixup for field %s\n",
692 (field ? field->val.leaf->name : "??"));
693 print_symbol_value (expP->X_add_symbol);
694 #endif
695 if (field && part_of_multi != -1)
696 {
697 rightshift -= field->val.leaf->length;
698
699 /* Shift reloc value by number of bits remaining after this
700 field. */
701 if (rightshift)
702 new_exp = make_right_shifted_expr (expP, rightshift, signed_p);
703 }
704
705 /* Truncate reloc values to length, *after* leftmost one. */
706 fixups[num_fixups].msb_field_p = (part_of_multi <= 0);
707 fixups[num_fixups].field = (CGEN_MAYBE_MULTI_IFLD *) field;
708
709 queue_fixup (opindex, opinfo, new_exp);
710 }
711 }
712
713 /* Encode the self-describing RELC reloc format's addend. */
714
715 static unsigned long
gas_cgen_encode_addend(const unsigned long start,const unsigned long len,const unsigned long oplen,const unsigned long wordsz,const unsigned long chunksz,const unsigned long signed_p,const unsigned long trunc_p)716 gas_cgen_encode_addend (const unsigned long start, /* in bits */
717 const unsigned long len, /* in bits */
718 const unsigned long oplen, /* in bits */
719 const unsigned long wordsz, /* in bytes */
720 const unsigned long chunksz, /* in bytes */
721 const unsigned long signed_p,
722 const unsigned long trunc_p)
723 {
724 unsigned long res = 0L;
725
726 res |= start & 0x3F;
727 res |= (oplen & 0x3F) << 6;
728 res |= (len & 0x3F) << 12;
729 res |= (wordsz & 0xF) << 18;
730 res |= (chunksz & 0xF) << 22;
731 res |= (CGEN_INSN_LSB0_P ? 1 : 0) << 27;
732 res |= signed_p << 28;
733 res |= trunc_p << 29;
734
735 return res;
736 }
737
738 /* Purpose: make a weak check that the expression doesn't overflow the
739 operand it's to be inserted into.
740
741 Rationale: some insns used to use %operators to disambiguate during a
742 parse. when these %operators are translated to expressions by the macro
743 expander, the ambiguity returns. we attempt to disambiguate by field
744 size.
745
746 Method: check to see if the expression's top node is an O_and operator,
747 and the mask is larger than the operand length. This would be an
748 overflow, so signal it by returning an error string. Any other case is
749 ambiguous, so we assume it's OK and return NULL. */
750
751 static const char *
weak_operand_overflow_check(const expressionS * exp,const CGEN_OPERAND * operand)752 weak_operand_overflow_check (const expressionS * exp,
753 const CGEN_OPERAND * operand)
754 {
755 const unsigned long len = operand->length;
756 unsigned long mask;
757 unsigned long opmask = (((1L << (len - 1)) - 1) << 1) | 1;
758
759 if (!exp)
760 return NULL;
761
762 if (exp->X_op != O_bit_and)
763 {
764 /* Check for implicit overflow flag. */
765 if (CGEN_OPERAND_ATTR_VALUE
766 (operand, CGEN_OPERAND_RELOC_IMPLIES_OVERFLOW))
767 return _("a reloc on this operand implies an overflow");
768 return NULL;
769 }
770
771 mask = exp->X_add_number;
772
773 if (exp->X_add_symbol
774 && exp->X_add_symbol->sy_value.X_op == O_constant)
775 mask |= exp->X_add_symbol->sy_value.X_add_number;
776
777 if (exp->X_op_symbol
778 && exp->X_op_symbol->sy_value.X_op == O_constant)
779 mask |= exp->X_op_symbol->sy_value.X_add_number;
780
781 /* Want to know if mask covers more bits than opmask.
782 this is the same as asking if mask has any bits not in opmask,
783 or whether (mask & ~opmask) is nonzero. */
784 if (mask && (mask & ~opmask))
785 {
786 #ifdef DEBUG
787 printf ("overflow: (mask = %8.8x, ~opmask = %8.8x, AND = %8.8x)\n",
788 mask, ~opmask, (mask & ~opmask));
789 #endif
790 return _("operand mask overflow");
791 }
792
793 return NULL;
794 }
795
796 static expressionS *
make_right_shifted_expr(expressionS * exp,const int amount,const int signed_p)797 make_right_shifted_expr (expressionS * exp,
798 const int amount,
799 const int signed_p)
800 {
801 symbolS * stmp = 0;
802 expressionS * new_exp;
803
804 stmp = expr_build_binary (O_right_shift,
805 make_expr_symbol (exp),
806 expr_build_uconstant (amount));
807
808 if (signed_p)
809 stmp->bsym->flags |= BSF_SRELC;
810 else
811 stmp->bsym->flags |= BSF_RELC;
812
813 /* Then wrap that in a "symbol expr" for good measure. */
814 new_exp = XNEW (expressionS);
815 memset (new_exp, 0, sizeof (expressionS));
816 new_exp->X_op = O_symbol;
817 new_exp->X_op_symbol = 0;
818 new_exp->X_add_symbol = stmp;
819 new_exp->X_add_number = 0;
820
821 return new_exp;
822 }
823
824 #endif
825
826 /* Apply a fixup to the object code. This is called for all the
827 fixups we generated by the call to fix_new_exp, above. In the call
828 above we used a reloc code which was the largest legal reloc code
829 plus the operand index. Here we undo that to recover the operand
830 index. At this point all symbol values should be fully resolved,
831 and we attempt to completely resolve the reloc. If we can not do
832 that, we determine the correct reloc code and put it back in the fixup. */
833
834 /* FIXME: This function handles some of the fixups and bfd_install_relocation
835 handles the rest. bfd_install_relocation (or some other bfd function)
836 should handle them all. */
837
838 void
gas_cgen_md_apply_fix(fixS * fixP,valueT * valP,segT seg ATTRIBUTE_UNUSED)839 gas_cgen_md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
840 {
841 char *where = fixP->fx_frag->fr_literal + fixP->fx_where;
842 valueT value = * valP;
843 /* Canonical name, since used a lot. */
844 CGEN_CPU_DESC cd = gas_cgen_cpu_desc;
845
846 if (fixP->fx_addsy == (symbolS *) NULL)
847 fixP->fx_done = 1;
848
849 /* We don't actually support subtracting a symbol. */
850 if (fixP->fx_subsy != (symbolS *) NULL)
851 as_bad_where (fixP->fx_file, fixP->fx_line, _("expression too complex"));
852
853 if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
854 {
855 int opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
856 const CGEN_OPERAND *operand = cgen_operand_lookup_by_num (cd, opindex);
857 const char *errmsg;
858 bfd_reloc_code_real_type reloc_type;
859 const CGEN_INSN *insn = fixP->fx_cgen.insn;
860 #ifdef OBJ_COMPLEX_RELC
861 int start;
862 int length;
863 int signed_p = 0;
864
865 if (fixP->fx_cgen.field)
866 {
867 /* Use the twisty little pointer path
868 back to the ifield if it exists. */
869 start = fixP->fx_cgen.field->val.leaf->start;
870 length = fixP->fx_cgen.field->val.leaf->length;
871 }
872 else
873 {
874 /* Or the far less useful operand-size guesstimate. */
875 start = operand->start;
876 length = operand->length;
877 }
878
879 /* FIXME: this is not a perfect heuristic for figuring out
880 whether an operand is signed: it only works when the operand
881 is an immediate. it's not terribly likely that any other
882 values will be signed relocs, but it's possible. */
883 if (operand && (operand->hw_type == HW_H_SINT))
884 signed_p = 1;
885 #endif
886
887 /* If the reloc has been fully resolved finish the operand here. */
888 /* FIXME: This duplicates the capabilities of code in BFD. */
889 if (fixP->fx_done
890 /* FIXME: If partial_inplace isn't set bfd_install_relocation won't
891 finish the job. Testing for pcrel is a temporary hack. */
892 || fixP->fx_pcrel)
893 {
894 CGEN_FIELDS *fields = xmalloc (CGEN_CPU_SIZEOF_FIELDS (cd));
895
896 CGEN_CPU_SET_FIELDS_BITSIZE (cd) (fields, CGEN_INSN_BITSIZE (insn));
897 CGEN_CPU_SET_VMA_OPERAND (cd) (cd, opindex, fields, (bfd_vma) value);
898
899 #if CGEN_INT_INSN_P
900 {
901 CGEN_INSN_INT insn_value =
902 cgen_get_insn_value (cd, (unsigned char *) where,
903 CGEN_INSN_BITSIZE (insn));
904
905 /* ??? 0 is passed for `pc'. */
906 errmsg = CGEN_CPU_INSERT_OPERAND (cd) (cd, opindex, fields,
907 &insn_value, (bfd_vma) 0);
908 cgen_put_insn_value (cd, (unsigned char *) where,
909 CGEN_INSN_BITSIZE (insn), insn_value);
910 }
911 #else
912 /* ??? 0 is passed for `pc'. */
913 errmsg = CGEN_CPU_INSERT_OPERAND (cd) (cd, opindex, fields,
914 (unsigned char *) where,
915 (bfd_vma) 0);
916 #endif
917 if (errmsg)
918 as_bad_where (fixP->fx_file, fixP->fx_line, "%s", errmsg);
919
920 free (fields);
921 }
922
923 if (fixP->fx_done)
924 return;
925
926 /* The operand isn't fully resolved. Determine a BFD reloc value
927 based on the operand information and leave it to
928 bfd_install_relocation. Note that this doesn't work when
929 partial_inplace == false. */
930
931 reloc_type = md_cgen_lookup_reloc (insn, operand, fixP);
932 #ifdef OBJ_COMPLEX_RELC
933 if (reloc_type == BFD_RELOC_RELC)
934 {
935 /* Change addend to "self-describing" form,
936 for BFD to handle in the linker. */
937 value = gas_cgen_encode_addend (start, operand->length,
938 length, fixP->fx_size,
939 cd->insn_chunk_bitsize / 8,
940 signed_p,
941 ! (fixP->fx_cgen.msb_field_p));
942 }
943 #endif
944
945 if (reloc_type != BFD_RELOC_NONE)
946 fixP->fx_r_type = reloc_type;
947 else
948 {
949 as_bad_where (fixP->fx_file, fixP->fx_line,
950 _("unresolved expression that must be resolved"));
951 fixP->fx_done = 1;
952 return;
953 }
954 }
955 else if (fixP->fx_done)
956 {
957 /* We're finished with this fixup. Install it because
958 bfd_install_relocation won't be called to do it. */
959 switch (fixP->fx_r_type)
960 {
961 case BFD_RELOC_8:
962 md_number_to_chars (where, value, 1);
963 break;
964 case BFD_RELOC_16:
965 md_number_to_chars (where, value, 2);
966 break;
967 case BFD_RELOC_32:
968 md_number_to_chars (where, value, 4);
969 break;
970 case BFD_RELOC_64:
971 md_number_to_chars (where, value, 8);
972 break;
973 default:
974 as_bad_where (fixP->fx_file, fixP->fx_line,
975 _("internal error: can't install fix for reloc type %d (`%s')"),
976 fixP->fx_r_type, bfd_get_reloc_code_name (fixP->fx_r_type));
977 break;
978 }
979 }
980 /* else
981 bfd_install_relocation will be called to finish things up. */
982
983 /* Tuck `value' away for use by tc_gen_reloc.
984 See the comment describing fx_addnumber in write.h.
985 This field is misnamed (or misused :-). */
986 fixP->fx_addnumber = value;
987 }
988
989 bfd_reloc_code_real_type
gas_cgen_pcrel_r_type(bfd_reloc_code_real_type r)990 gas_cgen_pcrel_r_type (bfd_reloc_code_real_type r)
991 {
992 switch (r)
993 {
994 case BFD_RELOC_8: r = BFD_RELOC_8_PCREL; break;
995 case BFD_RELOC_16: r = BFD_RELOC_16_PCREL; break;
996 case BFD_RELOC_24: r = BFD_RELOC_24_PCREL; break;
997 case BFD_RELOC_32: r = BFD_RELOC_32_PCREL; break;
998 case BFD_RELOC_64: r = BFD_RELOC_64_PCREL; break;
999 default:
1000 break;
1001 }
1002 return r;
1003 }
1004
1005 /* Translate internal representation of relocation info to BFD target format.
1006
1007 FIXME: To what extent can we get all relevant targets to use this? */
1008
1009 arelent *
gas_cgen_tc_gen_reloc(asection * section ATTRIBUTE_UNUSED,fixS * fixP)1010 gas_cgen_tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixP)
1011 {
1012 bfd_reloc_code_real_type r_type = fixP->fx_r_type;
1013 arelent *reloc;
1014
1015 reloc = XNEW (arelent);
1016
1017 #ifdef GAS_CGEN_PCREL_R_TYPE
1018 if (fixP->fx_pcrel)
1019 r_type = GAS_CGEN_PCREL_R_TYPE (r_type);
1020 #endif
1021 reloc->howto = bfd_reloc_type_lookup (stdoutput, r_type);
1022
1023 if (reloc->howto == (reloc_howto_type *) NULL)
1024 {
1025 as_bad_where (fixP->fx_file, fixP->fx_line,
1026 _("relocation is not supported"));
1027 return NULL;
1028 }
1029
1030 gas_assert (!fixP->fx_pcrel == !reloc->howto->pc_relative);
1031
1032 reloc->sym_ptr_ptr = XNEW (asymbol *);
1033 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy);
1034
1035 /* Use fx_offset for these cases. */
1036 if (fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY
1037 || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT)
1038 reloc->addend = fixP->fx_offset;
1039 else
1040 reloc->addend = fixP->fx_addnumber;
1041
1042 reloc->address = fixP->fx_frag->fr_address + fixP->fx_where;
1043 return reloc;
1044 }
1045
1046 /* Perform any cgen specific initialisation.
1047 Called after gas_cgen_cpu_desc has been created. */
1048
1049 void
gas_cgen_begin(void)1050 gas_cgen_begin (void)
1051 {
1052 if (flag_signed_overflow_ok)
1053 cgen_set_signed_overflow_ok (gas_cgen_cpu_desc);
1054 else
1055 cgen_clear_signed_overflow_ok (gas_cgen_cpu_desc);
1056 }
1057