SkSL::Compiler Class Reference

#include <SkSLCompiler.h>

Public Types
enum class	OverrideFlag { kDefault , kOff , kOn }

Public Member Functions
	Compiler ()
	~Compiler ()
	Compiler (const Compiler &)=delete
Compiler &	operator= (const Compiler &)=delete
std::unique_ptr< Program >	convertProgram (ProgramKind kind, std::string programSource, const ProgramSettings &settings)
void	handleError (std::string_view msg, Position pos)
std::string	errorText (bool showCount=true)
ErrorReporter &	errorReporter ()
int	errorCount () const
void	writeErrorCount ()
void	resetErrors ()
Context &	context () const
SymbolTable *	globalSymbols ()
SymbolTable *	symbolTable ()
std::unique_ptr< Module >	compileModule (ProgramKind kind, const char *moduleName, std::string moduleSource, const Module *parentModule, bool shouldInline)
bool	optimizeModuleBeforeMinifying (ProgramKind kind, Module &module, bool shrinkSymbols)
const Module *	moduleForProgramKind (ProgramKind kind)
void	runInliner (Program &program)

Static Public Member Functions
static std::array< float, 4 >	GetRTAdjustVector (SkISize rtDims, bool flipY)
static std::array< float, 2 >	GetRTFlipVector (int rtHeight, bool flipY)
static void	EnableOptimizer (OverrideFlag flag)
static void	EnableInliner (OverrideFlag flag)

Static Public Attributes
static constexpr const char	FRAGCOLOR_NAME [] = "sk_FragColor"
static constexpr const char	RTADJUST_NAME [] = "sk_RTAdjust"
static constexpr const char	POSITION_NAME [] = "sk_Position"
static constexpr const char	POISON_TAG [] = "<POISON>"

Friends
class	Parser
class	ThreadContext

Detailed Description

Main compiler entry point. The compiler parses the SkSL text directly into a tree of IRNodes, while performing basic optimizations such as constant-folding and dead-code elimination. Then the Program is passed into a CodeGenerator to produce compiled output.

See the README for information about SkSL.

Definition at line 69 of file SkSLCompiler.h.

Member Enumeration Documentation

OverrideFlag

enum class SkSL::Compiler::OverrideFlag

strong

Allows optimization settings to be unilaterally overridden. This is meant to allow tools like Viewer or Nanobench to override the compiler's ProgramSettings and ShaderCaps for debugging.

Enumerator
kDefault
kOff
kOn

Definition at line 116 of file SkSLCompiler.h.

                            {
        kDefault,
        kOff,
        kOn,
    };

Constructor & Destructor Documentation

Compiler() [1/2]

SkSL::Compiler::Compiler

(

)

Definition at line 56 of file SkSLCompiler.cpp.

                   : fErrorReporter(this) {
    auto moduleLoader = ModuleLoader::Get();
    fContext = std::make_shared<Context>(moduleLoader.builtinTypes(), fErrorReporter);
}

~Compiler()

SkSL::Compiler::~Compiler

(

)

Definition at line 61 of file SkSLCompiler.cpp.

{}

Compiler() [2/2]

SkSL::Compiler::Compiler ( const Compiler &  )

delete

Member Function Documentation

compileModule()

std::unique_ptr< Module > SkSL::Compiler::compileModule	(	ProgramKind	kind,
		const char *	moduleName,
		std::string	moduleSource,
		const Module *	parentModule,
		bool	shouldInline
	)

Definition at line 175 of file SkSLCompiler.cpp.

                                                                   {
    SkASSERT(parentModule);
    SkASSERT(!moduleSource.empty());
    SkASSERT(this->errorCount() == 0);
 
    // Wrap the program source in a pointer so it is guaranteed to be stable across moves.
    auto sourcePtr = std::make_unique<std::string>(std::move(moduleSource));
 
    // Compile the module from source, using default program settings (but no memory pooling).
    ProgramSettings settings;
    settings.fUseMemoryPool = false;
    this->initializeContext(parentModule, kind, settings, *sourcePtr, /*isModule=*/true);
 
    std::unique_ptr<Module> module = SkSL::Parser(this, settings, kind, std::move(sourcePtr))
                                             .moduleInheritingFrom(parentModule);
 
    this->cleanupContext();
 
    if (this->errorCount() != 0) {
        SkDebugf("Unexpected errors compiling %s:\n\n%s\n", moduleName, this->errorText().c_str());
        return nullptr;
    }
    if (shouldInline) {
        this->optimizeModuleAfterLoading(kind, *module);
    }
    return module;
}

