source: proto/parabix2/Compiler/bitstream_compiler.py @ 324

Last change on this file since 324 was 324, checked in by eamiri, 10 years ago

TODO list updated.

File size: 22.3 KB
Line 
1
2# bitstream_compiler.py - compile unbounded bitstreams code into
3#   equivalent block-by-block code in C.
4#
5# (c) 2009 Robert D. Cameron and Ehsan Amiri
6# All rights reserved.
7# Licensed to International Characters, Inc. under Academic Free License 3.0
8#
9
10import ast, bitexpr, py2bitexpr, copy
11
12
13#
14#  Code Generation
15#
16
17Nop = 'nop'
18Andc = 'simd_andc'
19And = 'simd_and'
20Or = 'simd_or'
21Xor = 'simd_xor'
22Not = 'not'
23Sel = 'simd_if'
24Add = 'adc128'
25Sub = 'sbb128'
26If = 'simd_has_bit'
27
28AllOne = 'AllOne'
29AllZero = 'AllZero'
30
31
32def expr2simd(genobj, expr):
33    """Translate a Boolean expression into three-address simd code
34       using code generator object genobj.
35       
36    """
37    if isinstance(expr, bitexpr.TrueLiteral): return expr
38    elif isinstance(expr, bitexpr.FalseLiteral): return expr
39    elif isinstance(expr, bitexpr.Var):
40        genobj.common_expression_map[expr.show()] = expr
41        return expr
42    elif isinstance(expr, bitexpr.Not):
43       e = genobj.expr_string_to_variable(expr2simd(genobj, expr.operand))
44       return bitexpr.Andc(bitexpr.Var('AllOne'), e)
45    elif isinstance(expr, bitexpr.Or):
46       if isinstance(expr.operand1, bitexpr.FalseLiteral):
47           return expr.operand2
48       elif isinstance(expr.operand1, bitexpr.TrueLiteral):
49           return bitexpr.TrueLiteral()
50       elif isinstance(expr.operand2, bitexpr.FalseLiteral):
51           return expr.operand1
52       elif isinstance(expr.operand2, bitexpr.TrueLiteral):
53           return bitexpr.TrueLiteral()
54       e1 = genobj.expr_string_to_variable(expr2simd(genobj, expr.operand1))
55       i = expr2simd(genobj, expr.operand2)
56       e2 = genobj.expr_string_to_variable(i)
57       return bitexpr.Or(e1, e2)
58    elif isinstance(expr, bitexpr.Xor):
59       e1 = genobj.expr_string_to_variable(expr2simd(genobj, expr.operand1))
60       e2 = genobj.expr_string_to_variable(expr2simd(genobj, expr.operand2))
61       return bitexpr.Xor(e1,e2)
62    elif isinstance(expr, bitexpr.And):
63       if isinstance(expr.operand1, bitexpr.Not):
64           e1 = genobj.expr_string_to_variable(expr2simd(genobj, expr.operand1.operand))
65           e2 = genobj.expr_string_to_variable(expr2simd(genobj, expr.operand2))
66           return bitexpr.Andc(e2, e1)
67       elif isinstance(expr.operand2, bitexpr.Not):
68           e1 = genobj.expr_string_to_variable(expr2simd(genobj, expr.operand1))
69           e2 = genobj.expr_string_to_variable(expr2simd(genobj, expr.operand2.operand))
70           return bitexpr.Andc(e1,e2)
71       elif isinstance(expr.operand1, bitexpr.FalseLiteral):
72           return bitexpr.FalseLiteral()
73       elif isinstance(expr.operand1, bitexpr.TrueLiteral):
74           return expr.operand2
75       elif isinstance(expr.operand2, bitexpr.FalseLiteral):
76           return bitexpr.FalseLiteral()
77       elif isinstance(expr.operand2, bitexpr.TrueLiteral):
78           return expr.operand1
79       else:
80           e1 = genobj.expr_string_to_variable(expr2simd(genobj, expr.operand1))
81           j = expr2simd(genobj, expr.operand2)
82           e2 = genobj.expr_string_to_variable(j)
83           return bitexpr.And(e1, e2)
84    elif isinstance(expr, bitexpr.Sel):
85       sel = genobj.expr_string_to_variable(expr2simd(genobj, expr.sel))
86       e1 = genobj.expr_string_to_variable(expr2simd(genobj, expr.true_branch))
87       e2 = genobj.expr_string_to_variable(expr2simd(genobj, expr.false_branch))
88       return bitexpr.Sel(sel,e1,e2)
89    elif isinstance(expr, bitexpr.Add):
90       e1 = genobj.expr_string_to_variable(expr2simd(genobj, expr.operand1))
91       e2 = genobj.expr_string_to_variable(expr2simd(genobj, expr.operand2))
92       carry = "carry%i"%BasicBlock.carry_counter
93       return bitexpr.Add(e1, e2, carry)
94    elif isinstance(expr, bitexpr.Sub):
95       e1 = genobj.expr_string_to_variable(expr2simd(genobj, expr.operand1))
96       e2 = genobj.expr_string_to_variable(expr2simd(genobj, expr.operand2))
97       brw = "brw%i"%BasicBlock.brw_counter
98       return bitexpr.Sub(e1, e2, brw)
99    elif isinstance(expr, bitexpr.Andc):
100       if isinstance(expr.operand2, bitexpr.Not):
101           e1 = genobj.expr_string_to_variable(expr2simd(genobj, expr.operand1))
102           e2 = genobj.expr_string_to_variable(expr2simd(genobj, expr.operand2.operand))
103           return bitexpr.And(e1,e2)
104       elif isinstance(expr.operand1, bitexpr.FalseLiteral):
105           return bitexpr.FalseLiteral()
106       elif isinstance(expr.operand2, bitexpr.FalseLiteral):
107           return expr.operand1
108       elif isinstance(expr.operand2, bitexpr.TrueLiteral):
109           return bitexpr.FalseLiteral()
110       else:
111           e1 = genobj.expr_string_to_variable(expr2simd(genobj, expr.operand1))
112           j = expr2simd(genobj, expr.operand2)
113           e2 = genobj.expr_string_to_variable(j)
114           return bitexpr.Andc(e1, e2)
115
116
117def simplify_expr(expr):
118    """
119       simplifies a logical expression due to replacement of variables by constants
120    """
121    if isinstance(expr, bitexpr.TrueLiteral): return expr
122    elif isinstance(expr, bitexpr.FalseLiteral): return expr
123    elif isinstance(expr, bitexpr.Var): return expr
124    elif isinstance(expr, bitexpr.Not): return expr
125    elif isinstance(expr, bitexpr.Or):
126       if isinstance(expr.operand1, bitexpr.FalseLiteral):
127           return expr.operand2
128       elif isinstance(expr.operand1, bitexpr.TrueLiteral):
129           return bitexpr.TrueLiteral()
130       elif isinstance(expr.operand2, bitexpr.FalseLiteral):
131           return expr.operand1
132       elif isinstance(expr.operand2, bitexpr.TrueLiteral):
133           return bitexpr.TrueLiteral()
134       else:
135           return expr
136    elif isinstance(expr, bitexpr.Xor):
137       if isinstance(expr.operand1, bitexpr.FalseLiteral):
138           return expr.operand2
139       elif isinstance(expr.operand1, bitexpr.TrueLiteral):
140           return bitexpr.Andc(bitexpr.TrueLiteral() ,expr.operand2)
141       elif isinstance(expr.operand2, bitexpr.FalseLiteral):
142           return expr.operand1
143       elif isinstance(expr.operand2, bitexpr.TrueLiteral):
144           return bitexpr.Andc(bitexpr.TrueLiteral() ,expr.operand1)
145       else:
146           return expr
147    elif isinstance(expr, bitexpr.And):
148       if isinstance(expr.operand1, bitexpr.FalseLiteral):
149           return bitexpr.FalseLiteral()
150       elif isinstance(expr.operand1, bitexpr.TrueLiteral):
151           return expr.operand2
152       elif isinstance(expr.operand2, bitexpr.FalseLiteral):
153           return bitexpr.FalseLiteral()
154       elif isinstance(expr.operand2, bitexpr.TrueLiteral):
155           return expr.operand1
156       else:
157            return expr
158    elif isinstance(expr, bitexpr.Sel):
159       if isinstance(expr.sel, bitexpr.FalseLiteral):
160           return expr.false_branch
161       elif isinstance(expr.sel, bitexpr.TrueLiteral):
162           return expr.true_branch
163       elif isinstance(expr.true_branch, bitexpr.FalseLiteral):
164           return bitexpr.Andc(expr.false_branch, expr.sel)
165       elif isinstance(expr.true_branch, bitexpr.TrueLiteral):
166           return bitexpr.Or(expr.false_branch, expr.sel)
167       elif isinstance(expr.false_branch, bitexpr.FalseLiteral):
168           return bitexpr.And(expr.true_branch, expr.sel)
169       elif isinstance(expr.false_branch, bitexpr.TrueLiteral):
170           return expr #SIMPLIFICATION IS POSSIBLE BUT ACCESS TO BASIC BLOCK IS NEEDED
171       else:
172            return expr
173    elif isinstance(expr, bitexpr.Add):
174        if isinstance(expr.operand1, bitexpr.FalseLiteral) and isinstance(expr.operand1, bitexpr.FalseLiteral):
175            return bitexpr.FalseLiteral()
176        else:
177            return expr
178    elif isinstance(expr, bitexpr.Sub):
179        return expr
180    elif isinstance(expr, bitexpr.Andc):
181       if isinstance(expr.operand1, bitexpr.FalseLiteral):
182           return bitexpr.FalseLiteral()
183       elif isinstance(expr.operand2, bitexpr.FalseLiteral):
184           return expr.operand1
185       elif isinstance(expr.operand2, bitexpr.TrueLiteral):
186           return bitexpr.FalseLiteral()
187       else:
188           return expr
189
190def gen_sym_table(code):
191        """Generate a simple symbol table for a three address code
192           each entry is of this form: var_name:[[defs][uses]]
193        """
194        table = {}
195        for index, stmt in enumerate(code):
196                if stmt.LHS in table:
197                        table[stmt.LHS][0].append(index)
198                else:
199                        table[stmt.LHS] = [[index],[]]
200               
201                for var in stmt.RHS.vars:
202                        if var in table:
203                                table[var][1].append(index)
204                        else:
205                                table[var] = [[], [index]]
206        return table
207
208
209################################################################
210## This class abstracts one basic block of code
211################################################################
212
213class BasicBlock:
214    gensym_counter = 0
215    carry_counter = 0
216    brw_counter = 0
217    def __init__(self, predeclared={}):
218        self.gensym_template = 'Temp%i'
219        self.code = []
220        self.common_expression_map = {}
221        self.new_vars = []
222        self.vars = {}
223        #for sym in predeclared: self.common_expression_map[sym] =sym
224        self.common_expression_map.update(predeclared)
225    def __len__(self):
226        return len(self.code)
227    def join(self, block):
228        self.code += block.code
229        self.common_expression_map.update(block.common_expression_map)
230    def get_defs(self, varname):
231        defs = []
232        for line, loc in enumerate(self.code):
233            if loc.LHS.varname == varname:
234                defs.append(line)
235        if len(defs)==0:
236            defs.append(None)
237        return defs
238    def get_uses(self, varname):
239        uses = []
240        for line, loc in enumerate(self.code):
241            if isinstance(loc.RHS, bitexpr.Not):
242                if loc.RHS.operand.varname == varname:
243                    uses.append(line)
244                continue
245            if isinstance(loc.RHS, bitexpr.Var):
246                if loc.RHS.varname == varname:
247                    uses.append(line)
248                continue
249               
250            if loc.RHS.operand1.varname == varname:
251                uses.append(line)
252            if loc.RHS.operand2.varname == varname:
253                uses.append(line)
254        if len(uses)==0:
255            uses.append(None)
256        return uses
257
258    def split(self, line):
259        code1 = self.code[:line]
260        code2 = self.code[line:]
261        bb2 = BasicBlock()
262        bb2.code = code2
263        bb2.common_expression_map = copy.copy(self.common_expression_map)
264       
265        bb2vars = []
266        for loc in code2:
267            bb2vars.append(loc.LHS.varname)
268        bb1vars = []
269        for loc in code1:
270            bb1vars.append(loc.LHS.varname)
271       
272        for i in self.common_expression_map:
273            if self.common_expression_map[i] in bb2vars and not self.common_expression_map[i] in bb1vars:
274                del self.common_expression_map[i]
275       
276        bb1 = BasicBlock()
277        bb1.code = code1
278        bb1.common_expression_map = self.common_expression_map
279        return bb1, bb2
280    def add_stmt(self, varname, expr):
281        assert(not isinstance(varname, str))
282        self.common_expression_map[expr.show()] = varname
283        self.code.append(bitexpr.BitAssign(varname, expr))
284        if isinstance(expr, bitexpr.Add):
285                BasicBlock.carry_counter += 1
286        if isinstance(expr, bitexpr.Sub):
287                BasicBlock.brw_counter += 1
288
289    def expr_string_to_variable(self, expr_string):
290        #if isinstance(expr_string, bitexpr.And):
291        #    print expr_string.operand1, expr_string.operand2
292        #print expr_string.show()
293        if self.common_expression_map.has_key(expr_string.show()):
294            return self.common_expression_map[expr_string.show()]
295        else:
296            BasicBlock.gensym_counter += 1
297            sym = bitexpr.Var(self.gensym_template % BasicBlock.gensym_counter)
298            self.add_stmt(sym, expr_string)
299            return sym
300
301    def showcode(self, indent, line_no = False):
302        s=""
303        for index, stmt in enumerate(self.code): 
304                #if index == 36:
305                #    print "::::", stmt, stmt.LHS, stmt.RHS, stmt.RHS.varname
306                if line_no:
307                        s+= "%i %s%s;\n"%(index, " "*indent,stmt.show())
308                else:
309                        #if not isinstance(stmt, bitexpr.BitAssign):
310                        #   print "~~~~", index, stmt
311                        s += " "*indent + stmt.show() + ";\n"
312        return s
313
314    def get_code(self):
315        return self.code
316
317    def calc_implications(self, assumptions):
318        changed = False
319        notchecked = [x for x in assumptions]
320        lhs = [x.LHS.varname for x in self.code]
321        while True:
322            if len(notchecked) == 0:
323                break
324            var = notchecked.pop(0)
325            if var in lhs:
326                index = lhs.index(var)
327                s = self.code[index]
328            else:
329                continue
330            if var in assumptions:
331                if isinstance(assumptions[s.LHS.varname], bitexpr.FalseLiteral):
332                    if isinstance(s.RHS, bitexpr.Not):
333                        assumptions[s.RHS.operand.varname] = bitexpr.TrueLiteral()
334                        notchecked.append(s.RHS.operand.varname)
335                    elif isinstance(s.RHS, bitexpr.Var):
336                        assumptions[s.RHS.varname] = bitexpr.FalseLiteral()
337                        notchecked.append(s.RHS.operand.varname)
338                    elif isinstance(s.RHS, bitexpr.Or):
339                        assumptions[s.RHS.operand1.varname] = bitexpr.FalseLiteral()
340                        assumptions[s.RHS.operand2.varname] = bitexpr.FalseLiteral()
341                        notchecked.append(s.RHS.operand1.varname)
342                        notchecked.append(s.RHS.operand2.varname)
343                    elif isinstance(s.RHS, bitexpr.Xor):
344                        pass
345                if isinstance(assumptions[s.LHS.varname], bitexpr.TrueLiteral):
346                    if isinstance(s.RHS, bitexpr.Not):
347                        assumptions[s.RHS.operand.varname] = bitexpr.FalseLiteral()
348                        notchecked.append(s.RHS.operand.varname)
349                    elif isinstance(s.RHS, bitexpr.Var):
350                        assumptions[s.RHS.varname] = bitexpr.TrueLiteral()
351                        notchecked.append(s.RHS.operand.varname)
352                    elif isinstance(s.RHS, bitexpr.And):
353                        assumptions[s.RHS.operand1.varname] = bitexpr.TrueLiteral()
354                        assumptions[s.RHS.operand2.varname] = bitexpr.TrueLiteral()
355                        notchecked.append(s.RHS.operand1.varname)
356                        notchecked.append(s.RHS.operand2.varname)
357                    elif isinstance(s.RHS, bitexpr.Andc):
358                        if isinstance(s.RHS.operand1, bitexpr.TrueLiteral):
359                            assumptions[s.RHS.operand2.varname] = bitexpr.FalseLiteral()
360                            notchecked.append(s.RHS.operand2.varname)
361                        else:
362                            assumptions[s.RHS.operand1.varname] = bitexpr.TrueLiteral()
363                            assumptions[s.RHS.operand2.varname] = bitexpr.FalseLiteral()
364                            notchecked.append(s.RHS.operand1.varname)
365                            notchecked.append(s.RHS.operand2.varname)
366        return assumptions
367    def propagate_constant(self, previous):
368        changed = False
369        fixed = previous
370        #print fixed
371        for s in self.code:
372            #if len(self.code)==1: print s, s.LHS.varname, s.RHS
373
374            if isinstance(s.RHS, bitexpr.FalseLiteral):
375                fixed[s.LHS.varname] = bitexpr.FalseLiteral()
376                continue
377            if isinstance(s.RHS, bitexpr.TrueLiteral):
378                fixed[s.LHS.varname] = bitexpr.TrueLiteral()
379                continue
380            if isinstance(s.RHS, bitexpr.Var):
381                if s.RHS.varname in fixed:
382                    s.RHS = fixed[s.RHS.varname]
383                fixed[s.LHS.varname] = s.RHS
384                continue
385            #   fixed[s.LHS] = s.RHS
386            if isinstance(s.RHS, bitexpr.Not):
387                if s.RHS.operand.varname in fixed:
388                    s.RHS.operand = fixed[s.RHS.operand.varname]
389                continue
390            if s.RHS.operand1.varname in fixed:
391                changed = True
392                s.RHS.operand1 = fixed[s.RHS.operand1.varname]
393            if s.RHS.operand2.varname in fixed:
394                s.RHS.operand2 = fixed[s.RHS.operand2.varname]
395                changed = True
396
397        return fixed, changed
398
399    def normalize(self, stmts):
400        for s in stmts:
401            self.add_stmt(s.LHS, expr2simd(self, s.RHS))
402    def transform(self):
403        for loc in self.code:
404            loc.RHS = simplify_expr(loc.RHS)
405    def simplify(self, previous):
406        changed = True
407        while changed:
408            self.transform()
409            fixed, changed = self.propagate_constant(previous)
410        return fixed
411
412################################################################
413# Going through compilation passes one by one
414################################################################
415def generate_code(s):
416
417    #Pass 1
418    s = ast.parse(s)
419    s = s.body[0].body
420
421    #Pass 2
422    s = py2bitexpr.translate_stmts(s)
423
424    #Pass 3
425    st = py2bitexpr.gen_sym_table(s)
426    s=py2bitexpr.make_SSA(s, st)
427
428    #Pass 4
429    bb, exprs = py2bitexpr.partition2bb(s)
430
431    #Pass 5
432    declarations = py2bitexpr.gen_declarations(bb)
433
434    #Pass 6
435    tree = py2bitexpr.construct_tree(bb, exprs)
436
437    #Pass 7
438    tree = py2bitexpr.Reducer().apply_all_opt(tree)
439
440    #Pass 8
441    py2bitexpr.simplify_tree(tree)
442
443   
444    livelist = ['u16hi[0]','u16hi[1]','u16hi[2]','u16hi[3]','u16hi[4]','u16hi[5]','u16hi[6]','u16hi[7]']
445    livelist += ['u16lo[0]','u16lo[1]','u16lo[2]','u16lo[3]','u16lo[4]','u16lo[5]','u16lo[6]','u16lo[7]', 'delmask', 'u8.error', 'error_mask']
446    py2bitexpr.eliminate_dead_code(tree, set(livelist))
447   
448    #Pass 9
449    s = py2bitexpr.unwind(tree)
450    return declarations+s
451
452
453###############################################################
454if __name__ == '__main__':
455        s=r"""def u8u16(u8, u8bit):
456        u8.unibyte = (~u8bit[0]);
457        optimize(u8.unibyte, allone)
458        u8.prefix = (u8bit[0] & u8bit[1]);
459        u8.prefix2 = (u8.prefix &~ u8bit[2]);
460        temp1 = (u8bit[2] &~ u8bit[3]);
461        u8.prefix3 = (u8.prefix & temp1);
462        temp2 = (u8bit[2] & u8bit[3]);
463        u8.prefix4 = (u8.prefix & temp2);
464        u8.suffix = (u8bit[0] &~ u8bit[1]);
465        maxtwo = u8.prefix2 | u8.unibyte | u8.suffix
466        optimize(maxtwo, allone)
467        temp3 = (u8bit[2] | u8bit[3]);
468        temp4 = (u8.prefix &~ temp3);
469        temp5 = (u8bit[4] | u8bit[5]);
470        temp6 = (temp5 | u8bit[6]);
471        temp7 = (temp4 &~ temp6);
472        temp8 = (u8bit[6] | u8bit[7]);
473        temp9 = (u8bit[5] & temp8);
474        temp10 = (u8bit[4] | temp9);
475        temp11 = (u8.prefix4 & temp10);
476        u8.badprefix = (temp7 | temp11);
477        temp12 = (temp5 | temp8);
478        u8.xE0 = (u8.prefix3 &~ temp12);
479        temp13 = (u8bit[4] & u8bit[5]);
480        temp14 = (u8bit[7] &~ u8bit[6]);
481        temp15 = (temp13 & temp14);
482        u8.xED = (u8.prefix3 & temp15);
483        u8.xF0 = (u8.prefix4 &~ temp12);
484        temp16 = (u8bit[5] &~ u8bit[4]);
485        temp17 = (temp16 &~ temp8);
486        u8.xF4 = (u8.prefix4 & temp17);
487        u8.xA0_xBF = (u8.suffix & u8bit[2]);
488        u8.x80_x9F = (u8.suffix &~ u8bit[2]);
489        u8.x90_xBF = (u8.suffix & temp3);
490        u8.x80_x8F = (u8.suffix &~ temp3);
491       
492        u8.scope22 = bitutil.Advance(u8.prefix2)
493        u8.scope32 = bitutil.Advance(u8.prefix3)
494        u8.scope33 = bitutil.Advance(u8.scope32)
495        u8.scope42 = bitutil.Advance(u8.prefix4)
496        u8.scope43 = bitutil.Advance(u8.scope42)
497        u8.scope44 = bitutil.Advance(u8.scope43)
498        u8lastscope = u8.scope22 | u8.scope33 | u8.scope44
499        u8anyscope = u8lastscope | u8.scope32 | u8.scope42 | u8.scope43
500       
501        # C0-C1 and F5-FF are illegal
502        error_mask = u8.badprefix
503       
504        error_mask |= bitutil.Advance(u8.xE0) & u8.x80_x9F
505        error_mask |= bitutil.Advance(u8.xED) & u8.xA0_xBF
506        error_mask |= bitutil.Advance(u8.xF0) & u8.x80_x8F
507        error_mask |= bitutil.Advance(u8.xF4) & u8.x90_xBF
508       
509        error_mask |= u8anyscope ^ u8.suffix
510        u8.error = error_mask
511       
512        u8lastscope = u8.scope22 | u8.scope33 | u8.scope44
513        u8lastbyte = u8.unibyte | u8lastscope
514        u16lo[2] = u8lastbyte & u8bit[2]
515        u16lo[3] = u8lastbyte & u8bit[3]
516        u16lo[4] = u8lastbyte & u8bit[4]
517        u16lo[5] = u8lastbyte & u8bit[5]
518        u16lo[6] = u8lastbyte & u8bit[6]
519        u16lo[7] = u8lastbyte & u8bit[7]
520        u16lo[1] = (u8.unibyte & u8bit[1]) | (u8lastscope & bitutil.Advance(u8bit[7]))
521        u16lo[0] = u8lastscope & bitutil.Advance(u8bit[6])
522       
523        u16hi[5] = u8lastscope & bitutil.Advance(u8bit[3])
524        u16hi[6] = u8lastscope & bitutil.Advance(u8bit[4])
525        u16hi[7] = u8lastscope & bitutil.Advance(u8bit[5])
526        u16hi[0] = u8.scope33 & bitutil.Advance(bitutil.Advance(u8bit[4]))
527        u16hi[1] = u8.scope33 & bitutil.Advance(bitutil.Advance(u8bit[5]))
528        u16hi[2] = u8.scope33 & bitutil.Advance(bitutil.Advance(u8bit[6]))
529        u16hi[3] = u8.scope33 & bitutil.Advance(bitutil.Advance(u8bit[7]))
530        u16hi[4] = u8.scope33 & bitutil.Advance(u8bit[2])
531
532        u8surrogate = u8.scope43 | u8.scope44
533        u16hi[0] = u16hi[0] | u8surrogate       
534        u16hi[1] = u16hi[1] | u8surrogate       
535        u16hi[3] = u16hi[3] | u8surrogate       
536        u16hi[4] = u16hi[4] | u8surrogate       
537        u16hi[5] = u16hi[5] | u8.scope44
538
539        s42lo1 = ~u8bit[3] # subtract 1
540        u16lo[1] = u16lo[1] | (u8.scope43 & bitutil.Advance(s42lo1))
541        s42lo0 = u8bit[2] ^ s42lo1 # borrow *
542        u16lo[0] = u16lo[0] | (u8.scope43 & bitutil.Advance(s42lo0))
543        borrow1 = s42lo1 & ~u8bit[2]
544        bitutil.Advance_bit7 = bitutil.Advance(u8bit[7])
545        s42hi7 = bitutil.Advance_bit7 ^ borrow1
546        u16hi[7]= u16hi[7] | (u8.scope43 & bitutil.Advance(s42hi7))
547        borrow2 = borrow1 & ~bitutil.Advance_bit7
548        s42hi6 = bitutil.Advance(u8bit[6]) ^ borrow2
549        u16hi[6] = u16hi[6] | (u8.scope43 & bitutil.Advance(s42hi6))
550
551        u16lo[2] = u16lo[2] | (u8.scope43 & bitutil.Advance(u8bit[4]))
552        u16lo[3] = u16lo[3] | (u8.scope43 & bitutil.Advance(u8bit[5]))
553        u16lo[4] = u16lo[4] | (u8.scope43 & bitutil.Advance(u8bit[6]))
554        u16lo[5] = u16lo[5] | (u8.scope43 & bitutil.Advance(u8bit[7]))
555        u16lo[6] = u16lo[6] | (u8.scope43 & u8bit[2])
556        u16lo[7] = u16lo[7] | (u8.scope43 & u8bit[3])
557
558        delmask = u8.prefix | u8.scope32 | u8.scope42"""
559        print generate_code(s)
560
561#TODO: merge expr2simd() and a simplify_expr()
562#TODO: there is some unnecesary code in output  duplication that can be removed
563#TODO: removing unreachable code is developed but is incomplete. Currently the code is not used.
564#TODO: Support optimizing over subset of values
565#TODO: optimize pragma can be put in the beginning of the code, or any point. Right now, it is sensitive to the location
566#TODO: A mechanism for programmer to let the compiler know about relations between bitstreams. Some relations might
567#       be possibly extracted automatically, but it might be expensive.Look at the optimize(maxtwo, allone) in the current example.
568#       it does not help at all, while it is an important case. This is because thecompiler can not extract all the information
569#       implied by the assumption maxtwo = allone.
Note: See TracBrowser for help on using the repository browser.