avm2: Significantly improve optimizer

Author: Lord-McSweeney

core/src/avm2.rs

@@ -57,7 +57,7 @@ mod multiname;
 mod namespace;
 pub mod object;
 mod op;
-mod optimize;
+mod optimizer;
 mod parameters;
 pub mod property;
 mod property_map;

core/src/avm2/activation.rs

@@ -849,8 +849,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
                     multiname,
                     num_args,
                 } => self.op_call_super(*multiname, *num_args),
-                Op::ReturnValue => self.op_return_value(method),
-                Op::ReturnValueNoCoerce => self.op_return_value_no_coerce(),
+                Op::ReturnValue { return_type } => self.op_return_value(*return_type),
                 Op::ReturnVoid => self.op_return_void(),
                 Op::GetProperty { multiname } => self.op_get_property(*multiname),
                 Op::SetProperty { multiname } => self.op_set_property(*multiname),
@@ -1208,10 +1207,9 @@ impl<'a, 'gc> Activation<'a, 'gc> {
 
     fn op_return_value(
         &mut self,
-        method: Gc<'gc, BytecodeMethod<'gc>>,
+        return_type: Option<Class<'gc>>,
     ) -> Result<FrameControl<'gc>, Error<'gc>> {
         let return_value = self.pop_stack();
-        let return_type = method.resolved_return_type();
 
         let coerced = if let Some(return_type) = return_type {
             return_value.coerce_to_type(self, return_type)?
@@ -1222,12 +1220,6 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         Ok(FrameControl::Return(coerced))
     }
 
-    fn op_return_value_no_coerce(&mut self) -> Result<FrameControl<'gc>, Error<'gc>> {
-        let return_value = self.pop_stack();
-
-        Ok(FrameControl::Return(return_value))
-    }
-
     fn op_return_void(&mut self) -> Result<FrameControl<'gc>, Error<'gc>> {
         Ok(FrameControl::Return(Value::Undefined))
     }
@@ -1547,24 +1539,22 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         Ok(FrameControl::Continue)
     }
 
-    fn op_get_outer_scope(&mut self, index: u32) -> Result<FrameControl<'gc>, Error<'gc>> {
+    fn op_get_outer_scope(&mut self, index: usize) -> Result<FrameControl<'gc>, Error<'gc>> {
         // Verifier ensures that this points to a valid outer scope
 
-        let scope = self.outer.get_unchecked(index as usize);
+        let scope = self.outer.get_unchecked(index);
 
         self.push_stack(scope.values());
 
         Ok(FrameControl::Continue)
     }
 
-    fn op_get_scope_object(&mut self, index: u8) -> Result<FrameControl<'gc>, Error<'gc>> {
-        let scope = self.scope_frame().get(index as usize).copied();
+    fn op_get_scope_object(&mut self, index: usize) -> Result<FrameControl<'gc>, Error<'gc>> {
+        // Verifier ensures that this points to a valid local scope
 
-        if let Some(scope) = scope {
-            self.push_stack(scope.values());
-        } else {
-            self.push_stack(Value::Undefined);
-        };
+        let scope = self.scope_frame()[index];
+
+        self.push_stack(scope.values());
 
         Ok(FrameControl::Continue)
     }

core/src/avm2/op.rs

@@ -136,13 +136,13 @@ pub enum Op<'gc> {
         index: u32,
     },
     GetOuterScope {
-        index: u32,
+        index: usize,
     },
     GetProperty {
         multiname: Gc<'gc, Multiname<'gc>>,
     },
     GetScopeObject {
-        index: u8,
+        index: usize,
     },
     GetScriptGlobals {
         script: Script<'gc>,
@@ -253,8 +253,9 @@ pub enum Op<'gc> {
     },
     PushUndefined,
     PushWith,
-    ReturnValue,
-    ReturnValueNoCoerce,
+    ReturnValue {
+        return_type: Option<Class<'gc>>,
+    },
     ReturnVoid,
     RShift,
     SetGlobalSlot {
@@ -297,18 +298,6 @@ pub enum Op<'gc> {
 }
 
 impl Op<'_> {
-    pub fn is_block_terminating(&self) -> bool {
-        matches!(
-            self,
-            Op::Jump { .. }
-                | Op::LookupSwitch { .. }
-                | Op::ReturnValue
-                | Op::ReturnValueNoCoerce
-                | Op::ReturnVoid
-                | Op::Throw
-        )
-    }
-
     pub fn can_throw_error(&self) -> bool {
         !matches!(
             self,