44   }
 45 
 46   Array(OopHandle handle, ObjectHeap heap) {
 47     super(handle, heap);
 48   }
 49 
 50   private static void initialize(TypeDataBase db) throws WrongTypeException {
 51     Type type   = db.lookupType("arrayOopDesc");
 52     typeSize    = (int)type.getSize();
 53   }
 54 
 55   // Size of the arrayOopDesc
 56   private static long headerSize=0;
 57   private static long lengthOffsetInBytes=0;
 58   private static long typeSize;
 59 
 60   private static long headerSizeInBytes() {
 61     if (headerSize != 0) {
 62       return headerSize;
 63     }
 64     if (VM.getVM().isCompressedKlassPointersEnabled()) {
 65       headerSize = typeSize;
 66     } else {
 67       headerSize = VM.getVM().alignUp(typeSize + VM.getVM().getIntSize(),
 68                                       VM.getVM().getHeapWordSize());




 69     }
 70     return headerSize;
 71   }
 72 
 73   private static long headerSize(BasicType type) {
 74     if (Universe.elementTypeShouldBeAligned(type)) {
 75        return alignObjectSize(headerSizeInBytes())/VM.getVM().getHeapWordSize();
 76     } else {
 77       return headerSizeInBytes()/VM.getVM().getHeapWordSize();
 78     }
 79   }
 80 
 81   private long lengthOffsetInBytes() {
 82     if (lengthOffsetInBytes != 0) {
 83       return lengthOffsetInBytes;
 84     }
 85     if (VM.getVM().isCompressedKlassPointersEnabled()) {
 86       lengthOffsetInBytes = typeSize - VM.getVM().getIntSize();
 87     } else {
 88       lengthOffsetInBytes = typeSize;




 89     }
 90     return lengthOffsetInBytes;
 91   }
 92 
 93   // Accessors for declared fields
 94   public long getLength() {
 95     boolean isUnsigned = true;
 96     return this.getHandle().getCIntegerAt(lengthOffsetInBytes(), VM.getVM().getIntSize(), isUnsigned);
 97   }
 98 
 99   public long getObjectSize() {
100     ArrayKlass klass = (ArrayKlass) getKlass();
101     // We have to fetch the length of the array, shift (multiply) it
102     // appropriately, up to wordSize, add the header, and align to
103     // object size.
104     long s = getLength() << klass.getLog2ElementSize();
105     s += klass.getArrayHeaderInBytes();
106     s = Oop.alignObjectSize(s);
107     return s;
108   }
109 
110   public static long baseOffsetInBytes(BasicType type) {
111     return headerSize(type) * VM.getVM().getHeapWordSize();










112   }
113 
114   public boolean isArray()             { return true; }
115 
116   public void iterateFields(OopVisitor visitor, boolean doVMFields) {
117     super.iterateFields(visitor, doVMFields);
118   }
119 }

 44   }
 45 
 46   Array(OopHandle handle, ObjectHeap heap) {
 47     super(handle, heap);
 48   }
 49 
 50   private static void initialize(TypeDataBase db) throws WrongTypeException {
 51     Type type   = db.lookupType("arrayOopDesc");
 52     typeSize    = (int)type.getSize();
 53   }
 54 
 55   // Size of the arrayOopDesc
 56   private static long headerSize=0;
 57   private static long lengthOffsetInBytes=0;
 58   private static long typeSize;
 59 
 60   private static long headerSizeInBytes() {
 61     if (headerSize != 0) {
 62       return headerSize;
 63     }
 64     if (VM.getVM().isCompactObjectHeadersEnabled()) {
 65       headerSize = lengthOffsetInBytes() + VM.getVM().getIntSize();
 66     } else {
 67       if (VM.getVM().isCompressedKlassPointersEnabled()) {
 68         headerSize = typeSize;
 69       } else {
 70         headerSize = VM.getVM().alignUp(typeSize + VM.getVM().getIntSize(),
 71                                         VM.getVM().getHeapWordSize());
 72       }
 73     }
 74     return headerSize;
 75   }
 76 
 77   private static long headerSize(BasicType type) {
 78      if (Universe.elementTypeShouldBeAligned(type)) {
 79         return alignObjectSize(headerSizeInBytes())/VM.getVM().getHeapWordSize();
 80      } else {
 81        return headerSizeInBytes()/VM.getVM().getHeapWordSize();
 82      }
 83    }
 84 
 85   private static long lengthOffsetInBytes() {
 86     if (lengthOffsetInBytes != 0) {
 87       return lengthOffsetInBytes;
 88     }
 89     if (VM.getVM().isCompactObjectHeadersEnabled()) {
 90       lengthOffsetInBytes = Oop.getHeaderSize();
 91     } else {
 92       if (VM.getVM().isCompressedKlassPointersEnabled()) {
 93         lengthOffsetInBytes = typeSize - VM.getVM().getIntSize();
 94       } else {
 95         lengthOffsetInBytes = typeSize;
 96       }
 97     }
 98     return lengthOffsetInBytes;
 99   }
100 
101   // Accessors for declared fields
102   public long getLength() {
103     boolean isUnsigned = true;
104     return this.getHandle().getCIntegerAt(lengthOffsetInBytes(), VM.getVM().getIntSize(), isUnsigned);
105   }
106 
107   public long getObjectSize() {
108     ArrayKlass klass = (ArrayKlass) getKlass();
109     // We have to fetch the length of the array, shift (multiply) it
110     // appropriately, up to wordSize, add the header, and align to
111     // object size.
112     long s = getLength() << klass.getLog2ElementSize();
113     s += klass.getArrayHeaderInBytes();
114     s = Oop.alignObjectSize(s);
115     return s;
116   }
117 
118   public static long baseOffsetInBytes(BasicType type) {
119     if (VM.getVM().isCompactObjectHeadersEnabled()) {
120       long typeSizeInBytes = headerSizeInBytes();
121       if (Universe.elementTypeShouldBeAligned(type)) {
122         VM vm = VM.getVM();
123         return vm.alignUp(typeSizeInBytes, vm.getVM().getHeapWordSize());
124       } else {
125         return typeSizeInBytes;
126       }
127     } else {
128       return headerSize(type) * VM.getVM().getHeapWordSize();
129     }
130   }
131 
132   public boolean isArray()             { return true; }
133 
134   public void iterateFields(OopVisitor visitor, boolean doVMFields) {
135     super.iterateFields(visitor, doVMFields);
136   }
137 }