Skip to main content

rustjava_runtime/classes/java/lang/
object.rs

1use core::{
2    hash::{Hash, Hasher},
3    time::Duration,
4};
5
6use alloc::{boxed::Box, format, vec};
7
8use dyn_clone::clone_box;
9use jvm::{ClassInstance, ClassInstanceRef, Jvm, MonitorWaitTimeout, Result, runtime::JavaLangString};
10use jvm_class_proto::JavaMethodProto;
11use jvm_types::{ClassAccessFlags, MethodAccessFlags};
12
13use crate::{Runtime, RuntimeClassProto, RuntimeContext, SpawnCallback, classes::java::lang::String};
14
15// class java.lang.Object
16pub struct Object;
17
18const FNV_OFFSET_BASIS_64: u64 = 0xcbf29ce484222325;
19const FNV_PRIME_64: u64 = 0x100000001b3;
20
21#[derive(Default)]
22struct IdentityHasher(u64);
23
24impl Hasher for IdentityHasher {
25    fn finish(&self) -> u64 {
26        self.0
27    }
28
29    fn write(&mut self, bytes: &[u8]) {
30        let mut hash = if self.0 == 0 { FNV_OFFSET_BASIS_64 } else { self.0 };
31        for byte in bytes {
32            hash ^= u64::from(*byte);
33            hash = hash.wrapping_mul(FNV_PRIME_64);
34        }
35        self.0 = hash;
36    }
37}
38
39impl Object {
40    pub(crate) fn identity_hash_code<T>(object: &ClassInstanceRef<T>) -> i32 {
41        let mut hasher = IdentityHasher::default();
42        object.hash(&mut hasher);
43        hasher.finish() as i32
44    }
45
46    pub fn as_proto() -> RuntimeClassProto {
47        RuntimeClassProto {
48            name: "java/lang/Object",
49            parent_class: None,
50            interfaces: vec![],
51            methods: vec![
52                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
53                JavaMethodProto::new(
54                    "getClass",
55                    "()Ljava/lang/Class;",
56                    Self::get_class,
57                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
58                ),
59                JavaMethodProto::new("hashCode", "()I", Self::hash_code, MethodAccessFlags::PUBLIC),
60                JavaMethodProto::new("equals", "(Ljava/lang/Object;)Z", Self::equals, MethodAccessFlags::PUBLIC),
61                JavaMethodProto::new(
62                    "clone",
63                    "()Ljava/lang/Object;",
64                    Self::clone,
65                    MethodAccessFlags::PROTECTED | MethodAccessFlags::NATIVE,
66                ),
67                JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
68                JavaMethodProto::new("notify", "()V", Self::notify, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
69                JavaMethodProto::new("notifyAll", "()V", Self::notify_all, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
70                JavaMethodProto::new("wait", "(J)V", Self::wait_long, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
71                JavaMethodProto::new("wait", "(JI)V", Self::wait_long_int, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
72                JavaMethodProto::new("wait", "()V", Self::wait, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
73                JavaMethodProto::new("finalize", "()V", Self::finalize, MethodAccessFlags::PROTECTED),
74            ],
75            fields: vec![],
76            access_flags: ClassAccessFlags::PUBLIC,
77        }
78    }
79
80    async fn init(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
81        tracing::debug!("java.lang.Object::<init>({this:?})");
82
83        Ok(())
84    }
85
86    async fn get_class(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
87        tracing::debug!("java.lang.Object::getClass({this:?})");
88
89        // TODO can we get class directly?
90        let this: Box<dyn ClassInstance> = this.into();
91        let class = jvm.resolve_class(&this.class_definition().name()).await?.java_class();
92
93        Ok(class.into())
94    }
95
96    async fn hash_code(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
97        tracing::debug!("java.lang.Object::hashCode({this:?})");
98
99        Ok(Self::identity_hash_code(&this))
100    }
101
102    async fn equals(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Self>) -> Result<bool> {
103        tracing::debug!("java.lang.Object::equals({this:?}, {other:?})");
104
105        if other.is_null() {
106            return Ok(false);
107        }
108
109        let rust_this: Box<dyn ClassInstance> = this.into();
110        let rust_other: Box<dyn ClassInstance> = other.into();
111
112        rust_this.equals(&*rust_other)
113    }
114
115    async fn clone(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
116        tracing::debug!("java.lang.Object::clone({this:?})");
117
118        if !jvm.is_instance(&**this, "java/lang/Cloneable") {
119            return Err(jvm.exception("java/lang/CloneNotSupportedException", "Cannot clone this object").await);
120        }
121
122        Ok(jvm.shallow_clone(&this)?.into())
123    }
124
125    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
126        tracing::debug!("java.lang.Object::toString({this:?})");
127
128        let class = jvm
129            .invoke_virtual(&this, "java/lang/Object", "getClass", "()Ljava/lang/Class;", ())
130            .await?;
131        let class_name = jvm
132            .invoke_virtual(&class, "java/lang/Class", "getName", "()Ljava/lang/String;", ())
133            .await?;
134        let class_name_rust = JavaLangString::to_rust_string(jvm, &class_name).await?;
135
136        let hash_code: i32 = jvm.invoke_virtual(&this, "java/lang/Object", "hashCode", "()I", ()).await?;
137
138        let result = format!("{class_name_rust}@{hash_code:x}");
139
140        Ok(JavaLangString::from_rust_string(jvm, &result).await?.into())
141    }
142
143    async fn notify(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
144        tracing::debug!("java.lang.Object::notify({this:?})");
145
146        jvm.object_notify(&this, 1).await?;
147
148        Ok(())
149    }
150
151    async fn notify_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
152        tracing::debug!("java.lang.Object::notifyAll({this:?})");
153
154        jvm.object_notify(&this, usize::MAX).await?;
155
156        Ok(())
157    }
158
159    async fn wait_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, millis: i64) -> Result<()> {
160        tracing::debug!("java.lang.Object::wait({this:?}, {millis:?})");
161
162        let _: () = jvm.invoke_virtual(&this, "java/lang/Object", "wait", "(JI)V", (millis, 0)).await?;
163
164        Ok(())
165    }
166
167    async fn wait_long_int(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>, millis: i64, nanos: i32) -> Result<()> {
168        tracing::debug!("java.lang.Object::wait({this:?}, {millis:?}, {nanos:?})");
169
170        if millis < 0 || !(0..=999_999).contains(&nanos) {
171            return Err(jvm.exception("java/lang/IllegalArgumentException", "invalid wait timeout").await);
172        }
173
174        struct TimeoutNotifier {
175            timeout: u64,
176            waiter: MonitorWaitTimeout,
177            context: Box<dyn Runtime>,
178        }
179
180        #[async_trait::async_trait]
181        impl SpawnCallback for TimeoutNotifier {
182            async fn call(&self) -> Result<()> {
183                self.context.sleep(Duration::from_millis(self.timeout)).await;
184                self.waiter.clone().notify();
185                Ok(())
186            }
187        }
188
189        let (waiter, timeout_notifier) = jvm.object_wait_prepare(&this).await?;
190        let timeout = millis as u64 + u64::from(nanos > 0);
191        if timeout != 0 {
192            context.spawn(
193                jvm,
194                Box::new(TimeoutNotifier {
195                    timeout,
196                    waiter: timeout_notifier,
197                    context: clone_box(context),
198                }),
199            );
200        }
201
202        jvm.object_wait(waiter).await?;
203
204        Ok(())
205    }
206
207    async fn wait(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
208        tracing::debug!("java.lang.Object::wait({this:?})");
209
210        let _: () = jvm.invoke_virtual(&this, "java/lang/Object", "wait", "(JI)V", (0i64, 0)).await?;
211
212        Ok(())
213    }
214
215    async fn finalize(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
216        tracing::warn!("stub java.lang.Object::finalize({this:?})");
217
218        Ok(())
219    }
220}