context()

Context & SkSL::Compiler::context ( ) const

inline

Definition at line 143 of file SkSLCompiler.h.

                             {
        return *fContext;
    }

convertProgram()

std::unique_ptr< Program > SkSL::Compiler::convertProgram	(	ProgramKind	kind,
		std::string	programSource,
		const ProgramSettings &	settings
	)

Definition at line 207 of file SkSLCompiler.cpp.

                                                                                   {
    TRACE_EVENT0("skia.shaders", "SkSL::Compiler::convertProgram");
 
    // Wrap the program source in a pointer so it is guaranteed to be stable across moves.
    auto sourcePtr = std::make_unique<std::string>(std::move(programSource));
 
    // Load the module used by this ProgramKind.
    const SkSL::Module* module = this->moduleForProgramKind(kind);
 
    this->initializeContext(module, kind, settings, *sourcePtr, /*isModule=*/false);
 
    std::unique_ptr<Program> program = SkSL::Parser(this, settings, kind, std::move(sourcePtr))
                                               .programInheritingFrom(module);
 
    this->cleanupContext();
    return program;
}

EnableInliner()

static void SkSL::Compiler::EnableInliner ( OverrideFlag  flag )

inlinestatic

Definition at line 122 of file SkSLCompiler.h.

{ sInliner = flag; }

EnableOptimizer()

static void SkSL::Compiler::EnableOptimizer ( OverrideFlag  flag )

inlinestatic

Definition at line 121 of file SkSLCompiler.h.

{ sOptimizer = flag; }

errorCount()

int SkSL::Compiler::errorCount ( ) const

inline

Definition at line 134 of file SkSLCompiler.h.

{ return fContext->fErrors->errorCount(); }

errorReporter()

ErrorReporter & SkSL::Compiler::errorReporter ( )

inline

Definition at line 132 of file SkSLCompiler.h.

{ return *fContext->fErrors; }

errorText()

std::string SkSL::Compiler::errorText

(

bool

showCount = true

)

Definition at line 512 of file SkSLCompiler.cpp.

                                            {
    if (showCount) {
        this->writeErrorCount();
    }
    std::string result = fErrorText;
    this->resetErrors();
    return result;
}

GetRTAdjustVector()

static std::array< float, 4 > SkSL::Compiler::GetRTAdjustVector ( SkISize  rtDims, bool  flipY  )

inlinestatic

Gets a float4 that adjusts the position from Skia device coords to normalized device coords, used to populate sk_RTAdjust. Assuming the transformed position, pos, is a homogeneous float4, the vec, v, is applied as such: float4((pos.xy * v.xz) + sk_Position.ww * v.yw, 0, pos.w);

Definition at line 82 of file SkSLCompiler.h.

                                                                            {
        std::array<float, 4> result;
        result[0] = 2.f/rtDims.width();
        result[2] = 2.f/rtDims.height();
        result[1] = -1.f;
        result[3] = -1.f;
        if (flipY) {
            result[2] = -result[2];
            result[3] = -result[3];
        }
        return result;
    }

GetRTFlipVector()

static std::array< float, 2 > SkSL::Compiler::GetRTFlipVector ( int  rtHeight, bool  flipY  )

inlinestatic

Uniform values used by the compiler to implement origin-neutral dFdy, sk_Clockwise, and sk_FragCoord.

Definition at line 99 of file SkSLCompiler.h.

                                                                        {
        std::array<float, 2> result;
        result[0] = flipY ? rtHeight : 0.f;
        result[1] = flipY ?     -1.f : 1.f;
        return result;
    }

globalSymbols()

SymbolTable * SkSL::Compiler::globalSymbols ( )

inline

Definition at line 147 of file SkSLCompiler.h.

                                 {
        return fGlobalSymbols.get();
    }

handleError()

void SkSL::Compiler::handleError	(	std::string_view	msg,
		Position	pos
	)

