Solidity Assembly – How to Bit Shift Bytes in Solidity/Assembly

assemblybit-manipulationsolidity

I can bit shift uint_n_ easily but I don't manage to bit shift a bytes memory myBytes.

When doing myBytes << i I have a compile error and when using assembly I receive 0.

See my MWE for assembly and test:

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

library BytesShift {
    function shiftLeft(bytes memory x, uint256 n)
        public
        pure
        returns (bytes memory)
    {
        bytes memory tmp;
        assembly {
            tmp := shl(n, x)
        }
        return tmp;
    }
}

describe("BytesShift", function () {
  describe("shiftLeft", () => {
    it(`Should shift bytes to the left`, async function () {
      const BytesShift = await ethers.getContract("BytesShift");
      const res = await BytesShift.shiftLeft("0xff", 1);
      expect(res).to.equal("0xfe");
    });
  });
});

failing with received value :

      AssertionError: expected '0x' to equal '0xfe'
      + expected - actual

      -0x
      +0xfe

Best Answer

The shift operation is only available for value types not for reference types (see https://docs.soliditylang.org/en/v0.8.11/types.html#value-types)

Value types exist on stack and there can be passed to the shift opcode.

The bytes memory only stores the location of the data in memory on stack. So in you assembly example you tmp just points to an invalid memory location and therefore returns 0.

If you want to shift a bytes you need to process the whole bytes data word by word and also handle overflows between the words.

Related Solutions

Assembly – Techniques for Manipulating Individual Bytes

Building up on @Jesbus comment, here is a commented example achieving what you want :

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

contract TestAssembly {
    function test(uint8 _count) public pure returns (bytes memory) {

        // Declares the array in memory
        bytes memory bytesTest = new bytes(10);

        // Protect against buffer overflow
        require(_count <= 10, "not enough bytes in the array");

        assembly {

            // Skip the first 32 bytes reserved for the length of the memory array
            let offset := add(bytesTest, 0x20)

            // Loop _count times over the array
            for { let i := 0} lt(i, _count) { i := add(i, 1) } { 
                // Make use of mstore8 (1 byte) instead of mstore (32 bytes)
                mstore8(add(offset, i), 0x33)
            }
        }

        return bytesTest;
    }
}

EDIT :

I'm adding an example relying on array literals where there is no length prefix and using bytes32.

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

contract TestAssembly {
    function test(uint8 _count) public pure returns (bytes32) {

        // Declares the byte32 array in memory : this is an array literal -> there is no length prefix
        bytes32[1] memory bytesTest = [bytes32(0)];

        // Protect against buffer overflow
        require(_count <= 32, "not enough bytes in the array");

        assembly {
            // Loop _count times over the array
            for { let i := 0} lt(i, _count) { i := add(i, 1) } { 
                // Make use of mstore8 (1 byte) instead of mstore (32 bytes)
                mstore8(add(bytesTest, i), 0x33)
            }
        }

        return bytesTest[0];
    }
}

Plus a third example not relying on solidity arrays but directly allocating / computing in memory through assembly.

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

contract TestAssembly {
    function test(uint8 _count) public pure returns (bytes32) {

        bytes32 result;

        // Protect against buffer overflow
        require(_count <= 32, "not enough bytes in the array");

        assembly {
            
            // Allocate 32 bytes from the free memory pointer
            let buffer := mload(0x40)

            // Increase the free memory pointer to account for our buffer
            mstore(0x40, add(buffer, 0x20))

            // Loop _count times over the array
            for { let i := 0} lt(i, _count) { i := add(i, 1) } { 
                // Make use of mstore8 (1 byte) instead of mstore (32 bytes)
                mstore8(add(buffer, i), 0x33)
            }

            result := mload(buffer)

            // Decrease the free memory pointer to account for our buffer
            mstore(0x40, sub(buffer, 0x20))
        }

        return result;
    }
}

Solidity Assembly – Troubleshooting Right Shift Not Working in Inline Assembly

Always double-check the documentation.

shr(x, y) logical shift right y by x bits

With your notation, you are effectively shifting 1 by x bits to the right. For any non-zero value, the result will be zero.

You probably meant to write :

function rightShift(uint256 x) public pure returns (uint256 result) {
   assembly {
      result := shr(1,x)
   }
}

Best Answer

Related Solutions

Assembly – Techniques for Manipulating Individual Bytes

Solidity Assembly – Troubleshooting Right Shift Not Working in Inline Assembly

Related Topic