rsdRuntimeStubs.cpp revision 2f6dc8469a45fa2dafcb772c76009565d0c3885f
1/* 2 * Copyright (C) 2011-2012 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 "rsdCore.h" 25#include "rsdBcc.h" 26 27#include "rsdPath.h" 28#include "rsdAllocation.h" 29#include "rsdShaderCache.h" 30#include "rsdVertexArray.h" 31 32#include <time.h> 33 34using namespace android; 35using namespace android::renderscript; 36 37typedef float float2 __attribute__((ext_vector_type(2))); 38typedef float float3 __attribute__((ext_vector_type(3))); 39typedef float float4 __attribute__((ext_vector_type(4))); 40typedef double double2 __attribute__((ext_vector_type(2))); 41typedef double double3 __attribute__((ext_vector_type(3))); 42typedef double double4 __attribute__((ext_vector_type(4))); 43typedef char char2 __attribute__((ext_vector_type(2))); 44typedef char char3 __attribute__((ext_vector_type(3))); 45typedef char char4 __attribute__((ext_vector_type(4))); 46typedef unsigned char uchar2 __attribute__((ext_vector_type(2))); 47typedef unsigned char uchar3 __attribute__((ext_vector_type(3))); 48typedef unsigned char uchar4 __attribute__((ext_vector_type(4))); 49typedef int16_t short2 __attribute__((ext_vector_type(2))); 50typedef int16_t short3 __attribute__((ext_vector_type(3))); 51typedef int16_t short4 __attribute__((ext_vector_type(4))); 52typedef uint16_t ushort2 __attribute__((ext_vector_type(2))); 53typedef uint16_t ushort3 __attribute__((ext_vector_type(3))); 54typedef uint16_t ushort4 __attribute__((ext_vector_type(4))); 55typedef int32_t int2 __attribute__((ext_vector_type(2))); 56typedef int32_t int3 __attribute__((ext_vector_type(3))); 57typedef int32_t int4 __attribute__((ext_vector_type(4))); 58typedef uint32_t uint2 __attribute__((ext_vector_type(2))); 59typedef uint32_t uint3 __attribute__((ext_vector_type(3))); 60typedef uint32_t uint4 __attribute__((ext_vector_type(4))); 61typedef int64_t long2 __attribute__((ext_vector_type(2))); 62typedef int64_t long3 __attribute__((ext_vector_type(3))); 63typedef int64_t long4 __attribute__((ext_vector_type(4))); 64typedef uint64_t ulong2 __attribute__((ext_vector_type(2))); 65typedef uint64_t ulong3 __attribute__((ext_vector_type(3))); 66typedef uint64_t ulong4 __attribute__((ext_vector_type(4))); 67 68typedef uint8_t uchar; 69typedef uint16_t ushort; 70typedef uint32_t uint; 71#ifndef RS_SERVER 72typedef uint64_t ulong; 73#endif 74 75#ifdef RS_COMPATIBILITY_LIB 76#define OPAQUETYPE(t) \ 77 typedef struct { const int* const p; } __attribute__((packed, aligned(4))) t; 78 79OPAQUETYPE(rs_element) 80OPAQUETYPE(rs_type) 81OPAQUETYPE(rs_allocation) 82OPAQUETYPE(rs_sampler) 83OPAQUETYPE(rs_script) 84OPAQUETYPE(rs_script_call) 85#undef OPAQUETYPE 86 87typedef enum { 88 // Empty to avoid conflicting definitions with RsAllocationCubemapFace 89} rs_allocation_cubemap_face; 90 91typedef struct { 92 int tm_sec; ///< seconds 93 int tm_min; ///< minutes 94 int tm_hour; ///< hours 95 int tm_mday; ///< day of the month 96 int tm_mon; ///< month 97 int tm_year; ///< year 98 int tm_wday; ///< day of the week 99 int tm_yday; ///< day of the year 100 int tm_isdst; ///< daylight savings time 101} rs_tm; 102#endif 103 104////////////////////////////////////////////////////////////////////////////// 105// Allocation 106////////////////////////////////////////////////////////////////////////////// 107 108 109static void SC_AllocationSyncAll2(android::renderscript::rs_allocation a, RsAllocationUsageType source) { 110 Context *rsc = RsdCpuReference::getTlsContext(); 111 rsrAllocationSyncAll(rsc, (Allocation*)a.p, source); 112} 113 114static void SC_AllocationSyncAll(android::renderscript::rs_allocation a) { 115 Context *rsc = RsdCpuReference::getTlsContext(); 116 rsrAllocationSyncAll(rsc, (Allocation*)a.p, RS_ALLOCATION_USAGE_SCRIPT); 117} 118 119#ifndef RS_COMPATIBILITY_LIB 120 121static void SC_AllocationCopy1DRange(android::renderscript::rs_allocation dstAlloc, 122 uint32_t dstOff, 123 uint32_t dstMip, 124 uint32_t count, 125 android::renderscript::rs_allocation srcAlloc, 126 uint32_t srcOff, uint32_t srcMip) { 127 Context *rsc = RsdCpuReference::getTlsContext(); 128 rsrAllocationCopy1DRange(rsc, (Allocation*)dstAlloc.p, dstOff, dstMip, count, 129 (Allocation*)srcAlloc.p, srcOff, srcMip); 130} 131 132static void SC_AllocationCopy2DRange(android::renderscript::rs_allocation dstAlloc, 133 uint32_t dstXoff, uint32_t dstYoff, 134 uint32_t dstMip, uint32_t dstFace, 135 uint32_t width, uint32_t height, 136 android::renderscript::rs_allocation srcAlloc, 137 uint32_t srcXoff, uint32_t srcYoff, 138 uint32_t srcMip, uint32_t srcFace) { 139 Context *rsc = RsdCpuReference::getTlsContext(); 140 rsrAllocationCopy2DRange(rsc, (Allocation*)dstAlloc.p, 141 dstXoff, dstYoff, dstMip, dstFace, 142 width, height, 143 (Allocation*)srcAlloc.p, 144 srcXoff, srcYoff, srcMip, srcFace); 145} 146 147static void SC_AllocationIoSend(android::renderscript::rs_allocation alloc) { 148 Context *rsc = RsdCpuReference::getTlsContext(); 149 rsrAllocationIoSend(rsc, (Allocation*)alloc.p); 150} 151 152 153static void SC_AllocationIoReceive(android::renderscript::rs_allocation alloc) { 154 Context *rsc = RsdCpuReference::getTlsContext(); 155 rsrAllocationIoReceive(rsc, (Allocation*)alloc.p); 156} 157 158#else 159 160static void SC_AllocationCopy1DRange(::rs_allocation dstAlloc, 161 uint32_t dstOff, 162 uint32_t dstMip, 163 uint32_t count, 164 ::rs_allocation srcAlloc, 165 uint32_t srcOff, uint32_t srcMip) { 166 Context *rsc = RsdCpuReference::getTlsContext(); 167 rsrAllocationCopy1DRange(rsc, (Allocation*)dstAlloc.p, dstOff, dstMip, count, 168 (Allocation*)srcAlloc.p, srcOff, srcMip); 169} 170 171static void SC_AllocationCopy2DRange(::rs_allocation dstAlloc, 172 uint32_t dstXoff, uint32_t dstYoff, 173 uint32_t dstMip, uint32_t dstFace, 174 uint32_t width, uint32_t height, 175 ::rs_allocation srcAlloc, 176 uint32_t srcXoff, uint32_t srcYoff, 177 uint32_t srcMip, uint32_t srcFace) { 178 Context *rsc = RsdCpuReference::getTlsContext(); 179 rsrAllocationCopy2DRange(rsc, (Allocation*)dstAlloc.p, 180 dstXoff, dstYoff, dstMip, dstFace, 181 width, height, 182 (Allocation*)srcAlloc.p, 183 srcXoff, srcYoff, srcMip, srcFace); 184} 185 186static void SC_AllocationIoSend(Allocation* alloc) { 187 Context *rsc = RsdCpuReference::getTlsContext(); 188 rsrAllocationIoSend(rsc, alloc); 189} 190 191 192static void SC_AllocationIoReceive(Allocation* alloc) { 193 Context *rsc = RsdCpuReference::getTlsContext(); 194 rsrAllocationIoReceive(rsc, alloc); 195} 196 197#endif 198 199#ifndef RS_COMPATIBILITY_LIB 200 201////////////////////////////////////////////////////////////////////////////// 202// Context 203////////////////////////////////////////////////////////////////////////////// 204 205static void SC_BindTexture(ProgramFragment *pf, uint32_t slot, Allocation *a) { 206 Context *rsc = RsdCpuReference::getTlsContext(); 207 rsrBindTexture(rsc, pf, slot, a); 208} 209 210static void SC_BindVertexConstant(ProgramVertex *pv, uint32_t slot, Allocation *a) { 211 Context *rsc = RsdCpuReference::getTlsContext(); 212 rsrBindConstant(rsc, pv, slot, a); 213} 214 215static void SC_BindFragmentConstant(ProgramFragment *pf, uint32_t slot, Allocation *a) { 216 Context *rsc = RsdCpuReference::getTlsContext(); 217 rsrBindConstant(rsc, pf, slot, a); 218} 219 220static void SC_BindSampler(ProgramFragment *pf, uint32_t slot, Sampler *s) { 221 Context *rsc = RsdCpuReference::getTlsContext(); 222 rsrBindSampler(rsc, pf, slot, s); 223} 224 225static void SC_BindProgramStore(ProgramStore *ps) { 226 Context *rsc = RsdCpuReference::getTlsContext(); 227 rsrBindProgramStore(rsc, ps); 228} 229 230static void SC_BindProgramFragment(ProgramFragment *pf) { 231 Context *rsc = RsdCpuReference::getTlsContext(); 232 rsrBindProgramFragment(rsc, pf); 233} 234 235static void SC_BindProgramVertex(ProgramVertex *pv) { 236 Context *rsc = RsdCpuReference::getTlsContext(); 237 rsrBindProgramVertex(rsc, pv); 238} 239 240static void SC_BindProgramRaster(ProgramRaster *pr) { 241 Context *rsc = RsdCpuReference::getTlsContext(); 242 rsrBindProgramRaster(rsc, pr); 243} 244 245static void SC_BindFrameBufferObjectColorTarget(Allocation *a, uint32_t slot) { 246 Context *rsc = RsdCpuReference::getTlsContext(); 247 rsrBindFrameBufferObjectColorTarget(rsc, a, slot); 248} 249 250static void SC_BindFrameBufferObjectDepthTarget(Allocation *a) { 251 Context *rsc = RsdCpuReference::getTlsContext(); 252 rsrBindFrameBufferObjectDepthTarget(rsc, a); 253} 254 255static void SC_ClearFrameBufferObjectColorTarget(uint32_t slot) { 256 Context *rsc = RsdCpuReference::getTlsContext(); 257 rsrClearFrameBufferObjectColorTarget(rsc, slot); 258} 259 260static void SC_ClearFrameBufferObjectDepthTarget(Context *, Script *) { 261 Context *rsc = RsdCpuReference::getTlsContext(); 262 rsrClearFrameBufferObjectDepthTarget(rsc); 263} 264 265static void SC_ClearFrameBufferObjectTargets(Context *, Script *) { 266 Context *rsc = RsdCpuReference::getTlsContext(); 267 rsrClearFrameBufferObjectTargets(rsc); 268} 269 270 271////////////////////////////////////////////////////////////////////////////// 272// VP 273////////////////////////////////////////////////////////////////////////////// 274 275static void SC_VpLoadProjectionMatrix(const rsc_Matrix *m) { 276 Context *rsc = RsdCpuReference::getTlsContext(); 277 rsrVpLoadProjectionMatrix(rsc, m); 278} 279 280static void SC_VpLoadModelMatrix(const rsc_Matrix *m) { 281 Context *rsc = RsdCpuReference::getTlsContext(); 282 rsrVpLoadModelMatrix(rsc, m); 283} 284 285static void SC_VpLoadTextureMatrix(const rsc_Matrix *m) { 286 Context *rsc = RsdCpuReference::getTlsContext(); 287 rsrVpLoadTextureMatrix(rsc, m); 288} 289 290static void SC_PfConstantColor(ProgramFragment *pf, float r, float g, float b, float a) { 291 Context *rsc = RsdCpuReference::getTlsContext(); 292 rsrPfConstantColor(rsc, pf, r, g, b, a); 293} 294 295static void SC_VpGetProjectionMatrix(rsc_Matrix *m) { 296 Context *rsc = RsdCpuReference::getTlsContext(); 297 rsrVpGetProjectionMatrix(rsc, m); 298} 299 300 301////////////////////////////////////////////////////////////////////////////// 302// Drawing 303////////////////////////////////////////////////////////////////////////////// 304 305static void SC_DrawQuadTexCoords(float x1, float y1, float z1, float u1, float v1, 306 float x2, float y2, float z2, float u2, float v2, 307 float x3, float y3, float z3, float u3, float v3, 308 float x4, float y4, float z4, float u4, float v4) { 309 Context *rsc = RsdCpuReference::getTlsContext(); 310 311 if (!rsc->setupCheck()) { 312 return; 313 } 314 315 RsdHal *dc = (RsdHal *)rsc->mHal.drv; 316 if (!dc->gl.shaderCache->setup(rsc)) { 317 return; 318 } 319 320 //ALOGE("Quad"); 321 //ALOGE("%4.2f, %4.2f, %4.2f", x1, y1, z1); 322 //ALOGE("%4.2f, %4.2f, %4.2f", x2, y2, z2); 323 //ALOGE("%4.2f, %4.2f, %4.2f", x3, y3, z3); 324 //ALOGE("%4.2f, %4.2f, %4.2f", x4, y4, z4); 325 326 float vtx[] = {x1,y1,z1, x2,y2,z2, x3,y3,z3, x4,y4,z4}; 327 const float tex[] = {u1,v1, u2,v2, u3,v3, u4,v4}; 328 329 RsdVertexArray::Attrib attribs[2]; 330 attribs[0].set(GL_FLOAT, 3, 12, false, (size_t)vtx, "ATTRIB_position"); 331 attribs[1].set(GL_FLOAT, 2, 8, false, (size_t)tex, "ATTRIB_texture0"); 332 333 RsdVertexArray va(attribs, 2); 334 va.setup(rsc); 335 336 RSD_CALL_GL(glDrawArrays, GL_TRIANGLE_FAN, 0, 4); 337} 338 339static void SC_DrawQuad(float x1, float y1, float z1, 340 float x2, float y2, float z2, 341 float x3, float y3, float z3, 342 float x4, float y4, float z4) { 343 SC_DrawQuadTexCoords(x1, y1, z1, 0, 1, 344 x2, y2, z2, 1, 1, 345 x3, y3, z3, 1, 0, 346 x4, y4, z4, 0, 0); 347} 348 349static void SC_DrawSpriteScreenspace(float x, float y, float z, float w, float h) { 350 Context *rsc = RsdCpuReference::getTlsContext(); 351 352 ObjectBaseRef<const ProgramVertex> tmp(rsc->getProgramVertex()); 353 rsc->setProgramVertex(rsc->getDefaultProgramVertex()); 354 //rsc->setupCheck(); 355 356 //GLint crop[4] = {0, h, w, -h}; 357 358 float sh = rsc->getHeight(); 359 360 SC_DrawQuad(x, sh - y, z, 361 x+w, sh - y, z, 362 x+w, sh - (y+h), z, 363 x, sh - (y+h), z); 364 rsc->setProgramVertex((ProgramVertex *)tmp.get()); 365} 366 367static void SC_DrawRect(float x1, float y1, float x2, float y2, float z) { 368 SC_DrawQuad(x1, y2, z, x2, y2, z, x2, y1, z, x1, y1, z); 369} 370 371static void SC_DrawPath(Path *p) { 372 Context *rsc = RsdCpuReference::getTlsContext(); 373 rsdPathDraw(rsc, p); 374} 375 376static void SC_DrawMesh(Mesh *m) { 377 Context *rsc = RsdCpuReference::getTlsContext(); 378 rsrDrawMesh(rsc, m); 379} 380 381static void SC_DrawMeshPrimitive(Mesh *m, uint32_t primIndex) { 382 Context *rsc = RsdCpuReference::getTlsContext(); 383 rsrDrawMeshPrimitive(rsc, m, primIndex); 384} 385 386static void SC_DrawMeshPrimitiveRange(Mesh *m, uint32_t primIndex, uint32_t start, uint32_t len) { 387 Context *rsc = RsdCpuReference::getTlsContext(); 388 rsrDrawMeshPrimitiveRange(rsc, m, primIndex, start, len); 389} 390 391static void SC_MeshComputeBoundingBox(Mesh *m, 392 float *minX, float *minY, float *minZ, 393 float *maxX, float *maxY, float *maxZ) { 394 Context *rsc = RsdCpuReference::getTlsContext(); 395 rsrMeshComputeBoundingBox(rsc, m, minX, minY, minZ, maxX, maxY, maxZ); 396} 397 398 399 400////////////////////////////////////////////////////////////////////////////// 401// 402////////////////////////////////////////////////////////////////////////////// 403 404 405static void SC_Color(float r, float g, float b, float a) { 406 Context *rsc = RsdCpuReference::getTlsContext(); 407 rsrColor(rsc, r, g, b, a); 408} 409 410static void SC_Finish() { 411 Context *rsc = RsdCpuReference::getTlsContext(); 412 rsdGLFinish(rsc); 413} 414 415static void SC_ClearColor(float r, float g, float b, float a) { 416 Context *rsc = RsdCpuReference::getTlsContext(); 417 rsrPrepareClear(rsc); 418 rsdGLClearColor(rsc, r, g, b, a); 419} 420 421static void SC_ClearDepth(float v) { 422 Context *rsc = RsdCpuReference::getTlsContext(); 423 rsrPrepareClear(rsc); 424 rsdGLClearDepth(rsc, v); 425} 426 427static uint32_t SC_GetWidth() { 428 Context *rsc = RsdCpuReference::getTlsContext(); 429 return rsrGetWidth(rsc); 430} 431 432static uint32_t SC_GetHeight() { 433 Context *rsc = RsdCpuReference::getTlsContext(); 434 return rsrGetHeight(rsc); 435} 436 437static void SC_DrawTextAlloc(Allocation *a, int x, int y) { 438 Context *rsc = RsdCpuReference::getTlsContext(); 439 rsrDrawTextAlloc(rsc, a, x, y); 440} 441 442static void SC_DrawText(const char *text, int x, int y) { 443 Context *rsc = RsdCpuReference::getTlsContext(); 444 rsrDrawText(rsc, text, x, y); 445} 446 447static void SC_MeasureTextAlloc(Allocation *a, 448 int32_t *left, int32_t *right, int32_t *top, int32_t *bottom) { 449 Context *rsc = RsdCpuReference::getTlsContext(); 450 rsrMeasureTextAlloc(rsc, a, left, right, top, bottom); 451} 452 453static void SC_MeasureText(const char *text, 454 int32_t *left, int32_t *right, int32_t *top, int32_t *bottom) { 455 Context *rsc = RsdCpuReference::getTlsContext(); 456 rsrMeasureText(rsc, text, left, right, top, bottom); 457} 458 459static void SC_BindFont(Font *f) { 460 Context *rsc = RsdCpuReference::getTlsContext(); 461 rsrBindFont(rsc, f); 462} 463 464static void SC_FontColor(float r, float g, float b, float a) { 465 Context *rsc = RsdCpuReference::getTlsContext(); 466 rsrFontColor(rsc, r, g, b, a); 467} 468#endif 469 470 471////////////////////////////////////////////////////////////////////////////// 472// 473////////////////////////////////////////////////////////////////////////////// 474 475static void SC_ClearObject(rs_object_base *dst) { 476 Context *rsc = RsdCpuReference::getTlsContext(); 477 rsrClearObject(rsc, dst); 478} 479#ifndef RS_COMPATIBILITY_LIB 480static void SC_SetObject(rs_object_base *dst, rs_object_base src) { 481 // ALOGE("SC_SetObject: dst = %p, src = %p", dst, src.p); 482 // ALOGE("SC_SetObject: dst[0] = %p", dst[0]); 483 Context *rsc = RsdCpuReference::getTlsContext(); 484 rsrSetObject(rsc, dst, (ObjectBase*)src.p); 485} 486 487#ifdef __LP64__ 488static void SC_SetObject_ByRef(rs_object_base *dst, rs_object_base *src) { 489 // ALOGE("SC_SetObject2: dst = %p, src = %p", dst, src->p); 490 Context *rsc = RsdCpuReference::getTlsContext(); 491 rsrSetObject(rsc, dst, (ObjectBase*)src->p); 492} 493#endif 494 495static bool SC_IsObject(rs_object_base o) { 496 Context *rsc = RsdCpuReference::getTlsContext(); 497 return rsrIsObject(rsc, o); 498} 499 500#ifdef __LP64__ 501static bool SC_IsObject_ByRef(rs_object_base *o) { 502 Context *rsc = RsdCpuReference::getTlsContext(); 503 return rsrIsObject(rsc, *o); 504} 505#endif 506 507#else 508static void SC_SetObject(rs_object_base *dst, ObjectBase* src) { 509 // ALOGE("SC_SetObject: dst = %p, src = %p", dst, src.p); 510 // ALOGE("SC_SetObject: dst[0] = %p", dst[0]); 511 Context *rsc = RsdCpuReference::getTlsContext(); 512 rsrSetObject(rsc, dst, src); 513} 514 515static bool SC_IsObject(ObjectBase* o) { 516 Context *rsc = RsdCpuReference::getTlsContext(); 517 return rsrIsObject(rsc, o); 518} 519#endif 520 521 522#ifndef RS_COMPATIBILITY_LIB 523#ifndef __LP64__ 524 525// i386 has different struct return passing to ARM; emulate with void* 526#ifdef __i386__ 527static const void* SC_GetAllocation(const void *ptr) { 528 Context *rsc = RsdCpuReference::getTlsContext(); 529 const Script *sc = RsdCpuReference::getTlsScript(); 530 Allocation* alloc = rsdScriptGetAllocationForPointer(rsc, sc, ptr); 531 android::renderscript::rs_allocation obj = {0}; 532 alloc->callUpdateCacheObject(rsc, &obj); 533 return (void*)obj.p; 534} 535#else 536// ARMv7/MIPS 537static const android::renderscript::rs_allocation SC_GetAllocation(const void *ptr) { 538 Context *rsc = RsdCpuReference::getTlsContext(); 539 const Script *sc = RsdCpuReference::getTlsScript(); 540 Allocation* alloc = rsdScriptGetAllocationForPointer(rsc, sc, ptr); 541 android::renderscript::rs_allocation obj = {0}; 542 alloc->callUpdateCacheObject(rsc, &obj); 543 return obj; 544} 545#endif 546#else 547// AArch64/x86_64/MIPS64 548static const android::renderscript::rs_allocation SC_GetAllocation(const void *ptr) { 549 Context *rsc = RsdCpuReference::getTlsContext(); 550 const Script *sc = RsdCpuReference::getTlsScript(); 551 Allocation* alloc = rsdScriptGetAllocationForPointer(rsc, sc, ptr); 552 android::renderscript::rs_allocation obj = {0, 0, 0, 0}; 553 alloc->callUpdateCacheObject(rsc, &obj); 554 return obj; 555} 556#endif 557#endif 558 559#ifndef RS_COMPATIBILITY_LIB 560#ifndef __LP64__ 561static void SC_ForEach_SAA(android::renderscript::rs_script target, 562 android::renderscript::rs_allocation in, 563 android::renderscript::rs_allocation out) { 564 Context *rsc = RsdCpuReference::getTlsContext(); 565 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, 566 nullptr, 0, nullptr); 567} 568#else 569static void SC_ForEach_SAA(android::renderscript::rs_script *target, 570 android::renderscript::rs_allocation *in, 571 android::renderscript::rs_allocation *out) { 572 Context *rsc = RsdCpuReference::getTlsContext(); 573 rsrForEach(rsc, (Script*)target->p, (Allocation*)in->p, (Allocation*)out->p, NULL, 0, NULL); 574} 575#endif 576 577#ifndef __LP64__ 578static void SC_ForEach_SAAU(android::renderscript::rs_script target, 579 android::renderscript::rs_allocation in, 580 android::renderscript::rs_allocation out, 581 const void *usr) { 582 Context *rsc = RsdCpuReference::getTlsContext(); 583 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, 584 usr, 0, nullptr); 585} 586#else 587static void SC_ForEach_SAAU(android::renderscript::rs_script *target, 588 android::renderscript::rs_allocation *in, 589 android::renderscript::rs_allocation *out, 590 const void *usr) { 591 Context *rsc = RsdCpuReference::getTlsContext(); 592 rsrForEach(rsc, (Script*)target->p, (Allocation*)in->p, (Allocation*)out->p, usr, 0, NULL); 593} 594#endif 595 596#ifndef __LP64__ 597static void SC_ForEach_SAAUS(android::renderscript::rs_script target, 598 android::renderscript::rs_allocation in, 599 android::renderscript::rs_allocation out, 600 const void *usr, 601 const RsScriptCall *call) { 602 Context *rsc = RsdCpuReference::getTlsContext(); 603 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, usr, 0, call); 604} 605#else 606static void SC_ForEach_SAAUS(android::renderscript::rs_script *target, 607 android::renderscript::rs_allocation *in, 608 android::renderscript::rs_allocation *out, 609 const void *usr, 610 const RsScriptCall *call) { 611 Context *rsc = RsdCpuReference::getTlsContext(); 612 rsrForEach(rsc, (Script*)target->p, (Allocation*)in->p, (Allocation*)out->p, usr, 0, call); 613} 614#endif 615 616// These functions are only supported in 32-bit. 617#ifndef __LP64__ 618static void SC_ForEach_SAAUL(android::renderscript::rs_script target, 619 android::renderscript::rs_allocation in, 620 android::renderscript::rs_allocation out, 621 const void *usr, 622 uint32_t usrLen) { 623 Context *rsc = RsdCpuReference::getTlsContext(); 624 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, 625 usr, usrLen, nullptr); 626} 627static void SC_ForEach_SAAULS(android::renderscript::rs_script target, 628 android::renderscript::rs_allocation in, 629 android::renderscript::rs_allocation out, 630 const void *usr, 631 uint32_t usrLen, 632 const RsScriptCall *call) { 633 Context *rsc = RsdCpuReference::getTlsContext(); 634 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, usr, usrLen, call); 635} 636#endif 637#endif 638 639 640////////////////////////////////////////////////////////////////////////////// 641// Time routines 642////////////////////////////////////////////////////////////////////////////// 643 644static float SC_GetDt() { 645 Context *rsc = RsdCpuReference::getTlsContext(); 646 const Script *sc = RsdCpuReference::getTlsScript(); 647 return rsrGetDt(rsc, sc); 648} 649 650#ifndef RS_COMPATIBILITY_LIB 651time_t SC_Time(time_t *timer) { 652 Context *rsc = RsdCpuReference::getTlsContext(); 653 return rsrTime(rsc, timer); 654} 655#else 656static int SC_Time(int *timer) { 657 Context *rsc = RsdCpuReference::getTlsContext(); 658 return rsrTime(rsc, (long*)timer); 659} 660#endif 661 662tm* SC_LocalTime(tm *local, time_t *timer) { 663 Context *rsc = RsdCpuReference::getTlsContext(); 664 return rsrLocalTime(rsc, local, timer); 665} 666 667int64_t SC_UptimeMillis() { 668 Context *rsc = RsdCpuReference::getTlsContext(); 669 return rsrUptimeMillis(rsc); 670} 671 672int64_t SC_UptimeNanos() { 673 Context *rsc = RsdCpuReference::getTlsContext(); 674 return rsrUptimeNanos(rsc); 675} 676 677////////////////////////////////////////////////////////////////////////////// 678// Message routines 679////////////////////////////////////////////////////////////////////////////// 680 681static uint32_t SC_ToClient2(int cmdID, const void *data, uint32_t len) { 682 Context *rsc = RsdCpuReference::getTlsContext(); 683 return rsrToClient(rsc, cmdID, data, len); 684} 685 686static uint32_t SC_ToClient(int cmdID) { 687 Context *rsc = RsdCpuReference::getTlsContext(); 688 return rsrToClient(rsc, cmdID, (const void *)nullptr, 0); 689} 690 691static uint32_t SC_ToClientBlocking2(int cmdID, const void *data, uint32_t len) { 692 Context *rsc = RsdCpuReference::getTlsContext(); 693 return rsrToClientBlocking(rsc, cmdID, data, len); 694} 695 696static uint32_t SC_ToClientBlocking(int cmdID) { 697 Context *rsc = RsdCpuReference::getTlsContext(); 698 return rsrToClientBlocking(rsc, cmdID, (const void *)nullptr, 0); 699} 700 701 702static void * ElementAt1D(Allocation *a, RsDataType dt, uint32_t vecSize, uint32_t x) { 703 Context *rsc = RsdCpuReference::getTlsContext(); 704 const Type *t = a->getType(); 705 const Element *e = t->getElement(); 706 707 char buf[256]; 708 if (x >= t->getLODDimX(0)) { 709 sprintf(buf, "Out range ElementAt X %i of %i", x, t->getLODDimX(0)); 710 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 711 return nullptr; 712 } 713 714 if (vecSize > 0) { 715 if (vecSize != e->getVectorSize()) { 716 sprintf(buf, "Vector size mismatch for ElementAt %i of %i", vecSize, e->getVectorSize()); 717 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 718 return nullptr; 719 } 720 721 if (dt != e->getType()) { 722 sprintf(buf, "Data type mismatch for ElementAt %i of %i", dt, e->getType()); 723 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 724 return nullptr; 725 } 726 } 727 728 uint8_t *p = (uint8_t *)a->mHal.drvState.lod[0].mallocPtr; 729 const uint32_t eSize = e->getSizeBytes(); 730 return &p[(eSize * x)]; 731} 732 733static void * ElementAt2D(Allocation *a, RsDataType dt, uint32_t vecSize, uint32_t x, uint32_t y) { 734 Context *rsc = RsdCpuReference::getTlsContext(); 735 const Type *t = a->getType(); 736 const Element *e = t->getElement(); 737 738 char buf[256]; 739 if (x >= t->getLODDimX(0)) { 740 sprintf(buf, "Out range ElementAt X %i of %i", x, t->getLODDimX(0)); 741 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 742 return nullptr; 743 } 744 745 if (y >= t->getLODDimY(0)) { 746 sprintf(buf, "Out range ElementAt Y %i of %i", y, t->getLODDimY(0)); 747 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 748 return nullptr; 749 } 750 751 if (vecSize > 0) { 752 if (vecSize != e->getVectorSize()) { 753 sprintf(buf, "Vector size mismatch for ElementAt %i of %i", vecSize, e->getVectorSize()); 754 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 755 return nullptr; 756 } 757 758 if (dt != e->getType()) { 759 sprintf(buf, "Data type mismatch for ElementAt %i of %i", dt, e->getType()); 760 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 761 return nullptr; 762 } 763 } 764 765 uint8_t *p = (uint8_t *)a->mHal.drvState.lod[0].mallocPtr; 766 const uint32_t eSize = e->getSizeBytes(); 767 const uint32_t stride = a->mHal.drvState.lod[0].stride; 768 return &p[(eSize * x) + (y * stride)]; 769} 770 771static void * ElementAt3D(Allocation *a, RsDataType dt, uint32_t vecSize, uint32_t x, uint32_t y, uint32_t z) { 772 Context *rsc = RsdCpuReference::getTlsContext(); 773 const Type *t = a->getType(); 774 const Element *e = t->getElement(); 775 776 char buf[256]; 777 if (x >= t->getLODDimX(0)) { 778 sprintf(buf, "Out range ElementAt X %i of %i", x, t->getLODDimX(0)); 779 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 780 return nullptr; 781 } 782 783 if (y >= t->getLODDimY(0)) { 784 sprintf(buf, "Out range ElementAt Y %i of %i", y, t->getLODDimY(0)); 785 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 786 return nullptr; 787 } 788 789 if (z >= t->getLODDimZ(0)) { 790 sprintf(buf, "Out range ElementAt Z %i of %i", z, t->getLODDimZ(0)); 791 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 792 return nullptr; 793 } 794 795 if (vecSize > 0) { 796 if (vecSize != e->getVectorSize()) { 797 sprintf(buf, "Vector size mismatch for ElementAt %i of %i", vecSize, e->getVectorSize()); 798 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 799 return nullptr; 800 } 801 802 if (dt != e->getType()) { 803 sprintf(buf, "Data type mismatch for ElementAt %i of %i", dt, e->getType()); 804 rsc->setError(RS_ERROR_FATAL_DEBUG, buf); 805 return nullptr; 806 } 807 } 808 809 uint8_t *p = (uint8_t *)a->mHal.drvState.lod[0].mallocPtr; 810 const uint32_t eSize = e->getSizeBytes(); 811 const uint32_t stride = a->mHal.drvState.lod[0].stride; 812 return &p[(eSize * x) + (y * stride)]; 813} 814 815static const void * SC_GetElementAt1D(android::renderscript::rs_allocation a, uint32_t x) { 816 return ElementAt1D((Allocation*)a.p, RS_TYPE_UNSIGNED_8, 0, x); 817} 818static const void * SC_GetElementAt2D(android::renderscript::rs_allocation a, uint32_t x, uint32_t y) { 819 return ElementAt2D((Allocation*)a.p, RS_TYPE_UNSIGNED_8, 0, x, y); 820} 821static const void * SC_GetElementAt3D(android::renderscript::rs_allocation a, uint32_t x, uint32_t y, uint32_t z) { 822 return ElementAt3D((Allocation*)a.p, RS_TYPE_UNSIGNED_8, 0, x, y, z); 823} 824 825static void SC_SetElementAt1D(android::renderscript::rs_allocation a, const void *ptr, uint32_t x) { 826 const Type *t = ((Allocation*)a.p)->getType(); 827 const Element *e = t->getElement(); 828 void *tmp = ElementAt1D((Allocation*)a.p, RS_TYPE_UNSIGNED_8, 0, x); 829 if (tmp != nullptr) { 830 memcpy(tmp, ptr, e->getSizeBytes()); 831 } 832} 833static void SC_SetElementAt2D(android::renderscript::rs_allocation a, const void *ptr, uint32_t x, uint32_t y) { 834 const Type *t = ((Allocation*)a.p)->getType(); 835 const Element *e = t->getElement(); 836 void *tmp = ElementAt2D((Allocation*)a.p, RS_TYPE_UNSIGNED_8, 0, x, y); 837 if (tmp != nullptr) { 838 memcpy(tmp, ptr, e->getSizeBytes()); 839 } 840} 841static void SC_SetElementAt3D(android::renderscript::rs_allocation a, const void *ptr, uint32_t x, uint32_t y, uint32_t z) { 842 const Type *t = ((Allocation*)a.p)->getType(); 843 const Element *e = t->getElement(); 844 void *tmp = ElementAt3D((Allocation*)a.p, RS_TYPE_UNSIGNED_8, 0, x, y, z); 845 if (tmp != nullptr) { 846 memcpy(tmp, ptr, e->getSizeBytes()); 847 } 848} 849 850#define ELEMENT_AT(T, DT, VS) \ 851 static void SC_SetElementAt1_##T(android::renderscript::rs_allocation a, const T *val, uint32_t x) { \ 852 void *r = ElementAt1D((Allocation*)a.p, DT, VS, x); \ 853 if (r != nullptr) ((T *)r)[0] = *val; \ 854 else ALOGE("Error from %s", __PRETTY_FUNCTION__); \ 855 } \ 856 static void SC_SetElementAt2_##T(android::renderscript::rs_allocation a, const T * val, uint32_t x, uint32_t y) { \ 857 void *r = ElementAt2D((Allocation*)a.p, DT, VS, x, y); \ 858 if (r != nullptr) ((T *)r)[0] = *val; \ 859 else ALOGE("Error from %s", __PRETTY_FUNCTION__); \ 860 } \ 861 static void SC_SetElementAt3_##T(android::renderscript::rs_allocation a, const T * val, uint32_t x, uint32_t y, uint32_t z) { \ 862 void *r = ElementAt3D((Allocation*)a.p, DT, VS, x, y, z); \ 863 if (r != nullptr) ((T *)r)[0] = *val; \ 864 else ALOGE("Error from %s", __PRETTY_FUNCTION__); \ 865 } \ 866 static void SC_GetElementAt1_##T(android::renderscript::rs_allocation a, T *val, uint32_t x) { \ 867 void *r = ElementAt1D((Allocation*)a.p, DT, VS, x); \ 868 if (r != nullptr) *val = ((T *)r)[0]; \ 869 else ALOGE("Error from %s", __PRETTY_FUNCTION__); \ 870 } \ 871 static void SC_GetElementAt2_##T(android::renderscript::rs_allocation a, T *val, uint32_t x, uint32_t y) { \ 872 void *r = ElementAt2D((Allocation*)a.p, DT, VS, x, y); \ 873 if (r != nullptr) *val = ((T *)r)[0]; \ 874 else ALOGE("Error from %s", __PRETTY_FUNCTION__); \ 875 } \ 876 static void SC_GetElementAt3_##T(android::renderscript::rs_allocation a, T *val, uint32_t x, uint32_t y, uint32_t z) { \ 877 void *r = ElementAt3D((Allocation*)a.p, DT, VS, x, y, z); \ 878 if (r != nullptr) *val = ((T *)r)[0]; \ 879 else ALOGE("Error from %s", __PRETTY_FUNCTION__); \ 880 } 881 882ELEMENT_AT(char, RS_TYPE_SIGNED_8, 1) 883ELEMENT_AT(char2, RS_TYPE_SIGNED_8, 2) 884ELEMENT_AT(char3, RS_TYPE_SIGNED_8, 3) 885ELEMENT_AT(char4, RS_TYPE_SIGNED_8, 4) 886ELEMENT_AT(uchar, RS_TYPE_UNSIGNED_8, 1) 887ELEMENT_AT(uchar2, RS_TYPE_UNSIGNED_8, 2) 888ELEMENT_AT(uchar3, RS_TYPE_UNSIGNED_8, 3) 889ELEMENT_AT(uchar4, RS_TYPE_UNSIGNED_8, 4) 890ELEMENT_AT(short, RS_TYPE_SIGNED_16, 1) 891ELEMENT_AT(short2, RS_TYPE_SIGNED_16, 2) 892ELEMENT_AT(short3, RS_TYPE_SIGNED_16, 3) 893ELEMENT_AT(short4, RS_TYPE_SIGNED_16, 4) 894ELEMENT_AT(ushort, RS_TYPE_UNSIGNED_16, 1) 895ELEMENT_AT(ushort2, RS_TYPE_UNSIGNED_16, 2) 896ELEMENT_AT(ushort3, RS_TYPE_UNSIGNED_16, 3) 897ELEMENT_AT(ushort4, RS_TYPE_UNSIGNED_16, 4) 898ELEMENT_AT(int, RS_TYPE_SIGNED_32, 1) 899ELEMENT_AT(int2, RS_TYPE_SIGNED_32, 2) 900ELEMENT_AT(int3, RS_TYPE_SIGNED_32, 3) 901ELEMENT_AT(int4, RS_TYPE_SIGNED_32, 4) 902ELEMENT_AT(uint, RS_TYPE_UNSIGNED_32, 1) 903ELEMENT_AT(uint2, RS_TYPE_UNSIGNED_32, 2) 904ELEMENT_AT(uint3, RS_TYPE_UNSIGNED_32, 3) 905ELEMENT_AT(uint4, RS_TYPE_UNSIGNED_32, 4) 906ELEMENT_AT(long, RS_TYPE_SIGNED_64, 1) 907ELEMENT_AT(long2, RS_TYPE_SIGNED_64, 2) 908ELEMENT_AT(long3, RS_TYPE_SIGNED_64, 3) 909ELEMENT_AT(long4, RS_TYPE_SIGNED_64, 4) 910ELEMENT_AT(ulong, RS_TYPE_UNSIGNED_64, 1) 911ELEMENT_AT(ulong2, RS_TYPE_UNSIGNED_64, 2) 912ELEMENT_AT(ulong3, RS_TYPE_UNSIGNED_64, 3) 913ELEMENT_AT(ulong4, RS_TYPE_UNSIGNED_64, 4) 914ELEMENT_AT(float, RS_TYPE_FLOAT_32, 1) 915ELEMENT_AT(float2, RS_TYPE_FLOAT_32, 2) 916ELEMENT_AT(float3, RS_TYPE_FLOAT_32, 3) 917ELEMENT_AT(float4, RS_TYPE_FLOAT_32, 4) 918ELEMENT_AT(double, RS_TYPE_FLOAT_64, 1) 919ELEMENT_AT(double2, RS_TYPE_FLOAT_64, 2) 920ELEMENT_AT(double3, RS_TYPE_FLOAT_64, 3) 921ELEMENT_AT(double4, RS_TYPE_FLOAT_64, 4) 922 923#undef ELEMENT_AT 924 925////////////////////////////////////////////////////////////////////////////// 926// Stub implementation 927////////////////////////////////////////////////////////////////////////////// 928 929// llvm name mangling ref 930// <builtin-type> ::= v # void 931// ::= b # bool 932// ::= c # char 933// ::= a # signed char 934// ::= h # unsigned char 935// ::= s # short 936// ::= t # unsigned short 937// ::= i # int 938// ::= j # unsigned int 939// ::= l # long 940// ::= m # unsigned long 941// ::= x # long long, __int64 942// ::= y # unsigned long long, __int64 943// ::= f # float 944// ::= d # double 945 946static RsdCpuReference::CpuSymbol gSyms[] = { 947 // Debug runtime 948 { "_Z14rsGetElementAt13rs_allocationj", (void *)&SC_GetElementAt1D, true }, 949 { "_Z14rsGetElementAt13rs_allocationjj", (void *)&SC_GetElementAt2D, true }, 950 { "_Z14rsGetElementAt13rs_allocationjjj", (void *)&SC_GetElementAt3D, true }, 951 { "_Z14rsSetElementAt13rs_allocationPKvj", (void *)&SC_SetElementAt1D, true }, 952 { "_Z14rsSetElementAt13rs_allocationPKvjj", (void *)&SC_SetElementAt2D, true }, 953 { "_Z14rsSetElementAt13rs_allocationPKvjjj", (void *)&SC_SetElementAt3D, true }, 954 955 956 { "_Z20rsGetElementAt_uchar13rs_allocationPhj", (void *)&SC_GetElementAt1_uchar, true }, 957 { "_Z21rsGetElementAt_uchar213rs_allocationPDv2_hj", (void *)&SC_GetElementAt1_uchar2, true }, 958 { "_Z21rsGetElementAt_uchar313rs_allocationPDv3_hj", (void *)&SC_GetElementAt1_uchar3, true }, 959 { "_Z21rsGetElementAt_uchar413rs_allocationPDv4_hj", (void *)&SC_GetElementAt1_uchar4, true }, 960 { "_Z20rsGetElementAt_uchar13rs_allocationPhjj", (void *)&SC_GetElementAt2_uchar, true }, 961 { "_Z21rsGetElementAt_uchar213rs_allocationPDv2_hjj", (void *)&SC_GetElementAt2_uchar2, true }, 962 { "_Z21rsGetElementAt_uchar313rs_allocationPDv3_hjj", (void *)&SC_GetElementAt2_uchar3, true }, 963 { "_Z21rsGetElementAt_uchar413rs_allocationPDv4_hjj", (void *)&SC_GetElementAt2_uchar4, true }, 964 { "_Z20rsGetElementAt_uchar13rs_allocationPhjjj", (void *)&SC_GetElementAt3_uchar, true }, 965 { "_Z21rsGetElementAt_uchar213rs_allocationPDv2_hjjj", (void *)&SC_GetElementAt3_uchar2, true }, 966 { "_Z21rsGetElementAt_uchar313rs_allocationPDv3_hjjj", (void *)&SC_GetElementAt3_uchar3, true }, 967 { "_Z21rsGetElementAt_uchar413rs_allocationPDv4_hjjj", (void *)&SC_GetElementAt3_uchar4, true }, 968 969 { "_Z19rsGetElementAt_char13rs_allocationPcj", (void *)&SC_GetElementAt1_char, true }, 970 { "_Z20rsGetElementAt_char213rs_allocationPDv2_cj", (void *)&SC_GetElementAt1_char2, true }, 971 { "_Z20rsGetElementAt_char313rs_allocationPDv3_cj", (void *)&SC_GetElementAt1_char3, true }, 972 { "_Z20rsGetElementAt_char413rs_allocationPDv4_cj", (void *)&SC_GetElementAt1_char4, true }, 973 { "_Z19rsGetElementAt_char13rs_allocationPcjj", (void *)&SC_GetElementAt2_char, true }, 974 { "_Z20rsGetElementAt_char213rs_allocationPDv2_cjj", (void *)&SC_GetElementAt2_char2, true }, 975 { "_Z20rsGetElementAt_char313rs_allocationPDv3_cjj", (void *)&SC_GetElementAt2_char3, true }, 976 { "_Z20rsGetElementAt_char413rs_allocationPDv4_cjj", (void *)&SC_GetElementAt2_char4, true }, 977 { "_Z19rsGetElementAt_char13rs_allocationPcjjj", (void *)&SC_GetElementAt3_char, true }, 978 { "_Z20rsGetElementAt_char213rs_allocationPDv2_cjjj", (void *)&SC_GetElementAt3_char2, true }, 979 { "_Z20rsGetElementAt_char313rs_allocationPDv3_cjjj", (void *)&SC_GetElementAt3_char3, true }, 980 { "_Z20rsGetElementAt_char413rs_allocationPDv4_cjjj", (void *)&SC_GetElementAt3_char4, true }, 981 982 { "_Z21rsGetElementAt_ushort13rs_allocationPtj", (void *)&SC_GetElementAt1_ushort, true }, 983 { "_Z22rsGetElementAt_ushort213rs_allocationPDv2_tj", (void *)&SC_GetElementAt1_ushort2, true }, 984 { "_Z22rsGetElementAt_ushort313rs_allocationPDv3_tj", (void *)&SC_GetElementAt1_ushort3, true }, 985 { "_Z22rsGetElementAt_ushort413rs_allocationPDv4_tj", (void *)&SC_GetElementAt1_ushort4, true }, 986 { "_Z21rsGetElementAt_ushort13rs_allocationPtjj", (void *)&SC_GetElementAt2_ushort, true }, 987 { "_Z22rsGetElementAt_ushort213rs_allocationPDv2_tjj", (void *)&SC_GetElementAt2_ushort2, true }, 988 { "_Z22rsGetElementAt_ushort313rs_allocationPDv3_tjj", (void *)&SC_GetElementAt2_ushort3, true }, 989 { "_Z22rsGetElementAt_ushort413rs_allocationPDv4_tjj", (void *)&SC_GetElementAt2_ushort4, true }, 990 { "_Z21rsGetElementAt_ushort13rs_allocationPtjjj", (void *)&SC_GetElementAt3_ushort, true }, 991 { "_Z22rsGetElementAt_ushort213rs_allocationPDv2_tjjj", (void *)&SC_GetElementAt3_ushort2, true }, 992 { "_Z22rsGetElementAt_ushort313rs_allocationPDv3_tjjj", (void *)&SC_GetElementAt3_ushort3, true }, 993 { "_Z22rsGetElementAt_ushort413rs_allocationPDv4_tjjj", (void *)&SC_GetElementAt3_ushort4, true }, 994 995 { "_Z20rsGetElementAt_short13rs_allocationPsj", (void *)&SC_GetElementAt1_short, true }, 996 { "_Z21rsGetElementAt_short213rs_allocationPDv2_sj", (void *)&SC_GetElementAt1_short2, true }, 997 { "_Z21rsGetElementAt_short313rs_allocationPDv3_sj", (void *)&SC_GetElementAt1_short3, true }, 998 { "_Z21rsGetElementAt_short413rs_allocationPDv4_sj", (void *)&SC_GetElementAt1_short4, true }, 999 { "_Z20rsGetElementAt_short13rs_allocationPsjj", (void *)&SC_GetElementAt2_short, true }, 1000 { "_Z21rsGetElementAt_short213rs_allocationPDv2_sjj", (void *)&SC_GetElementAt2_short2, true }, 1001 { "_Z21rsGetElementAt_short313rs_allocationPDv3_sjj", (void *)&SC_GetElementAt2_short3, true }, 1002 { "_Z21rsGetElementAt_short413rs_allocationPDv4_sjj", (void *)&SC_GetElementAt2_short4, true }, 1003 { "_Z20rsGetElementAt_short13rs_allocationPsjjj", (void *)&SC_GetElementAt3_short, true }, 1004 { "_Z21rsGetElementAt_short213rs_allocationPDv2_sjjj", (void *)&SC_GetElementAt3_short2, true }, 1005 { "_Z21rsGetElementAt_short313rs_allocationPDv3_sjjj", (void *)&SC_GetElementAt3_short3, true }, 1006 { "_Z21rsGetElementAt_short413rs_allocationPDv4_sjjj", (void *)&SC_GetElementAt3_short4, true }, 1007 1008 { "_Z19rsGetElementAt_uint13rs_allocationPjj", (void *)&SC_GetElementAt1_uint, true }, 1009 { "_Z20rsGetElementAt_uint213rs_allocationPDv2_jj", (void *)&SC_GetElementAt1_uint2, true }, 1010 { "_Z20rsGetElementAt_uint313rs_allocationPDv3_jj", (void *)&SC_GetElementAt1_uint3, true }, 1011 { "_Z20rsGetElementAt_uint413rs_allocationPDv4_jj", (void *)&SC_GetElementAt1_uint4, true }, 1012 { "_Z19rsGetElementAt_uint13rs_allocationPjjj", (void *)&SC_GetElementAt2_uint, true }, 1013 { "_Z20rsGetElementAt_uint213rs_allocationPDv2_jjj", (void *)&SC_GetElementAt2_uint2, true }, 1014 { "_Z20rsGetElementAt_uint313rs_allocationPDv3_jjj", (void *)&SC_GetElementAt2_uint3, true }, 1015 { "_Z20rsGetElementAt_uint413rs_allocationPDv4_jjj", (void *)&SC_GetElementAt2_uint4, true }, 1016 { "_Z19rsGetElementAt_uint13rs_allocationPjjjj", (void *)&SC_GetElementAt3_uint, true }, 1017 { "_Z20rsGetElementAt_uint213rs_allocationPDv2_jjjj", (void *)&SC_GetElementAt3_uint2, true }, 1018 { "_Z20rsGetElementAt_uint313rs_allocationPDv3_jjjj", (void *)&SC_GetElementAt3_uint3, true }, 1019 { "_Z20rsGetElementAt_uint413rs_allocationPDv4_jjjj", (void *)&SC_GetElementAt3_uint4, true }, 1020 1021 { "_Z18rsGetElementAt_int13rs_allocationPij", (void *)&SC_GetElementAt1_int, true }, 1022 { "_Z19rsGetElementAt_int213rs_allocationPDv2_ij", (void *)&SC_GetElementAt1_int2, true }, 1023 { "_Z19rsGetElementAt_int313rs_allocationPDv3_ij", (void *)&SC_GetElementAt1_int3, true }, 1024 { "_Z19rsGetElementAt_int413rs_allocationPDv4_ij", (void *)&SC_GetElementAt1_int4, true }, 1025 { "_Z18rsGetElementAt_int13rs_allocationPijj", (void *)&SC_GetElementAt2_int, true }, 1026 { "_Z19rsGetElementAt_int213rs_allocationPDv2_ijj", (void *)&SC_GetElementAt2_int2, true }, 1027 { "_Z19rsGetElementAt_int313rs_allocationPDv3_ijj", (void *)&SC_GetElementAt2_int3, true }, 1028 { "_Z19rsGetElementAt_int413rs_allocationPDv4_ijj", (void *)&SC_GetElementAt2_int4, true }, 1029 { "_Z18rsGetElementAt_int13rs_allocationPijjj", (void *)&SC_GetElementAt3_int, true }, 1030 { "_Z19rsGetElementAt_int213rs_allocationPDv2_ijjj", (void *)&SC_GetElementAt3_int2, true }, 1031 { "_Z19rsGetElementAt_int313rs_allocationPDv3_ijjj", (void *)&SC_GetElementAt3_int3, true }, 1032 { "_Z19rsGetElementAt_int413rs_allocationPDv4_ijjj", (void *)&SC_GetElementAt3_int4, true }, 1033 1034 { "_Z20rsGetElementAt_ulong13rs_allocationPmj", (void *)&SC_GetElementAt1_ulong, true }, 1035 { "_Z21rsGetElementAt_ulong213rs_allocationPDv2_mj", (void *)&SC_GetElementAt1_ulong2, true }, 1036 { "_Z21rsGetElementAt_ulong313rs_allocationPDv3_mj", (void *)&SC_GetElementAt1_ulong3, true }, 1037 { "_Z21rsGetElementAt_ulong413rs_allocationPDv4_mj", (void *)&SC_GetElementAt1_ulong4, true }, 1038 { "_Z20rsGetElementAt_ulong13rs_allocationPmjj", (void *)&SC_GetElementAt2_ulong, true }, 1039 { "_Z21rsGetElementAt_ulong213rs_allocationPDv2_mjj", (void *)&SC_GetElementAt2_ulong2, true }, 1040 { "_Z21rsGetElementAt_ulong313rs_allocationPDv3_mjj", (void *)&SC_GetElementAt2_ulong3, true }, 1041 { "_Z21rsGetElementAt_ulong413rs_allocationPDv4_mjj", (void *)&SC_GetElementAt2_ulong4, true }, 1042 { "_Z20rsGetElementAt_ulong13rs_allocationPmjjj", (void *)&SC_GetElementAt3_ulong, true }, 1043 { "_Z21rsGetElementAt_ulong213rs_allocationPDv2_mjjj", (void *)&SC_GetElementAt3_ulong2, true }, 1044 { "_Z21rsGetElementAt_ulong313rs_allocationPDv3_mjjj", (void *)&SC_GetElementAt3_ulong3, true }, 1045 { "_Z21rsGetElementAt_ulong413rs_allocationPDv4_mjjj", (void *)&SC_GetElementAt3_ulong4, true }, 1046 1047 { "_Z19rsGetElementAt_long13rs_allocationPlj", (void *)&SC_GetElementAt1_long, true }, 1048 { "_Z20rsGetElementAt_long213rs_allocationPDv2_lj", (void *)&SC_GetElementAt1_long2, true }, 1049 { "_Z20rsGetElementAt_long313rs_allocationPDv3_lj", (void *)&SC_GetElementAt1_long3, true }, 1050 { "_Z20rsGetElementAt_long413rs_allocationPDv4_lj", (void *)&SC_GetElementAt1_long4, true }, 1051 { "_Z19rsGetElementAt_long13rs_allocationPljj", (void *)&SC_GetElementAt2_long, true }, 1052 { "_Z20rsGetElementAt_long213rs_allocationPDv2_ljj", (void *)&SC_GetElementAt2_long2, true }, 1053 { "_Z20rsGetElementAt_long313rs_allocationPDv3_ljj", (void *)&SC_GetElementAt2_long3, true }, 1054 { "_Z20rsGetElementAt_long413rs_allocationPDv4_ljj", (void *)&SC_GetElementAt2_long4, true }, 1055 { "_Z19rsGetElementAt_long13rs_allocationPljjj", (void *)&SC_GetElementAt3_long, true }, 1056 { "_Z20rsGetElementAt_long213rs_allocationPDv2_ljjj", (void *)&SC_GetElementAt3_long2, true }, 1057 { "_Z20rsGetElementAt_long313rs_allocationPDv3_ljjj", (void *)&SC_GetElementAt3_long3, true }, 1058 { "_Z20rsGetElementAt_long413rs_allocationPDv4_ljjj", (void *)&SC_GetElementAt3_long4, true }, 1059 1060 { "_Z20rsGetElementAt_float13rs_allocationPfj", (void *)&SC_GetElementAt1_float, true }, 1061 { "_Z21rsGetElementAt_float213rs_allocationPDv2_fj", (void *)&SC_GetElementAt1_float2, true }, 1062 { "_Z21rsGetElementAt_float313rs_allocationPDv3_fj", (void *)&SC_GetElementAt1_float3, true }, 1063 { "_Z21rsGetElementAt_float413rs_allocationPDv4_fj", (void *)&SC_GetElementAt1_float4, true }, 1064 { "_Z20rsGetElementAt_float13rs_allocationPfjj", (void *)&SC_GetElementAt2_float, true }, 1065 { "_Z21rsGetElementAt_float213rs_allocationPDv2_fjj", (void *)&SC_GetElementAt2_float2, true }, 1066 { "_Z21rsGetElementAt_float313rs_allocationPDv3_fjj", (void *)&SC_GetElementAt2_float3, true }, 1067 { "_Z21rsGetElementAt_float413rs_allocationPDv4_fjj", (void *)&SC_GetElementAt2_float4, true }, 1068 { "_Z20rsGetElementAt_float13rs_allocationPfjjj", (void *)&SC_GetElementAt3_float, true }, 1069 { "_Z21rsGetElementAt_float213rs_allocationPDv2_fjjj", (void *)&SC_GetElementAt3_float2, true }, 1070 { "_Z21rsGetElementAt_float313rs_allocationPDv3_fjjj", (void *)&SC_GetElementAt3_float3, true }, 1071 { "_Z21rsGetElementAt_float413rs_allocationPDv4_fjjj", (void *)&SC_GetElementAt3_float4, true }, 1072 1073 { "_Z21rsGetElementAt_double13rs_allocationPdj", (void *)&SC_GetElementAt1_double, true }, 1074 { "_Z22rsGetElementAt_double213rs_allocationPDv2_dj", (void *)&SC_GetElementAt1_double2, true }, 1075 { "_Z22rsGetElementAt_double313rs_allocationPDv3_dj", (void *)&SC_GetElementAt1_double3, true }, 1076 { "_Z22rsGetElementAt_double413rs_allocationPDv4_dj", (void *)&SC_GetElementAt1_double4, true }, 1077 { "_Z21rsGetElementAt_double13rs_allocationPdjj", (void *)&SC_GetElementAt2_double, true }, 1078 { "_Z22rsGetElementAt_double213rs_allocationPDv2_djj", (void *)&SC_GetElementAt2_double2, true }, 1079 { "_Z22rsGetElementAt_double313rs_allocationPDv3_djj", (void *)&SC_GetElementAt2_double3, true }, 1080 { "_Z22rsGetElementAt_double413rs_allocationPDv4_djj", (void *)&SC_GetElementAt2_double4, true }, 1081 { "_Z21rsGetElementAt_double13rs_allocationPdjjj", (void *)&SC_GetElementAt3_double, true }, 1082 { "_Z22rsGetElementAt_double213rs_allocationPDv2_djjj", (void *)&SC_GetElementAt3_double2, true }, 1083 { "_Z22rsGetElementAt_double313rs_allocationPDv3_djjj", (void *)&SC_GetElementAt3_double3, true }, 1084 { "_Z22rsGetElementAt_double413rs_allocationPDv4_djjj", (void *)&SC_GetElementAt3_double4, true }, 1085 1086 1087 1088 { "_Z20rsSetElementAt_uchar13rs_allocationPKhj", (void *)&SC_SetElementAt1_uchar, true }, 1089 { "_Z21rsSetElementAt_uchar213rs_allocationPKDv2_hj", (void *)&SC_SetElementAt1_uchar2, true }, 1090 { "_Z21rsSetElementAt_uchar313rs_allocationPKDv3_hj", (void *)&SC_SetElementAt1_uchar3, true }, 1091 { "_Z21rsSetElementAt_uchar413rs_allocationPKDv4_hj", (void *)&SC_SetElementAt1_uchar4, true }, 1092 { "_Z20rsSetElementAt_uchar13rs_allocationPKhjj", (void *)&SC_SetElementAt2_uchar, true }, 1093 { "_Z21rsSetElementAt_uchar213rs_allocationPKDv2_hjj", (void *)&SC_SetElementAt2_uchar2, true }, 1094 { "_Z21rsSetElementAt_uchar313rs_allocationPKDv3_hjj", (void *)&SC_SetElementAt2_uchar3, true }, 1095 { "_Z21rsSetElementAt_uchar413rs_allocationPKDv4_hjj", (void *)&SC_SetElementAt2_uchar4, true }, 1096 { "_Z20rsSetElementAt_uchar13rs_allocationPKhjjj", (void *)&SC_SetElementAt3_uchar, true }, 1097 { "_Z21rsSetElementAt_uchar213rs_allocationPKDv2_hjjj", (void *)&SC_SetElementAt3_uchar2, true }, 1098 { "_Z21rsSetElementAt_uchar313rs_allocationPKDv3_hjjj", (void *)&SC_SetElementAt3_uchar3, true }, 1099 { "_Z21rsSetElementAt_uchar413rs_allocationPKDv4_hjjj", (void *)&SC_SetElementAt3_uchar4, true }, 1100 1101 { "_Z19rsSetElementAt_char13rs_allocationPKcj", (void *)&SC_SetElementAt1_char, true }, 1102 { "_Z20rsSetElementAt_char213rs_allocationPKDv2_cj", (void *)&SC_SetElementAt1_char2, true }, 1103 { "_Z20rsSetElementAt_char313rs_allocationPKDv3_cj", (void *)&SC_SetElementAt1_char3, true }, 1104 { "_Z20rsSetElementAt_char413rs_allocationPKDv4_cj", (void *)&SC_SetElementAt1_char4, true }, 1105 { "_Z19rsSetElementAt_char13rs_allocationPKcjj", (void *)&SC_SetElementAt2_char, true }, 1106 { "_Z20rsSetElementAt_char213rs_allocationPKDv2_cjj", (void *)&SC_SetElementAt2_char2, true }, 1107 { "_Z20rsSetElementAt_char313rs_allocationPKDv3_cjj", (void *)&SC_SetElementAt2_char3, true }, 1108 { "_Z20rsSetElementAt_char413rs_allocationPKDv4_cjj", (void *)&SC_SetElementAt2_char4, true }, 1109 { "_Z19rsSetElementAt_char13rs_allocationPKcjjj", (void *)&SC_SetElementAt3_char, true }, 1110 { "_Z20rsSetElementAt_char213rs_allocationPKDv2_cjjj", (void *)&SC_SetElementAt3_char2, true }, 1111 { "_Z20rsSetElementAt_char313rs_allocationPKDv3_cjjj", (void *)&SC_SetElementAt3_char3, true }, 1112 { "_Z20rsSetElementAt_char413rs_allocationPKDv4_cjjj", (void *)&SC_SetElementAt3_char4, true }, 1113 1114 { "_Z21rsSetElementAt_ushort13rs_allocationPKht", (void *)&SC_SetElementAt1_ushort, true }, 1115 { "_Z22rsSetElementAt_ushort213rs_allocationPKDv2_tj", (void *)&SC_SetElementAt1_ushort2, true }, 1116 { "_Z22rsSetElementAt_ushort313rs_allocationPKDv3_tj", (void *)&SC_SetElementAt1_ushort3, true }, 1117 { "_Z22rsSetElementAt_ushort413rs_allocationPKDv4_tj", (void *)&SC_SetElementAt1_ushort4, true }, 1118 { "_Z21rsSetElementAt_ushort13rs_allocationPKtjj", (void *)&SC_SetElementAt2_ushort, true }, 1119 { "_Z22rsSetElementAt_ushort213rs_allocationPKDv2_tjj", (void *)&SC_SetElementAt2_ushort2, true }, 1120 { "_Z22rsSetElementAt_ushort313rs_allocationPKDv3_tjj", (void *)&SC_SetElementAt2_ushort3, true }, 1121 { "_Z22rsSetElementAt_ushort413rs_allocationPKDv4_tjj", (void *)&SC_SetElementAt2_ushort4, true }, 1122 { "_Z21rsSetElementAt_ushort13rs_allocationPKtjjj", (void *)&SC_SetElementAt3_ushort, true }, 1123 { "_Z22rsSetElementAt_ushort213rs_allocationPKDv2_tjjj", (void *)&SC_SetElementAt3_ushort2, true }, 1124 { "_Z22rsSetElementAt_ushort313rs_allocationPKDv3_tjjj", (void *)&SC_SetElementAt3_ushort3, true }, 1125 { "_Z22rsSetElementAt_ushort413rs_allocationPKDv4_tjjj", (void *)&SC_SetElementAt3_ushort4, true }, 1126 1127 { "_Z20rsSetElementAt_short13rs_allocationPKsj", (void *)&SC_SetElementAt1_short, true }, 1128 { "_Z21rsSetElementAt_short213rs_allocationPKDv2_sj", (void *)&SC_SetElementAt1_short2, true }, 1129 { "_Z21rsSetElementAt_short313rs_allocationPKDv3_sj", (void *)&SC_SetElementAt1_short3, true }, 1130 { "_Z21rsSetElementAt_short413rs_allocationPKDv4_sj", (void *)&SC_SetElementAt1_short4, true }, 1131 { "_Z20rsSetElementAt_short13rs_allocationPKsjj", (void *)&SC_SetElementAt2_short, true }, 1132 { "_Z21rsSetElementAt_short213rs_allocationPKDv2_sjj", (void *)&SC_SetElementAt2_short2, true }, 1133 { "_Z21rsSetElementAt_short313rs_allocationPKDv3_sjj", (void *)&SC_SetElementAt2_short3, true }, 1134 { "_Z21rsSetElementAt_short413rs_allocationPKDv4_sjj", (void *)&SC_SetElementAt2_short4, true }, 1135 { "_Z20rsSetElementAt_short13rs_allocationPKsjjj", (void *)&SC_SetElementAt3_short, true }, 1136 { "_Z21rsSetElementAt_short213rs_allocationPKDv2_sjjj", (void *)&SC_SetElementAt3_short2, true }, 1137 { "_Z21rsSetElementAt_short313rs_allocationPKDv3_sjjj", (void *)&SC_SetElementAt3_short3, true }, 1138 { "_Z21rsSetElementAt_short413rs_allocationPKDv4_sjjj", (void *)&SC_SetElementAt3_short4, true }, 1139 1140 { "_Z19rsSetElementAt_uint13rs_allocationPKjj", (void *)&SC_SetElementAt1_uint, true }, 1141 { "_Z20rsSetElementAt_uint213rs_allocationPKDv2_jj", (void *)&SC_SetElementAt1_uint2, true }, 1142 { "_Z20rsSetElementAt_uint313rs_allocationPKDv3_jj", (void *)&SC_SetElementAt1_uint3, true }, 1143 { "_Z20rsSetElementAt_uint413rs_allocationPKDv4_jj", (void *)&SC_SetElementAt1_uint4, true }, 1144 { "_Z19rsSetElementAt_uint13rs_allocationPKjjj", (void *)&SC_SetElementAt2_uint, true }, 1145 { "_Z20rsSetElementAt_uint213rs_allocationPKDv2_jjj", (void *)&SC_SetElementAt2_uint2, true }, 1146 { "_Z20rsSetElementAt_uint313rs_allocationPKDv3_jjj", (void *)&SC_SetElementAt2_uint3, true }, 1147 { "_Z20rsSetElementAt_uint413rs_allocationPKDv4_jjj", (void *)&SC_SetElementAt2_uint4, true }, 1148 { "_Z19rsSetElementAt_uint13rs_allocationPKjjjj", (void *)&SC_SetElementAt3_uint, true }, 1149 { "_Z20rsSetElementAt_uint213rs_allocationPKDv2_jjjj", (void *)&SC_SetElementAt3_uint2, true }, 1150 { "_Z20rsSetElementAt_uint313rs_allocationPKDv3_jjjj", (void *)&SC_SetElementAt3_uint3, true }, 1151 { "_Z20rsSetElementAt_uint413rs_allocationPKDv4_jjjj", (void *)&SC_SetElementAt3_uint4, true }, 1152 1153 { "_Z18rsSetElementAt_int13rs_allocationPKij", (void *)&SC_SetElementAt1_int, true }, 1154 { "_Z19rsSetElementAt_int213rs_allocationPKDv2_ij", (void *)&SC_SetElementAt1_int2, true }, 1155 { "_Z19rsSetElementAt_int313rs_allocationPKDv3_ij", (void *)&SC_SetElementAt1_int3, true }, 1156 { "_Z19rsSetElementAt_int413rs_allocationPKDv4_ij", (void *)&SC_SetElementAt1_int4, true }, 1157 { "_Z18rsSetElementAt_int13rs_allocationPKijj", (void *)&SC_SetElementAt2_int, true }, 1158 { "_Z19rsSetElementAt_int213rs_allocationPKDv2_ijj", (void *)&SC_SetElementAt2_int2, true }, 1159 { "_Z19rsSetElementAt_int313rs_allocationPKDv3_ijj", (void *)&SC_SetElementAt2_int3, true }, 1160 { "_Z19rsSetElementAt_int413rs_allocationPKDv4_ijj", (void *)&SC_SetElementAt2_int4, true }, 1161 { "_Z18rsSetElementAt_int13rs_allocationPKijjj", (void *)&SC_SetElementAt3_int, true }, 1162 { "_Z19rsSetElementAt_int213rs_allocationPKDv2_ijjj", (void *)&SC_SetElementAt3_int2, true }, 1163 { "_Z19rsSetElementAt_int313rs_allocationPKDv3_ijjj", (void *)&SC_SetElementAt3_int3, true }, 1164 { "_Z19rsSetElementAt_int413rs_allocationPKDv4_ijjj", (void *)&SC_SetElementAt3_int4, true }, 1165 1166 { "_Z20rsSetElementAt_ulong13rs_allocationPKmj", (void *)&SC_SetElementAt1_ulong, true }, 1167 { "_Z21rsSetElementAt_ulong213rs_allocationPKDv2_mj", (void *)&SC_SetElementAt1_ulong2, true }, 1168 { "_Z21rsSetElementAt_ulong313rs_allocationPKDv3_mj", (void *)&SC_SetElementAt1_ulong3, true }, 1169 { "_Z21rsSetElementAt_ulong413rs_allocationPKDv4_mj", (void *)&SC_SetElementAt1_ulong4, true }, 1170 { "_Z20rsSetElementAt_ulong13rs_allocationPKmjj", (void *)&SC_SetElementAt2_ulong, true }, 1171 { "_Z21rsSetElementAt_ulong213rs_allocationPKDv2_mjj", (void *)&SC_SetElementAt2_ulong2, true }, 1172 { "_Z21rsSetElementAt_ulong313rs_allocationPKDv3_mjj", (void *)&SC_SetElementAt2_ulong3, true }, 1173 { "_Z21rsSetElementAt_ulong413rs_allocationPKDv4_mjj", (void *)&SC_SetElementAt2_ulong4, true }, 1174 { "_Z20rsSetElementAt_ulong13rs_allocationPKmjjj", (void *)&SC_SetElementAt3_ulong, true }, 1175 { "_Z21rsSetElementAt_ulong213rs_allocationPKDv2_mjjj", (void *)&SC_SetElementAt3_ulong2, true }, 1176 { "_Z21rsSetElementAt_ulong313rs_allocationPKDv3_mjjj", (void *)&SC_SetElementAt3_ulong3, true }, 1177 { "_Z21rsSetElementAt_ulong413rs_allocationPKDv4_mjjj", (void *)&SC_SetElementAt3_ulong4, true }, 1178 1179 // Pre-21 compatibility path 1180 { "_Z20rsSetElementAt_ulong13rs_allocationPKyj", (void *)&SC_SetElementAt1_ulong, true }, 1181 { "_Z21rsSetElementAt_ulong213rs_allocationPKDv2_yj", (void *)&SC_SetElementAt1_ulong2, true }, 1182 { "_Z21rsSetElementAt_ulong313rs_allocationPKDv3_yj", (void *)&SC_SetElementAt1_ulong3, true }, 1183 { "_Z21rsSetElementAt_ulong413rs_allocationPKDv4_yj", (void *)&SC_SetElementAt1_ulong4, true }, 1184 { "_Z20rsSetElementAt_ulong13rs_allocationPKyjj", (void *)&SC_SetElementAt2_ulong, true }, 1185 { "_Z21rsSetElementAt_ulong213rs_allocationPKDv2_yjj", (void *)&SC_SetElementAt2_ulong2, true }, 1186 { "_Z21rsSetElementAt_ulong313rs_allocationPKDv3_yjj", (void *)&SC_SetElementAt2_ulong3, true }, 1187 { "_Z21rsSetElementAt_ulong413rs_allocationPKDv4_yjj", (void *)&SC_SetElementAt2_ulong4, true }, 1188 { "_Z20rsSetElementAt_ulong13rs_allocationPKyjjj", (void *)&SC_SetElementAt3_ulong, true }, 1189 { "_Z21rsSetElementAt_ulong213rs_allocationPKDv2_yjjj", (void *)&SC_SetElementAt3_ulong2, true }, 1190 { "_Z21rsSetElementAt_ulong313rs_allocationPKDv3_yjjj", (void *)&SC_SetElementAt3_ulong3, true }, 1191 { "_Z21rsSetElementAt_ulong413rs_allocationPKDv4_yjjj", (void *)&SC_SetElementAt3_ulong4, true }, 1192 1193 { "_Z19rsSetElementAt_long13rs_allocationPKlj", (void *)&SC_SetElementAt1_long, true }, 1194 { "_Z20rsSetElementAt_long213rs_allocationPKDv2_lj", (void *)&SC_SetElementAt1_long2, true }, 1195 { "_Z20rsSetElementAt_long313rs_allocationPKDv3_lj", (void *)&SC_SetElementAt1_long3, true }, 1196 { "_Z20rsSetElementAt_long413rs_allocationPKDv4_lj", (void *)&SC_SetElementAt1_long4, true }, 1197 { "_Z19rsSetElementAt_long13rs_allocationPKljj", (void *)&SC_SetElementAt2_long, true }, 1198 { "_Z20rsSetElementAt_long213rs_allocationPKDv2_ljj", (void *)&SC_SetElementAt2_long2, true }, 1199 { "_Z20rsSetElementAt_long313rs_allocationPKDv3_ljj", (void *)&SC_SetElementAt2_long3, true }, 1200 { "_Z20rsSetElementAt_long413rs_allocationPKDv4_ljj", (void *)&SC_SetElementAt2_long4, true }, 1201 { "_Z19rsSetElementAt_long13rs_allocationPKljjj", (void *)&SC_SetElementAt3_long, true }, 1202 { "_Z20rsSetElementAt_long213rs_allocationPKDv2_ljjj", (void *)&SC_SetElementAt3_long2, true }, 1203 { "_Z20rsSetElementAt_long313rs_allocationPKDv3_ljjj", (void *)&SC_SetElementAt3_long3, true }, 1204 { "_Z20rsSetElementAt_long413rs_allocationPKDv4_ljjj", (void *)&SC_SetElementAt3_long4, true }, 1205 1206 // Pre-21 compatibility path 1207 { "_Z19rsSetElementAt_long13rs_allocationPKxj", (void *)&SC_SetElementAt1_long, true }, 1208 { "_Z20rsSetElementAt_long213rs_allocationPKDv2_xj", (void *)&SC_SetElementAt1_long2, true }, 1209 { "_Z20rsSetElementAt_long313rs_allocationPKDv3_xj", (void *)&SC_SetElementAt1_long3, true }, 1210 { "_Z20rsSetElementAt_long413rs_allocationPKDv4_xj", (void *)&SC_SetElementAt1_long4, true }, 1211 { "_Z19rsSetElementAt_long13rs_allocationPKxjj", (void *)&SC_SetElementAt2_long, true }, 1212 { "_Z20rsSetElementAt_long213rs_allocationPKDv2_xjj", (void *)&SC_SetElementAt2_long2, true }, 1213 { "_Z20rsSetElementAt_long313rs_allocationPKDv3_xjj", (void *)&SC_SetElementAt2_long3, true }, 1214 { "_Z20rsSetElementAt_long413rs_allocationPKDv4_xjj", (void *)&SC_SetElementAt2_long4, true }, 1215 { "_Z19rsSetElementAt_long13rs_allocationPKxjjj", (void *)&SC_SetElementAt3_long, true }, 1216 { "_Z20rsSetElementAt_long213rs_allocationPKDv2_xjjj", (void *)&SC_SetElementAt3_long2, true }, 1217 { "_Z20rsSetElementAt_long313rs_allocationPKDv3_xjjj", (void *)&SC_SetElementAt3_long3, true }, 1218 { "_Z20rsSetElementAt_long413rs_allocationPKDv4_xjjj", (void *)&SC_SetElementAt3_long4, true }, 1219 1220 { "_Z20rsSetElementAt_float13rs_allocationPKft", (void *)&SC_SetElementAt1_float, true }, 1221 { "_Z21rsSetElementAt_float213rs_allocationPKDv2_fj", (void *)&SC_SetElementAt1_float2, true }, 1222 { "_Z21rsSetElementAt_float313rs_allocationPKDv3_fj", (void *)&SC_SetElementAt1_float3, true }, 1223 { "_Z21rsSetElementAt_float413rs_allocationPKDv4_fj", (void *)&SC_SetElementAt1_float4, true }, 1224 { "_Z20rsSetElementAt_float13rs_allocationPKfjj", (void *)&SC_SetElementAt2_float, true }, 1225 { "_Z21rsSetElementAt_float213rs_allocationPKDv2_fjj", (void *)&SC_SetElementAt2_float2, true }, 1226 { "_Z21rsSetElementAt_float313rs_allocationPKDv3_fjj", (void *)&SC_SetElementAt2_float3, true }, 1227 { "_Z21rsSetElementAt_float413rs_allocationPKDv4_fjj", (void *)&SC_SetElementAt2_float4, true }, 1228 { "_Z20rsSetElementAt_float13rs_allocationPKfjjj", (void *)&SC_SetElementAt3_float, true }, 1229 { "_Z21rsSetElementAt_float213rs_allocationPKDv2_fjjj", (void *)&SC_SetElementAt3_float2, true }, 1230 { "_Z21rsSetElementAt_float313rs_allocationPKDv3_fjjj", (void *)&SC_SetElementAt3_float3, true }, 1231 { "_Z21rsSetElementAt_float413rs_allocationPKDv4_fjjj", (void *)&SC_SetElementAt3_float4, true }, 1232 1233 { "_Z21rsSetElementAt_double13rs_allocationPKdt", (void *)&SC_SetElementAt1_double, true }, 1234 { "_Z22rsSetElementAt_double213rs_allocationPKDv2_dj", (void *)&SC_SetElementAt1_double2, true }, 1235 { "_Z22rsSetElementAt_double313rs_allocationPKDv3_dj", (void *)&SC_SetElementAt1_double3, true }, 1236 { "_Z22rsSetElementAt_double413rs_allocationPKDv4_dj", (void *)&SC_SetElementAt1_double4, true }, 1237 { "_Z21rsSetElementAt_double13rs_allocationPKdjj", (void *)&SC_SetElementAt2_double, true }, 1238 { "_Z22rsSetElementAt_double213rs_allocationPKDv2_djj", (void *)&SC_SetElementAt2_double2, true }, 1239 { "_Z22rsSetElementAt_double313rs_allocationPKDv3_djj", (void *)&SC_SetElementAt2_double3, true }, 1240 { "_Z22rsSetElementAt_double413rs_allocationPKDv4_djj", (void *)&SC_SetElementAt2_double4, true }, 1241 { "_Z21rsSetElementAt_double13rs_allocationPKdjjj", (void *)&SC_SetElementAt3_double, true }, 1242 { "_Z22rsSetElementAt_double213rs_allocationPKDv2_djjj", (void *)&SC_SetElementAt3_double2, true }, 1243 { "_Z22rsSetElementAt_double313rs_allocationPKDv3_djjj", (void *)&SC_SetElementAt3_double3, true }, 1244 { "_Z22rsSetElementAt_double413rs_allocationPKDv4_djjj", (void *)&SC_SetElementAt3_double4, true }, 1245 1246 1247 // Refcounting 1248#ifndef __LP64__ 1249 { "_Z11rsSetObjectP10rs_elementS_", (void *)&SC_SetObject, true }, 1250 { "_Z10rsIsObject10rs_element", (void *)&SC_IsObject, true }, 1251 1252 { "_Z11rsSetObjectP7rs_typeS_", (void *)&SC_SetObject, true }, 1253 { "_Z10rsIsObject7rs_type", (void *)&SC_IsObject, true }, 1254 1255 { "_Z11rsSetObjectP13rs_allocationS_", (void *)&SC_SetObject, true }, 1256 { "_Z10rsIsObject13rs_allocation", (void *)&SC_IsObject, true }, 1257 1258 { "_Z11rsSetObjectP10rs_samplerS_", (void *)&SC_SetObject, true }, 1259 { "_Z10rsIsObject10rs_sampler", (void *)&SC_IsObject, true }, 1260 1261 { "_Z11rsSetObjectP9rs_scriptS_", (void *)&SC_SetObject, true }, 1262 { "_Z10rsIsObject9rs_script", (void *)&SC_IsObject, true }, 1263#else 1264 { "_Z11rsSetObjectP10rs_elementS_", (void *)&SC_SetObject_ByRef, true }, 1265 { "_Z10rsIsObject10rs_element", (void *)&SC_IsObject_ByRef, true }, 1266 1267 { "_Z11rsSetObjectP7rs_typeS_", (void *)&SC_SetObject_ByRef, true }, 1268 { "_Z10rsIsObject7rs_type", (void *)&SC_IsObject_ByRef, true }, 1269 1270 { "_Z11rsSetObjectP13rs_allocationS_", (void *)&SC_SetObject_ByRef, true }, 1271 { "_Z10rsIsObject13rs_allocation", (void *)&SC_IsObject_ByRef, true }, 1272 1273 { "_Z11rsSetObjectP10rs_samplerS_", (void *)&SC_SetObject_ByRef, true }, 1274 { "_Z10rsIsObject10rs_sampler", (void *)&SC_IsObject_ByRef, true }, 1275 1276 { "_Z11rsSetObjectP9rs_scriptS_", (void *)&SC_SetObject_ByRef, true }, 1277 { "_Z10rsIsObject9rs_script", (void *)&SC_IsObject_ByRef, true }, 1278#endif 1279 { "_Z13rsClearObjectP10rs_element", (void *)&SC_ClearObject, true }, 1280 { "_Z13rsClearObjectP7rs_type", (void *)&SC_ClearObject, true }, 1281 { "_Z13rsClearObjectP13rs_allocation", (void *)&SC_ClearObject, true }, 1282 { "_Z13rsClearObjectP10rs_sampler", (void *)&SC_ClearObject, true }, 1283 { "_Z13rsClearObjectP9rs_script", (void *)&SC_ClearObject, true }, 1284 1285 { "_Z11rsSetObjectP7rs_pathS_", (void *)&SC_SetObject, true }, 1286 { "_Z13rsClearObjectP7rs_path", (void *)&SC_ClearObject, true }, 1287 { "_Z10rsIsObject7rs_path", (void *)&SC_IsObject, true }, 1288 1289 { "_Z11rsSetObjectP7rs_meshS_", (void *)&SC_SetObject, true }, 1290 { "_Z13rsClearObjectP7rs_mesh", (void *)&SC_ClearObject, true }, 1291 { "_Z10rsIsObject7rs_mesh", (void *)&SC_IsObject, true }, 1292 1293 { "_Z11rsSetObjectP19rs_program_fragmentS_", (void *)&SC_SetObject, true }, 1294 { "_Z13rsClearObjectP19rs_program_fragment", (void *)&SC_ClearObject, true }, 1295 { "_Z10rsIsObject19rs_program_fragment", (void *)&SC_IsObject, true }, 1296 1297 { "_Z11rsSetObjectP17rs_program_vertexS_", (void *)&SC_SetObject, true }, 1298 { "_Z13rsClearObjectP17rs_program_vertex", (void *)&SC_ClearObject, true }, 1299 { "_Z10rsIsObject17rs_program_vertex", (void *)&SC_IsObject, true }, 1300 1301 { "_Z11rsSetObjectP17rs_program_rasterS_", (void *)&SC_SetObject, true }, 1302 { "_Z13rsClearObjectP17rs_program_raster", (void *)&SC_ClearObject, true }, 1303 { "_Z10rsIsObject17rs_program_raster", (void *)&SC_IsObject, true }, 1304 1305 { "_Z11rsSetObjectP16rs_program_storeS_", (void *)&SC_SetObject, true }, 1306 { "_Z13rsClearObjectP16rs_program_store", (void *)&SC_ClearObject, true }, 1307 { "_Z10rsIsObject16rs_program_store", (void *)&SC_IsObject, true }, 1308 1309 { "_Z11rsSetObjectP7rs_fontS_", (void *)&SC_SetObject, true }, 1310 { "_Z13rsClearObjectP7rs_font", (void *)&SC_ClearObject, true }, 1311 { "_Z10rsIsObject7rs_font", (void *)&SC_IsObject, true }, 1312 1313 // Allocation ops 1314 { "_Z21rsAllocationMarkDirty13rs_allocation", (void *)&SC_AllocationSyncAll, true }, 1315 { "_Z20rsgAllocationSyncAll13rs_allocation", (void *)&SC_AllocationSyncAll, false }, 1316 { "_Z20rsgAllocationSyncAll13rs_allocationj", (void *)&SC_AllocationSyncAll2, false }, 1317 { "_Z20rsgAllocationSyncAll13rs_allocation24rs_allocation_usage_type", (void *)&SC_AllocationSyncAll2, false }, 1318#ifndef RS_COMPATIBILITY_LIB 1319 { "_Z15rsGetAllocationPKv", (void *)&SC_GetAllocation, true }, 1320 { "_Z18rsAllocationIoSend13rs_allocation", (void *)&SC_AllocationIoSend, false }, 1321 { "_Z21rsAllocationIoReceive13rs_allocation", (void *)&SC_AllocationIoReceive, false }, 1322#endif 1323 { "_Z23rsAllocationCopy1DRange13rs_allocationjjjS_jj", (void *)&SC_AllocationCopy1DRange, false }, 1324 { "_Z23rsAllocationCopy2DRange13rs_allocationjjj26rs_allocation_cubemap_facejjS_jjjS0_", (void *)&SC_AllocationCopy2DRange, false }, 1325 1326 // Messaging 1327 1328 { "_Z14rsSendToClienti", (void *)&SC_ToClient, false }, 1329 { "_Z14rsSendToClientiPKvj", (void *)&SC_ToClient2, false }, 1330 { "_Z22rsSendToClientBlockingi", (void *)&SC_ToClientBlocking, false }, 1331 { "_Z22rsSendToClientBlockingiPKvj", (void *)&SC_ToClientBlocking2, false }, 1332#ifndef RS_COMPATIBILITY_LIB 1333 { "_Z22rsgBindProgramFragment19rs_program_fragment", (void *)&SC_BindProgramFragment, false }, 1334 { "_Z19rsgBindProgramStore16rs_program_store", (void *)&SC_BindProgramStore, false }, 1335 { "_Z20rsgBindProgramVertex17rs_program_vertex", (void *)&SC_BindProgramVertex, false }, 1336 { "_Z20rsgBindProgramRaster17rs_program_raster", (void *)&SC_BindProgramRaster, false }, 1337 { "_Z14rsgBindSampler19rs_program_fragmentj10rs_sampler", (void *)&SC_BindSampler, false }, 1338 { "_Z14rsgBindTexture19rs_program_fragmentj13rs_allocation", (void *)&SC_BindTexture, false }, 1339 { "_Z15rsgBindConstant19rs_program_fragmentj13rs_allocation", (void *)&SC_BindFragmentConstant, false }, 1340 { "_Z15rsgBindConstant17rs_program_vertexj13rs_allocation", (void *)&SC_BindVertexConstant, false }, 1341 1342 { "_Z36rsgProgramVertexLoadProjectionMatrixPK12rs_matrix4x4", (void *)&SC_VpLoadProjectionMatrix, false }, 1343 { "_Z31rsgProgramVertexLoadModelMatrixPK12rs_matrix4x4", (void *)&SC_VpLoadModelMatrix, false }, 1344 { "_Z33rsgProgramVertexLoadTextureMatrixPK12rs_matrix4x4", (void *)&SC_VpLoadTextureMatrix, false }, 1345 1346 { "_Z35rsgProgramVertexGetProjectionMatrixP12rs_matrix4x4", (void *)&SC_VpGetProjectionMatrix, false }, 1347 1348 { "_Z31rsgProgramFragmentConstantColor19rs_program_fragmentffff", (void *)&SC_PfConstantColor, false }, 1349 1350 { "_Z11rsgGetWidthv", (void *)&SC_GetWidth, false }, 1351 { "_Z12rsgGetHeightv", (void *)&SC_GetHeight, false }, 1352 1353 1354 { "_Z11rsgDrawRectfffff", (void *)&SC_DrawRect, false }, 1355 { "_Z11rsgDrawQuadffffffffffff", (void *)&SC_DrawQuad, false }, 1356 { "_Z20rsgDrawQuadTexCoordsffffffffffffffffffff", (void *)&SC_DrawQuadTexCoords, false }, 1357 { "_Z24rsgDrawSpriteScreenspacefffff", (void *)&SC_DrawSpriteScreenspace, false }, 1358 1359 { "_Z11rsgDrawMesh7rs_mesh", (void *)&SC_DrawMesh, false }, 1360 { "_Z11rsgDrawMesh7rs_meshj", (void *)&SC_DrawMeshPrimitive, false }, 1361 { "_Z11rsgDrawMesh7rs_meshjjj", (void *)&SC_DrawMeshPrimitiveRange, false }, 1362 { "_Z25rsgMeshComputeBoundingBox7rs_meshPfS0_S0_S0_S0_S0_", (void *)&SC_MeshComputeBoundingBox, false }, 1363 1364 { "_Z11rsgDrawPath7rs_path", (void *)&SC_DrawPath, false }, 1365 1366 { "_Z13rsgClearColorffff", (void *)&SC_ClearColor, false }, 1367 { "_Z13rsgClearDepthf", (void *)&SC_ClearDepth, false }, 1368 1369 { "_Z11rsgDrawTextPKcii", (void *)&SC_DrawText, false }, 1370 { "_Z11rsgDrawText13rs_allocationii", (void *)&SC_DrawTextAlloc, false }, 1371 { "_Z14rsgMeasureTextPKcPiS1_S1_S1_", (void *)&SC_MeasureText, false }, 1372 { "_Z14rsgMeasureText13rs_allocationPiS0_S0_S0_", (void *)&SC_MeasureTextAlloc, false }, 1373 1374 { "_Z11rsgBindFont7rs_font", (void *)&SC_BindFont, false }, 1375 { "_Z12rsgFontColorffff", (void *)&SC_FontColor, false }, 1376 1377 { "_Z18rsgBindColorTarget13rs_allocationj", (void *)&SC_BindFrameBufferObjectColorTarget, false }, 1378 { "_Z18rsgBindDepthTarget13rs_allocation", (void *)&SC_BindFrameBufferObjectDepthTarget, false }, 1379 { "_Z19rsgClearColorTargetj", (void *)&SC_ClearFrameBufferObjectColorTarget, false }, 1380 { "_Z19rsgClearDepthTargetv", (void *)&SC_ClearFrameBufferObjectDepthTarget, false }, 1381 { "_Z24rsgClearAllRenderTargetsv", (void *)&SC_ClearFrameBufferObjectTargets, false }, 1382 1383 1384 { "_Z9rsForEach9rs_script13rs_allocationS0_", (void *)&SC_ForEach_SAA, true }, 1385 { "_Z9rsForEach9rs_script13rs_allocationS0_PKv", (void *)&SC_ForEach_SAAU, true }, 1386 { "_Z9rsForEach9rs_script13rs_allocationS0_PKvPK14rs_script_call", (void *)&SC_ForEach_SAAUS, true }, 1387 1388 //rsForEach with usrdata is not supported in 64-bit 1389#ifndef __LP64__ 1390 { "_Z9rsForEach9rs_script13rs_allocationS0_PKvj", (void *)&SC_ForEach_SAAUL, true }, 1391 { "_Z9rsForEach9rs_script13rs_allocationS0_PKvjPK14rs_script_call", (void *)&SC_ForEach_SAAULS, true }, 1392#endif 1393#endif // RS_COMPATIBILITY_LIB 1394 1395#ifndef __LP64__ 1396 // time 1397 { "_Z6rsTimePi", (void *)&SC_Time, true }, 1398 { "_Z11rsLocaltimeP5rs_tmPKi", (void *)&SC_LocalTime, true }, 1399#else 1400 // time 1401 { "_Z6rsTimePl", (void *)&SC_Time, true }, 1402 { "_Z11rsLocaltimeP5rs_tmPKl", (void *)&SC_LocalTime, true }, 1403#endif 1404 { "_Z14rsUptimeMillisv", (void*)&SC_UptimeMillis, true }, 1405 { "_Z13rsUptimeNanosv", (void*)&SC_UptimeNanos, true }, 1406 { "_Z7rsGetDtv", (void*)&SC_GetDt, false }, 1407 1408 // misc 1409#ifndef RS_COMPATIBILITY_LIB 1410 { "_Z5colorffff", (void *)&SC_Color, false }, 1411 { "_Z9rsgFinishv", (void *)&SC_Finish, false }, 1412#endif 1413 1414 { nullptr, nullptr, false } 1415}; 1416 1417#ifdef RS_COMPATIBILITY_LIB 1418 1419////////////////////////////////////////////////////////////////////////////// 1420// Compatibility Library entry points 1421////////////////////////////////////////////////////////////////////////////// 1422 1423#define IS_CLEAR_SET_OBJ(t) \ 1424 bool rsIsObject(t src) { \ 1425 return src.p != nullptr; \ 1426 } \ 1427 void __attribute__((overloadable)) rsClearObject(t *dst) { \ 1428 return SC_ClearObject(reinterpret_cast<rs_object_base *>(dst)); \ 1429 } \ 1430 void __attribute__((overloadable)) rsSetObject(t *dst, t src) { \ 1431 return SC_SetObject(reinterpret_cast<rs_object_base *>(dst), (ObjectBase*)src.p); \ 1432 } 1433 1434IS_CLEAR_SET_OBJ(::rs_element) 1435IS_CLEAR_SET_OBJ(::rs_type) 1436IS_CLEAR_SET_OBJ(::rs_allocation) 1437IS_CLEAR_SET_OBJ(::rs_sampler) 1438IS_CLEAR_SET_OBJ(::rs_script) 1439#undef IS_CLEAR_SET_OBJ 1440 1441static void SC_ForEach_SAA(::rs_script target, 1442 ::rs_allocation in, 1443 ::rs_allocation out) { 1444 Context *rsc = RsdCpuReference::getTlsContext(); 1445 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, 1446 nullptr, 0, nullptr); 1447} 1448 1449static void SC_ForEach_SAAUS(::rs_script target, 1450 ::rs_allocation in, 1451 ::rs_allocation out, 1452 const void *usr, 1453 const RsScriptCall *call) { 1454 Context *rsc = RsdCpuReference::getTlsContext(); 1455 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, 1456 usr, 0, call); 1457} 1458 1459static void SC_ForEach_SAAUL(::rs_script target, 1460 ::rs_allocation in, 1461 ::rs_allocation out, 1462 const void *usr, 1463 uint32_t usrLen) { 1464 Context *rsc = RsdCpuReference::getTlsContext(); 1465 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, 1466 usr, usrLen, nullptr); 1467} 1468 1469static void SC_ForEach_SAAULS(::rs_script target, 1470 ::rs_allocation in, 1471 ::rs_allocation out, 1472 const void *usr, 1473 uint32_t usrLen, 1474 const RsScriptCall *call) { 1475 Context *rsc = RsdCpuReference::getTlsContext(); 1476 rsrForEach(rsc, (Script*)target.p, (Allocation*)in.p, (Allocation*)out.p, 1477 usr, usrLen, call); 1478} 1479 1480static const Allocation * SC_GetAllocation(const void *ptr) { 1481 Context *rsc = RsdCpuReference::getTlsContext(); 1482 const Script *sc = RsdCpuReference::getTlsScript(); 1483 return rsdScriptGetAllocationForPointer(rsc, sc, ptr); 1484} 1485 1486const Allocation * rsGetAllocation(const void *ptr) { 1487 return SC_GetAllocation(ptr); 1488} 1489 1490void __attribute__((overloadable)) rsAllocationIoSend(::rs_allocation a) { 1491 SC_AllocationIoSend((Allocation *)a.p); 1492} 1493 1494void __attribute__((overloadable)) rsAllocationIoReceive(::rs_allocation a) { 1495 SC_AllocationIoReceive((Allocation *)a.p); 1496} 1497 1498 1499void __attribute__((overloadable)) rsAllocationCopy1DRange( 1500 ::rs_allocation dstAlloc, 1501 uint32_t dstOff, uint32_t dstMip, uint32_t count, 1502 ::rs_allocation srcAlloc, 1503 uint32_t srcOff, uint32_t srcMip) { 1504 SC_AllocationCopy1DRange(dstAlloc, dstOff, dstMip, count, 1505 srcAlloc, srcOff, srcMip); 1506} 1507 1508void __attribute__((overloadable)) rsAllocationCopy2DRange( 1509 ::rs_allocation dstAlloc, 1510 uint32_t dstXoff, uint32_t dstYoff, 1511 uint32_t dstMip, rs_allocation_cubemap_face dstFace, 1512 uint32_t width, uint32_t height, 1513 ::rs_allocation srcAlloc, 1514 uint32_t srcXoff, uint32_t srcYoff, 1515 uint32_t srcMip, rs_allocation_cubemap_face srcFace) { 1516 SC_AllocationCopy2DRange(dstAlloc, dstXoff, dstYoff, 1517 dstMip, dstFace, width, height, 1518 srcAlloc, srcXoff, srcYoff, 1519 srcMip, srcFace); 1520} 1521 1522void __attribute__((overloadable)) rsForEach(::rs_script script, 1523 ::rs_allocation in, 1524 ::rs_allocation out, 1525 const void *usr, 1526 const rs_script_call *call) { 1527 return SC_ForEach_SAAUS(script, in, out, usr, (RsScriptCall*)call); 1528} 1529 1530void __attribute__((overloadable)) rsForEach(::rs_script script, 1531 ::rs_allocation in, 1532 ::rs_allocation out) { 1533 return SC_ForEach_SAA(script, in, out); 1534} 1535 1536void __attribute__((overloadable)) rsForEach(::rs_script script, 1537 ::rs_allocation in, 1538 ::rs_allocation out, 1539 const void *usr, 1540 uint32_t usrLen) { 1541 return SC_ForEach_SAAUL(script, in, out, usr, usrLen); 1542} 1543 1544void __attribute__((overloadable)) rsForEach(::rs_script script, 1545 ::rs_allocation in, 1546 ::rs_allocation out, 1547 const void *usr, 1548 uint32_t usrLen, 1549 const rs_script_call *call) { 1550 return SC_ForEach_SAAULS(script, in, out, usr, usrLen, (RsScriptCall*)call); 1551} 1552 1553int rsTime(int *timer) { 1554 return SC_Time(timer); 1555} 1556 1557rs_tm* rsLocaltime(rs_tm* local, const int *timer) { 1558 return (rs_tm*)(SC_LocalTime((tm*)local, (long*)timer)); 1559} 1560 1561int64_t rsUptimeMillis() { 1562 Context *rsc = RsdCpuReference::getTlsContext(); 1563 return rsrUptimeMillis(rsc); 1564} 1565 1566int64_t rsUptimeNanos() { 1567 return SC_UptimeNanos(); 1568} 1569 1570float rsGetDt() { 1571 return SC_GetDt(); 1572} 1573 1574uint32_t rsSendToClient(int cmdID) { 1575 return SC_ToClient(cmdID); 1576} 1577 1578uint32_t rsSendToClient(int cmdID, const void *data, uint32_t len) { 1579 return SC_ToClient2(cmdID, data, len); 1580} 1581 1582uint32_t rsSendToClientBlocking(int cmdID) { 1583 return SC_ToClientBlocking(cmdID); 1584} 1585 1586uint32_t rsSendToClientBlocking(int cmdID, const void *data, uint32_t len) { 1587 return SC_ToClientBlocking2(cmdID, data, len); 1588} 1589 1590static void SC_debugF(const char *s, float f) { 1591 ALOGD("%s %f, 0x%08x", s, f, *((int *) (&f))); 1592} 1593static void SC_debugFv2(const char *s, float f1, float f2) { 1594 ALOGD("%s {%f, %f}", s, f1, f2); 1595} 1596static void SC_debugFv3(const char *s, float f1, float f2, float f3) { 1597 ALOGD("%s {%f, %f, %f}", s, f1, f2, f3); 1598} 1599static void SC_debugFv4(const char *s, float f1, float f2, float f3, float f4) { 1600 ALOGD("%s {%f, %f, %f, %f}", s, f1, f2, f3, f4); 1601} 1602static void SC_debugF2(const char *s, float2 f) { 1603 ALOGD("%s {%f, %f}", s, f.x, f.y); 1604} 1605static void SC_debugF3(const char *s, float3 f) { 1606 ALOGD("%s {%f, %f, %f}", s, f.x, f.y, f.z); 1607} 1608static void SC_debugF4(const char *s, float4 f) { 1609 ALOGD("%s {%f, %f, %f, %f}", s, f.x, f.y, f.z, f.w); 1610} 1611static void SC_debugD(const char *s, double d) { 1612 ALOGD("%s %f, 0x%08llx", s, d, *((long long *) (&d))); 1613} 1614static void SC_debugFM4v4(const char *s, const float *f) { 1615 ALOGD("%s {%f, %f, %f, %f", s, f[0], f[4], f[8], f[12]); 1616 ALOGD("%s %f, %f, %f, %f", s, f[1], f[5], f[9], f[13]); 1617 ALOGD("%s %f, %f, %f, %f", s, f[2], f[6], f[10], f[14]); 1618 ALOGD("%s %f, %f, %f, %f}", s, f[3], f[7], f[11], f[15]); 1619} 1620static void SC_debugFM3v3(const char *s, const float *f) { 1621 ALOGD("%s {%f, %f, %f", s, f[0], f[3], f[6]); 1622 ALOGD("%s %f, %f, %f", s, f[1], f[4], f[7]); 1623 ALOGD("%s %f, %f, %f}",s, f[2], f[5], f[8]); 1624} 1625static void SC_debugFM2v2(const char *s, const float *f) { 1626 ALOGD("%s {%f, %f", s, f[0], f[2]); 1627 ALOGD("%s %f, %f}",s, f[1], f[3]); 1628} 1629static void SC_debugI8(const char *s, char c) { 1630 ALOGD("%s %hhd 0x%hhx", s, c, (unsigned char)c); 1631} 1632static void SC_debugC2(const char *s, char2 c) { 1633 ALOGD("%s {%hhd, %hhd} 0x%hhx 0x%hhx", s, c.x, c.y, (unsigned char)c.x, (unsigned char)c.y); 1634} 1635static void SC_debugC3(const char *s, char3 c) { 1636 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); 1637} 1638static void SC_debugC4(const char *s, char4 c) { 1639 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); 1640} 1641static void SC_debugU8(const char *s, unsigned char c) { 1642 ALOGD("%s %hhu 0x%hhx", s, c, c); 1643} 1644static void SC_debugUC2(const char *s, uchar2 c) { 1645 ALOGD("%s {%hhu, %hhu} 0x%hhx 0x%hhx", s, c.x, c.y, c.x, c.y); 1646} 1647static void SC_debugUC3(const char *s, uchar3 c) { 1648 ALOGD("%s {%hhu, %hhu, %hhu} 0x%hhx 0x%hhx 0x%hhx", s, c.x, c.y, c.z, c.x, c.y, c.z); 1649} 1650static void SC_debugUC4(const char *s, uchar4 c) { 1651 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); 1652} 1653static void SC_debugI16(const char *s, short c) { 1654 ALOGD("%s %hd 0x%hx", s, c, c); 1655} 1656static void SC_debugS2(const char *s, short2 c) { 1657 ALOGD("%s {%hd, %hd} 0x%hx 0x%hx", s, c.x, c.y, c.x, c.y); 1658} 1659static void SC_debugS3(const char *s, short3 c) { 1660 ALOGD("%s {%hd, %hd, %hd} 0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.x, c.y, c.z); 1661} 1662static void SC_debugS4(const char *s, short4 c) { 1663 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); 1664} 1665static void SC_debugU16(const char *s, unsigned short c) { 1666 ALOGD("%s %hu 0x%hx", s, c, c); 1667} 1668static void SC_debugUS2(const char *s, ushort2 c) { 1669 ALOGD("%s {%hu, %hu} 0x%hx 0x%hx", s, c.x, c.y, c.x, c.y); 1670} 1671static void SC_debugUS3(const char *s, ushort3 c) { 1672 ALOGD("%s {%hu, %hu, %hu} 0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.x, c.y, c.z); 1673} 1674static void SC_debugUS4(const char *s, ushort4 c) { 1675 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); 1676} 1677static void SC_debugI32(const char *s, int32_t i) { 1678 ALOGD("%s %d 0x%x", s, i, i); 1679} 1680static void SC_debugI2(const char *s, int2 i) { 1681 ALOGD("%s {%d, %d} 0x%x 0x%x", s, i.x, i.y, i.x, i.y); 1682} 1683static void SC_debugI3(const char *s, int3 i) { 1684 ALOGD("%s {%d, %d, %d} 0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.x, i.y, i.z); 1685} 1686static void SC_debugI4(const char *s, int4 i) { 1687 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); 1688} 1689static void SC_debugU32(const char *s, uint32_t i) { 1690 ALOGD("%s %u 0x%x", s, i, i); 1691} 1692static void SC_debugUI2(const char *s, uint2 i) { 1693 ALOGD("%s {%u, %u} 0x%x 0x%x", s, i.x, i.y, i.x, i.y); 1694} 1695static void SC_debugUI3(const char *s, uint3 i) { 1696 ALOGD("%s {%u, %u, %u} 0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.x, i.y, i.z); 1697} 1698static void SC_debugUI4(const char *s, uint4 i) { 1699 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); 1700} 1701static void SC_debugLL64(const char *s, long long ll) { 1702 ALOGD("%s %lld 0x%llx", s, ll, ll); 1703} 1704static void SC_debugL2(const char *s, long2 ll) { 1705 ALOGD("%s {%lld, %lld} 0x%llx 0x%llx", s, ll.x, ll.y, ll.x, ll.y); 1706} 1707static void SC_debugL3(const char *s, long3 ll) { 1708 ALOGD("%s {%lld, %lld, %lld} 0x%llx 0x%llx 0x%llx", s, ll.x, ll.y, ll.z, ll.x, ll.y, ll.z); 1709} 1710static void SC_debugL4(const char *s, long4 ll) { 1711 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); 1712} 1713static void SC_debugULL64(const char *s, unsigned long long ll) { 1714 ALOGD("%s %llu 0x%llx", s, ll, ll); 1715} 1716static void SC_debugUL2(const char *s, ulong2 ll) { 1717 ALOGD("%s {%llu, %llu} 0x%llx 0x%llx", s, ll.x, ll.y, ll.x, ll.y); 1718} 1719static void SC_debugUL3(const char *s, ulong3 ll) { 1720 ALOGD("%s {%llu, %llu, %llu} 0x%llx 0x%llx 0x%llx", s, ll.x, ll.y, ll.z, ll.x, ll.y, ll.z); 1721} 1722static void SC_debugUL4(const char *s, ulong4 ll) { 1723 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); 1724} 1725static void SC_debugP(const char *s, const void *p) { 1726 ALOGD("%s %p", s, p); 1727} 1728 1729// TODO: allocation ops, messaging, time 1730 1731void rsDebug(const char *s, float f) { 1732 SC_debugF(s, f); 1733} 1734 1735void rsDebug(const char *s, float f1, float f2) { 1736 SC_debugFv2(s, f1, f2); 1737} 1738 1739void rsDebug(const char *s, float f1, float f2, float f3) { 1740 SC_debugFv3(s, f1, f2, f3); 1741} 1742 1743void rsDebug(const char *s, float f1, float f2, float f3, float f4) { 1744 SC_debugFv4(s, f1, f2, f3, f4); 1745} 1746 1747void rsDebug(const char *s, const float2 *f) { 1748 SC_debugF2(s, *f); 1749} 1750 1751void rsDebug(const char *s, const float3 *f) { 1752 SC_debugF3(s, *f); 1753} 1754 1755void rsDebug(const char *s, const float4 *f) { 1756 SC_debugF4(s, *f); 1757} 1758 1759void rsDebug(const char *s, double d) { 1760 SC_debugD(s, d); 1761} 1762 1763void rsDebug(const char *s, const rs_matrix4x4 *m) { 1764 SC_debugFM4v4(s, (float *) m); 1765} 1766 1767void rsDebug(const char *s, const rs_matrix3x3 *m) { 1768 SC_debugFM3v3(s, (float *) m); 1769} 1770 1771void rsDebug(const char *s, const rs_matrix2x2 *m) { 1772 SC_debugFM2v2(s, (float *) m); 1773} 1774 1775void rsDebug(const char *s, char c) { 1776 SC_debugI8(s, c); 1777} 1778 1779void rsDebug(const char *s, const char2 *c) { 1780 SC_debugC2(s, *c); 1781} 1782 1783void rsDebug(const char *s, const char3 *c) { 1784 SC_debugC3(s, *c); 1785} 1786 1787void rsDebug(const char *s, const char4 *c) { 1788 SC_debugC4(s, *c); 1789} 1790 1791void rsDebug(const char *s, unsigned char c) { 1792 SC_debugU8(s, c); 1793} 1794 1795void rsDebug(const char *s, const uchar2 *c) { 1796 SC_debugUC2(s, *c); 1797} 1798 1799void rsDebug(const char *s, const uchar3 *c) { 1800 SC_debugUC3(s, *c); 1801} 1802 1803void rsDebug(const char *s, const uchar4 *c) { 1804 SC_debugUC4(s, *c); 1805} 1806 1807void rsDebug(const char *s, short c) { 1808 SC_debugI16(s, c); 1809} 1810 1811void rsDebug(const char *s, const short2 *c) { 1812 SC_debugS2(s, *c); 1813} 1814 1815void rsDebug(const char *s, const short3 *c) { 1816 SC_debugS3(s, *c); 1817} 1818 1819void rsDebug(const char *s, const short4 *c) { 1820 SC_debugS4(s, *c); 1821} 1822 1823void rsDebug(const char *s, unsigned short c) { 1824 SC_debugU16(s, c); 1825} 1826 1827void rsDebug(const char *s, const ushort2 *c) { 1828 SC_debugUS2(s, *c); 1829} 1830 1831void rsDebug(const char *s, const ushort3 *c) { 1832 SC_debugUS3(s, *c); 1833} 1834 1835void rsDebug(const char *s, const ushort4 *c) { 1836 SC_debugUS4(s, *c); 1837} 1838 1839void rsDebug(const char *s, int c) { 1840 SC_debugI32(s, c); 1841} 1842 1843void rsDebug(const char *s, const int2 *c) { 1844 SC_debugI2(s, *c); 1845} 1846 1847void rsDebug(const char *s, const int3 *c) { 1848 SC_debugI3(s, *c); 1849} 1850 1851void rsDebug(const char *s, const int4 *c) { 1852 SC_debugI4(s, *c); 1853} 1854 1855void rsDebug(const char *s, unsigned int c) { 1856 SC_debugU32(s, c); 1857} 1858 1859void rsDebug(const char *s, const uint2 *c) { 1860 SC_debugUI2(s, *c); 1861} 1862 1863void rsDebug(const char *s, const uint3 *c) { 1864 SC_debugUI3(s, *c); 1865} 1866 1867void rsDebug(const char *s, const uint4 *c) { 1868 SC_debugUI4(s, *c); 1869} 1870 1871void rsDebug(const char *s, long c) { 1872 SC_debugLL64(s, c); 1873} 1874 1875void rsDebug(const char *s, long long c) { 1876 SC_debugLL64(s, c); 1877} 1878 1879void rsDebug(const char *s, const long2 *c) { 1880 SC_debugL2(s, *c); 1881} 1882 1883void rsDebug(const char *s, const long3 *c) { 1884 SC_debugL3(s, *c); 1885} 1886 1887void rsDebug(const char *s, const long4 *c) { 1888 SC_debugL4(s, *c); 1889} 1890 1891void rsDebug(const char *s, unsigned long c) { 1892 SC_debugULL64(s, c); 1893} 1894 1895void rsDebug(const char *s, unsigned long long c) { 1896 SC_debugULL64(s, c); 1897} 1898 1899void rsDebug(const char *s, const ulong2 *c) { 1900 SC_debugUL2(s, *c); 1901} 1902 1903void rsDebug(const char *s, const ulong3 *c) { 1904 SC_debugUL3(s, *c); 1905} 1906 1907void rsDebug(const char *s, const ulong4 *c) { 1908 SC_debugUL4(s, *c); 1909} 1910 1911// FIXME: We need to export these function signatures for the compatibility 1912// library. The C++ name mangling that LLVM uses for ext_vector_type requires 1913// different versions for "long" vs. "long long". Note that the called 1914// functions are still using the appropriate 64-bit sizes. 1915typedef long l2 __attribute__((ext_vector_type(2))); 1916typedef long l3 __attribute__((ext_vector_type(3))); 1917typedef long l4 __attribute__((ext_vector_type(4))); 1918typedef unsigned long ul2 __attribute__((ext_vector_type(2))); 1919typedef unsigned long ul3 __attribute__((ext_vector_type(3))); 1920typedef unsigned long ul4 __attribute__((ext_vector_type(4))); 1921 1922void rsDebug(const char *s, const l2 *c) { 1923 SC_debugL2(s, *(const long2 *)c); 1924} 1925 1926void rsDebug(const char *s, const l3 *c) { 1927 SC_debugL3(s, *(const long3 *)c); 1928} 1929 1930void rsDebug(const char *s, const l4 *c) { 1931 SC_debugL4(s, *(const long4 *)c); 1932} 1933 1934void rsDebug(const char *s, const ul2 *c) { 1935 SC_debugUL2(s, *(const ulong2 *)c); 1936} 1937 1938void rsDebug(const char *s, const ul3 *c) { 1939 SC_debugUL3(s, *(const ulong3 *)c); 1940} 1941 1942void rsDebug(const char *s, const ul4 *c) { 1943 SC_debugUL4(s, *(const ulong4 *)c); 1944} 1945 1946void rsDebug(const char *s, const long2 c) { 1947 SC_debugL2(s, c); 1948} 1949 1950void rsDebug(const char *s, const long3 c) { 1951 SC_debugL3(s, c); 1952} 1953 1954void rsDebug(const char *s, const long4 c) { 1955 SC_debugL4(s, c); 1956} 1957 1958void rsDebug(const char *s, const ulong2 c) { 1959 SC_debugUL2(s, c); 1960} 1961 1962void rsDebug(const char *s, const ulong3 c) { 1963 SC_debugUL3(s, c); 1964} 1965 1966void rsDebug(const char *s, const ulong4 c) { 1967 SC_debugUL4(s, c); 1968} 1969 1970 1971void rsDebug(const char *s, const void *p) { 1972 SC_debugP(s, p); 1973} 1974#endif // RS_COMPATIBILITY_LIB 1975 1976extern const RsdCpuReference::CpuSymbol * rsdLookupRuntimeStub(Context * pContext, char const* name) { 1977 ScriptC *s = (ScriptC *)pContext; 1978 const RsdCpuReference::CpuSymbol *syms = gSyms; 1979 const RsdCpuReference::CpuSymbol *sym = nullptr; 1980 1981 if (!sym) { 1982 while (syms->fnPtr) { 1983 if (!strcmp(syms->name, name)) { 1984 return syms; 1985 } 1986 syms++; 1987 } 1988 } 1989 1990 return nullptr; 1991} 1992