Solidez – Montaje

El lenguaje ensamblador o ensamblador indica un lenguaje de programación de bajo nivel que se puede convertir a código de máquina mediante el uso de ensamblador. El lenguaje ensamblador está vinculado a una máquina física o virtual, ya que su implementación es un conjunto de instrucciones, y estas instrucciones le indican a la CPU que realice esa tarea fundamental, como sumar dos números.

Solidity tiene una opción para escribir un código de lenguaje ensamblador dentro del código fuente del contrato inteligente. Con la ayuda del ensamblaje Solidity, podemos interactuar directamente con el EVM usando los códigos de operación. El ensamblaje proporciona más control sobre alguna lógica que no puede ser posible usando solo solidez, como apuntar al bloque de memoria específico. Una de las principales ventajas es que reduce el costo del gas utilizado para implementar el contrato. Solidity tiene dos formas de implementar el lenguaje ensamblador: 

Ensamblaje en línea: el código de ensamblaje en línea se puede escribir dentro del código de solidez para un control más detallado y se usa especialmente para mejorar el lenguaje mediante la creación de nuevas bibliotecas. El ensamblaje en línea se puede insertar entre declaraciones de solidez de una manera que EVM pueda entender. También se puede usar cuando el optimizador no puede producir un código eficiente. La solidez se vuelve más fácil cuando se utilizan funciones como ensamblar variables locales, llamadas a funciones, sentencias de cambio, sentencias if, bucles, etc.
Sintaxis:

assembly{
     // assembly language statements
}

Ejemplo: en el siguiente ejemplo, se crea un contrato con una función, donde el código ensamblador en línea se encuentra dentro de la función.

// Solidity program to demonstrate 
// Inline Assembly
pragma solidity ^0.4.0;
  
// Creating a contract
contract InlineAssembly {
  
    // Defining function 
    function add(uint a) view returns (uint b) {
  
        // Inline assembly code
        assembly {
  
            // Creating a new variable 'c'
            // Calculate the sum of 'a+16' 
            // with the 'add' opcode
            // assign the value to the 'c'
            let c := add(a, 16)
  
            // Use 'mstore' opcode to 
            // store 'c' in memory 
            // at memory address 0x80
            mstore(0x80, c)
            {
  
                // Creating a new variable'
                // Calculate the sum of 'sload(c)+12' 
                // means values in variable 'c' 
               // with the 'add' opcode
               // assign the value to 'd'
                let d := add(sload(c), 12)
   
                 // assign the value of 'd' to 'b'
                b := d
   
            // 'd' is deallocated now
            } 
      
            // Calculate the sum of 'b+c' with the 'add' opcode
            // assign the value to 'b'
            b := add(b, c)
  
        // 'c' is deallocated here
        } 
    }
}

Producción : 

A veces, escribir código ensamblador es más difícil porque no realizará comprobaciones, por eso es mejor usarlo solo cuando las cosas son complejas y tiene una idea de lo que está haciendo.

Ensamblaje independiente: el ensamblaje independiente está planificado para crear un lenguaje intermedio para el compilador de solidez. Fue compatible con la compatibilidad reciente, pero ya no está documentado en la documentación de solidez. Los programas escritos en un ensamblado independiente se pueden leer incluso si el código ha sido generado por un compilador solidity. El flujo de control debe ser sencillo, para su optimización y verificación formal.

Ejemplo: En el siguiente ejemplo, el contrato y una función se crean para demostrar el concepto de ensamblaje independiente. 

// Solidity program to demonstrate
// Standalone Assembly
pragma solidity ^0.4.0;
  
// Creating a contract
contract StandaloneAssembly {
  
  // Defining a function
  function add(uint a) view returns (uint b) {
  
    // Initializing the variable b
    b = 10;
  
    // Executing for loop till the condition is met
    for (uint n = 0; n < a; n++)
      b = b + a;
  }
}

El código de nivel de ensamblaje para el ejemplo anterior es:  

mstore(0x40, 0x60) // esta línea almacenará el «puntero de memoria libre» 
// 
interruptor de función de despacho div(calldataload(0), exp(2, 226)) 
case 0xb3de649b { 
let (retData) = func(calldataload(4 )) 
let retVal := $memAllocate(0x20) 
mstore(retVal, retData) 
return(retVal, 0x20) 
} 
default { revert(0, 0) } 
// asignar 
función de memoria $memAllocate(tamaño) -> pos { 
pos := mload(0x40) 
mstore(0x40, add(pos, size)) 
} 
// función de la función de contrato 
suma(a) -> b { 
b := 10 
for { let n := 0 } lt(n, a) { n := sumar(n, 1) } { 
b := sumar(a, b) 
} 
} 
} 

Producción :