73 AddVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 74 virtual int Opcode() const; 75 }; 76 77 //------------------------------AddVSNode-------------------------------------- 78 // Vector add char/short 79 class AddVSNode : public VectorNode { 80 public: 81 AddVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 82 virtual int Opcode() const; 83 }; 84 85 //------------------------------AddVINode-------------------------------------- 86 // Vector add int 87 class AddVINode : public VectorNode { 88 public: 89 AddVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 90 virtual int Opcode() const; 91 }; 92 93 //------------------------------ReductionNode------------------------------------ 94 // Perform reduction of a vector 95 class ReductionNode : public Node { 96 public: 97 ReductionNode(Node *ctrl, Node* in1, Node* in2) : Node(ctrl, in1, in2) {} 98 99 static ReductionNode* make(int opc, Node *ctrl, Node* in1, Node* in2, BasicType bt); 100 static int opcode(int opc, BasicType bt); 101 static bool implemented(int opc, uint vlen, BasicType bt); 102 }; 103 104 //------------------------------AddReductionVINode-------------------------------------- 105 // Vector add int as a reduction 106 class AddReductionVINode : public ReductionNode { 107 public: 108 AddReductionVINode(Node * ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 109 virtual int Opcode() const; 110 virtual const Type* bottom_type() const { return TypeInt::INT; } 111 virtual uint ideal_reg() const { return Op_RegI; } 112 }; 113 114 //------------------------------AddReductionVLNode-------------------------------------- 115 // Vector add long as a reduction 116 class AddReductionVLNode : public ReductionNode { 117 public: 118 AddReductionVLNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 119 virtual int Opcode() const; 120 virtual const Type* bottom_type() const { return TypeLong::LONG; } 121 virtual uint ideal_reg() const { return Op_RegL; } 122 }; 123 124 //------------------------------AddVLNode-------------------------------------- 125 // Vector add long 126 class AddVLNode : public VectorNode { 127 public: 128 AddVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 129 virtual int Opcode() const; 130 }; 131 132 //------------------------------AddVFNode-------------------------------------- 133 // Vector add float 134 class AddVFNode : public VectorNode { 135 public: 136 AddVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 137 virtual int Opcode() const; 138 }; 139 140 //------------------------------AddReductionVFNode-------------------------------------- 141 // Vector add float as a reduction 142 class AddReductionVFNode : public ReductionNode { 143 public: 144 AddReductionVFNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 145 virtual int Opcode() const; 146 virtual const Type* bottom_type() const { return Type::FLOAT; } 147 virtual uint ideal_reg() const { return Op_RegF; } 148 }; 149 150 //------------------------------AddVDNode-------------------------------------- 151 // Vector add double 152 class AddVDNode : public VectorNode { 153 public: 154 AddVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 155 virtual int Opcode() const; 156 }; 157 158 //------------------------------AddReductionVDNode-------------------------------------- 159 // Vector add double as a reduction 160 class AddReductionVDNode : public ReductionNode { 161 public: 162 AddReductionVDNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 163 virtual int Opcode() const; 164 virtual const Type* bottom_type() const { return Type::DOUBLE; } 165 virtual uint ideal_reg() const { return Op_RegD; } 166 }; 167 168 //------------------------------SubVBNode-------------------------------------- 169 // Vector subtract byte 170 class SubVBNode : public VectorNode { 171 public: 172 SubVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 173 virtual int Opcode() const; 174 }; 175 176 //------------------------------SubVSNode-------------------------------------- 177 // Vector subtract short 212 SubVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 213 virtual int Opcode() const; 214 }; 215 216 //------------------------------MulVSNode-------------------------------------- 217 // Vector multiply short 218 class MulVSNode : public VectorNode { 219 public: 220 MulVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 221 virtual int Opcode() const; 222 }; 223 224 //------------------------------MulVINode-------------------------------------- 225 // Vector multiply int 226 class MulVINode : public VectorNode { 227 public: 228 MulVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 229 virtual int Opcode() const; 230 }; 231 232 //------------------------------MulReductionVINode-------------------------------------- 233 // Vector multiply int as a reduction 234 class MulReductionVINode : public ReductionNode { 235 public: 236 MulReductionVINode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 237 virtual int Opcode() const; 238 virtual const Type* bottom_type() const { return TypeInt::INT; } 239 virtual uint ideal_reg() const { return Op_RegI; } 240 }; 241 242 //------------------------------MulVFNode-------------------------------------- 243 // Vector multiply float 244 class MulVFNode : public VectorNode { 245 public: 246 MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 247 virtual int Opcode() const; 248 }; 249 250 //------------------------------MulReductionVFNode-------------------------------------- 251 // Vector multiply float as a reduction 252 class MulReductionVFNode : public ReductionNode { 253 public: 254 MulReductionVFNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 255 virtual int Opcode() const; 256 virtual const Type* bottom_type() const { return Type::FLOAT; } 257 virtual uint ideal_reg() const { return Op_RegF; } 258 }; 259 260 //------------------------------MulVDNode-------------------------------------- 261 // Vector multiply double 262 class MulVDNode : public VectorNode { 263 public: 264 MulVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 265 virtual int Opcode() const; 266 }; 267 268 //------------------------------MulReductionVDNode-------------------------------------- 269 // Vector multiply double as a reduction 270 class MulReductionVDNode : public ReductionNode { 271 public: 272 MulReductionVDNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 273 virtual int Opcode() const; 274 virtual const Type* bottom_type() const { return Type::DOUBLE; } 275 virtual uint ideal_reg() const { return Op_RegD; } 276 }; 277 278 //------------------------------DivVFNode-------------------------------------- 279 // Vector divide float 280 class DivVFNode : public VectorNode { 281 public: 282 DivVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 283 virtual int Opcode() const; 284 }; 285 | 73 AddVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 74 virtual int Opcode() const; 75 }; 76 77 //------------------------------AddVSNode-------------------------------------- 78 // Vector add char/short 79 class AddVSNode : public VectorNode { 80 public: 81 AddVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 82 virtual int Opcode() const; 83 }; 84 85 //------------------------------AddVINode-------------------------------------- 86 // Vector add int 87 class AddVINode : public VectorNode { 88 public: 89 AddVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 90 virtual int Opcode() const; 91 }; 92 93 //------------------------------AddVLNode-------------------------------------- 94 // Vector add long 95 class AddVLNode : public VectorNode { 96 public: 97 AddVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {} 98 virtual int Opcode() const; 99 }; 100 101 //------------------------------AddVFNode-------------------------------------- 102 // Vector add float 103 class AddVFNode : public VectorNode { 104 public: 105 AddVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {} 106 virtual int Opcode() const; 107 }; 108 109 //------------------------------AddVDNode-------------------------------------- 110 // Vector add double 111 class AddVDNode : public VectorNode { 112 public: 113 AddVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {} 114 virtual int Opcode() const; 115 }; 116 117 //------------------------------ReductionNode------------------------------------ 118 // Perform reduction of a vector 119 class ReductionNode : public Node { 120 public: 121 ReductionNode(Node *ctrl, Node* in1, Node* in2) : Node(ctrl, in1, in2) {} 122 123 static ReductionNode* make(int opc, Node *ctrl, Node* in1, Node* in2, BasicType bt); 124 static int opcode(int opc, BasicType bt); 125 static bool implemented(int opc, uint vlen, BasicType bt); 126 }; 127 128 //------------------------------AddReductionVINode-------------------------------------- 129 // Vector add int as a reduction 130 class AddReductionVINode : public ReductionNode { 131 public: 132 AddReductionVINode(Node * ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 133 virtual int Opcode() const; 134 virtual const Type* bottom_type() const { return TypeInt::INT; } 135 virtual uint ideal_reg() const { return Op_RegI; } 136 }; 137 138 //------------------------------AddReductionVLNode-------------------------------------- 139 // Vector add long as a reduction 140 class AddReductionVLNode : public ReductionNode { 141 public: 142 AddReductionVLNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 143 virtual int Opcode() const; 144 virtual const Type* bottom_type() const { return TypeLong::LONG; } 145 virtual uint ideal_reg() const { return Op_RegL; } 146 }; 147 148 //------------------------------AddReductionVFNode-------------------------------------- 149 // Vector add float as a reduction 150 class AddReductionVFNode : public ReductionNode { 151 public: 152 AddReductionVFNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 153 virtual int Opcode() const; 154 virtual const Type* bottom_type() const { return Type::FLOAT; } 155 virtual uint ideal_reg() const { return Op_RegF; } 156 }; 157 158 //------------------------------AddReductionVDNode-------------------------------------- 159 // Vector add double as a reduction 160 class AddReductionVDNode : public ReductionNode { 161 public: 162 AddReductionVDNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 163 virtual int Opcode() const; 164 virtual const Type* bottom_type() const { return Type::DOUBLE; } 165 virtual uint ideal_reg() const { return Op_RegD; } 166 }; 167 168 //------------------------------SubVBNode-------------------------------------- 169 // Vector subtract byte 170 class SubVBNode : public VectorNode { 171 public: 172 SubVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 173 virtual int Opcode() const; 174 }; 175 176 //------------------------------SubVSNode-------------------------------------- 177 // Vector subtract short 212 SubVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 213 virtual int Opcode() const; 214 }; 215 216 //------------------------------MulVSNode-------------------------------------- 217 // Vector multiply short 218 class MulVSNode : public VectorNode { 219 public: 220 MulVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 221 virtual int Opcode() const; 222 }; 223 224 //------------------------------MulVINode-------------------------------------- 225 // Vector multiply int 226 class MulVINode : public VectorNode { 227 public: 228 MulVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 229 virtual int Opcode() const; 230 }; 231 232 //------------------------------MulVLNode-------------------------------------- 233 // Vector multiply long 234 class MulVLNode : public VectorNode { 235 public: 236 MulVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {} 237 virtual int Opcode() const; 238 }; 239 240 //------------------------------MulVFNode-------------------------------------- 241 // Vector multiply float 242 class MulVFNode : public VectorNode { 243 public: 244 MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {} 245 virtual int Opcode() const; 246 }; 247 248 //------------------------------MulVDNode-------------------------------------- 249 // Vector multiply double 250 class MulVDNode : public VectorNode { 251 public: 252 MulVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {} 253 virtual int Opcode() const; 254 }; 255 256 //------------------------------MulReductionVINode-------------------------------------- 257 // Vector multiply int as a reduction 258 class MulReductionVINode : public ReductionNode { 259 public: 260 MulReductionVINode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 261 virtual int Opcode() const; 262 virtual const Type* bottom_type() const { return TypeInt::INT; } 263 virtual uint ideal_reg() const { return Op_RegI; } 264 }; 265 266 //------------------------------MulReductionVLNode-------------------------------------- 267 // Vector multiply int as a reduction 268 class MulReductionVLNode : public ReductionNode { 269 public: 270 MulReductionVLNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 271 virtual int Opcode() const; 272 virtual const Type* bottom_type() const { return TypeLong::LONG; } 273 virtual uint ideal_reg() const { return Op_RegI; } 274 }; 275 276 //------------------------------MulReductionVFNode-------------------------------------- 277 // Vector multiply float as a reduction 278 class MulReductionVFNode : public ReductionNode { 279 public: 280 MulReductionVFNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 281 virtual int Opcode() const; 282 virtual const Type* bottom_type() const { return Type::FLOAT; } 283 virtual uint ideal_reg() const { return Op_RegF; } 284 }; 285 286 //------------------------------MulReductionVDNode-------------------------------------- 287 // Vector multiply double as a reduction 288 class MulReductionVDNode : public ReductionNode { 289 public: 290 MulReductionVDNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 291 virtual int Opcode() const; 292 virtual const Type* bottom_type() const { return Type::DOUBLE; } 293 virtual uint ideal_reg() const { return Op_RegD; } 294 }; 295 296 //------------------------------DivVFNode-------------------------------------- 297 // Vector divide float 298 class DivVFNode : public VectorNode { 299 public: 300 DivVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 301 virtual int Opcode() const; 302 }; 303 |