jdk8-mips64-public/hotspot: src/share/vm/opto/vectornode.hpp@0d78aecb0948

8152172: PPC64: Support AES intrinsics
Summary: Add support for AES intrinsics on PPC64.
Reviewed-by: kvn, mdoerr, simonis, zmajo
Contributed-by: Hiroshi H Horii <horii@jp.ibm.com>

     1 /*

     2  * Copyright (c) 2007, 2012, 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  */

    24 #ifndef SHARE_VM_OPTO_VECTORNODE_HPP

    25 #define SHARE_VM_OPTO_VECTORNODE_HPP

    27 #include "opto/matcher.hpp"

    28 #include "opto/memnode.hpp"

    29 #include "opto/node.hpp"

    30 #include "opto/opcodes.hpp"

    32 //------------------------------VectorNode-------------------------------------

    33 // Vector Operation

    34 class VectorNode : public TypeNode {

    35  public:

    37   VectorNode(Node* n1, const TypeVect* vt) : TypeNode(vt, 2) {

    38     init_class_id(Class_Vector);

    39     init_req(1, n1);

    40   }

    41   VectorNode(Node* n1, Node* n2, const TypeVect* vt) : TypeNode(vt, 3) {

    42     init_class_id(Class_Vector);

    43     init_req(1, n1);

    44     init_req(2, n2);

    45   }

    47   const TypeVect* vect_type() const { return type()->is_vect(); }

    48   uint length() const { return vect_type()->length(); } // Vector length

    49   uint length_in_bytes() const { return vect_type()->length_in_bytes(); }

    51   virtual int Opcode() const;

    53   virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(vect_type()->length_in_bytes()); }

    55   static VectorNode* scalar2vector(Compile* C, Node* s, uint vlen, const Type* opd_t);

    56   static VectorNode* shift_count(Compile* C, Node* shift, Node* cnt, uint vlen, BasicType bt);

    57   static VectorNode* make(Compile* C, int opc, Node* n1, Node* n2, uint vlen, BasicType bt);

    59   static int  opcode(int opc, BasicType bt);

    60   static bool implemented(int opc, uint vlen, BasicType bt);

    61   static bool is_shift(Node* n);

    62   static bool is_invariant_vector(Node* n);

    63   // [Start, end) half-open range defining which operands are vectors

    64   static void vector_operands(Node* n, uint* start, uint* end);

    65 };

    67 //===========================Vector=ALU=Operations=============================

    69 //------------------------------AddVBNode--------------------------------------

    70 // Vector add byte

    71 class AddVBNode : public VectorNode {

    72  public:

    73   AddVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

    74   virtual int Opcode() const;

    75 };

    77 //------------------------------AddVSNode--------------------------------------

    78 // Vector add char/short

    79 class AddVSNode : public VectorNode {

    80  public:

    81   AddVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

    82   virtual int Opcode() const;

    83 };

    85 //------------------------------AddVINode--------------------------------------

    86 // Vector add int

    87 class AddVINode : public VectorNode {

    88  public:

    89   AddVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

    90   virtual int Opcode() const;

    91 };

    93 //------------------------------AddVLNode--------------------------------------

    94 // Vector add long

    95 class AddVLNode : public VectorNode {

    96  public:

    97   AddVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

    98   virtual int Opcode() const;

    99 };

   101 //------------------------------AddVFNode--------------------------------------

   102 // Vector add float

   103 class AddVFNode : public VectorNode {

   104  public:

   105   AddVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   106   virtual int Opcode() const;

   107 };

   109 //------------------------------AddVDNode--------------------------------------

   110 // Vector add double

   111 class AddVDNode : public VectorNode {

   112  public:

   113   AddVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   114   virtual int Opcode() const;

   115 };

   117 //------------------------------SubVBNode--------------------------------------

   118 // Vector subtract byte

   119 class SubVBNode : public VectorNode {

   120  public:

   121   SubVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   122   virtual int Opcode() const;

   123 };

   125 //------------------------------SubVSNode--------------------------------------

   126 // Vector subtract short

   127 class SubVSNode : public VectorNode {

   128  public:

   129   SubVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   130   virtual int Opcode() const;

   131 };

   133 //------------------------------SubVINode--------------------------------------

   134 // Vector subtract int

   135 class SubVINode : public VectorNode {

   136  public:

   137   SubVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   138   virtual int Opcode() const;

   139 };

   141 //------------------------------SubVLNode--------------------------------------

   142 // Vector subtract long

   143 class SubVLNode : public VectorNode {

   144  public:

   145   SubVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   146   virtual int Opcode() const;

   147 };

   149 //------------------------------SubVFNode--------------------------------------

   150 // Vector subtract float

   151 class SubVFNode : public VectorNode {

   152  public:

   153   SubVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   154   virtual int Opcode() const;

   155 };

   157 //------------------------------SubVDNode--------------------------------------

   158 // Vector subtract double

   159 class SubVDNode : public VectorNode {

   160  public:

   161   SubVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   162   virtual int Opcode() const;

   163 };

   165 //------------------------------MulVSNode--------------------------------------

   166 // Vector multiply short

   167 class MulVSNode : public VectorNode {

   168  public:

   169   MulVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   170   virtual int Opcode() const;

   171 };

   173 //------------------------------MulVINode--------------------------------------

   174 // Vector multiply int

   175 class MulVINode : public VectorNode {

   176  public:

   177   MulVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   178   virtual int Opcode() const;

   179 };

   181 //------------------------------MulVFNode--------------------------------------

   182 // Vector multiply float

   183 class MulVFNode : public VectorNode {

   184  public:

   185   MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   186   virtual int Opcode() const;

   187 };

   189 //------------------------------MulVDNode--------------------------------------

   190 // Vector multiply double

   191 class MulVDNode : public VectorNode {

   192  public:

   193   MulVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   194   virtual int Opcode() const;

   195 };

   197 //------------------------------DivVFNode--------------------------------------

   198 // Vector divide float

   199 class DivVFNode : public VectorNode {

   200  public:

   201   DivVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   202   virtual int Opcode() const;

   203 };

   205 //------------------------------DivVDNode--------------------------------------

   206 // Vector Divide double

   207 class DivVDNode : public VectorNode {

   208  public:

   209   DivVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   210   virtual int Opcode() const;

   211 };

   213 //------------------------------LShiftVBNode-----------------------------------

   214 // Vector left shift bytes

   215 class LShiftVBNode : public VectorNode {

   216  public:

   217   LShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   218   virtual int Opcode() const;

   219 };

   221 //------------------------------LShiftVSNode-----------------------------------

   222 // Vector left shift shorts

   223 class LShiftVSNode : public VectorNode {

   224  public:

   225   LShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   226   virtual int Opcode() const;

   227 };

   229 //------------------------------LShiftVINode-----------------------------------

   230 // Vector left shift ints

   231 class LShiftVINode : public VectorNode {

   232  public:

   233   LShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   234   virtual int Opcode() const;

   235 };

   237 //------------------------------LShiftVLNode-----------------------------------

   238 // Vector left shift longs

   239 class LShiftVLNode : public VectorNode {

   240  public:

   241   LShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   242   virtual int Opcode() const;

   243 };

   245 //------------------------------RShiftVBNode-----------------------------------

   246 // Vector right arithmetic (signed) shift bytes

   247 class RShiftVBNode : public VectorNode {

   248  public:

   249   RShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   250   virtual int Opcode() const;

   251 };

   253 //------------------------------RShiftVSNode-----------------------------------

   254 // Vector right arithmetic (signed) shift shorts

   255 class RShiftVSNode : public VectorNode {

   256  public:

   257   RShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   258   virtual int Opcode() const;

   259 };

   261 //------------------------------RShiftVINode-----------------------------------

   262 // Vector right arithmetic (signed) shift ints

   263 class RShiftVINode : public VectorNode {

   264  public:

   265   RShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   266   virtual int Opcode() const;

   267 };

   269 //------------------------------RShiftVLNode-----------------------------------

   270 // Vector right arithmetic (signed) shift longs

   271 class RShiftVLNode : public VectorNode {

   272  public:

   273   RShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   274   virtual int Opcode() const;

   275 };

   277 //------------------------------URShiftVBNode----------------------------------

   278 // Vector right logical (unsigned) shift bytes

   279 class URShiftVBNode : public VectorNode {

   280  public:

   281   URShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   282   virtual int Opcode() const;

   283 };

   285 //------------------------------URShiftVSNode----------------------------------

   286 // Vector right logical (unsigned) shift shorts

   287 class URShiftVSNode : public VectorNode {

   288  public:

   289   URShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   290   virtual int Opcode() const;

   291 };

   293 //------------------------------URShiftVINode----------------------------------

   294 // Vector right logical (unsigned) shift ints

   295 class URShiftVINode : public VectorNode {

   296  public:

   297   URShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   298   virtual int Opcode() const;

   299 };

   301 //------------------------------URShiftVLNode----------------------------------

   302 // Vector right logical (unsigned) shift longs

   303 class URShiftVLNode : public VectorNode {

   304  public:

   305   URShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   306   virtual int Opcode() const;

   307 };

   309 //------------------------------LShiftCntVNode---------------------------------

   310 // Vector left shift count

   311 class LShiftCntVNode : public VectorNode {

   312  public:

   313   LShiftCntVNode(Node* cnt, const TypeVect* vt) : VectorNode(cnt,vt) {}

   314   virtual int Opcode() const;

   315   virtual uint ideal_reg() const { return Matcher::vector_shift_count_ideal_reg(vect_type()->length_in_bytes()); }

   316 };

   318 //------------------------------RShiftCntVNode---------------------------------

   319 // Vector right shift count

   320 class RShiftCntVNode : public VectorNode {

   321  public:

   322   RShiftCntVNode(Node* cnt, const TypeVect* vt) : VectorNode(cnt,vt) {}

   323   virtual int Opcode() const;

   324   virtual uint ideal_reg() const { return Matcher::vector_shift_count_ideal_reg(vect_type()->length_in_bytes()); }

   325 };

   328 //------------------------------AndVNode---------------------------------------

   329 // Vector and integer

   330 class AndVNode : public VectorNode {

   331  public:

   332   AndVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   333   virtual int Opcode() const;

   334 };

   336 //------------------------------OrVNode---------------------------------------

   337 // Vector or integer

   338 class OrVNode : public VectorNode {

   339  public:

   340   OrVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   341   virtual int Opcode() const;

   342 };

   344 //------------------------------XorVNode---------------------------------------

   345 // Vector xor integer

   346 class XorVNode : public VectorNode {

   347  public:

   348   XorVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

   349   virtual int Opcode() const;

   350 };

   352 //================================= M E M O R Y ===============================

   354 //------------------------------LoadVectorNode---------------------------------

   355 // Load Vector from memory

   356 class LoadVectorNode : public LoadNode {

   357  public:

   358   LoadVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeVect* vt, ControlDependency control_dependency = LoadNode::DependsOnlyOnTest)

   359     : LoadNode(c, mem, adr, at, vt, MemNode::unordered, control_dependency) {

   360     init_class_id(Class_LoadVector);

   361   }

   363   const TypeVect* vect_type() const { return type()->is_vect(); }

   364   uint length() const { return vect_type()->length(); } // Vector length

   366   virtual int Opcode() const;

   368   virtual uint ideal_reg() const  { return Matcher::vector_ideal_reg(memory_size()); }

   369   virtual BasicType memory_type() const { return T_VOID; }

   370   virtual int memory_size() const { return vect_type()->length_in_bytes(); }

   372   virtual int store_Opcode() const { return Op_StoreVector; }

   374   static LoadVectorNode* make(Compile* C, int opc, Node* ctl, Node* mem,

   375                               Node* adr, const TypePtr* atyp, uint vlen, BasicType bt,

   376                               ControlDependency control_dependency = LoadNode::DependsOnlyOnTest);

   377 };

   379 //------------------------------StoreVectorNode--------------------------------

   380 // Store Vector to memory

   381 class StoreVectorNode : public StoreNode {

   382  public:

   383   StoreVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)

   384     : StoreNode(c, mem, adr, at, val, MemNode::unordered) {

   385     assert(val->is_Vector() || val->is_LoadVector(), "sanity");

   386     init_class_id(Class_StoreVector);

   387   }

   389   const TypeVect* vect_type() const { return in(MemNode::ValueIn)->bottom_type()->is_vect(); }

   390   uint length() const { return vect_type()->length(); } // Vector length

   392   virtual int Opcode() const;

   394   virtual uint ideal_reg() const  { return Matcher::vector_ideal_reg(memory_size()); }

   395   virtual BasicType memory_type() const { return T_VOID; }

   396   virtual int memory_size() const { return vect_type()->length_in_bytes(); }

   398   static StoreVectorNode* make(Compile* C, int opc, Node* ctl, Node* mem,

   399                                Node* adr, const TypePtr* atyp, Node* val,

   400                                uint vlen);

   401 };

   404 //=========================Promote_Scalar_to_Vector============================

   406 //------------------------------ReplicateBNode---------------------------------

   407 // Replicate byte scalar to be vector

   408 class ReplicateBNode : public VectorNode {

   409  public:

   410   ReplicateBNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}

   411   virtual int Opcode() const;

   412 };

   414 //------------------------------ReplicateSNode---------------------------------

   415 // Replicate short scalar to be vector

   416 class ReplicateSNode : public VectorNode {

   417  public:

   418   ReplicateSNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}

   419   virtual int Opcode() const;

   420 };

   422 //------------------------------ReplicateINode---------------------------------

   423 // Replicate int scalar to be vector

   424 class ReplicateINode : public VectorNode {

   425  public:

   426   ReplicateINode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}

   427   virtual int Opcode() const;

   428 };

   430 //------------------------------ReplicateLNode---------------------------------

   431 // Replicate long scalar to be vector

   432 class ReplicateLNode : public VectorNode {

   433  public:

   434   ReplicateLNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}

   435   virtual int Opcode() const;

   436 };

   438 //------------------------------ReplicateFNode---------------------------------

   439 // Replicate float scalar to be vector

   440 class ReplicateFNode : public VectorNode {

   441  public:

   442   ReplicateFNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}

   443   virtual int Opcode() const;

   444 };

   446 //------------------------------ReplicateDNode---------------------------------

   447 // Replicate double scalar to be vector

   448 class ReplicateDNode : public VectorNode {

   449  public:

   450   ReplicateDNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}

   451   virtual int Opcode() const;

   452 };

   454 //========================Pack_Scalars_into_a_Vector===========================

   456 //------------------------------PackNode---------------------------------------

   457 // Pack parent class (not for code generation).

   458 class PackNode : public VectorNode {

   459  public:

   460   PackNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}

   461   PackNode(Node* in1, Node* n2, const TypeVect* vt) : VectorNode(in1, n2, vt) {}

   462   virtual int Opcode() const;

   464   void add_opd(Node* n) {

   465     add_req(n);

   466   }

   468   // Create a binary tree form for Packs. [lo, hi) (half-open) range

   469   PackNode* binary_tree_pack(Compile* C, int lo, int hi);

   471   static PackNode* make(Compile* C, Node* s, uint vlen, BasicType bt);

   472 };

   474 //------------------------------PackBNode--------------------------------------

   475 // Pack byte scalars into vector

   476 class PackBNode : public PackNode {

   477  public:

   478   PackBNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}

   479   virtual int Opcode() const;

   480 };

   482 //------------------------------PackSNode--------------------------------------

   483 // Pack short scalars into a vector

   484 class PackSNode : public PackNode {

   485  public:

   486   PackSNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}

   487   PackSNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}

   488   virtual int Opcode() const;

   489 };

   491 //------------------------------PackINode--------------------------------------

   492 // Pack integer scalars into a vector

   493 class PackINode : public PackNode {

   494  public:

   495   PackINode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}

   496   PackINode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}

   497   virtual int Opcode() const;

   498 };

   500 //------------------------------PackLNode--------------------------------------

   501 // Pack long scalars into a vector

   502 class PackLNode : public PackNode {

   503  public:

   504   PackLNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}

   505   PackLNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}

   506   virtual int Opcode() const;

   507 };

   509 //------------------------------Pack2LNode-------------------------------------

   510 // Pack 2 long scalars into a vector

   511 class Pack2LNode : public PackNode {

   512  public:

   513   Pack2LNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}

   514   virtual int Opcode() const;

   515 };

   517 //------------------------------PackFNode--------------------------------------

   518 // Pack float scalars into vector

   519 class PackFNode : public PackNode {

   520  public:

   521   PackFNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}

   522   PackFNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}

   523   virtual int Opcode() const;

   524 };

   526 //------------------------------PackDNode--------------------------------------

   527 // Pack double scalars into a vector

   528 class PackDNode : public PackNode {

   529  public:

   530   PackDNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}

   531   PackDNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}

   532   virtual int Opcode() const;

   533 };

   535 //------------------------------Pack2DNode-------------------------------------

   536 // Pack 2 double scalars into a vector

   537 class Pack2DNode : public PackNode {

   538  public:

   539   Pack2DNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}

   540   virtual int Opcode() const;

   541 };

   544 //========================Extract_Scalar_from_Vector===========================

   546 //------------------------------ExtractNode------------------------------------

   547 // Extract a scalar from a vector at position "pos"

   548 class ExtractNode : public Node {

   549  public:

   550   ExtractNode(Node* src, ConINode* pos) : Node(NULL, src, (Node*)pos) {

   551     assert(in(2)->get_int() >= 0, "positive constants");

   552   }

   553   virtual int Opcode() const;

   554   uint  pos() const { return in(2)->get_int(); }

   556   static Node* make(Compile* C, Node* v, uint position, BasicType bt);

   557 };

   559 //------------------------------ExtractBNode-----------------------------------

   560 // Extract a byte from a vector at position "pos"

   561 class ExtractBNode : public ExtractNode {

   562  public:

   563   ExtractBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}

   564   virtual int Opcode() const;

   565   virtual const Type *bottom_type() const { return TypeInt::INT; }

   566   virtual uint ideal_reg() const { return Op_RegI; }

   567 };

   569 //------------------------------ExtractUBNode----------------------------------

   570 // Extract a boolean from a vector at position "pos"

   571 class ExtractUBNode : public ExtractNode {

   572  public:

   573   ExtractUBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}

   574   virtual int Opcode() const;

   575   virtual const Type *bottom_type() const { return TypeInt::INT; }

   576   virtual uint ideal_reg() const { return Op_RegI; }

   577 };

   579 //------------------------------ExtractCNode-----------------------------------

   580 // Extract a char from a vector at position "pos"

   581 class ExtractCNode : public ExtractNode {

   582  public:

   583   ExtractCNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}

   584   virtual int Opcode() const;

   585   virtual const Type *bottom_type() const { return TypeInt::INT; }

   586   virtual uint ideal_reg() const { return Op_RegI; }

   587 };

   589 //------------------------------ExtractSNode-----------------------------------

   590 // Extract a short from a vector at position "pos"

   591 class ExtractSNode : public ExtractNode {

   592  public:

   593   ExtractSNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}

   594   virtual int Opcode() const;

   595   virtual const Type *bottom_type() const { return TypeInt::INT; }

   596   virtual uint ideal_reg() const { return Op_RegI; }

   597 };

   599 //------------------------------ExtractINode-----------------------------------

   600 // Extract an int from a vector at position "pos"

   601 class ExtractINode : public ExtractNode {

   602  public:

   603   ExtractINode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}

   604   virtual int Opcode() const;

   605   virtual const Type *bottom_type() const { return TypeInt::INT; }

   606   virtual uint ideal_reg() const { return Op_RegI; }

   607 };

   609 //------------------------------ExtractLNode-----------------------------------

   610 // Extract a long from a vector at position "pos"

   611 class ExtractLNode : public ExtractNode {

   612  public:

   613   ExtractLNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}

   614   virtual int Opcode() const;

   615   virtual const Type *bottom_type() const { return TypeLong::LONG; }

   616   virtual uint ideal_reg() const { return Op_RegL; }

   617 };

   619 //------------------------------ExtractFNode-----------------------------------

   620 // Extract a float from a vector at position "pos"

   621 class ExtractFNode : public ExtractNode {

   622  public:

   623   ExtractFNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}

   624   virtual int Opcode() const;

   625   virtual const Type *bottom_type() const { return Type::FLOAT; }

   626   virtual uint ideal_reg() const { return Op_RegF; }

   627 };

   629 //------------------------------ExtractDNode-----------------------------------

   630 // Extract a double from a vector at position "pos"

   631 class ExtractDNode : public ExtractNode {

   632  public:

   633   ExtractDNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}

   634   virtual int Opcode() const;

   635   virtual const Type *bottom_type() const { return Type::DOUBLE; }

   636   virtual uint ideal_reg() const { return Op_RegD; }

   637 };

   639 #endif // SHARE_VM_OPTO_VECTORNODE_HPP

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

src/share/vm/opto/vectornode.hpp@0d78aecb0948

src/share/vm/opto/vectornode.hpp