结构&拷贝与引用

结构&拷贝与引用
2023-5-10 08:3:16 Author: ChaMd5安全团队(查看原文) 阅读量:14 收藏

开始之前，我们约定数据块也叫插槽，也就是storage。

storage是永久存储在区块链上的地方。如果你想操作storage中的数据，你可以将它复制到内存中。然后，所有内存代码都在堆栈上执行。Stack 的最大深度为 1024 个元素，支持 256 位的字长。

结构

当定义局部变量时，它存储在内存中，然后压入堆栈以执行。

1024栈深

简介

EVM不是寄存器机而是堆栈机，所以所有的计算都在称为堆栈的数据区域上进行。
在函数调用过程中

调用合约内部的函数不会增加层数，每一个外部调用（call, callcode, delegatecall, staticcall）都有自己的stack，用来存储参数、返回值和局部变量等。即如果一个调用A拥有自己的stack_A，如果再进行外部调用B，则会新起一个stack_B
每一个局部变量都会占据一级，比如局部变量是bytes1，并不会将32个bytes1拼凑在一起占用一个slot而占据一级
合约无法使用与查看call stack，合约只知道mg.sender和tx.origin，合约无法知道中间是否还有其他合约调用。但是我们在remix的debug中可以看到call调用其他合约的堆栈和内存，这是remix自己搞的功能，它可以访问所有的内容，然而EVM本身是没有这个功能的。想要看到中间调用了哪些外部合约，要进行contract trace。
调用链越深，你需要的插槽就越多，如果你走得太深，你最终会用超1024个插槽，然后报错。通常 1024 个就足够了，除非出现无限递归或者循环过多
stack 也叫execution stack，它会执行一系列操作码和运算，其数据来自memory
假如合约A调用自身的方法b()，stack 不会增加级数。用户B调用b()，会增加。合约A调用其他合约的函数，会增加。
用来存放变量、引用、方法或是方法返回值，用来存储函数内存中的数据。
它不做任何运算，只保存临时数据
memory
stack

设计原因

具有固定大小使得 EVM 的整体模型更加简单且易于实现
如果它非常大，那么执行合约会更昂贵（即需要更多内存）。1024 是一个非常保守的值，以尽可能安全
EVM 的设计方式往往会使更大的堆栈变得无用。EVM 只能访问堆栈中前16个slot。因此，即使您有一个 4096 slot的的堆栈，也只能够访问前16个，除非你不断pop，才可以访问到下面更深层次的内容

访问限制

对stack的访问仅限于顶端：

可以将最顶端的前 16 个元素之一复制到堆栈的顶部：

操作码【PUSH n】，将第n个slot的内容放入堆栈中，n从 1 到 16
操作码【DUP n】，复制第n 个堆栈项，n从 1 到16

可以将最顶端的元素与前 16 个元素之一交换

操作码【SWAP n】，交换第 1 个和第n 个堆栈项，其中 n从 1 到 16

其他的操作就是正常的stack操作：取栈顶的元素，计算，压回栈顶

正常的pop和push操作

注意：只可以访问前16个元素：状态变量可以无限个，但是局部变量最多16个，局部变量存储在堆栈中，下面是一个例子：

contract stackExample {
    function test() public{
        bytes1 a1 = "0";
        bytes1 a2 = "0";
        bytes1 a3 = "0";
        bytes1 a4 = "0";
        bytes1 a5 = "0";
        bytes1 a6 = "0";
        bytes1 a7 = "0";
        bytes1 a8 = "0";
        bytes1 a9 = "0";
        bytes1 a10 = "0";
        bytes1 a11 = "0";
        bytes1 a12 = "0";
        bytes1 a13 = "0";
        bytes1 a14 = "0";
        bytes1 a15 = "0";
        bytes1 a16 = "0";
        bytes1 a17 = "0";
    }
}

报错内容：

报错内容如下：
from solidity:
aaa.sol:6:9: CompilerError: Stack too deep, try removing local variables.
        uint256 a1 = 0;
        ^--------^
【去掉任何一个变量则不报错，因为局部变量最多16个】

2023/24/27更新

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract stackExample {
    function test() public returns (uint256){
        uint256 a1 = 0;
        uint256 a2 = 0;
        uint256 a3 = 0;
        uint256 a4 = 0;
        uint256 a5 = 0;
        uint256 a6 = 0;
        uint256 a7 = 0;
        uint256 a8 = 0;
        uint256 a9 = 0;
        uint256 a10 = 0;
        uint256 a11 = 0;
        uint256 a12 = 0;
        uint256 a13 = 0;
        uint256 a14 = 0;
        uint256 a15 = 0;
        uint256 a16 = 0;
        uint256 a17 = 0;
        uint256 a18 = 0;
        return a18;
    }
}
//上述合约无法通过编译// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract stackExample {
    function test() public returns (uint256){
        uint256 a1 = 0;
        uint256 a2 = 0;
        uint256 a3 = 0;
        uint256 a4 = 0;
        uint256 a5 = 0;
        uint256 a6 = 0;
        uint256 a7 = 0;
        uint256 a8 = 0;
        {uint256 a9 = 0;
        uint256 a10 = 0;
        uint256 a11 = 0;
        uint256 a12 = 0;
        uint256 a13 = 0;
        uint256 a14 = 0;
        uint256 a15 = 0;}
        uint256 a16 = 0;
        uint256 a17 = 0;
        uint256 a18 = 0;
        return a18;
    }
}
//上述合约可以通过编译
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract stackExample {
    function test() public{
        uint256 a1 = 0;
        uint256 a2 = 0;
        uint256 a3 = 0;
        uint256 a4 = 0;
        uint256 a5 = 0;
        uint256 a6 = 0;
        uint256 a7 = 0;
        uint256 a8 = 0;
        uint256 a9 = 0;
        uint256 a10 = 0;
        uint256 a11 = 0;
        uint256 a12 = 0;
        uint256 a13 = 0;
        uint256 a14 = 0;
        uint256 a15 = 0;
        uint256 a16 = 0;
        uint256 a17 = 0;
        uint256 a18 = 0;
    }
}
//上述合约可以通过编译

