DroidAssist | lightweight Android Studio gradle plugin based on Javassist | Bytecode library

The MethodParameters attribute is used to indicate that parameters are final. https://docs.oracle.com/javase/specs/jvms/se17/html/jvms-4.html#jvms-4.7.24

In order for javac to add this attribute, you need to pass the -parameters option.

There's no one "right" way to do this, but the simplest strategy is to leave the values on the stack, and the called method refers to them via negative offsets. For example, if the called method has 3 params, they're referenced from the base stack offset minus 3, 2, and 1. Each is copied to a local variable and then referenced in the usual manner. The stack offset can be updated to reflect that the params have been consumed. Of course, each local param can also be initially assigned by a bunch of pops, one for each param.

Other tricks can be performed to speed things up. There's no reason that local variables need to be stored differently than the stack. They can be stored on the stack itself. The passed in params occupy their original locations on the stack, and then additional space is allocated for the remaining local variables by just updating the stack offset. A base stack offset is remembered, and all local variables are referenced via the base offset.

Essentially, a local variable is just like a stack slot, except it can be accessed at any time, regardless of what's currently been pushed on top.

If what you are looking for is the output of the disassembler, then you can run the module as a script:

In CPython every function gets its own stack, it's called a frame in CPython and it's an implementation-specific detail(very old one) and other implementation of Python like IronPython¹ and Jython doesn't have this functionality or implement it differently.

To clarify when we say stack there are multiple stacks involved:

1. Python stack: The stack of frame objects
2. Function values stack: The values in each frame object are stored in this stack to be operated on within the scope of this frame²
3. C stack: For C function calls

When a function is called a new frame object is created first and placed on the Python stack. This frame object contains the code object of the function, global variables the function has access to, and also the local variables defined in the function get stored in the frame object.

You can get the current frames in Python stack and current frame using the utilities provided in the inspect module.

The issue with this is that it is a Python object, it has its own type PyFrame_Type, it gets reference count(gets all headers from PyVarObject) and consumes some memory and if we have a chain of function calls, each time we will be creating these frame objects in memory all over the heap.

In Python 3.11, the frame object will be replaced by an array of structs that won't have an object header. The frame objects will still be available, but only if we request for it using inspect.currentframe() or sys._get_frame().

² Function values stack

We can check stacksize of a function by accessing co_stacksize attribute of function's code object, this value is determined during the compilation time:

Frontend compilers generate code using simple patterns, and they rely on optimization passes to clean things up. At the point that the x == y expression is generated, the compiler doesn't "know" that the very next thing is a return statement. It could potentially check this, but that extra step can be handled just as easily with some sort of peephole optimizer.

The benefit of a peephole optimizer is that it can perform cascading optimizations, that is, the result of one optimization can feed into the next one. The code that generated the x == y expression doesn't really have any way of performing anything more than one optimization step without adding more complexity.

The java compiler used to have an optimization feature, but this was ditched in favor of HotSpot, which can perform even more powerful optimizations. Performing optimizations in the java compiler would slow it down and not really improve things all that much.

In general, the answer is no, but the JVM does require 32-bit alignment for the data portions of the lookupswitch and tableswitch instructions. Up to 3 bytes of padding (zeros) must be encoded to ensure proper alignment.

Yes, it's because they are double. In Java Virtual Machine Specification section 2.6.1 Local variables you can read:

A single local variable can hold a value of type boolean, byte, char, short, int, float, reference, or returnAddress. A pair of local variables can hold a value of type long or double.

It all eventually depends on the JVM instruction used:

• invokespecial would invoke the method without doing dynamic resolution based on the type of current object.

• invokevirtual would dispatch based on the class.

Related: Why invokeSpecial is needed when invokeVirtual exists

So the answer is it depends on the generated bytecode.

The signature of ArrayList.get method at 22 is wrong.
The correct one is (I)Ljava/lang/Object;