Shulou(Shulou.com)06/01 Report--

This article mainly introduces "how to use Solidity Assembly". In daily operation, I believe many people have doubts about how to use Solidity Assembly. The editor consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful for you to answer the doubts about "how to use Solidity Assembly"! Next, please follow the editor to study!

1. Use the Remix editor

First, let's paste this simple contract into the remix editor:

Pragma solidity ^ 0.5.10 X contract AssemblyArrays {bytes testArray; function getLength () public view returns (uint256) {return testArray.length;} function getElement (uint256 index) public view returns (bytes1) {return testArray [index];} function pushElement (bytes1 value) public {testArray.push (value);} function updateElement (bytes1 value, uint256 index) public {testArray [index] = value;}}

First familiarize yourself with the Remix editor. We first need to select the compiler version, then compile the contract, deploy the contract, perform some functions, and then debug.

2. The first line of assembly code

Now, let's modify the getLength function to write the first line of assembly code:

Function getLength () public view returns (uint256) {bytes memory memoryTestArray = testArray; uint256 result; assembly {result: = mload (memoryTestArray)} return result;}

A lot has happened in the above lines of code. Assembler is like this, and it takes a lot of code to implement a very simple function. We copied testArray from storage to memory because this is the focus of this article. We can talk about storage slots later.

Before delving into assembly language blocks, note that assembly instructions operate on 32-byte words. Therefore, the mload instruction pushes 32 bytes of the memory location that memoryTestArray points to onto the stack.

3. Breakpoint setting and step-by-step execution of Solidity assembly code

Now debug it. In Remix, you can set a breakpoint by clicking the line number. Let's set a breakpoint on line 11, so it looks like this:

After updating the getLength feature, make sure that the contract has been compiled and redeployed again. Now, let's call the pushElement function to insert the byte 0x05 into the array, then call getLength, which should return 1.

After calling getLength, we can debug it. Click the Debug button in the last call in the bottom panel, which opens the debugger in the left column. There is a button for fast forward (such as: fast_forward:) that jumps to the next breakpoint. Let's click that. If you use different compilers or different settings, it may not be exactly the same for you, but the core will be the same. The basic idea is to get the debugger before the mload executes, which in my environment is the # 0871 instruction.

4. Check the impact of Solidity assembly code on the stack

Now let's take a look at the stack / stack content of the debugger sidebar:

At the top of the stack, position 0 is 0x0...80. This is the location of the memoryTestArray in memory, which will be used as an argument to the mload instruction.

5. Check the impact of Solidity assembly code on memory

Now, let's look at the "memory" section of the debugger sidebar, starting with the address 0x0...80:

There are 31 bytes of 0x00, followed by 1 byte of 0x01, then 1 byte of 0x05, followed by 31 bytes of 0x00. This can be a little confusing, so let's step back a little bit and notice that 1 byte (8 bits) is represented by 2 hexadecimal digits (1 hexadecimal number represents 4 digits). Similarly, 0x10 hexadecimal equals 16. Therefore, in memory, location 0x80 holds 16 bytes, location 0x90 (0x80 + 0x10) holds the next 16 bytes, then location 0xa0 (0x90 + 0x10) holds the following 16 bytes, and location 0xb0 holds the last 16 bytes. Because the instructions in the assembly operate in 32 bytes, if we call mload (0x80), it will take 32 bytes from the memory location 0x80 and put them on the stack.

6. Execute mload instruction step by step

Let's take a look at the actual implementation. Let's click the step in button (that is, the down arrow) in the debugger to execute the mload instruction. Now take a look at the top of the stack:

The mload instruction takes the top content of the stack: 0x0...80, and then presses 32 bytes of the location 0x0...1 in memory, which is the most important thing to understand the byte array in memory: the length of the first 32 bytes.

Try calling the pushElement function to insert the element 0x06 into the array. Then call getLength and debug again. Again, mload will load 32 bytes from the memory location 0x80, but this time the memory content is 0x0...2. When we append new elements, Solidity updates the size of the array for us.

Another thing that has changed in memory is that the location 0xa0 is now 0x050600...00. Therefore, in memory, a byte array variable stores its length in the first 32 bytes, and then begins to store specific members. First we press in 0x05, then we press in 0x06.

7. Rewrite the getLength method with Solidity assembly

Try to press in some more elements, call getLength, and debug to see the new bytes in memory. If we convert getElement to assembly, the process will become clearer:

Function getElement (uint256 index) public view returns (bytes1) {uint256 length = getLength (); require (index < length); bytes memory memoryTestArray = testArray; bytes1 result Assembly {let wordIndex: = div (index, 32) let initialElement: = add (memoryTestArray, 32) let resultWord: = mload (add (initialElement, mul (wordIndex, 32)) let indexInWord: = mod (index, 32) result: = shl (mul (indexInWord, 8), resultWord)} return result;}

Well, this might scare you a little bit! Let's sort it out slowly.

The first super important thing is that we added a require statement to check that the index is not out of range. This is critical when calling mload, and we need to make sure that the memory location to be loaded is correct, otherwise we may disclose information that the caller should not have access to, which may put our contract at serious risk of attack.

Next, let's look at the assembly code block. Because mload reads 32 bytes at a time, it is not easy to read only 1 byte. If we divide index by 32 and round it, we get the 32-byte sequence number of the member we are looking for. For example:

Div (0,32) = 0div (18,32) = 0div (32,32) = 1div (65,32) = 2

It looks good. Remember, however, that the first built-in word (32 bytes) that memoryTestArray points to in memory stores the length of the array. Therefore, we need to add 32 bytes to find the first array member. With all these factors in mind, we can load a word (32 bytes) that contains the 1 byte we need:

Add 32 bytes to the memory location of memoryTestArray to skip the array length, plus wordIndex to 32, because each word has 32 bytes.

But it's not finished yet. Now we need to extract exactly 1 byte from the word. To do this, we need to find the index of the byte in the word. This is the remainder of the word index divided by 32, which can be obtained through the mod instruction. For example:

Mod (0,32) = 0mod (18,32) = 18mod (32,32) = 0mod (65,32) = 1

Yes, let's complete the last step to extract the byte. To keep the bytes first, we move the required number of bits to the left. The shl instruction moves one bit at a time, so to move the specified number of bits, we multiply indexInWord by 8.

Once we assign a 32-byte word that begins with this byte to the result variable, it deletes all other bytes because we declare its type as bytes1.

At this point, the study on "how to use Solidity Assembly" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.