1808 oop sun_reflect_ConstantPool::cp_oop(oop reflect) {
1809 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1810 return reflect->obj_field(_cp_oop_offset);
1811 }
1812
1813
1814 void sun_reflect_ConstantPool::set_cp_oop(oop reflect, oop value) {
1815 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1816 reflect->obj_field_put(_cp_oop_offset, value);
1817 }
1818
1819 void sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets() {
1820 klassOop k = SystemDictionary::reflect_unsafe_static_field_accessor_impl_klass();
1821 // This null test can be removed post beta
1822 if (k != NULL) {
1823 compute_offset(_base_offset, k,
1824 vmSymbols::base_name(), vmSymbols::object_signature());
1825 }
1826 }
1827
1828 oop java_lang_boxing_object::initialize_and_allocate(klassOop k, TRAPS) {
1829 instanceKlassHandle h (THREAD, k);
1830 if (!h->is_initialized()) h->initialize(CHECK_0);
1831 return h->allocate_instance(THREAD);
1832 }
1833
1834
1835 oop java_lang_boxing_object::create(BasicType type, jvalue* value, TRAPS) {
1836 oop box;
1837 switch (type) {
1838 case T_BOOLEAN:
1839 box = initialize_and_allocate(SystemDictionary::boolean_klass(), CHECK_0);
1840 box->bool_field_put(value_offset, value->z);
1841 break;
1842 case T_CHAR:
1843 box = initialize_and_allocate(SystemDictionary::char_klass(), CHECK_0);
1844 box->char_field_put(value_offset, value->c);
1845 break;
1846 case T_FLOAT:
1847 box = initialize_and_allocate(SystemDictionary::float_klass(), CHECK_0);
1848 box->float_field_put(value_offset, value->f);
1849 break;
1850 case T_DOUBLE:
1851 box = initialize_and_allocate(SystemDictionary::double_klass(), CHECK_0);
1852 box->double_field_put(value_offset, value->d);
1853 break;
1854 case T_BYTE:
1855 box = initialize_and_allocate(SystemDictionary::byte_klass(), CHECK_0);
1856 box->byte_field_put(value_offset, value->b);
1857 break;
1858 case T_SHORT:
1859 box = initialize_and_allocate(SystemDictionary::short_klass(), CHECK_0);
1860 box->short_field_put(value_offset, value->s);
1861 break;
1862 case T_INT:
1863 box = initialize_and_allocate(SystemDictionary::int_klass(), CHECK_0);
1864 box->int_field_put(value_offset, value->i);
1865 break;
1866 case T_LONG:
1867 box = initialize_and_allocate(SystemDictionary::long_klass(), CHECK_0);
1868 box->long_field_put(value_offset, value->j);
1869 break;
1870 default:
1871 return NULL;
1872 }
1873 return box;
1874 }
1875
1876
1877 BasicType java_lang_boxing_object::get_value(oop box, jvalue* value) {
1878 klassOop k = box->klass();
1879 if (k == SystemDictionary::boolean_klass()) {
1880 value->z = box->bool_field(value_offset);
1881 return T_BOOLEAN;
1882 }
1883 if (k == SystemDictionary::char_klass()) {
1884 value->c = box->char_field(value_offset);
1885 return T_CHAR;
1886 }
1887 if (k == SystemDictionary::float_klass()) {
1888 value->f = box->float_field(value_offset);
1889 return T_FLOAT;
1890 }
1891 if (k == SystemDictionary::double_klass()) {
1892 value->d = box->double_field(value_offset);
1893 return T_DOUBLE;
1894 }
1895 if (k == SystemDictionary::byte_klass()) {
1896 value->b = box->byte_field(value_offset);
1897 return T_BYTE;
1898 }
1899 if (k == SystemDictionary::short_klass()) {
1900 value->s = box->short_field(value_offset);
1901 return T_SHORT;
1902 }
1903 if (k == SystemDictionary::int_klass()) {
1904 value->i = box->int_field(value_offset);
1905 return T_INT;
1906 }
1907 if (k == SystemDictionary::long_klass()) {
1908 value->j = box->long_field(value_offset);
1909 return T_LONG;
1910 }
1911 return T_ILLEGAL;
1912 }
1913
1914
1915 BasicType java_lang_boxing_object::set_value(oop box, jvalue* value) {
1916 klassOop k = box->klass();
1917 if (k == SystemDictionary::boolean_klass()) {
1918 box->bool_field_put(value_offset, value->z);
1919 return T_BOOLEAN;
1920 }
1921 if (k == SystemDictionary::char_klass()) {
1922 box->char_field_put(value_offset, value->c);
1923 return T_CHAR;
1924 }
1925 if (k == SystemDictionary::float_klass()) {
1926 box->float_field_put(value_offset, value->f);
1927 return T_FLOAT;
1928 }
1929 if (k == SystemDictionary::double_klass()) {
1930 box->double_field_put(value_offset, value->d);
1931 return T_DOUBLE;
1932 }
1933 if (k == SystemDictionary::byte_klass()) {
1934 box->byte_field_put(value_offset, value->b);
1935 return T_BYTE;
1936 }
1937 if (k == SystemDictionary::short_klass()) {
1938 box->short_field_put(value_offset, value->s);
1939 return T_SHORT;
1940 }
1941 if (k == SystemDictionary::int_klass()) {
1942 box->int_field_put(value_offset, value->i);
1943 return T_INT;
1944 }
1945 if (k == SystemDictionary::long_klass()) {
1946 box->long_field_put(value_offset, value->j);
1947 return T_LONG;
1948 }
1949 return T_ILLEGAL;
1950 }
1951
1952
1953 // Support for java_lang_ref_Reference
1954
1955 void java_lang_ref_Reference::set_referent(oop ref, oop value) {
1956 ref->obj_field_put(referent_offset, value);
1957 }
1958
1959 oop* java_lang_ref_Reference::referent_addr(oop ref) {
1960 return ref->obj_field_addr(referent_offset);
1961 }
1962
1963 void java_lang_ref_Reference::set_next(oop ref, oop value) {
1964 ref->obj_field_put(next_offset, value);
1965 }
1966
1967 oop* java_lang_ref_Reference::next_addr(oop ref) {
1968 return ref->obj_field_addr(next_offset);
1969 }
|
1808 oop sun_reflect_ConstantPool::cp_oop(oop reflect) {
1809 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1810 return reflect->obj_field(_cp_oop_offset);
1811 }
1812
1813
1814 void sun_reflect_ConstantPool::set_cp_oop(oop reflect, oop value) {
1815 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1816 reflect->obj_field_put(_cp_oop_offset, value);
1817 }
1818
1819 void sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets() {
1820 klassOop k = SystemDictionary::reflect_unsafe_static_field_accessor_impl_klass();
1821 // This null test can be removed post beta
1822 if (k != NULL) {
1823 compute_offset(_base_offset, k,
1824 vmSymbols::base_name(), vmSymbols::object_signature());
1825 }
1826 }
1827
1828 oop java_lang_boxing_object::initialize_and_allocate(BasicType type, TRAPS) {
1829 klassOop k = SystemDictionary::box_klass(type);
1830 if (k == NULL) return NULL;
1831 instanceKlassHandle h (THREAD, k);
1832 if (!h->is_initialized()) h->initialize(CHECK_0);
1833 return h->allocate_instance(THREAD);
1834 }
1835
1836
1837 oop java_lang_boxing_object::create(BasicType type, jvalue* value, TRAPS) {
1838 oop box = initialize_and_allocate(type, CHECK_0);
1839 if (box == NULL) return NULL;
1840 switch (type) {
1841 case T_BOOLEAN:
1842 box->bool_field_put(value_offset, value->z);
1843 break;
1844 case T_CHAR:
1845 box->char_field_put(value_offset, value->c);
1846 break;
1847 case T_FLOAT:
1848 box->float_field_put(value_offset, value->f);
1849 break;
1850 case T_DOUBLE:
1851 box->double_field_put(value_offset, value->d);
1852 break;
1853 case T_BYTE:
1854 box->byte_field_put(value_offset, value->b);
1855 break;
1856 case T_SHORT:
1857 box->short_field_put(value_offset, value->s);
1858 break;
1859 case T_INT:
1860 box->int_field_put(value_offset, value->i);
1861 break;
1862 case T_LONG:
1863 box->long_field_put(value_offset, value->j);
1864 break;
1865 default:
1866 return NULL;
1867 }
1868 return box;
1869 }
1870
1871
1872 BasicType java_lang_boxing_object::basic_type(oop box) {
1873 if (box == NULL) return T_ILLEGAL;
1874 BasicType type = SystemDictionary::box_klass_type(box->klass());
1875 if (type == T_OBJECT) // 'unknown' value returned by SD::bkt
1876 return T_ILLEGAL;
1877 return type;
1878 }
1879
1880
1881 BasicType java_lang_boxing_object::get_value(oop box, jvalue* value) {
1882 BasicType type = SystemDictionary::box_klass_type(box->klass());
1883 switch (type) {
1884 case T_BOOLEAN:
1885 value->z = box->bool_field(value_offset);
1886 break;
1887 case T_CHAR:
1888 value->c = box->char_field(value_offset);
1889 break;
1890 case T_FLOAT:
1891 value->f = box->float_field(value_offset);
1892 break;
1893 case T_DOUBLE:
1894 value->d = box->double_field(value_offset);
1895 break;
1896 case T_BYTE:
1897 value->b = box->byte_field(value_offset);
1898 break;
1899 case T_SHORT:
1900 value->s = box->short_field(value_offset);
1901 break;
1902 case T_INT:
1903 value->i = box->int_field(value_offset);
1904 break;
1905 case T_LONG:
1906 value->j = box->long_field(value_offset);
1907 break;
1908 default:
1909 return T_ILLEGAL;
1910 } // end switch
1911 return type;
1912 }
1913
1914
1915 BasicType java_lang_boxing_object::set_value(oop box, jvalue* value) {
1916 BasicType type = SystemDictionary::box_klass_type(box->klass());
1917 switch (type) {
1918 case T_BOOLEAN:
1919 box->bool_field_put(value_offset, value->z);
1920 break;
1921 case T_CHAR:
1922 box->char_field_put(value_offset, value->c);
1923 break;
1924 case T_FLOAT:
1925 box->float_field_put(value_offset, value->f);
1926 break;
1927 case T_DOUBLE:
1928 box->double_field_put(value_offset, value->d);
1929 break;
1930 case T_BYTE:
1931 box->byte_field_put(value_offset, value->b);
1932 break;
1933 case T_SHORT:
1934 box->short_field_put(value_offset, value->s);
1935 break;
1936 case T_INT:
1937 box->int_field_put(value_offset, value->i);
1938 break;
1939 case T_LONG:
1940 box->long_field_put(value_offset, value->j);
1941 break;
1942 default:
1943 return T_ILLEGAL;
1944 } // end switch
1945 return type;
1946 }
1947
1948
1949 // Support for java_lang_ref_Reference
1950
1951 void java_lang_ref_Reference::set_referent(oop ref, oop value) {
1952 ref->obj_field_put(referent_offset, value);
1953 }
1954
1955 oop* java_lang_ref_Reference::referent_addr(oop ref) {
1956 return ref->obj_field_addr(referent_offset);
1957 }
1958
1959 void java_lang_ref_Reference::set_next(oop ref, oop value) {
1960 ref->obj_field_put(next_offset, value);
1961 }
1962
1963 oop* java_lang_ref_Reference::next_addr(oop ref) {
1964 return ref->obj_field_addr(next_offset);
1965 }
|