Changes in src/CodeGen/FixMain.cc [61efa42:9939dc3]

File:

• src/CodeGen/FixMain.cc (modified) (7 diffs)

src/CodeGen/FixMain.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// FixMain.cc -- Tools to change a Cforall main into a C main.
+// FixMain.cc --
 //
 // Author           : Thierry Delisle
@@ -13 +13 @@
 // Update Count     : 0
 //
+
 
 #include "FixMain.h"
@@ -22 +23 @@
 
 #include "AST/Decl.hpp"
-#include "AST/Pass.hpp"
 #include "AST/Type.hpp"
-#include "AST/Vector.hpp"
+#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "CodeGen/GenType.h"       // for GenType
+#include "SynTree/Declaration.h"   // for FunctionDecl, operator<<
+#include "SynTree/Type.h"          // for FunctionType
 #include "SymTab/Mangler.h"
 
@@ -33 +35 @@
 namespace {
 
-struct FindMainCore final {
-        ast::FunctionDecl const * main_declaration = nullptr;
+struct FindMainCore {
+        FunctionDecl * main_signature = nullptr;
 
-        void previsit( ast::FunctionDecl const * decl ) {
-                if ( isMain( decl ) ) {
-                        if ( main_declaration ) {
+        void previsit( FunctionDecl * decl ) {
+                if ( FixMain::isMain( decl ) ) {
+                        if ( main_signature ) {
                                 SemanticError( decl, "Multiple definition of main routine\n" );
                         }
-                        main_declaration = decl;
+                        main_signature = decl;
                 }
         }
 };
 
-std::string genTypeAt( const ast::vector<ast::Type> & types, size_t at ) {
-        return genType( types[at], "", Options( false, false, false, false ) );
 }
 
-ast::ObjectDecl * makeIntObj(){
-        return new ast::ObjectDecl( CodeLocation(), "",
-                new ast::BasicType( ast::BasicType::SignedInt ) );
+        template<typename container>
+        std::string genTypeAt(const container& p, size_t idx) {
+                return genType((*std::next(p.begin(), idx))->get_type(), "");
+        }
+
+        void FixMain::fix( std::list< Declaration * > & translationUnit,
+                        std::ostream &os, const char* bootloader_filename ) {
+                PassVisitor< FindMainCore > main_finder;
+                acceptAll( translationUnit, main_finder );
+                FunctionDecl * main_signature = main_finder.pass.main_signature;
+
+                if( main_signature ) {
+                        os << "static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return ";
+                        main_signature->mangleName = SymTab::Mangler::mangle(main_signature);
+
+                        os << main_signature->get_scopedMangleName() << "(";
+                        const auto& params = main_signature->get_functionType()->get_parameters();
+                        switch(params.size()) {
+                                case 3: os << "(" << genTypeAt(params, 0) << ")argc, (" << genTypeAt(params, 1) << ")argv, (" << genTypeAt(params, 2) << ")envp"; break;
+                                case 2: os << "(" << genTypeAt(params, 0) << ")argc, (" << genTypeAt(params, 1) << ")argv"; break;
+                                case 0: break;
+                                default : assert(false);
+                        }
+                        os << "); }\n";
+
+                        std::ifstream bootloader(bootloader_filename, std::ios::in);
+                        assertf( bootloader.is_open(), "cannot open bootloader.c\n" );
+                        os << bootloader.rdbuf();
+                }
+        }
+
+namespace {
+
+ObjectDecl * signedIntObj() {
+        return new ObjectDecl(
+                "", Type::StorageClasses(), LinkageSpec::Cforall, 0,
+                new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr );
 }
 
-ast::ObjectDecl * makeCharStarStarObj() {
-        return new ast::ObjectDecl( CodeLocation(), "",
-                new ast::PointerType(
-                        new ast::PointerType(
-                                new ast::BasicType( ast::BasicType::Char ) ) ) );
+ObjectDecl * makeArgvObj() {
+        return new ObjectDecl(
+                "", Type::StorageClasses(), LinkageSpec::Cforall, 0,
+                new PointerType( Type::Qualifiers(),
+                        new PointerType( Type::Qualifiers(),
+                                new BasicType( Type::Qualifiers(), BasicType::Char ) ) ),
+                nullptr );
 }
 
-std::string getMangledNameOfMain(
-                ast::vector<ast::DeclWithType> && params, ast::ArgumentFlag isVarArgs ) {
-        ast::ptr<ast::FunctionDecl> decl = new ast::FunctionDecl(
-                CodeLocation(),
-                "main",
-                ast::vector<ast::TypeDecl>(),
-                ast::vector<ast::DeclWithType>(),
-                std::move( params ),
-                { makeIntObj() },
-                nullptr,
-                ast::Storage::Classes(),
-                ast::Linkage::Spec(),
-                ast::vector<ast::Attribute>(),
-                ast::Function::Specs(),
-                isVarArgs
-        );
-        return Mangle::mangle( decl.get() );
+std::string create_mangled_main_function_name( FunctionType * function_type ) {
+        std::unique_ptr<FunctionDecl> decl( new FunctionDecl(
+                "main", Type::StorageClasses(), LinkageSpec::Cforall,
+                function_type, nullptr ) );
+        return SymTab::Mangler::mangle( decl.get() );
 }
 
-std::string getMangledNameOf0ParameterMain() {
-        return getMangledNameOfMain( {}, ast::VariableArgs );
+std::string mangled_0_argument_main() {
+        FunctionType* main_type = new FunctionType( Type::Qualifiers(), true );
+        main_type->get_returnVals().push_back( signedIntObj() );
+        return create_mangled_main_function_name( main_type );
 }
 
-std::string getMangledNameOf2ParameterMain() {
-        return getMangledNameOfMain( {
-                makeIntObj(),
-                makeCharStarStarObj(),
-        }, ast::FixedArgs );
+std::string mangled_2_argument_main() {
+        FunctionType* main_type = new FunctionType( Type::Qualifiers(), false );
+        main_type->get_returnVals().push_back( signedIntObj() );
+        main_type->get_parameters().push_back( signedIntObj() );
+        main_type->get_parameters().push_back( makeArgvObj() );
+        return create_mangled_main_function_name( main_type );
 }
 
@@ -95 +122 @@
         // This breaks if you move it out of the function.
         static const std::string mangled_mains[] = {
-                getMangledNameOf0ParameterMain(),
-                getMangledNameOf2ParameterMain(),
-                //getMangledNameOf3ParameterMain(),
+                mangled_0_argument_main(),
+                mangled_2_argument_main(),
+                //mangled_3_argument_main(),
         };
 
@@ -106 +133 @@
 }
 
-struct FixLinkageCore final {
-        ast::Linkage::Spec const spec;
-        FixLinkageCore( ast::Linkage::Spec spec ) : spec( spec ) {}
-
-        ast::FunctionDecl const * previsit( ast::FunctionDecl const * decl ) {
-                if ( decl->name != "main" ) return decl;
-                return ast::mutate_field( decl, &ast::FunctionDecl::linkage, spec );
-        }
-};
-
 } // namespace
 
-bool isMain( const ast::FunctionDecl * decl ) {
+bool FixMain::isMain( FunctionDecl * decl ) {
+        if ( std::string("main") != decl->name ) {
+                return false;
+        }
+        return is_main( SymTab::Mangler::mangle( decl, true, true ) );
+}
+
+bool FixMain::isMain( const ast::FunctionDecl * decl ) {
         if ( std::string("main") != decl->name ) {
                 return false;
@@ -125 +149 @@
 }
 
-void fixMainLinkage( ast::TranslationUnit & translationUnit,
-                bool replace_main ) {
-        ast::Linkage::Spec const spec =
-                ( replace_main ) ? ast::Linkage::Cforall : ast::Linkage::C;
-        ast::Pass<FixLinkageCore>::run( translationUnit, spec );
-}
-
-void fixMainInvoke( ast::TranslationUnit & translationUnit,
-                std::ostream &os, const char * bootloader_filename ) {
-
-        ast::Pass<FindMainCore> main_finder;
-        ast::accept_all( translationUnit, main_finder );
-        if ( nullptr == main_finder.core.main_declaration ) return;
-
-        ast::FunctionDecl * main_declaration =
-                ast::mutate( main_finder.core.main_declaration );
-
-        main_declaration->mangleName = Mangle::mangle( main_declaration );
-
-        os << "static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return ";
-        os << main_declaration->scopedMangleName() << "(";
-        const auto& params = main_declaration->type->params;
-        switch ( params.size() ) {
-                case 3: os << "(" << genTypeAt(params, 0) << ")argc, (" << genTypeAt(params, 1) << ")argv, (" << genTypeAt(params, 2) << ")envp"; break;
-                case 2: os << "(" << genTypeAt(params, 0) << ")argc, (" << genTypeAt(params, 1) << ")argv"; break;
-                case 0: break;
-                default : assert(false);
-        }
-        os << "); }\n";
-
-        std::ifstream bootloader( bootloader_filename, std::ios::in );
-        assertf( bootloader.is_open(), "cannot open bootloader.c\n" );
-        os << bootloader.rdbuf();
-}
-
-} // namespace CodeGen
+};