Merge pull request #9447 from ethereum/inlineArrays

[Sol->Yul] Implement inline arrays.

libsolidity/codegen/YulUtilFunctions.cpp

@@ -1620,26 +1620,45 @@ string YulUtilFunctions::zeroComplexMemoryArrayFunction(ArrayType const& _type)
 	});
 }
 
+string YulUtilFunctions::allocateMemoryArrayFunction(ArrayType const& _type)
+{
+	string functionName = "allocate_memory_array_" + _type.identifier();
+	return m_functionCollector.createFunction(functionName, [&]() {
+		return Whiskers(R"(
+				function <functionName>(length) -> memPtr {
+					let allocSize := <allocSize>(length)
+					memPtr := <alloc>(allocSize)
+					<?dynamic>
+					mstore(memPtr, length)
+					</dynamic>
+				}
+			)")
+			("functionName", functionName)
+			("alloc", allocationFunction())
+			("allocSize", arrayAllocationSizeFunction(_type))
+			("dynamic", _type.isDynamicallySized())
+			.render();
+	});
+}
+
 string YulUtilFunctions::allocateAndInitializeMemoryArrayFunction(ArrayType const& _type)
 {
 	string functionName = "allocate_and_zero_memory_array_" + _type.identifier();
 	return m_functionCollector.createFunction(functionName, [&]() {
 		return Whiskers(R"(
 				function <functionName>(length) -> memPtr {
-					let allocSize := <allocSize>(length)
-					memPtr := <alloc>(allocSize)
+					memPtr := <allocArray>(length)
 					let dataStart := memPtr
-					let dataSize := allocSize
+					let dataSize := <allocSize>(length)
 					<?dynamic>
 					dataStart := add(dataStart, 32)
 					dataSize := sub(dataSize, 32)
-					mstore(memPtr, length)
 					</dynamic>
 					<zeroArrayFunction>(dataStart, dataSize)
 				}
 			)")
 			("functionName", functionName)
-			("alloc", allocationFunction())
+			("allocArray", allocateMemoryArrayFunction(_type))
 			("allocSize", arrayAllocationSizeFunction(_type))
 			("zeroArrayFunction", zeroMemoryArrayFunction(_type))
 			("dynamic", _type.isDynamicallySized())

libsolidity/codegen/YulUtilFunctions.h

@@ -282,6 +282,12 @@ public:
 	/// signature: (dataStart, dataSizeInBytes) ->
 	std::string zeroComplexMemoryArrayFunction(ArrayType const& _type);
 
+	/// @returns the name of a function that allocates a memory array.
+	/// For dynamic arrays it adds space for length and stores it.
+	/// The contents of the data area are unspecified.
+	/// signature: (length) -> memPtr
+	std::string allocateMemoryArrayFunction(ArrayType const& _type);
+
 	/// @returns the name of a function that allocates and zeroes a memory array.
 	/// For dynamic arrays it adds space for length and stores it.
 	/// signature: (length) -> memPtr

libsolidity/codegen/ir/IRGeneratorForStatements.cpp

@@ -311,7 +311,31 @@ bool IRGeneratorForStatements::visit(Assignment const& _assignment)
 bool IRGeneratorForStatements::visit(TupleExpression const& _tuple)
 {
 	if (_tuple.isInlineArray())
-		solUnimplementedAssert(false, "");
+	{
+		auto const& arrayType = dynamic_cast<ArrayType const&>(*_tuple.annotation().type);
+		solAssert(!arrayType.isDynamicallySized(), "Cannot create dynamically sized inline array.");
+		define(_tuple) <<
+			m_utils.allocateMemoryArrayFunction(arrayType) <<
+			"(" <<
+			_tuple.components().size() <<
+			")\n";
+
+		string mpos = IRVariable(_tuple).part("mpos").name();
+		Type const& baseType = *arrayType.baseType();
+		for (size_t i = 0; i < _tuple.components().size(); i++)
+		{
+			Expression const& component = *_tuple.components()[i];
+			component.accept(*this);
+			IRVariable converted = convert(component, baseType);
+			m_code <<
+				m_utils.writeToMemoryFunction(baseType) <<
+				"(" <<
+				("add(" + mpos + ", " + to_string(i * arrayType.memoryStride()) + ")") <<
+				", " <<
+				converted.name() <<
+				")\n";
+		}
+	}
 	else
 	{
 		bool willBeWrittenTo = _tuple.annotation().willBeWrittenTo;

test/libsolidity/semanticTests/array/inline_array_index_access_ints.sol

@@ -4,5 +4,7 @@ contract C {
     }
 }
 
+// ====
+// compileViaYul: also
 // ----
 // f() -> 3

test/libsolidity/semanticTests/array/inline_array_singleton.sol

@@ -4,6 +4,7 @@ contract C {
         return [4][0];
     }
 }
-
+// ====
+// compileViaYul: also
 // ----
 // f() -> 4

test/libsolidity/semanticTests/array/inline_array_storage_to_memory_conversion_ints.sol

@@ -7,5 +7,7 @@ contract C {
     }
 }
 
+// ====
+// compileViaYul: also
 // ----
 // f() -> 3, 6

test/libsolidity/semanticTests/calldata/calldata_array_dynamic_bytes.sol

@@ -66,6 +66,8 @@ contract C {
 // found expectation comments:
 // same offset for both arrays @ ABI_CHECK(
 
+// ====
+// compileViaYul: false
 // ----
 // f1(bytes[1]): 0x20, 0x20, 0x3, hex"0102030000000000000000000000000000000000000000000000000000000000" -> 0x3, 0x1, 0x2, 0x3
 // f2(bytes[1],bytes[1]): 0x40, 0xa0, 0x20, 0x3, hex"0102030000000000000000000000000000000000000000000000000000000000", 0x20, 0x2, hex"0102000000000000000000000000000000000000000000000000000000000000" -> 0x3, 0x1, 0x2, 0x3, 0x2, 0x1, 0x2

test/libsolidity/semanticTests/isoltestFormatting.sol

@@ -8,6 +8,8 @@ contract C {
         return a;
     }
 }
+// ====
+// compileViaYul: also
 // ----
 // f() -> 4, 11, 0x0111, 0x333333, 2222222222222222222
 // g() -> 0x10, 0x0100, 0x0101, 0x333333, 2222222222222222222

test/libsolidity/semanticTests/snark.sol

@@ -288,6 +288,7 @@ contract Test {
 /// testMul() -> true
 //
 // ====
+// compileViaYul: also
 // EVMVersion: >=constantinople
 // ----
 // library: Pairing

test/libsolidity/semanticTests/various/inline_tuple_with_rational_numbers.sol

@@ -5,5 +5,7 @@ contract c {
     }
 }
 
+// ====
+// compileViaYul: also
 // ----
 // f() -> 1