← Back to branch summary

~ubuntu-branches/ubuntu/precise/mesa-lts-quantal/precise-updates

« back to all changes in this revision

Viewing changes to src/gallium/auxiliary/gallivm/lp_bld_arit.h

  • Committer: Package Import Robot
  • Author(s): Maarten Lankhorst
  • Date: 2012-11-30 20:58:34 UTC
  • Revision ID: package-import@ubuntu.com-20121130205834-gazuvne3fpwlf012
Tags: upstream-9.0
Import upstream version 9.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/auxiliary/gallivm/lp_bld_arit.h
 
1
/**************************************************************************
 
2
 *
 
3
 * Copyright 2009 VMware, Inc.
 
4
 * All Rights Reserved.
 
5
 *
 
6
 * Permission is hereby granted, free of charge, to any person obtaining a
 
7
 * copy of this software and associated documentation files (the
 
8
 * "Software"), to deal in the Software without restriction, including
 
9
 * without limitation the rights to use, copy, modify, merge, publish,
 
10
 * distribute, sub license, and/or sell copies of the Software, and to
 
11
 * permit persons to whom the Software is furnished to do so, subject to
 
12
 * the following conditions:
 
13
 *
 
14
 * The above copyright notice and this permission notice (including the
 
15
 * next paragraph) shall be included in all copies or substantial portions
 
16
 * of the Software.
 
17
 *
 
18
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 
19
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 
20
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
 
21
 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
 
22
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 
23
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 
24
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
25
 *
 
26
 **************************************************************************/
 
27
 
 
28
/**
 
29
 * @file
 
30
 * Helper arithmetic functions.
 
31
 *
 
32
 * @author Jose Fonseca <jfonseca@vmware.com>
 
33
 */
 
34
 
 
35
 
 
36
#ifndef LP_BLD_ARIT_H
 
37
#define LP_BLD_ARIT_H
 
38
 
 
39
 
 
40
#include "gallivm/lp_bld.h"
 
41
 
 
42
 
 
43
struct lp_type;
 
44
struct lp_build_context;
 
45
 
 
46
 
 
47
/**
 
48
 * Complement, i.e., 1 - a.
 
49
 */
 
50
LLVMValueRef
 
51
lp_build_comp(struct lp_build_context *bld,
 
52
              LLVMValueRef a);
 
53
 
 
54
LLVMValueRef
 
55
lp_build_add(struct lp_build_context *bld,
 
56
             LLVMValueRef a,
 
57
             LLVMValueRef b);
 
58
 
 
59
LLVMValueRef
 
60
lp_build_horizontal_add(struct lp_build_context *bld,
 
61
                        LLVMValueRef a);
 
62
 
 
63
LLVMValueRef
 
64
lp_build_hadd_partial4(struct lp_build_context *bld,
 
65
                       LLVMValueRef vectors[],
 
66
                       unsigned num_vecs);
 
67
 
 
68
LLVMValueRef
 
69
lp_build_sub(struct lp_build_context *bld,
 
70
             LLVMValueRef a,
 
71
             LLVMValueRef b);
 
72
 
 
73
LLVMValueRef
 
74
lp_build_mul(struct lp_build_context *bld,
 
75
             LLVMValueRef a,
 
76
             LLVMValueRef b);
 
77
 
 
78
LLVMValueRef
 
79
lp_build_mul_imm(struct lp_build_context *bld,
 
80
                 LLVMValueRef a,
 
81
                 int b);
 
82
 
 
83
LLVMValueRef
 
84
lp_build_div(struct lp_build_context *bld,
 
85
             LLVMValueRef a,
 
86
             LLVMValueRef b);
 
87
 
 
88
LLVMValueRef
 
89
lp_build_lerp(struct lp_build_context *bld,
 
90
              LLVMValueRef x,
 
91
              LLVMValueRef v0,
 
92
              LLVMValueRef v1);
 
93
 
 
94
/**
 
95
 * Bilinear interpolation.
 
96
 *
 
97
 * Values indices are in v_{yx}.
 
98
 */
 
99
LLVMValueRef
 
100
lp_build_lerp_2d(struct lp_build_context *bld,
 
101
                 LLVMValueRef x,
 
102
                 LLVMValueRef y,
 
103
                 LLVMValueRef v00,
 
104
                 LLVMValueRef v01,
 
105
                 LLVMValueRef v10,
 
106
                 LLVMValueRef v11);
 
107
 
 
108
LLVMValueRef
 
109
lp_build_min(struct lp_build_context *bld,
 
110
             LLVMValueRef a,
 
111
             LLVMValueRef b);
 
112
 
 
113
LLVMValueRef
 
114
lp_build_max(struct lp_build_context *bld,
 
115
             LLVMValueRef a,
 
116
             LLVMValueRef b);
 
117
 
 
118
LLVMValueRef
 
119
lp_build_clamp(struct lp_build_context *bld,
 
120
               LLVMValueRef a,
 
121
               LLVMValueRef min,
 
122
               LLVMValueRef max);
 
123
 
 
124
LLVMValueRef
 
125
lp_build_abs(struct lp_build_context *bld,
 
126
             LLVMValueRef a);
 
127
 
 
128
LLVMValueRef
 
129
lp_build_negate(struct lp_build_context *bld,
 
130
                LLVMValueRef a);
 
131
 
 
132
LLVMValueRef
 
133
lp_build_sgn(struct lp_build_context *bld,
 
134
             LLVMValueRef a);
 
135
 
 
136
LLVMValueRef
 
