fixed stack frame bug

src/AstVisitor.cpp

@@ -373,7 +373,7 @@ std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::BinaryOperatio
     ast.opString << std::endl;
     if (!operationMethod) {
         throw SemanticError(SemanticError::OPERATOR_NOT_FOUND,
-            std::string("operator ") + ast.opString + " not found for types '" +
+            "operator " + ast.opString + " not found for types '" +
             leftEval->type->asString() + "' and '" + rightEval->type->asString() + "'",
             ast.opPos);
     }

src/CodeGeneration.cpp

@@ -9,6 +9,7 @@
 #include <llvm/IR/BasicBlock.h>
 #include <llvm/IR/Verifier.h>
 #include <llvm/IR/IRBuilder.h>
+#include <llvm/IR/Attributes.h>
 #include <llvm/Target/TargetMachine.h>
 #include <llvm/Support/TargetRegistry.h>
 #include <llvm/Support/TargetSelect.h>
@@ -65,18 +66,36 @@ std::unique_ptr<llvm::Module> generateModule(const sem::GlobalScope& objects)
         cl->llvmType = st;
     }
     
+    llvm::AttrBuilder ab;
+    ab.addAttribute(llvm::Attribute::AttrKind::NoInline);
+    ab.addAttribute(llvm::Attribute::AttrKind::NoUnwind);
+    //ab.addAttribute(llvm::Attribute::AttrKind::OptimizeNone);
+    //ab.addAttribute(llvm::Attribute::AttrKind::UWTable);
+    ab.addAttribute("no-frame-pointer-elim", "true");
+    ab.addAttribute("no-frame-pointer-elim-non-leaf");
+    llvm::AttributeSet as = llvm::AttributeSet::get(context, ab);
+    
+    
     std::vector<llvm::Function*> functions;
     auto verifyStream = llvm::raw_os_ostream(logger.debug());
     
     // create all llvm functions
     for (auto& [name, cl] : objects.classes) {
         for (auto& [name, method] : cl->methods) {
-            functions.push_back(generateFunction(module.get(), method.get()));
+            Function* func = generateFunction(module.get(), method.get());
+            for (auto a : as) {
+                func->addFnAttr(a);
+            }
+            functions.push_back(func);
         }
     }
     
     for (auto& [name, method] : objects.functions) {
-        functions.push_back(generateFunction(module.get(), method.get()));
+        Function* func = generateFunction(module.get(), method.get());
+        for (auto a : as) {
+            func->addFnAttr(a);
+        }
+        functions.push_back(func);
     }
 
     for (auto& [name, cl] : objects.classes){
@@ -84,7 +103,7 @@ std::unique_ptr<llvm::Module> generateModule(const sem::GlobalScope& objects)
             if (!method->body)
                 continue;
             
-            FunctionGenerator fg(*method, module.get());
+            FunctionGenerator fg(*method, module.get(), as);
             Function* f = fg.generate();
             logger.debug() << "verifying function: " << method->name << std::endl;
             bool corrupt = llvm::verifyFunction(*f, &verifyStream);
@@ -101,7 +120,7 @@ std::unique_ptr<llvm::Module> generateModule(const sem::GlobalScope& objects)
         if (!method->body)
             continue;
         
-        FunctionGenerator fg(*method, module.get());
+        FunctionGenerator fg(*method, module.get(), as);
         Function* f = fg.generate();
         logger.debug() << "verifying function: " << method->name << std::endl;
         bool corrupt = llvm::verifyFunction(*f, &verifyStream);
@@ -188,7 +207,9 @@ void generateObjectFile(const std::string& filename, std::unique_ptr<llvm::Modul
     Logger& logger = Logger::getInstance();
     logger.debug() << "verifying mod" << std::endl;
     auto ostr = llvm::raw_os_ostream(logger.debug());
+#ifdef DEBUGGING
     module->print(ostr, nullptr);
+#endif
     bool broken = llvm::verifyModule(*module);
     
     if (broken)
@@ -231,13 +252,15 @@ void generateObjectFile(const std::string& filename, std::unique_ptr<llvm::Modul
 
     TargetOptions targetOptions;
     auto relocModel = llvm::Optional<llvm::Reloc::Model>(llvm::Reloc::Model::PIC_);
-    std::unique_ptr<TargetMachine> targetMachine(target->createTargetMachine(targetTriple, cpu,
+    std::unique_ptr<TargetMachine> targetMachine(
+        target->createTargetMachine(targetTriple, cpu,
             features, targetOptions, relocModel));
 
     std::error_code errorCode;
     raw_fd_ostream dest(filename, errorCode, llvm::sys::fs::F_None);
-    targetMachine->addPassesToEmitFile(pm, dest, llvm::LLVMTargetMachine::CGFT_ObjectFile,
-            llvm::TargetMachine::CGFT_ObjectFile);
+    targetMachine->addPassesToEmitFile(pm, dest,
+//        llvm::LLVMTargetMachine::CGFT_ObjectFile,
+        llvm::TargetMachine::CGFT_ObjectFile);
 
     pm.run(*module);
     dest.flush();

src/CodeGeneration.h

@@ -25,6 +25,7 @@ class qlow::gen::FunctionGenerator
 {
     const sem::Method& method;
     llvm::Module* module;
+    llvm::AttributeSet& attributes;
 
     std::stack<llvm::BasicBlock*> basicBlocks;
 
@@ -34,9 +35,11 @@ public:
     ExpressionCodegenVisitor expressionVisitor;
     LValueVisitor lvalueVisitor;
 
-    inline FunctionGenerator(const sem::Method& m, llvm::Module* module) :
+    inline FunctionGenerator(const sem::Method& m, llvm::Module* module,
+        llvm::AttributeSet& attributes) :
         method{ m },
         module{ module },
+        attributes{ attributes },
         expressionVisitor{ *this }
     {
     }

src/parser.y

@@ -168,16 +168,16 @@ typedef qlow::CodePosition QLOW_PARSER_LTYPE;
 %destructor { } <topLevel> // don't delete everything ;)
 %destructor { if ($$) delete $$; } <*>
 
-%left DOT
-%left AS 
-%left ASTERISK SLASH
-%left PLUS MINUS
-%left EQUALS
-%left NOT
-%left AND
-%left OR XOR
-%left CUSTOM_OPERATOR
 %left ASSIGN
+%left CUSTOM_OPERATOR
+%left OR XOR
+%left AND
+%left NOT
+%left EQUALS
+%left PLUS MINUS
+%left ASTERISK SLASH
+%left AS 
+%left DOT
 
 %start topLevel
 
@@ -529,11 +529,66 @@ operationExpression:
 
 
 binaryOperation:
-    expression operator expression {
+    expression PLUS expression {
         $$ = new BinaryOperation(std::unique_ptr<Expression>($1), 
             std::unique_ptr<Expression>($3), *$2, @$, @2);
         delete $2; $2 = nullptr;
-    };
+    }
+    |
+    expression MINUS expression {
+        $$ = new BinaryOperation(std::unique_ptr<Expression>($1), 
+            std::unique_ptr<Expression>($3), *$2, @$, @2);
+        delete $2; $2 = nullptr;
+    }
+    |
+    expression ASTERISK expression {
+        $$ = new BinaryOperation(std::unique_ptr<Expression>($1), 
+            std::unique_ptr<Expression>($3), *$2, @$, @2);
+        delete $2; $2 = nullptr;
+    }
+    |
+    expression SLASH expression {
+        $$ = new BinaryOperation(std::unique_ptr<Expression>($1), 
+            std::unique_ptr<Expression>($3), *$2, @$, @2);
+        delete $2; $2 = nullptr;
+    }
+    |
+    expression EQUALS expression {
+        $$ = new BinaryOperation(std::unique_ptr<Expression>($1), 
+            std::unique_ptr<Expression>($3), *$2, @$, @2);
+        delete $2; $2 = nullptr;
+    }
+    |
+    expression NOT_EQUALS expression {
+        $$ = new BinaryOperation(std::unique_ptr<Expression>($1), 
+            std::unique_ptr<Expression>($3), *$2, @$, @2);
+        delete $2; $2 = nullptr;
+    }
+    |
+    expression AND expression {
+        $$ = new BinaryOperation(std::unique_ptr<Expression>($1), 
+            std::unique_ptr<Expression>($3), *$2, @$, @2);
+        delete $2; $2 = nullptr;
+    }
+    |
+    expression OR expression {
+        $$ = new BinaryOperation(std::unique_ptr<Expression>($1), 
+            std::unique_ptr<Expression>($3), *$2, @$, @2);
+        delete $2; $2 = nullptr;
+    }
+    |
+    expression XOR expression {
+        $$ = new BinaryOperation(std::unique_ptr<Expression>($1), 
+            std::unique_ptr<Expression>($3), *$2, @$, @2);
+        delete $2; $2 = nullptr;
+    }
+    |
+    expression CUSTOM_OPERATOR expression {
+        $$ = new BinaryOperation(std::unique_ptr<Expression>($1), 
+            std::unique_ptr<Expression>($3), *$2, @$, @2);
+        delete $2; $2 = nullptr;
+    }
+    ;
 
 
 unaryOperation:

src/tests/structs.qlw

@@ -15,27 +15,30 @@ class Vec
         y := y + 1
     end
 
+    inner_product: Integer do
+        return x * x + y * y
+    end
+
     get_sum: Integer do
         return x + y
     end
 end
 
 
+nothing do
+    var: Vec
+    var.x := 1
+    var.y := 1
+end
+
+
 main: Integer do
     var: Vec
-    value: Integer
-    value := 2
-
-    var.x := value + 10
-    var.y := 100
-
-    //var.x := 2
-    value := var.yuhu
-    var.increment_both
-    value := var.get_sum
-//    var.x := 4
-//    var.hohoo := 4
-    return value
+
+    var.x := 3
+    var.y := 4
+
+    return var.inner_product
 end