DEV Community: Ruud Christopher Saimplice

Assembly x86-64 Linux: Discover the bare Bones !

Ruud Christopher Saimplice — Tue, 16 May 2023 20:50:54 +0000

In this journey, we will dive into the intriguing world of low-level programming, where we uncover the fundamental building blocks that power modern computer systems. As we peel back the layers, we will explore the bare bones of assembly language and witness the direct manipulation of the processor.

Introducing Assembly(ASM)

Assembly language serves as the bridge between high-level languages and machine code, allowing programmers to interact intimately with the hardware. With its concise syntax and fine-grained control over system resources, assembly programming enables optimized performance, deep system understanding, and the ability to overcome complex challenges.

In this blog series, we will focus specifically on x86-64 assembly, the dominant architecture in modern desktops, laptops, and servers. We will unravel the intricacies of the x86-64 instruction set, learn how to write efficient and concise assembly code, and gain insights into the inner workings of the processor.

The Central Processing Unit (CPU) of any computer is a microprocessor chip that conducts system functions such as accepting keyboard input and displaying output on the screen.

Only machine language instructions are understood by the CPU. These are binary sequences of ones and zeros, which are too cryptic for software development. The Assembly language solves this problem by giving symbols that express machine language instructions in an understandable fashion. As a result, assembly is also known as symbolic machine code.

Benefits of learning Assembly

Learning Assembly will teach you...

• How the CPU obtains and executes instructions.
• The manner in which data is stored in computer memory.
• The manner in which instructions access and process data.
• The manner in which programs interact with the operating system.
• Using disassembly to debug a high-level program.
• Understanding memory locations and pointers.
• How to write quick applications that use less memory.

By the end of this serie, you will have a solid foundation in x64 assembly language programming using ASMX64 and will be able to write efficient and optimized low-level code for the x64 architecture.

Follow me on Twitter and wait for the next lesson !!
https://twitter.com/web3_ruud

I’m on @buymeacoffee. If you like my work, you can buy me a and share your thoughts 🎉☕

https://www.buymeacoffee.com/officialsa4

Advance Solidity Assembly: Bit Shifting and Storage Offsets

Ruud Christopher Saimplice — Fri, 21 Apr 2023 17:13:02 +0000

Bit Shifting Overview

Bit shifting is an important notion in Solidity that enables for efficient binary data manipulation. In this blog post, we will look into bit shifting in Solidity and how it may be used. It can be used to transform data kinds, extract individual bits, and set specific bits. Understanding bit shifting is critical for producing efficient and optimized code.

Bit shifting is the process of shifting the bits of a binary number to the left or right. This procedure can be used to manipulate binary data, such as converting between data types, extracting certain bits, or setting specific bits.

We can execute bit shifting in Solidity by using the and >> operators. The operator shifts a number's bits to the left, whereas the >> operator shifts the bits to the right.

Packed Variables

You will occasionally need to access or write variables while using assembly.

There is a specific instance in which numerous variables are packed.

Because the EVM has 256 bits (32bytes) slots, you can't directly access the packed variables; instead, you'll access the storage slot and find the offset of said variable.

Then, shift the bits right until you reach the offset where the variable was stored inside the slot.

If necessary, mask some bits so that it returns the expected value.


uint128 public A = 2;
uint104 public D = 6;
uint16  public E = 4;
uint8   public G = 1;

function readBySlot(uint slot) external view returns(bytes32 value){
    assembly{
        value := sload(slot)
    }
} 
// return 0x0100040000000000000000000000000600000000000000000000000000000002

All of the variables are crammed into the same 32-byte slot.Variables will always be packed from the bottom to the top.

How can we get the value of the variable E ? To do so, we need to know the variable offset, which is the location of the variable in bytes from right to left.

function offsetE() external pure returns(uint256 _off){
    assembly{
        // return 29 bytes left
        _off := E.offset
    }
}

Now that we have everything we require, we will begin the shiffting process.We need to move the E value 29 bytes to the right in order to return it. We'll need to use shr to determine the number of bits to shift right. Because we have bytes, we must multiply that amount by 8:

function shiftE() external view returns(bytes32 e){
    assembly{
        let slot  := sload(E.slot)
        e := shr(mul(E.offset, 8), slot)
    }
}

return 0x0000000000000000000000000000000000000000000000000000000000010004

We're getting there; we now have E in the last byte, but there's something unusual going on. We still have the G variable 1.We shall now begin masking.

function shiftE() external view returns(bytes32 e,uint256 v){
    assembly{
        let slot  := sload(E.slot)
        e := shr(mul(E.offset, 8), slot)
        v := and(0xffff,e)
    }
}

