Merge remote-tracking branch 'origin/develop' into breaking

.circleci/config.yml

@@ -12,10 +12,10 @@ parameters:
     default: "4"
   ubuntu-2004-docker-image-rev:
     type: string
-    default: "1"
+    default: "2"
   ubuntu-2004-clang-docker-image-rev:
     type: string
-    default: "1"
+    default: "2"
   ubuntu-1604-clang-ossfuzz-docker-image-rev:
     type: string
     default: "2"

.circleci/docker/Dockerfile.ubuntu2004

@@ -26,6 +26,9 @@ FROM buildpack-deps:focal AS base
 ARG DEBIAN_FRONTEND=noninteractive
 
 RUN set -ex; \
+        dist=$(grep DISTRIB_CODENAME /etc/lsb-release | cut -d= -f2); \
+        echo "deb http://ppa.launchpad.net/ethereum/cpp-build-deps/ubuntu $dist main" >> /etc/apt/sources.list ; \
+        apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 1c52189c923f6ca9 ; \
 	apt-get update; \
 	apt-get install -qqy --no-install-recommends \
 		build-essential \
@@ -33,7 +36,7 @@ RUN set -ex; \
 		cmake ninja-build \
 		libboost-filesystem-dev libboost-test-dev libboost-system-dev \
 		libboost-program-options-dev \
-		libcvc4-dev z3 libz3-dev \
+		libcvc4-dev libz3-static-dev \
 		; \
 	apt-get install -qy python3-pip python3-sphinx; \
 	pip3 install codecov; \

.circleci/docker/Dockerfile.ubuntu2004.clang

@@ -26,6 +26,9 @@ FROM buildpack-deps:focal AS base
 ARG DEBIAN_FRONTEND=noninteractive
 
 RUN set -ex; \
+	dist=$(grep DISTRIB_CODENAME /etc/lsb-release | cut -d= -f2); \
+	echo "deb http://ppa.launchpad.net/ethereum/cpp-build-deps/ubuntu $dist main" >> /etc/apt/sources.list ; \
+	apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 1c52189c923f6ca9 ; \
 	apt-get update; \
 	apt-get install -qqy --no-install-recommends \
 		build-essential \
@@ -33,8 +36,8 @@ RUN set -ex; \
 		cmake ninja-build \
 		libboost-filesystem-dev libboost-test-dev libboost-system-dev \
 		libboost-program-options-dev \
