WAST::ModulePrintContext Struct Reference

Collaboration diagram for WAST::ModulePrintContext:

Public Member Functions
	ModulePrintContext (const Module &inModule, std::string &inString)
void	printModule ()
void	printInitializerExpression (const InitializerExpression &expression)

Public Attributes
const Module &	module
std::string &	string
DisassemblyNames	names

Detailed Description

Definition at line 160 of file Print.cpp.

Constructor & Destructor Documentation

ModulePrintContext()

WAST::ModulePrintContext::ModulePrintContext ( const Module & inModule, std::string & inString )

inline

Definition at line 167 of file Print.cpp.

        : module(inModule), string(inString)
        {
            // Start with the names from the module's user name section, but make sure they are unique, and add the "$" sigil.
            IR::getDisassemblyNames(module,names);
            NameScope globalNameScope('$');
            for(auto& name : names.types) { globalNameScope.map(name); }
            for(auto& name : names.tables) { globalNameScope.map(name); }
            for(auto& name : names.memories) { globalNameScope.map(name); }
            for(auto& name : names.globals) { globalNameScope.map(name); }
            for(auto& function : names.functions)
            {
                globalNameScope.map(function.name);
 
                NameScope localNameScope('$');
                for(auto& name : function.locals) { localNameScope.map(name); }
            }
        }

Here is the call graph for this function:

Member Function Documentation

printInitializerExpression()

void WAST::ModulePrintContext::printInitializerExpression ( const InitializerExpression & expression )

inline

Definition at line 188 of file Print.cpp.

        {
            switch(expression.type)
            {
            case InitializerExpression::Type::i32_const: string += "(i32.const " + std::to_string(expression.i32) + ')'; break;
            case InitializerExpression::Type::i64_const: string += "(i64.const " + std::to_string(expression.i64) + ')'; break;
            case InitializerExpression::Type::f32_const: string += "(f32.const " + Floats::asString(expression.f32) + ')'; break;
            case InitializerExpression::Type::f64_const: string += "(f64.const " + Floats::asString(expression.f64) + ')'; break;
            case InitializerExpression::Type::get_global: string += "(get_global " + names.globals[expression.globalIndex] + ')'; break;
            default: Errors::unreachable();
            };
        }

Here is the call graph for this function:

Here is the caller graph for this function:

printModule()

void WAST::ModulePrintContext::printModule

(

)

