gfx/graphite2/src/direct_machine.cpp

   1 /*  GRAPHITE2 LICENSING
   2
   3     Copyright 2010, SIL International
   4     All rights reserved.
   5
   6     This library is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU Lesser General Public License as published
   8     by the Free Software Foundation; either version 2.1 of License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14     Lesser General Public License for more details.
  15
  16     You should also have received a copy of the GNU Lesser General Public
  17     License along with this library in the file named "LICENSE".
  18     If not, write to the Free Software Foundation, 51 Franklin Street,
  19     Suite 500, Boston, MA 02110-1335, USA or visit their web page on the
  20     internet at http://www.fsf.org/licenses/lgpl.html.
  21
  22 Alternatively, the contents of this file may be used under the terms of the
  23 Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public
  24 License, as published by the Free Software Foundation, either version 2
  25 of the License or (at your option) any later version.
  26 */
  27 // This direct threaded interpreter implmentation for machine.h
  28 // Author: Tim Eves
  29
  30 // Build either this interpreter or the call_machine implementation.
  31 // The direct threaded interpreter is relies upon a gcc feature called
  32 // labels-as-values so is only portable to compilers that support the
  33 // extension (gcc only as far as I know) however it should build on any
  34 // architecture gcc supports.
  35 // This is twice as fast as the call threaded model and is likely faster on
  36 // inorder processors with short pipelines and little branch prediction such
  37 // as the ARM and possibly Atom chips.
  38
  39
  40 #include <cassert>
  41 #include <cstring>
  42 #include "inc/Machine.h"
  43 #include "inc/Segment.h"
  44 #include "inc/Slot.h"
  45 #include "inc/Rule.h"
  46
  47 #define STARTOP(name)           name: {
  48 #define ENDOP                   }; goto *((sp - sb)/Machine::STACK_MAX ? &&end : *++ip);
  49 #define EXIT(status)            { push(status); goto end; }
  50
  51 #define do_(name)               &&name
  52
  53
  54 using namespace graphite2;
  55 using namespace vm;
  56
  57 namespace {
  58
  59 // The GCC manual has this to say about labels as values:
  60 //   The &&foo expressions for the same label might have different values
  61 //   if the containing function is inlined or cloned. If a program relies
  62 //   on them being always the same, __attribute__((__noinline__,__noclone__))
  63 //   should be used to prevent inlining and cloning.
  64 //
  65 // is_return in Code.cpp relies on being able to do comparisons, so it needs
  66 // them to be always the same.
  67 //
  68 // The GCC manual further adds:
  69 //   If &&foo is used in a static variable initializer, inlining and
  70 //   cloning is forbidden.
  71 //
  72 // In this file, &&foo *is* used in a static variable initializer, and it's not
  73 // entirely clear whether this should prevent inlining of the function or not.
  74 // In practice, though, clang 7 can end up inlining the function with ThinLTO,
  75 // which breaks at least is_return. https://bugs.llvm.org/show_bug.cgi?id=39241
  76 // So all in all, we need at least the __noinline__ attribute. __noclone__
  77 // is not supported by clang.
  78 __attribute__((__noinline__))
  79 const void * direct_run(const bool          get_table_mode,
  80                         const instr       * program,
  81                         const byte        * data,
  82                         Machine::stack_t  * stack,
  83                         slotref         * & __map,
  84                         uint8                _dir,
  85                         Machine::status_t & status,
  86                         SlotMap           * __smap=0)
  87 {
  88     // We need to define and return to opcode table from within this function
  89     // other inorder to take the addresses of the instruction bodies.
  90     #include "inc/opcode_table.h"
  91     if (get_table_mode)
  92         return opcode_table;
  93
  94     // Declare virtual machine registers
  95     const instr           * ip = program;
  96     const byte            * dp = data;
  97     Machine::stack_t      * sp = stack + Machine::STACK_GUARD,
  98                     * const sb = sp;
  99     SlotMap             & smap = *__smap;
 100     Segment              & seg = smap.segment;
 101     slotref                 is = *__map,
 102                          * map = __map,
 103                   * const mapb = smap.begin()+smap.context();
 104     uint8                  dir = _dir;
 105     int8                 flags = 0;
 106
 107     // start the program
 108     goto **ip;
 109
 110     // Pull in the opcode definitions
 111     #include "inc/opcodes.h"
 112
 113     end:
 114     __map  = map;
 115     *__map = is;
 116     return sp;
 117 }
 118
 119 }
 120
 121 const opcode_t * Machine::getOpcodeTable() throw()
 122 {
 123     slotref * dummy;
 124     Machine::status_t dumstat = Machine::finished;
 125     return static_cast<const opcode_t *>(direct_run(true, 0, 0, 0, dummy, 0, dumstat));
 126 }
 127
 128
 129 Machine::stack_t  Machine::run(const instr   * program,
 130                                const byte    * data,
 131                                slotref     * & is)
 132 {
 133     assert(program != 0);
 134
 135     const stack_t *sp = static_cast<const stack_t *>(
 136                 direct_run(false, program, data, _stack, is, _map.dir(), _status, &_map));
 137     const stack_t ret = sp == _stack+STACK_GUARD+1 ? *sp-- : 0;
 138     check_final_stack(sp);
 139     return ret;
 140 }