[Semantic, LLVM] Applied changes from the Compiler to the corresponding directories

Author: JohnnyPol

llvm/ast.hpp

@@ -81,6 +81,7 @@ class AST
     // This function will be used to check thre type of return case in functions.
     // Default is NO_RETURN so we don't have to override it in every class.
     virtual ReturnInfo check_return_case() const { return ReturnInfo(NO_RETURN, false, false); }
+    virtual bool contains_loop() const { return false; }
 
     virtual llvm::Value *igen() { return nullptr; }
     virtual void LLVM_IR_gen();
@@ -211,6 +212,11 @@ class AST
     {
         return llvm::ConstantInt::get(TheContext, llvm::APInt(32, n, true));
     }
+    static llvm::ConstantInt *c64(int64_t n)
+    {
+        return llvm::ConstantInt::get(TheContext, llvm::APInt(64, n, true));
+    }
+
     static llvm::AllocaInst *createEntryBlockAlloca(
         llvm::Function *function,
         const std::string &name,
@@ -844,7 +850,15 @@ class LValue : public Expr
     {
         if (stringLiteral)
         {
-            this->type = TYPE_BYTE_ARRAY;
+            if(!indices.empty()) {
+                if(indices.size() > 1) {
+                    semantic_error(line, column, "String literal can only be indexed once.");
+                }
+                indices[0]->check_type(TYPE_INT);
+                this->type = TYPE_BYTE;
+            } else {
+                this->type = TYPE_BYTE_ARRAY;
+            }
             return;
         }
 
@@ -884,10 +898,6 @@ class LValue : public Expr
                 this->type = symbolTypeFromArray(var->type);
             else
                 this->type = var->type; // multi-dimensional arrays keep their type
-
-            // printf("LValue entry %s array dimensions: ", name);
-            // for(int d : var->arrayDimensions) printf("%d ", d);
-            // printf("\n");
         }
         else
         {
@@ -920,15 +930,33 @@ class LValue : public Expr
                 strConst,
                 globalName);
 
-            gvar->setAlignment(llvm::Align(1));
-
-            // Pointer to first character
-            llvm::Constant *zero = AST::c32(0);
-            std::vector<llvm::Constant *> idxList = {zero, zero};
-            llvm::Constant *strPtr = llvm::ConstantExpr::getGetElementPtr(
-                strConst->getType(), gvar, idxList);
-
-            return strPtr;
+            gvar->setAlignment(llvm::MaybeAlign(1));
+            gvar->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
+            
+            // Indices for GEP into [N x i8]: {0, idx}
+            llvm::Value *idx0 =AST::c64(0); // First index is always 0 (select the array, not an element past it)
+            llvm::Value *idx1;            
+
+            if (!indices.empty()) {
+                // Dynamic/variable index
+                llvm::Value *v = indices[0]->igen();
+                // Cast/truncate/extend to i64 for GEP
+                if (!v->getType()->isIntegerTy(64))
+                    v = AST::Builder.CreateSExtOrTrunc(v, AST::i64, "idx64");
+                idx1 = v;
+            } else {
+                // No indexing -> point at first char
+                idx1 = c64(0);
+            }
+
+            llvm::Value *chPtr = AST::Builder.CreateInBoundsGEP(
+                gvar->getValueType(),   // [N x i8]
+                gvar,                   // [N x i8]*
+                {idx0, idx1},           // {0, i}
+                "str.chptr"
+            );
+            // return Value of type i8*
+            return chPtr; // i8*
         }
 
         // === Case 2 & 3: Variable lookup (function arg or local) ===
@@ -1589,6 +1617,13 @@ class Block : public Stmt
         return result;
     }
 
+    bool contains_loop() const override {
+        for(Stmt* stmt : stmt_list) {
+            if (stmt->contains_loop()) return true;
+        }
+        return false;
+    }
+
     llvm::Value *igen() override
     {
         // Save current variable mapping
@@ -1904,6 +1939,15 @@ class IfStmt : public Stmt
         return combine_if(branches);
     }
 
+    bool contains_loop() const override {
+        if(then_block->contains_loop()) return true;
+        for(IfStmt* i : elifs) {
+            if(i->contains_loop()) return true;
+        }
+        if(else_block && else_block->contains_loop()) return true;
+        return false;
+    }
+
     llvm::Value *igen() override
     {
         llvm::Function *function = AST::Builder.GetInsertBlock()->getParent();
@@ -2041,6 +2085,10 @@ class LoopStmt : public Stmt
         return ReturnInfo(rc, false, false);
     }
 
