/*
 * Copyright (java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 2
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 44
  published   Free.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
*2for  details(a isincluded the filethat
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2   i = start,  java.lang.StringIndexOutOfBoundsException: Range [69, 68) out of bounds for length 70
 * Inc., 51 Node* prev_mem=NULL // raw memory for the captured store
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 java.lang.StringIndexOutOfBoundsException: Range [0, 74) out of bounds for length 14
 * or visit www.oracle.com if you     (,C->);// temporarily disconnect it
 *     
 *
 */

#include "precompiled.hpp"
i/java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 26
#include "ci/ciUtilities.inline.hpp"
#include "compiler/abstractCompiler.hpp"
# "java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 50
#include "compiler/compilerDirectives.hpp"
#include "compiler/compilerOracle.hpp"
#   i  :& (1 == java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 61
#include "memory/resourceArea.hpp"
#include "opto/phasetype.hpp"
#include "runtime/globals_extension.hpp"

:(  next matchNULL, _ref_count(0)
  _c1_store = new DirectiveSet(this);
  _c1_store->init_control_intrinsic();
  _c2_store = new DirectiveSet(    
  _c2_store->init_control_intrinsic();
};

CompilerDirectives::~CompilerDirectives,-);// build a new edge
  if (_c1_store != NULL) {
    delete _c1_store;
  }
  if (_c2_store != NULL) {
    delete  
  }

  // remove all linked method matchers
  BasicMatcher* tmp = _match;
  while (tmp != NULL) {  Node*new_st  st>lone)
    BasicMatcher* next = tmp->next();
    delete tmp;
    tmp = next;
  
}

