WIP: slang to C++ code generation (shader-slang#997)

* WIP: Emitting Cpp

* Added HLSLType instead of using IRInst - because they don't seem to be deduped.

* Removed need for lexer to take a String.
Added mechansim to lookup intrinsic functions on C++.

* A c/c++ cross compilation test.

* WIP Cpp output using cloning and slang types.

* More work to generate mul funcs.

* WIP: Outputting some simple C++.

* Expose findOrEmitHoistableInst to IRBuilder to aid cloning,

* Simplification for checking for BasicTypes.
Test infrastructure compiles output C++ code.

* Dot and mat/vec multiplication output.

* First pass at swizzling.

* First support for binary ops.

* Builtin binary and unary functions.

* Any and all.

* WIP adding support for other functions.
Added code to generate function signature.

* Add scalar functions to slang-cpp-prelude.h

* Support for most built in operations.

* Tested first ternary.

* Checking the emitting of corner cases functions - normalize, length, any, all, normalize, reflect.

* Check asfloat etc work.

* Fmod support.

* WIP Array handling in C++.

* First stage in being able to handl arbitrary type output for CLikeSourceEmitter

* Removed Handler/Emitter split - so can implement more easily complex type naming.

* Array passing by value first pass.

* Rename Array -> FixedArray

* Outputs structs in C++.

* Emit the thread config.

* Dimension -> TypeDimension

* SpecializedOperation -> SpecializedIntrinsic
Operation -> IntrinsicOp
Use shared impl of isNominalOp
Commented use of m_uniqueModule etc.

* Add code to test slang->cpp when compiled doesn't have errors. Does so by building shared library and exporting the entry point.

* Fix linux clang/gcc compile error about override not being specified.

* Make sure c-cross-compile is run on linux targets/smoke.

* Remove c-cross-compile.slang from smoke.

* Fix running tests/cross-compile/c-cross-compile.slang on Ubuntu 16.04

* Only add -std=c++11 for C++ source.

Author: jsmall-zzz

source/core/slang-gcc-compiler-util.cpp

@@ -338,6 +338,12 @@ static SlangResult _parseGCCFamilyLine(const UnownedStringSlice& line, LineParse
 /* static */void GCCCompilerUtil::calcArgs(const CompileOptions& options, CommandLine& cmdLine)
 {
     cmdLine.addArg("-fvisibility=hidden");
+
+    if (options.sourceType == SourceType::CPP)
+    {
+        cmdLine.addArg("-std=c++11");
+    }
+
     // Use shared libraries
     //cmdLine.addArg("-shared");
 
@@ -454,6 +460,8 @@ static SlangResult _parseGCCFamilyLine(const UnownedStringSlice& line, LineParse
     {
         // Make STD libs available
         cmdLine.addArg("-lstdc++");
+	// Make maths lib available
+        cmdLine.addArg("-lm");
     }
 }
 

source/slang/slang-emit-c-like.cpp

@@ -34,17 +34,16 @@ struct CLikeSourceEmitter::EDeclarator
 {
     enum class Flavor
     {
-        name,
+        Name,
         Array,
         UnsizedArray,
     };
     Flavor flavor;
     EDeclarator* next = nullptr;
 
     // Used for `Flavor::name`
-    Name*       name;
-    SourceLoc   loc;
-
+    const StringSliceLoc* nameAndLoc;
+    
     // Used for `Flavor::Array`
     IRInst* elementCount;
 };
@@ -149,8 +148,8 @@ void CLikeSourceEmitter::emitDeclarator(EDeclarator* declarator)
 
     switch (declarator->flavor)
     {
-    case EDeclarator::Flavor::name:
-        m_writer->emitName(declarator->name, declarator->loc);
+    case EDeclarator::Flavor::Name:
+        m_writer->emitName(*declarator->nameAndLoc);
         break;
 
     case EDeclarator::Flavor::Array:
@@ -250,40 +249,57 @@ void CLikeSourceEmitter::_emitType(IRType* type, EDeclarator* declarator)
 
 }
 
-void CLikeSourceEmitter::emitType(
-    IRType*             type,
-    SourceLoc const&    typeLoc,
-    Name*               name,
-    SourceLoc const&    nameLoc)
+void CLikeSourceEmitter::emitTypeImpl(IRType* type, const StringSliceLoc* nameAndLoc)
 {
-    m_writer->advanceToSourceLocation(typeLoc);
+    if (nameAndLoc)
+    {
+        // TODO(JS): No call to the previous version of this method was passing in a typeLoc, so disabled for
+        // now for simplicity
+        //m_writer->advanceToSourceLocation(typeLoc);
 
-    EDeclarator nameDeclarator;
-    nameDeclarator.flavor = EDeclarator::Flavor::name;
-    nameDeclarator.name = name;
-    nameDeclarator.loc = nameLoc;
-    _emitType(type, &nameDeclarator);
+        EDeclarator nameDeclarator;
+        nameDeclarator.flavor = EDeclarator::Flavor::Name;
+        nameDeclarator.nameAndLoc = nameAndLoc;
+        _emitType(type, &nameDeclarator);
+    }
+    else
+    {
+        _emitType(type, nullptr);
+    }
 }
 
 void CLikeSourceEmitter::emitType(IRType* type, Name* name)
 {
-    emitType(type, SourceLoc(), name, SourceLoc());
+    SLANG_ASSERT(name);
+    StringSliceLoc nameAndLoc(name->text.getUnownedSlice());
+    emitType(type, &nameAndLoc);
 }
 
 void CLikeSourceEmitter::emitType(IRType* type, const String& name)
 {
-    // HACK: the rest of the code wants a `Name`,
-    // so we'll create one for a bit...
-    Name tempName;
-    tempName.text = name;
+    StringSliceLoc nameAndLoc(name.getUnownedSlice());
+    emitType(type, &nameAndLoc);
+}
 
-    emitType(type, SourceLoc(), &tempName, SourceLoc());
+void CLikeSourceEmitter::emitType(IRType* type)
+{
+    emitType(type, (StringSliceLoc*)nullptr);
 }
 
+void CLikeSourceEmitter::emitType(IRType* type, Name* name, SourceLoc const& nameLoc)
+{
+    SLANG_ASSERT(name);
 
-void CLikeSourceEmitter::emitType(IRType* type)
+    StringSliceLoc nameAndLoc;
+    nameAndLoc.loc = nameLoc;
+    nameAndLoc.name = name->text.getUnownedSlice();
+    
+    emitType(type, &nameAndLoc);
+}
+
+void CLikeSourceEmitter::emitType(IRType* type, NameLoc const& nameAndLoc)
 {
-    _emitType(type, nullptr);
+    emitType(type, nameAndLoc.name, nameAndLoc.loc);
 }
 
 //
@@ -324,20 +340,6 @@ bool CLikeSourceEmitter::isTargetIntrinsicModifierApplicable(const String& targe
     }
 }
 
-void CLikeSourceEmitter::emitType(IRType* type, Name* name, SourceLoc const& nameLoc)
-{
-    emitType(
-        type,
-        SourceLoc(),
-        name,
-        nameLoc);
-}
-
-void CLikeSourceEmitter::emitType(IRType* type, NameLoc const& nameAndLoc)
-{
-    emitType(type, nameAndLoc.name, nameAndLoc.loc);
-}
-
 bool CLikeSourceEmitter::isTargetIntrinsicModifierApplicable(IRTargetIntrinsicDecoration* decoration)
 {
     auto targetName = String(decoration->getTargetName());
@@ -1533,12 +1535,10 @@ void CLikeSourceEmitter::emitIntrinsicCallExpr(
     //
     auto linkageDecoration = valueForName->findDecoration<IRLinkageDecoration>();
     SLANG_ASSERT(linkageDecoration);
-    auto mangledName = String(linkageDecoration->getMangledName());
-
-
+    
     // We will use the `MangledLexer` to
     // help us split the original name into its pieces.
-    MangledLexer lexer(mangledName);
+    MangledLexer lexer(linkageDecoration->getMangledName());
 
     // We'll read through the qualified name of the
     // symbol (e.g., `Texture2D<T>.Sample`) and then
@@ -1655,15 +1655,19 @@ void CLikeSourceEmitter::emitCallExpr(IRCall* inst, IREmitMode mode, EmitOpInfo
         maybeCloseParens(needClose);
     }
 }
-    
+
 void CLikeSourceEmitter::emitInstExpr(IRInst* inst, IREmitMode mode, const EmitOpInfo& inOuterPrec)
 {
     // Try target specific impl first
     if (tryEmitInstExprImpl(inst, mode, inOuterPrec))
     {
         return;
     }
+    defaultEmitInstExpr(inst, mode, inOuterPrec);
+}
 
+void CLikeSourceEmitter::defaultEmitInstExpr(IRInst* inst, IREmitMode mode, const EmitOpInfo& inOuterPrec)
+{
     EmitOpInfo outerPrec = inOuterPrec;
     bool needClose = false;
     switch(inst->op)

source/slang/slang-emit-c-like.h

@@ -133,15 +133,7 @@ class CLikeSourceEmitter: public RefObject
 
     void emitDeclarator(EDeclarator* declarator);
 
-    //void emitVectorTypeName(IRType* elementType, IRIntegerValue elementCount);
-    //void emitTextureType(IRTextureType* texType);
-    //void emitTextureSamplerType(IRTextureSamplerType* type);
-    //void emitImageType(IRGLSLImageType* type);
-    //void emitSamplerStateType(IRSamplerStateTypeBase* samplerStateType);
-    //void emitStructuredBufferType(IRHLSLStructuredBufferTypeBase* type);
-    //void emitUntypedBufferType(IRUntypedBufferResourceType* type);
-
-    void emitType(IRType* type, const SourceLoc& typeLoc, Name* name, const SourceLoc& nameLoc);
+    void emitType(IRType* type, const StringSliceLoc* nameLoc) { emitTypeImpl(type, nameLoc); }
     void emitType(IRType* type, Name* name);
     void emitType(IRType* type, String const& name);
     void emitType(IRType* type);
@@ -226,7 +218,8 @@ class CLikeSourceEmitter: public RefObject
     void emitCallExpr(IRCall* inst, IREmitMode mode, EmitOpInfo outerPrec);
 
     void emitInstExpr(IRInst* inst, IREmitMode mode, EmitOpInfo const& inOuterPrec);
-    
+    void defaultEmitInstExpr(IRInst* inst, IREmitMode mode, EmitOpInfo const& inOuterPrec);
+
     BaseType extractBaseType(IRType* inType);
 
     void emitInst(IRInst* inst, IREmitMode mode);
@@ -353,6 +346,7 @@ class CLikeSourceEmitter: public RefObject
     virtual void emitSimpleTypeImpl(IRType* type) = 0;
     virtual void emitVarDecorationsImpl(IRInst* varDecl) { SLANG_UNUSED(varDecl);  }
     virtual void emitMatrixLayoutModifiersImpl(VarLayout* layout) { SLANG_UNUSED(layout);  }
+    virtual void emitTypeImpl(IRType* type, const StringSliceLoc* nameLoc);
 
         // Only needed for glsl output with $ prefix intrinsics - so perhaps removable in the future
     virtual void emitTextureOrTextureSamplerTypeImpl(IRTextureTypeBase*  type, char const* baseName) { SLANG_UNUSED(type); SLANG_UNUSED(baseName); }