← Back to branch summary

~ubuntu-branches/ubuntu/saucy/golang/saucy

« back to all changes in this revision

Viewing changes to src/cmd/5g/gg.h

  • Committer: Package Import Robot
  • Author(s): Adam Conrad
  • Date: 2013-07-08 05:52:37 UTC
  • mfrom: (29.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20130708055237-at01839e0hp8z3ni
Tags: 2:1.1-1ubuntu1
016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cmd/5g/gg.h
15
15
{
16
16
        int32   offset;
17
17
        int32   offset2;
18
 
        double  dval;
19
 
        Prog*   branch;
20
 
        char    sval[NSNAME];
 
18
 
 
19
        union {
 
20
                double  dval;
 
21
                vlong   vval;
 
22
                Prog*   branch;
 
23
                char    sval[NSNAME];
 
24
        } u;
21
25
 
22
26
        Sym*    sym;
 
27
        Sym*    gotype;
23
28
        Node*   node;
24
29
        int     width;
25
30
        uchar   type;
26
31
        char    name;
27
32
        uchar   reg;
28
 
        char pun;
29
33
        uchar   etype;
30
34
};
31
35
#define A       ((Addr*)0)
32
36
 
33
37
struct  Prog
34
38
{
35
 
        short   as;             // opcode
36
39
        uint32  loc;            // pc offset in this func
37
40
        uint32  lineno;         // source line that generated this
38
 
        Addr    from;           // src address
39
 
        Addr    to;             // dst address
40
41
        Prog*   link;           // next instruction in this func
41
42
        void*   regp;           // points to enclosing Reg struct
 
43
        short   as;             // opcode
42
44
        uchar   reg;            // doubles as width in DATA op
43
45
        uchar   scond;
 
46
        Addr    from;           // src address
 
47
        Addr    to;             // dst address
44
48
};
45
49
 
46
50
#define TEXTFLAG reg
78
82
void    cgen_proc(Node*, int);
79
83
void    cgen_callret(Node*, Node*);
80
84
void    cgen_dcl(Node*);
81
 
int     cgen_inline(Node*, Node*);
82
85
int     needconvert(Type*, Type*);
83
86
void    genconv(Type*, Type*);
84
87
void    allocparams(void);
85
 
void    checklabels();
 
88
void    checklabels(void);
86
89
void    ginscall(Node*, int);
87
90
 
88
91
/*
89
92
 * cgen
90
93
 */
91
94
void    agen(Node*, Node*);
92
 
Prog* cgenindex(Node *, Node *);
 
95
Prog* cgenindex(Node *, Node *, int);
93
96
void    igen(Node*, Node*, Node*);
94
97
void agenr(Node *n, Node *a, Node *res);
95
98
vlong   fieldoffset(Type*, Node*);
96
 
void    bgen(Node*, int, Prog*);
97
99
void    sgen(Node*, Node*, int64);
98
100
void    gmove(Node*, Node*);
99
101
Prog*   gins(int, Node*, Node*);
104
106
Prog *  gregshift(int as, Node *lhs, int32 stype, Node *reg, Node *rhs);
105
107
void    naddr(Node*, Addr*, int);
106
108
void    cgen_aret(Node*, Node*);
107
 
void    cgen_shift(int, Node*, Node*, Node*);
 
109
void    cgen_hmul(Node*, Node*, Node*);
 
110
void    cgen_shift(int, int, Node*, Node*, Node*);
 
111
int     componentgen(Node*, Node*);
108
112
 
109
113
/*
110
114
 * cgen64.c
111
115
 */
112
 
void    cmp64(Node*, Node*, int, Prog*);
 
116
void    cmp64(Node*, Node*, int, int, Prog*);
113
117
void    cgen64(Node*, Node*);
114
118
 
115
119
/*
117
121
 */
118
122
void    clearp(Prog*);
119
123
void    proglist(void);
120
 
Prog*   gbranch(int, Type*);
 
124
Prog*   gbranch(int, Type*, int);
121
125
Prog*   prog(int);
122
 
void    gaddoffset(Node*);
123
126
void    gconv(int, int);
124
127
int     conv2pt(Type*);
125
128
vlong   convvtox(vlong, int);
126
129
void    fnparam(Type*, int, int);
127
130
Prog*   gop(int, Node*, Node*, Node*);
128
 
void    setconst(Addr*, vlong);
129
 
void    setaddr(Addr*, Node*);
130
131
int     optoas(int, Type*);
131
132
void    ginit(void);
132
133
void    gclean(void);
141
142
int     dotaddable(Node*, Node*);
142
143
void    sudoclean(void);
143
144
int     sudoaddable(int, Node*, Addr*, int*);
144
 
void    afunclit(Addr*);
 
145
void    afunclit(Addr*, Node*);
145
146
void    datagostring(Strlit*, Addr*);
146
147
void    split64(Node*, Node*, Node*);
147
148
void    splitclean(void);
148
149
Node*   ncon(uint32 i);
 
150
void    gtrack(Sym*);
149
151
 
150
152
/*
151
153
 * obj.c
164
166
int     Yconv(Fmt*);
165
167
void    listinit(void);
166
168
 
167
 
void    zaddr(Biobuf*, Addr*, int);
 
169
void    zaddr(Biobuf*, Addr*, int, int);
168
170
 
169
171
#pragma varargck        type    "D"     Addr*
170
172
#pragma varargck        type    "M"     Addr*