jdk8-mips64-public/hotspot: src/share/vm/opto/vectornode.hpp@83f08886981c

7026631: field _klass is incorrectly set for dual type of TypeAryPtr::OOPS
Summary: add missing check this->dual() != TypeAryPtr::OOPS into TypeAryPtr::klass().
Reviewed-by: never

     1 /*

     2  * Copyright (c) 2007, 2010, 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 Node {

    35  protected:

    36   uint _length; // vector length

    37   virtual BasicType elt_basic_type() const = 0; // Vector element basic type

    39   static const Type* vect_type(BasicType elt_bt, uint len);

    40   static const Type* vect_type(const Type* elt_type, uint len) {

    41     return vect_type(elt_type->array_element_basic_type(), len);

    42   }

    44  public:

    45   friend class VectorLoadNode;  // For vect_type

    46   friend class VectorStoreNode; // ditto.

    48   VectorNode(Node* n1, uint vlen) : Node(NULL, n1), _length(vlen) {

    49     init_flags(Flag_is_Vector);

    50   }

    51   VectorNode(Node* n1, Node* n2, uint vlen) : Node(NULL, n1, n2), _length(vlen) {

    52     init_flags(Flag_is_Vector);

    53   }

    54   virtual int Opcode() const;

    56   uint length() const { return _length; } // Vector length

    58   static uint max_vlen(BasicType bt) { // max vector length

    59     return (uint)(Matcher::vector_width_in_bytes() / type2aelembytes(bt));

    60   }

    62   // Element and vector type

    63   const Type* elt_type()  const { return Type::get_const_basic_type(elt_basic_type()); }

    64   const Type* vect_type() const { return vect_type(elt_basic_type(), length()); }

    66   virtual const Type *bottom_type() const { return vect_type(); }

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

    69   // Vector opcode from scalar opcode

    70   static int opcode(int sopc, uint vlen, const Type* opd_t);

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

    74   static VectorNode* make(Compile* C, int sopc, Node* n1, Node* n2, uint vlen, const Type* elt_t);

    76 };

    78 //===========================Vector=ALU=Operations====================================

    80 //------------------------------AddVBNode---------------------------------------

    81 // Vector add byte

    82 class AddVBNode : public VectorNode {

    83  protected:

    84   virtual BasicType elt_basic_type() const { return T_BYTE; }

    85  public:

    86   AddVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

    87   virtual int Opcode() const;

    88 };

    90 //------------------------------AddVCNode---------------------------------------

    91 // Vector add char

    92 class AddVCNode : public VectorNode {

    93  protected:

    94   virtual BasicType elt_basic_type() const { return T_CHAR; }

    95  public:

    96   AddVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

    97   virtual int Opcode() const;

    98 };

   100 //------------------------------AddVSNode---------------------------------------

   101 // Vector add short

   102 class AddVSNode : public VectorNode {

   103  protected:

   104   virtual BasicType elt_basic_type() const { return T_SHORT; }

   105  public:

   106   AddVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   107   virtual int Opcode() const;

   108 };

   110 //------------------------------AddVINode---------------------------------------

   111 // Vector add int

   112 class AddVINode : public VectorNode {

   113  protected:

   114   virtual BasicType elt_basic_type() const { return T_INT; }

   115  public:

   116   AddVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   117   virtual int Opcode() const;

   118 };

   120 //------------------------------AddVLNode---------------------------------------

   121 // Vector add long

   122 class AddVLNode : public VectorNode {

   123  protected:

   124   virtual BasicType elt_basic_type() const { return T_LONG; }

   125  public:

   126   AddVLNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   127   virtual int Opcode() const;

   128 };

   130 //------------------------------AddVFNode---------------------------------------

   131 // Vector add float

   132 class AddVFNode : public VectorNode {

   133  protected:

   134   virtual BasicType elt_basic_type() const { return T_FLOAT; }

   135  public:

   136   AddVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   137   virtual int Opcode() const;

   138 };

   140 //------------------------------AddVDNode---------------------------------------

   141 // Vector add double

   142 class AddVDNode : public VectorNode {

   143  protected:

   144   virtual BasicType elt_basic_type() const { return T_DOUBLE; }

   145  public:

   146   AddVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   147   virtual int Opcode() const;

   148 };

   150 //------------------------------SubVBNode---------------------------------------

   151 // Vector subtract byte

   152 class SubVBNode : public VectorNode {

   153  protected:

   154   virtual BasicType elt_basic_type() const { return T_BYTE; }

   155  public:

   156   SubVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   157   virtual int Opcode() const;

   158 };

   160 //------------------------------SubVCNode---------------------------------------

   161 // Vector subtract char

   162 class SubVCNode : public VectorNode {

   163  protected:

   164   virtual BasicType elt_basic_type() const { return T_CHAR; }

   165  public:

   166   SubVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   167   virtual int Opcode() const;

   168 };

   170 //------------------------------SubVSNode---------------------------------------

   171 // Vector subtract short

   172 class SubVSNode : public VectorNode {

   173  protected:

   174   virtual BasicType elt_basic_type() const { return T_SHORT; }

   175  public:

   176   SubVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   177   virtual int Opcode() const;

   178 };

   180 //------------------------------SubVINode---------------------------------------

   181 // Vector subtract int

   182 class SubVINode : public VectorNode {

   183  protected:

   184   virtual BasicType elt_basic_type() const { return T_INT; }

   185  public:

   186   SubVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   187   virtual int Opcode() const;

   188 };

   190 //------------------------------SubVLNode---------------------------------------

   191 // Vector subtract long

   192 class SubVLNode : public VectorNode {

   193  protected:

   194   virtual BasicType elt_basic_type() const { return T_LONG; }

   195  public:

   196   SubVLNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   197   virtual int Opcode() const;

   198 };

   200 //------------------------------SubVFNode---------------------------------------

   201 // Vector subtract float

   202 class SubVFNode : public VectorNode {

   203  protected:

   204   virtual BasicType elt_basic_type() const { return T_FLOAT; }

   205  public:

   206   SubVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   207   virtual int Opcode() const;

   208 };

   210 //------------------------------SubVDNode---------------------------------------

   211 // Vector subtract double

   212 class SubVDNode : public VectorNode {

   213  protected:

   214   virtual BasicType elt_basic_type() const { return T_DOUBLE; }

   215  public:

   216   SubVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   217   virtual int Opcode() const;

   218 };

   220 //------------------------------MulVFNode---------------------------------------

   221 // Vector multiply float

   222 class MulVFNode : public VectorNode {

   223  protected:

   224   virtual BasicType elt_basic_type() const { return T_FLOAT; }

   225  public:

   226   MulVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   227   virtual int Opcode() const;

   228 };

   230 //------------------------------MulVDNode---------------------------------------

   231 // Vector multiply double

   232 class MulVDNode : public VectorNode {

   233  protected:

   234   virtual BasicType elt_basic_type() const { return T_DOUBLE; }

   235  public:

   236   MulVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   237   virtual int Opcode() const;

   238 };

   240 //------------------------------DivVFNode---------------------------------------

   241 // Vector divide float

   242 class DivVFNode : public VectorNode {

   243  protected:

   244   virtual BasicType elt_basic_type() const { return T_FLOAT; }

   245  public:

   246   DivVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   247   virtual int Opcode() const;

   248 };

   250 //------------------------------DivVDNode---------------------------------------

   251 // Vector Divide double

   252 class DivVDNode : public VectorNode {

   253  protected:

   254   virtual BasicType elt_basic_type() const { return T_DOUBLE; }

   255  public:

   256   DivVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   257   virtual int Opcode() const;

   258 };

   260 //------------------------------LShiftVBNode---------------------------------------

   261 // Vector lshift byte

   262 class LShiftVBNode : public VectorNode {

   263  protected:

   264   virtual BasicType elt_basic_type() const { return T_BYTE; }

   265  public:

   266   LShiftVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   267   virtual int Opcode() const;

   268 };

   270 //------------------------------LShiftVCNode---------------------------------------

   271 // Vector lshift chars

   272 class LShiftVCNode : public VectorNode {

   273  protected:

   274   virtual BasicType elt_basic_type() const { return T_CHAR; }

   275  public:

   276   LShiftVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   277   virtual int Opcode() const;

   278 };

   280 //------------------------------LShiftVSNode---------------------------------------

   281 // Vector lshift shorts

   282 class LShiftVSNode : public VectorNode {

   283  protected:

   284   virtual BasicType elt_basic_type() const { return T_SHORT; }

   285  public:

   286   LShiftVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   287   virtual int Opcode() const;

   288 };

   290 //------------------------------LShiftVINode---------------------------------------

   291 // Vector lshift ints

   292 class LShiftVINode : public VectorNode {

   293  protected:

   294   virtual BasicType elt_basic_type() const { return T_INT; }

   295  public:

   296   LShiftVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   297   virtual int Opcode() const;

   298 };

   300 //------------------------------URShiftVBNode---------------------------------------

   301 // Vector urshift bytes

   302 class URShiftVBNode : public VectorNode {

   303  protected:

   304   virtual BasicType elt_basic_type() const { return T_BYTE; }

   305  public:

   306   URShiftVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   307   virtual int Opcode() const;

   308 };

   310 //------------------------------URShiftVCNode---------------------------------------

   311 // Vector urshift char

   312 class URShiftVCNode : public VectorNode {

   313  protected:

   314   virtual BasicType elt_basic_type() const { return T_SHORT; }

   315  public:

   316   URShiftVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   317   virtual int Opcode() const;

   318 };

   320 //------------------------------URShiftVSNode---------------------------------------

   321 // Vector urshift shorts

   322 class URShiftVSNode : public VectorNode {

   323  protected:

   324   virtual BasicType elt_basic_type() const { return T_SHORT; }

   325  public:

   326   URShiftVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   327   virtual int Opcode() const;

   328 };

   330 //------------------------------URShiftVINode---------------------------------------

   331 // Vector urshift ints

   332 class URShiftVINode : public VectorNode {

   333  protected:

   334   virtual BasicType elt_basic_type() const { return T_INT; }

   335  public:

   336   URShiftVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}

   337   virtual int Opcode() const;

   338 };

   340 //------------------------------AndVNode---------------------------------------

   341 // Vector and

   342 class AndVNode : public VectorNode {

   343  protected:

   344   BasicType _bt;

   345   virtual BasicType elt_basic_type() const { return _bt; }

   346  public:

   347   AndVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {}

   348   virtual int Opcode() const;

   349 };

   351 //------------------------------OrVNode---------------------------------------

   352 // Vector or

   353 class OrVNode : public VectorNode {

   354  protected:

   355   BasicType _bt;

   356   virtual BasicType elt_basic_type() const { return _bt; }

   357  public:

   358   OrVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {}

   359   virtual int Opcode() const;

   360 };

   362 //------------------------------XorVNode---------------------------------------

   363 // Vector xor

   364 class XorVNode : public VectorNode {

   365  protected:

   366   BasicType _bt;

   367   virtual BasicType elt_basic_type() const { return _bt; }

   368  public:

   369   XorVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {}

   370   virtual int Opcode() const;

   371 };

   373 //================================= M E M O R Y ==================================

   376 //------------------------------VectorLoadNode--------------------------------------

   377 // Vector Load from memory

   378 class VectorLoadNode : public LoadNode {

   379   virtual uint size_of() const { return sizeof(*this); }

   381  protected:

   382   virtual BasicType elt_basic_type()  const = 0; // Vector element basic type

   383   // For use in constructor

   384   static const Type* vect_type(const Type* elt_type, uint len) {

   385     return VectorNode::vect_type(elt_type, len);

   386   }

   388  public:

   389   VectorLoadNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *rt)

   390     : LoadNode(c,mem,adr,at,rt) {

   391       init_flags(Flag_is_Vector);

   392   }

   393   virtual int Opcode() const;

   395   virtual uint  length() const = 0; // Vector length

   397   // Element and vector type

   398   const Type* elt_type()  const { return Type::get_const_basic_type(elt_basic_type()); }

   399   const Type* vect_type() const { return VectorNode::vect_type(elt_basic_type(), length()); }

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

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

   403   virtual int memory_size() const { return length()*type2aelembytes(elt_basic_type()); }

   405   // Vector opcode from scalar opcode

   406   static int opcode(int sopc, uint vlen);

   408   static VectorLoadNode* make(Compile* C, int opc, Node* ctl, Node* mem,

   409                               Node* adr, const TypePtr* atyp, uint vlen);

   410 };

   412 //------------------------------Load16BNode--------------------------------------

   413 // Vector load of 16 bytes (8bits signed) from memory

   414 class Load16BNode : public VectorLoadNode {

   415  protected:

   416   virtual BasicType elt_basic_type() const { return T_BYTE; }

   417  public:

   418   Load16BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE)

   419     : VectorLoadNode(c,mem,adr,at,vect_type(ti,16)) {}

   420   virtual int Opcode() const;

   421   virtual int store_Opcode() const { return Op_Store16B; }

   422   virtual uint length() const { return 16; }

   423 };

   425 //------------------------------Load8BNode--------------------------------------

   426 // Vector load of 8 bytes (8bits signed) from memory

   427 class Load8BNode : public VectorLoadNode {

   428  protected:

   429   virtual BasicType elt_basic_type() const { return T_BYTE; }

   430  public:

   431   Load8BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE)

   432     : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {}

   433   virtual int Opcode() const;

   434   virtual int store_Opcode() const { return Op_Store8B; }

   435   virtual uint length() const { return 8; }

   436 };

   438 //------------------------------Load4BNode--------------------------------------

   439 // Vector load of 4 bytes (8bits signed) from memory

   440 class Load4BNode : public VectorLoadNode {

   441  protected:

   442   virtual BasicType elt_basic_type() const { return T_BYTE; }

   443  public:

   444   Load4BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE)

   445     : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}

   446   virtual int Opcode() const;

   447   virtual int store_Opcode() const { return Op_Store4B; }

   448   virtual uint length() const { return 4; }

   449 };

   451 //------------------------------Load8CNode--------------------------------------

   452 // Vector load of 8 chars (16bits unsigned) from memory

   453 class Load8CNode : public VectorLoadNode {

   454  protected:

   455   virtual BasicType elt_basic_type() const { return T_CHAR; }

   456  public:

   457   Load8CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR)

   458     : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {}

   459   virtual int Opcode() const;

   460   virtual int store_Opcode() const { return Op_Store8C; }

   461   virtual uint length() const { return 8; }

   462 };

   464 //------------------------------Load4CNode--------------------------------------

   465 // Vector load of 4 chars (16bits unsigned) from memory

   466 class Load4CNode : public VectorLoadNode {

   467  protected:

   468   virtual BasicType elt_basic_type() const { return T_CHAR; }

   469  public:

   470   Load4CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR)

   471     : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}

   472   virtual int Opcode() const;

   473   virtual int store_Opcode() const { return Op_Store4C; }

   474   virtual uint length() const { return 4; }

   475 };

   477 //------------------------------Load2CNode--------------------------------------

   478 // Vector load of 2 chars (16bits unsigned) from memory

   479 class Load2CNode : public VectorLoadNode {

   480  protected:

   481   virtual BasicType elt_basic_type() const { return T_CHAR; }

   482  public:

   483   Load2CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR)

   484     : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {}

   485   virtual int Opcode() const;

   486   virtual int store_Opcode() const { return Op_Store2C; }

   487   virtual uint length() const { return 2; }

   488 };

   490 //------------------------------Load8SNode--------------------------------------

   491 // Vector load of 8 shorts (16bits signed) from memory

   492 class Load8SNode : public VectorLoadNode {

   493  protected:

   494   virtual BasicType elt_basic_type() const { return T_SHORT; }

   495  public:

   496   Load8SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT)

   497     : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {}

   498   virtual int Opcode() const;

   499   virtual int store_Opcode() const { return Op_Store8C; }

   500   virtual uint length() const { return 8; }

   501 };

   503 //------------------------------Load4SNode--------------------------------------

   504 // Vector load of 4 shorts (16bits signed) from memory

   505 class Load4SNode : public VectorLoadNode {

   506  protected:

   507   virtual BasicType elt_basic_type() const { return T_SHORT; }

   508  public:

   509   Load4SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT)

   510     : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}

   511   virtual int Opcode() const;

   512   virtual int store_Opcode() const { return Op_Store4C; }

   513   virtual uint length() const { return 4; }

   514 };

   516 //------------------------------Load2SNode--------------------------------------

   517 // Vector load of 2 shorts (16bits signed) from memory

   518 class Load2SNode : public VectorLoadNode {

   519  protected:

   520   virtual BasicType elt_basic_type() const { return T_SHORT; }

   521  public:

   522   Load2SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT)

   523     : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {}

   524   virtual int Opcode() const;

   525   virtual int store_Opcode() const { return Op_Store2C; }

   526   virtual uint length() const { return 2; }

   527 };

   529 //------------------------------Load4INode--------------------------------------

   530 // Vector load of 4 integers (32bits signed) from memory

   531 class Load4INode : public VectorLoadNode {

   532  protected:

   533   virtual BasicType elt_basic_type() const { return T_INT; }

   534  public:

   535   Load4INode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::INT)

   536     : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}

   537   virtual int Opcode() const;

   538   virtual int store_Opcode() const { return Op_Store4I; }

   539   virtual uint length() const { return 4; }

   540 };

   542 //------------------------------Load2INode--------------------------------------

   543 // Vector load of 2 integers (32bits signed) from memory

   544 class Load2INode : public VectorLoadNode {

   545  protected:

   546   virtual BasicType elt_basic_type() const { return T_INT; }

   547  public:

   548   Load2INode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::INT)

   549     : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {}

   550   virtual int Opcode() const;

   551   virtual int store_Opcode() const { return Op_Store2I; }

   552   virtual uint length() const { return 2; }

   553 };

   555 //------------------------------Load2LNode--------------------------------------

   556 // Vector load of 2 longs (64bits signed) from memory

   557 class Load2LNode : public VectorLoadNode {

   558  protected:

   559   virtual BasicType elt_basic_type() const { return T_LONG; }

   560  public:

   561   Load2LNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeLong *tl = TypeLong::LONG)

   562     : VectorLoadNode(c,mem,adr,at,vect_type(tl,2)) {}

   563   virtual int Opcode() const;

   564   virtual int store_Opcode() const { return Op_Store2L; }

   565   virtual uint length() const { return 2; }

   566 };

   568 //------------------------------Load4FNode--------------------------------------

   569 // Vector load of 4 floats (32bits) from memory

   570 class Load4FNode : public VectorLoadNode {

   571  protected:

   572   virtual BasicType elt_basic_type() const { return T_FLOAT; }

   573  public:

   574   Load4FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::FLOAT)

   575     : VectorLoadNode(c,mem,adr,at,vect_type(t,4)) {}

   576   virtual int Opcode() const;

   577   virtual int store_Opcode() const { return Op_Store4F; }

   578   virtual uint length() const { return 4; }

   579 };

   581 //------------------------------Load2FNode--------------------------------------

   582 // Vector load of 2 floats (32bits) from memory

   583 class Load2FNode : public VectorLoadNode {

   584  protected:

   585   virtual BasicType elt_basic_type() const { return T_FLOAT; }

   586  public:

   587   Load2FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::FLOAT)

   588     : VectorLoadNode(c,mem,adr,at,vect_type(t,2)) {}

   589   virtual int Opcode() const;

   590   virtual int store_Opcode() const { return Op_Store2F; }

   591   virtual uint length() const { return 2; }

   592 };

   594 //------------------------------Load2DNode--------------------------------------

   595 // Vector load of 2 doubles (64bits) from memory

   596 class Load2DNode : public VectorLoadNode {

   597  protected:

   598   virtual BasicType elt_basic_type() const { return T_DOUBLE; }

   599  public:

   600   Load2DNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::DOUBLE)

   601     : VectorLoadNode(c,mem,adr,at,vect_type(t,2)) {}

   602   virtual int Opcode() const;

   603   virtual int store_Opcode() const { return Op_Store2D; }

   604   virtual uint length() const { return 2; }

   605 };

   608 //------------------------------VectorStoreNode--------------------------------------

   609 // Vector Store to memory

   610 class VectorStoreNode : public StoreNode {

   611   virtual uint size_of() const { return sizeof(*this); }

   613  protected:

   614   virtual BasicType elt_basic_type()  const = 0; // Vector element basic type

   616  public:

   617   VectorStoreNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)

   618     : StoreNode(c,mem,adr,at,val) {

   619       init_flags(Flag_is_Vector);

   620   }

   621   virtual int Opcode() const;

   623   virtual uint  length() const = 0; // Vector length

   625   // Element and vector type

   626   const Type* elt_type()  const { return Type::get_const_basic_type(elt_basic_type()); }

   627   const Type* vect_type() const { return VectorNode::vect_type(elt_basic_type(), length()); }

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

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

   631   virtual int memory_size() const { return length()*type2aelembytes(elt_basic_type()); }

   633   // Vector opcode from scalar opcode

   634   static int opcode(int sopc, uint vlen);

   636   static VectorStoreNode* make(Compile* C, int opc, Node* ctl, Node* mem,

   637                                Node* adr, const TypePtr* atyp, VectorNode* val,

   638                                uint vlen);

   639 };

   641 //------------------------------Store16BNode--------------------------------------

   642 // Vector store of 16 bytes (8bits signed) to memory

   643 class Store16BNode : public VectorStoreNode {

   644  protected:

   645   virtual BasicType elt_basic_type() const { return T_BYTE; }

   646  public:

   647   Store16BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)

   648     : VectorStoreNode(c,mem,adr,at,val) {}

   649   virtual int Opcode() const;

   650   virtual uint length() const { return 16; }

   651 };

   653 //------------------------------Store8BNode--------------------------------------

   654 // Vector store of 8 bytes (8bits signed) to memory

   655 class Store8BNode : public VectorStoreNode {

   656  protected:

   657   virtual BasicType elt_basic_type() const { return T_BYTE; }

   658  public:

   659   Store8BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)

   660     : VectorStoreNode(c,mem,adr,at,val) {}

   661   virtual int Opcode() const;

   662   virtual uint length() const { return 8; }

   663 };

   665 //------------------------------Store4BNode--------------------------------------

   666 // Vector store of 4 bytes (8bits signed) to memory

   667 class Store4BNode : public VectorStoreNode {

   668  protected:

   669   virtual BasicType elt_basic_type() const { return T_BYTE; }

   670  public:

   671   Store4BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)

   672     : VectorStoreNode(c,mem,adr,at,val) {}

   673   virtual int Opcode() const;

   674   virtual uint length() const { return 4; }

   675 };

   677 //------------------------------Store8CNode--------------------------------------

   678 // Vector store of 8 chars (16bits signed/unsigned) to memory

   679 class Store8CNode : public VectorStoreNode {

   680  protected:

   681   virtual BasicType elt_basic_type() const { return T_CHAR; }

   682  public:

   683   Store8CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)

   684     : VectorStoreNode(c,mem,adr,at,val) {}

   685   virtual int Opcode() const;

   686   virtual uint length() const { return 8; }

   687 };

   689 //------------------------------Store4CNode--------------------------------------

   690 // Vector store of 4 chars (16bits signed/unsigned) to memory

   691 class Store4CNode : public VectorStoreNode {

   692  protected:

   693   virtual BasicType elt_basic_type() const { return T_CHAR; }

   694  public:

   695   Store4CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)

   696     : VectorStoreNode(c,mem,adr,at,val) {}

   697   virtual int Opcode() const;

   698   virtual uint length() const { return 4; }

   699 };

   701 //------------------------------Store2CNode--------------------------------------

   702 // Vector store of 2 chars (16bits signed/unsigned) to memory

   703 class Store2CNode : public VectorStoreNode {

   704  protected:

   705   virtual BasicType elt_basic_type() const { return T_CHAR; }

   706  public:

   707   Store2CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)

   708     : VectorStoreNode(c,mem,adr,at,val) {}

   709   virtual int Opcode() const;

   710   virtual uint length() const { return 2; }

   711 };

   713 //------------------------------Store4INode--------------------------------------

   714 // Vector store of 4 integers (32bits signed) to memory

   715 class Store4INode : public VectorStoreNode {

   716  protected:

   717   virtual BasicType elt_basic_type() const { return T_INT; }

   718  public:

   719   Store4INode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)

   720     : VectorStoreNode(c,mem,adr,at,val) {}

   721   virtual int Opcode() const;

   722   virtual uint length() const { return 4; }

   723 };

   725 //------------------------------Store2INode--------------------------------------

   726 // Vector store of 2 integers (32bits signed) to memory

   727 class Store2INode : public VectorStoreNode {

   728  protected:

   729   virtual BasicType elt_basic_type() const { return T_INT; }

   730  public:

   731   Store2INode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)

   732     : VectorStoreNode(c,mem,adr,at,val) {}

   733   virtual int Opcode() const;

   734   virtual uint length() const { return 2; }

   735 };

   737 //------------------------------Store2LNode--------------------------------------

   738 // Vector store of 2 longs (64bits signed) to memory

   739 class Store2LNode : public VectorStoreNode {

   740  protected:

   741   virtual BasicType elt_basic_type() const { return T_LONG; }

   742  public:

   743   Store2LNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)

   744     : VectorStoreNode(c,mem,adr,at,val) {}

   745   virtual int Opcode() const;

   746   virtual uint length() const { return 2; }

   747 };

   749 //------------------------------Store4FNode--------------------------------------

   750 // Vector store of 4 floats (32bits) to memory

   751 class Store4FNode : public VectorStoreNode {

   752  protected:

   753   virtual BasicType elt_basic_type() const { return T_FLOAT; }

   754  public:

   755   Store4FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)

   756     : VectorStoreNode(c,mem,adr,at,val) {}

   757   virtual int Opcode() const;

   758   virtual uint length() const { return 4; }

   759 };

   761 //------------------------------Store2FNode--------------------------------------

   762 // Vector store of 2 floats (32bits) to memory

   763 class Store2FNode : public VectorStoreNode {

   764  protected:

   765   virtual BasicType elt_basic_type() const { return T_FLOAT; }

   766  public:

   767   Store2FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)

   768     : VectorStoreNode(c,mem,adr,at,val) {}

   769   virtual int Opcode() const;

   770   virtual uint length() const { return 2; }

   771 };

   773 //------------------------------Store2DNode--------------------------------------

   774 // Vector store of 2 doubles (64bits) to memory

   775 class Store2DNode : public VectorStoreNode {

   776  protected:

   777   virtual BasicType elt_basic_type() const { return T_DOUBLE; }

   778  public:

   779   Store2DNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)

   780     : VectorStoreNode(c,mem,adr,at,val) {}

   781   virtual int Opcode() const;

   782   virtual uint length() const { return 2; }

   783 };

   785 //=========================Promote_Scalar_to_Vector====================================

   787 //------------------------------Replicate16BNode---------------------------------------

   788 // Replicate byte scalar to be vector of 16 bytes

   789 class Replicate16BNode : public VectorNode {

   790  protected:

   791   virtual BasicType elt_basic_type() const { return T_BYTE; }

   792  public:

   793   Replicate16BNode(Node* in1) : VectorNode(in1, 16) {}

   794   virtual int Opcode() const;

   795 };

   797 //------------------------------Replicate8BNode---------------------------------------

   798 // Replicate byte scalar to be vector of 8 bytes

   799 class Replicate8BNode : public VectorNode {

   800  protected:

   801   virtual BasicType elt_basic_type() const { return T_BYTE; }

   802  public:

   803   Replicate8BNode(Node* in1) : VectorNode(in1, 8) {}

   804   virtual int Opcode() const;

   805 };

   807 //------------------------------Replicate4BNode---------------------------------------

   808 // Replicate byte scalar to be vector of 4 bytes

   809 class Replicate4BNode : public VectorNode {

   810  protected:

   811   virtual BasicType elt_basic_type() const { return T_BYTE; }

   812  public:

   813   Replicate4BNode(Node* in1) : VectorNode(in1, 4) {}

   814   virtual int Opcode() const;

   815 };

   817 //------------------------------Replicate8CNode---------------------------------------

   818 // Replicate char scalar to be vector of 8 chars

   819 class Replicate8CNode : public VectorNode {

   820  protected:

   821   virtual BasicType elt_basic_type() const { return T_CHAR; }

   822  public:

   823   Replicate8CNode(Node* in1) : VectorNode(in1, 8) {}

   824   virtual int Opcode() const;

   825 };

   827 //------------------------------Replicate4CNode---------------------------------------

   828 // Replicate char scalar to be vector of 4 chars

   829 class Replicate4CNode : public VectorNode {

   830  protected:

   831   virtual BasicType elt_basic_type() const { return T_CHAR; }

   832  public:

   833   Replicate4CNode(Node* in1) : VectorNode(in1, 4) {}

   834   virtual int Opcode() const;

   835 };

   837 //------------------------------Replicate2CNode---------------------------------------

   838 // Replicate char scalar to be vector of 2 chars

   839 class Replicate2CNode : public VectorNode {

   840  protected:

   841   virtual BasicType elt_basic_type() const { return T_CHAR; }

   842  public:

   843   Replicate2CNode(Node* in1) : VectorNode(in1, 2) {}

   844   virtual int Opcode() const;

   845 };

   847 //------------------------------Replicate8SNode---------------------------------------

   848 // Replicate short scalar to be vector of 8 shorts

   849 class Replicate8SNode : public VectorNode {

   850  protected:

   851   virtual BasicType elt_basic_type() const { return T_SHORT; }

   852  public:

   853   Replicate8SNode(Node* in1) : VectorNode(in1, 8) {}

   854   virtual int Opcode() const;

   855 };

   857 //------------------------------Replicate4SNode---------------------------------------

   858 // Replicate short scalar to be vector of 4 shorts

   859 class Replicate4SNode : public VectorNode {

   860  protected:

   861   virtual BasicType elt_basic_type() const { return T_SHORT; }

   862  public:

   863   Replicate4SNode(Node* in1) : VectorNode(in1, 4) {}

   864   virtual int Opcode() const;

   865 };

   867 //------------------------------Replicate2SNode---------------------------------------

   868 // Replicate short scalar to be vector of 2 shorts

   869 class Replicate2SNode : public VectorNode {

   870  protected:

   871   virtual BasicType elt_basic_type() const { return T_SHORT; }

   872  public:

   873   Replicate2SNode(Node* in1) : VectorNode(in1, 2) {}

   874   virtual int Opcode() const;

   875 };

   877 //------------------------------Replicate4INode---------------------------------------

   878 // Replicate int scalar to be vector of 4 ints

   879 class Replicate4INode : public VectorNode {

   880  protected:

   881   virtual BasicType elt_basic_type() const { return T_INT; }

   882  public:

   883   Replicate4INode(Node* in1) : VectorNode(in1, 4) {}

   884   virtual int Opcode() const;

   885 };

   887 //------------------------------Replicate2INode---------------------------------------

   888 // Replicate int scalar to be vector of 2 ints

   889 class Replicate2INode : public VectorNode {

   890  protected:

   891   virtual BasicType elt_basic_type() const { return T_INT; }

   892  public:

   893   Replicate2INode(Node* in1) : VectorNode(in1, 2) {}

   894   virtual int Opcode() const;

   895 };

   897 //------------------------------Replicate2LNode---------------------------------------

   898 // Replicate long scalar to be vector of 2 longs

   899 class Replicate2LNode : public VectorNode {

   900  protected:

   901   virtual BasicType elt_basic_type() const { return T_LONG; }

   902  public:

   903   Replicate2LNode(Node* in1) : VectorNode(in1, 2) {}

   904   virtual int Opcode() const;

   905 };

   907 //------------------------------Replicate4FNode---------------------------------------

   908 // Replicate float scalar to be vector of 4 floats

   909 class Replicate4FNode : public VectorNode {

   910  protected:

   911   virtual BasicType elt_basic_type() const { return T_FLOAT; }

   912  public:

   913   Replicate4FNode(Node* in1) : VectorNode(in1, 4) {}

   914   virtual int Opcode() const;

   915 };

   917 //------------------------------Replicate2FNode---------------------------------------

   918 // Replicate float scalar to be vector of 2 floats

   919 class Replicate2FNode : public VectorNode {

   920  protected:

   921   virtual BasicType elt_basic_type() const { return T_FLOAT; }

   922  public:

   923   Replicate2FNode(Node* in1) : VectorNode(in1, 2) {}

   924   virtual int Opcode() const;

   925 };

   927 //------------------------------Replicate2DNode---------------------------------------

   928 // Replicate double scalar to be vector of 2 doubles

   929 class Replicate2DNode : public VectorNode {

   930  protected:

   931   virtual BasicType elt_basic_type() const { return T_DOUBLE; }

   932  public:

   933   Replicate2DNode(Node* in1) : VectorNode(in1, 2) {}

   934   virtual int Opcode() const;

   935 };

   937 //========================Pack_Scalars_into_a_Vector==============================

   939 //------------------------------PackNode---------------------------------------

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

   941 class PackNode : public VectorNode {

   942  public:

   943   PackNode(Node* in1)  : VectorNode(in1, 1) {}

   944   PackNode(Node* in1, Node* n2)  : VectorNode(in1, n2, 2) {}

   945   virtual int Opcode() const;

   947   void add_opd(Node* n) {

   948     add_req(n);

   949     _length++;

   950     assert(_length == req() - 1, "vector length matches edge count");

   951   }

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

   954   Node* binaryTreePack(Compile* C, int lo, int hi);

   956   static PackNode* make(Compile* C, Node* s, const Type* elt_t);

   957 };

   959 //------------------------------PackBNode---------------------------------------

   960 // Pack byte scalars into vector

   961 class PackBNode : public PackNode {

   962  protected:

   963   virtual BasicType elt_basic_type() const { return T_BYTE; }

   964  public:

   965   PackBNode(Node* in1)  : PackNode(in1) {}

   966   virtual int Opcode() const;

   967 };

   969 //------------------------------PackCNode---------------------------------------

   970 // Pack char scalars into vector

   971 class PackCNode : public PackNode {

   972  protected:

   973   virtual BasicType elt_basic_type() const { return T_CHAR; }

   974  public:

   975   PackCNode(Node* in1)  : PackNode(in1) {}

   976   virtual int Opcode() const;

   977 };

   979 //------------------------------PackSNode---------------------------------------

   980 // Pack short scalars into a vector

   981 class PackSNode : public PackNode {

   982  protected:

   983   virtual BasicType elt_basic_type() const { return T_SHORT; }

   984  public:

   985   PackSNode(Node* in1)  : PackNode(in1) {}

   986   virtual int Opcode() const;

   987 };

   989 //------------------------------PackINode---------------------------------------

   990 // Pack integer scalars into a vector

   991 class PackINode : public PackNode {

   992  protected:

   993   virtual BasicType elt_basic_type() const { return T_INT; }

   994  public:

   995   PackINode(Node* in1)  : PackNode(in1) {}

   996   PackINode(Node* in1, Node* in2) : PackNode(in1, in2) {}

   997   virtual int Opcode() const;

   998 };

  1000 //------------------------------PackLNode---------------------------------------

  1001 // Pack long scalars into a vector

  1002 class PackLNode : public PackNode {

  1003  protected:

  1004   virtual BasicType elt_basic_type() const { return T_LONG; }

  1005  public:

  1006   PackLNode(Node* in1)  : PackNode(in1) {}

  1007   PackLNode(Node* in1, Node* in2) : PackNode(in1, in2) {}

  1008   virtual int Opcode() const;

  1009 };

  1011 //------------------------------PackFNode---------------------------------------

  1012 // Pack float scalars into vector

  1013 class PackFNode : public PackNode {

  1014  protected:

  1015   virtual BasicType elt_basic_type() const { return T_FLOAT; }

  1016  public:

  1017   PackFNode(Node* in1)  : PackNode(in1) {}

  1018   PackFNode(Node* in1, Node* in2) : PackNode(in1, in2) {}

  1019   virtual int Opcode() const;

  1020 };

  1022 //------------------------------PackDNode---------------------------------------

  1023 // Pack double scalars into a vector

  1024 class PackDNode : public PackNode {

  1025  protected:

  1026   virtual BasicType elt_basic_type() const { return T_DOUBLE; }

  1027  public:

  1028   PackDNode(Node* in1)  : PackNode(in1) {}

  1029   PackDNode(Node* in1, Node* in2) : PackNode(in1, in2) {}

  1030   virtual int Opcode() const;

  1031 };

  1033 // The Pack2xN nodes assist code generation.  They are created from

  1034 // Pack4C, etc. nodes in final_graph_reshape in the form of a

  1035 // balanced, binary tree.

  1037 //------------------------------Pack2x1BNode-----------------------------------------

  1038 // Pack 2 1-byte integers into vector of 2 bytes

  1039 class Pack2x1BNode : public PackNode {

  1040  protected:

  1041   virtual BasicType elt_basic_type() const { return T_BYTE; }

  1042  public:

  1043   Pack2x1BNode(Node *in1, Node* in2) : PackNode(in1, in2) {}

  1044   virtual int Opcode() const;

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

  1046 };

  1048 //------------------------------Pack2x2BNode---------------------------------------

  1049 // Pack 2 2-byte integers into vector of 4 bytes

  1050 class Pack2x2BNode : public PackNode {

  1051  protected:

  1052   virtual BasicType elt_basic_type() const { return T_CHAR; }

  1053  public:

  1054   Pack2x2BNode(Node *in1, Node* in2) : PackNode(in1, in2) {}

  1055   virtual int Opcode() const;

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

  1057 };

  1059 //========================Extract_Scalar_from_Vector===============================

  1061 //------------------------------ExtractNode---------------------------------------

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

  1063 class ExtractNode : public Node {

  1064  public:

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

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

  1067   }

  1068   virtual int Opcode() const;

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

  1071   static Node* make(Compile* C, Node* v, uint position, const Type* opd_t);

  1072 };

  1074 //------------------------------ExtractBNode---------------------------------------

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

  1076 class ExtractBNode : public ExtractNode {

  1077  public:

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

  1079   virtual int Opcode() const;

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

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

  1082 };

  1084 //------------------------------ExtractCNode---------------------------------------

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

  1086 class ExtractCNode : public ExtractNode {

  1087  public:

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

  1089   virtual int Opcode() const;

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

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

  1092 };

  1094 //------------------------------ExtractSNode---------------------------------------

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

  1096 class ExtractSNode : public ExtractNode {

  1097  public:

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

  1099   virtual int Opcode() const;

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

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

  1102 };

  1104 //------------------------------ExtractINode---------------------------------------

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

  1106 class ExtractINode : public ExtractNode {

  1107  public:

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

  1109   virtual int Opcode() const;

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

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

  1112 };

  1114 //------------------------------ExtractLNode---------------------------------------

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

  1116 class ExtractLNode : public ExtractNode {

  1117  public:

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

  1119   virtual int Opcode() const;

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

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

  1122 };

  1124 //------------------------------ExtractFNode---------------------------------------

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

  1126 class ExtractFNode : public ExtractNode {

  1127  public:

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

  1129   virtual int Opcode() const;

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

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

  1132 };

  1134 //------------------------------ExtractDNode---------------------------------------

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

  1136 class ExtractDNode : public ExtractNode {

  1137  public:

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

  1139   virtual int Opcode() const;

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

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

  1142 };

  1144 #endif // SHARE_VM_OPTO_VECTORNODE_HPP

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

src/share/vm/opto/vectornode.hpp@83f08886981c

src/share/vm/opto/vectornode.hpp