Skip to content

Commit 617efd2

Browse files
clonkerclonker
committed
yul literal value is struct of u256 + optional formatting hint or 'unlimited'
- unlimited meaning a specific string literal argument of a builtin function
1 parent 0f98226 commit 617efd2

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

49 files changed

+427
-195
lines changed

‎libsolidity/codegen/ir/IRGeneratorForStatements.cpp‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -37,6 +37,7 @@
3737
#include <libyul/AsmPrinter.h>
3838
#include <libyul/AST.h>
3939
#include <libyul/Dialect.h>
40+
#include <libyul/Utilities.h>
4041
#include <libyul/optimiser/ASTCopier.h>
4142

4243
#include <liblangutil/Exceptions.h>
@@ -202,7 +203,7 @@ struct CopyTranslate: public yul::ASTCopier
202203
solAssert(false);
203204

204205
if (isDigit(value.front()))
205-
return yul::Literal{_identifier.debugData, yul::LiteralKind::Number, yul::YulString{value}, {}};
206+
return yul::Literal{_identifier.debugData, yul::LiteralKind::Number, yul::valueOfNumberLiteral(value), {}};
206207
else
207208
return yul::Identifier{_identifier.debugData, yul::YulString{value}};
208209
}

‎libsolutil/CommonData.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -161,7 +161,7 @@ std::string solidity::util::getChecksummedAddress(std::string const& _addr)
161161
return ret;
162162
}
163163

164-
bool solidity::util::isValidHex(std::string const& _string)
164+
bool solidity::util::isValidHex(std::string_view const _string)
165165
{
166166
if (_string.substr(0, 2) != "0x")
167167
return false;
@@ -170,7 +170,7 @@ bool solidity::util::isValidHex(std::string const& _string)
170170
return true;
171171
}
172172

