Я реализую компилятор для проприетарного языка.
Язык имеет один встроенный целочисленный тип с неограниченным диапазоном.Иногда переменные представляются с использованием меньших типов, например, если a
и b
являются целочисленными переменными, но b
только когда-либо присваивается значение выражения a % 100000
или a & 0xFFFFFF
, тогда b
можно представить какInt32
вместо.
Я рассматриваю возможность реализации следующей оптимизации.Предположим, он видит эквивалент этого метода C #:
public static void Main(string[] args)
{
BigInt i = 0;
while (true)
{
DoStuff(i++);
}
}
Математически говоря, преобразование в следующее: not valid:
public static void Main(string[] args)
{
Int64 i = 0;
while (true)
{
DoStuff(i++);
}
}
Поскольку я заменил aBigInt
с Int64
, который в конечном итоге переполнится, если цикл будет выполняться вечно.Однако я подозреваю, что могу игнорировать эту возможность, потому что:
i
инициализируется в 0 и изменяется только путем многократного добавления к нему 1, что означает, что потребуется 2 63 итерации цикла, чтобы сделать его переполненным - Если
DoStuff
сделает какую-либо полезную работу, потребуются столетия (экстраполированные из моих очень грубых тестов) для i
для переполнения.Машина, на которой работает программа, не прослужит так долго.Не только это, но и архитектура , вероятно, тоже не будет длиться так долго, поэтому мне также не нужно беспокоиться о том, что он работает на виртуальной машине, которая перенесена на новое оборудование. - Если
DoStuff
не выполняет никакой полезной работы, оператор в конечном итоге заметит, что он тратит впустую циклы ЦП и убивает процесс
Так о каких сценариях do мне нужно беспокоиться?
Какие-нибудь компиляторы уже используют этот хак?