-		clang llvm-dev \
+		clang \
-		z3 libz3-dev \
+		libz3-static-dev \
 		; \
 	rm -rf /var/lib/apt/lists/*
 

.circleci/osx_install_dependencies.sh

@@ -43,13 +43,13 @@ then
   ./scripts/install_obsolete_jsoncpp_1_7_4.sh
 
   # z3
-  wget https://github.com/Z3Prover/z3/releases/download/z3-4.8.7/z3-4.8.7-x64-osx-10.14.6.zip
+  wget https://github.com/Z3Prover/z3/releases/download/z3-4.8.8/z3-4.8.8-x64-osx-10.14.6.zip
-  unzip z3-4.8.7-x64-osx-10.14.6.zip
+  unzip z3-4.8.8-x64-osx-10.14.6.zip
-  rm -f z3-4.8.7-x64-osx-10.14.6.zip
+  rm -f z3-4.8.8-x64-osx-10.14.6.zip
-  cp z3-4.8.7-x64-osx-10.14.6/bin/libz3.a /usr/local/lib
+  cp z3-4.8.8-x64-osx-10.14.6/bin/libz3.a /usr/local/lib
-  cp z3-4.8.7-x64-osx-10.14.6/bin/z3 /usr/local/bin
+  cp z3-4.8.8-x64-osx-10.14.6/bin/z3 /usr/local/bin
-  cp z3-4.8.7-x64-osx-10.14.6/include/* /usr/local/include
+  cp z3-4.8.8-x64-osx-10.14.6/include/* /usr/local/include
-  rm -rf z3-4.8.7-x64-osx-10.14.6
+  rm -rf z3-4.8.8-x64-osx-10.14.6
 
   # evmone
   wget https://github.com/ethereum/evmone/releases/download/v0.4.0/evmone-0.4.0-darwin-x86_64.tar.gz

Changelog.md

@@ -14,6 +14,19 @@ Compiler Features:
 Bugfixes:
  * NatSpec: Constructors and functions have consistent userdoc output.
 
+
+### 0.6.9 (unreleased)
+
+Language Features:
+
+
+Compiler Features:
+
+
+Bugfixes:
+
+
+
 ### 0.6.8 (2020-05-14)
 
 Important Bugfixes:

libsolidity/analysis/NameAndTypeResolver.cpp

@@ -37,16 +37,13 @@ namespace solidity::frontend
 NameAndTypeResolver::NameAndTypeResolver(
 	GlobalContext& _globalContext,
 	langutil::EVMVersion _evmVersion,
-	map<ASTNode const*, shared_ptr<DeclarationContainer>>& _scopes,
 	ErrorReporter& _errorReporter
 ):
-	m_scopes(_scopes),
 	m_evmVersion(_evmVersion),
 	m_errorReporter(_errorReporter),
 	m_globalContext(_globalContext)
 {
-	if (!m_scopes[nullptr])
+	m_scopes[nullptr] = make_shared<DeclarationContainer>();
-		m_scopes[nullptr] = make_shared<DeclarationContainer>();
 	for (Declaration const* declaration: _globalContext.declarations())
 	{
 		solAssert(m_scopes[nullptr]->registerDeclaration(*declaration), "Unable to register global declaration.");

libsolidity/analysis/NameAndTypeResolver.h

@@ -56,7 +56,6 @@ public:
 	NameAndTypeResolver(
 		GlobalContext& _globalContext,
 		langutil::EVMVersion _evmVersion,
-		std::map<ASTNode const*, std::shared_ptr<DeclarationContainer>>& _scopes,
 		langutil::ErrorReporter& _errorReporter
 	);
 	/// Registers all declarations found in the AST node, usually a source unit.
@@ -123,7 +122,7 @@ private:
 	/// where nullptr denotes the global scope. Note that structs are not scope since they do
 	/// not contain code.
 	/// Aliases (for example `import "x" as y;`) create multiple pointers to the same scope.
-	std::map<ASTNode const*, std::shared_ptr<DeclarationContainer>>& m_scopes;
+	std::map<ASTNode const*, std::shared_ptr<DeclarationContainer>> m_scopes;
 
 	langutil::EVMVersion m_evmVersion;
 	DeclarationContainer* m_currentScope = nullptr;

libsolidity/codegen/YulUtilFunctions.cpp

@@ -1499,8 +1499,6 @@ string YulUtilFunctions::zeroComplexMemoryArrayFunction(ArrayType const& _type)
 
 string YulUtilFunctions::allocateAndInitializeMemoryArrayFunction(ArrayType const& _type)
 {
-	solUnimplementedAssert(!_type.isByteArray(), "");
-
 	string functionName = "allocate_and_zero_memory_array_" + _type.identifier();
 	return m_functionCollector.createFunction(functionName, [&]() {
 		return Whiskers(R"(

libsolidity/interface/CompilerStack.cpp

@@ -214,7 +214,6 @@ void CompilerStack::reset(bool _keepSettings)
 		m_metadataHash = MetadataHash::IPFS;
 	}
 	m_globalContext.reset();
-	m_scopes.clear();
 	m_sourceOrder.clear();
 	m_contracts.clear();
 	m_errorReporter.clear();
@@ -314,7 +313,8 @@ bool CompilerStack::analyze()
 				noErrors = false;
 
 		m_globalContext = make_shared<GlobalContext>();
-		NameAndTypeResolver resolver(*m_globalContext, m_evmVersion, m_scopes, m_errorReporter);
+		// We need to keep the same resolver during the whole process.
+		NameAndTypeResolver resolver(*m_globalContext, m_evmVersion, m_errorReporter);
 		for (Source const* source: m_sourceOrder)
 			if (source->ast && !resolver.registerDeclarations(*source->ast))
 				return false;

libsolidity/interface/CompilerStack.h

@@ -447,8 +447,6 @@ private:
 	std::map<util::h256, std::string> m_smtlib2Responses;
 	std::shared_ptr<GlobalContext> m_globalContext;
 	std::vector<Source const*> m_sourceOrder;
-	/// This is updated during compilation.
-	std::map<ASTNode const*, std::shared_ptr<DeclarationContainer>> m_scopes;
 	std::map<std::string const, Contract> m_contracts;
 	langutil::ErrorList m_errorList;
 	langutil::ErrorReporter m_errorReporter;

libsolutil/picosha2.h

@@ -1,7 +1,7 @@
 /*
 The MIT License (MIT)
 
-Copyright (C) 2014 okdshin
+Copyright (C) 2017 okdshin
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -21,268 +21,365 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 */
-#pragma once
+#ifndef PICOSHA2_H
+#define PICOSHA2_H
+// picosha2:20140213
+
+#ifndef PICOSHA2_BUFFER_SIZE_FOR_INPUT_ITERATOR
+#define PICOSHA2_BUFFER_SIZE_FOR_INPUT_ITERATOR \
+    1048576  //=1024*1024: default is 1MB memory
+#endif
 
-//picosha2:20140213
-#include <cstdint>
-#include <iostream>
-#include <vector>
-#include <iterator>
-#include <cassert>
-#include <sstream>
 #include <algorithm>