173-
bool solidity::util::isValidDecimal(std::string const& _string)
173+
bool solidity::util::isValidDecimal(std::string_view const _string)
174174
{
175175
if (_string.empty())
176176
return false;

‎libsolutil/CommonData.h‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -584,8 +584,8 @@ bool passesAddressChecksum(std::string const& _str, bool _strict);
584584
/// @param hex strings that look like an address
585585
std::string getChecksummedAddress(std::string const& _addr);
586586

587-
bool isValidHex(std::string const& _string);
588-
bool isValidDecimal(std::string const& _string);
587+
bool isValidHex(std::string_view _string);
588+
bool isValidDecimal(std::string_view _string);
589589

590590
/// @returns a quoted string if all characters are printable ASCII chars,
591591
/// or its hex representation otherwise.

‎libyul/AST.cpp‎

Lines changed: 80 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,80 @@
1+
/*
2+
This file is part of solidity.
3+
4+
solidity is free software: you can redistribute it and/or modify
5+
it under the terms of the GNU General Public License as published by
6+
the Free Software Foundation, either version 3 of the License, or
7+
(at your option) any later version.
8+
9+
solidity is distributed in the hope that it will be useful,
10+
but WITHOUT ANY WARRANTY; without even the implied warranty of
11+
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12+
GNU General Public License for more details.
13+
14+
You should have received a copy of the GNU General Public License
15+
along with solidity. If not, see <http://www.gnu.org/licenses/>.
16+
*/
17+
// SPDX-License-Identifier: GPL-3.0
18+
19+
#include <libyul/AST.h>
20+
#include <libyul/Exceptions.h>
21+
22+
namespace solidity::yul
23+
{
24+
25+
LiteralValue::LiteralValue(std::string _builtinStringLiteralValue):
26+
m_numericValue(std::nullopt),
27+
m_stringValue(std::make_shared<std::string>(std::move(_builtinStringLiteralValue)))
28+
{ }
29+
30+
LiteralValue::LiteralValue(solidity::yul::LiteralValue::Data const& _data, std::optional<std::string> const& _hint):
31+
m_numericValue(_data),
32+
m_stringValue(_hint ? std::make_shared<std::string>(*_hint) : nullptr)
33+
{ }
34+
35+
LiteralValue::Data const& LiteralValue::value() const
36+
{
37+
yulAssert(!unlimited() && m_numericValue.has_value());
38+
return *m_numericValue;
39+
}
40+
41+
LiteralValue::BuiltinStringLiteralData const& LiteralValue::builtinStringLiteralValue() const
42+
{
43+
yulAssert(unlimited() && m_stringValue != nullptr);
44+
return *m_stringValue;
45+
}
46+
47+
bool LiteralValue::unlimited() const
48+
{
49+
return !m_numericValue.has_value();
50+
}
51+
52+
LiteralValue::RepresentationHint const& LiteralValue::hint() const
53+
{
54+
yulAssert(!unlimited());
55+
return m_stringValue;
56+
}
57+
58+
bool LiteralValue::operator==(LiteralValue const& _rhs) const
59+
{
60+
if (unlimited() != _rhs.unlimited())
61+
return false;
62+
63+
if (unlimited())
64+
return builtinStringLiteralValue() == _rhs.builtinStringLiteralValue();
65+
66+
return value() == _rhs.value();
67+
}
68+
69+
bool LiteralValue::operator<(solidity::yul::LiteralValue const& _rhs) const
70+
{
71+
if (unlimited() != _rhs.unlimited())
72+
return unlimited() < _rhs.unlimited();
73+
74+
if (unlimited())
75+
return builtinStringLiteralValue() < _rhs.builtinStringLiteralValue();
76+
77+
return value() < _rhs.value();
78+
}
79+
80+
}

‎libyul/AST.h‎

Lines changed: 26 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -28,6 +28,8 @@
2828

2929
#include <liblangutil/DebugData.h>
3030

31+
#include <libsolutil/Numeric.h>
32+
3133
#include <memory>
3234
#include <optional>
3335

@@ -41,7 +43,30 @@ using TypedNameList = std::vector<TypedName>;
4143

4244
/// Literal number or string (up to 32 bytes)
4345
enum class LiteralKind { Number, Boolean, String };
44-
struct Literal { langutil::DebugData::ConstPtr debugData; LiteralKind kind; YulString value; Type type; };
46+
/// Literal value that holds a u256 word of data, can be of LiteralKind type and - in case of arguments to
47+
/// builtins - exceed the u256 word (32 bytes), in which case the value is set to `unlimited`
48+
class LiteralValue {
49+
public:
50+
using Data = u256;
51+
using BuiltinStringLiteralData = std::string;
52+
using RepresentationHint = std::shared_ptr<std::string>;
53+
54+
LiteralValue() = default;
55+
explicit LiteralValue(std::string _builtinStringLiteralValue);
56+
explicit LiteralValue(Data const& _data, std::optional<std::string> const& _hint = std::nullopt);
57+
58+
bool operator==(LiteralValue const& _rhs) const;
59+
bool operator<(LiteralValue const& _rhs) const;
60+
Data const& value() const;
61+
BuiltinStringLiteralData const& builtinStringLiteralValue() const;
62+
bool unlimited() const;
63+
RepresentationHint const& hint() const;
64+
65+
private:
66+
std::optional<Data> m_numericValue;
67+
std::shared_ptr<std::string> m_stringValue;
68+
};
69+
struct Literal { langutil::DebugData::ConstPtr debugData; LiteralKind kind; LiteralValue value; Type type; };
4570
/// External / internal identifier or label reference
4671
struct Identifier { langutil::DebugData::ConstPtr debugData; YulString name; };
4772
/// Assignment ("x := mload(20:u256)", expects push-1-expression on the right hand

‎libyul/ASTForward.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -29,6 +29,7 @@ namespace solidity::yul
2929
{
3030

3131
enum class LiteralKind;
32+
class LiteralValue;
3233
struct Literal;
3334
struct Label;
3435
struct Identifier;

‎libyul/AsmAnalysis.cpp‎

Lines changed: 31 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -41,7 +41,6 @@
4141

4242
#include <fmt/format.h>
4343

44-
#include <memory>
4544
#include <functional>
4645

4746
using namespace std::string_literals;
@@ -101,24 +100,37 @@ AsmAnalysisInfo AsmAnalyzer::analyzeStrictAssertCorrect(Dialect const& _dialect,
101100
std::vector<YulString> AsmAnalyzer::operator()(Literal const& _literal)
102101
{
103102
expectValidType(_literal.type, nativeLocationOf(_literal));
104-
if (_literal.kind == LiteralKind::String && _literal.value.str().size() > 32)
103+
bool erroneousLiteral = false;
104+
if (_literal.kind == LiteralKind::String && !_literal.value.unlimited() && _literal.value.hint() && _literal.value.hint()->size() > 32)
105+
{
106+
erroneousLiteral = true;
105107
m_errorReporter.typeError(
106108
3069_error,
107109
nativeLocationOf(_literal),
108-
"String literal too long (" + std::to_string(_literal.value.str().size()) + " > 32)"
109-
);
110-
else if (_literal.kind == LiteralKind::Number && bigint(_literal.value.str()) > u256(-1))
110+
"String literal too long (" + std::to_string(formatLiteral(_literal, false).size()) + " > 32)");
111+
}
112+
else if (_literal.kind == LiteralKind::Number && _literal.value.hint() && bigint(*_literal.value.hint()) > u256(-1))
113+
{
114+
erroneousLiteral = true;
111115
m_errorReporter.typeError(6708_error, nativeLocationOf(_literal), "Number literal too large (> 256 bits)");
116+
}
112117
else if (_literal.kind == LiteralKind::Boolean)
113-
yulAssert(_literal.value == "true"_yulstring || _literal.value == "false"_yulstring, "");
118+
{
119+
yulAssert(_literal.value.value() == true || _literal.value.value() == false);
120+
if (_literal.value.hint())
121+
yulAssert(*_literal.value.hint() == "true" || *_literal.value.hint() == "false");
122+
}
114123

115124
if (!m_dialect.validTypeForLiteral(_literal.kind, _literal.value, _literal.type))
125+
{
126+
erroneousLiteral = true;
116127
m_errorReporter.typeError(
117128
5170_error,
118129
nativeLocationOf(_literal),
119-
"Invalid type \"" + _literal.type.str() + "\" for literal \"" + _literal.value.str() + "\"."
120-
);
130+
"Invalid type \"" + _literal.type.str() + "\" for literal \"" + formatLiteral(_literal, false) + "\".");
131+
}
121132

133+
yulAssert(erroneousLiteral || validLiteral(_literal), "Invalid literal after validating it through AsmAnalyzer.");
122134
return {_literal.type};
123135
}
124136

@@ -417,23 +429,25 @@ std::vector<YulString> AsmAnalyzer::operator()(FunctionCall const& _funCall)
417429
std::string functionName = _funCall.functionName.name.str();
418430
if (functionName == "datasize" || functionName == "dataoffset")
419431
{
420-
if (!m_dataNames.count(std::get<Literal>(arg).value))
432+
auto const& argumentAsLiteral = std::get<Literal>(arg);
433+
if (!m_dataNames.count(YulString(formatLiteral(argumentAsLiteral))))
421434
m_errorReporter.typeError(
422435
3517_error,
423436
nativeLocationOf(arg),
424-
"Unknown data object \"" + std::get<Literal>(arg).value.str() + "\"."
437+
"Unknown data object \"" + formatLiteral(argumentAsLiteral) + "\"."
425438
);
426439
}
427440
else if (functionName.substr(0, "verbatim_"s.size()) == "verbatim_")
428441
{
429-
if (std::get<Literal>(arg).value.empty())
442+
static u256 const empty {valueOfStringLiteral("").value()};
443+
auto const& literalValue = std::get<Literal>(arg).value;
444+
if ((literalValue.unlimited() && literalValue.builtinStringLiteralValue().empty()) || (!literalValue.unlimited() && literalValue.value() == empty))
430445
m_errorReporter.typeError(
431446
1844_error,
432447
nativeLocationOf(arg),
433448
"The \"verbatim_*\" builtins cannot be used with empty bytecode."
434449
);
435450
}
436-
437451
argTypes.emplace_back(expectUnlimitedStringLiteral(std::get<Literal>(arg)));
438452
continue;
439453
}
@@ -492,12 +506,12 @@ void AsmAnalyzer::operator()(Switch const& _switch)
492506
(*this)(*_case.value);
493507

