LCOV - code coverage report
Current view: directory - gfx/graphite2/src - direct_machine.cpp (source / functions) Found Hit Coverage
Test: app.info Lines: 26 0 0.0 %
Date: 2012-06-02 Functions: 3 0 0.0 %

       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               0 : const void * direct_run(const bool          get_table_mode,
      60                 :                         const instr       * program,
      61                 :                         const byte        * data,
      62                 :                         Machine::stack_t  * stack,
      63                 :                         slotref         * & __map,
      64                 :                         SlotMap           * __smap=0)
      65                 : {
      66                 :     // We need to define and return to opcode table from within this function 
      67                 :     // other inorder to take the addresses of the instruction bodies.
      68                 :     #include "inc/opcode_table.h"
      69               0 :     if (get_table_mode)
      70               0 :         return opcode_table;
      71                 : 
      72                 :     // Declare virtual machine registers
      73               0 :     const instr       * ip = program;
      74               0 :     const byte        * dp = data;
      75               0 :     Machine::stack_t  * sp = stack + Machine::STACK_GUARD,
      76               0 :                 * const sb = sp;
      77               0 :     SlotMap         & smap = *__smap;
      78               0 :     Segment          & seg = smap.segment;
      79               0 :     slotref             is = *__map,
      80               0 :                      * map = __map,
      81               0 :               * const mapb = smap.begin()+smap.context();
      82               0 :     int8             flags = 0;
      83                 :     
      84                 :     // start the program
      85               0 :     goto **ip;
      86                 : 
      87                 :     // Pull in the opcode definitions
      88                 :     #include "inc/opcodes.h"
      89                 :     
      90                 :     end:
      91               0 :     __map  = map;
      92               0 :     *__map = is;
      93               0 :     return sp;
      94                 : }
      95                 : 
      96                 : }
      97                 : 
      98               0 : const opcode_t * Machine::getOpcodeTable() throw()
      99                 : {
     100                 :     slotref * dummy;
     101               0 :     return static_cast<const opcode_t *>(direct_run(true, 0, 0, 0, dummy, 0));
     102                 : }
     103                 : 
     104                 : 
     105               0 : Machine::stack_t  Machine::run(const instr   * program,
     106                 :                                const byte    * data,
     107                 :                                slotref     * & is)
     108                 : {
     109               0 :     assert(program != 0);
     110               0 :     assert(_status == finished);
     111                 :     
     112                 :     const stack_t *sp = static_cast<const stack_t *>(
     113               0 :                 direct_run(false, program, data, _stack, is, &_map));
     114               0 :     const stack_t ret = sp == _stack+STACK_GUARD+1 ? *sp-- : 0;
     115               0 :     check_final_stack(sp);
     116               0 :     return ret;
     117                 : }
     118                 : 

Generated by: LCOV version 1.7