src/share/vm/opto/memnode.cpp

*** 41,50 ****
--- 41,51 ----
  #include "opto/mulnode.hpp"
  #include "opto/narrowptrnode.hpp"
  #include "opto/phaseX.hpp"
  #include "opto/regmask.hpp"
  #include "utilities/copy.hpp"
+ #include "utilities/vmError.hpp"
  
  // Portions of code courtesy of Clifford Click
  
  // Optimization - Graph Style
  
*** 711,721 ****
  const TypePtr* MemNode::calculate_adr_type(const Type* t, const TypePtr* cross_check) {
    if (t == Type::TOP)  return NULL; // does not touch memory any more?
    #ifdef PRODUCT
    cross_check = NULL;
    #else
!   if (!VerifyAliases || is_error_reported() || Node::in_dump())  cross_check = NULL;
    #endif
    const TypePtr* tp = t->isa_ptr();
    if (tp == NULL) {
      assert(cross_check == NULL || cross_check == TypePtr::BOTTOM, "expected memory type must be wide");
      return TypePtr::BOTTOM;           // touches lots of memory
--- 712,722 ----
  const TypePtr* MemNode::calculate_adr_type(const Type* t, const TypePtr* cross_check) {
    if (t == Type::TOP)  return NULL; // does not touch memory any more?
    #ifdef PRODUCT
    cross_check = NULL;
    #else
!   if (!VerifyAliases || VMError::is_error_reported() || Node::in_dump())  cross_check = NULL;
    #endif
    const TypePtr* tp = t->isa_ptr();
    if (tp == NULL) {
      assert(cross_check == NULL || cross_check == TypePtr::BOTTOM, "expected memory type must be wide");
      return TypePtr::BOTTOM;           // touches lots of memory
*** 4384,4394 ****
  }
  
  // verify a narrow slice (either incoming or outgoing)
  static void verify_memory_slice(const MergeMemNode* m, int alias_idx, Node* n) {
    if (!VerifyAliases)       return;  // don't bother to verify unless requested
!   if (is_error_reported())  return;  // muzzle asserts when debugging an error
    if (Node::in_dump())      return;  // muzzle asserts when printing
    assert(alias_idx >= Compile::AliasIdxRaw, "must not disturb base_memory or sentinel");
    assert(n != NULL, "");
    // Elide intervening MergeMem's
    while (n->is_MergeMem()) {
--- 4385,4395 ----
  }
  
  // verify a narrow slice (either incoming or outgoing)
  static void verify_memory_slice(const MergeMemNode* m, int alias_idx, Node* n) {
    if (!VerifyAliases)                return;  // don't bother to verify unless requested
!   if (VMError::is_error_reported())  return;  // muzzle asserts when debugging an error
    if (Node::in_dump())               return;  // muzzle asserts when printing
    assert(alias_idx >= Compile::AliasIdxRaw, "must not disturb base_memory or sentinel");
    assert(n != NULL, "");
    // Elide intervening MergeMem's
    while (n->is_MergeMem()) {
*** 4445,4455 ****
      // AliasLevel == 0 if we are organizing the memory states manually.
      // See verify_memory_slice for comments on TypeRawPtr::BOTTOM.
    } else {
      // make sure the stored slice is sane
      #ifdef ASSERT
!     if (is_error_reported() || Node::in_dump()) {
      } else if (might_be_same(n, base_memory())) {
        // Give it a pass:  It is a mostly harmless repetition of the base.
        // This can arise normally from node subsumption during optimization.
      } else {
        verify_memory_slice(this, alias_idx, n);
--- 4446,4456 ----
      // AliasLevel == 0 if we are organizing the memory states manually.
      // See verify_memory_slice for comments on TypeRawPtr::BOTTOM.
    } else {
      // make sure the stored slice is sane
      #ifdef ASSERT
!     if (VMError::is_error_reported() || Node::in_dump()) {
      } else if (might_be_same(n, base_memory())) {
        // Give it a pass:  It is a mostly harmless repetition of the base.
        // This can arise normally from node subsumption during optimization.
      } else {
        verify_memory_slice(this, alias_idx, n);