Add dump:assembly for close-to-assembly output

Penguinwizzard · Penguinwizzard · commit 7f1d6445e12a · 2018-07-06T16:25:17.000-07:00
diff --git a/lib/Backend/Encoder.cpp b/lib/Backend/Encoder.cpp
@@ -320,6 +320,165 @@ Encoder::Encode()
         }
     }
 
+    // Assembly Dump Phase
+    // This phase exists to assist tooling that expects "assemblable" output - that is,
+    // output that, with minimal manual handling, could theoretically be fed to another
+    // assembler to make a valid function for the target platform. We don't guarantee a
+    // dump from this will _actually_ be assemblable, but it is significantly closer to
+    // that than our normal, annotated output
+#if DBG_DUMP
+    if (PHASE_DUMP(Js::AssemblyPhase, m_func))
+    {
+        FOREACH_INSTR_IN_FUNC(instr, m_func)
+        {
+            bool hasPrintedForOpnds = false;
+            Func* localScopeFuncForLambda = m_func;
+            auto printOpnd = [&hasPrintedForOpnds, localScopeFuncForLambda](IR::Opnd* opnd)
+            {
+                if (hasPrintedForOpnds)
+                {
+                    Output::Print(_u(", "));
+                }
+                switch (opnd->m_kind)
+                {
+                case IR::OpndKindInvalid:
+                    AssertMsg(false, "Should be unreachable");
+                    break;
+                case IR::OpndKindIntConst:
+                    Output::Print(_u("%lli"), (long long int)opnd->AsIntConstOpnd()->GetValue());
+                    break;
+                case IR::OpndKindInt64Const:
+                case IR::OpndKindFloatConst:
+                case IR::OpndKindFloat32Const:
+                case IR::OpndKindSimd128Const:
+                    AssertMsg(false, "Not Yet Implemented");
+                    break;
+                case IR::OpndKindHelperCall:
+                    Output::Print(_u("%s"), IR::GetMethodName(opnd->AsHelperCallOpnd()->m_fnHelper));
+                    break;
+                case IR::OpndKindSym:
+                    Output::Print(_u("SYM("));
+                    opnd->Dump(IRDumpFlags_SimpleForm, localScopeFuncForLambda);
+                    Output::Print(_u(")"));
+                    break;
+                case IR::OpndKindReg:
+                    Output::Print(_u("%S"), RegNames[opnd->AsRegOpnd()->GetReg()]);
+                    break;
+                case IR::OpndKindAddr:
+                    Output::Print(_u("0x%p"), opnd->AsAddrOpnd()->m_address);
+                    break;
+                case IR::OpndKindIndir:
+                {
+                    IR::IndirOpnd* indirOpnd = opnd->AsIndirOpnd();
+                    IR::RegOpnd* baseOpnd = indirOpnd->GetBaseOpnd();
+                    IR::RegOpnd* indexOpnd = indirOpnd->GetIndexOpnd();
+                    Output::Print(_u("["));
+                    bool hasPrintedComponent = false;
+                    if (baseOpnd != nullptr)
+                    {
+                        Output::Print(_u("%S"), RegNames[baseOpnd->GetReg()]);
+                        hasPrintedComponent = true;
+                    }
+                    if (indexOpnd != nullptr)
+                    {
+                        if (hasPrintedComponent)
+                        {
+                            Output::Print(_u(" + "));
+                        }
+                        Output::Print(_u("%S * %u"), RegNames[indexOpnd->GetReg()], indirOpnd->GetScale());
+                        hasPrintedComponent = true;
+                    }
+                    if (hasPrintedComponent)
+                    {
+                        Output::Print(_u(" + "));
+                    }
+                    Output::Print(_u("(%i)]"), indirOpnd->GetOffset());
+                    break;
+                }
+                case IR::OpndKindLabel:
+                    opnd->Dump(IRDumpFlags_SimpleForm, localScopeFuncForLambda);
+                    break;
+                case IR::OpndKindMemRef:
+                    opnd->DumpOpndKindMemRef(true, localScopeFuncForLambda);
+                    break;
+                case IR::OpndKindRegBV:
+                    AssertMsg(false, "Should be unreachable");
+                    break;
+                case IR::OpndKindList:
+                    AssertMsg(false, "Should be unreachable");
+                    break;
+                default:
+                    AssertMsg(false, "Missing operand type");
+                }
+                hasPrintedForOpnds = true;
+            };
+            switch(instr->GetKind())
+            {
+            case IR::InstrKindInvalid:
+                Assert(false);
+                break;
+            case IR::InstrKindJitProfiling:
+            case IR::InstrKindProfiled:
+            case IR::InstrKindInstr:
+            {
+                Output::SkipToColumn(4);
+                Output::Print(_u("%s "), Js::OpCodeUtil::GetOpCodeName(instr->m_opcode));
+                Output::SkipToColumn(18);
+                IR::Opnd* dst = instr->GetDst();
+                IR::Opnd* src1 = instr->GetSrc1();
+                IR::Opnd* src2 = instr->GetSrc2();
+                if (dst != nullptr && (src1 == nullptr || !dst->IsRegOpnd() || !src1->IsRegOpnd() || dst->AsRegOpnd()->GetReg() != src1->AsRegOpnd()->GetReg())) // Print dst if it's there, and not the same reg as src1 (which is usually an instr that has a srcdest
+                {
+                    printOpnd(dst);
+                }
+                if (src1 != nullptr)
+                {
+                    printOpnd(src1);
+                }
+                if (src2 != nullptr)
+                {
+                    printOpnd(src2);
+                }
+                break;
+            }
+            case IR::InstrKindBranch:
+                Output::SkipToColumn(4);
+                Output::Print(_u("%s "), Js::OpCodeUtil::GetOpCodeName(instr->m_opcode));
+                Output::SkipToColumn(18);
+                if (instr->AsBranchInstr()->IsMultiBranch())
+                {
+                    Assert(instr->GetSrc1() != nullptr);
+                    printOpnd(instr->GetSrc1());
+                }
+                else
+                {
+                    Output::Print(_u("L%u"), instr->AsBranchInstr()->GetTarget()->m_id);
+                }
+                break;
+            case IR::InstrKindProfiledLabel:
+            case IR::InstrKindLabel:
+                Output::Print(_u("L%u:"), instr->AsLabelInstr()->m_id);
+                break;
+            case IR::InstrKindEntry:
+            case IR::InstrKindExit:
+            case IR::InstrKindPragma:
+                // No output
+                break;
+            case IR::InstrKindByteCodeUses:
+                AssertMsg(false, "Instruction kind shouldn't be present here");
+                break;
+            default:
+                Assert(false);
+                break;
+            }
+            Output::SetAlignAndPrefix(60, _u("; "));
+            instr->Dump();
+            Output::ResetAlignAndPrefix();
+        } NEXT_INSTR_IN_FUNC;
+    }
+#endif
+    // End Assembly Dump Phase
+
     BEGIN_CODEGEN_PHASE(m_func, Js::EmitterPhase);
 
     // Copy to permanent buffer.