return
1:0x0000000000000000000000000000000000000000000000000000000000010004.
2:4

Write to storage without causing any problems with the code

Because the EVM can only write in 32-byte increments, writing can be challenging.We're going to write to a packed variable, say E, which is uint16.Let's put something in storage! Change the E value to 4.

function setE(uint16 newE)external  returns(bytes32 value,bytes32 clearedE, bytes32 newV, bytes32 shifted){
    assembly{

        value:= sload(E.slot)
        //VALUE -> 0x0100040000000000000000000000000600000000000000000000000000000002

        //WE WANT TO DELETE E
        clearedE := and(0xff0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, value)
        //CLEARED E -> 0x0100000000000000000000000000000600000000000000000000000000000002

        shifted := shl(mul(E.offset,8),newE)
        //0x0000030000000000000000000000000000000000000000000000000000000000

        newV := or(shifted,clearedE)
        //NEW VALUE -> 0x0100030000000000000000000000000600000000000000000000000000000002
        sstore(E.slot,newV)
    }
}

Follow me on Twitter and wait for the next serie !!
https://twitter.com/web3_ruud

I’m on @buymeacoffee. If you like my work, you can buy me a and share your thoughts 🎉☕ https://www.buymeacoffee.com/officialsa4

Advance Solidity Assembly: Calldata Part 1

Ruud Christopher Saimplice — Sat, 04 Mar 2023 13:48:09 +0000

In Solidity, calldata is a special data location that is used to store the function arguments and other data that is passed to a function when it is called. calldata is read-only, which means that the function cannot modify the data in calldata.

When a Solidity function is called, its arguments are copied to calldata, which is a portion of the transaction data. This is different from the memory data location, which is used to store data that is only used within the function and is not part of the transaction data.

Calldata in Gory Details !!!!

Calldata is a continuous sequence of bytes that is structured in the same way as memory, as opposed to other data locations like storage or stack, which are composed of 32-byte words.

When reading from calldata, the behavior is the same as memory: you can load 32 bytes at a time using calldataload or mload. However, calldata is different from memory because you cannot write to it.

Calldata is a data location that is unique to EVM-based blockchains, and it has a specific layout that includes:

1- The first 4 bytes of calldata represent the function signature selector.

2- The remaining bytes of calldata represent the input parameters of the function. Each input argument is always 32 bytes long, regardless of its actual size. If an argument's type is smaller than 32 bytes, it will be padded to fill the remaining space.

Input arguments in Solidity are padded either on the right or left depending on their type. For example, uintN and address types are padded on the left, while bytesN types are padded on the right.

Advance Solidity Assembly: Storage Slots Part 2

Ruud Christopher Saimplice — Sun, 26 Feb 2023 22:22:24 +0000

Arrays with Fixed Sized

In Solidity, fixed-size arrays are stored in memory as contiguous blocks of memory. Each element in the array is stored in the next available memory slot, starting from the base memory address of the array.

uint256[3] public fixedArray = [1,2,3];

function fixedArraySlot() external pure returns(uint256 _slot){
   assembly{
     //return 0
     _slot:= fixedArray.slot
   }
}

To read a specific element of a fixed-size array in Solidity, you need to calculate the memory location of the element by adding the memory slot of the start of the array to the index of the element you want to access. This calculation is necessary because fixed-size arrays in Solidity are stored in contiguous blocks of memory, with each element occupying a fixed amount of space. By adding the appropriate offset to the start of the array, you can find the memory location of the element you want to read or modify.

function fixedArrayView(uint256 index) external view returns(uint256 _value){
   assembly{
     _value:= sload(add(fixedArray.slot,index))
   }
}

Arrays with No-Fixed Size

To obtain the length of a dynamic array in Solidity, you need to access the slot in memory where the length of the array is stored.

uint256[]  public bigArray   = [14,1,9];
bigArray.slot // return 3

The keccak256 function is used to generate a unique identifier for the storage slot where the dynamic array is stored. This identifier, represented as a bytes32 value, is then used to determine the precise location of the array within the storage space. By using this identifier to calculate the location of the array in storage, you can access its elements or modify its contents using Solidity assembly code.

function readBigArray(uint index)  external view returns(uint256 _data,bytes32 location){

    uint256 _slot ;

    assembly {
        _slot:= bigArray.slot
    }

    //hash of the slot give us the location
    location = keccak256(abi.encode(_slot));

    assembly {
        _data:= sload(add(location,index))
    }
}

Small Arrays !! It's the same process

uint8[]  public smallArray = [1,5,4,7];