+#include <cassert>
+#include <iterator>
+#include <sstream>
+#include <vector>
+#include <fstream>
+namespace picosha2 {
+typedef unsigned long word_t;
+typedef unsigned char byte_t;
 
-namespace picosha2
+static const size_t k_digest_size = 32;
-{
 
-namespace detail
+namespace detail {
-{
+inline byte_t mask_8bit(byte_t x) { return x & 0xff; }
 
-inline uint8_t mask_8bit(uint8_t x)
+inline word_t mask_32bit(word_t x) { return x & 0xffffffff; }
-{
+
-	return x & 0xff;
+const word_t add_constant[64] = {
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
+    0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+    0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+    0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+    0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+    0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2};
+
+const word_t initial_message_digest[8] = {0x6a09e667, 0xbb67ae85, 0x3c6ef372,
+                                          0xa54ff53a, 0x510e527f, 0x9b05688c,
+                                          0x1f83d9ab, 0x5be0cd19};
+
+inline word_t ch(word_t x, word_t y, word_t z) { return (x & y) ^ ((~x) & z); }
+
+inline word_t maj(word_t x, word_t y, word_t z) {
+    return (x & y) ^ (x & z) ^ (y & z);
 }
 
-inline uint32_t mask_32bit(uint32_t x)
+inline word_t rotr(word_t x, std::size_t n) {
-{
+    assert(n < 32);
-	return x & 0xffffffff;
+    return mask_32bit((x >> n) | (x << (32 - n)));
 }
 
-static uint32_t const add_constant[64] = {
+inline word_t bsig0(word_t x) { return rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22); }
-	0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
+
-	0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+inline word_t bsig1(word_t x) { return rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25); }
-	0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+
-	0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+inline word_t shr(word_t x, std::size_t n) {
-	0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+    assert(n < 32);
-	0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    return x >> n;
-	0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+}
-	0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+
-	0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+inline word_t ssig0(word_t x) { return rotr(x, 7) ^ rotr(x, 18) ^ shr(x, 3); }
-	0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+
-	0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+inline word_t ssig1(word_t x) { return rotr(x, 17) ^ rotr(x, 19) ^ shr(x, 10); }
-	0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+
-	0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
+template <typename RaIter1, typename RaIter2>
-	0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+void hash256_block(RaIter1 message_digest, RaIter2 first, RaIter2 last) {
-	0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+    assert(first + 64 == last);
-	0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+    static_cast<void>(last);  // for avoiding unused-variable warning
+    word_t w[64];
+    std::fill(w, w + 64, 0);
+    for (std::size_t i = 0; i < 16; ++i) {
+        w[i] = (static_cast<word_t>(mask_8bit(*(first + i * 4))) << 24) |
+               (static_cast<word_t>(mask_8bit(*(first + i * 4 + 1))) << 16) |
+               (static_cast<word_t>(mask_8bit(*(first + i * 4 + 2))) << 8) |
+               (static_cast<word_t>(mask_8bit(*(first + i * 4 + 3))));
+    }
+    for (std::size_t i = 16; i < 64; ++i) {
+        w[i] = mask_32bit(ssig1(w[i - 2]) + w[i - 7] + ssig0(w[i - 15]) +
+                          w[i - 16]);
+    }
+
+    word_t a = *message_digest;
+    word_t b = *(message_digest + 1);
+    word_t c = *(message_digest + 2);
+    word_t d = *(message_digest + 3);
+    word_t e = *(message_digest + 4);
+    word_t f = *(message_digest + 5);
+    word_t g = *(message_digest + 6);
+    word_t h = *(message_digest + 7);
+
+    for (std::size_t i = 0; i < 64; ++i) {
+        word_t temp1 = h + bsig1(e) + ch(e, f, g) + add_constant[i] + w[i];
+        word_t temp2 = bsig0(a) + maj(a, b, c);
+        h = g;
+        g = f;
+        f = e;
+        e = mask_32bit(d + temp1);
+        d = c;
+        c = b;
+        b = a;
+        a = mask_32bit(temp1 + temp2);
+    }
+    *message_digest += a;
+    *(message_digest + 1) += b;
+    *(message_digest + 2) += c;
+    *(message_digest + 3) += d;
+    *(message_digest + 4) += e;
+    *(message_digest + 5) += f;
+    *(message_digest + 6) += g;
+    *(message_digest + 7) += h;
+    for (std::size_t i = 0; i < 8; ++i) {
+        *(message_digest + i) = mask_32bit(*(message_digest + i));
+    }
+}
+
+}  // namespace detail
+
+template <typename InIter>
+void output_hex(InIter first, InIter last, std::ostream& os) {
+    os.setf(std::ios::hex, std::ios::basefield);
+    while (first != last) {
+        os.width(2);
+        os.fill('0');
+        os << static_cast<unsigned int>(*first);
+        ++first;
+    }
+    os.setf(std::ios::dec, std::ios::basefield);
+}
+
+template <typename InIter>
+void bytes_to_hex_string(InIter first, InIter last, std::string& hex_str) {
+    std::ostringstream oss;
+    output_hex(first, last, oss);
+    hex_str.assign(oss.str());
+}
+
+template <typename InContainer>
+void bytes_to_hex_string(const InContainer& bytes, std::string& hex_str) {
+    bytes_to_hex_string(bytes.begin(), bytes.end(), hex_str);
+}
+
+template <typename InIter>
+std::string bytes_to_hex_string(InIter first, InIter last) {
+    std::string hex_str;
+    bytes_to_hex_string(first, last, hex_str);
+    return hex_str;
+}
+
+template <typename InContainer>
+std::string bytes_to_hex_string(const InContainer& bytes) {
+    std::string hex_str;
+    bytes_to_hex_string(bytes, hex_str);
+    return hex_str;
+}
+
+class hash256_one_by_one {
+   public:
+    hash256_one_by_one() { init(); }
+
+    void init() {
+        buffer_.clear();
+        std::fill(data_length_digits_, data_length_digits_ + 4, 0);
+        std::copy(detail::initial_message_digest,
+                  detail::initial_message_digest + 8, h_);
+    }
+
+    template <typename RaIter>
+    void process(RaIter first, RaIter last) {
+        add_to_data_length(static_cast<word_t>(std::distance(first, last)));
+        std::copy(first, last, std::back_inserter(buffer_));
+        std::size_t i = 0;
+        for (; i + 64 <= buffer_.size(); i += 64) {
+            detail::hash256_block(h_, buffer_.begin() + i,
+                                  buffer_.begin() + i + 64);
+        }
+        buffer_.erase(buffer_.begin(), buffer_.begin() + i);
+    }
+
+    void finish() {
+        byte_t temp[64];
+        std::fill(temp, temp + 64, 0);
+        std::size_t remains = buffer_.size();
+        std::copy(buffer_.begin(), buffer_.end(), temp);
+        temp[remains] = 0x80;
+
+        if (remains > 55) {
+            std::fill(temp + remains + 1, temp + 64, 0);
+            detail::hash256_block(h_, temp, temp + 64);
+            std::fill(temp, temp + 64 - 4, 0);
+        } else {
+            std::fill(temp + remains + 1, temp + 64 - 4, 0);
+        }
+
+        write_data_bit_length(&(temp[56]));
+        detail::hash256_block(h_, temp, temp + 64);
+    }
+
+    template <typename OutIter>
+    void get_hash_bytes(OutIter first, OutIter last) const {
+        for (const word_t* iter = h_; iter != h_ + 8; ++iter) {
+            for (std::size_t i = 0; i < 4 && first != last; ++i) {
+                *(first++) = detail::mask_8bit(
+                    static_cast<byte_t>((*iter >> (24 - 8 * i))));
+            }
+        }
+    }
+
+   private:
+    void add_to_data_length(word_t n) {
+        word_t carry = 0;
+        data_length_digits_[0] += n;
+        for (std::size_t i = 0; i < 4; ++i) {
+            data_length_digits_[i] += carry;
+            if (data_length_digits_[i] >= 65536u) {
+                carry = data_length_digits_[i] >> 16;
+                data_length_digits_[i] &= 65535u;
+            } else {
+                break;
+            }
+        }
+    }
+    void write_data_bit_length(byte_t* begin) {
+        word_t data_bit_length_digits[4];
+        std::copy(data_length_digits_, data_length_digits_ + 4,
+                  data_bit_length_digits);
+
+        // convert byte length to bit length (multiply 8 or shift 3 times left)
+        word_t carry = 0;
+        for (std::size_t i = 0; i < 4; ++i) {
+            word_t before_val = data_bit_length_digits[i];
+            data_bit_length_digits[i] <<= 3;
+            data_bit_length_digits[i] |= carry;
+            data_bit_length_digits[i] &= 65535u;
+            carry = (before_val >> (16 - 3)) & 65535u;
+        }
+
+        // write data_bit_length
+        for (int i = 3; i >= 0; --i) {
+            (*begin++) = static_cast<byte_t>(data_bit_length_digits[i] >> 8);
+            (*begin++) = static_cast<byte_t>(data_bit_length_digits[i]);
+        }
+    }
+    std::vector<byte_t> buffer_;
+    word_t data_length_digits_[4];  // as 64bit integer (16bit x 4 integer)
+    word_t h_[8];
 };
 
-static uint32_t const initial_message_digest[8] = {
+inline void get_hash_hex_string(const hash256_one_by_one& hasher,
-	0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+                                std::string& hex_str) {
-	0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+    byte_t hash[k_digest_size];
-};
+    hasher.get_hash_bytes(hash, hash + k_digest_size);
-
+    return bytes_to_hex_string(hash, hash + k_digest_size, hex_str);
-inline uint32_t ch(uint32_t x, uint32_t y, uint32_t z)
-{
-	return (x & y) ^ ((~x) & z);
 }
 
-inline uint32_t maj(uint32_t x, uint32_t y, uint32_t z)
+inline std::string get_hash_hex_string(const hash256_one_by_one& hasher) {
-{
+    std::string hex_str;
-	return (x & y) ^ (x & z) ^ (y & z);
+    get_hash_hex_string(hasher, hex_str);
+    return hex_str;
 }
 
-inline uint32_t rotr(uint32_t x, std::size_t n)
+namespace impl {
-{
+template <typename RaIter, typename OutIter>
-	assert(n < 32);
+void hash256_impl(RaIter first, RaIter last, OutIter first2, OutIter last2, int,
-	return mask_32bit((x >> n) | (x << (32 - n)));
+                  std::random_access_iterator_tag) {
+    hash256_one_by_one hasher;
+    // hasher.init();
+    hasher.process(first, last);
+    hasher.finish();
+    hasher.get_hash_bytes(first2, last2);
 }
 
-inline uint32_t bsig0(uint32_t x)
+template <typename InputIter, typename OutIter>
-{
+void hash256_impl(InputIter first, InputIter last, OutIter first2,
-	return rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22);
+                  OutIter last2, int buffer_size, std::input_iterator_tag) {
+    std::vector<byte_t> buffer(buffer_size);
+    hash256_one_by_one hasher;
+    // hasher.init();
+    while (first != last) {
+        int size = buffer_size;
+        for (int i = 0; i != buffer_size; ++i, ++first) {
+            if (first == last) {
+                size = i;
+                break;
+            }
+            buffer[i] = *first;
+        }
+        hasher.process(buffer.begin(), buffer.begin() + size);
+    }
+    hasher.finish();
+    hasher.get_hash_bytes(first2, last2);
+}
 }
 
-inline uint32_t bsig1(uint32_t x)
+template <typename InIter, typename OutIter>
-{
+void hash256(InIter first, InIter last, OutIter first2, OutIter last2,
-	return rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25);
+             int buffer_size = PICOSHA2_BUFFER_SIZE_FOR_INPUT_ITERATOR) {
+    picosha2::impl::hash256_impl(
+        first, last, first2, last2, buffer_size,
+        typename std::iterator_traits<InIter>::iterator_category());
 }
 
-inline uint32_t shr(uint32_t x, std::size_t n)
+template <typename InIter, typename OutContainer>
-{
+void hash256(InIter first, InIter last, OutContainer& dst) {
-	assert(n < 32);
+    hash256(first, last, dst.begin(), dst.end());
-	return x >> n;
 }
 
-inline uint32_t ssig0(uint32_t x)
+template <typename InContainer, typename OutIter>
-{
+void hash256(const InContainer& src, OutIter first, OutIter last) {
-	return rotr(x, 7) ^ rotr(x, 18) ^ shr(x, 3);
+    hash256(src.begin(), src.end(), first, last);
 }
 
-inline uint32_t ssig1(uint32_t x)
+template <typename InContainer, typename OutContainer>
-{
+void hash256(const InContainer& src, OutContainer& dst) {
-	return rotr(x, 17) ^ rotr(x, 19) ^ shr(x, 10);
+    hash256(src.begin(), src.end(), dst.begin(), dst.end());
 }
 
-template<typename RaIter1, typename RaIter2>
+template <typename InIter>
-void hash256_block(RaIter1 message_digest, RaIter2 first, RaIter2 last)
+void hash256_hex_string(InIter first, InIter last, std::string& hex_str) {
-{
+    byte_t hashed[k_digest_size];
-	(void)last; // FIXME: check this is valid
+    hash256(first, last, hashed, hashed + k_digest_size);
-	uint32_t w[64];
+    std::ostringstream oss;
-	std::fill(w, w+64, 0);
+    output_hex(hashed, hashed + k_digest_size, oss);
-	for (std::size_t i = 0; i < 16; ++i)
+    hex_str.assign(oss.str());
-		w[i] = (static_cast<uint32_t>(mask_8bit(*(first + i * 4))) << 24)
-			| (static_cast<uint32_t>(mask_8bit(*(first + i * 4 + 1))) << 16)
-			| (static_cast<uint32_t>(mask_8bit(*(first + i * 4 + 2))) << 8)
-			| (static_cast<uint32_t>(mask_8bit(*(first + i * 4 + 3))));
-	for (std::size_t i = 16; i < 64; ++i)
-		w[i] = mask_32bit(ssig1(w[i-2])+w[i-7]+ssig0(w[i-15])+w[i-16]);
-
-	uint32_t a = *message_digest;
-	uint32_t b = *(message_digest + 1);
-	uint32_t c = *(message_digest + 2);
-	uint32_t d = *(message_digest + 3);
-	uint32_t e = *(message_digest + 4);
-	uint32_t f = *(message_digest + 5);
-	uint32_t g = *(message_digest + 6);
-	uint32_t h = *(message_digest + 7);
-
-	for (std::size_t i = 0; i < 64; ++i)
-	{
-		uint32_t temp1 = h+bsig1(e)+ch(e,f,g)+add_constant[i]+w[i];
-		uint32_t temp2 = bsig0(a)+maj(a,b,c);
-		h = g;
-		g = f;
-		f = e;
-		e = mask_32bit(d+temp1);
-		d = c;
-		c = b;
-		b = a;
-		a = mask_32bit(temp1+temp2);
-	}
-	*message_digest += a;
-	*(message_digest+1) += b;
-	*(message_digest+2) += c;
-	*(message_digest+3) += d;
-	*(message_digest+4) += e;
-	*(message_digest+5) += f;
-	*(message_digest+6) += g;
-	*(message_digest+7) += h;
-	for (std::size_t i = 0; i < 8; ++i)
-		*(message_digest+i) = mask_32bit(*(message_digest+i));
-}
-
-}//namespace detail
-
-class hash256_one_by_one
-{
-public:
-	hash256_one_by_one()
-	{
-		init();
-	}
-
-	void init()
-	{
-		buffer_.clear();
-		std::fill(data_length_digits_, data_length_digits_ + 4, 0);
-		std::copy(detail::initial_message_digest, detail::initial_message_digest+8, h_);
-	}
-
-	template<typename RaIter>
-	void process(RaIter first, RaIter last)
-	{
-		add_to_data_length(std::distance(first, last));
-		std::copy(first, last, std::back_inserter(buffer_));
-		std::size_t i = 0;
-		for (;i + 64 <= buffer_.size(); i+=64)
-			detail::hash256_block(h_, buffer_.begin()+i, buffer_.begin()+i+64);
-		buffer_.erase(buffer_.begin(), buffer_.begin()+i);
-	}
-
-	void finish()
-	{
-		uint8_t temp[64];
-		std::fill(temp, temp+64, 0);
-		std::size_t remains = buffer_.size();
-		std::copy(buffer_.begin(), buffer_.end(), temp);
-		temp[remains] = 0x80;
-
-		if (remains > 55)
-		{
-			std::fill(temp+remains+1, temp+64, 0);
-			detail::hash256_block(h_, temp, temp+64);
-			std::fill(temp, temp+64-4, 0);
-		}
-		else
-			std::fill(temp+remains+1, temp+64-4, 0);
-
-		write_data_bit_length(&(temp[56]));
-		detail::hash256_block(h_, temp, temp+64);
-	}
-
-	template<typename OutIter>
-	void get_hash_bytes(OutIter first, OutIter last) const
-	{
-		for (uint32_t const* iter = h_; iter != h_ + 8; ++iter)
-			for (std::size_t i = 0; i < 4 && first != last; ++i)
-				*(first++) = detail::mask_8bit(static_cast<uint8_t>(*iter >> (24 - 8 * i)));
-	}
-
-private:
-	void add_to_data_length(uint32_t n)
-	{
-		uint32_t carry = 0;
-		data_length_digits_[0] += n;
-		for (std::size_t i = 0; i < 4; ++i)
-		{
-			data_length_digits_[i] += carry;
-			if (data_length_digits_[i] >= 65536u)
-			{
-				carry = data_length_digits_[i] >> 16;
-				data_length_digits_[i] &= 65535u;
-			}
-			else
-				break;
-		}
-	}
-	void write_data_bit_length(uint8_t* begin)
-	{
-		uint32_t data_bit_length_digits[4];
-		std::copy(
-			data_length_digits_, data_length_digits_ + 4,
-			data_bit_length_digits
-		);
-
-		// convert byte length to bit length (multiply 8 or shift 3 times left)
-		uint32_t carry = 0;
-		for (std::size_t i = 0; i < 4; ++i)
-		{
-			uint32_t before_val = data_bit_length_digits[i];
-			data_bit_length_digits[i] <<= 3;
-			data_bit_length_digits[i] |= carry;
-			data_bit_length_digits[i] &= 65535u;
-			carry = (before_val >> (16-3)) & 65535u;
-		}
-
-		// write data_bit_length
-		for (int i = 3; i >= 0; --i)
-		{
-			(*begin++) = static_cast<uint8_t>(data_bit_length_digits[i] >> 8);
-			(*begin++) = static_cast<uint8_t>(data_bit_length_digits[i]);
-		}
-	}
-	std::vector<uint8_t> buffer_;
-	uint32_t data_length_digits_[4]; //as 64bit integer (16bit x 4 integer)
-	uint32_t h_[8];
-};
-
-template<typename RaIter, typename OutIter>
-void hash256(RaIter first, RaIter last, OutIter first2, OutIter last2)
-{
-	hash256_one_by_one hasher;
-	//hasher.init();
-	hasher.process(first, last);
-	hasher.finish();
-	hasher.get_hash_bytes(first2, last2);
 }
 
 template <typename RaContainer>
 std::vector<uint8_t> hash256(RaContainer const& _src)
 {
-	std::vector<uint8_t> ret(32);
+       std::vector<uint8_t> ret(32);
-	hash256(_src.begin(), _src.end(), ret.begin(), ret.end());
+       hash256(_src.begin(), _src.end(), ret.begin(), ret.end());
-	return ret;
+       return ret;
 }
 
-}//namespace picosha2
+template <typename InIter>
+std::string hash256_hex_string(InIter first, InIter last) {
+    std::string hex_str;
+    hash256_hex_string(first, last, hex_str);
+    return hex_str;
+}
+
+inline void hash256_hex_string(const std::string& src, std::string& hex_str) {
+    hash256_hex_string(src.begin(), src.end(), hex_str);
+}
+
+template <typename InContainer>
+void hash256_hex_string(const InContainer& src, std::string& hex_str) {
+    hash256_hex_string(src.begin(), src.end(), hex_str);
+}
+
+template <typename InContainer>
+std::string hash256_hex_string(const InContainer& src) {
+    return hash256_hex_string(src.begin(), src.end());
+}
+template<typename OutIter>void hash256(std::ifstream& f, OutIter first, OutIter last){
+    hash256(std::istreambuf_iterator<char>(f), std::istreambuf_iterator<char>(), first,last);
+
+}
+}// namespace picosha2
+#endif  // PICOSHA2_H

scripts/check_style.sh

@@ -15,18 +15,25 @@ then
 	exit 1
 fi
 
+function preparedGrep()
+{
+	git grep -nIE "$1" -- '*.h' '*.cpp' | grep -v "picosha2.h"
+	return $?
+}
+
+
 FORMATERROR=$(
 (
-	git grep -nIE "#include \"" -- '*.h' '*.cpp' | egrep -v -e "license.h" -e "BuildInfo.h"  # Use include with <> characters
+	preparedGrep "#include \"" | egrep -v -e "license.h" -e "BuildInfo.h"  # Use include with <> characters
-	git grep -nIE "\<(if|for|while|switch)\(" -- '*.h' '*.cpp' # no space after "if", "for", "while" or "switch"
+	preparedGrep "\<(if|for|while|switch)\(" # no space after "if", "for", "while" or "switch"
-	git grep -nIE "\<for\>\s*\([^=]*\>\s:\s.*\)" -- '*.h' '*.cpp' # no space before range based for-loop
+	preparedGrep "\<for\>\s*\([^=]*\>\s:\s.*\)" # no space before range based for-loop
-	git grep -nIE "\<if\>\s*\(.*\)\s*\{\s*$" -- '*.h' '*.cpp' # "{\n" on same line as "if" / "for"
+	preparedGrep "\<if\>\s*\(.*\)\s*\{\s*$" # "{\n" on same line as "if" / "for"
-	git grep -nIE "[,\(<]\s*const " -- '*.h' '*.cpp' # const on left side of type
+	preparedGrep "[,\(<]\s*const " # const on left side of type
-	git grep -nIE "^\s*(static)?\s*const " -- '*.h' '*.cpp' # const on left side of type (beginning of line)
+	preparedGrep "^\s*(static)?\s*const " # const on left side of type (beginning of line)
-	git grep -nIE "^ [^*]|[^*] 	|	 [^*]" -- '*.h' '*.cpp' # uses spaces for indentation or mixes spaces and tabs
+	preparedGrep "^ [^*]|[^*] 	|	 [^*]" # uses spaces for indentation or mixes spaces and tabs
-	git grep -nIE "[a-zA-Z0-9_]\s*[&][a-zA-Z_]" -- '*.h' '*.cpp' | egrep -v "return [&]" # right-aligned reference ampersand (needs to exclude return)
+	preparedGrep "[a-zA-Z0-9_]\s*[&][a-zA-Z_]" | egrep -v "return [&]" # right-aligned reference ampersand (needs to exclude return)
 	# right-aligned reference pointer star (needs to exclude return and comments)
-	git grep -nIE "[a-zA-Z0-9_]\s*[*][a-zA-Z_]" -- '*.h' '*.cpp' | egrep -v -e "return [*]" -e "^* [*]" -e "^*//.*"
+	preparedGrep "[a-zA-Z0-9_]\s*[*][a-zA-Z_]" | egrep -v -e "return [*]" -e "^* [*]" -e "^*//.*"
 ) | egrep -v -e "^[a-zA-Z\./]*:[0-9]*:\s*\/(\/|\*)" -e "^test/"
 )
 

scripts/deps-ppa/static_z3.sh

@@ -25,11 +25,9 @@ set -ev
 keyid=70D110489D66E2F6
 email=builds@ethereum.org
 packagename=libz3-static-dev
-# On the next version the git cherry-pick below should be removed and the patch suffix removed from the version string.
+version=4.8.8
-version=4.8.7
-version_patchsuffix=-1
 
-DISTRIBUTIONS="bionic disco eoan focal"
+DISTRIBUTIONS="bionic eoan focal"
 
 for distribution in $DISTRIBUTIONS
 do
@@ -44,10 +42,8 @@ ppafilesurl=https://launchpad.net/~ethereum/+archive/ubuntu/${pparepo}/+files
 # Fetch source
 git clone --branch z3-${version} https://github.com/Z3Prover/z3.git
 cd z3
-# Patch build failure.
-git cherry-pick e212159f4e
 
-debversion="${version}${version_patchsuffix}"
+debversion="${version}"
 
 CMAKE_OPTIONS="-DZ3_BUILD_LIBZ3_SHARED=OFF -DCMAKE_BUILD_TYPE=Release"
 
@@ -181,7 +177,7 @@ This program is free software: you can redistribute it and/or modify
  Public License version 3 can be found in "/usr/share/common-licenses/GPL-3".
 EOF
 cat <<EOF > debian/changelog
-libz3-static-dev (0.0.1-2ubuntu0) saucy; urgency=low
+libz3-static-dev (0.0.1-1ubuntu0) saucy; urgency=low
 
   * Initial release.
 
@@ -191,7 +187,7 @@ mkdir debian/source
 echo "3.0 (quilt)" > debian/source/format
 chmod +x debian/rules
 
-versionsuffix=2ubuntu0~${distribution}
+versionsuffix=1ubuntu0~${distribution}
 EMAIL="$email" dch -v 1:${debversion}-${versionsuffix} "build of ${version}"
 
 # build source package

scripts/release_ppa.sh

@@ -55,9 +55,9 @@ keyid=70D110489D66E2F6
 email=builds@ethereum.org
 packagename=solc
 
-static_build_distribution=disco
+static_build_distribution=focal
 
-DISTRIBUTIONS="bionic disco eoan focal"
+DISTRIBUTIONS="bionic eoan focal"
 
 if is_release
 then
@@ -85,7 +85,7 @@ else
     fi
     if [ $distribution = focal ]
     then
-        SMTDEPENDENCY="libz3-dev,
+        SMTDEPENDENCY="libz3-static-dev,
             libcvc4-dev,
             "
     elif [ $distribution = disco ]

test/libsolidity/Assembly.cpp

@@ -58,9 +58,8 @@ evmasm::AssemblyItems compileContract(std::shared_ptr<CharStream> _sourceCode)
 	BOOST_REQUIRE_NO_THROW(sourceUnit = parser.parse(make_shared<Scanner>(_sourceCode)));
 	BOOST_CHECK(!!sourceUnit);
 
-	map<ASTNode const*, shared_ptr<DeclarationContainer>> scopes;
 	GlobalContext globalContext;
-	NameAndTypeResolver resolver(globalContext, solidity::test::CommonOptions::get().evmVersion(), scopes, errorReporter);
+	NameAndTypeResolver resolver(globalContext, solidity::test::CommonOptions::get().evmVersion(), errorReporter);
 	DeclarationTypeChecker declarationTypeChecker(errorReporter, solidity::test::CommonOptions::get().evmVersion());
 	solAssert(Error::containsOnlyWarnings(errorReporter.errors()), "");
 	resolver.registerDeclarations(*sourceUnit);

test/libsolidity/SolidityExpressionCompiler.cpp

@@ -116,8 +116,7 @@ bytes compileFirstExpression(
 	ErrorList errors;
 	ErrorReporter errorReporter(errors);
 	GlobalContext globalContext;
-	map<ASTNode const*, shared_ptr<DeclarationContainer>> scopes;
+	NameAndTypeResolver resolver(globalContext, solidity::test::CommonOptions::get().evmVersion(), errorReporter);
-	NameAndTypeResolver resolver(globalContext, solidity::test::CommonOptions::get().evmVersion(), scopes, errorReporter);
 	resolver.registerDeclarations(*sourceUnit);
 	for (ASTPointer<ASTNode> const& node: sourceUnit->nodes())
 		if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))

test/libsolidity/semanticTests/abiEncoderV1/abi_encode_calldata_slice.sol

@@ -56,6 +56,7 @@ contract C {
 	}
 }
 // ====
+// compileViaYul: also
 // EVMVersion: >homestead
 // ----
 // test_bytes() ->

test/libsolidity/semanticTests/abiEncoderV2/abi_encode_calldata_slice.sol

@@ -57,6 +57,7 @@ contract C {
 	}
 }
 // ====
+// compileViaYul: also
 // EVMVersion: >homestead
 // ----
 // test_bytes() ->

test/libsolidity/semanticTests/array/create_memory_byte_array.sol

@@ -0,0 +1,12 @@
+contract C {
+    function f() public returns (bytes1) {
+        bytes memory x = new bytes(35);
+        assert(x.length == 35);
+        x[34] = "A";
+        return (x[34]);
+    }
+}
+// ====
+// compileViaYul: also
+// ----
+// f() -> "A"

test/libsolidity/semanticTests/inlineAssembly/inline_assembly_memory_access.sol

@@ -9,5 +9,7 @@ contract C {
     }
 }
 
+// ====
+// compileViaYul: also
 // ----
 // test() -> 0x20, 0x5, "12345"

test/libsolidity/smtCheckerTests/loops/for_loop_array_assignment_storage_memory.sol

@@ -19,5 +19,4 @@ contract LoopFor2 {
 	}
 }
 // ----
-// Warning: (316-336): Assertion violation happens here
 // Warning: (363-382): Assertion violation happens here

test/libsolidity/smtCheckerTests/loops/for_loop_array_assignment_storage_storage.sol

@@ -19,6 +19,5 @@ contract LoopFor2 {
 	}
 }
 // ----
-// Warning: (317-337): Assertion violation happens here
 // Warning: (341-360): Assertion violation happens here
 // Warning: (364-383): Assertion violation happens here

test/libsolidity/smtCheckerTests/loops/while_loop_array_assignment_storage_storage.sol

@@ -21,6 +21,5 @@ contract LoopFor2 {
 	}
 }
 // ----
-// Warning: (296-316): Assertion violation happens here
 // Warning: (320-339): Assertion violation happens here
 // Warning: (343-362): Assertion violation happens here

test/libsolidity/smtCheckerTests/operators/compound_assignment_division_1.sol

@@ -9,4 +9,6 @@ contract C {
 	}
 }
 // ----