Definition at line 433 of file SkSLCompiler.cpp.

                                                           {
    fErrorText += "error: ";
    bool printLocation = false;
    std::string_view src = this->errorReporter().source();
    int line = -1;
    if (pos.valid()) {
        line = pos.line(src);
        printLocation = pos.startOffset() < (int)src.length();
        fErrorText += std::to_string(line) + ": ";
    }
    fErrorText += std::string(msg) + "\n";
    if (printLocation) {
        const int kMaxSurroundingChars = 100;
 
        // Find the beginning of the line.
        int lineStart = pos.startOffset();
        while (lineStart > 0) {
            if (src[lineStart - 1] == '\n') {
                break;
            }
            --lineStart;
        }
 
        // We don't want to show more than 100 characters surrounding the error, so push the line
        // start forward and add a leading ellipsis if there would be more than this.
        std::string lineText;
        std::string caretText;
        if ((pos.startOffset() - lineStart) > kMaxSurroundingChars) {
            lineStart = pos.startOffset() - kMaxSurroundingChars;
            lineText = "...";
            caretText = "   ";
        }
 
        // Echo the line. Again, we don't want to show more than 100 characters after the end of the
        // error, so truncate with a trailing ellipsis if needed.
        const char* lineSuffix = "...\n";
        int lineStop = pos.endOffset() + kMaxSurroundingChars;
        if (lineStop >= (int)src.length()) {
            lineStop = src.length() - 1;
            lineSuffix = "\n";  // no ellipsis if we reach end-of-file
        }
        for (int i = lineStart; i < lineStop; ++i) {
            char c = src[i];
            if (c == '\n') {
                lineSuffix = "\n";  // no ellipsis if we reach end-of-line
                break;
            }
            switch (c) {
                case '\t': lineText += "    "; break;
                case '\0': lineText += " ";    break;
                default:   lineText += src[i]; break;
            }
        }
        fErrorText += lineText + lineSuffix;
 
        // print the carets underneath it, pointing to the range in question
        for (int i = lineStart; i < (int)src.length(); i++) {
            if (i >= pos.endOffset()) {
                break;
            }
            switch (src[i]) {
                case '\t':
                   caretText += (i >= pos.startOffset()) ? "^^^^" : "    ";
                   break;
                case '\n':
                    SkASSERT(i >= pos.startOffset());
                    // use an ellipsis if the error continues past the end of the line
                    caretText += (pos.endOffset() > i + 1) ? "..." : "^";
                    i = src.length();
                    break;
                default:
                    caretText += (i >= pos.startOffset()) ? '^' : ' ';
                    break;
            }
        }
        fErrorText += caretText + '\n';
    }
}

moduleForProgramKind()

const Module * SkSL::Compiler::moduleForProgramKind

(

ProgramKind

kind

)

Definition at line 63 of file SkSLCompiler.cpp.

                                                             {
    auto m = ModuleLoader::Get();
    switch (kind) {
        case ProgramKind::kFragment:              return m.loadFragmentModule(this);
        case ProgramKind::kVertex:                return m.loadVertexModule(this);
        case ProgramKind::kCompute:               return m.loadComputeModule(this);
        case ProgramKind::kGraphiteFragment:      return m.loadGraphiteFragmentModule(this);
        case ProgramKind::kGraphiteVertex:        return m.loadGraphiteVertexModule(this);
        case ProgramKind::kGraphiteFragmentES2:   return m.loadGraphiteFragmentES2Module(this);
        case ProgramKind::kGraphiteVertexES2:     return m.loadGraphiteVertexES2Module(this);
        case ProgramKind::kPrivateRuntimeShader:  return m.loadPrivateRTShaderModule(this);
        case ProgramKind::kRuntimeColorFilter:
        case ProgramKind::kRuntimeShader:
        case ProgramKind::kRuntimeBlender:
        case ProgramKind::kPrivateRuntimeColorFilter:
        case ProgramKind::kPrivateRuntimeBlender:
        case ProgramKind::kMeshVertex:
        case ProgramKind::kMeshFragment:          return m.loadPublicModule(this);
    }
    SkUNREACHABLE;
}

operator=()

Compiler & SkSL::Compiler::operator= ( const Compiler &  )

delete

optimizeModuleBeforeMinifying()

bool SkSL::Compiler::optimizeModuleBeforeMinifying	(	ProgramKind	kind,
		Module &	module,
		bool	shrinkSymbols
	)

Optimize a module at minification time, before writing it out.