diff --git a/lib/Common/ConfigFlagsList.h b/lib/Common/ConfigFlagsList.h
@@ -257,6 +257,7 @@ PHASE(All)
         PHASE(PrologEpilog)
         PHASE(InsertNOPs)
         PHASE(Encoder)
+            PHASE(Assembly)
             PHASE(Emitter)
             PHASE(DebugBreak)
 #if defined(_M_IX86) || defined(_M_X64)
diff --git a/lib/Common/Core/Output.cpp b/lib/Common/Core/Output.cpp
@@ -46,6 +46,11 @@ THREAD_ST WORD     Output::s_color = 0;
 THREAD_ST bool     Output::s_hasColor = false;
 THREAD_ST bool     Output::s_capture = false;
 
+THREAD_ST bool     Output::hasDoneAlignPrefixForThisLine = false;
+THREAD_ST bool     Output::usingCustomAlignAndPrefix = false;
+THREAD_ST size_t   Output::align = 0;
+THREAD_ST const char16* Output::prefix = nullptr;
+
 #define MAX_OUTPUT_BUFFER_SIZE 10 * 1024 * 1024  // 10 MB maximum before we force a flush
 
 size_t __cdecl
@@ -282,6 +287,86 @@ Output::VPrint(const char16 *form, va_list argptr)
 size_t __cdecl
 Output::PrintBuffer(const char16 * buf, size_t size)
 {
+    // Handle custom line prefixing
+    bool internallyAllocatedBuffer = false;
+    if (usingCustomAlignAndPrefix)
+    {
+        if (hasDoneAlignPrefixForThisLine && wcschr(buf, '\n') == nullptr)
+        {
+            // no newlines, and we've already prefixed this line, so nothing to do
+        }
+        else
+        {
+            size_t newbufsize = size + align;
+            char16* newbuf = (char16*)calloc(newbufsize, sizeof(char16));
+            AssertOrFailFastMsg(newbuf != nullptr, "Ran out of memory while printing output");
+            internallyAllocatedBuffer = true;
+            const char16* currentReadIndex = buf;
+            char16* currentWriteIndex = newbuf;
+            auto ensureSpace = [&currentWriteIndex, &newbuf, &newbufsize](size_t numCharsWantToWrite)
+            {
+                size_t charsWritten = (currentWriteIndex - newbuf); // pointer subtraction is number of elements of pointed type between pointers
+                size_t remaining = newbufsize - charsWritten;
+                if (numCharsWantToWrite + 1 > remaining)
+                {
+                    char16* tempbuf = (char16*)realloc(newbuf, newbufsize * sizeof(char16) * 2);
+                    AssertOrFailFastMsg(tempbuf != nullptr, "Ran out of memory while printing output");
+                    newbuf = tempbuf;
+                    newbufsize = newbufsize * 2;
+                    currentWriteIndex = newbuf + charsWritten;
+                }
+            };
+            const size_t prefixlength = wcslen(prefix);
+            size_t oldS_Column = Output::s_Column;
+            while (currentReadIndex < buf + size)
+            {
+                if (!hasDoneAlignPrefixForThisLine)
+                {
+                    // attempt to write the alignment
+                    {
+                        unsigned int alignspacesneeded = 1; // always put at least one space
+                        if (oldS_Column < align)
+                        {
+                            alignspacesneeded = (unsigned int)(align - oldS_Column);
+                        }
+                        ensureSpace(alignspacesneeded);
+                        for (unsigned int i = 0; i < alignspacesneeded; i++)
+                        {
+                            *(currentWriteIndex++) = ' ';
+                        }
+                    }
+                    // attempt to write the prefix
+                    ensureSpace(prefixlength);
+                    js_wmemcpy_s(currentWriteIndex, (newbuf + newbufsize) - currentWriteIndex, Output::prefix, prefixlength);
+                    currentWriteIndex += prefixlength;
+                    oldS_Column = align + prefixlength;
+                    hasDoneAlignPrefixForThisLine = true;
+                }
+                const char16* endOfLine = wcschr(currentReadIndex, '\n');
+                size_t charsToCopy = 0;
+                if (endOfLine != nullptr)
+                {
+                    charsToCopy = (endOfLine - currentReadIndex) + 1; // We want to grab the newline character as part of this line
+                    oldS_Column = 0; // We're ending this line, and want the next to be calculated properly
+                    hasDoneAlignPrefixForThisLine = false; // The next line will need this
+                }
+                else
+                {
+                    charsToCopy = (buf + size) - currentReadIndex; // the rest of the input buffer
+                    oldS_Column += charsToCopy; // Will be reset anyway later on
+                }
+                ensureSpace(endOfLine - currentReadIndex);
+                js_wmemcpy_s(currentWriteIndex, (newbuf + newbufsize) - currentWriteIndex, currentReadIndex, charsToCopy);
+                currentReadIndex += charsToCopy;
+                currentWriteIndex += charsToCopy;
+            }
+            // null terminate becuase there's no real reason not to
+            ensureSpace(1);
+            *(currentWriteIndex++) = '\0';
+            buf = newbuf;
+            size = (currentWriteIndex - newbuf) - 1; // not counting the terminator here though, to align with vsnwprintf_s's behavior
+        }
+    }
     Output::s_Column += size;
     const char16 * endbuf = wcschr(buf, '\n');
     while (endbuf != nullptr)
@@ -443,15 +528,27 @@ void Output::DirectPrint(char16 const * string)
 void
 Output::SkipToColumn(size_t column)
 {
-    if (column <= Output::s_Column)
+    size_t columnbias = 0;
+    // If we're using a custom alignment and prefix, we want to do this relative to that
+    if (usingCustomAlignAndPrefix)
+    {
+        // If we've already added the alignment and prefix, we need to add the alignment to our column number here
+        columnbias = align + wcslen(prefix);
+    }
+    size_t reference = 0;
+    if (Output::s_Column > columnbias)
+    {
+        reference = Output::s_Column - columnbias;
+    }
+    if (column <= reference)
     {
         Output::Print(_u(" "));
         return;
     }
 
     // compute distance to our destination
 
-    size_t dist = column - Output::s_Column;
+    size_t dist = column - reference;
 
     // Print at least one space
     while (dist > 0)
@@ -564,3 +661,20 @@ Output::CaptureEnd()
 
     return returnBuffer;
 }
+
+void
+Output::SetAlignAndPrefix(unsigned int align, const char16 *prefix)
+{
+    Output::hasDoneAlignPrefixForThisLine = false;
+    Output::usingCustomAlignAndPrefix = true;
+    Output::prefix = prefix;
+    Output::align = align;
+}
+void
+Output::ResetAlignAndPrefix()
+{
+    Output::hasDoneAlignPrefixForThisLine = false;
+    Output::usingCustomAlignAndPrefix = false;
+    Output::prefix = nullptr;
+    Output::align = 0;
+}
diff --git a/lib/Common/Core/Output.h b/lib/Common/Core/Output.h
@@ -114,7 +114,10 @@ class Output
 
     static WORD     SetConsoleForeground(WORD color);
     static void     CaptureStart();
-    static char16* CaptureEnd();
+    static char16*  CaptureEnd();
+
+    static void     SetAlignAndPrefix(unsigned int align, const char16 *prefix);
+    static void     ResetAlignAndPrefix();
 
 private:
     static void     DirectPrint(const char16 * string);
@@ -134,6 +137,11 @@ class Output
 
 #define THREAD_ST THREAD_LOCAL
 
+    THREAD_ST static bool hasDoneAlignPrefixForThisLine;
+    THREAD_ST static bool usingCustomAlignAndPrefix;
+    THREAD_ST static const char16* prefix;
+    THREAD_ST static size_t align;
+
     THREAD_ST static bool s_capture;
     THREAD_ST static FILE * s_file;
 #ifdef _WIN32