拷贝与引用

特点

数据类型

值类型
引用类型
成员变量storage
局部变量

局部变量的location

memory
calldata
storage：指向storage

消息调用的有效载荷叫做calldata，和location的calldata不是同一个意思！
消息调用message的calldata，即有效载荷的部分。message不能被修改，因此location的calldata是只读的。calldata的数据块不能被值拷贝，但是可以进行引用拷贝。也就是说，calldata这个area的数据只能引用message中的数据，或者两个calldata之间相互引用。
任何一个成员变量永远都只会指向属于自己的数据块(插槽)，是一对一的关系，不存在一对多、多对一、多对多的情况，如图：

图示与算法

代码演示

pragma solidity ^0.8.0;contract MemberVatiable{
	int256[] data1;
	int256[] data2;
		function getData1() public view returns(int256 memory){
		return data1;
	} 
		function getData2() public view returns(uint256 memory){
		return data2;
	}
		function insertData1(int256 d) public{
		return data1.push(d);
	}
		function insertData2(int256 d) public{
		return data2.push(d);
	}
		//1.成员变量都是存放在storage
	//2.storage存储位置的变量之间赋值的时候是值拷贝
	function setData2ToData1() public{
		data1 = data2;//成员变量相互赋值
	}
		//成员变量本质上就是插槽，storage layout
	function refAndState_1() public{
		int256p[] storage dataref = data1;//data1和dataref指向同一个数据块(插槽)
		//下面这条语句是引用赋值: data2和dataref指向同一个数据块(插槽)
		dataref = data2;
	}
		//成员变量本质上就是插槽，storage layout
	function refAndState_2() public{
		int256p[] storage dataref = data2;//data2和dataref指向同一个数据块(插槽)
		//下面这条语句是值拷贝
		data1 = dataref;
	}
		function calldata_ref_right(string calldata name) public{
		string calldata temp = name;//引用拷贝
		name = temp;
	}
    function calldata_copy_wrong(string calldata name) public {
        //calldata不能成为值拷贝目标
        //以下内容报错
        //string memory temp = name;//值拷贝
        //name = temp;
                //报错内容：Type string memory is not implicitly convertible to expected type string calldata.
    }
		function valueCopy() public{//值类型的数据之间赋值: 只能是值拷贝
		uint v1 = 1;
		uint v2 = 2;
		v1 = v2;
	}
		function refCopy() public{//引用类型的数据之间赋值：
			//定义一个引用变量，必须指明他的location，否则报错，例如
        //string x;  ===>  这会报错，应该这么写
        string memory x;//或string calldata x;或string storage x;
        //假如location写成calldata，那么这个变量x就是指向消息调用calldata的一部分calldata
        //注意：location的calldata指的是数据类型的，而消息调用的数据叫做calldata，两者不同
	}
		function x_1() public{
		data1 = data2;//值拷贝
	}
		function x_2() public{
		int256[] memory temp = new int256[](6);
		data1 = temp;//值拷贝
	}
		function x_3() public{
		int256[] memory temp = new int256[](6);
		temp1 = data2;//值拷贝
	}
		function x_4() public{
		int256[] storage temp = data1;
		temp = data2;//引用拷贝
	}
	}

例子1

初始状态下，调用insertData1()和insertData2()向data1和data2插入两个数据，结果：getData1()返回[1,1]，getData2()返回[2,2]
调用setData2ToData1()，结果：getData1()返回[2,2]，getData2()返回[2,2]
调用insertData1()向data1插入数据1
结果：getData1()返回[2,2,1]，getData2()返回[2,2]
调用insertData2()向data2插入数据2
结果：getData1()返回[2,2,1]，getData2()返回[2,2，2]
结论：storage存储位置的变量之间赋值的时候是值拷贝

例子2

初始状态下，调用insertData1()和insertData2()向data1和data2插入两个数据，结果：getData1()返回[1,1]，getData2()返回[2,2]
调用refAndState_2()，结果：getData1()返回[2,2]，getData2()返回[2,2]

招新小广告

ChaMd5 Venom 招收大佬入圈

新成立组IOT+工控+样本分析长期招新

欢迎联系[email protected]

文章来源: http://mp.weixin.qq.com/s?__biz=MzIzMTc1MjExOQ==&mid=2247508764&idx=1&sn=bc79ec8e82f9d7de14f17ddac110ad78&chksm=e89d8bc4dfea02d2b0f004aace3f1d8f9913d24c598461699722f914f4b3f56362da83fe1491#rd
如有侵权请联系:admin#unsafe.sh