├── .gitignore ├── .travis.yml ├── CoordinatedOmission └── wrk2_CleanVsCO.png ├── LICENSE ├── Makefile ├── NOTICE ├── README.md ├── SCRIPTING ├── deps └── luajit │ ├── COPYRIGHT │ ├── Makefile │ ├── README │ ├── doc │ ├── bluequad-print.css │ ├── bluequad.css │ ├── changes.html │ ├── contact.html │ ├── ext_c_api.html │ ├── ext_ffi.html │ ├── ext_ffi_api.html │ ├── ext_ffi_semantics.html │ ├── ext_ffi_tutorial.html │ ├── ext_jit.html │ ├── ext_profiler.html │ ├── extensions.html │ ├── faq.html │ ├── img │ │ └── contact.png │ ├── install.html │ ├── luajit.html │ ├── running.html │ └── status.html │ ├── dynasm │ ├── dasm_arm.h │ ├── dasm_arm.lua │ ├── dasm_arm64.h │ ├── dasm_arm64.lua │ ├── dasm_mips.h │ ├── dasm_mips.lua │ ├── dasm_mips64.lua │ ├── dasm_ppc.h │ ├── dasm_ppc.lua │ ├── dasm_proto.h │ ├── dasm_x64.lua │ ├── dasm_x86.h │ ├── dasm_x86.lua │ └── dynasm.lua │ ├── etc │ ├── luajit.1 │ └── luajit.pc │ └── src │ ├── Makefile │ ├── Makefile.dep │ ├── host │ ├── README │ ├── buildvm.c │ ├── buildvm.h │ ├── buildvm_asm.c │ ├── buildvm_fold.c │ ├── buildvm_lib.c │ ├── buildvm_libbc.h │ ├── buildvm_peobj.c │ ├── genlibbc.lua │ ├── genminilua.lua │ └── minilua.c │ ├── jit │ ├── bc.lua │ ├── bcsave.lua │ ├── dis_arm.lua │ ├── dis_arm64.lua │ ├── dis_arm64be.lua │ ├── dis_mips.lua │ ├── dis_mips64.lua │ ├── dis_mips64el.lua │ ├── dis_mipsel.lua │ ├── dis_ppc.lua │ ├── dis_x64.lua │ ├── dis_x86.lua │ ├── dump.lua │ ├── p.lua │ ├── v.lua │ └── zone.lua │ ├── lauxlib.h │ ├── lib_aux.c │ ├── lib_base.c │ ├── lib_bit.c │ ├── lib_debug.c │ ├── lib_ffi.c │ ├── lib_init.c │ ├── lib_io.c │ ├── lib_jit.c │ ├── lib_math.c │ ├── lib_os.c │ ├── lib_package.c │ ├── lib_string.c │ ├── lib_table.c │ ├── lj.supp │ ├── lj_alloc.c │ ├── lj_alloc.h │ ├── lj_api.c │ ├── lj_arch.h │ ├── lj_asm.c │ ├── lj_asm.h │ ├── lj_asm_arm.h │ ├── lj_asm_arm64.h │ ├── lj_asm_mips.h │ ├── lj_asm_ppc.h │ ├── lj_asm_x86.h │ ├── lj_bc.c │ ├── lj_bc.h │ ├── lj_bcdump.h │ ├── lj_bcread.c │ ├── lj_bcwrite.c │ ├── lj_buf.c │ ├── lj_buf.h │ ├── lj_carith.c │ ├── lj_carith.h │ ├── lj_ccall.c │ ├── lj_ccall.h │ ├── lj_ccallback.c │ ├── lj_ccallback.h │ ├── lj_cconv.c │ ├── lj_cconv.h │ ├── lj_cdata.c │ ├── lj_cdata.h │ ├── lj_char.c │ ├── lj_char.h │ ├── lj_clib.c │ ├── lj_clib.h │ ├── lj_cparse.c │ ├── lj_cparse.h │ ├── lj_crecord.c │ ├── lj_crecord.h │ ├── lj_ctype.c │ ├── lj_ctype.h │ ├── lj_debug.c │ ├── lj_debug.h │ ├── lj_def.h │ ├── lj_dispatch.c │ ├── lj_dispatch.h │ ├── lj_emit_arm.h │ ├── lj_emit_arm64.h │ ├── lj_emit_mips.h │ ├── lj_emit_ppc.h │ ├── lj_emit_x86.h │ ├── lj_err.c │ ├── lj_err.h │ ├── lj_errmsg.h │ ├── lj_ff.h │ ├── lj_ffrecord.c │ ├── lj_ffrecord.h │ ├── lj_frame.h │ ├── lj_func.c │ ├── lj_func.h │ ├── lj_gc.c │ ├── lj_gc.h │ ├── lj_gdbjit.c │ ├── lj_gdbjit.h │ ├── lj_ir.c │ ├── lj_ir.h │ ├── lj_ircall.h │ ├── lj_iropt.h │ ├── lj_jit.h │ ├── lj_lex.c │ ├── lj_lex.h │ ├── lj_lib.c │ ├── lj_lib.h │ ├── lj_load.c │ ├── lj_mcode.c │ ├── lj_mcode.h │ ├── lj_meta.c │ ├── lj_meta.h │ ├── lj_obj.c │ ├── lj_obj.h │ ├── lj_opt_dce.c │ ├── lj_opt_fold.c │ ├── lj_opt_loop.c │ ├── lj_opt_mem.c │ ├── lj_opt_narrow.c │ ├── lj_opt_sink.c │ ├── lj_opt_split.c │ ├── lj_parse.c │ ├── lj_parse.h │ ├── lj_profile.c │ ├── lj_profile.h │ ├── lj_record.c │ ├── lj_record.h │ ├── lj_snap.c │ ├── lj_snap.h │ ├── lj_state.c │ ├── lj_state.h │ ├── lj_str.c │ ├── lj_str.h │ ├── lj_strfmt.c │ ├── lj_strfmt.h │ ├── lj_strfmt_num.c │ ├── lj_strscan.c │ ├── lj_strscan.h │ ├── lj_tab.c │ ├── lj_tab.h │ ├── lj_target.h │ ├── lj_target_arm.h │ ├── lj_target_arm64.h │ ├── lj_target_mips.h │ ├── lj_target_ppc.h │ ├── lj_target_x86.h │ ├── lj_trace.c │ ├── lj_trace.h │ ├── lj_traceerr.h │ ├── lj_udata.c │ ├── lj_udata.h │ ├── lj_vm.h │ ├── lj_vmevent.c │ ├── lj_vmevent.h │ ├── lj_vmmath.c │ ├── ljamalg.c │ ├── lua.h │ ├── lua.hpp │ ├── luaconf.h │ ├── luajit.c │ ├── luajit.h │ ├── lualib.h │ ├── msvcbuild.bat │ ├── ps4build.bat │ ├── psvitabuild.bat │ ├── vm_arm.dasc │ ├── vm_arm64.dasc │ ├── vm_mips.dasc │ ├── vm_mips64.dasc │ ├── vm_ppc.dasc │ ├── vm_x64.dasc │ ├── vm_x86.dasc │ ├── xb1build.bat │ └── xedkbuild.bat ├── docker ├── Dockerfile.benchmark-container-prometheus-export ├── Dockerfile.cache-stresser ├── README.md ├── prometheus-export-wrapper └── setup-cache-stresser ├── scripts ├── addr.lua ├── auth.lua ├── cache-stresser.lua ├── counter.lua ├── multi-server.lua ├── multiple-endpoints-prometheus-metrics.lua ├── multiple-endpoints.lua ├── pipeline.lua ├── post.lua ├── report.lua ├── setup.lua └── stop.lua └── src ├── ae.c ├── ae.h ├── ae_epoll.c ├── ae_evport.c ├── ae_kqueue.c ├── ae_select.c ├── aprintf.c ├── aprintf.h ├── config.h ├── hdr_histogram.c ├── hdr_histogram.h ├── http_parser.c ├── http_parser.h ├── main.h ├── net.c ├── net.h ├── script.c ├── script.h ├── ssl.c ├── ssl.h ├── stats.c ├── stats.h ├── tinymt64.c ├── tinymt64.h ├── units.c ├── units.h ├── wrk.c ├── wrk.h ├── wrk.lua ├── zmalloc.c └── zmalloc.h /.gitignore: -------------------------------------------------------------------------------- 1 | *.o 2 | *.a 3 | wrk 4 | 5 | deps/luajit/src/host/buildvm 6 | deps/luajit/src/host/buildvm_arch.h 7 | deps/luajit/src/host/minilua 8 | deps/luajit/src/jit/vmdef.lua 9 | deps/luajit/src/lj_bcdef.h 10 | deps/luajit/src/lj_ffdef.h 11 | deps/luajit/src/lj_folddef.h 12 | deps/luajit/src/lj_libdef.h 13 | deps/luajit/src/lj_recdef.h 14 | deps/luajit/src/lj_vm.s 15 | deps/luajit/src/luajit 16 | 17 | .idea 18 | CMakeLists.txt 19 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: c 2 | 3 | os: 4 | - linux 5 | - osx 6 | 7 | compiler: 8 | - gcc 9 | - clang 10 | 11 | script: 12 | - make 13 | -------------------------------------------------------------------------------- /CoordinatedOmission/wrk2_CleanVsCO.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kinvolk/wrk2/ef17109fe1c952f5e270c7dbab737621c2b649b9/CoordinatedOmission/wrk2_CleanVsCO.png -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | CFLAGS := -std=c99 -Wall -O2 -D_REENTRANT 2 | LIBS := -lpthread -lm -lcrypto -lssl 3 | 4 | TARGET := $(shell uname -s | tr '[A-Z]' '[a-z]' 2>/dev/null || echo unknown) 5 | 6 | ifeq ($(TARGET), sunos) 7 | CFLAGS += -D_PTHREADS -D_POSIX_C_SOURCE=200112L 8 | LIBS += -lsocket 9 | else ifeq ($(TARGET), darwin) 10 | # Per https://luajit.org/install.html: If MACOSX_DEPLOYMENT_TARGET 11 | # is not set then it's forced to 10.4, which breaks compile on Mojave. 12 | export MACOSX_DEPLOYMENT_TARGET = $(shell sw_vers -productVersion) 13 | LDFLAGS += -pagezero_size 10000 -image_base 100000000 14 | LIBS += -L/usr/local/opt/openssl/lib 15 | CFLAGS += -I/usr/local/include -I/usr/local/opt/openssl/include 16 | else ifeq ($(TARGET), linux) 17 | CFLAGS += -D_POSIX_C_SOURCE=200809L -D_BSD_SOURCE 18 | LIBS += -ldl 19 | LDFLAGS += -Wl,-E 20 | else ifeq ($(TARGET), freebsd) 21 | CFLAGS += -D_DECLARE_C99_LDBL_MATH 22 | LDFLAGS += -Wl,-E 23 | endif 24 | 25 | SRC := wrk.c net.c ssl.c aprintf.c stats.c script.c units.c \ 26 | ae.c zmalloc.c http_parser.c tinymt64.c hdr_histogram.c 27 | BIN := wrk 28 | 29 | ODIR := obj 30 | OBJ := $(patsubst %.c,$(ODIR)/%.o,$(SRC)) $(ODIR)/bytecode.o 31 | 32 | LDIR = deps/luajit/src 33 | LIBS := -lluajit $(LIBS) 34 | CFLAGS += -I$(LDIR) 35 | LDFLAGS += -L$(LDIR) 36 | 37 | all: $(BIN) 38 | 39 | clean: 40 | $(RM) $(BIN) obj/* 41 | @$(MAKE) -C deps/luajit clean 42 | 43 | $(BIN): $(OBJ) 44 | @echo LINK $(BIN) 45 | @$(CC) $(LDFLAGS) -o $@ $^ $(LIBS) 46 | 47 | $(OBJ): config.h Makefile $(LDIR)/libluajit.a | $(ODIR) 48 | 49 | $(ODIR): 50 | @mkdir -p $@ 51 | 52 | $(ODIR)/bytecode.o: src/wrk.lua 53 | @echo LUAJIT $< 54 | @$(SHELL) -c 'cd $(LDIR) && ./luajit -b $(CURDIR)/$< $(CURDIR)/$@' 55 | 56 | $(ODIR)/%.o : %.c 57 | @echo CC $< 58 | @$(CC) $(CFLAGS) -c -o $@ $< 59 | 60 | $(LDIR)/libluajit.a: 61 | @echo Building LuaJIT... 62 | @$(MAKE) -C $(LDIR) BUILDMODE=static XCFLAGS=-DLUAJIT_ENABLE_GC64 63 | 64 | .PHONY: all clean 65 | .SUFFIXES: 66 | .SUFFIXES: .c .o .lua 67 | 68 | vpath %.c src 69 | vpath %.h src 70 | vpath %.lua scripts 71 | -------------------------------------------------------------------------------- /SCRIPTING: -------------------------------------------------------------------------------- 1 | Overview 2 | 3 | wrk supports executing a LuaJIT script during three distinct phases: setup, 4 | running, and done. Each wrk thread has an independent scripting environment 5 | and the setup & done phases execute in a separate environment which does 6 | not participate in the running phase. 7 | 8 | The public Lua API consists of a global table and a number of global 9 | functions: 10 | 11 | wrk = { 12 | scheme = "http", 13 | host = "localhost", 14 | port = nil, 15 | method = "GET", 16 | path = "/", 17 | headers = {}, 18 | body = nil, 19 | thread = , 20 | } 21 | 22 | function wrk.format(method, path, headers, body) 23 | 24 | wrk.format returns a HTTP request string containing the passed parameters 25 | merged with values from the wrk table. 26 | 27 | function wrk.lookup(host, service) 28 | 29 | wrk.lookup returns a table containing all known addresses for the host 30 | and service pair. This corresponds to the POSIX getaddrinfo() function. 31 | 32 | function wrk.connect(addr) 33 | 34 | wrk.connect returns true if the address can be connected to, otherwise 35 | it returns false. The address must be one returned from wrk.lookup(). 36 | 37 | The following globals are optional, and if defined must be functions: 38 | 39 | global setup -- called during thread setup 40 | global init -- called when the thread is starting 41 | global request -- called to generate the HTTP request 42 | global response -- called with HTTP response header and body 43 | (body does not contain actual response data if 44 | the command line option --lua-dont-pass-body is used) 45 | global done -- called with results of run 46 | 47 | Setup 48 | 49 | function setup(thread) 50 | 51 | The setup phase begins after the target IP address has been resolved and all 52 | threads have been initialized but not yet started. 53 | 54 | setup() is called once for each thread and receives a userdata object 55 | representing the thread. setup() is called in the global LUA context. 56 | 57 | thread.addr - get or set the thread's server address 58 | thread:get(name) - get the value of a global in the thread's env 59 | thread:set(name, value) - set the value of a global in the thread's env 60 | thread:stop() - stop the thread 61 | 62 | Only boolean, nil, number, wrk.addr, and string values or tables of the same 63 | may be transfered via get()/set() and thread:stop() can only be called while 64 | the thread is running. 65 | 66 | Running 67 | 68 | The following functions are called in a privte per-thread LUA context. Each 69 | context corresponds to an entry in the 'thread' table passed to setup(). 70 | 71 | function init(args) 72 | function request() 73 | function response(status, headers, body) 74 | 75 | The running phase begins with a single call to init(), followed by 76 | a call to request() and response() for each request cycle. 77 | 78 | The init() function receives any extra command line arguments for the 79 | script which must be separated from wrk arguments with "--". 80 | 81 | request() returns a string containing the HTTP request. Building a new 82 | request each time is expensive, when testing a high performance server 83 | one solution is to pre-generate all requests in init() and do a quick 84 | lookup in request(). 85 | 86 | response() is called with the HTTP response status and headers. 87 | Parsing the headers is expensive, so if the response global is 88 | nil after the call to init() wrk will ignore the headers and body. 89 | Using wrk's --lua-dont-pass-body command line option will cause a "dummy" 90 | body to be passed instead of the actual body. The option is useful for 91 | benchmarking endpoints which pass large response bodies. 92 | 93 | teardown() is called without arguments after the run concluded. 94 | Done 95 | 96 | function done(summary, latency, requests) 97 | 98 | done() is called in the global LUA context. 99 | 100 | The done() function receives a table containing result data, and two 101 | statistics objects representing the per-request latency and per-thread 102 | request rate. Duration and latency are microsecond values and rate is 103 | measured in requests per second. 104 | 105 | latency.min -- minimum value seen 106 | latency.max -- maximum value seen 107 | latency.mean -- average value seen 108 | latency.stdev -- standard deviation 109 | latency:percentile(99.0) -- 99th percentile value 110 | latency(i) -- raw value and count 111 | 112 | summary = { 113 | duration = N, -- run duration in microseconds 114 | requests = N, -- total completed requests 115 | bytes = N, -- total bytes received 116 | errors = { 117 | connect = N, -- total socket connection errors 118 | read = N, -- total socket read errors 119 | write = N, -- total socket write errors 120 | status = N, -- total HTTP status codes > 399 121 | timeout = N -- total request timeouts 122 | } 123 | } 124 | -------------------------------------------------------------------------------- /deps/luajit/COPYRIGHT: -------------------------------------------------------------------------------- 1 | =============================================================================== 2 | LuaJIT -- a Just-In-Time Compiler for Lua. http://luajit.org/ 3 | 4 | Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy 7 | of this software and associated documentation files (the "Software"), to deal 8 | in the Software without restriction, including without limitation the rights 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 | copies of the Software, and to permit persons to whom the Software is 11 | furnished to do so, subject to the following conditions: 12 | 13 | The above copyright notice and this permission notice shall be included in 14 | all copies or substantial portions of the Software. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 | THE SOFTWARE. 23 | 24 | [ MIT license: http://www.opensource.org/licenses/mit-license.php ] 25 | 26 | =============================================================================== 27 | [ LuaJIT includes code from Lua 5.1/5.2, which has this license statement: ] 28 | 29 | Copyright (C) 1994-2012 Lua.org, PUC-Rio. 30 | 31 | Permission is hereby granted, free of charge, to any person obtaining a copy 32 | of this software and associated documentation files (the "Software"), to deal 33 | in the Software without restriction, including without limitation the rights 34 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 35 | copies of the Software, and to permit persons to whom the Software is 36 | furnished to do so, subject to the following conditions: 37 | 38 | The above copyright notice and this permission notice shall be included in 39 | all copies or substantial portions of the Software. 40 | 41 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 42 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 43 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 44 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 45 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 46 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 47 | THE SOFTWARE. 48 | 49 | =============================================================================== 50 | [ LuaJIT includes code from dlmalloc, which has this license statement: ] 51 | 52 | This is a version (aka dlmalloc) of malloc/free/realloc written by 53 | Doug Lea and released to the public domain, as explained at 54 | http://creativecommons.org/licenses/publicdomain 55 | 56 | =============================================================================== 57 | -------------------------------------------------------------------------------- /deps/luajit/README: -------------------------------------------------------------------------------- 1 | README for LuaJIT 2.1.0-beta3 2 | ----------------------------- 3 | 4 | LuaJIT is a Just-In-Time (JIT) compiler for the Lua programming language. 5 | 6 | Project Homepage: http://luajit.org/ 7 | 8 | LuaJIT is Copyright (C) 2005-2017 Mike Pall. 9 | LuaJIT is free software, released under the MIT license. 10 | See full Copyright Notice in the COPYRIGHT file or in luajit.h. 11 | 12 | Documentation for LuaJIT is available in HTML format. 13 | Please point your favorite browser to: 14 | 15 | doc/luajit.html 16 | 17 | -------------------------------------------------------------------------------- /deps/luajit/doc/bluequad-print.css: -------------------------------------------------------------------------------- 1 | /* Copyright (C) 2004-2017 Mike Pall. 2 | * 3 | * You are welcome to use the general ideas of this design for your own sites. 4 | * But please do not steal the stylesheet, the layout or the color scheme. 5 | */ 6 | body { 7 | font-family: serif; 8 | font-size: 11pt; 9 | margin: 0 3em; 10 | padding: 0; 11 | border: none; 12 | } 13 | a:link, a:visited, a:hover, a:active { 14 | text-decoration: none; 15 | background: transparent; 16 | color: #0000ff; 17 | } 18 | h1, h2, h3 { 19 | font-family: sans-serif; 20 | font-weight: bold; 21 | text-align: left; 22 | margin: 0.5em 0; 23 | padding: 0; 24 | } 25 | h1 { 26 | font-size: 200%; 27 | } 28 | h2 { 29 | font-size: 150%; 30 | } 31 | h3 { 32 | font-size: 125%; 33 | } 34 | p { 35 | margin: 0 0 0.5em 0; 36 | padding: 0; 37 | } 38 | ul, ol { 39 | margin: 0.5em 0; 40 | padding: 0 0 0 2em; 41 | } 42 | ul { 43 | list-style: outside square; 44 | } 45 | ol { 46 | list-style: outside decimal; 47 | } 48 | li { 49 | margin: 0; 50 | padding: 0; 51 | } 52 | dl { 53 | margin: 1em 0; 54 | padding: 1em; 55 | border: 1px solid black; 56 | } 57 | dt { 58 | font-weight: bold; 59 | margin: 0; 60 | padding: 0; 61 | } 62 | dt sup { 63 | float: right; 64 | margin-left: 1em; 65 | } 66 | dd { 67 | margin: 0.5em 0 0 2em; 68 | padding: 0; 69 | } 70 | table { 71 | table-layout: fixed; 72 | width: 100%; 73 | margin: 1em 0; 74 | padding: 0; 75 | border: 1px solid black; 76 | border-spacing: 0; 77 | border-collapse: collapse; 78 | } 79 | tr { 80 | margin: 0; 81 | padding: 0; 82 | border: none; 83 | } 84 | td { 85 | text-align: left; 86 | margin: 0; 87 | padding: 0.2em 0.5em; 88 | border-top: 1px solid black; 89 | border-bottom: 1px solid black; 90 | } 91 | tr.separate td { 92 | border-top: double; 93 | } 94 | tt, pre, code, kbd, samp { 95 | font-family: monospace; 96 | font-size: 75%; 97 | } 98 | kbd { 99 | font-weight: bolder; 100 | } 101 | blockquote, pre { 102 | margin: 1em 2em; 103 | padding: 0; 104 | } 105 | img { 106 | border: none; 107 | vertical-align: baseline; 108 | margin: 0; 109 | padding: 0; 110 | } 111 | img.left { 112 | float: left; 113 | margin: 0.5em 1em 0.5em 0; 114 | } 115 | img.right { 116 | float: right; 117 | margin: 0.5em 0 0.5em 1em; 118 | } 119 | .flush { 120 | clear: both; 121 | visibility: hidden; 122 | } 123 | .hide, .noprint, #nav { 124 | display: none !important; 125 | } 126 | .pagebreak { 127 | page-break-before: always; 128 | } 129 | #site { 130 | text-align: right; 131 | font-family: sans-serif; 132 | font-weight: bold; 133 | margin: 0 1em; 134 | border-bottom: 1pt solid black; 135 | } 136 | #site a { 137 | font-size: 1.2em; 138 | } 139 | #site a:link, #site a:visited { 140 | text-decoration: none; 141 | font-weight: bold; 142 | background: transparent; 143 | color: #ffffff; 144 | } 145 | #logo { 146 | color: #ff8000; 147 | } 148 | #head { 149 | clear: both; 150 | margin: 0 1em; 151 | } 152 | #main { 153 | line-height: 1.3; 154 | text-align: justify; 155 | margin: 1em; 156 | } 157 | #foot { 158 | clear: both; 159 | font-size: 80%; 160 | text-align: center; 161 | margin: 0 1.25em; 162 | padding: 0.5em 0 0 0; 163 | border-top: 1pt solid black; 164 | page-break-before: avoid; 165 | page-break-after: avoid; 166 | } 167 | -------------------------------------------------------------------------------- /deps/luajit/doc/contact.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | Contact 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 |
14 | Lua 15 |
16 | 19 | 62 |
63 |

64 | If you want to report bugs, propose fixes or suggest enhancements, 65 | please use the 66 | GitHub issue tracker. 67 |

68 |

69 | Please send general questions to the 70 | » LuaJIT mailing list. 71 |

72 |

73 | You can also send any questions you have directly to me: 74 |

75 | 76 | 84 | 88 | 92 | 93 |

Copyright

94 |

95 | All documentation is 96 | Copyright © 2005-2017 Mike Pall. 97 |

98 | 99 | 100 |
101 |
102 | 110 | 111 | 112 | -------------------------------------------------------------------------------- /deps/luajit/doc/img/contact.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kinvolk/wrk2/ef17109fe1c952f5e270c7dbab737621c2b649b9/deps/luajit/doc/img/contact.png -------------------------------------------------------------------------------- /deps/luajit/doc/status.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | Status 5 | 6 | 7 | 8 | 9 | 10 | 11 | 14 | 15 | 16 |
17 | Lua 18 |
19 | 22 | 65 |
66 |

67 | LuaJIT 2.0 is the current 68 | stable branch. This branch is in 69 | feature-freeze — new features will only be added to LuaJIT 2.1. 70 |

71 | 72 |

Current Status

73 |

74 | LuaJIT ought to run all Lua 5.1-compatible source code just fine. 75 | It's considered a serious bug if the VM crashes or produces unexpected 76 | results — please report this. 77 |

78 |

79 | Known incompatibilities and issues in LuaJIT 2.0: 80 |