Definition at line 477 of file Print.cpp.

    {
        ScopedTagPrinter moduleTag(string,"module");
        
        // Print the types.
        for(Uptr typeIndex = 0;typeIndex < module.types.size();++typeIndex)
        {
            string += '\n';
            ScopedTagPrinter typeTag(string,"type");
            string += ' ';
            string += names.types[typeIndex];
            string += " (func ";
            print(string,module.types[typeIndex]);
            string += ')';
        }
 
        // Print the module imports.
        for(Uptr importIndex = 0;importIndex < module.functions.imports.size();++importIndex)
        {
            printImport(string,module,module.functions.imports[importIndex],importIndex,names.functions[importIndex].name.c_str(),"func");
        }
        for(Uptr importIndex = 0;importIndex < module.tables.imports.size();++importIndex)
        {
            printImport(string,module,module.tables.imports[importIndex],importIndex,names.tables[importIndex].c_str(),"table");
        }
        for(Uptr importIndex = 0;importIndex < module.memories.imports.size();++importIndex)
        {
            printImport(string,module,module.memories.imports[importIndex],importIndex,names.memories[importIndex].c_str(),"memory");
        }
        for(Uptr importIndex = 0;importIndex < module.globals.imports.size();++importIndex)
        {
            printImport(string,module,module.globals.imports[importIndex],importIndex,names.globals[importIndex].c_str(),"global");
        }
        // Print the module exports.
        for(auto export_ : module.exports)
        {
            string += '\n';
            ScopedTagPrinter exportTag(string,"export");
            string += " \"";
            string += escapeString(export_.name.c_str(),export_.name.length());
            string += "\" (";
            switch(export_.kind)
            {
            case ObjectKind::function: string += "func " + names.functions[export_.index].name; break;
            case ObjectKind::table: string += "table " + names.tables[export_.index]; break;
            case ObjectKind::memory: string += "memory " + names.memories[export_.index]; break;
            case ObjectKind::global: string += "global " + names.globals[export_.index]; break;
            default: Errors::unreachable();
            };
            string += ')';
        }
 
        // Print the module memory definitions.
        for(Uptr memoryDefIndex = 0;memoryDefIndex < module.memories.defs.size();++memoryDefIndex)
        {
            const MemoryDef& memoryDef = module.memories.defs[memoryDefIndex];
            string += '\n';
            ScopedTagPrinter memoryTag(string,"memory");
            string += ' ';
            string += names.memories[module.memories.imports.size() + memoryDefIndex];
            string += ' ';
            print(string,memoryDef.type);
        }
        
        // Print the module table definitions and elem segments.
        for(Uptr tableDefIndex = 0;tableDefIndex < module.tables.defs.size();++tableDefIndex)
        {
            const TableDef& tableDef = module.tables.defs[tableDefIndex];
            string += '\n';
            ScopedTagPrinter memoryTag(string,"table");
            string += ' ';
            string += names.tables[module.tables.imports.size() + tableDefIndex];
            string += ' ';
            print(string,tableDef.type);
        }
        
        // Print the module global definitions.
        for(Uptr globalDefIndex = 0;globalDefIndex < module.globals.defs.size();++globalDefIndex)
        {
            const GlobalDef& globalDef = module.globals.defs[globalDefIndex];
            string += '\n';
            ScopedTagPrinter memoryTag(string,"global");
            string += ' ';
            string += names.globals[module.globals.imports.size() + globalDefIndex];
            string += ' ';
            print(string,globalDef.type);
            string += ' ';
            printInitializerExpression(globalDef.initializer);
        }
        
        // Print the data and table segment definitions.
        for(auto tableSegment : module.tableSegments)
        {
            string += '\n';
            ScopedTagPrinter dataTag(string,"elem");
            string += ' ';
            string += names.tables[tableSegment.tableIndex];
            string += ' ';
            printInitializerExpression(tableSegment.baseOffset);
            enum { numElemsPerLine = 8 };
            for(Uptr elementIndex = 0;elementIndex < tableSegment.indices.size();++elementIndex)
            {
                if(elementIndex % numElemsPerLine == 0) { string += '\n'; }
                else { string += ' '; }
                string += names.functions[tableSegment.indices[elementIndex]].name;
            }
        }
        for(auto dataSegment : module.dataSegments)
        {
            string += '\n';
            ScopedTagPrinter dataTag(string,"data");
            string += ' ';
            string += names.memories[dataSegment.memoryIndex];
            string += ' ';
            printInitializerExpression(dataSegment.baseOffset);
            enum { numBytesPerLine = 64 };
            for(Uptr offset = 0;offset < dataSegment.data.size();offset += numBytesPerLine)
            {
                string += "\n\"";
                string += escapeString((const char*)dataSegment.data.data() + offset,std::min(dataSegment.data.size() - offset,(Uptr)numBytesPerLine));
                string += "\"";
            }
        }
 
        for(Uptr functionDefIndex = 0;functionDefIndex < module.functions.defs.size();++functionDefIndex)
        {
            const Uptr functionIndex = module.functions.imports.size() + functionDefIndex;
            const FunctionDef& functionDef = module.functions.defs[functionDefIndex];
            const FunctionType* functionType = module.types[functionDef.type.index];
            FunctionPrintContext functionContext(*this,functionDefIndex);
        
            string += "\n\n";
            ScopedTagPrinter funcTag(string,"func");
 
            string += ' ';
            string += names.functions[functionIndex].name;
            
            // Print the function parameters.
            if(functionType->parameters.size())
            {
                for(Uptr parameterIndex = 0;parameterIndex < functionType->parameters.size();++parameterIndex)
                {
                    string += '\n';
                    ScopedTagPrinter paramTag(string,"param");
                    string += ' ';
                    string += functionContext.localNames[parameterIndex];
                    string += ' ';
                    print(string,functionType->parameters[parameterIndex]);
                }
            }
 
            // Print the function return type.
            if(functionType->ret != ResultType::none)
            {
                string += '\n';
                ScopedTagPrinter resultTag(string,"result");
                string += ' ';
                print(string,functionType->ret);
            }
 
            // Print the function's locals.
            for(Uptr localIndex = 0;localIndex < functionDef.nonParameterLocalTypes.size();++localIndex)
            {
                string += '\n';
                ScopedTagPrinter localTag(string,"local");
                string += ' ';
                string += functionContext.localNames[functionType->parameters.size() + localIndex];
                string += ' ';
                print(string,functionDef.nonParameterLocalTypes[localIndex]);
            }
 
            functionContext.printFunctionBody();
        }
 
        // Print user sections (other than the name section).
        for(const auto& userSection : module.userSections)
        {
            if(userSection.name != "name")
            {
                string += '\n';
                ScopedTagPrinter dataTag(string,"user_section");
                string += " \"";
                string += escapeString(userSection.name.c_str(),userSection.name.length());
                string += "\" ";
                enum { numBytesPerLine = 64 };
                for(Uptr offset = 0;offset < userSection.data.size();offset += numBytesPerLine)
                {
                    string += "\n\"";
                    string += escapeString((const char*)userSection.data.data() + offset,std::min(userSection.data.size() - offset,(Uptr)numBytesPerLine));
                    string += "\"";
                }
            }
        }
    }

Here is the call graph for this function:

Member Data Documentation

module

const Module& WAST::ModulePrintContext::module

Definition at line 162 of file Print.cpp.

names

DisassemblyNames WAST::ModulePrintContext::names

Definition at line 165 of file Print.cpp.

string

std::string& WAST::ModulePrintContext::string

Definition at line 163 of file Print.cpp.

---

The documentation for this struct was generated from the following file:

• libraries/wasm-jit/Source/WAST/Print.cpp