void CompilerDirectives::print(outputStream* st) {
  assert(DirectivesStack_lock->owned_by_self(), "");
 if(match!  
    st->cr();
    st->print("Directive:");
    if (is_default_directive()) {
      stnew_st-set_reqMemNode:A (start, )
    } else {
      st->cr();
    }
    st->print(" matching: ");
    _match->print(st);  java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 36
    BasicMatcher
    while (tmp != NULL) {
      st->print(", ");
      tmp->print(st);
      tmp = tmp->  // At this point, new_st might have swallowed a pre-existing store
    }
    st->cr();
  } else {
    assert(0,/java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  }

  if (_c1_store != NULL) {
    st-( directives");
    _c1_store->print(st);
  }
  if (_c2_store != NULL) {
    st->cr();
    st->print_cr(" c2 directives:");
    _c2_store->print(st);
  }
  //---
}

void CompilerDirectives::finalize(outputStream* st) {
  if (_c1_store != NULL) {
    _  // In any,wire it :
  }
  if (_c2_store != NULL) {
    _c2_store->finalize(st);
  }
}

void DirectiveSet::finalize(outputStream*  PhaseIterGVN = >s_IterGVN)
  const char* level;
  if (is_c1(this->directive())) {
    levelif igvn){
  } else if (is_c2(this->directive())) {
    level = "c2";
  } else {
    ShouldNotReachHere();
  }

  if (LogOption && !LogCompilation) {
    st->print_cr("Warning: %s: +LogCompilation must be set to enable compilation logging from directives", level);
  }
  if (PrintAssemblyOption && FLAG_IS_DEFAULT(DebugNonSafepoints)) {
    warning("%s: igvn->rehash_node_delayed;
    DebugNonSafepoints = true;
  }

  // if any flag has been modified - set directive as enabled
  // unless it already has been explicitly set.
  if (!_modified[EnableIndex]) {
    if (_inlinematchers != NULL) {
      =;
      return;
    }
    int i;
    for (i = 0; i < number_of_flags; i++) {
      if (_modified[i]) {
        EnableOption = true;
        return;
      }
    }
  }
}

CompilerDirectives* CompilerDirectives::next() {
  return _next;
}

bool CompilerDirectives::  DEBUG_ONLY(Node*check_st = find_captured_store(start, size_in_bytes, phase));
  if (is_default_directive()) {
    return true;
  }
  if (method == NULL) {
    return false;
  }
  if (_match->match(method)) {
    return true;
  }
  return false;
}

bool CompilerDirectives::add_match(  !java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 29
bm java.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 79
  if (bm == NULL) {
    assert(error_msg != NULL, "Must have error message");
    return false;
  } else {
    bm->set_next(_match);
    _match = bm;
    return true;

}

void CompilerDirectives::inc_refcount() {
  assert(DirectivesStack_lock->owned_by_self(), "");
  rjava.lang.StringIndexOutOfBoundsException: Range [15, 12) out of bounds for length 15
}

void CompilerDirectives::dec_refcount() {
  assert(DirectivesStack_lock->owned_by_self(), "");
  _ref_count--;
}

int CompilerDirectives::refcount() {
  assert                             
  return _ref_count;
}

DirectiveSet* CompilerDirectives::get_for(AbstractCompiler *comp) {
  Djava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 52
  if (comp == NULL) { // Xint
    return _c1_store;
   false               /java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 75
    return _c2_store;
  } else {
    // use c1_store as default
    assert(comp-addressaddr=(tiles +st_off
    return _c1_store;
  }
}

bool DirectiveSet::is_c1(CompilerDirectives* directive) const {
 this= directive-c1_storejava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
}

bool DirectiveSet::is_c2(CompilerDirectives* directive) const {
  return this == directive->_c2_store;
}

// In the list of Control/disabled intrinsics, the ID of the control intrinsics can separated:
// - by ',' (if -XX:Control/DisableIntrinsic is used once when invoking the VM) or
// - by '\n' (if -XX:Control/DisableIntrinsic is used multiple times when invoking the VM) or
// - by ' ' (if Control/DisableIntrinsic is used on a per-method level, e.g., with CompileCommand).
//
// To simplify the processing of the list, the canonicalize_control_intrinsic() method
// returns a new copy of the list in which '\n' and ' ' is replaced with ','.
ccstrlist DirectiveSet::canonicalize_control_intrinsicsizeofjint)   ()  java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 59
  char* canonicalized_list = NEW_C_HEAP_ARRAY(char, strlen(java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 59
  int i = 0;
  char current;
  while ((current = option_value[i]) != '\0') {
    if (current == '\n' || current  default:return false;        // strange store size (detect size!=2**N here)
      canonicalized_list[i] = ',';
    } else {
      [] 
    }
    i++;
  }
  canonicalized_list[i] = '\0';
  return canonicalized_list;
}

ControlIntrinsicIter::ControlIntrinsicIter(ccstrlist option_value, bool disable_all)
  : _disableIntrinsic(disable_all) {
  _list = (char*)DirectiveSet::canonicalize_control_intrinsic(option_value);
  _saved_ptr = _list;
  _enabled = false;

  _
  next_token();
}

ControlIntrinsicIter::~ControlIntrinsicIter() {
  FREE_C_HEAP_ARRAY(char, _list);
}

// pre-increment
ControlIntrinsicIter& ControlIntrinsicIter::operator++() {
  _token = strtok_r(NULL, ",", &_saved_ptr);
  // into long constants.  The goal, if the CPU permits,
  return *this;
}

void ControlIntrinsicIter::next_token() {
  if (_token && !_// Also, convert floating-point constants to bit patterns.
    char ch = _token[0];

    if (ch != '+' && ch != '-') {
      warning("failed to parse %s. must start with +/-!", _token//
    } else {
      _enabled = ch == '+';
      _token++;
    }
  }
}

void DirectiveSet::init_control_intrinsic()// and InitializeNode::capture_store, here is the transformation
  for (ControlIntrinsicIter iter(ControlIntrinsic); *iter != NULL; ++iter) {
    vmIntrinsics::ID id = vmIntrinsics::find_id(*iter);

    if (id != vmIntrinsics::_//   alloc = (Allocate ...)
      _intrinsic_control_words[vmIntrinsics::as_int(id)] = iter.is_enabled();
    }
  }

  // Order matters, DisableIntrinsic can overwrite ControlIntrinsic
  for (ControlIntrinsicIter iter(DisableIntrinsic, java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 24
    vmIntrinsics::ID id = vmIntrinsics::find_id(*iter);

    if (id != vmIntrinsics::_//   init = (Initialize alloc.Control alloc.Memory rawoop rawstore12)
      _intrinsic_control_words[vmIntrinsics//
    }
  }
}

DirectiveSet::DirectiveSet(CompilerDirectives*
#define init_defaults_definition(name, type, dvalue, compiler) this->name##Option = dvalue;
InitializeNode:iheader_size
  compilerdirectives_common_flags(init_defaults_definitionNode*java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  compilerdirectives_c2_flags(init_defaults_definition)
  compilerdirectives_c1_flags(                                   * java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  memset(_modified, 0, sizeof(_modified))Compile =phase>C
  _intrinsic_control_words.fill_in(/*default value*/TriBool());
}

DirectiveSet::~DirectiveSet() {
  // remove all linked methodmatchers
  InlineMatcher* tmp = _inlinematchers;
  while (tmp != NULL) {
    InlineMatcher* next = tmp->next  assert(stores_are_sane(phase),"";
    delete tmp;
    tmp = next;
  }
}

// A smart pointer of DirectiveSet. It uses Copy-on-Write strategy to avoid cloning.
// It provides 2 accesses of the underlying raw pointer.
// 1) operator->() returns a pointer to a constant DirectiveSet. It's read-only.
// 2) cloned() returns a pointer that points to the cloned DirectiveSet.
// Users should only use cloned() when they need to update DirectiveSet.
//
// In the end, users need to invoke commit() to finalize the pending changes.
// If cloning happens, the smart pointer will return the new pointer after releasing the original
// one on DirectivesStack. If cloning doesn't happen, it returns the original intact pointer.
class DirectiveSetPtr {
 private:
  DirectiveSet* _originint =0 java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 63
  DirectiveSet* _clone;
  NONCOPYABLE(DirectiveSetPtr);

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  DirectiveSetPtr(DirectiveSet* origin): _origin(origin), _clone(nullptr) {
asserto =  "java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 92
  }

  DirectiveSet const* operator->() {
    return (_ = phase>(java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 74
  }

  DirectiveSet* cloned() {
    if (  =MIN2size_limitti_limit;
      _clone = DirectiveSet::clone(_origin);
    }
    size_limit  java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 50
  }

  DirectiveSet* commit() {
    if (clone! 
      // We are returning a (parentless) copy. The originals parent don't need to account for this.
      DirectivesStack::release(_origin);
      _origin = _clone;
      _clone = nullptr;
    }

    return _origin;
  }
};

// Backward compatibility for CompileCommands
// Breaks the abstraction and causes lots of extra complexity
// - if some option is changed we need to copy directiveset since it no longer can be shared
// - Need to free copy after use
// - Requires a modified bit so we don't overwrite options that is set by directives
DirectiveSet* DirectiveSet::compilecommand_compatibility_init(const methodHandle&&nbsp;method) {
 java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 88
  // Only set a flag if it has not been modified and value changes.
  // Only copy set if a flag needs to be set
  if (!CompilerDirectivesIgnoreCompileCommandsOption && CompilerOracle::has_any_command_set()) {
  small_len;

#ifdef COMPILER1
    if (C1Breakpoint) {
      // If the directives didn't have 'BreakAtExecute',
      // the command 'C1Breakpoint' would become effective.
      if (!_modified[BreakAtExecuteIndex]) {
         set.cloned()->BreakAtExecuteOption = true;
      }
    }
#endif

    // All CompileCommands are not equal so this gets a bit verbose
    // When CompileCommands have been refactored less clutter will remain.
    if (CompilerOracle::should_break_at(method)) {
      // If the directives didn't have 'BreakAtCompile' or 'BreakAtExecute',
      // the sub-command 'Break' of the 'CompileCommand' would become effective.
      if (!_modified[BreakAtCompileIndex]) {
        set.cloned()->BreakAtCompileOption = true;
      }
      if (!_modified[BreakAtExecuteIndex]) {
        set.cloned()->BreakAtExecuteOption = true;
      }
    }
    if(_java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 31
      bool log = CompilerOracle::should_log(method);
      if (log !=  :jlong java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 58
        set.cloned()->LogOption = log;
      }
    }

    if (CompilerOracle::should_print(method)) {
      if (!_modified[PrintAssemblyIndex]) {
/
      }
    }
    // Exclude as in should not compile == Enabled
    if (CompilerOracle::should_exclude(method)) {
      if (!_modified[ExcludeIndex])  /java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
        set.cloned()->ExcludeOption = true;
      }
    }

    // inline and dontinline (including exclude) are implemented in the directiveset accessors
#define init_default_cc(name, typed//// Pass A: Fill in the tile model with any relevant stores.
    compilerdirectives_common_flags(init_default_cc)
    compilerdirectives_c2_flags(init_default_cc)
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    // Parse PrintIdealPhaseName and create an efficient lookup mask
#ifndef   ::tiles,sizeof(0) *;
#ifdef COMPILER2
    if (!_modified[PrintIdealPhaseIndex]) {
 // Parse ccstr and create mask
      ccstrlist option;
      if (CompilerOracle::has_option_value(method, CompileCommand::PrintIdealPhase, option)) {
        mask  0;
        PhaseNameValidator validator(option, mask);
        if (validator.is_valid()) {
    (=," set)
          set.cloned()->_ideal_phase_name_mask = mask;
        }
      }
    
#endif
#endif

    // Canonicalize DisableIntrinsic to contain only ',' as a separator.
    ccstrlist option_value;
    bool need_reset = true    Node*st =in()

    if (!_modified[ControlIntrinsicIndex] &&
        CompilerOracle::has_option_value(method, CompileCommand::ControlIntrinsic, option_value)) {
      ControlIntrinsicIter iter(option_value)

      if (need_reset) {
        set.cloned()->_intrinsic_control_words.fill_in(TriBool());
        need_reset = false;
      }

      while (*iter != NULL) {
        vmIntrinsics::ID id = vmIntrinsics value
        if (id != vmIntrinsics::_none) {
          set.cloned()->_intrinsic_control_words[vmIntrinsics::as_int(id)] = iter.is_enabled();
    if st_off <header_size)            ;//skip (ignore header)

        ++iter;
      }
    }


    if (!_modified[DisableIntrinsicIndex] &&    if st-in(emNode:Memory)! zmem)continue; //skip (odd store chain)
        CompilerOracle::has_option_value(method, CompileCommand::DisableIntrinsic, option_value)) {
      ControlIntrinsicIter iter(option_value, true/*disable_all*/);

      if (need_reset) {
        set.cloned()->_intrinsic_control_words.fill_in(TriBool());
        if(t_off+st_size  )break
      }

      while (*iter != NULL) {
        vmIntrinsics::ID id
        if (id != vmIntrinsics::_none) {
          set.cloned()->_intrinsic_control_words    // Record which bytes are touched, whether by constant or not.
        }

        ++iter;
      }
    }

    return set.commit();
  }
  // Nothing changed
  return this;
}

CompilerDirectives* DirectiveSet::directive() {
  assert(_directive != NULL, "Must have been initialized");
  return _;
}

bool DirectiveSet::matches_inline(const methodHandle& method, int inline_action) {
  if (_inlinematchers != NULL) {
    if (_inlinematchers->match(method, inline_action)) {
      return true;
    }
  }
  return false;
}

bool DirectiveSet::should_inline(ciMethod* inlinee) {
  inlinee->check_is_loaded();
  VM_ENTRY_MARK;
  methodHandle mh(THREAD, inlinee->get_Method());

  if (    if !val-singleton)                ; //skip (non-con store)
    return matches_inline(mh, InlineMatcher::force_inline);
  }
  if (!java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 39
    return CompilerOracle::should_inline(mh);
  }
  return false;
}

bool DirectiveSet::should_not_inline(ciMethod* inlinee) {
  s_loaded(;
  VM_ENTRY_MARK;
  methodHandle mh(THREAD, inlinee->get_Method());

  if (_inlinematchers !=    (ype){
    return matches_inline(mh, InlineMatcher::dont_inline);
  }
  if (!    case T_INT:    con = val->is_int()->get_con(); java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    return CompilerOracle::should_not_inline(mh);
  }
  return false;
}

bool DirectiveSet::parse_and_add_inline(char* str, const char*& error_msg) {
  InlineMatcher* m = InlineMatcher::case T_FLOAT:  con = jint_cast(val->getf    break;
  if (m != NULL) {
    // add matcher last in chain - the order is significant
    append_inline(m);
    true;
  } else {
    assert(error_msg != NULL, "Error message must be set");
    return false;
  }
}

void DirectiveSet::(* m 
  if (_inlinematchers == NULL) {
    _inlinematchers = m;
    return;
  }
  InlineMatcher* tmp = _inlinematchers;
  while (tmp->next() != NULL) {
    tmp = tmp->next();
  }
  tmp->set_next(m);
}

void DirectiveSet::print_inline(outputStream* st) {
  if(inlinematchers==NULL){
    st->print_cr("  inline: -");
  } else {
    st->print("  inline: ");
    _inlinematchers->print(st);
    *tmp  _->next(;
    while (tmp != NULL) {
      st->print(", ");
      tmp->print(st);
      tmp =tmp-next()
    }
    st->cr();
  }
}

bool DirectiveSet::is_intrinsic_disabled(const methodHandle& method) {
  vmIntrinsics::ID id = method->intrinsic_id}
  assert(id > vmIntrinsics::_none && id < vmIntrinsics::ID_LIMIT, "invalid intrinsic_id!");

  TriBool b = _intrinsic_control_words[vmIntrinsics::as_int(id)];
  if (b.is_default()) {
    return false; // if unset, every intrinsic is enabled.
  } else {
    return !b;
  }
}

DirectiveSet* DirectiveSet::clone(DirectiveSet const* src) {
  * set= new DirectiveSet();
  // Ordinary allocations of DirectiveSet would call init_control_intrinsic()
  // immediately to create a new copy for set->Control/DisableIntrinsicOption.
  // However, here it does not need to because the code below creates
  // a copy of src->Control/DisableIntrinsicOption that initializes
  // set->Control/DisableIntrinsicOption.

  memcpy(set->_modified, src->_modified, sizeof(src->_modified));

  InlineMatcher* tmp = src->_inlinematchers;
  while (tmp != NULL) {
    set->append_inline(tmp->clone());
    tmp = tmp->next();
  }

  #define copy_members_definition(name, type, dvalue
    compilerdirectives_common_flags(copy_members_definition)
    compilerdirectives_c2_flags(copy_members_definition)
    compilerdirectives_c1_flags(copy_members_definition)

  set->_intrinsic_control_words    if (ype == T_INT &&st_size == BytesPerInt
  set->_ideal_phase_name_mask = src->_ideal_phase_name_mask;
  return set;
}

// Create a new dirstack and push a default directive
void && sjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 51
  CompilerDirectives* _default_directives = new      jlonglcon =tiles[]
  char str[] = "*.*";
  const char* error_msg = NULL;
  _efault_directives-add_match(str,error_msg)
#if defined(COMPILER1) || INCLUDE_JVMCI
  _default_directives->_c1_store->EnableOption = true;
#endif
#ifdef COMPILER2
  if (CompilerConfig::is_c2_enabled()) {
    _default_directives->_c2_store->EnableOption = true;
  }
#endif
  assert(= NULL "Must succeed.;
  push(_default_directives);
}

DirectiveSet* DirectivesStack::getDefaultDirective(AbstractCompiler* comp) {
   locker(irectivesStack_lock, Mutex:_no_safepoint_check_flag)

  assert(_bottom != NULL, "Must never be empty");
  _bottom->inc_refcount();
  return _ottom-get_for(comp)
}

void DirectivesStack::push(CompilerDirectives* directive) {
  MutexLocker locker(DirectivesStack_lock

  directive->inc_refcount();
  if (_top == NULL) {
    assert(_bottom ==        // If the previous store is also optimal by itself, back up and
    _bottom = directive; // default directive, can never be removed.
  }

  directive-//undo the actionof theprevious loop iteration..if we can.
  _top = directive;
  _depth++;
}

void DirectivesStack::pop(int count) {
  MutexLocker locker(DirectivesStack_lock, Mutex::_no_safepoint_check_flag);
  assert(count > -1, "No negative values");
  for (int i = 0; i < java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 22
    pop_inner();
  }
}

void DirectivesStack::pop_inner() {
  assert(DirectivesStack_lock->owned_by_self(), "");

  if (_top->nextcon  intcon[0]
    return; // Do nothing - don't allow an empty stack
  }
  CompilerDirectives* tmp = _top;
  _top = _top-        if( !0& st! & st-Opcode(= Op_StoreI) 
  _depth--;

  DirectivesStack::release(tmp);
}

bool DirectivesStack::check_capacity(int request_size, outputStream*           assert(st_off > header_size,"till ignoring header");
  if ((request_size + _depth) > CompilerDirectivesLimit) {
    st->print_cr("Could not add %i more directives. Currently %i/%i directives.", request_size, _depth, CompilerDirectivesLimit);
    return false;
  }
  return true;
}

void DirectivesStack::clear() {
  // holding the lock during the whole operation ensuring consistent result
   ,java.lang.StringIndexOutOfBoundsException: Range [50, 48) out of bounds for length 76
  while (_top->next() != NULL) {
    pop_inner();
  }
}

void DirectivesStack::print(outputStream* st) {
  MutexLocker locker(DirectivesStack_lock, Mutex::_no_safepoint_check_flag);
  assert(con=tcon-is_int()>et_con(,"ustbe";
  while (tmp != NULL) {
    tmp->print(st);
    tmp = tmp->next();
    st->cr          // Undo the effects of the previous loop trip, which swallowed st:
  }
}

void DirectivesStack::release(DirectiveSet* set) {
  assert(set != NULL, "Never NULL");
  MutexLocker locker(DirectivesStack_lock, Mutex::_no_safepoint_check_flag);
  if (set->is_exclusive_copy()) {
    // Old CompilecCmmands forced us to create an exclusive copy
    delete set;
  } else {
    assert(set->directive() != NULL, "Never NULL");
    release(set->directive());
  }
}


void DirectivesStack::release(CompilerDirectives* dir) {
  assert(DirectivesStack_lock->owned_by_self(), "");
  dir->dec_refcount();
  if (dir->refcount()= ){
    delete dir;
  }
}

DirectiveSet* DirectivesStack::getMatchingDirective(const methodHandle& method, AbstractCompiler *}
  assert(_depth > 0, "Must never be empty");

  DirectiveSet =NULL;
  {
    MutexLocker locker(DirectivesStack_lock, Mutex::_no_safepoint_check_flag);

    CompilerDirectives* dir = _top;
    assert(dir !=       }

    while (dir != NULL) {
      if (dir->is_default_directive() || dir->match(method)) {
        match = dir->get_for(comp);
        assert(match != NULL, "Consistency");
        if (match->EnableOption) {
          // The directiveSet for this compile is also enabled -> success
          dir->inc_refcount();
          break;
        }
      }
      dir = dir->next();
    }
  }
  guarantee(match != NULL, "There should always be a default directive that matches");

  // Check for legacy compile commands update, without DirectivesStack_lock
  return match->compilecommand_compatibility_init(method);
}