Revision be449fca libavcodec/sparc/vis.h

View differences:

libavcodec/sparc/vis.h
55 55
#define vis_rd_d(X)     (vis_dreg(X) << 25)
56 56

  
57 57
#define vis_ss2s(opf,rs1,rs2,rd) \
58
        asm volatile (".word %0" \
58
        __asm__ volatile (".word %0" \
59 59
                              : : "i" (vis_opc_base | vis_opf(opf) | \
60 60
                                       vis_rs1_s(rs1) | \
61 61
                                       vis_rs2_s(rs2) | \
62 62
                                       vis_rd_s(rd)))
63 63

  
64 64
#define vis_dd2d(opf,rs1,rs2,rd) \
65
        asm volatile (".word %0" \
65
        __asm__ volatile (".word %0" \
66 66
                              : : "i" (vis_opc_base | vis_opf(opf) | \
67 67
                                       vis_rs1_d(rs1) | \
68 68
                                       vis_rs2_d(rs2) | \
69 69
                                       vis_rd_d(rd)))
70 70

  
71 71
#define vis_ss2d(opf,rs1,rs2,rd) \
72
        asm volatile (".word %0" \
72
        __asm__ volatile (".word %0" \
73 73
                              : : "i" (vis_opc_base | vis_opf(opf) | \
74 74
                                       vis_rs1_s(rs1) | \
75 75
                                       vis_rs2_s(rs2) | \
76 76
                                       vis_rd_d(rd)))
77 77

  
78 78
#define vis_sd2d(opf,rs1,rs2,rd) \
79
        asm volatile (".word %0" \
79
        __asm__ volatile (".word %0" \
80 80
                              : : "i" (vis_opc_base | vis_opf(opf) | \
81 81
                                       vis_rs1_s(rs1) | \
82 82
                                       vis_rs2_d(rs2) | \
83 83
                                       vis_rd_d(rd)))
84 84

  
85 85
#define vis_d2s(opf,rs2,rd) \
86
        asm volatile (".word %0" \
86
        __asm__ volatile (".word %0" \
87 87
                              : : "i" (vis_opc_base | vis_opf(opf) | \
88 88
                                       vis_rs2_d(rs2) | \
89 89
                                       vis_rd_s(rd)))
90 90

  
91 91
#define vis_s2d(opf,rs2,rd) \
92
        asm volatile (".word %0" \
92
        __asm__ volatile (".word %0" \
93 93
                              : : "i" (vis_opc_base | vis_opf(opf) | \
94 94
                                       vis_rs2_s(rs2) | \
95 95
                                       vis_rd_d(rd)))
96 96

  
97 97
#define vis_d12d(opf,rs1,rd) \
98
        asm volatile (".word %0" \
98
        __asm__ volatile (".word %0" \
99 99
                              : : "i" (vis_opc_base | vis_opf(opf) | \
100 100
                                       vis_rs1_d(rs1) | \
101 101
                                       vis_rd_d(rd)))
102 102

  
103 103
#define vis_d22d(opf,rs2,rd) \
104
        asm volatile (".word %0" \
104
        __asm__ volatile (".word %0" \
105 105
                              : : "i" (vis_opc_base | vis_opf(opf) | \
106 106
                                       vis_rs2_d(rs2) | \
107 107
                                       vis_rd_d(rd)))
108 108

  
109 109
#define vis_s12s(opf,rs1,rd) \
110
        asm volatile (".word %0" \
110
        __asm__ volatile (".word %0" \
111 111
                              : : "i" (vis_opc_base | vis_opf(opf) | \
112 112
                                       vis_rs1_s(rs1) | \
113 113
                                       vis_rd_s(rd)))
114 114

  
115 115
#define vis_s22s(opf,rs2,rd) \
116
        asm volatile (".word %0" \
116
        __asm__ volatile (".word %0" \
117 117
                              : : "i" (vis_opc_base | vis_opf(opf) | \
118 118
                                       vis_rs2_s(rs2) | \
119 119
                                       vis_rd_s(rd)))
120 120

  
121 121
#define vis_s(opf,rd) \
122
        asm volatile (".word %0" \
122
        __asm__ volatile (".word %0" \
123 123
                              : : "i" (vis_opc_base | vis_opf(opf) | \
124 124
                                       vis_rd_s(rd)))
125 125

  
126 126
#define vis_d(opf,rd) \
127
        asm volatile (".word %0" \
127
        __asm__ volatile (".word %0" \
128 128
                              : : "i" (vis_opc_base | vis_opf(opf) | \
129 129
                                       vis_rd_d(rd)))
130 130

  
131 131
#define vis_r2m(op,rd,mem) \
132
        asm volatile (#op "\t%%f" #rd ", [%0]" : : "r" (&(mem)) )
132
        __asm__ volatile (#op "\t%%f" #rd ", [%0]" : : "r" (&(mem)) )
133 133

  
134 134
#define vis_r2m_2(op,rd,mem1,mem2) \
135
        asm volatile (#op "\t%%f" #rd ", [%0 + %1]" : : "r" (mem1), "r" (mem2) )
135
        __asm__ volatile (#op "\t%%f" #rd ", [%0 + %1]" : : "r" (mem1), "r" (mem2) )
136 136

  
137 137
#define vis_m2r(op,mem,rd) \
138
        asm volatile (#op "\t[%0], %%f" #rd : : "r" (&(mem)) )
138
        __asm__ volatile (#op "\t[%0], %%f" #rd : : "r" (&(mem)) )
139 139

  
140 140
#define vis_m2r_2(op,mem1,mem2,rd) \
141
        asm volatile (#op "\t[%0 + %1], %%f" #rd : : "r" (mem1), "r" (mem2) )
141
        __asm__ volatile (#op "\t[%0 + %1], %%f" #rd : : "r" (mem1), "r" (mem2) )
142 142

  
143 143
static inline void vis_set_gsr(unsigned int _val)
144 144
{
145
        register unsigned int val asm("g1");
145
        register unsigned int val __asm__("g1");
146 146

  
147 147
        val = _val;
148
        asm volatile(".word 0xa7804000"
148
        __asm__ volatile(".word 0xa7804000"
149 149
                             : : "r" (val));
150 150
}
151 151

  
......
164 164
#define vis_st64_2(rs1,mem1,mem2)       vis_r2m_2(std, rs1, mem1, mem2)
165 165

  
166 166
#define vis_ldblk(mem, rd) \
167
do {        register void *__mem asm("g1"); \
167
do {        register void *__mem __asm__("g1"); \
168 168
        __mem = &(mem); \
169
        asm volatile(".word 0xc1985e00 | %1" \
169
        __asm__ volatile(".word 0xc1985e00 | %1" \
170 170
                             : \
171 171
                             : "r" (__mem), \
172 172
                               "i" (vis_rd_d(rd)) \
......
174 174
} while (0)
175 175

  
176 176
#define vis_stblk(rd, mem) \
177
do {        register void *__mem asm("g1"); \
177
do {        register void *__mem __asm__("g1"); \
178 178
        __mem = &(mem); \
179
        asm volatile(".word 0xc1b85e00 | %1" \
179
        __asm__ volatile(".word 0xc1b85e00 | %1" \
180 180
                             : \
181 181
                             : "r" (__mem), \
182 182
                               "i" (vis_rd_d(rd)) \
......
184 184
} while (0)
185 185

  
186 186
#define vis_membar_storestore()        \
187
        asm volatile(".word 0x8143e008" : : : "memory")
187
        __asm__ volatile(".word 0x8143e008" : : : "memory")
188 188

  
189 189
#define vis_membar_sync()        \
190
        asm volatile(".word 0x8143e040" : : : "memory")
190
        __asm__ volatile(".word 0x8143e040" : : : "memory")
191 191

  
192 192
/* 16 and 32 bit partitioned addition and subtraction.  The normal
193 193
 * versions perform 4 16-bit or 2 32-bit additions or subtractions.
......
226 226

  
227 227
static inline void *vis_alignaddr(void *_ptr)
228 228
{
229
        register void *ptr asm("g1");
229
        register void *ptr __asm__("g1");
230 230

  
231 231
        ptr = _ptr;
232 232

  
233
        asm volatile(".word %2"
233
        __asm__ volatile(".word %2"
234 234
                             : "=&r" (ptr)
235 235
                             : "0" (ptr),
236 236
                               "i" (vis_opc_base | vis_opf(0x18) |
......
243 243

  
244 244
static inline void vis_alignaddr_g0(void *_ptr)
245 245
{
246
        register void *ptr asm("g1");
246
        register void *ptr __asm__("g1");
247 247

  
248 248
        ptr = _ptr;
249 249

  
250
        asm volatile(".word %2"
250
        __asm__ volatile(".word %2"
251 251
                             : "=&r" (ptr)
252 252
                             : "0" (ptr),
253 253
                               "i" (vis_opc_base | vis_opf(0x18) |
......
258 258

  
259 259
static inline void *vis_alignaddrl(void *_ptr)
260 260
{
261
        register void *ptr asm("g1");
261
        register void *ptr __asm__("g1");
262 262

  
263 263
        ptr = _ptr;
264 264

  
265
        asm volatile(".word %2"
265
        __asm__ volatile(".word %2"
266 266
                             : "=&r" (ptr)
267 267
                             : "0" (ptr),
268 268
                               "i" (vis_opc_base | vis_opf(0x19) |
......
275 275

  
276 276
static inline void vis_alignaddrl_g0(void *_ptr)
277 277
{
278
        register void *ptr asm("g1");
278
        register void *ptr __asm__("g1");
279 279

  
280 280
        ptr = _ptr;
281 281

  
282
        asm volatile(".word %2"
282
        __asm__ volatile(".word %2"
283 283
                             : "=&r" (ptr)
284 284
                             : "0" (ptr),
285 285
                               "i" (vis_opc_base | vis_opf(0x19) |

Also available in: Unified diff