/* Hash function for candidate CAND. */ static hashval_t cand_hash (const void *cand) { const_cand_t c = (const_cand_t) cand; lra_insn_recog_data_t id = lra_get_insn_recog_data (c->insn); struct lra_static_insn_data *static_id = id->insn_static_data; int nops = static_id->n_operands; hashval_t hash = 0; for (int i = 0; i < nops; i++) if (i == c->nop) hash = iterative_hash_object (c->regno, hash); else if (static_id->operand[i].type == OP_IN) hash = iterative_hash_object (*id->operand_loc[i], hash); return hash; }
hashval_t iterative_hash_rtx (const_rtx x, hashval_t hash) { enum rtx_code code; enum machine_mode mode; int i, j; const char *fmt; if (x == NULL_RTX) return hash; code = GET_CODE (x); hash = iterative_hash_object (code, hash); mode = GET_MODE (x); hash = iterative_hash_object (mode, hash); switch (code) { case REG: i = REGNO (x); return iterative_hash_object (i, hash); case CONST_INT: return iterative_hash_object (INTVAL (x), hash); case SYMBOL_REF: if (XSTR (x, 0)) return iterative_hash (XSTR (x, 0), strlen (XSTR (x, 0)) + 1, hash); return hash; case LABEL_REF: case DEBUG_EXPR: case VALUE: case SCRATCH: case CONST_DOUBLE: case CONST_FIXED: case DEBUG_IMPLICIT_PTR: case DEBUG_PARAMETER_REF: return hash; default: break; } fmt = GET_RTX_FORMAT (code); for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) switch (fmt[i]) { case 'w': hash = iterative_hash_object (XWINT (x, i), hash); break; case 'n': case 'i': hash = iterative_hash_object (XINT (x, i), hash); break; case 'V': case 'E': j = XVECLEN (x, i); hash = iterative_hash_object (j, hash); for (j = 0; j < XVECLEN (x, i); j++) hash = iterative_hash_rtx (XVECEXP (x, i, j), hash); break; case 'e': hash = iterative_hash_rtx (XEXP (x, i), hash); break; case 'S': case 's': if (XSTR (x, i)) hash = iterative_hash (XSTR (x, 0), strlen (XSTR (x, 0)) + 1, hash); break; default: break; } return hash; }
/* Recursive hash function for RTL X. */ static hashval_t rtx_hash (rtx x) { int i, j; enum rtx_code code; const char *fmt; hashval_t val = 0; if (x == 0) return val; code = GET_CODE (x); val += (int) code + 4095; /* Some RTL can be compared nonrecursively. */ switch (code) { case REG: return val + REGNO (x); case LABEL_REF: return iterative_hash_object (XEXP (x, 0), val); case SYMBOL_REF: return iterative_hash_object (XSTR (x, 0), val); case SCRATCH: case CONST_DOUBLE: case CONST_INT: case CONST_VECTOR: return val; default: break; } /* Hash the elements. */ fmt = GET_RTX_FORMAT (code); for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) { switch (fmt[i]) { case 'w': val += XWINT (x, i); break; case 'n': case 'i': val += XINT (x, i); break; case 'V': case 'E': val += XVECLEN (x, i); for (j = 0; j < XVECLEN (x, i); j++) val += rtx_hash (XVECEXP (x, i, j)); break; case 'e': val += rtx_hash (XEXP (x, i)); break; case 'S': case 's': val += htab_hash_string (XSTR (x, i)); break; case 'u': case '0': case 't': break; /* It is believed that rtx's at this level will never contain anything but integers and other rtx's, except for within LABEL_REFs and SYMBOL_REFs. */ default: abort (); } } return val; }
static hashval_t cie_compute_hash (struct cie *c) { hashval_t h = 0; h = iterative_hash_object (c->length, h); h = iterative_hash_object (c->version, h); h = iterative_hash (c->augmentation, strlen (c->augmentation) + 1, h); h = iterative_hash_object (c->code_align, h); h = iterative_hash_object (c->data_align, h); h = iterative_hash_object (c->ra_column, h); h = iterative_hash_object (c->augmentation_size, h); h = iterative_hash_object (c->personality, h); h = iterative_hash_object (c->output_sec, h); h = iterative_hash_object (c->per_encoding, h); h = iterative_hash_object (c->lsda_encoding, h); h = iterative_hash_object (c->fde_encoding, h); h = iterative_hash_object (c->initial_insn_length, h); h = iterative_hash (c->initial_instructions, c->initial_insn_length, h); c->hash = h; return h; }