--- a/hotspot/src/share/vm/opto/vectornode.hpp Thu Jun 14 14:59:52 2012 -0700
+++ b/hotspot/src/share/vm/opto/vectornode.hpp Fri Jun 15 01:25:19 2012 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -31,48 +31,32 @@
//------------------------------VectorNode--------------------------------------
// Vector Operation
-class VectorNode : public Node {
- virtual uint size_of() const { return sizeof(*this); }
- protected:
- uint _length; // vector length
- virtual BasicType elt_basic_type() const = 0; // Vector element basic type
+class VectorNode : public TypeNode {
+ public:
- static const Type* vect_type(BasicType elt_bt, uint len);
- static const Type* vect_type(const Type* elt_type, uint len) {
- return vect_type(elt_type->array_element_basic_type(), len);
+ VectorNode(Node* n1, const TypeVect* vt) : TypeNode(vt, 2) {
+ init_class_id(Class_Vector);
+ init_req(1, n1);
+ }
+ VectorNode(Node* n1, Node* n2, const TypeVect* vt) : TypeNode(vt, 3) {
+ init_class_id(Class_Vector);
+ init_req(1, n1);
+ init_req(2, n2);
}
- public:
- friend class VectorLoadNode; // For vect_type
- friend class VectorStoreNode; // ditto.
+ const TypeVect* vect_type() const { return type()->is_vect(); }
+ uint length() const { return vect_type()->length(); } // Vector length
- VectorNode(Node* n1, uint vlen) : Node(NULL, n1), _length(vlen) {
- init_class_id(Class_Vector);
- }
- VectorNode(Node* n1, Node* n2, uint vlen) : Node(NULL, n1, n2), _length(vlen) {
- init_class_id(Class_Vector);
- }
virtual int Opcode() const;
- uint length() const { return _length; } // Vector length
-
- static uint max_vlen(BasicType bt) { // max vector length
- return (uint)(Matcher::vector_width_in_bytes() / type2aelembytes(bt));
- }
-
- // Element and vector type
- const Type* elt_type() const { return Type::get_const_basic_type(elt_basic_type()); }
- const Type* vect_type() const { return vect_type(elt_basic_type(), length()); }
-
- virtual const Type *bottom_type() const { return vect_type(); }
- virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(); }
-
- // Vector opcode from scalar opcode
- static int opcode(int sopc, uint vlen, const Type* opd_t);
+ virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(vect_type()->length_in_bytes()); }
static VectorNode* scalar2vector(Compile* C, Node* s, uint vlen, const Type* opd_t);
- static VectorNode* make(Compile* C, int sopc, Node* n1, Node* n2, uint vlen, const Type* elt_t);
+ static VectorNode* make(Compile* C, int opc, Node* n1, Node* n2, uint vlen, BasicType bt);
+
+ static int opcode(int opc, uint vlen, BasicType bt);
+ static bool implemented(int opc, uint vlen, BasicType bt);
};
@@ -81,981 +65,393 @@
//------------------------------AddVBNode---------------------------------------
// Vector add byte
class AddVBNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_BYTE; }
public:
- AddVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
- virtual int Opcode() const;
-};
-
-//------------------------------AddVCNode---------------------------------------
-// Vector add char
-class AddVCNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_CHAR; }
- public:
- AddVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ AddVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------AddVSNode---------------------------------------
-// Vector add short
+// Vector add char/short
class AddVSNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_SHORT; }
public:
- AddVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ AddVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------AddVINode---------------------------------------
// Vector add int
class AddVINode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_INT; }
public:
- AddVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ AddVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------AddVLNode---------------------------------------
// Vector add long
class AddVLNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_LONG; }
public:
- AddVLNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ AddVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------AddVFNode---------------------------------------
// Vector add float
class AddVFNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_FLOAT; }
public:
- AddVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ AddVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------AddVDNode---------------------------------------
// Vector add double
class AddVDNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_DOUBLE; }
public:
- AddVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ AddVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------SubVBNode---------------------------------------
// Vector subtract byte
class SubVBNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_BYTE; }
public:
- SubVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
- virtual int Opcode() const;
-};
-
-//------------------------------SubVCNode---------------------------------------
-// Vector subtract char
-class SubVCNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_CHAR; }
- public:
- SubVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ SubVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------SubVSNode---------------------------------------
// Vector subtract short
class SubVSNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_SHORT; }
public:
- SubVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ SubVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------SubVINode---------------------------------------
// Vector subtract int
class SubVINode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_INT; }
public:
- SubVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ SubVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------SubVLNode---------------------------------------
// Vector subtract long
class SubVLNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_LONG; }
public:
- SubVLNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ SubVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------SubVFNode---------------------------------------
// Vector subtract float
class SubVFNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_FLOAT; }
public:
- SubVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ SubVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------SubVDNode---------------------------------------
// Vector subtract double
class SubVDNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_DOUBLE; }
public:
- SubVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ SubVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------MulVFNode---------------------------------------
// Vector multiply float
class MulVFNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_FLOAT; }
public:
- MulVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------MulVDNode---------------------------------------
// Vector multiply double
class MulVDNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_DOUBLE; }
public:
- MulVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ MulVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------DivVFNode---------------------------------------
// Vector divide float
class DivVFNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_FLOAT; }
public:
- DivVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ DivVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------DivVDNode---------------------------------------
// Vector Divide double
class DivVDNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_DOUBLE; }
public:
- DivVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ DivVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------LShiftVBNode---------------------------------------
// Vector lshift byte
class LShiftVBNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_BYTE; }
public:
- LShiftVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
- virtual int Opcode() const;
-};
-
-//------------------------------LShiftVCNode---------------------------------------
-// Vector lshift chars
-class LShiftVCNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_CHAR; }
- public:
- LShiftVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ LShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------LShiftVSNode---------------------------------------
// Vector lshift shorts
class LShiftVSNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_SHORT; }
public:
- LShiftVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ LShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------LShiftVINode---------------------------------------
// Vector lshift ints
class LShiftVINode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_INT; }
public:
- LShiftVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ LShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------URShiftVBNode---------------------------------------
// Vector urshift bytes
-class URShiftVBNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_BYTE; }
+class RShiftVBNode : public VectorNode {
public:
- URShiftVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
- virtual int Opcode() const;
-};
-
-//------------------------------URShiftVCNode---------------------------------------
-// Vector urshift char
-class URShiftVCNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_SHORT; }
- public:
- URShiftVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ RShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------URShiftVSNode---------------------------------------
// Vector urshift shorts
-class URShiftVSNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_SHORT; }
+class RShiftVSNode : public VectorNode {
public:
- URShiftVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ RShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------URShiftVINode---------------------------------------
// Vector urshift ints
-class URShiftVINode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_INT; }
+class RShiftVINode : public VectorNode {
public:
- URShiftVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
+ RShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------AndVNode---------------------------------------
// Vector and
class AndVNode : public VectorNode {
- protected:
- BasicType _bt;
- virtual BasicType elt_basic_type() const { return _bt; }
public:
- AndVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {}
+ AndVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------OrVNode---------------------------------------
// Vector or
class OrVNode : public VectorNode {
- protected:
- BasicType _bt;
- virtual BasicType elt_basic_type() const { return _bt; }
public:
- OrVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {}
+ OrVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
//------------------------------XorVNode---------------------------------------
// Vector xor
class XorVNode : public VectorNode {
- protected:
- BasicType _bt;
- virtual BasicType elt_basic_type() const { return _bt; }
public:
- XorVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {}
+ XorVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
virtual int Opcode() const;
};
-//================================= M E M O R Y ==================================
-
+//================================= M E M O R Y ===============================
-//------------------------------VectorLoadNode--------------------------------------
-// Vector Load from memory
-class VectorLoadNode : public LoadNode {
- virtual uint size_of() const { return sizeof(*this); }
-
- protected:
- virtual BasicType elt_basic_type() const = 0; // Vector element basic type
- // For use in constructor
- static const Type* vect_type(const Type* elt_type, uint len) {
- return VectorNode::vect_type(elt_type, len);
+//------------------------------LoadVectorNode---------------------------------
+// Load Vector from memory
+class LoadVectorNode : public LoadNode {
+ public:
+ LoadVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeVect* vt)
+ : LoadNode(c, mem, adr, at, vt) {
+ init_class_id(Class_LoadVector);
}
- public:
- VectorLoadNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *rt)
- : LoadNode(c,mem,adr,at,rt) {
- init_class_id(Class_VectorLoad);
- }
+ const TypeVect* vect_type() const { return type()->is_vect(); }
+ uint length() const { return vect_type()->length(); } // Vector length
+
virtual int Opcode() const;
- virtual uint length() const = 0; // Vector length
-
- // Element and vector type
- const Type* elt_type() const { return Type::get_const_basic_type(elt_basic_type()); }
- const Type* vect_type() const { return VectorNode::vect_type(elt_basic_type(), length()); }
-
- virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(); }
+ virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(memory_size()); }
virtual BasicType memory_type() const { return T_VOID; }
- virtual int memory_size() const { return length()*type2aelembytes(elt_basic_type()); }
-
- // Vector opcode from scalar opcode
- static int opcode(int sopc, uint vlen);
-
- static VectorLoadNode* make(Compile* C, int opc, Node* ctl, Node* mem,
- Node* adr, const TypePtr* atyp, uint vlen);
-};
-
-//------------------------------Load16BNode--------------------------------------
-// Vector load of 16 bytes (8bits signed) from memory
-class Load16BNode : public VectorLoadNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_BYTE; }
- public:
- Load16BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE)
- : VectorLoadNode(c,mem,adr,at,vect_type(ti,16)) {}
- virtual int Opcode() const;
- virtual int store_Opcode() const { return Op_Store16B; }
- virtual uint length() const { return 16; }
-};
-
-//------------------------------Load8BNode--------------------------------------
-// Vector load of 8 bytes (8bits signed) from memory
-class Load8BNode : public VectorLoadNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_BYTE; }
- public:
- Load8BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE)
- : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {}
- virtual int Opcode() const;
- virtual int store_Opcode() const { return Op_Store8B; }
- virtual uint length() const { return 8; }
-};
+ virtual int memory_size() const { return vect_type()->length_in_bytes(); }
-//------------------------------Load4BNode--------------------------------------
-// Vector load of 4 bytes (8bits signed) from memory
-class Load4BNode : public VectorLoadNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_BYTE; }
- public:
- Load4BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE)
- : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}
- virtual int Opcode() const;
- virtual int store_Opcode() const { return Op_Store4B; }
- virtual uint length() const { return 4; }
-};
-
-//------------------------------Load8CNode--------------------------------------
-// Vector load of 8 chars (16bits unsigned) from memory
-class Load8CNode : public VectorLoadNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_CHAR; }
- public:
- Load8CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR)
- : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {}
- virtual int Opcode() const;
- virtual int store_Opcode() const { return Op_Store8C; }
- virtual uint length() const { return 8; }
-};
+ virtual int store_Opcode() const { return Op_StoreVector; }
-//------------------------------Load4CNode--------------------------------------
-// Vector load of 4 chars (16bits unsigned) from memory
-class Load4CNode : public VectorLoadNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_CHAR; }
- public:
- Load4CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR)
- : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}
- virtual int Opcode() const;
- virtual int store_Opcode() const { return Op_Store4C; }
- virtual uint length() const { return 4; }
-};
-
-//------------------------------Load2CNode--------------------------------------
-// Vector load of 2 chars (16bits unsigned) from memory
-class Load2CNode : public VectorLoadNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_CHAR; }
- public:
- Load2CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR)
- : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {}
- virtual int Opcode() const;
- virtual int store_Opcode() const { return Op_Store2C; }
- virtual uint length() const { return 2; }
-};
-
-//------------------------------Load8SNode--------------------------------------
-// Vector load of 8 shorts (16bits signed) from memory
-class Load8SNode : public VectorLoadNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_SHORT; }
- public:
- Load8SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT)
- : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {}
- virtual int Opcode() const;
- virtual int store_Opcode() const { return Op_Store8C; }
- virtual uint length() const { return 8; }
+ static LoadVectorNode* make(Compile* C, int opc, Node* ctl, Node* mem,
+ Node* adr, const TypePtr* atyp, uint vlen, BasicType bt);
};
-//------------------------------Load4SNode--------------------------------------
-// Vector load of 4 shorts (16bits signed) from memory
-class Load4SNode : public VectorLoadNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_SHORT; }
- public:
- Load4SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT)
- : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}
- virtual int Opcode() const;
- virtual int store_Opcode() const { return Op_Store4C; }
- virtual uint length() const { return 4; }
-};
-
-//------------------------------Load2SNode--------------------------------------
-// Vector load of 2 shorts (16bits signed) from memory
-class Load2SNode : public VectorLoadNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_SHORT; }
- public:
- Load2SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT)
- : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {}
- virtual int Opcode() const;
- virtual int store_Opcode() const { return Op_Store2C; }
- virtual uint length() const { return 2; }
-};
-
-//------------------------------Load4INode--------------------------------------
-// Vector load of 4 integers (32bits signed) from memory
-class Load4INode : public VectorLoadNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_INT; }
- public:
- Load4INode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::INT)
- : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}
- virtual int Opcode() const;
- virtual int store_Opcode() const { return Op_Store4I; }
- virtual uint length() const { return 4; }
-};
-
-//------------------------------Load2INode--------------------------------------
-// Vector load of 2 integers (32bits signed) from memory
-class Load2INode : public VectorLoadNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_INT; }
- public:
- Load2INode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::INT)
- : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {}
- virtual int Opcode() const;
- virtual int store_Opcode() const { return Op_Store2I; }
- virtual uint length() const { return 2; }
-};
-
-//------------------------------Load2LNode--------------------------------------
-// Vector load of 2 longs (64bits signed) from memory
-class Load2LNode : public VectorLoadNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_LONG; }
+//------------------------------StoreVectorNode--------------------------------
+// Store Vector to memory
+class StoreVectorNode : public StoreNode {
public:
- Load2LNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeLong *tl = TypeLong::LONG)
- : VectorLoadNode(c,mem,adr,at,vect_type(tl,2)) {}
- virtual int Opcode() const;
- virtual int store_Opcode() const { return Op_Store2L; }
- virtual uint length() const { return 2; }
-};
-
-//------------------------------Load4FNode--------------------------------------
-// Vector load of 4 floats (32bits) from memory
-class Load4FNode : public VectorLoadNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_FLOAT; }
- public:
- Load4FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::FLOAT)
- : VectorLoadNode(c,mem,adr,at,vect_type(t,4)) {}
- virtual int Opcode() const;
- virtual int store_Opcode() const { return Op_Store4F; }
- virtual uint length() const { return 4; }
-};
+ StoreVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
+ : StoreNode(c, mem, adr, at, val) {
+ assert(val->is_Vector() || val->is_LoadVector(), "sanity");
+ init_class_id(Class_StoreVector);
+ }
-//------------------------------Load2FNode--------------------------------------
-// Vector load of 2 floats (32bits) from memory
-class Load2FNode : public VectorLoadNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_FLOAT; }
- public:
- Load2FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::FLOAT)
- : VectorLoadNode(c,mem,adr,at,vect_type(t,2)) {}
- virtual int Opcode() const;
- virtual int store_Opcode() const { return Op_Store2F; }
- virtual uint length() const { return 2; }
-};
+ const TypeVect* vect_type() const { return in(MemNode::ValueIn)->bottom_type()->is_vect(); }
+ uint length() const { return vect_type()->length(); } // Vector length
-//------------------------------Load2DNode--------------------------------------
-// Vector load of 2 doubles (64bits) from memory
-class Load2DNode : public VectorLoadNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_DOUBLE; }
- public:
- Load2DNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::DOUBLE)
- : VectorLoadNode(c,mem,adr,at,vect_type(t,2)) {}
- virtual int Opcode() const;
- virtual int store_Opcode() const { return Op_Store2D; }
- virtual uint length() const { return 2; }
-};
-
-
-//------------------------------VectorStoreNode--------------------------------------
-// Vector Store to memory
-class VectorStoreNode : public StoreNode {
- virtual uint size_of() const { return sizeof(*this); }
-
- protected:
- virtual BasicType elt_basic_type() const = 0; // Vector element basic type
-
- public:
- VectorStoreNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
- : StoreNode(c,mem,adr,at,val) {
- init_class_id(Class_VectorStore);
- }
virtual int Opcode() const;
- virtual uint length() const = 0; // Vector length
-
- // Element and vector type
- const Type* elt_type() const { return Type::get_const_basic_type(elt_basic_type()); }
- const Type* vect_type() const { return VectorNode::vect_type(elt_basic_type(), length()); }
+ virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(memory_size()); }
+ virtual BasicType memory_type() const { return T_VOID; }
+ virtual int memory_size() const { return vect_type()->length_in_bytes(); }
- virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(); }
- virtual BasicType memory_type() const { return T_VOID; }
- virtual int memory_size() const { return length()*type2aelembytes(elt_basic_type()); }
-
- // Vector opcode from scalar opcode
- static int opcode(int sopc, uint vlen);
-
- static VectorStoreNode* make(Compile* C, int opc, Node* ctl, Node* mem,
+ static StoreVectorNode* make(Compile* C, int opc, Node* ctl, Node* mem,
Node* adr, const TypePtr* atyp, Node* val,
uint vlen);
};
-//------------------------------Store16BNode--------------------------------------
-// Vector store of 16 bytes (8bits signed) to memory
-class Store16BNode : public VectorStoreNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_BYTE; }
- public:
- Store16BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
- : VectorStoreNode(c,mem,adr,at,val) {}
- virtual int Opcode() const;
- virtual uint length() const { return 16; }
-};
+
+//=========================Promote_Scalar_to_Vector============================
-//------------------------------Store8BNode--------------------------------------
-// Vector store of 8 bytes (8bits signed) to memory
-class Store8BNode : public VectorStoreNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_BYTE; }
+//------------------------------ReplicateBNode---------------------------------
+// Replicate byte scalar to be vector
+class ReplicateBNode : public VectorNode {
public:
- Store8BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
- : VectorStoreNode(c,mem,adr,at,val) {}
- virtual int Opcode() const;
- virtual uint length() const { return 8; }
-};
-
-//------------------------------Store4BNode--------------------------------------
-// Vector store of 4 bytes (8bits signed) to memory
-class Store4BNode : public VectorStoreNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_BYTE; }
- public:
- Store4BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
- : VectorStoreNode(c,mem,adr,at,val) {}
+ ReplicateBNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
virtual int Opcode() const;
- virtual uint length() const { return 4; }
-};
-
-//------------------------------Store8CNode--------------------------------------
-// Vector store of 8 chars (16bits signed/unsigned) to memory
-class Store8CNode : public VectorStoreNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_CHAR; }
- public:
- Store8CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
- : VectorStoreNode(c,mem,adr,at,val) {}
- virtual int Opcode() const;
- virtual uint length() const { return 8; }
-};
-
-//------------------------------Store4CNode--------------------------------------
-// Vector store of 4 chars (16bits signed/unsigned) to memory
-class Store4CNode : public VectorStoreNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_CHAR; }
- public:
- Store4CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
- : VectorStoreNode(c,mem,adr,at,val) {}
- virtual int Opcode() const;
- virtual uint length() const { return 4; }
-};
-
-//------------------------------Store2CNode--------------------------------------
-// Vector store of 2 chars (16bits signed/unsigned) to memory
-class Store2CNode : public VectorStoreNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_CHAR; }
- public:
- Store2CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
- : VectorStoreNode(c,mem,adr,at,val) {}
- virtual int Opcode() const;
- virtual uint length() const { return 2; }
};
-//------------------------------Store4INode--------------------------------------
-// Vector store of 4 integers (32bits signed) to memory
-class Store4INode : public VectorStoreNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_INT; }
- public:
- Store4INode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
- : VectorStoreNode(c,mem,adr,at,val) {}
- virtual int Opcode() const;
- virtual uint length() const { return 4; }
-};
-
-//------------------------------Store2INode--------------------------------------
-// Vector store of 2 integers (32bits signed) to memory
-class Store2INode : public VectorStoreNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_INT; }
- public:
- Store2INode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
- : VectorStoreNode(c,mem,adr,at,val) {}
- virtual int Opcode() const;
- virtual uint length() const { return 2; }
-};
-
-//------------------------------Store2LNode--------------------------------------
-// Vector store of 2 longs (64bits signed) to memory
-class Store2LNode : public VectorStoreNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_LONG; }
+//------------------------------ReplicateSNode---------------------------------
+// Replicate short scalar to be vector
+class ReplicateSNode : public VectorNode {
public:
- Store2LNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
- : VectorStoreNode(c,mem,adr,at,val) {}
- virtual int Opcode() const;
- virtual uint length() const { return 2; }
-};
-
-//------------------------------Store4FNode--------------------------------------
-// Vector store of 4 floats (32bits) to memory
-class Store4FNode : public VectorStoreNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_FLOAT; }
- public:
- Store4FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
- : VectorStoreNode(c,mem,adr,at,val) {}
- virtual int Opcode() const;
- virtual uint length() const { return 4; }
-};
-
-//------------------------------Store2FNode--------------------------------------
-// Vector store of 2 floats (32bits) to memory
-class Store2FNode : public VectorStoreNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_FLOAT; }
- public:
- Store2FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
- : VectorStoreNode(c,mem,adr,at,val) {}
- virtual int Opcode() const;
- virtual uint length() const { return 2; }
-};
-
-//------------------------------Store2DNode--------------------------------------
-// Vector store of 2 doubles (64bits) to memory
-class Store2DNode : public VectorStoreNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_DOUBLE; }
- public:
- Store2DNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
- : VectorStoreNode(c,mem,adr,at,val) {}
- virtual int Opcode() const;
- virtual uint length() const { return 2; }
-};
-
-//=========================Promote_Scalar_to_Vector====================================
-
-//------------------------------Replicate16BNode---------------------------------------
-// Replicate byte scalar to be vector of 16 bytes
-class Replicate16BNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_BYTE; }
- public:
- Replicate16BNode(Node* in1) : VectorNode(in1, 16) {}
+ ReplicateSNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
virtual int Opcode() const;
};
-//------------------------------Replicate8BNode---------------------------------------
-// Replicate byte scalar to be vector of 8 bytes
-class Replicate8BNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_BYTE; }
+//------------------------------ReplicateINode---------------------------------
+// Replicate int scalar to be vector
+class ReplicateINode : public VectorNode {
public:
- Replicate8BNode(Node* in1) : VectorNode(in1, 8) {}
- virtual int Opcode() const;
-};
-
-//------------------------------Replicate4BNode---------------------------------------
-// Replicate byte scalar to be vector of 4 bytes
-class Replicate4BNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_BYTE; }
- public:
- Replicate4BNode(Node* in1) : VectorNode(in1, 4) {}
- virtual int Opcode() const;
-};
-
-//------------------------------Replicate8CNode---------------------------------------
-// Replicate char scalar to be vector of 8 chars
-class Replicate8CNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_CHAR; }
- public:
- Replicate8CNode(Node* in1) : VectorNode(in1, 8) {}
+ ReplicateINode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
virtual int Opcode() const;
};
-//------------------------------Replicate4CNode---------------------------------------
-// Replicate char scalar to be vector of 4 chars
-class Replicate4CNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_CHAR; }
- public:
- Replicate4CNode(Node* in1) : VectorNode(in1, 4) {}
- virtual int Opcode() const;
-};
-
-//------------------------------Replicate2CNode---------------------------------------
-// Replicate char scalar to be vector of 2 chars
-class Replicate2CNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_CHAR; }
+//------------------------------ReplicateLNode---------------------------------
+// Replicate long scalar to be vector
+class ReplicateLNode : public VectorNode {
public:
- Replicate2CNode(Node* in1) : VectorNode(in1, 2) {}
- virtual int Opcode() const;
-};
-
-//------------------------------Replicate8SNode---------------------------------------
-// Replicate short scalar to be vector of 8 shorts
-class Replicate8SNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_SHORT; }
- public:
- Replicate8SNode(Node* in1) : VectorNode(in1, 8) {}
- virtual int Opcode() const;
-};
-
-//------------------------------Replicate4SNode---------------------------------------
-// Replicate short scalar to be vector of 4 shorts
-class Replicate4SNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_SHORT; }
- public:
- Replicate4SNode(Node* in1) : VectorNode(in1, 4) {}
+ ReplicateLNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
virtual int Opcode() const;
};
-//------------------------------Replicate2SNode---------------------------------------
-// Replicate short scalar to be vector of 2 shorts
-class Replicate2SNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_SHORT; }
+//------------------------------ReplicateFNode---------------------------------
+// Replicate float scalar to be vector
+class ReplicateFNode : public VectorNode {
public:
- Replicate2SNode(Node* in1) : VectorNode(in1, 2) {}
- virtual int Opcode() const;
-};
-
-//------------------------------Replicate4INode---------------------------------------
-// Replicate int scalar to be vector of 4 ints
-class Replicate4INode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_INT; }
- public:
- Replicate4INode(Node* in1) : VectorNode(in1, 4) {}
- virtual int Opcode() const;
-};
-
-//------------------------------Replicate2INode---------------------------------------
-// Replicate int scalar to be vector of 2 ints
-class Replicate2INode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_INT; }
- public:
- Replicate2INode(Node* in1) : VectorNode(in1, 2) {}
+ ReplicateFNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
virtual int Opcode() const;
};
-//------------------------------Replicate2LNode---------------------------------------
-// Replicate long scalar to be vector of 2 longs
-class Replicate2LNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_LONG; }
+//------------------------------ReplicateDNode---------------------------------
+// Replicate double scalar to be vector
+class ReplicateDNode : public VectorNode {
public:
- Replicate2LNode(Node* in1) : VectorNode(in1, 2) {}
- virtual int Opcode() const;
-};
-
-//------------------------------Replicate4FNode---------------------------------------
-// Replicate float scalar to be vector of 4 floats
-class Replicate4FNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_FLOAT; }
- public:
- Replicate4FNode(Node* in1) : VectorNode(in1, 4) {}
+ ReplicateDNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
virtual int Opcode() const;
};
-//------------------------------Replicate2FNode---------------------------------------
-// Replicate float scalar to be vector of 2 floats
-class Replicate2FNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_FLOAT; }
- public:
- Replicate2FNode(Node* in1) : VectorNode(in1, 2) {}
- virtual int Opcode() const;
-};
-
-//------------------------------Replicate2DNode---------------------------------------
-// Replicate double scalar to be vector of 2 doubles
-class Replicate2DNode : public VectorNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_DOUBLE; }
- public:
- Replicate2DNode(Node* in1) : VectorNode(in1, 2) {}
- virtual int Opcode() const;
-};
-
-//========================Pack_Scalars_into_a_Vector==============================
+//========================Pack_Scalars_into_a_Vector===========================
//------------------------------PackNode---------------------------------------
// Pack parent class (not for code generation).
class PackNode : public VectorNode {
public:
- PackNode(Node* in1) : VectorNode(in1, 1) {}
- PackNode(Node* in1, Node* n2) : VectorNode(in1, n2, 2) {}
+ PackNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
+ PackNode(Node* in1, Node* n2, const TypeVect* vt) : VectorNode(in1, n2, vt) {}
virtual int Opcode() const;
- void add_opd(Node* n) {
- add_req(n);
- _length++;
- assert(_length == req() - 1, "vector length matches edge count");
+ void add_opd(uint i, Node* n) {
+ init_req(i+1, n);
}
// Create a binary tree form for Packs. [lo, hi) (half-open) range
Node* binaryTreePack(Compile* C, int lo, int hi);
- static PackNode* make(Compile* C, Node* s, const Type* elt_t);
+ static PackNode* make(Compile* C, Node* s, uint vlen, BasicType bt);
};
//------------------------------PackBNode---------------------------------------
// Pack byte scalars into vector
class PackBNode : public PackNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_BYTE; }
public:
- PackBNode(Node* in1) : PackNode(in1) {}
- virtual int Opcode() const;
-};
-
-//------------------------------PackCNode---------------------------------------
-// Pack char scalars into vector
-class PackCNode : public PackNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_CHAR; }
- public:
- PackCNode(Node* in1) : PackNode(in1) {}
+ PackBNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
virtual int Opcode() const;
};
//------------------------------PackSNode---------------------------------------
// Pack short scalars into a vector
class PackSNode : public PackNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_SHORT; }
public:
- PackSNode(Node* in1) : PackNode(in1) {}
+ PackSNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
+ PackSNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
virtual int Opcode() const;
};
//------------------------------PackINode---------------------------------------
// Pack integer scalars into a vector
class PackINode : public PackNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_INT; }
public:
- PackINode(Node* in1) : PackNode(in1) {}
- PackINode(Node* in1, Node* in2) : PackNode(in1, in2) {}
+ PackINode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
+ PackINode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
virtual int Opcode() const;
};
//------------------------------PackLNode---------------------------------------
// Pack long scalars into a vector
class PackLNode : public PackNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_LONG; }
public:
- PackLNode(Node* in1) : PackNode(in1) {}
- PackLNode(Node* in1, Node* in2) : PackNode(in1, in2) {}
+ PackLNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
+ PackLNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
+ virtual int Opcode() const;
+};
+
+//------------------------------Pack2LNode--------------------------------------
+// Pack 2 long scalars into a vector
+class Pack2LNode : public PackNode {
+ public:
+ Pack2LNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
virtual int Opcode() const;
};
//------------------------------PackFNode---------------------------------------
// Pack float scalars into vector
class PackFNode : public PackNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_FLOAT; }
public:
- PackFNode(Node* in1) : PackNode(in1) {}
- PackFNode(Node* in1, Node* in2) : PackNode(in1, in2) {}
+ PackFNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
+ PackFNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
virtual int Opcode() const;
};
//------------------------------PackDNode---------------------------------------
// Pack double scalars into a vector
class PackDNode : public PackNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_DOUBLE; }
public:
- PackDNode(Node* in1) : PackNode(in1) {}
- PackDNode(Node* in1, Node* in2) : PackNode(in1, in2) {}
+ PackDNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
+ PackDNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
virtual int Opcode() const;
};
-// The Pack2xN nodes assist code generation. They are created from
-// Pack4C, etc. nodes in final_graph_reshape in the form of a
-// balanced, binary tree.
-
-//------------------------------Pack2x1BNode-----------------------------------------
-// Pack 2 1-byte integers into vector of 2 bytes
-class Pack2x1BNode : public PackNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_BYTE; }
+//------------------------------Pack2DNode--------------------------------------
+// Pack 2 double scalars into a vector
+class Pack2DNode : public PackNode {
public:
- Pack2x1BNode(Node *in1, Node* in2) : PackNode(in1, in2) {}
+ Pack2DNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
virtual int Opcode() const;
- virtual uint ideal_reg() const { return Op_RegI; }
};
-//------------------------------Pack2x2BNode---------------------------------------
-// Pack 2 2-byte integers into vector of 4 bytes
-class Pack2x2BNode : public PackNode {
- protected:
- virtual BasicType elt_basic_type() const { return T_CHAR; }
- public:
- Pack2x2BNode(Node *in1, Node* in2) : PackNode(in1, in2) {}
- virtual int Opcode() const;
- virtual uint ideal_reg() const { return Op_RegI; }
-};
//========================Extract_Scalar_from_Vector===============================
@@ -1069,7 +465,7 @@
virtual int Opcode() const;
uint pos() const { return in(2)->get_int(); }
- static Node* make(Compile* C, Node* v, uint position, const Type* opd_t);
+ static Node* make(Compile* C, Node* v, uint position, BasicType bt);
};
//------------------------------ExtractBNode---------------------------------------
@@ -1082,6 +478,16 @@
virtual uint ideal_reg() const { return Op_RegI; }
};
+//------------------------------ExtractUBNode--------------------------------------
+// Extract a boolean from a vector at position "pos"
+class ExtractUBNode : public ExtractNode {
+ public:
+ ExtractUBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
+ virtual int Opcode() const;
+ virtual const Type *bottom_type() const { return TypeInt::INT; }
+ virtual uint ideal_reg() const { return Op_RegI; }
+};
+
//------------------------------ExtractCNode---------------------------------------
// Extract a char from a vector at position "pos"
class ExtractCNode : public ExtractNode {