Mercurial > hg > graal-compiler

comparison src/share/vm/opto/connode.hpp @ 6948:e522a00b91aa

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works
author Doug Simon <doug.simon@oracle.com>
date Mon, 12 Nov 2012 23:14:12 +0100
parents d804e148cff8
children 5ec7dace41a6
comparison
equal deleted inserted replaced
6711:ae13cc658b80 6948:e522a00b91aa
1 /* 1 /*
2 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. 2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 * 4 *
5 * This code is free software; you can redistribute it and/or modify it 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 6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. 7 * published by the Free Software Foundation.
56 ConINode( const TypeInt *t ) : ConNode(t) {} 56 ConINode( const TypeInt *t ) : ConNode(t) {}
57 virtual int Opcode() const; 57 virtual int Opcode() const;
58 58
59 // Factory method: 59 // Factory method:
60 static ConINode* make( Compile* C, int con ) { 60 static ConINode* make( Compile* C, int con ) {
61 return new (C, 1) ConINode( TypeInt::make(con) ); 61 return new (C) ConINode( TypeInt::make(con) );
62 } 62 }
63 63
64 }; 64 };
65 65
66 //------------------------------ConPNode--------------------------------------- 66 //------------------------------ConPNode---------------------------------------
71 virtual int Opcode() const; 71 virtual int Opcode() const;
72 72
73 // Factory methods: 73 // Factory methods:
74 static ConPNode* make( Compile *C ,address con ) { 74 static ConPNode* make( Compile *C ,address con ) {
75 if (con == NULL) 75 if (con == NULL)
76 return new (C, 1) ConPNode( TypePtr::NULL_PTR ) ; 76 return new (C) ConPNode( TypePtr::NULL_PTR ) ;
77 else 77 else
78 return new (C, 1) ConPNode( TypeRawPtr::make(con) ); 78 return new (C) ConPNode( TypeRawPtr::make(con) );
79 } 79 }
80 }; 80 };
81 81
82 82
83 //------------------------------ConNNode-------------------------------------- 83 //------------------------------ConNNode--------------------------------------
86 public: 86 public:
87 ConNNode( const TypeNarrowOop *t ) : ConNode(t) {} 87 ConNNode( const TypeNarrowOop *t ) : ConNode(t) {}
88 virtual int Opcode() const; 88 virtual int Opcode() const;
89 }; 89 };
90 90
91 //------------------------------ConNKlassNode---------------------------------
92 // Simple narrow klass constants
93 class ConNKlassNode : public ConNode {
94 public:
95 ConNKlassNode( const TypeNarrowKlass *t ) : ConNode(t) {}
96 virtual int Opcode() const;
97 };
98
91 99
92 //------------------------------ConLNode--------------------------------------- 100 //------------------------------ConLNode---------------------------------------
93 // Simple long constants 101 // Simple long constants
94 class ConLNode : public ConNode { 102 class ConLNode : public ConNode {
95 public: 103 public:
96 ConLNode( const TypeLong *t ) : ConNode(t) {} 104 ConLNode( const TypeLong *t ) : ConNode(t) {}
97 virtual int Opcode() const; 105 virtual int Opcode() const;
98 106
99 // Factory method: 107 // Factory method:
100 static ConLNode* make( Compile *C ,jlong con ) { 108 static ConLNode* make( Compile *C ,jlong con ) {
101 return new (C, 1) ConLNode( TypeLong::make(con) ); 109 return new (C) ConLNode( TypeLong::make(con) );
102 } 110 }
103 111
104 }; 112 };
105 113
106 //------------------------------ConFNode--------------------------------------- 114 //------------------------------ConFNode---------------------------------------
110 ConFNode( const TypeF *t ) : ConNode(t) {} 118 ConFNode( const TypeF *t ) : ConNode(t) {}
111 virtual int Opcode() const; 119 virtual int Opcode() const;
112 120
113 // Factory method: 121 // Factory method:
114 static ConFNode* make( Compile *C, float con ) { 122 static ConFNode* make( Compile *C, float con ) {
115 return new (C, 1) ConFNode( TypeF::make(con) ); 123 return new (C) ConFNode( TypeF::make(con) );
116 } 124 }
117 125
118 }; 126 };
119 127
120 //------------------------------ConDNode--------------------------------------- 128 //------------------------------ConDNode---------------------------------------
124 ConDNode( const TypeD *t ) : ConNode(t) {} 132 ConDNode( const TypeD *t ) : ConNode(t) {}
125 virtual int Opcode() const; 133 virtual int Opcode() const;
126 134
127 // Factory method: 135 // Factory method:
128 static ConDNode* make( Compile *C, double con ) { 136 static ConDNode* make( Compile *C, double con ) {
129 return new (C, 1) ConDNode( TypeD::make(con) ); 137 return new (C) ConDNode( TypeD::make(con) );
130 } 138 }
131 139
132 }; 140 };
133 141
134 //------------------------------BinaryNode------------------------------------- 142 //------------------------------BinaryNode-------------------------------------
268 // the proper address type - which is required to compute anti-deps. 276 // the proper address type - which is required to compute anti-deps.
269 //virtual Node *Ideal_DU_postCCP( PhaseCCP * ); 277 //virtual Node *Ideal_DU_postCCP( PhaseCCP * );
270 }; 278 };
271 279
272 280
281 //------------------------------EncodeNarrowPtr--------------------------------
282 class EncodeNarrowPtrNode : public TypeNode {
283 protected:
284 EncodeNarrowPtrNode(Node* value, const Type* type):
285 TypeNode(type, 2) {
286 init_class_id(Class_EncodeNarrowPtr);
287 init_req(0, NULL);
288 init_req(1, value);
289 }
290 public:
291 virtual uint ideal_reg() const { return Op_RegN; }
292 virtual Node *Ideal_DU_postCCP( PhaseCCP *ccp );
293 };
294
273 //------------------------------EncodeP-------------------------------- 295 //------------------------------EncodeP--------------------------------
274 // Encodes an oop pointers into its compressed form 296 // Encodes an oop pointers into its compressed form
275 // Takes an extra argument which is the real heap base as a long which 297 // Takes an extra argument which is the real heap base as a long which
276 // may be useful for code generation in the backend. 298 // may be useful for code generation in the backend.
277 class EncodePNode : public TypeNode { 299 class EncodePNode : public EncodeNarrowPtrNode {
278 public: 300 public:
279 EncodePNode(Node* value, const Type* type): 301 EncodePNode(Node* value, const Type* type):
302 EncodeNarrowPtrNode(value, type) {
303 init_class_id(Class_EncodeP);
304 }
305 virtual int Opcode() const;
306 virtual Node *Identity( PhaseTransform *phase );
307 virtual const Type *Value( PhaseTransform *phase ) const;
308 };
309
310 //------------------------------EncodePKlass--------------------------------
311 // Encodes a klass pointer into its compressed form
312 // Takes an extra argument which is the real heap base as a long which
313 // may be useful for code generation in the backend.
314 class EncodePKlassNode : public EncodeNarrowPtrNode {
315 public:
316 EncodePKlassNode(Node* value, const Type* type):
317 EncodeNarrowPtrNode(value, type) {
318 init_class_id(Class_EncodePKlass);
319 }
320 virtual int Opcode() const;
321 virtual Node *Identity( PhaseTransform *phase );
322 virtual const Type *Value( PhaseTransform *phase ) const;
323 };
324
325 //------------------------------DecodeNarrowPtr--------------------------------
326 class DecodeNarrowPtrNode : public TypeNode {
327 protected:
328 DecodeNarrowPtrNode(Node* value, const Type* type):
280 TypeNode(type, 2) { 329 TypeNode(type, 2) {
281 init_class_id(Class_EncodeP); 330 init_class_id(Class_DecodeNarrowPtr);
282 init_req(0, NULL); 331 init_req(0, NULL);
283 init_req(1, value); 332 init_req(1, value);
284 } 333 }
285 virtual int Opcode() const; 334 public:
286 virtual Node *Identity( PhaseTransform *phase ); 335 virtual uint ideal_reg() const { return Op_RegP; }
287 virtual const Type *Value( PhaseTransform *phase ) const;
288 virtual uint ideal_reg() const { return Op_RegN; }
289
290 virtual Node *Ideal_DU_postCCP( PhaseCCP *ccp );
291 }; 336 };
292 337
293 //------------------------------DecodeN-------------------------------- 338 //------------------------------DecodeN--------------------------------
294 // Converts a narrow oop into a real oop ptr. 339 // Converts a narrow oop into a real oop ptr.
295 // Takes an extra argument which is the real heap base as a long which 340 // Takes an extra argument which is the real heap base as a long which
296 // may be useful for code generation in the backend. 341 // may be useful for code generation in the backend.
297 class DecodeNNode : public TypeNode { 342 class DecodeNNode : public DecodeNarrowPtrNode {
298 public: 343 public:
299 DecodeNNode(Node* value, const Type* type): 344 DecodeNNode(Node* value, const Type* type):
300 TypeNode(type, 2) { 345 DecodeNarrowPtrNode(value, type) {
301 init_class_id(Class_DecodeN); 346 init_class_id(Class_DecodeN);
302 init_req(0, NULL); 347 }
303 init_req(1, value); 348 virtual int Opcode() const;
304 } 349 virtual const Type *Value( PhaseTransform *phase ) const;
305 virtual int Opcode() const; 350 virtual Node *Identity( PhaseTransform *phase );
306 virtual Node *Identity( PhaseTransform *phase ); 351 };
307 virtual const Type *Value( PhaseTransform *phase ) const; 352
308 virtual uint ideal_reg() const { return Op_RegP; } 353 //------------------------------DecodeNKlass--------------------------------
354 // Converts a narrow klass pointer into a real klass ptr.
355 // Takes an extra argument which is the real heap base as a long which
356 // may be useful for code generation in the backend.
357 class DecodeNKlassNode : public DecodeNarrowPtrNode {
358 public:
359 DecodeNKlassNode(Node* value, const Type* type):
360 DecodeNarrowPtrNode(value, type) {
361 init_class_id(Class_DecodeNKlass);
362 }
363 virtual int Opcode() const;
364 virtual const Type *Value( PhaseTransform *phase ) const;
365 virtual Node *Identity( PhaseTransform *phase );
309 }; 366 };
310 367
311 //------------------------------Conv2BNode------------------------------------- 368 //------------------------------Conv2BNode-------------------------------------
312 // Convert int/pointer to a Boolean. Map zero to zero, all else to 1. 369 // Convert int/pointer to a Boolean. Map zero to zero, all else to 1.
313 class Conv2BNode : public Node { 370 class Conv2BNode : public Node {