hotspot/src/share/vm/code/exceptionHandlerTable.cpp
author twisti
Wed, 25 Aug 2010 05:27:54 -0700
changeset 6418 6671edbd230e
parent 5547 f4b087cbb361
child 7397 5b173b4ca846
permissions -rw-r--r--
6978355: renaming for 6961697 Summary: This is the renaming part of 6961697 to keep the actual changes small for review. Reviewed-by: kvn, never
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 5547
diff changeset
     2
 * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
#include "incls/_precompiled.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
#include "incls/_exceptionHandlerTable.cpp.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
void ExceptionHandlerTable::add_entry(HandlerTableEntry entry) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
  _nesting.check();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
  if (_length >= _size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
    // not enough space => grow the table (amortized growth, double its size)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
    guarantee(_size > 0, "no space allocated => cannot grow the table since it is part of nmethod");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
    int new_size = _size * 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
    _table = REALLOC_RESOURCE_ARRAY(HandlerTableEntry, _table, _size, new_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
    _size = new_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
  assert(_length < _size, "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
  _table[_length++] = entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
HandlerTableEntry* ExceptionHandlerTable::subtable_for(int catch_pco) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
  int i = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
  while (i < _length) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
    HandlerTableEntry* t = _table + i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
    if (t->pco() == catch_pco) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
      // found subtable matching the catch_pco
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
      return t;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
      // advance to next subtable
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
      i += t->len() + 1; // +1 for header
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
ExceptionHandlerTable::ExceptionHandlerTable(int initial_size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  guarantee(initial_size > 0, "initial size must be > 0");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  _table  = NEW_RESOURCE_ARRAY(HandlerTableEntry, initial_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  _length = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  _size   = initial_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
ExceptionHandlerTable::ExceptionHandlerTable(const nmethod* nm) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  _table  = (HandlerTableEntry*)nm->handler_table_begin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  _length = nm->handler_table_size() / sizeof(HandlerTableEntry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  _size   = 0; // no space allocated by ExeptionHandlerTable!
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
void ExceptionHandlerTable::add_subtable(
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  int                 catch_pco,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  GrowableArray<intptr_t>* handler_bcis,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  GrowableArray<intptr_t>* scope_depths_from_top_scope,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  GrowableArray<intptr_t>* handler_pcos
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  assert(subtable_for(catch_pco) == NULL, "catch handlers for this catch_pco added twice");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  assert(handler_bcis->length() == handler_pcos->length(), "bci & pc table have different length");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  assert(scope_depths_from_top_scope == NULL || handler_bcis->length() == scope_depths_from_top_scope->length(), "bci & scope_depths table have different length");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  if (handler_bcis->length() > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
    // add subtable header
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
    add_entry(HandlerTableEntry(handler_bcis->length(), catch_pco, 0));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
    // add individual entries
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
    for (int i = 0; i < handler_bcis->length(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
      intptr_t scope_depth = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
      if (scope_depths_from_top_scope != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
        scope_depth = scope_depths_from_top_scope->at(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
      add_entry(HandlerTableEntry(handler_bcis->at(i), handler_pcos->at(i), scope_depth));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
      assert(entry_for(catch_pco, handler_bcis->at(i), scope_depth)->pco() == handler_pcos->at(i), "entry not added correctly (1)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
      assert(entry_for(catch_pco, handler_bcis->at(i), scope_depth)->scope_depth() == scope_depth, "entry not added correctly (2)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
void ExceptionHandlerTable::copy_to(nmethod* nm) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  assert(size_in_bytes() == nm->handler_table_size(), "size of space allocated in nmethod incorrect");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  memmove(nm->handler_table_begin(), _table, size_in_bytes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
HandlerTableEntry* ExceptionHandlerTable::entry_for(int catch_pco, int handler_bci, int scope_depth) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  HandlerTableEntry* t = subtable_for(catch_pco);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  if (t != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
    int l = t->len();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
    while (l-- > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
      t++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
      if (t->bci() == handler_bci && t->scope_depth() == scope_depth) return t;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
void ExceptionHandlerTable::print_subtable(HandlerTableEntry* t) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  int l = t->len();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  tty->print_cr("catch_pco = %d (%d entries)", t->pco(), l);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  while (l-- > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
    t++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
    tty->print_cr("  bci %d at scope depth %d -> pco %d", t->bci(), t->scope_depth(), t->pco());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
void ExceptionHandlerTable::print() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  tty->print_cr("ExceptionHandlerTable (size = %d bytes)", size_in_bytes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  int i = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  while (i < _length) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
    HandlerTableEntry* t = _table + i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
    print_subtable(t);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
    // advance to next subtable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
    i += t->len() + 1; // +1 for header
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
void ExceptionHandlerTable::print_subtable_for(int catch_pco) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  HandlerTableEntry* subtable = subtable_for(catch_pco);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  if( subtable != NULL ) { print_subtable( subtable ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
// ----------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
// Implicit null exception tables.  Maps an exception PC offset to a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
// continuation PC offset.  During construction it's a variable sized
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
// array with a max size and current length.  When stored inside an
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
// nmethod a zero length table takes no space.  This is detected by
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
// nul_chk_table_size() == 0.  Otherwise the table has a length word
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
// followed by pairs of <excp-offset, const-offset>.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
void ImplicitExceptionTable::set_size( uint size ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  _size = size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  _data = NEW_RESOURCE_ARRAY(implicit_null_entry, (size*2));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  _len = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
void ImplicitExceptionTable::append( uint exec_off, uint cont_off ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  assert( (sizeof(implicit_null_entry) >= 4) || (exec_off < 65535), "" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  assert( (sizeof(implicit_null_entry) >= 4) || (cont_off < 65535), "" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  uint l = len();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  if (l == _size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
    uint old_size_in_elements = _size*2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
    if (_size == 0) _size = 4;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
    _size *= 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
    uint new_size_in_elements = _size*2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
    _data = REALLOC_RESOURCE_ARRAY(uint, _data, old_size_in_elements, new_size_in_elements);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  *(adr(l)  ) = exec_off;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  *(adr(l)+1) = cont_off;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  _len = l+1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
uint ImplicitExceptionTable::at( uint exec_off ) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  uint l = len();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  for( uint i=0; i<l; i++ )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
    if( *adr(i) == exec_off )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
      return *(adr(i)+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  return 0;                     // Failed to find any execption offset
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
void ImplicitExceptionTable::print(address base) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  tty->print("{");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  for( uint i=0; i<len(); i++ )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
    tty->print("< "INTPTR_FORMAT", "INTPTR_FORMAT" > ",base + *adr(i), base + *(adr(i)+1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  tty->print_cr("}");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
ImplicitExceptionTable::ImplicitExceptionTable(const nmethod* nm) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  if (nm->nul_chk_table_size() == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
    _len = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
    _data = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
    // the first word is the length if non-zero, so read it out and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
    // skip to the next word to get the table.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
    _data  = (implicit_null_entry*)nm->nul_chk_table_begin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
    _len = _data[0];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
    _data++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  _size = len();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  assert(size_in_bytes() <= nm->nul_chk_table_size(), "size of space allocated in nmethod incorrect");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
void ImplicitExceptionTable::copy_to( nmethod* nm ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  assert(size_in_bytes() <= nm->nul_chk_table_size(), "size of space allocated in nmethod incorrect");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  if (len() != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
    implicit_null_entry* nmdata = (implicit_null_entry*)nm->nul_chk_table_begin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
    // store the length in the first uint
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
    nmdata[0] = _len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
    nmdata++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
    // copy the table after the length
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
    memmove( nmdata, _data, 2 * len() * sizeof(implicit_null_entry));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
    // zero length table takes zero bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
    assert(size_in_bytes() == 0, "bad size");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
    assert(nm->nul_chk_table_size() == 0, "bad size");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
void ImplicitExceptionTable::verify(nmethod *nm) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  for (uint i = 0; i < len(); i++) {
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 5547
diff changeset
   222
     if ((*adr(i) > (unsigned int)nm->insts_size()) ||
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 5547
diff changeset
   223
         (*(adr(i)+1) > (unsigned int)nm->insts_size()))
5403
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 1
diff changeset
   224
       fatal(err_msg("Invalid offset in ImplicitExceptionTable at " PTR_FORMAT, _data));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
}