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

src/share/vm/opto/vectornode.hpp@c792b641b8bd

src/share/vm/opto/vectornode.hpp

Wed, 10 Sep 2008 20:44:47 -0700

author
kvn
date
Wed, 10 Sep 2008 20:44:47 -0700
changeset 767
c792b641b8bd
parent 631
d1605aabd0a1
child 1907
c18cbe5936b8
permissions
-rw-r--r--

6746907: Improve implicit null check generation
Summary: add missing implicit null check cases.
Reviewed-by: never

     1 /*

     2  * Copyright 2007-2008 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  */

    23 

    24 //------------------------------VectorNode--------------------------------------

    25 // Vector Operation

    26 class VectorNode : public Node {

    27  protected:

    28   uint _length; // vector length

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

    30 

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

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

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

    34   }

    35 

    36  public:

    37   friend class VectorLoadNode;  // For vect_type

    38   friend class VectorStoreNode; // ditto.

    39 

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

    41     init_flags(Flag_is_Vector);

    42   }

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

    44     init_flags(Flag_is_Vector);

    45   }

    46   virtual int Opcode() const;

    47 

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

    49 

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

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

    52   }

    53 

    54   // Element and vector type

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

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

    57 

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

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

    60 

    61   // Vector opcode from scalar opcode

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

    63 

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

    65 

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

    67 

    68 };

    69 

    70 //===========================Vector=ALU=Operations====================================

    71 

    72 //------------------------------AddVBNode---------------------------------------

    73 // Vector add byte

    74 class AddVBNode : public VectorNode {

    75  protected:

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

    77  public:

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

    79   virtual int Opcode() const;

    80 };

    81 

    82 //------------------------------AddVCNode---------------------------------------

    83 // Vector add char

    84 class AddVCNode : public VectorNode {

    85  protected:

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

    87  public:

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

    89   virtual int Opcode() const;

    90 };

    91 

    92 //------------------------------AddVSNode---------------------------------------

    93 // Vector add short

    94 class AddVSNode : public VectorNode {

    95  protected:

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

    97  public:

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

    99   virtual int Opcode() const;

   100 };

   101 

   102 //------------------------------AddVINode---------------------------------------

   103 // Vector add int

   104 class AddVINode : public VectorNode {

   105  protected:

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

   107  public:

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

   109   virtual int Opcode() const;

   110 };

   111 

   112 //------------------------------AddVLNode---------------------------------------

   113 // Vector add long

   114 class AddVLNode : public VectorNode {

   115  protected:

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

   117  public:

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

   119   virtual int Opcode() const;

   120 };

   121 

   122 //------------------------------AddVFNode---------------------------------------

   123 // Vector add float

   124 class AddVFNode : public VectorNode {

   125  protected:

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

   127  public:

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

   129   virtual int Opcode() const;

   130 };

   131 

   132 //------------------------------AddVDNode---------------------------------------

   133 // Vector add double

   134 class AddVDNode : public VectorNode {

   135  protected:

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

   137  public:

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

   139   virtual int Opcode() const;

   140 };

   141 

   142 //------------------------------SubVBNode---------------------------------------

   143 // Vector subtract byte

   144 class SubVBNode : public VectorNode {

   145  protected:

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

   147  public:

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

   149   virtual int Opcode() const;

   150 };

   151 

   152 //------------------------------SubVCNode---------------------------------------

   153 // Vector subtract char

   154 class SubVCNode : public VectorNode {

   155  protected:

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

   157  public:

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

   159   virtual int Opcode() const;

   160 };

   161 

   162 //------------------------------SubVSNode---------------------------------------

   163 // Vector subtract short

   164 class SubVSNode : public VectorNode {

   165  protected:

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

   167  public:

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

   169   virtual int Opcode() const;

   170 };

   171 

   172 //------------------------------SubVINode---------------------------------------

   173 // Vector subtract int

   174 class SubVINode : public VectorNode {

   175  protected:

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

   177  public:

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

   179   virtual int Opcode() const;

   180 };

   181 

   182 //------------------------------SubVLNode---------------------------------------

   183 // Vector subtract long

   184 class SubVLNode : public VectorNode {

   185  protected:

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

   187  public:

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

   189   virtual int Opcode() const;

   190 };

   191 

   192 //------------------------------SubVFNode---------------------------------------

   193 // Vector subtract float

   194 class SubVFNode : public VectorNode {

   195  protected:

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

   197  public:

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

   199   virtual int Opcode() const;

   200 };

   201 

   202 //------------------------------SubVDNode---------------------------------------

   203 // Vector subtract double

   204 class SubVDNode : public VectorNode {

   205  protected:

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

   207  public:

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

   209   virtual int Opcode() const;

   210 };

   211 

   212 //------------------------------MulVFNode---------------------------------------

   213 // Vector multiply float

   214 class MulVFNode : public VectorNode {

   215  protected:

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

   217  public:

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

   219   virtual int Opcode() const;

   220 };

   221 

   222 //------------------------------MulVDNode---------------------------------------

   223 // Vector multiply double

   224 class MulVDNode : public VectorNode {

   225  protected:

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

   227  public:

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

   229   virtual int Opcode() const;

   230 };

   231 

   232 //------------------------------DivVFNode---------------------------------------

   233 // Vector divide float

   234 class DivVFNode : public VectorNode {

   235  protected:

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

   237  public:

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

   239   virtual int Opcode() const;

   240 };

   241 

   242 //------------------------------DivVDNode---------------------------------------

   243 // Vector Divide double

   244 class DivVDNode : public VectorNode {

   245  protected:

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

   247  public:

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

   249   virtual int Opcode() const;

   250 };

   251 

   252 //------------------------------LShiftVBNode---------------------------------------

   253 // Vector lshift byte

   254 class LShiftVBNode : public VectorNode {

   255  protected:

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

   257  public:

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

   259   virtual int Opcode() const;

   260 };

   261 

   262 //------------------------------LShiftVCNode---------------------------------------

   263 // Vector lshift chars

   264 class LShiftVCNode : public VectorNode {

   265  protected:

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

   267  public:

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

   269   virtual int Opcode() const;

   270 };

   271 

   272 //------------------------------LShiftVSNode---------------------------------------

   273 // Vector lshift shorts

   274 class LShiftVSNode : public VectorNode {

   275  protected:

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

   277  public:

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

   279   virtual int Opcode() const;

   280 };

   281 

   282 //------------------------------LShiftVINode---------------------------------------

   283 // Vector lshift ints

   284 class LShiftVINode : public VectorNode {

   285  protected:

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

   287  public:

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

   289   virtual int Opcode() const;

   290 };

   291 

   292 //------------------------------URShiftVBNode---------------------------------------

   293 // Vector urshift bytes

   294 class URShiftVBNode : public VectorNode {

   295  protected:

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

   297  public:

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

   299   virtual int Opcode() const;

   300 };

   301 

   302 //------------------------------URShiftVCNode---------------------------------------

   303 // Vector urshift char

   304 class URShiftVCNode : public VectorNode {

   305  protected:

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

   307  public:

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

   309   virtual int Opcode() const;

   310 };

   311 

   312 //------------------------------URShiftVSNode---------------------------------------

   313 // Vector urshift shorts

   314 class URShiftVSNode : public VectorNode {

   315  protected:

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

   317  public:

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

   319   virtual int Opcode() const;

   320 };

   321 

   322 //------------------------------URShiftVINode---------------------------------------

   323 // Vector urshift ints

   324 class URShiftVINode : public VectorNode {

   325  protected:

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

   327  public:

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

   329   virtual int Opcode() const;

   330 };

   331 

   332 //------------------------------AndVNode---------------------------------------

   333 // Vector and

   334 class AndVNode : public VectorNode {

   335  protected:

   336   BasicType _bt;

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

   338  public:

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

   340   virtual int Opcode() const;

   341 };

   342 

   343 //------------------------------OrVNode---------------------------------------

   344 // Vector or

   345 class OrVNode : public VectorNode {

   346  protected:

   347   BasicType _bt;

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

   349  public:

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

   351   virtual int Opcode() const;

   352 };

   353 

   354 //------------------------------XorVNode---------------------------------------

   355 // Vector xor

   356 class XorVNode : public VectorNode {

   357  protected:

   358   BasicType _bt;

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

   360  public:

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

   362   virtual int Opcode() const;

   363 };

   364 

   365 //================================= M E M O R Y ==================================

   366 

   367 

   368 //------------------------------VectorLoadNode--------------------------------------

   369 // Vector Load from memory

   370 class VectorLoadNode : public LoadNode {

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

   372 

   373  protected:

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

   375   // For use in constructor

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

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

   378   }

   379 

   380  public:

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

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

   383       init_flags(Flag_is_Vector);

   384   }

   385   virtual int Opcode() const;

   386 

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

   388 

   389   // Element and vector type

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

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

   392 

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

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

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

   396 

   397   // Vector opcode from scalar opcode

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

   399 

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

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

   402 };

   403 

   404 //------------------------------Load16BNode--------------------------------------

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

   406 class Load16BNode : public VectorLoadNode {

   407  protected:

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

   409  public:

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

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

   412   virtual int Opcode() const;

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

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

   415 };

   416 

   417 //------------------------------Load8BNode--------------------------------------

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

   419 class Load8BNode : public VectorLoadNode {

   420  protected:

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

   422  public:

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

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

   425   virtual int Opcode() const;

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

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

   428 };

   429 

   430 //------------------------------Load4BNode--------------------------------------

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

   432 class Load4BNode : public VectorLoadNode {

   433  protected:

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

   435  public:

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

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

   438   virtual int Opcode() const;

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

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

   441 };

   442 

   443 //------------------------------Load8CNode--------------------------------------

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

   445 class Load8CNode : public VectorLoadNode {

   446  protected:

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

   448  public:

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

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

   451   virtual int Opcode() const;

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

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

   454 };

   455 

   456 //------------------------------Load4CNode--------------------------------------

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

   458 class Load4CNode : public VectorLoadNode {

   459  protected:

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

   461  public:

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

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

   464   virtual int Opcode() const;

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

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

   467 };

   468 

   469 //------------------------------Load2CNode--------------------------------------

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

   471 class Load2CNode : public VectorLoadNode {

   472  protected:

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

   474  public:

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

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

   477   virtual int Opcode() const;

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

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

   480 };

   481 

   482 //------------------------------Load8SNode--------------------------------------

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

   484 class Load8SNode : public VectorLoadNode {

   485  protected:

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

   487  public:

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

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

   490   virtual int Opcode() const;

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

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

   493 };

   494 

   495 //------------------------------Load4SNode--------------------------------------

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

   497 class Load4SNode : public VectorLoadNode {

   498  protected:

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

   500  public:

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

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

   503   virtual int Opcode() const;

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

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

   506 };

   507 

   508 //------------------------------Load2SNode--------------------------------------

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

   510 class Load2SNode : public VectorLoadNode {

   511  protected:

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

   513  public:

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

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

   516   virtual int Opcode() const;

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

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

   519 };

   520 

   521 //------------------------------Load4INode--------------------------------------

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

   523 class Load4INode : public VectorLoadNode {

   524  protected:

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

   526  public:

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

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

   529   virtual int Opcode() const;

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

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

   532 };

   533 

   534 //------------------------------Load2INode--------------------------------------

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

   536 class Load2INode : public VectorLoadNode {

   537  protected:

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

   539  public:

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

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

   542   virtual int Opcode() const;

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

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

   545 };

   546 

   547 //------------------------------Load2LNode--------------------------------------

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

   549 class Load2LNode : public VectorLoadNode {

   550  protected:

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

   552  public:

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

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

   555   virtual int Opcode() const;

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

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

   558 };

   559 

   560 //------------------------------Load4FNode--------------------------------------

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

   562 class Load4FNode : public VectorLoadNode {

   563  protected:

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

   565  public:

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

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

   568   virtual int Opcode() const;

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

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

   571 };

   572 

   573 //------------------------------Load2FNode--------------------------------------

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

   575 class Load2FNode : public VectorLoadNode {

   576  protected:

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

   578  public:

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

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

   581   virtual int Opcode() const;

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

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

   584 };

   585 

   586 //------------------------------Load2DNode--------------------------------------

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

   588 class Load2DNode : public VectorLoadNode {

   589  protected:

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

   591  public:

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

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

   594   virtual int Opcode() const;

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

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

   597 };

   598 

   599 

   600 //------------------------------VectorStoreNode--------------------------------------

   601 // Vector Store to memory

   602 class VectorStoreNode : public StoreNode {

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

   604 

   605  protected:

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

   607 

   608  public:

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

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

   611       init_flags(Flag_is_Vector);

   612   }

   613   virtual int Opcode() const;

   614 

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

   616 

   617   // Element and vector type

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

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

   620 

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

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

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

   624 

   625   // Vector opcode from scalar opcode

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

   627 

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

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

   630                                uint vlen);

   631 };

   632 

   633 //------------------------------Store16BNode--------------------------------------

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

   635 class Store16BNode : public VectorStoreNode {

   636  protected:

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

   638  public:

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

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

   641   virtual int Opcode() const;

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

   643 };

   644 

   645 //------------------------------Store8BNode--------------------------------------

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

   647 class Store8BNode : public VectorStoreNode {

   648  protected:

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

   650  public:

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

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

   653   virtual int Opcode() const;

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

   655 };

   656 

   657 //------------------------------Store4BNode--------------------------------------

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

   659 class Store4BNode : public VectorStoreNode {

   660  protected:

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

   662  public:

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

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

   665   virtual int Opcode() const;

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

   667 };

   668 

   669 //------------------------------Store8CNode--------------------------------------

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

   671 class Store8CNode : public VectorStoreNode {

   672  protected:

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

   674  public:

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

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

   677   virtual int Opcode() const;

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

   679 };

   680 

   681 //------------------------------Store4CNode--------------------------------------

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

   683 class Store4CNode : public VectorStoreNode {

   684  protected:

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

   686  public:

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

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

   689   virtual int Opcode() const;

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

   691 };

   692 

   693 //------------------------------Store2CNode--------------------------------------

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

   695 class Store2CNode : public VectorStoreNode {

   696  protected:

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

   698  public:

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

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

   701   virtual int Opcode() const;

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

   703 };

   704 

   705 //------------------------------Store4INode--------------------------------------

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

   707 class Store4INode : public VectorStoreNode {

   708  protected:

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

   710  public:

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

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

   713   virtual int Opcode() const;

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

   715 };

   716 

   717 //------------------------------Store2INode--------------------------------------

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

   719 class Store2INode : public VectorStoreNode {

   720  protected:

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

   722  public:

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

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

   725   virtual int Opcode() const;

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

   727 };

   728 

   729 //------------------------------Store2LNode--------------------------------------

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

   731 class Store2LNode : public VectorStoreNode {

   732  protected:

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

   734  public:

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

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

   737   virtual int Opcode() const;

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

   739 };

   740 

   741 //------------------------------Store4FNode--------------------------------------

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

   743 class Store4FNode : public VectorStoreNode {

   744  protected:

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

   746  public:

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

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

   749   virtual int Opcode() const;

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

   751 };

   752 

   753 //------------------------------Store2FNode--------------------------------------

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

   755 class Store2FNode : public VectorStoreNode {

   756  protected:

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

   758  public:

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

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

   761   virtual int Opcode() const;

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

   763 };

   764 

   765 //------------------------------Store2DNode--------------------------------------

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

   767 class Store2DNode : public VectorStoreNode {

   768  protected:

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

   770  public:

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

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

   773   virtual int Opcode() const;

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

   775 };

   776 

   777 //=========================Promote_Scalar_to_Vector====================================

   778 

   779 //------------------------------Replicate16BNode---------------------------------------

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

   781 class Replicate16BNode : public VectorNode {

   782  protected:

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

   784  public:

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

   786   virtual int Opcode() const;

   787 };

   788 

   789 //------------------------------Replicate8BNode---------------------------------------

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

   791 class Replicate8BNode : public VectorNode {

   792  protected:

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

   794  public:

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

   796   virtual int Opcode() const;

   797 };

   798 

   799 //------------------------------Replicate4BNode---------------------------------------

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

   801 class Replicate4BNode : public VectorNode {

   802  protected:

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

   804  public:

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

   806   virtual int Opcode() const;

   807 };

   808 

   809 //------------------------------Replicate8CNode---------------------------------------

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

   811 class Replicate8CNode : public VectorNode {

   812  protected:

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

   814  public:

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

   816   virtual int Opcode() const;

   817 };

   818 

   819 //------------------------------Replicate4CNode---------------------------------------

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

   821 class Replicate4CNode : public VectorNode {

   822  protected:

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

   824  public:

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

   826   virtual int Opcode() const;

   827 };

   828 

   829 //------------------------------Replicate2CNode---------------------------------------

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

   831 class Replicate2CNode : public VectorNode {

   832  protected:

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

   834  public:

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

   836   virtual int Opcode() const;

   837 };

   838 

   839 //------------------------------Replicate8SNode---------------------------------------

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

   841 class Replicate8SNode : public VectorNode {

   842  protected:

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

   844  public:

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

   846   virtual int Opcode() const;

   847 };

   848 

   849 //------------------------------Replicate4SNode---------------------------------------

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

   851 class Replicate4SNode : public VectorNode {

   852  protected:

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

   854  public:

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

   856   virtual int Opcode() const;

   857 };

   858 

   859 //------------------------------Replicate2SNode---------------------------------------

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

   861 class Replicate2SNode : public VectorNode {

   862  protected:

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

   864  public:

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

   866   virtual int Opcode() const;

   867 };

   868 

   869 //------------------------------Replicate4INode---------------------------------------

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

   871 class Replicate4INode : public VectorNode {

   872  protected:

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

   874  public:

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

   876   virtual int Opcode() const;

   877 };

   878 

   879 //------------------------------Replicate2INode---------------------------------------

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

   881 class Replicate2INode : public VectorNode {

   882  protected:

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

   884  public:

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

   886   virtual int Opcode() const;

   887 };

   888 

   889 //------------------------------Replicate2LNode---------------------------------------

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

   891 class Replicate2LNode : public VectorNode {

   892  protected:

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

   894  public:

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

   896   virtual int Opcode() const;

   897 };

   898 

   899 //------------------------------Replicate4FNode---------------------------------------

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

   901 class Replicate4FNode : public VectorNode {

   902  protected:

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

   904  public:

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

   906   virtual int Opcode() const;

   907 };

   908 

   909 //------------------------------Replicate2FNode---------------------------------------

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

   911 class Replicate2FNode : public VectorNode {

   912  protected:

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

   914  public:

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

   916   virtual int Opcode() const;

   917 };

   918 

   919 //------------------------------Replicate2DNode---------------------------------------

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

   921 class Replicate2DNode : public VectorNode {

   922  protected:

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

   924  public:

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

   926   virtual int Opcode() const;

   927 };

   928 

   929 //========================Pack_Scalars_into_a_Vector==============================

   930 

   931 //------------------------------PackNode---------------------------------------

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

   933 class PackNode : public VectorNode {

   934  public:

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

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

   937   virtual int Opcode() const;

   938 

   939   void add_opd(Node* n) {

   940     add_req(n);

   941     _length++;

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

   943   }

   944 

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

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

   947 

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

   949 };

   950 

   951 //------------------------------PackBNode---------------------------------------

   952 // Pack byte scalars into vector

   953 class PackBNode : public PackNode {

   954  protected:

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

   956  public:

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

   958   virtual int Opcode() const;

   959 };

   960 

   961 //------------------------------PackCNode---------------------------------------

   962 // Pack char scalars into vector

   963 class PackCNode : public PackNode {

   964  protected:

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

   966  public:

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

   968   virtual int Opcode() const;

   969 };

   970 

   971 //------------------------------PackSNode---------------------------------------

   972 // Pack short scalars into a vector

   973 class PackSNode : public PackNode {

   974  protected:

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

   976  public:

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

   978   virtual int Opcode() const;

   979 };

   980 

   981 //------------------------------PackINode---------------------------------------

   982 // Pack integer scalars into a vector

   983 class PackINode : public PackNode {

   984  protected:

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

   986  public:

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

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

   989   virtual int Opcode() const;

   990 };

   991 

   992 //------------------------------PackLNode---------------------------------------

   993 // Pack long scalars into a vector

   994 class PackLNode : public PackNode {

   995  protected:

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

   997  public:

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

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

  1000   virtual int Opcode() const;

  1001 };

  1002 

  1003 //------------------------------PackFNode---------------------------------------

  1004 // Pack float scalars into vector

  1005 class PackFNode : public PackNode {

  1006  protected:

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

  1008  public:

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

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

  1011   virtual int Opcode() const;

  1012 };

  1013 

  1014 //------------------------------PackDNode---------------------------------------

  1015 // Pack double scalars into a vector

  1016 class PackDNode : public PackNode {

  1017  protected:

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

  1019  public:

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

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

  1022   virtual int Opcode() const;

  1023 };

  1024 

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

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

  1027 // balanced, binary tree.

  1028 

  1029 //------------------------------Pack2x1BNode-----------------------------------------

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

  1031 class Pack2x1BNode : public PackNode {

  1032  protected:

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

  1034  public:

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

  1036   virtual int Opcode() const;

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

  1038 };

  1039 

  1040 //------------------------------Pack2x2BNode---------------------------------------

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

  1042 class Pack2x2BNode : public PackNode {

  1043  protected:

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

  1045  public:

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

  1047   virtual int Opcode() const;

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

  1049 };

  1050 

  1051 //========================Extract_Scalar_from_Vector===============================

  1052 

  1053 //------------------------------ExtractNode---------------------------------------

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

  1055 class ExtractNode : public Node {

  1056  public:

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

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

  1059   }

  1060   virtual int Opcode() const;

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

  1062 

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

  1064 };

  1065 

  1066 //------------------------------ExtractBNode---------------------------------------

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

  1068 class ExtractBNode : public ExtractNode {

  1069  public:

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

  1071   virtual int Opcode() const;

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

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

  1074 };

  1075 

  1076 //------------------------------ExtractCNode---------------------------------------

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

  1078 class ExtractCNode : public ExtractNode {

  1079  public:

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

  1081   virtual int Opcode() const;

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

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

  1084 };

  1085 

  1086 //------------------------------ExtractSNode---------------------------------------

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

  1088 class ExtractSNode : public ExtractNode {

  1089  public:

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

  1091   virtual int Opcode() const;

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

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

  1094 };

  1095 

  1096 //------------------------------ExtractINode---------------------------------------

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

  1098 class ExtractINode : public ExtractNode {

  1099  public:

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

  1101   virtual int Opcode() const;

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

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

  1104 };

  1105 

  1106 //------------------------------ExtractLNode---------------------------------------

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

  1108 class ExtractLNode : public ExtractNode {

  1109  public:

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

  1111   virtual int Opcode() const;

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

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

  1114 };

  1115 

  1116 //------------------------------ExtractFNode---------------------------------------

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

  1118 class ExtractFNode : public ExtractNode {

  1119  public:

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

  1121   virtual int Opcode() const;

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

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

  1124 };

  1125 

  1126 //------------------------------ExtractDNode---------------------------------------

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

  1128 class ExtractDNode : public ExtractNode {

  1129  public:

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

  1131   virtual int Opcode() const;

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

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

  1134 };

Mercurial Repository: jdk8-mips64-public/hotspot

mercurial