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__))
direct_run(const bool get_table_mode,const instr * program,const byte * data,Machine::stack_t * stack,slotref * & __map,uint8 _dir,Machine::status_t & status,SlotMap * __smap=0)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
getOpcodeTable()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
run(const instr * program,const byte * data,slotref * & is)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 }
141