truffle: src/share/vm/opto/type.cpp comparison

comparison src/share/vm/opto/type.cpp @ 628:7bb995fbd3c0

Merge

author	trims
date	Thu, 12 Mar 2009 18:16:36 -0700
parents	0fbdb4381b99 337400e7a5dd
children	915cc9c5ebc6

comparison

equal deleted inserted replaced

-:ce2272390558
+:7bb995fbd3c0
 TypeInt::CC_GT   = TypeInt::make( 1, 1, WidenMin);  // == TypeInt::ONE
 TypeInt::CC_EQ   = TypeInt::make( 0, 0, WidenMin);  // == TypeInt::ZERO
 TypeInt::CC_LE   = TypeInt::make(-1, 0, WidenMin);
 TypeInt::CC_GE   = TypeInt::make( 0, 1, WidenMin);  // == TypeInt::BOOL
 TypeInt::BYTE    = TypeInt::make(-128,127,     WidenMin); // Bytes
+TypeInt::UBYTE   = TypeInt::make(0, 255,       WidenMin); // Unsigned Bytes
 TypeInt::CHAR    = TypeInt::make(0,65535,      WidenMin); // Java chars
 TypeInt::SHORT   = TypeInt::make(-32768,32767, WidenMin); // Java shorts
 TypeInt::POS     = TypeInt::make(0,max_jint,   WidenMin); // Non-neg values
 TypeInt::POS1    = TypeInt::make(1,max_jint,   WidenMin); // Positive values
 TypeInt::INT     = TypeInt::make(min_jint,max_jint, WidenMax); // 32-bit integers
 const TypeInt *TypeInt::CC_GT;  // [1]   == ONE
 const TypeInt *TypeInt::CC_EQ;  // [0]   == ZERO
 const TypeInt *TypeInt::CC_LE;  // [-1,0]
 const TypeInt *TypeInt::CC_GE;  // [0,1] == BOOL (!)
 const TypeInt *TypeInt::BYTE;   // Bytes, -128 to 127
+const TypeInt *TypeInt::UBYTE;  // Unsigned Bytes, 0 to 255
 const TypeInt *TypeInt::CHAR;   // Java chars, 0-65535
 const TypeInt *TypeInt::SHORT;  // Java shorts, -32768-32767
 const TypeInt *TypeInt::POS;    // Positive 32-bit integers or zero
 const TypeInt *TypeInt::POS1;   // Positive 32-bit integers
 const TypeInt *TypeInt::INT;    // 32-bit integers
 // directly manipulates the addresses of oops.  Rather, it only has a pointer
 // to a handle at compile time.  This handle is embedded in the generated
 // code and dereferenced at the time the nmethod is made.  Until that time,
 // it is not reasonable to do arithmetic with the addresses of oops (we don't
 // have access to the addresses!).  This does not seem to currently happen,
-// but this assertion here is to help prevent its occurrance.
+// but this assertion here is to help prevent its occurence.
 tty->print_cr("Found oop constant with non-zero offset");
 ShouldNotReachHere();
 }
 return (intptr_t)const_oop()->encoding();
 case NotNull:
 case BotPTR:                // Fall down to object klass
 // LCA is object_klass, but if we subclass from the top we can do better
 if( above_centerline(_ptr) ) { // if( _ptr == TopPTR || _ptr == AnyNull )
 // If 'this' (InstPtr) is above the centerline and it is Object class
-// then we can subclass in the Java class heirarchy.
+// then we can subclass in the Java class hierarchy.
 if (klass()->equals(ciEnv::current()->Object_klass())) {
 // that is, tp's array type is a subtype of my klass
 return TypeAryPtr::make(ptr, tp->ary(), tp->klass(), tp->klass_is_exact(), offset, instance_id);
 }
 }
 }
 //------------------------------xdual------------------------------------------
 // Dual: do NOT dual on klasses.  This means I do NOT understand the Java
-// inheritence mechanism.
+// inheritance mechanism.
 const Type *TypeInstPtr::xdual() const {
 return new TypeInstPtr( dual_ptr(), klass(), klass_is_exact(), const_oop(), dual_offset(), dual_instance_id()  );
 }
 //------------------------------eq---------------------------------------------
 jint max_hi = max_array_length(elem()->basic_type());
 //if (index_not_size)  --max_hi;     // type of a valid array index, FTR
 bool chg = false;
 if (lo < min_lo) { lo = min_lo; chg = true; }
 if (hi > max_hi) { hi = max_hi; chg = true; }
-// Negative length arrays will produce weird intermediate dead fath-path code
+// Negative length arrays will produce weird intermediate dead fast-path code
 if (lo > hi)
 return TypeInt::ZERO;
 if (!chg)
 return size;
 return TypeInt::make(lo, hi, Type::WidenMin);
 case NotNull:
 case BotPTR:                // Fall down to object klass
 // LCA is object_klass, but if we subclass from the top we can do better
 if (above_centerline(tp->ptr())) {
 // If 'tp'  is above the centerline and it is Object class
-// then we can subclass in the Java class heirarchy.
+// then we can subclass in the Java class hierarchy.
 if( tp->klass()->equals(ciEnv::current()->Object_klass()) ) {
 // that is, my array type is a subtype of 'tp' klass
 return make( ptr, _ary, _klass, _klass_is_exact, offset, instance_id );
 }
 }

Mercurial > hg > truffle

comparison src/share/vm/opto/type.cpp @ 628:7bb995fbd3c0