jdk8-mips64-public/hotspot: src/share/vm/code/compressedStream.hpp@246d977b51f2

7178670: runtime/7158800/BadUtf8.java fails in SymbolTable::rehash_table
Summary: Cannot delete _buckets and HashtableEntries in shared space (CDS)
Reviewed-by: acorn, kvn, dlong, dcubed, kamg

     1 /*

     2  * Copyright (c) 1997, 2010, 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  */

    25 #ifndef SHARE_VM_CODE_COMPRESSEDSTREAM_HPP

    26 #define SHARE_VM_CODE_COMPRESSEDSTREAM_HPP

    28 #include "memory/allocation.hpp"

    30 // Simple interface for filing out and filing in basic types

    31 // Used for writing out and reading in debugging information.

    33 class CompressedStream : public ResourceObj {

    34   friend class VMStructs;

    35  protected:

    36   u_char* _buffer;

    37   int     _position;

    39   enum {

    40     // Constants for UNSIGNED5 coding of Pack200

    41     lg_H = 6, H = 1<<lg_H,    // number of high codes (64)

    42     L = (1<<BitsPerByte)-H,   // number of low codes (192)

    43     MAX_i = 4                 // bytes are numbered in (0..4), max 5 bytes

    44   };

    46   // these inlines are defined only in compressedStream.cpp

    47   static inline juint encode_sign(jint  value);  // for Pack200 SIGNED5

    48   static inline jint  decode_sign(juint value);  // for Pack200 SIGNED5

    49   static inline juint reverse_int(juint bits);   // to trim trailing float 0's

    51  public:

    52   CompressedStream(u_char* buffer, int position = 0) {

    53     _buffer   = buffer;

    54     _position = position;

    55   }

    57   u_char* buffer() const               { return _buffer; }

    59   // Positioning

    60   int position() const                 { return _position; }

    61   void set_position(int position)      { _position = position; }

    62 };

    65 class CompressedReadStream : public CompressedStream {

    66  private:

    67   inline u_char read()                 { return _buffer[_position++]; }

    69   jint     read_int_mb(jint b0);  // UNSIGNED5 coding, 2-5 byte cases

    71  public:

    72   CompressedReadStream(u_char* buffer, int position = 0)

    73   : CompressedStream(buffer, position) {}

    75   jboolean read_bool()                 { return (jboolean) read();      }

    76   jbyte    read_byte()                 { return (jbyte   ) read();      }

    77   jchar    read_char()                 { return (jchar   ) read_int();  }

    78   jshort   read_short()                { return (jshort  ) read_signed_int(); }

    79   jint     read_int()                  { jint   b0 = read();

    80                                          if (b0 < L)  return b0;

    81                                          else         return read_int_mb(b0);

    82                                        }

    83   jint     read_signed_int();

    84   jfloat   read_float();               // jfloat_cast(reverse_int(read_int()))

    85   jdouble  read_double();              // jdouble_cast(2*reverse_int(read_int))

    86   jlong    read_long();                // jlong_from(2*read_signed_int())

    87 };

    90 class CompressedWriteStream : public CompressedStream {

    91  private:

    92   bool full() {

    93     return _position >= _size;

    94   }

    95   void store(u_char b) {

    96     _buffer[_position++] = b;

    97   }

    98   void write(u_char b) {

    99     if (full()) grow();

   100     store(b);

   101   }

   102   void grow();

   104   void write_int_mb(jint value);  // UNSIGNED5 coding, 1-5 byte cases

   106  protected:

   107   int _size;

   109  public:

   110   CompressedWriteStream(int initial_size);

   111   CompressedWriteStream(u_char* buffer, int initial_size, int position = 0)

   112   : CompressedStream(buffer, position) { _size = initial_size; }

   114   void write_bool(jboolean value)      { write(value);      }

   115   void write_byte(jbyte value)         { write(value);      }

   116   void write_char(jchar value)         { write_int(value); }

   117   void write_short(jshort value)       { write_signed_int(value);  }

   118   void write_int(jint value)           { if ((juint)value < L && !full())

   119                                                store((u_char)value);

   120                                          else  write_int_mb(value);  }

   121   void write_signed_int(jint value);   // write_int(encode_sign(value))

   122   void write_float(jfloat value);      // write_int(reverse_int(jint_cast(v)))

   123   void write_double(jdouble value);    // write_int(reverse_int(<low,high>))

   124   void write_long(jlong value);        // write_signed_int(<low,high>)

   125 };

   127 #endif // SHARE_VM_CODE_COMPRESSEDSTREAM_HPP

Mercurial > jdk8-mips64-public > hotspot / file revision

src/share/vm/code/compressedStream.hpp@246d977b51f2

src/share/vm/code/compressedStream.hpp