jdk8-mips64-public/hotspot: src/cpu/zero/vm/nativeInst

     1 /*

     2  * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.

     3  * Copyright 2007 Red Hat, Inc.

     4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     5  *

     6  * This code is free software; you can redistribute it and/or modify it

     7  * under the terms of the GNU General Public License version 2 only, as

     8  * published by the Free Software Foundation.

     9  *

    10  * This code is distributed in the hope that it will be useful, but WITHOUT

    11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    13  * version 2 for more details (a copy is included in the LICENSE file that

    14  * accompanied this code).

    15  *

    16  * You should have received a copy of the GNU General Public License version

    17  * 2 along with this work; if not, write to the Free Software Foundation,

    18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    19  *

    20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    21  * or visit www.oracle.com if you need additional information or have any

    22  * questions.

    23  *

    24  */

    26 #ifndef CPU_ZERO_VM_NATIVEINST_ZERO_HPP

    27 #define CPU_ZERO_VM_NATIVEINST_ZERO_HPP

    29 #include "asm/assembler.hpp"

    30 #include "memory/allocation.hpp"

    31 #include "runtime/icache.hpp"

    32 #include "runtime/os.hpp"

    33 #include "utilities/top.hpp"

    35 // We have interfaces for the following instructions:

    36 // - NativeInstruction

    37 // - - NativeCall

    38 // - - NativeMovConstReg

    39 // - - NativeMovConstRegPatching

    40 // - - NativeJump

    41 // - - NativeIllegalOpCode

    42 // - - NativeReturn

    43 // - - NativeReturnX (return with argument)

    44 // - - NativePushConst

    45 // - - NativeTstRegMem

    47 // The base class for different kinds of native instruction abstractions.

    48 // Provides the primitive operations to manipulate code relative to this.

    50 class NativeInstruction VALUE_OBJ_CLASS_SPEC {

    51  public:

    52   bool is_jump() {

    53     ShouldNotCallThis();

    54     return false;

    55   }

    57   bool is_safepoint_poll() {

    58     ShouldNotCallThis();

    59     return false;

    60   }

    61 };

    63 inline NativeInstruction* nativeInstruction_at(address address) {

    64   ShouldNotCallThis();

    65   return NULL;

    66 }

    68 class NativeCall : public NativeInstruction {

    69  public:

    70   enum zero_specific_constants {

    71     instruction_size = 0 // not used within the interpreter

    72   };

    74   address instruction_address() const {

    75     ShouldNotCallThis();

    76     return NULL;

    77   }

    79   address next_instruction_address() const {

    80     ShouldNotCallThis();

    81     return NULL;

    82   }

    84   address return_address() const {

    85     ShouldNotCallThis();

    86     return NULL;

    87   }

    89   address destination() const {

    90     ShouldNotCallThis();

    91     return NULL;

    92   }

    94   void set_destination_mt_safe(address dest) {

    95     ShouldNotCallThis();

    96   }

    98   void verify_alignment() {

    99     ShouldNotCallThis();

   100   }

   102   void verify() {

   103     ShouldNotCallThis();

   104   }

   106   static bool is_call_before(address return_address) {

   107     ShouldNotCallThis();

   108     return false;

   109   }

   110 };

   112 inline NativeCall* nativeCall_before(address return_address) {

   113   ShouldNotCallThis();

   114   return NULL;

   115 }

   117 inline NativeCall* nativeCall_at(address address) {

   118   ShouldNotCallThis();

   119   return NULL;

   120 }

   122 class NativeMovConstReg : public NativeInstruction {

   123  public:

   124   address next_instruction_address() const {

   125     ShouldNotCallThis();

   126     return NULL;

   127   }

   129   intptr_t data() const {

   130     ShouldNotCallThis();

   131     return 0;

   132   }

   134   void set_data(intptr_t x) {

   135     ShouldNotCallThis();

   136   }

   137 };

   139 inline NativeMovConstReg* nativeMovConstReg_at(address address) {

   140   ShouldNotCallThis();

   141   return NULL;

   142 }

   144 class NativeMovRegMem : public NativeInstruction {

   145  public:

   146   int offset() const {

   147     ShouldNotCallThis();

   148     return 0;

   149   }

   151   void set_offset(intptr_t x) {

   152     ShouldNotCallThis();

   153   }

   155   void add_offset_in_bytes(int add_offset) {

   156     ShouldNotCallThis();

   157   }

   158 };

   160 inline NativeMovRegMem* nativeMovRegMem_at(address address) {

   161   ShouldNotCallThis();

   162   return NULL;

   163 }

   165 class NativeJump : public NativeInstruction {

   166  public:

   167   enum zero_specific_constants {

   168     instruction_size = 0 // not used within the interpreter

   169   };

   171   address jump_destination() const {

   172     ShouldNotCallThis();

   173     return NULL;

   174   }

   176   void set_jump_destination(address dest) {

   177     ShouldNotCallThis();

   178   }

   180   static void check_verified_entry_alignment(address entry,

   181                                              address verified_entry) {

   182   }

   184   static void patch_verified_entry(address entry,

   185                                    address verified_entry,

   186                                    address dest);

   187 };

   189 inline NativeJump* nativeJump_at(address address) {

   190   ShouldNotCallThis();

   191   return NULL;

   192 }

   194 class NativeGeneralJump : public NativeInstruction {

   195  public:

   196   address jump_destination() const {

   197     ShouldNotCallThis();

   198     return NULL;

   199   }

   201   static void insert_unconditional(address code_pos, address entry) {

   202     ShouldNotCallThis();

   203   }

   205   static void replace_mt_safe(address instr_addr, address code_buffer) {

   206     ShouldNotCallThis();

   207   }

   208 };

   210 inline NativeGeneralJump* nativeGeneralJump_at(address address) {

   211   ShouldNotCallThis();

   212   return NULL;

   213 }

   215 #endif // CPU_ZERO_VM_NATIVEINST_ZERO_HPP

src/cpu/zero/vm/nativeInst_zero.hpp@a9becfeecd1b