const MemRegion *R;
/// The bit offset within the base region. It shouldn't be negative.
- uint64_t Offset;
+ int64_t Offset;
public:
RegionOffset(const MemRegion *r) : R(r), Offset(0) {}
- RegionOffset(const MemRegion *r, uint64_t off) : R(r), Offset(off) {}
+ RegionOffset(const MemRegion *r, int64_t off) : R(r), Offset(off) {}
const MemRegion *getRegion() const { return R; }
- uint64_t getOffset() const { return Offset; }
+ int64_t getOffset() const { return Offset; }
};
//===----------------------------------------------------------------------===//
public:
const MemRegion *R;
Interval I;
- RegionInterval(const MemRegion *r, uint64_t s, uint64_t e) : R(r), I(s, e){}
+ RegionInterval(const MemRegion *r, int64_t s, int64_t e) : R(r), I(s, e){}
};
RegionInterval RegionToInterval(const MemRegion *R);
switch (R->getKind()) {
case MemRegion::VarRegionKind: {
QualType T = cast<VarRegion>(R)->getValueType(Ctx);
- uint64_t Size = Ctx.getTypeSize(T);
+ int64_t Size = Ctx.getTypeSize(T);
return RegionInterval(R, 0, Size-1);
}
// with symbolic offsets.
if (!Offset.getRegion())
return RegionInterval(0, 0, 0);
- uint64_t Start = Offset.getOffset();
- uint64_t Size = Ctx.getTypeSize(cast<TypedRegion>(R)->getValueType(Ctx));
+ int64_t Start = Offset.getOffset();
+ int64_t Size = Ctx.getTypeSize(cast<TypedRegion>(R)->getValueType(Ctx));
return RegionInterval(Offset.getRegion(), Start, Start+Size);
}
RegionOffset MemRegion::getAsOffset() const {
const MemRegion *R = this;
- uint64_t Offset = 0;
+ int64_t Offset = 0;
while (1) {
switch (R->getKind()) {
SVal Index = ER->getIndex();
if (const nonloc::ConcreteInt *CI=dyn_cast<nonloc::ConcreteInt>(&Index)) {
int64_t i = CI->getValue().getSExtValue();
- assert(i >= 0);
CharUnits Size = getContext().getTypeSizeInChars(EleTy);
Offset += i * Size.getQuantity() * 8;
} else {