81 | 112 |
113 |
114 | 122 | 123 | 124 | -------------------------------------------------------------------------------- /deps/luajit/dynasm/dasm_mips64.lua: -------------------------------------------------------------------------------- 1 | ------------------------------------------------------------------------------ 2 | -- DynASM MIPS64 module. 3 | -- 4 | -- Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | -- See dynasm.lua for full copyright notice. 6 | ------------------------------------------------------------------------------ 7 | -- This module just sets 64 bit mode for the combined MIPS/MIPS64 module. 8 | -- All the interesting stuff is there. 9 | ------------------------------------------------------------------------------ 10 | 11 | mips64 = true -- Using a global is an ugly, but effective solution. 12 | return require("dasm_mips") 13 | -------------------------------------------------------------------------------- /deps/luajit/dynasm/dasm_proto.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** DynASM encoding engine prototypes. 3 | ** Copyright (C) 2005-2017 Mike Pall. All rights reserved. 4 | ** Released under the MIT license. See dynasm.lua for full copyright notice. 5 | */ 6 | 7 | #ifndef _DASM_PROTO_H 8 | #define _DASM_PROTO_H 9 | 10 | #include 11 | #include 12 | 13 | #define DASM_IDENT "DynASM 1.4.0" 14 | #define DASM_VERSION 10400 /* 1.4.0 */ 15 | 16 | #ifndef Dst_DECL 17 | #define Dst_DECL dasm_State **Dst 18 | #endif 19 | 20 | #ifndef Dst_REF 21 | #define Dst_REF (*Dst) 22 | #endif 23 | 24 | #ifndef DASM_FDEF 25 | #define DASM_FDEF extern 26 | #endif 27 | 28 | #ifndef DASM_M_GROW 29 | #define DASM_M_GROW(ctx, t, p, sz, need) \ 30 | do { \ 31 | size_t _sz = (sz), _need = (need); \ 32 | if (_sz < _need) { \ 33 | if (_sz < 16) _sz = 16; \ 34 | while (_sz < _need) _sz += _sz; \ 35 | (p) = (t *)realloc((p), _sz); \ 36 | if ((p) == NULL) exit(1); \ 37 | (sz) = _sz; \ 38 | } \ 39 | } while(0) 40 | #endif 41 | 42 | #ifndef DASM_M_FREE 43 | #define DASM_M_FREE(ctx, p, sz) free(p) 44 | #endif 45 | 46 | /* Internal DynASM encoder state. */ 47 | typedef struct dasm_State dasm_State; 48 | 49 | 50 | /* Initialize and free DynASM state. */ 51 | DASM_FDEF void dasm_init(Dst_DECL, int maxsection); 52 | DASM_FDEF void dasm_free(Dst_DECL); 53 | 54 | /* Setup global array. Must be called before dasm_setup(). */ 55 | DASM_FDEF void dasm_setupglobal(Dst_DECL, void **gl, unsigned int maxgl); 56 | 57 | /* Grow PC label array. Can be called after dasm_setup(), too. */ 58 | DASM_FDEF void dasm_growpc(Dst_DECL, unsigned int maxpc); 59 | 60 | /* Setup encoder. */ 61 | DASM_FDEF void dasm_setup(Dst_DECL, const void *actionlist); 62 | 63 | /* Feed encoder with actions. Calls are generated by pre-processor. */ 64 | DASM_FDEF void dasm_put(Dst_DECL, int start, ...); 65 | 66 | /* Link sections and return the resulting size. */ 67 | DASM_FDEF int dasm_link(Dst_DECL, size_t *szp); 68 | 69 | /* Encode sections into buffer. */ 70 | DASM_FDEF int dasm_encode(Dst_DECL, void *buffer); 71 | 72 | /* Get PC label offset. */ 73 | DASM_FDEF int dasm_getpclabel(Dst_DECL, unsigned int pc); 74 | 75 | #ifdef DASM_CHECKS 76 | /* Optional sanity checker to call between isolated encoding steps. */ 77 | DASM_FDEF int dasm_checkstep(Dst_DECL, int secmatch); 78 | #else 79 | #define dasm_checkstep(a, b) 0 80 | #endif 81 | 82 | 83 | #endif /* _DASM_PROTO_H */ 84 | -------------------------------------------------------------------------------- /deps/luajit/dynasm/dasm_x64.lua: -------------------------------------------------------------------------------- 1 | ------------------------------------------------------------------------------ 2 | -- DynASM x64 module. 3 | -- 4 | -- Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | -- See dynasm.lua for full copyright notice. 6 | ------------------------------------------------------------------------------ 7 | -- This module just sets 64 bit mode for the combined x86/x64 module. 8 | -- All the interesting stuff is there. 9 | ------------------------------------------------------------------------------ 10 | 11 | x64 = true -- Using a global is an ugly, but effective solution. 12 | return require("dasm_x86") 13 | -------------------------------------------------------------------------------- /deps/luajit/etc/luajit.1: -------------------------------------------------------------------------------- 1 | .TH luajit 1 "" "" "LuaJIT documentation" 2 | .SH NAME 3 | luajit \- Just-In-Time Compiler for the Lua Language 4 | \fB 5 | .SH SYNOPSIS 6 | .B luajit 7 | [\fIoptions\fR]... [\fIscript\fR [\fIargs\fR]...] 8 | .SH "WEB SITE" 9 | .IR http://luajit.org 10 | .SH DESCRIPTION 11 | .PP 12 | This is the command-line program to run Lua programs with \fBLuaJIT\fR. 13 | .PP 14 | \fBLuaJIT\fR is a just-in-time (JIT) compiler for the Lua language. 15 | The virtual machine (VM) is based on a fast interpreter combined with 16 | a trace compiler. It can significantly improve the performance of Lua programs. 17 | .PP 18 | \fBLuaJIT\fR is API\- and ABI-compatible with the VM of the standard 19 | Lua\ 5.1 interpreter. When embedding the VM into an application, 20 | the built library can be used as a drop-in replacement. 21 | .SH OPTIONS 22 | .TP 23 | .BI "\-e " chunk 24 | Run the given chunk of Lua code. 25 | .TP 26 | .BI "\-l " library 27 | Load the named library, just like \fBrequire("\fR\fIlibrary\fR\fB")\fR. 28 | .TP 29 | .BI "\-b " ... 30 | Save or list bytecode. Run without arguments to get help on options. 31 | .TP 32 | .BI "\-j " command 33 | Perform LuaJIT control command (optional space after \fB\-j\fR). 34 | .TP 35 | .BI "\-O" [opt] 36 | Control LuaJIT optimizations. 37 | .TP 38 | .B "\-i" 39 | Run in interactive mode. 40 | .TP 41 | .B "\-v" 42 | Show \fBLuaJIT\fR version. 43 | .TP 44 | .B "\-E" 45 | Ignore environment variables. 46 | .TP 47 | .B "\-\-" 48 | Stop processing options. 49 | .TP 50 | .B "\-" 51 | Read script from stdin instead. 52 | .PP 53 | After all options are processed, the given \fIscript\fR is run. 54 | The arguments are passed in the global \fIarg\fR table. 55 | .PP 56 | Interactive mode is only entered, if no \fIscript\fR and no \fB\-e\fR 57 | option is given. Interactive mode can be left with EOF (\fICtrl\-Z\fB). 58 | .SH EXAMPLES 59 | .TP 60 | luajit hello.lua world 61 | 62 | Prints "Hello world", assuming \fIhello.lua\fR contains: 63 | .br 64 | print("Hello", arg[1]) 65 | .TP 66 | luajit \-e "local x=0; for i=1,1e9 do x=x+i end; print(x)" 67 | 68 | Calculates the sum of the numbers from 1 to 1000000000. 69 | .br 70 | And finishes in a reasonable amount of time, too. 71 | .TP 72 | luajit \-jv \-e "for i=1,10 do for j=1,10 do for k=1,100 do end end end" 73 | 74 | Runs some nested loops and shows the resulting traces. 75 | .SH COPYRIGHT 76 | .PP 77 | \fBLuaJIT\fR is Copyright \(co 2005-2017 Mike Pall. 78 | .br 79 | \fBLuaJIT\fR is open source software, released under the MIT license. 80 | .SH SEE ALSO 81 | .PP 82 | More details in the provided HTML docs or at: 83 | .IR http://luajit.org 84 | .br 85 | More about the Lua language can be found at: 86 | .IR http://lua.org/docs.html 87 | .PP 88 | lua(1) 89 | -------------------------------------------------------------------------------- /deps/luajit/etc/luajit.pc: -------------------------------------------------------------------------------- 1 | # Package information for LuaJIT to be used by pkg-config. 2 | majver=2 3 | minver=1 4 | relver=0 5 | version=${majver}.${minver}.${relver}-beta3 6 | abiver=5.1 7 | 8 | prefix=/usr/local 9 | multilib=lib 10 | exec_prefix=${prefix} 11 | libdir=${exec_prefix}/${multilib} 12 | libname=luajit-${abiver} 13 | includedir=${prefix}/include/luajit-${majver}.${minver} 14 | 15 | INSTALL_LMOD=${prefix}/share/lua/${abiver} 16 | INSTALL_CMOD=${prefix}/${multilib}/lua/${abiver} 17 | 18 | Name: LuaJIT 19 | Description: Just-in-time compiler for Lua 20 | URL: http://luajit.org 21 | Version: ${version} 22 | Requires: 23 | Libs: -L${libdir} -l${libname} 24 | Libs.private: -Wl,-E -lm -ldl 25 | Cflags: -I${includedir} 26 | -------------------------------------------------------------------------------- /deps/luajit/src/host/README: -------------------------------------------------------------------------------- 1 | The files in this directory are only used during the build process of LuaJIT. 2 | For cross-compilation, they must be executed on the host, not on the target. 3 | 4 | These files should NOT be installed! 5 | -------------------------------------------------------------------------------- /deps/luajit/src/host/buildvm.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** LuaJIT VM builder. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _BUILDVM_H 7 | #define _BUILDVM_H 8 | 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | #include "lj_def.h" 16 | #include "lj_arch.h" 17 | 18 | /* Hardcoded limits. Increase as needed. */ 19 | #define BUILD_MAX_RELOC 200 /* Max. number of relocations. */ 20 | #define BUILD_MAX_FOLD 4096 /* Max. number of fold rules. */ 21 | 22 | /* Prefix for scanned library definitions. */ 23 | #define LIBDEF_PREFIX "LJLIB_" 24 | 25 | /* Prefix for scanned fold definitions. */ 26 | #define FOLDDEF_PREFIX "LJFOLD" 27 | 28 | /* Prefixes for generated labels. */ 29 | #define LABEL_PREFIX "lj_" 30 | #define LABEL_PREFIX_BC LABEL_PREFIX "BC_" 31 | #define LABEL_PREFIX_FF LABEL_PREFIX "ff_" 32 | #define LABEL_PREFIX_CF LABEL_PREFIX "cf_" 33 | #define LABEL_PREFIX_FFH LABEL_PREFIX "ffh_" 34 | #define LABEL_PREFIX_LIBCF LABEL_PREFIX "lib_cf_" 35 | #define LABEL_PREFIX_LIBINIT LABEL_PREFIX "lib_init_" 36 | 37 | /* Forward declaration. */ 38 | struct dasm_State; 39 | 40 | /* Build modes. */ 41 | #define BUILDDEF(_) \ 42 | _(elfasm) _(coffasm) _(machasm) _(peobj) _(raw) \ 43 | _(bcdef) _(ffdef) _(libdef) _(recdef) _(vmdef) \ 44 | _(folddef) 45 | 46 | typedef enum { 47 | #define BUILDENUM(name) BUILD_##name, 48 | BUILDDEF(BUILDENUM) 49 | #undef BUILDENUM 50 | BUILD__MAX 51 | } BuildMode; 52 | 53 | /* Code relocation. */ 54 | typedef struct BuildReloc { 55 | int32_t ofs; 56 | int sym; 57 | int type; 58 | } BuildReloc; 59 | 60 | typedef struct BuildSym { 61 | const char *name; 62 | int32_t ofs; 63 | } BuildSym; 64 | 65 | /* Build context structure. */ 66 | typedef struct BuildCtx { 67 | /* DynASM state pointer. Should be first member. */ 68 | struct dasm_State *D; 69 | /* Parsed command line. */ 70 | BuildMode mode; 71 | FILE *fp; 72 | const char *outname; 73 | char **args; 74 | /* Code and symbols generated by DynASM. */ 75 | uint8_t *code; 76 | size_t codesz; 77 | int npc, nglob, nsym, nreloc, nrelocsym; 78 | void **glob; 79 | BuildSym *sym; 80 | const char **relocsym; 81 | int32_t *bc_ofs; 82 | const char *beginsym; 83 | /* Strings generated by DynASM. */ 84 | const char *const *globnames; 85 | const char *const *extnames; 86 | const char *dasm_ident; 87 | const char *dasm_arch; 88 | /* Relocations. */ 89 | BuildReloc reloc[BUILD_MAX_RELOC]; 90 | } BuildCtx; 91 | 92 | extern void owrite(BuildCtx *ctx, const void *ptr, size_t sz); 93 | extern void emit_asm(BuildCtx *ctx); 94 | extern void emit_peobj(BuildCtx *ctx); 95 | extern void emit_lib(BuildCtx *ctx); 96 | extern void emit_fold(BuildCtx *ctx); 97 | 98 | extern const char *const bc_names[]; 99 | extern const char *const ir_names[]; 100 | extern const char *const irt_names[]; 101 | extern const char *const irfpm_names[]; 102 | extern const char *const irfield_names[]; 103 | extern const char *const ircall_names[]; 104 | 105 | #endif 106 | -------------------------------------------------------------------------------- /deps/luajit/src/host/buildvm_libbc.h: -------------------------------------------------------------------------------- 1 | /* This is a generated file. DO NOT EDIT! */ 2 | 3 | static const int libbc_endian = 0; 4 | 5 | static const uint8_t libbc_code[] = { 6 | #if LJ_FR2 7 | 0,1,2,0,0,1,2,24,1,0,0,76,1,2,0,241,135,158,166,3,220,203,178,130,4,0,1,2,0, 8 | 0,1,2,24,1,0,0,76,1,2,0,243,244,148,165,20,198,190,199,252,3,0,1,2,0,0,0,3, 9 | 16,0,5,0,21,1,0,0,76,1,2,0,0,2,10,0,0,0,15,16,0,12,0,16,1,9,0,41,2,1,0,21,3, 10 | 0,0,41,4,1,0,77,2,8,128,18,6,1,0,18,8,5,0,59,9,5,0,66,6,3,2,10,6,0,0,88,7,1, 11 | 128,76,6,2,0,79,2,248,127,75,0,1,0,0,2,11,0,0,0,16,16,0,12,0,16,1,9,0,43,2, 12 | 0,0,18,3,0,0,41,4,0,0,88,5,7,128,18,7,1,0,18,9,5,0,18,10,6,0,66,7,3,2,10,7, 13 | 0,0,88,8,1,128,76,7,2,0,70,5,3,3,82,5,247,127,75,0,1,0,0,1,2,0,0,0,3,16,0,12, 14 | 0,21,1,0,0,76,1,2,0,0,2,10,0,0,2,30,16,0,12,0,21,2,0,0,11,1,0,0,88,3,7,128, 15 | 8,2,0,0,88,3,23,128,59,3,2,0,43,4,0,0,64,4,2,0,76,3,2,0,88,3,18,128,16,1,14, 16 | 0,41,3,1,0,3,3,1,0,88,3,14,128,3,1,2,0,88,3,12,128,59,3,1,0,22,4,1,1,18,5,2, 17 | 0,41,6,1,0,77,4,4,128,23,8,1,7,59,9,7,0,64,9,8,0,79,4,252,127,43,4,0,0,64,4, 18 | 2,0,76,3,2,0,75,0,1,0,0,2,0,5,12,0,0,0,35,16,0,12,0,16,1,14,0,16,2,14,0,16, 19 | 3,14,0,11,4,0,0,88,5,1,128,18,4,0,0,16,4,12,0,3,1,2,0,88,5,24,128,33,5,1,3, 20 | 0,2,3,0,88,6,4,128,2,3,1,0,88,6,2,128,4,4,0,0,88,6,9,128,18,6,1,0,18,7,2,0, 21 | 41,8,1,0,77,6,4,128,32,10,5,9,59,11,9,0,64,11,10,4,79,6,252,127,88,6,8,128, 22 | 18,6,2,0,18,7,1,0,41,8,255,255,77,6,4,128,32,10,5,9,59,11,9,0,64,11,10,4,79, 23 | 6,252,127,76,4,2,0,0 24 | #else 25 | 0,1,2,0,0,1,2,24,1,0,0,76,1,2,0,241,135,158,166,3,220,203,178,130,4,0,1,2,0, 26 | 0,1,2,24,1,0,0,76,1,2,0,243,244,148,165,20,198,190,199,252,3,0,1,2,0,0,0,3, 27 | 16,0,5,0,21,1,0,0,76,1,2,0,0,2,9,0,0,0,15,16,0,12,0,16,1,9,0,41,2,1,0,21,3, 28 | 0,0,41,4,1,0,77,2,8,128,18,6,1,0,18,7,5,0,59,8,5,0,66,6,3,2,10,6,0,0,88,7,1, 29 | 128,76,6,2,0,79,2,248,127,75,0,1,0,0,2,10,0,0,0,16,16,0,12,0,16,1,9,0,43,2, 30 | 0,0,18,3,0,0,41,4,0,0,88,5,7,128,18,7,1,0,18,8,5,0,18,9,6,0,66,7,3,2,10,7,0, 31 | 0,88,8,1,128,76,7,2,0,70,5,3,3,82,5,247,127,75,0,1,0,0,1,2,0,0,0,3,16,0,12, 32 | 0,21,1,0,0,76,1,2,0,0,2,10,0,0,2,30,16,0,12,0,21,2,0,0,11,1,0,0,88,3,7,128, 33 | 8,2,0,0,88,3,23,128,59,3,2,0,43,4,0,0,64,4,2,0,76,3,2,0,88,3,18,128,16,1,14, 34 | 0,41,3,1,0,3,3,1,0,88,3,14,128,3,1,2,0,88,3,12,128,59,3,1,0,22,4,1,1,18,5,2, 35 | 0,41,6,1,0,77,4,4,128,23,8,1,7,59,9,7,0,64,9,8,0,79,4,252,127,43,4,0,0,64,4, 36 | 2,0,76,3,2,0,75,0,1,0,0,2,0,5,12,0,0,0,35,16,0,12,0,16,1,14,0,16,2,14,0,16, 37 | 3,14,0,11,4,0,0,88,5,1,128,18,4,0,0,16,4,12,0,3,1,2,0,88,5,24,128,33,5,1,3, 38 | 0,2,3,0,88,6,4,128,2,3,1,0,88,6,2,128,4,4,0,0,88,6,9,128,18,6,1,0,18,7,2,0, 39 | 41,8,1,0,77,6,4,128,32,10,5,9,59,11,9,0,64,11,10,4,79,6,252,127,88,6,8,128, 40 | 18,6,2,0,18,7,1,0,41,8,255,255,77,6,4,128,32,10,5,9,59,11,9,0,64,11,10,4,79, 41 | 6,252,127,76,4,2,0,0 42 | #endif 43 | }; 44 | 45 | static const struct { const char *name; int ofs; } libbc_map[] = { 46 | {"math_deg",0}, 47 | {"math_rad",25}, 48 | {"string_len",50}, 49 | {"table_foreachi",69}, 50 | {"table_foreach",136}, 51 | {"table_getn",207}, 52 | {"table_remove",226}, 53 | {"table_move",355}, 54 | {NULL,502} 55 | }; 56 | 57 | -------------------------------------------------------------------------------- /deps/luajit/src/jit/dis_arm64be.lua: -------------------------------------------------------------------------------- 1 | ---------------------------------------------------------------------------- 2 | -- LuaJIT ARM64BE disassembler wrapper module. 3 | -- 4 | -- Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | -- Released under the MIT license. See Copyright Notice in luajit.h 6 | ---------------------------------------------------------------------------- 7 | -- ARM64 instructions are always little-endian. So just forward to the 8 | -- common ARM64 disassembler module. All the interesting stuff is there. 9 | ------------------------------------------------------------------------------ 10 | 11 | return require((string.match(..., ".*%.") or "").."dis_arm64") 12 | 13 | -------------------------------------------------------------------------------- /deps/luajit/src/jit/dis_mips64.lua: -------------------------------------------------------------------------------- 1 | ---------------------------------------------------------------------------- 2 | -- LuaJIT MIPS64 disassembler wrapper module. 3 | -- 4 | -- Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | -- Released under the MIT license. See Copyright Notice in luajit.h 6 | ---------------------------------------------------------------------------- 7 | -- This module just exports the big-endian functions from the 8 | -- MIPS disassembler module. All the interesting stuff is there. 9 | ------------------------------------------------------------------------------ 10 | 11 | local dis_mips = require((string.match(..., ".*%.") or "").."dis_mips") 12 | return { 13 | create = dis_mips.create, 14 | disass = dis_mips.disass, 15 | regname = dis_mips.regname 16 | } 17 | 18 | -------------------------------------------------------------------------------- /deps/luajit/src/jit/dis_mips64el.lua: -------------------------------------------------------------------------------- 1 | ---------------------------------------------------------------------------- 2 | -- LuaJIT MIPS64EL disassembler wrapper module. 3 | -- 4 | -- Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | -- Released under the MIT license. See Copyright Notice in luajit.h 6 | ---------------------------------------------------------------------------- 7 | -- This module just exports the little-endian functions from the 8 | -- MIPS disassembler module. All the interesting stuff is there. 9 | ------------------------------------------------------------------------------ 10 | 11 | local dis_mips = require((string.match(..., ".*%.") or "").."dis_mips") 12 | return { 13 | create = dis_mips.create_el, 14 | disass = dis_mips.disass_el, 15 | regname = dis_mips.regname 16 | } 17 | 18 | -------------------------------------------------------------------------------- /deps/luajit/src/jit/dis_mipsel.lua: -------------------------------------------------------------------------------- 1 | ---------------------------------------------------------------------------- 2 | -- LuaJIT MIPSEL disassembler wrapper module. 3 | -- 4 | -- Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | -- Released under the MIT license. See Copyright Notice in luajit.h 6 | ---------------------------------------------------------------------------- 7 | -- This module just exports the little-endian functions from the 8 | -- MIPS disassembler module. All the interesting stuff is there. 9 | ------------------------------------------------------------------------------ 10 | 11 | local dis_mips = require((string.match(..., ".*%.") or "").."dis_mips") 12 | return { 13 | create = dis_mips.create_el, 14 | disass = dis_mips.disass_el, 15 | regname = dis_mips.regname 16 | } 17 | 18 | -------------------------------------------------------------------------------- /deps/luajit/src/jit/dis_x64.lua: -------------------------------------------------------------------------------- 1 | ---------------------------------------------------------------------------- 2 | -- LuaJIT x64 disassembler wrapper module. 3 | -- 4 | -- Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | -- Released under the MIT license. See Copyright Notice in luajit.h 6 | ---------------------------------------------------------------------------- 7 | -- This module just exports the 64 bit functions from the combined 8 | -- x86/x64 disassembler module. All the interesting stuff is there. 9 | ------------------------------------------------------------------------------ 10 | 11 | local dis_x86 = require((string.match(..., ".*%.") or "").."dis_x86") 12 | return { 13 | create = dis_x86.create64, 14 | disass = dis_x86.disass64, 15 | regname = dis_x86.regname64 16 | } 17 | 18 | -------------------------------------------------------------------------------- /deps/luajit/src/jit/zone.lua: -------------------------------------------------------------------------------- 1 | ---------------------------------------------------------------------------- 2 | -- LuaJIT profiler zones. 3 | -- 4 | -- Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | -- Released under the MIT license. See Copyright Notice in luajit.h 6 | ---------------------------------------------------------------------------- 7 | -- 8 | -- This module implements a simple hierarchical zone model. 9 | -- 10 | -- Example usage: 11 | -- 12 | -- local zone = require("jit.zone") 13 | -- zone("AI") 14 | -- ... 15 | -- zone("A*") 16 | -- ... 17 | -- print(zone:get()) --> "A*" 18 | -- ... 19 | -- zone() 20 | -- ... 21 | -- print(zone:get()) --> "AI" 22 | -- ... 23 | -- zone() 24 | -- 25 | ---------------------------------------------------------------------------- 26 | 27 | local remove = table.remove 28 | 29 | return setmetatable({ 30 | flush = function(t) 31 | for i=#t,1,-1 do t[i] = nil end 32 | end, 33 | get = function(t) 34 | return t[#t] 35 | end 36 | }, { 37 | __call = function(t, zone) 38 | if zone then 39 | t[#t+1] = zone 40 | else 41 | return (assert(remove(t), "empty zone stack")) 42 | end 43 | end 44 | }) 45 | 46 | -------------------------------------------------------------------------------- /deps/luajit/src/lib_bit.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** Bit manipulation library. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #define lib_bit_c 7 | #define LUA_LIB 8 | 9 | #include "lua.h" 10 | #include "lauxlib.h" 11 | #include "lualib.h" 12 | 13 | #include "lj_obj.h" 14 | #include "lj_err.h" 15 | #include "lj_buf.h" 16 | #include "lj_strscan.h" 17 | #include "lj_strfmt.h" 18 | #if LJ_HASFFI 19 | #include "lj_ctype.h" 20 | #include "lj_cdata.h" 21 | #include "lj_cconv.h" 22 | #include "lj_carith.h" 23 | #endif 24 | #include "lj_ff.h" 25 | #include "lj_lib.h" 26 | 27 | /* ------------------------------------------------------------------------ */ 28 | 29 | #define LJLIB_MODULE_bit 30 | 31 | #if LJ_HASFFI 32 | static int bit_result64(lua_State *L, CTypeID id, uint64_t x) 33 | { 34 | GCcdata *cd = lj_cdata_new_(L, id, 8); 35 | *(uint64_t *)cdataptr(cd) = x; 36 | setcdataV(L, L->base-1-LJ_FR2, cd); 37 | return FFH_RES(1); 38 | } 39 | #else 40 | static int32_t bit_checkbit(lua_State *L, int narg) 41 | { 42 | TValue *o = L->base + narg-1; 43 | if (!(o < L->top && lj_strscan_numberobj(o))) 44 | lj_err_argt(L, narg, LUA_TNUMBER); 45 | if (LJ_LIKELY(tvisint(o))) { 46 | return intV(o); 47 | } else { 48 | int32_t i = lj_num2bit(numV(o)); 49 | if (LJ_DUALNUM) setintV(o, i); 50 | return i; 51 | } 52 | } 53 | #endif 54 | 55 | LJLIB_ASM(bit_tobit) LJLIB_REC(bit_tobit) 56 | { 57 | #if LJ_HASFFI 58 | CTypeID id = 0; 59 | setintV(L->base-1-LJ_FR2, (int32_t)lj_carith_check64(L, 1, &id)); 60 | return FFH_RES(1); 61 | #else 62 | lj_lib_checknumber(L, 1); 63 | return FFH_RETRY; 64 | #endif 65 | } 66 | 67 | LJLIB_ASM(bit_bnot) LJLIB_REC(bit_unary IR_BNOT) 68 | { 69 | #if LJ_HASFFI 70 | CTypeID id = 0; 71 | uint64_t x = lj_carith_check64(L, 1, &id); 72 | return id ? bit_result64(L, id, ~x) : FFH_RETRY; 73 | #else 74 | lj_lib_checknumber(L, 1); 75 | return FFH_RETRY; 76 | #endif 77 | } 78 | 79 | LJLIB_ASM(bit_bswap) LJLIB_REC(bit_unary IR_BSWAP) 80 | { 81 | #if LJ_HASFFI 82 | CTypeID id = 0; 83 | uint64_t x = lj_carith_check64(L, 1, &id); 84 | return id ? bit_result64(L, id, lj_bswap64(x)) : FFH_RETRY; 85 | #else 86 | lj_lib_checknumber(L, 1); 87 | return FFH_RETRY; 88 | #endif 89 | } 90 | 91 | LJLIB_ASM(bit_lshift) LJLIB_REC(bit_shift IR_BSHL) 92 | { 93 | #if LJ_HASFFI 94 | CTypeID id = 0, id2 = 0; 95 | uint64_t x = lj_carith_check64(L, 1, &id); 96 | int32_t sh = (int32_t)lj_carith_check64(L, 2, &id2); 97 | if (id) { 98 | x = lj_carith_shift64(x, sh, curr_func(L)->c.ffid - (int)FF_bit_lshift); 99 | return bit_result64(L, id, x); 100 | } 101 | if (id2) setintV(L->base+1, sh); 102 | return FFH_RETRY; 103 | #else 104 | lj_lib_checknumber(L, 1); 105 | bit_checkbit(L, 2); 106 | return FFH_RETRY; 107 | #endif 108 | } 109 | LJLIB_ASM_(bit_rshift) LJLIB_REC(bit_shift IR_BSHR) 110 | LJLIB_ASM_(bit_arshift) LJLIB_REC(bit_shift IR_BSAR) 111 | LJLIB_ASM_(bit_rol) LJLIB_REC(bit_shift IR_BROL) 112 | LJLIB_ASM_(bit_ror) LJLIB_REC(bit_shift IR_BROR) 113 | 114 | LJLIB_ASM(bit_band) LJLIB_REC(bit_nary IR_BAND) 115 | { 116 | #if LJ_HASFFI 117 | CTypeID id = 0; 118 | TValue *o = L->base, *top = L->top; 119 | int i = 0; 120 | do { lj_carith_check64(L, ++i, &id); } while (++o < top); 121 | if (id) { 122 | CTState *cts = ctype_cts(L); 123 | CType *ct = ctype_get(cts, id); 124 | int op = curr_func(L)->c.ffid - (int)FF_bit_bor; 125 | uint64_t x, y = op >= 0 ? 0 : ~(uint64_t)0; 126 | o = L->base; 127 | do { 128 | lj_cconv_ct_tv(cts, ct, (uint8_t *)&x, o, 0); 129 | if (op < 0) y &= x; else if (op == 0) y |= x; else y ^= x; 130 | } while (++o < top); 131 | return bit_result64(L, id, y); 132 | } 133 | return FFH_RETRY; 134 | #else 135 | int i = 0; 136 | do { lj_lib_checknumber(L, ++i); } while (L->base+i < L->top); 137 | return FFH_RETRY; 138 | #endif 139 | } 140 | LJLIB_ASM_(bit_bor) LJLIB_REC(bit_nary IR_BOR) 141 | LJLIB_ASM_(bit_bxor) LJLIB_REC(bit_nary IR_BXOR) 142 | 143 | /* ------------------------------------------------------------------------ */ 144 | 145 | LJLIB_CF(bit_tohex) LJLIB_REC(.) 146 | { 147 | #if LJ_HASFFI 148 | CTypeID id = 0, id2 = 0; 149 | uint64_t b = lj_carith_check64(L, 1, &id); 150 | int32_t n = L->base+1>=L->top ? (id ? 16 : 8) : 151 | (int32_t)lj_carith_check64(L, 2, &id2); 152 | #else 153 | uint32_t b = (uint32_t)bit_checkbit(L, 1); 154 | int32_t n = L->base+1>=L->top ? 8 : bit_checkbit(L, 2); 155 | #endif 156 | SBuf *sb = lj_buf_tmp_(L); 157 | SFormat sf = (STRFMT_UINT|STRFMT_T_HEX); 158 | if (n < 0) { n = -n; sf |= STRFMT_F_UPPER; } 159 | sf |= ((SFormat)((n+1)&255) << STRFMT_SH_PREC); 160 | #if LJ_HASFFI 161 | if (n < 16) b &= ((uint64_t)1 << 4*n)-1; 162 | #else 163 | if (n < 8) b &= (1u << 4*n)-1; 164 | #endif 165 | sb = lj_strfmt_putfxint(sb, sf, b); 166 | setstrV(L, L->top-1, lj_buf_str(L, sb)); 167 | lj_gc_check(L); 168 | return 1; 169 | } 170 | 171 | /* ------------------------------------------------------------------------ */ 172 | 173 | #include "lj_libdef.h" 174 | 175 | LUALIB_API int luaopen_bit(lua_State *L) 176 | { 177 | LJ_LIB_REG(L, LUA_BITLIBNAME, bit); 178 | return 1; 179 | } 180 | 181 | -------------------------------------------------------------------------------- /deps/luajit/src/lib_init.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** Library initialization. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | ** 5 | ** Major parts taken verbatim from the Lua interpreter. 6 | ** Copyright (C) 1994-2008 Lua.org, PUC-Rio. See Copyright Notice in lua.h 7 | */ 8 | 9 | #define lib_init_c 10 | #define LUA_LIB 11 | 12 | #include "lua.h" 13 | #include "lauxlib.h" 14 | #include "lualib.h" 15 | 16 | #include "lj_arch.h" 17 | 18 | static const luaL_Reg lj_lib_load[] = { 19 | { "", luaopen_base }, 20 | { LUA_LOADLIBNAME, luaopen_package }, 21 | { LUA_TABLIBNAME, luaopen_table }, 22 | { LUA_IOLIBNAME, luaopen_io }, 23 | { LUA_OSLIBNAME, luaopen_os }, 24 | { LUA_STRLIBNAME, luaopen_string }, 25 | { LUA_MATHLIBNAME, luaopen_math }, 26 | { LUA_DBLIBNAME, luaopen_debug }, 27 | { LUA_BITLIBNAME, luaopen_bit }, 28 | { LUA_JITLIBNAME, luaopen_jit }, 29 | { NULL, NULL } 30 | }; 31 | 32 | static const luaL_Reg lj_lib_preload[] = { 33 | #if LJ_HASFFI 34 | { LUA_FFILIBNAME, luaopen_ffi }, 35 | #endif 36 | { NULL, NULL } 37 | }; 38 | 39 | LUALIB_API void luaL_openlibs(lua_State *L) 40 | { 41 | const luaL_Reg *lib; 42 | for (lib = lj_lib_load; lib->func; lib++) { 43 | lua_pushcfunction(L, lib->func); 44 | lua_pushstring(L, lib->name); 45 | lua_call(L, 1, 0); 46 | } 47 | luaL_findtable(L, LUA_REGISTRYINDEX, "_PRELOAD", 48 | sizeof(lj_lib_preload)/sizeof(lj_lib_preload[0])-1); 49 | for (lib = lj_lib_preload; lib->func; lib++) { 50 | lua_pushcfunction(L, lib->func); 51 | lua_setfield(L, -2, lib->name); 52 | } 53 | lua_pop(L, 1); 54 | } 55 | 56 | -------------------------------------------------------------------------------- /deps/luajit/src/lj.supp: -------------------------------------------------------------------------------- 1 | # Valgrind suppression file for LuaJIT 2.0. 2 | { 3 | Optimized string compare 4 | Memcheck:Addr4 5 | fun:lj_str_cmp 6 | } 7 | { 8 | Optimized string compare 9 | Memcheck:Addr1 10 | fun:lj_str_cmp 11 | } 12 | { 13 | Optimized string compare 14 | Memcheck:Addr4 15 | fun:lj_str_new 16 | } 17 | { 18 | Optimized string compare 19 | Memcheck:Addr1 20 | fun:lj_str_new 21 | } 22 | { 23 | Optimized string compare 24 | Memcheck:Cond 25 | fun:lj_str_new 26 | } 27 | { 28 | Optimized string compare 29 | Memcheck:Addr4 30 | fun:str_fastcmp 31 | } 32 | { 33 | Optimized string compare 34 | Memcheck:Addr1 35 | fun:str_fastcmp 36 | } 37 | { 38 | Optimized string compare 39 | Memcheck:Cond 40 | fun:str_fastcmp 41 | } 42 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_alloc.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Bundled memory allocator. 3 | ** Donated to the public domain. 4 | */ 5 | 6 | #ifndef _LJ_ALLOC_H 7 | #define _LJ_ALLOC_H 8 | 9 | #include "lj_def.h" 10 | 11 | #ifndef LUAJIT_USE_SYSMALLOC 12 | LJ_FUNC void *lj_alloc_create(void); 13 | LJ_FUNC void lj_alloc_destroy(void *msp); 14 | LJ_FUNC void *lj_alloc_f(void *msp, void *ptr, size_t osize, size_t nsize); 15 | #endif 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_asm.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** IR assembler (SSA IR -> machine code). 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_ASM_H 7 | #define _LJ_ASM_H 8 | 9 | #include "lj_jit.h" 10 | 11 | #if LJ_HASJIT 12 | LJ_FUNC void lj_asm_trace(jit_State *J, GCtrace *T); 13 | LJ_FUNC void lj_asm_patchexit(jit_State *J, GCtrace *T, ExitNo exitno, 14 | MCode *target); 15 | #endif 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_bc.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** Bytecode instruction modes. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #define lj_bc_c 7 | #define LUA_CORE 8 | 9 | #include "lj_obj.h" 10 | #include "lj_bc.h" 11 | 12 | /* Bytecode offsets and bytecode instruction modes. */ 13 | #include "lj_bcdef.h" 14 | 15 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_bcdump.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Bytecode dump definitions. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_BCDUMP_H 7 | #define _LJ_BCDUMP_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_lex.h" 11 | 12 | /* -- Bytecode dump format ------------------------------------------------ */ 13 | 14 | /* 15 | ** dump = header proto+ 0U 16 | ** header = ESC 'L' 'J' versionB flagsU [namelenU nameB*] 17 | ** proto = lengthU pdata 18 | ** pdata = phead bcinsW* uvdataH* kgc* knum* [debugB*] 19 | ** phead = flagsB numparamsB framesizeB numuvB numkgcU numknU numbcU 20 | ** [debuglenU [firstlineU numlineU]] 21 | ** kgc = kgctypeU { ktab | (loU hiU) | (rloU rhiU iloU ihiU) | strB* } 22 | ** knum = intU0 | (loU1 hiU) 23 | ** ktab = narrayU nhashU karray* khash* 24 | ** karray = ktabk 25 | ** khash = ktabk ktabk 26 | ** ktabk = ktabtypeU { intU | (loU hiU) | strB* } 27 | ** 28 | ** B = 8 bit, H = 16 bit, W = 32 bit, U = ULEB128 of W, U0/U1 = ULEB128 of W+1 29 | */ 30 | 31 | /* Bytecode dump header. */ 32 | #define BCDUMP_HEAD1 0x1b 33 | #define BCDUMP_HEAD2 0x4c 34 | #define BCDUMP_HEAD3 0x4a 35 | 36 | /* If you perform *any* kind of private modifications to the bytecode itself 37 | ** or to the dump format, you *must* set BCDUMP_VERSION to 0x80 or higher. 38 | */ 39 | #define BCDUMP_VERSION 2 40 | 41 | /* Compatibility flags. */ 42 | #define BCDUMP_F_BE 0x01 43 | #define BCDUMP_F_STRIP 0x02 44 | #define BCDUMP_F_FFI 0x04 45 | #define BCDUMP_F_FR2 0x08 46 | 47 | #define BCDUMP_F_KNOWN (BCDUMP_F_FR2*2-1) 48 | 49 | /* Type codes for the GC constants of a prototype. Plus length for strings. */ 50 | enum { 51 | BCDUMP_KGC_CHILD, BCDUMP_KGC_TAB, BCDUMP_KGC_I64, BCDUMP_KGC_U64, 52 | BCDUMP_KGC_COMPLEX, BCDUMP_KGC_STR 53 | }; 54 | 55 | /* Type codes for the keys/values of a constant table. */ 56 | enum { 57 | BCDUMP_KTAB_NIL, BCDUMP_KTAB_FALSE, BCDUMP_KTAB_TRUE, 58 | BCDUMP_KTAB_INT, BCDUMP_KTAB_NUM, BCDUMP_KTAB_STR 59 | }; 60 | 61 | /* -- Bytecode reader/writer ---------------------------------------------- */ 62 | 63 | LJ_FUNC int lj_bcwrite(lua_State *L, GCproto *pt, lua_Writer writer, 64 | void *data, int strip); 65 | LJ_FUNC GCproto *lj_bcread_proto(LexState *ls); 66 | LJ_FUNC GCproto *lj_bcread(LexState *ls); 67 | 68 | #endif 69 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_buf.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Buffer handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_BUF_H 7 | #define _LJ_BUF_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_gc.h" 11 | #include "lj_str.h" 12 | 13 | /* Resizable string buffers. Struct definition in lj_obj.h. */ 14 | #define sbufB(sb) (mref((sb)->b, char)) 15 | #define sbufP(sb) (mref((sb)->p, char)) 16 | #define sbufE(sb) (mref((sb)->e, char)) 17 | #define sbufL(sb) (mref((sb)->L, lua_State)) 18 | #define sbufsz(sb) ((MSize)(sbufE((sb)) - sbufB((sb)))) 19 | #define sbuflen(sb) ((MSize)(sbufP((sb)) - sbufB((sb)))) 20 | #define sbufleft(sb) ((MSize)(sbufE((sb)) - sbufP((sb)))) 21 | #define setsbufP(sb, q) (setmref((sb)->p, (q))) 22 | #define setsbufL(sb, l) (setmref((sb)->L, (l))) 23 | 24 | /* Buffer management */ 25 | LJ_FUNC char *LJ_FASTCALL lj_buf_need2(SBuf *sb, MSize sz); 26 | LJ_FUNC char *LJ_FASTCALL lj_buf_more2(SBuf *sb, MSize sz); 27 | LJ_FUNC void LJ_FASTCALL lj_buf_shrink(lua_State *L, SBuf *sb); 28 | LJ_FUNC char * LJ_FASTCALL lj_buf_tmp(lua_State *L, MSize sz); 29 | 30 | static LJ_AINLINE void lj_buf_init(lua_State *L, SBuf *sb) 31 | { 32 | setsbufL(sb, L); 33 | setmref(sb->p, NULL); setmref(sb->e, NULL); setmref(sb->b, NULL); 34 | } 35 | 36 | static LJ_AINLINE void lj_buf_reset(SBuf *sb) 37 | { 38 | setmrefr(sb->p, sb->b); 39 | } 40 | 41 | static LJ_AINLINE SBuf *lj_buf_tmp_(lua_State *L) 42 | { 43 | SBuf *sb = &G(L)->tmpbuf; 44 | setsbufL(sb, L); 45 | lj_buf_reset(sb); 46 | return sb; 47 | } 48 | 49 | static LJ_AINLINE void lj_buf_free(global_State *g, SBuf *sb) 50 | { 51 | lj_mem_free(g, sbufB(sb), sbufsz(sb)); 52 | } 53 | 54 | static LJ_AINLINE char *lj_buf_need(SBuf *sb, MSize sz) 55 | { 56 | if (LJ_UNLIKELY(sz > sbufsz(sb))) 57 | return lj_buf_need2(sb, sz); 58 | return sbufB(sb); 59 | } 60 | 61 | static LJ_AINLINE char *lj_buf_more(SBuf *sb, MSize sz) 62 | { 63 | if (LJ_UNLIKELY(sz > sbufleft(sb))) 64 | return lj_buf_more2(sb, sz); 65 | return sbufP(sb); 66 | } 67 | 68 | /* Low-level buffer put operations */ 69 | LJ_FUNC SBuf *lj_buf_putmem(SBuf *sb, const void *q, MSize len); 70 | LJ_FUNC SBuf * LJ_FASTCALL lj_buf_putchar(SBuf *sb, int c); 71 | LJ_FUNC SBuf * LJ_FASTCALL lj_buf_putstr(SBuf *sb, GCstr *s); 72 | 73 | static LJ_AINLINE char *lj_buf_wmem(char *p, const void *q, MSize len) 74 | { 75 | return (char *)memcpy(p, q, len) + len; 76 | } 77 | 78 | static LJ_AINLINE void lj_buf_putb(SBuf *sb, int c) 79 | { 80 | char *p = lj_buf_more(sb, 1); 81 | *p++ = (char)c; 82 | setsbufP(sb, p); 83 | } 84 | 85 | /* High-level buffer put operations */ 86 | LJ_FUNCA SBuf * LJ_FASTCALL lj_buf_putstr_reverse(SBuf *sb, GCstr *s); 87 | LJ_FUNCA SBuf * LJ_FASTCALL lj_buf_putstr_lower(SBuf *sb, GCstr *s); 88 | LJ_FUNCA SBuf * LJ_FASTCALL lj_buf_putstr_upper(SBuf *sb, GCstr *s); 89 | LJ_FUNC SBuf *lj_buf_putstr_rep(SBuf *sb, GCstr *s, int32_t rep); 90 | LJ_FUNC SBuf *lj_buf_puttab(SBuf *sb, GCtab *t, GCstr *sep, 91 | int32_t i, int32_t e); 92 | 93 | /* Miscellaneous buffer operations */ 94 | LJ_FUNCA GCstr * LJ_FASTCALL lj_buf_tostr(SBuf *sb); 95 | LJ_FUNC GCstr *lj_buf_cat2str(lua_State *L, GCstr *s1, GCstr *s2); 96 | LJ_FUNC uint32_t LJ_FASTCALL lj_buf_ruleb128(const char **pp); 97 | 98 | static LJ_AINLINE GCstr *lj_buf_str(lua_State *L, SBuf *sb) 99 | { 100 | return lj_str_new(L, sbufB(sb), sbuflen(sb)); 101 | } 102 | 103 | #endif 104 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_carith.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** C data arithmetic. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_CARITH_H 7 | #define _LJ_CARITH_H 8 | 9 | #include "lj_obj.h" 10 | 11 | #if LJ_HASFFI 12 | 13 | LJ_FUNC int lj_carith_op(lua_State *L, MMS mm); 14 | 15 | #if LJ_32 16 | LJ_FUNC uint64_t lj_carith_shl64(uint64_t x, int32_t sh); 17 | LJ_FUNC uint64_t lj_carith_shr64(uint64_t x, int32_t sh); 18 | LJ_FUNC uint64_t lj_carith_sar64(uint64_t x, int32_t sh); 19 | LJ_FUNC uint64_t lj_carith_rol64(uint64_t x, int32_t sh); 20 | LJ_FUNC uint64_t lj_carith_ror64(uint64_t x, int32_t sh); 21 | #endif 22 | LJ_FUNC uint64_t lj_carith_shift64(uint64_t x, int32_t sh, int op); 23 | LJ_FUNC uint64_t lj_carith_check64(lua_State *L, int narg, CTypeID *id); 24 | 25 | #if LJ_32 && LJ_HASJIT 26 | LJ_FUNC int64_t lj_carith_mul64(int64_t x, int64_t k); 27 | #endif 28 | LJ_FUNC uint64_t lj_carith_divu64(uint64_t a, uint64_t b); 29 | LJ_FUNC int64_t lj_carith_divi64(int64_t a, int64_t b); 30 | LJ_FUNC uint64_t lj_carith_modu64(uint64_t a, uint64_t b); 31 | LJ_FUNC int64_t lj_carith_modi64(int64_t a, int64_t b); 32 | LJ_FUNC uint64_t lj_carith_powu64(uint64_t x, uint64_t k); 33 | LJ_FUNC int64_t lj_carith_powi64(int64_t x, int64_t k); 34 | 35 | #endif 36 | 37 | #endif 38 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_ccallback.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** FFI C callback handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_CCALLBACK_H 7 | #define _LJ_CCALLBACK_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_ctype.h" 11 | 12 | #if LJ_HASFFI 13 | 14 | /* Really belongs to lj_vm.h. */ 15 | LJ_ASMF void lj_vm_ffi_callback(void); 16 | 17 | LJ_FUNC MSize lj_ccallback_ptr2slot(CTState *cts, void *p); 18 | LJ_FUNCA lua_State * LJ_FASTCALL lj_ccallback_enter(CTState *cts, void *cf); 19 | LJ_FUNCA void LJ_FASTCALL lj_ccallback_leave(CTState *cts, TValue *o); 20 | LJ_FUNC void *lj_ccallback_new(CTState *cts, CType *ct, GCfunc *fn); 21 | LJ_FUNC void lj_ccallback_mcode_free(CTState *cts); 22 | 23 | #endif 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_cconv.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** C type conversions. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_CCONV_H 7 | #define _LJ_CCONV_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_ctype.h" 11 | 12 | #if LJ_HASFFI 13 | 14 | /* Compressed C type index. ORDER CCX. */ 15 | enum { 16 | CCX_B, /* Bool. */ 17 | CCX_I, /* Integer. */ 18 | CCX_F, /* Floating-point number. */ 19 | CCX_C, /* Complex. */ 20 | CCX_V, /* Vector. */ 21 | CCX_P, /* Pointer. */ 22 | CCX_A, /* Refarray. */ 23 | CCX_S /* Struct/union. */ 24 | }; 25 | 26 | /* Convert C type info to compressed C type index. ORDER CT. ORDER CCX. */ 27 | static LJ_AINLINE uint32_t cconv_idx(CTInfo info) 28 | { 29 | uint32_t idx = ((info >> 26) & 15u); /* Dispatch bits. */ 30 | lua_assert(ctype_type(info) <= CT_MAYCONVERT); 31 | #if LJ_64 32 | idx = ((uint32_t)(U64x(f436fff5,fff7f021) >> 4*idx) & 15u); 33 | #else 34 | idx = (((idx < 8 ? 0xfff7f021u : 0xf436fff5) >> 4*(idx & 7u)) & 15u); 35 | #endif 36 | lua_assert(idx < 8); 37 | return idx; 38 | } 39 | 40 | #define cconv_idx2(dinfo, sinfo) \ 41 | ((cconv_idx((dinfo)) << 3) + cconv_idx((sinfo))) 42 | 43 | #define CCX(dst, src) ((CCX_##dst << 3) + CCX_##src) 44 | 45 | /* Conversion flags. */ 46 | #define CCF_CAST 0x00000001u 47 | #define CCF_FROMTV 0x00000002u 48 | #define CCF_SAME 0x00000004u 49 | #define CCF_IGNQUAL 0x00000008u 50 | 51 | #define CCF_ARG_SHIFT 8 52 | #define CCF_ARG(n) ((n) << CCF_ARG_SHIFT) 53 | #define CCF_GETARG(f) ((f) >> CCF_ARG_SHIFT) 54 | 55 | LJ_FUNC int lj_cconv_compatptr(CTState *cts, CType *d, CType *s, CTInfo flags); 56 | LJ_FUNC void lj_cconv_ct_ct(CTState *cts, CType *d, CType *s, 57 | uint8_t *dp, uint8_t *sp, CTInfo flags); 58 | LJ_FUNC int lj_cconv_tv_ct(CTState *cts, CType *s, CTypeID sid, 59 | TValue *o, uint8_t *sp); 60 | LJ_FUNC int lj_cconv_tv_bf(CTState *cts, CType *s, TValue *o, uint8_t *sp); 61 | LJ_FUNC void lj_cconv_ct_tv(CTState *cts, CType *d, 62 | uint8_t *dp, TValue *o, CTInfo flags); 63 | LJ_FUNC void lj_cconv_bf_tv(CTState *cts, CType *d, uint8_t *dp, TValue *o); 64 | LJ_FUNC int lj_cconv_multi_init(CTState *cts, CType *d, TValue *o); 65 | LJ_FUNC void lj_cconv_ct_init(CTState *cts, CType *d, CTSize sz, 66 | uint8_t *dp, TValue *o, MSize len); 67 | 68 | #endif 69 | 70 | #endif 71 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_cdata.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** C data management. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_CDATA_H 7 | #define _LJ_CDATA_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_gc.h" 11 | #include "lj_ctype.h" 12 | 13 | #if LJ_HASFFI 14 | 15 | /* Get C data pointer. */ 16 | static LJ_AINLINE void *cdata_getptr(void *p, CTSize sz) 17 | { 18 | if (LJ_64 && sz == 4) { /* Support 32 bit pointers on 64 bit targets. */ 19 | return ((void *)(uintptr_t)*(uint32_t *)p); 20 | } else { 21 | lua_assert(sz == CTSIZE_PTR); 22 | return *(void **)p; 23 | } 24 | } 25 | 26 | /* Set C data pointer. */ 27 | static LJ_AINLINE void cdata_setptr(void *p, CTSize sz, const void *v) 28 | { 29 | if (LJ_64 && sz == 4) { /* Support 32 bit pointers on 64 bit targets. */ 30 | *(uint32_t *)p = (uint32_t)(uintptr_t)v; 31 | } else { 32 | lua_assert(sz == CTSIZE_PTR); 33 | *(void **)p = (void *)v; 34 | } 35 | } 36 | 37 | /* Allocate fixed-size C data object. */ 38 | static LJ_AINLINE GCcdata *lj_cdata_new(CTState *cts, CTypeID id, CTSize sz) 39 | { 40 | GCcdata *cd; 41 | #ifdef LUA_USE_ASSERT 42 | CType *ct = ctype_raw(cts, id); 43 | lua_assert((ctype_hassize(ct->info) ? ct->size : CTSIZE_PTR) == sz); 44 | #endif 45 | cd = (GCcdata *)lj_mem_newgco(cts->L, sizeof(GCcdata) + sz); 46 | cd->gct = ~LJ_TCDATA; 47 | cd->ctypeid = ctype_check(cts, id); 48 | return cd; 49 | } 50 | 51 | /* Variant which works without a valid CTState. */ 52 | static LJ_AINLINE GCcdata *lj_cdata_new_(lua_State *L, CTypeID id, CTSize sz) 53 | { 54 | GCcdata *cd = (GCcdata *)lj_mem_newgco(L, sizeof(GCcdata) + sz); 55 | cd->gct = ~LJ_TCDATA; 56 | cd->ctypeid = id; 57 | return cd; 58 | } 59 | 60 | LJ_FUNC GCcdata *lj_cdata_newref(CTState *cts, const void *pp, CTypeID id); 61 | LJ_FUNC GCcdata *lj_cdata_newv(lua_State *L, CTypeID id, CTSize sz, 62 | CTSize align); 63 | LJ_FUNC GCcdata *lj_cdata_newx(CTState *cts, CTypeID id, CTSize sz, 64 | CTInfo info); 65 | 66 | LJ_FUNC void LJ_FASTCALL lj_cdata_free(global_State *g, GCcdata *cd); 67 | LJ_FUNC void lj_cdata_setfin(lua_State *L, GCcdata *cd, GCobj *obj, 68 | uint32_t it); 69 | 70 | LJ_FUNC CType *lj_cdata_index(CTState *cts, GCcdata *cd, cTValue *key, 71 | uint8_t **pp, CTInfo *qual); 72 | LJ_FUNC int lj_cdata_get(CTState *cts, CType *s, TValue *o, uint8_t *sp); 73 | LJ_FUNC void lj_cdata_set(CTState *cts, CType *d, uint8_t *dp, TValue *o, 74 | CTInfo qual); 75 | 76 | #endif 77 | 78 | #endif 79 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_char.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** Character types. 3 | ** Donated to the public domain. 4 | ** 5 | ** This is intended to replace the problematic libc single-byte NLS functions. 6 | ** These just don't make sense anymore with UTF-8 locales becoming the norm 7 | ** on POSIX systems. It never worked too well on Windows systems since hardly 8 | ** anyone bothered to call setlocale(). 9 | ** 10 | ** This table is hardcoded for ASCII. Identifiers include the characters 11 | ** 128-255, too. This allows for the use of all non-ASCII chars as identifiers 12 | ** in the lexer. This is a broad definition, but works well in practice 13 | ** for both UTF-8 locales and most single-byte locales (such as ISO-8859-*). 14 | ** 15 | ** If you really need proper character types for UTF-8 strings, please use 16 | ** an add-on library such as slnunicode: http://luaforge.net/projects/sln/ 17 | */ 18 | 19 | #define lj_char_c 20 | #define LUA_CORE 21 | 22 | #include "lj_char.h" 23 | 24 | LJ_DATADEF const uint8_t lj_char_bits[257] = { 25 | 0, 26 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 1, 1, 27 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 28 | 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 29 | 152,152,152,152,152,152,152,152,152,152, 4, 4, 4, 4, 4, 4, 30 | 4,176,176,176,176,176,176,160,160,160,160,160,160,160,160,160, 31 | 160,160,160,160,160,160,160,160,160,160,160, 4, 4, 4, 4,132, 32 | 4,208,208,208,208,208,208,192,192,192,192,192,192,192,192,192, 33 | 192,192,192,192,192,192,192,192,192,192,192, 4, 4, 4, 4, 1, 34 | 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, 35 | 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, 36 | 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, 37 | 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, 38 | 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, 39 | 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, 40 | 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, 41 | 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128 42 | }; 43 | 44 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_char.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Character types. 3 | ** Donated to the public domain. 4 | */ 5 | 6 | #ifndef _LJ_CHAR_H 7 | #define _LJ_CHAR_H 8 | 9 | #include "lj_def.h" 10 | 11 | #define LJ_CHAR_CNTRL 0x01 12 | #define LJ_CHAR_SPACE 0x02 13 | #define LJ_CHAR_PUNCT 0x04 14 | #define LJ_CHAR_DIGIT 0x08 15 | #define LJ_CHAR_XDIGIT 0x10 16 | #define LJ_CHAR_UPPER 0x20 17 | #define LJ_CHAR_LOWER 0x40 18 | #define LJ_CHAR_IDENT 0x80 19 | #define LJ_CHAR_ALPHA (LJ_CHAR_LOWER|LJ_CHAR_UPPER) 20 | #define LJ_CHAR_ALNUM (LJ_CHAR_ALPHA|LJ_CHAR_DIGIT) 21 | #define LJ_CHAR_GRAPH (LJ_CHAR_ALNUM|LJ_CHAR_PUNCT) 22 | 23 | /* Only pass -1 or 0..255 to these macros. Never pass a signed char! */ 24 | #define lj_char_isa(c, t) ((lj_char_bits+1)[(c)] & t) 25 | #define lj_char_iscntrl(c) lj_char_isa((c), LJ_CHAR_CNTRL) 26 | #define lj_char_isspace(c) lj_char_isa((c), LJ_CHAR_SPACE) 27 | #define lj_char_ispunct(c) lj_char_isa((c), LJ_CHAR_PUNCT) 28 | #define lj_char_isdigit(c) lj_char_isa((c), LJ_CHAR_DIGIT) 29 | #define lj_char_isxdigit(c) lj_char_isa((c), LJ_CHAR_XDIGIT) 30 | #define lj_char_isupper(c) lj_char_isa((c), LJ_CHAR_UPPER) 31 | #define lj_char_islower(c) lj_char_isa((c), LJ_CHAR_LOWER) 32 | #define lj_char_isident(c) lj_char_isa((c), LJ_CHAR_IDENT) 33 | #define lj_char_isalpha(c) lj_char_isa((c), LJ_CHAR_ALPHA) 34 | #define lj_char_isalnum(c) lj_char_isa((c), LJ_CHAR_ALNUM) 35 | #define lj_char_isgraph(c) lj_char_isa((c), LJ_CHAR_GRAPH) 36 | 37 | #define lj_char_toupper(c) ((c) - (lj_char_islower(c) >> 1)) 38 | #define lj_char_tolower(c) ((c) + lj_char_isupper(c)) 39 | 40 | LJ_DATA const uint8_t lj_char_bits[257]; 41 | 42 | #endif 43 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_clib.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** FFI C library loader. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_CLIB_H 7 | #define _LJ_CLIB_H 8 | 9 | #include "lj_obj.h" 10 | 11 | #if LJ_HASFFI 12 | 13 | /* Namespace for C library indexing. */ 14 | #define CLNS_INDEX ((1u<env. */ 20 | } CLibrary; 21 | 22 | LJ_FUNC TValue *lj_clib_index(lua_State *L, CLibrary *cl, GCstr *name); 23 | LJ_FUNC void lj_clib_load(lua_State *L, GCtab *mt, GCstr *name, int global); 24 | LJ_FUNC void lj_clib_unload(CLibrary *cl); 25 | LJ_FUNC void lj_clib_default(lua_State *L, GCtab *mt); 26 | 27 | #endif 28 | 29 | #endif 30 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_cparse.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** C declaration parser. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_CPARSE_H 7 | #define _LJ_CPARSE_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_ctype.h" 11 | 12 | #if LJ_HASFFI 13 | 14 | /* C parser limits. */ 15 | #define CPARSE_MAX_BUF 32768 /* Max. token buffer size. */ 16 | #define CPARSE_MAX_DECLSTACK 100 /* Max. declaration stack depth. */ 17 | #define CPARSE_MAX_DECLDEPTH 20 /* Max. recursive declaration depth. */ 18 | #define CPARSE_MAX_PACKSTACK 7 /* Max. pack pragma stack depth. */ 19 | 20 | /* Flags for C parser mode. */ 21 | #define CPARSE_MODE_MULTI 1 /* Process multiple declarations. */ 22 | #define CPARSE_MODE_ABSTRACT 2 /* Accept abstract declarators. */ 23 | #define CPARSE_MODE_DIRECT 4 /* Accept direct declarators. */ 24 | #define CPARSE_MODE_FIELD 8 /* Accept field width in bits, too. */ 25 | #define CPARSE_MODE_NOIMPLICIT 16 /* Reject implicit declarations. */ 26 | #define CPARSE_MODE_SKIP 32 /* Skip definitions, ignore errors. */ 27 | 28 | typedef int CPChar; /* C parser character. Unsigned ext. from char. */ 29 | typedef int CPToken; /* C parser token. */ 30 | 31 | /* C parser internal value representation. */ 32 | typedef struct CPValue { 33 | union { 34 | int32_t i32; /* Value for CTID_INT32. */ 35 | uint32_t u32; /* Value for CTID_UINT32. */ 36 | }; 37 | CTypeID id; /* C Type ID of the value. */ 38 | } CPValue; 39 | 40 | /* C parser state. */ 41 | typedef struct CPState { 42 | CPChar c; /* Current character. */ 43 | CPToken tok; /* Current token. */ 44 | CPValue val; /* Token value. */ 45 | GCstr *str; /* Interned string of identifier/keyword. */ 46 | CType *ct; /* C type table entry. */ 47 | const char *p; /* Current position in input buffer. */ 48 | SBuf sb; /* String buffer for tokens. */ 49 | lua_State *L; /* Lua state. */ 50 | CTState *cts; /* C type state. */ 51 | TValue *param; /* C type parameters. */ 52 | const char *srcname; /* Current source name. */ 53 | BCLine linenumber; /* Input line counter. */ 54 | int depth; /* Recursive declaration depth. */ 55 | uint32_t tmask; /* Type mask for next identifier. */ 56 | uint32_t mode; /* C parser mode. */ 57 | uint8_t packstack[CPARSE_MAX_PACKSTACK]; /* Stack for pack pragmas. */ 58 | uint8_t curpack; /* Current position in pack pragma stack. */ 59 | } CPState; 60 | 61 | LJ_FUNC int lj_cparse(CPState *cp); 62 | 63 | #endif 64 | 65 | #endif 66 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_crecord.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Trace recorder for C data operations. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_CRECORD_H 7 | #define _LJ_CRECORD_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_jit.h" 11 | #include "lj_ffrecord.h" 12 | 13 | #if LJ_HASJIT && LJ_HASFFI 14 | LJ_FUNC void LJ_FASTCALL recff_cdata_index(jit_State *J, RecordFFData *rd); 15 | LJ_FUNC void LJ_FASTCALL recff_cdata_call(jit_State *J, RecordFFData *rd); 16 | LJ_FUNC void LJ_FASTCALL recff_cdata_arith(jit_State *J, RecordFFData *rd); 17 | LJ_FUNC void LJ_FASTCALL recff_clib_index(jit_State *J, RecordFFData *rd); 18 | LJ_FUNC void LJ_FASTCALL recff_ffi_new(jit_State *J, RecordFFData *rd); 19 | LJ_FUNC void LJ_FASTCALL recff_ffi_errno(jit_State *J, RecordFFData *rd); 20 | LJ_FUNC void LJ_FASTCALL recff_ffi_string(jit_State *J, RecordFFData *rd); 21 | LJ_FUNC void LJ_FASTCALL recff_ffi_copy(jit_State *J, RecordFFData *rd); 22 | LJ_FUNC void LJ_FASTCALL recff_ffi_fill(jit_State *J, RecordFFData *rd); 23 | LJ_FUNC void LJ_FASTCALL recff_ffi_typeof(jit_State *J, RecordFFData *rd); 24 | LJ_FUNC void LJ_FASTCALL recff_ffi_istype(jit_State *J, RecordFFData *rd); 25 | LJ_FUNC void LJ_FASTCALL recff_ffi_abi(jit_State *J, RecordFFData *rd); 26 | LJ_FUNC void LJ_FASTCALL recff_ffi_xof(jit_State *J, RecordFFData *rd); 27 | LJ_FUNC void LJ_FASTCALL recff_ffi_gc(jit_State *J, RecordFFData *rd); 28 | 29 | LJ_FUNC void LJ_FASTCALL recff_bit64_tobit(jit_State *J, RecordFFData *rd); 30 | LJ_FUNC int LJ_FASTCALL recff_bit64_unary(jit_State *J, RecordFFData *rd); 31 | LJ_FUNC int LJ_FASTCALL recff_bit64_nary(jit_State *J, RecordFFData *rd); 32 | LJ_FUNC int LJ_FASTCALL recff_bit64_shift(jit_State *J, RecordFFData *rd); 33 | LJ_FUNC TRef recff_bit64_tohex(jit_State *J, RecordFFData *rd, TRef hdr); 34 | 35 | LJ_FUNC void LJ_FASTCALL lj_crecord_tonumber(jit_State *J, RecordFFData *rd); 36 | #endif 37 | 38 | #endif 39 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_debug.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Debugging and introspection. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_DEBUG_H 7 | #define _LJ_DEBUG_H 8 | 9 | #include "lj_obj.h" 10 | 11 | typedef struct lj_Debug { 12 | /* Common fields. Must be in the same order as in lua.h. */ 13 | int event; 14 | const char *name; 15 | const char *namewhat; 16 | const char *what; 17 | const char *source; 18 | int currentline; 19 | int nups; 20 | int linedefined; 21 | int lastlinedefined; 22 | char short_src[LUA_IDSIZE]; 23 | int i_ci; 24 | /* Extended fields. Only valid if lj_debug_getinfo() is called with ext = 1.*/ 25 | int nparams; 26 | int isvararg; 27 | } lj_Debug; 28 | 29 | LJ_FUNC cTValue *lj_debug_frame(lua_State *L, int level, int *size); 30 | LJ_FUNC BCLine LJ_FASTCALL lj_debug_line(GCproto *pt, BCPos pc); 31 | LJ_FUNC const char *lj_debug_uvname(GCproto *pt, uint32_t idx); 32 | LJ_FUNC const char *lj_debug_uvnamev(cTValue *o, uint32_t idx, TValue **tvp); 33 | LJ_FUNC const char *lj_debug_slotname(GCproto *pt, const BCIns *pc, 34 | BCReg slot, const char **name); 35 | LJ_FUNC const char *lj_debug_funcname(lua_State *L, cTValue *frame, 36 | const char **name); 37 | LJ_FUNC void lj_debug_shortname(char *out, GCstr *str, BCLine line); 38 | LJ_FUNC void lj_debug_addloc(lua_State *L, const char *msg, 39 | cTValue *frame, cTValue *nextframe); 40 | LJ_FUNC void lj_debug_pushloc(lua_State *L, GCproto *pt, BCPos pc); 41 | LJ_FUNC int lj_debug_getinfo(lua_State *L, const char *what, lj_Debug *ar, 42 | int ext); 43 | #if LJ_HASPROFILE 44 | LJ_FUNC void lj_debug_dumpstack(lua_State *L, SBuf *sb, const char *fmt, 45 | int depth); 46 | #endif 47 | 48 | /* Fixed internal variable names. */ 49 | #define VARNAMEDEF(_) \ 50 | _(FOR_IDX, "(for index)") \ 51 | _(FOR_STOP, "(for limit)") \ 52 | _(FOR_STEP, "(for step)") \ 53 | _(FOR_GEN, "(for generator)") \ 54 | _(FOR_STATE, "(for state)") \ 55 | _(FOR_CTL, "(for control)") 56 | 57 | enum { 58 | VARNAME_END, 59 | #define VARNAMEENUM(name, str) VARNAME_##name, 60 | VARNAMEDEF(VARNAMEENUM) 61 | #undef VARNAMEENUM 62 | VARNAME__MAX 63 | }; 64 | 65 | #endif 66 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_err.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Error handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_ERR_H 7 | #define _LJ_ERR_H 8 | 9 | #include 10 | 11 | #include "lj_obj.h" 12 | 13 | typedef enum { 14 | #define ERRDEF(name, msg) \ 15 | LJ_ERR_##name, LJ_ERR_##name##_ = LJ_ERR_##name + sizeof(msg)-1, 16 | #include "lj_errmsg.h" 17 | LJ_ERR__MAX 18 | } ErrMsg; 19 | 20 | LJ_DATA const char *lj_err_allmsg; 21 | #define err2msg(em) (lj_err_allmsg+(int)(em)) 22 | 23 | LJ_FUNC GCstr *lj_err_str(lua_State *L, ErrMsg em); 24 | LJ_FUNCA_NORET void LJ_FASTCALL lj_err_throw(lua_State *L, int errcode); 25 | LJ_FUNC_NORET void lj_err_mem(lua_State *L); 26 | LJ_FUNC_NORET void lj_err_run(lua_State *L); 27 | LJ_FUNC_NORET void lj_err_msg(lua_State *L, ErrMsg em); 28 | LJ_FUNC_NORET void lj_err_lex(lua_State *L, GCstr *src, const char *tok, 29 | BCLine line, ErrMsg em, va_list argp); 30 | LJ_FUNC_NORET void lj_err_optype(lua_State *L, cTValue *o, ErrMsg opm); 31 | LJ_FUNC_NORET void lj_err_comp(lua_State *L, cTValue *o1, cTValue *o2); 32 | LJ_FUNC_NORET void lj_err_optype_call(lua_State *L, TValue *o); 33 | LJ_FUNC_NORET void lj_err_callermsg(lua_State *L, const char *msg); 34 | LJ_FUNC_NORET void lj_err_callerv(lua_State *L, ErrMsg em, ...); 35 | LJ_FUNC_NORET void lj_err_caller(lua_State *L, ErrMsg em); 36 | LJ_FUNC_NORET void lj_err_arg(lua_State *L, int narg, ErrMsg em); 37 | LJ_FUNC_NORET void lj_err_argv(lua_State *L, int narg, ErrMsg em, ...); 38 | LJ_FUNC_NORET void lj_err_argtype(lua_State *L, int narg, const char *xname); 39 | LJ_FUNC_NORET void lj_err_argt(lua_State *L, int narg, int tt); 40 | 41 | #endif 42 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_ff.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Fast function IDs. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_FF_H 7 | #define _LJ_FF_H 8 | 9 | /* Fast function ID. */ 10 | typedef enum { 11 | FF_LUA_ = FF_LUA, /* Lua function (must be 0). */ 12 | FF_C_ = FF_C, /* Regular C function (must be 1). */ 13 | #define FFDEF(name) FF_##name, 14 | #include "lj_ffdef.h" 15 | FF__MAX 16 | } FastFunc; 17 | 18 | #endif 19 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_ffrecord.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Fast function call recorder. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_FFRECORD_H 7 | #define _LJ_FFRECORD_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_jit.h" 11 | 12 | #if LJ_HASJIT 13 | /* Data used by handlers to record a fast function. */ 14 | typedef struct RecordFFData { 15 | TValue *argv; /* Runtime argument values. */ 16 | ptrdiff_t nres; /* Number of returned results (defaults to 1). */ 17 | uint32_t data; /* Per-ffid auxiliary data (opcode, literal etc.). */ 18 | } RecordFFData; 19 | 20 | LJ_FUNC int32_t lj_ffrecord_select_mode(jit_State *J, TRef tr, TValue *tv); 21 | LJ_FUNC void lj_ffrecord_func(jit_State *J); 22 | #endif 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_func.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Function handling (prototypes, functions and upvalues). 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_FUNC_H 7 | #define _LJ_FUNC_H 8 | 9 | #include "lj_obj.h" 10 | 11 | /* Prototypes. */ 12 | LJ_FUNC void LJ_FASTCALL lj_func_freeproto(global_State *g, GCproto *pt); 13 | 14 | /* Upvalues. */ 15 | LJ_FUNCA void LJ_FASTCALL lj_func_closeuv(lua_State *L, TValue *level); 16 | LJ_FUNC void LJ_FASTCALL lj_func_freeuv(global_State *g, GCupval *uv); 17 | 18 | /* Functions (closures). */ 19 | LJ_FUNC GCfunc *lj_func_newC(lua_State *L, MSize nelems, GCtab *env); 20 | LJ_FUNC GCfunc *lj_func_newL_empty(lua_State *L, GCproto *pt, GCtab *env); 21 | LJ_FUNCA GCfunc *lj_func_newL_gc(lua_State *L, GCproto *pt, GCfuncL *parent); 22 | LJ_FUNC void LJ_FASTCALL lj_func_free(global_State *g, GCfunc *c); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_gdbjit.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Client for the GDB JIT API. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_GDBJIT_H 7 | #define _LJ_GDBJIT_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_jit.h" 11 | 12 | #if LJ_HASJIT && defined(LUAJIT_USE_GDBJIT) 13 | 14 | LJ_FUNC void lj_gdbjit_addtrace(jit_State *J, GCtrace *T); 15 | LJ_FUNC void lj_gdbjit_deltrace(jit_State *J, GCtrace *T); 16 | 17 | #else 18 | #define lj_gdbjit_addtrace(J, T) UNUSED(T) 19 | #define lj_gdbjit_deltrace(J, T) UNUSED(T) 20 | #endif 21 | 22 | #endif 23 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_lex.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Lexical analyzer. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_LEX_H 7 | #define _LJ_LEX_H 8 | 9 | #include 10 | 11 | #include "lj_obj.h" 12 | #include "lj_err.h" 13 | 14 | /* Lua lexer tokens. */ 15 | #define TKDEF(_, __) \ 16 | _(and) _(break) _(do) _(else) _(elseif) _(end) _(false) \ 17 | _(for) _(function) _(goto) _(if) _(in) _(local) _(nil) _(not) _(or) \ 18 | _(repeat) _(return) _(then) _(true) _(until) _(while) \ 19 | __(concat, ..) __(dots, ...) __(eq, ==) __(ge, >=) __(le, <=) __(ne, ~=) \ 20 | __(label, ::) __(number, ) __(name, ) __(string, ) \ 21 | __(eof, ) 22 | 23 | enum { 24 | TK_OFS = 256, 25 | #define TKENUM1(name) TK_##name, 26 | #define TKENUM2(name, sym) TK_##name, 27 | TKDEF(TKENUM1, TKENUM2) 28 | #undef TKENUM1 29 | #undef TKENUM2 30 | TK_RESERVED = TK_while - TK_OFS 31 | }; 32 | 33 | typedef int LexChar; /* Lexical character. Unsigned ext. from char. */ 34 | typedef int LexToken; /* Lexical token. */ 35 | 36 | /* Combined bytecode ins/line. Only used during bytecode generation. */ 37 | typedef struct BCInsLine { 38 | BCIns ins; /* Bytecode instruction. */ 39 | BCLine line; /* Line number for this bytecode. */ 40 | } BCInsLine; 41 | 42 | /* Info for local variables. Only used during bytecode generation. */ 43 | typedef struct VarInfo { 44 | GCRef name; /* Local variable name or goto/label name. */ 45 | BCPos startpc; /* First point where the local variable is active. */ 46 | BCPos endpc; /* First point where the local variable is dead. */ 47 | uint8_t slot; /* Variable slot. */ 48 | uint8_t info; /* Variable/goto/label info. */ 49 | } VarInfo; 50 | 51 | /* Lua lexer state. */ 52 | typedef struct LexState { 53 | struct FuncState *fs; /* Current FuncState. Defined in lj_parse.c. */ 54 | struct lua_State *L; /* Lua state. */ 55 | TValue tokval; /* Current token value. */ 56 | TValue lookaheadval; /* Lookahead token value. */ 57 | const char *p; /* Current position in input buffer. */ 58 | const char *pe; /* End of input buffer. */ 59 | LexChar c; /* Current character. */ 60 | LexToken tok; /* Current token. */ 61 | LexToken lookahead; /* Lookahead token. */ 62 | SBuf sb; /* String buffer for tokens. */ 63 | lua_Reader rfunc; /* Reader callback. */ 64 | void *rdata; /* Reader callback data. */ 65 | BCLine linenumber; /* Input line counter. */ 66 | BCLine lastline; /* Line of last token. */ 67 | GCstr *chunkname; /* Current chunk name (interned string). */ 68 | const char *chunkarg; /* Chunk name argument. */ 69 | const char *mode; /* Allow loading bytecode (b) and/or source text (t). */ 70 | VarInfo *vstack; /* Stack for names and extents of local variables. */ 71 | MSize sizevstack; /* Size of variable stack. */ 72 | MSize vtop; /* Top of variable stack. */ 73 | BCInsLine *bcstack; /* Stack for bytecode instructions/line numbers. */ 74 | MSize sizebcstack; /* Size of bytecode stack. */ 75 | uint32_t level; /* Syntactical nesting level. */ 76 | } LexState; 77 | 78 | LJ_FUNC int lj_lex_setup(lua_State *L, LexState *ls); 79 | LJ_FUNC void lj_lex_cleanup(lua_State *L, LexState *ls); 80 | LJ_FUNC void lj_lex_next(LexState *ls); 81 | LJ_FUNC LexToken lj_lex_lookahead(LexState *ls); 82 | LJ_FUNC const char *lj_lex_token2str(LexState *ls, LexToken tok); 83 | LJ_FUNC_NORET void lj_lex_error(LexState *ls, LexToken tok, ErrMsg em, ...); 84 | LJ_FUNC void lj_lex_init(lua_State *L); 85 | 86 | #endif 87 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_lib.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Library function support. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_LIB_H 7 | #define _LJ_LIB_H 8 | 9 | #include "lj_obj.h" 10 | 11 | /* 12 | ** A fallback handler is called by the assembler VM if the fast path fails: 13 | ** 14 | ** - too few arguments: unrecoverable. 15 | ** - wrong argument type: recoverable, if coercion succeeds. 16 | ** - bad argument value: unrecoverable. 17 | ** - stack overflow: recoverable, if stack reallocation succeeds. 18 | ** - extra handling: recoverable. 19 | ** 20 | ** The unrecoverable cases throw an error with lj_err_arg(), lj_err_argtype(), 21 | ** lj_err_caller() or lj_err_callermsg(). 22 | ** The recoverable cases return 0 or the number of results + 1. 23 | ** The assembler VM retries the fast path only if 0 is returned. 24 | ** This time the fallback must not be called again or it gets stuck in a loop. 25 | */ 26 | 27 | /* Return values from fallback handler. */ 28 | #define FFH_RETRY 0 29 | #define FFH_UNREACHABLE FFH_RETRY 30 | #define FFH_RES(n) ((n)+1) 31 | #define FFH_TAILCALL (-1) 32 | 33 | LJ_FUNC TValue *lj_lib_checkany(lua_State *L, int narg); 34 | LJ_FUNC GCstr *lj_lib_checkstr(lua_State *L, int narg); 35 | LJ_FUNC GCstr *lj_lib_optstr(lua_State *L, int narg); 36 | #if LJ_DUALNUM 37 | LJ_FUNC void lj_lib_checknumber(lua_State *L, int narg); 38 | #else 39 | #define lj_lib_checknumber(L, narg) lj_lib_checknum((L), (narg)) 40 | #endif 41 | LJ_FUNC lua_Number lj_lib_checknum(lua_State *L, int narg); 42 | LJ_FUNC int32_t lj_lib_checkint(lua_State *L, int narg); 43 | LJ_FUNC int32_t lj_lib_optint(lua_State *L, int narg, int32_t def); 44 | LJ_FUNC GCfunc *lj_lib_checkfunc(lua_State *L, int narg); 45 | LJ_FUNC GCtab *lj_lib_checktab(lua_State *L, int narg); 46 | LJ_FUNC GCtab *lj_lib_checktabornil(lua_State *L, int narg); 47 | LJ_FUNC int lj_lib_checkopt(lua_State *L, int narg, int def, const char *lst); 48 | 49 | /* Avoid including lj_frame.h. */ 50 | #if LJ_GC64 51 | #define lj_lib_upvalue(L, n) \ 52 | (&gcval(L->base-2)->fn.c.upvalue[(n)-1]) 53 | #elif LJ_FR2 54 | #define lj_lib_upvalue(L, n) \ 55 | (&gcref((L->base-2)->gcr)->fn.c.upvalue[(n)-1]) 56 | #else 57 | #define lj_lib_upvalue(L, n) \ 58 | (&gcref((L->base-1)->fr.func)->fn.c.upvalue[(n)-1]) 59 | #endif 60 | 61 | #if LJ_TARGET_WINDOWS 62 | #define lj_lib_checkfpu(L) \ 63 | do { setnumV(L->top++, (lua_Number)1437217655); \ 64 | if (lua_tointeger(L, -1) != 1437217655) lj_err_caller(L, LJ_ERR_BADFPU); \ 65 | L->top--; } while (0) 66 | #else 67 | #define lj_lib_checkfpu(L) UNUSED(L) 68 | #endif 69 | 70 | LJ_FUNC GCfunc *lj_lib_pushcc(lua_State *L, lua_CFunction f, int id, int n); 71 | #define lj_lib_pushcf(L, fn, id) (lj_lib_pushcc(L, (fn), (id), 0)) 72 | 73 | /* Library function declarations. Scanned by buildvm. */ 74 | #define LJLIB_CF(name) static int lj_cf_##name(lua_State *L) 75 | #define LJLIB_ASM(name) static int lj_ffh_##name(lua_State *L) 76 | #define LJLIB_ASM_(name) 77 | #define LJLIB_LUA(name) 78 | #define LJLIB_SET(name) 79 | #define LJLIB_PUSH(arg) 80 | #define LJLIB_REC(handler) 81 | #define LJLIB_NOREGUV 82 | #define LJLIB_NOREG 83 | 84 | #define LJ_LIB_REG(L, regname, name) \ 85 | lj_lib_register(L, regname, lj_lib_init_##name, lj_lib_cf_##name) 86 | 87 | LJ_FUNC void lj_lib_register(lua_State *L, const char *libname, 88 | const uint8_t *init, const lua_CFunction *cf); 89 | LJ_FUNC void lj_lib_prereg(lua_State *L, const char *name, lua_CFunction f, 90 | GCtab *env); 91 | LJ_FUNC int lj_lib_postreg(lua_State *L, lua_CFunction cf, int id, 92 | const char *name); 93 | 94 | /* Library init data tags. */ 95 | #define LIBINIT_LENMASK 0x3f 96 | #define LIBINIT_TAGMASK 0xc0 97 | #define LIBINIT_CF 0x00 98 | #define LIBINIT_ASM 0x40 99 | #define LIBINIT_ASM_ 0x80 100 | #define LIBINIT_STRING 0xc0 101 | #define LIBINIT_MAXSTR 0x38 102 | #define LIBINIT_LUA 0xf9 103 | #define LIBINIT_SET 0xfa 104 | #define LIBINIT_NUMBER 0xfb 105 | #define LIBINIT_COPY 0xfc 106 | #define LIBINIT_LASTCL 0xfd 107 | #define LIBINIT_FFID 0xfe 108 | #define LIBINIT_END 0xff 109 | 110 | /* Exported library functions. */ 111 | 112 | typedef struct RandomState RandomState; 113 | LJ_FUNC uint64_t LJ_FASTCALL lj_math_random_step(RandomState *rs); 114 | 115 | #endif 116 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_load.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** Load and dump code. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #include 7 | #include 8 | 9 | #define lj_load_c 10 | #define LUA_CORE 11 | 12 | #include "lua.h" 13 | #include "lauxlib.h" 14 | 15 | #include "lj_obj.h" 16 | #include "lj_gc.h" 17 | #include "lj_err.h" 18 | #include "lj_buf.h" 19 | #include "lj_func.h" 20 | #include "lj_frame.h" 21 | #include "lj_vm.h" 22 | #include "lj_lex.h" 23 | #include "lj_bcdump.h" 24 | #include "lj_parse.h" 25 | 26 | /* -- Load Lua source code and bytecode ----------------------------------- */ 27 | 28 | static TValue *cpparser(lua_State *L, lua_CFunction dummy, void *ud) 29 | { 30 | LexState *ls = (LexState *)ud; 31 | GCproto *pt; 32 | GCfunc *fn; 33 | int bc; 34 | UNUSED(dummy); 35 | cframe_errfunc(L->cframe) = -1; /* Inherit error function. */ 36 | bc = lj_lex_setup(L, ls); 37 | if (ls->mode && !strchr(ls->mode, bc ? 'b' : 't')) { 38 | setstrV(L, L->top++, lj_err_str(L, LJ_ERR_XMODE)); 39 | lj_err_throw(L, LUA_ERRSYNTAX); 40 | } 41 | pt = bc ? lj_bcread(ls) : lj_parse(ls); 42 | fn = lj_func_newL_empty(L, pt, tabref(L->env)); 43 | /* Don't combine above/below into one statement. */ 44 | setfuncV(L, L->top++, fn); 45 | return NULL; 46 | } 47 | 48 | LUA_API int lua_loadx(lua_State *L, lua_Reader reader, void *data, 49 | const char *chunkname, const char *mode) 50 | { 51 | LexState ls; 52 | int status; 53 | ls.rfunc = reader; 54 | ls.rdata = data; 55 | ls.chunkarg = chunkname ? chunkname : "?"; 56 | ls.mode = mode; 57 | lj_buf_init(L, &ls.sb); 58 | status = lj_vm_cpcall(L, NULL, &ls, cpparser); 59 | lj_lex_cleanup(L, &ls); 60 | lj_gc_check(L); 61 | return status; 62 | } 63 | 64 | LUA_API int lua_load(lua_State *L, lua_Reader reader, void *data, 65 | const char *chunkname) 66 | { 67 | return lua_loadx(L, reader, data, chunkname, NULL); 68 | } 69 | 70 | typedef struct FileReaderCtx { 71 | FILE *fp; 72 | char buf[LUAL_BUFFERSIZE]; 73 | } FileReaderCtx; 74 | 75 | static const char *reader_file(lua_State *L, void *ud, size_t *size) 76 | { 77 | FileReaderCtx *ctx = (FileReaderCtx *)ud; 78 | UNUSED(L); 79 | if (feof(ctx->fp)) return NULL; 80 | *size = fread(ctx->buf, 1, sizeof(ctx->buf), ctx->fp); 81 | return *size > 0 ? ctx->buf : NULL; 82 | } 83 | 84 | LUALIB_API int luaL_loadfilex(lua_State *L, const char *filename, 85 | const char *mode) 86 | { 87 | FileReaderCtx ctx; 88 | int status; 89 | const char *chunkname; 90 | if (filename) { 91 | ctx.fp = fopen(filename, "rb"); 92 | if (ctx.fp == NULL) { 93 | lua_pushfstring(L, "cannot open %s: %s", filename, strerror(errno)); 94 | return LUA_ERRFILE; 95 | } 96 | chunkname = lua_pushfstring(L, "@%s", filename); 97 | } else { 98 | ctx.fp = stdin; 99 | chunkname = "=stdin"; 100 | } 101 | status = lua_loadx(L, reader_file, &ctx, chunkname, mode); 102 | if (ferror(ctx.fp)) { 103 | L->top -= filename ? 2 : 1; 104 | lua_pushfstring(L, "cannot read %s: %s", chunkname+1, strerror(errno)); 105 | if (filename) 106 | fclose(ctx.fp); 107 | return LUA_ERRFILE; 108 | } 109 | if (filename) { 110 | L->top--; 111 | copyTV(L, L->top-1, L->top); 112 | fclose(ctx.fp); 113 | } 114 | return status; 115 | } 116 | 117 | LUALIB_API int luaL_loadfile(lua_State *L, const char *filename) 118 | { 119 | return luaL_loadfilex(L, filename, NULL); 120 | } 121 | 122 | typedef struct StringReaderCtx { 123 | const char *str; 124 | size_t size; 125 | } StringReaderCtx; 126 | 127 | static const char *reader_string(lua_State *L, void *ud, size_t *size) 128 | { 129 | StringReaderCtx *ctx = (StringReaderCtx *)ud; 130 | UNUSED(L); 131 | if (ctx->size == 0) return NULL; 132 | *size = ctx->size; 133 | ctx->size = 0; 134 | return ctx->str; 135 | } 136 | 137 | LUALIB_API int luaL_loadbufferx(lua_State *L, const char *buf, size_t size, 138 | const char *name, const char *mode) 139 | { 140 | StringReaderCtx ctx; 141 | ctx.str = buf; 142 | ctx.size = size; 143 | return lua_loadx(L, reader_string, &ctx, name, mode); 144 | } 145 | 146 | LUALIB_API int luaL_loadbuffer(lua_State *L, const char *buf, size_t size, 147 | const char *name) 148 | { 149 | return luaL_loadbufferx(L, buf, size, name, NULL); 150 | } 151 | 152 | LUALIB_API int luaL_loadstring(lua_State *L, const char *s) 153 | { 154 | return luaL_loadbuffer(L, s, strlen(s), s); 155 | } 156 | 157 | /* -- Dump bytecode ------------------------------------------------------- */ 158 | 159 | LUA_API int lua_dump(lua_State *L, lua_Writer writer, void *data) 160 | { 161 | cTValue *o = L->top-1; 162 | api_check(L, L->top > L->base); 163 | if (tvisfunc(o) && isluafunc(funcV(o))) 164 | return lj_bcwrite(L, funcproto(funcV(o)), writer, data, 0); 165 | else 166 | return 1; 167 | } 168 | 169 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_mcode.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Machine code management. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_MCODE_H 7 | #define _LJ_MCODE_H 8 | 9 | #include "lj_obj.h" 10 | 11 | #if LJ_HASJIT || LJ_HASFFI 12 | LJ_FUNC void lj_mcode_sync(void *start, void *end); 13 | #endif 14 | 15 | #if LJ_HASJIT 16 | 17 | #include "lj_jit.h" 18 | 19 | LJ_FUNC void lj_mcode_free(jit_State *J); 20 | LJ_FUNC MCode *lj_mcode_reserve(jit_State *J, MCode **lim); 21 | LJ_FUNC void lj_mcode_commit(jit_State *J, MCode *m); 22 | LJ_FUNC void lj_mcode_abort(jit_State *J); 23 | LJ_FUNC MCode *lj_mcode_patch(jit_State *J, MCode *ptr, int finish); 24 | LJ_FUNC_NORET void lj_mcode_limiterr(jit_State *J, size_t need); 25 | 26 | #define lj_mcode_commitbot(J, m) (J->mcbot = (m)) 27 | 28 | #endif 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_meta.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Metamethod handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_META_H 7 | #define _LJ_META_H 8 | 9 | #include "lj_obj.h" 10 | 11 | /* Metamethod handling */ 12 | LJ_FUNC void lj_meta_init(lua_State *L); 13 | LJ_FUNC cTValue *lj_meta_cache(GCtab *mt, MMS mm, GCstr *name); 14 | LJ_FUNC cTValue *lj_meta_lookup(lua_State *L, cTValue *o, MMS mm); 15 | #if LJ_HASFFI 16 | LJ_FUNC int lj_meta_tailcall(lua_State *L, cTValue *tv); 17 | #endif 18 | 19 | #define lj_meta_fastg(g, mt, mm) \ 20 | ((mt) == NULL ? NULL : ((mt)->nomm & (1u<<(mm))) ? NULL : \ 21 | lj_meta_cache(mt, mm, mmname_str(g, mm))) 22 | #define lj_meta_fast(L, mt, mm) lj_meta_fastg(G(L), mt, mm) 23 | 24 | /* C helpers for some instructions, called from assembler VM. */ 25 | LJ_FUNCA cTValue *lj_meta_tget(lua_State *L, cTValue *o, cTValue *k); 26 | LJ_FUNCA TValue *lj_meta_tset(lua_State *L, cTValue *o, cTValue *k); 27 | LJ_FUNCA TValue *lj_meta_arith(lua_State *L, TValue *ra, cTValue *rb, 28 | cTValue *rc, BCReg op); 29 | LJ_FUNCA TValue *lj_meta_cat(lua_State *L, TValue *top, int left); 30 | LJ_FUNCA TValue * LJ_FASTCALL lj_meta_len(lua_State *L, cTValue *o); 31 | LJ_FUNCA TValue *lj_meta_equal(lua_State *L, GCobj *o1, GCobj *o2, int ne); 32 | LJ_FUNCA TValue * LJ_FASTCALL lj_meta_equal_cd(lua_State *L, BCIns ins); 33 | LJ_FUNCA TValue *lj_meta_comp(lua_State *L, cTValue *o1, cTValue *o2, int op); 34 | LJ_FUNCA void lj_meta_istype(lua_State *L, BCReg ra, BCReg tp); 35 | LJ_FUNCA void lj_meta_call(lua_State *L, TValue *func, TValue *top); 36 | LJ_FUNCA void LJ_FASTCALL lj_meta_for(lua_State *L, TValue *o); 37 | 38 | #endif 39 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_obj.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** Miscellaneous object handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #define lj_obj_c 7 | #define LUA_CORE 8 | 9 | #include "lj_obj.h" 10 | 11 | /* Object type names. */ 12 | LJ_DATADEF const char *const lj_obj_typename[] = { /* ORDER LUA_T */ 13 | "no value", "nil", "boolean", "userdata", "number", "string", 14 | "table", "function", "userdata", "thread", "proto", "cdata" 15 | }; 16 | 17 | LJ_DATADEF const char *const lj_obj_itypename[] = { /* ORDER LJ_T */ 18 | "nil", "boolean", "boolean", "userdata", "string", "upval", "thread", 19 | "proto", "function", "trace", "cdata", "table", "userdata", "number" 20 | }; 21 | 22 | /* Compare two objects without calling metamethods. */ 23 | int LJ_FASTCALL lj_obj_equal(cTValue *o1, cTValue *o2) 24 | { 25 | if (itype(o1) == itype(o2)) { 26 | if (tvispri(o1)) 27 | return 1; 28 | if (!tvisnum(o1)) 29 | return gcrefeq(o1->gcr, o2->gcr); 30 | } else if (!tvisnumber(o1) || !tvisnumber(o2)) { 31 | return 0; 32 | } 33 | return numberVnum(o1) == numberVnum(o2); 34 | } 35 | 36 | /* Return pointer to object or its object data. */ 37 | const void * LJ_FASTCALL lj_obj_ptr(cTValue *o) 38 | { 39 | if (tvisudata(o)) 40 | return uddata(udataV(o)); 41 | else if (tvislightud(o)) 42 | return lightudV(o); 43 | else if (LJ_HASFFI && tviscdata(o)) 44 | return cdataptr(cdataV(o)); 45 | else if (tvisgcv(o)) 46 | return gcV(o); 47 | else 48 | return NULL; 49 | } 50 | 51 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_opt_dce.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** DCE: Dead Code Elimination. Pre-LOOP only -- ASM already performs DCE. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #define lj_opt_dce_c 7 | #define LUA_CORE 8 | 9 | #include "lj_obj.h" 10 | 11 | #if LJ_HASJIT 12 | 13 | #include "lj_ir.h" 14 | #include "lj_jit.h" 15 | #include "lj_iropt.h" 16 | 17 | /* Some local macros to save typing. Undef'd at the end. */ 18 | #define IR(ref) (&J->cur.ir[(ref)]) 19 | 20 | /* Scan through all snapshots and mark all referenced instructions. */ 21 | static void dce_marksnap(jit_State *J) 22 | { 23 | SnapNo i, nsnap = J->cur.nsnap; 24 | for (i = 0; i < nsnap; i++) { 25 | SnapShot *snap = &J->cur.snap[i]; 26 | SnapEntry *map = &J->cur.snapmap[snap->mapofs]; 27 | MSize n, nent = snap->nent; 28 | for (n = 0; n < nent; n++) { 29 | IRRef ref = snap_ref(map[n]); 30 | if (ref >= REF_FIRST) 31 | irt_setmark(IR(ref)->t); 32 | } 33 | } 34 | } 35 | 36 | /* Backwards propagate marks. Replace unused instructions with NOPs. */ 37 | static void dce_propagate(jit_State *J) 38 | { 39 | IRRef1 *pchain[IR__MAX]; 40 | IRRef ins; 41 | uint32_t i; 42 | for (i = 0; i < IR__MAX; i++) pchain[i] = &J->chain[i]; 43 | for (ins = J->cur.nins-1; ins >= REF_FIRST; ins--) { 44 | IRIns *ir = IR(ins); 45 | if (irt_ismarked(ir->t)) { 46 | irt_clearmark(ir->t); 47 | pchain[ir->o] = &ir->prev; 48 | } else if (!ir_sideeff(ir)) { 49 | *pchain[ir->o] = ir->prev; /* Reroute original instruction chain. */ 50 | ir->t.irt = IRT_NIL; 51 | ir->o = IR_NOP; /* Replace instruction with NOP. */ 52 | ir->op1 = ir->op2 = 0; 53 | ir->prev = 0; 54 | continue; 55 | } 56 | if (ir->op1 >= REF_FIRST) irt_setmark(IR(ir->op1)->t); 57 | if (ir->op2 >= REF_FIRST) irt_setmark(IR(ir->op2)->t); 58 | } 59 | } 60 | 61 | /* Dead Code Elimination. 62 | ** 63 | ** First backpropagate marks for all used instructions. Then replace 64 | ** the unused ones with a NOP. Note that compressing the IR to eliminate 65 | ** the NOPs does not pay off. 66 | */ 67 | void lj_opt_dce(jit_State *J) 68 | { 69 | if ((J->flags & JIT_F_OPT_DCE)) { 70 | dce_marksnap(J); 71 | dce_propagate(J); 72 | memset(J->bpropcache, 0, sizeof(J->bpropcache)); /* Invalidate cache. */ 73 | } 74 | } 75 | 76 | #undef IR 77 | 78 | #endif 79 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_parse.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Lua parser (source code -> bytecode). 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_PARSE_H 7 | #define _LJ_PARSE_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_lex.h" 11 | 12 | LJ_FUNC GCproto *lj_parse(LexState *ls); 13 | LJ_FUNC GCstr *lj_parse_keepstr(LexState *ls, const char *str, size_t l); 14 | #if LJ_HASFFI 15 | LJ_FUNC void lj_parse_keepcdata(LexState *ls, TValue *tv, GCcdata *cd); 16 | #endif 17 | 18 | #endif 19 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_profile.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Low-overhead profiling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_PROFILE_H 7 | #define _LJ_PROFILE_H 8 | 9 | #include "lj_obj.h" 10 | 11 | #if LJ_HASPROFILE 12 | 13 | LJ_FUNC void LJ_FASTCALL lj_profile_interpreter(lua_State *L); 14 | #if !LJ_PROFILE_SIGPROF 15 | LJ_FUNC void LJ_FASTCALL lj_profile_hook_enter(global_State *g); 16 | LJ_FUNC void LJ_FASTCALL lj_profile_hook_leave(global_State *g); 17 | #endif 18 | 19 | #endif 20 | 21 | #endif 22 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_record.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Trace recorder (bytecode -> SSA IR). 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_RECORD_H 7 | #define _LJ_RECORD_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_jit.h" 11 | 12 | #if LJ_HASJIT 13 | /* Context for recording an indexed load/store. */ 14 | typedef struct RecordIndex { 15 | TValue tabv; /* Runtime value of table (or indexed object). */ 16 | TValue keyv; /* Runtime value of key. */ 17 | TValue valv; /* Runtime value of stored value. */ 18 | TValue mobjv; /* Runtime value of metamethod object. */ 19 | GCtab *mtv; /* Runtime value of metatable object. */ 20 | cTValue *oldv; /* Runtime value of previously stored value. */ 21 | TRef tab; /* Table (or indexed object) reference. */ 22 | TRef key; /* Key reference. */ 23 | TRef val; /* Value reference for a store or 0 for a load. */ 24 | TRef mt; /* Metatable reference. */ 25 | TRef mobj; /* Metamethod object reference. */ 26 | int idxchain; /* Index indirections left or 0 for raw lookup. */ 27 | } RecordIndex; 28 | 29 | LJ_FUNC int lj_record_objcmp(jit_State *J, TRef a, TRef b, 30 | cTValue *av, cTValue *bv); 31 | LJ_FUNC void lj_record_stop(jit_State *J, TraceLink linktype, TraceNo lnk); 32 | LJ_FUNC TRef lj_record_constify(jit_State *J, cTValue *o); 33 | 34 | LJ_FUNC void lj_record_call(jit_State *J, BCReg func, ptrdiff_t nargs); 35 | LJ_FUNC void lj_record_tailcall(jit_State *J, BCReg func, ptrdiff_t nargs); 36 | LJ_FUNC void lj_record_ret(jit_State *J, BCReg rbase, ptrdiff_t gotresults); 37 | 38 | LJ_FUNC int lj_record_mm_lookup(jit_State *J, RecordIndex *ix, MMS mm); 39 | LJ_FUNC TRef lj_record_idx(jit_State *J, RecordIndex *ix); 40 | 41 | LJ_FUNC void lj_record_ins(jit_State *J); 42 | LJ_FUNC void lj_record_setup(jit_State *J); 43 | #endif 44 | 45 | #endif 46 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_snap.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Snapshot handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_SNAP_H 7 | #define _LJ_SNAP_H 8 | 9 | #include "lj_obj.h" 10 | #include "lj_jit.h" 11 | 12 | #if LJ_HASJIT 13 | LJ_FUNC void lj_snap_add(jit_State *J); 14 | LJ_FUNC void lj_snap_purge(jit_State *J); 15 | LJ_FUNC void lj_snap_shrink(jit_State *J); 16 | LJ_FUNC IRIns *lj_snap_regspmap(GCtrace *T, SnapNo snapno, IRIns *ir); 17 | LJ_FUNC void lj_snap_replay(jit_State *J, GCtrace *T); 18 | LJ_FUNC const BCIns *lj_snap_restore(jit_State *J, void *exptr); 19 | LJ_FUNC void lj_snap_grow_buf_(jit_State *J, MSize need); 20 | LJ_FUNC void lj_snap_grow_map_(jit_State *J, MSize need); 21 | 22 | static LJ_AINLINE void lj_snap_grow_buf(jit_State *J, MSize need) 23 | { 24 | if (LJ_UNLIKELY(need > J->sizesnap)) lj_snap_grow_buf_(J, need); 25 | } 26 | 27 | static LJ_AINLINE void lj_snap_grow_map(jit_State *J, MSize need) 28 | { 29 | if (LJ_UNLIKELY(need > J->sizesnapmap)) lj_snap_grow_map_(J, need); 30 | } 31 | 32 | #endif 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_state.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** State and stack handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_STATE_H 7 | #define _LJ_STATE_H 8 | 9 | #include "lj_obj.h" 10 | 11 | #define incr_top(L) \ 12 | (++L->top >= tvref(L->maxstack) && (lj_state_growstack1(L), 0)) 13 | 14 | #define savestack(L, p) ((char *)(p) - mref(L->stack, char)) 15 | #define restorestack(L, n) ((TValue *)(mref(L->stack, char) + (n))) 16 | 17 | LJ_FUNC void lj_state_relimitstack(lua_State *L); 18 | LJ_FUNC void lj_state_shrinkstack(lua_State *L, MSize used); 19 | LJ_FUNCA void LJ_FASTCALL lj_state_growstack(lua_State *L, MSize need); 20 | LJ_FUNC void LJ_FASTCALL lj_state_growstack1(lua_State *L); 21 | 22 | static LJ_AINLINE void lj_state_checkstack(lua_State *L, MSize need) 23 | { 24 | if ((mref(L->maxstack, char) - (char *)L->top) <= 25 | (ptrdiff_t)need*(ptrdiff_t)sizeof(TValue)) 26 | lj_state_growstack(L, need); 27 | } 28 | 29 | LJ_FUNC lua_State *lj_state_new(lua_State *L); 30 | LJ_FUNC void LJ_FASTCALL lj_state_free(global_State *g, lua_State *L); 31 | #if LJ_64 && !LJ_GC64 && !(defined(LUAJIT_USE_VALGRIND) && defined(LUAJIT_USE_SYSMALLOC)) 32 | LJ_FUNC lua_State *lj_state_newstate(lua_Alloc f, void *ud); 33 | #endif 34 | 35 | #endif 36 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_str.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** String handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_STR_H 7 | #define _LJ_STR_H 8 | 9 | #include 10 | 11 | #include "lj_obj.h" 12 | 13 | /* String helpers. */ 14 | LJ_FUNC int32_t LJ_FASTCALL lj_str_cmp(GCstr *a, GCstr *b); 15 | LJ_FUNC const char *lj_str_find(const char *s, const char *f, 16 | MSize slen, MSize flen); 17 | LJ_FUNC int lj_str_haspattern(GCstr *s); 18 | 19 | /* String interning. */ 20 | LJ_FUNC void lj_str_resize(lua_State *L, MSize newmask); 21 | LJ_FUNCA GCstr *lj_str_new(lua_State *L, const char *str, size_t len); 22 | LJ_FUNC void LJ_FASTCALL lj_str_free(global_State *g, GCstr *s); 23 | 24 | #define lj_str_newz(L, s) (lj_str_new(L, s, strlen(s))) 25 | #define lj_str_newlit(L, s) (lj_str_new(L, "" s, sizeof(s)-1)) 26 | 27 | #endif 28 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_strfmt.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** String formatting. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_STRFMT_H 7 | #define _LJ_STRFMT_H 8 | 9 | #include "lj_obj.h" 10 | 11 | typedef uint32_t SFormat; /* Format indicator. */ 12 | 13 | /* Format parser state. */ 14 | typedef struct FormatState { 15 | const uint8_t *p; /* Current format string pointer. */ 16 | const uint8_t *e; /* End of format string. */ 17 | const char *str; /* Returned literal string. */ 18 | MSize len; /* Size of literal string. */ 19 | } FormatState; 20 | 21 | /* Format types (max. 16). */ 22 | typedef enum FormatType { 23 | STRFMT_EOF, STRFMT_ERR, STRFMT_LIT, 24 | STRFMT_INT, STRFMT_UINT, STRFMT_NUM, STRFMT_STR, STRFMT_CHAR, STRFMT_PTR 25 | } FormatType; 26 | 27 | /* Format subtypes (bits are reused). */ 28 | #define STRFMT_T_HEX 0x0010 /* STRFMT_UINT */ 29 | #define STRFMT_T_OCT 0x0020 /* STRFMT_UINT */ 30 | #define STRFMT_T_FP_A 0x0000 /* STRFMT_NUM */ 31 | #define STRFMT_T_FP_E 0x0010 /* STRFMT_NUM */ 32 | #define STRFMT_T_FP_F 0x0020 /* STRFMT_NUM */ 33 | #define STRFMT_T_FP_G 0x0030 /* STRFMT_NUM */ 34 | #define STRFMT_T_QUOTED 0x0010 /* STRFMT_STR */ 35 | 36 | /* Format flags. */ 37 | #define STRFMT_F_LEFT 0x0100 38 | #define STRFMT_F_PLUS 0x0200 39 | #define STRFMT_F_ZERO 0x0400 40 | #define STRFMT_F_SPACE 0x0800 41 | #define STRFMT_F_ALT 0x1000 42 | #define STRFMT_F_UPPER 0x2000 43 | 44 | /* Format indicator fields. */ 45 | #define STRFMT_SH_WIDTH 16 46 | #define STRFMT_SH_PREC 24 47 | 48 | #define STRFMT_TYPE(sf) ((FormatType)((sf) & 15)) 49 | #define STRFMT_WIDTH(sf) (((sf) >> STRFMT_SH_WIDTH) & 255u) 50 | #define STRFMT_PREC(sf) ((((sf) >> STRFMT_SH_PREC) & 255u) - 1u) 51 | #define STRFMT_FP(sf) (((sf) >> 4) & 3) 52 | 53 | /* Formats for conversion characters. */ 54 | #define STRFMT_A (STRFMT_NUM|STRFMT_T_FP_A) 55 | #define STRFMT_C (STRFMT_CHAR) 56 | #define STRFMT_D (STRFMT_INT) 57 | #define STRFMT_E (STRFMT_NUM|STRFMT_T_FP_E) 58 | #define STRFMT_F (STRFMT_NUM|STRFMT_T_FP_F) 59 | #define STRFMT_G (STRFMT_NUM|STRFMT_T_FP_G) 60 | #define STRFMT_I STRFMT_D 61 | #define STRFMT_O (STRFMT_UINT|STRFMT_T_OCT) 62 | #define STRFMT_P (STRFMT_PTR) 63 | #define STRFMT_Q (STRFMT_STR|STRFMT_T_QUOTED) 64 | #define STRFMT_S (STRFMT_STR) 65 | #define STRFMT_U (STRFMT_UINT) 66 | #define STRFMT_X (STRFMT_UINT|STRFMT_T_HEX) 67 | #define STRFMT_G14 (STRFMT_G | ((14+1) << STRFMT_SH_PREC)) 68 | 69 | /* Maximum buffer sizes for conversions. */ 70 | #define STRFMT_MAXBUF_XINT (1+22) /* '0' prefix + uint64_t in octal. */ 71 | #define STRFMT_MAXBUF_INT (1+10) /* Sign + int32_t in decimal. */ 72 | #define STRFMT_MAXBUF_NUM 32 /* Must correspond with STRFMT_G14. */ 73 | #define STRFMT_MAXBUF_PTR (2+2*sizeof(ptrdiff_t)) /* "0x" + hex ptr. */ 74 | 75 | /* Format parser. */ 76 | LJ_FUNC SFormat LJ_FASTCALL lj_strfmt_parse(FormatState *fs); 77 | 78 | static LJ_AINLINE void lj_strfmt_init(FormatState *fs, const char *p, MSize len) 79 | { 80 | fs->p = (const uint8_t *)p; 81 | fs->e = (const uint8_t *)p + len; 82 | lua_assert(*fs->e == 0); /* Must be NUL-terminated (may have NULs inside). */ 83 | } 84 | 85 | /* Raw conversions. */ 86 | LJ_FUNC char * LJ_FASTCALL lj_strfmt_wint(char *p, int32_t k); 87 | LJ_FUNC char * LJ_FASTCALL lj_strfmt_wptr(char *p, const void *v); 88 | LJ_FUNC char * LJ_FASTCALL lj_strfmt_wuleb128(char *p, uint32_t v); 89 | LJ_FUNC const char *lj_strfmt_wstrnum(lua_State *L, cTValue *o, MSize *lenp); 90 | 91 | /* Unformatted conversions to buffer. */ 92 | LJ_FUNC SBuf * LJ_FASTCALL lj_strfmt_putint(SBuf *sb, int32_t k); 93 | #if LJ_HASJIT 94 | LJ_FUNC SBuf * LJ_FASTCALL lj_strfmt_putnum(SBuf *sb, cTValue *o); 95 | #endif 96 | LJ_FUNC SBuf * LJ_FASTCALL lj_strfmt_putptr(SBuf *sb, const void *v); 97 | LJ_FUNC SBuf * LJ_FASTCALL lj_strfmt_putquoted(SBuf *sb, GCstr *str); 98 | 99 | /* Formatted conversions to buffer. */ 100 | LJ_FUNC SBuf *lj_strfmt_putfxint(SBuf *sb, SFormat sf, uint64_t k); 101 | LJ_FUNC SBuf *lj_strfmt_putfnum_int(SBuf *sb, SFormat sf, lua_Number n); 102 | LJ_FUNC SBuf *lj_strfmt_putfnum_uint(SBuf *sb, SFormat sf, lua_Number n); 103 | LJ_FUNC SBuf *lj_strfmt_putfnum(SBuf *sb, SFormat, lua_Number n); 104 | LJ_FUNC SBuf *lj_strfmt_putfchar(SBuf *sb, SFormat, int32_t c); 105 | LJ_FUNC SBuf *lj_strfmt_putfstr(SBuf *sb, SFormat, GCstr *str); 106 | 107 | /* Conversions to strings. */ 108 | LJ_FUNC GCstr * LJ_FASTCALL lj_strfmt_int(lua_State *L, int32_t k); 109 | LJ_FUNCA GCstr * LJ_FASTCALL lj_strfmt_num(lua_State *L, cTValue *o); 110 | LJ_FUNCA GCstr * LJ_FASTCALL lj_strfmt_number(lua_State *L, cTValue *o); 111 | #if LJ_HASJIT 112 | LJ_FUNC GCstr * LJ_FASTCALL lj_strfmt_char(lua_State *L, int c); 113 | #endif 114 | LJ_FUNC GCstr * LJ_FASTCALL lj_strfmt_obj(lua_State *L, cTValue *o); 115 | 116 | /* Internal string formatting. */ 117 | LJ_FUNC const char *lj_strfmt_pushvf(lua_State *L, const char *fmt, 118 | va_list argp); 119 | LJ_FUNC const char *lj_strfmt_pushf(lua_State *L, const char *fmt, ...) 120 | #ifdef __GNUC__ 121 | __attribute__ ((format (printf, 2, 3))) 122 | #endif 123 | ; 124 | 125 | #endif 126 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_strscan.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** String scanning. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_STRSCAN_H 7 | #define _LJ_STRSCAN_H 8 | 9 | #include "lj_obj.h" 10 | 11 | /* Options for accepted/returned formats. */ 12 | #define STRSCAN_OPT_TOINT 0x01 /* Convert to int32_t, if possible. */ 13 | #define STRSCAN_OPT_TONUM 0x02 /* Always convert to double. */ 14 | #define STRSCAN_OPT_IMAG 0x04 15 | #define STRSCAN_OPT_LL 0x08 16 | #define STRSCAN_OPT_C 0x10 17 | 18 | /* Returned format. */ 19 | typedef enum { 20 | STRSCAN_ERROR, 21 | STRSCAN_NUM, STRSCAN_IMAG, 22 | STRSCAN_INT, STRSCAN_U32, STRSCAN_I64, STRSCAN_U64, 23 | } StrScanFmt; 24 | 25 | LJ_FUNC StrScanFmt lj_strscan_scan(const uint8_t *p, TValue *o, uint32_t opt); 26 | LJ_FUNC int LJ_FASTCALL lj_strscan_num(GCstr *str, TValue *o); 27 | #if LJ_DUALNUM 28 | LJ_FUNC int LJ_FASTCALL lj_strscan_number(GCstr *str, TValue *o); 29 | #else 30 | #define lj_strscan_number(s, o) lj_strscan_num((s), (o)) 31 | #endif 32 | 33 | /* Check for number or convert string to number/int in-place (!). */ 34 | static LJ_AINLINE int lj_strscan_numberobj(TValue *o) 35 | { 36 | return tvisnumber(o) || (tvisstr(o) && lj_strscan_number(strV(o), o)); 37 | } 38 | 39 | #endif 40 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_tab.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Table handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_TAB_H 7 | #define _LJ_TAB_H 8 | 9 | #include "lj_obj.h" 10 | 11 | /* Hash constants. Tuned using a brute force search. */ 12 | #define HASH_BIAS (-0x04c11db7) 13 | #define HASH_ROT1 14 14 | #define HASH_ROT2 5 15 | #define HASH_ROT3 13 16 | 17 | /* Scramble the bits of numbers and pointers. */ 18 | static LJ_AINLINE uint32_t hashrot(uint32_t lo, uint32_t hi) 19 | { 20 | #if LJ_TARGET_X86ORX64 21 | /* Prefer variant that compiles well for a 2-operand CPU. */ 22 | lo ^= hi; hi = lj_rol(hi, HASH_ROT1); 23 | lo -= hi; hi = lj_rol(hi, HASH_ROT2); 24 | hi ^= lo; hi -= lj_rol(lo, HASH_ROT3); 25 | #else 26 | lo ^= hi; 27 | lo = lo - lj_rol(hi, HASH_ROT1); 28 | hi = lo ^ lj_rol(hi, HASH_ROT1 + HASH_ROT2); 29 | hi = hi - lj_rol(lo, HASH_ROT3); 30 | #endif 31 | return hi; 32 | } 33 | 34 | #define hsize2hbits(s) ((s) ? ((s)==1 ? 1 : 1+lj_fls((uint32_t)((s)-1))) : 0) 35 | 36 | LJ_FUNCA GCtab *lj_tab_new(lua_State *L, uint32_t asize, uint32_t hbits); 37 | LJ_FUNC GCtab *lj_tab_new_ah(lua_State *L, int32_t a, int32_t h); 38 | #if LJ_HASJIT 39 | LJ_FUNC GCtab * LJ_FASTCALL lj_tab_new1(lua_State *L, uint32_t ahsize); 40 | #endif 41 | LJ_FUNCA GCtab * LJ_FASTCALL lj_tab_dup(lua_State *L, const GCtab *kt); 42 | LJ_FUNC void LJ_FASTCALL lj_tab_clear(GCtab *t); 43 | LJ_FUNC void LJ_FASTCALL lj_tab_free(global_State *g, GCtab *t); 44 | #if LJ_HASFFI 45 | LJ_FUNC void lj_tab_rehash(lua_State *L, GCtab *t); 46 | #endif 47 | LJ_FUNC void lj_tab_resize(lua_State *L, GCtab *t, uint32_t asize, uint32_t hbits); 48 | LJ_FUNCA void lj_tab_reasize(lua_State *L, GCtab *t, uint32_t nasize); 49 | 50 | /* Caveat: all getters except lj_tab_get() can return NULL! */ 51 | 52 | LJ_FUNCA cTValue * LJ_FASTCALL lj_tab_getinth(GCtab *t, int32_t key); 53 | LJ_FUNC cTValue *lj_tab_getstr(GCtab *t, GCstr *key); 54 | LJ_FUNCA cTValue *lj_tab_get(lua_State *L, GCtab *t, cTValue *key); 55 | 56 | /* Caveat: all setters require a write barrier for the stored value. */ 57 | 58 | LJ_FUNCA TValue *lj_tab_newkey(lua_State *L, GCtab *t, cTValue *key); 59 | LJ_FUNCA TValue *lj_tab_setinth(lua_State *L, GCtab *t, int32_t key); 60 | LJ_FUNC TValue *lj_tab_setstr(lua_State *L, GCtab *t, GCstr *key); 61 | LJ_FUNC TValue *lj_tab_set(lua_State *L, GCtab *t, cTValue *key); 62 | 63 | #define inarray(t, key) ((MSize)(key) < (MSize)(t)->asize) 64 | #define arrayslot(t, i) (&tvref((t)->array)[(i)]) 65 | #define lj_tab_getint(t, key) \ 66 | (inarray((t), (key)) ? arrayslot((t), (key)) : lj_tab_getinth((t), (key))) 67 | #define lj_tab_setint(L, t, key) \ 68 | (inarray((t), (key)) ? arrayslot((t), (key)) : lj_tab_setinth(L, (t), (key))) 69 | 70 | LJ_FUNCA int lj_tab_next(lua_State *L, GCtab *t, TValue *key); 71 | LJ_FUNCA MSize LJ_FASTCALL lj_tab_len(GCtab *t); 72 | 73 | #endif 74 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_trace.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Trace management. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_TRACE_H 7 | #define _LJ_TRACE_H 8 | 9 | #include "lj_obj.h" 10 | 11 | #if LJ_HASJIT 12 | #include "lj_jit.h" 13 | #include "lj_dispatch.h" 14 | 15 | /* Trace errors. */ 16 | typedef enum { 17 | #define TREDEF(name, msg) LJ_TRERR_##name, 18 | #include "lj_traceerr.h" 19 | LJ_TRERR__MAX 20 | } TraceError; 21 | 22 | LJ_FUNC_NORET void lj_trace_err(jit_State *J, TraceError e); 23 | LJ_FUNC_NORET void lj_trace_err_info(jit_State *J, TraceError e); 24 | 25 | /* Trace management. */ 26 | LJ_FUNC GCtrace * LJ_FASTCALL lj_trace_alloc(lua_State *L, GCtrace *T); 27 | LJ_FUNC void LJ_FASTCALL lj_trace_free(global_State *g, GCtrace *T); 28 | LJ_FUNC void lj_trace_reenableproto(GCproto *pt); 29 | LJ_FUNC void lj_trace_flushproto(global_State *g, GCproto *pt); 30 | LJ_FUNC void lj_trace_flush(jit_State *J, TraceNo traceno); 31 | LJ_FUNC int lj_trace_flushall(lua_State *L); 32 | LJ_FUNC void lj_trace_initstate(global_State *g); 33 | LJ_FUNC void lj_trace_freestate(global_State *g); 34 | 35 | /* Event handling. */ 36 | LJ_FUNC void lj_trace_ins(jit_State *J, const BCIns *pc); 37 | LJ_FUNCA void LJ_FASTCALL lj_trace_hot(jit_State *J, const BCIns *pc); 38 | LJ_FUNCA void LJ_FASTCALL lj_trace_stitch(jit_State *J, const BCIns *pc); 39 | LJ_FUNCA int LJ_FASTCALL lj_trace_exit(jit_State *J, void *exptr); 40 | 41 | /* Signal asynchronous abort of trace or end of trace. */ 42 | #define lj_trace_abort(g) (G2J(g)->state &= ~LJ_TRACE_ACTIVE) 43 | #define lj_trace_end(J) (J->state = LJ_TRACE_END) 44 | 45 | #else 46 | 47 | #define lj_trace_flushall(L) (UNUSED(L), 0) 48 | #define lj_trace_initstate(g) UNUSED(g) 49 | #define lj_trace_freestate(g) UNUSED(g) 50 | #define lj_trace_abort(g) UNUSED(g) 51 | #define lj_trace_end(J) UNUSED(J) 52 | 53 | #endif 54 | 55 | #endif 56 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_traceerr.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Trace compiler error messages. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | /* This file may be included multiple times with different TREDEF macros. */ 7 | 8 | /* Recording. */ 9 | TREDEF(RECERR, "error thrown or hook called during recording") 10 | TREDEF(TRACEUV, "trace too short") 11 | TREDEF(TRACEOV, "trace too long") 12 | TREDEF(STACKOV, "trace too deep") 13 | TREDEF(SNAPOV, "too many snapshots") 14 | TREDEF(BLACKL, "blacklisted") 15 | TREDEF(RETRY, "retry recording") 16 | TREDEF(NYIBC, "NYI: bytecode %d") 17 | 18 | /* Recording loop ops. */ 19 | TREDEF(LLEAVE, "leaving loop in root trace") 20 | TREDEF(LINNER, "inner loop in root trace") 21 | TREDEF(LUNROLL, "loop unroll limit reached") 22 | 23 | /* Recording calls/returns. */ 24 | TREDEF(BADTYPE, "bad argument type") 25 | TREDEF(CJITOFF, "JIT compilation disabled for function") 26 | TREDEF(CUNROLL, "call unroll limit reached") 27 | TREDEF(DOWNREC, "down-recursion, restarting") 28 | TREDEF(NYIFFU, "NYI: unsupported variant of FastFunc %s") 29 | TREDEF(NYIRETL, "NYI: return to lower frame") 30 | 31 | /* Recording indexed load/store. */ 32 | TREDEF(STORENN, "store with nil or NaN key") 33 | TREDEF(NOMM, "missing metamethod") 34 | TREDEF(IDXLOOP, "looping index lookup") 35 | TREDEF(NYITMIX, "NYI: mixed sparse/dense table") 36 | 37 | /* Recording C data operations. */ 38 | TREDEF(NOCACHE, "symbol not in cache") 39 | TREDEF(NYICONV, "NYI: unsupported C type conversion") 40 | TREDEF(NYICALL, "NYI: unsupported C function type") 41 | 42 | /* Optimizations. */ 43 | TREDEF(GFAIL, "guard would always fail") 44 | TREDEF(PHIOV, "too many PHIs") 45 | TREDEF(TYPEINS, "persistent type instability") 46 | 47 | /* Assembler. */ 48 | TREDEF(MCODEAL, "failed to allocate mcode memory") 49 | TREDEF(MCODEOV, "machine code too long") 50 | TREDEF(MCODELM, "hit mcode limit (retrying)") 51 | TREDEF(SPILLOV, "too many spill slots") 52 | TREDEF(BADRA, "inconsistent register allocation") 53 | TREDEF(NYIIR, "NYI: cannot assemble IR instruction %d") 54 | TREDEF(NYIPHI, "NYI: PHI shuffling too complex") 55 | TREDEF(NYICOAL, "NYI: register coalescing too complex") 56 | 57 | #undef TREDEF 58 | 59 | /* Detecting unused error messages: 60 | awk -F, '/^TREDEF/ { gsub(/TREDEF./, ""); printf "grep -q LJ_TRERR_%s *.[ch] || echo %s\n", $1, $1}' lj_traceerr.h | sh 61 | */ 62 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_udata.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** Userdata handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #define lj_udata_c 7 | #define LUA_CORE 8 | 9 | #include "lj_obj.h" 10 | #include "lj_gc.h" 11 | #include "lj_udata.h" 12 | 13 | GCudata *lj_udata_new(lua_State *L, MSize sz, GCtab *env) 14 | { 15 | GCudata *ud = lj_mem_newt(L, sizeof(GCudata) + sz, GCudata); 16 | global_State *g = G(L); 17 | newwhite(g, ud); /* Not finalized. */ 18 | ud->gct = ~LJ_TUDATA; 19 | ud->udtype = UDTYPE_USERDATA; 20 | ud->len = sz; 21 | /* NOBARRIER: The GCudata is new (marked white). */ 22 | setgcrefnull(ud->metatable); 23 | setgcref(ud->env, obj2gco(env)); 24 | /* Chain to userdata list (after main thread). */ 25 | setgcrefr(ud->nextgc, mainthread(g)->nextgc); 26 | setgcref(mainthread(g)->nextgc, obj2gco(ud)); 27 | return ud; 28 | } 29 | 30 | void LJ_FASTCALL lj_udata_free(global_State *g, GCudata *ud) 31 | { 32 | lj_mem_free(g, ud, sizeudata(ud)); 33 | } 34 | 35 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_udata.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Userdata handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_UDATA_H 7 | #define _LJ_UDATA_H 8 | 9 | #include "lj_obj.h" 10 | 11 | LJ_FUNC GCudata *lj_udata_new(lua_State *L, MSize sz, GCtab *env); 12 | LJ_FUNC void LJ_FASTCALL lj_udata_free(global_State *g, GCudata *ud); 13 | 14 | #endif 15 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_vm.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Assembler VM interface definitions. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_VM_H 7 | #define _LJ_VM_H 8 | 9 | #include "lj_obj.h" 10 | 11 | /* Entry points for ASM parts of VM. */ 12 | LJ_ASMF void lj_vm_call(lua_State *L, TValue *base, int nres1); 13 | LJ_ASMF int lj_vm_pcall(lua_State *L, TValue *base, int nres1, ptrdiff_t ef); 14 | typedef TValue *(*lua_CPFunction)(lua_State *L, lua_CFunction func, void *ud); 15 | LJ_ASMF int lj_vm_cpcall(lua_State *L, lua_CFunction func, void *ud, 16 | lua_CPFunction cp); 17 | LJ_ASMF int lj_vm_resume(lua_State *L, TValue *base, int nres1, ptrdiff_t ef); 18 | LJ_ASMF_NORET void LJ_FASTCALL lj_vm_unwind_c(void *cframe, int errcode); 19 | LJ_ASMF_NORET void LJ_FASTCALL lj_vm_unwind_ff(void *cframe); 20 | #if LJ_ABI_WIN && LJ_TARGET_X86 21 | LJ_ASMF_NORET void LJ_FASTCALL lj_vm_rtlunwind(void *cframe, void *excptrec, 22 | void *unwinder, int errcode); 23 | #endif 24 | LJ_ASMF void lj_vm_unwind_c_eh(void); 25 | LJ_ASMF void lj_vm_unwind_ff_eh(void); 26 | #if LJ_TARGET_X86ORX64 27 | LJ_ASMF void lj_vm_unwind_rethrow(void); 28 | #endif 29 | 30 | /* Miscellaneous functions. */ 31 | #if LJ_TARGET_X86ORX64 32 | LJ_ASMF int lj_vm_cpuid(uint32_t f, uint32_t res[4]); 33 | #endif 34 | #if LJ_TARGET_PPC 35 | void lj_vm_cachesync(void *start, void *end); 36 | #endif 37 | LJ_ASMF double lj_vm_foldarith(double x, double y, int op); 38 | #if LJ_HASJIT 39 | LJ_ASMF double lj_vm_foldfpm(double x, int op); 40 | #endif 41 | #if !LJ_ARCH_HASFPU 42 | /* Declared in lj_obj.h: LJ_ASMF int32_t lj_vm_tobit(double x); */ 43 | #endif 44 | 45 | /* Dispatch targets for recording and hooks. */ 46 | LJ_ASMF void lj_vm_record(void); 47 | LJ_ASMF void lj_vm_inshook(void); 48 | LJ_ASMF void lj_vm_rethook(void); 49 | LJ_ASMF void lj_vm_callhook(void); 50 | LJ_ASMF void lj_vm_profhook(void); 51 | 52 | /* Trace exit handling. */ 53 | LJ_ASMF void lj_vm_exit_handler(void); 54 | LJ_ASMF void lj_vm_exit_interp(void); 55 | 56 | /* Internal math helper functions. */ 57 | #if LJ_TARGET_PPC || LJ_TARGET_ARM64 || (LJ_TARGET_MIPS && LJ_ABI_SOFTFP) 58 | #define lj_vm_floor floor 59 | #define lj_vm_ceil ceil 60 | #else 61 | LJ_ASMF double lj_vm_floor(double); 62 | LJ_ASMF double lj_vm_ceil(double); 63 | #if LJ_TARGET_ARM 64 | LJ_ASMF double lj_vm_floor_sf(double); 65 | LJ_ASMF double lj_vm_ceil_sf(double); 66 | #endif 67 | #endif 68 | #ifdef LUAJIT_NO_LOG2 69 | LJ_ASMF double lj_vm_log2(double); 70 | #else 71 | #define lj_vm_log2 log2 72 | #endif 73 | #if !(defined(_LJ_DISPATCH_H) && LJ_TARGET_MIPS) 74 | LJ_ASMF int32_t LJ_FASTCALL lj_vm_modi(int32_t, int32_t); 75 | #endif 76 | 77 | #if LJ_HASJIT 78 | #if LJ_TARGET_X86ORX64 79 | LJ_ASMF void lj_vm_floor_sse(void); 80 | LJ_ASMF void lj_vm_ceil_sse(void); 81 | LJ_ASMF void lj_vm_trunc_sse(void); 82 | LJ_ASMF void lj_vm_powi_sse(void); 83 | #define lj_vm_powi NULL 84 | #else 85 | LJ_ASMF double lj_vm_powi(double, int32_t); 86 | #endif 87 | #if LJ_TARGET_PPC || LJ_TARGET_ARM64 88 | #define lj_vm_trunc trunc 89 | #else 90 | LJ_ASMF double lj_vm_trunc(double); 91 | #if LJ_TARGET_ARM 92 | LJ_ASMF double lj_vm_trunc_sf(double); 93 | #endif 94 | #endif 95 | #ifdef LUAJIT_NO_EXP2 96 | LJ_ASMF double lj_vm_exp2(double); 97 | #else 98 | #define lj_vm_exp2 exp2 99 | #endif 100 | #if LJ_HASFFI 101 | LJ_ASMF int lj_vm_errno(void); 102 | #endif 103 | #endif 104 | 105 | /* Continuations for metamethods. */ 106 | LJ_ASMF void lj_cont_cat(void); /* Continue with concatenation. */ 107 | LJ_ASMF void lj_cont_ra(void); /* Store result in RA from instruction. */ 108 | LJ_ASMF void lj_cont_nop(void); /* Do nothing, just continue execution. */ 109 | LJ_ASMF void lj_cont_condt(void); /* Branch if result is true. */ 110 | LJ_ASMF void lj_cont_condf(void); /* Branch if result is false. */ 111 | LJ_ASMF void lj_cont_hook(void); /* Continue from hook yield. */ 112 | LJ_ASMF void lj_cont_stitch(void); /* Trace stitching. */ 113 | 114 | /* Start of the ASM code. */ 115 | LJ_ASMF char lj_vm_asm_begin[]; 116 | 117 | /* Bytecode offsets are relative to lj_vm_asm_begin. */ 118 | #define makeasmfunc(ofs) ((ASMFunction)(lj_vm_asm_begin + (ofs))) 119 | 120 | #endif 121 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_vmevent.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** VM event handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #include 7 | 8 | #define lj_vmevent_c 9 | #define LUA_CORE 10 | 11 | #include "lj_obj.h" 12 | #include "lj_str.h" 13 | #include "lj_tab.h" 14 | #include "lj_state.h" 15 | #include "lj_dispatch.h" 16 | #include "lj_vm.h" 17 | #include "lj_vmevent.h" 18 | 19 | ptrdiff_t lj_vmevent_prepare(lua_State *L, VMEvent ev) 20 | { 21 | global_State *g = G(L); 22 | GCstr *s = lj_str_newlit(L, LJ_VMEVENTS_REGKEY); 23 | cTValue *tv = lj_tab_getstr(tabV(registry(L)), s); 24 | if (tvistab(tv)) { 25 | int hash = VMEVENT_HASH(ev); 26 | tv = lj_tab_getint(tabV(tv), hash); 27 | if (tv && tvisfunc(tv)) { 28 | lj_state_checkstack(L, LUA_MINSTACK); 29 | setfuncV(L, L->top++, funcV(tv)); 30 | if (LJ_FR2) setnilV(L->top++); 31 | return savestack(L, L->top); 32 | } 33 | } 34 | g->vmevmask &= ~VMEVENT_MASK(ev); /* No handler: cache this fact. */ 35 | return 0; 36 | } 37 | 38 | void lj_vmevent_call(lua_State *L, ptrdiff_t argbase) 39 | { 40 | global_State *g = G(L); 41 | uint8_t oldmask = g->vmevmask; 42 | uint8_t oldh = hook_save(g); 43 | int status; 44 | g->vmevmask = 0; /* Disable all events. */ 45 | hook_vmevent(g); 46 | status = lj_vm_pcall(L, restorestack(L, argbase), 0+1, 0); 47 | if (LJ_UNLIKELY(status)) { 48 | /* Really shouldn't use stderr here, but where else to complain? */ 49 | L->top--; 50 | fputs("VM handler failed: ", stderr); 51 | fputs(tvisstr(L->top) ? strVdata(L->top) : "?", stderr); 52 | fputc('\n', stderr); 53 | } 54 | hook_restore(g, oldh); 55 | if (g->vmevmask != VMEVENT_NOCACHE) 56 | g->vmevmask = oldmask; /* Restore event mask, but not if not modified. */ 57 | } 58 | 59 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_vmevent.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** VM event handling. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LJ_VMEVENT_H 7 | #define _LJ_VMEVENT_H 8 | 9 | #include "lj_obj.h" 10 | 11 | /* Registry key for VM event handler table. */ 12 | #define LJ_VMEVENTS_REGKEY "_VMEVENTS" 13 | #define LJ_VMEVENTS_HSIZE 4 14 | 15 | #define VMEVENT_MASK(ev) ((uint8_t)1 << ((int)(ev) & 7)) 16 | #define VMEVENT_HASH(ev) ((int)(ev) & ~7) 17 | #define VMEVENT_HASHIDX(h) ((int)(h) << 3) 18 | #define VMEVENT_NOCACHE 255 19 | 20 | #define VMEVENT_DEF(name, hash) \ 21 | LJ_VMEVENT_##name##_, \ 22 | LJ_VMEVENT_##name = ((LJ_VMEVENT_##name##_) & 7)|((hash) << 3) 23 | 24 | /* VM event IDs. */ 25 | typedef enum { 26 | VMEVENT_DEF(BC, 0x00003883), 27 | VMEVENT_DEF(TRACE, 0xb2d91467), 28 | VMEVENT_DEF(RECORD, 0x9284bf4f), 29 | VMEVENT_DEF(TEXIT, 0xb29df2b0), 30 | LJ_VMEVENT__MAX 31 | } VMEvent; 32 | 33 | #ifdef LUAJIT_DISABLE_VMEVENT 34 | #define lj_vmevent_send(L, ev, args) UNUSED(L) 35 | #define lj_vmevent_send_(L, ev, args, post) UNUSED(L) 36 | #else 37 | #define lj_vmevent_send(L, ev, args) \ 38 | if (G(L)->vmevmask & VMEVENT_MASK(LJ_VMEVENT_##ev)) { \ 39 | ptrdiff_t argbase = lj_vmevent_prepare(L, LJ_VMEVENT_##ev); \ 40 | if (argbase) { \ 41 | args \ 42 | lj_vmevent_call(L, argbase); \ 43 | } \ 44 | } 45 | #define lj_vmevent_send_(L, ev, args, post) \ 46 | if (G(L)->vmevmask & VMEVENT_MASK(LJ_VMEVENT_##ev)) { \ 47 | ptrdiff_t argbase = lj_vmevent_prepare(L, LJ_VMEVENT_##ev); \ 48 | if (argbase) { \ 49 | args \ 50 | lj_vmevent_call(L, argbase); \ 51 | post \ 52 | } \ 53 | } 54 | 55 | LJ_FUNC ptrdiff_t lj_vmevent_prepare(lua_State *L, VMEvent ev); 56 | LJ_FUNC void lj_vmevent_call(lua_State *L, ptrdiff_t argbase); 57 | #endif 58 | 59 | #endif 60 | -------------------------------------------------------------------------------- /deps/luajit/src/lj_vmmath.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** Math helper functions for assembler VM. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #define lj_vmmath_c 7 | #define LUA_CORE 8 | 9 | #include 10 | #include 11 | 12 | #include "lj_obj.h" 13 | #include "lj_ir.h" 14 | #include "lj_vm.h" 15 | 16 | /* -- Wrapper functions --------------------------------------------------- */ 17 | 18 | #if LJ_TARGET_X86 && __ELF__ && __PIC__ 19 | /* Wrapper functions to deal with the ELF/x86 PIC disaster. */ 20 | LJ_FUNCA double lj_wrap_log(double x) { return log(x); } 21 | LJ_FUNCA double lj_wrap_log10(double x) { return log10(x); } 22 | LJ_FUNCA double lj_wrap_exp(double x) { return exp(x); } 23 | LJ_FUNCA double lj_wrap_sin(double x) { return sin(x); } 24 | LJ_FUNCA double lj_wrap_cos(double x) { return cos(x); } 25 | LJ_FUNCA double lj_wrap_tan(double x) { return tan(x); } 26 | LJ_FUNCA double lj_wrap_asin(double x) { return asin(x); } 27 | LJ_FUNCA double lj_wrap_acos(double x) { return acos(x); } 28 | LJ_FUNCA double lj_wrap_atan(double x) { return atan(x); } 29 | LJ_FUNCA double lj_wrap_sinh(double x) { return sinh(x); } 30 | LJ_FUNCA double lj_wrap_cosh(double x) { return cosh(x); } 31 | LJ_FUNCA double lj_wrap_tanh(double x) { return tanh(x); } 32 | LJ_FUNCA double lj_wrap_atan2(double x, double y) { return atan2(x, y); } 33 | LJ_FUNCA double lj_wrap_pow(double x, double y) { return pow(x, y); } 34 | LJ_FUNCA double lj_wrap_fmod(double x, double y) { return fmod(x, y); } 35 | #endif 36 | 37 | /* -- Helper functions for generated machine code ------------------------- */ 38 | 39 | double lj_vm_foldarith(double x, double y, int op) 40 | { 41 | switch (op) { 42 | case IR_ADD - IR_ADD: return x+y; break; 43 | case IR_SUB - IR_ADD: return x-y; break; 44 | case IR_MUL - IR_ADD: return x*y; break; 45 | case IR_DIV - IR_ADD: return x/y; break; 46 | case IR_MOD - IR_ADD: return x-lj_vm_floor(x/y)*y; break; 47 | case IR_POW - IR_ADD: return pow(x, y); break; 48 | case IR_NEG - IR_ADD: return -x; break; 49 | case IR_ABS - IR_ADD: return fabs(x); break; 50 | #if LJ_HASJIT 51 | case IR_ATAN2 - IR_ADD: return atan2(x, y); break; 52 | case IR_LDEXP - IR_ADD: return ldexp(x, (int)y); break; 53 | case IR_MIN - IR_ADD: return x > y ? y : x; break; 54 | case IR_MAX - IR_ADD: return x < y ? y : x; break; 55 | #endif 56 | default: return x; 57 | } 58 | } 59 | 60 | #if (LJ_HASJIT && !(LJ_TARGET_ARM || LJ_TARGET_ARM64 || LJ_TARGET_PPC)) || LJ_TARGET_MIPS 61 | int32_t LJ_FASTCALL lj_vm_modi(int32_t a, int32_t b) 62 | { 63 | uint32_t y, ua, ub; 64 | lua_assert(b != 0); /* This must be checked before using this function. */ 65 | ua = a < 0 ? (uint32_t)-a : (uint32_t)a; 66 | ub = b < 0 ? (uint32_t)-b : (uint32_t)b; 67 | y = ua % ub; 68 | if (y != 0 && (a^b) < 0) y = y - ub; 69 | if (((int32_t)y^b) < 0) y = (uint32_t)-(int32_t)y; 70 | return (int32_t)y; 71 | } 72 | #endif 73 | 74 | #if LJ_HASJIT 75 | 76 | #ifdef LUAJIT_NO_LOG2 77 | double lj_vm_log2(double a) 78 | { 79 | return log(a) * 1.4426950408889634074; 80 | } 81 | #endif 82 | 83 | #ifdef LUAJIT_NO_EXP2 84 | double lj_vm_exp2(double a) 85 | { 86 | return exp(a * 0.6931471805599453); 87 | } 88 | #endif 89 | 90 | #if !LJ_TARGET_X86ORX64 91 | /* Unsigned x^k. */ 92 | static double lj_vm_powui(double x, uint32_t k) 93 | { 94 | double y; 95 | lua_assert(k != 0); 96 | for (; (k & 1) == 0; k >>= 1) x *= x; 97 | y = x; 98 | if ((k >>= 1) != 0) { 99 | for (;;) { 100 | x *= x; 101 | if (k == 1) break; 102 | if (k & 1) y *= x; 103 | k >>= 1; 104 | } 105 | y *= x; 106 | } 107 | return y; 108 | } 109 | 110 | /* Signed x^k. */ 111 | double lj_vm_powi(double x, int32_t k) 112 | { 113 | if (k > 1) 114 | return lj_vm_powui(x, (uint32_t)k); 115 | else if (k == 1) 116 | return x; 117 | else if (k == 0) 118 | return 1.0; 119 | else 120 | return 1.0 / lj_vm_powui(x, (uint32_t)-k); 121 | } 122 | #endif 123 | 124 | /* Computes fpm(x) for extended math functions. */ 125 | double lj_vm_foldfpm(double x, int fpm) 126 | { 127 | switch (fpm) { 128 | case IRFPM_FLOOR: return lj_vm_floor(x); 129 | case IRFPM_CEIL: return lj_vm_ceil(x); 130 | case IRFPM_TRUNC: return lj_vm_trunc(x); 131 | case IRFPM_SQRT: return sqrt(x); 132 | case IRFPM_EXP: return exp(x); 133 | case IRFPM_EXP2: return lj_vm_exp2(x); 134 | case IRFPM_LOG: return log(x); 135 | case IRFPM_LOG2: return lj_vm_log2(x); 136 | case IRFPM_LOG10: return log10(x); 137 | case IRFPM_SIN: return sin(x); 138 | case IRFPM_COS: return cos(x); 139 | case IRFPM_TAN: return tan(x); 140 | default: lua_assert(0); 141 | } 142 | return 0; 143 | } 144 | 145 | #if LJ_HASFFI 146 | int lj_vm_errno(void) 147 | { 148 | return errno; 149 | } 150 | #endif 151 | 152 | #endif 153 | -------------------------------------------------------------------------------- /deps/luajit/src/ljamalg.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** LuaJIT core and libraries amalgamation. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | /* 7 | +--------------------------------------------------------------------------+ 8 | | WARNING: Compiling the amalgamation needs a lot of virtual memory | 9 | | (around 300 MB with GCC 4.x)! If you don't have enough physical memory | 10 | | your machine will start swapping to disk and the compile will not finish | 11 | | within a reasonable amount of time. | 12 | | So either compile on a bigger machine or use the non-amalgamated build. | 13 | +--------------------------------------------------------------------------+ 14 | */ 15 | 16 | #define ljamalg_c 17 | #define LUA_CORE 18 | 19 | /* To get the mremap prototype. Must be defined before any system includes. */ 20 | #if defined(__linux__) && !defined(_GNU_SOURCE) 21 | #define _GNU_SOURCE 22 | #endif 23 | 24 | #ifndef WINVER 25 | #define WINVER 0x0501 26 | #endif 27 | 28 | #include "lua.h" 29 | #include "lauxlib.h" 30 | 31 | #include "lj_gc.c" 32 | #include "lj_err.c" 33 | #include "lj_char.c" 34 | #include "lj_bc.c" 35 | #include "lj_obj.c" 36 | #include "lj_buf.c" 37 | #include "lj_str.c" 38 | #include "lj_tab.c" 39 | #include "lj_func.c" 40 | #include "lj_udata.c" 41 | #include "lj_meta.c" 42 | #include "lj_debug.c" 43 | #include "lj_state.c" 44 | #include "lj_dispatch.c" 45 | #include "lj_vmevent.c" 46 | #include "lj_vmmath.c" 47 | #include "lj_strscan.c" 48 | #include "lj_strfmt.c" 49 | #include "lj_strfmt_num.c" 50 | #include "lj_api.c" 51 | #include "lj_profile.c" 52 | #include "lj_lex.c" 53 | #include "lj_parse.c" 54 | #include "lj_bcread.c" 55 | #include "lj_bcwrite.c" 56 | #include "lj_load.c" 57 | #include "lj_ctype.c" 58 | #include "lj_cdata.c" 59 | #include "lj_cconv.c" 60 | #include "lj_ccall.c" 61 | #include "lj_ccallback.c" 62 | #include "lj_carith.c" 63 | #include "lj_clib.c" 64 | #include "lj_cparse.c" 65 | #include "lj_lib.c" 66 | #include "lj_ir.c" 67 | #include "lj_opt_mem.c" 68 | #include "lj_opt_fold.c" 69 | #include "lj_opt_narrow.c" 70 | #include "lj_opt_dce.c" 71 | #include "lj_opt_loop.c" 72 | #include "lj_opt_split.c" 73 | #include "lj_opt_sink.c" 74 | #include "lj_mcode.c" 75 | #include "lj_snap.c" 76 | #include "lj_record.c" 77 | #include "lj_crecord.c" 78 | #include "lj_ffrecord.c" 79 | #include "lj_asm.c" 80 | #include "lj_trace.c" 81 | #include "lj_gdbjit.c" 82 | #include "lj_alloc.c" 83 | 84 | #include "lib_aux.c" 85 | #include "lib_base.c" 86 | #include "lib_math.c" 87 | #include "lib_string.c" 88 | #include "lib_table.c" 89 | #include "lib_io.c" 90 | #include "lib_os.c" 91 | #include "lib_package.c" 92 | #include "lib_debug.c" 93 | #include "lib_bit.c" 94 | #include "lib_jit.c" 95 | #include "lib_ffi.c" 96 | #include "lib_init.c" 97 | 98 | -------------------------------------------------------------------------------- /deps/luajit/src/lua.hpp: -------------------------------------------------------------------------------- 1 | // C++ wrapper for LuaJIT header files. 2 | 3 | extern "C" { 4 | #include "lua.h" 5 | #include "lauxlib.h" 6 | #include "lualib.h" 7 | #include "luajit.h" 8 | } 9 | 10 | -------------------------------------------------------------------------------- /deps/luajit/src/luajit.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** LuaJIT -- a Just-In-Time Compiler for Lua. http://luajit.org/ 3 | ** 4 | ** Copyright (C) 2005-2017 Mike Pall. All rights reserved. 5 | ** 6 | ** Permission is hereby granted, free of charge, to any person obtaining 7 | ** a copy of this software and associated documentation files (the 8 | ** "Software"), to deal in the Software without restriction, including 9 | ** without limitation the rights to use, copy, modify, merge, publish, 10 | ** distribute, sublicense, and/or sell copies of the Software, and to 11 | ** permit persons to whom the Software is furnished to do so, subject to 12 | ** the following conditions: 13 | ** 14 | ** The above copyright notice and this permission notice shall be 15 | ** included in all copies or substantial portions of the Software. 16 | ** 17 | ** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 18 | ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 19 | ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 20 | ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 21 | ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 22 | ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 23 | ** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 24 | ** 25 | ** [ MIT license: http://www.opensource.org/licenses/mit-license.php ] 26 | */ 27 | 28 | #ifndef _LUAJIT_H 29 | #define _LUAJIT_H 30 | 31 | #include "lua.h" 32 | 33 | #define LUAJIT_VERSION "LuaJIT 2.1.0-beta3" 34 | #define LUAJIT_VERSION_NUM 20100 /* Version 2.1.0 = 02.01.00. */ 35 | #define LUAJIT_VERSION_SYM luaJIT_version_2_1_0_beta3 36 | #define LUAJIT_COPYRIGHT "Copyright (C) 2005-2017 Mike Pall" 37 | #define LUAJIT_URL "http://luajit.org/" 38 | 39 | /* Modes for luaJIT_setmode. */ 40 | #define LUAJIT_MODE_MASK 0x00ff 41 | 42 | enum { 43 | LUAJIT_MODE_ENGINE, /* Set mode for whole JIT engine. */ 44 | LUAJIT_MODE_DEBUG, /* Set debug mode (idx = level). */ 45 | 46 | LUAJIT_MODE_FUNC, /* Change mode for a function. */ 47 | LUAJIT_MODE_ALLFUNC, /* Recurse into subroutine protos. */ 48 | LUAJIT_MODE_ALLSUBFUNC, /* Change only the subroutines. */ 49 | 50 | LUAJIT_MODE_TRACE, /* Flush a compiled trace. */ 51 | 52 | LUAJIT_MODE_WRAPCFUNC = 0x10, /* Set wrapper mode for C function calls. */ 53 | 54 | LUAJIT_MODE_MAX 55 | }; 56 | 57 | /* Flags or'ed in to the mode. */ 58 | #define LUAJIT_MODE_OFF 0x0000 /* Turn feature off. */ 59 | #define LUAJIT_MODE_ON 0x0100 /* Turn feature on. */ 60 | #define LUAJIT_MODE_FLUSH 0x0200 /* Flush JIT-compiled code. */ 61 | 62 | /* LuaJIT public C API. */ 63 | 64 | /* Control the JIT engine. */ 65 | LUA_API int luaJIT_setmode(lua_State *L, int idx, int mode); 66 | 67 | /* Low-overhead profiling API. */ 68 | typedef void (*luaJIT_profile_callback)(void *data, lua_State *L, 69 | int samples, int vmstate); 70 | LUA_API void luaJIT_profile_start(lua_State *L, const char *mode, 71 | luaJIT_profile_callback cb, void *data); 72 | LUA_API void luaJIT_profile_stop(lua_State *L); 73 | LUA_API const char *luaJIT_profile_dumpstack(lua_State *L, const char *fmt, 74 | int depth, size_t *len); 75 | 76 | /* Enforce (dynamic) linker error for version mismatches. Call from main. */ 77 | LUA_API void LUAJIT_VERSION_SYM(void); 78 | 79 | #endif 80 | -------------------------------------------------------------------------------- /deps/luajit/src/lualib.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** Standard library header. 3 | ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 4 | */ 5 | 6 | #ifndef _LUALIB_H 7 | #define _LUALIB_H 8 | 9 | #include "lua.h" 10 | 11 | #define LUA_FILEHANDLE "FILE*" 12 | 13 | #define LUA_COLIBNAME "coroutine" 14 | #define LUA_MATHLIBNAME "math" 15 | #define LUA_STRLIBNAME "string" 16 | #define LUA_TABLIBNAME "table" 17 | #define LUA_IOLIBNAME "io" 18 | #define LUA_OSLIBNAME "os" 19 | #define LUA_LOADLIBNAME "package" 20 | #define LUA_DBLIBNAME "debug" 21 | #define LUA_BITLIBNAME "bit" 22 | #define LUA_JITLIBNAME "jit" 23 | #define LUA_FFILIBNAME "ffi" 24 | 25 | LUALIB_API int luaopen_base(lua_State *L); 26 | LUALIB_API int luaopen_math(lua_State *L); 27 | LUALIB_API int luaopen_string(lua_State *L); 28 | LUALIB_API int luaopen_table(lua_State *L); 29 | LUALIB_API int luaopen_io(lua_State *L); 30 | LUALIB_API int luaopen_os(lua_State *L); 31 | LUALIB_API int luaopen_package(lua_State *L); 32 | LUALIB_API int luaopen_debug(lua_State *L); 33 | LUALIB_API int luaopen_bit(lua_State *L); 34 | LUALIB_API int luaopen_jit(lua_State *L); 35 | LUALIB_API int luaopen_ffi(lua_State *L); 36 | 37 | LUALIB_API void luaL_openlibs(lua_State *L); 38 | 39 | #ifndef lua_assert 40 | #define lua_assert(x) ((void)0) 41 | #endif 42 | 43 | #endif 44 | -------------------------------------------------------------------------------- /deps/luajit/src/msvcbuild.bat: -------------------------------------------------------------------------------- 1 | @rem Script to build LuaJIT with MSVC. 2 | @rem Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h 3 | @rem 4 | @rem Either open a "Visual Studio .NET Command Prompt" 5 | @rem (Note that the Express Edition does not contain an x64 compiler) 6 | @rem -or- 7 | @rem Open a "Windows SDK Command Shell" and set the compiler environment: 8 | @rem setenv /release /x86 9 | @rem -or- 10 | @rem setenv /release /x64 11 | @rem 12 | @rem Then cd to this directory and run this script. 13 | 14 | @if not defined INCLUDE goto :FAIL 15 | 16 | @setlocal 17 | @set LJCOMPILE=cl /nologo /c /O2 /W3 /D_CRT_SECURE_NO_DEPRECATE /D_CRT_STDIO_INLINE=__declspec(dllexport)__inline 18 | @set LJLINK=link /nologo 19 | @set LJMT=mt /nologo 20 | @set LJLIB=lib /nologo /nodefaultlib 21 | @set DASMDIR=..\dynasm 22 | @set DASM=%DASMDIR%\dynasm.lua 23 | @set DASC=vm_x86.dasc 24 | @set LJDLLNAME=lua51.dll 25 | @set LJLIBNAME=lua51.lib 26 | @set ALL_LIB=lib_base.c lib_math.c lib_bit.c lib_string.c lib_table.c lib_io.c lib_os.c lib_package.c lib_debug.c lib_jit.c lib_ffi.c 27 | 28 | %LJCOMPILE% host\minilua.c 29 | @if errorlevel 1 goto :BAD 30 | %LJLINK% /out:minilua.exe minilua.obj 31 | @if errorlevel 1 goto :BAD 32 | if exist minilua.exe.manifest^ 33 | %LJMT% -manifest minilua.exe.manifest -outputresource:minilua.exe 34 | 35 | @set DASMFLAGS=-D WIN -D JIT -D FFI -D P64 36 | @set LJARCH=x64 37 | @minilua 38 | @if errorlevel 8 goto :X64 39 | @set DASMFLAGS=-D WIN -D JIT -D FFI 40 | @set LJARCH=x86 41 | @set LJCOMPILE=%LJCOMPILE% /arch:SSE2 42 | :X64 43 | @if "%1" neq "gc64" goto :NOGC64 44 | @shift 45 | @set DASC=vm_x64.dasc 46 | @set LJCOMPILE=%LJCOMPILE% /DLUAJIT_ENABLE_GC64 47 | :NOGC64 48 | minilua %DASM% -LN %DASMFLAGS% -o host\buildvm_arch.h %DASC% 49 | @if errorlevel 1 goto :BAD 50 | 51 | %LJCOMPILE% /I "." /I %DASMDIR% host\buildvm*.c 52 | @if errorlevel 1 goto :BAD 53 | %LJLINK% /out:buildvm.exe buildvm*.obj 54 | @if errorlevel 1 goto :BAD 55 | if exist buildvm.exe.manifest^ 56 | %LJMT% -manifest buildvm.exe.manifest -outputresource:buildvm.exe 57 | 58 | buildvm -m peobj -o lj_vm.obj 59 | @if errorlevel 1 goto :BAD 60 | buildvm -m bcdef -o lj_bcdef.h %ALL_LIB% 61 | @if errorlevel 1 goto :BAD 62 | buildvm -m ffdef -o lj_ffdef.h %ALL_LIB% 63 | @if errorlevel 1 goto :BAD 64 | buildvm -m libdef -o lj_libdef.h %ALL_LIB% 65 | @if errorlevel 1 goto :BAD 66 | buildvm -m recdef -o lj_recdef.h %ALL_LIB% 67 | @if errorlevel 1 goto :BAD 68 | buildvm -m vmdef -o jit\vmdef.lua %ALL_LIB% 69 | @if errorlevel 1 goto :BAD 70 | buildvm -m folddef -o lj_folddef.h lj_opt_fold.c 71 | @if errorlevel 1 goto :BAD 72 | 73 | @if "%1" neq "debug" goto :NODEBUG 74 | @shift 75 | @set LJCOMPILE=%LJCOMPILE% /Zi 76 | @set LJLINK=%LJLINK% /debug /opt:ref /opt:icf /incremental:no 77 | :NODEBUG 78 | @if "%1"=="amalg" goto :AMALGDLL 79 | @if "%1"=="static" goto :STATIC 80 | %LJCOMPILE% /MD /DLUA_BUILD_AS_DLL lj_*.c lib_*.c 81 | @if errorlevel 1 goto :BAD 82 | %LJLINK% /DLL /out:%LJDLLNAME% lj_*.obj lib_*.obj 83 | @if errorlevel 1 goto :BAD 84 | @goto :MTDLL 85 | :STATIC 86 | %LJCOMPILE% lj_*.c lib_*.c 87 | @if errorlevel 1 goto :BAD 88 | %LJLIB% /OUT:%LJLIBNAME% lj_*.obj lib_*.obj 89 | @if errorlevel 1 goto :BAD 90 | @goto :MTDLL 91 | :AMALGDLL 92 | %LJCOMPILE% /MD /DLUA_BUILD_AS_DLL ljamalg.c 93 | @if errorlevel 1 goto :BAD 94 | %LJLINK% /DLL /out:%LJDLLNAME% ljamalg.obj lj_vm.obj 95 | @if errorlevel 1 goto :BAD 96 | :MTDLL 97 | if exist %LJDLLNAME%.manifest^ 98 | %LJMT% -manifest %LJDLLNAME%.manifest -outputresource:%LJDLLNAME%;2 99 | 100 | %LJCOMPILE% luajit.c 101 | @if errorlevel 1 goto :BAD 102 | %LJLINK% /out:luajit.exe luajit.obj %LJLIBNAME% 103 | @if errorlevel 1 goto :BAD 104 | if exist luajit.exe.manifest^ 105 | %LJMT% -manifest luajit.exe.manifest -outputresource:luajit.exe 106 | 107 | @del *.obj *.manifest minilua.exe buildvm.exe 108 | @del host\buildvm_arch.h 109 | @del lj_bcdef.h lj_ffdef.h lj_libdef.h lj_recdef.h lj_folddef.h 110 | @echo. 111 | @echo === Successfully built LuaJIT for Windows/%LJARCH% === 112 | 113 | @goto :END 114 | :BAD 115 | @echo. 116 | @echo ******************************************************* 117 | @echo *** Build FAILED -- Please check the error messages *** 118 | @echo ******************************************************* 119 | @goto :END 120 | :FAIL 121 | @echo You must open a "Visual Studio .NET Command Prompt" to run this script 122 | :END 123 | -------------------------------------------------------------------------------- /deps/luajit/src/ps4build.bat: -------------------------------------------------------------------------------- 1 | @rem Script to build LuaJIT with the PS4 SDK. 2 | @rem Donated to the public domain. 3 | @rem 4 | @rem Open a "Visual Studio .NET Command Prompt" (64 bit host compiler) 5 | @rem or "VS2015 x64 Native Tools Command Prompt". 6 | @rem 7 | @rem Then cd to this directory and run this script. 8 | @rem 9 | @rem Recommended invocation: 10 | @rem 11 | @rem ps4build release build, amalgamated, 64-bit GC 12 | @rem ps4build debug debug build, amalgamated, 64-bit GC 13 | @rem 14 | @rem Additional command-line options (not generally recommended): 15 | @rem 16 | @rem gc32 (before debug) 32-bit GC 17 | @rem noamalg (after debug) non-amalgamated build 18 | 19 | @if not defined INCLUDE goto :FAIL 20 | @if not defined SCE_ORBIS_SDK_DIR goto :FAIL 21 | 22 | @setlocal 23 | @rem ---- Host compiler ---- 24 | @set LJCOMPILE=cl /nologo /c /MD /O2 /W3 /D_CRT_SECURE_NO_DEPRECATE 25 | @set LJLINK=link /nologo 26 | @set LJMT=mt /nologo 27 | @set DASMDIR=..\dynasm 28 | @set DASM=%DASMDIR%\dynasm.lua 29 | @set ALL_LIB=lib_base.c lib_math.c lib_bit.c lib_string.c lib_table.c lib_io.c lib_os.c lib_package.c lib_debug.c lib_jit.c lib_ffi.c 30 | @set GC64=-DLUAJIT_ENABLE_GC64 31 | @set DASC=vm_x64.dasc 32 | 33 | @if "%1" neq "gc32" goto :NOGC32 34 | @shift 35 | @set GC64= 36 | @set DASC=vm_x86.dasc 37 | :NOGC32 38 | 39 | %LJCOMPILE% host\minilua.c 40 | @if errorlevel 1 goto :BAD 41 | %LJLINK% /out:minilua.exe minilua.obj 42 | @if errorlevel 1 goto :BAD 43 | if exist minilua.exe.manifest^ 44 | %LJMT% -manifest minilua.exe.manifest -outputresource:minilua.exe 45 | 46 | @rem Check for 64 bit host compiler. 47 | @minilua 48 | @if not errorlevel 8 goto :FAIL 49 | 50 | @set DASMFLAGS=-D P64 -D NO_UNWIND 51 | minilua %DASM% -LN %DASMFLAGS% -o host\buildvm_arch.h %DASC% 52 | @if errorlevel 1 goto :BAD 53 | 54 | %LJCOMPILE% /I "." /I %DASMDIR% %GC64% -DLUAJIT_TARGET=LUAJIT_ARCH_X64 -DLUAJIT_OS=LUAJIT_OS_OTHER -DLUAJIT_DISABLE_JIT -DLUAJIT_DISABLE_FFI -DLUAJIT_NO_UNWIND host\buildvm*.c 55 | @if errorlevel 1 goto :BAD 56 | %LJLINK% /out:buildvm.exe buildvm*.obj 57 | @if errorlevel 1 goto :BAD 58 | if exist buildvm.exe.manifest^ 59 | %LJMT% -manifest buildvm.exe.manifest -outputresource:buildvm.exe 60 | 61 | buildvm -m elfasm -o lj_vm.s 62 | @if errorlevel 1 goto :BAD 63 | buildvm -m bcdef -o lj_bcdef.h %ALL_LIB% 64 | @if errorlevel 1 goto :BAD 65 | buildvm -m ffdef -o lj_ffdef.h %ALL_LIB% 66 | @if errorlevel 1 goto :BAD 67 | buildvm -m libdef -o lj_libdef.h %ALL_LIB% 68 | @if errorlevel 1 goto :BAD 69 | buildvm -m recdef -o lj_recdef.h %ALL_LIB% 70 | @if errorlevel 1 goto :BAD 71 | buildvm -m vmdef -o jit\vmdef.lua %ALL_LIB% 72 | @if errorlevel 1 goto :BAD 73 | buildvm -m folddef -o lj_folddef.h lj_opt_fold.c 74 | @if errorlevel 1 goto :BAD 75 | 76 | @rem ---- Cross compiler ---- 77 | @set LJCOMPILE="%SCE_ORBIS_SDK_DIR%\host_tools\bin\orbis-clang" -c -Wall -DLUAJIT_DISABLE_FFI %GC64% 78 | @set LJLIB="%SCE_ORBIS_SDK_DIR%\host_tools\bin\orbis-ar" rcus 79 | @set INCLUDE="" 80 | 81 | orbis-as -o lj_vm.o lj_vm.s 82 | 83 | @if "%1" neq "debug" goto :NODEBUG 84 | @shift 85 | @set LJCOMPILE=%LJCOMPILE% -g -O0 86 | @set TARGETLIB=libluajitD_ps4.a 87 | goto :BUILD 88 | :NODEBUG 89 | @set LJCOMPILE=%LJCOMPILE% -O2 90 | @set TARGETLIB=libluajit_ps4.a 91 | :BUILD 92 | del %TARGETLIB% 93 | @if "%1" neq "noamalg" goto :AMALG 94 | for %%f in (lj_*.c lib_*.c) do ( 95 | %LJCOMPILE% %%f 96 | @if errorlevel 1 goto :BAD 97 | ) 98 | 99 | %LJLIB% %TARGETLIB% lj_*.o lib_*.o 100 | @if errorlevel 1 goto :BAD 101 | @goto :NOAMALG 102 | :AMALG 103 | %LJCOMPILE% ljamalg.c 104 | @if errorlevel 1 goto :BAD 105 | %LJLIB% %TARGETLIB% ljamalg.o lj_vm.o 106 | @if errorlevel 1 goto :BAD 107 | :NOAMALG 108 | 109 | @del *.o *.obj *.manifest minilua.exe buildvm.exe 110 | @echo. 111 | @echo === Successfully built LuaJIT for PS4 === 112 | 113 | @goto :END 114 | :BAD 115 | @echo. 116 | @echo ******************************************************* 117 | @echo *** Build FAILED -- Please check the error messages *** 118 | @echo ******************************************************* 119 | @goto :END 120 | :FAIL 121 | @echo To run this script you must open a "Visual Studio .NET Command Prompt" 122 | @echo (64 bit host compiler). The PS4 Orbis SDK must be installed, too. 123 | :END 124 | -------------------------------------------------------------------------------- /deps/luajit/src/psvitabuild.bat: -------------------------------------------------------------------------------- 1 | @rem Script to build LuaJIT with the PS Vita SDK. 2 | @rem Donated to the public domain. 3 | @rem 4 | @rem Open a "Visual Studio .NET Command Prompt" (32 bit host compiler) 5 | @rem Then cd to this directory and run this script. 6 | 7 | @if not defined INCLUDE goto :FAIL 8 | @if not defined SCE_PSP2_SDK_DIR goto :FAIL 9 | 10 | @setlocal 11 | @rem ---- Host compiler ---- 12 | @set LJCOMPILE=cl /nologo /c /MD /O2 /W3 /D_CRT_SECURE_NO_DEPRECATE 13 | @set LJLINK=link /nologo 14 | @set LJMT=mt /nologo 15 | @set DASMDIR=..\dynasm 16 | @set DASM=%DASMDIR%\dynasm.lua 17 | @set ALL_LIB=lib_base.c lib_math.c lib_bit.c lib_string.c lib_table.c lib_io.c lib_os.c lib_package.c lib_debug.c lib_jit.c lib_ffi.c 18 | 19 | %LJCOMPILE% host\minilua.c 20 | @if errorlevel 1 goto :BAD 21 | %LJLINK% /out:minilua.exe minilua.obj 22 | @if errorlevel 1 goto :BAD 23 | if exist minilua.exe.manifest^ 24 | %LJMT% -manifest minilua.exe.manifest -outputresource:minilua.exe 25 | 26 | @rem Check for 32 bit host compiler. 27 | @minilua 28 | @if errorlevel 8 goto :FAIL 29 | 30 | @set DASMFLAGS=-D FPU -D HFABI 31 | minilua %DASM% -LN %DASMFLAGS% -o host\buildvm_arch.h vm_arm.dasc 32 | @if errorlevel 1 goto :BAD 33 | 34 | %LJCOMPILE% /I "." /I %DASMDIR% -DLUAJIT_TARGET=LUAJIT_ARCH_ARM -DLUAJIT_OS=LUAJIT_OS_OTHER -DLUAJIT_DISABLE_JIT -DLUAJIT_DISABLE_FFI -DLJ_TARGET_PSVITA=1 host\buildvm*.c 35 | @if errorlevel 1 goto :BAD 36 | %LJLINK% /out:buildvm.exe buildvm*.obj 37 | @if errorlevel 1 goto :BAD 38 | if exist buildvm.exe.manifest^ 39 | %LJMT% -manifest buildvm.exe.manifest -outputresource:buildvm.exe 40 | 41 | buildvm -m elfasm -o lj_vm.s 42 | @if errorlevel 1 goto :BAD 43 | buildvm -m bcdef -o lj_bcdef.h %ALL_LIB% 44 | @if errorlevel 1 goto :BAD 45 | buildvm -m ffdef -o lj_ffdef.h %ALL_LIB% 46 | @if errorlevel 1 goto :BAD 47 | buildvm -m libdef -o lj_libdef.h %ALL_LIB% 48 | @if errorlevel 1 goto :BAD 49 | buildvm -m recdef -o lj_recdef.h %ALL_LIB% 50 | @if errorlevel 1 goto :BAD 51 | buildvm -m vmdef -o jit\vmdef.lua %ALL_LIB% 52 | @if errorlevel 1 goto :BAD 53 | buildvm -m folddef -o lj_folddef.h lj_opt_fold.c 54 | @if errorlevel 1 goto :BAD 55 | 56 | @rem ---- Cross compiler ---- 57 | @set LJCOMPILE="%SCE_PSP2_SDK_DIR%\host_tools\build\bin\psp2snc" -c -w -DLUAJIT_DISABLE_FFI -DLUAJIT_USE_SYSMALLOC 58 | @set LJLIB="%SCE_PSP2_SDK_DIR%\host_tools\build\bin\psp2ld32" -r --output= 59 | @set INCLUDE="" 60 | 61 | "%SCE_PSP2_SDK_DIR%\host_tools\build\bin\psp2as" -o lj_vm.o lj_vm.s 62 | 63 | @if "%1" neq "debug" goto :NODEBUG 64 | @shift 65 | @set LJCOMPILE=%LJCOMPILE% -g -O0 66 | @set TARGETLIB=libluajitD.a 67 | goto :BUILD 68 | :NODEBUG 69 | @set LJCOMPILE=%LJCOMPILE% -O2 70 | @set TARGETLIB=libluajit.a 71 | :BUILD 72 | del %TARGETLIB% 73 | 74 | %LJCOMPILE% ljamalg.c 75 | @if errorlevel 1 goto :BAD 76 | %LJLIB%%TARGETLIB% ljamalg.o lj_vm.o 77 | @if errorlevel 1 goto :BAD 78 | 79 | @del *.o *.obj *.manifest minilua.exe buildvm.exe 80 | @echo. 81 | @echo === Successfully built LuaJIT for PS Vita === 82 | 83 | @goto :END 84 | :BAD 85 | @echo. 86 | @echo ******************************************************* 87 | @echo *** Build FAILED -- Please check the error messages *** 88 | @echo ******************************************************* 89 | @goto :END 90 | :FAIL 91 | @echo To run this script you must open a "Visual Studio .NET Command Prompt" 92 | @echo (32 bit host compiler). The PS Vita SDK must be installed, too. 93 | :END 94 | -------------------------------------------------------------------------------- /deps/luajit/src/xb1build.bat: -------------------------------------------------------------------------------- 1 | @rem Script to build LuaJIT with the Xbox One SDK. 2 | @rem Donated to the public domain. 3 | @rem 4 | @rem Open a "Visual Studio .NET Command Prompt" (64 bit host compiler) 5 | @rem Then cd to this directory and run this script. 6 | 7 | @if not defined INCLUDE goto :FAIL 8 | @if not defined DurangoXDK goto :FAIL 9 | 10 | @setlocal 11 | @echo ---- Host compiler ---- 12 | @set LJCOMPILE=cl /nologo /c /MD /O2 /W3 /D_CRT_SECURE_NO_DEPRECATE /DLUAJIT_ENABLE_GC64 13 | @set LJLINK=link /nologo 14 | @set LJMT=mt /nologo 15 | @set DASMDIR=..\dynasm 16 | @set DASM=%DASMDIR%\dynasm.lua 17 | @set ALL_LIB=lib_base.c lib_math.c lib_bit.c lib_string.c lib_table.c lib_io.c lib_os.c lib_package.c lib_debug.c lib_jit.c lib_ffi.c 18 | 19 | %LJCOMPILE% host\minilua.c 20 | @if errorlevel 1 goto :BAD 21 | %LJLINK% /out:minilua.exe minilua.obj 22 | @if errorlevel 1 goto :BAD 23 | if exist minilua.exe.manifest^ 24 | %LJMT% -manifest minilua.exe.manifest -outputresource:minilua.exe 25 | 26 | @rem Error out for 64 bit host compiler 27 | @minilua 28 | @if not errorlevel 8 goto :FAIL 29 | 30 | @set DASMFLAGS=-D WIN -D FFI -D P64 31 | minilua %DASM% -LN %DASMFLAGS% -o host\buildvm_arch.h vm_x64.dasc 32 | @if errorlevel 1 goto :BAD 33 | 34 | %LJCOMPILE% /I "." /I %DASMDIR% /D_DURANGO host\buildvm*.c 35 | @if errorlevel 1 goto :BAD 36 | %LJLINK% /out:buildvm.exe buildvm*.obj 37 | @if errorlevel 1 goto :BAD 38 | if exist buildvm.exe.manifest^ 39 | %LJMT% -manifest buildvm.exe.manifest -outputresource:buildvm.exe 40 | 41 | buildvm -m peobj -o lj_vm.obj 42 | @if errorlevel 1 goto :BAD 43 | buildvm -m bcdef -o lj_bcdef.h %ALL_LIB% 44 | @if errorlevel 1 goto :BAD 45 | buildvm -m ffdef -o lj_ffdef.h %ALL_LIB% 46 | @if errorlevel 1 goto :BAD 47 | buildvm -m libdef -o lj_libdef.h %ALL_LIB% 48 | @if errorlevel 1 goto :BAD 49 | buildvm -m recdef -o lj_recdef.h %ALL_LIB% 50 | @if errorlevel 1 goto :BAD 51 | buildvm -m vmdef -o jit\vmdef.lua %ALL_LIB% 52 | @if errorlevel 1 goto :BAD 53 | buildvm -m folddef -o lj_folddef.h lj_opt_fold.c 54 | @if errorlevel 1 goto :BAD 55 | 56 | @echo ---- Cross compiler ---- 57 | 58 | @set CWD=%cd% 59 | @call "%DurangoXDK%\xdk\DurangoVars.cmd" XDK 60 | @cd /D "%CWD%" 61 | @shift 62 | 63 | @set LJCOMPILE="cl" /nologo /c /W3 /GF /Gm- /GR- /GS- /Gy /openmp- /D_CRT_SECURE_NO_DEPRECATE /D_LIB /D_UNICODE /D_DURANGO 64 | @set LJLIB="lib" /nologo 65 | 66 | @if "%1"=="debug" ( 67 | @shift 68 | @set LJCOMPILE=%LJCOMPILE% /Zi /MDd /Od 69 | @set LJLINK=%LJLINK% /debug 70 | ) else ( 71 | @set LJCOMPILE=%LJCOMPILE% /MD /O2 /DNDEBUG 72 | ) 73 | 74 | @if "%1"=="amalg" goto :AMALG 75 | %LJCOMPILE% /DLUA_BUILD_AS_DLL lj_*.c lib_*.c 76 | @if errorlevel 1 goto :BAD 77 | %LJLIB% /OUT:luajit.lib lj_*.obj lib_*.obj 78 | @if errorlevel 1 goto :BAD 79 | @goto :NOAMALG 80 | :AMALG 81 | %LJCOMPILE% /DLUA_BUILD_AS_DLL ljamalg.c 82 | @if errorlevel 1 goto :BAD 83 | %LJLIB% /OUT:luajit.lib ljamalg.obj lj_vm.obj 84 | @if errorlevel 1 goto :BAD 85 | :NOAMALG 86 | 87 | @del *.obj *.manifest minilua.exe buildvm.exe 88 | @echo. 89 | @echo === Successfully built LuaJIT for Xbox One === 90 | 91 | @goto :END 92 | :BAD 93 | @echo. 94 | @echo ******************************************************* 95 | @echo *** Build FAILED -- Please check the error messages *** 96 | @echo ******************************************************* 97 | @goto :END 98 | :FAIL 99 | @echo To run this script you must open a "Visual Studio .NET Command Prompt" 100 | @echo (64 bit host compiler). The Xbox One SDK must be installed, too. 101 | :END 102 | -------------------------------------------------------------------------------- /deps/luajit/src/xedkbuild.bat: -------------------------------------------------------------------------------- 1 | @rem Script to build LuaJIT with the Xbox 360 SDK. 2 | @rem Donated to the public domain. 3 | @rem 4 | @rem Open a "Visual Studio .NET Command Prompt" (32 bit host compiler) 5 | @rem Then cd to this directory and run this script. 6 | 7 | @if not defined INCLUDE goto :FAIL 8 | @if not defined XEDK goto :FAIL 9 | 10 | @setlocal 11 | @rem ---- Host compiler ---- 12 | @set LJCOMPILE=cl /nologo /c /MD /O2 /W3 /D_CRT_SECURE_NO_DEPRECATE 13 | @set LJLINK=link /nologo 14 | @set LJMT=mt /nologo 15 | @set DASMDIR=..\dynasm 16 | @set DASM=%DASMDIR%\dynasm.lua 17 | @set ALL_LIB=lib_base.c lib_math.c lib_bit.c lib_string.c lib_table.c lib_io.c lib_os.c lib_package.c lib_debug.c lib_jit.c lib_ffi.c 18 | 19 | %LJCOMPILE% host\minilua.c 20 | @if errorlevel 1 goto :BAD 21 | %LJLINK% /out:minilua.exe minilua.obj 22 | @if errorlevel 1 goto :BAD 23 | if exist minilua.exe.manifest^ 24 | %LJMT% -manifest minilua.exe.manifest -outputresource:minilua.exe 25 | 26 | @rem Error out for 64 bit host compiler 27 | @minilua 28 | @if errorlevel 8 goto :FAIL 29 | 30 | @set DASMFLAGS=-D GPR64 -D FRAME32 -D PPE -D SQRT -D DUALNUM 31 | minilua %DASM% -LN %DASMFLAGS% -o host\buildvm_arch.h vm_ppc.dasc 32 | @if errorlevel 1 goto :BAD 33 | 34 | %LJCOMPILE% /I "." /I %DASMDIR% /D_XBOX_VER=200 /DLUAJIT_TARGET=LUAJIT_ARCH_PPC host\buildvm*.c 35 | @if errorlevel 1 goto :BAD 36 | %LJLINK% /out:buildvm.exe buildvm*.obj 37 | @if errorlevel 1 goto :BAD 38 | if exist buildvm.exe.manifest^ 39 | %LJMT% -manifest buildvm.exe.manifest -outputresource:buildvm.exe 40 | 41 | buildvm -m peobj -o lj_vm.obj 42 | @if errorlevel 1 goto :BAD 43 | buildvm -m bcdef -o lj_bcdef.h %ALL_LIB% 44 | @if errorlevel 1 goto :BAD 45 | buildvm -m ffdef -o lj_ffdef.h %ALL_LIB% 46 | @if errorlevel 1 goto :BAD 47 | buildvm -m libdef -o lj_libdef.h %ALL_LIB% 48 | @if errorlevel 1 goto :BAD 49 | buildvm -m recdef -o lj_recdef.h %ALL_LIB% 50 | @if errorlevel 1 goto :BAD 51 | buildvm -m vmdef -o jit\vmdef.lua %ALL_LIB% 52 | @if errorlevel 1 goto :BAD 53 | buildvm -m folddef -o lj_folddef.h lj_opt_fold.c 54 | @if errorlevel 1 goto :BAD 55 | 56 | @rem ---- Cross compiler ---- 57 | @set LJCOMPILE="%XEDK%\bin\win32\cl" /nologo /c /MT /O2 /W3 /GF /Gm- /GR- /GS- /Gy /openmp- /D_CRT_SECURE_NO_DEPRECATE /DNDEBUG /D_XBOX /D_LIB /DLUAJIT_USE_SYSMALLOC 58 | @set LJLIB="%XEDK%\bin\win32\lib" /nologo 59 | @set "INCLUDE=%XEDK%\include\xbox" 60 | 61 | @if "%1" neq "debug" goto :NODEBUG 62 | @shift 63 | @set "LJCOMPILE=%LJCOMPILE% /Zi" 64 | :NODEBUG 65 | @if "%1"=="amalg" goto :AMALG 66 | %LJCOMPILE% /DLUA_BUILD_AS_DLL lj_*.c lib_*.c 67 | @if errorlevel 1 goto :BAD 68 | %LJLIB% /OUT:luajit20.lib lj_*.obj lib_*.obj 69 | @if errorlevel 1 goto :BAD 70 | @goto :NOAMALG 71 | :AMALG 72 | %LJCOMPILE% /DLUA_BUILD_AS_DLL ljamalg.c 73 | @if errorlevel 1 goto :BAD 74 | %LJLIB% /OUT:luajit20.lib ljamalg.obj lj_vm.obj 75 | @if errorlevel 1 goto :BAD 76 | :NOAMALG 77 | 78 | @del *.obj *.manifest minilua.exe buildvm.exe 79 | @echo. 80 | @echo === Successfully built LuaJIT for Xbox 360 === 81 | 82 | @goto :END 83 | :BAD 84 | @echo. 85 | @echo ******************************************************* 86 | @echo *** Build FAILED -- Please check the error messages *** 87 | @echo ******************************************************* 88 | @goto :END 89 | :FAIL 90 | @echo To run this script you must open a "Visual Studio .NET Command Prompt" 91 | @echo (32 bit host compiler). The Xbox 360 SDK must be installed, too. 92 | :END 93 | -------------------------------------------------------------------------------- /docker/Dockerfile.benchmark-container-prometheus-export: -------------------------------------------------------------------------------- 1 | # Leave empty for x86, set to e.g. "arm64v8/" (note closing slash!) for ARM, e,g, 2 | # $ docker build --build-arg ARCH="arm64v8/" -t wrk2-arm -f docker/Dockerfile.benchmark-container-prometheus-export . 3 | ARG ARCH="" 4 | 5 | FROM ${ARCH}alpine as builder 6 | MAINTAINER Kinvolk 7 | 8 | WORKDIR /usr/src 9 | RUN apk add --update alpine-sdk zlib-dev openssl-dev wget lua lua-dev luarocks 10 | RUN luarocks-5.1 install luasocket 11 | COPY ./ /usr/src/wrk2-cache-stresser 12 | RUN cd wrk2-cache-stresser && \ 13 | make clean && \ 14 | make -j && \ 15 | strip wrk 16 | 17 | 18 | 19 | FROM ${ARCH}alpine 20 | MAINTAINER Kinvolk 21 | 22 | RUN apk add --update --no-cache expect curl util-linux \ 23 | so:libcrypto.so.1.1 so:libssl.so.1.1 so:libgcc_s.so.1 24 | 25 | COPY --from=builder /usr/src/wrk2-cache-stresser/wrk /usr/local/bin/ 26 | COPY --from=builder /usr/local/lib/lua/ /usr/local/lib/lua/ 27 | COPY --from=builder /usr/local/share/lua/ /usr/local/share/lua/ 28 | COPY --from=builder /usr/src/wrk2-cache-stresser/scripts/multiple-endpoints-prometheus-metrics.lua /usr/local/bin/ 29 | 30 | RUN mkdir /tmpfs 31 | 32 | COPY ./docker/prometheus-export-wrapper /usr/local/bin/ 33 | 34 | ENTRYPOINT ["/usr/local/bin/prometheus-export-wrapper"] 35 | -------------------------------------------------------------------------------- /docker/Dockerfile.cache-stresser: -------------------------------------------------------------------------------- 1 | FROM alpine as builder 2 | MAINTAINER Kinvolk 3 | 4 | WORKDIR /usr/src 5 | RUN apk add --update alpine-sdk zlib-dev openssl-dev wget 6 | COPY ./ /usr/src/wrk2-cache-stresser 7 | RUN cd wrk2-cache-stresser && \ 8 | make clean && \ 9 | make -j && \ 10 | strip wrk 11 | 12 | FROM alpine 13 | MAINTAINER Kinvolk 14 | 15 | RUN apk add --update --no-cache curl nload\ 16 | so:libcrypto.so.1.1 so:libssl.so.1.1 so:libgcc_s.so.1 17 | 18 | COPY --from=builder /usr/src/wrk2-cache-stresser/wrk /usr/local/bin/ 19 | COPY --from=builder /usr/src/wrk2-cache-stresser/scripts/cache-stresser.lua /usr/local/bin/ 20 | COPY ./docker/setup-cache-stresser /usr/local/bin/ 21 | 22 | ENTRYPOINT ["/usr/local/bin/setup-cache-stresser"] 23 | -------------------------------------------------------------------------------- /docker/README.md: -------------------------------------------------------------------------------- 1 | # docker files 2 | 3 | This is a collection of Docker image build files for various purposes. 4 | 5 | ## Building an image 6 | 7 | Builds need to run from the top-level directory since the sources will be 8 | copied to the builder image during the course of the build. 9 | 10 | Build the image by referencing the respective docker file from the repository 11 | root: 12 | 13 | ```shell 14 | $ docker build [-t ] -f docker/ . 15 | ``` 16 | e.g. 17 | ```shell 18 | $ docker build -t cache-stresser -f docker/Dockerfile.cache-stresser . 19 | ``` 20 | 21 | ## wrk2 with Prometheus stats export 22 | 23 | A tiny Docker image based on Alpine which can export both run-time metrics (current RPS, resource usage) and result metrics (overall RPS, latency histogramm). The container image wraps `wrk2` into `prometheus-export-wrapper`, emitting metrics to a prometheus [push-gateway](https://github.com/prometheus/pushgateway). 24 | The image can be built for (at least) both x86_64 (the default) and ARM64. 25 | 26 | For x86 simply use 27 | ```shell 28 | $ docker build -t wrk2 -f docker/Dockerfile.benchmark-container-prometheus-export . 29 | ``` 30 | 31 | and for ARM64 use 32 | ```shell 33 | $ docker build --build-arg ARCH="arm64v8/" -t wrk2-arm -f docker/Dockerfile.benchmark-container-prometheus-export . 34 | ``` 35 | 36 | 37 | ## Cache-stresser 38 | A tiny Docker image based on Alpine for stressing CDN / cache servers. 39 | 40 | We maintain an up-to-date container image at 41 | [quay.io](http://quay.io/kinvolk/cache-stresser). 42 | 43 | 44 | ### Using the container to run stress tests 45 | 46 | Please **NOTE** the it-looks-like-a-http-url-but-actually-isn't-quite URL format: 47 | `http[s]:////...` 48 | 49 | ```shell 50 | $ docker run -ti cache-stresser \ 51 | [-c ] \ 52 | [-r ] \ 53 | [-d ] \ 54 | http[s]:////path \ 55 | [ http[s]:////path ] \ 56 | ... 57 | 58 | ``` 59 | 60 | By default, the stresser uses 10 concurrent connections overall(i.e. 5 per 61 | cache server in the above example), with an overall of 10 requests per second - 62 | that's 1 request per second, per connection. The stress test duration is 60 seconds by default. 63 | 64 | While the test is running it will display throughput per interface via the `nload` utility. After the test is done, 65 | throughput, RPS, and latency statistics will be displayed. 66 | -------------------------------------------------------------------------------- /docker/setup-cache-stresser: -------------------------------------------------------------------------------- 1 | #!/bin/ash 2 | # 3 | # Wrapper script around wrk to provide options specific to cache server 4 | # stressing. 5 | # 6 | 7 | 8 | [ -z "$1" -o "help" = "$1" -o "-h" = "$1" -o "--help" = "$1" ] && { 9 | echo "Usage:" 10 | echo " docker run -ti quay.io/kinvolk/wrk2-cachestress \\" 11 | echo " [-c ] \\" 12 | echo " [-r ] \\" 13 | echo " [-d ] \\" 14 | echo " http[s]:////path \\" 15 | echo " [ http[s]:////path] \\" 16 | echo " ..." 17 | echo 18 | echo "Please NOTE the looks-like-a-http-url-but-actually-isn't URL format:" 19 | echo "http[s]:////..." 20 | echo 21 | exit 22 | } 23 | 24 | conn=10 25 | rps=10 26 | dur=60 27 | servers="" 28 | 29 | i=1; next="" 30 | for arg do 31 | [ "$arg" = "-c" ] && { next="conn"; continue; } 32 | [ "$arg" = "-r" ] && { next="rps"; continue; } 33 | [ "$arg" = "-d" ] && { next="dur"; continue; } 34 | 35 | [ -n "$next" ] && { eval $next="$arg"; next=""; continue; } 36 | 37 | servers="$servers $arg" 38 | done 39 | 40 | 41 | echo "Running stresser with:" 42 | echo "conn: $conn" 43 | echo "rps: $rps" 44 | echo "duration: $dur" 45 | echo "servers: $servers" 46 | echo "---" 47 | 48 | sleep 1 49 | 50 | > /status 51 | 52 | ( while ! grep -q "DONE" "/status"; do sleep 1; done; 53 | killall -9 nload 54 | ) & 55 | 56 | ( /usr/local/bin/wrk -s /usr/local/bin/cache-stresser.lua \ 57 | --lua-dont-pass-body \ 58 | -R "$rps" -c "$conn" -t "$conn" -d "$dur" \ 59 | $servers; 60 | echo "DONE" ) > /status & 61 | 62 | nload -m 63 | 64 | reset 65 | 66 | cat status 67 | -------------------------------------------------------------------------------- /scripts/addr.lua: -------------------------------------------------------------------------------- 1 | -- example script that demonstrates use of setup() to pass 2 | -- a random server address to each thread 3 | 4 | local addrs = nil 5 | 6 | function setup(thread) 7 | if not addrs then 8 | addrs = wrk.lookup(wrk.host, wrk.port or "http") 9 | for i = #addrs, 1, -1 do 10 | if not wrk.connect(addrs[i]) then 11 | table.remove(addrs, i) 12 | end 13 | end 14 | end 15 | 16 | thread.addr = addrs[math.random(#addrs)] 17 | end 18 | 19 | function init(args) 20 | local msg = "thread addr: %s" 21 | print(msg:format(wrk.thread.addr)) 22 | end 23 | -------------------------------------------------------------------------------- /scripts/auth.lua: -------------------------------------------------------------------------------- 1 | -- example script that demonstrates response handling and 2 | -- retrieving an authentication token to set on all future 3 | -- requests 4 | 5 | token = nil 6 | path = "/authenticate" 7 | 8 | request = function() 9 | return wrk.format("GET", path) 10 | end 11 | 12 | response = function(status, headers, body) 13 | if not token and status == 200 then 14 | token = headers["X-Token"] 15 | path = "/resource" 16 | wrk.headers["X-Token"] = token 17 | end 18 | end 19 | -------------------------------------------------------------------------------- /scripts/counter.lua: -------------------------------------------------------------------------------- 1 | -- example dynamic request script which demonstrates changing 2 | -- the request path and a header for each request 3 | ------------------------------------------------------------- 4 | -- NOTE: each wrk thread has an independent Lua scripting 5 | -- context and thus there will be one counter per thread 6 | 7 | counter = 0 8 | 9 | request = function() 10 | path = "/" .. counter 11 | wrk.headers["X-Counter"] = counter 12 | counter = counter + 1 13 | return wrk.format(nil, path) 14 | end 15 | -------------------------------------------------------------------------------- /scripts/multi-server.lua: -------------------------------------------------------------------------------- 1 | -- This script extends wrk2 to handle multiple server addresses, and multiple 2 | -- paths on each server. 3 | 4 | local threads = {} 5 | local counter = 1 6 | 7 | -- Global context 8 | 9 | function setup(thread) 10 | table.insert(threads, thread) 11 | thread:set("id",counter) 12 | counter = counter +1 13 | math.randomseed(os.time()) 14 | math.random(); math.random(); math.random() 15 | end 16 | 17 | -- Thread context 18 | 19 | function thread_next_server() 20 | idx = math.random(#reqs) 21 | local next_addr = string.format("%s", addrs[idx]) 22 | if curr_addr ~= "" and next_addr ~= curr_addr then 23 | wrk.thread.addr = addrs[idx] 24 | end 25 | curr_addr = next_addr 26 | end 27 | 28 | 29 | function init(args) 30 | urls = "" 31 | counts = "" 32 | reqs = {""} 33 | c_resps = 0 34 | c_requs = 0 35 | addrs = {} 36 | curr_addr = "" 37 | idx = 0 38 | 39 | if 2 > #args then 40 | --print("Usage: wrk ") 41 | os.exit(1) 42 | end 43 | 44 | -- the dash ("-") is magic in lua, so we need to escape it. 45 | local match = string.gsub(args[1], '-', '%%%-') 46 | local count = tonumber(args[2],10) 47 | local p = wrk.port 48 | if not p then p="" else p=":" .. p end 49 | 50 | local paths={} 51 | for i=3, #args, 1 do 52 | if "/" == args[i]:sub(1,1) then 53 | paths[i-2] = args[i] 54 | else 55 | paths[i-2] = "/" .. args[i] 56 | end 57 | end 58 | if 0 == #paths then 59 | paths[1] = "/" 60 | end 61 | 62 | for i=1, count, 1 do 63 | local repl = string.gsub(match, "-[0-9]+$", string.format("-%d",i)) 64 | local host = string.gsub(wrk.host, match, repl) 65 | for j=1, #paths, 1 do 66 | local idx = (i-1) * #paths + j 67 | for k, v in ipairs(wrk.lookup(host, wrk.port or "http")) do 68 | addrs[idx] = v; break 69 | end 70 | reqs[idx] = string.format( 71 | "GET %s HTTP/1.1\r\n" 72 | .. "Host:%s%s\r\n\r\n", 73 | paths[j], host, p) 74 | urls = string.format("%s,(%s) %s://%s%s%s", 75 | urls, addrs[idx], wrk.scheme, host, p, paths[j]) 76 | end 77 | end 78 | 79 | urls = urls .. "," 80 | thread_next_server() 81 | end 82 | 83 | 84 | function request() 85 | local ret = reqs[idx] 86 | 87 | if counts == "" then 88 | counts = tostring(idx) 89 | else 90 | counts = string.format("%s,%s", counts, tostring(idx)) 91 | end 92 | 93 | c_requs = c_requs + 1 94 | return ret 95 | end 96 | 97 | 98 | function response(status, headers, body) 99 | c_resps = c_resps + 1 100 | thread_next_server() 101 | end 102 | 103 | -- Global context 104 | 105 | function done(summary, latency, requests) 106 | print(string.format("Total Requests: %d", summary.requests)) 107 | print(string.format("HTTP errors: %d", summary.errors.status)) 108 | print(string.format("Requests timed out: %d", summary.errors.timeout)) 109 | print(string.format("Bytes received: %d", summary.bytes)) 110 | print(string.format("Socket connect errors: %d", summary.errors.connect)) 111 | print(string.format("Socket read errors: %d", summary.errors.read)) 112 | print(string.format("Socket write errors: %d", summary.errors.write)) 113 | 114 | -- generate table of URLs from first thread's string (all threads use same list) 115 | local urls = {} 116 | local c_requs = 0 117 | local c_resps = 0 118 | t = unpack(threads,1,2) 119 | t:get("urls"):gsub("([^,]+),", function(u) table.insert(urls, u) end) 120 | 121 | local counts = {} 122 | for i=1, #urls, 1 do 123 | counts[i] = 0 124 | end 125 | 126 | -- fetch url call counts of individual threads 127 | local c = t:get("counts") 128 | c = c .. "," 129 | for i, t in ipairs(threads) do 130 | c:gsub("([0-9]+),", function(s) 131 | i = tonumber(s) 132 | counts[i] = counts[i] + 1 133 | end) 134 | c_requs = c_requs + t:get("c_requs") 135 | c_resps = c_resps + t:get("c_resps") 136 | end 137 | 138 | print(string.format("total requests issued:%d, responses received within runtime:%d", c_requs, c_resps)) 139 | 140 | print("\nURL call count") 141 | for i=1, #urls, 1 do 142 | print(string.format("%s %d", urls[i], counts[i])) 143 | end 144 | 145 | end 146 | -------------------------------------------------------------------------------- /scripts/pipeline.lua: -------------------------------------------------------------------------------- 1 | -- example script demonstrating HTTP pipelining 2 | 3 | init = function(args) 4 | local r = {} 5 | r[1] = wrk.format(nil, "/?foo") 6 | r[2] = wrk.format(nil, "/?bar") 7 | r[3] = wrk.format(nil, "/?baz") 8 | 9 | req = table.concat(r) 10 | end 11 | 12 | request = function() 13 | return req 14 | end 15 | -------------------------------------------------------------------------------- /scripts/post.lua: -------------------------------------------------------------------------------- 1 | -- example HTTP POST script which demonstrates setting the 2 | -- HTTP method, body, and adding a header 3 | 4 | wrk.method = "POST" 5 | wrk.body = "foo=bar&baz=quux" 6 | wrk.headers["Content-Type"] = "application/x-www-form-urlencoded" 7 | -------------------------------------------------------------------------------- /scripts/report.lua: -------------------------------------------------------------------------------- 1 | -- example reporting script which demonstrates a custom 2 | -- done() function that prints latency percentiles as CSV 3 | 4 | done = function(summary, latency, requests) 5 | io.write("------------------------------\n") 6 | for _, p in pairs({ 50, 90, 99, 99.999 }) do 7 | n = latency:percentile(p) 8 | io.write(string.format("%g%%,%d\n", p, n)) 9 | end 10 | end 11 | -------------------------------------------------------------------------------- /scripts/setup.lua: -------------------------------------------------------------------------------- 1 | -- example script that demonstrates use of setup() to pass 2 | -- data to and from the threads 3 | 4 | local counter = 1 5 | local threads = {} 6 | 7 | function setup(thread) 8 | thread:set("id", counter) 9 | table.insert(threads, thread) 10 | counter = counter + 1 11 | end 12 | 13 | function init(args) 14 | requests = 0 15 | responses = 0 16 | 17 | local msg = "thread %d created" 18 | print(msg:format(id)) 19 | end 20 | 21 | function request() 22 | requests = requests + 1 23 | return wrk.request() 24 | end 25 | 26 | function response(status, headers, body) 27 | responses = responses + 1 28 | end 29 | 30 | function done(summary, latency, requests) 31 | for index, thread in ipairs(threads) do 32 | local id = thread:get("id") 33 | local requests = thread:get("requests") 34 | local responses = thread:get("responses") 35 | local msg = "thread %d made %d requests and got %d responses" 36 | print(msg:format(id, requests, responses)) 37 | end 38 | end 39 | -------------------------------------------------------------------------------- /scripts/stop.lua: -------------------------------------------------------------------------------- 1 | -- example script that demonstrates use of thread:stop() 2 | 3 | local counter = 1 4 | 5 | function response() 6 | if counter == 100 then 7 | wrk.thread:stop() 8 | end 9 | counter = counter + 1 10 | end 11 | -------------------------------------------------------------------------------- /src/ae.h: -------------------------------------------------------------------------------- 1 | /* A simple event-driven programming library. Originally I wrote this code 2 | * for the Jim's event-loop (Jim is a Tcl interpreter) but later translated 3 | * it in form of a library for easy reuse. 4 | * 5 | * Copyright (c) 2006-2012, Salvatore Sanfilippo 6 | * All rights reserved. 7 | * 8 | * Redistribution and use in source and binary forms, with or without 9 | * modification, are permitted provided that the following conditions are met: 10 | * 11 | * * Redistributions of source code must retain the above copyright notice, 12 | * this list of conditions and the following disclaimer. 13 | * * Redistributions in binary form must reproduce the above copyright 14 | * notice, this list of conditions and the following disclaimer in the 15 | * documentation and/or other materials provided with the distribution. 16 | * * Neither the name of Redis nor the names of its contributors may be used 17 | * to endorse or promote products derived from this software without 18 | * specific prior written permission. 19 | * 20 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 21 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 | * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 24 | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 | * POSSIBILITY OF SUCH DAMAGE. 31 | */ 32 | 33 | #ifndef __AE_H__ 34 | #define __AE_H__ 35 | 36 | #define AE_OK 0 37 | #define AE_ERR -1 38 | 39 | #define AE_NONE 0 40 | #define AE_READABLE 1 41 | #define AE_WRITABLE 2 42 | 43 | #define AE_FILE_EVENTS 1 44 | #define AE_TIME_EVENTS 2 45 | #define AE_ALL_EVENTS (AE_FILE_EVENTS|AE_TIME_EVENTS) 46 | #define AE_DONT_WAIT 4 47 | 48 | #define AE_NOMORE -1 49 | 50 | /* Macros */ 51 | #define AE_NOTUSED(V) ((void) V) 52 | 53 | struct aeEventLoop; 54 | 55 | /* Types and data structures */ 56 | typedef void aeFileProc(struct aeEventLoop *eventLoop, int fd, void *clientData, int mask); 57 | typedef int aeTimeProc(struct aeEventLoop *eventLoop, long long id, void *clientData); 58 | typedef void aeEventFinalizerProc(struct aeEventLoop *eventLoop, void *clientData); 59 | typedef void aeBeforeSleepProc(struct aeEventLoop *eventLoop); 60 | 61 | /* File event structure */ 62 | typedef struct aeFileEvent { 63 | int mask; /* one of AE_(READABLE|WRITABLE) */ 64 | aeFileProc *rfileProc; 65 | aeFileProc *wfileProc; 66 | void *clientData; 67 | } aeFileEvent; 68 | 69 | /* Time event structure */ 70 | typedef struct aeTimeEvent { 71 | long long id; /* time event identifier. */ 72 | long when_sec; /* seconds */ 73 | long when_ms; /* milliseconds */ 74 | aeTimeProc *timeProc; 75 | aeEventFinalizerProc *finalizerProc; 76 | void *clientData; 77 | struct aeTimeEvent *next; 78 | } aeTimeEvent; 79 | 80 | /* A fired event */ 81 | typedef struct aeFiredEvent { 82 | int fd; 83 | int mask; 84 | } aeFiredEvent; 85 | 86 | /* State of an event based program */ 87 | typedef struct aeEventLoop { 88 | int maxfd; /* highest file descriptor currently registered */ 89 | int setsize; /* max number of file descriptors tracked */ 90 | long long timeEventNextId; 91 | time_t lastTime; /* Used to detect system clock skew */ 92 | aeFileEvent *events; /* Registered events */ 93 | aeFiredEvent *fired; /* Fired events */ 94 | aeTimeEvent *timeEventHead; 95 | int stop; 96 | void *apidata; /* This is used for polling API specific data */ 97 | aeBeforeSleepProc *beforesleep; 98 | } aeEventLoop; 99 | 100 | /* Prototypes */ 101 | aeEventLoop *aeCreateEventLoop(int setsize); 102 | void aeDeleteEventLoop(aeEventLoop *eventLoop); 103 | void aeStop(aeEventLoop *eventLoop); 104 | int aeCreateFileEvent(aeEventLoop *eventLoop, int fd, int mask, 105 | aeFileProc *proc, void *clientData); 106 | void aeDeleteFileEvent(aeEventLoop *eventLoop, int fd, int mask); 107 | int aeGetFileEvents(aeEventLoop *eventLoop, int fd); 108 | long long aeCreateTimeEvent(aeEventLoop *eventLoop, long long milliseconds, 109 | aeTimeProc *proc, void *clientData, 110 | aeEventFinalizerProc *finalizerProc); 111 | int aeDeleteTimeEvent(aeEventLoop *eventLoop, long long id); 112 | int aeProcessEvents(aeEventLoop *eventLoop, int flags); 113 | int aeWait(int fd, int mask, long long milliseconds); 114 | void aeMain(aeEventLoop *eventLoop); 115 | char *aeGetApiName(void); 116 | void aeSetBeforeSleepProc(aeEventLoop *eventLoop, aeBeforeSleepProc *beforesleep); 117 | 118 | #endif 119 | -------------------------------------------------------------------------------- /src/ae_kqueue.c: -------------------------------------------------------------------------------- 1 | /* Kqueue(2)-based ae.c module 2 | * 3 | * Copyright (C) 2009 Harish Mallipeddi - harish.mallipeddi@gmail.com 4 | * All rights reserved. 5 | * 6 | * Redistribution and use in source and binary forms, with or without 7 | * modification, are permitted provided that the following conditions are met: 8 | * 9 | * * Redistributions of source code must retain the above copyright notice, 10 | * this list of conditions and the following disclaimer. 11 | * * Redistributions in binary form must reproduce the above copyright 12 | * notice, this list of conditions and the following disclaimer in the 13 | * documentation and/or other materials provided with the distribution. 14 | * * Neither the name of Redis nor the names of its contributors may be used 15 | * to endorse or promote products derived from this software without 16 | * specific prior written permission. 17 | * 18 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 19 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 | * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 22 | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 23 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 25 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 26 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 28 | * POSSIBILITY OF SUCH DAMAGE. 29 | */ 30 | 31 | 32 | #include 33 | #include 34 | #include 35 | 36 | typedef struct aeApiState { 37 | int kqfd; 38 | struct kevent *events; 39 | } aeApiState; 40 | 41 | static int aeApiCreate(aeEventLoop *eventLoop) { 42 | aeApiState *state = zmalloc(sizeof(aeApiState)); 43 | 44 | if (!state) return -1; 45 | state->events = zmalloc(sizeof(struct kevent)*eventLoop->setsize); 46 | if (!state->events) { 47 | zfree(state); 48 | return -1; 49 | } 50 | state->kqfd = kqueue(); 51 | if (state->kqfd == -1) { 52 | zfree(state->events); 53 | zfree(state); 54 | return -1; 55 | } 56 | eventLoop->apidata = state; 57 | 58 | return 0; 59 | } 60 | 61 | static void aeApiFree(aeEventLoop *eventLoop) { 62 | aeApiState *state = eventLoop->apidata; 63 | 64 | close(state->kqfd); 65 | zfree(state->events); 66 | zfree(state); 67 | } 68 | 69 | static int aeApiAddEvent(aeEventLoop *eventLoop, int fd, int mask) { 70 | aeApiState *state = eventLoop->apidata; 71 | struct kevent ke; 72 | 73 | if (mask & AE_READABLE) { 74 | EV_SET(&ke, fd, EVFILT_READ, EV_ADD, 0, 0, NULL); 75 | if (kevent(state->kqfd, &ke, 1, NULL, 0, NULL) == -1) return -1; 76 | } 77 | if (mask & AE_WRITABLE) { 78 | EV_SET(&ke, fd, EVFILT_WRITE, EV_ADD, 0, 0, NULL); 79 | if (kevent(state->kqfd, &ke, 1, NULL, 0, NULL) == -1) return -1; 80 | } 81 | return 0; 82 | } 83 | 84 | static void aeApiDelEvent(aeEventLoop *eventLoop, int fd, int mask) { 85 | aeApiState *state = eventLoop->apidata; 86 | struct kevent ke; 87 | 88 | if (mask & AE_READABLE) { 89 | EV_SET(&ke, fd, EVFILT_READ, EV_DELETE, 0, 0, NULL); 90 | kevent(state->kqfd, &ke, 1, NULL, 0, NULL); 91 | } 92 | if (mask & AE_WRITABLE) { 93 | EV_SET(&ke, fd, EVFILT_WRITE, EV_DELETE, 0, 0, NULL); 94 | kevent(state->kqfd, &ke, 1, NULL, 0, NULL); 95 | } 96 | } 97 | 98 | static int aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp) { 99 | aeApiState *state = eventLoop->apidata; 100 | int retval, numevents = 0; 101 | 102 | if (tvp != NULL) { 103 | struct timespec timeout; 104 | timeout.tv_sec = tvp->tv_sec; 105 | timeout.tv_nsec = tvp->tv_usec * 1000; 106 | retval = kevent(state->kqfd, NULL, 0, state->events, eventLoop->setsize, 107 | &timeout); 108 | } else { 109 | retval = kevent(state->kqfd, NULL, 0, state->events, eventLoop->setsize, 110 | NULL); 111 | } 112 | 113 | if (retval > 0) { 114 | int j; 115 | 116 | numevents = retval; 117 | for(j = 0; j < numevents; j++) { 118 | int mask = 0; 119 | struct kevent *e = state->events+j; 120 | 121 | if (e->filter == EVFILT_READ) mask |= AE_READABLE; 122 | if (e->filter == EVFILT_WRITE) mask |= AE_WRITABLE; 123 | eventLoop->fired[j].fd = e->ident; 124 | eventLoop->fired[j].mask = mask; 125 | } 126 | } 127 | return numevents; 128 | } 129 | 130 | static char *aeApiName(void) { 131 | return "kqueue"; 132 | } 133 | -------------------------------------------------------------------------------- /src/ae_select.c: -------------------------------------------------------------------------------- 1 | /* Select()-based ae.c module. 2 | * 3 | * Copyright (c) 2009-2012, Salvatore Sanfilippo 4 | * All rights reserved. 5 | * 6 | * Redistribution and use in source and binary forms, with or without 7 | * modification, are permitted provided that the following conditions are met: 8 | * 9 | * * Redistributions of source code must retain the above copyright notice, 10 | * this list of conditions and the following disclaimer. 11 | * * Redistributions in binary form must reproduce the above copyright 12 | * notice, this list of conditions and the following disclaimer in the 13 | * documentation and/or other materials provided with the distribution. 14 | * * Neither the name of Redis nor the names of its contributors may be used 15 | * to endorse or promote products derived from this software without 16 | * specific prior written permission. 17 | * 18 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 19 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 | * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 22 | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 23 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 25 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 26 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 28 | * POSSIBILITY OF SUCH DAMAGE. 29 | */ 30 | 31 | 32 | #include 33 | 34 | typedef struct aeApiState { 35 | fd_set rfds, wfds; 36 | /* We need to have a copy of the fd sets as it's not safe to reuse 37 | * FD sets after select(). */ 38 | fd_set _rfds, _wfds; 39 | } aeApiState; 40 | 41 | static int aeApiCreate(aeEventLoop *eventLoop) { 42 | aeApiState *state = zmalloc(sizeof(aeApiState)); 43 | 44 | if (!state) return -1; 45 | FD_ZERO(&state->rfds); 46 | FD_ZERO(&state->wfds); 47 | eventLoop->apidata = state; 48 | return 0; 49 | } 50 | 51 | static void aeApiFree(aeEventLoop *eventLoop) { 52 | zfree(eventLoop->apidata); 53 | } 54 | 55 | static int aeApiAddEvent(aeEventLoop *eventLoop, int fd, int mask) { 56 | aeApiState *state = eventLoop->apidata; 57 | 58 | if (mask & AE_READABLE) FD_SET(fd,&state->rfds); 59 | if (mask & AE_WRITABLE) FD_SET(fd,&state->wfds); 60 | return 0; 61 | } 62 | 63 | static void aeApiDelEvent(aeEventLoop *eventLoop, int fd, int mask) { 64 | aeApiState *state = eventLoop->apidata; 65 | 66 | if (mask & AE_READABLE) FD_CLR(fd,&state->rfds); 67 | if (mask & AE_WRITABLE) FD_CLR(fd,&state->wfds); 68 | } 69 | 70 | static int aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp) { 71 | aeApiState *state = eventLoop->apidata; 72 | int retval, j, numevents = 0; 73 | 74 | memcpy(&state->_rfds,&state->rfds,sizeof(fd_set)); 75 | memcpy(&state->_wfds,&state->wfds,sizeof(fd_set)); 76 | 77 | retval = select(eventLoop->maxfd+1, 78 | &state->_rfds,&state->_wfds,NULL,tvp); 79 | if (retval > 0) { 80 | for (j = 0; j <= eventLoop->maxfd; j++) { 81 | int mask = 0; 82 | aeFileEvent *fe = &eventLoop->events[j]; 83 | 84 | if (fe->mask == AE_NONE) continue; 85 | if (fe->mask & AE_READABLE && FD_ISSET(j,&state->_rfds)) 86 | mask |= AE_READABLE; 87 | if (fe->mask & AE_WRITABLE && FD_ISSET(j,&state->_wfds)) 88 | mask |= AE_WRITABLE; 89 | eventLoop->fired[numevents].fd = j; 90 | eventLoop->fired[numevents].mask = mask; 91 | numevents++; 92 | } 93 | } 94 | return numevents; 95 | } 96 | 97 | static char *aeApiName(void) { 98 | return "select"; 99 | } 100 | -------------------------------------------------------------------------------- /src/aprintf.c: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2012 - Will Glozer. All rights reserved. 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | char *aprintf(char **s, const char *fmt, ...) { 9 | char *c = NULL; 10 | int n, len; 11 | va_list ap; 12 | 13 | va_start(ap, fmt); 14 | n = vsnprintf(NULL, 0, fmt, ap) + 1; 15 | va_end(ap); 16 | 17 | len = *s ? strlen(*s) : 0; 18 | 19 | if ((*s = realloc(*s, (len + n) * sizeof(char)))) { 20 | c = *s + len; 21 | va_start(ap, fmt); 22 | vsnprintf(c, n, fmt, ap); 23 | va_end(ap); 24 | } 25 | 26 | return c; 27 | } 28 | -------------------------------------------------------------------------------- /src/aprintf.h: -------------------------------------------------------------------------------- 1 | #ifndef APRINTF_H 2 | #define APRINTF_H 3 | 4 | char *aprintf(char **, const char *, ...); 5 | 6 | #endif /* APRINTF_H */ 7 | -------------------------------------------------------------------------------- /src/config.h: -------------------------------------------------------------------------------- 1 | #ifndef CONFIG_H 2 | #define CONFIG_H 3 | 4 | #if defined(__FreeBSD__) || defined(__APPLE__) 5 | #define HAVE_KQUEUE 6 | #elif defined(__linux__) 7 | #define HAVE_EPOLL 8 | #define _POSIX_C_SOURCE 200809L 9 | #elif defined (__sun) 10 | #define HAVE_EVPORT 11 | #endif 12 | 13 | #endif /* CONFIG_H */ 14 | -------------------------------------------------------------------------------- /src/main.h: -------------------------------------------------------------------------------- 1 | #ifndef MAIN_H 2 | #define MAIN_H 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | 22 | #include "ssl.h" 23 | #include "aprintf.h" 24 | #include "stats.h" 25 | #include "units.h" 26 | #include "zmalloc.h" 27 | 28 | struct config; 29 | 30 | static void *thread_main(void *); 31 | static int connect_socket(thread *, connection *); 32 | static int reconnect_socket(thread *, connection *); 33 | 34 | static int calibrate(aeEventLoop *, long long, void *); 35 | static int sample_rate(aeEventLoop *, long long, void *); 36 | static int delayed_initial_connect(aeEventLoop *, long long, void *); 37 | static int check_timeouts(aeEventLoop *, long long, void *); 38 | 39 | static void socket_connected(aeEventLoop *, int, void *, int); 40 | static void socket_writeable(aeEventLoop *, int, void *, int); 41 | static void socket_readable(aeEventLoop *, int, void *, int); 42 | 43 | static int response_complete(http_parser *); 44 | static int header_field(http_parser *, const char *, size_t); 45 | static int header_value(http_parser *, const char *, size_t); 46 | static int response_body(http_parser *, const char *, size_t); 47 | 48 | static uint64_t time_us(); 49 | 50 | static int parse_args(struct config *, char **, struct http_parser_url *, char **, int, char **); 51 | static char *copy_url_part(char *, struct http_parser_url *, enum http_parser_url_fields); 52 | static void print_stats_header(); 53 | static void print_stats(char *, stats *, char *(*)(long double)); 54 | static void print_stats_latency(stats *); 55 | static void print_hdr_latency(struct hdr_histogram*, const char*); 56 | 57 | #endif /* MAIN_H */ 58 | -------------------------------------------------------------------------------- /src/net.c: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2013 - Will Glozer. All rights reserved. 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | #include "net.h" 8 | 9 | status sock_connect(connection *c, char *host) { 10 | return OK; 11 | } 12 | 13 | status sock_close(connection *c) { 14 | return OK; 15 | } 16 | 17 | status sock_read(connection *c, size_t *n) { 18 | ssize_t r = read(c->fd, c->buf, sizeof(c->buf)); 19 | *n = (size_t) r; 20 | if (r == 0) return READ_EOF; 21 | return r > 0 ? OK : ERROR; 22 | } 23 | 24 | status sock_write(connection *c, char *buf, size_t len, size_t *n) { 25 | ssize_t r; 26 | if ((r = write(c->fd, buf, len)) == -1) { 27 | switch (errno) { 28 | case EAGAIN: return RETRY; 29 | default: return ERROR; 30 | } 31 | } 32 | *n = (size_t) r; 33 | return OK; 34 | } 35 | 36 | size_t sock_readable(connection *c) { 37 | int n, rc; 38 | rc = ioctl(c->fd, FIONREAD, &n); 39 | return rc == -1 ? 0 : n; 40 | } 41 | -------------------------------------------------------------------------------- /src/net.h: -------------------------------------------------------------------------------- 1 | #ifndef NET_H 2 | #define NET_H 3 | 4 | #include "config.h" 5 | #include 6 | #include 7 | #include "wrk.h" 8 | 9 | typedef enum { 10 | OK, 11 | ERROR, 12 | RETRY, 13 | READ_EOF 14 | } status; 15 | 16 | struct sock { 17 | status ( *connect)(connection *, char *); 18 | status ( *close)(connection *); 19 | status ( *read)(connection *, size_t *); 20 | status ( *write)(connection *, char *, size_t, size_t *); 21 | size_t (*readable)(connection *); 22 | }; 23 | 24 | status sock_connect(connection *, char *); 25 | status sock_close(connection *); 26 | status sock_read(connection *, size_t *); 27 | status sock_write(connection *, char *, size_t, size_t *); 28 | size_t sock_readable(connection *); 29 | 30 | #endif /* NET_H */ 31 | -------------------------------------------------------------------------------- /src/script.h: -------------------------------------------------------------------------------- 1 | #ifndef SCRIPT_H 2 | #define SCRIPT_H 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include "stats.h" 10 | #include "wrk.h" 11 | 12 | lua_State *script_create(char *, char *, char **); 13 | 14 | bool script_resolve(lua_State *, char *, char *); 15 | void script_setup(lua_State *, thread *); 16 | void script_done(lua_State *, stats *, stats *); 17 | 18 | void script_init(lua_State *, thread *, int, char **); 19 | void script_request(lua_State *, char **, size_t *); 20 | void script_response(lua_State *, int, buffer *, buffer *); 21 | void script_teardown(lua_State *); 22 | size_t script_verify_request(lua_State *L); 23 | 24 | bool script_is_static(lua_State *); 25 | bool script_want_response(lua_State *L); 26 | bool script_has_teardown(lua_State *L); 27 | bool script_has_done(lua_State *L); 28 | void script_summary(lua_State *, uint64_t, uint64_t, uint64_t); 29 | void script_errors(lua_State *, errors *); 30 | 31 | void script_copy_value(lua_State *, lua_State *, int); 32 | int script_parse_url(char *, struct http_parser_url *); 33 | 34 | void buffer_append(buffer *, const char *, size_t); 35 | void buffer_reset(buffer *); 36 | char *buffer_pushlstring(lua_State *, char *); 37 | 38 | #endif /* SCRIPT_H */ 39 | -------------------------------------------------------------------------------- /src/ssl.c: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2013 - Will Glozer. All rights reserved. 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | #include "ssl.h" 10 | 11 | static pthread_mutex_t *locks; 12 | 13 | static void ssl_lock(int mode, int n, const char *file, int line) { 14 | pthread_mutex_t *lock = &locks[n]; 15 | if (mode & CRYPTO_LOCK) { 16 | pthread_mutex_lock(lock); 17 | } else { 18 | pthread_mutex_unlock(lock); 19 | } 20 | } 21 | 22 | static unsigned long ssl_id() { 23 | return (unsigned long) pthread_self(); 24 | } 25 | 26 | SSL_CTX *ssl_init() { 27 | SSL_CTX *ctx = NULL; 28 | 29 | SSL_load_error_strings(); 30 | SSL_library_init(); 31 | OpenSSL_add_all_algorithms(); 32 | 33 | if ((locks = calloc(CRYPTO_num_locks(), sizeof(pthread_mutex_t)))) { 34 | for (int i = 0; i < CRYPTO_num_locks(); i++) { 35 | pthread_mutex_init(&locks[i], NULL); 36 | } 37 | 38 | CRYPTO_set_locking_callback(ssl_lock); 39 | CRYPTO_set_id_callback(ssl_id); 40 | 41 | if ((ctx = SSL_CTX_new(SSLv23_client_method()))) { 42 | SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL); 43 | SSL_CTX_set_verify_depth(ctx, 0); 44 | SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY); 45 | SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_CLIENT); 46 | } 47 | } 48 | 49 | return ctx; 50 | } 51 | 52 | status ssl_connect(connection *c, char *host) { 53 | int r; 54 | SSL_set_fd(c->ssl, c->fd); 55 | SSL_set_tlsext_host_name(c->ssl, host); 56 | if ((r = SSL_connect(c->ssl)) != 1) { 57 | switch (SSL_get_error(c->ssl, r)) { 58 | case SSL_ERROR_WANT_READ: return RETRY; 59 | case SSL_ERROR_WANT_WRITE: return RETRY; 60 | default: return ERROR; 61 | } 62 | } 63 | return OK; 64 | } 65 | 66 | status ssl_close(connection *c) { 67 | SSL_shutdown(c->ssl); 68 | SSL_clear(c->ssl); 69 | return OK; 70 | } 71 | 72 | status ssl_read(connection *c, size_t *n) { 73 | int r; 74 | if ((r = SSL_read(c->ssl, c->buf, sizeof(c->buf))) <= 0) { 75 | switch (SSL_get_error(c->ssl, r)) { 76 | case SSL_ERROR_WANT_READ: return RETRY; 77 | case SSL_ERROR_WANT_WRITE: return RETRY; 78 | default: return ERROR; 79 | } 80 | } 81 | *n = (size_t) r; 82 | return OK; 83 | } 84 | 85 | status ssl_write(connection *c, char *buf, size_t len, size_t *n) { 86 | int r; 87 | if ((r = SSL_write(c->ssl, buf, len)) <= 0) { 88 | switch (SSL_get_error(c->ssl, r)) { 89 | case SSL_ERROR_WANT_READ: return RETRY; 90 | case SSL_ERROR_WANT_WRITE: return RETRY; 91 | default: return ERROR; 92 | } 93 | } 94 | *n = (size_t) r; 95 | return OK; 96 | } 97 | 98 | size_t ssl_readable(connection *c) { 99 | return SSL_pending(c->ssl); 100 | } 101 | -------------------------------------------------------------------------------- /src/ssl.h: -------------------------------------------------------------------------------- 1 | #ifndef SSL_H 2 | #define SSL_H 3 | 4 | #include "net.h" 5 | 6 | SSL_CTX *ssl_init(); 7 | 8 | status ssl_connect(connection *, char *); 9 | status ssl_close(connection *); 10 | status ssl_read(connection *, size_t *); 11 | status ssl_write(connection *, char *, size_t, size_t *); 12 | size_t ssl_readable(connection *); 13 | 14 | #endif /* SSL_H */ 15 | -------------------------------------------------------------------------------- /src/stats.c: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2012 - Will Glozer. All rights reserved. 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | #include "stats.h" 8 | #include "zmalloc.h" 9 | 10 | stats *stats_alloc(uint64_t samples) { 11 | stats *s = zcalloc(sizeof(stats) + sizeof(uint64_t) * samples); 12 | s->samples = samples; 13 | s->min = UINT64_MAX; 14 | s->histogram = NULL; 15 | return s; 16 | } 17 | 18 | void stats_free(stats *stats) { 19 | zfree(stats); 20 | } 21 | 22 | void stats_reset(stats *stats) { 23 | stats->limit = 0; 24 | stats->index = 0; 25 | stats->min = UINT64_MAX; 26 | stats->max = 0; 27 | } 28 | 29 | void stats_rewind(stats *stats) { 30 | stats->limit = 0; 31 | stats->index = 0; 32 | } 33 | 34 | void stats_record(stats *stats, uint64_t x) { 35 | if (x < stats->min) stats->min = x; 36 | if (x > stats->max) stats->max = x; 37 | if (stats->histogram != NULL) { 38 | hdr_record_value(stats->histogram, x); 39 | return; 40 | } 41 | 42 | stats->data[stats->index++] = x; 43 | if (stats->limit < stats->samples) stats->limit++; 44 | if (stats->index == stats->samples) stats->index = 0; 45 | } 46 | 47 | static int stats_compare(const void *a, const void *b) { 48 | uint64_t *x = (uint64_t *) a; 49 | uint64_t *y = (uint64_t *) b; 50 | return *x - *y; 51 | } 52 | 53 | long double stats_summarize(stats *stats) { 54 | qsort(stats->data, stats->limit, sizeof(uint64_t), &stats_compare); 55 | return stats_mean(stats); 56 | } 57 | 58 | long double stats_mean(stats *stats) { 59 | if (stats->histogram != NULL) { 60 | return hdr_mean(stats->histogram); 61 | } 62 | if (stats->limit == 0) return 0.0; 63 | 64 | uint64_t sum = 0; 65 | for (uint64_t i = 0; i < stats->limit; i++) { 66 | sum += stats->data[i]; 67 | } 68 | return sum / (long double) stats->limit; 69 | } 70 | 71 | long double stats_stdev(stats *stats, long double mean) { 72 | if (stats->histogram != NULL) { 73 | return hdr_stddev(stats->histogram); 74 | } 75 | long double sum = 0.0; 76 | if (stats->limit < 2) return 0.0; 77 | for (uint64_t i = 0; i < stats->limit; i++) { 78 | sum += powl(stats->data[i] - mean, 2); 79 | } 80 | return sqrtl(sum / (stats->limit - 1)); 81 | } 82 | 83 | long double stats_within_stdev(stats *stats, long double mean, long double stdev, uint64_t n) { 84 | long double upper = mean + (stdev * n); 85 | long double lower = mean - (stdev * n); 86 | if (stats->histogram != NULL) { 87 | int64_t total_count = stats->histogram->total_count; 88 | if (total_count == 0) { 89 | return 0.0; 90 | } 91 | int64_t upper_value = upper; 92 | int64_t lower_value = lower; 93 | struct hdr_iter iter; 94 | hdr_iter_init(&iter, stats->histogram); 95 | int64_t lower_count = 0; 96 | int64_t upper_count = 0; 97 | bool found_upper = false; 98 | while (hdr_iter_next(&iter)) { 99 | if (lower_value > iter.value_from_index) { 100 | lower_count = iter.count_to_index; 101 | } 102 | if (upper_value < iter.highest_equivalent_value) { 103 | upper_count = iter.count_to_index; 104 | found_upper = true; 105 | break; 106 | } 107 | } 108 | if (!found_upper) { 109 | upper_count = total_count; 110 | } 111 | return 100.0 * (upper_count - lower_count) / (double) total_count; 112 | } 113 | uint64_t sum = 0; 114 | 115 | for (uint64_t i = 0; i < stats->limit; i++) { 116 | uint64_t x = stats->data[i]; 117 | if (x >= lower && x <= upper) sum++; 118 | } 119 | 120 | return (sum / (long double) stats->limit) * 100; 121 | } 122 | 123 | uint64_t stats_percentile(stats *stats, long double p) { 124 | if (stats->histogram != NULL) { 125 | double percentile = p; 126 | int64_t value = hdr_value_at_percentile(stats->histogram, percentile); 127 | return (value < 0) ? 0 : value; 128 | } 129 | uint64_t rank = round((p / 100.0) * stats->limit + 0.5); 130 | return stats->data[rank - 1]; 131 | } 132 | 133 | void stats_sample(stats *dst, tinymt64_t *state, uint64_t count, stats *src) { 134 | for (uint64_t i = 0; i < count; i++) { 135 | uint64_t n = rand64(state, src->limit); 136 | stats_record(dst, src->data[n]); 137 | } 138 | } 139 | 140 | uint64_t rand64(tinymt64_t *state, uint64_t n) { 141 | uint64_t x, max = ~UINT64_C(0); 142 | max -= max % n; 143 | do { 144 | x = tinymt64_generate_uint64(state); 145 | } while (x >= max); 146 | return x % n; 147 | } 148 | -------------------------------------------------------------------------------- /src/stats.h: -------------------------------------------------------------------------------- 1 | #ifndef STATS_H 2 | #define STATS_H 3 | 4 | #include 5 | #include 6 | #include "tinymt64.h" 7 | #include "hdr_histogram.h" 8 | 9 | #define MAX(X, Y) ((X) > (Y) ? (X) : (Y)) 10 | #define MIN(X, Y) ((X) < (Y) ? (X) : (Y)) 11 | 12 | typedef struct { 13 | uint32_t connect; 14 | uint32_t read; 15 | uint32_t write; 16 | uint32_t status; 17 | uint32_t timeout; 18 | } errors; 19 | 20 | typedef struct { 21 | uint64_t samples; 22 | uint64_t index; 23 | uint64_t limit; 24 | uint64_t min; 25 | uint64_t max; 26 | struct hdr_histogram *histogram; 27 | uint64_t data[]; 28 | } stats; 29 | 30 | stats *stats_alloc(uint64_t); 31 | void stats_free(stats *); 32 | void stats_reset(stats *); 33 | void stats_rewind(stats *); 34 | 35 | void stats_record(stats *, uint64_t); 36 | 37 | long double stats_summarize(stats *); 38 | long double stats_mean(stats *); 39 | long double stats_stdev(stats *stats, long double); 40 | long double stats_within_stdev(stats *, long double, long double, uint64_t); 41 | uint64_t stats_percentile(stats *, long double); 42 | 43 | void stats_sample(stats *, tinymt64_t *, uint64_t, stats *); 44 | uint64_t rand64(tinymt64_t *, uint64_t); 45 | 46 | #endif /* STATS_H */ 47 | -------------------------------------------------------------------------------- /src/tinymt64.c: -------------------------------------------------------------------------------- 1 | /** 2 | * @file tinymt64.c 3 | * 4 | * @brief 64-bit Tiny Mersenne Twister only 127 bit internal state 5 | * 6 | * @author Mutsuo Saito (Hiroshima University) 7 | * @author Makoto Matsumoto (The University of Tokyo) 8 | * 9 | * Copyright (C) 2011 Mutsuo Saito, Makoto Matsumoto, 10 | * Hiroshima University and The University of Tokyo. 11 | * All rights reserved. 12 | * 13 | * The 3-clause BSD License is applied to this software, see 14 | * LICENSE.txt 15 | */ 16 | #include "tinymt64.h" 17 | 18 | #define MIN_LOOP 8 19 | 20 | /** 21 | * This function represents a function used in the initialization 22 | * by init_by_array 23 | * @param[in] x 64-bit integer 24 | * @return 64-bit integer 25 | */ 26 | static uint64_t ini_func1(uint64_t x) { 27 | return (x ^ (x >> 59)) * UINT64_C(2173292883993); 28 | } 29 | 30 | /** 31 | * This function represents a function used in the initialization 32 | * by init_by_array 33 | * @param[in] x 64-bit integer 34 | * @return 64-bit integer 35 | */ 36 | static uint64_t ini_func2(uint64_t x) { 37 | return (x ^ (x >> 59)) * UINT64_C(58885565329898161); 38 | } 39 | 40 | /** 41 | * This function certificate the period of 2^127-1. 42 | * @param random tinymt state vector. 43 | */ 44 | static void period_certification(tinymt64_t * random) { 45 | if ((random->status[0] & TINYMT64_MASK) == 0 && 46 | random->status[1] == 0) { 47 | random->status[0] = 'T'; 48 | random->status[1] = 'M'; 49 | } 50 | } 51 | 52 | /** 53 | * This function initializes the internal state array with a 64-bit 54 | * unsigned integer seed. 55 | * @param random tinymt state vector. 56 | * @param seed a 64-bit unsigned integer used as a seed. 57 | */ 58 | void tinymt64_init(tinymt64_t * random, uint64_t seed) { 59 | random->status[0] = seed ^ ((uint64_t)random->mat1 << 32); 60 | random->status[1] = random->mat2 ^ random->tmat; 61 | for (int i = 1; i < MIN_LOOP; i++) { 62 | random->status[i & 1] ^= i + UINT64_C(6364136223846793005) 63 | * (random->status[(i - 1) & 1] 64 | ^ (random->status[(i - 1) & 1] >> 62)); 65 | } 66 | period_certification(random); 67 | } 68 | 69 | /** 70 | * This function initializes the internal state array, 71 | * with an array of 64-bit unsigned integers used as seeds 72 | * @param random tinymt state vector. 73 | * @param init_key the array of 64-bit integers, used as a seed. 74 | * @param key_length the length of init_key. 75 | */ 76 | void tinymt64_init_by_array(tinymt64_t * random, const uint64_t init_key[], 77 | int key_length) { 78 | const int lag = 1; 79 | const int mid = 1; 80 | const int size = 4; 81 | int i, j; 82 | int count; 83 | uint64_t r; 84 | uint64_t st[4]; 85 | 86 | st[0] = 0; 87 | st[1] = random->mat1; 88 | st[2] = random->mat2; 89 | st[3] = random->tmat; 90 | if (key_length + 1 > MIN_LOOP) { 91 | count = key_length + 1; 92 | } else { 93 | count = MIN_LOOP; 94 | } 95 | r = ini_func1(st[0] ^ st[mid % size] 96 | ^ st[(size - 1) % size]); 97 | st[mid % size] += r; 98 | r += key_length; 99 | st[(mid + lag) % size] += r; 100 | st[0] = r; 101 | count--; 102 | for (i = 1, j = 0; (j < count) && (j < key_length); j++) { 103 | r = ini_func1(st[i] ^ st[(i + mid) % size] ^ st[(i + size - 1) % size]); 104 | st[(i + mid) % size] += r; 105 | r += init_key[j] + i; 106 | st[(i + mid + lag) % size] += r; 107 | st[i] = r; 108 | i = (i + 1) % size; 109 | } 110 | for (; j < count; j++) { 111 | r = ini_func1(st[i] ^ st[(i + mid) % size] ^ st[(i + size - 1) % size]); 112 | st[(i + mid) % size] += r; 113 | r += i; 114 | st[(i + mid + lag) % size] += r; 115 | st[i] = r; 116 | i = (i + 1) % size; 117 | } 118 | for (j = 0; j < size; j++) { 119 | r = ini_func2(st[i] + st[(i + mid) % size] + st[(i + size - 1) % size]); 120 | st[(i + mid) % size] ^= r; 121 | r -= i; 122 | st[(i + mid + lag) % size] ^= r; 123 | st[i] = r; 124 | i = (i + 1) % size; 125 | } 126 | random->status[0] = st[0] ^ st[1]; 127 | random->status[1] = st[2] ^ st[3]; 128 | period_certification(random); 129 | } 130 | -------------------------------------------------------------------------------- /src/units.c: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2012 - Will Glozer. All rights reserved. 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #include "units.h" 9 | #include "aprintf.h" 10 | 11 | typedef struct { 12 | int scale; 13 | char *base; 14 | char *units[]; 15 | } units; 16 | 17 | units time_units_us = { 18 | .scale = 1000, 19 | .base = "us", 20 | .units = { "ms", "s", NULL } 21 | }; 22 | 23 | units time_units_s = { 24 | .scale = 60, 25 | .base = "s", 26 | .units = { "m", "h", NULL } 27 | }; 28 | 29 | units binary_units = { 30 | .scale = 1024, 31 | .base = "", 32 | .units = { "K", "M", "G", "T", "P", NULL } 33 | }; 34 | 35 | units metric_units = { 36 | .scale = 1000, 37 | .base = "", 38 | .units = { "k", "M", "G", "T", "P", NULL } 39 | }; 40 | 41 | static char *format_units(long double n, units *m, int p) { 42 | long double amt = n, scale; 43 | char *unit = m->base; 44 | char *msg = NULL; 45 | 46 | scale = m->scale * 0.85; 47 | 48 | for (int i = 0; m->units[i+1] && amt >= scale; i++) { 49 | amt /= m->scale; 50 | unit = m->units[i]; 51 | } 52 | 53 | aprintf(&msg, "%.*Lf%s", p, amt, unit); 54 | 55 | return msg; 56 | } 57 | 58 | static int scan_units(char *s, uint64_t *n, units *m) { 59 | uint64_t base, scale = 1; 60 | char unit[3] = { 0, 0, 0 }; 61 | int i, c; 62 | 63 | if ((c = sscanf(s, "%"SCNu64"%2s", &base, unit)) < 1) return -1; 64 | 65 | if (c == 2 && strncasecmp(unit, m->base, 3)) { 66 | for (i = 0; m->units[i] != NULL; i++) { 67 | scale *= m->scale; 68 | if (!strncasecmp(unit, m->units[i], 3)) break; 69 | } 70 | if (m->units[i] == NULL) return -1; 71 | } 72 | 73 | *n = base * scale; 74 | return 0; 75 | } 76 | 77 | char *format_binary(long double n) { 78 | return format_units(n, &binary_units, 2); 79 | } 80 | 81 | char *format_metric(long double n) { 82 | return format_units(n, &metric_units, 2); 83 | } 84 | 85 | char *format_time_us(long double n) { 86 | units *units = &time_units_us; 87 | if (n >= 1000000.0) { 88 | n /= 1000000.0; 89 | units = &time_units_s; 90 | } 91 | return format_units(n, units, 2); 92 | } 93 | 94 | char *format_time_s(long double n) { 95 | return format_units(n, &time_units_s, 0); 96 | } 97 | 98 | int scan_metric(char *s, uint64_t *n) { 99 | return scan_units(s, n, &metric_units); 100 | } 101 | 102 | int scan_time(char *s, uint64_t *n) { 103 | return scan_units(s, n, &time_units_s); 104 | } 105 | -------------------------------------------------------------------------------- /src/units.h: -------------------------------------------------------------------------------- 1 | #ifndef UNITS_H 2 | #define UNITS_H 3 | 4 | char *format_binary(long double); 5 | char *format_metric(long double); 6 | char *format_time_us(long double); 7 | char *format_time_s(long double); 8 | 9 | int scan_metric(char *, uint64_t *); 10 | int scan_time(char *, uint64_t *); 11 | 12 | #endif /* UNITS_H */ 13 | -------------------------------------------------------------------------------- /src/wrk.h: -------------------------------------------------------------------------------- 1 | #ifndef WRK_H 2 | #define WRK_H 3 | 4 | #include "config.h" 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | #include 12 | #include 13 | #include 14 | 15 | #include "stats.h" 16 | #include "ae.h" 17 | #include "http_parser.h" 18 | #include "hdr_histogram.h" 19 | 20 | #define VERSION "4.0.0" 21 | #define RECVBUF 8192 22 | #define SAMPLES 100000000 23 | 24 | #define SOCKET_TIMEOUT_MS 2000 25 | #define CALIBRATE_DELAY_MS 10000 26 | #define TIMEOUT_INTERVAL_MS 2000 27 | 28 | typedef struct { 29 | pthread_t thread; 30 | aeEventLoop *loop; 31 | struct addrinfo *addr; 32 | uint64_t connections; 33 | void (*reconnect_all)(void*); 34 | int interval; 35 | uint64_t stop_at; 36 | uint64_t complete; 37 | uint64_t requests; 38 | uint64_t bytes; 39 | uint64_t start; 40 | double throughput; 41 | uint64_t mean; 42 | struct hdr_histogram *latency_histogram; 43 | struct hdr_histogram *u_latency_histogram; 44 | tinymt64_t rand; 45 | lua_State *L; 46 | errors errors; 47 | struct connection *cs; 48 | } thread; 49 | 50 | typedef struct { 51 | char *buffer; 52 | size_t length; 53 | char *cursor; 54 | } buffer; 55 | 56 | typedef struct connection { 57 | thread *thread; 58 | http_parser parser; 59 | enum { 60 | FIELD, VALUE 61 | } state; 62 | int fd; 63 | SSL *ssl; 64 | double throughput; 65 | double catch_up_throughput; 66 | uint64_t complete; 67 | uint64_t complete_at_last_batch_start; 68 | uint64_t catch_up_start_time; 69 | uint64_t complete_at_catch_up_start; 70 | uint64_t thread_start; 71 | uint64_t start; 72 | char *request; 73 | size_t length; 74 | size_t written; 75 | uint64_t pending; 76 | buffer headers; 77 | buffer body; 78 | char buf[RECVBUF]; 79 | uint64_t actual_latency_start; 80 | bool has_pending; 81 | bool caught_up; 82 | // Internal tracking numbers (used purely for debugging): 83 | uint64_t latest_should_send_time; 84 | uint64_t latest_expected_start; 85 | uint64_t latest_connect; 86 | uint64_t latest_write; 87 | } connection; 88 | 89 | #endif /* WRK_H */ 90 | -------------------------------------------------------------------------------- /src/wrk.lua: -------------------------------------------------------------------------------- 1 | local wrk = { 2 | scheme = "http", 3 | host = "localhost", 4 | port = nil, 5 | method = "GET", 6 | path = "/", 7 | headers = {}, 8 | body = nil, 9 | thread = nil, 10 | } 11 | 12 | function wrk.resolve(host, service) 13 | local addrs = wrk.lookup(host, service) 14 | for i = #addrs, 1, -1 do 15 | if not wrk.connect(addrs[i]) then 16 | table.remove(addrs, i) 17 | end 18 | end 19 | wrk.addrs = addrs 20 | end 21 | 22 | function wrk.setup(thread) 23 | thread.addr = wrk.addrs[1] 24 | if type(setup) == "function" then 25 | setup(thread) 26 | end 27 | end 28 | 29 | function wrk.init(args) 30 | if not wrk.headers["Host"] then 31 | local host = wrk.host 32 | local port = wrk.port 33 | 34 | host = host:find(":") and ("[" .. host .. "]") or host 35 | host = port and (host .. ":" .. port) or host 36 | 37 | wrk.headers["Host"] = host 38 | end 39 | 40 | if type(init) == "function" then 41 | init(args) 42 | end 43 | 44 | local req = wrk.format() 45 | wrk.request = function() 46 | return req 47 | end 48 | end 49 | 50 | function wrk.format(method, path, headers, body) 51 | local method = method or wrk.method 52 | local path = path or wrk.path 53 | local headers = headers or wrk.headers 54 | local body = body or wrk.body 55 | local s = {} 56 | 57 | if not headers["Host"] then 58 | headers["Host"] = wrk.headers["Host"] 59 | end 60 | 61 | headers["Content-Length"] = body and string.len(body) 62 | 63 | s[1] = string.format("%s %s HTTP/1.1", method, path) 64 | for name, value in pairs(headers) do 65 | s[#s+1] = string.format("%s: %s", name, value) 66 | end 67 | 68 | s[#s+1] = "" 69 | s[#s+1] = body or "" 70 | 71 | return table.concat(s, "\r\n") 72 | end 73 | 74 | return wrk 75 | -------------------------------------------------------------------------------- /src/zmalloc.h: -------------------------------------------------------------------------------- 1 | /* zmalloc - total amount of allocated memory aware version of malloc() 2 | * 3 | * Copyright (c) 2009-2010, Salvatore Sanfilippo 4 | * All rights reserved. 5 | * 6 | * Redistribution and use in source and binary forms, with or without 7 | * modification, are permitted provided that the following conditions are met: 8 | * 9 | * * Redistributions of source code must retain the above copyright notice, 10 | * this list of conditions and the following disclaimer. 11 | * * Redistributions in binary form must reproduce the above copyright 12 | * notice, this list of conditions and the following disclaimer in the 13 | * documentation and/or other materials provided with the distribution. 14 | * * Neither the name of Redis nor the names of its contributors may be used 15 | * to endorse or promote products derived from this software without 16 | * specific prior written permission. 17 | * 18 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 19 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 | * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 22 | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 23 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 25 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 26 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 28 | * POSSIBILITY OF SUCH DAMAGE. 29 | */ 30 | 31 | #ifndef __ZMALLOC_H 32 | #define __ZMALLOC_H 33 | 34 | /* Double expansion needed for stringification of macro values. */ 35 | #define __xstr(s) __str(s) 36 | #define __str(s) #s 37 | 38 | #if defined(USE_TCMALLOC) 39 | #define ZMALLOC_LIB ("tcmalloc-" __xstr(TC_VERSION_MAJOR) "." __xstr(TC_VERSION_MINOR)) 40 | #include 41 | #if TC_VERSION_MAJOR >= 1 && TC_VERSION_MINOR >= 6 42 | #define HAVE_MALLOC_SIZE 1 43 | #define zmalloc_size(p) tc_malloc_size(p) 44 | #else 45 | #error "Newer version of tcmalloc required" 46 | #endif 47 | 48 | #elif defined(USE_JEMALLOC) 49 | #define ZMALLOC_LIB ("jemalloc-" __xstr(JEMALLOC_VERSION_MAJOR) "." __xstr(JEMALLOC_VERSION_MINOR) "." __xstr(JEMALLOC_VERSION_BUGFIX)) 50 | #define JEMALLOC_MANGLE 51 | #include 52 | #if JEMALLOC_VERSION_MAJOR >= 2 && JEMALLOC_VERSION_MINOR >= 1 53 | #define HAVE_MALLOC_SIZE 1 54 | #define zmalloc_size(p) JEMALLOC_P(malloc_usable_size)(p) 55 | #else 56 | #error "Newer version of jemalloc required" 57 | #endif 58 | 59 | #elif defined(__APPLE__) 60 | #include 61 | #define HAVE_MALLOC_SIZE 1 62 | #define zmalloc_size(p) malloc_size(p) 63 | #endif 64 | 65 | #ifndef ZMALLOC_LIB 66 | #define ZMALLOC_LIB "libc" 67 | #endif 68 | 69 | void *zmalloc(size_t size); 70 | void *zcalloc(size_t size); 71 | void *zrealloc(void *ptr, size_t size); 72 | void zfree(void *ptr); 73 | char *zstrdup(const char *s); 74 | size_t zmalloc_used_memory(void); 75 | void zmalloc_enable_thread_safeness(void); 76 | float zmalloc_get_fragmentation_ratio(void); 77 | size_t zmalloc_get_rss(void); 78 | 79 | #ifndef HAVE_MALLOC_SIZE 80 | size_t zmalloc_size(void *ptr); 81 | #endif 82 | 83 | #endif /* __ZMALLOC_H */ 84 | --------------------------------------------------------------------------------