Simplify D1G so that it can inline DrawOneGlyph, and fix a bug in codegen

src/core/SkFindAndPlaceGlyph.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkFindAndPositionGlyph_DEFINED
 #define SkFindAndPositionGlyph_DEFINED
 
@@ skipping 12 matching lines @@
 struct SkMaxSizeOf<> {
     static const size_t value = 0;
 };
 
 template<typename H, typename... Ts>
 struct SkMaxSizeOf<H, Ts...> {
     static const size_t value =
         sizeof(H) >= SkMaxSizeOf<Ts...>::value ? sizeof(H) : SkMaxSizeOf<Ts...>::value;
 };
 
+
+// This is a temporary helper function to work around a bug in the code generation
+// for aarch64 (arm) on GCC 4.9. This bug does not show up on other platforms, so it
+// seems to be an aarch64 backend problem.
+//
+// GCC 4.9 on ARM64 does not generate the proper constructor code for PositionReader or
+// GlyphFindAndPlace. The vtable is not set properly without adding the fixme code.
+// The implementation is in SkDraw.cpp.
+extern void FixGCC49Arm64Bug(int v);
+
 class SkFindAndPlaceGlyph {
 public:
     template<typename ProcessOneGlyph>
     static void ProcessText(
         SkPaint::TextEncoding, const char text[], size_t byteLength,
         SkPoint offset, const SkMatrix& matrix, SkPaint::Align textAlignment,
         SkGlyphCache* cache, ProcessOneGlyph&& processOneGlyph);
     // ProcessPosText handles all cases for finding and positioning glyphs. It has a very large
     // multiplicity. It figures out the glyph, position and rounding and pass those parameters to
     // processOneGlyph.
@@ skipping 179 matching lines @@
         ) { }
     };
 
     // PositionReaderInterface reads a point from the pos vector.
     // * HorizontalPositions - assumes a common Y for many X values.
     // * ArbitraryPositions - a list of (X,Y) pairs.
     class PositionReaderInterface {
     public:
         virtual ~PositionReaderInterface() { }
         virtual SkPoint nextPoint() = 0;
+        // This is only here to fix a GCC 4.9 aarch64 code gen bug.
+        // See comment at the top of the file.
+        virtual int forceUseForBug() = 0;
     };
 
     class HorizontalPositions final : public PositionReaderInterface {
     public:
         explicit HorizontalPositions(const SkScalar* positions)
             : fPositions(positions) { }
 
         SkPoint nextPoint() override {
             SkScalar x = *fPositions++;
             return {x, 0};
         }
 
+        int forceUseForBug() override { return 1; }
+
     private:
         const SkScalar* fPositions;
     };
 
     class ArbitraryPositions final : public PositionReaderInterface {
     public:
         explicit ArbitraryPositions(const SkScalar* positions)
             : fPositions(positions) { }
 
         SkPoint nextPoint() override {
             SkPoint to_return{fPositions[0], fPositions[1]};
             fPositions += 2;
             return to_return;
         }
 
+        int forceUseForBug() override { return 2; }
+
     private:
         const SkScalar* fPositions;
     };
 
     typedef PolymorphicVariant<PositionReaderInterface, HorizontalPositions, ArbitraryPositions>
         PositionReader;
 
     // MapperInterface given a point map it through the matrix. There are several shortcut
     // variants.
     // * TranslationMapper - assumes a translation only matrix.