494508
/// Note: the parser ensures there is only one default case
495-
if (watcher.ok() && !cases.insert(valueOfLiteral(*_case.value)).second)
509+
if (watcher.ok() && !cases.insert(_case.value->value.value()).second)
496510
m_errorReporter.declarationError(
497511
6792_error,
498512
nativeLocationOf(_case),
499513
"Duplicate case \"" +
500-
valueOfLiteral(*_case.value).str() +
514+
formatLiteral(*_case.value) +
501515
"\" defined."
502516
);
503517
}
@@ -557,8 +571,9 @@ YulString AsmAnalyzer::expectExpression(Expression const& _expr)
557571

558572
YulString AsmAnalyzer::expectUnlimitedStringLiteral(Literal const& _literal)
559573
{
560-
yulAssert(_literal.kind == LiteralKind::String, "");
561-
yulAssert(m_dialect.validTypeForLiteral(LiteralKind::String, _literal.value, _literal.type), "");
574+
yulAssert(_literal.kind == LiteralKind::String);
575+
yulAssert(m_dialect.validTypeForLiteral(LiteralKind::String, _literal.value, _literal.type));
576+
yulAssert(_literal.value.unlimited());
562577

563578
return {_literal.type};
564579
}

‎libyul/AsmJsonConverter.cpp‎