function readSmallArrayLocation(uint256 index) external view returns (bytes32 ret) {
    uint256 slot;
    assembly {
        slot := smallArray.slot
    }
    bytes32 location = keccak256(abi.encode(slot));

    assembly {
        ret := sload(add(location, index))
    }
}

Mapping

When a mapping is declared, Solidity reserves a space in storage to store the mapping data. The location of this space is determined by a unique identifier generated by the keccak256 function, which is concatenated with the key of the storage slot and the slot.

function getMapping(uint256 key) external view returns (uint256 ret) {

    uint256 slot;
    assembly {
        slot := myMapping.slot
    }

    bytes32 location = keccak256(abi.encode(key, uint256(slot)));

    assembly {
        ret := sload(location)
    }
}

Follow me on Twitter !! https://twitter.com/web3_ruud

I’m on @buymeacoffee. If you like my work, you can buy me a and share your thoughts 🎉☕ https://www.buymeacoffee.com/officialsa4

Advance Solidity Assembly: Storage Slots Part 1

Ruud Christopher Saimplice — Sat, 25 Feb 2023 23:41:21 +0000

Solidity's storage is organized into slots of 256 bits each, and variables are packed into these slots to make more efficient use of storage. When variables are packed into a slot, they are placed in the lowest-indexed positions in the slot first, with any remaining bits at the end of the slot unused.

Storage Slot.

A storage slot is a fixed-sized unit of storage that can hold 256 bits of data. Solidity's storage is organized into a virtual array of these slots, indexed by 256-bit unsigned integers. Each storage slot can hold one or more variables, depending on their size and packing rules.

When a variable is declared in a Solidity contract, it is assigned to a storage slot in a deterministic manner, based on its type and position in the contract's state variables. The Solidity compiler calculates the correct slot number for each variable and generates the necessary bytecode to access or modify its value in storage.

In Solidity, the .slot keyword is used to access the storage slot of a contract's state variable.

(variable_name).slot

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

contract GetBySlot{

    uint256 public a = 34;
    uint256 public b = 122;

    function getSlotVarA() external pure returns(uint _slot){
        assembly{
            //return 0
            _slot:= a.slot
        }
    }
    function getSlotVarB() external pure returns(uint _slot){
        assembly{
            //return 1
            _slot:= b.slot
        }
    }

}

Update Value using Storage Slot.

In Solidity assembly, the sstore opcode is used to store a value in the contract's storage.

The Solidity storage is a persistent key-value store that is used to store the state variables of the contract. Each key-value pair is stored in a unique storage slot, which is identified by a 256-bit key. The sstore opcode is used to store a 256-bit value in a specific storage slot, identified by its key.

// Be carefull with this instruction in your code
function setBySlot(uint256 slot,uint256 value) external {
  assembly {
     sstore(slot,value)
  }
}

Warning ⚠️

When using Solidity assembly to manipulate storage slots, it is important to keep in mind that storage operations are very expensive in terms of gas consumption. Every read or write operation to a storage slot incurs a gas cost, which is significantly higher than the gas cost of equivalent operations on memory or stack.

As a result, it is generally a good practice to minimize the number of storage operations in your contract, and to carefully consider the layout of your data in storage to optimize for gas efficiency.

In addition, it is important to be aware of the potential risks of using assembly to directly manipulate storage slots, as this can introduce subtle bugs and security vulnerabilities in your contract. If you are new to Solidity programming, it is recommended that you start with simpler, high-level abstractions before diving into low-level assembly programming.

When working with storage slots in Solidity assembly, it is also important to be aware of the potential for collisions between different contract variables that share the same storage slot. This can occur if two variables are declared with the same storage location using the slot keyword, or if the same storage slot is used for different purposes at different points in the contract execution.

To avoid these risks, it is important to carefully manage your use of storage slots and to ensure that each variable has a unique storage location. It is also recommended to use higher-level Solidity constructs, such as structs and mappings, to manage complex data structures in storage, as these can help to simplify the logic of your code and reduce the risk of errors.

Follow me on Twitter !! https://twitter.com/web3_ruud

I’m on @buymeacoffee. If you like my work, you can buy me a and share your thoughts 🎉☕ https://www.buymeacoffee.com/officialsa4

Unlocking the Power of Solidity: Dive into the Basics of Assembly Language

Ruud Christopher Saimplice — Thu, 23 Feb 2023 22:08:19 +0000

Solidity assembly is a low-level programming language that is used in the Ethereum Virtual Machine (EVM). It is a set of instructions that can be used to interact directly with the EVM, which is responsible for executing smart contracts on the Ethereum blockchain. Assembly language provides a way to write more optimized and efficient code by directly accessing and manipulating the EVM's memory and registers.

Why use Solidity Assembly ?

