1 /*
   2  * Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 
  25 package org.graalvm.compiler.code;
  26 
  27 import static jdk.vm.ci.meta.MetaUtil.identityHashCodeString;
  28 
  29 import java.nio.ByteBuffer;
  30 import java.util.ArrayList;
  31 import java.util.Iterator;
  32 import java.util.Objects;
  33 import java.util.function.BiConsumer;
  34 
  35 import org.graalvm.compiler.code.DataSection.Data;
  36 
  37 import jdk.vm.ci.code.site.DataSectionReference;
  38 import jdk.vm.ci.meta.SerializableConstant;
  39 import jdk.vm.ci.meta.VMConstant;
  40 
  41 public final class DataSection implements Iterable<Data> {
  42 
  43     public interface Patches {
  44 
  45         void registerPatch(int position, VMConstant c);
  46     }
  47 
  48     public abstract static class Data {
  49 
  50         private int alignment;
  51         private final int size;
  52 
  53         private DataSectionReference ref;
  54 
  55         protected Data(int alignment, int size) {
  56             this.alignment = alignment;
  57             this.size = size;
  58 
  59             // initialized in DataSection.insertData(Data)
  60             ref = null;
  61         }
  62 
  63         protected abstract void emit(ByteBuffer buffer, Patches patches);
  64 
  65         public void updateAlignment(int newAlignment) {
  66             if (newAlignment == alignment) {
  67                 return;
  68             }
  69             alignment = lcm(alignment, newAlignment);
  70         }
  71 
  72         public int getAlignment() {
  73             return alignment;
  74         }
  75 
  76         public int getSize() {
  77             return size;
  78         }
  79 
  80         @Override
  81         public int hashCode() {
  82             // Data instances should not be used as hash map keys
  83             throw new UnsupportedOperationException("hashCode");
  84         }
  85 
  86         @Override
  87         public String toString() {
  88             return identityHashCodeString(this);
  89         }
  90 
  91         @Override
  92         public boolean equals(Object obj) {
  93             assert ref != null;
  94             if (obj == this) {
  95                 return true;
  96             }
  97             if (obj instanceof Data) {
  98                 Data that = (Data) obj;
  99                 if (this.alignment == that.alignment && this.size == that.size && this.ref.equals(that.ref)) {
 100                     return true;
 101                 }
 102             }
 103             return false;
 104         }
 105     }
 106 
 107     public static final class RawData extends Data {
 108 
 109         private final byte[] data;
 110 
 111         public RawData(byte[] data, int alignment) {
 112             super(alignment, data.length);
 113             this.data = data;
 114         }
 115 
 116         @Override
 117         protected void emit(ByteBuffer buffer, Patches patches) {
 118             buffer.put(data);
 119         }
 120     }
 121 
 122     public static final class SerializableData extends Data {
 123 
 124         private final SerializableConstant constant;
 125 
 126         public SerializableData(SerializableConstant constant) {
 127             this(constant, 1);
 128         }
 129 
 130         public SerializableData(SerializableConstant constant, int alignment) {
 131             super(alignment, constant.getSerializedSize());
 132             this.constant = constant;
 133         }
 134 
 135         @Override
 136         protected void emit(ByteBuffer buffer, Patches patches) {
 137             int position = buffer.position();
 138             constant.serialize(buffer);
 139             assert buffer.position() - position == constant.getSerializedSize() : "wrong number of bytes written";
 140         }
 141     }
 142 
 143     public static class ZeroData extends Data {
 144 
 145         protected ZeroData(int alignment, int size) {
 146             super(alignment, size);
 147         }
 148 
 149         public static ZeroData create(int alignment, int size) {
 150             switch (size) {
 151                 case 1:
 152                     return new ZeroData(alignment, size) {
 153                         @Override
 154                         protected void emit(ByteBuffer buffer, Patches patches) {
 155                             buffer.put((byte) 0);
 156                         }
 157                     };
 158 
 159                 case 2:
 160                     return new ZeroData(alignment, size) {
 161                         @Override
 162                         protected void emit(ByteBuffer buffer, Patches patches) {
 163                             buffer.putShort((short) 0);
 164                         }
 165                     };
 166 
 167                 case 4:
 168                     return new ZeroData(alignment, size) {
 169                         @Override
 170                         protected void emit(ByteBuffer buffer, Patches patches) {
 171                             buffer.putInt(0);
 172                         }
 173                     };
 174 
 175                 case 8:
 176                     return new ZeroData(alignment, size) {
 177                         @Override
 178                         protected void emit(ByteBuffer buffer, Patches patches) {
 179                             buffer.putLong(0);
 180                         }
 181                     };
 182 
 183                 default:
 184                     return new ZeroData(alignment, size);
 185             }
 186         }
 187 
 188         @Override
 189         protected void emit(ByteBuffer buffer, Patches patches) {
 190             int rest = getSize();
 191             while (rest > 8) {
 192                 buffer.putLong(0L);
 193                 rest -= 8;
 194             }
 195             while (rest > 0) {
 196                 buffer.put((byte) 0);
 197                 rest--;
 198             }
 199         }
 200     }
 201 
 202     public static final class PackedData extends Data {
 203 
 204         private final Data[] nested;
 205 
 206         private PackedData(int alignment, int size, Data[] nested) {
 207             super(alignment, size);
 208             this.nested = nested;
 209         }
 210 
 211         public static PackedData create(Data[] nested) {
 212             int size = 0;
 213             int alignment = 1;
 214             for (int i = 0; i < nested.length; i++) {
 215                 assert size % nested[i].getAlignment() == 0 : "invalid alignment in packed constants";
 216                 alignment = DataSection.lcm(alignment, nested[i].getAlignment());
 217                 size += nested[i].getSize();
 218             }
 219             return new PackedData(alignment, size, nested);
 220         }
 221 
 222         @Override
 223         protected void emit(ByteBuffer buffer, Patches patches) {
 224             for (Data data : nested) {
 225                 data.emit(buffer, patches);
 226             }
 227         }
 228     }
 229 
 230     private final ArrayList<Data> dataItems = new ArrayList<>();
 231 
 232     private boolean closed;
 233     private int sectionAlignment;
 234     private int sectionSize;
 235 
 236     @Override
 237     public int hashCode() {
 238         // DataSection instances should not be used as hash map keys
 239         throw new UnsupportedOperationException("hashCode");
 240     }
 241 
 242     @Override
 243     public String toString() {
 244         return identityHashCodeString(this);
 245     }
 246 
 247     @Override
 248     public boolean equals(Object obj) {
 249         if (this == obj) {
 250             return true;
 251         }
 252         if (obj instanceof DataSection) {
 253             DataSection that = (DataSection) obj;
 254             if (this.closed == that.closed && this.sectionAlignment == that.sectionAlignment && this.sectionSize == that.sectionSize && Objects.equals(this.dataItems, that.dataItems)) {
 255                 return true;
 256             }
 257         }
 258         return false;
 259     }
 260 
 261     /**
 262      * Inserts a {@link Data} item into the data section. If the item is already in the data
 263      * section, the same {@link DataSectionReference} is returned.
 264      *
 265      * @param data the {@link Data} item to be inserted
 266      * @return a unique {@link DataSectionReference} identifying the {@link Data} item
 267      */
 268     public DataSectionReference insertData(Data data) {
 269         checkOpen();
 270         synchronized (data) {
 271             if (data.ref == null) {
 272                 data.ref = new DataSectionReference();
 273                 dataItems.add(data);
 274             }
 275             return data.ref;
 276         }
 277     }
 278 
 279     /**
 280      * Transfers all {@link Data} from the provided other {@link DataSection} to this
 281      * {@link DataSection}, and empties the other section.
 282      */
 283     public void addAll(DataSection other) {
 284         checkOpen();
 285         other.checkOpen();
 286 
 287         for (Data data : other.dataItems) {
 288             assert data.ref != null;
 289             dataItems.add(data);
 290         }
 291         other.dataItems.clear();
 292     }
 293 
 294     /**
 295      * Determines if this object has been {@link #close() closed}.
 296      */
 297     public boolean closed() {
 298         return closed;
 299     }
 300 
 301     /**
 302      * Computes the layout of the data section and closes this object to further updates.
 303      *
 304      * This must be called exactly once.
 305      */
 306     public void close() {
 307         checkOpen();
 308         closed = true;
 309 
 310         // simple heuristic: put items with larger alignment requirement first
 311         dataItems.sort((a, b) -> a.alignment - b.alignment);
 312 
 313         int position = 0;
 314         int alignment = 1;
 315         for (Data d : dataItems) {
 316             alignment = lcm(alignment, d.alignment);
 317             position = align(position, d.alignment);
 318 
 319             d.ref.setOffset(position);
 320             position += d.size;
 321         }
 322 
 323         sectionAlignment = alignment;
 324         sectionSize = position;
 325     }
 326 
 327     /**
 328      * Gets the size of the data section.
 329      *
 330      * This must only be called once this object has been {@linkplain #closed() closed}.
 331      */
 332     public int getSectionSize() {
 333         checkClosed();
 334         return sectionSize;
 335     }
 336 
 337     /**
 338      * Gets the minimum alignment requirement of the data section.
 339      *
 340      * This must only be called once this object has been {@linkplain #closed() closed}.
 341      */
 342     public int getSectionAlignment() {
 343         checkClosed();
 344         return sectionAlignment;
 345     }
 346 
 347     /**
 348      * Builds the data section into a given buffer.
 349      *
 350      * This must only be called once this object has been {@linkplain #closed() closed}.
 351      *
 352      * @param buffer the {@link ByteBuffer} where the data section should be built. The buffer must
 353      *            hold at least {@link #getSectionSize()} bytes.
 354      * @param patch a {@link Patches} instance to receive {@link VMConstant constants} for
 355      *            relocations in the data section
 356      */
 357     public void buildDataSection(ByteBuffer buffer, Patches patch) {
 358         buildDataSection(buffer, patch, (r, s) -> {
 359         });
 360     }
 361 
 362     /**
 363      * Builds the data section into a given buffer.
 364      *
 365      * This must only be called once this object has been {@linkplain #closed() closed}. When this
 366      * method returns, the buffers' position is just after the last data item.
 367      *
 368      * @param buffer the {@link ByteBuffer} where the data section should be built. The buffer must
 369      *            hold at least {@link #getSectionSize()} bytes.
 370      * @param patch a {@link Patches} instance to receive {@link VMConstant constants} for
 371      * @param onEmit a function that is called before emitting each data item with the
 372      *            {@link DataSectionReference} and the size of the data.
 373      */
 374     public void buildDataSection(ByteBuffer buffer, Patches patch, BiConsumer<DataSectionReference, Integer> onEmit) {
 375         checkClosed();
 376         assert buffer.remaining() >= sectionSize;
 377         int start = buffer.position();
 378         for (Data d : dataItems) {
 379             buffer.position(start + d.ref.getOffset());
 380             onEmit.accept(d.ref, d.getSize());
 381             d.emit(buffer, patch);
 382         }
 383         buffer.position(start + sectionSize);
 384     }
 385 
 386     public Data findData(DataSectionReference ref) {
 387         for (Data d : dataItems) {
 388             if (d.ref == ref) {
 389                 return d;
 390             }
 391         }
 392         return null;
 393     }
 394 
 395     public static void emit(ByteBuffer buffer, Data data, Patches patch) {
 396         data.emit(buffer, patch);
 397     }
 398 
 399     @Override
 400     public Iterator<Data> iterator() {
 401         return dataItems.iterator();
 402     }
 403 
 404     private static int lcm(int x, int y) {
 405         if (x == 0) {
 406             return y;
 407         } else if (y == 0) {
 408             return x;
 409         }
 410 
 411         int a = Math.max(x, y);
 412         int b = Math.min(x, y);
 413         while (b > 0) {
 414             int tmp = a % b;
 415             a = b;
 416             b = tmp;
 417         }
 418 
 419         int gcd = a;
 420         return x * y / gcd;
 421     }
 422 
 423     private static int align(int position, int alignment) {
 424         return ((position + alignment - 1) / alignment) * alignment;
 425     }
 426 
 427     private void checkClosed() {
 428         if (!closed) {
 429             throw new IllegalStateException();
 430         }
 431     }
 432 
 433     private void checkOpen() {
 434         if (closed) {
 435             throw new IllegalStateException();
 436         }
 437     }
 438 
 439     public void clear() {
 440         checkOpen();
 441         this.dataItems.clear();
 442         this.sectionAlignment = 0;
 443         this.sectionSize = 0;
 444     }
 445 }