jdk8-mips64-public/hotspot: src/share/vm/asm/register.hpp@166d744df0de

8055494: Add C2 x86 intrinsic for BigInteger::multiplyToLen() method
Summary: Add new C2 intrinsic for BigInteger::multiplyToLen() on x86 in 64-bit VM.
Reviewed-by: roland

     1 /*

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

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

     4  *

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

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

     7  * published by the Free Software Foundation.

     8  *

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

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

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

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

    13  * accompanied this code).

    14  *

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

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

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

    18  *

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

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

    21  * questions.

    22  *

    23  */

    25 #ifndef SHARE_VM_ASM_REGISTER_HPP

    26 #define SHARE_VM_ASM_REGISTER_HPP

    28 #include "utilities/top.hpp"

    30 // Use AbstractRegister as shortcut

    31 class AbstractRegisterImpl;

    32 typedef AbstractRegisterImpl* AbstractRegister;

    35 // The super class for platform specific registers. Instead of using value objects,

    36 // registers are implemented as pointers. Subclassing is used so all registers can

    37 // use the debugging suport below. No virtual functions are used for efficiency.

    38 // They are canonicalized; i.e., registers are equal if their pointers are equal,

    39 // and vice versa. A concrete implementation may just map the register onto 'this'.

    41 class AbstractRegisterImpl {

    42  protected:

    43   int value() const                              { return (int)(intx)this; }

    44 };

    47 //

    48 // Macros for use in defining Register instances.  We'd like to be

    49 // able to simply define const instances of the RegisterImpl* for each

    50 // of the registers needed on a system in a header file.  However many

    51 // compilers don't handle this very well and end up producing a

    52 // private definition in every file which includes the header file.

    53 // Along with the static constructors necessary for initialization it

    54 // can consume a significant amount of space in the result library.

    55 //

    56 // The following macros allow us to declare the instance in a .hpp and

    57 // produce an enumeration value which has the same number.  Then in a

    58 // .cpp the the register instance can be defined using the enumeration

    59 // value.  This avoids the use of static constructors and multiple

    60 // definitions per .cpp.  In addition #defines for the register can be

    61 // produced so that the constant registers can be inlined.  These

    62 // macros should not be used inside other macros, because you may get

    63 // multiple evaluations of the macros which can give bad results.

    64 //

    65 // Here are some example uses and expansions.  Note that the macro

    66 // invocation is terminated with a ;.

    67 //

    68 // CONSTANT_REGISTER_DECLARATION(Register, G0, 0);

    69 //

    70 // extern const Register G0 ;

    71 // enum { G0_RegisterEnumValue = 0 } ;

    72 //

    73 // REGISTER_DECLARATION(Register, Gmethod, G5);

    74 //

    75 // extern const Register Gmethod ;

    76 // enum { Gmethod_RegisterEnumValue = G5_RegisterEnumValue } ;

    77 //

    78 // REGISTER_DEFINITION(Register, G0);

    79 //

    80 // const Register G0 = ( ( Register ) G0_RegisterEnumValue ) ;

    81 //

    83 #define AS_REGISTER(type,name)         ((type)name##_##type##EnumValue)

    85 #define CONSTANT_REGISTER_DECLARATION(type, name, value) \

    86 extern const type name;                                  \

    87 enum { name##_##type##EnumValue = (value) }

    89 #define REGISTER_DECLARATION(type, name, value) \

    90 extern const type name;                         \

    91 enum { name##_##type##EnumValue = value##_##type##EnumValue }

    93 #define REGISTER_DEFINITION(type, name) \

    94 const type name = ((type)name##_##type##EnumValue)

    96 #ifdef TARGET_ARCH_x86

    97 # include "register_x86.hpp"

    98 #endif

    99 #ifdef TARGET_ARCH_sparc

   100 # include "register_sparc.hpp"

   101 #endif

   102 #ifdef TARGET_ARCH_zero

   103 # include "register_zero.hpp"

   104 #endif

   105 #ifdef TARGET_ARCH_arm

   106 # include "register_arm.hpp"

   107 #endif

   108 #ifdef TARGET_ARCH_ppc

   109 # include "register_ppc.hpp"

   110 #endif

   113 // Debugging support

   115 inline void assert_different_registers(

   116   AbstractRegister a,

   117   AbstractRegister b

   118 ) {

   119   assert(

   120     a != b,

   121     err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT "",

   122                 p2i(a), p2i(b))

   123   );

   124 }

   127 inline void assert_different_registers(

   128   AbstractRegister a,

   129   AbstractRegister b,

   130   AbstractRegister c

   131 ) {

   132   assert(

   133     a != b && a != c

   134            && b != c,

   135     err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT

   136                 ", c=" INTPTR_FORMAT "",

   137                 p2i(a), p2i(b), p2i(c))

   138   );

   139 }

   142 inline void assert_different_registers(

   143   AbstractRegister a,

   144   AbstractRegister b,

   145   AbstractRegister c,

   146   AbstractRegister d

   147 ) {

   148   assert(

   149     a != b && a != c && a != d

   150            && b != c && b != d

   151                      && c != d,

   152     err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT

   153                 ", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT "",

   154                 p2i(a), p2i(b), p2i(c), p2i(d))

   155   );

   156 }

   159 inline void assert_different_registers(

   160   AbstractRegister a,

   161   AbstractRegister b,

   162   AbstractRegister c,

   163   AbstractRegister d,

   164   AbstractRegister e

   165 ) {

   166   assert(

   167     a != b && a != c && a != d && a != e

   168            && b != c && b != d && b != e

   169                      && c != d && c != e

   170                                && d != e,

   171     err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT

   172                 ", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT ", e=" INTPTR_FORMAT "",

   173                 p2i(a), p2i(b), p2i(c), p2i(d), p2i(e))

   174   );

   175 }

   178 inline void assert_different_registers(

   179   AbstractRegister a,

   180   AbstractRegister b,

   181   AbstractRegister c,

   182   AbstractRegister d,

   183   AbstractRegister e,

   184   AbstractRegister f

   185 ) {

   186   assert(

   187     a != b && a != c && a != d && a != e && a != f

   188            && b != c && b != d && b != e && b != f

   189                      && c != d && c != e && c != f

   190                                && d != e && d != f

   191                                          && e != f,

   192     err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT

   193                 ", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT ", e=" INTPTR_FORMAT

   194                 ", f=" INTPTR_FORMAT "",

   195                 p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f))

   196   );

   197 }

   200 inline void assert_different_registers(

   201   AbstractRegister a,

   202   AbstractRegister b,

   203   AbstractRegister c,

   204   AbstractRegister d,

   205   AbstractRegister e,

   206   AbstractRegister f,

   207   AbstractRegister g

   208 ) {

   209   assert(

   210     a != b && a != c && a != d && a != e && a != f && a != g

   211            && b != c && b != d && b != e && b != f && b != g

   212                      && c != d && c != e && c != f && c != g

   213                                && d != e && d != f && d != g

   214                                          && e != f && e != g

   215                                                    && f != g,

   216     err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT

   217                 ", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT ", e=" INTPTR_FORMAT

   218                 ", f=" INTPTR_FORMAT ", g=" INTPTR_FORMAT "",

   219                 p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g))

   220   );

   221 }

   224 inline void assert_different_registers(

   225   AbstractRegister a,

   226   AbstractRegister b,

   227   AbstractRegister c,

   228   AbstractRegister d,

   229   AbstractRegister e,

   230   AbstractRegister f,

   231   AbstractRegister g,

   232   AbstractRegister h

   233 ) {

   234   assert(

   235     a != b && a != c && a != d && a != e && a != f && a != g && a != h

   236            && b != c && b != d && b != e && b != f && b != g && b != h

   237                      && c != d && c != e && c != f && c != g && c != h

   238                                && d != e && d != f && d != g && d != h

   239                                          && e != f && e != g && e != h

   240                                                    && f != g && f != h

   241                                                              && g != h,

   242     err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT

   243                 ", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT ", e=" INTPTR_FORMAT

   244                 ", f=" INTPTR_FORMAT ", g=" INTPTR_FORMAT ", h=" INTPTR_FORMAT "",

   245                 p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g), p2i(h))

   246   );

   247 }

   250 inline void assert_different_registers(

   251   AbstractRegister a,

   252   AbstractRegister b,

   253   AbstractRegister c,

   254   AbstractRegister d,

   255   AbstractRegister e,

   256   AbstractRegister f,

   257   AbstractRegister g,

   258   AbstractRegister h,

   259   AbstractRegister i

   260 ) {

   261   assert(

   262     a != b && a != c && a != d && a != e && a != f && a != g && a != h && a != i

   263            && b != c && b != d && b != e && b != f && b != g && b != h && b != i

   264                      && c != d && c != e && c != f && c != g && c != h && c != i

   265                                && d != e && d != f && d != g && d != h && d != i

   266                                          && e != f && e != g && e != h && e != i

   267                                                    && f != g && f != h && f != i

   268                                                              && g != h && g != i

   269                                                                        && h != i,

   270     err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT

   271                 ", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT ", e=" INTPTR_FORMAT

   272                 ", f=" INTPTR_FORMAT ", g=" INTPTR_FORMAT ", h=" INTPTR_FORMAT

   273                 ", i=" INTPTR_FORMAT "",

   274                 p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g), p2i(h), p2i(i))

   275   );

   276 }

   278 inline void assert_different_registers(

   279   AbstractRegister a,

   280   AbstractRegister b,

   281   AbstractRegister c,

   282   AbstractRegister d,

   283   AbstractRegister e,

   284   AbstractRegister f,

   285   AbstractRegister g,

   286   AbstractRegister h,

   287   AbstractRegister i,

   288   AbstractRegister j

   289 ) {

   290   assert(

   291     a != b && a != c && a != d && a != e && a != f && a != g && a != h && a != i && a != j

   292            && b != c && b != d && b != e && b != f && b != g && b != h && b != i && b != j

   293                      && c != d && c != e && c != f && c != g && c != h && c != i && c != j

   294                                && d != e && d != f && d != g && d != h && d != i && d != j

   295                                          && e != f && e != g && e != h && e != i && e != j

   296                                                    && f != g && f != h && f != i && f != j

   297                                                              && g != h && g != i && g != j

   298                                                                        && h != i && h != j

   299                                                                                  && i != j,

   300     err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT

   301                 ", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT ", e=" INTPTR_FORMAT

   302                 ", f=" INTPTR_FORMAT ", g=" INTPTR_FORMAT ", h=" INTPTR_FORMAT

   303                 ", i=" INTPTR_FORMAT ", j=" INTPTR_FORMAT "",

   304                 p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g), p2i(h), p2i(i), p2i(j))

   305   );

   306 }

   308 inline void assert_different_registers(

   309   AbstractRegister a,

   310   AbstractRegister b,

   311   AbstractRegister c,

   312   AbstractRegister d,

   313   AbstractRegister e,

   314   AbstractRegister f,

   315   AbstractRegister g,

   316   AbstractRegister h,

   317   AbstractRegister i,

   318   AbstractRegister j,

   319   AbstractRegister k

   320 ) {

   321   assert(

   322     a != b && a != c && a != d && a != e && a != f && a != g && a != h && a != i && a != j && a !=k

   323            && b != c && b != d && b != e && b != f && b != g && b != h && b != i && b != j && b !=k

   324                      && c != d && c != e && c != f && c != g && c != h && c != i && c != j && c !=k

   325                                && d != e && d != f && d != g && d != h && d != i && d != j && d !=k

   326                                          && e != f && e != g && e != h && e != i && e != j && e !=k

   327                                                    && f != g && f != h && f != i && f != j && f !=k

   328                                                              && g != h && g != i && g != j && g !=k

   329                                                                        && h != i && h != j && h !=k

   330                                                                                  && i != j && i !=k

   331                                                                                            && j !=k,

   332     err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT

   333                 ", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT ", e=" INTPTR_FORMAT

   334                 ", f=" INTPTR_FORMAT ", g=" INTPTR_FORMAT ", h=" INTPTR_FORMAT

   335                 ", i=" INTPTR_FORMAT ", j=" INTPTR_FORMAT ", k=" INTPTR_FORMAT "",

   336                 p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g), p2i(h), p2i(i), p2i(j), p2i(k))

   337   );

   338 }

   340 inline void assert_different_registers(

   341   AbstractRegister a,

   342   AbstractRegister b,

   343   AbstractRegister c,

   344   AbstractRegister d,

   345   AbstractRegister e,

   346   AbstractRegister f,

   347   AbstractRegister g,

   348   AbstractRegister h,

   349   AbstractRegister i,

   350   AbstractRegister j,

   351   AbstractRegister k,

   352   AbstractRegister l

   353 ) {

   354   assert(

   355     a != b && a != c && a != d && a != e && a != f && a != g && a != h && a != i && a != j && a !=k && a !=l

   356            && b != c && b != d && b != e && b != f && b != g && b != h && b != i && b != j && b !=k && b !=l

   357                      && c != d && c != e && c != f && c != g && c != h && c != i && c != j && c !=k && c !=l

   358                                && d != e && d != f && d != g && d != h && d != i && d != j && d !=k && d !=l

   359                                          && e != f && e != g && e != h && e != i && e != j && e !=k && e !=l

   360                                                    && f != g && f != h && f != i && f != j && f !=k && f !=l

   361                                                              && g != h && g != i && g != j && g !=k && g !=l

   362                                                                        && h != i && h != j && h !=k && h !=l

   363                                                                                  && i != j && i !=k && i !=l

   364                                                                                            && j !=k && j !=l

   365                                                                                                     && k !=l,

   366     err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT

   367                 ", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT ", e=" INTPTR_FORMAT

   368                 ", f=" INTPTR_FORMAT ", g=" INTPTR_FORMAT ", h=" INTPTR_FORMAT

   369                 ", i=" INTPTR_FORMAT ", j=" INTPTR_FORMAT ", k=" INTPTR_FORMAT

   370                 ", l=" INTPTR_FORMAT "",

   371                 p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g), p2i(h), p2i(i), p2i(j), p2i(k), p2i(l))

   372   );

   373 }

   375 #endif // SHARE_VM_ASM_REGISTER_HPP

Mercurial > jdk8-mips64-public > hotspot / file revision

src/share/vm/asm/register.hpp@166d744df0de

src/share/vm/asm/register.hpp