return region;
  final public static Address alignAllocation(Address region, int alignment,                                             int offset, int knownAlignment,                                              boolean fillAlignmentGap)      throws InlinePragma {    if (Assert.VERIFY_ASSERTIONS) {      Assert._assert(knownAlignment >= MIN_ALIGNMENT);      Assert._assert(MIN_ALIGNMENT >= BYTES_IN_INT);      Assert._assert(!(fillAlignmentGap && region.isZero()));      Assert._assert(alignment <= MAX_ALIGNMENT);      Assert._assert(offset >= 0);      Assert._assert(region.toWord().and(Word.fromIntSignExtend(MIN_ALIGNMENT-1)).isZero());      Assert._assert((alignment & (MIN_ALIGNMENT - 1)) == 0);      Assert._assert((offset & (MIN_ALIGNMENT - 1)) == 0);    }    // No alignment ever required.    if (alignment <= knownAlignment || MAX_ALIGNMENT <= MIN_ALIGNMENT)      return region;    // May require an alignment    Word mask = Word.fromIntSignExtend(alignment - 1);    Word negOff = Word.fromIntSignExtend(-offset);    Offset delta = negOff.minus(region.toWord()).and(mask).toOffset();    if (fillAlignmentGap && ALIGNMENT_VALUE != 0) {      if ((MAX_ALIGNMENT - MIN_ALIGNMENT) == BYTES_IN_INT) {        // At most a single hole        if (!delta.isZero()) {          region.store(ALIGNMENT_VALUE);          region = region.plus(delta);        }        return region;      } else {        while (delta.toWord().GT(Word.zero())) {          region.store(ALIGNMENT_VALUE);          region = region.plus(BYTES_IN_INT);          delta = delta.minus(BYTES_IN_INT);        }        return region;      }    }    return region.plus(delta);  }