rsdRuntimeStubs.cpp revision c500e74d0848b721bf01cf0ab344a6adb035c312
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 27#include "rsdRuntime.h" 28 29#include <time.h> 30 31using namespace android; 32using namespace android::renderscript; 33 34#define GET_TLS() ScriptTLSStruct * tls = \ 35 (ScriptTLSStruct *)pthread_getspecific(rsdgThreadTLSKey); \ 36 Context * rsc = tls->mContext; \ 37 ScriptC * sc = (ScriptC *) tls->mScript 38 39 40 41////////////////////////////////////////////////////////////////////////////// 42// Allocation 43////////////////////////////////////////////////////////////////////////////// 44 45static uint32_t SC_allocGetDimX(Allocation *a) { 46 return a->mHal.state.dimensionX; 47} 48 49static uint32_t SC_allocGetDimY(Allocation *a) { 50 return a->mHal.state.dimensionY; 51} 52 53static uint32_t SC_allocGetDimZ(Allocation *a) { 54 return a->mHal.state.dimensionZ; 55} 56 57static uint32_t SC_allocGetDimLOD(Allocation *a) { 58 return a->mHal.state.hasMipmaps; 59} 60 61static uint32_t SC_allocGetDimFaces(Allocation *a) { 62 return a->mHal.state.hasFaces; 63} 64 65static const void * SC_getElementAtX(Allocation *a, uint32_t x) { 66 const uint8_t *p = (const uint8_t *)a->getPtr(); 67 return &p[a->mHal.state.elementSizeBytes * x]; 68} 69 70static const void * SC_getElementAtXY(Allocation *a, uint32_t x, uint32_t y) { 71 const uint8_t *p = (const uint8_t *)a->getPtr(); 72 return &p[a->mHal.state.elementSizeBytes * (x + y * a->mHal.state.dimensionX)]; 73} 74 75static const void * SC_getElementAtXYZ(Allocation *a, uint32_t x, uint32_t y, uint32_t z) { 76 const uint8_t *p = (const uint8_t *)a->getPtr(); 77 return &p[a->mHal.state.elementSizeBytes * (x + y * a->mHal.state.dimensionX + 78 z * a->mHal.state.dimensionX * a->mHal.state.dimensionY)]; 79} 80 81static void SC_AllocationSyncAll2(Allocation *a, RsAllocationUsageType source) { 82 GET_TLS(); 83 rsrAllocationSyncAll(rsc, sc, a, source); 84} 85 86static void SC_AllocationSyncAll(Allocation *a) { 87 GET_TLS(); 88 rsrAllocationSyncAll(rsc, sc, a, RS_ALLOCATION_USAGE_SCRIPT); 89} 90 91static void SC_AllocationCopy1DRange(Allocation *dstAlloc, 92 uint32_t dstOff, 93 uint32_t dstMip, 94 uint32_t count, 95 Allocation *srcAlloc, 96 uint32_t srcOff, uint32_t srcMip) { 97 GET_TLS(); 98 rsrAllocationCopy1DRange(rsc, dstAlloc, dstOff, dstMip, count, 99 srcAlloc, srcOff, srcMip); 100} 101 102static void SC_AllocationCopy2DRange(Allocation *dstAlloc, 103 uint32_t dstXoff, uint32_t dstYoff, 104 uint32_t dstMip, uint32_t dstFace, 105 uint32_t width, uint32_t height, 106 Allocation *srcAlloc, 107 uint32_t srcXoff, uint32_t srcYoff, 108 uint32_t srcMip, uint32_t srcFace) { 109 GET_TLS(); 110 rsrAllocationCopy2DRange(rsc, dstAlloc, 111 dstXoff, dstYoff, dstMip, dstFace, 112 width, height, 113 srcAlloc, 114 srcXoff, srcYoff, srcMip, srcFace); 115} 116 117 118const Allocation * SC_getAllocation(const void *ptr) { 119 GET_TLS(); 120 return rsrGetAllocation(rsc, sc, ptr); 121} 122 123 124////////////////////////////////////////////////////////////////////////////// 125// Context 126////////////////////////////////////////////////////////////////////////////// 127 128static void SC_BindTexture(ProgramFragment *pf, uint32_t slot, Allocation *a) { 129 GET_TLS(); 130 rsrBindTexture(rsc, sc, pf, slot, a); 131} 132 133static void SC_BindSampler(ProgramFragment *pf, uint32_t slot, Sampler *s) { 134 GET_TLS(); 135 rsrBindSampler(rsc, sc, pf, slot, s); 136} 137 138static void SC_BindProgramStore(ProgramStore *ps) { 139 GET_TLS(); 140 rsrBindProgramStore(rsc, sc, ps); 141} 142 143static void SC_BindProgramFragment(ProgramFragment *pf) { 144 GET_TLS(); 145 rsrBindProgramFragment(rsc, sc, pf); 146} 147 148static void SC_BindProgramVertex(ProgramVertex *pv) { 149 GET_TLS(); 150 rsrBindProgramVertex(rsc, sc, pv); 151} 152 153static void SC_BindProgramRaster(ProgramRaster *pr) { 154 GET_TLS(); 155 rsrBindProgramRaster(rsc, sc, pr); 156} 157 158static void SC_BindFrameBufferObjectColorTarget(Allocation *a, uint32_t slot) { 159 GET_TLS(); 160 rsrBindFrameBufferObjectColorTarget(rsc, sc, a, slot); 161} 162 163static void SC_BindFrameBufferObjectDepthTarget(Allocation *a) { 164 GET_TLS(); 165 rsrBindFrameBufferObjectDepthTarget(rsc, sc, a); 166} 167 168static void SC_ClearFrameBufferObjectColorTarget(uint32_t slot) { 169 GET_TLS(); 170 rsrClearFrameBufferObjectColorTarget(rsc, sc, slot); 171} 172 173static void SC_ClearFrameBufferObjectDepthTarget(Context *, Script *) { 174 GET_TLS(); 175 rsrClearFrameBufferObjectDepthTarget(rsc, sc); 176} 177 178static void SC_ClearFrameBufferObjectTargets(Context *, Script *) { 179 GET_TLS(); 180 rsrClearFrameBufferObjectTargets(rsc, sc); 181} 182 183 184////////////////////////////////////////////////////////////////////////////// 185// VP 186////////////////////////////////////////////////////////////////////////////// 187 188static void SC_VpLoadProjectionMatrix(const rsc_Matrix *m) { 189 GET_TLS(); 190 rsrVpLoadProjectionMatrix(rsc, sc, m); 191} 192 193static void SC_VpLoadModelMatrix(const rsc_Matrix *m) { 194 GET_TLS(); 195 rsrVpLoadModelMatrix(rsc, sc, m); 196} 197 198static void SC_VpLoadTextureMatrix(const rsc_Matrix *m) { 199 GET_TLS(); 200 rsrVpLoadTextureMatrix(rsc, sc, m); 201} 202 203static void SC_PfConstantColor(ProgramFragment *pf, float r, float g, float b, float a) { 204 GET_TLS(); 205 rsrPfConstantColor(rsc, sc, pf, r, g, b, a); 206} 207 208static void SC_VpGetProjectionMatrix(rsc_Matrix *m) { 209 GET_TLS(); 210 rsrVpGetProjectionMatrix(rsc, sc, m); 211} 212 213 214////////////////////////////////////////////////////////////////////////////// 215// Drawing 216////////////////////////////////////////////////////////////////////////////// 217 218static void SC_DrawQuadTexCoords(float x1, float y1, float z1, float u1, float v1, 219 float x2, float y2, float z2, float u2, float v2, 220 float x3, float y3, float z3, float u3, float v3, 221 float x4, float y4, float z4, float u4, float v4) { 222 GET_TLS(); 223 rsrDrawQuadTexCoords(rsc, sc, 224 x1, y1, z1, u1, v1, 225 x2, y2, z2, u2, v2, 226 x3, y3, z3, u3, v3, 227 x4, y4, z4, u4, v4); 228} 229 230static void SC_DrawQuad(float x1, float y1, float z1, 231 float x2, float y2, float z2, 232 float x3, float y3, float z3, 233 float x4, float y4, float z4) { 234 GET_TLS(); 235 rsrDrawQuad(rsc, sc, x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4); 236} 237 238static void SC_DrawSpriteScreenspace(float x, float y, float z, float w, float h) { 239 GET_TLS(); 240 rsrDrawSpriteScreenspace(rsc, sc, x, y, z, w, h); 241} 242 243static void SC_DrawRect(float x1, float y1, float x2, float y2, float z) { 244 GET_TLS(); 245 rsrDrawRect(rsc, sc, x1, y1, x2, y2, z); 246} 247 248static void SC_DrawMesh(Mesh *m) { 249 GET_TLS(); 250 rsrDrawMesh(rsc, sc, m); 251} 252 253static void SC_DrawMeshPrimitive(Mesh *m, uint32_t primIndex) { 254 GET_TLS(); 255 rsrDrawMeshPrimitive(rsc, sc, m, primIndex); 256} 257 258static void SC_DrawMeshPrimitiveRange(Mesh *m, uint32_t primIndex, uint32_t start, uint32_t len) { 259 GET_TLS(); 260 rsrDrawMeshPrimitiveRange(rsc, sc, m, primIndex, start, len); 261} 262 263static void SC_MeshComputeBoundingBox(Mesh *m, 264 float *minX, float *minY, float *minZ, 265 float *maxX, float *maxY, float *maxZ) { 266 GET_TLS(); 267 rsrMeshComputeBoundingBox(rsc, sc, m, minX, minY, minZ, maxX, maxY, maxZ); 268} 269 270 271 272////////////////////////////////////////////////////////////////////////////// 273// 274////////////////////////////////////////////////////////////////////////////// 275 276 277static void SC_Color(float r, float g, float b, float a) { 278 GET_TLS(); 279 rsrColor(rsc, sc, r, g, b, a); 280} 281 282static void SC_Finish() { 283 GET_TLS(); 284 rsrFinish(rsc, sc); 285} 286 287static void SC_ClearColor(float r, float g, float b, float a) { 288 GET_TLS(); 289 rsrClearColor(rsc, sc, r, g, b, a); 290} 291 292static void SC_ClearDepth(float v) { 293 GET_TLS(); 294 rsrClearDepth(rsc, sc, v); 295} 296 297static uint32_t SC_GetWidth() { 298 GET_TLS(); 299 return rsrGetWidth(rsc, sc); 300} 301 302static uint32_t SC_GetHeight() { 303 GET_TLS(); 304 return rsrGetHeight(rsc, sc); 305} 306 307static void SC_DrawTextAlloc(Allocation *a, int x, int y) { 308 GET_TLS(); 309 rsrDrawTextAlloc(rsc, sc, a, x, y); 310} 311 312static void SC_DrawText(const char *text, int x, int y) { 313 GET_TLS(); 314 rsrDrawText(rsc, sc, text, x, y); 315} 316 317static void SC_MeasureTextAlloc(Allocation *a, 318 int32_t *left, int32_t *right, int32_t *top, int32_t *bottom) { 319 GET_TLS(); 320 rsrMeasureTextAlloc(rsc, sc, a, left, right, top, bottom); 321} 322 323static void SC_MeasureText(const char *text, 324 int32_t *left, int32_t *right, int32_t *top, int32_t *bottom) { 325 GET_TLS(); 326 rsrMeasureText(rsc, sc, text, left, right, top, bottom); 327} 328 329static void SC_BindFont(Font *f) { 330 GET_TLS(); 331 rsrBindFont(rsc, sc, f); 332} 333 334static void SC_FontColor(float r, float g, float b, float a) { 335 GET_TLS(); 336 rsrFontColor(rsc, sc, r, g, b, a); 337} 338 339 340 341////////////////////////////////////////////////////////////////////////////// 342// 343////////////////////////////////////////////////////////////////////////////// 344 345static void SC_SetObject(ObjectBase **dst, ObjectBase * src) { 346 GET_TLS(); 347 rsrSetObject(rsc, sc, dst, src); 348} 349 350static void SC_ClearObject(ObjectBase **dst) { 351 GET_TLS(); 352 rsrClearObject(rsc, sc, dst); 353} 354 355static bool SC_IsObject(const ObjectBase *src) { 356 GET_TLS(); 357 return rsrIsObject(rsc, sc, src); 358} 359 360 361 362 363static const Allocation * SC_GetAllocation(const void *ptr) { 364 GET_TLS(); 365 return rsrGetAllocation(rsc, sc, ptr); 366} 367 368static void SC_ForEach_SAA(Script *target, 369 Allocation *in, 370 Allocation *out) { 371 GET_TLS(); 372 rsrForEach(rsc, sc, target, in, out, NULL, 0, NULL); 373} 374 375static void SC_ForEach_SAAU(Script *target, 376 Allocation *in, 377 Allocation *out, 378 const void *usr) { 379 GET_TLS(); 380 rsrForEach(rsc, sc, target, in, out, usr, 0, NULL); 381} 382 383static void SC_ForEach_SAAUS(Script *target, 384 Allocation *in, 385 Allocation *out, 386 const void *usr, 387 const RsScriptCall *call) { 388 GET_TLS(); 389 rsrForEach(rsc, sc, target, in, out, usr, 0, call); 390} 391 392static void SC_ForEach_SAAUL(Script *target, 393 Allocation *in, 394 Allocation *out, 395 const void *usr, 396 uint32_t usrLen) { 397 GET_TLS(); 398 rsrForEach(rsc, sc, target, in, out, usr, usrLen, NULL); 399} 400 401static void SC_ForEach_SAAULS(Script *target, 402 Allocation *in, 403 Allocation *out, 404 const void *usr, 405 uint32_t usrLen, 406 const RsScriptCall *call) { 407 GET_TLS(); 408 rsrForEach(rsc, sc, target, in, out, usr, usrLen, call); 409} 410 411 412 413////////////////////////////////////////////////////////////////////////////// 414// Time routines 415////////////////////////////////////////////////////////////////////////////// 416 417static float SC_GetDt() { 418 GET_TLS(); 419 return rsrGetDt(rsc, sc); 420} 421 422time_t SC_Time(time_t *timer) { 423 GET_TLS(); 424 return rsrTime(rsc, sc, timer); 425} 426 427tm* SC_LocalTime(tm *local, time_t *timer) { 428 GET_TLS(); 429 return rsrLocalTime(rsc, sc, local, timer); 430} 431 432int64_t SC_UptimeMillis() { 433 GET_TLS(); 434 return rsrUptimeMillis(rsc, sc); 435} 436 437int64_t SC_UptimeNanos() { 438 GET_TLS(); 439 return rsrUptimeNanos(rsc, sc); 440} 441 442////////////////////////////////////////////////////////////////////////////// 443// Message routines 444////////////////////////////////////////////////////////////////////////////// 445 446static uint32_t SC_ToClient2(int cmdID, void *data, int len) { 447 GET_TLS(); 448 return rsrToClient(rsc, sc, cmdID, data, len); 449} 450 451static uint32_t SC_ToClient(int cmdID) { 452 GET_TLS(); 453 return rsrToClient(rsc, sc, cmdID, NULL, 0); 454} 455 456static uint32_t SC_ToClientBlocking2(int cmdID, void *data, int len) { 457 GET_TLS(); 458 return rsrToClientBlocking(rsc, sc, cmdID, data, len); 459} 460 461static uint32_t SC_ToClientBlocking(int cmdID) { 462 GET_TLS(); 463 return rsrToClientBlocking(rsc, sc, cmdID, NULL, 0); 464} 465 466int SC_divsi3(int a, int b) { 467 return a / b; 468} 469 470int SC_modsi3(int a, int b) { 471 return a % b; 472} 473 474unsigned int SC_udivsi3(unsigned int a, unsigned int b) { 475 return a / b; 476} 477 478unsigned int SC_umodsi3(unsigned int a, unsigned int b) { 479 return a % b; 480} 481 482static void SC_debugF(const char *s, float f) { 483 LOGD("%s %f, 0x%08x", s, f, *((int *) (&f))); 484} 485static void SC_debugFv2(const char *s, float f1, float f2) { 486 LOGD("%s {%f, %f}", s, f1, f2); 487} 488static void SC_debugFv3(const char *s, float f1, float f2, float f3) { 489 LOGD("%s {%f, %f, %f}", s, f1, f2, f3); 490} 491static void SC_debugFv4(const char *s, float f1, float f2, float f3, float f4) { 492 LOGD("%s {%f, %f, %f, %f}", s, f1, f2, f3, f4); 493} 494static void SC_debugD(const char *s, double d) { 495 LOGD("%s %f, 0x%08llx", s, d, *((long long *) (&d))); 496} 497static void SC_debugFM4v4(const char *s, const float *f) { 498 LOGD("%s {%f, %f, %f, %f", s, f[0], f[4], f[8], f[12]); 499 LOGD("%s %f, %f, %f, %f", s, f[1], f[5], f[9], f[13]); 500 LOGD("%s %f, %f, %f, %f", s, f[2], f[6], f[10], f[14]); 501 LOGD("%s %f, %f, %f, %f}", s, f[3], f[7], f[11], f[15]); 502} 503static void SC_debugFM3v3(const char *s, const float *f) { 504 LOGD("%s {%f, %f, %f", s, f[0], f[3], f[6]); 505 LOGD("%s %f, %f, %f", s, f[1], f[4], f[7]); 506 LOGD("%s %f, %f, %f}",s, f[2], f[5], f[8]); 507} 508static void SC_debugFM2v2(const char *s, const float *f) { 509 LOGD("%s {%f, %f", s, f[0], f[2]); 510 LOGD("%s %f, %f}",s, f[1], f[3]); 511} 512 513static void SC_debugI32(const char *s, int32_t i) { 514 LOGD("%s %i 0x%x", s, i, i); 515} 516static void SC_debugU32(const char *s, uint32_t i) { 517 LOGD("%s %u 0x%x", s, i, i); 518} 519static void SC_debugLL64(const char *s, long long ll) { 520 LOGD("%s %lld 0x%llx", s, ll, ll); 521} 522static void SC_debugULL64(const char *s, unsigned long long ll) { 523 LOGD("%s %llu 0x%llx", s, ll, ll); 524} 525 526static void SC_debugP(const char *s, const void *p) { 527 LOGD("%s %p", s, p); 528} 529 530 531////////////////////////////////////////////////////////////////////////////// 532// Stub implementation 533////////////////////////////////////////////////////////////////////////////// 534 535// llvm name mangling ref 536// <builtin-type> ::= v # void 537// ::= b # bool 538// ::= c # char 539// ::= a # signed char 540// ::= h # unsigned char 541// ::= s # short 542// ::= t # unsigned short 543// ::= i # int 544// ::= j # unsigned int 545// ::= l # long 546// ::= m # unsigned long 547// ::= x # long long, __int64 548// ::= y # unsigned long long, __int64 549// ::= f # float 550// ::= d # double 551 552static RsdSymbolTable gSyms[] = { 553 { "memset", (void *)&memset, true }, 554 { "memcpy", (void *)&memcpy, true }, 555 556 // Refcounting 557 { "_Z11rsSetObjectP10rs_elementS_", (void *)&SC_SetObject, true }, 558 { "_Z13rsClearObjectP10rs_element", (void *)&SC_ClearObject, true }, 559 { "_Z10rsIsObject10rs_element", (void *)&SC_IsObject, true }, 560 561 { "_Z11rsSetObjectP7rs_typeS_", (void *)&SC_SetObject, true }, 562 { "_Z13rsClearObjectP7rs_type", (void *)&SC_ClearObject, true }, 563 { "_Z10rsIsObject7rs_type", (void *)&SC_IsObject, true }, 564 565 { "_Z11rsSetObjectP13rs_allocationS_", (void *)&SC_SetObject, true }, 566 { "_Z13rsClearObjectP13rs_allocation", (void *)&SC_ClearObject, true }, 567 { "_Z10rsIsObject13rs_allocation", (void *)&SC_IsObject, true }, 568 569 { "_Z11rsSetObjectP10rs_samplerS_", (void *)&SC_SetObject, true }, 570 { "_Z13rsClearObjectP10rs_sampler", (void *)&SC_ClearObject, true }, 571 { "_Z10rsIsObject10rs_sampler", (void *)&SC_IsObject, true }, 572 573 { "_Z11rsSetObjectP9rs_scriptS_", (void *)&SC_SetObject, true }, 574 { "_Z13rsClearObjectP9rs_script", (void *)&SC_ClearObject, true }, 575 { "_Z10rsIsObject9rs_script", (void *)&SC_IsObject, true }, 576 577 { "_Z11rsSetObjectP7rs_meshS_", (void *)&SC_SetObject, true }, 578 { "_Z13rsClearObjectP7rs_mesh", (void *)&SC_ClearObject, true }, 579 { "_Z10rsIsObject7rs_mesh", (void *)&SC_IsObject, true }, 580 581 { "_Z11rsSetObjectP19rs_program_fragmentS_", (void *)&SC_SetObject, true }, 582 { "_Z13rsClearObjectP19rs_program_fragment", (void *)&SC_ClearObject, true }, 583 { "_Z10rsIsObject19rs_program_fragment", (void *)&SC_IsObject, true }, 584 585 { "_Z11rsSetObjectP17rs_program_vertexS_", (void *)&SC_SetObject, true }, 586 { "_Z13rsClearObjectP17rs_program_vertex", (void *)&SC_ClearObject, true }, 587 { "_Z10rsIsObject17rs_program_vertex", (void *)&SC_IsObject, true }, 588 589 { "_Z11rsSetObjectP17rs_program_rasterS_", (void *)&SC_SetObject, true }, 590 { "_Z13rsClearObjectP17rs_program_raster", (void *)&SC_ClearObject, true }, 591 { "_Z10rsIsObject17rs_program_raster", (void *)&SC_IsObject, true }, 592 593 { "_Z11rsSetObjectP16rs_program_storeS_", (void *)&SC_SetObject, true }, 594 { "_Z13rsClearObjectP16rs_program_store", (void *)&SC_ClearObject, true }, 595 { "_Z10rsIsObject16rs_program_store", (void *)&SC_IsObject, true }, 596 597 { "_Z11rsSetObjectP7rs_fontS_", (void *)&SC_SetObject, true }, 598 { "_Z13rsClearObjectP7rs_font", (void *)&SC_ClearObject, true }, 599 { "_Z10rsIsObject7rs_font", (void *)&SC_IsObject, true }, 600 601 // Allocation ops 602 { "_Z19rsAllocationGetDimX13rs_allocation", (void *)&SC_allocGetDimX, true }, 603 { "_Z19rsAllocationGetDimY13rs_allocation", (void *)&SC_allocGetDimY, true }, 604 { "_Z19rsAllocationGetDimZ13rs_allocation", (void *)&SC_allocGetDimZ, true }, 605 { "_Z21rsAllocationGetDimLOD13rs_allocation", (void *)&SC_allocGetDimLOD, true }, 606 { "_Z23rsAllocationGetDimFaces13rs_allocation", (void *)&SC_allocGetDimFaces, true }, 607 608 { "_Z14rsGetElementAt13rs_allocationj", (void *)&SC_getElementAtX, true }, 609 { "_Z14rsGetElementAt13rs_allocationjj", (void *)&SC_getElementAtXY, true }, 610 { "_Z14rsGetElementAt13rs_allocationjjj", (void *)&SC_getElementAtXYZ, true }, 611 612 { "_Z15rsGetAllocationPKv", (void *)&SC_getAllocation, true }, 613 614 { "_Z21rsAllocationMarkDirty13rs_allocation", (void *)&SC_AllocationSyncAll, true }, 615 { "_Z20rsgAllocationSyncAll13rs_allocation", (void *)&SC_AllocationSyncAll, false }, 616 { "_Z20rsgAllocationSyncAll13rs_allocationj", (void *)&SC_AllocationSyncAll2, false }, 617 { "_Z20rsgAllocationSyncAll13rs_allocation24rs_allocation_usage_type", (void *)&SC_AllocationSyncAll2, false }, 618 { "_Z15rsGetAllocationPKv", (void *)&SC_GetAllocation, true }, 619 620 { "_Z23rsAllocationCopy1DRange13rs_allocationjjjS_jj", (void *)&SC_AllocationCopy1DRange, false }, 621 { "_Z23rsAllocationCopy2DRange13rs_allocationjjj26rs_allocation_cubemap_facejjS_jjjS0_", (void *)&SC_AllocationCopy2DRange, false }, 622 623 // Messaging 624 625 { "_Z14rsSendToClienti", (void *)&SC_ToClient, false }, 626 { "_Z14rsSendToClientiPKvj", (void *)&SC_ToClient2, false }, 627 { "_Z22rsSendToClientBlockingi", (void *)&SC_ToClientBlocking, false }, 628 { "_Z22rsSendToClientBlockingiPKvj", (void *)&SC_ToClientBlocking2, false }, 629 630 { "_Z22rsgBindProgramFragment19rs_program_fragment", (void *)&SC_BindProgramFragment, false }, 631 { "_Z19rsgBindProgramStore16rs_program_store", (void *)&SC_BindProgramStore, false }, 632 { "_Z20rsgBindProgramVertex17rs_program_vertex", (void *)&SC_BindProgramVertex, false }, 633 { "_Z20rsgBindProgramRaster17rs_program_raster", (void *)&SC_BindProgramRaster, false }, 634 { "_Z14rsgBindSampler19rs_program_fragmentj10rs_sampler", (void *)&SC_BindSampler, false }, 635 { "_Z14rsgBindTexture19rs_program_fragmentj13rs_allocation", (void *)&SC_BindTexture, false }, 636 637 { "_Z36rsgProgramVertexLoadProjectionMatrixPK12rs_matrix4x4", (void *)&SC_VpLoadProjectionMatrix, false }, 638 { "_Z31rsgProgramVertexLoadModelMatrixPK12rs_matrix4x4", (void *)&SC_VpLoadModelMatrix, false }, 639 { "_Z33rsgProgramVertexLoadTextureMatrixPK12rs_matrix4x4", (void *)&SC_VpLoadTextureMatrix, false }, 640 641 { "_Z35rsgProgramVertexGetProjectionMatrixP12rs_matrix4x4", (void *)&SC_VpGetProjectionMatrix, false }, 642 643 { "_Z31rsgProgramFragmentConstantColor19rs_program_fragmentffff", (void *)&SC_PfConstantColor, false }, 644 645 { "_Z11rsgGetWidthv", (void *)&SC_GetWidth, false }, 646 { "_Z12rsgGetHeightv", (void *)&SC_GetHeight, false }, 647 648 649 { "_Z11rsgDrawRectfffff", (void *)&SC_DrawRect, false }, 650 { "_Z11rsgDrawQuadffffffffffff", (void *)&SC_DrawQuad, false }, 651 { "_Z20rsgDrawQuadTexCoordsffffffffffffffffffff", (void *)&SC_DrawQuadTexCoords, false }, 652 { "_Z24rsgDrawSpriteScreenspacefffff", (void *)&SC_DrawSpriteScreenspace, false }, 653 654 { "_Z11rsgDrawMesh7rs_mesh", (void *)&SC_DrawMesh, false }, 655 { "_Z11rsgDrawMesh7rs_meshj", (void *)&SC_DrawMeshPrimitive, false }, 656 { "_Z11rsgDrawMesh7rs_meshjjj", (void *)&SC_DrawMeshPrimitiveRange, false }, 657 { "_Z25rsgMeshComputeBoundingBox7rs_meshPfS0_S0_S0_S0_S0_", (void *)&SC_MeshComputeBoundingBox, false }, 658 659 { "_Z13rsgClearColorffff", (void *)&SC_ClearColor, false }, 660 { "_Z13rsgClearDepthf", (void *)&SC_ClearDepth, false }, 661 662 { "_Z11rsgDrawTextPKcii", (void *)&SC_DrawText, false }, 663 { "_Z11rsgDrawText13rs_allocationii", (void *)&SC_DrawTextAlloc, false }, 664 { "_Z14rsgMeasureTextPKcPiS1_S1_S1_", (void *)&SC_MeasureText, false }, 665 { "_Z14rsgMeasureText13rs_allocationPiS0_S0_S0_", (void *)&SC_MeasureTextAlloc, false }, 666 667 { "_Z11rsgBindFont7rs_font", (void *)&SC_BindFont, false }, 668 { "_Z12rsgFontColorffff", (void *)&SC_FontColor, false }, 669 670 { "_Z18rsgBindColorTarget13rs_allocationj", (void *)&SC_BindFrameBufferObjectColorTarget, false }, 671 { "_Z18rsgBindDepthTarget13rs_allocation", (void *)&SC_BindFrameBufferObjectDepthTarget, false }, 672 { "_Z19rsgClearColorTargetj", (void *)&SC_ClearFrameBufferObjectColorTarget, false }, 673 { "_Z19rsgClearDepthTargetv", (void *)&SC_ClearFrameBufferObjectDepthTarget, false }, 674 { "_Z24rsgClearAllRenderTargetsv", (void *)&SC_ClearFrameBufferObjectTargets, false }, 675 676 { "_Z9rsForEach9rs_script13rs_allocationS0_", (void *)&SC_ForEach_SAA, false }, 677 { "_Z9rsForEach9rs_script13rs_allocationS0_PKv", (void *)&SC_ForEach_SAAU, false }, 678 { "_Z9rsForEach9rs_script13rs_allocationS0_PKvPK16rs_script_call_t", (void *)&SC_ForEach_SAAUS, false }, 679 { "_Z9rsForEach9rs_script13rs_allocationS0_PKvj", (void *)&SC_ForEach_SAAUL, false }, 680 { "_Z9rsForEach9rs_script13rs_allocationS0_PKvjPK16rs_script_call_t", (void *)&SC_ForEach_SAAULS, false }, 681 682 // time 683 { "_Z6rsTimePi", (void *)&SC_Time, true }, 684 { "_Z11rsLocaltimeP5rs_tmPKi", (void *)&SC_LocalTime, true }, 685 { "_Z14rsUptimeMillisv", (void*)&SC_UptimeMillis, true }, 686 { "_Z13rsUptimeNanosv", (void*)&SC_UptimeNanos, true }, 687 { "_Z7rsGetDtv", (void*)&SC_GetDt, false }, 688 689 // misc 690 { "_Z5colorffff", (void *)&SC_Color, false }, 691 { "_Z9rsgFinishv", (void *)&SC_Finish, false }, 692 693 // Debug 694 { "_Z7rsDebugPKcf", (void *)&SC_debugF, true }, 695 { "_Z7rsDebugPKcff", (void *)&SC_debugFv2, true }, 696 { "_Z7rsDebugPKcfff", (void *)&SC_debugFv3, true }, 697 { "_Z7rsDebugPKcffff", (void *)&SC_debugFv4, true }, 698 { "_Z7rsDebugPKcd", (void *)&SC_debugD, true }, 699 { "_Z7rsDebugPKcPK12rs_matrix4x4", (void *)&SC_debugFM4v4, true }, 700 { "_Z7rsDebugPKcPK12rs_matrix3x3", (void *)&SC_debugFM3v3, true }, 701 { "_Z7rsDebugPKcPK12rs_matrix2x2", (void *)&SC_debugFM2v2, true }, 702 { "_Z7rsDebugPKci", (void *)&SC_debugI32, true }, 703 { "_Z7rsDebugPKcj", (void *)&SC_debugU32, true }, 704 // Both "long" and "unsigned long" need to be redirected to their 705 // 64-bit counterparts, since we have hacked Slang to use 64-bit 706 // for "long" on Arm (to be similar to Java). 707 { "_Z7rsDebugPKcl", (void *)&SC_debugLL64, true }, 708 { "_Z7rsDebugPKcm", (void *)&SC_debugULL64, true }, 709 { "_Z7rsDebugPKcx", (void *)&SC_debugLL64, true }, 710 { "_Z7rsDebugPKcy", (void *)&SC_debugULL64, true }, 711 { "_Z7rsDebugPKcPKv", (void *)&SC_debugP, true }, 712 713 { NULL, NULL, false } 714}; 715 716 717void* rsdLookupRuntimeStub(void* pContext, char const* name) { 718 ScriptC *s = (ScriptC *)pContext; 719 if (!strcmp(name, "__isThreadable")) { 720 return (void*) s->mHal.info.isThreadable; 721 } else if (!strcmp(name, "__clearThreadable")) { 722 s->mHal.info.isThreadable = false; 723 return NULL; 724 } 725 726 RsdSymbolTable *syms = gSyms; 727 const RsdSymbolTable *sym = rsdLookupSymbolMath(name); 728 729 if (!sym) { 730 while (syms->mPtr) { 731 if (!strcmp(syms->mName, name)) { 732 sym = syms; 733 } 734 syms++; 735 } 736 } 737 738 if (sym) { 739 s->mHal.info.isThreadable &= sym->threadable; 740 return sym->mPtr; 741 } 742 LOGE("ScriptC sym lookup failed for %s", name); 743 return NULL; 744} 745 746 747