+6 -1

cmake/use_ld64.cmake

reviewed

··· 1 1 set(dylib_paths "") 2 2 FUNCTION(use_ld64 target) 3 3 get_property(ld_dylib_paths GLOBAL PROPERTY ld_dylib_paths) 4 4 - message("dylib path is ${ld_dylib_paths}") 5 4 set_property(TARGET ${target} APPEND_STRING PROPERTY 6 5 LINK_FLAGS " -B ${CMAKE_BINARY_DIR}/src/external/cctools-port/cctools/ld64/src/ \ 7 6 -B ${CMAKE_BINARY_DIR}/src/external/cctools-port/cctools/misc/ \ ··· 70 69 function(reexport reexporter reexportee) 71 70 get_property(reexportee_binary_dir TARGET ${reexportee} PROPERTY BINARY_DIR) 72 71 get_property(reexportee_output_name TARGET ${reexportee} PROPERTY OUTPUT_NAME) 72 72 + if(NOT DEFINED reexportee_output_name) 73 73 + get_property(reexportee_output_name TARGET ${reexportee} PROPERTY DYLIB_BUILD_NAME) 74 74 + if(NOT DEFINED reexportee_output_name) 75 75 + message(FATAL_ERROR "failed to get reexportee path") 76 76 + endif(NOT DEFINED reexportee_output_name) 77 77 + endif(NOT DEFINED reexportee_output_name) 73 78 set(reexportee_output "${reexportee_binary_dir}/${reexportee_output_name}") 74 79 get_property(reexportee_install_name TARGET ${reexportee} PROPERTY DYLIB_INSTALL_NAME) 75 80 set_property(TARGET ${reexporter} APPEND_STRING PROPERTY

+3

src/Accelerate/CMakeLists.txt

reviewed

··· 3 3 set(DYLIB_COMPAT_VERSION "1.0.0") 4 4 set(DYLIB_CURRENT_VERSION "4.0.0") 5 5 6 6 + add_subdirectory(vecLib) 7 7 + 6 8 add_framework(Accelerate 7 9 FAT 8 10 CURRENT_VERSION ··· 14 16 DEPENDENCIES 15 17 system 16 18 ) 19 19 + reexport(Accelerate vecLib)

+25

src/Accelerate/vecLib/CMakeLists.txt

reviewed

··· 1 1 + project(vecLib) 2 2 + 3 3 + # TODO: Move to /src/CMakeLists.txt when done 4 4 + include_directories(${CMAKE_CURRENT_SOURCE_DIR}/vMisc/include) 5 5 + 6 6 + add_subdirectory(vMisc) 7 7 + 8 8 + set(DYLIB_COMPAT_VERSION "1.0.0") 9 9 + set(DYLIB_CURRENT_VERSION "671.250.4") 10 10 + 11 11 + add_framework(vecLib 12 12 + FAT 13 13 + CURRENT_VERSION 14 14 + VERSION "A" 15 15 + PARENT "Accelerate" 16 16 + 17 17 + SOURCES 18 18 + empty.c 19 19 + 20 20 + DEPENDENCIES 21 21 + system 22 22 + ) 23 23 + reexport(vecLib vMisc) 24 24 + 25 25 + InstallSymlink(Accelerate.framework/Versions/A/Frameworks/vecLib.framework ${CMAKE_INSTALL_PREFIX}/libexec/darling/System/Library/Frameworks/vecLib.framework)

src/Accelerate/vecLib/empty.c

reviewed

This is a binary file and will not be displayed.

+18

src/Accelerate/vecLib/vMisc/CMakeLists.txt

reviewed

··· 1 1 + project(libvMisc) 2 2 + 3 3 + set(DYLIB_INSTALL_NAME "/System/Library/Frameworks/Accelerate.framework/Versions/A/Frameworks/vecLib.framework/Versions/A/libvMisc.dylib") 4 4 + set(DYLIB_COMPAT_VERSION "1.0.0") 5 5 + set(DYLIB_CURRENT_VERSION "671.250.4") 6 6 + 7 7 + add_darling_library(vMisc SHARED 8 8 + src/libvMisc.c 9 9 + ) 10 10 + set_property(TARGET vMisc PROPERTY DYLIB_INSTALL_NAME ${DYLIB_INSTALL_NAME}) 11 11 + set_property(TARGET vMisc PROPERTY DYLIB_BUILD_NAME libvMisc.dylib) 12 12 + make_fat(vMisc) 13 13 + target_link_libraries(vMisc system) 14 14 + install(TARGETS vMisc DESTINATION libexec/darling/System/Library/Frameworks/Accelerate.framework/Versions/A/Frameworks/vecLib.framework/Versions/A) 15 15 + InstallSymlink( 16 16 + Versions/A/libvMisc.dylib 17 17 + ${CMAKE_INSTALL_PREFIX}/libexec/darling/System/Library/Frameworks/Accelerate.framework/Versions/A/Frameworks/vecLib.framework/libvMisc.dylib 18 18 + )

+617

src/Accelerate/vecLib/vMisc/include/libvMisc/libvMisc.h

reviewed

··· 1 1 + /* 2 2 + This file is part of Darling. 3 3 + 4 4 + Copyright (C) 2019 Lubos Dolezel 5 5 + 6 6 + Darling is free software: you can redistribute it and/or modify 7 7 + it under the terms of the GNU General Public License as published by 8 8 + the Free Software Foundation, either version 3 of the License, or 9 9 + (at your option) any later version. 10 10 + 11 11 + Darling is distributed in the hope that it will be useful, 12 12 + but WITHOUT ANY WARRANTY; without even the implied warranty of 13 13 + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 14 + GNU General Public License for more details. 15 15 + 16 16 + You should have received a copy of the GNU General Public License 17 17 + along with Darling. If not, see <http://www.gnu.org/licenses/>. 18 18 + */ 19 19 + 20 20 + 21 21 + #ifndef _libvMisc_H_ 22 22 + #define _libvMisc_H_ 23 23 + 24 24 + void* VVACOS(void); 25 25 + void* VVACOSF(void); 26 26 + void* VVACOSF_(void); 27 27 + void* VVACOSH(void); 28 28 + void* VVACOSHF(void); 29 29 + void* VVACOSHF_(void); 30 30 + void* VVACOSH_(void); 31 31 + void* VVACOS_(void); 32 32 + void* VVASIN(void); 33 33 + void* VVASINF(void); 34 34 + void* VVASINF_(void); 35 35 + void* VVASINH(void); 36 36 + void* VVASINHF(void); 37 37 + void* VVASINHF_(void); 38 38 + void* VVASINH_(void); 39 39 + void* VVASIN_(void); 40 40 + void* VVATAN(void); 41 41 + void* VVATAN2(void); 42 42 + void* VVATAN2F(void); 43 43 + void* VVATAN2F_(void); 44 44 + void* VVATAN2_(void); 45 45 + void* VVATANF(void); 46 46 + void* VVATANF_(void); 47 47 + void* VVATANH(void); 48 48 + void* VVATANHF(void); 49 49 + void* VVATANHF_(void); 50 50 + void* VVATANH_(void); 51 51 + void* VVATAN_(void); 52 52 + void* VVCBRT(void); 53 53 + void* VVCBRTF(void); 54 54 + void* VVCBRTF_(void); 55 55 + void* VVCBRT_(void); 56 56 + void* VVCEIL(void); 57 57 + void* VVCEILF(void); 58 58 + void* VVCEILF_(void); 59 59 + void* VVCEIL_(void); 60 60 + void* VVCOPYSIGN(void); 61 61 + void* VVCOPYSIGNF(void); 62 62 + void* VVCOPYSIGNF_(void); 63 63 + void* VVCOPYSIGN_(void); 64 64 + void* VVCOS(void); 65 65 + void* VVCOSF(void); 66 66 + void* VVCOSF_(void); 67 67 + void* VVCOSH(void); 68 68 + void* VVCOSHF(void); 69 69 + void* VVCOSHF_(void); 70 70 + void* VVCOSH_(void); 71 71 + void* VVCOSISIN(void); 72 72 + void* VVCOSISINF(void); 73 73 + void* VVCOSISINF_(void); 74 74 + void* VVCOSISIN_(void); 75 75 + void* VVCOSPI(void); 76 76 + void* VVCOSPIF(void); 77 77 + void* VVCOSPIF_(void); 78 78 + void* VVCOSPI_(void); 79 79 + void* VVCOS_(void); 80 80 + void* VVDIV(void); 81 81 + void* VVDIVF(void); 82 82 + void* VVDIVF_(void); 83 83 + void* VVDIV_(void); 84 84 + void* VVEXP(void); 85 85 + void* VVEXP2(void); 86 86 + void* VVEXP2F(void); 87 87 + void* VVEXP2F_(void); 88 88 + void* VVEXP2_(void); 89 89 + void* VVEXPF(void); 90 90 + void* VVEXPF_(void); 91 91 + void* VVEXPM1(void); 92 92 + void* VVEXPM1F(void); 93 93 + void* VVEXPM1F_(void); 94 94 + void* VVEXPM1_(void); 95 95 + void* VVEXP_(void); 96 96 + void* VVFABF(void); 97 97 + void* VVFABF_(void); 98 98 + void* VVFABS(void); 99 99 + void* VVFABSF(void); 100 100 + void* VVFABSF_(void); 101 101 + void* VVFABS_(void); 102 102 + void* VVFLOOR(void); 103 103 + void* VVFLOORF(void); 104 104 + void* VVFLOORF_(void); 105 105 + void* VVFLOOR_(void); 106 106 + void* VVFMOD(void); 107 107 + void* VVFMODF(void); 108 108 + void* VVFMODF_(void); 109 109 + void* VVFMOD_(void); 110 110 + void* VVINT(void); 111 111 + void* VVINTF(void); 112 112 + void* VVINTF_(void); 113 113 + void* VVINT_(void); 114 114 + void* VVLOG(void); 115 115 + void* VVLOG10(void); 116 116 + void* VVLOG10F(void); 117 117 + void* VVLOG10F_(void); 118 118 + void* VVLOG10_(void); 119 119 + void* VVLOG1P(void); 120 120 + void* VVLOG1PF(void); 121 121 + void* VVLOG1PF_(void); 122 122 + void* VVLOG1P_(void); 123 123 + void* VVLOG2(void); 124 124 + void* VVLOG2F(void); 125 125 + void* VVLOG2F_(void); 126 126 + void* VVLOG2_(void); 127 127 + void* VVLOGB(void); 128 128 + void* VVLOGBF(void); 129 129 + void* VVLOGBF_(void); 130 130 + void* VVLOGB_(void); 131 131 + void* VVLOGF(void); 132 132 + void* VVLOGF_(void); 133 133 + void* VVLOG_(void); 134 134 + void* VVNEXTAFTER(void); 135 135 + void* VVNEXTAFTERF(void); 136 136 + void* VVNEXTAFTERF_(void); 137 137 + void* VVNEXTAFTER_(void); 138 138 + void* VVNINT(void); 139 139 + void* VVNINTF(void); 140 140 + void* VVNINTF_(void); 141 141 + void* VVNINT_(void); 142 142 + void* VVPOW(void); 143 143 + void* VVPOWF(void); 144 144 + void* VVPOWF_(void); 145 145 + void* VVPOWS(void); 146 146 + void* VVPOWSF(void); 147 147 + void* VVPOWSF_(void); 148 148 + void* VVPOWS_(void); 149 149 + void* VVPOW_(void); 150 150 + void* VVREC(void); 151 151 + void* VVRECF(void); 152 152 + void* VVRECF_(void); 153 153 + void* VVREC_(void); 154 154 + void* VVREMAINDER(void); 155 155 + void* VVREMAINDERF(void); 156 156 + void* VVREMAINDERF_(void); 157 157 + void* VVREMAINDER_(void); 158 158 + void* VVRSQRT(void); 159 159 + void* VVRSQRTF(void); 160 160 + void* VVRSQRTF_(void); 161 161 + void* VVRSQRT_(void); 162 162 + void* VVSIN(void); 163 163 + void* VVSINCOS(void); 164 164 + void* VVSINCOSF(void); 165 165 + void* VVSINCOSF_(void); 166 166 + void* VVSINCOS_(void); 167 167 + void* VVSINF(void); 168 168 + void* VVSINF_(void); 169 169 + void* VVSINH(void); 170 170 + void* VVSINHF(void); 171 171 + void* VVSINHF_(void); 172 172 + void* VVSINH_(void); 173 173 + void* VVSINPI(void); 174 174 + void* VVSINPIF(void); 175 175 + void* VVSINPIF_(void); 176 176 + void* VVSINPI_(void); 177 177 + void* VVSIN_(void); 178 178 + void* VVSQRT(void); 179 179 + void* VVSQRTF(void); 180 180 + void* VVSQRTF_(void); 181 181 + void* VVSQRT_(void); 182 182 + void* VVTAN(void); 183 183 + void* VVTANF(void); 184 184 + void* VVTANF_(void); 185 185 + void* VVTANH(void); 186 186 + void* VVTANHF(void); 187 187 + void* VVTANHF_(void); 188 188 + void* VVTANH_(void); 189 189 + void* VVTANPI(void); 190 190 + void* VVTANPIF(void); 191 191 + void* VVTANPIF_(void); 192 192 + void* VVTANPI_(void); 193 193 + void* VVTAN_(void); 194 194 + void* __cblas_isamax(void); 195 195 + void* __cblas_sasum(void); 196 196 + void* __cblas_saxpy(void); 197 197 + void* __cblas_sgemm(void); 198 198 + void* __cblas_sgemv(void); 199 199 + void* __cblas_srot(void); 200 200 + void* __cblas_sscal(void); 201 201 + void* __cblas_sswap(void); 202 202 + void* dMultMatMat_16x16(void); 203 203 + void* dMultMatMat_32x32(void); 204 204 + void* dMultMatMat_4x4(void); 205 205 + void* dMultMatMat_8x8(void); 206 206 + void* dMultMatVec_16x16(void); 207 207 + void* dMultMatVec_32x32(void); 208 208 + void* dMultMatVec_4x4(void); 209 209 + void* dMultMatVec_8x8(void); 210 210 + void* dMultVecMat_16x16(void); 211 211 + void* dMultVecMat_32x32(void); 212 212 + void* dMultVecMat_4x4(void); 213 213 + void* dMultVecMat_8x8(void); 214 214 + void* sMultMatMat_16x16(void); 215 215 + void* sMultMatMat_32x32(void); 216 216 + void* sMultMatMat_4x4(void); 217 217 + void* sMultMatMat_8x8(void); 218 218 + void* sMultMatVec_16x16(void); 219 219 + void* sMultMatVec_32x32(void); 220 220 + void* sMultMatVec_4x4(void); 221 221 + void* sMultMatVec_8x8(void); 222 222 + void* sMultVecMat_16x16(void); 223 223 + void* sMultVecMat_32x32(void); 224 224 + void* sMultVecMat_4x4(void); 225 225 + void* sMultVecMat_8x8(void); 226 226 + void* vA1024Shift(void); 227 227 + void* vA128Shift(void); 228 228 + void* vA256Shift(void); 229 229 + void* vA512Shift(void); 230 230 + void* vA64Shift(void); 231 231 + void* vA64Shift2(void); 232 232 + void* vIsamax(void); 233 233 + void* vIsamin(void); 234 234 + void* vIsmax(void); 235 235 + void* vIsmin(void); 236 236 + void* vL1024Rotate(void); 237 237 + void* vL128Rotate(void); 238 238 + void* vL256Rotate(void); 239 239 + void* vL512Rotate(void); 240 240 + void* vL64Rotate(void); 241 241 + void* vL64Rotate2(void); 242 242 + void* vLL1024Shift(void); 243 243 + void* vLL128Shift(void); 244 244 + void* vLL256Shift(void); 245 245 + void* vLL512Shift(void); 246 246 + void* vLL64Shift(void); 247 247 + void* vLL64Shift2(void); 248 248 + void* vLR1024Shift(void); 249 249 + void* vLR128Shift(void); 250 250 + void* vLR256Shift(void); 251 251 + void* vLR512Shift(void); 252 252 + void* vLR64Shift(void); 253 253 + void* vLR64Shift2(void); 254 254 + void* vMultMatMat_16x16(void); 255 255 + void* vMultMatMat_32x32(void); 256 256 + void* vMultMatMat_4x4(void); 257 257 + void* vMultMatMat_8x8(void); 258 258 + void* vMultMatVec_16x16(void); 259 259 + void* vMultMatVec_32x32(void); 260 260 + void* vMultMatVec_4x4(void); 261 261 + void* vMultMatVec_8x8(void); 262 262 + void* vMultVecMat_16x16(void); 263 263 + void* vMultVecMat_32x32(void); 264 264 + void* vMultVecMat_4x4(void); 265 265 + void* vMultVecMat_8x8(void); 266 266 + void* vR1024Rotate(void); 267 267 + void* vR128Rotate(void); 268 268 + void* vR256Rotate(void); 269 269 + void* vR512Rotate(void); 270 270 + void* vR64Rotate(void); 271 271 + void* vR64Rotate2(void); 272 272 + void* vS1024Add(void); 273 273 + void* vS1024AddS(void); 274 274 + void* vS1024Divide(void); 275 275 + void* vS1024HalfMultiply(void); 276 276 + void* vS1024Mod(void); 277 277 + void* vS1024Neg(void); 278 278 + void* vS1024Sub(void); 279 279 + void* vS1024SubS(void); 280 280 + void* vS128Add(void); 281 281 + void* vS128AddS(void); 282 282 + void* vS128Divide(void); 283 283 + void* vS128FullMultiply(void); 284 284 + void* vS128HalfMultiply(void); 285 285 + void* vS128Neg(void); 286 286 + void* vS128Sub(void); 287 287 + void* vS128SubS(void); 288 288 + void* vS16Divide(void); 289 289 + void* vS16HalfMultiply(void); 290 290 + void* vS256Add(void); 291 291 + void* vS256AddS(void); 292 292 + void* vS256Divide(void); 293 293 + void* vS256FullMultiply(void); 294 294 + void* vS256HalfMultiply(void); 295 295 + void* vS256Mod(void); 296 296 + void* vS256Neg(void); 297 297 + void* vS256Sub(void); 298 298 + void* vS256SubS(void); 299 299 + void* vS32Divide(void); 300 300 + void* vS32FullMulEven(void); 301 301 + void* vS32FullMulOdd(void); 302 302 + void* vS32HalfMultiply(void); 303 303 + void* vS512Add(void); 304 304 + void* vS512AddS(void); 305 305 + void* vS512Divide(void); 306 306 + void* vS512FullMultiply(void); 307 307 + void* vS512HalfMultiply(void); 308 308 + void* vS512Mod(void); 309 309 + void* vS512Neg(void); 310 310 + void* vS512Sub(void); 311 311 + void* vS512SubS(void); 312 312 + void* vS64Add(void); 313 313 + void* vS64AddS(void); 314 314 + void* vS64Divide(void); 315 315 + void* vS64FullMulEven(void); 316 316 + void* vS64FullMulOdd(void); 317 317 + void* vS64HalfMultiply(void); 318 318 + void* vS64Neg(void); 319 319 + void* vS64Sub(void); 320 320 + void* vS64SubS(void); 321 321 + void* vS8Divide(void); 322 322 + void* vS8HalfMultiply(void); 323 323 + void* vSasum(void); 324 324 + void* vSaxpy(void); 325 325 + void* vScopy(void); 326 326 + void* vSdot(void); 327 327 + void* vSgeadd(void); 328 328 + void* vSgemm(void); 329 329 + void* vSgemtx(void); 330 330 + void* vSgemul(void); 331 331 + void* vSgemv(void); 332 332 + void* vSgemx(void); 333 333 + void* vSgesub(void); 334 334 + void* vSgetmi(void); 335 335 + void* vSgetmo(void); 336 336 + void* vSgevv(void); 337 337 + void* vSnaxpy(void); 338 338 + void* vSndot(void); 339 339 + void* vSnorm2(void); 340 340 + void* vSnrm2(void); 341 341 + void* vSrot(void); 342 342 + void* vSscal(void); 343 343 + void* vSsum(void); 344 344 + void* vSswap(void); 345 345 + void* vSyax(void); 346 346 + void* vSzaxpy(void); 347 347 + void* vU1024Add(void); 348 348 + void* vU1024AddS(void); 349 349 + void* vU1024Divide(void); 350 350 + void* vU1024HalfMultiply(void); 351 351 + void* vU1024Mod(void); 352 352 + void* vU1024Neg(void); 353 353 + void* vU1024Sub(void); 354 354 + void* vU1024SubS(void); 355 355 + void* vU128Add(void); 356 356 + void* vU128AddS(void); 357 357 + void* vU128Divide(void); 358 358 + void* vU128FullMultiply(void); 359 359 + void* vU128HalfMultiply(void); 360 360 + void* vU128Neg(void); 361 361 + void* vU128Sub(void); 362 362 + void* vU128SubS(void); 363 363 + void* vU16Divide(void); 364 364 + void* vU16HalfMultiply(void); 365 365 + void* vU256Add(void); 366 366 + void* vU256AddS(void); 367 367 + void* vU256Divide(void); 368 368 + void* vU256FullMultiply(void); 369 369 + void* vU256HalfMultiply(void); 370 370 + void* vU256Mod(void); 371 371 + void* vU256Neg(void); 372 372 + void* vU256Sub(void); 373 373 + void* vU256SubS(void); 374 374 + void* vU32Divide(void); 375 375 + void* vU32FullMulEven(void); 376 376 + void* vU32FullMulOdd(void); 377 377 + void* vU32HalfMultiply(void); 378 378 + void* vU512Add(void); 379 379 + void* vU512AddS(void); 380 380 + void* vU512Divide(void); 381 381 + void* vU512FullMultiply(void); 382 382 + void* vU512HalfMultiply(void); 383 383 + void* vU512Mod(void); 384 384 + void* vU512Neg(void); 385 385 + void* vU512Sub(void); 386 386 + void* vU512SubS(void); 387 387 + void* vU64Add(void); 388 388 + void* vU64AddS(void); 389 389 + void* vU64Divide(void); 390 390 + void* vU64FullMulEven(void); 391 391 + void* vU64FullMulOdd(void); 392 392 + void* vU64HalfMultiply(void); 393 393 + void* vU64Neg(void); 394 394 + void* vU64Sub(void); 395 395 + void* vU64SubS(void); 396 396 + void* vU8Divide(void); 397 397 + void* vU8HalfMultiply(void); 398 398 + void* vacosf(void); 399 399 + void* vacoshf(void); 400 400 + void* vasinf(void); 401 401 + void* vasinhf(void); 402 402 + void* vatan2f(void); 403 403 + void* vatanf(void); 404 404 + void* vatanhf(void); 405 405 + void* vceilf(void); 406 406 + void* vclassifyf(void); 407 407 + void* vcopysignf(void); 408 408 + void* vcosf(void); 409 409 + void* vcoshf(void); 410 410 + void* vcospif(void); 411 411 + void* vdivf(void); 412 412 + void* vec_sdot(void); 413 413 + void* vexp2f(void); 414 414 + void* vexpf(void); 415 415 + void* vexpm1f(void); 416 416 + void* vfabf(void); 417 417 + void* vfabsf(void); 418 418 + void* vfloorf(void); 419 419 + void* vfmodf(void); 420 420 + void* vintf(void); 421 421 + void* vipowf(void); 422 422 + void* vlog10f(void); 423 423 + void* vlog1pf(void); 424 424 + void* vlog2f(void); 425 425 + void* vlogbf(void); 426 426 + void* vlogf(void); 427 427 + void* vnextafterf(void); 428 428 + void* vnintf(void); 429 429 + void* vpowf(void); 430 430 + void* vrecf(void); 431 431 + void* vremainderf(void); 432 432 + void* vremquof(void); 433 433 + void* vrsqrtf(void); 434 434 + void* vscalbf(void); 435 435 + void* vsignbitf(void); 436 436 + void* vsincosf(void); 437 437 + void* vsinf(void); 438 438 + void* vsinhf(void); 439 439 + void* vsinpif(void); 440 440 + void* vsqrtf(void); 441 441 + void* vtablelookup(void); 442 442 + void* vtanf(void); 443 443 + void* vtanhf(void); 444 444 + void* vtanpif(void); 445 445 + void* vtruncf(void); 446 446 + void* vvacos(void); 447 447 + void* vvacos_(void); 448 448 + void* vvacosf(void); 449 449 + void* vvacosf_(void); 450 450 + void* vvacosh(void); 451 451 + void* vvacosh_(void); 452 452 + void* vvacoshf(void); 453 453 + void* vvacoshf_(void); 454 454 + void* vvasin(void); 455 455 + void* vvasin_(void); 456 456 + void* vvasinf(void); 457 457 + void* vvasinf_(void); 458 458 + void* vvasinh(void); 459 459 + void* vvasinh_(void); 460 460 + void* vvasinhf(void); 461 461 + void* vvasinhf_(void); 462 462 + void* vvatan(void); 463 463 + void* vvatan2(void); 464 464 + void* vvatan2_(void); 465 465 + void* vvatan2f(void); 466 466 + void* vvatan2f_(void); 467 467 + void* vvatan_(void); 468 468 + void* vvatanf(void); 469 469 + void* vvatanf_(void); 470 470 + void* vvatanh(void); 471 471 + void* vvatanh_(void); 472 472 + void* vvatanhf(void); 473 473 + void* vvatanhf_(void); 474 474 + void* vvcbrt(void); 475 475 + void* vvcbrt_(void); 476 476 + void* vvcbrtf(void); 477 477 + void* vvcbrtf_(void); 478 478 + void* vvceil(void); 479 479 + void* vvceil_(void); 480 480 + void* vvceilf(void); 481 481 + void* vvceilf_(void); 482 482 + void* vvcopysign(void); 483 483 + void* vvcopysign_(void); 484 484 + void* vvcopysignf(void); 485 485 + void* vvcopysignf_(void); 486 486 + void* vvcos(void); 487 487 + void* vvcos_(void); 488 488 + void* vvcosf(void); 489 489 + void* vvcosf_(void); 490 490 + void* vvcosh(void); 491 491 + void* vvcosh_(void); 492 492 + void* vvcoshf(void); 493 493 + void* vvcoshf_(void); 494 494 + void* vvcosisin(void); 495 495 + void* vvcosisin_(void); 496 496 + void* vvcosisinf(void); 497 497 + void* vvcosisinf_(void); 498 498 + void* vvcospi(void); 499 499 + void* vvcospi_(void); 500 500 + void* vvcospif(void); 501 501 + void* vvcospif_(void); 502 502 + void* vvdiv(void); 503 503 + void* vvdiv_(void); 504 504 + void* vvdivf(void); 505 505 + void* vvdivf_(void); 506 506 + void* vvexp(void); 507 507 + void* vvexp2(void); 508 508 + void* vvexp2_(void); 509 509 + void* vvexp2f(void); 510 510 + void* vvexp2f_(void); 511 511 + void* vvexp_(void); 512 512 + void* vvexpf(void); 513 513 + void* vvexpf_(void); 514 514 + void* vvexpm1(void); 515 515 + void* vvexpm1_(void); 516 516 + void* vvexpm1f(void); 517 517 + void* vvexpm1f_(void); 518 518 + void* vvfabf(void); 519 519 + void* vvfabf_(void); 520 520 + void* vvfabs(void); 521 521 + void* vvfabs_(void); 522 522 + void* vvfabsf(void); 523 523 + void* vvfabsf_(void); 524 524 + void* vvfloor(void); 525 525 + void* vvfloor_(void); 526 526 + void* vvfloorf(void); 527 527 + void* vvfloorf_(void); 528 528 + void* vvfmod(void); 529 529 + void* vvfmod_(void); 530 530 + void* vvfmodf(void); 531 531 + void* vvfmodf_(void); 532 532 + void* vvint(void); 533 533 + void* vvint_(void); 534 534 + void* vvintf(void); 535 535 + void* vvintf_(void); 536 536 + void* vvlog(void); 537 537 + void* vvlog10(void); 538 538 + void* vvlog10_(void); 539 539 + void* vvlog10f(void); 540 540 + void* vvlog10f_(void); 541 541 + void* vvlog1p(void); 542 542 + void* vvlog1p_(void); 543 543 + void* vvlog1pf(void); 544 544 + void* vvlog1pf_(void); 545 545 + void* vvlog2(void); 546 546 + void* vvlog2_(void); 547 547 + void* vvlog2f(void); 548 548 + void* vvlog2f_(void); 549 549 + void* vvlog_(void); 550 550 + void* vvlogb(void); 551 551 + void* vvlogb_(void); 552 552 + void* vvlogbf(void); 553 553 + void* vvlogbf_(void); 554 554 + void* vvlogf(void); 555 555 + void* vvlogf_(void); 556 556 + void* vvnextafter(void); 557 557 + void* vvnextafter_(void); 558 558 + void* vvnextafterf(void); 559 559 + void* vvnextafterf_(void); 560 560 + void* vvnint(void); 561 561 + void* vvnint_(void); 562 562 + void* vvnintf(void); 563 563 + void* vvnintf_(void); 564 564 + void* vvpow(void); 565 565 + void* vvpow_(void); 566 566 + void* vvpowf(void); 567 567 + void* vvpowf_(void); 568 568 + void* vvpows(void); 569 569 + void* vvpows_(void); 570 570 + void* vvpowsf(void); 571 571 + void* vvpowsf_(void); 572 572 + void* vvrec(void); 573 573 + void* vvrec_(void); 574 574 + void* vvrecf(void); 575 575 + void* vvrecf_(void); 576 576 + void* vvremainder(void); 577 577 + void* vvremainder_(void); 578 578 + void* vvremainderf(void); 579 579 + void* vvremainderf_(void); 580 580 + void* vvrsqrt(void); 581 581 + void* vvrsqrt_(void); 582 582 + void* vvrsqrtf(void); 583 583 + void* vvrsqrtf_(void); 584 584 + void* vvsin(void); 585 585 + void* vvsin_(void); 586 586 + void* vvsincos(void); 587 587 + void* vvsincos_(void); 588 588 + void* vvsincosf(void); 589 589 + void* vvsincosf_(void); 590 590 + void* vvsinf(void); 591 591 + void* vvsinf_(void); 592 592 + void* vvsinh(void); 593 593 + void* vvsinh_(void); 594 594 + void* vvsinhf(void); 595 595 + void* vvsinhf_(void); 596 596 + void* vvsinpi(void); 597 597 + void* vvsinpi_(void); 598 598 + void* vvsinpif(void); 599 599 + void* vvsinpif_(void); 600 600 + void* vvsqrt(void); 601 601 + void* vvsqrt_(void); 602 602 + void* vvsqrtf(void); 603 603 + void* vvsqrtf_(void); 604 604 + void* vvtan(void); 605 605 + void* vvtan_(void); 606 606 + void* vvtanf(void); 607 607 + void* vvtanf_(void); 608 608 + void* vvtanh(void); 609 609 + void* vvtanh_(void); 610 610 + void* vvtanhf(void); 611 611 + void* vvtanhf_(void); 612 612 + void* vvtanpi(void); 613 613 + void* vvtanpi_(void); 614 614 + void* vvtanpif(void); 615 615 + void* vvtanpif_(void); 616 616 + 617 617 + #endif

+3582

src/Accelerate/vecLib/vMisc/src/libvMisc.c

reviewed

··· 1 1 + /* 2 2 + This file is part of Darling. 3 3 + 4 4 + Copyright (C) 2019 Lubos Dolezel 5 5 + 6 6 + Darling is free software: you can redistribute it and/or modify 7 7 + it under the terms of the GNU General Public License as published by 8 8 + the Free Software Foundation, either version 3 of the License, or 9 9 + (at your option) any later version. 10 10 + 11 11 + Darling is distributed in the hope that it will be useful, 12 12 + but WITHOUT ANY WARRANTY; without even the implied warranty of 13 13 + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 14 + GNU General Public License for more details. 15 15 + 16 16 + You should have received a copy of the GNU General Public License 17 17 + along with Darling. If not, see <http://www.gnu.org/licenses/>. 18 18 + */ 19 19 + 20 20 + 21 21 + #include <libvMisc/libvMisc.h> 22 22 + #include <stdlib.h> 23 23 + #include <stdio.h> 24 24 + 25 25 + static int verbose = 0; 26 26 + 27 27 + __attribute__((constructor)) 28 28 + static void initme(void) { 29 29 + verbose = getenv("STUB_VERBOSE") != NULL; 30 30 + } 31 31 + 32 32 + void* VVACOS(void) 33 33 + { 34 34 + if (verbose) puts("STUB: VVACOS called"); 35 35 + return NULL; 36 36 + } 37 37 + 38 38 + void* VVACOSF(void) 39 39 + { 40 40 + if (verbose) puts("STUB: VVACOSF called"); 41 41 + return NULL; 42 42 + } 43 43 + 44 44 + void* VVACOSF_(void) 45 45 + { 46 46 + if (verbose) puts("STUB: VVACOSF_ called"); 47 47 + return NULL; 48 48 + } 49 49 + 50 50 + void* VVACOSH(void) 51 51 + { 52 52 + if (verbose) puts("STUB: VVACOSH called"); 53 53 + return NULL; 54 54 + } 55 55 + 56 56 + void* VVACOSHF(void) 57 57 + { 58 58 + if (verbose) puts("STUB: VVACOSHF called"); 59 59 + return NULL; 60 60 + } 61 61 + 62 62 + void* VVACOSHF_(void) 63 63 + { 64 64 + if (verbose) puts("STUB: VVACOSHF_ called"); 65 65 + return NULL; 66 66 + } 67 67 + 68 68 + void* VVACOSH_(void) 69 69 + { 70 70 + if (verbose) puts("STUB: VVACOSH_ called"); 71 71 + return NULL; 72 72 + } 73 73 + 74 74 + void* VVACOS_(void) 75 75 + { 76 76 + if (verbose) puts("STUB: VVACOS_ called"); 77 77 + return NULL; 78 78 + } 79 79 + 80 80 + void* VVASIN(void) 81 81 + { 82 82 + if (verbose) puts("STUB: VVASIN called"); 83 83 + return NULL; 84 84 + } 85 85 + 86 86 + void* VVASINF(void) 87 87 + { 88 88 + if (verbose) puts("STUB: VVASINF called"); 89 89 + return NULL; 90 90 + } 91 91 + 92 92 + void* VVASINF_(void) 93 93 + { 94 94 + if (verbose) puts("STUB: VVASINF_ called"); 95 95 + return NULL; 96 96 + } 97 97 + 98 98 + void* VVASINH(void) 99 99 + { 100 100 + if (verbose) puts("STUB: VVASINH called"); 101 101 + return NULL; 102 102 + } 103 103 + 104 104 + void* VVASINHF(void) 105 105 + { 106 106 + if (verbose) puts("STUB: VVASINHF called"); 107 107 + return NULL; 108 108 + } 109 109 + 110 110 + void* VVASINHF_(void) 111 111 + { 112 112 + if (verbose) puts("STUB: VVASINHF_ called"); 113 113 + return NULL; 114 114 + } 115 115 + 116 116 + void* VVASINH_(void) 117 117 + { 118 118 + if (verbose) puts("STUB: VVASINH_ called"); 119 119 + return NULL; 120 120 + } 121 121 + 122 122 + void* VVASIN_(void) 123 123 + { 124 124 + if (verbose) puts("STUB: VVASIN_ called"); 125 125 + return NULL; 126 126 + } 127 127 + 128 128 + void* VVATAN(void) 129 129 + { 130 130 + if (verbose) puts("STUB: VVATAN called"); 131 131 + return NULL; 132 132 + } 133 133 + 134 134 + void* VVATAN2(void) 135 135 + { 136 136 + if (verbose) puts("STUB: VVATAN2 called"); 137 137 + return NULL; 138 138 + } 139 139 + 140 140 + void* VVATAN2F(void) 141 141 + { 142 142 + if (verbose) puts("STUB: VVATAN2F called"); 143 143 + return NULL; 144 144 + } 145 145 + 146 146 + void* VVATAN2F_(void) 147 147 + { 148 148 + if (verbose) puts("STUB: VVATAN2F_ called"); 149 149 + return NULL; 150 150 + } 151 151 + 152 152 + void* VVATAN2_(void) 153 153 + { 154 154 + if (verbose) puts("STUB: VVATAN2_ called"); 155 155 + return NULL; 156 156 + } 157 157 + 158 158 + void* VVATANF(void) 159 159 + { 160 160 + if (verbose) puts("STUB: VVATANF called"); 161 161 + return NULL; 162 162 + } 163 163 + 164 164 + void* VVATANF_(void) 165 165 + { 166 166 + if (verbose) puts("STUB: VVATANF_ called"); 167 167 + return NULL; 168 168 + } 169 169 + 170 170 + void* VVATANH(void) 171 171 + { 172 172 + if (verbose) puts("STUB: VVATANH called"); 173 173 + return NULL; 174 174 + } 175 175 + 176 176 + void* VVATANHF(void) 177 177 + { 178 178 + if (verbose) puts("STUB: VVATANHF called"); 179 179 + return NULL; 180 180 + } 181 181 + 182 182 + void* VVATANHF_(void) 183 183 + { 184 184 + if (verbose) puts("STUB: VVATANHF_ called"); 185 185 + return NULL; 186 186 + } 187 187 + 188 188 + void* VVATANH_(void) 189 189 + { 190 190 + if (verbose) puts("STUB: VVATANH_ called"); 191 191 + return NULL; 192 192 + } 193 193 + 194 194 + void* VVATAN_(void) 195 195 + { 196 196 + if (verbose) puts("STUB: VVATAN_ called"); 197 197 + return NULL; 198 198 + } 199 199 + 200 200 + void* VVCBRT(void) 201 201 + { 202 202 + if (verbose) puts("STUB: VVCBRT called"); 203 203 + return NULL; 204 204 + } 205 205 + 206 206 + void* VVCBRTF(void) 207 207 + { 208 208 + if (verbose) puts("STUB: VVCBRTF called"); 209 209 + return NULL; 210 210 + } 211 211 + 212 212 + void* VVCBRTF_(void) 213 213 + { 214 214 + if (verbose) puts("STUB: VVCBRTF_ called"); 215 215 + return NULL; 216 216 + } 217 217 + 218 218 + void* VVCBRT_(void) 219 219 + { 220 220 + if (verbose) puts("STUB: VVCBRT_ called"); 221 221 + return NULL; 222 222 + } 223 223 + 224 224 + void* VVCEIL(void) 225 225 + { 226 226 + if (verbose) puts("STUB: VVCEIL called"); 227 227 + return NULL; 228 228 + } 229 229 + 230 230 + void* VVCEILF(void) 231 231 + { 232 232 + if (verbose) puts("STUB: VVCEILF called"); 233 233 + return NULL; 234 234 + } 235 235 + 236 236 + void* VVCEILF_(void) 237 237 + { 238 238 + if (verbose) puts("STUB: VVCEILF_ called"); 239 239 + return NULL; 240 240 + } 241 241 + 242 242 + void* VVCEIL_(void) 243 243 + { 244 244 + if (verbose) puts("STUB: VVCEIL_ called"); 245 245 + return NULL; 246 246 + } 247 247 + 248 248 + void* VVCOPYSIGN(void) 249 249 + { 250 250 + if (verbose) puts("STUB: VVCOPYSIGN called"); 251 251 + return NULL; 252 252 + } 253 253 + 254 254 + void* VVCOPYSIGNF(void) 255 255 + { 256 256 + if (verbose) puts("STUB: VVCOPYSIGNF called"); 257 257 + return NULL; 258 258 + } 259 259 + 260 260 + void* VVCOPYSIGNF_(void) 261 261 + { 262 262 + if (verbose) puts("STUB: VVCOPYSIGNF_ called"); 263 263 + return NULL; 264 264 + } 265 265 + 266 266 + void* VVCOPYSIGN_(void) 267 267 + { 268 268 + if (verbose) puts("STUB: VVCOPYSIGN_ called"); 269 269 + return NULL; 270 270 + } 271 271 + 272 272 + void* VVCOS(void) 273 273 + { 274 274 + if (verbose) puts("STUB: VVCOS called"); 275 275 + return NULL; 276 276 + } 277 277 + 278 278 + void* VVCOSF(void) 279 279 + { 280 280 + if (verbose) puts("STUB: VVCOSF called"); 281 281 + return NULL; 282 282 + } 283 283 + 284 284 + void* VVCOSF_(void) 285 285 + { 286 286 + if (verbose) puts("STUB: VVCOSF_ called"); 287 287 + return NULL; 288 288 + } 289 289 + 290 290 + void* VVCOSH(void) 291 291 + { 292 292 + if (verbose) puts("STUB: VVCOSH called"); 293 293 + return NULL; 294 294 + } 295 295 + 296 296 + void* VVCOSHF(void) 297 297 + { 298 298 + if (verbose) puts("STUB: VVCOSHF called"); 299 299 + return NULL; 300 300 + } 301 301 + 302 302 + void* VVCOSHF_(void) 303 303 + { 304 304 + if (verbose) puts("STUB: VVCOSHF_ called"); 305 305 + return NULL; 306 306 + } 307 307 + 308 308 + void* VVCOSH_(void) 309 309 + { 310 310 + if (verbose) puts("STUB: VVCOSH_ called"); 311 311 + return NULL; 312 312 + } 313 313 + 314 314 + void* VVCOSISIN(void) 315 315 + { 316 316 + if (verbose) puts("STUB: VVCOSISIN called"); 317 317 + return NULL; 318 318 + } 319 319 + 320 320 + void* VVCOSISINF(void) 321 321 + { 322 322 + if (verbose) puts("STUB: VVCOSISINF called"); 323 323 + return NULL; 324 324 + } 325 325 + 326 326 + void* VVCOSISINF_(void) 327 327 + { 328 328 + if (verbose) puts("STUB: VVCOSISINF_ called"); 329 329 + return NULL; 330 330 + } 331 331 + 332 332 + void* VVCOSISIN_(void) 333 333 + { 334 334 + if (verbose) puts("STUB: VVCOSISIN_ called"); 335 335 + return NULL; 336 336 + } 337 337 + 338 338 + void* VVCOSPI(void) 339 339 + { 340 340 + if (verbose) puts("STUB: VVCOSPI called"); 341 341 + return NULL; 342 342 + } 343 343 + 344 344 + void* VVCOSPIF(void) 345 345 + { 346 346 + if (verbose) puts("STUB: VVCOSPIF called"); 347 347 + return NULL; 348 348 + } 349 349 + 350 350 + void* VVCOSPIF_(void) 351 351 + { 352 352 + if (verbose) puts("STUB: VVCOSPIF_ called"); 353 353 + return NULL; 354 354 + } 355 355 + 356 356 + void* VVCOSPI_(void) 357 357 + { 358 358 + if (verbose) puts("STUB: VVCOSPI_ called"); 359 359 + return NULL; 360 360 + } 361 361 + 362 362 + void* VVCOS_(void) 363 363 + { 364 364 + if (verbose) puts("STUB: VVCOS_ called"); 365 365 + return NULL; 366 366 + } 367 367 + 368 368 + void* VVDIV(void) 369 369 + { 370 370 + if (verbose) puts("STUB: VVDIV called"); 371 371 + return NULL; 372 372 + } 373 373 + 374 374 + void* VVDIVF(void) 375 375 + { 376 376 + if (verbose) puts("STUB: VVDIVF called"); 377 377 + return NULL; 378 378 + } 379 379 + 380 380 + void* VVDIVF_(void) 381 381 + { 382 382 + if (verbose) puts("STUB: VVDIVF_ called"); 383 383 + return NULL; 384 384 + } 385 385 + 386 386 + void* VVDIV_(void) 387 387 + { 388 388 + if (verbose) puts("STUB: VVDIV_ called"); 389 389 + return NULL; 390 390 + } 391 391 + 392 392 + void* VVEXP(void) 393 393 + { 394 394 + if (verbose) puts("STUB: VVEXP called"); 395 395 + return NULL; 396 396 + } 397 397 + 398 398 + void* VVEXP2(void) 399 399 + { 400 400 + if (verbose) puts("STUB: VVEXP2 called"); 401 401 + return NULL; 402 402 + } 403 403 + 404 404 + void* VVEXP2F(void) 405 405 + { 406 406 + if (verbose) puts("STUB: VVEXP2F called"); 407 407 + return NULL; 408 408 + } 409 409 + 410 410 + void* VVEXP2F_(void) 411 411 + { 412 412 + if (verbose) puts("STUB: VVEXP2F_ called"); 413 413 + return NULL; 414 414 + } 415 415 + 416 416 + void* VVEXP2_(void) 417 417 + { 418 418 + if (verbose) puts("STUB: VVEXP2_ called"); 419 419 + return NULL; 420 420 + } 421 421 + 422 422 + void* VVEXPF(void) 423 423 + { 424 424 + if (verbose) puts("STUB: VVEXPF called"); 425 425 + return NULL; 426 426 + } 427 427 + 428 428 + void* VVEXPF_(void) 429 429 + { 430 430 + if (verbose) puts("STUB: VVEXPF_ called"); 431 431 + return NULL; 432 432 + } 433 433 + 434 434 + void* VVEXPM1(void) 435 435 + { 436 436 + if (verbose) puts("STUB: VVEXPM1 called"); 437 437 + return NULL; 438 438 + } 439 439 + 440 440 + void* VVEXPM1F(void) 441 441 + { 442 442 + if (verbose) puts("STUB: VVEXPM1F called"); 443 443 + return NULL; 444 444 + } 445 445 + 446 446 + void* VVEXPM1F_(void) 447 447 + { 448 448 + if (verbose) puts("STUB: VVEXPM1F_ called"); 449 449 + return NULL; 450 450 + } 451 451 + 452 452 + void* VVEXPM1_(void) 453 453 + { 454 454 + if (verbose) puts("STUB: VVEXPM1_ called"); 455 455 + return NULL; 456 456 + } 457 457 + 458 458 + void* VVEXP_(void) 459 459 + { 460 460 + if (verbose) puts("STUB: VVEXP_ called"); 461 461 + return NULL; 462 462 + } 463 463 + 464 464 + void* VVFABF(void) 465 465 + { 466 466 + if (verbose) puts("STUB: VVFABF called"); 467 467 + return NULL; 468 468 + } 469 469 + 470 470 + void* VVFABF_(void) 471 471 + { 472 472 + if (verbose) puts("STUB: VVFABF_ called"); 473 473 + return NULL; 474 474 + } 475 475 + 476 476 + void* VVFABS(void) 477 477 + { 478 478 + if (verbose) puts("STUB: VVFABS called"); 479 479 + return NULL; 480 480 + } 481 481 + 482 482 + void* VVFABSF(void) 483 483 + { 484 484 + if (verbose) puts("STUB: VVFABSF called"); 485 485 + return NULL; 486 486 + } 487 487 + 488 488 + void* VVFABSF_(void) 489 489 + { 490 490 + if (verbose) puts("STUB: VVFABSF_ called"); 491 491 + return NULL; 492 492 + } 493 493 + 494 494 + void* VVFABS_(void) 495 495 + { 496 496 + if (verbose) puts("STUB: VVFABS_ called"); 497 497 + return NULL; 498 498 + } 499 499 + 500 500 + void* VVFLOOR(void) 501 501 + { 502 502 + if (verbose) puts("STUB: VVFLOOR called"); 503 503 + return NULL; 504 504 + } 505 505 + 506 506 + void* VVFLOORF(void) 507 507 + { 508 508 + if (verbose) puts("STUB: VVFLOORF called"); 509 509 + return NULL; 510 510 + } 511 511 + 512 512 + void* VVFLOORF_(void) 513 513 + { 514 514 + if (verbose) puts("STUB: VVFLOORF_ called"); 515 515 + return NULL; 516 516 + } 517 517 + 518 518 + void* VVFLOOR_(void) 519 519 + { 520 520 + if (verbose) puts("STUB: VVFLOOR_ called"); 521 521 + return NULL; 522 522 + } 523 523 + 524 524 + void* VVFMOD(void) 525 525 + { 526 526 + if (verbose) puts("STUB: VVFMOD called"); 527 527 + return NULL; 528 528 + } 529 529 + 530 530 + void* VVFMODF(void) 531 531 + { 532 532 + if (verbose) puts("STUB: VVFMODF called"); 533 533 + return NULL; 534 534 + } 535 535 + 536 536 + void* VVFMODF_(void) 537 537 + { 538 538 + if (verbose) puts("STUB: VVFMODF_ called"); 539 539 + return NULL; 540 540 + } 541 541 + 542 542 + void* VVFMOD_(void) 543 543 + { 544 544 + if (verbose) puts("STUB: VVFMOD_ called"); 545 545 + return NULL; 546 546 + } 547 547 + 548 548 + void* VVINT(void) 549 549 + { 550 550 + if (verbose) puts("STUB: VVINT called"); 551 551 + return NULL; 552 552 + } 553 553 + 554 554 + void* VVINTF(void) 555 555 + { 556 556 + if (verbose) puts("STUB: VVINTF called"); 557 557 + return NULL; 558 558 + } 559 559 + 560 560 + void* VVINTF_(void) 561 561 + { 562 562 + if (verbose) puts("STUB: VVINTF_ called"); 563 563 + return NULL; 564 564 + } 565 565 + 566 566 + void* VVINT_(void) 567 567 + { 568 568 + if (verbose) puts("STUB: VVINT_ called"); 569 569 + return NULL; 570 570 + } 571 571 + 572 572 + void* VVLOG(void) 573 573 + { 574 574 + if (verbose) puts("STUB: VVLOG called"); 575 575 + return NULL; 576 576 + } 577 577 + 578 578 + void* VVLOG10(void) 579 579 + { 580 580 + if (verbose) puts("STUB: VVLOG10 called"); 581 581 + return NULL; 582 582 + } 583 583 + 584 584 + void* VVLOG10F(void) 585 585 + { 586 586 + if (verbose) puts("STUB: VVLOG10F called"); 587 587 + return NULL; 588 588 + } 589 589 + 590 590 + void* VVLOG10F_(void) 591 591 + { 592 592 + if (verbose) puts("STUB: VVLOG10F_ called"); 593 593 + return NULL; 594 594 + } 595 595 + 596 596 + void* VVLOG10_(void) 597 597 + { 598 598 + if (verbose) puts("STUB: VVLOG10_ called"); 599 599 + return NULL; 600 600 + } 601 601 + 602 602 + void* VVLOG1P(void) 603 603 + { 604 604 + if (verbose) puts("STUB: VVLOG1P called"); 605 605 + return NULL; 606 606 + } 607 607 + 608 608 + void* VVLOG1PF(void) 609 609 + { 610 610 + if (verbose) puts("STUB: VVLOG1PF called"); 611 611 + return NULL; 612 612 + } 613 613 + 614 614 + void* VVLOG1PF_(void) 615 615 + { 616 616 + if (verbose) puts("STUB: VVLOG1PF_ called"); 617 617 + return NULL; 618 618 + } 619 619 + 620 620 + void* VVLOG1P_(void) 621 621 + { 622 622 + if (verbose) puts("STUB: VVLOG1P_ called"); 623 623 + return NULL; 624 624 + } 625 625 + 626 626 + void* VVLOG2(void) 627 627 + { 628 628 + if (verbose) puts("STUB: VVLOG2 called"); 629 629 + return NULL; 630 630 + } 631 631 + 632 632 + void* VVLOG2F(void) 633 633 + { 634 634 + if (verbose) puts("STUB: VVLOG2F called"); 635 635 + return NULL; 636 636 + } 637 637 + 638 638 + void* VVLOG2F_(void) 639 639 + { 640 640 + if (verbose) puts("STUB: VVLOG2F_ called"); 641 641 + return NULL; 642 642 + } 643 643 + 644 644 + void* VVLOG2_(void) 645 645 + { 646 646 + if (verbose) puts("STUB: VVLOG2_ called"); 647 647 + return NULL; 648 648 + } 649 649 + 650 650 + void* VVLOGB(void) 651 651 + { 652 652 + if (verbose) puts("STUB: VVLOGB called"); 653 653 + return NULL; 654 654 + } 655 655 + 656 656 + void* VVLOGBF(void) 657 657 + { 658 658 + if (verbose) puts("STUB: VVLOGBF called"); 659 659 + return NULL; 660 660 + } 661 661 + 662 662 + void* VVLOGBF_(void) 663 663 + { 664 664 + if (verbose) puts("STUB: VVLOGBF_ called"); 665 665 + return NULL; 666 666 + } 667 667 + 668 668 + void* VVLOGB_(void) 669 669 + { 670 670 + if (verbose) puts("STUB: VVLOGB_ called"); 671 671 + return NULL; 672 672 + } 673 673 + 674 674 + void* VVLOGF(void) 675 675 + { 676 676 + if (verbose) puts("STUB: VVLOGF called"); 677 677 + return NULL; 678 678 + } 679 679 + 680 680 + void* VVLOGF_(void) 681 681 + { 682 682 + if (verbose) puts("STUB: VVLOGF_ called"); 683 683 + return NULL; 684 684 + } 685 685 + 686 686 + void* VVLOG_(void) 687 687 + { 688 688 + if (verbose) puts("STUB: VVLOG_ called"); 689 689 + return NULL; 690 690 + } 691 691 + 692 692 + void* VVNEXTAFTER(void) 693 693 + { 694 694 + if (verbose) puts("STUB: VVNEXTAFTER called"); 695 695 + return NULL; 696 696 + } 697 697 + 698 698 + void* VVNEXTAFTERF(void) 699 699 + { 700 700 + if (verbose) puts("STUB: VVNEXTAFTERF called"); 701 701 + return NULL; 702 702 + } 703 703 + 704 704 + void* VVNEXTAFTERF_(void) 705 705 + { 706 706 + if (verbose) puts("STUB: VVNEXTAFTERF_ called"); 707 707 + return NULL; 708 708 + } 709 709 + 710 710 + void* VVNEXTAFTER_(void) 711 711 + { 712 712 + if (verbose) puts("STUB: VVNEXTAFTER_ called"); 713 713 + return NULL; 714 714 + } 715 715 + 716 716 + void* VVNINT(void) 717 717 + { 718 718 + if (verbose) puts("STUB: VVNINT called"); 719 719 + return NULL; 720 720 + } 721 721 + 722 722 + void* VVNINTF(void) 723 723 + { 724 724 + if (verbose) puts("STUB: VVNINTF called"); 725 725 + return NULL; 726 726 + } 727 727 + 728 728 + void* VVNINTF_(void) 729 729 + { 730 730 + if (verbose) puts("STUB: VVNINTF_ called"); 731 731 + return NULL; 732 732 + } 733 733 + 734 734 + void* VVNINT_(void) 735 735 + { 736 736 + if (verbose) puts("STUB: VVNINT_ called"); 737 737 + return NULL; 738 738 + } 739 739 + 740 740 + void* VVPOW(void) 741 741 + { 742 742 + if (verbose) puts("STUB: VVPOW called"); 743 743 + return NULL; 744 744 + } 745 745 + 746 746 + void* VVPOWF(void) 747 747 + { 748 748 + if (verbose) puts("STUB: VVPOWF called"); 749 749 + return NULL; 750 750 + } 751 751 + 752 752 + void* VVPOWF_(void) 753 753 + { 754 754 + if (verbose) puts("STUB: VVPOWF_ called"); 755 755 + return NULL; 756 756 + } 757 757 + 758 758 + void* VVPOWS(void) 759 759 + { 760 760 + if (verbose) puts("STUB: VVPOWS called"); 761 761 + return NULL; 762 762 + } 763 763 + 764 764 + void* VVPOWSF(void) 765 765 + { 766 766 + if (verbose) puts("STUB: VVPOWSF called"); 767 767 + return NULL; 768 768 + } 769 769 + 770 770 + void* VVPOWSF_(void) 771 771 + { 772 772 + if (verbose) puts("STUB: VVPOWSF_ called"); 773 773 + return NULL; 774 774 + } 775 775 + 776 776 + void* VVPOWS_(void) 777 777 + { 778 778 + if (verbose) puts("STUB: VVPOWS_ called"); 779 779 + return NULL; 780 780 + } 781 781 + 782 782 + void* VVPOW_(void) 783 783 + { 784 784 + if (verbose) puts("STUB: VVPOW_ called"); 785 785 + return NULL; 786 786 + } 787 787 + 788 788 + void* VVREC(void) 789 789 + { 790 790 + if (verbose) puts("STUB: VVREC called"); 791 791 + return NULL; 792 792 + } 793 793 + 794 794 + void* VVRECF(void) 795 795 + { 796 796 + if (verbose) puts("STUB: VVRECF called"); 797 797 + return NULL; 798 798 + } 799 799 + 800 800 + void* VVRECF_(void) 801 801 + { 802 802 + if (verbose) puts("STUB: VVRECF_ called"); 803 803 + return NULL; 804 804 + } 805 805 + 806 806 + void* VVREC_(void) 807 807 + { 808 808 + if (verbose) puts("STUB: VVREC_ called"); 809 809 + return NULL; 810 810 + } 811 811 + 812 812 + void* VVREMAINDER(void) 813 813 + { 814 814 + if (verbose) puts("STUB: VVREMAINDER called"); 815 815 + return NULL; 816 816 + } 817 817 + 818 818 + void* VVREMAINDERF(void) 819 819 + { 820 820 + if (verbose) puts("STUB: VVREMAINDERF called"); 821 821 + return NULL; 822 822 + } 823 823 + 824 824 + void* VVREMAINDERF_(void) 825 825 + { 826 826 + if (verbose) puts("STUB: VVREMAINDERF_ called"); 827 827 + return NULL; 828 828 + } 829 829 + 830 830 + void* VVREMAINDER_(void) 831 831 + { 832 832 + if (verbose) puts("STUB: VVREMAINDER_ called"); 833 833 + return NULL; 834 834 + } 835 835 + 836 836 + void* VVRSQRT(void) 837 837 + { 838 838 + if (verbose) puts("STUB: VVRSQRT called"); 839 839 + return NULL; 840 840 + } 841 841 + 842 842 + void* VVRSQRTF(void) 843 843 + { 844 844 + if (verbose) puts("STUB: VVRSQRTF called"); 845 845 + return NULL; 846 846 + } 847 847 + 848 848 + void* VVRSQRTF_(void) 849 849 + { 850 850 + if (verbose) puts("STUB: VVRSQRTF_ called"); 851 851 + return NULL; 852 852 + } 853 853 + 854 854 + void* VVRSQRT_(void) 855 855 + { 856 856 + if (verbose) puts("STUB: VVRSQRT_ called"); 857 857 + return NULL; 858 858 + } 859 859 + 860 860 + void* VVSIN(void) 861 861 + { 862 862 + if (verbose) puts("STUB: VVSIN called"); 863 863 + return NULL; 864 864 + } 865 865 + 866 866 + void* VVSINCOS(void) 867 867 + { 868 868 + if (verbose) puts("STUB: VVSINCOS called"); 869 869 + return NULL; 870 870 + } 871 871 + 872 872 + void* VVSINCOSF(void) 873 873 + { 874 874 + if (verbose) puts("STUB: VVSINCOSF called"); 875 875 + return NULL; 876 876 + } 877 877 + 878 878 + void* VVSINCOSF_(void) 879 879 + { 880 880 + if (verbose) puts("STUB: VVSINCOSF_ called"); 881 881 + return NULL; 882 882 + } 883 883 + 884 884 + void* VVSINCOS_(void) 885 885 + { 886 886 + if (verbose) puts("STUB: VVSINCOS_ called"); 887 887 + return NULL; 888 888 + } 889 889 + 890 890 + void* VVSINF(void) 891 891 + { 892 892 + if (verbose) puts("STUB: VVSINF called"); 893 893 + return NULL; 894 894 + } 895 895 + 896 896 + void* VVSINF_(void) 897 897 + { 898 898 + if (verbose) puts("STUB: VVSINF_ called"); 899 899 + return NULL; 900 900 + } 901 901 + 902 902 + void* VVSINH(void) 903 903 + { 904 904 + if (verbose) puts("STUB: VVSINH called"); 905 905 + return NULL; 906 906 + } 907 907 + 908 908 + void* VVSINHF(void) 909 909 + { 910 910 + if (verbose) puts("STUB: VVSINHF called"); 911 911 + return NULL; 912 912 + } 913 913 + 914 914 + void* VVSINHF_(void) 915 915 + { 916 916 + if (verbose) puts("STUB: VVSINHF_ called"); 917 917 + return NULL; 918 918 + } 919 919 + 920 920 + void* VVSINH_(void) 921 921 + { 922 922 + if (verbose) puts("STUB: VVSINH_ called"); 923 923 + return NULL; 924 924 + } 925 925 + 926 926 + void* VVSINPI(void) 927 927 + { 928 928 + if (verbose) puts("STUB: VVSINPI called"); 929 929 + return NULL; 930 930 + } 931 931 + 932 932 + void* VVSINPIF(void) 933 933 + { 934 934 + if (verbose) puts("STUB: VVSINPIF called"); 935 935 + return NULL; 936 936 + } 937 937 + 938 938 + void* VVSINPIF_(void) 939 939 + { 940 940 + if (verbose) puts("STUB: VVSINPIF_ called"); 941 941 + return NULL; 942 942 + } 943 943 + 944 944 + void* VVSINPI_(void) 945 945 + { 946 946 + if (verbose) puts("STUB: VVSINPI_ called"); 947 947 + return NULL; 948 948 + } 949 949 + 950 950 + void* VVSIN_(void) 951 951 + { 952 952 + if (verbose) puts("STUB: VVSIN_ called"); 953 953 + return NULL; 954 954 + } 955 955 + 956 956 + void* VVSQRT(void) 957 957 + { 958 958 + if (verbose) puts("STUB: VVSQRT called"); 959 959 + return NULL; 960 960 + } 961 961 + 962 962 + void* VVSQRTF(void) 963 963 + { 964 964 + if (verbose) puts("STUB: VVSQRTF called"); 965 965 + return NULL; 966 966 + } 967 967 + 968 968 + void* VVSQRTF_(void) 969 969 + { 970 970 + if (verbose) puts("STUB: VVSQRTF_ called"); 971 971 + return NULL; 972 972 + } 973 973 + 974 974 + void* VVSQRT_(void) 975 975 + { 976 976 + if (verbose) puts("STUB: VVSQRT_ called"); 977 977 + return NULL; 978 978 + } 979 979 + 980 980 + void* VVTAN(void) 981 981 + { 982 982 + if (verbose) puts("STUB: VVTAN called"); 983 983 + return NULL; 984 984 + } 985 985 + 986 986 + void* VVTANF(void) 987 987 + { 988 988 + if (verbose) puts("STUB: VVTANF called"); 989 989 + return NULL; 990 990 + } 991 991 + 992 992 + void* VVTANF_(void) 993 993 + { 994 994 + if (verbose) puts("STUB: VVTANF_ called"); 995 995 + return NULL; 996 996 + } 997 997 + 998 998 + void* VVTANH(void) 999 999 + { 1000 1000 + if (verbose) puts("STUB: VVTANH called"); 1001 1001 + return NULL; 1002 1002 + } 1003 1003 + 1004 1004 + void* VVTANHF(void) 1005 1005 + { 1006 1006 + if (verbose) puts("STUB: VVTANHF called"); 1007 1007 + return NULL; 1008 1008 + } 1009 1009 + 1010 1010 + void* VVTANHF_(void) 1011 1011 + { 1012 1012 + if (verbose) puts("STUB: VVTANHF_ called"); 1013 1013 + return NULL; 1014 1014 + } 1015 1015 + 1016 1016 + void* VVTANH_(void) 1017 1017 + { 1018 1018 + if (verbose) puts("STUB: VVTANH_ called"); 1019 1019 + return NULL; 1020 1020 + } 1021 1021 + 1022 1022 + void* VVTANPI(void) 1023 1023 + { 1024 1024 + if (verbose) puts("STUB: VVTANPI called"); 1025 1025 + return NULL; 1026 1026 + } 1027 1027 + 1028 1028 + void* VVTANPIF(void) 1029 1029 + { 1030 1030 + if (verbose) puts("STUB: VVTANPIF called"); 1031 1031 + return NULL; 1032 1032 + } 1033 1033 + 1034 1034 + void* VVTANPIF_(void) 1035 1035 + { 1036 1036 + if (verbose) puts("STUB: VVTANPIF_ called"); 1037 1037 + return NULL; 1038 1038 + } 1039 1039 + 1040 1040 + void* VVTANPI_(void) 1041 1041 + { 1042 1042 + if (verbose) puts("STUB: VVTANPI_ called"); 1043 1043 + return NULL; 1044 1044 + } 1045 1045 + 1046 1046 + void* VVTAN_(void) 1047 1047 + { 1048 1048 + if (verbose) puts("STUB: VVTAN_ called"); 1049 1049 + return NULL; 1050 1050 + } 1051 1051 + 1052 1052 + void* __cblas_isamax(void) 1053 1053 + { 1054 1054 + if (verbose) puts("STUB: __cblas_isamax called"); 1055 1055 + return NULL; 1056 1056 + } 1057 1057 + 1058 1058 + void* __cblas_sasum(void) 1059 1059 + { 1060 1060 + if (verbose) puts("STUB: __cblas_sasum called"); 1061 1061 + return NULL; 1062 1062 + } 1063 1063 + 1064 1064 + void* __cblas_saxpy(void) 1065 1065 + { 1066 1066 + if (verbose) puts("STUB: __cblas_saxpy called"); 1067 1067 + return NULL; 1068 1068 + } 1069 1069 + 1070 1070 + void* __cblas_sgemm(void) 1071 1071 + { 1072 1072 + if (verbose) puts("STUB: __cblas_sgemm called"); 1073 1073 + return NULL; 1074 1074 + } 1075 1075 + 1076 1076 + void* __cblas_sgemv(void) 1077 1077 + { 1078 1078 + if (verbose) puts("STUB: __cblas_sgemv called"); 1079 1079 + return NULL; 1080 1080 + } 1081 1081 + 1082 1082 + void* __cblas_srot(void) 1083 1083 + { 1084 1084 + if (verbose) puts("STUB: __cblas_srot called"); 1085 1085 + return NULL; 1086 1086 + } 1087 1087 + 1088 1088 + void* __cblas_sscal(void) 1089 1089 + { 1090 1090 + if (verbose) puts("STUB: __cblas_sscal called"); 1091 1091 + return NULL; 1092 1092 + } 1093 1093 + 1094 1094 + void* __cblas_sswap(void) 1095 1095 + { 1096 1096 + if (verbose) puts("STUB: __cblas_sswap called"); 1097 1097 + return NULL; 1098 1098 + } 1099 1099 + 1100 1100 + void* dMultMatMat_16x16(void) 1101 1101 + { 1102 1102 + if (verbose) puts("STUB: dMultMatMat_16x16 called"); 1103 1103 + return NULL; 1104 1104 + } 1105 1105 + 1106 1106 + void* dMultMatMat_32x32(void) 1107 1107 + { 1108 1108 + if (verbose) puts("STUB: dMultMatMat_32x32 called"); 1109 1109 + return NULL; 1110 1110 + } 1111 1111 + 1112 1112 + void* dMultMatMat_4x4(void) 1113 1113 + { 1114 1114 + if (verbose) puts("STUB: dMultMatMat_4x4 called"); 1115 1115 + return NULL; 1116 1116 + } 1117 1117 + 1118 1118 + void* dMultMatMat_8x8(void) 1119 1119 + { 1120 1120 + if (verbose) puts("STUB: dMultMatMat_8x8 called"); 1121 1121 + return NULL; 1122 1122 + } 1123 1123 + 1124 1124 + void* dMultMatVec_16x16(void) 1125 1125 + { 1126 1126 + if (verbose) puts("STUB: dMultMatVec_16x16 called"); 1127 1127 + return NULL; 1128 1128 + } 1129 1129 + 1130 1130 + void* dMultMatVec_32x32(void) 1131 1131 + { 1132 1132 + if (verbose) puts("STUB: dMultMatVec_32x32 called"); 1133 1133 + return NULL; 1134 1134 + } 1135 1135 + 1136 1136 + void* dMultMatVec_4x4(void) 1137 1137 + { 1138 1138 + if (verbose) puts("STUB: dMultMatVec_4x4 called"); 1139 1139 + return NULL; 1140 1140 + } 1141 1141 + 1142 1142 + void* dMultMatVec_8x8(void) 1143 1143 + { 1144 1144 + if (verbose) puts("STUB: dMultMatVec_8x8 called"); 1145 1145 + return NULL; 1146 1146 + } 1147 1147 + 1148 1148 + void* dMultVecMat_16x16(void) 1149 1149 + { 1150 1150 + if (verbose) puts("STUB: dMultVecMat_16x16 called"); 1151 1151 + return NULL; 1152 1152 + } 1153 1153 + 1154 1154 + void* dMultVecMat_32x32(void) 1155 1155 + { 1156 1156 + if (verbose) puts("STUB: dMultVecMat_32x32 called"); 1157 1157 + return NULL; 1158 1158 + } 1159 1159 + 1160 1160 + void* dMultVecMat_4x4(void) 1161 1161 + { 1162 1162 + if (verbose) puts("STUB: dMultVecMat_4x4 called"); 1163 1163 + return NULL; 1164 1164 + } 1165 1165 + 1166 1166 + void* dMultVecMat_8x8(void) 1167 1167 + { 1168 1168 + if (verbose) puts("STUB: dMultVecMat_8x8 called"); 1169 1169 + return NULL; 1170 1170 + } 1171 1171 + 1172 1172 + void* sMultMatMat_16x16(void) 1173 1173 + { 1174 1174 + if (verbose) puts("STUB: sMultMatMat_16x16 called"); 1175 1175 + return NULL; 1176 1176 + } 1177 1177 + 1178 1178 + void* sMultMatMat_32x32(void) 1179 1179 + { 1180 1180 + if (verbose) puts("STUB: sMultMatMat_32x32 called"); 1181 1181 + return NULL; 1182 1182 + } 1183 1183 + 1184 1184 + void* sMultMatMat_4x4(void) 1185 1185 + { 1186 1186 + if (verbose) puts("STUB: sMultMatMat_4x4 called"); 1187 1187 + return NULL; 1188 1188 + } 1189 1189 + 1190 1190 + void* sMultMatMat_8x8(void) 1191 1191 + { 1192 1192 + if (verbose) puts("STUB: sMultMatMat_8x8 called"); 1193 1193 + return NULL; 1194 1194 + } 1195 1195 + 1196 1196 + void* sMultMatVec_16x16(void) 1197 1197 + { 1198 1198 + if (verbose) puts("STUB: sMultMatVec_16x16 called"); 1199 1199 + return NULL; 1200 1200 + } 1201 1201 + 1202 1202 + void* sMultMatVec_32x32(void) 1203 1203 + { 1204 1204 + if (verbose) puts("STUB: sMultMatVec_32x32 called"); 1205 1205 + return NULL; 1206 1206 + } 1207 1207 + 1208 1208 + void* sMultMatVec_4x4(void) 1209 1209 + { 1210 1210 + if (verbose) puts("STUB: sMultMatVec_4x4 called"); 1211 1211 + return NULL; 1212 1212 + } 1213 1213 + 1214 1214 + void* sMultMatVec_8x8(void) 1215 1215 + { 1216 1216 + if (verbose) puts("STUB: sMultMatVec_8x8 called"); 1217 1217 + return NULL; 1218 1218 + } 1219 1219 + 1220 1220 + void* sMultVecMat_16x16(void) 1221 1221 + { 1222 1222 + if (verbose) puts("STUB: sMultVecMat_16x16 called"); 1223 1223 + return NULL; 1224 1224 + } 1225 1225 + 1226 1226 + void* sMultVecMat_32x32(void) 1227 1227 + { 1228 1228 + if (verbose) puts("STUB: sMultVecMat_32x32 called"); 1229 1229 + return NULL; 1230 1230 + } 1231 1231 + 1232 1232 + void* sMultVecMat_4x4(void) 1233 1233 + { 1234 1234 + if (verbose) puts("STUB: sMultVecMat_4x4 called"); 1235 1235 + return NULL; 1236 1236 + } 1237 1237 + 1238 1238 + void* sMultVecMat_8x8(void) 1239 1239 + { 1240 1240 + if (verbose) puts("STUB: sMultVecMat_8x8 called"); 1241 1241 + return NULL; 1242 1242 + } 1243 1243 + 1244 1244 + void* vA1024Shift(void) 1245 1245 + { 1246 1246 + if (verbose) puts("STUB: vA1024Shift called"); 1247 1247 + return NULL; 1248 1248 + } 1249 1249 + 1250 1250 + void* vA128Shift(void) 1251 1251 + { 1252 1252 + if (verbose) puts("STUB: vA128Shift called"); 1253 1253 + return NULL; 1254 1254 + } 1255 1255 + 1256 1256 + void* vA256Shift(void) 1257 1257 + { 1258 1258 + if (verbose) puts("STUB: vA256Shift called"); 1259 1259 + return NULL; 1260 1260 + } 1261 1261 + 1262 1262 + void* vA512Shift(void) 1263 1263 + { 1264 1264 + if (verbose) puts("STUB: vA512Shift called"); 1265 1265 + return NULL; 1266 1266 + } 1267 1267 + 1268 1268 + void* vA64Shift(void) 1269 1269 + { 1270 1270 + if (verbose) puts("STUB: vA64Shift called"); 1271 1271 + return NULL; 1272 1272 + } 1273 1273 + 1274 1274 + void* vA64Shift2(void) 1275 1275 + { 1276 1276 + if (verbose) puts("STUB: vA64Shift2 called"); 1277 1277 + return NULL; 1278 1278 + } 1279 1279 + 1280 1280 + void* vIsamax(void) 1281 1281 + { 1282 1282 + if (verbose) puts("STUB: vIsamax called"); 1283 1283 + return NULL; 1284 1284 + } 1285 1285 + 1286 1286 + void* vIsamin(void) 1287 1287 + { 1288 1288 + if (verbose) puts("STUB: vIsamin called"); 1289 1289 + return NULL; 1290 1290 + } 1291 1291 + 1292 1292 + void* vIsmax(void) 1293 1293 + { 1294 1294 + if (verbose) puts("STUB: vIsmax called"); 1295 1295 + return NULL; 1296 1296 + } 1297 1297 + 1298 1298 + void* vIsmin(void) 1299 1299 + { 1300 1300 + if (verbose) puts("STUB: vIsmin called"); 1301 1301 + return NULL; 1302 1302 + } 1303 1303 + 1304 1304 + void* vL1024Rotate(void) 1305 1305 + { 1306 1306 + if (verbose) puts("STUB: vL1024Rotate called"); 1307 1307 + return NULL; 1308 1308 + } 1309 1309 + 1310 1310 + void* vL128Rotate(void) 1311 1311 + { 1312 1312 + if (verbose) puts("STUB: vL128Rotate called"); 1313 1313 + return NULL; 1314 1314 + } 1315 1315 + 1316 1316 + void* vL256Rotate(void) 1317 1317 + { 1318 1318 + if (verbose) puts("STUB: vL256Rotate called"); 1319 1319 + return NULL; 1320 1320 + } 1321 1321 + 1322 1322 + void* vL512Rotate(void) 1323 1323 + { 1324 1324 + if (verbose) puts("STUB: vL512Rotate called"); 1325 1325 + return NULL; 1326 1326 + } 1327 1327 + 1328 1328 + void* vL64Rotate(void) 1329 1329 + { 1330 1330 + if (verbose) puts("STUB: vL64Rotate called"); 1331 1331 + return NULL; 1332 1332 + } 1333 1333 + 1334 1334 + void* vL64Rotate2(void) 1335 1335 + { 1336 1336 + if (verbose) puts("STUB: vL64Rotate2 called"); 1337 1337 + return NULL; 1338 1338 + } 1339 1339 + 1340 1340 + void* vLL1024Shift(void) 1341 1341 + { 1342 1342 + if (verbose) puts("STUB: vLL1024Shift called"); 1343 1343 + return NULL; 1344 1344 + } 1345 1345 + 1346 1346 + void* vLL128Shift(void) 1347 1347 + { 1348 1348 + if (verbose) puts("STUB: vLL128Shift called"); 1349 1349 + return NULL; 1350 1350 + } 1351 1351 + 1352 1352 + void* vLL256Shift(void) 1353 1353 + { 1354 1354 + if (verbose) puts("STUB: vLL256Shift called"); 1355 1355 + return NULL; 1356 1356 + } 1357 1357 + 1358 1358 + void* vLL512Shift(void) 1359 1359 + { 1360 1360 + if (verbose) puts("STUB: vLL512Shift called"); 1361 1361 + return NULL; 1362 1362 + } 1363 1363 + 1364 1364 + void* vLL64Shift(void) 1365 1365 + { 1366 1366 + if (verbose) puts("STUB: vLL64Shift called"); 1367 1367 + return NULL; 1368 1368 + } 1369 1369 + 1370 1370 + void* vLL64Shift2(void) 1371 1371 + { 1372 1372 + if (verbose) puts("STUB: vLL64Shift2 called"); 1373 1373 + return NULL; 1374 1374 + } 1375 1375 + 1376 1376 + void* vLR1024Shift(void) 1377 1377 + { 1378 1378 + if (verbose) puts("STUB: vLR1024Shift called"); 1379 1379 + return NULL; 1380 1380 + } 1381 1381 + 1382 1382 + void* vLR128Shift(void) 1383 1383 + { 1384 1384 + if (verbose) puts("STUB: vLR128Shift called"); 1385 1385 + return NULL; 1386 1386 + } 1387 1387 + 1388 1388 + void* vLR256Shift(void) 1389 1389 + { 1390 1390 + if (verbose) puts("STUB: vLR256Shift called"); 1391 1391 + return NULL; 1392 1392 + } 1393 1393 + 1394 1394 + void* vLR512Shift(void) 1395 1395 + { 1396 1396 + if (verbose) puts("STUB: vLR512Shift called"); 1397 1397 + return NULL; 1398 1398 + } 1399 1399 + 1400 1400 + void* vLR64Shift(void) 1401 1401 + { 1402 1402 + if (verbose) puts("STUB: vLR64Shift called"); 1403 1403 + return NULL; 1404 1404 + } 1405 1405 + 1406 1406 + void* vLR64Shift2(void) 1407 1407 + { 1408 1408 + if (verbose) puts("STUB: vLR64Shift2 called"); 1409 1409 + return NULL; 1410 1410 + } 1411 1411 + 1412 1412 + void* vMultMatMat_16x16(void) 1413 1413 + { 1414 1414 + if (verbose) puts("STUB: vMultMatMat_16x16 called"); 1415 1415 + return NULL; 1416 1416 + } 1417 1417 + 1418 1418 + void* vMultMatMat_32x32(void) 1419 1419 + { 1420 1420 + if (verbose) puts("STUB: vMultMatMat_32x32 called"); 1421 1421 + return NULL; 1422 1422 + } 1423 1423 + 1424 1424 + void* vMultMatMat_4x4(void) 1425 1425 + { 1426 1426 + if (verbose) puts("STUB: vMultMatMat_4x4 called"); 1427 1427 + return NULL; 1428 1428 + } 1429 1429 + 1430 1430 + void* vMultMatMat_8x8(void) 1431 1431 + { 1432 1432 + if (verbose) puts("STUB: vMultMatMat_8x8 called"); 1433 1433 + return NULL; 1434 1434 + } 1435 1435 + 1436 1436 + void* vMultMatVec_16x16(void) 1437 1437 + { 1438 1438 + if (verbose) puts("STUB: vMultMatVec_16x16 called"); 1439 1439 + return NULL; 1440 1440 + } 1441 1441 + 1442 1442 + void* vMultMatVec_32x32(void) 1443 1443 + { 1444 1444 + if (verbose) puts("STUB: vMultMatVec_32x32 called"); 1445 1445 + return NULL; 1446 1446 + } 1447 1447 + 1448 1448 + void* vMultMatVec_4x4(void) 1449 1449 + { 1450 1450 + if (verbose) puts("STUB: vMultMatVec_4x4 called"); 1451 1451 + return NULL; 1452 1452 + } 1453 1453 + 1454 1454 + void* vMultMatVec_8x8(void) 1455 1455 + { 1456 1456 + if (verbose) puts("STUB: vMultMatVec_8x8 called"); 1457 1457 + return NULL; 1458 1458 + } 1459 1459 + 1460 1460 + void* vMultVecMat_16x16(void) 1461 1461 + { 1462 1462 + if (verbose) puts("STUB: vMultVecMat_16x16 called"); 1463 1463 + return NULL; 1464 1464 + } 1465 1465 + 1466 1466 + void* vMultVecMat_32x32(void) 1467 1467 + { 1468 1468 + if (verbose) puts("STUB: vMultVecMat_32x32 called"); 1469 1469 + return NULL; 1470 1470 + } 1471 1471 + 1472 1472 + void* vMultVecMat_4x4(void) 1473 1473 + { 1474 1474 + if (verbose) puts("STUB: vMultVecMat_4x4 called"); 1475 1475 + return NULL; 1476 1476 + } 1477 1477 + 1478 1478 + void* vMultVecMat_8x8(void) 1479 1479 + { 1480 1480 + if (verbose) puts("STUB: vMultVecMat_8x8 called"); 1481 1481 + return NULL; 1482 1482 + } 1483 1483 + 1484 1484 + void* vR1024Rotate(void) 1485 1485 + { 1486 1486 + if (verbose) puts("STUB: vR1024Rotate called"); 1487 1487 + return NULL; 1488 1488 + } 1489 1489 + 1490 1490 + void* vR128Rotate(void) 1491 1491 + { 1492 1492 + if (verbose) puts("STUB: vR128Rotate called"); 1493 1493 + return NULL; 1494 1494 + } 1495 1495 + 1496 1496 + void* vR256Rotate(void) 1497 1497 + { 1498 1498 + if (verbose) puts("STUB: vR256Rotate called"); 1499 1499 + return NULL; 1500 1500 + } 1501 1501 + 1502 1502 + void* vR512Rotate(void) 1503 1503 + { 1504 1504 + if (verbose) puts("STUB: vR512Rotate called"); 1505 1505 + return NULL; 1506 1506 + } 1507 1507 + 1508 1508 + void* vR64Rotate(void) 1509 1509 + { 1510 1510 + if (verbose) puts("STUB: vR64Rotate called"); 1511 1511 + return NULL; 1512 1512 + } 1513 1513 + 1514 1514 + void* vR64Rotate2(void) 1515 1515 + { 1516 1516 + if (verbose) puts("STUB: vR64Rotate2 called"); 1517 1517 + return NULL; 1518 1518 + } 1519 1519 + 1520 1520 + void* vS1024Add(void) 1521 1521 + { 1522 1522 + if (verbose) puts("STUB: vS1024Add called"); 1523 1523 + return NULL; 1524 1524 + } 1525 1525 + 1526 1526 + void* vS1024AddS(void) 1527 1527 + { 1528 1528 + if (verbose) puts("STUB: vS1024AddS called"); 1529 1529 + return NULL; 1530 1530 + } 1531 1531 + 1532 1532 + void* vS1024Divide(void) 1533 1533 + { 1534 1534 + if (verbose) puts("STUB: vS1024Divide called"); 1535 1535 + return NULL; 1536 1536 + } 1537 1537 + 1538 1538 + void* vS1024HalfMultiply(void) 1539 1539 + { 1540 1540 + if (verbose) puts("STUB: vS1024HalfMultiply called"); 1541 1541 + return NULL; 1542 1542 + } 1543 1543 + 1544 1544 + void* vS1024Mod(void) 1545 1545 + { 1546 1546 + if (verbose) puts("STUB: vS1024Mod called"); 1547 1547 + return NULL; 1548 1548 + } 1549 1549 + 1550 1550 + void* vS1024Neg(void) 1551 1551 + { 1552 1552 + if (verbose) puts("STUB: vS1024Neg called"); 1553 1553 + return NULL; 1554 1554 + } 1555 1555 + 1556 1556 + void* vS1024Sub(void) 1557 1557 + { 1558 1558 + if (verbose) puts("STUB: vS1024Sub called"); 1559 1559 + return NULL; 1560 1560 + } 1561 1561 + 1562 1562 + void* vS1024SubS(void) 1563 1563 + { 1564 1564 + if (verbose) puts("STUB: vS1024SubS called"); 1565 1565 + return NULL; 1566 1566 + } 1567 1567 + 1568 1568 + void* vS128Add(void) 1569 1569 + { 1570 1570 + if (verbose) puts("STUB: vS128Add called"); 1571 1571 + return NULL; 1572 1572 + } 1573 1573 + 1574 1574 + void* vS128AddS(void) 1575 1575 + { 1576 1576 + if (verbose) puts("STUB: vS128AddS called"); 1577 1577 + return NULL; 1578 1578 + } 1579 1579 + 1580 1580 + void* vS128Divide(void) 1581 1581 + { 1582 1582 + if (verbose) puts("STUB: vS128Divide called"); 1583 1583 + return NULL; 1584 1584 + } 1585 1585 + 1586 1586 + void* vS128FullMultiply(void) 1587 1587 + { 1588 1588 + if (verbose) puts("STUB: vS128FullMultiply called"); 1589 1589 + return NULL; 1590 1590 + } 1591 1591 + 1592 1592 + void* vS128HalfMultiply(void) 1593 1593 + { 1594 1594 + if (verbose) puts("STUB: vS128HalfMultiply called"); 1595 1595 + return NULL; 1596 1596 + } 1597 1597 + 1598 1598 + void* vS128Neg(void) 1599 1599 + { 1600 1600 + if (verbose) puts("STUB: vS128Neg called"); 1601 1601 + return NULL; 1602 1602 + } 1603 1603 + 1604 1604 + void* vS128Sub(void) 1605 1605 + { 1606 1606 + if (verbose) puts("STUB: vS128Sub called"); 1607 1607 + return NULL; 1608 1608 + } 1609 1609 + 1610 1610 + void* vS128SubS(void) 1611 1611 + { 1612 1612 + if (verbose) puts("STUB: vS128SubS called"); 1613 1613 + return NULL; 1614 1614 + } 1615 1615 + 1616 1616 + void* vS16Divide(void) 1617 1617 + { 1618 1618 + if (verbose) puts("STUB: vS16Divide called"); 1619 1619 + return NULL; 1620 1620 + } 1621 1621 + 1622 1622 + void* vS16HalfMultiply(void) 1623 1623 + { 1624 1624 + if (verbose) puts("STUB: vS16HalfMultiply called"); 1625 1625 + return NULL; 1626 1626 + } 1627 1627 + 1628 1628 + void* vS256Add(void) 1629 1629 + { 1630 1630 + if (verbose) puts("STUB: vS256Add called"); 1631 1631 + return NULL; 1632 1632 + } 1633 1633 + 1634 1634 + void* vS256AddS(void) 1635 1635 + { 1636 1636 + if (verbose) puts("STUB: vS256AddS called"); 1637 1637 + return NULL; 1638 1638 + } 1639 1639 + 1640 1640 + void* vS256Divide(void) 1641 1641 + { 1642 1642 + if (verbose) puts("STUB: vS256Divide called"); 1643 1643 + return NULL; 1644 1644 + } 1645 1645 + 1646 1646 + void* vS256FullMultiply(void) 1647 1647 + { 1648 1648 + if (verbose) puts("STUB: vS256FullMultiply called"); 1649 1649 + return NULL; 1650 1650 + } 1651 1651 + 1652 1652 + void* vS256HalfMultiply(void) 1653 1653 + { 1654 1654 + if (verbose) puts("STUB: vS256HalfMultiply called"); 1655 1655 + return NULL; 1656 1656 + } 1657 1657 + 1658 1658 + void* vS256Mod(void) 1659 1659 + { 1660 1660 + if (verbose) puts("STUB: vS256Mod called"); 1661 1661 + return NULL; 1662 1662 + } 1663 1663 + 1664 1664 + void* vS256Neg(void) 1665 1665 + { 1666 1666 + if (verbose) puts("STUB: vS256Neg called"); 1667 1667 + return NULL; 1668 1668 + } 1669 1669 + 1670 1670 + void* vS256Sub(void) 1671 1671 + { 1672 1672 + if (verbose) puts("STUB: vS256Sub called"); 1673 1673 + return NULL; 1674 1674 + } 1675 1675 + 1676 1676 + void* vS256SubS(void) 1677 1677 + { 1678 1678 + if (verbose) puts("STUB: vS256SubS called"); 1679 1679 + return NULL; 1680 1680 + } 1681 1681 + 1682 1682 + void* vS32Divide(void) 1683 1683 + { 1684 1684 + if (verbose) puts("STUB: vS32Divide called"); 1685 1685 + return NULL; 1686 1686 + } 1687 1687 + 1688 1688 + void* vS32FullMulEven(void) 1689 1689 + { 1690 1690 + if (verbose) puts("STUB: vS32FullMulEven called"); 1691 1691 + return NULL; 1692 1692 + } 1693 1693 + 1694 1694 + void* vS32FullMulOdd(void) 1695 1695 + { 1696 1696 + if (verbose) puts("STUB: vS32FullMulOdd called"); 1697 1697 + return NULL; 1698 1698 + } 1699 1699 + 1700 1700 + void* vS32HalfMultiply(void) 1701 1701 + { 1702 1702 + if (verbose) puts("STUB: vS32HalfMultiply called"); 1703 1703 + return NULL; 1704 1704 + } 1705 1705 + 1706 1706 + void* vS512Add(void) 1707 1707 + { 1708 1708 + if (verbose) puts("STUB: vS512Add called"); 1709 1709 + return NULL; 1710 1710 + } 1711 1711 + 1712 1712 + void* vS512AddS(void) 1713 1713 + { 1714 1714 + if (verbose) puts("STUB: vS512AddS called"); 1715 1715 + return NULL; 1716 1716 + } 1717 1717 + 1718 1718 + void* vS512Divide(void) 1719 1719 + { 1720 1720 + if (verbose) puts("STUB: vS512Divide called"); 1721 1721 + return NULL; 1722 1722 + } 1723 1723 + 1724 1724 + void* vS512FullMultiply(void) 1725 1725 + { 1726 1726 + if (verbose) puts("STUB: vS512FullMultiply called"); 1727 1727 + return NULL; 1728 1728 + } 1729 1729 + 1730 1730 + void* vS512HalfMultiply(void) 1731 1731 + { 1732 1732 + if (verbose) puts("STUB: vS512HalfMultiply called"); 1733 1733 + return NULL; 1734 1734 + } 1735 1735 + 1736 1736 + void* vS512Mod(void) 1737 1737 + { 1738 1738 + if (verbose) puts("STUB: vS512Mod called"); 1739 1739 + return NULL; 1740 1740 + } 1741 1741 + 1742 1742 + void* vS512Neg(void) 1743 1743 + { 1744 1744 + if (verbose) puts("STUB: vS512Neg called"); 1745 1745 + return NULL; 1746 1746 + } 1747 1747 + 1748 1748 + void* vS512Sub(void) 1749 1749 + { 1750 1750 + if (verbose) puts("STUB: vS512Sub called"); 1751 1751 + return NULL; 1752 1752 + } 1753 1753 + 1754 1754 + void* vS512SubS(void) 1755 1755 + { 1756 1756 + if (verbose) puts("STUB: vS512SubS called"); 1757 1757 + return NULL; 1758 1758 + } 1759 1759 + 1760 1760 + void* vS64Add(void) 1761 1761 + { 1762 1762 + if (verbose) puts("STUB: vS64Add called"); 1763 1763 + return NULL; 1764 1764 + } 1765 1765 + 1766 1766 + void* vS64AddS(void) 1767 1767 + { 1768 1768 + if (verbose) puts("STUB: vS64AddS called"); 1769 1769 + return NULL; 1770 1770 + } 1771 1771 + 1772 1772 + void* vS64Divide(void) 1773 1773 + { 1774 1774 + if (verbose) puts("STUB: vS64Divide called"); 1775 1775 + return NULL; 1776 1776 + } 1777 1777 + 1778 1778 + void* vS64FullMulEven(void) 1779 1779 + { 1780 1780 + if (verbose) puts("STUB: vS64FullMulEven called"); 1781 1781 + return NULL; 1782 1782 + } 1783 1783 + 1784 1784 + void* vS64FullMulOdd(void) 1785 1785 + { 1786 1786 + if (verbose) puts("STUB: vS64FullMulOdd called"); 1787 1787 + return NULL; 1788 1788 + } 1789 1789 + 1790 1790 + void* vS64HalfMultiply(void) 1791 1791 + { 1792 1792 + if (verbose) puts("STUB: vS64HalfMultiply called"); 1793 1793 + return NULL; 1794 1794 + } 1795 1795 + 1796 1796 + void* vS64Neg(void) 1797 1797 + { 1798 1798 + if (verbose) puts("STUB: vS64Neg called"); 1799 1799 + return NULL; 1800 1800 + } 1801 1801 + 1802 1802 + void* vS64Sub(void) 1803 1803 + { 1804 1804 + if (verbose) puts("STUB: vS64Sub called"); 1805 1805 + return NULL; 1806 1806 + } 1807 1807 + 1808 1808 + void* vS64SubS(void) 1809 1809 + { 1810 1810 + if (verbose) puts("STUB: vS64SubS called"); 1811 1811 + return NULL; 1812 1812 + } 1813 1813 + 1814 1814 + void* vS8Divide(void) 1815 1815 + { 1816 1816 + if (verbose) puts("STUB: vS8Divide called"); 1817 1817 + return NULL; 1818 1818 + } 1819 1819 + 1820 1820 + void* vS8HalfMultiply(void) 1821 1821 + { 1822 1822 + if (verbose) puts("STUB: vS8HalfMultiply called"); 1823 1823 + return NULL; 1824 1824 + } 1825 1825 + 1826 1826 + void* vSasum(void) 1827 1827 + { 1828 1828 + if (verbose) puts("STUB: vSasum called"); 1829 1829 + return NULL; 1830 1830 + } 1831 1831 + 1832 1832 + void* vSaxpy(void) 1833 1833 + { 1834 1834 + if (verbose) puts("STUB: vSaxpy called"); 1835 1835 + return NULL; 1836 1836 + } 1837 1837 + 1838 1838 + void* vScopy(void) 1839 1839 + { 1840 1840 + if (verbose) puts("STUB: vScopy called"); 1841 1841 + return NULL; 1842 1842 + } 1843 1843 + 1844 1844 + void* vSdot(void) 1845 1845 + { 1846 1846 + if (verbose) puts("STUB: vSdot called"); 1847 1847 + return NULL; 1848 1848 + } 1849 1849 + 1850 1850 + void* vSgeadd(void) 1851 1851 + { 1852 1852 + if (verbose) puts("STUB: vSgeadd called"); 1853 1853 + return NULL; 1854 1854 + } 1855 1855 + 1856 1856 + void* vSgemm(void) 1857 1857 + { 1858 1858 + if (verbose) puts("STUB: vSgemm called"); 1859 1859 + return NULL; 1860 1860 + } 1861 1861 + 1862 1862 + void* vSgemtx(void) 1863 1863 + { 1864 1864 + if (verbose) puts("STUB: vSgemtx called"); 1865 1865 + return NULL; 1866 1866 + } 1867 1867 + 1868 1868 + void* vSgemul(void) 1869 1869 + { 1870 1870 + if (verbose) puts("STUB: vSgemul called"); 1871 1871 + return NULL; 1872 1872 + } 1873 1873 + 1874 1874 + void* vSgemv(void) 1875 1875 + { 1876 1876 + if (verbose) puts("STUB: vSgemv called"); 1877 1877 + return NULL; 1878 1878 + } 1879 1879 + 1880 1880 + void* vSgemx(void) 1881 1881 + { 1882 1882 + if (verbose) puts("STUB: vSgemx called"); 1883 1883 + return NULL; 1884 1884 + } 1885 1885 + 1886 1886 + void* vSgesub(void) 1887 1887 + { 1888 1888 + if (verbose) puts("STUB: vSgesub called"); 1889 1889 + return NULL; 1890 1890 + } 1891 1891 + 1892 1892 + void* vSgetmi(void) 1893 1893 + { 1894 1894 + if (verbose) puts("STUB: vSgetmi called"); 1895 1895 + return NULL; 1896 1896 + } 1897 1897 + 1898 1898 + void* vSgetmo(void) 1899 1899 + { 1900 1900 + if (verbose) puts("STUB: vSgetmo called"); 1901 1901 + return NULL; 1902 1902 + } 1903 1903 + 1904 1904 + void* vSgevv(void) 1905 1905 + { 1906 1906 + if (verbose) puts("STUB: vSgevv called"); 1907 1907 + return NULL; 1908 1908 + } 1909 1909 + 1910 1910 + void* vSnaxpy(void) 1911 1911 + { 1912 1912 + if (verbose) puts("STUB: vSnaxpy called"); 1913 1913 + return NULL; 1914 1914 + } 1915 1915 + 1916 1916 + void* vSndot(void) 1917 1917 + { 1918 1918 + if (verbose) puts("STUB: vSndot called"); 1919 1919 + return NULL; 1920 1920 + } 1921 1921 + 1922 1922 + void* vSnorm2(void) 1923 1923 + { 1924 1924 + if (verbose) puts("STUB: vSnorm2 called"); 1925 1925 + return NULL; 1926 1926 + } 1927 1927 + 1928 1928 + void* vSnrm2(void) 1929 1929 + { 1930 1930 + if (verbose) puts("STUB: vSnrm2 called"); 1931 1931 + return NULL; 1932 1932 + } 1933 1933 + 1934 1934 + void* vSrot(void) 1935 1935 + { 1936 1936 + if (verbose) puts("STUB: vSrot called"); 1937 1937 + return NULL; 1938 1938 + } 1939 1939 + 1940 1940 + void* vSscal(void) 1941 1941 + { 1942 1942 + if (verbose) puts("STUB: vSscal called"); 1943 1943 + return NULL; 1944 1944 + } 1945 1945 + 1946 1946 + void* vSsum(void) 1947 1947 + { 1948 1948 + if (verbose) puts("STUB: vSsum called"); 1949 1949 + return NULL; 1950 1950 + } 1951 1951 + 1952 1952 + void* vSswap(void) 1953 1953 + { 1954 1954 + if (verbose) puts("STUB: vSswap called"); 1955 1955 + return NULL; 1956 1956 + } 1957 1957 + 1958 1958 + void* vSyax(void) 1959 1959 + { 1960 1960 + if (verbose) puts("STUB: vSyax called"); 1961 1961 + return NULL; 1962 1962 + } 1963 1963 + 1964 1964 + void* vSzaxpy(void) 1965 1965 + { 1966 1966 + if (verbose) puts("STUB: vSzaxpy called"); 1967 1967 + return NULL; 1968 1968 + } 1969 1969 + 1970 1970 + void* vU1024Add(void) 1971 1971 + { 1972 1972 + if (verbose) puts("STUB: vU1024Add called"); 1973 1973 + return NULL; 1974 1974 + } 1975 1975 + 1976 1976 + void* vU1024AddS(void) 1977 1977 + { 1978 1978 + if (verbose) puts("STUB: vU1024AddS called"); 1979 1979 + return NULL; 1980 1980 + } 1981 1981 + 1982 1982 + void* vU1024Divide(void) 1983 1983 + { 1984 1984 + if (verbose) puts("STUB: vU1024Divide called"); 1985 1985 + return NULL; 1986 1986 + } 1987 1987 + 1988 1988 + void* vU1024HalfMultiply(void) 1989 1989 + { 1990 1990 + if (verbose) puts("STUB: vU1024HalfMultiply called"); 1991 1991 + return NULL; 1992 1992 + } 1993 1993 + 1994 1994 + void* vU1024Mod(void) 1995 1995 + { 1996 1996 + if (verbose) puts("STUB: vU1024Mod called"); 1997 1997 + return NULL; 1998 1998 + } 1999 1999 + 2000 2000 + void* vU1024Neg(void) 2001 2001 + { 2002 2002 + if (verbose) puts("STUB: vU1024Neg called"); 2003 2003 + return NULL; 2004 2004 + } 2005 2005 + 2006 2006 + void* vU1024Sub(void) 2007 2007 + { 2008 2008 + if (verbose) puts("STUB: vU1024Sub called"); 2009 2009 + return NULL; 2010 2010 + } 2011 2011 + 2012 2012 + void* vU1024SubS(void) 2013 2013 + { 2014 2014 + if (verbose) puts("STUB: vU1024SubS called"); 2015 2015 + return NULL; 2016 2016 + } 2017 2017 + 2018 2018 + void* vU128Add(void) 2019 2019 + { 2020 2020 + if (verbose) puts("STUB: vU128Add called"); 2021 2021 + return NULL; 2022 2022 + } 2023 2023 + 2024 2024 + void* vU128AddS(void) 2025 2025 + { 2026 2026 + if (verbose) puts("STUB: vU128AddS called"); 2027 2027 + return NULL; 2028 2028 + } 2029 2029 + 2030 2030 + void* vU128Divide(void) 2031 2031 + { 2032 2032 + if (verbose) puts("STUB: vU128Divide called"); 2033 2033 + return NULL; 2034 2034 + } 2035 2035 + 2036 2036 + void* vU128FullMultiply(void) 2037 2037 + { 2038 2038 + if (verbose) puts("STUB: vU128FullMultiply called"); 2039 2039 + return NULL; 2040 2040 + } 2041 2041 + 2042 2042 + void* vU128HalfMultiply(void) 2043 2043 + { 2044 2044 + if (verbose) puts("STUB: vU128HalfMultiply called"); 2045 2045 + return NULL; 2046 2046 + } 2047 2047 + 2048 2048 + void* vU128Neg(void) 2049 2049 + { 2050 2050 + if (verbose) puts("STUB: vU128Neg called"); 2051 2051 + return NULL; 2052 2052 + } 2053 2053 + 2054 2054 + void* vU128Sub(void) 2055 2055 + { 2056 2056 + if (verbose) puts("STUB: vU128Sub called"); 2057 2057 + return NULL; 2058 2058 + } 2059 2059 + 2060 2060 + void* vU128SubS(void) 2061 2061 + { 2062 2062 + if (verbose) puts("STUB: vU128SubS called"); 2063 2063 + return NULL; 2064 2064 + } 2065 2065 + 2066 2066 + void* vU16Divide(void) 2067 2067 + { 2068 2068 + if (verbose) puts("STUB: vU16Divide called"); 2069 2069 + return NULL; 2070 2070 + } 2071 2071 + 2072 2072 + void* vU16HalfMultiply(void) 2073 2073 + { 2074 2074 + if (verbose) puts("STUB: vU16HalfMultiply called"); 2075 2075 + return NULL; 2076 2076 + } 2077 2077 + 2078 2078 + void* vU256Add(void) 2079 2079 + { 2080 2080 + if (verbose) puts("STUB: vU256Add called"); 2081 2081 + return NULL; 2082 2082 + } 2083 2083 + 2084 2084 + void* vU256AddS(void) 2085 2085 + { 2086 2086 + if (verbose) puts("STUB: vU256AddS called"); 2087 2087 + return NULL; 2088 2088 + } 2089 2089 + 2090 2090 + void* vU256Divide(void) 2091 2091 + { 2092 2092 + if (verbose) puts("STUB: vU256Divide called"); 2093 2093 + return NULL; 2094 2094 + } 2095 2095 + 2096 2096 + void* vU256FullMultiply(void) 2097 2097 + { 2098 2098 + if (verbose) puts("STUB: vU256FullMultiply called"); 2099 2099 + return NULL; 2100 2100 + } 2101 2101 + 2102 2102 + void* vU256HalfMultiply(void) 2103 2103 + { 2104 2104 + if (verbose) puts("STUB: vU256HalfMultiply called"); 2105 2105 + return NULL; 2106 2106 + } 2107 2107 + 2108 2108 + void* vU256Mod(void) 2109 2109 + { 2110 2110 + if (verbose) puts("STUB: vU256Mod called"); 2111 2111 + return NULL; 2112 2112 + } 2113 2113 + 2114 2114 + void* vU256Neg(void) 2115 2115 + { 2116 2116 + if (verbose) puts("STUB: vU256Neg called"); 2117 2117 + return NULL; 2118 2118 + } 2119 2119 + 2120 2120 + void* vU256Sub(void) 2121 2121 + { 2122 2122 + if (verbose) puts("STUB: vU256Sub called"); 2123 2123 + return NULL; 2124 2124 + } 2125 2125 + 2126 2126 + void* vU256SubS(void) 2127 2127 + { 2128 2128 + if (verbose) puts("STUB: vU256SubS called"); 2129 2129 + return NULL; 2130 2130 + } 2131 2131 + 2132 2132 + void* vU32Divide(void) 2133 2133 + { 2134 2134 + if (verbose) puts("STUB: vU32Divide called"); 2135 2135 + return NULL; 2136 2136 + } 2137 2137 + 2138 2138 + void* vU32FullMulEven(void) 2139 2139 + { 2140 2140 + if (verbose) puts("STUB: vU32FullMulEven called"); 2141 2141 + return NULL; 2142 2142 + } 2143 2143 + 2144 2144 + void* vU32FullMulOdd(void) 2145 2145 + { 2146 2146 + if (verbose) puts("STUB: vU32FullMulOdd called"); 2147 2147 + return NULL; 2148 2148 + } 2149 2149 + 2150 2150 + void* vU32HalfMultiply(void) 2151 2151 + { 2152 2152 + if (verbose) puts("STUB: vU32HalfMultiply called"); 2153 2153 + return NULL; 2154 2154 + } 2155 2155 + 2156 2156 + void* vU512Add(void) 2157 2157 + { 2158 2158 + if (verbose) puts("STUB: vU512Add called"); 2159 2159 + return NULL; 2160 2160 + } 2161 2161 + 2162 2162 + void* vU512AddS(void) 2163 2163 + { 2164 2164 + if (verbose) puts("STUB: vU512AddS called"); 2165 2165 + return NULL; 2166 2166 + } 2167 2167 + 2168 2168 + void* vU512Divide(void) 2169 2169 + { 2170 2170 + if (verbose) puts("STUB: vU512Divide called"); 2171 2171 + return NULL; 2172 2172 + } 2173 2173 + 2174 2174 + void* vU512FullMultiply(void) 2175 2175 + { 2176 2176 + if (verbose) puts("STUB: vU512FullMultiply called"); 2177 2177 + return NULL; 2178 2178 + } 2179 2179 + 2180 2180 + void* vU512HalfMultiply(void) 2181 2181 + { 2182 2182 + if (verbose) puts("STUB: vU512HalfMultiply called"); 2183 2183 + return NULL; 2184 2184 + } 2185 2185 + 2186 2186 + void* vU512Mod(void) 2187 2187 + { 2188 2188 + if (verbose) puts("STUB: vU512Mod called"); 2189 2189 + return NULL; 2190 2190 + } 2191 2191 + 2192 2192 + void* vU512Neg(void) 2193 2193 + { 2194 2194 + if (verbose) puts("STUB: vU512Neg called"); 2195 2195 + return NULL; 2196 2196 + } 2197 2197 + 2198 2198 + void* vU512Sub(void) 2199 2199 + { 2200 2200 + if (verbose) puts("STUB: vU512Sub called"); 2201 2201 + return NULL; 2202 2202 + } 2203 2203 + 2204 2204 + void* vU512SubS(void) 2205 2205 + { 2206 2206 + if (verbose) puts("STUB: vU512SubS called"); 2207 2207 + return NULL; 2208 2208 + } 2209 2209 + 2210 2210 + void* vU64Add(void) 2211 2211 + { 2212 2212 + if (verbose) puts("STUB: vU64Add called"); 2213 2213 + return NULL; 2214 2214 + } 2215 2215 + 2216 2216 + void* vU64AddS(void) 2217 2217 + { 2218 2218 + if (verbose) puts("STUB: vU64AddS called"); 2219 2219 + return NULL; 2220 2220 + } 2221 2221 + 2222 2222 + void* vU64Divide(void) 2223 2223 + { 2224 2224 + if (verbose) puts("STUB: vU64Divide called"); 2225 2225 + return NULL; 2226 2226 + } 2227 2227 + 2228 2228 + void* vU64FullMulEven(void) 2229 2229 + { 2230 2230 + if (verbose) puts("STUB: vU64FullMulEven called"); 2231 2231 + return NULL; 2232 2232 + } 2233 2233 + 2234 2234 + void* vU64FullMulOdd(void) 2235 2235 + { 2236 2236 + if (verbose) puts("STUB: vU64FullMulOdd called"); 2237 2237 + return NULL; 2238 2238 + } 2239 2239 + 2240 2240 + void* vU64HalfMultiply(void) 2241 2241 + { 2242 2242 + if (verbose) puts("STUB: vU64HalfMultiply called"); 2243 2243 + return NULL; 2244 2244 + } 2245 2245 + 2246 2246 + void* vU64Neg(void) 2247 2247 + { 2248 2248 + if (verbose) puts("STUB: vU64Neg called"); 2249 2249 + return NULL; 2250 2250 + } 2251 2251 + 2252 2252 + void* vU64Sub(void) 2253 2253 + { 2254 2254 + if (verbose) puts("STUB: vU64Sub called"); 2255 2255 + return NULL; 2256 2256 + } 2257 2257 + 2258 2258 + void* vU64SubS(void) 2259 2259 + { 2260 2260 + if (verbose) puts("STUB: vU64SubS called"); 2261 2261 + return NULL; 2262 2262 + } 2263 2263 + 2264 2264 + void* vU8Divide(void) 2265 2265 + { 2266 2266 + if (verbose) puts("STUB: vU8Divide called"); 2267 2267 + return NULL; 2268 2268 + } 2269 2269 + 2270 2270 + void* vU8HalfMultiply(void) 2271 2271 + { 2272 2272 + if (verbose) puts("STUB: vU8HalfMultiply called"); 2273 2273 + return NULL; 2274 2274 + } 2275 2275 + 2276 2276 + void* vacosf(void) 2277 2277 + { 2278 2278 + if (verbose) puts("STUB: vacosf called"); 2279 2279 + return NULL; 2280 2280 + } 2281 2281 + 2282 2282 + void* vacoshf(void) 2283 2283 + { 2284 2284 + if (verbose) puts("STUB: vacoshf called"); 2285 2285 + return NULL; 2286 2286 + } 2287 2287 + 2288 2288 + void* vasinf(void) 2289 2289 + { 2290 2290 + if (verbose) puts("STUB: vasinf called"); 2291 2291 + return NULL; 2292 2292 + } 2293 2293 + 2294 2294 + void* vasinhf(void) 2295 2295 + { 2296 2296 + if (verbose) puts("STUB: vasinhf called"); 2297 2297 + return NULL; 2298 2298 + } 2299 2299 + 2300 2300 + void* vatan2f(void) 2301 2301 + { 2302 2302 + if (verbose) puts("STUB: vatan2f called"); 2303 2303 + return NULL; 2304 2304 + } 2305 2305 + 2306 2306 + void* vatanf(void) 2307 2307 + { 2308 2308 + if (verbose) puts("STUB: vatanf called"); 2309 2309 + return NULL; 2310 2310 + } 2311 2311 + 2312 2312 + void* vatanhf(void) 2313 2313 + { 2314 2314 + if (verbose) puts("STUB: vatanhf called"); 2315 2315 + return NULL; 2316 2316 + } 2317 2317 + 2318 2318 + void* vceilf(void) 2319 2319 + { 2320 2320 + if (verbose) puts("STUB: vceilf called"); 2321 2321 + return NULL; 2322 2322 + } 2323 2323 + 2324 2324 + void* vclassifyf(void) 2325 2325 + { 2326 2326 + if (verbose) puts("STUB: vclassifyf called"); 2327 2327 + return NULL; 2328 2328 + } 2329 2329 + 2330 2330 + void* vcopysignf(void) 2331 2331 + { 2332 2332 + if (verbose) puts("STUB: vcopysignf called"); 2333 2333 + return NULL; 2334 2334 + } 2335 2335 + 2336 2336 + void* vcosf(void) 2337 2337 + { 2338 2338 + if (verbose) puts("STUB: vcosf called"); 2339 2339 + return NULL; 2340 2340 + } 2341 2341 + 2342 2342 + void* vcoshf(void) 2343 2343 + { 2344 2344 + if (verbose) puts("STUB: vcoshf called"); 2345 2345 + return NULL; 2346 2346 + } 2347 2347 + 2348 2348 + void* vcospif(void) 2349 2349 + { 2350 2350 + if (verbose) puts("STUB: vcospif called"); 2351 2351 + return NULL; 2352 2352 + } 2353 2353 + 2354 2354 + void* vdivf(void) 2355 2355 + { 2356 2356 + if (verbose) puts("STUB: vdivf called"); 2357 2357 + return NULL; 2358 2358 + } 2359 2359 + 2360 2360 + void* vec_sdot(void) 2361 2361 + { 2362 2362 + if (verbose) puts("STUB: vec_sdot called"); 2363 2363 + return NULL; 2364 2364 + } 2365 2365 + 2366 2366 + void* vexp2f(void) 2367 2367 + { 2368 2368 + if (verbose) puts("STUB: vexp2f called"); 2369 2369 + return NULL; 2370 2370 + } 2371 2371 + 2372 2372 + void* vexpf(void) 2373 2373 + { 2374 2374 + if (verbose) puts("STUB: vexpf called"); 2375 2375 + return NULL; 2376 2376 + } 2377 2377 + 2378 2378 + void* vexpm1f(void) 2379 2379 + { 2380 2380 + if (verbose) puts("STUB: vexpm1f called"); 2381 2381 + return NULL; 2382 2382 + } 2383 2383 + 2384 2384 + void* vfabf(void) 2385 2385 + { 2386 2386 + if (verbose) puts("STUB: vfabf called"); 2387 2387 + return NULL; 2388 2388 + } 2389 2389 + 2390 2390 + void* vfabsf(void) 2391 2391 + { 2392 2392 + if (verbose) puts("STUB: vfabsf called"); 2393 2393 + return NULL; 2394 2394 + } 2395 2395 + 2396 2396 + void* vfloorf(void) 2397 2397 + { 2398 2398 + if (verbose) puts("STUB: vfloorf called"); 2399 2399 + return NULL; 2400 2400 + } 2401 2401 + 2402 2402 + void* vfmodf(void) 2403 2403 + { 2404 2404 + if (verbose) puts("STUB: vfmodf called"); 2405 2405 + return NULL; 2406 2406 + } 2407 2407 + 2408 2408 + void* vintf(void) 2409 2409 + { 2410 2410 + if (verbose) puts("STUB: vintf called"); 2411 2411 + return NULL; 2412 2412 + } 2413 2413 + 2414 2414 + void* vipowf(void) 2415 2415 + { 2416 2416 + if (verbose) puts("STUB: vipowf called"); 2417 2417 + return NULL; 2418 2418 + } 2419 2419 + 2420 2420 + void* vlog10f(void) 2421 2421 + { 2422 2422 + if (verbose) puts("STUB: vlog10f called"); 2423 2423 + return NULL; 2424 2424 + } 2425 2425 + 2426 2426 + void* vlog1pf(void) 2427 2427 + { 2428 2428 + if (verbose) puts("STUB: vlog1pf called"); 2429 2429 + return NULL; 2430 2430 + } 2431 2431 + 2432 2432 + void* vlog2f(void) 2433 2433 + { 2434 2434 + if (verbose) puts("STUB: vlog2f called"); 2435 2435 + return NULL; 2436 2436 + } 2437 2437 + 2438 2438 + void* vlogbf(void) 2439 2439 + { 2440 2440 + if (verbose) puts("STUB: vlogbf called"); 2441 2441 + return NULL; 2442 2442 + } 2443 2443 + 2444 2444 + void* vlogf(void) 2445 2445 + { 2446 2446 + if (verbose) puts("STUB: vlogf called"); 2447 2447 + return NULL; 2448 2448 + } 2449 2449 + 2450 2450 + void* vnextafterf(void) 2451 2451 + { 2452 2452 + if (verbose) puts("STUB: vnextafterf called"); 2453 2453 + return NULL; 2454 2454 + } 2455 2455 + 2456 2456 + void* vnintf(void) 2457 2457 + { 2458 2458 + if (verbose) puts("STUB: vnintf called"); 2459 2459 + return NULL; 2460 2460 + } 2461 2461 + 2462 2462 + void* vpowf(void) 2463 2463 + { 2464 2464 + if (verbose) puts("STUB: vpowf called"); 2465 2465 + return NULL; 2466 2466 + } 2467 2467 + 2468 2468 + void* vrecf(void) 2469 2469 + { 2470 2470 + if (verbose) puts("STUB: vrecf called"); 2471 2471 + return NULL; 2472 2472 + } 2473 2473 + 2474 2474 + void* vremainderf(void) 2475 2475 + { 2476 2476 + if (verbose) puts("STUB: vremainderf called"); 2477 2477 + return NULL; 2478 2478 + } 2479 2479 + 2480 2480 + void* vremquof(void) 2481 2481 + { 2482 2482 + if (verbose) puts("STUB: vremquof called"); 2483 2483 + return NULL; 2484 2484 + } 2485 2485 + 2486 2486 + void* vrsqrtf(void) 2487 2487 + { 2488 2488 + if (verbose) puts("STUB: vrsqrtf called"); 2489 2489 + return NULL; 2490 2490 + } 2491 2491 + 2492 2492 + void* vscalbf(void) 2493 2493 + { 2494 2494 + if (verbose) puts("STUB: vscalbf called"); 2495 2495 + return NULL; 2496 2496 + } 2497 2497 + 2498 2498 + void* vsignbitf(void) 2499 2499 + { 2500 2500 + if (verbose) puts("STUB: vsignbitf called"); 2501 2501 + return NULL; 2502 2502 + } 2503 2503 + 2504 2504 + void* vsincosf(void) 2505 2505 + { 2506 2506 + if (verbose) puts("STUB: vsincosf called"); 2507 2507 + return NULL; 2508 2508 + } 2509 2509 + 2510 2510 + void* vsinf(void) 2511 2511 + { 2512 2512 + if (verbose) puts("STUB: vsinf called"); 2513 2513 + return NULL; 2514 2514 + } 2515 2515 + 2516 2516 + void* vsinhf(void) 2517 2517 + { 2518 2518 + if (verbose) puts("STUB: vsinhf called"); 2519 2519 + return NULL; 2520 2520 + } 2521 2521 + 2522 2522 + void* vsinpif(void) 2523 2523 + { 2524 2524 + if (verbose) puts("STUB: vsinpif called"); 2525 2525 + return NULL; 2526 2526 + } 2527 2527 + 2528 2528 + void* vsqrtf(void) 2529 2529 + { 2530 2530 + if (verbose) puts("STUB: vsqrtf called"); 2531 2531 + return NULL; 2532 2532 + } 2533 2533 + 2534 2534 + void* vtablelookup(void) 2535 2535 + { 2536 2536 + if (verbose) puts("STUB: vtablelookup called"); 2537 2537 + return NULL; 2538 2538 + } 2539 2539 + 2540 2540 + void* vtanf(void) 2541 2541 + { 2542 2542 + if (verbose) puts("STUB: vtanf called"); 2543 2543 + return NULL; 2544 2544 + } 2545 2545 + 2546 2546 + void* vtanhf(void) 2547 2547 + { 2548 2548 + if (verbose) puts("STUB: vtanhf called"); 2549 2549 + return NULL; 2550 2550 + } 2551 2551 + 2552 2552 + void* vtanpif(void) 2553 2553 + { 2554 2554 + if (verbose) puts("STUB: vtanpif called"); 2555 2555 + return NULL; 2556 2556 + } 2557 2557 + 2558 2558 + void* vtruncf(void) 2559 2559 + { 2560 2560 + if (verbose) puts("STUB: vtruncf called"); 2561 2561 + return NULL; 2562 2562 + } 2563 2563 + 2564 2564 + void* vvacos(void) 2565 2565 + { 2566 2566 + if (verbose) puts("STUB: vvacos called"); 2567 2567 + return NULL; 2568 2568 + } 2569 2569 + 2570 2570 + void* vvacos_(void) 2571 2571 + { 2572 2572 + if (verbose) puts("STUB: vvacos_ called"); 2573 2573 + return NULL; 2574 2574 + } 2575 2575 + 2576 2576 + void* vvacosf(void) 2577 2577 + { 2578 2578 + if (verbose) puts("STUB: vvacosf called"); 2579 2579 + return NULL; 2580 2580 + } 2581 2581 + 2582 2582 + void* vvacosf_(void) 2583 2583 + { 2584 2584 + if (verbose) puts("STUB: vvacosf_ called"); 2585 2585 + return NULL; 2586 2586 + } 2587 2587 + 2588 2588 + void* vvacosh(void) 2589 2589 + { 2590 2590 + if (verbose) puts("STUB: vvacosh called"); 2591 2591 + return NULL; 2592 2592 + } 2593 2593 + 2594 2594 + void* vvacosh_(void) 2595 2595 + { 2596 2596 + if (verbose) puts("STUB: vvacosh_ called"); 2597 2597 + return NULL; 2598 2598 + } 2599 2599 + 2600 2600 + void* vvacoshf(void) 2601 2601 + { 2602 2602 + if (verbose) puts("STUB: vvacoshf called"); 2603 2603 + return NULL; 2604 2604 + } 2605 2605 + 2606 2606 + void* vvacoshf_(void) 2607 2607 + { 2608 2608 + if (verbose) puts("STUB: vvacoshf_ called"); 2609 2609 + return NULL; 2610 2610 + } 2611 2611 + 2612 2612 + void* vvasin(void) 2613 2613 + { 2614 2614 + if (verbose) puts("STUB: vvasin called"); 2615 2615 + return NULL; 2616 2616 + } 2617 2617 + 2618 2618 + void* vvasin_(void) 2619 2619 + { 2620 2620 + if (verbose) puts("STUB: vvasin_ called"); 2621 2621 + return NULL; 2622 2622 + } 2623 2623 + 2624 2624 + void* vvasinf(void) 2625 2625 + { 2626 2626 + if (verbose) puts("STUB: vvasinf called"); 2627 2627 + return NULL; 2628 2628 + } 2629 2629 + 2630 2630 + void* vvasinf_(void) 2631 2631 + { 2632 2632 + if (verbose) puts("STUB: vvasinf_ called"); 2633 2633 + return NULL; 2634 2634 + } 2635 2635 + 2636 2636 + void* vvasinh(void) 2637 2637 + { 2638 2638 + if (verbose) puts("STUB: vvasinh called"); 2639 2639 + return NULL; 2640 2640 + } 2641 2641 + 2642 2642 + void* vvasinh_(void) 2643 2643 + { 2644 2644 + if (verbose) puts("STUB: vvasinh_ called"); 2645 2645 + return NULL; 2646 2646 + } 2647 2647 + 2648 2648 + void* vvasinhf(void) 2649 2649 + { 2650 2650 + if (verbose) puts("STUB: vvasinhf called"); 2651 2651 + return NULL; 2652 2652 + } 2653 2653 + 2654 2654 + void* vvasinhf_(void) 2655 2655 + { 2656 2656 + if (verbose) puts("STUB: vvasinhf_ called"); 2657 2657 + return NULL; 2658 2658 + } 2659 2659 + 2660 2660 + void* vvatan(void) 2661 2661 + { 2662 2662 + if (verbose) puts("STUB: vvatan called"); 2663 2663 + return NULL; 2664 2664 + } 2665 2665 + 2666 2666 + void* vvatan2(void) 2667 2667 + { 2668 2668 + if (verbose) puts("STUB: vvatan2 called"); 2669 2669 + return NULL; 2670 2670 + } 2671 2671 + 2672 2672 + void* vvatan2_(void) 2673 2673 + { 2674 2674 + if (verbose) puts("STUB: vvatan2_ called"); 2675 2675 + return NULL; 2676 2676 + } 2677 2677 + 2678 2678 + void* vvatan2f(void) 2679 2679 + { 2680 2680 + if (verbose) puts("STUB: vvatan2f called"); 2681 2681 + return NULL; 2682 2682 + } 2683 2683 + 2684 2684 + void* vvatan2f_(void) 2685 2685 + { 2686 2686 + if (verbose) puts("STUB: vvatan2f_ called"); 2687 2687 + return NULL; 2688 2688 + } 2689 2689 + 2690 2690 + void* vvatan_(void) 2691 2691 + { 2692 2692 + if (verbose) puts("STUB: vvatan_ called"); 2693 2693 + return NULL; 2694 2694 + } 2695 2695 + 2696 2696 + void* vvatanf(void) 2697 2697 + { 2698 2698 + if (verbose) puts("STUB: vvatanf called"); 2699 2699 + return NULL; 2700 2700 + } 2701 2701 + 2702 2702 + void* vvatanf_(void) 2703 2703 + { 2704 2704 + if (verbose) puts("STUB: vvatanf_ called"); 2705 2705 + return NULL; 2706 2706 + } 2707 2707 + 2708 2708 + void* vvatanh(void) 2709 2709 + { 2710 2710 + if (verbose) puts("STUB: vvatanh called"); 2711 2711 + return NULL; 2712 2712 + } 2713 2713 + 2714 2714 + void* vvatanh_(void) 2715 2715 + { 2716 2716 + if (verbose) puts("STUB: vvatanh_ called"); 2717 2717 + return NULL; 2718 2718 + } 2719 2719 + 2720 2720 + void* vvatanhf(void) 2721 2721 + { 2722 2722 + if (verbose) puts("STUB: vvatanhf called"); 2723 2723 + return NULL; 2724 2724 + } 2725 2725 + 2726 2726 + void* vvatanhf_(void) 2727 2727 + { 2728 2728 + if (verbose) puts("STUB: vvatanhf_ called"); 2729 2729 + return NULL; 2730 2730 + } 2731 2731 + 2732 2732 + void* vvcbrt(void) 2733 2733 + { 2734 2734 + if (verbose) puts("STUB: vvcbrt called"); 2735 2735 + return NULL; 2736 2736 + } 2737 2737 + 2738 2738 + void* vvcbrt_(void) 2739 2739 + { 2740 2740 + if (verbose) puts("STUB: vvcbrt_ called"); 2741 2741 + return NULL; 2742 2742 + } 2743 2743 + 2744 2744 + void* vvcbrtf(void) 2745 2745 + { 2746 2746 + if (verbose) puts("STUB: vvcbrtf called"); 2747 2747 + return NULL; 2748 2748 + } 2749 2749 + 2750 2750 + void* vvcbrtf_(void) 2751 2751 + { 2752 2752 + if (verbose) puts("STUB: vvcbrtf_ called"); 2753 2753 + return NULL; 2754 2754 + } 2755 2755 + 2756 2756 + void* vvceil(void) 2757 2757 + { 2758 2758 + if (verbose) puts("STUB: vvceil called"); 2759 2759 + return NULL; 2760 2760 + } 2761 2761 + 2762 2762 + void* vvceil_(void) 2763 2763 + { 2764 2764 + if (verbose) puts("STUB: vvceil_ called"); 2765 2765 + return NULL; 2766 2766 + } 2767 2767 + 2768 2768 + void* vvceilf(void) 2769 2769 + { 2770 2770 + if (verbose) puts("STUB: vvceilf called"); 2771 2771 + return NULL; 2772 2772 + } 2773 2773 + 2774 2774 + void* vvceilf_(void) 2775 2775 + { 2776 2776 + if (verbose) puts("STUB: vvceilf_ called"); 2777 2777 + return NULL; 2778 2778 + } 2779 2779 + 2780 2780 + void* vvcopysign(void) 2781 2781 + { 2782 2782 + if (verbose) puts("STUB: vvcopysign called"); 2783 2783 + return NULL; 2784 2784 + } 2785 2785 + 2786 2786 + void* vvcopysign_(void) 2787 2787 + { 2788 2788 + if (verbose) puts("STUB: vvcopysign_ called"); 2789 2789 + return NULL; 2790 2790 + } 2791 2791 + 2792 2792 + void* vvcopysignf(void) 2793 2793 + { 2794 2794 + if (verbose) puts("STUB: vvcopysignf called"); 2795 2795 + return NULL; 2796 2796 + } 2797 2797 + 2798 2798 + void* vvcopysignf_(void) 2799 2799 + { 2800 2800 + if (verbose) puts("STUB: vvcopysignf_ called"); 2801 2801 + return NULL; 2802 2802 + } 2803 2803 + 2804 2804 + void* vvcos(void) 2805 2805 + { 2806 2806 + if (verbose) puts("STUB: vvcos called"); 2807 2807 + return NULL; 2808 2808 + } 2809 2809 + 2810 2810 + void* vvcos_(void) 2811 2811 + { 2812 2812 + if (verbose) puts("STUB: vvcos_ called"); 2813 2813 + return NULL; 2814 2814 + } 2815 2815 + 2816 2816 + void* vvcosf(void) 2817 2817 + { 2818 2818 + if (verbose) puts("STUB: vvcosf called"); 2819 2819 + return NULL; 2820 2820 + } 2821 2821 + 2822 2822 + void* vvcosf_(void) 2823 2823 + { 2824 2824 + if (verbose) puts("STUB: vvcosf_ called"); 2825 2825 + return NULL; 2826 2826 + } 2827 2827 + 2828 2828 + void* vvcosh(void) 2829 2829 + { 2830 2830 + if (verbose) puts("STUB: vvcosh called"); 2831 2831 + return NULL; 2832 2832 + } 2833 2833 + 2834 2834 + void* vvcosh_(void) 2835 2835 + { 2836 2836 + if (verbose) puts("STUB: vvcosh_ called"); 2837 2837 + return NULL; 2838 2838 + } 2839 2839 + 2840 2840 + void* vvcoshf(void) 2841 2841 + { 2842 2842 + if (verbose) puts("STUB: vvcoshf called"); 2843 2843 + return NULL; 2844 2844 + } 2845 2845 + 2846 2846 + void* vvcoshf_(void) 2847 2847 + { 2848 2848 + if (verbose) puts("STUB: vvcoshf_ called"); 2849 2849 + return NULL; 2850 2850 + } 2851 2851 + 2852 2852 + void* vvcosisin(void) 2853 2853 + { 2854 2854 + if (verbose) puts("STUB: vvcosisin called"); 2855 2855 + return NULL; 2856 2856 + } 2857 2857 + 2858 2858 + void* vvcosisin_(void) 2859 2859 + { 2860 2860 + if (verbose) puts("STUB: vvcosisin_ called"); 2861 2861 + return NULL; 2862 2862 + } 2863 2863 + 2864 2864 + void* vvcosisinf(void) 2865 2865 + { 2866 2866 + if (verbose) puts("STUB: vvcosisinf called"); 2867 2867 + return NULL; 2868 2868 + } 2869 2869 + 2870 2870 + void* vvcosisinf_(void) 2871 2871 + { 2872 2872 + if (verbose) puts("STUB: vvcosisinf_ called"); 2873 2873 + return NULL; 2874 2874 + } 2875 2875 + 2876 2876 + void* vvcospi(void) 2877 2877 + { 2878 2878 + if (verbose) puts("STUB: vvcospi called"); 2879 2879 + return NULL; 2880 2880 + } 2881 2881 + 2882 2882 + void* vvcospi_(void) 2883 2883 + { 2884 2884 + if (verbose) puts("STUB: vvcospi_ called"); 2885 2885 + return NULL; 2886 2886 + } 2887 2887 + 2888 2888 + void* vvcospif(void) 2889 2889 + { 2890 2890 + if (verbose) puts("STUB: vvcospif called"); 2891 2891 + return NULL; 2892 2892 + } 2893 2893 + 2894 2894 + void* vvcospif_(void) 2895 2895 + { 2896 2896 + if (verbose) puts("STUB: vvcospif_ called"); 2897 2897 + return NULL; 2898 2898 + } 2899 2899 + 2900 2900 + void* vvdiv(void) 2901 2901 + { 2902 2902 + if (verbose) puts("STUB: vvdiv called"); 2903 2903 + return NULL; 2904 2904 + } 2905 2905 + 2906 2906 + void* vvdiv_(void) 2907 2907 + { 2908 2908 + if (verbose) puts("STUB: vvdiv_ called"); 2909 2909 + return NULL; 2910 2910 + } 2911 2911 + 2912 2912 + void* vvdivf(void) 2913 2913 + { 2914 2914 + if (verbose) puts("STUB: vvdivf called"); 2915 2915 + return NULL; 2916 2916 + } 2917 2917 + 2918 2918 + void* vvdivf_(void) 2919 2919 + { 2920 2920 + if (verbose) puts("STUB: vvdivf_ called"); 2921 2921 + return NULL; 2922 2922 + } 2923 2923 + 2924 2924 + void* vvexp(void) 2925 2925 + { 2926 2926 + if (verbose) puts("STUB: vvexp called"); 2927 2927 + return NULL; 2928 2928 + } 2929 2929 + 2930 2930 + void* vvexp2(void) 2931 2931 + { 2932 2932 + if (verbose) puts("STUB: vvexp2 called"); 2933 2933 + return NULL; 2934 2934 + } 2935 2935 + 2936 2936 + void* vvexp2_(void) 2937 2937 + { 2938 2938 + if (verbose) puts("STUB: vvexp2_ called"); 2939 2939 + return NULL; 2940 2940 + } 2941 2941 + 2942 2942 + void* vvexp2f(void) 2943 2943 + { 2944 2944 + if (verbose) puts("STUB: vvexp2f called"); 2945 2945 + return NULL; 2946 2946 + } 2947 2947 + 2948 2948 + void* vvexp2f_(void) 2949 2949 + { 2950 2950 + if (verbose) puts("STUB: vvexp2f_ called"); 2951 2951 + return NULL; 2952 2952 + } 2953 2953 + 2954 2954 + void* vvexp_(void) 2955 2955 + { 2956 2956 + if (verbose) puts("STUB: vvexp_ called"); 2957 2957 + return NULL; 2958 2958 + } 2959 2959 + 2960 2960 + void* vvexpf(void) 2961 2961 + { 2962 2962 + if (verbose) puts("STUB: vvexpf called"); 2963 2963 + return NULL; 2964 2964 + } 2965 2965 + 2966 2966 + void* vvexpf_(void) 2967 2967 + { 2968 2968 + if (verbose) puts("STUB: vvexpf_ called"); 2969 2969 + return NULL; 2970 2970 + } 2971 2971 + 2972 2972 + void* vvexpm1(void) 2973 2973 + { 2974 2974 + if (verbose) puts("STUB: vvexpm1 called"); 2975 2975 + return NULL; 2976 2976 + } 2977 2977 + 2978 2978 + void* vvexpm1_(void) 2979 2979 + { 2980 2980 + if (verbose) puts("STUB: vvexpm1_ called"); 2981 2981 + return NULL; 2982 2982 + } 2983 2983 + 2984 2984 + void* vvexpm1f(void) 2985 2985 + { 2986 2986 + if (verbose) puts("STUB: vvexpm1f called"); 2987 2987 + return NULL; 2988 2988 + } 2989 2989 + 2990 2990 + void* vvexpm1f_(void) 2991 2991 + { 2992 2992 + if (verbose) puts("STUB: vvexpm1f_ called"); 2993 2993 + return NULL; 2994 2994 + } 2995 2995 + 2996 2996 + void* vvfabf(void) 2997 2997 + { 2998 2998 + if (verbose) puts("STUB: vvfabf called"); 2999 2999 + return NULL; 3000 3000 + } 3001 3001 + 3002 3002 + void* vvfabf_(void) 3003 3003 + { 3004 3004 + if (verbose) puts("STUB: vvfabf_ called"); 3005 3005 + return NULL; 3006 3006 + } 3007 3007 + 3008 3008 + void* vvfabs(void) 3009 3009 + { 3010 3010 + if (verbose) puts("STUB: vvfabs called"); 3011 3011 + return NULL; 3012 3012 + } 3013 3013 + 3014 3014 + void* vvfabs_(void) 3015 3015 + { 3016 3016 + if (verbose) puts("STUB: vvfabs_ called"); 3017 3017 + return NULL; 3018 3018 + } 3019 3019 + 3020 3020 + void* vvfabsf(void) 3021 3021 + { 3022 3022 + if (verbose) puts("STUB: vvfabsf called"); 3023 3023 + return NULL; 3024 3024 + } 3025 3025 + 3026 3026 + void* vvfabsf_(void) 3027 3027 + { 3028 3028 + if (verbose) puts("STUB: vvfabsf_ called"); 3029 3029 + return NULL; 3030 3030 + } 3031 3031 + 3032 3032 + void* vvfloor(void) 3033 3033 + { 3034 3034 + if (verbose) puts("STUB: vvfloor called"); 3035 3035 + return NULL; 3036 3036 + } 3037 3037 + 3038 3038 + void* vvfloor_(void) 3039 3039 + { 3040 3040 + if (verbose) puts("STUB: vvfloor_ called"); 3041 3041 + return NULL; 3042 3042 + } 3043 3043 + 3044 3044 + void* vvfloorf(void) 3045 3045 + { 3046 3046 + if (verbose) puts("STUB: vvfloorf called"); 3047 3047 + return NULL; 3048 3048 + } 3049 3049 + 3050 3050 + void* vvfloorf_(void) 3051 3051 + { 3052 3052 + if (verbose) puts("STUB: vvfloorf_ called"); 3053 3053 + return NULL; 3054 3054 + } 3055 3055 + 3056 3056 + void* vvfmod(void) 3057 3057 + { 3058 3058 + if (verbose) puts("STUB: vvfmod called"); 3059 3059 + return NULL; 3060 3060 + } 3061 3061 + 3062 3062 + void* vvfmod_(void) 3063 3063 + { 3064 3064 + if (verbose) puts("STUB: vvfmod_ called"); 3065 3065 + return NULL; 3066 3066 + } 3067 3067 + 3068 3068 + void* vvfmodf(void) 3069 3069 + { 3070 3070 + if (verbose) puts("STUB: vvfmodf called"); 3071 3071 + return NULL; 3072 3072 + } 3073 3073 + 3074 3074 + void* vvfmodf_(void) 3075 3075 + { 3076 3076 + if (verbose) puts("STUB: vvfmodf_ called"); 3077 3077 + return NULL; 3078 3078 + } 3079 3079 + 3080 3080 + void* vvint(void) 3081 3081 + { 3082 3082 + if (verbose) puts("STUB: vvint called"); 3083 3083 + return NULL; 3084 3084 + } 3085 3085 + 3086 3086 + void* vvint_(void) 3087 3087 + { 3088 3088 + if (verbose) puts("STUB: vvint_ called"); 3089 3089 + return NULL; 3090 3090 + } 3091 3091 + 3092 3092 + void* vvintf(void) 3093 3093 + { 3094 3094 + if (verbose) puts("STUB: vvintf called"); 3095 3095 + return NULL; 3096 3096 + } 3097 3097 + 3098 3098 + void* vvintf_(void) 3099 3099 + { 3100 3100 + if (verbose) puts("STUB: vvintf_ called"); 3101 3101 + return NULL; 3102 3102 + } 3103 3103 + 3104 3104 + void* vvlog(void) 3105 3105 + { 3106 3106 + if (verbose) puts("STUB: vvlog called"); 3107 3107 + return NULL; 3108 3108 + } 3109 3109 + 3110 3110 + void* vvlog10(void) 3111 3111 + { 3112 3112 + if (verbose) puts("STUB: vvlog10 called"); 3113 3113 + return NULL; 3114 3114 + } 3115 3115 + 3116 3116 + void* vvlog10_(void) 3117 3117 + { 3118 3118 + if (verbose) puts("STUB: vvlog10_ called"); 3119 3119 + return NULL; 3120 3120 + } 3121 3121 + 3122 3122 + void* vvlog10f(void) 3123 3123 + { 3124 3124 + if (verbose) puts("STUB: vvlog10f called"); 3125 3125 + return NULL; 3126 3126 + } 3127 3127 + 3128 3128 + void* vvlog10f_(void) 3129 3129 + { 3130 3130 + if (verbose) puts("STUB: vvlog10f_ called"); 3131 3131 + return NULL; 3132 3132 + } 3133 3133 + 3134 3134 + void* vvlog1p(void) 3135 3135 + { 3136 3136 + if (verbose) puts("STUB: vvlog1p called"); 3137 3137 + return NULL; 3138 3138 + } 3139 3139 + 3140 3140 + void* vvlog1p_(void) 3141 3141 + { 3142 3142 + if (verbose) puts("STUB: vvlog1p_ called"); 3143 3143 + return NULL; 3144 3144 + } 3145 3145 + 3146 3146 + void* vvlog1pf(void) 3147 3147 + { 3148 3148 + if (verbose) puts("STUB: vvlog1pf called"); 3149 3149 + return NULL; 3150 3150 + } 3151 3151 + 3152 3152 + void* vvlog1pf_(void) 3153 3153 + { 3154 3154 + if (verbose) puts("STUB: vvlog1pf_ called"); 3155 3155 + return NULL; 3156 3156 + } 3157 3157 + 3158 3158 + void* vvlog2(void) 3159 3159 + { 3160 3160 + if (verbose) puts("STUB: vvlog2 called"); 3161 3161 + return NULL; 3162 3162 + } 3163 3163 + 3164 3164 + void* vvlog2_(void) 3165 3165 + { 3166 3166 + if (verbose) puts("STUB: vvlog2_ called"); 3167 3167 + return NULL; 3168 3168 + } 3169 3169 + 3170 3170 + void* vvlog2f(void) 3171 3171 + { 3172 3172 + if (verbose) puts("STUB: vvlog2f called"); 3173 3173 + return NULL; 3174 3174 + } 3175 3175 + 3176 3176 + void* vvlog2f_(void) 3177 3177 + { 3178 3178 + if (verbose) puts("STUB: vvlog2f_ called"); 3179 3179 + return NULL; 3180 3180 + } 3181 3181 + 3182 3182 + void* vvlog_(void) 3183 3183 + { 3184 3184 + if (verbose) puts("STUB: vvlog_ called"); 3185 3185 + return NULL; 3186 3186 + } 3187 3187 + 3188 3188 + void* vvlogb(void) 3189 3189 + { 3190 3190 + if (verbose) puts("STUB: vvlogb called"); 3191 3191 + return NULL; 3192 3192 + } 3193 3193 + 3194 3194 + void* vvlogb_(void) 3195 3195 + { 3196 3196 + if (verbose) puts("STUB: vvlogb_ called"); 3197 3197 + return NULL; 3198 3198 + } 3199 3199 + 3200 3200 + void* vvlogbf(void) 3201 3201 + { 3202 3202 + if (verbose) puts("STUB: vvlogbf called"); 3203 3203 + return NULL; 3204 3204 + } 3205 3205 + 3206 3206 + void* vvlogbf_(void) 3207 3207 + { 3208 3208 + if (verbose) puts("STUB: vvlogbf_ called"); 3209 3209 + return NULL; 3210 3210 + } 3211 3211 + 3212 3212 + void* vvlogf(void) 3213 3213 + { 3214 3214 + if (verbose) puts("STUB: vvlogf called"); 3215 3215 + return NULL; 3216 3216 + } 3217 3217 + 3218 3218 + void* vvlogf_(void) 3219 3219 + { 3220 3220 + if (verbose) puts("STUB: vvlogf_ called"); 3221 3221 + return NULL; 3222 3222 + } 3223 3223 + 3224 3224 + void* vvnextafter(void) 3225 3225 + { 3226 3226 + if (verbose) puts("STUB: vvnextafter called"); 3227 3227 + return NULL; 3228 3228 + } 3229 3229 + 3230 3230 + void* vvnextafter_(void) 3231 3231 + { 3232 3232 + if (verbose) puts("STUB: vvnextafter_ called"); 3233 3233 + return NULL; 3234 3234 + } 3235 3235 + 3236 3236 + void* vvnextafterf(void) 3237 3237 + { 3238 3238 + if (verbose) puts("STUB: vvnextafterf called"); 3239 3239 + return NULL; 3240 3240 + } 3241 3241 + 3242 3242 + void* vvnextafterf_(void) 3243 3243 + { 3244 3244 + if (verbose) puts("STUB: vvnextafterf_ called"); 3245 3245 + return NULL; 3246 3246 + } 3247 3247 + 3248 3248 + void* vvnint(void) 3249 3249 + { 3250 3250 + if (verbose) puts("STUB: vvnint called"); 3251 3251 + return NULL; 3252 3252 + } 3253 3253 + 3254 3254 + void* vvnint_(void) 3255 3255 + { 3256 3256 + if (verbose) puts("STUB: vvnint_ called"); 3257 3257 + return NULL; 3258 3258 + } 3259 3259 + 3260 3260 + void* vvnintf(void) 3261 3261 + { 3262 3262 + if (verbose) puts("STUB: vvnintf called"); 3263 3263 + return NULL; 3264 3264 + } 3265 3265 + 3266 3266 + void* vvnintf_(void) 3267 3267 + { 3268 3268 + if (verbose) puts("STUB: vvnintf_ called"); 3269 3269 + return NULL; 3270 3270 + } 3271 3271 + 3272 3272 + void* vvpow(void) 3273 3273 + { 3274 3274 + if (verbose) puts("STUB: vvpow called"); 3275 3275 + return NULL; 3276 3276 + } 3277 3277 + 3278 3278 + void* vvpow_(void) 3279 3279 + { 3280 3280 + if (verbose) puts("STUB: vvpow_ called"); 3281 3281 + return NULL; 3282 3282 + } 3283 3283 + 3284 3284 + void* vvpowf(void) 3285 3285 + { 3286 3286 + if (verbose) puts("STUB: vvpowf called"); 3287 3287 + return NULL; 3288 3288 + } 3289 3289 + 3290 3290 + void* vvpowf_(void) 3291 3291 + { 3292 3292 + if (verbose) puts("STUB: vvpowf_ called"); 3293 3293 + return NULL; 3294 3294 + } 3295 3295 + 3296 3296 + void* vvpows(void) 3297 3297 + { 3298 3298 + if (verbose) puts("STUB: vvpows called"); 3299 3299 + return NULL; 3300 3300 + } 3301 3301 + 3302 3302 + void* vvpows_(void) 3303 3303 + { 3304 3304 + if (verbose) puts("STUB: vvpows_ called"); 3305 3305 + return NULL; 3306 3306 + } 3307 3307 + 3308 3308 + void* vvpowsf(void) 3309 3309 + { 3310 3310 + if (verbose) puts("STUB: vvpowsf called"); 3311 3311 + return NULL; 3312 3312 + } 3313 3313 + 3314 3314 + void* vvpowsf_(void) 3315 3315 + { 3316 3316 + if (verbose) puts("STUB: vvpowsf_ called"); 3317 3317 + return NULL; 3318 3318 + } 3319 3319 + 3320 3320 + void* vvrec(void) 3321 3321 + { 3322 3322 + if (verbose) puts("STUB: vvrec called"); 3323 3323 + return NULL; 3324 3324 + } 3325 3325 + 3326 3326 + void* vvrec_(void) 3327 3327 + { 3328 3328 + if (verbose) puts("STUB: vvrec_ called"); 3329 3329 + return NULL; 3330 3330 + } 3331 3331 + 3332 3332 + void* vvrecf(void) 3333 3333 + { 3334 3334 + if (verbose) puts("STUB: vvrecf called"); 3335 3335 + return NULL; 3336 3336 + } 3337 3337 + 3338 3338 + void* vvrecf_(void) 3339 3339 + { 3340 3340 + if (verbose) puts("STUB: vvrecf_ called"); 3341 3341 + return NULL; 3342 3342 + } 3343 3343 + 3344 3344 + void* vvremainder(void) 3345 3345 + { 3346 3346 + if (verbose) puts("STUB: vvremainder called"); 3347 3347 + return NULL; 3348 3348 + } 3349 3349 + 3350 3350 + void* vvremainder_(void) 3351 3351 + { 3352 3352 + if (verbose) puts("STUB: vvremainder_ called"); 3353 3353 + return NULL; 3354 3354 + } 3355 3355 + 3356 3356 + void* vvremainderf(void) 3357 3357 + { 3358 3358 + if (verbose) puts("STUB: vvremainderf called"); 3359 3359 + return NULL; 3360 3360 + } 3361 3361 + 3362 3362 + void* vvremainderf_(void) 3363 3363 + { 3364 3364 + if (verbose) puts("STUB: vvremainderf_ called"); 3365 3365 + return NULL; 3366 3366 + } 3367 3367 + 3368 3368 + void* vvrsqrt(void) 3369 3369 + { 3370 3370 + if (verbose) puts("STUB: vvrsqrt called"); 3371 3371 + return NULL; 3372 3372 + } 3373 3373 + 3374 3374 + void* vvrsqrt_(void) 3375 3375 + { 3376 3376 + if (verbose) puts("STUB: vvrsqrt_ called"); 3377 3377 + return NULL; 3378 3378 + } 3379 3379 + 3380 3380 + void* vvrsqrtf(void) 3381 3381 + { 3382 3382 + if (verbose) puts("STUB: vvrsqrtf called"); 3383 3383 + return NULL; 3384 3384 + } 3385 3385 + 3386 3386 + void* vvrsqrtf_(void) 3387 3387 + { 3388 3388 + if (verbose) puts("STUB: vvrsqrtf_ called"); 3389 3389 + return NULL; 3390 3390 + } 3391 3391 + 3392 3392 + void* vvsin(void) 3393 3393 + { 3394 3394 + if (verbose) puts("STUB: vvsin called"); 3395 3395 + return NULL; 3396 3396 + } 3397 3397 + 3398 3398 + void* vvsin_(void) 3399 3399 + { 3400 3400 + if (verbose) puts("STUB: vvsin_ called"); 3401 3401 + return NULL; 3402 3402 + } 3403 3403 + 3404 3404 + void* vvsincos(void) 3405 3405 + { 3406 3406 + if (verbose) puts("STUB: vvsincos called"); 3407 3407 + return NULL; 3408 3408 + } 3409 3409 + 3410 3410 + void* vvsincos_(void) 3411 3411 + { 3412 3412 + if (verbose) puts("STUB: vvsincos_ called"); 3413 3413 + return NULL; 3414 3414 + } 3415 3415 + 3416 3416 + void* vvsincosf(void) 3417 3417 + { 3418 3418 + if (verbose) puts("STUB: vvsincosf called"); 3419 3419 + return NULL; 3420 3420 + } 3421 3421 + 3422 3422 + void* vvsincosf_(void) 3423 3423 + { 3424 3424 + if (verbose) puts("STUB: vvsincosf_ called"); 3425 3425 + return NULL; 3426 3426 + } 3427 3427 + 3428 3428 + void* vvsinf(void) 3429 3429 + { 3430 3430 + if (verbose) puts("STUB: vvsinf called"); 3431 3431 + return NULL; 3432 3432 + } 3433 3433 + 3434 3434 + void* vvsinf_(void) 3435 3435 + { 3436 3436 + if (verbose) puts("STUB: vvsinf_ called"); 3437 3437 + return NULL; 3438 3438 + } 3439 3439 + 3440 3440 + void* vvsinh(void) 3441 3441 + { 3442 3442 + if (verbose) puts("STUB: vvsinh called"); 3443 3443 + return NULL; 3444 3444 + } 3445 3445 + 3446 3446 + void* vvsinh_(void) 3447 3447 + { 3448 3448 + if (verbose) puts("STUB: vvsinh_ called"); 3449 3449 + return NULL; 3450 3450 + } 3451 3451 + 3452 3452 + void* vvsinhf(void) 3453 3453 + { 3454 3454 + if (verbose) puts("STUB: vvsinhf called"); 3455 3455 + return NULL; 3456 3456 + } 3457 3457 + 3458 3458 + void* vvsinhf_(void) 3459 3459 + { 3460 3460 + if (verbose) puts("STUB: vvsinhf_ called"); 3461 3461 + return NULL; 3462 3462 + } 3463 3463 + 3464 3464 + void* vvsinpi(void) 3465 3465 + { 3466 3466 + if (verbose) puts("STUB: vvsinpi called"); 3467 3467 + return NULL; 3468 3468 + } 3469 3469 + 3470 3470 + void* vvsinpi_(void) 3471 3471 + { 3472 3472 + if (verbose) puts("STUB: vvsinpi_ called"); 3473 3473 + return NULL; 3474 3474 + } 3475 3475 + 3476 3476 + void* vvsinpif(void) 3477 3477 + { 3478 3478 + if (verbose) puts("STUB: vvsinpif called"); 3479 3479 + return NULL; 3480 3480 + } 3481 3481 + 3482 3482 + void* vvsinpif_(void) 3483 3483 + { 3484 3484 + if (verbose) puts("STUB: vvsinpif_ called"); 3485 3485 + return NULL; 3486 3486 + } 3487 3487 + 3488 3488 + void* vvsqrt(void) 3489 3489 + { 3490 3490 + if (verbose) puts("STUB: vvsqrt called"); 3491 3491 + return NULL; 3492 3492 + } 3493 3493 + 3494 3494 + void* vvsqrt_(void) 3495 3495 + { 3496 3496 + if (verbose) puts("STUB: vvsqrt_ called"); 3497 3497 + return NULL; 3498 3498 + } 3499 3499 + 3500 3500 + void* vvsqrtf(void) 3501 3501 + { 3502 3502 + if (verbose) puts("STUB: vvsqrtf called"); 3503 3503 + return NULL; 3504 3504 + } 3505 3505 + 3506 3506 + void* vvsqrtf_(void) 3507 3507 + { 3508 3508 + if (verbose) puts("STUB: vvsqrtf_ called"); 3509 3509 + return NULL; 3510 3510 + } 3511 3511 + 3512 3512 + void* vvtan(void) 3513 3513 + { 3514 3514 + if (verbose) puts("STUB: vvtan called"); 3515 3515 + return NULL; 3516 3516 + } 3517 3517 + 3518 3518 + void* vvtan_(void) 3519 3519 + { 3520 3520 + if (verbose) puts("STUB: vvtan_ called"); 3521 3521 + return NULL; 3522 3522 + } 3523 3523 + 3524 3524 + void* vvtanf(void) 3525 3525 + { 3526 3526 + if (verbose) puts("STUB: vvtanf called"); 3527 3527 + return NULL; 3528 3528 + } 3529 3529 + 3530 3530 + void* vvtanf_(void) 3531 3531 + { 3532 3532 + if (verbose) puts("STUB: vvtanf_ called"); 3533 3533 + return NULL; 3534 3534 + } 3535 3535 + 3536 3536 + void* vvtanh(void) 3537 3537 + { 3538 3538 + if (verbose) puts("STUB: vvtanh called"); 3539 3539 + return NULL; 3540 3540 + } 3541 3541 + 3542 3542 + void* vvtanh_(void) 3543 3543 + { 3544 3544 + if (verbose) puts("STUB: vvtanh_ called"); 3545 3545 + return NULL; 3546 3546 + } 3547 3547 + 3548 3548 + void* vvtanhf(void) 3549 3549 + { 3550 3550 + if (verbose) puts("STUB: vvtanhf called"); 3551 3551 + return NULL; 3552 3552 + } 3553 3553 + 3554 3554 + void* vvtanhf_(void) 3555 3555 + { 3556 3556 + if (verbose) puts("STUB: vvtanhf_ called"); 3557 3557 + return NULL; 3558 3558 + } 3559 3559 + 3560 3560 + void* vvtanpi(void) 3561 3561 + { 3562 3562 + if (verbose) puts("STUB: vvtanpi called"); 3563 3563 + return NULL; 3564 3564 + } 3565 3565 + 3566 3566 + void* vvtanpi_(void) 3567 3567 + { 3568 3568 + if (verbose) puts("STUB: vvtanpi_ called"); 3569 3569 + return NULL; 3570 3570 + } 3571 3571 + 3572 3572 + void* vvtanpif(void) 3573 3573 + { 3574 3574 + if (verbose) puts("STUB: vvtanpif called"); 3575 3575 + return NULL; 3576 3576 + } 3577 3577 + 3578 3578 + void* vvtanpif_(void) 3579 3579 + { 3580 3580 + if (verbose) puts("STUB: vvtanpif_ called"); 3581 3581 + return NULL; 3582 3582 + }

+3582

src/Accelerate/vecLib/vMisc/src/libvMisc.dylib.c

reviewed

··· 1 1 + /* 2 2 + This file is part of Darling. 3 3 + 4 4 + Copyright (C) 2019 Lubos Dolezel 5 5 + 6 6 + Darling is free software: you can redistribute it and/or modify 7 7 + it under the terms of the GNU General Public License as published by 8 8 + the Free Software Foundation, either version 3 of the License, or 9 9 + (at your option) any later version. 10 10 + 11 11 + Darling is distributed in the hope that it will be useful, 12 12 + but WITHOUT ANY WARRANTY; without even the implied warranty of 13 13 + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 14 + GNU General Public License for more details. 15 15 + 16 16 + You should have received a copy of the GNU General Public License 17 17 + along with Darling. If not, see <http://www.gnu.org/licenses/>. 18 18 + */ 19 19 + 20 20 + 21 21 + #include </libvMisc.dylib//libvMisc.dylib.h> 22 22 + #include <stdlib.h> 23 23 + #include <stdio.h> 24 24 + 25 25 + static int verbose = 0; 26 26 + 27 27 + __attribute__((constructor)) 28 28 + static void initme(void) { 29 29 + verbose = getenv("STUB_VERBOSE") != NULL; 30 30 + } 31 31 + 32 32 + void* VVACOS(void) 33 33 + { 34 34 + if (verbose) puts("STUB: VVACOS called"); 35 35 + return NULL; 36 36 + } 37 37 + 38 38 + void* VVACOSF(void) 39 39 + { 40 40 + if (verbose) puts("STUB: VVACOSF called"); 41 41 + return NULL; 42 42 + } 43 43 + 44 44 + void* VVACOSF_(void) 45 45 + { 46 46 + if (verbose) puts("STUB: VVACOSF_ called"); 47 47 + return NULL; 48 48 + } 49 49 + 50 50 + void* VVACOSH(void) 51 51 + { 52 52 + if (verbose) puts("STUB: VVACOSH called"); 53 53 + return NULL; 54 54 + } 55 55 + 56 56 + void* VVACOSHF(void) 57 57 + { 58 58 + if (verbose) puts("STUB: VVACOSHF called"); 59 59 + return NULL; 60 60 + } 61 61 + 62 62 + void* VVACOSHF_(void) 63 63 + { 64 64 + if (verbose) puts("STUB: VVACOSHF_ called"); 65 65 + return NULL; 66 66 + } 67 67 + 68 68 + void* VVACOSH_(void) 69 69 + { 70 70 + if (verbose) puts("STUB: VVACOSH_ called"); 71 71 + return NULL; 72 72 + } 73 73 + 74 74 + void* VVACOS_(void) 75 75 + { 76 76 + if (verbose) puts("STUB: VVACOS_ called"); 77 77 + return NULL; 78 78 + } 79 79 + 80 80 + void* VVASIN(void) 81 81 + { 82 82 + if (verbose) puts("STUB: VVASIN called"); 83 83 + return NULL; 84 84 + } 85 85 + 86 86 + void* VVASINF(void) 87 87 + { 88 88 + if (verbose) puts("STUB: VVASINF called"); 89 89 + return NULL; 90 90 + } 91 91 + 92 92 + void* VVASINF_(void) 93 93 + { 94 94 + if (verbose) puts("STUB: VVASINF_ called"); 95 95 + return NULL; 96 96 + } 97 97 + 98 98 + void* VVASINH(void) 99 99 + { 100 100 + if (verbose) puts("STUB: VVASINH called"); 101 101 + return NULL; 102 102 + } 103 103 + 104 104 + void* VVASINHF(void) 105 105 + { 106 106 + if (verbose) puts("STUB: VVASINHF called"); 107 107 + return NULL; 108 108 + } 109 109 + 110 110 + void* VVASINHF_(void) 111 111 + { 112 112 + if (verbose) puts("STUB: VVASINHF_ called"); 113 113 + return NULL; 114 114 + } 115 115 + 116 116 + void* VVASINH_(void) 117 117 + { 118 118 + if (verbose) puts("STUB: VVASINH_ called"); 119 119 + return NULL; 120 120 + } 121 121 + 122 122 + void* VVASIN_(void) 123 123 + { 124 124 + if (verbose) puts("STUB: VVASIN_ called"); 125 125 + return NULL; 126 126 + } 127 127 + 128 128 + void* VVATAN(void) 129 129 + { 130 130 + if (verbose) puts("STUB: VVATAN called"); 131 131 + return NULL; 132 132 + } 133 133 + 134 134 + void* VVATAN2(void) 135 135 + { 136 136 + if (verbose) puts("STUB: VVATAN2 called"); 137 137 + return NULL; 138 138 + } 139 139 + 140 140 + void* VVATAN2F(void) 141 141 + { 142 142 + if (verbose) puts("STUB: VVATAN2F called"); 143 143 + return NULL; 144 144 + } 145 145 + 146 146 + void* VVATAN2F_(void) 147 147 + { 148 148 + if (verbose) puts("STUB: VVATAN2F_ called"); 149 149 + return NULL; 150 150 + } 151 151 + 152 152 + void* VVATAN2_(void) 153 153 + { 154 154 + if (verbose) puts("STUB: VVATAN2_ called"); 155 155 + return NULL; 156 156 + } 157 157 + 158 158 + void* VVATANF(void) 159 159 + { 160 160 + if (verbose) puts("STUB: VVATANF called"); 161 161 + return NULL; 162 162 + } 163 163 + 164 164 + void* VVATANF_(void) 165 165 + { 166 166 + if (verbose) puts("STUB: VVATANF_ called"); 167 167 + return NULL; 168 168 + } 169 169 + 170 170 + void* VVATANH(void) 171 171 + { 172 172 + if (verbose) puts("STUB: VVATANH called"); 173 173 + return NULL; 174 174 + } 175 175 + 176 176 + void* VVATANHF(void) 177 177 + { 178 178 + if (verbose) puts("STUB: VVATANHF called"); 179 179 + return NULL; 180 180 + } 181 181 + 182 182 + void* VVATANHF_(void) 183 183 + { 184 184 + if (verbose) puts("STUB: VVATANHF_ called"); 185 185 + return NULL; 186 186 + } 187 187 + 188 188 + void* VVATANH_(void) 189 189 + { 190 190 + if (verbose) puts("STUB: VVATANH_ called"); 191 191 + return NULL; 192 192 + } 193 193 + 194 194 + void* VVATAN_(void) 195 195 + { 196 196 + if (verbose) puts("STUB: VVATAN_ called"); 197 197 + return NULL; 198 198 + } 199 199 + 200 200 + void* VVCBRT(void) 201 201 + { 202 202 + if (verbose) puts("STUB: VVCBRT called"); 203 203 + return NULL; 204 204 + } 205 205 + 206 206 + void* VVCBRTF(void) 207 207 + { 208 208 + if (verbose) puts("STUB: VVCBRTF called"); 209 209 + return NULL; 210 210 + } 211 211 + 212 212 + void* VVCBRTF_(void) 213 213 + { 214 214 + if (verbose) puts("STUB: VVCBRTF_ called"); 215 215 + return NULL; 216 216 + } 217 217 + 218 218 + void* VVCBRT_(void) 219 219 + { 220 220 + if (verbose) puts("STUB: VVCBRT_ called"); 221 221 + return NULL; 222 222 + } 223 223 + 224 224 + void* VVCEIL(void) 225 225 + { 226 226 + if (verbose) puts("STUB: VVCEIL called"); 227 227 + return NULL; 228 228 + } 229 229 + 230 230 + void* VVCEILF(void) 231 231 + { 232 232 + if (verbose) puts("STUB: VVCEILF called"); 233 233 + return NULL; 234 234 + } 235 235 + 236 236 + void* VVCEILF_(void) 237 237 + { 238 238 + if (verbose) puts("STUB: VVCEILF_ called"); 239 239 + return NULL; 240 240 + } 241 241 + 242 242 + void* VVCEIL_(void) 243 243 + { 244 244 + if (verbose) puts("STUB: VVCEIL_ called"); 245 245 + return NULL; 246 246 + } 247 247 + 248 248 + void* VVCOPYSIGN(void) 249 249 + { 250 250 + if (verbose) puts("STUB: VVCOPYSIGN called"); 251 251 + return NULL; 252 252 + } 253 253 + 254 254 + void* VVCOPYSIGNF(void) 255 255 + { 256 256 + if (verbose) puts("STUB: VVCOPYSIGNF called"); 257 257 + return NULL; 258 258 + } 259 259 + 260 260 + void* VVCOPYSIGNF_(void) 261 261 + { 262 262 + if (verbose) puts("STUB: VVCOPYSIGNF_ called"); 263 263 + return NULL; 264 264 + } 265 265 + 266 266 + void* VVCOPYSIGN_(void) 267 267 + { 268 268 + if (verbose) puts("STUB: VVCOPYSIGN_ called"); 269 269 + return NULL; 270 270 + } 271 271 + 272 272 + void* VVCOS(void) 273 273 + { 274 274 + if (verbose) puts("STUB: VVCOS called"); 275 275 + return NULL; 276 276 + } 277 277 + 278 278 + void* VVCOSF(void) 279 279 + { 280 280 + if (verbose) puts("STUB: VVCOSF called"); 281 281 + return NULL; 282 282 + } 283 283 + 284 284 + void* VVCOSF_(void) 285 285 + { 286 286 + if (verbose) puts("STUB: VVCOSF_ called"); 287 287 + return NULL; 288 288 + } 289 289 + 290 290 + void* VVCOSH(void) 291 291 + { 292 292 + if (verbose) puts("STUB: VVCOSH called"); 293 293 + return NULL; 294 294 + } 295 295 + 296 296 + void* VVCOSHF(void) 297 297 + { 298 298 + if (verbose) puts("STUB: VVCOSHF called"); 299 299 + return NULL; 300 300 + } 301 301 + 302 302 + void* VVCOSHF_(void) 303 303 + { 304 304 + if (verbose) puts("STUB: VVCOSHF_ called"); 305 305 + return NULL; 306 306 + } 307 307 + 308 308 + void* VVCOSH_(void) 309 309 + { 310 310 + if (verbose) puts("STUB: VVCOSH_ called"); 311 311 + return NULL; 312 312 + } 313 313 + 314 314 + void* VVCOSISIN(void) 315 315 + { 316 316 + if (verbose) puts("STUB: VVCOSISIN called"); 317 317 + return NULL; 318 318 + } 319 319 + 320 320 + void* VVCOSISINF(void) 321 321 + { 322 322 + if (verbose) puts("STUB: VVCOSISINF called"); 323 323 + return NULL; 324 324 + } 325 325 + 326 326 + void* VVCOSISINF_(void) 327 327 + { 328 328 + if (verbose) puts("STUB: VVCOSISINF_ called"); 329 329 + return NULL; 330 330 + } 331 331 + 332 332 + void* VVCOSISIN_(void) 333 333 + { 334 334 + if (verbose) puts("STUB: VVCOSISIN_ called"); 335 335 + return NULL; 336 336 + } 337 337 + 338 338 + void* VVCOSPI(void) 339 339 + { 340 340 + if (verbose) puts("STUB: VVCOSPI called"); 341 341 + return NULL; 342 342 + } 343 343 + 344 344 + void* VVCOSPIF(void) 345 345 + { 346 346 + if (verbose) puts("STUB: VVCOSPIF called"); 347 347 + return NULL; 348 348 + } 349 349 + 350 350 + void* VVCOSPIF_(void) 351 351 + { 352 352 + if (verbose) puts("STUB: VVCOSPIF_ called"); 353 353 + return NULL; 354 354 + } 355 355 + 356 356 + void* VVCOSPI_(void) 357 357 + { 358 358 + if (verbose) puts("STUB: VVCOSPI_ called"); 359 359 + return NULL; 360 360 + } 361 361 + 362 362 + void* VVCOS_(void) 363 363 + { 364 364 + if (verbose) puts("STUB: VVCOS_ called"); 365 365 + return NULL; 366 366 + } 367 367 + 368 368 + void* VVDIV(void) 369 369 + { 370 370 + if (verbose) puts("STUB: VVDIV called"); 371 371 + return NULL; 372 372 + } 373 373 + 374 374 + void* VVDIVF(void) 375 375 + { 376 376 + if (verbose) puts("STUB: VVDIVF called"); 377 377 + return NULL; 378 378 + } 379 379 + 380 380 + void* VVDIVF_(void) 381 381 + { 382 382 + if (verbose) puts("STUB: VVDIVF_ called"); 383 383 + return NULL; 384 384 + } 385 385 + 386 386 + void* VVDIV_(void) 387 387 + { 388 388 + if (verbose) puts("STUB: VVDIV_ called"); 389 389 + return NULL; 390 390 + } 391 391 + 392 392 + void* VVEXP(void) 393 393 + { 394 394 + if (verbose) puts("STUB: VVEXP called"); 395 395 + return NULL; 396 396 + } 397 397 + 398 398 + void* VVEXP2(void) 399 399 + { 400 400 + if (verbose) puts("STUB: VVEXP2 called"); 401 401 + return NULL; 402 402 + } 403 403 + 404 404 + void* VVEXP2F(void) 405 405 + { 406 406 + if (verbose) puts("STUB: VVEXP2F called"); 407 407 + return NULL; 408 408 + } 409 409 + 410 410 + void* VVEXP2F_(void) 411 411 + { 412 412 + if (verbose) puts("STUB: VVEXP2F_ called"); 413 413 + return NULL; 414 414 + } 415 415 + 416 416 + void* VVEXP2_(void) 417 417 + { 418 418 + if (verbose) puts("STUB: VVEXP2_ called"); 419 419 + return NULL; 420 420 + } 421 421 + 422 422 + void* VVEXPF(void) 423 423 + { 424 424 + if (verbose) puts("STUB: VVEXPF called"); 425 425 + return NULL; 426 426 + } 427 427 + 428 428 + void* VVEXPF_(void) 429 429 + { 430 430 + if (verbose) puts("STUB: VVEXPF_ called"); 431 431 + return NULL; 432 432 + } 433 433 + 434 434 + void* VVEXPM1(void) 435 435 + { 436 436 + if (verbose) puts("STUB: VVEXPM1 called"); 437 437 + return NULL; 438 438 + } 439 439 + 440 440 + void* VVEXPM1F(void) 441 441 + { 442 442 + if (verbose) puts("STUB: VVEXPM1F called"); 443 443 + return NULL; 444 444 + } 445 445 + 446 446 + void* VVEXPM1F_(void) 447 447 + { 448 448 + if (verbose) puts("STUB: VVEXPM1F_ called"); 449 449 + return NULL; 450 450 + } 451 451 + 452 452 + void* VVEXPM1_(void) 453 453 + { 454 454 + if (verbose) puts("STUB: VVEXPM1_ called"); 455 455 + return NULL; 456 456 + } 457 457 + 458 458 + void* VVEXP_(void) 459 459 + { 460 460 + if (verbose) puts("STUB: VVEXP_ called"); 461 461 + return NULL; 462 462 + } 463 463 + 464 464 + void* VVFABF(void) 465 465 + { 466 466 + if (verbose) puts("STUB: VVFABF called"); 467 467 + return NULL; 468 468 + } 469 469 + 470 470 + void* VVFABF_(void) 471 471 + { 472 472 + if (verbose) puts("STUB: VVFABF_ called"); 473 473 + return NULL; 474 474 + } 475 475 + 476 476 + void* VVFABS(void) 477 477 + { 478 478 + if (verbose) puts("STUB: VVFABS called"); 479 479 + return NULL; 480 480 + } 481 481 + 482 482 + void* VVFABSF(void) 483 483 + { 484 484 + if (verbose) puts("STUB: VVFABSF called"); 485 485 + return NULL; 486 486 + } 487 487 + 488 488 + void* VVFABSF_(void) 489 489 + { 490 490 + if (verbose) puts("STUB: VVFABSF_ called"); 491 491 + return NULL; 492 492 + } 493 493 + 494 494 + void* VVFABS_(void) 495 495 + { 496 496 + if (verbose) puts("STUB: VVFABS_ called"); 497 497 + return NULL; 498 498 + } 499 499 + 500 500 + void* VVFLOOR(void) 501 501 + { 502 502 + if (verbose) puts("STUB: VVFLOOR called"); 503 503 + return NULL; 504 504 + } 505 505 + 506 506 + void* VVFLOORF(void) 507 507 + { 508 508 + if (verbose) puts("STUB: VVFLOORF called"); 509 509 + return NULL; 510 510 + } 511 511 + 512 512 + void* VVFLOORF_(void) 513 513 + { 514 514 + if (verbose) puts("STUB: VVFLOORF_ called"); 515 515 + return NULL; 516 516 + } 517 517 + 518 518 + void* VVFLOOR_(void) 519 519 + { 520 520 + if (verbose) puts("STUB: VVFLOOR_ called"); 521 521 + return NULL; 522 522 + } 523 523 + 524 524 + void* VVFMOD(void) 525 525 + { 526 526 + if (verbose) puts("STUB: VVFMOD called"); 527 527 + return NULL; 528 528 + } 529 529 + 530 530 + void* VVFMODF(void) 531 531 + { 532 532 + if (verbose) puts("STUB: VVFMODF called"); 533 533 + return NULL; 534 534 + } 535 535 + 536 536 + void* VVFMODF_(void) 537 537 + { 538 538 + if (verbose) puts("STUB: VVFMODF_ called"); 539 539 + return NULL; 540 540 + } 541 541 + 542 542 + void* VVFMOD_(void) 543 543 + { 544 544 + if (verbose) puts("STUB: VVFMOD_ called"); 545 545 + return NULL; 546 546 + } 547 547 + 548 548 + void* VVINT(void) 549 549 + { 550 550 + if (verbose) puts("STUB: VVINT called"); 551 551 + return NULL; 552 552 + } 553 553 + 554 554 + void* VVINTF(void) 555 555 + { 556 556 + if (verbose) puts("STUB: VVINTF called"); 557 557 + return NULL; 558 558 + } 559 559 + 560 560 + void* VVINTF_(void) 561 561 + { 562 562 + if (verbose) puts("STUB: VVINTF_ called"); 563 563 + return NULL; 564 564 + } 565 565 + 566 566 + void* VVINT_(void) 567 567 + { 568 568 + if (verbose) puts("STUB: VVINT_ called"); 569 569 + return NULL; 570 570 + } 571 571 + 572 572 + void* VVLOG(void) 573 573 + { 574 574 + if (verbose) puts("STUB: VVLOG called"); 575 575 + return NULL; 576 576 + } 577 577 + 578 578 + void* VVLOG10(void) 579 579 + { 580 580 + if (verbose) puts("STUB: VVLOG10 called"); 581 581 + return NULL; 582 582 + } 583 583 + 584 584 + void* VVLOG10F(void) 585 585 + { 586 586 + if (verbose) puts("STUB: VVLOG10F called"); 587 587 + return NULL; 588 588 + } 589 589 + 590 590 + void* VVLOG10F_(void) 591 591 + { 592 592 + if (verbose) puts("STUB: VVLOG10F_ called"); 593 593 + return NULL; 594 594 + } 595 595 + 596 596 + void* VVLOG10_(void) 597 597 + { 598 598 + if (verbose) puts("STUB: VVLOG10_ called"); 599 599 + return NULL; 600 600 + } 601 601 + 602 602 + void* VVLOG1P(void) 603 603 + { 604 604 + if (verbose) puts("STUB: VVLOG1P called"); 605 605 + return NULL; 606 606 + } 607 607 + 608 608 + void* VVLOG1PF(void) 609 609 + { 610 610 + if (verbose) puts("STUB: VVLOG1PF called"); 611 611 + return NULL; 612 612 + } 613 613 + 614 614 + void* VVLOG1PF_(void) 615 615 + { 616 616 + if (verbose) puts("STUB: VVLOG1PF_ called"); 617 617 + return NULL; 618 618 + } 619 619 + 620 620 + void* VVLOG1P_(void) 621 621 + { 622 622 + if (verbose) puts("STUB: VVLOG1P_ called"); 623 623 + return NULL; 624 624 + } 625 625 + 626 626 + void* VVLOG2(void) 627 627 + { 628 628 + if (verbose) puts("STUB: VVLOG2 called"); 629 629 + return NULL; 630 630 + } 631 631 + 632 632 + void* VVLOG2F(void) 633 633 + { 634 634 + if (verbose) puts("STUB: VVLOG2F called"); 635 635 + return NULL; 636 636 + } 637 637 + 638 638 + void* VVLOG2F_(void) 639 639 + { 640 640 + if (verbose) puts("STUB: VVLOG2F_ called"); 641 641 + return NULL; 642 642 + } 643 643 + 644 644 + void* VVLOG2_(void) 645 645 + { 646 646 + if (verbose) puts("STUB: VVLOG2_ called"); 647 647 + return NULL; 648 648 + } 649 649 + 650 650 + void* VVLOGB(void) 651 651 + { 652 652 + if (verbose) puts("STUB: VVLOGB called"); 653 653 + return NULL; 654 654 + } 655 655 + 656 656 + void* VVLOGBF(void) 657 657 + { 658 658 + if (verbose) puts("STUB: VVLOGBF called"); 659 659 + return NULL; 660 660 + } 661 661 + 662 662 + void* VVLOGBF_(void) 663 663 + { 664 664 + if (verbose) puts("STUB: VVLOGBF_ called"); 665 665 + return NULL; 666 666 + } 667 667 + 668 668 + void* VVLOGB_(void) 669 669 + { 670 670 + if (verbose) puts("STUB: VVLOGB_ called"); 671 671 + return NULL; 672 672 + } 673 673 + 674 674 + void* VVLOGF(void) 675 675 + { 676 676 + if (verbose) puts("STUB: VVLOGF called"); 677 677 + return NULL; 678 678 + } 679 679 + 680 680 + void* VVLOGF_(void) 681 681 + { 682 682 + if (verbose) puts("STUB: VVLOGF_ called"); 683 683 + return NULL; 684 684 + } 685 685 + 686 686 + void* VVLOG_(void) 687 687 + { 688 688 + if (verbose) puts("STUB: VVLOG_ called"); 689 689 + return NULL; 690 690 + } 691 691 + 692 692 + void* VVNEXTAFTER(void) 693 693 + { 694 694 + if (verbose) puts("STUB: VVNEXTAFTER called"); 695 695 + return NULL; 696 696 + } 697 697 + 698 698 + void* VVNEXTAFTERF(void) 699 699 + { 700 700 + if (verbose) puts("STUB: VVNEXTAFTERF called"); 701 701 + return NULL; 702 702 + } 703 703 + 704 704 + void* VVNEXTAFTERF_(void) 705 705 + { 706 706 + if (verbose) puts("STUB: VVNEXTAFTERF_ called"); 707 707 + return NULL; 708 708 + } 709 709 + 710 710 + void* VVNEXTAFTER_(void) 711 711 + { 712 712 + if (verbose) puts("STUB: VVNEXTAFTER_ called"); 713 713 + return NULL; 714 714 + } 715 715 + 716 716 + void* VVNINT(void) 717 717 + { 718 718 + if (verbose) puts("STUB: VVNINT called"); 719 719 + return NULL; 720 720 + } 721 721 + 722 722 + void* VVNINTF(void) 723 723 + { 724 724 + if (verbose) puts("STUB: VVNINTF called"); 725 725 + return NULL; 726 726 + } 727 727 + 728 728 + void* VVNINTF_(void) 729 729 + { 730 730 + if (verbose) puts("STUB: VVNINTF_ called"); 731 731 + return NULL; 732 732 + } 733 733 + 734 734 + void* VVNINT_(void) 735 735 + { 736 736 + if (verbose) puts("STUB: VVNINT_ called"); 737 737 + return NULL; 738 738 + } 739 739 + 740 740 + void* VVPOW(void) 741 741 + { 742 742 + if (verbose) puts("STUB: VVPOW called"); 743 743 + return NULL; 744 744 + } 745 745 + 746 746 + void* VVPOWF(void) 747 747 + { 748 748 + if (verbose) puts("STUB: VVPOWF called"); 749 749 + return NULL; 750 750 + } 751 751 + 752 752 + void* VVPOWF_(void) 753 753 + { 754 754 + if (verbose) puts("STUB: VVPOWF_ called"); 755 755 + return NULL; 756 756 + } 757 757 + 758 758 + void* VVPOWS(void) 759 759 + { 760 760 + if (verbose) puts("STUB: VVPOWS called"); 761 761 + return NULL; 762 762 + } 763 763 + 764 764 + void* VVPOWSF(void) 765 765 + { 766 766 + if (verbose) puts("STUB: VVPOWSF called"); 767 767 + return NULL; 768 768 + } 769 769 + 770 770 + void* VVPOWSF_(void) 771 771 + { 772 772 + if (verbose) puts("STUB: VVPOWSF_ called"); 773 773 + return NULL; 774 774 + } 775 775 + 776 776 + void* VVPOWS_(void) 777 777 + { 778 778 + if (verbose) puts("STUB: VVPOWS_ called"); 779 779 + return NULL; 780 780 + } 781 781 + 782 782 + void* VVPOW_(void) 783 783 + { 784 784 + if (verbose) puts("STUB: VVPOW_ called"); 785 785 + return NULL; 786 786 + } 787 787 + 788 788 + void* VVREC(void) 789 789 + { 790 790 + if (verbose) puts("STUB: VVREC called"); 791 791 + return NULL; 792 792 + } 793 793 + 794 794 + void* VVRECF(void) 795 795 + { 796 796 + if (verbose) puts("STUB: VVRECF called"); 797 797 + return NULL; 798 798 + } 799 799 + 800 800 + void* VVRECF_(void) 801 801 + { 802 802 + if (verbose) puts("STUB: VVRECF_ called"); 803 803 + return NULL; 804 804 + } 805 805 + 806 806 + void* VVREC_(void) 807 807 + { 808 808 + if (verbose) puts("STUB: VVREC_ called"); 809 809 + return NULL; 810 810 + } 811 811 + 812 812 + void* VVREMAINDER(void) 813 813 + { 814 814 + if (verbose) puts("STUB: VVREMAINDER called"); 815 815 + return NULL; 816 816 + } 817 817 + 818 818 + void* VVREMAINDERF(void) 819 819 + { 820 820 + if (verbose) puts("STUB: VVREMAINDERF called"); 821 821 + return NULL; 822 822 + } 823 823 + 824 824 + void* VVREMAINDERF_(void) 825 825 + { 826 826 + if (verbose) puts("STUB: VVREMAINDERF_ called"); 827 827 + return NULL; 828 828 + } 829 829 + 830 830 + void* VVREMAINDER_(void) 831 831 + { 832 832 + if (verbose) puts("STUB: VVREMAINDER_ called"); 833 833 + return NULL; 834 834 + } 835 835 + 836 836 + void* VVRSQRT(void) 837 837 + { 838 838 + if (verbose) puts("STUB: VVRSQRT called"); 839 839 + return NULL; 840 840 + } 841 841 + 842 842 + void* VVRSQRTF(void) 843 843 + { 844 844 + if (verbose) puts("STUB: VVRSQRTF called"); 845 845 + return NULL; 846 846 + } 847 847 + 848 848 + void* VVRSQRTF_(void) 849 849 + { 850 850 + if (verbose) puts("STUB: VVRSQRTF_ called"); 851 851 + return NULL; 852 852 + } 853 853 + 854 854 + void* VVRSQRT_(void) 855 855 + { 856 856 + if (verbose) puts("STUB: VVRSQRT_ called"); 857 857 + return NULL; 858 858 + } 859 859 + 860 860 + void* VVSIN(void) 861 861 + { 862 862 + if (verbose) puts("STUB: VVSIN called"); 863 863 + return NULL; 864 864 + } 865 865 + 866 866 + void* VVSINCOS(void) 867 867 + { 868 868 + if (verbose) puts("STUB: VVSINCOS called"); 869 869 + return NULL; 870 870 + } 871 871 + 872 872 + void* VVSINCOSF(void) 873 873 + { 874 874 + if (verbose) puts("STUB: VVSINCOSF called"); 875 875 + return NULL; 876 876 + } 877 877 + 878 878 + void* VVSINCOSF_(void) 879 879 + { 880 880 + if (verbose) puts("STUB: VVSINCOSF_ called"); 881 881 + return NULL; 882 882 + } 883 883 + 884 884 + void* VVSINCOS_(void) 885 885 + { 886 886 + if (verbose) puts("STUB: VVSINCOS_ called"); 887 887 + return NULL; 888 888 + } 889 889 + 890 890 + void* VVSINF(void) 891 891 + { 892 892 + if (verbose) puts("STUB: VVSINF called"); 893 893 + return NULL; 894 894 + } 895 895 + 896 896 + void* VVSINF_(void) 897 897 + { 898 898 + if (verbose) puts("STUB: VVSINF_ called"); 899 899 + return NULL; 900 900 + } 901 901 + 902 902 + void* VVSINH(void) 903 903 + { 904 904 + if (verbose) puts("STUB: VVSINH called"); 905 905 + return NULL; 906 906 + } 907 907 + 908 908 + void* VVSINHF(void) 909 909 + { 910 910 + if (verbose) puts("STUB: VVSINHF called"); 911 911 + return NULL; 912 912 + } 913 913 + 914 914 + void* VVSINHF_(void) 915 915 + { 916 916 + if (verbose) puts("STUB: VVSINHF_ called"); 917 917 + return NULL; 918 918 + } 919 919 + 920 920 + void* VVSINH_(void) 921 921 + { 922 922 + if (verbose) puts("STUB: VVSINH_ called"); 923 923 + return NULL; 924 924 + } 925 925 + 926 926 + void* VVSINPI(void) 927 927 + { 928 928 + if (verbose) puts("STUB: VVSINPI called"); 929 929 + return NULL; 930 930 + } 931 931 + 932 932 + void* VVSINPIF(void) 933 933 + { 934 934 + if (verbose) puts("STUB: VVSINPIF called"); 935 935 + return NULL; 936 936 + } 937 937 + 938 938 + void* VVSINPIF_(void) 939 939 + { 940 940 + if (verbose) puts("STUB: VVSINPIF_ called"); 941 941 + return NULL; 942 942 + } 943 943 + 944 944 + void* VVSINPI_(void) 945 945 + { 946 946 + if (verbose) puts("STUB: VVSINPI_ called"); 947 947 + return NULL; 948 948 + } 949 949 + 950 950 + void* VVSIN_(void) 951 951 + { 952 952 + if (verbose) puts("STUB: VVSIN_ called"); 953 953 + return NULL; 954 954 + } 955 955 + 956 956 + void* VVSQRT(void) 957 957 + { 958 958 + if (verbose) puts("STUB: VVSQRT called"); 959 959 + return NULL; 960 960 + } 961 961 + 962 962 + void* VVSQRTF(void) 963 963 + { 964 964 + if (verbose) puts("STUB: VVSQRTF called"); 965 965 + return NULL; 966 966 + } 967 967 + 968 968 + void* VVSQRTF_(void) 969 969 + { 970 970 + if (verbose) puts("STUB: VVSQRTF_ called"); 971 971 + return NULL; 972 972 + } 973 973 + 974 974 + void* VVSQRT_(void) 975 975 + { 976 976 + if (verbose) puts("STUB: VVSQRT_ called"); 977 977 + return NULL; 978 978 + } 979 979 + 980 980 + void* VVTAN(void) 981 981 + { 982 982 + if (verbose) puts("STUB: VVTAN called"); 983 983 + return NULL; 984 984 + } 985 985 + 986 986 + void* VVTANF(void) 987 987 + { 988 988 + if (verbose) puts("STUB: VVTANF called"); 989 989 + return NULL; 990 990 + } 991 991 + 992 992 + void* VVTANF_(void) 993 993 + { 994 994 + if (verbose) puts("STUB: VVTANF_ called"); 995 995 + return NULL; 996 996 + } 997 997 + 998 998 + void* VVTANH(void) 999 999 + { 1000 1000 + if (verbose) puts("STUB: VVTANH called"); 1001 1001 + return NULL; 1002 1002 + } 1003 1003 + 1004 1004 + void* VVTANHF(void) 1005 1005 + { 1006 1006 + if (verbose) puts("STUB: VVTANHF called"); 1007 1007 + return NULL; 1008 1008 + } 1009 1009 + 1010 1010 + void* VVTANHF_(void) 1011 1011 + { 1012 1012 + if (verbose) puts("STUB: VVTANHF_ called"); 1013 1013 + return NULL; 1014 1014 + } 1015 1015 + 1016 1016 + void* VVTANH_(void) 1017 1017 + { 1018 1018 + if (verbose) puts("STUB: VVTANH_ called"); 1019 1019 + return NULL; 1020 1020 + } 1021 1021 + 1022 1022 + void* VVTANPI(void) 1023 1023 + { 1024 1024 + if (verbose) puts("STUB: VVTANPI called"); 1025 1025 + return NULL; 1026 1026 + } 1027 1027 + 1028 1028 + void* VVTANPIF(void) 1029 1029 + { 1030 1030 + if (verbose) puts("STUB: VVTANPIF called"); 1031 1031 + return NULL; 1032 1032 + } 1033 1033 + 1034 1034 + void* VVTANPIF_(void) 1035 1035 + { 1036 1036 + if (verbose) puts("STUB: VVTANPIF_ called"); 1037 1037 + return NULL; 1038 1038 + } 1039 1039 + 1040 1040 + void* VVTANPI_(void) 1041 1041 + { 1042 1042 + if (verbose) puts("STUB: VVTANPI_ called"); 1043 1043 + return NULL; 1044 1044 + } 1045 1045 + 1046 1046 + void* VVTAN_(void) 1047 1047 + { 1048 1048 + if (verbose) puts("STUB: VVTAN_ called"); 1049 1049 + return NULL; 1050 1050 + } 1051 1051 + 1052 1052 + void* __cblas_isamax(void) 1053 1053 + { 1054 1054 + if (verbose) puts("STUB: __cblas_isamax called"); 1055 1055 + return NULL; 1056 1056 + } 1057 1057 + 1058 1058 + void* __cblas_sasum(void) 1059 1059 + { 1060 1060 + if (verbose) puts("STUB: __cblas_sasum called"); 1061 1061 + return NULL; 1062 1062 + } 1063 1063 + 1064 1064 + void* __cblas_saxpy(void) 1065 1065 + { 1066 1066 + if (verbose) puts("STUB: __cblas_saxpy called"); 1067 1067 + return NULL; 1068 1068 + } 1069 1069 + 1070 1070 + void* __cblas_sgemm(void) 1071 1071 + { 1072 1072 + if (verbose) puts("STUB: __cblas_sgemm called"); 1073 1073 + return NULL; 1074 1074 + } 1075 1075 + 1076 1076 + void* __cblas_sgemv(void) 1077 1077 + { 1078 1078 + if (verbose) puts("STUB: __cblas_sgemv called"); 1079 1079 + return NULL; 1080 1080 + } 1081 1081 + 1082 1082 + void* __cblas_srot(void) 1083 1083 + { 1084 1084 + if (verbose) puts("STUB: __cblas_srot called"); 1085 1085 + return NULL; 1086 1086 + } 1087 1087 + 1088 1088 + void* __cblas_sscal(void) 1089 1089 + { 1090 1090 + if (verbose) puts("STUB: __cblas_sscal called"); 1091 1091 + return NULL; 1092 1092 + } 1093 1093 + 1094 1094 + void* __cblas_sswap(void) 1095 1095 + { 1096 1096 + if (verbose) puts("STUB: __cblas_sswap called"); 1097 1097 + return NULL; 1098 1098 + } 1099 1099 + 1100 1100 + void* dMultMatMat_16x16(void) 1101 1101 + { 1102 1102 + if (verbose) puts("STUB: dMultMatMat_16x16 called"); 1103 1103 + return NULL; 1104 1104 + } 1105 1105 + 1106 1106 + void* dMultMatMat_32x32(void) 1107 1107 + { 1108 1108 + if (verbose) puts("STUB: dMultMatMat_32x32 called"); 1109 1109 + return NULL; 1110 1110 + } 1111 1111 + 1112 1112 + void* dMultMatMat_4x4(void) 1113 1113 + { 1114 1114 + if (verbose) puts("STUB: dMultMatMat_4x4 called"); 1115 1115 + return NULL; 1116 1116 + } 1117 1117 + 1118 1118 + void* dMultMatMat_8x8(void) 1119 1119 + { 1120 1120 + if (verbose) puts("STUB: dMultMatMat_8x8 called"); 1121 1121 + return NULL; 1122 1122 + } 1123 1123 + 1124 1124 + void* dMultMatVec_16x16(void) 1125 1125 + { 1126 1126 + if (verbose) puts("STUB: dMultMatVec_16x16 called"); 1127 1127 + return NULL; 1128 1128 + } 1129 1129 + 1130 1130 + void* dMultMatVec_32x32(void) 1131 1131 + { 1132 1132 + if (verbose) puts("STUB: dMultMatVec_32x32 called"); 1133 1133 + return NULL; 1134 1134 + } 1135 1135 + 1136 1136 + void* dMultMatVec_4x4(void) 1137 1137 + { 1138 1138 + if (verbose) puts("STUB: dMultMatVec_4x4 called"); 1139 1139 + return NULL; 1140 1140 + } 1141 1141 + 1142 1142 + void* dMultMatVec_8x8(void) 1143 1143 + { 1144 1144 + if (verbose) puts("STUB: dMultMatVec_8x8 called"); 1145 1145 + return NULL; 1146 1146 + } 1147 1147 + 1148 1148 + void* dMultVecMat_16x16(void) 1149 1149 + { 1150 1150 + if (verbose) puts("STUB: dMultVecMat_16x16 called"); 1151 1151 + return NULL; 1152 1152 + } 1153 1153 + 1154 1154 + void* dMultVecMat_32x32(void) 1155 1155 + { 1156 1156 + if (verbose) puts("STUB: dMultVecMat_32x32 called"); 1157 1157 + return NULL; 1158 1158 + } 1159 1159 + 1160 1160 + void* dMultVecMat_4x4(void) 1161 1161 + { 1162 1162 + if (verbose) puts("STUB: dMultVecMat_4x4 called"); 1163 1163 + return NULL; 1164 1164 + } 1165 1165 + 1166 1166 + void* dMultVecMat_8x8(void) 1167 1167 + { 1168 1168 + if (verbose) puts("STUB: dMultVecMat_8x8 called"); 1169 1169 + return NULL; 1170 1170 + } 1171 1171 + 1172 1172 + void* sMultMatMat_16x16(void) 1173 1173 + { 1174 1174 + if (verbose) puts("STUB: sMultMatMat_16x16 called"); 1175 1175 + return NULL; 1176 1176 + } 1177 1177 + 1178 1178 + void* sMultMatMat_32x32(void) 1179 1179 + { 1180 1180 + if (verbose) puts("STUB: sMultMatMat_32x32 called"); 1181 1181 + return NULL; 1182 1182 + } 1183 1183 + 1184 1184 + void* sMultMatMat_4x4(void) 1185 1185 + { 1186 1186 + if (verbose) puts("STUB: sMultMatMat_4x4 called"); 1187 1187 + return NULL; 1188 1188 + } 1189 1189 + 1190 1190 + void* sMultMatMat_8x8(void) 1191 1191 + { 1192 1192 + if (verbose) puts("STUB: sMultMatMat_8x8 called"); 1193 1193 + return NULL; 1194 1194 + } 1195 1195 + 1196 1196 + void* sMultMatVec_16x16(void) 1197 1197 + { 1198 1198 + if (verbose) puts("STUB: sMultMatVec_16x16 called"); 1199 1199 + return NULL; 1200 1200 + } 1201 1201 + 1202 1202 + void* sMultMatVec_32x32(void) 1203 1203 + { 1204 1204 + if (verbose) puts("STUB: sMultMatVec_32x32 called"); 1205 1205 + return NULL; 1206 1206 + } 1207 1207 + 1208 1208 + void* sMultMatVec_4x4(void) 1209 1209 + { 1210 1210 + if (verbose) puts("STUB: sMultMatVec_4x4 called"); 1211 1211 + return NULL; 1212 1212 + } 1213 1213 + 1214 1214 + void* sMultMatVec_8x8(void) 1215 1215 + { 1216 1216 + if (verbose) puts("STUB: sMultMatVec_8x8 called"); 1217 1217 + return NULL; 1218 1218 + } 1219 1219 + 1220 1220 + void* sMultVecMat_16x16(void) 1221 1221 + { 1222 1222 + if (verbose) puts("STUB: sMultVecMat_16x16 called"); 1223 1223 + return NULL; 1224 1224 + } 1225 1225 + 1226 1226 + void* sMultVecMat_32x32(void) 1227 1227 + { 1228 1228 + if (verbose) puts("STUB: sMultVecMat_32x32 called"); 1229 1229 + return NULL; 1230 1230 + } 1231 1231 + 1232 1232 + void* sMultVecMat_4x4(void) 1233 1233 + { 1234 1234 + if (verbose) puts("STUB: sMultVecMat_4x4 called"); 1235 1235 + return NULL; 1236 1236 + } 1237 1237 + 1238 1238 + void* sMultVecMat_8x8(void) 1239 1239 + { 1240 1240 + if (verbose) puts("STUB: sMultVecMat_8x8 called"); 1241 1241 + return NULL; 1242 1242 + } 1243 1243 + 1244 1244 + void* vA1024Shift(void) 1245 1245 + { 1246 1246 + if (verbose) puts("STUB: vA1024Shift called"); 1247 1247 + return NULL; 1248 1248 + } 1249 1249 + 1250 1250 + void* vA128Shift(void) 1251 1251 + { 1252 1252 + if (verbose) puts("STUB: vA128Shift called"); 1253 1253 + return NULL; 1254 1254 + } 1255 1255 + 1256 1256 + void* vA256Shift(void) 1257 1257 + { 1258 1258 + if (verbose) puts("STUB: vA256Shift called"); 1259 1259 + return NULL; 1260 1260 + } 1261 1261 + 1262 1262 + void* vA512Shift(void) 1263 1263 + { 1264 1264 + if (verbose) puts("STUB: vA512Shift called"); 1265 1265 + return NULL; 1266 1266 + } 1267 1267 + 1268 1268 + void* vA64Shift(void) 1269 1269 + { 1270 1270 + if (verbose) puts("STUB: vA64Shift called"); 1271 1271 + return NULL; 1272 1272 + } 1273 1273 + 1274 1274 + void* vA64Shift2(void) 1275 1275 + { 1276 1276 + if (verbose) puts("STUB: vA64Shift2 called"); 1277 1277 + return NULL; 1278 1278 + } 1279 1279 + 1280 1280 + void* vIsamax(void) 1281 1281 + { 1282 1282 + if (verbose) puts("STUB: vIsamax called"); 1283 1283 + return NULL; 1284 1284 + } 1285 1285 + 1286 1286 + void* vIsamin(void) 1287 1287 + { 1288 1288 + if (verbose) puts("STUB: vIsamin called"); 1289 1289 + return NULL; 1290 1290 + } 1291 1291 + 1292 1292 + void* vIsmax(void) 1293 1293 + { 1294 1294 + if (verbose) puts("STUB: vIsmax called"); 1295 1295 + return NULL; 1296 1296 + } 1297 1297 + 1298 1298 + void* vIsmin(void) 1299 1299 + { 1300 1300 + if (verbose) puts("STUB: vIsmin called"); 1301 1301 + return NULL; 1302 1302 + } 1303 1303 + 1304 1304 + void* vL1024Rotate(void) 1305 1305 + { 1306 1306 + if (verbose) puts("STUB: vL1024Rotate called"); 1307 1307 + return NULL; 1308 1308 + } 1309 1309 + 1310 1310 + void* vL128Rotate(void) 1311 1311 + { 1312 1312 + if (verbose) puts("STUB: vL128Rotate called"); 1313 1313 + return NULL; 1314 1314 + } 1315 1315 + 1316 1316 + void* vL256Rotate(void) 1317 1317 + { 1318 1318 + if (verbose) puts("STUB: vL256Rotate called"); 1319 1319 + return NULL; 1320 1320 + } 1321 1321 + 1322 1322 + void* vL512Rotate(void) 1323 1323 + { 1324 1324 + if (verbose) puts("STUB: vL512Rotate called"); 1325 1325 + return NULL; 1326 1326 + } 1327 1327 + 1328 1328 + void* vL64Rotate(void) 1329 1329 + { 1330 1330 + if (verbose) puts("STUB: vL64Rotate called"); 1331 1331 + return NULL; 1332 1332 + } 1333 1333 + 1334 1334 + void* vL64Rotate2(void) 1335 1335 + { 1336 1336 + if (verbose) puts("STUB: vL64Rotate2 called"); 1337 1337 + return NULL; 1338 1338 + } 1339 1339 + 1340 1340 + void* vLL1024Shift(void) 1341 1341 + { 1342 1342 + if (verbose) puts("STUB: vLL1024Shift called"); 1343 1343 + return NULL; 1344 1344 + } 1345 1345 + 1346 1346 + void* vLL128Shift(void) 1347 1347 + { 1348 1348 + if (verbose) puts("STUB: vLL128Shift called"); 1349 1349 + return NULL; 1350 1350 + } 1351 1351 + 1352 1352 + void* vLL256Shift(void) 1353 1353 + { 1354 1354 + if (verbose) puts("STUB: vLL256Shift called"); 1355 1355 + return NULL; 1356 1356 + } 1357 1357 + 1358 1358 + void* vLL512Shift(void) 1359 1359 + { 1360 1360 + if (verbose) puts("STUB: vLL512Shift called"); 1361 1361 + return NULL; 1362 1362 + } 1363 1363 + 1364 1364 + void* vLL64Shift(void) 1365 1365 + { 1366 1366 + if (verbose) puts("STUB: vLL64Shift called"); 1367 1367 + return NULL; 1368 1368 + } 1369 1369 + 1370 1370 + void* vLL64Shift2(void) 1371 1371 + { 1372 1372 + if (verbose) puts("STUB: vLL64Shift2 called"); 1373 1373 + return NULL; 1374 1374 + } 1375 1375 + 1376 1376 + void* vLR1024Shift(void) 1377 1377 + { 1378 1378 + if (verbose) puts("STUB: vLR1024Shift called"); 1379 1379 + return NULL; 1380 1380 + } 1381 1381 + 1382 1382 + void* vLR128Shift(void) 1383 1383 + { 1384 1384 + if (verbose) puts("STUB: vLR128Shift called"); 1385 1385 + return NULL; 1386 1386 + } 1387 1387 + 1388 1388 + void* vLR256Shift(void) 1389 1389 + { 1390 1390 + if (verbose) puts("STUB: vLR256Shift called"); 1391 1391 + return NULL; 1392 1392 + } 1393 1393 + 1394 1394 + void* vLR512Shift(void) 1395 1395 + { 1396 1396 + if (verbose) puts("STUB: vLR512Shift called"); 1397 1397 + return NULL; 1398 1398 + } 1399 1399 + 1400 1400 + void* vLR64Shift(void) 1401 1401 + { 1402 1402 + if (verbose) puts("STUB: vLR64Shift called"); 1403 1403 + return NULL; 1404 1404 + } 1405 1405 + 1406 1406 + void* vLR64Shift2(void) 1407 1407 + { 1408 1408 + if (verbose) puts("STUB: vLR64Shift2 called"); 1409 1409 + return NULL; 1410 1410 + } 1411 1411 + 1412 1412 + void* vMultMatMat_16x16(void) 1413 1413 + { 1414 1414 + if (verbose) puts("STUB: vMultMatMat_16x16 called"); 1415 1415 + return NULL; 1416 1416 + } 1417 1417 + 1418 1418 + void* vMultMatMat_32x32(void) 1419 1419 + { 1420 1420 + if (verbose) puts("STUB: vMultMatMat_32x32 called"); 1421 1421 + return NULL; 1422 1422 + } 1423 1423 + 1424 1424 + void* vMultMatMat_4x4(void) 1425 1425 + { 1426 1426 + if (verbose) puts("STUB: vMultMatMat_4x4 called"); 1427 1427 + return NULL; 1428 1428 + } 1429 1429 + 1430 1430 + void* vMultMatMat_8x8(void) 1431 1431 + { 1432 1432 + if (verbose) puts("STUB: vMultMatMat_8x8 called"); 1433 1433 + return NULL; 1434 1434 + } 1435 1435 + 1436 1436 + void* vMultMatVec_16x16(void) 1437 1437 + { 1438 1438 + if (verbose) puts("STUB: vMultMatVec_16x16 called"); 1439 1439 + return NULL; 1440 1440 + } 1441 1441 + 1442 1442 + void* vMultMatVec_32x32(void) 1443 1443 + { 1444 1444 + if (verbose) puts("STUB: vMultMatVec_32x32 called"); 1445 1445 + return NULL; 1446 1446 + } 1447 1447 + 1448 1448 + void* vMultMatVec_4x4(void) 1449 1449 + { 1450 1450 + if (verbose) puts("STUB: vMultMatVec_4x4 called"); 1451 1451 + return NULL; 1452 1452 + } 1453 1453 + 1454 1454 + void* vMultMatVec_8x8(void) 1455 1455 + { 1456 1456 + if (verbose) puts("STUB: vMultMatVec_8x8 called"); 1457 1457 + return NULL; 1458 1458 + } 1459 1459 + 1460 1460 + void* vMultVecMat_16x16(void) 1461 1461 + { 1462 1462 + if (verbose) puts("STUB: vMultVecMat_16x16 called"); 1463 1463 + return NULL; 1464 1464 + } 1465 1465 + 1466 1466 + void* vMultVecMat_32x32(void) 1467 1467 + { 1468 1468 + if (verbose) puts("STUB: vMultVecMat_32x32 called"); 1469 1469 + return NULL; 1470 1470 + } 1471 1471 + 1472 1472 + void* vMultVecMat_4x4(void) 1473 1473 + { 1474 1474 + if (verbose) puts("STUB: vMultVecMat_4x4 called"); 1475 1475 + return NULL; 1476 1476 + } 1477 1477 + 1478 1478 + void* vMultVecMat_8x8(void) 1479 1479 + { 1480 1480 + if (verbose) puts("STUB: vMultVecMat_8x8 called"); 1481 1481 + return NULL; 1482 1482 + } 1483 1483 + 1484 1484 + void* vR1024Rotate(void) 1485 1485 + { 1486 1486 + if (verbose) puts("STUB: vR1024Rotate called"); 1487 1487 + return NULL; 1488 1488 + } 1489 1489 + 1490 1490 + void* vR128Rotate(void) 1491 1491 + { 1492 1492 + if (verbose) puts("STUB: vR128Rotate called"); 1493 1493 + return NULL; 1494 1494 + } 1495 1495 + 1496 1496 + void* vR256Rotate(void) 1497 1497 + { 1498 1498 + if (verbose) puts("STUB: vR256Rotate called"); 1499 1499 + return NULL; 1500 1500 + } 1501 1501 + 1502 1502 + void* vR512Rotate(void) 1503 1503 + { 1504 1504 + if (verbose) puts("STUB: vR512Rotate called"); 1505 1505 + return NULL; 1506 1506 + } 1507 1507 + 1508 1508 + void* vR64Rotate(void) 1509 1509 + { 1510 1510 + if (verbose) puts("STUB: vR64Rotate called"); 1511 1511 + return NULL; 1512 1512 + } 1513 1513 + 1514 1514 + void* vR64Rotate2(void) 1515 1515 + { 1516 1516 + if (verbose) puts("STUB: vR64Rotate2 called"); 1517 1517 + return NULL; 1518 1518 + } 1519 1519 + 1520 1520 + void* vS1024Add(void) 1521 1521 + { 1522 1522 + if (verbose) puts("STUB: vS1024Add called"); 1523 1523 + return NULL; 1524 1524 + } 1525 1525 + 1526 1526 + void* vS1024AddS(void) 1527 1527 + { 1528 1528 + if (verbose) puts("STUB: vS1024AddS called"); 1529 1529 + return NULL; 1530 1530 + } 1531 1531 + 1532 1532 + void* vS1024Divide(void) 1533 1533 + { 1534 1534 + if (verbose) puts("STUB: vS1024Divide called"); 1535 1535 + return NULL; 1536 1536 + } 1537 1537 + 1538 1538 + void* vS1024HalfMultiply(void) 1539 1539 + { 1540 1540 + if (verbose) puts("STUB: vS1024HalfMultiply called"); 1541 1541 + return NULL; 1542 1542 + } 1543 1543 + 1544 1544 + void* vS1024Mod(void) 1545 1545 + { 1546 1546 + if (verbose) puts("STUB: vS1024Mod called"); 1547 1547 + return NULL; 1548 1548 + } 1549 1549 + 1550 1550 + void* vS1024Neg(void) 1551 1551 + { 1552 1552 + if (verbose) puts("STUB: vS1024Neg called"); 1553 1553 + return NULL; 1554 1554 + } 1555 1555 + 1556 1556 + void* vS1024Sub(void) 1557 1557 + { 1558 1558 + if (verbose) puts("STUB: vS1024Sub called"); 1559 1559 + return NULL; 1560 1560 + } 1561 1561 + 1562 1562 + void* vS1024SubS(void) 1563 1563 + { 1564 1564 + if (verbose) puts("STUB: vS1024SubS called"); 1565 1565 + return NULL; 1566 1566 + } 1567 1567 + 1568 1568 + void* vS128Add(void) 1569 1569 + { 1570 1570 + if (verbose) puts("STUB: vS128Add called"); 1571 1571 + return NULL; 1572 1572 + } 1573 1573 + 1574 1574 + void* vS128AddS(void) 1575 1575 + { 1576 1576 + if (verbose) puts("STUB: vS128AddS called"); 1577 1577 + return NULL; 1578 1578 + } 1579 1579 + 1580 1580 + void* vS128Divide(void) 1581 1581 + { 1582 1582 + if (verbose) puts("STUB: vS128Divide called"); 1583 1583 + return NULL; 1584 1584 + } 1585 1585 + 1586 1586 + void* vS128FullMultiply(void) 1587 1587 + { 1588 1588 + if (verbose) puts("STUB: vS128FullMultiply called"); 1589 1589 + return NULL; 1590 1590 + } 1591 1591 + 1592 1592 + void* vS128HalfMultiply(void) 1593 1593 + { 1594 1594 + if (verbose) puts("STUB: vS128HalfMultiply called"); 1595 1595 + return NULL; 1596 1596 + } 1597 1597 + 1598 1598 + void* vS128Neg(void) 1599 1599 + { 1600 1600 + if (verbose) puts("STUB: vS128Neg called"); 1601 1601 + return NULL; 1602 1602 + } 1603 1603 + 1604 1604 + void* vS128Sub(void) 1605 1605 + { 1606 1606 + if (verbose) puts("STUB: vS128Sub called"); 1607 1607 + return NULL; 1608 1608 + } 1609 1609 + 1610 1610 + void* vS128SubS(void) 1611 1611 + { 1612 1612 + if (verbose) puts("STUB: vS128SubS called"); 1613 1613 + return NULL; 1614 1614 + } 1615 1615 + 1616 1616 + void* vS16Divide(void) 1617 1617 + { 1618 1618 + if (verbose) puts("STUB: vS16Divide called"); 1619 1619 + return NULL; 1620 1620 + } 1621 1621 + 1622 1622 + void* vS16HalfMultiply(void) 1623 1623 + { 1624 1624 + if (verbose) puts("STUB: vS16HalfMultiply called"); 1625 1625 + return NULL; 1626 1626 + } 1627 1627 + 1628 1628 + void* vS256Add(void) 1629 1629 + { 1630 1630 + if (verbose) puts("STUB: vS256Add called"); 1631 1631 + return NULL; 1632 1632 + } 1633 1633 + 1634 1634 + void* vS256AddS(void) 1635 1635 + { 1636 1636 + if (verbose) puts("STUB: vS256AddS called"); 1637 1637 + return NULL; 1638 1638 + } 1639 1639 + 1640 1640 + void* vS256Divide(void) 1641 1641 + { 1642 1642 + if (verbose) puts("STUB: vS256Divide called"); 1643 1643 + return NULL; 1644 1644 + } 1645 1645 + 1646 1646 + void* vS256FullMultiply(void) 1647 1647 + { 1648 1648 + if (verbose) puts("STUB: vS256FullMultiply called"); 1649 1649 + return NULL; 1650 1650 + } 1651 1651 + 1652 1652 + void* vS256HalfMultiply(void) 1653 1653 + { 1654 1654 + if (verbose) puts("STUB: vS256HalfMultiply called"); 1655 1655 + return NULL; 1656 1656 + } 1657 1657 + 1658 1658 + void* vS256Mod(void) 1659 1659 + { 1660 1660 + if (verbose) puts("STUB: vS256Mod called"); 1661 1661 + return NULL; 1662 1662 + } 1663 1663 + 1664 1664 + void* vS256Neg(void) 1665 1665 + { 1666 1666 + if (verbose) puts("STUB: vS256Neg called"); 1667 1667 + return NULL; 1668 1668 + } 1669 1669 + 1670 1670 + void* vS256Sub(void) 1671 1671 + { 1672 1672 + if (verbose) puts("STUB: vS256Sub called"); 1673 1673 + return NULL; 1674 1674 + } 1675 1675 + 1676 1676 + void* vS256SubS(void) 1677 1677 + { 1678 1678 + if (verbose) puts("STUB: vS256SubS called"); 1679 1679 + return NULL; 1680 1680 + } 1681 1681 + 1682 1682 + void* vS32Divide(void) 1683 1683 + { 1684 1684 + if (verbose) puts("STUB: vS32Divide called"); 1685 1685 + return NULL; 1686 1686 + } 1687 1687 + 1688 1688 + void* vS32FullMulEven(void) 1689 1689 + { 1690 1690 + if (verbose) puts("STUB: vS32FullMulEven called"); 1691 1691 + return NULL; 1692 1692 + } 1693 1693 + 1694 1694 + void* vS32FullMulOdd(void) 1695 1695 + { 1696 1696 + if (verbose) puts("STUB: vS32FullMulOdd called"); 1697 1697 + return NULL; 1698 1698 + } 1699 1699 + 1700 1700 + void* vS32HalfMultiply(void) 1701 1701 + { 1702 1702 + if (verbose) puts("STUB: vS32HalfMultiply called"); 1703 1703 + return NULL; 1704 1704 + } 1705 1705 + 1706 1706 + void* vS512Add(void) 1707 1707 + { 1708 1708 + if (verbose) puts("STUB: vS512Add called"); 1709 1709 + return NULL; 1710 1710 + } 1711 1711 + 1712 1712 + void* vS512AddS(void) 1713 1713 + { 1714 1714 + if (verbose) puts("STUB: vS512AddS called"); 1715 1715 + return NULL; 1716 1716 + } 1717 1717 + 1718 1718 + void* vS512Divide(void) 1719 1719 + { 1720 1720 + if (verbose) puts("STUB: vS512Divide called"); 1721 1721 + return NULL; 1722 1722 + } 1723 1723 + 1724 1724 + void* vS512FullMultiply(void) 1725 1725 + { 1726 1726 + if (verbose) puts("STUB: vS512FullMultiply called"); 1727 1727 + return NULL; 1728 1728 + } 1729 1729 + 1730 1730 + void* vS512HalfMultiply(void) 1731 1731 + { 1732 1732 + if (verbose) puts("STUB: vS512HalfMultiply called"); 1733 1733 + return NULL; 1734 1734 + } 1735 1735 + 1736 1736 + void* vS512Mod(void) 1737 1737 + { 1738 1738 + if (verbose) puts("STUB: vS512Mod called"); 1739 1739 + return NULL; 1740 1740 + } 1741 1741 + 1742 1742 + void* vS512Neg(void) 1743 1743 + { 1744 1744 + if (verbose) puts("STUB: vS512Neg called"); 1745 1745 + return NULL; 1746 1746 + } 1747 1747 + 1748 1748 + void* vS512Sub(void) 1749 1749 + { 1750 1750 + if (verbose) puts("STUB: vS512Sub called"); 1751 1751 + return NULL; 1752 1752 + } 1753 1753 + 1754 1754 + void* vS512SubS(void) 1755 1755 + { 1756 1756 + if (verbose) puts("STUB: vS512SubS called"); 1757 1757 + return NULL; 1758 1758 + } 1759 1759 + 1760 1760 + void* vS64Add(void) 1761 1761 + { 1762 1762 + if (verbose) puts("STUB: vS64Add called"); 1763 1763 + return NULL; 1764 1764 + } 1765 1765 + 1766 1766 + void* vS64AddS(void) 1767 1767 + { 1768 1768 + if (verbose) puts("STUB: vS64AddS called"); 1769 1769 + return NULL; 1770 1770 + } 1771 1771 + 1772 1772 + void* vS64Divide(void) 1773 1773 + { 1774 1774 + if (verbose) puts("STUB: vS64Divide called"); 1775 1775 + return NULL; 1776 1776 + } 1777 1777 + 1778 1778 + void* vS64FullMulEven(void) 1779 1779 + { 1780 1780 + if (verbose) puts("STUB: vS64FullMulEven called"); 1781 1781 + return NULL; 1782 1782 + } 1783 1783 + 1784 1784 + void* vS64FullMulOdd(void) 1785 1785 + { 1786 1786 + if (verbose) puts("STUB: vS64FullMulOdd called"); 1787 1787 + return NULL; 1788 1788 + } 1789 1789 + 1790 1790 + void* vS64HalfMultiply(void) 1791 1791 + { 1792 1792 + if (verbose) puts("STUB: vS64HalfMultiply called"); 1793 1793 + return NULL; 1794 1794 + } 1795 1795 + 1796 1796 + void* vS64Neg(void) 1797 1797 + { 1798 1798 + if (verbose) puts("STUB: vS64Neg called"); 1799 1799 + return NULL; 1800 1800 + } 1801 1801 + 1802 1802 + void* vS64Sub(void) 1803 1803 + { 1804 1804 + if (verbose) puts("STUB: vS64Sub called"); 1805 1805 + return NULL; 1806 1806 + } 1807 1807 + 1808 1808 + void* vS64SubS(void) 1809 1809 + { 1810 1810 + if (verbose) puts("STUB: vS64SubS called"); 1811 1811 + return NULL; 1812 1812 + } 1813 1813 + 1814 1814 + void* vS8Divide(void) 1815 1815 + { 1816 1816 + if (verbose) puts("STUB: vS8Divide called"); 1817 1817 + return NULL; 1818 1818 + } 1819 1819 + 1820 1820 + void* vS8HalfMultiply(void) 1821 1821 + { 1822 1822 + if (verbose) puts("STUB: vS8HalfMultiply called"); 1823 1823 + return NULL; 1824 1824 + } 1825 1825 + 1826 1826 + void* vSasum(void) 1827 1827 + { 1828 1828 + if (verbose) puts("STUB: vSasum called"); 1829 1829 + return NULL; 1830 1830 + } 1831 1831 + 1832 1832 + void* vSaxpy(void) 1833 1833 + { 1834 1834 + if (verbose) puts("STUB: vSaxpy called"); 1835 1835 + return NULL; 1836 1836 + } 1837 1837 + 1838 1838 + void* vScopy(void) 1839 1839 + { 1840 1840 + if (verbose) puts("STUB: vScopy called"); 1841 1841 + return NULL; 1842 1842 + } 1843 1843 + 1844 1844 + void* vSdot(void) 1845 1845 + { 1846 1846 + if (verbose) puts("STUB: vSdot called"); 1847 1847 + return NULL; 1848 1848 + } 1849 1849 + 1850 1850 + void* vSgeadd(void) 1851 1851 + { 1852 1852 + if (verbose) puts("STUB: vSgeadd called"); 1853 1853 + return NULL; 1854 1854 + } 1855 1855 + 1856 1856 + void* vSgemm(void) 1857 1857 + { 1858 1858 + if (verbose) puts("STUB: vSgemm called"); 1859 1859 + return NULL; 1860 1860 + } 1861 1861 + 1862 1862 + void* vSgemtx(void) 1863 1863 + { 1864 1864 + if (verbose) puts("STUB: vSgemtx called"); 1865 1865 + return NULL; 1866 1866 + } 1867 1867 + 1868 1868 + void* vSgemul(void) 1869 1869 + { 1870 1870 + if (verbose) puts("STUB: vSgemul called"); 1871 1871 + return NULL; 1872 1872 + } 1873 1873 + 1874 1874 + void* vSgemv(void) 1875 1875 + { 1876 1876 + if (verbose) puts("STUB: vSgemv called"); 1877 1877 + return NULL; 1878 1878 + } 1879 1879 + 1880 1880 + void* vSgemx(void) 1881 1881 + { 1882 1882 + if (verbose) puts("STUB: vSgemx called"); 1883 1883 + return NULL; 1884 1884 + } 1885 1885 + 1886 1886 + void* vSgesub(void) 1887 1887 + { 1888 1888 + if (verbose) puts("STUB: vSgesub called"); 1889 1889 + return NULL; 1890 1890 + } 1891 1891 + 1892 1892 + void* vSgetmi(void) 1893 1893 + { 1894 1894 + if (verbose) puts("STUB: vSgetmi called"); 1895 1895 + return NULL; 1896 1896 + } 1897 1897 + 1898 1898 + void* vSgetmo(void) 1899 1899 + { 1900 1900 + if (verbose) puts("STUB: vSgetmo called"); 1901 1901 + return NULL; 1902 1902 + } 1903 1903 + 1904 1904 + void* vSgevv(void) 1905 1905 + { 1906 1906 + if (verbose) puts("STUB: vSgevv called"); 1907 1907 + return NULL; 1908 1908 + } 1909 1909 + 1910 1910 + void* vSnaxpy(void) 1911 1911 + { 1912 1912 + if (verbose) puts("STUB: vSnaxpy called"); 1913 1913 + return NULL; 1914 1914 + } 1915 1915 + 1916 1916 + void* vSndot(void) 1917 1917 + { 1918 1918 + if (verbose) puts("STUB: vSndot called"); 1919 1919 + return NULL; 1920 1920 + } 1921 1921 + 1922 1922 + void* vSnorm2(void) 1923 1923 + { 1924 1924 + if (verbose) puts("STUB: vSnorm2 called"); 1925 1925 + return NULL; 1926 1926 + } 1927 1927 + 1928 1928 + void* vSnrm2(void) 1929 1929 + { 1930 1930 + if (verbose) puts("STUB: vSnrm2 called"); 1931 1931 + return NULL; 1932 1932 + } 1933 1933 + 1934 1934 + void* vSrot(void) 1935 1935 + { 1936 1936 + if (verbose) puts("STUB: vSrot called"); 1937 1937 + return NULL; 1938 1938 + } 1939 1939 + 1940 1940 + void* vSscal(void) 1941 1941 + { 1942 1942 + if (verbose) puts("STUB: vSscal called"); 1943 1943 + return NULL; 1944 1944 + } 1945 1945 + 1946 1946 + void* vSsum(void) 1947 1947 + { 1948 1948 + if (verbose) puts("STUB: vSsum called"); 1949 1949 + return NULL; 1950 1950 + } 1951 1951 + 1952 1952 + void* vSswap(void) 1953 1953 + { 1954 1954 + if (verbose) puts("STUB: vSswap called"); 1955 1955 + return NULL; 1956 1956 + } 1957 1957 + 1958 1958 + void* vSyax(void) 1959 1959 + { 1960 1960 + if (verbose) puts("STUB: vSyax called"); 1961 1961 + return NULL; 1962 1962 + } 1963 1963 + 1964 1964 + void* vSzaxpy(void) 1965 1965 + { 1966 1966 + if (verbose) puts("STUB: vSzaxpy called"); 1967 1967 + return NULL; 1968 1968 + } 1969 1969 + 1970 1970 + void* vU1024Add(void) 1971 1971 + { 1972 1972 + if (verbose) puts("STUB: vU1024Add called"); 1973 1973 + return NULL; 1974 1974 + } 1975 1975 + 1976 1976 + void* vU1024AddS(void) 1977 1977 + { 1978 1978 + if (verbose) puts("STUB: vU1024AddS called"); 1979 1979 + return NULL; 1980 1980 + } 1981 1981 + 1982 1982 + void* vU1024Divide(void) 1983 1983 + { 1984 1984 + if (verbose) puts("STUB: vU1024Divide called"); 1985 1985 + return NULL; 1986 1986 + } 1987 1987 + 1988 1988 + void* vU1024HalfMultiply(void) 1989 1989 + { 1990 1990 + if (verbose) puts("STUB: vU1024HalfMultiply called"); 1991 1991 + return NULL; 1992 1992 + } 1993 1993 + 1994 1994 + void* vU1024Mod(void) 1995 1995 + { 1996 1996 + if (verbose) puts("STUB: vU1024Mod called"); 1997 1997 + return NULL; 1998 1998 + } 1999 1999 + 2000 2000 + void* vU1024Neg(void) 2001 2001 + { 2002 2002 + if (verbose) puts("STUB: vU1024Neg called"); 2003 2003 + return NULL; 2004 2004 + } 2005 2005 + 2006 2006 + void* vU1024Sub(void) 2007 2007 + { 2008 2008 + if (verbose) puts("STUB: vU1024Sub called"); 2009 2009 + return NULL; 2010 2010 + } 2011 2011 + 2012 2012 + void* vU1024SubS(void) 2013 2013 + { 2014 2014 + if (verbose) puts("STUB: vU1024SubS called"); 2015 2015 + return NULL; 2016 2016 + } 2017 2017 + 2018 2018 + void* vU128Add(void) 2019 2019 + { 2020 2020 + if (verbose) puts("STUB: vU128Add called"); 2021 2021 + return NULL; 2022 2022 + } 2023 2023 + 2024 2024 + void* vU128AddS(void) 2025 2025 + { 2026 2026 + if (verbose) puts("STUB: vU128AddS called"); 2027 2027 + return NULL; 2028 2028 + } 2029 2029 + 2030 2030 + void* vU128Divide(void) 2031 2031 + { 2032 2032 + if (verbose) puts("STUB: vU128Divide called"); 2033 2033 + return NULL; 2034 2034 + } 2035 2035 + 2036 2036 + void* vU128FullMultiply(void) 2037 2037 + { 2038 2038 + if (verbose) puts("STUB: vU128FullMultiply called"); 2039 2039 + return NULL; 2040 2040 + } 2041 2041 + 2042 2042 + void* vU128HalfMultiply(void) 2043 2043 + { 2044 2044 + if (verbose) puts("STUB: vU128HalfMultiply called"); 2045 2045 + return NULL; 2046 2046 + } 2047 2047 + 2048 2048 + void* vU128Neg(void) 2049 2049 + { 2050 2050 + if (verbose) puts("STUB: vU128Neg called"); 2051 2051 + return NULL; 2052 2052 + } 2053 2053 + 2054 2054 + void* vU128Sub(void) 2055 2055 + { 2056 2056 + if (verbose) puts("STUB: vU128Sub called"); 2057 2057 + return NULL; 2058 2058 + } 2059 2059 + 2060 2060 + void* vU128SubS(void) 2061 2061 + { 2062 2062 + if (verbose) puts("STUB: vU128SubS called"); 2063 2063 + return NULL; 2064 2064 + } 2065 2065 + 2066 2066 + void* vU16Divide(void) 2067 2067 + { 2068 2068 + if (verbose) puts("STUB: vU16Divide called"); 2069 2069 + return NULL; 2070 2070 + } 2071 2071 + 2072 2072 + void* vU16HalfMultiply(void) 2073 2073 + { 2074 2074 + if (verbose) puts("STUB: vU16HalfMultiply called"); 2075 2075 + return NULL; 2076 2076 + } 2077 2077 + 2078 2078 + void* vU256Add(void) 2079 2079 + { 2080 2080 + if (verbose) puts("STUB: vU256Add called"); 2081 2081 + return NULL; 2082 2082 + } 2083 2083 + 2084 2084 + void* vU256AddS(void) 2085 2085 + { 2086 2086 + if (verbose) puts("STUB: vU256AddS called"); 2087 2087 + return NULL; 2088 2088 + } 2089 2089 + 2090 2090 + void* vU256Divide(void) 2091 2091 + { 2092 2092 + if (verbose) puts("STUB: vU256Divide called"); 2093 2093 + return NULL; 2094 2094 + } 2095 2095 + 2096 2096 + void* vU256FullMultiply(void) 2097 2097 + { 2098 2098 + if (verbose) puts("STUB: vU256FullMultiply called"); 2099 2099 + return NULL; 2100 2100 + } 2101 2101 + 2102 2102 + void* vU256HalfMultiply(void) 2103 2103 + { 2104 2104 + if (verbose) puts("STUB: vU256HalfMultiply called"); 2105 2105 + return NULL; 2106 2106 + } 2107 2107 + 2108 2108 + void* vU256Mod(void) 2109 2109 + { 2110 2110 + if (verbose) puts("STUB: vU256Mod called"); 2111 2111 + return NULL; 2112 2112 + } 2113 2113 + 2114 2114 + void* vU256Neg(void) 2115 2115 + { 2116 2116 + if (verbose) puts("STUB: vU256Neg called"); 2117 2117 + return NULL; 2118 2118 + } 2119 2119 + 2120 2120 + void* vU256Sub(void) 2121 2121 + { 2122 2122 + if (verbose) puts("STUB: vU256Sub called"); 2123 2123 + return NULL; 2124 2124 + } 2125 2125 + 2126 2126 + void* vU256SubS(void) 2127 2127 + { 2128 2128 + if (verbose) puts("STUB: vU256SubS called"); 2129 2129 + return NULL; 2130 2130 + } 2131 2131 + 2132 2132 + void* vU32Divide(void) 2133 2133 + { 2134 2134 + if (verbose) puts("STUB: vU32Divide called"); 2135 2135 + return NULL; 2136 2136 + } 2137 2137 + 2138 2138 + void* vU32FullMulEven(void) 2139 2139 + { 2140 2140 + if (verbose) puts("STUB: vU32FullMulEven called"); 2141 2141 + return NULL; 2142 2142 + } 2143 2143 + 2144 2144 + void* vU32FullMulOdd(void) 2145 2145 + { 2146 2146 + if (verbose) puts("STUB: vU32FullMulOdd called"); 2147 2147 + return NULL; 2148 2148 + } 2149 2149 + 2150 2150 + void* vU32HalfMultiply(void) 2151 2151 + { 2152 2152 + if (verbose) puts("STUB: vU32HalfMultiply called"); 2153 2153 + return NULL; 2154 2154 + } 2155 2155 + 2156 2156 + void* vU512Add(void) 2157 2157 + { 2158 2158 + if (verbose) puts("STUB: vU512Add called"); 2159 2159 + return NULL; 2160 2160 + } 2161 2161 + 2162 2162 + void* vU512AddS(void) 2163 2163 + { 2164 2164 + if (verbose) puts("STUB: vU512AddS called"); 2165 2165 + return NULL; 2166 2166 + } 2167 2167 + 2168 2168 + void* vU512Divide(void) 2169 2169 + { 2170 2170 + if (verbose) puts("STUB: vU512Divide called"); 2171 2171 + return NULL; 2172 2172 + } 2173 2173 + 2174 2174 + void* vU512FullMultiply(void) 2175 2175 + { 2176 2176 + if (verbose) puts("STUB: vU512FullMultiply called"); 2177 2177 + return NULL; 2178 2178 + } 2179 2179 + 2180 2180 + void* vU512HalfMultiply(void) 2181 2181 + { 2182 2182 + if (verbose) puts("STUB: vU512HalfMultiply called"); 2183 2183 + return NULL; 2184 2184 + } 2185 2185 + 2186 2186 + void* vU512Mod(void) 2187 2187 + { 2188 2188 + if (verbose) puts("STUB: vU512Mod called"); 2189 2189 + return NULL; 2190 2190 + } 2191 2191 + 2192 2192 + void* vU512Neg(void) 2193 2193 + { 2194 2194 + if (verbose) puts("STUB: vU512Neg called"); 2195 2195 + return NULL; 2196 2196 + } 2197 2197 + 2198 2198 + void* vU512Sub(void) 2199 2199 + { 2200 2200 + if (verbose) puts("STUB: vU512Sub called"); 2201 2201 + return NULL; 2202 2202 + } 2203 2203 + 2204 2204 + void* vU512SubS(void) 2205 2205 + { 2206 2206 + if (verbose) puts("STUB: vU512SubS called"); 2207 2207 + return NULL; 2208 2208 + } 2209 2209 + 2210 2210 + void* vU64Add(void) 2211 2211 + { 2212 2212 + if (verbose) puts("STUB: vU64Add called"); 2213 2213 + return NULL; 2214 2214 + } 2215 2215 + 2216 2216 + void* vU64AddS(void) 2217 2217 + { 2218 2218 + if (verbose) puts("STUB: vU64AddS called"); 2219 2219 + return NULL; 2220 2220 + } 2221 2221 + 2222 2222 + void* vU64Divide(void) 2223 2223 + { 2224 2224 + if (verbose) puts("STUB: vU64Divide called"); 2225 2225 + return NULL; 2226 2226 + } 2227 2227 + 2228 2228 + void* vU64FullMulEven(void) 2229 2229 + { 2230 2230 + if (verbose) puts("STUB: vU64FullMulEven called"); 2231 2231 + return NULL; 2232 2232 + } 2233 2233 + 2234 2234 + void* vU64FullMulOdd(void) 2235 2235 + { 2236 2236 + if (verbose) puts("STUB: vU64FullMulOdd called"); 2237 2237 + return NULL; 2238 2238 + } 2239 2239 + 2240 2240 + void* vU64HalfMultiply(void) 2241 2241 + { 2242 2242 + if (verbose) puts("STUB: vU64HalfMultiply called"); 2243 2243 + return NULL; 2244 2244 + } 2245 2245 + 2246 2246 + void* vU64Neg(void) 2247 2247 + { 2248 2248 + if (verbose) puts("STUB: vU64Neg called"); 2249 2249 + return NULL; 2250 2250 + } 2251 2251 + 2252 2252 + void* vU64Sub(void) 2253 2253 + { 2254 2254 + if (verbose) puts("STUB: vU64Sub called"); 2255 2255 + return NULL; 2256 2256 + } 2257 2257 + 2258 2258 + void* vU64SubS(void) 2259 2259 + { 2260 2260 + if (verbose) puts("STUB: vU64SubS called"); 2261 2261 + return NULL; 2262 2262 + } 2263 2263 + 2264 2264 + void* vU8Divide(void) 2265 2265 + { 2266 2266 + if (verbose) puts("STUB: vU8Divide called"); 2267 2267 + return NULL; 2268 2268 + } 2269 2269 + 2270 2270 + void* vU8HalfMultiply(void) 2271 2271 + { 2272 2272 + if (verbose) puts("STUB: vU8HalfMultiply called"); 2273 2273 + return NULL; 2274 2274 + } 2275 2275 + 2276 2276 + void* vacosf(void) 2277 2277 + { 2278 2278 + if (verbose) puts("STUB: vacosf called"); 2279 2279 + return NULL; 2280 2280 + } 2281 2281 + 2282 2282 + void* vacoshf(void) 2283 2283 + { 2284 2284 + if (verbose) puts("STUB: vacoshf called"); 2285 2285 + return NULL; 2286 2286 + } 2287 2287 + 2288 2288 + void* vasinf(void) 2289 2289 + { 2290 2290 + if (verbose) puts("STUB: vasinf called"); 2291 2291 + return NULL; 2292 2292 + } 2293 2293 + 2294 2294 + void* vasinhf(void) 2295 2295 + { 2296 2296 + if (verbose) puts("STUB: vasinhf called"); 2297 2297 + return NULL; 2298 2298 + } 2299 2299 + 2300 2300 + void* vatan2f(void) 2301 2301 + { 2302 2302 + if (verbose) puts("STUB: vatan2f called"); 2303 2303 + return NULL; 2304 2304 + } 2305 2305 + 2306 2306 + void* vatanf(void) 2307 2307 + { 2308 2308 + if (verbose) puts("STUB: vatanf called"); 2309 2309 + return NULL; 2310 2310 + } 2311 2311 + 2312 2312 + void* vatanhf(void) 2313 2313 + { 2314 2314 + if (verbose) puts("STUB: vatanhf called"); 2315 2315 + return NULL; 2316 2316 + } 2317 2317 + 2318 2318 + void* vceilf(void) 2319 2319 + { 2320 2320 + if (verbose) puts("STUB: vceilf called"); 2321 2321 + return NULL; 2322 2322 + } 2323 2323 + 2324 2324 + void* vclassifyf(void) 2325 2325 + { 2326 2326 + if (verbose) puts("STUB: vclassifyf called"); 2327 2327 + return NULL; 2328 2328 + } 2329 2329 + 2330 2330 + void* vcopysignf(void) 2331 2331 + { 2332 2332 + if (verbose) puts("STUB: vcopysignf called"); 2333 2333 + return NULL; 2334 2334 + } 2335 2335 + 2336 2336 + void* vcosf(void) 2337 2337 + { 2338 2338 + if (verbose) puts("STUB: vcosf called"); 2339 2339 + return NULL; 2340 2340 + } 2341 2341 + 2342 2342 + void* vcoshf(void) 2343 2343 + { 2344 2344 + if (verbose) puts("STUB: vcoshf called"); 2345 2345 + return NULL; 2346 2346 + } 2347 2347 + 2348 2348 + void* vcospif(void) 2349 2349 + { 2350 2350 + if (verbose) puts("STUB: vcospif called"); 2351 2351 + return NULL; 2352 2352 + } 2353 2353 + 2354 2354 + void* vdivf(void) 2355 2355 + { 2356 2356 + if (verbose) puts("STUB: vdivf called"); 2357 2357 + return NULL; 2358 2358 + } 2359 2359 + 2360 2360 + void* vec_sdot(void) 2361 2361 + { 2362 2362 + if (verbose) puts("STUB: vec_sdot called"); 2363 2363 + return NULL; 2364 2364 + } 2365 2365 + 2366 2366 + void* vexp2f(void) 2367 2367 + { 2368 2368 + if (verbose) puts("STUB: vexp2f called"); 2369 2369 + return NULL; 2370 2370 + } 2371 2371 + 2372 2372 + void* vexpf(void) 2373 2373 + { 2374 2374 + if (verbose) puts("STUB: vexpf called"); 2375 2375 + return NULL; 2376 2376 + } 2377 2377 + 2378 2378 + void* vexpm1f(void) 2379 2379 + { 2380 2380 + if (verbose) puts("STUB: vexpm1f called"); 2381 2381 + return NULL; 2382 2382 + } 2383 2383 + 2384 2384 + void* vfabf(void) 2385 2385 + { 2386 2386 + if (verbose) puts("STUB: vfabf called"); 2387 2387 + return NULL; 2388 2388 + } 2389 2389 + 2390 2390 + void* vfabsf(void) 2391 2391 + { 2392 2392 + if (verbose) puts("STUB: vfabsf called"); 2393 2393 + return NULL; 2394 2394 + } 2395 2395 + 2396 2396 + void* vfloorf(void) 2397 2397 + { 2398 2398 + if (verbose) puts("STUB: vfloorf called"); 2399 2399 + return NULL; 2400 2400 + } 2401 2401 + 2402 2402 + void* vfmodf(void) 2403 2403 + { 2404 2404 + if (verbose) puts("STUB: vfmodf called"); 2405 2405 + return NULL; 2406 2406 + } 2407 2407 + 2408 2408 + void* vintf(void) 2409 2409 + { 2410 2410 + if (verbose) puts("STUB: vintf called"); 2411 2411 + return NULL; 2412 2412 + } 2413 2413 + 2414 2414 + void* vipowf(void) 2415 2415 + { 2416 2416 + if (verbose) puts("STUB: vipowf called"); 2417 2417 + return NULL; 2418 2418 + } 2419 2419 + 2420 2420 + void* vlog10f(void) 2421 2421 + { 2422 2422 + if (verbose) puts("STUB: vlog10f called"); 2423 2423 + return NULL; 2424 2424 + } 2425 2425 + 2426 2426 + void* vlog1pf(void) 2427 2427 + { 2428 2428 + if (verbose) puts("STUB: vlog1pf called"); 2429 2429 + return NULL; 2430 2430 + } 2431 2431 + 2432 2432 + void* vlog2f(void) 2433 2433 + { 2434 2434 + if (verbose) puts("STUB: vlog2f called"); 2435 2435 + return NULL; 2436 2436 + } 2437 2437 + 2438 2438 + void* vlogbf(void) 2439 2439 + { 2440 2440 + if (verbose) puts("STUB: vlogbf called"); 2441 2441 + return NULL; 2442 2442 + } 2443 2443 + 2444 2444 + void* vlogf(void) 2445 2445 + { 2446 2446 + if (verbose) puts("STUB: vlogf called"); 2447 2447 + return NULL; 2448 2448 + } 2449 2449 + 2450 2450 + void* vnextafterf(void) 2451 2451 + { 2452 2452 + if (verbose) puts("STUB: vnextafterf called"); 2453 2453 + return NULL; 2454 2454 + } 2455 2455 + 2456 2456 + void* vnintf(void) 2457 2457 + { 2458 2458 + if (verbose) puts("STUB: vnintf called"); 2459 2459 + return NULL; 2460 2460 + } 2461 2461 + 2462 2462 + void* vpowf(void) 2463 2463 + { 2464 2464 + if (verbose) puts("STUB: vpowf called"); 2465 2465 + return NULL; 2466 2466 + } 2467 2467 + 2468 2468 + void* vrecf(void) 2469 2469 + { 2470 2470 + if (verbose) puts("STUB: vrecf called"); 2471 2471 + return NULL; 2472 2472 + } 2473 2473 + 2474 2474 + void* vremainderf(void) 2475 2475 + { 2476 2476 + if (verbose) puts("STUB: vremainderf called"); 2477 2477 + return NULL; 2478 2478 + } 2479 2479 + 2480 2480 + void* vremquof(void) 2481 2481 + { 2482 2482 + if (verbose) puts("STUB: vremquof called"); 2483 2483 + return NULL; 2484 2484 + } 2485 2485 + 2486 2486 + void* vrsqrtf(void) 2487 2487 + { 2488 2488 + if (verbose) puts("STUB: vrsqrtf called"); 2489 2489 + return NULL; 2490 2490 + } 2491 2491 + 2492 2492 + void* vscalbf(void) 2493 2493 + { 2494 2494 + if (verbose) puts("STUB: vscalbf called"); 2495 2495 + return NULL; 2496 2496 + } 2497 2497 + 2498 2498 + void* vsignbitf(void) 2499 2499 + { 2500 2500 + if (verbose) puts("STUB: vsignbitf called"); 2501 2501 + return NULL; 2502 2502 + } 2503 2503 + 2504 2504 + void* vsincosf(void) 2505 2505 + { 2506 2506 + if (verbose) puts("STUB: vsincosf called"); 2507 2507 + return NULL; 2508 2508 + } 2509 2509 + 2510 2510 + void* vsinf(void) 2511 2511 + { 2512 2512 + if (verbose) puts("STUB: vsinf called"); 2513 2513 + return NULL; 2514 2514 + } 2515 2515 + 2516 2516 + void* vsinhf(void) 2517 2517 + { 2518 2518 + if (verbose) puts("STUB: vsinhf called"); 2519 2519 + return NULL; 2520 2520 + } 2521 2521 + 2522 2522 + void* vsinpif(void) 2523 2523 + { 2524 2524 + if (verbose) puts("STUB: vsinpif called"); 2525 2525 + return NULL; 2526 2526 + } 2527 2527 + 2528 2528 + void* vsqrtf(void) 2529 2529 + { 2530 2530 + if (verbose) puts("STUB: vsqrtf called"); 2531 2531 + return NULL; 2532 2532 + } 2533 2533 + 2534 2534 + void* vtablelookup(void) 2535 2535 + { 2536 2536 + if (verbose) puts("STUB: vtablelookup called"); 2537 2537 + return NULL; 2538 2538 + } 2539 2539 + 2540 2540 + void* vtanf(void) 2541 2541 + { 2542 2542 + if (verbose) puts("STUB: vtanf called"); 2543 2543 + return NULL; 2544 2544 + } 2545 2545 + 2546 2546 + void* vtanhf(void) 2547 2547 + { 2548 2548 + if (verbose) puts("STUB: vtanhf called"); 2549 2549 + return NULL; 2550 2550 + } 2551 2551 + 2552 2552 + void* vtanpif(void) 2553 2553 + { 2554 2554 + if (verbose) puts("STUB: vtanpif called"); 2555 2555 + return NULL; 2556 2556 + } 2557 2557 + 2558 2558 + void* vtruncf(void) 2559 2559 + { 2560 2560 + if (verbose) puts("STUB: vtruncf called"); 2561 2561 + return NULL; 2562 2562 + } 2563 2563 + 2564 2564 + void* vvacos(void) 2565 2565 + { 2566 2566 + if (verbose) puts("STUB: vvacos called"); 2567 2567 + return NULL; 2568 2568 + } 2569 2569 + 2570 2570 + void* vvacos_(void) 2571 2571 + { 2572 2572 + if (verbose) puts("STUB: vvacos_ called"); 2573 2573 + return NULL; 2574 2574 + } 2575 2575 + 2576 2576 + void* vvacosf(void) 2577 2577 + { 2578 2578 + if (verbose) puts("STUB: vvacosf called"); 2579 2579 + return NULL; 2580 2580 + } 2581 2581 + 2582 2582 + void* vvacosf_(void) 2583 2583 + { 2584 2584 + if (verbose) puts("STUB: vvacosf_ called"); 2585 2585 + return NULL; 2586 2586 + } 2587 2587 + 2588 2588 + void* vvacosh(void) 2589 2589 + { 2590 2590 + if (verbose) puts("STUB: vvacosh called"); 2591 2591 + return NULL; 2592 2592 + } 2593 2593 + 2594 2594 + void* vvacosh_(void) 2595 2595 + { 2596 2596 + if (verbose) puts("STUB: vvacosh_ called"); 2597 2597 + return NULL; 2598 2598 + } 2599 2599 + 2600 2600 + void* vvacoshf(void) 2601 2601 + { 2602 2602 + if (verbose) puts("STUB: vvacoshf called"); 2603 2603 + return NULL; 2604 2604 + } 2605 2605 + 2606 2606 + void* vvacoshf_(void) 2607 2607 + { 2608 2608 + if (verbose) puts("STUB: vvacoshf_ called"); 2609 2609 + return NULL; 2610 2610 + } 2611 2611 + 2612 2612 + void* vvasin(void) 2613 2613 + { 2614 2614 + if (verbose) puts("STUB: vvasin called"); 2615 2615 + return NULL; 2616 2616 + } 2617 2617 + 2618 2618 + void* vvasin_(void) 2619 2619 + { 2620 2620 + if (verbose) puts("STUB: vvasin_ called"); 2621 2621 + return NULL; 2622 2622 + } 2623 2623 + 2624 2624 + void* vvasinf(void) 2625 2625 + { 2626 2626 + if (verbose) puts("STUB: vvasinf called"); 2627 2627 + return NULL; 2628 2628 + } 2629 2629 + 2630 2630 + void* vvasinf_(void) 2631 2631 + { 2632 2632 + if (verbose) puts("STUB: vvasinf_ called"); 2633 2633 + return NULL; 2634 2634 + } 2635 2635 + 2636 2636 + void* vvasinh(void) 2637 2637 + { 2638 2638 + if (verbose) puts("STUB: vvasinh called"); 2639 2639 + return NULL; 2640 2640 + } 2641 2641 + 2642 2642 + void* vvasinh_(void) 2643 2643 + { 2644 2644 + if (verbose) puts("STUB: vvasinh_ called"); 2645 2645 + return NULL; 2646 2646 + } 2647 2647 + 2648 2648 + void* vvasinhf(void) 2649 2649 + { 2650 2650 + if (verbose) puts("STUB: vvasinhf called"); 2651 2651 + return NULL; 2652 2652 + } 2653 2653 + 2654 2654 + void* vvasinhf_(void) 2655 2655 + { 2656 2656 + if (verbose) puts("STUB: vvasinhf_ called"); 2657 2657 + return NULL; 2658 2658 + } 2659 2659 + 2660 2660 + void* vvatan(void) 2661 2661 + { 2662 2662 + if (verbose) puts("STUB: vvatan called"); 2663 2663 + return NULL; 2664 2664 + } 2665 2665 + 2666 2666 + void* vvatan2(void) 2667 2667 + { 2668 2668 + if (verbose) puts("STUB: vvatan2 called"); 2669 2669 + return NULL; 2670 2670 + } 2671 2671 + 2672 2672 + void* vvatan2_(void) 2673 2673 + { 2674 2674 + if (verbose) puts("STUB: vvatan2_ called"); 2675 2675 + return NULL; 2676 2676 + } 2677 2677 + 2678 2678 + void* vvatan2f(void) 2679 2679 + { 2680 2680 + if (verbose) puts("STUB: vvatan2f called"); 2681 2681 + return NULL; 2682 2682 + } 2683 2683 + 2684 2684 + void* vvatan2f_(void) 2685 2685 + { 2686 2686 + if (verbose) puts("STUB: vvatan2f_ called"); 2687 2687 + return NULL; 2688 2688 + } 2689 2689 + 2690 2690 + void* vvatan_(void) 2691 2691 + { 2692 2692 + if (verbose) puts("STUB: vvatan_ called"); 2693 2693 + return NULL; 2694 2694 + } 2695 2695 + 2696 2696 + void* vvatanf(void) 2697 2697 + { 2698 2698 + if (verbose) puts("STUB: vvatanf called"); 2699 2699 + return NULL; 2700 2700 + } 2701 2701 + 2702 2702 + void* vvatanf_(void) 2703 2703 + { 2704 2704 + if (verbose) puts("STUB: vvatanf_ called"); 2705 2705 + return NULL; 2706 2706 + } 2707 2707 + 2708 2708 + void* vvatanh(void) 2709 2709 + { 2710 2710 + if (verbose) puts("STUB: vvatanh called"); 2711 2711 + return NULL; 2712 2712 + } 2713 2713 + 2714 2714 + void* vvatanh_(void) 2715 2715 + { 2716 2716 + if (verbose) puts("STUB: vvatanh_ called"); 2717 2717 + return NULL; 2718 2718 + } 2719 2719 + 2720 2720 + void* vvatanhf(void) 2721 2721 + { 2722 2722 + if (verbose) puts("STUB: vvatanhf called"); 2723 2723 + return NULL; 2724 2724 + } 2725 2725 + 2726 2726 + void* vvatanhf_(void) 2727 2727 + { 2728 2728 + if (verbose) puts("STUB: vvatanhf_ called"); 2729 2729 + return NULL; 2730 2730 + } 2731 2731 + 2732 2732 + void* vvcbrt(void) 2733 2733 + { 2734 2734 + if (verbose) puts("STUB: vvcbrt called"); 2735 2735 + return NULL; 2736 2736 + } 2737 2737 + 2738 2738 + void* vvcbrt_(void) 2739 2739 + { 2740 2740 + if (verbose) puts("STUB: vvcbrt_ called"); 2741 2741 + return NULL; 2742 2742 + } 2743 2743 + 2744 2744 + void* vvcbrtf(void) 2745 2745 + { 2746 2746 + if (verbose) puts("STUB: vvcbrtf called"); 2747 2747 + return NULL; 2748 2748 + } 2749 2749 + 2750 2750 + void* vvcbrtf_(void) 2751 2751 + { 2752 2752 + if (verbose) puts("STUB: vvcbrtf_ called"); 2753 2753 + return NULL; 2754 2754 + } 2755 2755 + 2756 2756 + void* vvceil(void) 2757 2757 + { 2758 2758 + if (verbose) puts("STUB: vvceil called"); 2759 2759 + return NULL; 2760 2760 + } 2761 2761 + 2762 2762 + void* vvceil_(void) 2763 2763 + { 2764 2764 + if (verbose) puts("STUB: vvceil_ called"); 2765 2765 + return NULL; 2766 2766 + } 2767 2767 + 2768 2768 + void* vvceilf(void) 2769 2769 + { 2770 2770 + if (verbose) puts("STUB: vvceilf called"); 2771 2771 + return NULL; 2772 2772 + } 2773 2773 + 2774 2774 + void* vvceilf_(void) 2775 2775 + { 2776 2776 + if (verbose) puts("STUB: vvceilf_ called"); 2777 2777 + return NULL; 2778 2778 + } 2779 2779 + 2780 2780 + void* vvcopysign(void) 2781 2781 + { 2782 2782 + if (verbose) puts("STUB: vvcopysign called"); 2783 2783 + return NULL; 2784 2784 + } 2785 2785 + 2786 2786 + void* vvcopysign_(void) 2787 2787 + { 2788 2788 + if (verbose) puts("STUB: vvcopysign_ called"); 2789 2789 + return NULL; 2790 2790 + } 2791 2791 + 2792 2792 + void* vvcopysignf(void) 2793 2793 + { 2794 2794 + if (verbose) puts("STUB: vvcopysignf called"); 2795 2795 + return NULL; 2796 2796 + } 2797 2797 + 2798 2798 + void* vvcopysignf_(void) 2799 2799 + { 2800 2800 + if (verbose) puts("STUB: vvcopysignf_ called"); 2801 2801 + return NULL; 2802 2802 + } 2803 2803 + 2804 2804 + void* vvcos(void) 2805 2805 + { 2806 2806 + if (verbose) puts("STUB: vvcos called"); 2807 2807 + return NULL; 2808 2808 + } 2809 2809 + 2810 2810 + void* vvcos_(void) 2811 2811 + { 2812 2812 + if (verbose) puts("STUB: vvcos_ called"); 2813 2813 + return NULL; 2814 2814 + } 2815 2815 + 2816 2816 + void* vvcosf(void) 2817 2817 + { 2818 2818 + if (verbose) puts("STUB: vvcosf called"); 2819 2819 + return NULL; 2820 2820 + } 2821 2821 + 2822 2822 + void* vvcosf_(void) 2823 2823 + { 2824 2824 + if (verbose) puts("STUB: vvcosf_ called"); 2825 2825 + return NULL; 2826 2826 + } 2827 2827 + 2828 2828 + void* vvcosh(void) 2829 2829 + { 2830 2830 + if (verbose) puts("STUB: vvcosh called"); 2831 2831 + return NULL; 2832 2832 + } 2833 2833 + 2834 2834 + void* vvcosh_(void) 2835 2835 + { 2836 2836 + if (verbose) puts("STUB: vvcosh_ called"); 2837 2837 + return NULL; 2838 2838 + } 2839 2839 + 2840 2840 + void* vvcoshf(void) 2841 2841 + { 2842 2842 + if (verbose) puts("STUB: vvcoshf called"); 2843 2843 + return NULL; 2844 2844 + } 2845 2845 + 2846 2846 + void* vvcoshf_(void) 2847 2847 + { 2848 2848 + if (verbose) puts("STUB: vvcoshf_ called"); 2849 2849 + return NULL; 2850 2850 + } 2851 2851 + 2852 2852 + void* vvcosisin(void) 2853 2853 + { 2854 2854 + if (verbose) puts("STUB: vvcosisin called"); 2855 2855 + return NULL; 2856 2856 + } 2857 2857 + 2858 2858 + void* vvcosisin_(void) 2859 2859 + { 2860 2860 + if (verbose) puts("STUB: vvcosisin_ called"); 2861 2861 + return NULL; 2862 2862 + } 2863 2863 + 2864 2864 + void* vvcosisinf(void) 2865 2865 + { 2866 2866 + if (verbose) puts("STUB: vvcosisinf called"); 2867 2867 + return NULL; 2868 2868 + } 2869 2869 + 2870 2870 + void* vvcosisinf_(void) 2871 2871 + { 2872 2872 + if (verbose) puts("STUB: vvcosisinf_ called"); 2873 2873 + return NULL; 2874 2874 + } 2875 2875 + 2876 2876 + void* vvcospi(void) 2877 2877 + { 2878 2878 + if (verbose) puts("STUB: vvcospi called"); 2879 2879 + return NULL; 2880 2880 + } 2881 2881 + 2882 2882 + void* vvcospi_(void) 2883 2883 + { 2884 2884 + if (verbose) puts("STUB: vvcospi_ called"); 2885 2885 + return NULL; 2886 2886 + } 2887 2887 + 2888 2888 + void* vvcospif(void) 2889 2889 + { 2890 2890 + if (verbose) puts("STUB: vvcospif called"); 2891 2891 + return NULL; 2892 2892 + } 2893 2893 + 2894 2894 + void* vvcospif_(void) 2895 2895 + { 2896 2896 + if (verbose) puts("STUB: vvcospif_ called"); 2897 2897 + return NULL; 2898 2898 + } 2899 2899 + 2900 2900 + void* vvdiv(void) 2901 2901 + { 2902 2902 + if (verbose) puts("STUB: vvdiv called"); 2903 2903 + return NULL; 2904 2904 + } 2905 2905 + 2906 2906 + void* vvdiv_(void) 2907 2907 + { 2908 2908 + if (verbose) puts("STUB: vvdiv_ called"); 2909 2909 + return NULL; 2910 2910 + } 2911 2911 + 2912 2912 + void* vvdivf(void) 2913 2913 + { 2914 2914 + if (verbose) puts("STUB: vvdivf called"); 2915 2915 + return NULL; 2916 2916 + } 2917 2917 + 2918 2918 + void* vvdivf_(void) 2919 2919 + { 2920 2920 + if (verbose) puts("STUB: vvdivf_ called"); 2921 2921 + return NULL; 2922 2922 + } 2923 2923 + 2924 2924 + void* vvexp(void) 2925 2925 + { 2926 2926 + if (verbose) puts("STUB: vvexp called"); 2927 2927 + return NULL; 2928 2928 + } 2929 2929 + 2930 2930 + void* vvexp2(void) 2931 2931 + { 2932 2932 + if (verbose) puts("STUB: vvexp2 called"); 2933 2933 + return NULL; 2934 2934 + } 2935 2935 + 2936 2936 + void* vvexp2_(void) 2937 2937 + { 2938 2938 + if (verbose) puts("STUB: vvexp2_ called"); 2939 2939 + return NULL; 2940 2940 + } 2941 2941 + 2942 2942 + void* vvexp2f(void) 2943 2943 + { 2944 2944 + if (verbose) puts("STUB: vvexp2f called"); 2945 2945 + return NULL; 2946 2946 + } 2947 2947 + 2948 2948 + void* vvexp2f_(void) 2949 2949 + { 2950 2950 + if (verbose) puts("STUB: vvexp2f_ called"); 2951 2951 + return NULL; 2952 2952 + } 2953 2953 + 2954 2954 + void* vvexp_(void) 2955 2955 + { 2956 2956 + if (verbose) puts("STUB: vvexp_ called"); 2957 2957 + return NULL; 2958 2958 + } 2959 2959 + 2960 2960 + void* vvexpf(void) 2961 2961 + { 2962 2962 + if (verbose) puts("STUB: vvexpf called"); 2963 2963 + return NULL; 2964 2964 + } 2965 2965 + 2966 2966 + void* vvexpf_(void) 2967 2967 + { 2968 2968 + if (verbose) puts("STUB: vvexpf_ called"); 2969 2969 + return NULL; 2970 2970 + } 2971 2971 + 2972 2972 + void* vvexpm1(void) 2973 2973 + { 2974 2974 + if (verbose) puts("STUB: vvexpm1 called"); 2975 2975 + return NULL; 2976 2976 + } 2977 2977 + 2978 2978 + void* vvexpm1_(void) 2979 2979 + { 2980 2980 + if (verbose) puts("STUB: vvexpm1_ called"); 2981 2981 + return NULL; 2982 2982 + } 2983 2983 + 2984 2984 + void* vvexpm1f(void) 2985 2985 + { 2986 2986 + if (verbose) puts("STUB: vvexpm1f called"); 2987 2987 + return NULL; 2988 2988 + } 2989 2989 + 2990 2990 + void* vvexpm1f_(void) 2991 2991 + { 2992 2992 + if (verbose) puts("STUB: vvexpm1f_ called"); 2993 2993 + return NULL; 2994 2994 + } 2995 2995 + 2996 2996 + void* vvfabf(void) 2997 2997 + { 2998 2998 + if (verbose) puts("STUB: vvfabf called"); 2999 2999 + return NULL; 3000 3000 + } 3001 3001 + 3002 3002 + void* vvfabf_(void) 3003 3003 + { 3004 3004 + if (verbose) puts("STUB: vvfabf_ called"); 3005 3005 + return NULL; 3006 3006 + } 3007 3007 + 3008 3008 + void* vvfabs(void) 3009 3009 + { 3010 3010 + if (verbose) puts("STUB: vvfabs called"); 3011 3011 + return NULL; 3012 3012 + } 3013 3013 + 3014 3014 + void* vvfabs_(void) 3015 3015 + { 3016 3016 + if (verbose) puts("STUB: vvfabs_ called"); 3017 3017 + return NULL; 3018 3018 + } 3019 3019 + 3020 3020 + void* vvfabsf(void) 3021 3021 + { 3022 3022 + if (verbose) puts("STUB: vvfabsf called"); 3023 3023 + return NULL; 3024 3024 + } 3025 3025 + 3026 3026 + void* vvfabsf_(void) 3027 3027 + { 3028 3028 + if (verbose) puts("STUB: vvfabsf_ called"); 3029 3029 + return NULL; 3030 3030 + } 3031 3031 + 3032 3032 + void* vvfloor(void) 3033 3033 + { 3034 3034 + if (verbose) puts("STUB: vvfloor called"); 3035 3035 + return NULL; 3036 3036 + } 3037 3037 + 3038 3038 + void* vvfloor_(void) 3039 3039 + { 3040 3040 + if (verbose) puts("STUB: vvfloor_ called"); 3041 3041 + return NULL; 3042 3042 + } 3043 3043 + 3044 3044 + void* vvfloorf(void) 3045 3045 + { 3046 3046 + if (verbose) puts("STUB: vvfloorf called"); 3047 3047 + return NULL; 3048 3048 + } 3049 3049 + 3050 3050 + void* vvfloorf_(void) 3051 3051 + { 3052 3052 + if (verbose) puts("STUB: vvfloorf_ called"); 3053 3053 + return NULL; 3054 3054 + } 3055 3055 + 3056 3056 + void* vvfmod(void) 3057 3057 + { 3058 3058 + if (verbose) puts("STUB: vvfmod called"); 3059 3059 + return NULL; 3060 3060 + } 3061 3061 + 3062 3062 + void* vvfmod_(void) 3063 3063 + { 3064 3064 + if (verbose) puts("STUB: vvfmod_ called"); 3065 3065 + return NULL; 3066 3066 + } 3067 3067 + 3068 3068 + void* vvfmodf(void) 3069 3069 + { 3070 3070 + if (verbose) puts("STUB: vvfmodf called"); 3071 3071 + return NULL; 3072 3072 + } 3073 3073 + 3074 3074 + void* vvfmodf_(void) 3075 3075 + { 3076 3076 + if (verbose) puts("STUB: vvfmodf_ called"); 3077 3077 + return NULL; 3078 3078 + } 3079 3079 + 3080 3080 + void* vvint(void) 3081 3081 + { 3082 3082 + if (verbose) puts("STUB: vvint called"); 3083 3083 + return NULL; 3084 3084 + } 3085 3085 + 3086 3086 + void* vvint_(void) 3087 3087 + { 3088 3088 + if (verbose) puts("STUB: vvint_ called"); 3089 3089 + return NULL; 3090 3090 + } 3091 3091 + 3092 3092 + void* vvintf(void) 3093 3093 + { 3094 3094 + if (verbose) puts("STUB: vvintf called"); 3095 3095 + return NULL; 3096 3096 + } 3097 3097 + 3098 3098 + void* vvintf_(void) 3099 3099 + { 3100 3100 + if (verbose) puts("STUB: vvintf_ called"); 3101 3101 + return NULL; 3102 3102 + } 3103 3103 + 3104 3104 + void* vvlog(void) 3105 3105 + { 3106 3106 + if (verbose) puts("STUB: vvlog called"); 3107 3107 + return NULL; 3108 3108 + } 3109 3109 + 3110 3110 + void* vvlog10(void) 3111 3111 + { 3112 3112 + if (verbose) puts("STUB: vvlog10 called"); 3113 3113 + return NULL; 3114 3114 + } 3115 3115 + 3116 3116 + void* vvlog10_(void) 3117 3117 + { 3118 3118 + if (verbose) puts("STUB: vvlog10_ called"); 3119 3119 + return NULL; 3120 3120 + } 3121 3121 + 3122 3122 + void* vvlog10f(void) 3123 3123 + { 3124 3124 + if (verbose) puts("STUB: vvlog10f called"); 3125 3125 + return NULL; 3126 3126 + } 3127 3127 + 3128 3128 + void* vvlog10f_(void) 3129 3129 + { 3130 3130 + if (verbose) puts("STUB: vvlog10f_ called"); 3131 3131 + return NULL; 3132 3132 + } 3133 3133 + 3134 3134 + void* vvlog1p(void) 3135 3135 + { 3136 3136 + if (verbose) puts("STUB: vvlog1p called"); 3137 3137 + return NULL; 3138 3138 + } 3139 3139 + 3140 3140 + void* vvlog1p_(void) 3141 3141 + { 3142 3142 + if (verbose) puts("STUB: vvlog1p_ called"); 3143 3143 + return NULL; 3144 3144 + } 3145 3145 + 3146 3146 + void* vvlog1pf(void) 3147 3147 + { 3148 3148 + if (verbose) puts("STUB: vvlog1pf called"); 3149 3149 + return NULL; 3150 3150 + } 3151 3151 + 3152 3152 + void* vvlog1pf_(void) 3153 3153 + { 3154 3154 + if (verbose) puts("STUB: vvlog1pf_ called"); 3155 3155 + return NULL; 3156 3156 + } 3157 3157 + 3158 3158 + void* vvlog2(void) 3159 3159 + { 3160 3160 + if (verbose) puts("STUB: vvlog2 called"); 3161 3161 + return NULL; 3162 3162 + } 3163 3163 + 3164 3164 + void* vvlog2_(void) 3165 3165 + { 3166 3166 + if (verbose) puts("STUB: vvlog2_ called"); 3167 3167 + return NULL; 3168 3168 + } 3169 3169 + 3170 3170 + void* vvlog2f(void) 3171 3171 + { 3172 3172 + if (verbose) puts("STUB: vvlog2f called"); 3173 3173 + return NULL; 3174 3174 + } 3175 3175 + 3176 3176 + void* vvlog2f_(void) 3177 3177 + { 3178 3178 + if (verbose) puts("STUB: vvlog2f_ called"); 3179 3179 + return NULL; 3180 3180 + } 3181 3181 + 3182 3182 + void* vvlog_(void) 3183 3183 + { 3184 3184 + if (verbose) puts("STUB: vvlog_ called"); 3185 3185 + return NULL; 3186 3186 + } 3187 3187 + 3188 3188 + void* vvlogb(void) 3189 3189 + { 3190 3190 + if (verbose) puts("STUB: vvlogb called"); 3191 3191 + return NULL; 3192 3192 + } 3193 3193 + 3194 3194 + void* vvlogb_(void) 3195 3195 + { 3196 3196 + if (verbose) puts("STUB: vvlogb_ called"); 3197 3197 + return NULL; 3198 3198 + } 3199 3199 + 3200 3200 + void* vvlogbf(void) 3201 3201 + { 3202 3202 + if (verbose) puts("STUB: vvlogbf called"); 3203 3203 + return NULL; 3204 3204 + } 3205 3205 + 3206 3206 + void* vvlogbf_(void) 3207 3207 + { 3208 3208 + if (verbose) puts("STUB: vvlogbf_ called"); 3209 3209 + return NULL; 3210 3210 + } 3211 3211 + 3212 3212 + void* vvlogf(void) 3213 3213 + { 3214 3214 + if (verbose) puts("STUB: vvlogf called"); 3215 3215 + return NULL; 3216 3216 + } 3217 3217 + 3218 3218 + void* vvlogf_(void) 3219 3219 + { 3220 3220 + if (verbose) puts("STUB: vvlogf_ called"); 3221 3221 + return NULL; 3222 3222 + } 3223 3223 + 3224 3224 + void* vvnextafter(void) 3225 3225 + { 3226 3226 + if (verbose) puts("STUB: vvnextafter called"); 3227 3227 + return NULL; 3228 3228 + } 3229 3229 + 3230 3230 + void* vvnextafter_(void) 3231 3231 + { 3232 3232 + if (verbose) puts("STUB: vvnextafter_ called"); 3233 3233 + return NULL; 3234 3234 + } 3235 3235 + 3236 3236 + void* vvnextafterf(void) 3237 3237 + { 3238 3238 + if (verbose) puts("STUB: vvnextafterf called"); 3239 3239 + return NULL; 3240 3240 + } 3241 3241 + 3242 3242 + void* vvnextafterf_(void) 3243 3243 + { 3244 3244 + if (verbose) puts("STUB: vvnextafterf_ called"); 3245 3245 + return NULL; 3246 3246 + } 3247 3247 + 3248 3248 + void* vvnint(void) 3249 3249 + { 3250 3250 + if (verbose) puts("STUB: vvnint called"); 3251 3251 + return NULL; 3252 3252 + } 3253 3253 + 3254 3254 + void* vvnint_(void) 3255 3255 + { 3256 3256 + if (verbose) puts("STUB: vvnint_ called"); 3257 3257 + return NULL; 3258 3258 + } 3259 3259 + 3260 3260 + void* vvnintf(void) 3261 3261 + { 3262 3262 + if (verbose) puts("STUB: vvnintf called"); 3263 3263 + return NULL; 3264 3264 + } 3265 3265 + 3266 3266 + void* vvnintf_(void) 3267 3267 + { 3268 3268 + if (verbose) puts("STUB: vvnintf_ called"); 3269 3269 + return NULL; 3270 3270 + } 3271 3271 + 3272 3272 + void* vvpow(void) 3273 3273 + { 3274 3274 + if (verbose) puts("STUB: vvpow called"); 3275 3275 + return NULL; 3276 3276 + } 3277 3277 + 3278 3278 + void* vvpow_(void) 3279 3279 + { 3280 3280 + if (verbose) puts("STUB: vvpow_ called"); 3281 3281 + return NULL; 3282 3282 + } 3283 3283 + 3284 3284 + void* vvpowf(void) 3285 3285 + { 3286 3286 + if (verbose) puts("STUB: vvpowf called"); 3287 3287 + return NULL; 3288 3288 + } 3289 3289 + 3290 3290 + void* vvpowf_(void) 3291 3291 + { 3292 3292 + if (verbose) puts("STUB: vvpowf_ called"); 3293 3293 + return NULL; 3294 3294 + } 3295 3295 + 3296 3296 + void* vvpows(void) 3297 3297 + { 3298 3298 + if (verbose) puts("STUB: vvpows called"); 3299 3299 + return NULL; 3300 3300 + } 3301 3301 + 3302 3302 + void* vvpows_(void) 3303 3303 + { 3304 3304 + if (verbose) puts("STUB: vvpows_ called"); 3305 3305 + return NULL; 3306 3306 + } 3307 3307 + 3308 3308 + void* vvpowsf(void) 3309 3309 + { 3310 3310 + if (verbose) puts("STUB: vvpowsf called"); 3311 3311 + return NULL; 3312 3312 + } 3313 3313 + 3314 3314 + void* vvpowsf_(void) 3315 3315 + { 3316 3316 + if (verbose) puts("STUB: vvpowsf_ called"); 3317 3317 + return NULL; 3318 3318 + } 3319 3319 + 3320 3320 + void* vvrec(void) 3321 3321 + { 3322 3322 + if (verbose) puts("STUB: vvrec called"); 3323 3323 + return NULL; 3324 3324 + } 3325 3325 + 3326 3326 + void* vvrec_(void) 3327 3327 + { 3328 3328 + if (verbose) puts("STUB: vvrec_ called"); 3329 3329 + return NULL; 3330 3330 + } 3331 3331 + 3332 3332 + void* vvrecf(void) 3333 3333 + { 3334 3334 + if (verbose) puts("STUB: vvrecf called"); 3335 3335 + return NULL; 3336 3336 + } 3337 3337 + 3338 3338 + void* vvrecf_(void) 3339 3339 + { 3340 3340 + if (verbose) puts("STUB: vvrecf_ called"); 3341 3341 + return NULL; 3342 3342 + } 3343 3343 + 3344 3344 + void* vvremainder(void) 3345 3345 + { 3346 3346 + if (verbose) puts("STUB: vvremainder called"); 3347 3347 + return NULL; 3348 3348 + } 3349 3349 + 3350 3350 + void* vvremainder_(void) 3351 3351 + { 3352 3352 + if (verbose) puts("STUB: vvremainder_ called"); 3353 3353 + return NULL; 3354 3354 + } 3355 3355 + 3356 3356 + void* vvremainderf(void) 3357 3357 + { 3358 3358 + if (verbose) puts("STUB: vvremainderf called"); 3359 3359 + return NULL; 3360 3360 + } 3361 3361 + 3362 3362 + void* vvremainderf_(void) 3363 3363 + { 3364 3364 + if (verbose) puts("STUB: vvremainderf_ called"); 3365 3365 + return NULL; 3366 3366 + } 3367 3367 + 3368 3368 + void* vvrsqrt(void) 3369 3369 + { 3370 3370 + if (verbose) puts("STUB: vvrsqrt called"); 3371 3371 + return NULL; 3372 3372 + } 3373 3373 + 3374 3374 + void* vvrsqrt_(void) 3375 3375 + { 3376 3376 + if (verbose) puts("STUB: vvrsqrt_ called"); 3377 3377 + return NULL; 3378 3378 + } 3379 3379 + 3380 3380 + void* vvrsqrtf(void) 3381 3381 + { 3382 3382 + if (verbose) puts("STUB: vvrsqrtf called"); 3383 3383 + return NULL; 3384 3384 + } 3385 3385 + 3386 3386 + void* vvrsqrtf_(void) 3387 3387 + { 3388 3388 + if (verbose) puts("STUB: vvrsqrtf_ called"); 3389 3389 + return NULL; 3390 3390 + } 3391 3391 + 3392 3392 + void* vvsin(void) 3393 3393 + { 3394 3394 + if (verbose) puts("STUB: vvsin called"); 3395 3395 + return NULL; 3396 3396 + } 3397 3397 + 3398 3398 + void* vvsin_(void) 3399 3399 + { 3400 3400 + if (verbose) puts("STUB: vvsin_ called"); 3401 3401 + return NULL; 3402 3402 + } 3403 3403 + 3404 3404 + void* vvsincos(void) 3405 3405 + { 3406 3406 + if (verbose) puts("STUB: vvsincos called"); 3407 3407 + return NULL; 3408 3408 + } 3409 3409 + 3410 3410 + void* vvsincos_(void) 3411 3411 + { 3412 3412 + if (verbose) puts("STUB: vvsincos_ called"); 3413 3413 + return NULL; 3414 3414 + } 3415 3415 + 3416 3416 + void* vvsincosf(void) 3417 3417 + { 3418 3418 + if (verbose) puts("STUB: vvsincosf called"); 3419 3419 + return NULL; 3420 3420 + } 3421 3421 + 3422 3422 + void* vvsincosf_(void) 3423 3423 + { 3424 3424 + if (verbose) puts("STUB: vvsincosf_ called"); 3425 3425 + return NULL; 3426 3426 + } 3427 3427 + 3428 3428 + void* vvsinf(void) 3429 3429 + { 3430 3430 + if (verbose) puts("STUB: vvsinf called"); 3431 3431 + return NULL; 3432 3432 + } 3433 3433 + 3434 3434 + void* vvsinf_(void) 3435 3435 + { 3436 3436 + if (verbose) puts("STUB: vvsinf_ called"); 3437 3437 + return NULL; 3438 3438 + } 3439 3439 + 3440 3440 + void* vvsinh(void) 3441 3441 + { 3442 3442 + if (verbose) puts("STUB: vvsinh called"); 3443 3443 + return NULL; 3444 3444 + } 3445 3445 + 3446 3446 + void* vvsinh_(void) 3447 3447 + { 3448 3448 + if (verbose) puts("STUB: vvsinh_ called"); 3449 3449 + return NULL; 3450 3450 + } 3451 3451 + 3452 3452 + void* vvsinhf(void) 3453 3453 + { 3454 3454 + if (verbose) puts("STUB: vvsinhf called"); 3455 3455 + return NULL; 3456 3456 + } 3457 3457 + 3458 3458 + void* vvsinhf_(void) 3459 3459 + { 3460 3460 + if (verbose) puts("STUB: vvsinhf_ called"); 3461 3461 + return NULL; 3462 3462 + } 3463 3463 + 3464 3464 + void* vvsinpi(void) 3465 3465 + { 3466 3466 + if (verbose) puts("STUB: vvsinpi called"); 3467 3467 + return NULL; 3468 3468 + } 3469 3469 + 3470 3470 + void* vvsinpi_(void) 3471 3471 + { 3472 3472 + if (verbose) puts("STUB: vvsinpi_ called"); 3473 3473 + return NULL; 3474 3474 + } 3475 3475 + 3476 3476 + void* vvsinpif(void) 3477 3477 + { 3478 3478 + if (verbose) puts("STUB: vvsinpif called"); 3479 3479 + return NULL; 3480 3480 + } 3481 3481 + 3482 3482 + void* vvsinpif_(void) 3483 3483 + { 3484 3484 + if (verbose) puts("STUB: vvsinpif_ called"); 3485 3485 + return NULL; 3486 3486 + } 3487 3487 + 3488 3488 + void* vvsqrt(void) 3489 3489 + { 3490 3490 + if (verbose) puts("STUB: vvsqrt called"); 3491 3491 + return NULL; 3492 3492 + } 3493 3493 + 3494 3494 + void* vvsqrt_(void) 3495 3495 + { 3496 3496 + if (verbose) puts("STUB: vvsqrt_ called"); 3497 3497 + return NULL; 3498 3498 + } 3499 3499 + 3500 3500 + void* vvsqrtf(void) 3501 3501 + { 3502 3502 + if (verbose) puts("STUB: vvsqrtf called"); 3503 3503 + return NULL; 3504 3504 + } 3505 3505 + 3506 3506 + void* vvsqrtf_(void) 3507 3507 + { 3508 3508 + if (verbose) puts("STUB: vvsqrtf_ called"); 3509 3509 + return NULL; 3510 3510 + } 3511 3511 + 3512 3512 + void* vvtan(void) 3513 3513 + { 3514 3514 + if (verbose) puts("STUB: vvtan called"); 3515 3515 + return NULL; 3516 3516 + } 3517 3517 + 3518 3518 + void* vvtan_(void) 3519 3519 + { 3520 3520 + if (verbose) puts("STUB: vvtan_ called"); 3521 3521 + return NULL; 3522 3522 + } 3523 3523 + 3524 3524 + void* vvtanf(void) 3525 3525 + { 3526 3526 + if (verbose) puts("STUB: vvtanf called"); 3527 3527 + return NULL; 3528 3528 + } 3529 3529 + 3530 3530 + void* vvtanf_(void) 3531 3531 + { 3532 3532 + if (verbose) puts("STUB: vvtanf_ called"); 3533 3533 + return NULL; 3534 3534 + } 3535 3535 + 3536 3536 + void* vvtanh(void) 3537 3537 + { 3538 3538 + if (verbose) puts("STUB: vvtanh called"); 3539 3539 + return NULL; 3540 3540 + } 3541 3541 + 3542 3542 + void* vvtanh_(void) 3543 3543 + { 3544 3544 + if (verbose) puts("STUB: vvtanh_ called"); 3545 3545 + return NULL; 3546 3546 + } 3547 3547 + 3548 3548 + void* vvtanhf(void) 3549 3549 + { 3550 3550 + if (verbose) puts("STUB: vvtanhf called"); 3551 3551 + return NULL; 3552 3552 + } 3553 3553 + 3554 3554 + void* vvtanhf_(void) 3555 3555 + { 3556 3556 + if (verbose) puts("STUB: vvtanhf_ called"); 3557 3557 + return NULL; 3558 3558 + } 3559 3559 + 3560 3560 + void* vvtanpi(void) 3561 3561 + { 3562 3562 + if (verbose) puts("STUB: vvtanpi called"); 3563 3563 + return NULL; 3564 3564 + } 3565 3565 + 3566 3566 + void* vvtanpi_(void) 3567 3567 + { 3568 3568 + if (verbose) puts("STUB: vvtanpi_ called"); 3569 3569 + return NULL; 3570 3570 + } 3571 3571 + 3572 3572 + void* vvtanpif(void) 3573 3573 + { 3574 3574 + if (verbose) puts("STUB: vvtanpif called"); 3575 3575 + return NULL; 3576 3576 + } 3577 3577 + 3578 3578 + void* vvtanpif_(void) 3579 3579 + { 3580 3580 + if (verbose) puts("STUB: vvtanpif_ called"); 3581 3581 + return NULL; 3582 3582 + }