rsdRuntimeStubs.cpp revision f598811a60088236222bb1879503842094ca378b 
1/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "rsContext.h"
18#include "rsScriptC.h"
19#include "rsMatrix4x4.h"
20#include "rsMatrix3x3.h"
21#include "rsMatrix2x2.h"
22#include "rsRuntime.h"
23
24#include "utils/Timers.h"
25#include "rsdCore.h"
26#include "rsdBcc.h"
27
28#include "rsdRuntime.h"
29#include "rsdPath.h"
30#include "rsdAllocation.h"
31#include "rsdShaderCache.h"
32#include "rsdVertexArray.h"
33
34#include <time.h>
35
36using namespace android;
37using namespace android::renderscript;
38
39#define GET_TLS()  ScriptTLSStruct * tls = \
40    (ScriptTLSStruct *)pthread_getspecific(rsdgThreadTLSKey); \
41    Context * rsc = tls->mContext; \
42    ScriptC * sc = (ScriptC *) tls->mScript
43
44typedef float float2 __attribute__((ext_vector_type(2)));
45typedef float float3 __attribute__((ext_vector_type(3)));
46typedef float float4 __attribute__((ext_vector_type(4)));
47typedef char char2 __attribute__((ext_vector_type(2)));
48typedef char char3 __attribute__((ext_vector_type(3)));
49typedef char char4 __attribute__((ext_vector_type(4)));
50typedef unsigned char uchar2 __attribute__((ext_vector_type(2)));
51typedef unsigned char uchar3 __attribute__((ext_vector_type(3)));
52typedef unsigned char uchar4 __attribute__((ext_vector_type(4)));
53typedef short short2 __attribute__((ext_vector_type(2)));
54typedef short short3 __attribute__((ext_vector_type(3)));
55typedef short short4 __attribute__((ext_vector_type(4)));
56typedef unsigned short ushort2 __attribute__((ext_vector_type(2)));
57typedef unsigned short ushort3 __attribute__((ext_vector_type(3)));
58typedef unsigned short ushort4 __attribute__((ext_vector_type(4)));
59typedef int32_t int2 __attribute__((ext_vector_type(2)));
60typedef int32_t int3 __attribute__((ext_vector_type(3)));
61typedef int32_t int4 __attribute__((ext_vector_type(4)));
62typedef uint32_t uint2 __attribute__((ext_vector_type(2)));
63typedef uint32_t uint3 __attribute__((ext_vector_type(3)));
64typedef uint32_t uint4 __attribute__((ext_vector_type(4)));
65typedef long long long2 __attribute__((ext_vector_type(2)));
66typedef long long long3 __attribute__((ext_vector_type(3)));
67typedef long long long4 __attribute__((ext_vector_type(4)));
68typedef unsigned long long ulong2 __attribute__((ext_vector_type(2)));
69typedef unsigned long long ulong3 __attribute__((ext_vector_type(3)));
70typedef unsigned long long ulong4 __attribute__((ext_vector_type(4)));
71
72
73//////////////////////////////////////////////////////////////////////////////
74// Allocation
75//////////////////////////////////////////////////////////////////////////////
76
77
78static void SC_AllocationSyncAll2(Allocation *a, RsAllocationUsageType source) {
79    GET_TLS();
80    rsrAllocationSyncAll(rsc, sc, a, source);
81}
82
83static void SC_AllocationSyncAll(Allocation *a) {
84    GET_TLS();
85    rsrAllocationSyncAll(rsc, sc, a, RS_ALLOCATION_USAGE_SCRIPT);
86}
87
88static void SC_AllocationCopy1DRange(Allocation *dstAlloc,
89                                     uint32_t dstOff,
90                                     uint32_t dstMip,
91                                     uint32_t count,
92                                     Allocation *srcAlloc,
93                                     uint32_t srcOff, uint32_t srcMip) {
94    GET_TLS();
95    rsrAllocationCopy1DRange(rsc, dstAlloc, dstOff, dstMip, count,
96                             srcAlloc, srcOff, srcMip);
97}
98
99static void SC_AllocationCopy2DRange(Allocation *dstAlloc,
100                                     uint32_t dstXoff, uint32_t dstYoff,
101                                     uint32_t dstMip, uint32_t dstFace,
102                                     uint32_t width, uint32_t height,
103                                     Allocation *srcAlloc,
104                                     uint32_t srcXoff, uint32_t srcYoff,
105                                     uint32_t srcMip, uint32_t srcFace) {
106    GET_TLS();
107    rsrAllocationCopy2DRange(rsc, dstAlloc,
108                             dstXoff, dstYoff, dstMip, dstFace,
109                             width, height,
110                             srcAlloc,
111                             srcXoff, srcYoff, srcMip, srcFace);
112}
113
114static void SC_AllocationIoSend(Allocation *alloc) {
115    GET_TLS();
116    rsdAllocationIoSend(rsc, alloc);
117}
118
119
120static void SC_AllocationIoReceive(Allocation *alloc) {
121    GET_TLS();
122    rsdAllocationIoReceive(rsc, alloc);
123}
124
125
126
127//////////////////////////////////////////////////////////////////////////////
128// Context
129//////////////////////////////////////////////////////////////////////////////
130
131static void SC_BindTexture(ProgramFragment *pf, uint32_t slot, Allocation *a) {
132    GET_TLS();
133    rsrBindTexture(rsc, sc, pf, slot, a);
134}
135
136static void SC_BindVertexConstant(ProgramVertex *pv, uint32_t slot, Allocation *a) {
137    GET_TLS();
138    rsrBindConstant(rsc, sc, pv, slot, a);
139}
140
141static void SC_BindFragmentConstant(ProgramFragment *pf, uint32_t slot, Allocation *a) {
142    GET_TLS();
143    rsrBindConstant(rsc, sc, pf, slot, a);
144}
145
146static void SC_BindSampler(ProgramFragment *pf, uint32_t slot, Sampler *s) {
147    GET_TLS();
148    rsrBindSampler(rsc, sc, pf, slot, s);
149}
150
151static void SC_BindProgramStore(ProgramStore *ps) {
152    GET_TLS();
153    rsrBindProgramStore(rsc, sc, ps);
154}
155
156static void SC_BindProgramFragment(ProgramFragment *pf) {
157    GET_TLS();
158    rsrBindProgramFragment(rsc, sc, pf);
159}
160
161static void SC_BindProgramVertex(ProgramVertex *pv) {
162    GET_TLS();
163    rsrBindProgramVertex(rsc, sc, pv);
164}
165
166static void SC_BindProgramRaster(ProgramRaster *pr) {
167    GET_TLS();
168    rsrBindProgramRaster(rsc, sc, pr);
169}
170
171static void SC_BindFrameBufferObjectColorTarget(Allocation *a, uint32_t slot) {
172    GET_TLS();
173    rsrBindFrameBufferObjectColorTarget(rsc, sc, a, slot);
174}
175
176static void SC_BindFrameBufferObjectDepthTarget(Allocation *a) {
177    GET_TLS();
178    rsrBindFrameBufferObjectDepthTarget(rsc, sc, a);
179}
180
181static void SC_ClearFrameBufferObjectColorTarget(uint32_t slot) {
182    GET_TLS();
183    rsrClearFrameBufferObjectColorTarget(rsc, sc, slot);
184}
185
186static void SC_ClearFrameBufferObjectDepthTarget(Context *, Script *) {
187    GET_TLS();
188    rsrClearFrameBufferObjectDepthTarget(rsc, sc);
189}
190
191static void SC_ClearFrameBufferObjectTargets(Context *, Script *) {
192    GET_TLS();
193    rsrClearFrameBufferObjectTargets(rsc, sc);
194}
195
196
197//////////////////////////////////////////////////////////////////////////////
198// VP
199//////////////////////////////////////////////////////////////////////////////
200
201static void SC_VpLoadProjectionMatrix(const rsc_Matrix *m) {
202    GET_TLS();
203    rsrVpLoadProjectionMatrix(rsc, sc, m);
204}
205
206static void SC_VpLoadModelMatrix(const rsc_Matrix *m) {
207    GET_TLS();
208    rsrVpLoadModelMatrix(rsc, sc, m);
209}
210
211static void SC_VpLoadTextureMatrix(const rsc_Matrix *m) {
212    GET_TLS();
213    rsrVpLoadTextureMatrix(rsc, sc, m);
214}
215
216static void SC_PfConstantColor(ProgramFragment *pf, float r, float g, float b, float a) {
217    GET_TLS();
218    rsrPfConstantColor(rsc, sc, pf, r, g, b, a);
219}
220
221static void SC_VpGetProjectionMatrix(rsc_Matrix *m) {
222    GET_TLS();
223    rsrVpGetProjectionMatrix(rsc, sc, m);
224}
225
226
227//////////////////////////////////////////////////////////////////////////////
228// Drawing
229//////////////////////////////////////////////////////////////////////////////
230
231static void SC_DrawQuadTexCoords(float x1, float y1, float z1, float u1, float v1,
232                                 float x2, float y2, float z2, float u2, float v2,
233                                 float x3, float y3, float z3, float u3, float v3,
234                                 float x4, float y4, float z4, float u4, float v4) {
235    GET_TLS();
236
237    if (!rsc->setupCheck()) {
238        return;
239    }
240
241    RsdHal *dc = (RsdHal *)rsc->mHal.drv;
242    if (!dc->gl.shaderCache->setup(rsc)) {
243        return;
244    }
245
246    //ALOGE("Quad");
247    //ALOGE("%4.2f, %4.2f, %4.2f", x1, y1, z1);
248    //ALOGE("%4.2f, %4.2f, %4.2f", x2, y2, z2);
249    //ALOGE("%4.2f, %4.2f, %4.2f", x3, y3, z3);
250    //ALOGE("%4.2f, %4.2f, %4.2f", x4, y4, z4);
251
252    float vtx[] = {x1,y1,z1, x2,y2,z2, x3,y3,z3, x4,y4,z4};
253    const float tex[] = {u1,v1, u2,v2, u3,v3, u4,v4};
254
255    RsdVertexArray::Attrib attribs[2];
256    attribs[0].set(GL_FLOAT, 3, 12, false, (uint32_t)vtx, "ATTRIB_position");
257    attribs[1].set(GL_FLOAT, 2, 8, false, (uint32_t)tex, "ATTRIB_texture0");
258
259    RsdVertexArray va(attribs, 2);
260    va.setup(rsc);
261
262    RSD_CALL_GL(glDrawArrays, GL_TRIANGLE_FAN, 0, 4);
263}
264
265static void SC_DrawQuad(float x1, float y1, float z1,
266                        float x2, float y2, float z2,
267                        float x3, float y3, float z3,
268                        float x4, float y4, float z4) {
269    GET_TLS();
270    SC_DrawQuadTexCoords(x1, y1, z1, 0, 1,
271                         x2, y2, z2, 1, 1,
272                         x3, y3, z3, 1, 0,
273                         x4, y4, z4, 0, 0);
274}
275
276static void SC_DrawSpriteScreenspace(float x, float y, float z, float w, float h) {
277    GET_TLS();
278
279    ObjectBaseRef<const ProgramVertex> tmp(rsc->getProgramVertex());
280    rsc->setProgramVertex(rsc->getDefaultProgramVertex());
281    //rsc->setupCheck();
282
283    //GLint crop[4] = {0, h, w, -h};
284
285    float sh = rsc->getHeight();
286
287    SC_DrawQuad(x,   sh - y,     z,
288                x+w, sh - y,     z,
289                x+w, sh - (y+h), z,
290                x,   sh - (y+h), z);
291    rsc->setProgramVertex((ProgramVertex *)tmp.get());
292}
293
294static void SC_DrawRect(float x1, float y1, float x2, float y2, float z) {
295    GET_TLS();
296
297    SC_DrawQuad(x1, y2, z, x2, y2, z, x2, y1, z, x1, y1, z);
298
299}
300
301static void SC_DrawPath(Path *p) {
302    GET_TLS();
303    //rsrDrawPath(rsc, sc, p);
304    rsdPathDraw(rsc, p);
305}
306
307static void SC_DrawMesh(Mesh *m) {
308    GET_TLS();
309    rsrDrawMesh(rsc, sc, m);
310}
311
312static void SC_DrawMeshPrimitive(Mesh *m, uint32_t primIndex) {
313    GET_TLS();
314    rsrDrawMeshPrimitive(rsc, sc, m, primIndex);
315}
316
317static void SC_DrawMeshPrimitiveRange(Mesh *m, uint32_t primIndex, uint32_t start, uint32_t len) {
318    GET_TLS();
319    rsrDrawMeshPrimitiveRange(rsc, sc, m, primIndex, start, len);
320}
321
322static void SC_MeshComputeBoundingBox(Mesh *m,
323                               float *minX, float *minY, float *minZ,
324                               float *maxX, float *maxY, float *maxZ) {
325    GET_TLS();
326    rsrMeshComputeBoundingBox(rsc, sc, m, minX, minY, minZ, maxX, maxY, maxZ);
327}
328
329
330
331//////////////////////////////////////////////////////////////////////////////
332//
333//////////////////////////////////////////////////////////////////////////////
334
335
336static void SC_Color(float r, float g, float b, float a) {
337    GET_TLS();
338    rsrColor(rsc, sc, r, g, b, a);
339}
340
341static void SC_Finish() {
342    GET_TLS();
343    rsdGLFinish(rsc);
344}
345
346static void SC_ClearColor(float r, float g, float b, float a) {
347    GET_TLS();
348    rsrPrepareClear(rsc, sc);
349    rsdGLClearColor(rsc, r, g, b, a);
350}
351
352static void SC_ClearDepth(float v) {
353    GET_TLS();
354    rsrPrepareClear(rsc, sc);
355    rsdGLClearDepth(rsc, v);
356}
357
358static uint32_t SC_GetWidth() {
359    GET_TLS();
360    return rsrGetWidth(rsc, sc);
361}
362
363static uint32_t SC_GetHeight() {
364    GET_TLS();
365    return rsrGetHeight(rsc, sc);
366}
367
368static void SC_DrawTextAlloc(Allocation *a, int x, int y) {
369    GET_TLS();
370    rsrDrawTextAlloc(rsc, sc, a, x, y);
371}
372
373static void SC_DrawText(const char *text, int x, int y) {
374    GET_TLS();
375    rsrDrawText(rsc, sc, text, x, y);
376}
377
378static void SC_MeasureTextAlloc(Allocation *a,
379                         int32_t *left, int32_t *right, int32_t *top, int32_t *bottom) {
380    GET_TLS();
381    rsrMeasureTextAlloc(rsc, sc, a, left, right, top, bottom);
382}
383
384static void SC_MeasureText(const char *text,
385                    int32_t *left, int32_t *right, int32_t *top, int32_t *bottom) {
386    GET_TLS();
387    rsrMeasureText(rsc, sc, text, left, right, top, bottom);
388}
389
390static void SC_BindFont(Font *f) {
391    GET_TLS();
392    rsrBindFont(rsc, sc, f);
393}
394
395static void SC_FontColor(float r, float g, float b, float a) {
396    GET_TLS();
397    rsrFontColor(rsc, sc, r, g, b, a);
398}
399
400
401
402//////////////////////////////////////////////////////////////////////////////
403//
404//////////////////////////////////////////////////////////////////////////////
405
406static void SC_SetObject(ObjectBase **dst, ObjectBase * src) {
407    GET_TLS();
408    rsrSetObject(rsc, sc, dst, src);
409}
410
411static void SC_ClearObject(ObjectBase **dst) {
412    GET_TLS();
413    rsrClearObject(rsc, sc, dst);
414}
415
416static bool SC_IsObject(const ObjectBase *src) {
417    GET_TLS();
418    return rsrIsObject(rsc, sc, src);
419}
420
421
422
423
424static const Allocation * SC_GetAllocation(const void *ptr) {
425    GET_TLS();
426    return rsdScriptGetAllocationForPointer(rsc, sc, ptr);
427}
428
429static void SC_ForEach_SAA(Script *target,
430                            Allocation *in,
431                            Allocation *out) {
432    GET_TLS();
433    rsrForEach(rsc, sc, target, in, out, NULL, 0, NULL);
434}
435
436static void SC_ForEach_SAAU(Script *target,
437                            Allocation *in,
438                            Allocation *out,
439                            const void *usr) {
440    GET_TLS();
441    rsrForEach(rsc, sc, target, in, out, usr, 0, NULL);
442}
443
444static void SC_ForEach_SAAUS(Script *target,
445                             Allocation *in,
446                             Allocation *out,
447                             const void *usr,
448                             const RsScriptCall *call) {
449    GET_TLS();
450    rsrForEach(rsc, sc, target, in, out, usr, 0, call);
451}
452
453static void SC_ForEach_SAAUL(Script *target,
454                             Allocation *in,
455                             Allocation *out,
456                             const void *usr,
457                             uint32_t usrLen) {
458    GET_TLS();
459    rsrForEach(rsc, sc, target, in, out, usr, usrLen, NULL);
460}
461
462static void SC_ForEach_SAAULS(Script *target,
463                              Allocation *in,
464                              Allocation *out,
465                              const void *usr,
466                              uint32_t usrLen,
467                              const RsScriptCall *call) {
468    GET_TLS();
469    rsrForEach(rsc, sc, target, in, out, usr, usrLen, call);
470}
471
472
473
474//////////////////////////////////////////////////////////////////////////////
475// Time routines
476//////////////////////////////////////////////////////////////////////////////
477
478static float SC_GetDt() {
479    GET_TLS();
480    return rsrGetDt(rsc, sc);
481}
482
483time_t SC_Time(time_t *timer) {
484    GET_TLS();
485    return rsrTime(rsc, sc, timer);
486}
487
488tm* SC_LocalTime(tm *local, time_t *timer) {
489    GET_TLS();
490    return rsrLocalTime(rsc, sc, local, timer);
491}
492
493int64_t SC_UptimeMillis() {
494    GET_TLS();
495    return rsrUptimeMillis(rsc, sc);
496}
497
498int64_t SC_UptimeNanos() {
499    GET_TLS();
500    return rsrUptimeNanos(rsc, sc);
501}
502
503//////////////////////////////////////////////////////////////////////////////
504// Message routines
505//////////////////////////////////////////////////////////////////////////////
506
507static uint32_t SC_ToClient2(int cmdID, void *data, int len) {
508    GET_TLS();
509    return rsrToClient(rsc, sc, cmdID, data, len);
510}
511
512static uint32_t SC_ToClient(int cmdID) {
513    GET_TLS();
514    return rsrToClient(rsc, sc, cmdID, NULL, 0);
515}
516
517static uint32_t SC_ToClientBlocking2(int cmdID, void *data, int len) {
518    GET_TLS();
519    return rsrToClientBlocking(rsc, sc, cmdID, data, len);
520}
521
522static uint32_t SC_ToClientBlocking(int cmdID) {
523    GET_TLS();
524    return rsrToClientBlocking(rsc, sc, cmdID, NULL, 0);
525}
526
527int SC_divsi3(int a, int b) {
528    return a / b;
529}
530
531int SC_modsi3(int a, int b) {
532    return a % b;
533}
534
535unsigned int SC_udivsi3(unsigned int a, unsigned int b) {
536    return a / b;
537}
538
539unsigned int SC_umodsi3(unsigned int a, unsigned int b) {
540    return a % b;
541}
542
543static void SC_debugF(const char *s, float f) {
544    ALOGD("%s %f, 0x%08x", s, f, *((int *) (&f)));
545}
546static void SC_debugFv2(const char *s, float f1, float f2) {
547    ALOGD("%s {%f, %f}", s, f1, f2);
548}
549static void SC_debugFv3(const char *s, float f1, float f2, float f3) {
550    ALOGD("%s {%f, %f, %f}", s, f1, f2, f3);
551}
552static void SC_debugFv4(const char *s, float f1, float f2, float f3, float f4) {
553    ALOGD("%s {%f, %f, %f, %f}", s, f1, f2, f3, f4);
554}
555static void SC_debugF2(const char *s, float2 f) {
556    ALOGD("%s {%f, %f}", s, f.x, f.y);
557}
558static void SC_debugF3(const char *s, float3 f) {
559    ALOGD("%s {%f, %f, %f}", s, f.x, f.y, f.z);
560}
561static void SC_debugF4(const char *s, float4 f) {
562    ALOGD("%s {%f, %f, %f, %f}", s, f.x, f.y, f.z, f.w);
563}
564static void SC_debugD(const char *s, double d) {
565    ALOGD("%s %f, 0x%08llx", s, d, *((long long *) (&d)));
566}
567static void SC_debugFM4v4(const char *s, const float *f) {
568    ALOGD("%s {%f, %f, %f, %f", s, f[0], f[4], f[8], f[12]);
569    ALOGD("%s  %f, %f, %f, %f", s, f[1], f[5], f[9], f[13]);
570    ALOGD("%s  %f, %f, %f, %f", s, f[2], f[6], f[10], f[14]);
571    ALOGD("%s  %f, %f, %f, %f}", s, f[3], f[7], f[11], f[15]);
572}
573static void SC_debugFM3v3(const char *s, const float *f) {
574    ALOGD("%s {%f, %f, %f", s, f[0], f[3], f[6]);
575    ALOGD("%s  %f, %f, %f", s, f[1], f[4], f[7]);
576    ALOGD("%s  %f, %f, %f}",s, f[2], f[5], f[8]);
577}
578static void SC_debugFM2v2(const char *s, const float *f) {
579    ALOGD("%s {%f, %f", s, f[0], f[2]);
580    ALOGD("%s  %f, %f}",s, f[1], f[3]);
581}
582static void SC_debugI8(const char *s, char c) {
583    ALOGD("%s %hhd  0x%hhx", s, c, (unsigned char)c);
584}
585static void SC_debugC2(const char *s, char2 c) {
586    ALOGD("%s {%hhd, %hhd}  0x%hhx 0x%hhx", s, c.x, c.y, (unsigned char)c.x, (unsigned char)c.y);
587}
588static void SC_debugC3(const char *s, char3 c) {
589    ALOGD("%s {%hhd, %hhd, %hhd}  0x%hhx 0x%hhx 0x%hhx", s, c.x, c.y, c.z, (unsigned char)c.x, (unsigned char)c.y, (unsigned char)c.z);
590}
591static void SC_debugC4(const char *s, char4 c) {
592    ALOGD("%s {%hhd, %hhd, %hhd, %hhd}  0x%hhx 0x%hhx 0x%hhx 0x%hhx", s, c.x, c.y, c.z, c.w, (unsigned char)c.x, (unsigned char)c.y, (unsigned char)c.z, (unsigned char)c.w);
593}
594static void SC_debugU8(const char *s, unsigned char c) {
595    ALOGD("%s %hhu  0x%hhx", s, c, c);
596}
597static void SC_debugUC2(const char *s, uchar2 c) {
598    ALOGD("%s {%hhu, %hhu}  0x%hhx 0x%hhx", s, c.x, c.y, c.x, c.y);
599}
600static void SC_debugUC3(const char *s, uchar3 c) {
601    ALOGD("%s {%hhu, %hhu, %hhu}  0x%hhx 0x%hhx 0x%hhx", s, c.x, c.y, c.z, c.x, c.y, c.z);
602}
603static void SC_debugUC4(const char *s, uchar4 c) {
604    ALOGD("%s {%hhu, %hhu, %hhu, %hhu}  0x%hhx 0x%hhx 0x%hhx 0x%hhx", s, c.x, c.y, c.z, c.w, c.x, c.y, c.z, c.w);
605}
606static void SC_debugI16(const char *s, short c) {
607    ALOGD("%s %hd  0x%hx", s, c, c);
608}
609static void SC_debugS2(const char *s, short2 c) {
610    ALOGD("%s {%hd, %hd}  0x%hx 0x%hx", s, c.x, c.y, c.x, c.y);
611}
612static void SC_debugS3(const char *s, short3 c) {
613    ALOGD("%s {%hd, %hd, %hd}  0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.x, c.y, c.z);
614}
615static void SC_debugS4(const char *s, short4 c) {
616    ALOGD("%s {%hd, %hd, %hd, %hd}  0x%hx 0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.w, c.x, c.y, c.z, c.w);
617}
618static void SC_debugU16(const char *s, unsigned short c) {
619    ALOGD("%s %hu  0x%hx", s, c, c);
620}
621static void SC_debugUS2(const char *s, ushort2 c) {
622    ALOGD("%s {%hu, %hu}  0x%hx 0x%hx", s, c.x, c.y, c.x, c.y);
623}
624static void SC_debugUS3(const char *s, ushort3 c) {
625    ALOGD("%s {%hu, %hu, %hu}  0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.x, c.y, c.z);
626}
627static void SC_debugUS4(const char *s, ushort4 c) {
628    ALOGD("%s {%hu, %hu, %hu, %hu}  0x%hx 0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.w, c.x, c.y, c.z, c.w);
629}
630static void SC_debugI32(const char *s, int32_t i) {
631    ALOGD("%s %d  0x%x", s, i, i);
632}
633static void SC_debugI2(const char *s, int2 i) {
634    ALOGD("%s {%d, %d}  0x%x 0x%x", s, i.x, i.y, i.x, i.y);
635}
636static void SC_debugI3(const char *s, int3 i) {
637    ALOGD("%s {%d, %d, %d}  0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.x, i.y, i.z);
638}
639static void SC_debugI4(const char *s, int4 i) {
640    ALOGD("%s {%d, %d, %d, %d}  0x%x 0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.w, i.x, i.y, i.z, i.w);
641}
642static void SC_debugU32(const char *s, uint32_t i) {
643    ALOGD("%s %u  0x%x", s, i, i);
644}
645static void SC_debugUI2(const char *s, uint2 i) {
646    ALOGD("%s {%u, %u}  0x%x 0x%x", s, i.x, i.y, i.x, i.y);
647}
648static void SC_debugUI3(const char *s, uint3 i) {
649    ALOGD("%s {%u, %u, %u}  0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.x, i.y, i.z);
650}
651static void SC_debugUI4(const char *s, uint4 i) {
652    ALOGD("%s {%u, %u, %u, %u}  0x%x 0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.w, i.x, i.y, i.z, i.w);
653}
654static void SC_debugLL64(const char *s, long long ll) {
655    ALOGD("%s %lld  0x%llx", s, ll, ll);
656}
657static void SC_debugL2(const char *s, long2 ll) {
658    ALOGD("%s {%lld, %lld}  0x%llx 0x%llx", s, ll.x, ll.y, ll.x, ll.y);
659}
660static void SC_debugL3(const char *s, long3 ll) {
661    ALOGD("%s {%lld, %lld, %lld}  0x%llx 0x%llx 0x%llx", s, ll.x, ll.y, ll.z, ll.x, ll.y, ll.z);
662}
663static void SC_debugL4(const char *s, long4 ll) {
664    ALOGD("%s {%lld, %lld, %lld, %lld}  0x%llx 0x%llx 0x%llx 0x%llx", s, ll.x, ll.y, ll.z, ll.w, ll.x, ll.y, ll.z, ll.w);
665}
666static void SC_debugULL64(const char *s, unsigned long long ll) {
667    ALOGD("%s %llu  0x%llx", s, ll, ll);
668}
669static void SC_debugUL2(const char *s, ulong2 ll) {
670    ALOGD("%s {%llu, %llu}  0x%llx 0x%llx", s, ll.x, ll.y, ll.x, ll.y);
671}
672static void SC_debugUL3(const char *s, ulong3 ll) {
673    ALOGD("%s {%llu, %llu, %llu}  0x%llx 0x%llx 0x%llx", s, ll.x, ll.y, ll.z, ll.x, ll.y, ll.z);
674}
675static void SC_debugUL4(const char *s, ulong4 ll) {
676    ALOGD("%s {%llu, %llu, %llu, %llu}  0x%llx 0x%llx 0x%llx 0x%llx", s, ll.x, ll.y, ll.z, ll.w, ll.x, ll.y, ll.z, ll.w);
677}
678static void SC_debugP(const char *s, const void *p) {
679    ALOGD("%s %p", s, p);
680}
681
682
683//////////////////////////////////////////////////////////////////////////////
684// Stub implementation
685//////////////////////////////////////////////////////////////////////////////
686
687// llvm name mangling ref
688//  <builtin-type> ::= v  # void
689//                 ::= b  # bool
690//                 ::= c  # char
691//                 ::= a  # signed char
692//                 ::= h  # unsigned char
693//                 ::= s  # short
694//                 ::= t  # unsigned short
695//                 ::= i  # int
696//                 ::= j  # unsigned int
697//                 ::= l  # long
698//                 ::= m  # unsigned long
699//                 ::= x  # long long, __int64
700//                 ::= y  # unsigned long long, __int64
701//                 ::= f  # float
702//                 ::= d  # double
703
704static RsdSymbolTable gSyms[] = {
705    { "memset", (void *)&memset, true },
706    { "memcpy", (void *)&memcpy, true },
707
708    // Refcounting
709    { "_Z11rsSetObjectP10rs_elementS_", (void *)&SC_SetObject, true },
710    { "_Z13rsClearObjectP10rs_element", (void *)&SC_ClearObject, true },
711    { "_Z10rsIsObject10rs_element", (void *)&SC_IsObject, true },
712
713    { "_Z11rsSetObjectP7rs_typeS_", (void *)&SC_SetObject, true },
714    { "_Z13rsClearObjectP7rs_type", (void *)&SC_ClearObject, true },
715    { "_Z10rsIsObject7rs_type", (void *)&SC_IsObject, true },
716
717    { "_Z11rsSetObjectP13rs_allocationS_", (void *)&SC_SetObject, true },
718    { "_Z13rsClearObjectP13rs_allocation", (void *)&SC_ClearObject, true },
719    { "_Z10rsIsObject13rs_allocation", (void *)&SC_IsObject, true },
720
721    { "_Z11rsSetObjectP10rs_samplerS_", (void *)&SC_SetObject, true },
722    { "_Z13rsClearObjectP10rs_sampler", (void *)&SC_ClearObject, true },
723    { "_Z10rsIsObject10rs_sampler", (void *)&SC_IsObject, true },
724
725    { "_Z11rsSetObjectP9rs_scriptS_", (void *)&SC_SetObject, true },
726    { "_Z13rsClearObjectP9rs_script", (void *)&SC_ClearObject, true },
727    { "_Z10rsIsObject9rs_script", (void *)&SC_IsObject, true },
728
729    { "_Z11rsSetObjectP7rs_pathS_", (void *)&SC_SetObject, true },
730    { "_Z13rsClearObjectP7rs_path", (void *)&SC_ClearObject, true },
731    { "_Z10rsIsObject7rs_path", (void *)&SC_IsObject, true },
732
733    { "_Z11rsSetObjectP7rs_meshS_", (void *)&SC_SetObject, true },
734    { "_Z13rsClearObjectP7rs_mesh", (void *)&SC_ClearObject, true },
735    { "_Z10rsIsObject7rs_mesh", (void *)&SC_IsObject, true },
736
737    { "_Z11rsSetObjectP19rs_program_fragmentS_", (void *)&SC_SetObject, true },
738    { "_Z13rsClearObjectP19rs_program_fragment", (void *)&SC_ClearObject, true },
739    { "_Z10rsIsObject19rs_program_fragment", (void *)&SC_IsObject, true },
740
741    { "_Z11rsSetObjectP17rs_program_vertexS_", (void *)&SC_SetObject, true },
742    { "_Z13rsClearObjectP17rs_program_vertex", (void *)&SC_ClearObject, true },
743    { "_Z10rsIsObject17rs_program_vertex", (void *)&SC_IsObject, true },
744
745    { "_Z11rsSetObjectP17rs_program_rasterS_", (void *)&SC_SetObject, true },
746    { "_Z13rsClearObjectP17rs_program_raster", (void *)&SC_ClearObject, true },
747    { "_Z10rsIsObject17rs_program_raster", (void *)&SC_IsObject, true },
748
749    { "_Z11rsSetObjectP16rs_program_storeS_", (void *)&SC_SetObject, true },
750    { "_Z13rsClearObjectP16rs_program_store", (void *)&SC_ClearObject, true },
751    { "_Z10rsIsObject16rs_program_store", (void *)&SC_IsObject, true },
752
753    { "_Z11rsSetObjectP7rs_fontS_", (void *)&SC_SetObject, true },
754    { "_Z13rsClearObjectP7rs_font", (void *)&SC_ClearObject, true },
755    { "_Z10rsIsObject7rs_font", (void *)&SC_IsObject, true },
756
757    // Allocation ops
758    { "_Z21rsAllocationMarkDirty13rs_allocation", (void *)&SC_AllocationSyncAll, true },
759    { "_Z20rsgAllocationSyncAll13rs_allocation", (void *)&SC_AllocationSyncAll, false },
760    { "_Z20rsgAllocationSyncAll13rs_allocationj", (void *)&SC_AllocationSyncAll2, false },
761    { "_Z20rsgAllocationSyncAll13rs_allocation24rs_allocation_usage_type", (void *)&SC_AllocationSyncAll2, false },
762    { "_Z15rsGetAllocationPKv", (void *)&SC_GetAllocation, true },
763    { "_Z18rsAllocationIoSend13rs_allocation", (void *)&SC_AllocationIoSend, false },
764    { "_Z21rsAllocationIoReceive13rs_allocation", (void *)&SC_AllocationIoReceive, false },
765    { "_Z23rsAllocationCopy1DRange13rs_allocationjjjS_jj", (void *)&SC_AllocationCopy1DRange, false },
766    { "_Z23rsAllocationCopy2DRange13rs_allocationjjj26rs_allocation_cubemap_facejjS_jjjS0_", (void *)&SC_AllocationCopy2DRange, false },
767
768    // Messaging
769
770    { "_Z14rsSendToClienti", (void *)&SC_ToClient, false },
771    { "_Z14rsSendToClientiPKvj", (void *)&SC_ToClient2, false },
772    { "_Z22rsSendToClientBlockingi", (void *)&SC_ToClientBlocking, false },
773    { "_Z22rsSendToClientBlockingiPKvj", (void *)&SC_ToClientBlocking2, false },
774
775    { "_Z22rsgBindProgramFragment19rs_program_fragment", (void *)&SC_BindProgramFragment, false },
776    { "_Z19rsgBindProgramStore16rs_program_store", (void *)&SC_BindProgramStore, false },
777    { "_Z20rsgBindProgramVertex17rs_program_vertex", (void *)&SC_BindProgramVertex, false },
778    { "_Z20rsgBindProgramRaster17rs_program_raster", (void *)&SC_BindProgramRaster, false },
779    { "_Z14rsgBindSampler19rs_program_fragmentj10rs_sampler", (void *)&SC_BindSampler, false },
780    { "_Z14rsgBindTexture19rs_program_fragmentj13rs_allocation", (void *)&SC_BindTexture, false },
781    { "_Z15rsgBindConstant19rs_program_fragmentj13rs_allocation", (void *)&SC_BindFragmentConstant, false },
782    { "_Z15rsgBindConstant17rs_program_vertexj13rs_allocation", (void *)&SC_BindVertexConstant, false },
783
784    { "_Z36rsgProgramVertexLoadProjectionMatrixPK12rs_matrix4x4", (void *)&SC_VpLoadProjectionMatrix, false },
785    { "_Z31rsgProgramVertexLoadModelMatrixPK12rs_matrix4x4", (void *)&SC_VpLoadModelMatrix, false },
786    { "_Z33rsgProgramVertexLoadTextureMatrixPK12rs_matrix4x4", (void *)&SC_VpLoadTextureMatrix, false },
787
788    { "_Z35rsgProgramVertexGetProjectionMatrixP12rs_matrix4x4", (void *)&SC_VpGetProjectionMatrix, false },
789
790    { "_Z31rsgProgramFragmentConstantColor19rs_program_fragmentffff", (void *)&SC_PfConstantColor, false },
791
792    { "_Z11rsgGetWidthv", (void *)&SC_GetWidth, false },
793    { "_Z12rsgGetHeightv", (void *)&SC_GetHeight, false },
794
795
796    { "_Z11rsgDrawRectfffff", (void *)&SC_DrawRect, false },
797    { "_Z11rsgDrawQuadffffffffffff", (void *)&SC_DrawQuad, false },
798    { "_Z20rsgDrawQuadTexCoordsffffffffffffffffffff", (void *)&SC_DrawQuadTexCoords, false },
799    { "_Z24rsgDrawSpriteScreenspacefffff", (void *)&SC_DrawSpriteScreenspace, false },
800
801    { "_Z11rsgDrawMesh7rs_mesh", (void *)&SC_DrawMesh, false },
802    { "_Z11rsgDrawMesh7rs_meshj", (void *)&SC_DrawMeshPrimitive, false },
803    { "_Z11rsgDrawMesh7rs_meshjjj", (void *)&SC_DrawMeshPrimitiveRange, false },
804    { "_Z25rsgMeshComputeBoundingBox7rs_meshPfS0_S0_S0_S0_S0_", (void *)&SC_MeshComputeBoundingBox, false },
805
806    { "_Z11rsgDrawPath7rs_path", (void *)&SC_DrawPath, false },
807
808    { "_Z13rsgClearColorffff", (void *)&SC_ClearColor, false },
809    { "_Z13rsgClearDepthf", (void *)&SC_ClearDepth, false },
810
811    { "_Z11rsgDrawTextPKcii", (void *)&SC_DrawText, false },
812    { "_Z11rsgDrawText13rs_allocationii", (void *)&SC_DrawTextAlloc, false },
813    { "_Z14rsgMeasureTextPKcPiS1_S1_S1_", (void *)&SC_MeasureText, false },
814    { "_Z14rsgMeasureText13rs_allocationPiS0_S0_S0_", (void *)&SC_MeasureTextAlloc, false },
815
816    { "_Z11rsgBindFont7rs_font", (void *)&SC_BindFont, false },
817    { "_Z12rsgFontColorffff", (void *)&SC_FontColor, false },
818
819    { "_Z18rsgBindColorTarget13rs_allocationj", (void *)&SC_BindFrameBufferObjectColorTarget, false },
820    { "_Z18rsgBindDepthTarget13rs_allocation", (void *)&SC_BindFrameBufferObjectDepthTarget, false },
821    { "_Z19rsgClearColorTargetj", (void *)&SC_ClearFrameBufferObjectColorTarget, false },
822    { "_Z19rsgClearDepthTargetv", (void *)&SC_ClearFrameBufferObjectDepthTarget, false },
823    { "_Z24rsgClearAllRenderTargetsv", (void *)&SC_ClearFrameBufferObjectTargets, false },
824
825    { "_Z9rsForEach9rs_script13rs_allocationS0_", (void *)&SC_ForEach_SAA, true },
826    { "_Z9rsForEach9rs_script13rs_allocationS0_PKv", (void *)&SC_ForEach_SAAU, true },
827    { "_Z9rsForEach9rs_script13rs_allocationS0_PKvPK14rs_script_call", (void *)&SC_ForEach_SAAUS, true },
828    { "_Z9rsForEach9rs_script13rs_allocationS0_PKvj", (void *)&SC_ForEach_SAAUL, true },
829    { "_Z9rsForEach9rs_script13rs_allocationS0_PKvjPK14rs_script_call", (void *)&SC_ForEach_SAAULS, true },
830
831    // time
832    { "_Z6rsTimePi", (void *)&SC_Time, true },
833    { "_Z11rsLocaltimeP5rs_tmPKi", (void *)&SC_LocalTime, true },
834    { "_Z14rsUptimeMillisv", (void*)&SC_UptimeMillis, true },
835    { "_Z13rsUptimeNanosv", (void*)&SC_UptimeNanos, true },
836    { "_Z7rsGetDtv", (void*)&SC_GetDt, false },
837
838    // misc
839    { "_Z5colorffff", (void *)&SC_Color, false },
840    { "_Z9rsgFinishv", (void *)&SC_Finish, false },
841
842    // Debug
843    { "_Z7rsDebugPKcf", (void *)&SC_debugF, true },
844    { "_Z7rsDebugPKcff", (void *)&SC_debugFv2, true },
845    { "_Z7rsDebugPKcfff", (void *)&SC_debugFv3, true },
846    { "_Z7rsDebugPKcffff", (void *)&SC_debugFv4, true },
847    { "_Z7rsDebugPKcDv2_f", (void *)&SC_debugF2, true },
848    { "_Z7rsDebugPKcDv3_f", (void *)&SC_debugF3, true },
849    { "_Z7rsDebugPKcDv4_f", (void *)&SC_debugF4, true },
850    { "_Z7rsDebugPKcd", (void *)&SC_debugD, true },
851    { "_Z7rsDebugPKcPK12rs_matrix4x4", (void *)&SC_debugFM4v4, true },
852    { "_Z7rsDebugPKcPK12rs_matrix3x3", (void *)&SC_debugFM3v3, true },
853    { "_Z7rsDebugPKcPK12rs_matrix2x2", (void *)&SC_debugFM2v2, true },
854    { "_Z7rsDebugPKcc", (void *)&SC_debugI8, true },
855    { "_Z7rsDebugPKcDv2_c", (void *)&SC_debugC2, true },
856    { "_Z7rsDebugPKcDv3_c", (void *)&SC_debugC3, true },
857    { "_Z7rsDebugPKcDv4_c", (void *)&SC_debugC4, true },
858    { "_Z7rsDebugPKch", (void *)&SC_debugU8, true },
859    { "_Z7rsDebugPKcDv2_h", (void *)&SC_debugUC2, true },
860    { "_Z7rsDebugPKcDv3_h", (void *)&SC_debugUC3, true },
861    { "_Z7rsDebugPKcDv4_h", (void *)&SC_debugUC4, true },
862    { "_Z7rsDebugPKcs", (void *)&SC_debugI16, true },
863    { "_Z7rsDebugPKcDv2_s", (void *)&SC_debugS2, true },
864    { "_Z7rsDebugPKcDv3_s", (void *)&SC_debugS3, true },
865    { "_Z7rsDebugPKcDv4_s", (void *)&SC_debugS4, true },
866    { "_Z7rsDebugPKct", (void *)&SC_debugU16, true },
867    { "_Z7rsDebugPKcDv2_t", (void *)&SC_debugUS2, true },
868    { "_Z7rsDebugPKcDv3_t", (void *)&SC_debugUS3, true },
869    { "_Z7rsDebugPKcDv4_t", (void *)&SC_debugUS4, true },
870    { "_Z7rsDebugPKci", (void *)&SC_debugI32, true },
871    { "_Z7rsDebugPKcDv2_i", (void *)&SC_debugI2, true },
872    { "_Z7rsDebugPKcDv3_i", (void *)&SC_debugI3, true },
873    { "_Z7rsDebugPKcDv4_i", (void *)&SC_debugI4, true },
874    { "_Z7rsDebugPKcj", (void *)&SC_debugU32, true },
875    { "_Z7rsDebugPKcDv2_j", (void *)&SC_debugUI2, true },
876    { "_Z7rsDebugPKcDv3_j", (void *)&SC_debugUI3, true },
877    { "_Z7rsDebugPKcDv4_j", (void *)&SC_debugUI4, true },
878    // Both "long" and "unsigned long" need to be redirected to their
879    // 64-bit counterparts, since we have hacked Slang to use 64-bit
880    // for "long" on Arm (to be similar to Java).
881    { "_Z7rsDebugPKcl", (void *)&SC_debugLL64, true },
882    { "_Z7rsDebugPKcDv2_l", (void *)&SC_debugL2, true },
883    { "_Z7rsDebugPKcDv3_l", (void *)&SC_debugL3, true },
884    { "_Z7rsDebugPKcDv4_l", (void *)&SC_debugL4, true },
885    { "_Z7rsDebugPKcm", (void *)&SC_debugULL64, true },
886    { "_Z7rsDebugPKcDv2_m", (void *)&SC_debugUL2, true },
887    { "_Z7rsDebugPKcDv3_m", (void *)&SC_debugUL3, true },
888    { "_Z7rsDebugPKcDv4_m", (void *)&SC_debugUL4, true },
889    { "_Z7rsDebugPKcx", (void *)&SC_debugLL64, true },
890    { "_Z7rsDebugPKcDv2_x", (void *)&SC_debugL2, true },
891    { "_Z7rsDebugPKcDv3_x", (void *)&SC_debugL3, true },
892    { "_Z7rsDebugPKcDv4_x", (void *)&SC_debugL4, true },
893    { "_Z7rsDebugPKcy", (void *)&SC_debugULL64, true },
894    { "_Z7rsDebugPKcDv2_y", (void *)&SC_debugUL2, true },
895    { "_Z7rsDebugPKcDv3_y", (void *)&SC_debugUL3, true },
896    { "_Z7rsDebugPKcDv4_y", (void *)&SC_debugUL4, true },
897    { "_Z7rsDebugPKcPKv", (void *)&SC_debugP, true },
898
899    { NULL, NULL, false }
900};
901
902
903void* rsdLookupRuntimeStub(void* pContext, char const* name) {
904    ScriptC *s = (ScriptC *)pContext;
905    RsdSymbolTable *syms = gSyms;
906    const RsdSymbolTable *sym = rsdLookupSymbolMath(name);
907
908    if (!sym) {
909        while (syms->mPtr) {
910            if (!strcmp(syms->mName, name)) {
911                sym = syms;
912            }
913            syms++;
914        }
915    }
916
917    if (sym) {
918        s->mHal.info.isThreadable &= sym->threadable;
919        return sym->mPtr;
920    }
921    ALOGE("ScriptC sym lookup failed for %s", name);
922    return NULL;
923}
924
925
926