+    bool contains_loop() const override {
+        return true;
+    }
+
     llvm::Value *igen() override
     {
         llvm::Function *function = AST::Builder.GetInsertBlock()->getParent();
@@ -2577,10 +2625,12 @@ class FParDef : public AST
                 if (type->getDataType() == DataType::INT)
                 {
                     entry->type = TYPE_INT_ARRAY;
+                    entry->isAssigned = true;
                 }
                 else if (type->getDataType() == DataType::BYTE)
                 {
                     entry->type = TYPE_BYTE_ARRAY;
+                    entry->isAssigned = true;
                 }
                 else
                 {
@@ -2591,7 +2641,11 @@ class FParDef : public AST
                 entry->isRef = true; // all arrays are passed by reference
             }
             entry->persistent = true; // Parameters should be persistent because they are needed later
-            entry->isVar = true;
+            
+            if(entry->isRef) {
+                entry->isVar = true;
+            }
+            
             st.insert(id, entry);
         }
     }
@@ -2845,6 +2899,14 @@ class FuncDecl : public AST
     void sem_analyze() override
     {
         header->sem_analyze();
+        STEntry *he = st.lookup(header->getName());
+
+        if (header->getParams().empty() && he->functionReturnType == TYPE_VOID)
+        {
+            std::ostringstream sout;
+            sout << "Function \"" << header->getName() << "\" declaration has no return type or parameters.";
+            semantic_warning(sout.str());
+        }
 
         // Let's create a new scope for the decleration so
         // its parameters are entered into the SymbolTable
@@ -2990,17 +3052,19 @@ class VarDef : public AST
                 oss << "Duplicate variable definition: variable \"" << varName << "\" is already defined in the current scope.";
                 semantic_error(line, column, oss.str());
             }
-            
+
             STEntry *entry = new STEntry();
             if (!type->getParenthesisList().empty())
             {
                 if (type->getDataType() == DataType::INT)
                 {
                     entry->type = TYPE_INT_ARRAY;
+                    entry->isAssigned = true;
                 }
                 else if (type->getDataType() == DataType::BYTE)
                 {
                     entry->type = TYPE_BYTE_ARRAY;
+                    entry->isAssigned = true;
                 }
                 else
                 {
@@ -3142,7 +3206,24 @@ class FuncDef : public AST
     }
 
     ReturnInfo check_return_case() const override {
-        return block->check_return_case();
+        ReturnInfo ri = block->check_return_case();
+
+        // Added after discussion with Professor Sagonas on issue #43
+        if(ri.rc == WEAK_RETURN && contains_loop()) {
+            ri.rc = STRONG_RETURN;
+
+            std::ostringstream oss;
+            oss << "Function \"" << header->getName() << "\" contains a loop and may not always return a value."
+                << " Please add a return statement at the end of the function to ensure all possible paths return a value.";
+
+            semantic_warning_wline(line, column, oss.str());
+        }
+
+        return ri;
+    }
+
+    bool contains_loop() const override {
+        return block->contains_loop();
     }
 
     Header *getHeader() const
@@ -3155,6 +3236,14 @@ class FuncDef : public AST
         // Check for previous declaration before inserting the new entry of definition
         STEntry *previousDecl = st.getCurrentScope().searchPreviousDeclaration(header->getName());
 
+        // Check for previous definition -> error: no duplicate defs
+        STEntry *existingDef = st.lookup(header->getName());
+        if(existingDef && existingDef->type == TYPE_FUNCTION && !existingDef->isDeclaration) {
+            std::ostringstream oss;
+            oss << "Duplicate definition of function \"" << header->getName() << "\" is not allowed!";
+            semantic_error(line, column, oss.str());
+        }
+
         // 1st: insert the function's own header into the parent scope
         header->sem_analyze(); // FParDefs are inserted here... No!
 
@@ -3292,7 +3381,20 @@ class FuncDef : public AST
                 }
             }
         }
+
+        const Scope& scope = st.getCurrentScope();
+        const std::map<std::string, STEntry*>& entriesMap = scope.getLocals(); 
+
         block->sem_analyze();
+
+        for(auto it = entriesMap.begin(); it != entriesMap.end(); it++) {
+            if(!it->second->isAssigned && it->second->isVar && it->second->arrayDimensions.empty()) {
+                std::ostringstream sout;
+                sout << "Variable \"" << it->first << "\" is declared but never assigned a value!";
+                semantic_warning(sout.str());
+            }
+        }
+
         st.exitScope();
     }
 

llvm/symbol.hpp

@@ -9,7 +9,6 @@
 #include "lexer.hpp" // for yyerror
 #include "error.hpp" // for semantic_error
 