While Solidity is a high-level programming language, it has certain limitations when it comes to efficiency and control over the EVM's execution. Solidity assembly allows you to bypass these limitations and write code that can be executed directly on the EVM. This can be particularly useful in situations where you need to optimize gas usage, perform low-level operations, or access specific parts of the EVM that are not accessible through Solidity.

Solidity assembly also provides a way to write more complex logic that cannot be easily expressed in Solidity. For example, you can use assembly to perform bitwise operations, which are not natively supported in Solidity. Additionally, assembly provides a way to implement cryptographic algorithms and perform other complex calculations that require low-level access to the EVM.

EVM (Ethereum Virtual Machine)

The EVM is a stack machine.A stack is a collection of elements or items, and two main operations can be performed on it: push and pop. Pushing an item onto the stack adds it to the top, and popping an item from the stack removes the top item. The stack is typically visualized as a vertical structure, with the top of the stack at the top of the visualization and the bottom of the stack at the bottom.

A stack machine is a type of computer architecture that uses a stack data structure to manage its memory,computation and also store all operands.In assembly language,an operand is a value (an argument) on which the instruction,named by mnemonics operates.

In order to be useful the state machine have to implement some basic functionality like ADD,MUL... Without forgetting instructions usually pop one or more values from the stack to do some computation and push the result .This process is AKA Reverse Polish Notation.

Reverse Polish Notation (RPN), AKA postfix notation, is a mathematical notation where operators come after the operands. In RPN, an expression is evaluated by scanning it from left to right, and pushing operands onto a stack. When an operator is encountered, it is applied to the top two operands on the stack, and the result is pushed back onto the stack.

For example, the infix expression "3 + 4" can be written in RPN as "3 4 +". Here, the operands 3 and 4 are pushed onto the stack, and the operator "+" is applied to them. The result, 7, is pushed back onto the stack.

3 + 4  // Standard notation.
3 4 + // Reverse polish notation.

Different Types of Assembly in Solidity

1- Inline Assembly : Inside the solidity source code.
2- Standalone Assembly : Can use without the solidity.

//Inline Assembly
assembly {
   let x:= x
}

How to Use Solidity Assembly ?

Solidity assembly is written using the assembly keyword and is enclosed in curly braces. Inside the braces, you can write a series of assembly instructions that will be executed directly on the EVM. Assembly instructions are written in a specific syntax that is similar to other assembly languages. Here is an example of Solidity assembly that add two values to memory location 0x0 and returns it after:

function add(uint x,uint y) external pure returns(uint) {
  assembly {

    /*This line is calling the add operation provided by the 
    assembly language to add x and y, and storing the result 
    in a variable res.*/

    let res := add(x,y)

    /*This line is using the mstore operation to store the 
    value of res at memory location 0x0. mstore takes two 
    arguments: the memory location to store the data and the 
    data to store.*/

    mstore(0x0,res)

    /*This line is returning the result of the addition as a 
    32-byte value starting at memory location 0x0. The return 
    statement takes two arguments: the memory location of the 
    data to return and the size of the data to return.*/

    return (0x0,32)
  }
}

Variables declarations and Assignments

1- Stack Variables: In assembly language, variables can be declared as stack variables using the mstore operation. Stack variables are used to store values on the stack and are local to the current execution context.

assembly {
  mstore(0x0, 5) // Declare stack variable and assign value 5
}

2- Memory Variables: Memory variables are used to store data in memory and are declared using the mload operation. Memory variables can be global or local to a function.

assembly {
  let myVariable := mload(0x40) // Declare memory variable
  mstore(myVariable, 5) // Assign value 5 to memory variable
}

3- Storage Variables: Storage variables are used to store data in storage and are declared using the sload operation. Storage variables can be global or local to a function.

assembly {
  let myVariable := sload(0x0) // Declare storage variable
  sstore(0x0, 5) // Assign value 5 to storage variable
}

We use the let keyword.You can then assign it value with the := operator.When declaring a new local variable with let, Solidity will automatically allocate a new memory slot for the variable and initialize it with the default value (which is zero for all types except bool, which is false). The variable's type is determined by the type of the assigned value.Variables declared in let are not visible outside the assembly block.

It's important to note that using assembly language for variable declaration and assignment can be more complex than using Solidity's built-in syntax. Additionally, assembly language can be more difficult to read and write, and can introduce security risks if not used correctly. It is recommended to use assembly language only when necessary and with caution.

Follow me on Twitter !! https://twitter.com/web3_ruud

I’m on @buymeacoffee. If you like my work, you can buy me a and share your thoughts 🎉☕ https://www.buymeacoffee.com/officialsa4