Lines changed: 6 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -20,9 +20,10 @@
2020
* Converts inline assembly AST to JSON format
2121
*/
2222

23-
#include <libyul/AsmJsonConverter.h>
2423
#include <libyul/AST.h>
24+
#include <libyul/AsmJsonConverter.h>
2525
#include <libyul/Exceptions.h>
26+
#include <libyul/Utilities.h>
2627
#include <libsolutil/CommonData.h>
2728
#include <libsolutil/UTF8.h>
2829

@@ -51,23 +52,20 @@ Json AsmJsonConverter::operator()(Literal const& _node) const
5152
switch (_node.kind)
5253
{
5354
case LiteralKind::Number:
54-
yulAssert(
55-
util::isValidDecimal(_node.value.str()) || util::isValidHex(_node.value.str()),
56-
"Invalid number literal"
57-
);
55+
yulAssert(validNumberLiteral(_node), "Invalid number literal");
5856
ret["kind"] = "number";
5957
break;
6058
case LiteralKind::Boolean:
6159
ret["kind"] = "bool";
6260
break;
6361
case LiteralKind::String:
6462
ret["kind"] = "string";
65-
ret["hexValue"] = util::toHex(util::asBytes(_node.value.str()));
63+
ret["hexValue"] = util::toHex(util::asBytes(formatLiteral(_node)));
6664
break;
6765
}
6866
ret["type"] = _node.type.str();
69-
if (util::validateUTF8(_node.value.str()))
70-
ret["value"] = _node.value.str();
67+
if (auto const value = formatLiteral(_node); util::validateUTF8(value))
68+
ret["value"] = value;
7169
return ret;
7270
}
7371

‎libyul/AsmJsonImporter.cpp‎

Lines changed: 13 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,7 @@
2525
#include <libyul/AsmJsonImporter.h>
2626
#include <libyul/AST.h>
2727
#include <libyul/Exceptions.h>
28+
#include <libyul/Utilities.h>
2829

2930
#include <liblangutil/Exceptions.h>
3031
#include <liblangutil/Scanner.h>
@@ -165,26 +166,25 @@ Literal AsmJsonImporter::createLiteral(Json const& _node)
165166
std::string kind = member(_node, "kind").get<std::string>();
166167

167168
solAssert(member(_node, "hexValue").is_string() || member(_node, "value").is_string(), "");
169+
std::string value;
168170
if (_node.contains("hexValue"))
169-
lit.value = YulString{util::asString(util::fromHex(member(_node, "hexValue").get<std::string>()))};
171+
value = util::asString(util::fromHex(member(_node, "hexValue").get<std::string>()));
170172
else
171-
lit.value = YulString{member(_node, "value").get<std::string>()};
172-
173-
lit.type= YulString{member(_node, "type").get<std::string>()};
174-
173+
value = member(_node, "value").get<std::string>();
174+
lit.type = YulString{member(_node, "type").get<std::string>()};
175175
if (kind == "number")
176176
{
177-
langutil::CharStream charStream(lit.value.str(), "");
177+
langutil::CharStream charStream(value, "");
178178
langutil::Scanner scanner{charStream};
179179
lit.kind = LiteralKind::Number;
180180
yulAssert(
181181
scanner.currentToken() == Token::Number,
182-
"Expected number but got " + langutil::TokenTraits::friendlyName(scanner.currentToken()) + std::string(" while scanning ") + lit.value.str()
182+
"Expected number but got " + langutil::TokenTraits::friendlyName(scanner.currentToken()) + std::string(" while scanning ") + value
183183
);
184184
}
185185
else if (kind == "bool")
186186
{
187-
langutil::CharStream charStream(lit.value.str(), "");
187+
langutil::CharStream charStream(value, "");
188188
langutil::Scanner scanner{charStream};
189189
lit.kind = LiteralKind::Boolean;
190190
yulAssert(
@@ -197,13 +197,16 @@ Literal AsmJsonImporter::createLiteral(Json const& _node)
197197
{
198198
lit.kind = LiteralKind::String;
199199
yulAssert(
200-
lit.value.str().size() <= 32,
201-
"String literal too long (" + std::to_string(lit.value.str().size()) + " > 32)"
200+
value.size() <= 32,
201+
"String literal too long (" + std::to_string(value.size()) + " > 32)"
202202
);
203203
}
204204
else
205205
yulAssert(false, "unknown type of literal");
206206

207+
// import only for inline assembly, no unlimited string literals there
208+
lit.value = valueOfLiteral(value, lit.kind, false);
209+
207210
return lit;
208211
}
209212

0 commit comments

Comments
 (0)