+// Warning: (129-143): Error trying to invoke SMT solver.
+// Warning: (147-161): Error trying to invoke SMT solver.
 // Warning: (147-161): Assertion violation happens here

test/libsolidity/smtCheckerTests/operators/compound_assignment_division_2.sol

@@ -10,4 +10,6 @@ contract C {
 	}
 }
 // ----
+// Warning: (163-184): Error trying to invoke SMT solver.
+// Warning: (188-209): Error trying to invoke SMT solver.
 // Warning: (188-209): Assertion violation happens here

test/libsolidity/smtCheckerTests/operators/compound_assignment_division_3.sol

@@ -10,4 +10,6 @@ contract C {
 	}
 }
 // ----
+// Warning: (171-190): Error trying to invoke SMT solver.
+// Warning: (194-213): Error trying to invoke SMT solver.
 // Warning: (194-213): Assertion violation happens here

test/libsolidity/smtCheckerTests/operators/delete_array_index_2d.sol

@@ -16,4 +16,3 @@ contract C
 // ====
 // SMTSolvers: z3
 // ----
-// Warning: (174-194): Assertion violation happens here

test/libsolidity/smtCheckerTests/operators/division_truncates_correctly_1.sol

@@ -6,3 +6,5 @@ contract C {
 		assert(x / y == 3);
 	}
 }