137
lp_build_set_sign(struct lp_build_context *bld,
 
138
                  LLVMValueRef a, LLVMValueRef sign);
 
139
 
 
140
LLVMValueRef
 
141
lp_build_int_to_float(struct lp_build_context *bld,
 
142
                      LLVMValueRef a);
 
143
 
 
144
LLVMValueRef
 
145
lp_build_round(struct lp_build_context *bld,
 
146
               LLVMValueRef a);
 
147
 
 
148
LLVMValueRef
 
149
lp_build_floor(struct lp_build_context *bld,
 
150
               LLVMValueRef a);
 
151
 
 
152
LLVMValueRef
 
153
lp_build_ceil(struct lp_build_context *bld,
 
154
              LLVMValueRef a);
 
155
 
 
156
LLVMValueRef
 
157
lp_build_trunc(struct lp_build_context *bld,
 
158
               LLVMValueRef a);
 
159
 
 
160
LLVMValueRef
 
161
lp_build_fract(struct lp_build_context *bld,
 
162
               LLVMValueRef a);
 
163
 
 
164
LLVMValueRef
 
165
lp_build_fract_safe(struct lp_build_context *bld,
 
166
                    LLVMValueRef a);
 
167
 
 
168
LLVMValueRef
 
169
lp_build_ifloor(struct lp_build_context *bld,
 
170
                LLVMValueRef a);
 
171
LLVMValueRef
 
172
lp_build_iceil(struct lp_build_context *bld,
 
173
               LLVMValueRef a);
 
174
 
 
175
LLVMValueRef
 
176
lp_build_iround(struct lp_build_context *bld,
 
177
                LLVMValueRef a);
 
178
 
 
179
LLVMValueRef
 
180
lp_build_itrunc(struct lp_build_context *bld,
 
181
                LLVMValueRef a);
 
182
 
 
183
void
 
184
lp_build_ifloor_fract(struct lp_build_context *bld,
 
185
                      LLVMValueRef a,
 
186
                      LLVMValueRef *out_ipart,
 
187
                      LLVMValueRef *out_fpart);
 
188
 
 
189
void
 
190
lp_build_ifloor_fract_safe(struct lp_build_context *bld,
 
191
                           LLVMValueRef a,
 
192
                           LLVMValueRef *out_ipart,
 
193
                           LLVMValueRef *out_fpart);
 
194
 
 
195
LLVMValueRef
 
196
lp_build_sqrt(struct lp_build_context *bld,
 
197
              LLVMValueRef a);
 
198
 
 
199
LLVMValueRef
 
200
lp_build_rcp(struct lp_build_context *bld,
 
201
             LLVMValueRef a);
 
202
 
 
203
LLVMValueRef
 
204
lp_build_rsqrt(struct lp_build_context *bld,
 
205
               LLVMValueRef a);
 
206
 
 
207
LLVMValueRef
 
208
lp_build_cos(struct lp_build_context *bld,
 
209
             LLVMValueRef a);
 
210
 
 
211
LLVMValueRef
 
212
lp_build_sin(struct lp_build_context *bld,
 
213
             LLVMValueRef a);
 
214
 
 
215
LLVMValueRef
 
216
lp_build_pow(struct lp_build_context *bld,
 
217
             LLVMValueRef a,
 
218
             LLVMValueRef b);
 
219
 
 
220
LLVMValueRef
 
221
lp_build_exp(struct lp_build_context *bld,
 
222
             LLVMValueRef a);
 
223
 
 
224
LLVMValueRef
 
225
lp_build_log(struct lp_build_context *bld,
 
226
             LLVMValueRef a);
 
227
 
 
228
LLVMValueRef
 
229
lp_build_exp2(struct lp_build_context *bld,
 
230
              LLVMValueRef a);
 
231
 
 
232
LLVMValueRef
 
233
lp_build_extract_exponent(struct lp_build_context *bld,
 
234
                          LLVMValueRef x,
 
235
                          int bias);
 
236
 
 
237
LLVMValueRef
 
238
lp_build_extract_mantissa(struct lp_build_context *bld,
 
239
                          LLVMValueRef x);
 
240
 
 
241
LLVMValueRef
 
242
lp_build_log2(struct lp_build_context *bld,
 
243
              LLVMValueRef a);
 
244
 
 
245
LLVMValueRef
 
246
lp_build_fast_log2(struct lp_build_context *bld,
 
247
                   LLVMValueRef a);
 
248
 
 
249
LLVMValueRef
 
250
lp_build_ilog2(struct lp_build_context *bld,
 
251
               LLVMValueRef x);
 
252
 
 
253
void
 
254
lp_build_exp2_approx(struct lp_build_context *bld,
 
255
                     LLVMValueRef x,
 
256
                     LLVMValueRef *p_exp2_int_part,
 
257
                     LLVMValueRef *p_frac_part,
 
258
                     LLVMValueRef *p_exp2);
 
259
 
 
260
void
 
261
lp_build_log2_approx(struct lp_build_context *bld,
 
262
                     LLVMValueRef x,
 
263
                     LLVMValueRef *p_exp,
 
264
                     LLVMValueRef *p_floor_log2,
 
265
                     LLVMValueRef *p_log2);
 
266
 
 
267
LLVMValueRef
 
268
lp_build_mod(struct lp_build_context *bld,
 
269
             LLVMValueRef x,
 
270
             LLVMValueRef y);
 
271
 
 
272
#endif /* !LP_BLD_ARIT_H */