@@ skipping 134 matching lines @@
     };
 
     // GlyphFindAndPlaceSubpixel handles finding and placing glyphs when sub-pixel positioning is
     // requested. After it has found and placed the glyph it calls the templated function
     // ProcessOneGlyph in order to actually perform an action.
     template<typename ProcessOneGlyph, SkPaint::Align kTextAlignment,
              SkAxisAlignment kAxisAlignment>
     class GlyphFindAndPlaceSubpixel final : public GlyphFindAndPlaceInterface<ProcessOneGlyph> {
     public:
         GlyphFindAndPlaceSubpixel(LookupGlyph& glyphFinder)
-            : fGlyphFinder(glyphFinder) { }
+            : fGlyphFinder(glyphFinder) {
+            FixGCC49Arm64Bug(1);
+        }
 
         SkPoint findAndPositionGlyph(
             const char** text, SkPoint position, ProcessOneGlyph&& processOneGlyph) override {
             SkPoint finalPosition = position;
             if (kTextAlignment != SkPaint::kLeft_Align) {
                 // Get the width of an un-sub-pixel positioned glyph for calculating the
                 // alignment. This is not needed for kLeftAlign because its adjustment is
                 // always {0, 0}.
                 const char* tempText = *text;
                 const SkGlyph &metricGlyph = fGlyphFinder->lookupGlyph(&tempText);
@@ skipping 33 matching lines @@
     };
 
     // GlyphFindAndPlaceFullPixel handles finding and placing glyphs when no sub-pixel
     // positioning is requested. The kUseKerning argument should be true for drawText, and false
     // for drawPosText.
     template<typename ProcessOneGlyph, SkPaint::Align kTextAlignment, SelectKerning kUseKerning>
     class GlyphFindAndPlaceFullPixel final : public GlyphFindAndPlaceInterface<ProcessOneGlyph> {
     public:
         GlyphFindAndPlaceFullPixel(LookupGlyph& glyphFinder)
             : fGlyphFinder(glyphFinder) {
+            FixGCC49Arm64Bug(2);
             // Kerning can only be used with SkPaint::kLeft_Align
             static_assert(!kUseKerning || SkPaint::kLeft_Align == kTextAlignment,
                           "Kerning can only be used with left aligned text.");
         }
 
         SkPoint findAndPositionGlyph(
             const char** text, SkPoint position, ProcessOneGlyph&& processOneGlyph) override {
             SkPoint finalPosition = position;
             const SkGlyph& glyph = fGlyphFinder->lookupGlyph(text);
             if (kUseKerning) {
@@ skipping 117 matching lines @@
         return;
     }
 
     PositionReader positionReader{
         [&](PositionReader::Variants* to_init) {
             if (2 == scalarsPerPosition) {
                 to_init->initialize<ArbitraryPositions>(pos);
             } else {
                 to_init->initialize<HorizontalPositions>(pos);
             }
+            positionReader->forceUseForBug();
         }
     };
 
     Mapper mapper{
         [&](Mapper::Variants* to_init) {
             if (mtype & (SkMatrix::kAffine_Mask | SkMatrix::kPerspective_Mask)
                 || scalarsPerPosition == 2) {
                 to_init->initialize<GeneralMapper>(matrix, offset);
             } else if (mtype & SkMatrix::kScale_Mask) {
                 to_init->initialize<XScaleMapper>(matrix, offset);
             } else {
                 to_init->initialize<TranslationMapper>(matrix, offset);
             }
         }
     };
 
-    GlyphFindAndPlace<ProcessOneGlyph> findAndPosition{
+    GlyphFindAndPlace<ProcessOneGlyph> findAndPosition {
         [&](typename GlyphFindAndPlace<ProcessOneGlyph>::Variants* to_init) {
             if (cache->isSubpixel()) {
                 switch (textAlignment) {
                     case SkPaint::kLeft_Align:
                         InitSubpixel<ProcessOneGlyph, SkPaint::kLeft_Align>(
                             to_init, axisAlignment, glyphFinder);
                         break;
                     case SkPaint::kCenter_Align:
                         InitSubpixel<ProcessOneGlyph, SkPaint::kCenter_Align>(
                             to_init, axisAlignment, glyphFinder);
@@ skipping 72 matching lines @@
     SkPoint current = offset;
     while (text < stop) {
         current =
             findAndPosition->findAndPositionGlyph(
                 &text, current, skstd::forward<ProcessOneGlyph>(processOneGlyph));
 
     }
 }
 
 #endif  // SkFindAndPositionGlyph_DEFINED