← Back to branch summary

~ubuntu-branches/ubuntu/vivid/golang/vivid

« back to all changes in this revision

Viewing changes to src/cmd/6g/opt.h

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-08-20 14:06:23 UTC
  • mfrom: (14.1.23 saucy-proposed)
  • Revision ID: package-import@ubuntu.com-20130820140623-b414jfxi3m0qkmrq
Tags: 2:1.1.2-2ubuntu1
https://launchpad.net/bugs/1211749
https://launchpad.net/bugs/1202027
* Merge from Debian unstable (LP: #1211749, #1202027). Remaining changes:
  - 016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.
  - d/control,control.cross: Update Breaks/Replaces for Ubuntu
    versions to ensure smooth upgrades, regenerate control file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cmd/6g/opt.h
34
34
#define D_HI    D_NONE
35
35
#define D_LO    D_NONE
36
36
 
37
 
#define isregtype(t)    ((t)>= D_AX && (t)<=D_R15)
38
 
 
39
37
#define BLOAD(r)        band(bnot(r->refbehind), r->refahead)
40
38
#define BSTORE(r)       band(bnot(r->calbehind), r->calahead)
41
39
#define LOAD(r)         (~r->refbehind.b[z] & r->refahead.b[z])
49
47
typedef struct  Reg     Reg;
50
48
typedef struct  Rgn     Rgn;
51
49
 
 
50
// A Reg is a wrapper around a single Prog (one instruction) that holds
 
51
// register optimization information while the optimizer runs.
 
52
// r->prog is the instruction.
 
53
// r->prog->regp points back to r.
52
54
struct  Reg
53
55
{
54
56
 
55
 
        Bits    set;
56
 
        Bits    use1;
57
 
        Bits    use2;
 
57
        Bits    set;            // variables written by this instruction.
 
58
        Bits    use1;           // variables read by prog->from.
 
59
        Bits    use2;           // variables read by prog->to.
58
60
 
59
61
        Bits    refbehind;
60
62
        Bits    refahead;
70
72
        uint16  loop;           // x5 for every loop
71
73
        uchar   refset;         // diagnostic generated
72
74
 
73
 
        Reg*    p1;
74
 
        Reg*    p2;
 
75
        Reg*    p1;             // predecessors of this instruction: p1,
 
76
        Reg*    p2;             // and then p2 linked though p2link.
75
77
        Reg*    p2link;
76
 
        Reg*    s1;
 
78
        Reg*    s1;             // successors of this instruction (at most two: s1 and s2).
77
79
        Reg*    s2;
78
 
        Reg*    link;
79
 
        Prog*   prog;
 
80
        Reg*    link;           // next instruction in function code
 
81
        Prog*   prog;           // actual instruction
80
82
};
81
83
#define R       ((Reg*)0)
82
84