Lines Matching +defs:label +defs:offset
69 of a constraint type, a variable, and an offset.
82 field" in each variable that points to the next field in offset
88 3. "offset", that tells the offset in bits from the beginning of the
101 foo.a -> id 1, size 32, offset 0, fullsize 64, next foo.b
102 foo.b -> id 2, size 32, offset 32, fullsize 64, next NULL
103 bar -> id 3, size 32, offset 0, fullsize 32, next NULL
145 on and turned into anything), but isn't. You can just see what offset
294 unsigned HOST_WIDE_INT offset;
432 vi->offset = 0;
439 vi2->offset = 1;
513 HOST_WIDE_INT offset;
516 /* Use 0x8000... as special unknown offset. */
569 /* Equivalence class representative for a label. This is used for
573 /* Pointer equivalence label for a node. All nodes with the same
574 pointer equivalence label can be unified together at some point
579 /* Pointer equivalence representative for a label. This is used to
585 /* Pointer equivalence label for each node, used during variable
589 /* Location equivalence label for each node, used during location
678 if (c->lhs.offset == UNKNOWN_OFFSET)
680 else if (c->lhs.offset != 0)
681 fprintf (file, " + " HOST_WIDE_INT_PRINT_DEC, c->lhs.offset);
688 if (c->rhs.offset == UNKNOWN_OFFSET)
690 else if (c->rhs.offset != 0)
691 fprintf (file, " + " HOST_WIDE_INT_PRINT_DEC, c->rhs.offset);
769 fprintf (file, " [label=\"\\N\\n");
852 return a.type == b.type && a.var == b.var && a.offset == b.offset;
865 return a.offset < b.offset;
997 /* If the offset is unknown we have to expand the solution to
1006 /* For non-zero offset union the offsetted solution into the destination. */
1019 HOST_WIDE_INT fieldoffset = vi->offset + inc;
1022 /* If the offset makes the pointer point to before the
1023 variable use offset zero for the field lookup. */
1040 while (vi->offset < fieldoffset + size);
1268 if (rhs.offset == 0 && lhs.offset == 0 && rhs.type == SCALAR)
1274 if (rhs.offset == 0 && lhs.offset == 0 && lhs.type == SCALAR)
1311 && lhsvar != rhsvar && lhs.offset == 0 && rhs.offset == 0)
1319 else if (lhs.offset != 0 || rhs.offset != 0)
1321 if (rhs.offset != 0)
1323 else if (lhs.offset != 0)
1354 if (rhs.offset == 0 && lhs.offset == 0 && rhs.type == SCALAR)
1359 if (rhs.offset == 0 && lhs.offset == 0 && lhs.type == SCALAR)
1369 && lhsvar != rhsvar && lhs.offset == 0 && rhs.offset == 0)
1624 HOST_WIDE_INT roffset = c->rhs.offset;
1627 gcc_checking_assert (c->lhs.offset == 0);
1637 /* If we do not know at with offset the rhs is dereferenced compute
1643 /* No further offset processing is necessary. */
1652 HOST_WIDE_INT fieldoffset = v->offset + roffset;
1690 while (v->offset < fieldoffset + size);
1712 HOST_WIDE_INT loff = c->lhs.offset;
1716 gcc_checking_assert (c->rhs.offset == 0);
1737 /* If we do not know at with offset the rhs is dereferenced compute
1752 HOST_WIDE_INT fieldoffset = v->offset + loff;
1798 while (v->offset < fieldoffset + size);
1833 && c->rhs.offset != 0 && c->lhs.offset == 0);
1836 flag = set_union_with_increment (tmp, delta, c->rhs.offset,
2008 All unlabeled nodes (label == 0) are not pointers and all edges
2024 and label it's nodes with DFS numbers. */
2287 fprintf (file, "[label=\"%s = {", get_varinfo (i)->name);
2289 fprintf (file, "[label=\"*%s = {",
2361 /* Actually the label the nodes for pointer equivalences */
2387 /* Look up the location equivalence label if one exists, or make
2488 unsigned int node, unsigned int label)
2491 substitute it for anything else with the same label.
2497 gcc_checking_assert (label < graph->size);
2499 if (graph->eq_rep[label] != -1)
2502 if (unite (graph->eq_rep[label], node))
2503 unify_nodes (graph, graph->eq_rep[label], node, false);
2504 return graph->eq_rep[label];
2508 graph->eq_rep[label] = node;
2509 graph->pe_rep[label] = node;
2514 gcc_checking_assert (label < graph->size);
2515 graph->pe[node] = label;
2516 if (graph->pe_rep[label] == -1)
2517 graph->pe_rep[label] = node;
2536 unsigned int label = graph->pe[i];
2537 if (label)
2539 int label_rep = graph->pe_rep[label];
2576 && (lhs.offset != 0 || rhs.offset != 0))
2955 vi->offset = 0;
2963 tmp.offset = 0;
2996 cexpr.offset = 0;
3026 cexpr.offset = 0;
3034 cexpr.offset = 0;
3093 else if ((rhs.type != SCALAR || rhs.offset != 0) && lhs.type == DEREF)
3103 gcc_assert (rhs.type != ADDRESSOF || rhs.offset == 0);
3128 get_constraint_for_ptr_offset (tree ptr, tree offset,
3143 /* If the offset is not a non-negative integer constant that fits
3147 if (offset == NULL_TREE
3148 || TREE_CODE (offset) != INTEGER_CST)
3152 /* Sign-extend the offset. */
3153 offset_int soffset = offset_int::from (wi::to_wide (offset), SIGNED);
3158 /* Make sure the bit-offset also fits. */
3184 /* If we do not know the offset add all subfields. */
3193 c2.offset = 0;
3203 unsigned HOST_WIDE_INT offset = curr->offset + rhsoffset;
3205 /* If curr->offset + rhsoffset is less than zero adjust it. */
3207 && curr->offset < offset)
3208 offset = 0;
3215 temp = first_or_preceding_vi_for_offset (curr, offset);
3217 c.offset = 0;
3220 && temp->offset < offset + curr->size)
3225 c2.offset = 0;
3232 gcc_assert (c.offset == 0);
3233 c.offset = rhsoffset;
3272 temp.offset = 0;
3290 result.offset = 0;
3295 /* Avoid creating pointer-offset constraints, so handle MEM_REF
3329 /* For single-field vars do not bother about the offset. */
3330 result.offset = 0;
3342 right offset, it may start in some padding. We only care about
3348 cexpr.offset = 0;
3351 if (ranges_maybe_overlap_p (poly_int64 (curr->offset),
3381 cexpr.offset = 0;
3405 || result.offset == UNKNOWN_OFFSET)
3406 result.offset = UNKNOWN_OFFSET;
3408 result.offset += const_bitpos;
3416 result.offset = 0;
3507 temp.offset = 0;
3518 temp.offset = 0;
3559 results->last ().offset = UNKNOWN_OFFSET;
3577 if (curr->offset - vi->offset < size)
3647 temp.offset = 0;
3657 temp.offset = 0;
3732 lhsp->offset = UNKNOWN_OFFSET;
3737 rhsp->offset = UNKNOWN_OFFSET;
3765 || ranges_overlap_p (lhsv->offset + rhsoffset, lhsv->size,
3766 rhsv->offset + lhsoffset, rhsv->size)))
3770 || (lhsv->offset + rhsoffset + lhsv->size
3771 > rhsv->offset + lhsoffset + rhsv->size)))
3795 includes.offset = 0;
3820 lhs.offset = 0;
3824 rhs.offset = 0;
3837 lhs.offset = 0;
3841 rhs.offset = 0;
3864 lhs.offset = 0;
3867 rhs.offset = UNKNOWN_OFFSET;
3881 lhs.offset = 0;
3884 rhs.offset = UNKNOWN_OFFSET;
3921 vi->offset = 0;
3982 c.offset = 0;
3992 c.offset = 0;
3998 c.offset = part;
4059 lhs.offset = 0;
4062 rhs.offset = 0;
4075 rhsc.offset = UNKNOWN_OFFSET;
4093 lhsc.offset = 0;
4101 rhsc.offset = 0;
4126 tmpc.offset = 0;
4160 tmpc.offset = 0;
4207 rhsc.offset = 0;
4231 ce.offset = UNKNOWN_OFFSET;
4237 rhsc.offset = 0;
4297 rhsc.offset = 0;
4302 rhsc.offset = 0;
4468 ac.offset = 0;
4493 tmpc.offset = 0;
4511 tmpc.offset = 0;
4595 nul.offset = 0;
4749 rhs.offset = 0;
4773 rhs.offset = 0;
5122 rhsc.offset = 0;
5516 first_vi_for_offset (varinfo_t start, unsigned HOST_WIDE_INT offset)
5518 /* If the offset is outside of the variable, bail out. */
5519 if (offset >= start->fullsize)
5522 /* If we cannot reach offset from start, lookup the first field
5524 if (start->offset > offset)
5530 offset when we have glommed a structure to a variable.
5531 In that case, however, offset should still be within the size
5533 if (offset >= start->offset
5534 && (offset - start->offset) < start->size)
5549 unsigned HOST_WIDE_INT offset)
5551 /* If we cannot reach offset from start, lookup the first field
5553 if (start->offset > offset)
5557 offset when we have glommed a structure to a variable.
5558 In that case, however, offset should still be within the size
5560 If we got beyond the offset we look for return the field
5561 directly preceding offset which may be the last field. */
5563 && offset >= start->offset
5564 && !((offset - start->offset) < start->size))
5572 to track the offset of the field, since bitpos_of_field gives it
5579 HOST_WIDE_INT offset;
5606 if (foa->offset < fob->offset)
5608 else if (foa->offset > fob->offset)
5620 /* Sort a fieldstack according to the field offset and sizes. */
5684 OFFSET is used to keep track of the offset in this entire
5691 HOST_WIDE_INT offset)
5717 (field_type, fieldstack, offset + foff)
5734 /* If there isn't anything at offset zero, create sth. */
5736 && offset + foff != 0)
5739 = {0, offset + foff, false, false, true, false, NULL_TREE};
5754 && pair->offset + (HOST_WIDE_INT)pair->size == offset + foff)
5761 e.offset = offset + foff;
5827 vi->offset = 0;
5850 clobbervi->offset = fi_clobbers;
5857 gcc_assert (prev_vi->offset < clobbervi->offset);
5866 usevi->offset = fi_uses;
5873 gcc_assert (prev_vi->offset < usevi->offset);
5890 chainvi->offset = fi_static_chain;
5902 gcc_assert (prev_vi->offset < chainvi->offset);
5924 resultvi->offset = fi_result;
5939 gcc_assert (prev_vi->offset < resultvi->offset);
5952 if (rvi && rvi->offset == fi_result)
5973 argvi->offset = fi_parm_base + i;
5987 gcc_assert (prev_vi->offset < argvi->offset);
6010 argvi->offset = fi_parm_base + num_args;
6020 gcc_assert (prev_vi->offset < argvi->offset);
6029 FIELDSTACK is assumed to be sorted by offset. */
6040 if (fo->offset == lastoffset)
6042 lastoffset = fo->offset;
6071 vi->offset = 0;
6096 || fo->offset < 0)
6126 vi->offset = 0;
6178 fo->offset, fo->size);
6188 newvi->offset = fo->offset;
6245 lhs.offset = 0;
6305 lhs.offset = 0;
6314 lhs.offset = 0;
7044 var_nothing->offset = 0;
7057 var_anything->offset = 0;
7066 lhs.offset = 0;
7069 rhs.offset = 0;
7082 var_string->offset = 0;
7093 var_escaped->offset = 0;
7103 var_nonlocal->offset = 0;
7111 lhs.offset = 0;
7114 rhs.offset = 0;
7121 lhs.offset = 0;
7124 rhs.offset = UNKNOWN_OFFSET;
7132 lhs.offset = 0;
7135 rhs.offset = 0;
7142 lhs.offset = 0;
7145 rhs.offset = 0;
7149 rhs.offset = 0;
7157 var_storedanything->offset = 0;
7169 var_integer->offset = 0;
7176 lhs.offset = 0;
7179 rhs.offset = 0;
8014 if (vi->offset)
8015 fprintf (file, "%soffset:" HOST_WIDE_INT_PRINT_DEC, sep, vi->offset);