+// ----
+// Warning: (107-125): Error trying to invoke SMT solver.

test/libsolidity/smtCheckerTests/operators/division_truncates_correctly_2.sol

@@ -6,3 +6,5 @@ contract C {
 		assert(x / y == 3);
 	}
 }
+// ----
+// Warning: (105-123): Error trying to invoke SMT solver.

test/libsolidity/smtCheckerTests/operators/division_truncates_correctly_3.sol

@@ -6,3 +6,5 @@ contract C {
 		assert(x / y == -3);
 	}
 }
+// ----
+// Warning: (106-125): Error trying to invoke SMT solver.

test/libsolidity/smtCheckerTests/operators/division_truncates_correctly_4.sol

@@ -6,3 +6,5 @@ contract C {
 		assert(x / y == -3);
 	}
 }
+// ----
+// Warning: (106-125): Error trying to invoke SMT solver.

test/libsolidity/smtCheckerTests/operators/division_truncates_correctly_5.sol

@@ -6,3 +6,5 @@ contract C {
 		assert(x / y == 3);
 	}
 }
+// ----
+// Warning: (107-125): Error trying to invoke SMT solver.

test/libsolidity/smtCheckerTests/operators/mod.sol

@@ -8,3 +8,5 @@ contract C {
 		assert(z1 == z2);
 	}
 }
+// ----
+// Warning: (166-182): Error trying to invoke SMT solver.

test/libsolidity/smtCheckerTests/operators/mod_even.sol

@@ -8,3 +8,5 @@ contract C
 		assert((y % 2) == 0);
 	}
 }
+// ----
+// Warning: (122-142): Error trying to invoke SMT solver.

test/libsolidity/smtCheckerTests/operators/mod_n.sol

@@ -8,3 +8,5 @@ contract C
 		assert(z < y);
 	}
 }
+// ----
+// Warning: (126-139): Error trying to invoke SMT solver.

test/libsolidity/smtCheckerTests/operators/mod_n_uint16.sol

@@ -8,3 +8,5 @@ contract C
 		assert(z < 100_000);
 	}
 }
+// ----
+// Warning: (130-149): Error trying to invoke SMT solver.