+#ifdef OBJ_COMPLEX_RELC
+/* Queue many fixups, recursively. If the field is a multi-ifield,
+ repeatedly queue its sub-parts, right shifted to fit into the field (we
+ assume here multi-fields represent a left-to-right, MSB0-LSB0
+ reading). */
+
+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)
+{
+ if (field && field->count)
+ {
+ int i;
+
+ for (i = 0; i < field->count; ++ i)
+ queue_fixup_recursively (opindex, opinfo, expP,
+ & (field->val.multi[i]), signed_p, i);
+ }
+ else
+ {
+ expressionS * new_exp = expP;
+
+#ifdef DEBUG
+ printf ("queueing fixup for field %s\n",
+ (field ? field->val.leaf->name : "??"));
+ print_symbol_value (expP->X_add_symbol);
+#endif
+ if (field && part_of_multi != -1)
+ {
+ rightshift -= field->val.leaf->length;
+
+ /* Shift reloc value by number of bits remaining after this
+ field. */
+ if (rightshift)
+ new_exp = make_right_shifted_expr (expP, rightshift, signed_p);
+ }
+
+ /* Truncate reloc values to length, *after* leftmost one. */
+ fixups[num_fixups].msb_field_p = (part_of_multi <= 0);
+ fixups[num_fixups].field = (CGEN_MAYBE_MULTI_IFLD *) field;
+
+ queue_fixup (opindex, opinfo, new_exp);
+ }
+}
+
+/* Encode the self-describing RELC reloc format's addend. */
+
+static unsigned long
+gas_cgen_encode_addend (const unsigned long start, /* in bits */
+ const unsigned long len, /* in bits */
+ const unsigned long oplen, /* in bits */
+ const unsigned long wordsz, /* in bytes */
+ const unsigned long chunksz, /* in bytes */
+ const unsigned long signed_p,
+ const unsigned long trunc_p)
+{
+ unsigned long res = 0L;
+
+ res |= start & 0x3F;
+ res |= (oplen & 0x3F) << 6;
+ res |= (len & 0x3F) << 12;
+ res |= (wordsz & 0xF) << 18;
+ res |= (chunksz & 0xF) << 22;
+ res |= (CGEN_INSN_LSB0_P ? 1 : 0) << 27;
+ res |= signed_p << 28;
+ res |= trunc_p << 29;
+
+ return res;
+}
+
+/* Purpose: make a weak check that the expression doesn't overflow the
+ operand it's to be inserted into.
+
+ Rationale: some insns used to use %operators to disambiguate during a
+ parse. when these %operators are translated to expressions by the macro
+ expander, the ambiguity returns. we attempt to disambiguate by field
+ size.
+
+ Method: check to see if the expression's top node is an O_and operator,
+ and the mask is larger than the operand length. This would be an
+ overflow, so signal it by returning an error string. Any other case is
+ ambiguous, so we assume it's OK and return NULL. */
+
+static const char *
+weak_operand_overflow_check (const expressionS * exp,
+ const CGEN_OPERAND * operand)
+{
+ const unsigned long len = operand->length;
+ unsigned long mask;
+ unsigned long opmask = (((1L << (len - 1)) - 1) << 1) | 1;
+
+ if (!exp)
+ return NULL;
+
+ if (exp->X_op != O_bit_and)
+ {
+ /* Check for implicit overflow flag. */
+ if (CGEN_OPERAND_ATTR_VALUE
+ (operand, CGEN_OPERAND_RELOC_IMPLIES_OVERFLOW))
+ return _("a reloc on this operand implies an overflow");
+ return NULL;
+ }
+
+ mask = exp->X_add_number;
+
+ if (exp->X_add_symbol
+ && symbol_constant_p (exp->X_add_symbol))
+ mask |= *symbol_X_add_number (exp->X_add_symbol);
+
+ if (exp->X_op_symbol
+ && symbol_constant_p (exp->X_op_symbol))
+ mask |= *symbol_X_add_number (exp->X_op_symbol);
+
+ /* Want to know if mask covers more bits than opmask.
+ this is the same as asking if mask has any bits not in opmask,
+ or whether (mask & ~opmask) is nonzero. */
+ if (mask && (mask & ~opmask))
+ {
+#ifdef DEBUG
+ printf ("overflow: (mask = %8.8x, ~opmask = %8.8x, AND = %8.8x)\n",
+ mask, ~opmask, (mask & ~opmask));
+#endif
+ return _("operand mask overflow");
+ }
+
+ return NULL;
+}
+
+static expressionS *
+make_right_shifted_expr (expressionS * exp,
+ const int amount,
+ const int signed_p)
+{
+ symbolS * stmp = 0;
+ expressionS * new_exp;
+ asymbol *bsym;
+
+ stmp = expr_build_binary (O_right_shift,
+ make_expr_symbol (exp),
+ expr_build_uconstant (amount));
+ bsym = symbol_get_bfdsym (stmp);
+
+ if (signed_p)
+ bsym->flags |= BSF_SRELC;
+ else
+ bsym->flags |= BSF_RELC;
+
+ /* Then wrap that in a "symbol expr" for good measure. */
+ new_exp = XNEW (expressionS);
+ memset (new_exp, 0, sizeof (expressionS));
+ new_exp->X_op = O_symbol;
+ new_exp->X_op_symbol = 0;
+ new_exp->X_add_symbol = stmp;
+ new_exp->X_add_number = 0;
+
+ return new_exp;
+}
+
+#endif
+
projects / deliverable / binutils-gdb.git / blobdiff