[CodeGen] Solve int256/bool binary operation; Add Immutable Array as a global table

Author: eee4017

lib/CodeGen/CGExpr.cpp

@@ -9,6 +9,7 @@
 #include <llvm/ADT/StringRef.h>
 #include <llvm/IR/Type.h>
 #include <llvm/IR/Value.h>
+#include <llvm/Support/raw_ostream.h>
 namespace soll::CodeGen {
 
 ExprValuePtr CodeGenFunction::emitExpr(const Expr *E) {
@@ -1011,9 +1012,18 @@ void CodeGenFunction::emitAsmSetImmutable(const CallExpr *CE) {
       auto &Ctx = CGM.getContext();
       auto &Map = Ctx.getImmutableAddressMap();
       if (Map.find(StringRefName) != Map.end()) {
-        llvm::Value *Offset = Builder.getInt(Map.lookup(StringRefName));
-        llvm::Value *Ptr = Builder.CreateIntToPtr(Offset, Int256PtrTy);
-        Builder.CreateStore(Value, Ptr);
+        llvm::Value *Offset = emitExpr(Arguments[0])->load(Builder, CGM);
+        llvm::Value *TableOffset = Builder.getInt(Map.lookup(StringRefName));
+        llvm::Value *ImmutableCPtr = Builder.CreateInBoundsGEP(
+            CGM.getImmutableBase(), {TableOffset}, "immutable.cptr");
+        Builder.CreateStore(
+            Offset,
+            Builder.CreateBitCast(ImmutableCPtr, Int256PtrTy, "immutable.ptr"));
+
+        llvm::Value *HeapCPtr =
+            Builder.CreateInBoundsGEP(CGM.getHeapBase(), {Offset}, "heap.cptr");
+        Builder.CreateStore(
+            Value, Builder.CreateBitCast(HeapCPtr, Int256PtrTy, "heap.ptr"));
         CGM.emitUpdateMemorySize(Offset, Builder.getIntN(256, 0x20));
         return;
       }
@@ -1032,9 +1042,16 @@ llvm::Value *CodeGenFunction::emitAsmLoadImmutable(const CallExpr *CE) {
       auto &Ctx = CGM.getContext();
       auto &Map = Ctx.getImmutableAddressMap();
       if (Map.find(StringRefName) != Map.end()) {
-        llvm::Value *Offset = Builder.getInt(Map.lookup(StringRefName));
-        llvm::Value *Ptr = Builder.CreateIntToPtr(Offset, Int256PtrTy);
-        return CGM.getEndianlessValue(Builder.CreateLoad(Ptr, Int256Ty));
+        llvm::Value *TableOffset = Builder.getInt(Map.lookup(StringRefName));
+        llvm::Value *ImmutableCPtr = Builder.CreateInBoundsGEP(
+            CGM.getImmutableBase(), {TableOffset}, "immutable.cptr");
+        llvm::Value *Offset = Builder.CreateLoad(
+            Builder.CreateBitCast(ImmutableCPtr, Int256PtrTy, "immutable.ptr"));
+
+        llvm::Value *HeapCPtr =
+            Builder.CreateInBoundsGEP(CGM.getHeapBase(), {Offset}, "heap.cptr");
+        return Builder.CreateLoad(
+            Builder.CreateBitCast(HeapCPtr, Int256PtrTy, "heap.ptr"));
       }
     }
   }

lib/CodeGen/CodeGenFunction.h

@@ -9,6 +9,7 @@
 #include <llvm/IR/BasicBlock.h>
 #include <llvm/IR/ConstantFolder.h>
 #include <llvm/IR/IRBuilder.h>
+#include <llvm/IR/Value.h>
 
 namespace soll::CodeGen {
 
@@ -26,7 +27,6 @@ class CodeGenFunction : public CodeGenTypeCache {
   llvm::Value *ReturnValue;
 
   using DeclMapTy = llvm::DenseMap<const Decl *, llvm::Value *>;
-  llvm::StringMap<llvm::Value *> ImmutableAllocationTable;
   DeclMapTy LocalDeclMap;
   void setAddrOfLocalVar(const Decl *VD, llvm::Value *Addr) {
     assert(!LocalDeclMap.count(VD) && "Decl already exists in LocalDeclMap!");

lib/CodeGen/CodeGenModule.cpp

@@ -2,8 +2,10 @@
 #include "CodeGenModule.h"
 #include "ABICodec.h"
 #include "CodeGenFunction.h"
+#include <llvm/ADT/APInt.h>
 #include <llvm/IR/Attributes.h>
 #include <llvm/IR/Constants.h>
+#include <llvm/IR/DerivedTypes.h>
 
 /*
 // for testing purpose
@@ -125,6 +127,22 @@ void CodeGenModule::initMemorySection() {
   initUpdateMemorySize();
 }
 
+void CodeGenModule::initImmutableTable() {
+  size_t ImmutableSize = Context.getImmutableAddressMap().size();
+  if (ImmutableSize && !ImmtableTable) {
+    // Immutable array is a array of offsets of memory
+    llvm::ArrayType *ImmtableArrayType =
+        llvm::ArrayType::get(Int256Ty, ImmutableSize);
+    ImmtableTable =
+        new llvm::GlobalVariable(TheModule, ImmtableArrayType, false,
+                                 llvm::GlobalVariable::PrivateLinkage, nullptr,
+                                 "__immutable_table_base");
+    ImmtableTable->setInitializer(
+        llvm::Constant::getNullValue(ImmtableArrayType));
+    ImmtableTable->setAlignment(llvm::MaybeAlign(256));
+  }
+}
+
 void CodeGenModule::initUpdateMemorySize() {
   llvm::Argument *Pos = Func_updateMemorySize->arg_begin();
   Pos->setName("memory.pos");
@@ -1622,6 +1640,14 @@ void CodeGenModule::emitYulCode(const YulCode *YC, llvm::StringRef Name) {
       FT, llvm::Function::ExternalLinkage, FunctionName, TheModule);
   llvm::BasicBlock *Entry = llvm::BasicBlock::Create(VMContext, "entry", Main);
   Builder.SetInsertPoint(Entry);
+
+  // Global variable Immutable table should be generated here.
+  // Immutable table should not be generated with other global variables
+  // (e.g. heap_base), since the parsing stage have not finished, so the number
+  // of the immutable variable is not decided. The table should be generated
+  // as early as possible, so the immutable variable could be set at any time.
+  initImmutableTable();
+
   CodeGenFunction(*this).generateYulCode(YC);
   Builder.CreateRetVoid();
 }

lib/CodeGen/CodeGenModule.h

@@ -63,6 +63,8 @@ class CodeGenModule : public CodeGenTypeCache {
   llvm::DenseMap<const VarDecl *, llvm::GlobalVariable *> StateVarDeclMap;
   llvm::DenseMap<const YulData *, llvm::GlobalVariable *> YulDataMap;
   std::size_t StateVarAddrCursor;
+  llvm::GlobalVariable *ImmtableTable = nullptr;
+  llvm::ArrayType *ImmtableArrayType = nullptr;
 
   llvm::Function *Func_create = nullptr;
   llvm::Function *Func_call = nullptr;
@@ -122,6 +124,7 @@ class CodeGenModule : public CodeGenTypeCache {
   void initTypes();
   void initMemorySection();
   void initUpdateMemorySize();
+  void initImmutableTable();
 
   void initEVMOpcodeDeclaration();
   void initEEIDeclaration();
@@ -279,6 +282,8 @@ class CodeGenModule : public CodeGenTypeCache {
   llvm::GlobalVariable *getYulDataAddr(const YulData *YD) const {
     return YulDataMap.lookup(YD);
   }
+  llvm::GlobalVariable *getImmutableBase() { return ImmtableTable; }
+
   std::variant<std::monostate, const YulData *, const YulObject *>
   lookupYulDataOrYulObject(llvm::StringRef Name) const;
 };

lib/Sema/SemaResolveImmutable.cpp

@@ -38,12 +38,13 @@ class ImmutableResolver : public StmtVisitor {
         auto *ICE0 = dynamic_cast<const ImplicitCastExpr *>(Arguments[0]);
         auto *ICE1 = dynamic_cast<const ImplicitCastExpr *>(Arguments[1]);
         if (ICE0 && ICE1) {
-          auto *NL = dynamic_cast<const NumberLiteral *>(ICE0->getSubExpr());
           auto *SL = dynamic_cast<const StringLiteral *>(ICE1->getSubExpr());
-          if (SL && NL) {
+          if (SL) {
             std::string Name = SL->getValue();
             auto &ImmutableMap = Actions.getContext().getImmutableAddressMap();
-            ImmutableMap.try_emplace(llvm::StringRef(Name), NL->getValue());
+            const size_t ImmutableIndex = ImmutableMap.size();
+            ImmutableMap.try_emplace(llvm::StringRef(Name),
+                                     llvm::APInt(256, ImmutableIndex));
           }
         }
       }

lib/Sema/SemaResolveType.cpp

@@ -4,7 +4,6 @@
 #include "soll/Sema/Sema.h"
 #include <unordered_set>
 #include <vector>
-
 namespace soll {
 namespace {
 
@@ -29,6 +28,9 @@ bool isAllowedTypeForBinary(BinaryOperatorKind BOK, const Type::Category TyC) {
   case Type::Category::Bool:
     return BinaryOperator::isEqualityOp(BOK) || BOK == BO_LAnd ||
            BOK == BO_LOr || BOK == BO_Assign ||
+           BinaryOperator::isShiftOp(BOK) ||
+           BinaryOperator::isAdditiveOp(BOK) ||
+           BinaryOperator::isMultiplicativeOp(BOK) ||
            BinaryOperator::isAsmBitwiseOp(BOK);
   case Type::Category::Integer:
     return BinaryOperator::isComparisonOp(BOK) ||