360 const Type *bottom_type() const { return TypeInt::INT; }
361 virtual uint ideal_reg() const { return Op_RegI; }
362 };
363
364
365 //------------------------------NegNode----------------------------------------
366 class NegNode : public Node {
367 public:
368 NegNode( Node *in1 ) : Node(0,in1) {}
369 };
370
371 //------------------------------NegFNode---------------------------------------
372 // Negate value a float. Negating 0.0 returns -0.0, but subtracting from
373 // zero returns +0.0 (per JVM spec on 'fneg' bytecode). As subtraction
374 // cannot be used to replace negation we have to implement negation as ideal
375 // node; note that negation and addition can replace subtraction.
376 class NegFNode : public NegNode {
377 public:
378 NegFNode( Node *in1 ) : NegNode(in1) {}
379 virtual int Opcode() const;
380 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
381 const Type *bottom_type() const { return Type::FLOAT; }
382 virtual uint ideal_reg() const { return Op_RegF; }
383 };
384
385 //------------------------------NegDNode---------------------------------------
386 // Negate value a double. Negating 0.0 returns -0.0, but subtracting from
387 // zero returns +0.0 (per JVM spec on 'dneg' bytecode). As subtraction
388 // cannot be used to replace negation we have to implement negation as ideal
389 // node; note that negation and addition can replace subtraction.
390 class NegDNode : public NegNode {
391 public:
392 NegDNode( Node *in1 ) : NegNode(in1) {}
393 virtual int Opcode() const;
394 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
395 const Type *bottom_type() const { return Type::DOUBLE; }
396 virtual uint ideal_reg() const { return Op_RegD; }
397 };
398
399 //------------------------------CosDNode---------------------------------------
400 // Cosinus of a double
401 class CosDNode : public Node {
402 public:
403 CosDNode( Node *in1 ) : Node(0, in1) {}
404 virtual int Opcode() const;
405 const Type *bottom_type() const { return Type::DOUBLE; }
406 virtual uint ideal_reg() const { return Op_RegD; }
407 virtual const Type *Value( PhaseTransform *phase ) const;
408 };
409
410 //------------------------------CosDNode---------------------------------------
411 // Sinus of a double
412 class SinDNode : public Node {
413 public:
414 SinDNode( Node *in1 ) : Node(0, in1) {}
|
360 const Type *bottom_type() const { return TypeInt::INT; }
361 virtual uint ideal_reg() const { return Op_RegI; }
362 };
363
364
365 //------------------------------NegNode----------------------------------------
366 class NegNode : public Node {
367 public:
368 NegNode( Node *in1 ) : Node(0,in1) {}
369 };
370
371 //------------------------------NegFNode---------------------------------------
372 // Negate value a float. Negating 0.0 returns -0.0, but subtracting from
373 // zero returns +0.0 (per JVM spec on 'fneg' bytecode). As subtraction
374 // cannot be used to replace negation we have to implement negation as ideal
375 // node; note that negation and addition can replace subtraction.
376 class NegFNode : public NegNode {
377 public:
378 NegFNode( Node *in1 ) : NegNode(in1) {}
379 virtual int Opcode() const;
380 const Type *bottom_type() const { return Type::FLOAT; }
381 virtual uint ideal_reg() const { return Op_RegF; }
382 };
383
384 //------------------------------NegDNode---------------------------------------
385 // Negate value a double. Negating 0.0 returns -0.0, but subtracting from
386 // zero returns +0.0 (per JVM spec on 'dneg' bytecode). As subtraction
387 // cannot be used to replace negation we have to implement negation as ideal
388 // node; note that negation and addition can replace subtraction.
389 class NegDNode : public NegNode {
390 public:
391 NegDNode( Node *in1 ) : NegNode(in1) {}
392 virtual int Opcode() const;
393 const Type *bottom_type() const { return Type::DOUBLE; }
394 virtual uint ideal_reg() const { return Op_RegD; }
395 };
396
397 //------------------------------CosDNode---------------------------------------
398 // Cosinus of a double
399 class CosDNode : public Node {
400 public:
401 CosDNode( Node *in1 ) : Node(0, in1) {}
402 virtual int Opcode() const;
403 const Type *bottom_type() const { return Type::DOUBLE; }
404 virtual uint ideal_reg() const { return Op_RegD; }
405 virtual const Type *Value( PhaseTransform *phase ) const;
406 };
407
408 //------------------------------CosDNode---------------------------------------
409 // Sinus of a double
410 class SinDNode : public Node {
411 public:
412 SinDNode( Node *in1 ) : Node(0, in1) {}
|