/*
 * Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
 * 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 only, as
 * published by the Free Software Foundation.
 *
 * 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
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */

#ifndef SHARE_VM_CODE_CODE_CACHE_EXTENSIONS_EXT_HPP
#define SHARE_VM_CODE_CODE_CACHE_EXTENSIONS_EXT_HPP

#include "utilities/macros.hpp"
#include "memory/allocation.hpp"
#include "utilities/globalDefinitions.hpp"
#include "interpreter/bytecodes.hpp"

class AdapterHandlerEntry;
class CodeBlob;
class CodeBuffer;
class InterpreterMacroAssembler;
class Template;

// All the methods defined here are placeholders for possible extensions.

class CodeCacheExtensions: AllStatic {
  friend class CodeCacheDumper;

public:
  // init both code saving and loading
  // Must be called very early, before any code is generated.
  static void initialize() {}

  // Check whether the generated interpreter will be saved.
  static bool saving_generated_interpreter() { return false; }

  // Check whether a pregenerated interpreter is used.
  static bool use_pregenerated_interpreter() { return false; }

  // Placeholder for additional VM initialization code
  static void complete_step(CodeCacheExtensionsSteps::Step phase) {}

  // Return false for newly generated code, on systems where it is not
  // executable.
  static bool is_executable(void *pc) { return true; }

  // Return whether dynamically generated code can be executable
  static bool support_dynamic_code() { return true; }

  // Skip new code generation when known to be useless.
  static bool skip_code_generation() { return false; }

  // Skip stubs used only for compiled code support.
  static bool skip_compiler_support() { return false; }

  // Ignore UseFastSignatureHandlers when returning false
  static bool support_fast_signature_handlers() { return true; }

  /////////////////////////
  // Handle generated code:
  // - allow newly generated code to be shared
  // - allow pregenerated code to be used in place of the newly generated one
  //   (modifying pc).
  // - support remapping when doing both save and load
  // 'remap' can be set to false if the addresses handled are not referenced
  // from code generated later.

  // Associate a name to a generated codelet and possibly modify the pc
  // Note: use instead the specialized versions when they exist:
  // - handle_generated_blob for CodeBlob
  // - handle_generated_handler for SignatureHandlers
  // See also the optimized calls below that handle several PCs at once.
  static void handle_generated_pc(address &pc, const char *name) {}

  // Adds a safe definition of the codelet, for codelets used right after
  // generation (else we would need to immediately stop the JVM and convert
  // the generated code to executable format before being able to go further).
  static void handle_generated_pc(address &pc, const char *name, address default_entry) {}

  // Special cases

  // Special case for CodeBlobs, which may require blob specific actions.
  static CodeBlob* handle_generated_blob(CodeBlob* blob, const char *name = NULL) { return blob; }

  // Special case for Signature Handlers.
  static void handle_generated_handler(address &handler_start, const char *name, address handler_end) {}

  // Support for generating different variants of the interpreter
  // that can be dynamically selected after reload.
  //
  // - init_interpreter_assembler allows to configure the assembler for
  //   the current variant
  //
  // - needs_other_interpreter_variant returns true as long as other
  //   variants are needed.
  //
  // - skip_template_interpreter_entries returns true if new entries
  //   need not be generated for this masm setup and this bytecode
  //
  // - completed_template_interpreter_entries is called after new
  //   entries have been generated and installed, for any non skipped
  //   bytecode.
  static void init_interpreter_assembler(InterpreterMacroAssembler* masm, CodeBuffer* code) {}
  static bool needs_other_interpreter_variant() { return false; }
  static bool skip_template_interpreter_entries(Bytecodes::Code code) { return false; }
  static void completed_template_interpreter_entries(InterpreterMacroAssembler* masm, Bytecodes::Code code) {}

  // Code size optimization. May optimize the requested size.
  static void size_blob(const char* name, int *updatable_size) {}

  // ergonomics
  static void set_ergonomics_flags() {}
};

#endif // SHARE_VM_CODE_CODE_CACHE_EXTENSIONS_EXT_HPP