-// New implementation: use TYPE_INT_ARRAY and TYPE_BYTE_ARRAY
 // Strings will be TYPE_BYTE_ARRAY with only one dimension
 enum SymbolType {
     TYPE_INT,
@@ -45,14 +44,14 @@ struct STEntry {
 
     // Fields for function entries
     SymbolType functionReturnType;
-    std::vector<STEntry*> functionParams; // new implementation
+    std::vector<STEntry*> functionParams;
 
     // Functions with decl keyword
     bool isDeclaration = false;
 
     // Fields for array and ref entries
-    std::vector<int> arrayDimensions; // dimensions for arrays
-    bool isRef = false; // true if this is a reference type
+    std::vector<int> arrayDimensions;       // dimensions for arrays
+    bool isRef = false;                     // true if this is a reference type
 
     // If an entry is persistent, it will not be deleted when a scope is removed from the stack
     bool persistent = false;
@@ -131,15 +130,10 @@ class Scope {
             locals[name] = entry;
         }
 
-        bool isThereNameInLocals(const std::string& name) const {
-            return locals.find(name) != locals.end();
-        }
-
         STEntry* lookup(const std::string& name) {
             if (locals.find(name) == locals.end()) {
                 return nullptr;
             }
-            //printf("Found symbol: %s\n", name.c_str());
             return locals[name];
         }
 
@@ -171,11 +165,14 @@ class Scope {
             return locals;
         }
 
+        bool isThereNameInLocals(const std::string& name) const {
+            return locals.find(name) != locals.end();
+        }
+
         STEntry* searchPreviousDeclaration(const std::string& name) const {
-            //std::cout << "Searching for decl " << name << "...\n";
             if(locals.find(name) == locals.end())
                 return nullptr;
-            //std::cout << "Found it?\n";
+            
             STEntry* entry = locals.at(name);
             if(entry->isDeclaration && entry->type == TYPE_FUNCTION)
                 return entry;
@@ -186,10 +183,10 @@ class Scope {
     private:
         std::map<std::string, STEntry*> locals;
         int offset;
-        ScopeType scopeType = SCOPE_DEFAULT; // default scope type
+        ScopeType scopeType = SCOPE_DEFAULT;    // default scope type
 
         // Fields only for function scopes
-        SymbolType funcType = TYPE_VOID; // default function type
+        SymbolType funcType = TYPE_VOID;        // default function type
 
         bool canInsert(const std::string& name, SymbolType toInsert) const {
             if(locals.find(name) == locals.end()) 
@@ -260,12 +257,10 @@ class SymbolTable {
 
         void insert(const std::string& name, SymbolType type) {
             scopes.back().insert(name, type);
-            //std::cout << "Inserted Scope: " << name << " of type: " << symbolTypeToString(type) << std::endl;
         }
 
         void insert(const std::string& name, STEntry* entry) {
             scopes.back().insert(name, entry);
-            //std::cout << "Inserted symbol: " << name << " of type: " << symbolTypeToString(entry->type) << std::endl;
         }
 
         STEntry* lookup(const std::string& name) {
@@ -275,7 +270,6 @@ class SymbolTable {
                     return entry;
                 }
             }
-            //yyerror(("Symbol not found: " + name).c_str());
             return nullptr; // not found
         }
 
@@ -311,34 +305,22 @@ class SymbolTable {
         void enterScope(ScopeType scopeType = SCOPE_DEFAULT, SymbolType funcType = TYPE_VOID) {
             int offset = scopes.empty() ? 0 : scopes.back().getOffset();
             scopes.push_back(Scope(offset, scopeType, funcType));
-            //std::cout << "Entering scope with type: " 
-                          //<< scopeTypeToString(scopeType) 
-                          //<< " and function type: " 
-                          //<< symbolTypeToString(funcType) 
-                          //<< std::endl;
-            
-            //printf("Entered scope!\n");
         }
 
         void exitScope() {
             // clean the locals but for the persistent ones
             if(scopes.back().getLocals().empty()) {
                 //printf("Exiting empty scope\n");
             } else {
-                //printf("Exiting scope with %ld symbols\n", scopes.back().getLocals().size());
                 for(auto it = scopes.back().getLocals().begin(); it != scopes.back().getLocals().end(); it++) {
-                    //printf("it second is null ? %d\n", it->second == nullptr);
                     if(!it->second->persistent) {
-                        //printf("Deleting symbol: %s\n", it->first.c_str());
-                        delete it->second; // delete the entry
-                        it->second = nullptr; // set to null to avoid dangling pointer
+                        delete it->second;      // delete the entry
+                        it->second = nullptr;   // set to null to avoid dangling pointer
                     }
                 }
             }
 
-            //printf("Before pop scope...\n");
             scopes.pop_back();
-            //printf("Successfully exited scope\n");
         }
 
         void changeCurrentScopeType(ScopeType scopeType) {
@@ -353,6 +335,7 @@ class SymbolTable {
             return scopes.back();
         }
 
+        // For debugging purposes
         void printScopes() const {
             std::cout << "=== Symbol Table Scopes ===" << std::endl;
             for (size_t i = 0; i < scopes.size(); ++i) {