From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from localhost (localhost [127.0.0.1]) by turing.freelists.org (Avenir Technologies Mail Multiplex) with ESMTP id 9D31B22DB4 for ; Thu, 5 Sep 2019 10:17:54 -0400 (EDT) Received: from turing.freelists.org ([127.0.0.1]) by localhost (turing.freelists.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 9XC3rmBvteoI for ; Thu, 5 Sep 2019 10:17:54 -0400 (EDT) Received: from smtp54.i.mail.ru (smtp54.i.mail.ru [217.69.128.34]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by turing.freelists.org (Avenir Technologies Mail Multiplex) with ESMTPS id 300E22086C for ; Thu, 5 Sep 2019 10:17:54 -0400 (EDT) From: Igor Munkin Subject: [tarantool-patches] [PATCH 1/1] test: add tests from tarantool source tree Date: Thu, 5 Sep 2019 17:20:07 +0300 Message-Id: In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: tarantool-patches-bounce@freelists.org Errors-to: tarantool-patches-bounce@freelists.org Reply-To: tarantool-patches@freelists.org List-Help: List-Unsubscribe: List-software: Ecartis version 1.0.0 List-Id: tarantool-patches List-Subscribe: List-Owner: List-post: List-Archive: To: tarantool-patches@freelists.org Cc: Igor Munkin Introduced structure has the following benefits: * Excess testing machinery currently is not required directly in luajit repo considering whole CI process setup for tarantool and its static linking with libluajit * All new tests related to luajit fixes and enhancements can be added within a single patch with the corresponding changeset NB!: All added test chunks use tarantool tap module --- test/fold_bug_LuaJIT_505.test.lua | 21 +++ test/gh.test.lua | 17 +++ test/suite.ini | 5 + test/table_chain_bug_LuaJIT_494.test.lua | 178 +++++++++++++++++++++++ test/unsink_64_kptr.test.lua | 44 ++++++ 5 files changed, 265 insertions(+) create mode 100755 test/fold_bug_LuaJIT_505.test.lua create mode 100755 test/gh.test.lua create mode 100644 test/suite.ini create mode 100755 test/table_chain_bug_LuaJIT_494.test.lua create mode 100755 test/unsink_64_kptr.test.lua diff --git a/test/fold_bug_LuaJIT_505.test.lua b/test/fold_bug_LuaJIT_505.test.lua new file mode 100755 index 0000000..71e2cba --- /dev/null +++ b/test/fold_bug_LuaJIT_505.test.lua @@ -0,0 +1,21 @@ +#!/usr/bin/env tarantool + +tap = require('tap') + +test = tap.test("505") +test:plan(1) + +-- Test file to demonstrate Lua fold machinery icorrect behavior, details: +-- https://github.com/LuaJIT/LuaJIT/issues/505 + +jit.opt.start(0, "hotloop=1") +require('jit.dump').start("+bti", "505.trace") +for _ = 1, 20 do + local value = "abc" + local pos_c = string.find(value, "c", 1, true) + local value2 = string.sub(value, 1, pos_c - 1) + local pos_b = string.find(value2, "b", 2, true) + assert(pos_b == 2, "FAIL: position of 'b' is " .. pos_b) +end + +test:ok("PASS") diff --git a/test/gh.test.lua b/test/gh.test.lua new file mode 100755 index 0000000..00b71a6 --- /dev/null +++ b/test/gh.test.lua @@ -0,0 +1,17 @@ +#!/usr/bin/env tarantool + +-- Miscellaneous test for LuaJIT bugs +tap = require('tap') + +test = tap.test("gh") +test:plan(2) +-- +-- gh-3196: incorrect string length if Lua hash returns 0 +-- +h = "\x1F\x93\xE2\x1C\xCA\xDE\x28\x08\x26\x01\xED\x0A\x2F\xE4\x21\x02\x97\x77\xD9\x3E" +test:is(h:len(), 20) + +h = "\x0F\x93\xE2\x1C\xCA\xDE\x28\x08\x26\x01\xED\x0A\x2F\xE4\x21\x02\x97\x77\xD9\x3E" +test:is(h:len(), 20) + +test:check() diff --git a/test/suite.ini b/test/suite.ini new file mode 100644 index 0000000..3e860c9 --- /dev/null +++ b/test/suite.ini @@ -0,0 +1,5 @@ +[default] +core = app +description = Luajit tests +is_parallel = True +pretest_clean = True diff --git a/test/table_chain_bug_LuaJIT_494.test.lua b/test/table_chain_bug_LuaJIT_494.test.lua new file mode 100755 index 0000000..06c0f0d --- /dev/null +++ b/test/table_chain_bug_LuaJIT_494.test.lua @@ -0,0 +1,178 @@ +#!/usr/bin/env tarantool + +tap = require('tap') + +test = tap.test("494") +test:plan(1) + +-- Test file to demonstrate Lua table hash chain bugs discussed in +-- https://github.com/LuaJIT/LuaJIT/issues/494 +-- Credit: prepared by Peter Cawley here with minor edits: +-- https://gist.github.com/corsix/1fc9b13a2dd5f3659417b62dd54d4500 + +--- Plumbing +ffi = require"ffi" +ffi.cdef"char* strstr(const char*, const char*)" +strstr = ffi.C.strstr +cast = ffi.cast +str_hash_offset = cast("uint32_t*", strstr("*", ""))[-2] == 1 and 3 or 2 +function str_hash(s) + return cast("uint32_t*", strstr(s, "")) - str_hash_offset +end +table_new = require"table.new" + +--- Prepare some objects +victims = {} +orig_hash = {} +for c in ("abcdef"):gmatch"." do + v = c .. "{09add58a-13a4-44e0-a52c-d44d0f9b2b95}" + victims[c] = v + orig_hash[c] = str_hash(v)[0] +end +collectgarbage() + +do --- Basic version of the problem + for k, v in pairs(victims) do + str_hash(v)[0] = 0 + end + t = table_new(0, 8) + -- Make chain a -> b -> c -> d, all with a as primary + t[victims.a] = true + t[victims.d] = true + t[victims.c] = true + t[victims.b] = true + -- Change c's primary to b, and d's primary to c + t[victims.d] = nil + t[victims.c] = nil + str_hash(victims.c)[0] = 5 + str_hash(victims.d)[0] = 6 + t[victims.c] = true + t[victims.d] = true + -- Insert something with b as primary + str_hash(victims.e)[0] = 5 + t[victims.e] = true + -- Check for consistency + for c in ("abcde"):gmatch"." do + assert(t[victims[c]], c) + end +end +collectgarbage() + +do --- Just `mn != freenode` can lead to infinite loops + for k, v in pairs(victims) do + str_hash(v)[0] = 0 + end + t = table_new(0, 8) + -- Make chain a -> b -> c -> d, all with a as primary + t[victims.a] = true + t[victims.d] = true + t[victims.c] = true + t[victims.b] = true + -- Change c's primary to b, and d's primary to d + t[victims.d] = nil + t[victims.c] = nil + str_hash(victims.c)[0] = 5 + str_hash(victims.d)[0] = 7 + t[victims.c] = true + t[victims.d] = true + -- Insert something with b as primary + str_hash(victims.e)[0] = 5 + t[victims.e] = true + -- Insert something with d as primary (infinite lookup loop) + str_hash(victims.f)[0] = 7 + t[victims.f] = true +end +collectgarbage() + +do --- Just `mn != nn` can lead to infinite loops + for k, v in pairs(victims) do + str_hash(v)[0] = 0 + end + t = table_new(0, 8) + -- Make chain a -> b -> c -> d -> e, all with a as primary + t[victims.a] = true + t[victims.e] = true + t[victims.d] = true + t[victims.c] = true + t[victims.b] = true + -- Change c's primary to b, d's primary to d, and e's primary to d + t[victims.e] = nil + t[victims.d] = nil + t[victims.c] = nil + str_hash(victims.c)[0] = 4 + str_hash(victims.d)[0] = 6 + str_hash(victims.e)[0] = 6 + t[victims.c] = true + t[victims.d] = true + t[victims.e] = true + -- Insert something with b as primary (infinite rechaining loop) + str_hash(victims.f)[0] = 4 + t[victims.f] = true +end + +for i = 0, 10 do --- Non-strings can need rechaining too + collectgarbage() + + k = tonumber((("0x%xp-1074"):format(i))) + str_hash(victims.a)[0] = 0 + str_hash(victims.b)[0] = 0 + t = table_new(0, 4) + -- a -> b, both with a as primary + t[victims.a] = true + t[victims.b] = true + -- Change b's primary to b + t[victims.b] = nil + str_hash(victims.b)[0] = 3 + t[victims.b] = true + -- Might get a -> b -> k, with k's primary as b + t[k] = true + -- Change b's primary to a + t[victims.b] = nil + str_hash(victims.b)[0] = 0 + t[victims.b] = true + -- Insert something with b as primary + str_hash(victims.c)[0] = 3 + t[victims.c] = true + -- Check for consistency + assert(t[k], i) +end + +for i = 0, 10 do --- Non-strings can be moved to freenode + collectgarbage() + + k = false + str_hash(victims.a)[0] = 0 + str_hash(victims.b)[0] = 0 + t = table_new(0, 4) + -- a -> k -> b, all with a as primary + t[victims.a] = true + t[victims.b] = true + t[k] = true + -- Change b's primary to k + t[victims.b] = nil + str_hash(victims.b)[0] = 2 + t[victims.b] = true + -- Insert a non-string with primary of k + t[tonumber((("0x%xp-1074"):format(i)))] = true + -- Check for consistency + assert(t[victims.b], i) +end +collectgarbage() + +do --- Do not forget to advance freenode in the not-string case + t = table_new(0, 4) + -- Chain of colliding numbers + t[0x0p-1074] = true + t[0x4p-1074] = true + t[0x8p-1074] = true + -- Steal middle node of the chain to be a main node (infinite walking loop) + t[0x2p-1074] = true +end +collectgarbage() + +--- Restore interpreter invariants, just in case +for c, v in pairs(victims) do + str_hash(v)[0] = orig_hash[c] +end + +test:ok("PASS") diff --git a/test/unsink_64_kptr.test.lua b/test/unsink_64_kptr.test.lua new file mode 100755 index 0000000..8995763 --- /dev/null +++ b/test/unsink_64_kptr.test.lua @@ -0,0 +1,44 @@ +#!/usr/bin/env tarantool + +tap = require('tap') + +test = tap.test("232") +test:plan(1) + +--- From: Thibault Charbonnier +--- tests: ffi: added a test case unsinking a 64-bit pointer from a constant. +--- +--- This test case reproduces the issue observed at: +--- https://github.com/openresty/lua-resty-core/issues/232 and was +--- contributed by @lukego and myself. +--- +--- Co-authored-by: Luke Gorrie +--- +local ffi = require("ffi") + +local array = ffi.new("struct { int x; } [1]") + +-- This test forces the VM to unsink a pointer that was constructed +-- from a constant. The IR will include a 'cnewi' instruction to +-- allocate an FFI pointer object, the pointer value will be an IR +-- constant, the allocation will be sunk, and the allocation will +-- at some point be "unsunk" due to a reference in the snapshot for +-- a taken exit. + +-- Note: JIT will recognize as a "singleton" and allow its +-- address to be inlined ("constified") instead of looking up the +-- upvalue at runtime. + +local function fn(i) + local struct = array[0] -- Load pointer that the JIT will constify. + if i == 1000 then end -- Force trace exit when i==1000. + struct.x = 0 -- Ensure that 'struct' is live after exit. +end + +-- Loop over the function to make it compile and take a trace exit +-- during the final iteration. +for i = 1, 1000 do + fn(i) +end + +test:ok("PASS") -- 2.22.1