Definition at line 247 of file SkSLCompiler.cpp.

                                                                                                 {
    SkASSERT(this->errorCount() == 0);
 
    auto m = SkSL::ModuleLoader::Get();
 
    // Create a temporary program configuration with default settings.
    ProgramConfig config;
    config.fIsBuiltinCode = true;
    config.fKind = kind;
    AutoProgramConfig autoConfig(this->context(), &config);
 
    std::unique_ptr<ProgramUsage> usage = Analysis::GetUsage(module);
 
    if (shrinkSymbols) {
        // Assign shorter names to symbols as long as it won't change the external meaning of the
        // code.
        Transform::RenamePrivateSymbols(this->context(), module, usage.get(), kind);
 
        // Replace constant variables with their literal values to save space.
        Transform::ReplaceConstVarsWithLiterals(module, usage.get());
    }
 
    // Remove any unreachable code.
    Transform::EliminateUnreachableCode(module, usage.get());
 
    // We can only remove dead functions from runtime shaders, since runtime-effect helper functions
    // are isolated from other parts of the program. In a module, an unreferenced function is
    // intended to be called by the code that includes the module.
    if (kind == ProgramKind::kRuntimeShader) {
        while (Transform::EliminateDeadFunctions(this->context(), module, usage.get())) {
            // Removing dead functions may cause more functions to become unreferenced. Try again.
        }
    }
 
    while (Transform::EliminateDeadLocalVariables(this->context(), module, usage.get())) {
        // Removing dead variables may cause more variables to become unreferenced. Try again.
    }
 
    // Runtime shaders are isolated from other parts of the program via name mangling, so we can
    // eliminate public globals if they aren't referenced. Otherwise, we only eliminate private
    // globals (prefixed with `$`) to avoid changing the meaning of the module code.
    bool onlyPrivateGlobals = !ProgramConfig::IsRuntimeEffect(kind);
    while (Transform::EliminateDeadGlobalVariables(this->context(), module, usage.get(),
                                                   onlyPrivateGlobals)) {
        // Repeat until no changes occur.
    }
 
    // We eliminate empty statements to avoid runs of `;;;;;;` caused by the previous passes.
    SkSL::Transform::EliminateEmptyStatements(module);
 
    // We can eliminate `{}` around single-statement blocks.
    SkSL::Transform::EliminateUnnecessaryBraces(module);
 
    // Make sure that program usage is still correct after the optimization pass is complete.
    SkASSERT(*usage == *Analysis::GetUsage(module));
 
    return this->errorCount() == 0;
}

resetErrors()

void SkSL::Compiler::resetErrors ( )

inline

Definition at line 138 of file SkSLCompiler.h.

                       {
        fErrorText.clear();
        this->errorReporter().resetErrorCount();
    }

runInliner()

void SkSL::Compiler::runInliner

(

Program &

program

)

Run the inliner on a program which was compiled earlier (with inlining turned off).

Definition at line 370 of file SkSLCompiler.cpp.

                                          {
#ifndef SK_ENABLE_OPTIMIZE_SIZE
    AutoProgramConfig autoConfig(this->context(), program.fConfig.get());
    Inliner inliner(fContext.get());
    this->runInliner(&inliner, program.fOwnedElements, program.fSymbols.get(),
                     program.fUsage.get());
#endif
}

symbolTable()

SymbolTable * SkSL::Compiler::symbolTable ( )

inline

Definition at line 151 of file SkSLCompiler.h.

                               {
        return fContext->fSymbolTable;
    }

writeErrorCount()

void SkSL::Compiler::writeErrorCount

(

)

Definition at line 521 of file SkSLCompiler.cpp.

                               {
    int count = this->errorCount();
    if (count) {
        fErrorText += std::to_string(count) +
                      ((count == 1) ? " error\n" : " errors\n");
    }
}

Friends And Related Function Documentation

Parser

friend class Parser

friend

Definition at line 230 of file SkSLCompiler.h.

ThreadContext

friend class ThreadContext

friend

Definition at line 231 of file SkSLCompiler.h.

Member Data Documentation

FRAGCOLOR_NAME

constexpr const char SkSL::Compiler::FRAGCOLOR_NAME[] = "sk_FragColor"

inlinestaticconstexpr

Definition at line 71 of file SkSLCompiler.h.

POISON_TAG

constexpr const char SkSL::Compiler::POISON_TAG[] = "<POISON>"

inlinestaticconstexpr

Definition at line 74 of file SkSLCompiler.h.

POSITION_NAME

constexpr const char SkSL::Compiler::POSITION_NAME[] = "sk_Position"

inlinestaticconstexpr

Definition at line 73 of file SkSLCompiler.h.

RTADJUST_NAME

constexpr const char SkSL::Compiler::RTADJUST_NAME[] = "sk_RTAdjust"

inlinestaticconstexpr

Definition at line 72 of file SkSLCompiler.h.

---

The documentation for this class was generated from the following files:

• third_party/skia/src/sksl/SkSLCompiler.h
• third_party/skia/src/sksl/SkSLCompiler.cpp