text stringlengths 1 1.05M |
|---|
/*
* fs/exec/elf-loader.cpp
*
* InfOS
* Copyright (C) University of Edinburgh 2016. All Rights Reserved.
*
* Tom Spink <tspink@inf.ed.ac.uk>
*/
#include "infos/define.h"
#include <infos/fs/exec/elf-loader.h>
#include <infos/fs/file.h>
#include <infos/kernel/kernel.h>
#include <infos/kernel/process.h>
#include <infos/mm/mm.h>
#include <infos/mm/page-allocator.h>
using namespace infos::kernel;
using namespace infos::fs;
using namespace infos::fs::exec;
using namespace infos::util;
ComponentLog infos::fs::exec::elf_log(syslog, "elf");
#define MAGIC_NUMBER 0x464c457f
#define ECLASS_32BIT 1
#define ECLASS_64BIT 2
#define EDATA_LITTLE 1
#define EDATA_BIG 2
struct ELF64Header
{
struct {
union {
char magic_bytes[4];
uint32_t magic_number;
};
uint8_t eclass, data, version, osabi, abiversion;
uint8_t pad[7];
} ident __packed;
uint16_t type;
uint16_t machine;
uint32_t version;
uint64_t entry_point;
uint64_t phoff;
uint64_t shoff;
uint32_t flags;
uint16_t ehsize;
uint16_t phentsize;
uint16_t phnum;
uint16_t shentsize;
uint16_t shnum;
uint16_t shstrndx;
} __packed;
struct ELF64ProgramHeaderEntry
{
uint32_t type, flags;
uint64_t offset, vaddr, paddr;
uint64_t filesz, memsz, align;
};
struct ELF64SectionHeaderEntry
{
uint32_t sh_name;
uint32_t sh_type;
uint64_t sh_flags;
uint64_t sh_addr;
uint64_t sh_offset;
uint64_t sh_size;
uint32_t sh_link;
uint32_t sh_info;
uint64_t sh_addralign;
uint64_t sh_entsize;
};
ElfLoader::ElfLoader(File& f) : _file(f)
{
}
Process* ElfLoader::load(const String& cmdline)
{
ELF64Header hdr;
_file.seek(0, File::SeekAbsolute);
int bytes = _file.read(&hdr, sizeof(hdr));
if (bytes != sizeof(hdr)) {
elf_log.messagef(LogLevel::DEBUG, "Unable to read ELF header");
return NULL;
}
if (hdr.ident.magic_number != MAGIC_NUMBER) {
elf_log.messagef(LogLevel::DEBUG, "Invalid ELF magic number %x", hdr.ident.magic_number);
return NULL;
}
if (hdr.ident.eclass != ECLASS_64BIT) {
elf_log.message(LogLevel::DEBUG, "Only 64-bit ELF programs are supported");
return NULL;
}
if (hdr.ident.data != EDATA_LITTLE) {
elf_log.message(LogLevel::DEBUG, "Only little-endian ELF programs are supported");
return NULL;
}
if (hdr.type != 2) {
elf_log.messagef(LogLevel::DEBUG, "Only executables can be loaded (%d)", hdr.type);
return NULL;
}
if (hdr.machine != 0x3e) {
elf_log.messagef(LogLevel::DEBUG, "Unsupported instruction set architecture (%d)", hdr.machine);
return NULL;
}
if (hdr.version != 1) {
elf_log.message(LogLevel::DEBUG, "Invalid ELF version");
return NULL;
}
Process *np = new Process("unknown", false, (Thread::thread_proc_t)hdr.entry_point);
for (unsigned int i = 0; i < hdr.phnum; i++) {
ELF64ProgramHeaderEntry ent;
off_t off = hdr.phoff + (i * hdr.phentsize);
if (_file.pread(&ent, sizeof(ent), off) != sizeof(ent)) {
delete np;
elf_log.message(LogLevel::DEBUG, "Unable to read PH entry");
return NULL;
}
if (ent.type == 1) {
if (!np->vma().is_mapped(ent.vaddr)) {
virt_addr_t base = __page_base(ent.vaddr);
size_t size = __page_offset(ent.vaddr) + ent.memsz;
np->vma().allocate_virt(base, __align_up_page(size) >> 12);
}
char *buffer = new char[ent.filesz];
_file.pread(buffer, ent.filesz, ent.offset);
np->vma().copy_to(ent.vaddr, buffer, ent.filesz);
delete buffer;
}
}
// Iterate over section headers
for(unsigned int i = 0; i < hdr.shnum; i++) {
ELF64SectionHeaderEntry section;
off_t off = hdr.shoff + (i * hdr.shentsize);
if (_file.pread(§ion, sizeof(section), off) != sizeof(section)) {
delete np;
elf_log.message(LogLevel::DEBUG, "Unable to read SH entry");
return NULL;
}
// SHT_NOBITS
if(section.sh_type == 8) {
// Skip if it the section is empty
if(!section.sh_size) continue;
// SHF_ALLOC
if(section.sh_flags & 2) {
// Allocate and zero some memory
if (!np->vma().is_mapped(section.sh_addr)) {
virt_addr_t base = __page_base(section.sh_addr);
size_t size = __page_offset(section.sh_addr) + section.sh_size;
np->vma().allocate_virt(base, __align_up_page(size) >> 12);
}
}
}
}
np->main_thread().allocate_user_stack(0xffffd000, 0x2000);
if (cmdline.length() > 0) {
virt_addr_t cmdline_start = 0xfffff000;
np->vma().allocate_virt(cmdline_start, 1);
if (!np->vma().copy_to(cmdline_start, cmdline.c_str(), cmdline.length())) {
return NULL;
}
np->main_thread().add_entry_argument((void *)cmdline_start);
} else {
np->main_thread().add_entry_argument(NULL);
}
return np;
}
|
; A023542: Convolution of natural numbers with Beatty sequence for tau^2 A001950.
; 2,9,23,47,84,136,206,296,409,548,715,913,1145,1413,1720,2068,2460,2899,3387,3927,4521,5172,5883,6656,7494,8400,9376,10425,11549,12751,14034,15400,16852,18393,20025,21751,23573,25494,27517,29644
mov $19,$0
mov $21,$0
add $21,1
lpb $21
clr $0,19
mov $0,$19
sub $21,1
sub $0,$21
mov $16,$0
mov $18,$0
add $18,1
lpb $18
clr $0,16
mov $0,$16
sub $18,1
sub $0,$18
mov $13,$0
mov $15,$0
add $15,1
lpb $15
mov $0,$13
sub $15,1
sub $0,$15
mov $9,$0
mov $11,2
lpb $11
sub $11,1
add $0,$11
sub $0,1
mov $6,10
mov $8,1
add $8,$0
mul $6,$8
mul $6,6
mov $3,$6
div $3,97
mov $1,$3
mov $12,$11
lpb $12
mov $10,$1
sub $12,1
lpe
lpe
lpb $9
mov $9,0
sub $10,$1
lpe
mov $1,$10
add $1,2
add $14,$1
lpe
add $17,$14
lpe
add $20,$17
lpe
mov $1,$20
|
.MODEL SMALL
.STACK 100H
OUTPUT MACRO MSG
LEA DX,MSG
MOV AH,9
INT 21H
ENDM
INPUT MACRO
MOV AH,1
INT 21H
ENDM
.DATA
STRING1 DB ?
REVERSED DB ?
MSG1 DB 13, 10, "First Digit:$"
MSG2 DB 13, 10, "Second Digit:$"
NLINE DB 13,10,"$"
.CODE
MAIN PROC
MOV AX, @DATA
MOV DS, AX
OUTPUT MSG1
INPUT
MOV BL,AL
SUB BL,30H
OUTPUT MSG2
INPUT
SUB AL,30H
MUL BL
CMP AX,000FH
JBE @ZERO
@ONE:
OUTPUT NLINE
MOV DX,0031H
MOV AH,2
INT 21H
JMP @EXIT
@ZERO:
OUTPUT NLINE
MOV DX,0030H
MOV AH,2
INT 21H
@EXIT:
MOV AH,4CH
INT 21H
MAIN ENDP
END MAIN
|
; A095894: a(2n) = 6n^2+7n+1; a(2n+1) = 6n^2+13n+7.
; 1,7,14,26,39,57,76,100,125,155,186,222,259,301,344,392,441,495,550,610,671,737,804,876,949,1027,1106,1190,1275,1365,1456,1552,1649,1751,1854,1962,2071,2185,2300,2420,2541,2667,2794,2926,3059,3197,3336,3480,3625,3775,3926,4082,4239,4401,4564,4732,4901,5075,5250,5430,5611,5797,5984,6176,6369,6567,6766,6970,7175,7385,7596,7812,8029,8251,8474,8702,8931,9165,9400,9640,9881,10127,10374,10626,10879,11137,11396,11660,11925,12195,12466,12742,13019,13301,13584,13872,14161,14455,14750,15050,15351,15657,15964,16276,16589,16907,17226,17550,17875,18205,18536,18872,19209,19551,19894,20242,20591,20945,21300,21660,22021,22387,22754,23126,23499,23877,24256,24640,25025,25415,25806,26202,26599,27001,27404,27812,28221,28635,29050,29470,29891,30317,30744,31176,31609,32047,32486,32930,33375,33825,34276,34732,35189,35651,36114,36582,37051,37525,38000,38480,38961,39447,39934,40426,40919,41417,41916,42420,42925,43435,43946,44462,44979,45501,46024,46552,47081,47615,48150,48690,49231,49777,50324,50876,51429,51987,52546,53110,53675,54245,54816,55392,55969,56551,57134,57722,58311,58905,59500,60100,60701,61307,61914,62526,63139,63757,64376,65000,65625,66255,66886,67522,68159,68801,69444,70092,70741,71395,72050,72710,73371,74037,74704,75376,76049,76727,77406,78090,78775,79465,80156,80852,81549,82251,82954,83662,84371,85085,85800,86520,87241,87967,88694,89426,90159,90897,91636,92380,93125,93875
add $0,1
mov $2,1
lpb $0,1
sub $0,1
add $1,$2
mov $3,$2
add $4,6
mov $2,$4
mov $4,$3
lpe
|
//
// Created by Grishka on 10.08.2018.
//
#include "VideoRenderer.h"
#ifdef __ANDROID__
#include "../os/android/VideoRendererAndroid.h"
#elif defined(__APPLE__) && !defined(TARGET_OSX32)
#include "../os/darwin/SampleBufferDisplayLayerRenderer.h"
#endif
std::vector<uint32_t> tgvoip::video::VideoRenderer::GetAvailableDecoders(){
#ifdef __ANDROID__
return VideoRendererAndroid::availableDecoders;
#elif defined(__APPLE__) && !defined(TARGET_OSX32)
return SampleBufferDisplayLayerRenderer::GetAvailableDecoders();
#endif
return std::vector<uint32_t>();
}
int tgvoip::video::VideoRenderer::GetMaximumResolution(){
#ifdef __ANDROID__
return VideoRendererAndroid::maxResolution;
#elif defined(__APPLE__) && !defined(TARGET_OSX32)
return SampleBufferDisplayLayerRenderer::GetMaximumResolution();
#endif
return 0;
}
|
;===============================================================================
; Copyright 2014-2021 Intel Corporation
;
; Licensed under the Apache License, Version 2.0 (the "License");
; you may not use this file except in compliance with the License.
; You may obtain a copy of the License at
;
; http://www.apache.org/licenses/LICENSE-2.0
;
; Unless required by applicable law or agreed to in writing, software
; distributed under the License is distributed on an "AS IS" BASIS,
; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
; See the License for the specific language governing permissions and
; limitations under the License.
;===============================================================================
;
;
; Purpose: Cryptography Primitive.
; Message block processing according to SHA-256
;
; Content:
; UpdateSHA256ni
;
;
%include "asmdefs.inc"
%include "ia_emm.inc"
%include "pcpvariant.inc"
%if (_ENABLE_ALG_SHA256_)
%if (_SHA_NI_ENABLING_ == _FEATURE_ON_) || (_SHA_NI_ENABLING_ == _FEATURE_TICKTOCK_)
segment .text align=IPP_ALIGN_FACTOR
align IPP_ALIGN_FACTOR
CODE_DATA:
PSHUFFLE_BYTE_FLIP_MASK \
DB 3,2,1,0, 7,6,5,4, 11,10,9,8, 15,14,13,12
align IPP_ALIGN_FACTOR
;*****************************************************************************************
;* Purpose: Update internal digest according to message block
;*
;* void UpdateSHA256ni(DigestSHA256 digest, const Ipp8u* msg, int mlen, const Ipp32u K_256[])
;*
;*****************************************************************************************
%ifndef _VXWORKS
IPPASM UpdateSHA256ni,PUBLIC
USES_GPR esi,edi,ebx,ebp
mov ebp, esp ; save original esp to use it to reach parameters
%xdefine pDigest [ebp + ARG_1 + 0*sizeof(dword)] ; pointer to the in/out digest
%xdefine pMsg [ebp + ARG_1 + 1*sizeof(dword)] ; pointer to the inp message
%xdefine msgLen [ebp + ARG_1 + 2*sizeof(dword)] ; message length
%xdefine pTbl [ebp + ARG_1 + 3*sizeof(dword)] ; pointer to SHA256 table of constants
%xdefine MBS_SHA256 (64) ; SHA-1 message block length (bytes)
%xdefine HASH_PTR edi ; 1st arg
%xdefine MSG_PTR esi ; 2nd arg
%xdefine MSG_LEN edx ; 3rd arg
%xdefine K256_PTR ebx ; 4rd arg
%xdefine MSG xmm0
%xdefine STATE0 xmm1
%xdefine STATE1 xmm2
%xdefine MSGTMP0 xmm3
%xdefine MSGTMP1 xmm4
%xdefine MSGTMP2 xmm5
%xdefine MSGTMP3 xmm6
%xdefine MSGTMP4 xmm7
;
; stack frame
;
%xdefine mask_save eax
%xdefine abef_save eax+sizeof(oword)
%xdefine cdgh_save eax+sizeof(oword)*2
%xdefine frame_size sizeof(oword)+sizeof(oword)+sizeof(oword)
sub esp, (frame_size+16)
lea eax, [esp+16]
and eax, -16
mov MSG_LEN, msgLen ; message length
test MSG_LEN, MSG_LEN
jz .quit
mov HASH_PTR, pDigest
mov MSG_PTR, pMsg
mov K256_PTR, pTbl
;; load input hash value, reorder these appropriately
movdqu STATE0, oword [HASH_PTR+0*sizeof(oword)]
movdqu STATE1, oword [HASH_PTR+1*sizeof(oword)]
pshufd STATE0, STATE0, 0B1h ; CDAB
pshufd STATE1, STATE1, 01Bh ; EFGH
movdqa MSGTMP4, STATE0
palignr STATE0, STATE1, 8 ; ABEF
pblendw STATE1, MSGTMP4, 0F0h ; CDGH
;; copy byte_flip_mask to stack
mov ecx, 000010203h ;; DB 3,2,1,0, 7,6,5,4, 11,10,9,8, 15,14,13,12
mov dword [mask_save], ecx
mov ecx, 004050607h
mov dword [mask_save+1*sizeof(dword)], ecx
mov ecx, 008090a0bh
mov dword [mask_save+2*sizeof(dword)], ecx
mov ecx, 00c0d0e0fh
mov dword [mask_save+3*sizeof(dword)], ecx
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; process next data block
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
.sha256_block_loop:
movdqa oword [abef_save], STATE0 ; save for addition after rounds
movdqa oword [cdgh_save], STATE1
;; rounds 0-3
movdqu MSG, oword [MSG_PTR + 0*sizeof(oword)]
pshufb MSG, [mask_save]
movdqa MSGTMP0, MSG
paddd MSG, oword [K256_PTR + 0*sizeof(oword)]
sha256rnds2 STATE1, STATE0
pshufd MSG, MSG, 0Eh
sha256rnds2 STATE0, STATE1
;; rounds 4-7
movdqu MSG, oword [MSG_PTR + 1*sizeof(oword)]
pshufb MSG, [mask_save]
movdqa MSGTMP1, MSG
paddd MSG, oword [K256_PTR + 1*sizeof(oword)]
sha256rnds2 STATE1, STATE0
pshufd MSG, MSG, 0Eh
sha256rnds2 STATE0, STATE1
sha256msg1 MSGTMP0, MSGTMP1
;; rounds 8-11
movdqu MSG, oword [MSG_PTR + 2*sizeof(oword)]
pshufb MSG, [mask_save]
movdqa MSGTMP2, MSG
paddd MSG, oword [K256_PTR + 2*sizeof(oword)]
sha256rnds2 STATE1, STATE0
pshufd MSG, MSG, 0Eh
sha256rnds2 STATE0, STATE1
sha256msg1 MSGTMP1, MSGTMP2
;; rounds 12-15
movdqu MSG, oword [MSG_PTR + 3*sizeof(oword)]
pshufb MSG, [mask_save]
movdqa MSGTMP3, MSG
paddd MSG, oword [K256_PTR + 3*sizeof(oword)]
sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP3
palignr MSGTMP4, MSGTMP2, 4
paddd MSGTMP0, MSGTMP4
sha256msg2 MSGTMP0, MSGTMP3
pshufd MSG, MSG, 0Eh
sha256rnds2 STATE0, STATE1
sha256msg1 MSGTMP2, MSGTMP3
;; rounds 16-19
movdqa MSG, MSGTMP0
paddd MSG, oword [K256_PTR + 4*sizeof(oword)]
sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP0
palignr MSGTMP4, MSGTMP3, 4
paddd MSGTMP1, MSGTMP4
sha256msg2 MSGTMP1, MSGTMP0
pshufd MSG, MSG, 0Eh
sha256rnds2 STATE0, STATE1
sha256msg1 MSGTMP3, MSGTMP0
;; rounds 20-23
movdqa MSG, MSGTMP1
paddd MSG, oword [K256_PTR + 5*sizeof(oword)]
sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP1
palignr MSGTMP4, MSGTMP0, 4
paddd MSGTMP2, MSGTMP4
sha256msg2 MSGTMP2, MSGTMP1
pshufd MSG, MSG, 0Eh
sha256rnds2 STATE0, STATE1
sha256msg1 MSGTMP0, MSGTMP1
;; rounds 24-27
movdqa MSG, MSGTMP2
paddd MSG, oword [K256_PTR + 6*sizeof(oword)]
sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP2
palignr MSGTMP4, MSGTMP1, 4
paddd MSGTMP3, MSGTMP4
sha256msg2 MSGTMP3, MSGTMP2
pshufd MSG, MSG, 0Eh
sha256rnds2 STATE0, STATE1
sha256msg1 MSGTMP1, MSGTMP2
;; rounds 28-31
movdqa MSG, MSGTMP3
paddd MSG, oword [K256_PTR + 7*sizeof(oword)]
sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP3
palignr MSGTMP4, MSGTMP2, 4
paddd MSGTMP0, MSGTMP4
sha256msg2 MSGTMP0, MSGTMP3
pshufd MSG, MSG, 0Eh
sha256rnds2 STATE0, STATE1
sha256msg1 MSGTMP2, MSGTMP3
;; rounds 32-35
movdqa MSG, MSGTMP0
paddd MSG, oword [K256_PTR + 8*sizeof(oword)]
sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP0
palignr MSGTMP4, MSGTMP3, 4
paddd MSGTMP1, MSGTMP4
sha256msg2 MSGTMP1, MSGTMP0
pshufd MSG, MSG, 0Eh
sha256rnds2 STATE0, STATE1
sha256msg1 MSGTMP3, MSGTMP0
;; rounds 36-39
movdqa MSG, MSGTMP1
paddd MSG, oword [K256_PTR + 9*sizeof(oword)]
sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP1
palignr MSGTMP4, MSGTMP0, 4
paddd MSGTMP2, MSGTMP4
sha256msg2 MSGTMP2, MSGTMP1
pshufd MSG, MSG, 0Eh
sha256rnds2 STATE0, STATE1
sha256msg1 MSGTMP0, MSGTMP1
;; rounds 40-43
movdqa MSG, MSGTMP2
paddd MSG, oword [K256_PTR + 10*sizeof(oword)]
sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP2
palignr MSGTMP4, MSGTMP1, 4
paddd MSGTMP3, MSGTMP4
sha256msg2 MSGTMP3, MSGTMP2
pshufd MSG, MSG, 0Eh
sha256rnds2 STATE0, STATE1
sha256msg1 MSGTMP1, MSGTMP2
;; rounds 44-47
movdqa MSG, MSGTMP3
paddd MSG, oword [K256_PTR + 11*sizeof(oword)]
sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP3
palignr MSGTMP4, MSGTMP2, 4
paddd MSGTMP0, MSGTMP4
sha256msg2 MSGTMP0, MSGTMP3
pshufd MSG, MSG, 0Eh
sha256rnds2 STATE0, STATE1
sha256msg1 MSGTMP2, MSGTMP3
;; rounds 48-51
movdqa MSG, MSGTMP0
paddd MSG, oword [K256_PTR + 12*sizeof(oword)]
sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP0
palignr MSGTMP4, MSGTMP3, 4
paddd MSGTMP1, MSGTMP4
sha256msg2 MSGTMP1, MSGTMP0
pshufd MSG, MSG, 0Eh
sha256rnds2 STATE0, STATE1
sha256msg1 MSGTMP3, MSGTMP0
;; rounds 52-55
movdqa MSG, MSGTMP1
paddd MSG, oword [K256_PTR + 13*sizeof(oword)]
sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP1
palignr MSGTMP4, MSGTMP0, 4
paddd MSGTMP2, MSGTMP4
sha256msg2 MSGTMP2, MSGTMP1
pshufd MSG, MSG, 0Eh
sha256rnds2 STATE0, STATE1
;; rounds 56-59
movdqa MSG, MSGTMP2
paddd MSG, oword [K256_PTR + 14*sizeof(oword)]
sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP2
palignr MSGTMP4, MSGTMP1, 4
paddd MSGTMP3, MSGTMP4
sha256msg2 MSGTMP3, MSGTMP2
pshufd MSG, MSG, 0Eh
sha256rnds2 STATE0, STATE1
;; rounds 60-63
movdqa MSG, MSGTMP3
paddd MSG, oword [K256_PTR + 15*sizeof(oword)]
sha256rnds2 STATE1, STATE0
pshufd MSG, MSG, 0Eh
sha256rnds2 STATE0, STATE1
paddd STATE0, oword [abef_save] ; update previously saved hash
paddd STATE1, oword [cdgh_save]
add MSG_PTR, MBS_SHA256
sub MSG_LEN, MBS_SHA256
jg .sha256_block_loop
; reorder hash
pshufd STATE0, STATE0, 01Bh ; FEBA
pshufd STATE1, STATE1, 0B1h ; DCHG
movdqa MSGTMP4, STATE0
pblendw STATE0, STATE1, 0F0h ; DCBA
palignr STATE1, MSGTMP4, 8 ; HGFE
; and store it back
movdqu oword [HASH_PTR + 0*sizeof(oword)], STATE0
movdqu oword [HASH_PTR + 1*sizeof(oword)], STATE1
.quit:
add esp, (frame_size+16)
REST_GPR
ret
ENDFUNC UpdateSHA256ni
%else ;; no sha ni support in VxWorks - therefore we temporary use db
IPPASM UpdateSHA256ni,PUBLIC
USES_GPR esi,edi,ebx,ebp
mov ebp, esp ; save original esp to use it to reach parameters
%xdefine pDigest [ebp + ARG_1 + 0*sizeof(dword)] ; pointer to the in/out digest
%xdefine pMsg [ebp + ARG_1 + 1*sizeof(dword)] ; pointer to the inp message
%xdefine msgLen [ebp + ARG_1 + 2*sizeof(dword)] ; message length
%xdefine pTbl [ebp + ARG_1 + 3*sizeof(dword)] ; pointer to SHA256 table of constants
%xdefine MBS_SHA256 (64) ; SHA-1 message block length (bytes)
%xdefine HASH_PTR edi ; 1st arg
%xdefine MSG_PTR esi ; 2nd arg
%xdefine MSG_LEN edx ; 3rd arg
%xdefine K256_PTR ebx ; 4rd arg
%xdefine MSG xmm0
%xdefine STATE0 xmm1
%xdefine STATE1 xmm2
%xdefine MSGTMP0 xmm3
%xdefine MSGTMP1 xmm4
%xdefine MSGTMP2 xmm5
%xdefine MSGTMP3 xmm6
%xdefine MSGTMP4 xmm7
;
; stack frame
;
%xdefine mask_save eax
%xdefine abef_save eax+sizeof(oword)
%xdefine cdgh_save eax+sizeof(oword)*2
%xdefine frame_size sizeof(oword)+sizeof(oword)+sizeof(oword)
sub esp, (frame_size+16)
lea eax, [esp+16]
and eax, -16
mov MSG_LEN, msgLen ; message length
test MSG_LEN, MSG_LEN
jz .quit
mov HASH_PTR, pDigest
mov MSG_PTR, pMsg
mov K256_PTR, pTbl
;; load input hash value, reorder these appropriately
movdqu STATE0, oword [HASH_PTR+0*sizeof(oword)]
movdqu STATE1, oword [HASH_PTR+1*sizeof(oword)]
pshufd STATE0, STATE0, 0B1h ; CDAB
pshufd STATE1, STATE1, 01Bh ; EFGH
movdqa MSGTMP4, STATE0
palignr STATE0, STATE1, 8 ; ABEF
pblendw STATE1, MSGTMP4, 0F0h ; CDGH
;; copy byte_flip_mask to stack
;movdqa MSGTMP4, oword [PSHUFFLE_BYTE_FLIP_MASK]
LD_ADDR ecx, CODE_DATA
movdqa MSGTMP4, oword [ecx+(PSHUFFLE_BYTE_FLIP_MASK-CODE_DATA)]
movdqa oword [mask_save], MSGTMP4
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; process next data block
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
.sha256_block_loop:
movdqa oword [abef_save], STATE0 ; save for addition after rounds
movdqa oword [cdgh_save], STATE1
;; rounds 0-3
movdqu MSG, oword [MSG_PTR + 0*sizeof(oword)]
pshufb MSG, oword [mask_save]
movdqa MSGTMP0, MSG
paddd MSG, oword [K256_PTR + 0*sizeof(oword)]
db 0FH,038H,0CBH,0D1H ;; sha256rnds2 STATE1, STATE0
pshufd MSG, MSG, 0Eh
db 0FH,038H,0CBH,0CAH ;; sha256rnds2 STATE0, STATE1
;; rounds 4-7
movdqu MSG, oword [MSG_PTR + 1*sizeof(oword)]
pshufb MSG, oword [mask_save]
movdqa MSGTMP1, MSG
paddd MSG, oword [K256_PTR + 1*sizeof(oword)]
db 0FH,038H,0CBH,0D1H ;; sha256rnds2 STATE1, STATE0
pshufd MSG, MSG, 0Eh
db 0FH,038H,0CBH,0CAH ;; sha256rnds2 STATE0, STATE1
db 0FH,038H,0CCH,0DCH ;; sha256msg1 MSGTMP0, MSGTMP1
;; rounds 8-11
movdqu MSG, oword [MSG_PTR + 2*sizeof(oword)]
pshufb MSG, oword [mask_save]
movdqa MSGTMP2, MSG
paddd MSG, oword [K256_PTR + 2*sizeof(oword)]
db 0FH,038H,0CBH,0D1H ;; sha256rnds2 STATE1, STATE0
pshufd MSG, MSG, 0Eh
db 0FH,038H,0CBH,0CAH ;; sha256rnds2 STATE0, STATE1
db 0FH,038H,0CCH,0E5H ;; sha256msg1 MSGTMP1, MSGTMP2
;; rounds 12-15
movdqu MSG, oword [MSG_PTR + 3*sizeof(oword)]
pshufb MSG, oword [mask_save]
movdqa MSGTMP3, MSG
paddd MSG, oword [K256_PTR + 3*sizeof(oword)]
db 0FH,038H,0CBH,0D1H ;; sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP3
palignr MSGTMP4, MSGTMP2, 4
paddd MSGTMP0, MSGTMP4
db 0FH,038H,0CDH,0DEH ;; sha256msg2 MSGTMP0, MSGTMP3
pshufd MSG, MSG, 0Eh
db 0FH,038H,0CBH,0CAH ;; sha256rnds2 STATE0, STATE1
db 0FH,038H,0CCH,0EEH ;; sha256msg1 MSGTMP2, MSGTMP3
;; rounds 16-19
movdqa MSG, MSGTMP0
paddd MSG, oword [K256_PTR + 4*sizeof(oword)]
db 0FH,038H,0CBH,0D1H ;; sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP0
palignr MSGTMP4, MSGTMP3, 4
paddd MSGTMP1, MSGTMP4
db 0FH,038H,0CDH,0E3H ;; sha256msg2 MSGTMP1, MSGTMP0
pshufd MSG, MSG, 0Eh
db 0FH,038H,0CBH,0CAH ;; sha256rnds2 STATE0, STATE1
db 0FH,038H,0CCH,0F3H ;; sha256msg1 MSGTMP3, MSGTMP0
;; rounds 20-23
movdqa MSG, MSGTMP1
paddd MSG, oword [K256_PTR + 5*sizeof(oword)]
db 0FH,038H,0CBH,0D1H ;; sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP1
palignr MSGTMP4, MSGTMP0, 4
paddd MSGTMP2, MSGTMP4
db 0FH,038H,0CDH,0ECH ;; sha256msg2 MSGTMP2, MSGTMP1
pshufd MSG, MSG, 0Eh
db 0FH,038H,0CBH,0CAH ;; sha256rnds2 STATE0, STATE1
db 0FH,038H,0CCH,0DCH ;; sha256msg1 MSGTMP0, MSGTMP1
;; rounds 24-27
movdqa MSG, MSGTMP2
paddd MSG, oword [K256_PTR + 6*sizeof(oword)]
db 0FH,038H,0CBH,0D1H ;; sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP2
palignr MSGTMP4, MSGTMP1, 4
paddd MSGTMP3, MSGTMP4
db 0FH,038H,0CDH,0F5H ;; sha256msg2 MSGTMP3, MSGTMP2
pshufd MSG, MSG, 0Eh
db 0FH,038H,0CBH,0CAH ;; sha256rnds2 STATE0, STATE1
db 0FH,038H,0CCH,0E5H ;; sha256msg1 MSGTMP1, MSGTMP2
;; rounds 28-31
movdqa MSG, MSGTMP3
paddd MSG, oword [K256_PTR + 7*sizeof(oword)]
db 0FH,038H,0CBH,0D1H ;; sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP3
palignr MSGTMP4, MSGTMP2, 4
paddd MSGTMP0, MSGTMP4
db 0FH,038H,0CDH,0DEH ;; sha256msg2 MSGTMP0, MSGTMP3
pshufd MSG, MSG, 0Eh
db 0FH,038H,0CBH,0CAH ;; sha256rnds2 STATE0, STATE1
db 0FH,038H,0CCH,0EEH ;; sha256msg1 MSGTMP2, MSGTMP3
;; rounds 32-35
movdqa MSG, MSGTMP0
paddd MSG, oword [K256_PTR + 8*sizeof(oword)]
db 0FH,038H,0CBH,0D1H ;; sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP0
palignr MSGTMP4, MSGTMP3, 4
paddd MSGTMP1, MSGTMP4
db 0FH,038H,0CDH,0E3H ;; sha256msg2 MSGTMP1, MSGTMP0
pshufd MSG, MSG, 0Eh
db 0FH,038H,0CBH,0CAH ;; sha256rnds2 STATE0, STATE1
db 0FH,038H,0CCH,0F3H ;; sha256msg1 MSGTMP3, MSGTMP0
;; rounds 36-39
movdqa MSG, MSGTMP1
paddd MSG, oword [K256_PTR + 9*sizeof(oword)]
db 0FH,038H,0CBH,0D1H ;; sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP1
palignr MSGTMP4, MSGTMP0, 4
paddd MSGTMP2, MSGTMP4
db 0FH,038H,0CDH,0ECH ;; sha256msg2 MSGTMP2, MSGTMP1
pshufd MSG, MSG, 0Eh
db 0FH,038H,0CBH,0CAH ;; sha256rnds2 STATE0, STATE1
db 0FH,038H,0CCH,0DCH ;; sha256msg1 MSGTMP0, MSGTMP1
;; rounds 40-43
movdqa MSG, MSGTMP2
paddd MSG, oword [K256_PTR + 10*sizeof(oword)]
db 0FH,038H,0CBH,0D1H ;; sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP2
palignr MSGTMP4, MSGTMP1, 4
paddd MSGTMP3, MSGTMP4
db 0FH,038H,0CDH,0F5H ;; sha256msg2 MSGTMP3, MSGTMP2
pshufd MSG, MSG, 0Eh
db 0FH,038H,0CBH,0CAH ;; sha256rnds2 STATE0, STATE1
db 0FH,038H,0CCH,0E5H ;; sha256msg1 MSGTMP1, MSGTMP2
;; rounds 44-47
movdqa MSG, MSGTMP3
paddd MSG, oword [K256_PTR + 11*sizeof(oword)]
db 0FH,038H,0CBH,0D1H ;; sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP3
palignr MSGTMP4, MSGTMP2, 4
paddd MSGTMP0, MSGTMP4
db 0FH,038H,0CDH,0DEH ;; sha256msg2 MSGTMP0, MSGTMP3
pshufd MSG, MSG, 0Eh
db 0FH,038H,0CBH,0CAH ;; sha256rnds2 STATE0, STATE1
db 0FH,038H,0CCH,0EEH ;; sha256msg1 MSGTMP2, MSGTMP3
;; rounds 48-51
movdqa MSG, MSGTMP0
paddd MSG, oword [K256_PTR + 12*sizeof(oword)]
db 0FH,038H,0CBH,0D1H ;; sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP0
palignr MSGTMP4, MSGTMP3, 4
paddd MSGTMP1, MSGTMP4
db 0FH,038H,0CDH,0E3H ;; sha256msg2 MSGTMP1, MSGTMP0
pshufd MSG, MSG, 0Eh
db 0FH,038H,0CBH,0CAH ;; sha256rnds2 STATE0, STATE1
db 0FH,038H,0CCH,0F3H ;; sha256msg1 MSGTMP3, MSGTMP0
;; rounds 52-55
movdqa MSG, MSGTMP1
paddd MSG, oword [K256_PTR + 13*sizeof(oword)]
db 0FH,038H,0CBH,0D1H ;; sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP1
palignr MSGTMP4, MSGTMP0, 4
paddd MSGTMP2, MSGTMP4
db 0FH,038H,0CDH,0ECH ;; sha256msg2 MSGTMP2, MSGTMP1
pshufd MSG, MSG, 0Eh
db 0FH,038H,0CBH,0CAH ;; sha256rnds2 STATE0, STATE1
;; rounds 56-59
movdqa MSG, MSGTMP2
paddd MSG, oword [K256_PTR + 14*sizeof(oword)]
db 0FH,038H,0CBH,0D1H ;; sha256rnds2 STATE1, STATE0
movdqa MSGTMP4, MSGTMP2
palignr MSGTMP4, MSGTMP1, 4
paddd MSGTMP3, MSGTMP4
db 0FH,038H,0CDH,0F5H ;; sha256msg2 MSGTMP3, MSGTMP2
pshufd MSG, MSG, 0Eh
db 0FH,038H,0CBH,0CAH ;; sha256rnds2 STATE0, STATE1
;; rounds 60-63
movdqa MSG, MSGTMP3
paddd MSG, oword [K256_PTR + 15*sizeof(oword)]
db 0FH,038H,0CBH,0D1H ;; sha256rnds2 STATE1, STATE0
pshufd MSG, MSG, 0Eh
db 0FH,038H,0CBH,0CAH ;; sha256rnds2 STATE0, STATE1
paddd STATE0, oword [abef_save] ; update previously saved hash
paddd STATE1, oword [cdgh_save]
add MSG_PTR, MBS_SHA256
sub MSG_LEN, MBS_SHA256
jg .sha256_block_loop
; reorder hash
pshufd STATE0, STATE0, 01Bh ; FEBA
pshufd STATE1, STATE1, 0B1h ; DCHG
movdqa MSGTMP4, STATE0
pblendw STATE0, STATE1, 0F0h ; DCBA
palignr STATE1, MSGTMP4, 8 ; HGFE
; and store it back
movdqu oword [HASH_PTR + 0*sizeof(oword)], STATE0
movdqu oword [HASH_PTR + 1*sizeof(oword)], STATE1
.quit:
add esp, (frame_size+16)
REST_GPR
ret
ENDFUNC UpdateSHA256ni
%endif ;; VxWorks
%endif ;; _FEATURE_ON_ / _FEATURE_TICKTOCK_
%endif ;; _ENABLE_ALG_SHA256_
|
; ::: data1.txt
0001_1000
; ::: data2.txt
101
; ::: data3.txt
0101
1010
1 1 1 1
0101
1010
; ::: data4.txt
0b1101
; :::
#d incbinstr("data1.txt") ; = 0x18
; :::
#d incbinstr("data2.txt") ; = 0b101
; :::
#d incbinstr("data3.txt") ; = 0x5af5a
; :::
#d incbinstr("data4.txt") ; error: invalid character
; :::
#d incbinstr("unk") ; error: not found
; :::
#d incbinstr("unk" @ 0xffff) ; error: not found
; :::
#d x
#d incbinstr(x) ; error: not found
x = "data1.txt"
; :::
#d incbinstr() ; error: wrong
; :::
#d incbinstr("data1.txt", "data2.txt") ; error: wrong |
BLACK equ 00000000b
BLUE equ 00000001b
GREEN equ 00000010b
CYAN equ 00000011b
RED equ 00000100b
PINK equ 00000101b
BROWN equ 00000110b
GRAY equ 00000111b
DARK_GRAY equ 00001000b
BRIGHT_BLUE equ 00001001b
BRIGHT_GREEN equ 00001010b
BRIGHT_RED equ 00001100b
BRIGHT_PINK equ 00001101b
YELLOW equ 00001110b
WHITE equ 00001111b
BLOCK_SZ equ 127
macro SET_FONT v1, v2
{
mov [char_font], v2
shl byte[char_font], 4
or byte[char_font], v1
}
macro SET_CURSOR v1, v2
{
mov [cursor_x], v1
mov [cursor_y], v2
}
macro PRINT_CHAR v1
{
mov cl, v1
call print_char
}
macro PRINT_STR v1
{
push v1
call print_str
}
macro PRINT_STR_XY v1, v2, v3
{
mov [cursor_x], v1
mov [cursor_y], v2
push v3
call print_str
}
code:
cli
mov ax, 0x800 ; 0x800 segment
mov ds, ax
mov es, ax
mov ss, ax
mov sp, 0xFFFF
sti
call init_screen
call calc_cpu_clock
call calc_delays
call clear_screen
call draw_interface
call get_drives
call draw_drives
@key:
mov ah, 0x0
int 0x16
cmp ah, 0x48
je @keyup
cmp ah, 0x50
je @keydown
cmp ah, 0x1C
je @keyenter
cmp ah, 0x44
je @keyf12
@keyup:
cmp [current_drive], 0
je @key
dec [current_drive]
call draw_drives
jmp @key
@keydown:
mov ax, [max_drives]
dec ax
cmp ax, [current_drive]
je @key
inc [current_drive]
call draw_drives
jmp @key
; scan
@keyenter:
call reset_scan
SET_FONT WHITE, BLUE
PRINT_STR_XY 1, 24, s_control2
SET_FONT BLUE, GRAY
mov al, byte[current_drive]
mov byte[disk], al
mov dword[block_size], BLOCK_SZ
call scan_drive
SET_FONT WHITE, BLUE
PRINT_STR_XY 1, 24, s_control
SET_FONT BLUE, GRAY
jmp @key
; reboot
@keyf12:
mov word[0x472], 0x1234
mov al, 0xFE
out 0x64, al
hlt
jmp @key
jmp @key
jmp $
draw_drives:
mov [drive_index], 0
@@ddr:
SET_FONT BLUE, GRAY
mov dx, [drive_index]
add dx, 19
SET_CURSOR 0, dx
mov dx, [current_drive]
cmp dx, [drive_index]
jne @f
SET_FONT BLUE, CYAN
@@:
; HDD
PRINT_CHAR 221
PRINT_STR s_hdd
PRINT_CHAR 222
mov [cursor_x], 4
push [drive_index]
call print_dec
PRINT_STR s_splitter
mov bx, [drive_index]
shl bx, 2
mov eax, dword[drives + bx]
cmp dword[drives + bx], 2097152
jb @f
shr eax, 10
@@:
shr eax, 10
shl eax, 9
shr eax, 10
call print_dec32
PRINT_CHAR 'G'
mov bx, [drive_index]
shl bx, 2
cmp dword[drives + bx], 2097152
jge @f
dec [cursor_x]
PRINT_CHAR 'M'
@@:
inc [drive_index]
mov ax, [drive_index]
cmp ax, [max_drives]
jne @@ddr
ret
; ********************************** Procedures ***********************************;
init_screen:
; 80x25
mov ax, 0x3
int 0x10
; hide cursor
mov ah, 0x1
mov cx, 0x2607
int 0x10
ret
clear_screen:
SET_CURSOR 0, 0
SET_FONT BLUE, GRAY
mov cx, 2000
@@:
push cx
PRINT_CHAR ' '
pop cx
loop @b
SET_CURSOR 0, 0
ret
; cl - char
print_char:
cmp [cursor_x], 80
jb @f
mov [cursor_x], 0
inc [cursor_y]
@@:
cmp [cursor_y], 25
jb @f
mov [cursor_y], 0
@@:
xor dx, dx
mov ax, [cursor_y]
mov bx, 80
mul bx
add ax, [cursor_x]
mov bx, 2
mul bx
mov bx, ax
push 0xB800
pop es
mov byte[es:bx], cl
mov ch, [char_font]
mov byte[es:bx + 1], ch
inc [cursor_x]
ret
print_str:
push bp
mov bp, sp
mov si, [bp + 4]
@@:
cmp byte[si], 0
je @f
mov cl, byte[si]
call print_char
inc si
jmp @b
@@:
pop bp
ret 2
print_dec:
push bp
mov bp, sp
mov ax, [bp + 4]
push 0
@@:
xor dx, dx
mov bx, 10
div bx
add dl, 0x30
push dx
cmp ax, 0
jne @b
@@:
pop dx
cmp dx, 0
je @f
mov cl, dl
call print_char
jmp @b
@@:
pop bp
ret 2
; EAX
print_dec32:
mov si, buff
mov cx, 10
@@:
mov byte[si], ' '
inc si
loop @b
xor si, si
@@:
xor edx, edx
mov ebx, 10
div ebx
add dl, 0x30
mov byte[buff + si], dl
inc si
cmp eax, 0
jne @b
mov si, buff + 9
mov cx, 10
@@1:
cmp byte[si], ' '
je @f
push cx
mov cl, byte[si]
call print_char
pop cx
@@:
dec si
loop @@1
ret
buff db ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 0
get_time:
mov ah, 0x0
int 0x1A
xor eax, eax
mov ax, cx
shl eax, 16
mov ax, dx
ret
draw_interface:
SET_FONT WHITE, BLUE
; top header
SET_CURSOR 0, 0
mov cx, 80
@@:
push cx
PRINT_CHAR ' '
pop cx
loop @b
; title
SET_CURSOR 1, 0
push title
call print_str
; bottom header
SET_CURSOR 0, 24
mov cx, 80
@@:
push cx
PRINT_CHAR ' '
pop cx
loop @b
PRINT_STR_XY 1, 24, s_control
SET_FONT BLUE, GRAY
; left border
mov cx, 23
@@:
push cx
SET_CURSOR 0, cx
PRINT_CHAR 221
pop cx
loop @b
; right border
mov cx, 23
@@:
push cx
SET_CURSOR 79, cx
PRINT_CHAR 222
pop cx
loop @b
; middle border
mov cx, 23
@@:
push cx
SET_CURSOR 57, cx
PRINT_CHAR 222
pop cx
loop @b
; drives border
SET_FONT WHITE, BLUE
SET_CURSOR 0, 18
mov cx, 58
@@:
push cx
PRINT_CHAR ' '
pop cx
loop @b
PRINT_STR_XY 1, 18, s_drives
; BLACK TOP HEADER
SET_CURSOR 0, 1
SET_FONT BLUE, BLACK
PRINT_CHAR 221
mov cx, 56
@@:
push cx
PRINT_CHAR ' '
pop cx
loop @b
PRINT_CHAR 222
; BLACK DOWN HEADER
SET_CURSOR 0, 17
SET_FONT BLUE, BLACK
PRINT_CHAR 221
mov cx, 56
@@:
push cx
PRINT_CHAR ' '
pop cx
loop @b
PRINT_CHAR 222
; BLACK TOP HEADER blocks
SET_FONT BLUE, BLACK
SET_CURSOR 58, 1
mov cx, 21
@@:
push cx
PRINT_CHAR ' '
pop cx
loop @b
PRINT_CHAR 222
; BLACK TOP HEADER errors
SET_CURSOR 58, 9
mov cx, 21
@@:
push cx
PRINT_CHAR ' '
pop cx
loop @b
PRINT_CHAR 222
; block times
SET_FONT BLUE, GRAY
PRINT_STR_XY 59, 2, s_blocks_5
PRINT_STR_XY 59, 3, s_blocks_20
PRINT_STR_XY 59, 4, s_blocks_50
PRINT_STR_XY 59, 5, s_blocks_200
PRINT_STR_XY 59, 6, s_blocks_500
PRINT_STR_XY 59, 7, s_blocks_o500
PRINT_STR_XY 59, 8, s_blocks_unc
; blocks/errors
SET_FONT GRAY, BLACK
PRINT_STR_XY 59, 1, s_blocks
PRINT_STR_XY 59, 9, s_errors
; clear bad sectors list
SET_FONT BLUE, GRAY
mov [cursor_y], 10
mov cx, 14
@@:
push cx
mov [cursor_x], 58
PRINT_STR s_empty
PRINT_CHAR 222
inc [cursor_y]
pop cx
loop @b
; legend
SET_CURSOR 1, 1
SET_FONT DARK_GRAY, BLACK
PRINT_CHAR 254
SET_FONT GRAY, BLACK
PRINT_STR s_unch_block
SET_CURSOR 23, 1
SET_FONT GREEN, BLACK
PRINT_CHAR 254
SET_FONT GRAY, BLACK
PRINT_STR s_good_block
SET_CURSOR 43, 1
SET_FONT RED, BLACK
PRINT_CHAR 254
SET_FONT GRAY, BLACK
PRINT_STR s_bad_block
call draw_map
ret
calc_cpu_clock:
; get time
mov ah, 0x0
int 0x1A
mov word [d0], dx
mov word [d0 + 2], cx
; wait next tick
@@:
mov ah, 0x0
int 0x1A
mov word [d], dx
mov word [d + 2], cx
mov eax, dword[d]
sub eax, dword[d0]
cmp eax, 0
je @b
; set d0
mov ah, 0x0
int 0x1A
mov word [d0], dx
mov word [d0 + 2], cx
; start time
rdtsc
mov dword [t0_l], eax
mov dword [t0_h], edx
; wait 1 sec
@@:
mov ah, 0x0
int 0x1A
mov word [d], dx
mov word [d + 2], cx
mov eax, dword[d]
sub eax, dword[d0]
cmp eax, 18
jb @b
; finish time
rdtsc
sub edx, dword [t0_h]
cmp eax, dword [t0_l]
jb @f
dec dword[t0_h]
@@:
sub eax, dword [t0_l]
mov dword[cpu_clock], eax
ret
t0_h dd 0
t0_l dd 0
d0 dd 0
d dd 0
calc_delays:
; 5 ms
xor edx, edx
mov eax, dword[cpu_clock]
mov ebp, 200
div ebp
mov dword[ticks_5], eax
; 20 ms
xor edx, edx
mov eax, dword[cpu_clock]
mov ebp, 50
div ebp
mov dword[ticks_20], eax
; 50 ms
xor edx, edx
mov eax, dword[cpu_clock]
mov ebp, 20
div ebp
mov dword[ticks_50], eax
; 200 ms
xor edx, edx
mov eax, dword[cpu_clock]
mov ebp, 5
div ebp
mov dword[ticks_200], eax
; 500 ms
xor edx, edx
mov eax, dword[cpu_clock]
mov ebp, 2
div ebp
mov dword[ticks_500], eax
ret
check_edd:
or dl, 0x80
mov ah, 0x41
mov bx, 0x55AA
int 0x13
jnc @f
mov ax, 0
ret
@@:
mov ax, 1
ret
; DL - drive
get_drive_parameters:
mov word[dev_info], 26
or dl, 0x80
mov ah, 0x48
mov si, dev_info
int 0x13
jnc @f
mov ax, 0
ret
@@:
mov ax, 1
ret
; DL - drive
read_sector:
jmp sc3
cmp dword[dap + 8], 127
jne sc
mov ax, 0
ret
sc:
cmp dword[dap + 8], 200
jne sc2
mov ax, 0
ret
sc2:
cmp dword[dap + 8], 250
jne sc3
mov ax, 0
ret
sc3 :
mov byte[dap], 16
or dl, 0x80
mov ah, 0x42
mov si, dap
int 0x13
jnc @f
mov ax, 0
ret
@@:
mov ax, 1
ret
verify_sectors:
mov byte[dap], 16
or dl, 0x80
mov ah, 0x44
mov si, dap
int 0x13
jnc @f
mov ax, 0
ret
@@:
mov ax, 1
ret
; DL - drive
recalibrate_drive:
or dl, 0x80
mov ah, 0x11
int 0x13
jnc @f
mov ax, 0
ret
@@:
mov ax, 1
ret
;**********************************************************************;
; ;
; Get Drives List ;
; ;
;**********************************************************************;
get_drives:
mov dx, 0 ; drive num
mov bx, 0
mov cx, 5
@@gd1:
push cx
push bx
push dx
call get_drive_parameters
pop dx
inc dx
pop bx
cmp ax, 1
jne @@gd2
mov eax, dword[dev_info + 16]
mov dword[drives + bx], eax
add bx, 4
inc [max_drives]
@@gd2:
pop cx
loop @@gd1
ret
;**********************************************************************;
; ;
; Scan Block ;
; ;
;**********************************************************************;
scan_sectors:
mov ah, 0x1 ; get keyb buffer
int 0x16
jz @scan
cmp ah, 1 ; ESC pressed
je @user_abort
mov ah, 0x0 ; reset keyb buffer
int 0x16
jmp @scan
@user_abort:
mov ah, 0x0 ; reset keyb buffer
int 0x16
mov ax, 0
ret
@scan:
mov edx, dword[block_size]
mov byte[dap + 2], dl
; start time
rdtsc
mov dword [t0_l], eax
mov dword [t0_h], edx
; read block
mov dl, [disk]
call read_sector
;call verify_sectors
push ax
; finish time
rdtsc
sub edx, dword [t0_h]
cmp eax, dword [t0_l]
jb @f
dec dword[t0_h]
@@:
sub eax, dword [t0_l]
mov dword[block_time], eax
; check read_sector result
pop ax
cmp ax, 1
je scan_success
; error detected! now we test each sector
call draw_bad_blocks
mov byte[dap + 2], 1
mov cx, word[block_size]
scan_each:
push cx
mov dl, [disk]
call read_sector
cmp ax, 1
je @f
; bad sector (
call add_bad_to_list
@@:
inc dword[dap + 8]
inc dword[scanned_lba]
pop cx
loop scan_each
mov ax, 1
ret
scan_success:
call calc_blocks_speed
mov eax, dword[block_size]
add dword[dap + 8], eax
add dword[scanned_lba], eax
mov ax, 1
ret
;**********************************************************************;
; ;
; Get Drive ;
; ;
;**********************************************************************;
scan_drive:
; get geomtery
mov dl, [disk]
call get_drive_parameters
cmp ax, 0
jne @f
mov ax, 0
ret
@@:
; set head to sector 0
SET_FONT GRAY, BLACK
PRINT_STR_XY 1, 17, s_recal
mov dl, [disk]
call recalibrate_drive
mov dword[scanned_lba], 0
xor edx, edx
mov eax, dword[dev_info + 16]
mov dword[total_lba], eax
mov ebp, [block_size]
div ebp
mov dword[scan_blocks], eax
cmp edx, 0
je @f
inc dword[scan_blocks]
@@:
mov dword[scan_block], 1
mov word[dap + 4], 0x0 ; offset
mov word[dap + 6], 0x1800 ; segment
mov dword[dap + 8], 0 ; start sector (low)
mov dword[dap + 12], 0 ; start sector (high)
@@scan:
mov eax, dword[block_size]
cmp dword[dev_info + 16], eax
jge @f
mov eax, dword[dev_info + 16]
mov dword[block_size], eax
@@:
call scan_sectors
cmp ax, 0
je sc_e
call scan_progress
mov eax, dword[block_size]
sub dword[dev_info + 16], eax
cmp dword[dev_info + 16], 0
jne @@scan
; user abort
sc_e:
mov ax, 1
ret
scan_progress:
SET_FONT GRAY, BLACK
PRINT_STR_XY 1, 17, s_scan
mov eax, dword[scanned_lba]
call print_dec32
PRINT_CHAR '/'
mov eax, dword[total_lba]
call print_dec32
xor edx, edx
mov eax, dword[scan_block]
mov ebp, 100
mul ebp
mov ebp, dword[scan_blocks]
div ebp
mov dword[perc], eax
PRINT_STR s_progress
mov eax, dword[perc]
call print_dec32
PRINT_CHAR '%'
inc dword[scan_block]
; calc disk speed
mov eax, dword[scanned_lba]
sub eax, dword[speed_last]
add dword[speed_disk], eax
mov eax, dword[scanned_lba]
mov dword[speed_last], eax
call get_time
mov edx, eax ; save time
sub eax, dword[speed_time]
cmp eax, 18
jb @f
mov dword[speed_time], edx
mov eax, dword[speed_disk]
shr eax, 10
shl eax, 9
shr eax, 10
mov dword[speed_out], eax
mov dword[speed_disk], 0
@@:
PRINT_STR s_splitter
mov eax, dword[speed_out]
call print_dec32
PRINT_STR s_speed
SET_FONT BLUE, GRAY
call mark_map_block
ret
perc dd 0
add_bad_to_list:
cmp dword[bad_sectors], 14 ; FIX IT! (14 is the size of bad block list)
jne @f
ret
@@:
mov ebx, dword[bad_sectors]
shl ebx, 2
mov eax, dword[dap + 8]
mov dword[bad_sectors_list + ebx], eax
inc dword[bad_sectors]
; draw
SET_FONT WHITE, RED
mov [cursor_y], 10
mov bx, 0
mov cx, word[bad_sectors]
@@:
push cx
push bx
mov [cursor_x], 58
PRINT_STR s_empty
SET_FONT BLUE, RED
PRINT_CHAR 222
SET_FONT WHITE, RED
pop bx
push bx
mov [cursor_x], 59
mov si, bx
shl si, 2
mov eax, dword[bad_sectors_list + si]
call print_dec32
pop bx
inc bx
inc [cursor_y]
pop cx
loop @b
SET_FONT BLUE, GRAY
ret
draw_bad_blocks:
SET_FONT BLUE, GRAY
inc dword[blocks_bad]
mov [map_bad_block], 1
SET_CURSOR 69, 8
mov eax, dword[blocks_bad]
call print_dec32
ret
calc_blocks_speed:
SET_FONT BLUE, GRAY
mov eax, dword[block_time]
cmp eax, dword[ticks_500]
jbe check_block500
jmp add_block_o500
check_block500:
cmp eax, dword[ticks_200]
jg add_block500
jbe check_block200
check_block200:
cmp eax, dword[ticks_50]
jg add_block200
jbe check_block50
check_block50:
cmp eax, dword[ticks_20]
jg add_block50
jbe check_block20
check_block20:
cmp eax, dword[ticks_5]
jg add_block20
jbe add_block5
add_block5:
inc dword[blocks_5]
SET_CURSOR 69, 2
mov eax, dword[blocks_5]
jmp print_block
add_block20:
inc dword[blocks_20]
SET_CURSOR 69, 3
mov eax, dword[blocks_20]
jmp print_block
add_block50:
inc dword[blocks_50]
SET_CURSOR 69, 4
mov eax, dword[blocks_50]
jmp print_block
add_block200:
inc dword[blocks_200]
SET_CURSOR 69, 5
mov eax, dword[blocks_200]
jmp print_block
add_block500:
inc dword[blocks_500]
SET_CURSOR 69, 6
mov eax, dword[blocks_500]
jmp print_block
add_block_o500:
inc dword[blocks_o500]
SET_CURSOR 69, 7
mov eax, dword[blocks_o500]
jmp print_block
print_block:
call print_dec32
ret
draw_map:
SET_FONT DARK_GRAY, GRAY
SET_CURSOR 1, 2
mov cx, 840
@d_m:
push cx
PRINT_CHAR 254
cmp [cursor_x], 57
jne @f
mov [cursor_x], 1
inc [cursor_y]
@@:
pop cx
loop @d_m
SET_FONT BLUE, GRAY
ret
; EAX - block
mark_map_block:
SET_FONT GREEN, GRAY
mov eax, dword[scan_block]
sub eax, 2 ; scan_block - 2
xor edx, edx
mov ebp, 840
mul ebp
;xor edx, edx ; do not clear EDX else 32 Bit OVERFLOW detected!
mov ebp, dword[scan_blocks]
div ebp
xor edx, edx
mov ebp, 56
div ebp
add eax, 2
mov [cursor_y], ax ; Y
add edx, 1
mov [cursor_x], dx ; X
push [cursor_y]
push [cursor_x]
; check prev
cmp ax, [map_prev_y]
jne @mark
cmp dx, [map_prev_x]
jne @mark
cmp [map_bad_block], 1
je @mark
jmp @no_mark
@mark:
cmp [map_bad_block], 1
jne @f
SET_FONT RED, GRAY
mov [map_bad_block], 0
@@:
PRINT_CHAR 254
@no_mark:
SET_FONT BLUE, GRAY
pop [map_prev_x]
pop [map_prev_y]
ret
reset_scan:
mov [block_size], 0
mov [scan_block], 0
mov [scan_blocks], 0
mov [scanned_lba], 0
mov [total_lba], 0
mov [blocks_5], 0
mov [blocks_20], 0
mov [blocks_50], 0
mov [blocks_200], 0
mov [blocks_500], 0
mov [blocks_o500], 0
mov [blocks_bad] , 0
mov [bad_sectors], 0
mov [map_prev_x], 0xFFFF
mov [map_prev_y], 0xFFFF
mov [map_bad_block], 0
mov dword[speed_time], 0
mov dword[speed_disk], 0
mov dword[speed_last], 0
mov dword[speed_out], 0
call draw_interface
call draw_drives
ret
; ******************************** Data ***************************************** ;
cursor_x dw 0
cursor_y dw 0
char_font db 0
cpu_clock dd 0
ticks_5 dd 0
ticks_20 dd 0
ticks_50 dd 0
ticks_200 dd 0
ticks_500 dd 0
disk db 0
block_size dd 0
scan_block dd 0
scan_blocks dd 0
scanned_lba dd 0
total_lba dd 0
block_time dd 0
blocks_5 dd 0
blocks_20 dd 0
blocks_50 dd 0
blocks_200 dd 0
blocks_500 dd 0
blocks_o500 dd 0
blocks_bad dd 0
bad_sectors dd 0
map_prev_x dw 0xFFFF
map_prev_y dw 0xFFFF
map_bad_block db 0
speed_time dd 0
speed_disk dd 0
speed_last dd 0
speed_out dd 0
max_drives dw 0
drive_index dw 0
current_drive dw 0
drives:
dd 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
bad_sectors_list:
times 50 dd 0
dev_info:
dw 0 ;size
dw 0 ;info
dd 0 ;cyl
dd 0 ;head
dd 0 ;secpertrack;
dd 0 ;sectors_lo;
dd 0 ;sectors_hi;
dw 0 ;bytespersec;
dap:
db 0 ;size;
db 0 ;reserved1;
db 0 ;count;
db 0 ;reserved2;
dw 0 ;offset;
dw 0 ;segment;
dd 0 ;sector_lo;
dd 0 ;sector_hi;
title db "GL DiskTest", 0
s_control db 24, 25, " - Select drive ENTER - Begin test F10 - Reboot", 0
s_control2 db "ESC - Stop test ", 0
s_blocks_5 db 254, " 5ms : ", 0
s_blocks_20 db 254, " 20ms : ", 0
s_blocks_50 db 254, " 50ms : ", 0
s_blocks_200 db 254, " 200ms : ", 0
s_blocks_500 db 254, " 500ms : ", 0
s_blocks_o500 db 254, " >500ms: ", 0
s_blocks_unc db 254, " UNC : ", 0
s_blocks db "Blocks", 0
s_errors db "Errors", 0
s_drives db "Drives", 0
s_progress db " LBA - ", 0
s_hdd db "HDD ", 0
s_speed db "MB/s ", 0
s_splitter db " - ", 0
s_empty db " ", 0
s_unch_block db " - Unchecked block", 0
s_good_block db " - Checked block", 0
s_bad_block db " - Bad block", 0
s_recal db "Recalibrate...", 0
s_scan db "Scan ", 0
|
#include "BoardSPI.h"
#include "Definitions.h"
BoardSPI::BoardSPI() {
}
void BoardSPI::initialize() {
spi.begin();
spi.setSpeed(4000000); // use 4MHz for ADS and LIS3DH
spi.setMode(DSPI_MODE0); // default to SD card mode!
}
void BoardSPI::activateADS() {
spi.setMode(DSPI_MODE1);
spi.setSpeed(4000000);
digitalWrite(BOARD_ADS, LOW);
}
void BoardSPI::deactivateADS() {
digitalWrite(BOARD_ADS, HIGH);
spi.setSpeed(20000000);
spi.setMode(DSPI_MODE0); // DEFAULT TO SD MODE!
}
void BoardSPI::activateSD() {
spi.setMode(DSPI_MODE0);
spi.setSpeed(20000000);
digitalWrite(SD_SS, LOW);
}
void BoardSPI::deactivateSD() {
digitalWrite(SD_SS, HIGH);
}
unsigned char BoardSPI::send(unsigned char value) {
return spi.transfer(value);
}
BoardSPI bSPI;
|
; exit(99) Linux x86
;
; Shellcode WITH NULL BYTES to exit(99). Used solely for testing.
; by Daniel Roberson (daniel @ planethacker . net)
;
BITS 32
mov eax, 1
mov ebx, 99
int 0x80
|
; A003881: Decimal expansion of Pi/4.
; Submitted by Christian Krause
; 7,8,5,3,9,8,1,6,3,3,9,7,4,4,8,3,0,9,6,1,5,6,6,0,8,4,5,8,1,9,8,7,5,7,2,1,0,4,9,2,9,2,3,4,9,8,4,3,7,7,6,4,5,5,2,4,3,7,3,6,1,4,8,0,7,6,9,5,4,1,0,1,5,7,1,5,5,2,2,4,9,6,5,7,0,0,8,7,0,6,3,3,5,5,2,9,2,6,6,9
mov $1,1
mov $2,1
mov $3,$0
mul $3,5
lpb $3
mul $1,$3
mov $5,$3
mul $5,2
add $5,1
mul $2,$5
add $1,$2
cmp $4,0
mov $5,$0
add $5,$4
div $1,$5
div $2,$5
sub $3,1
lpe
mul $1,5
mov $6,10
pow $6,$0
mov $4,$6
cmp $4,1
add $6,$4
div $2,$6
mov $4,$2
cmp $4,0
add $2,$4
div $1,$2
add $1,$6
mov $0,$1
mod $0,10
|
.386
END
|
; A094729: Number of connected ordered 2-element multiantichains on a labeled n-set.
; 0,1,1,7,37,151,541,1807,5797,18151,55981,171007,519157,1569751,4733821,14250607,42850117,128746951,386634061,1160688607,3483638677,10454061751,31368476701,94118013007,282379204837,847187946151,2541664501741,7625194831807,22875987148597,68628766752151,205887910869181,617666953833007,1853007303949957,5559034796751751,16677130160059021,50031442019784607,150094429138568917,450283493574136951,1350850893039271261,4052553503751534607,12157662160522045477,36472989780101019751,109418975937372825901,328256941006258011007,984770849407053099637,2954312600997717432151,8862937908546268562941,26588813936745038221807,79766442232447579731397,239299327541767669326151,717897984314152868242381,2153693956320158325255007,6461081875715874416820757,19383245640658422132573751,58149736948996864161944221,174449210901033788014278607,523347632811187755099727717,1570042898649736047412966951,4710128696381553706466468461,14130386090009352247854540607,42391158271757439000473892277,127173474818731081515242217751,381520424463110773573367735101,1144561273403167378775385369007,3433683820237172252436720434437,10301051460766856989531289958151,30903154382411251433036127184141,92709463147455115227992896171807,278128389442808067541747717754197,834385168329309646340781211740151,2503155504989699826453419752175581,7509466514972641254222411490437007,22528399544925007312391538939131557,67585198634789189036623225753035751,202755595904395901308766895130389421,608266787713244372324095121133732607
mov $2,2
lpb $0
sub $0,1
trn $1,1
add $1,$2
mov $2,$1
mul $1,2
mul $3,2
add $3,3
lpe
sub $1,$3
mov $0,$1
|
section .data
sy: db 1d,
sx: db 40d,
c: db 1d,
t: db 0d,
printchar: db 0d,
section .text
global _start
_start:
call clearscreen
_start2:
call init
call printthreetriangles
inc byte [sy]
add byte [sx], 5d
startl2:
mov cl,[c]
startl1:
push cx
call printthreetriangles
pop cx
sub byte [sx], 7d
sub byte [sy], 3d
dec cl
cmp cl,0d
jnz startl1
add byte [sy], 4d
add byte [sx], 20d
mov al,[t]
add byte [sx], al
add byte [t], 8d
inc byte [c]
cmp byte [c], 6d
jne startl2
jmp _start2
clearscreen:
mov ah, 0h
mov al, 3h
int 10h
mov ah,9h
mov al,32d
mov bl,2d
mov cx,2000d
int 10h
ret
init:
mov byte [sy],1d
mov byte [sx],40d
mov byte [c],2d
mov byte [t],0d
ret
printthreetriangles:
mov cl,3d
pttl:
cmp cl,2d
jne ptt2
inc byte [sy]
inc byte [sx]
ptt2:
cmp cl,1d
jne ptt1
dec byte [sy]
sub byte [sx], 5
ptt1:
dec cl
call printtriangle
cmp cl,0d
jnz pttl
ret
print:
mov ah,02h
mov dh,[sy]
mov dl,[sx]
int 10h
mov ah,9h
mov al,[printchar]
add bl,[fs:046ch]
shr bl,4
and bl,[sx]
inc bl
push cx
mov cx,1d
int 10h
pop cx
ret
printtriangle:
mov byte [printchar], 42d
call print
mov byte [printchar], 47d
inc byte [sy]
dec byte [sx]
call print
mov byte [printchar], 92d
add byte [sx], 2
call print
ret |
; Read AMX Mouse
; 08.2003 aralbrec
PUBLIC INMouseAMX
EXTERN _in_AMXcoordX, _in_AMXcoordY
; exit : C = button state 00000MRL active high
; B = X coordinate (0..255)
; A = Y coordinate (0..191)
; uses : AF,BC,HL
.INMouseAMX
ld c,$1f
in a,($df) ; mouse button state will randomly
or c ; fluctuate except when the mouse
ld c,a ; buttons are really pressed!
in a,($df) ; let's hope reading the buttons
or c ; five times is enough
ld c,a
in a,($df)
or c
ld c,a
in a,($df)
or c
ld c,a
in a,($df)
or c
rlca
rlca
rlca
and $07
add a,buttbl % 256
ld l,a
ld h,buttbl / 256
jr nc, noinc
inc h
.noinc
ld c,(hl) ; c = button state
ld a,(_in_AMXcoordX + 1)
ld b,a
ld a,(_in_AMXcoordY + 1)
cp 192
ret c
ld a,191
ld (_in_AMXcoordY + 1),a
ret
.buttbl
defb $07, $03, $05, $01, $06, $02, $04, $00
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %r13
push %r9
push %rbp
push %rdx
push %rsi
lea addresses_WT_ht+0x19278, %r11
nop
nop
nop
nop
cmp $38388, %r9
mov (%r11), %bp
nop
sub $47796, %rsi
lea addresses_WT_ht+0x1358a, %r9
nop
nop
add %r13, %r13
movb (%r9), %dl
nop
nop
cmp $16927, %rdx
lea addresses_normal_ht+0x16dd2, %r9
nop
nop
nop
nop
add %r11, %r11
mov (%r9), %edx
nop
cmp $6487, %r11
lea addresses_D_ht+0x71d2, %rbp
and $13624, %r10
mov $0x6162636465666768, %r13
movq %r13, %xmm3
vmovups %ymm3, (%rbp)
xor $11231, %r10
lea addresses_D_ht+0x1a7c0, %rbp
nop
nop
nop
sub $361, %rsi
movb (%rbp), %r10b
dec %r13
lea addresses_WC_ht+0xec56, %r10
nop
nop
nop
nop
nop
add $64255, %rbp
mov $0x6162636465666768, %r13
movq %r13, %xmm6
movups %xmm6, (%r10)
nop
nop
nop
nop
xor $9600, %rsi
pop %rsi
pop %rdx
pop %rbp
pop %r9
pop %r13
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r13
push %r15
push %r8
push %r9
push %rbp
push %rcx
// Store
lea addresses_WC+0x1a5b2, %r15
nop
cmp $61469, %r13
mov $0x5152535455565758, %r8
movq %r8, %xmm3
vmovups %ymm3, (%r15)
nop
nop
nop
and %r8, %r8
// Store
lea addresses_US+0x1fd2, %r8
nop
cmp %r10, %r10
movl $0x51525354, (%r8)
nop
nop
nop
sub $3950, %r9
// Faulty Load
lea addresses_WC+0x10dd2, %r13
nop
nop
nop
nop
sub $62663, %rcx
vmovups (%r13), %ymm5
vextracti128 $0, %ymm5, %xmm5
vpextrq $1, %xmm5, %r8
lea oracles, %r15
and $0xff, %r8
shlq $12, %r8
mov (%r15,%r8,1), %r8
pop %rcx
pop %rbp
pop %r9
pop %r8
pop %r15
pop %r13
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'size': 32, 'NT': True, 'type': 'addresses_WC', 'same': True, 'AVXalign': False, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'size': 32, 'NT': False, 'type': 'addresses_WC', 'same': False, 'AVXalign': False, 'congruent': 3}}
{'OP': 'STOR', 'dst': {'size': 4, 'NT': False, 'type': 'addresses_US', 'same': False, 'AVXalign': False, 'congruent': 6}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'size': 32, 'NT': False, 'type': 'addresses_WC', 'same': True, 'AVXalign': False, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'size': 2, 'NT': False, 'type': 'addresses_WT_ht', 'same': False, 'AVXalign': False, 'congruent': 0}}
{'OP': 'LOAD', 'src': {'size': 1, 'NT': False, 'type': 'addresses_WT_ht', 'same': False, 'AVXalign': False, 'congruent': 3}}
{'OP': 'LOAD', 'src': {'size': 4, 'NT': False, 'type': 'addresses_normal_ht', 'same': False, 'AVXalign': True, 'congruent': 11}}
{'OP': 'STOR', 'dst': {'size': 32, 'NT': False, 'type': 'addresses_D_ht', 'same': False, 'AVXalign': False, 'congruent': 9}}
{'OP': 'LOAD', 'src': {'size': 1, 'NT': False, 'type': 'addresses_D_ht', 'same': False, 'AVXalign': False, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'size': 16, 'NT': False, 'type': 'addresses_WC_ht', 'same': False, 'AVXalign': False, 'congruent': 1}}
{'00': 5174}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
|
; A224329: Number of idempotent n X n 0..4 matrices of rank n-1.
; 1,18,147,996,6245,37494,218743,1249992,7031241,39062490,214843739,1171874988,6347656237,34179687486,183105468735,976562499984,5187988281233,27465820312482,144958496093731,762939453124980,4005432128906229
mov $3,$0
lpb $0
sub $0,1
mov $2,5
lpe
add $1,8
pow $2,$3
mul $2,2
sub $2,1
add $3,1
mul $3,$2
add $1,$3
sub $1,8
|
.global s_prepare_buffers
s_prepare_buffers:
push %r12
push %r13
push %r15
push %r9
push %rbp
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_WT_ht+0x19c04, %rdx
nop
nop
nop
nop
nop
sub $7339, %rbp
mov (%rdx), %r15d
dec %r13
lea addresses_normal_ht+0x1d050, %r9
nop
nop
and $62971, %r12
movups (%r9), %xmm4
vpextrq $0, %xmm4, %rcx
nop
sub $47525, %rbp
lea addresses_normal_ht+0x185ac, %r15
nop
nop
nop
xor %r12, %r12
movups (%r15), %xmm1
vpextrq $1, %xmm1, %r13
nop
nop
nop
nop
nop
inc %r13
lea addresses_A_ht+0x18d36, %rsi
lea addresses_normal_ht+0xe10e, %rdi
clflush (%rsi)
nop
nop
and $16476, %r13
mov $44, %rcx
rep movsq
nop
nop
nop
nop
add %r12, %r12
lea addresses_D_ht+0x10aba, %r15
nop
nop
nop
and $59036, %rcx
mov $0x6162636465666768, %r13
movq %r13, %xmm4
vmovups %ymm4, (%r15)
nop
nop
nop
nop
cmp $24045, %rcx
lea addresses_WT_ht+0x166c6, %rsi
nop
and $15253, %r13
mov $0x6162636465666768, %r9
movq %r9, %xmm4
vmovups %ymm4, (%rsi)
cmp $39116, %rdx
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbp
pop %r9
pop %r15
pop %r13
pop %r12
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r13
push %r14
push %r15
push %r8
push %rax
push %rdx
// Store
lea addresses_UC+0x8572, %r14
cmp %r13, %r13
mov $0x5152535455565758, %r12
movq %r12, (%r14)
nop
nop
dec %r12
// Faulty Load
lea addresses_WC+0x1e572, %r15
clflush (%r15)
nop
cmp $27573, %rdx
mov (%r15), %r13d
lea oracles, %r14
and $0xff, %r13
shlq $12, %r13
mov (%r14,%r13,1), %r13
pop %rdx
pop %rax
pop %r8
pop %r15
pop %r14
pop %r13
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_WC', 'same': False, 'size': 16, 'congruent': 0, 'NT': True, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_UC', 'same': False, 'size': 8, 'congruent': 11, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
[Faulty Load]
{'src': {'type': 'addresses_WC', 'same': True, 'size': 4, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_WT_ht', 'same': False, 'size': 4, 'congruent': 1, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_normal_ht', 'same': False, 'size': 16, 'congruent': 1, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_normal_ht', 'same': True, 'size': 16, 'congruent': 1, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_A_ht', 'congruent': 0, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 2, 'same': False}, 'OP': 'REPM'}
{'dst': {'type': 'addresses_D_ht', 'same': False, 'size': 32, 'congruent': 3, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_WT_ht', 'same': False, 'size': 32, 'congruent': 2, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'38': 21829}
38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38
*/
|
; A041683: Denominators of continued fraction convergents to sqrt(360).
; 1,1,37,38,1405,1443,53353,54796,2026009,2080805,76934989,79015794,2921503573,3000519367,110940200785,113940720152,4212806126257,4326746846409,159975692596981,164302439443390,6074863512559021,6239165952002411,230684837784645817,236924003736648228,8759948972303982025,8996872976040630253,332647376109766671133,341644249085807301386,12631840343198829521029,12973484592284636822415,479677285665445755127969,492650770257730391950384,18215105014943739865341793,18707755785201470257292177
seq $0,41161 ; Denominators of continued fraction convergents to sqrt(90).
dif $0,2
|
.global s_prepare_buffers
s_prepare_buffers:
push %r13
push %r15
push %rbp
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_WC_ht+0x135c5, %rbp
nop
nop
add $47309, %r15
movb (%rbp), %dl
nop
nop
nop
and %rdx, %rdx
lea addresses_WT_ht+0x199c5, %rsi
lea addresses_normal_ht+0x3645, %rdi
nop
nop
nop
nop
nop
inc %r13
mov $122, %rcx
rep movsw
sub $4604, %rdi
lea addresses_WT_ht+0x1daef, %rdx
nop
nop
nop
nop
cmp %r15, %r15
mov $0x6162636465666768, %rcx
movq %rcx, %xmm5
movups %xmm5, (%rdx)
nop
nop
nop
nop
nop
xor %rdi, %rdi
lea addresses_D_ht+0xc845, %r15
clflush (%r15)
cmp $35008, %rbp
mov (%r15), %rdi
nop
nop
nop
nop
nop
cmp %rcx, %rcx
lea addresses_UC_ht+0x61c5, %rsi
lea addresses_UC_ht+0xf845, %rdi
nop
nop
nop
and $22722, %rdx
mov $43, %rcx
rep movsl
nop
nop
and $19978, %rcx
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbp
pop %r15
pop %r13
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %rax
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
// REPMOV
lea addresses_WT+0x3245, %rsi
lea addresses_D+0x6845, %rdi
clflush (%rdi)
nop
nop
nop
nop
and $63037, %r11
mov $23, %rcx
rep movsw
nop
nop
sub %rdi, %rdi
// Load
mov $0x66ccc90000000438, %rbx
nop
nop
nop
sub %rdx, %rdx
mov (%rbx), %si
nop
nop
dec %rbx
// Store
lea addresses_RW+0x14e79, %rax
nop
nop
nop
dec %r11
movl $0x51525354, (%rax)
nop
sub $43784, %rax
// Load
lea addresses_UC+0x46e5, %rsi
nop
nop
nop
nop
xor %r11, %r11
movups (%rsi), %xmm4
vpextrq $1, %xmm4, %rdx
nop
nop
nop
nop
nop
inc %r11
// Store
lea addresses_normal+0x15945, %rsi
nop
nop
dec %rcx
mov $0x5152535455565758, %rbx
movq %rbx, %xmm0
vmovups %ymm0, (%rsi)
and %r11, %r11
// Faulty Load
lea addresses_D+0x6845, %rdx
nop
nop
sub $64096, %rcx
movb (%rdx), %r11b
lea oracles, %rbx
and $0xff, %r11
shlq $12, %r11
mov (%rbx,%r11,1), %r11
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %rax
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_D', 'AVXalign': False, 'size': 8, 'NT': False, 'same': False, 'congruent': 0}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WT', 'congruent': 8, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_D', 'congruent': 0, 'same': True}}
{'src': {'type': 'addresses_NC', 'AVXalign': False, 'size': 2, 'NT': False, 'same': False, 'congruent': 0}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'type': 'addresses_RW', 'AVXalign': False, 'size': 4, 'NT': False, 'same': False, 'congruent': 1}}
{'src': {'type': 'addresses_UC', 'AVXalign': False, 'size': 16, 'NT': False, 'same': False, 'congruent': 2}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'type': 'addresses_normal', 'AVXalign': False, 'size': 32, 'NT': False, 'same': False, 'congruent': 8}}
[Faulty Load]
{'src': {'type': 'addresses_D', 'AVXalign': False, 'size': 1, 'NT': True, 'same': True, 'congruent': 0}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 1, 'NT': False, 'same': False, 'congruent': 6}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WT_ht', 'congruent': 7, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_normal_ht', 'congruent': 9, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 16, 'NT': False, 'same': False, 'congruent': 0}}
{'src': {'type': 'addresses_D_ht', 'AVXalign': False, 'size': 8, 'NT': False, 'same': False, 'congruent': 11}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_UC_ht', 'congruent': 7, 'same': True}, 'OP': 'REPM', 'dst': {'type': 'addresses_UC_ht', 'congruent': 7, 'same': False}}
{'39': 7}
39 39 39 39 39 39 39
*/
|
/*
* Copyright 2022 HEAVY.AI, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <gtest/gtest.h>
#include <boost/filesystem.hpp>
#include <boost/filesystem/operations.hpp>
#include <csignal>
#include <thread>
#include <tuple>
#include "../Catalog/Catalog.h"
#include "../Catalog/DBObject.h"
#include "../DataMgr/DataMgr.h"
#include "../QueryEngine/ArrowResultSet.h"
#include "../QueryEngine/Descriptors/RelAlgExecutionDescriptor.h"
#include "../QueryEngine/Execute.h"
#include "../QueryRunner/QueryRunner.h"
#include "DBHandlerTestHelpers.h"
#include "Shared/SysDefinitions.h"
#include "Shared/scope.h"
#include "TestHelpers.h"
#include "ThriftHandler/QueryState.h"
#include "gen-cpp/CalciteServer.h"
#ifndef BASE_PATH
#define BASE_PATH "./tmp"
#endif
using namespace TestHelpers;
using QR = QueryRunner::QueryRunner;
using Catalog_Namespace::DBMetadata;
using Catalog_Namespace::SysCatalog;
using Catalog_Namespace::UserMetadata;
extern size_t g_leaf_count;
std::string g_test_binary_file_path;
namespace {
std::shared_ptr<Calcite> g_calcite;
bool g_aggregator{false};
Catalog_Namespace::UserMetadata g_user;
std::vector<DBObject> privObjects;
auto& sys_cat = Catalog_Namespace::SysCatalog::instance();
inline void run_ddl_statement(const std::string& query) {
QR::get()->runDDLStatement(query);
}
inline auto sql(std::string_view sql_stmts) {
return QR::get()->runMultipleStatements(std::string(sql_stmts),
ExecutorDeviceType::CPU);
}
} // namespace
struct Users {
void setup_users() {
if (!sys_cat.getMetadataForUser("Chelsea", g_user)) {
sys_cat.createUser(
"Chelsea",
Catalog_Namespace::UserAlterations{
"password", /*is_super=*/true, /*default_db=*/"", /*can_login=*/true},
false);
CHECK(sys_cat.getMetadataForUser("Chelsea", g_user));
}
if (!sys_cat.getMetadataForUser("Arsenal", g_user)) {
sys_cat.createUser(
"Arsenal",
Catalog_Namespace::UserAlterations{
"password", /*is_super=*/false, /*default_db=*/"", /*can_login=*/true},
false);
CHECK(sys_cat.getMetadataForUser("Arsenal", g_user));
}
if (!sys_cat.getMetadataForUser("Juventus", g_user)) {
sys_cat.createUser(
"Juventus",
Catalog_Namespace::UserAlterations{
"password", /*is_super=*/false, /*default_db=*/"", /*can_login=*/true},
false);
CHECK(sys_cat.getMetadataForUser("Juventus", g_user));
}
if (!sys_cat.getMetadataForUser("Bayern", g_user)) {
sys_cat.createUser(
"Bayern",
Catalog_Namespace::UserAlterations{
"password", /*is_super=*/false, /*default_db=*/"", /*can_login=*/true},
false);
CHECK(sys_cat.getMetadataForUser("Bayern", g_user));
}
}
void drop_users() {
if (sys_cat.getMetadataForUser("Chelsea", g_user)) {
sys_cat.dropUser("Chelsea");
CHECK(!sys_cat.getMetadataForUser("Chelsea", g_user));
}
if (sys_cat.getMetadataForUser("Arsenal", g_user)) {
sys_cat.dropUser("Arsenal");
CHECK(!sys_cat.getMetadataForUser("Arsenal", g_user));
}
if (sys_cat.getMetadataForUser("Juventus", g_user)) {
sys_cat.dropUser("Juventus");
CHECK(!sys_cat.getMetadataForUser("Juventus", g_user));
}
if (sys_cat.getMetadataForUser("Bayern", g_user)) {
sys_cat.dropUser("Bayern");
CHECK(!sys_cat.getMetadataForUser("Bayern", g_user));
}
}
Users() { setup_users(); }
virtual ~Users() { drop_users(); }
};
struct Roles {
void setup_roles() {
if (!sys_cat.getRoleGrantee("OldLady")) {
sys_cat.createRole("OldLady", false);
CHECK(sys_cat.getRoleGrantee("OldLady"));
}
if (!sys_cat.getRoleGrantee("Gunners")) {
sys_cat.createRole("Gunners", false);
CHECK(sys_cat.getRoleGrantee("Gunners"));
}
if (!sys_cat.getRoleGrantee("Sudens")) {
sys_cat.createRole("Sudens", false);
CHECK(sys_cat.getRoleGrantee("Sudens"));
}
}
void drop_roles() {
if (sys_cat.getRoleGrantee("OldLady")) {
sys_cat.dropRole("OldLady");
CHECK(!sys_cat.getRoleGrantee("OldLady"));
}
if (sys_cat.getRoleGrantee("Gunners")) {
sys_cat.dropRole("Gunners");
CHECK(!sys_cat.getRoleGrantee("Gunners"));
}
if (sys_cat.getRoleGrantee("Sudens")) {
sys_cat.dropRole("Sudens");
CHECK(!sys_cat.getRoleGrantee("sudens"));
}
}
Roles() { setup_roles(); }
virtual ~Roles() { drop_roles(); }
};
struct GrantSyntax : testing::Test {
Users user_;
Roles role_;
void setup_tables() {
run_ddl_statement("CREATE TABLE IF NOT EXISTS tbl(i INTEGER)");
run_ddl_statement("CREATE VIEW grantView AS SELECT i FROM tbl;");
}
void drop_tables() {
run_ddl_statement("DROP TABLE IF EXISTS tbl");
run_ddl_statement("DROP VIEW IF EXISTS grantView");
}
explicit GrantSyntax() {
drop_tables();
setup_tables();
}
~GrantSyntax() override { drop_tables(); }
};
struct DatabaseObject : testing::Test {
Catalog_Namespace::UserMetadata user_meta;
Catalog_Namespace::DBMetadata db_meta;
Users user_;
Roles role_;
explicit DatabaseObject() {}
~DatabaseObject() override {}
};
struct TableObject : testing::Test {
const std::string cquery1 =
"CREATE TABLE IF NOT EXISTS epl(gp SMALLINT, won SMALLINT);";
const std::string cquery2 =
"CREATE TABLE IF NOT EXISTS seriea(gp SMALLINT, won SMALLINT);";
const std::string cquery3 =
"CREATE TABLE IF NOT EXISTS bundesliga(gp SMALLINT, won SMALLINT);";
const std::string dquery1 = "DROP TABLE IF EXISTS epl;";
const std::string dquery2 = "DROP TABLE IF EXISTS seriea;";
const std::string dquery3 = "DROP TABLE IF EXISTS bundesliga;";
Users user_;
Roles role_;
void setup_tables() {
run_ddl_statement(cquery1);
run_ddl_statement(cquery2);
run_ddl_statement(cquery3);
}
void drop_tables() {
run_ddl_statement(dquery1);
run_ddl_statement(dquery2);
run_ddl_statement(dquery3);
}
explicit TableObject() {
drop_tables();
setup_tables();
}
~TableObject() override { drop_tables(); }
};
class ViewObject : public ::testing::Test {
protected:
void SetUp() override {
run_ddl_statement("CREATE USER bob (password = 'password', is_super = 'false');");
run_ddl_statement("CREATE ROLE salesDept;");
run_ddl_statement("CREATE USER foo (password = 'password', is_super = 'false');");
run_ddl_statement("GRANT salesDept TO foo;");
run_ddl_statement("CREATE TABLE bill_table(id integer);");
run_ddl_statement("CREATE VIEW bill_view AS SELECT id FROM bill_table;");
run_ddl_statement("CREATE VIEW bill_view_outer AS SELECT id FROM bill_view;");
}
void TearDown() override {
run_ddl_statement("DROP VIEW bill_view_outer;");
run_ddl_statement("DROP VIEW bill_view;");
run_ddl_statement("DROP TABLE bill_table");
run_ddl_statement("DROP USER foo;");
run_ddl_statement("DROP ROLE salesDept;");
run_ddl_statement("DROP USER bob;");
}
};
class DashboardObject : public ::testing::Test {
protected:
const std::string dname1 = "ChampionsLeague";
const std::string dname2 = "Europa";
const std::string dstate = "active";
const std::string dhash = "image00";
const std::string dmeta = "Chelsea are champions";
int id;
Users user_;
Roles role_;
DashboardDescriptor vd1;
void setup_dashboards() {
auto session = QR::get()->getSession();
CHECK(session);
auto& cat = session->getCatalog();
vd1.dashboardName = dname1;
vd1.dashboardState = dstate;
vd1.imageHash = dhash;
vd1.dashboardMetadata = dmeta;
vd1.userId = session->get_currentUser().userId;
vd1.user = session->get_currentUser().userName;
id = cat.createDashboard(vd1);
sys_cat.createDBObject(
session->get_currentUser(), dname1, DBObjectType::DashboardDBObjectType, cat, id);
}
void drop_dashboards() {
auto session = QR::get()->getSession();
CHECK(session);
auto& cat = session->getCatalog();
if (cat.getMetadataForDashboard(id)) {
cat.deleteMetadataForDashboards({id}, session->get_currentUser());
}
}
void SetUp() override {
drop_dashboards();
setup_dashboards();
}
void TearDown() override { drop_dashboards(); }
};
struct ServerObject : public DBHandlerTestFixture {
Users user_;
Roles role_;
protected:
void SetUp() override {
if (g_aggregator) {
LOG(INFO) << "Test fixture not supported in distributed mode.";
return;
}
DBHandlerTestFixture::SetUp();
sql("CREATE SERVER test_server FOREIGN DATA WRAPPER delimited_file "
"WITH (storage_type = 'LOCAL_FILE', base_path = '/test_path/');");
}
void TearDown() override {
if (g_aggregator) {
LOG(INFO) << "Test fixture not supported in distributed mode.";
return;
}
sql("DROP SERVER IF EXISTS test_server;");
DBHandlerTestFixture::TearDown();
}
};
TEST_F(GrantSyntax, MultiPrivilegeGrantRevoke) {
if (g_aggregator) {
LOG(ERROR) << "Test not supported in distributed mode.";
return;
}
auto session = QR::get()->getSession();
CHECK(session);
auto& cat = session->getCatalog();
DBObject tbl_object("tbl", DBObjectType::TableDBObjectType);
tbl_object.loadKey(cat);
tbl_object.resetPrivileges();
auto tbl_object_select = tbl_object;
auto tbl_object_insert = tbl_object;
tbl_object_select.setPrivileges(AccessPrivileges::SELECT_FROM_TABLE);
tbl_object_insert.setPrivileges(AccessPrivileges::INSERT_INTO_TABLE);
std::vector<DBObject> objects = {tbl_object_select, tbl_object_insert};
ASSERT_NO_THROW(
sys_cat.grantDBObjectPrivilegesBatch({"Arsenal", "Juventus"}, objects, cat));
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", objects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", objects), true);
ASSERT_NO_THROW(
sys_cat.revokeDBObjectPrivilegesBatch({"Arsenal", "Juventus"}, objects, cat));
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", objects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", objects), false);
// now the same thing, but with SQL queries
ASSERT_NO_THROW(
run_ddl_statement("GRANT SELECT, INSERT ON TABLE tbl TO Arsenal, Juventus"));
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", objects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", objects), true);
ASSERT_NO_THROW(
run_ddl_statement("REVOKE SELECT, INSERT ON TABLE tbl FROM Arsenal, Juventus"));
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", objects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", objects), false);
}
TEST_F(GrantSyntax, MultiRoleGrantRevoke) {
if (g_aggregator) {
LOG(ERROR) << "Test not supported in distributed mode.";
return;
}
std::vector<std::string> roles = {"Gunners", "Sudens"};
std::vector<std::string> grantees = {"Juventus", "Bayern"};
auto check_grant = []() {
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("Juventus", "Gunners", true), true);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("Bayern", "Gunners", true), true);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("Juventus", "Sudens", true), true);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("Bayern", "Sudens", true), true);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("Arsenal", "Sudens", true), false);
};
auto check_revoke = []() {
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("Juventus", "Gunners", true), false);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("Bayern", "Gunners", true), false);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("Juventus", "Sudens", true), false);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("Bayern", "Sudens", true), false);
};
ASSERT_NO_THROW(sys_cat.grantRoleBatch(roles, grantees));
check_grant();
ASSERT_NO_THROW(sys_cat.revokeRoleBatch(roles, grantees));
check_revoke();
// now the same thing, but with SQL queries
ASSERT_NO_THROW(run_ddl_statement("GRANT Gunners, Sudens TO Juventus, Bayern"));
check_grant();
ASSERT_NO_THROW(run_ddl_statement("REVOKE Gunners, Sudens FROM Juventus, Bayern"));
check_revoke();
}
class InvalidGrantSyntax : public DBHandlerTestFixture {};
TEST_F(InvalidGrantSyntax, InvalidGrantSyntax) {
std::string error_message;
error_message =
"SQL Error: Encountered \"ON\" at line 1, column 23.\nWas expecting one of:\n "
"\"ALTER\" ...\n \"CREATE\" ...\n \"DELETE\" ...\n \"DROP\" ...\n "
"\"INSERT\" ...\n \"SELECT\" ...\n \"TRUNCATE\" ...\n \"UPDATE\" ...\n "
"\"USAGE\" ...\n \"VIEW\" ...\n \"ACCESS\" ...\n \"EDIT\" ...\n "
"\"SERVER\" ...\n \"ALL\" ...\n ";
queryAndAssertException("GRANT SELECT, INSERT, ON TABLE tbl TO Arsenal, Juventus;",
error_message);
}
TEST_F(InvalidGrantSyntax, InvalidGrantType) {
std::string error_message;
error_message = "GRANT failed. Object 'grantView' of type TABLE not found.";
queryAndAssertException("GRANT SELECT ON TABLE grantView TO Arsenal;", error_message);
error_message = "REVOKE failed. Object 'grantView' of type TABLE not found.";
queryAndAssertException("REVOKE SELECT ON TABLE grantView FROM Arsenal;",
error_message);
error_message = "GRANT failed. Object 'tbl' of type VIEW not found.";
queryAndAssertException("GRANT SELECT ON VIEW tbl TO Arsenal;", error_message);
error_message = "REVOKE failed. Object 'tbl' of type VIEW not found.";
queryAndAssertException("REVOKE SELECT ON VIEW tbl FROM Arsenal;", error_message);
}
TEST(UserRoles, InvalidGrantsRevokesTest) {
run_ddl_statement("CREATE USER Antazin(password = 'password', is_super = 'false');");
run_ddl_statement("CREATE USER \"Max\"(password = 'password', is_super = 'false');");
EXPECT_THROW(run_ddl_statement("GRANT Antazin to Antazin;"), std::runtime_error);
EXPECT_THROW(run_ddl_statement("REVOKE Antazin from Antazin;"), std::runtime_error);
EXPECT_THROW(run_ddl_statement("GRANT Antazin to \"Max\";"), std::runtime_error);
EXPECT_THROW(run_ddl_statement("REVOKE Antazin from \"Max\";"), std::runtime_error);
EXPECT_THROW(run_ddl_statement("GRANT \"Max\" to Antazin;"), std::runtime_error);
EXPECT_THROW(run_ddl_statement("REVOKE \"Max\" from Antazin;"), std::runtime_error);
run_ddl_statement("DROP USER Antazin;");
run_ddl_statement("DROP USER \"Max\";");
}
TEST(UserRoles, ValidNames) {
EXPECT_NO_THROW(
run_ddl_statement("CREATE USER \"dumm.user\" (password = 'password');"));
EXPECT_NO_THROW(run_ddl_statement("DROP USER \"dumm.user\";"));
EXPECT_NO_THROW(run_ddl_statement("CREATE USER vasya (password = 'password');"));
EXPECT_NO_THROW(run_ddl_statement(
"CREATE USER \"vasya.vasya@vasya.com\" (password = 'password');"));
EXPECT_NO_THROW(run_ddl_statement(
"CREATE USER \"vasya ivanov@vasya.ivanov.com\" (password = 'password');"));
EXPECT_NO_THROW(
run_ddl_statement("CREATE USER \"vasya-vasya\" (password = 'password');"));
EXPECT_NO_THROW(run_ddl_statement("CREATE ROLE developer;"));
EXPECT_NO_THROW(run_ddl_statement("CREATE ROLE \"developer-backend\";"));
EXPECT_NO_THROW(run_ddl_statement("CREATE ROLE \"developer-backend-rendering\";"));
EXPECT_NO_THROW(run_ddl_statement("GRANT \"developer-backend-rendering\" TO vasya;"));
EXPECT_NO_THROW(run_ddl_statement(
"GRANT \"developer-backend\" TO \"vasya ivanov@vasya.ivanov.com\";"));
EXPECT_NO_THROW(run_ddl_statement("GRANT developer TO \"vasya.vasya@vasya.com\";"));
EXPECT_NO_THROW(
run_ddl_statement("GRANT \"developer-backend-rendering\" TO \"vasya-vasya\";"));
EXPECT_NO_THROW(run_ddl_statement("DROP USER vasya;"));
EXPECT_NO_THROW(run_ddl_statement("DROP USER \"vasya.vasya@vasya.com\";"));
EXPECT_NO_THROW(run_ddl_statement("DROP USER \"vasya ivanov@vasya.ivanov.com\";"));
EXPECT_NO_THROW(run_ddl_statement("DROP USER \"vasya-vasya\";"));
EXPECT_NO_THROW(run_ddl_statement("DROP ROLE developer;"));
EXPECT_NO_THROW(run_ddl_statement("DROP ROLE \"developer-backend\";"));
EXPECT_NO_THROW(run_ddl_statement("DROP ROLE \"developer-backend-rendering\";"));
}
TEST(UserRoles, RoleHierarchies) {
// hr prefix here stands for hierarchical roles
// create objects
run_ddl_statement("CREATE USER hr_u1 (password = 'u1');");
run_ddl_statement("CREATE ROLE hr_r1;");
run_ddl_statement("CREATE ROLE hr_r2;");
run_ddl_statement("CREATE ROLE hr_r3;");
run_ddl_statement("CREATE ROLE hr_r4;");
run_ddl_statement("CREATE TABLE hr_tbl1 (i INTEGER);");
// check that we can't create cycles
EXPECT_NO_THROW(run_ddl_statement("GRANT hr_r4 TO hr_r3;"));
EXPECT_THROW(run_ddl_statement("GRANT hr_r3 TO hr_r4;"), std::runtime_error);
EXPECT_NO_THROW(run_ddl_statement("GRANT hr_r3 TO hr_r2;"));
EXPECT_THROW(run_ddl_statement("GRANT hr_r2 TO hr_r4;"), std::runtime_error);
// make the grant hierarchy
EXPECT_NO_THROW(run_ddl_statement("GRANT hr_r2 TO hr_r1;"));
EXPECT_NO_THROW(run_ddl_statement("GRANT hr_r1 TO hr_u1;"));
EXPECT_NO_THROW(run_ddl_statement("GRANT SELECT ON TABLE hr_tbl1 TO hr_r1;"));
EXPECT_NO_THROW(run_ddl_statement("GRANT INSERT ON TABLE hr_tbl1 TO hr_r2;"));
EXPECT_NO_THROW(run_ddl_statement("GRANT DELETE ON TABLE hr_tbl1 TO hr_r3;"));
EXPECT_NO_THROW(run_ddl_statement("GRANT UPDATE ON TABLE hr_tbl1 TO hr_r4;"));
// check that we see privileges gratnted via roles' hierarchy
auto session = QR::get()->getSession();
CHECK(session);
auto& cat = session->getCatalog();
AccessPrivileges tbl_privs;
ASSERT_NO_THROW(tbl_privs.add(AccessPrivileges::SELECT_FROM_TABLE));
ASSERT_NO_THROW(tbl_privs.add(AccessPrivileges::INSERT_INTO_TABLE));
ASSERT_NO_THROW(tbl_privs.add(AccessPrivileges::DELETE_FROM_TABLE));
ASSERT_NO_THROW(tbl_privs.add(AccessPrivileges::UPDATE_IN_TABLE));
DBObject tbl1_object("hr_tbl1", DBObjectType::TableDBObjectType);
tbl1_object.loadKey(cat);
ASSERT_NO_THROW(tbl1_object.setPrivileges(tbl_privs));
privObjects.clear();
privObjects.push_back(tbl1_object);
EXPECT_EQ(sys_cat.checkPrivileges("hr_u1", privObjects), true);
// check that when we remove privilege from one role, it's grantees are updated
EXPECT_NO_THROW(run_ddl_statement("REVOKE DELETE ON TABLE hr_tbl1 FROM hr_r3;"));
EXPECT_EQ(sys_cat.checkPrivileges("hr_u1", privObjects), false);
tbl_privs.remove(AccessPrivileges::DELETE_FROM_TABLE);
ASSERT_NO_THROW(tbl1_object.setPrivileges(tbl_privs));
privObjects.clear();
privObjects.push_back(tbl1_object);
EXPECT_EQ(sys_cat.checkPrivileges("hr_u1", privObjects), true);
// check that if we remove a role from a middle of hierarchy everythings is fine
EXPECT_NO_THROW(run_ddl_statement("REVOKE hr_r2 FROM hr_r1;"));
EXPECT_EQ(sys_cat.checkPrivileges("hr_u1", privObjects), false);
tbl_privs.remove(AccessPrivileges::UPDATE_IN_TABLE);
ASSERT_NO_THROW(tbl1_object.setPrivileges(tbl_privs));
privObjects.clear();
privObjects.push_back(tbl1_object);
EXPECT_EQ(sys_cat.checkPrivileges("hr_u1", privObjects), false);
tbl_privs.remove(AccessPrivileges::INSERT_INTO_TABLE);
ASSERT_NO_THROW(tbl1_object.setPrivileges(tbl_privs));
privObjects.clear();
privObjects.push_back(tbl1_object);
EXPECT_EQ(sys_cat.checkPrivileges("hr_u1", privObjects), true);
// clean-up objects
run_ddl_statement("DROP USER hr_u1;");
run_ddl_statement("DROP ROLE hr_r1;");
run_ddl_statement("DROP ROLE hr_r2;");
run_ddl_statement("DROP ROLE hr_r3;");
run_ddl_statement("DROP ROLE hr_r4;");
run_ddl_statement("DROP TABLE hr_tbl1;");
}
TEST(Roles, RecursiveRoleCheckTest) {
// create roles
run_ddl_statement("CREATE ROLE regista;");
run_ddl_statement("CREATE ROLE makelele;");
run_ddl_statement("CREATE ROLE raumdeuter;");
run_ddl_statement("CREATE ROLE cdm;");
run_ddl_statement("CREATE ROLE shadow_cm;");
run_ddl_statement("CREATE ROLE ngolo_kante;");
run_ddl_statement("CREATE ROLE thomas_muller;");
run_ddl_statement("CREATE ROLE jorginho;");
run_ddl_statement("CREATE ROLE bhagwan;");
run_ddl_statement("CREATE ROLE messi;");
// Grant roles
EXPECT_NO_THROW(run_ddl_statement("GRANT cdm TO regista;"));
EXPECT_NO_THROW(run_ddl_statement("GRANT cdm TO makelele;"));
EXPECT_NO_THROW(run_ddl_statement("GRANT shadow_cm TO raumdeuter;"));
EXPECT_NO_THROW(run_ddl_statement("GRANT regista to jorginho;"));
EXPECT_NO_THROW(run_ddl_statement("GRANT makelele to ngolo_kante;"));
EXPECT_NO_THROW(run_ddl_statement("GRANT raumdeuter to thomas_muller;"));
EXPECT_NO_THROW(run_ddl_statement("GRANT makelele to ngolo_kante;"));
EXPECT_NO_THROW(run_ddl_statement("GRANT makelele to bhagwan;"));
EXPECT_NO_THROW(run_ddl_statement("GRANT regista to bhagwan;"));
EXPECT_NO_THROW(run_ddl_statement("GRANT raumdeuter to bhagwan;"));
EXPECT_NO_THROW(run_ddl_statement("GRANT bhagwan to messi;"));
auto check_jorginho = [&]() {
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("jorginho", "regista", true), true);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("jorginho", "makelele", false), false);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("jorginho", "raumdeuter", false), false);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("jorginho", "cdm", true), false);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("jorginho", "cdm", false), true);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("jorginho", "shadow_cm", false), false);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("jorginho", "bhagwan", false), false);
};
auto check_kante = [&]() {
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("ngolo_kante", "regista", false), false);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("ngolo_kante", "makelele", true), true);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("ngolo_kante", "raumdeuter", false), false);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("ngolo_kante", "cdm", true), false);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("ngolo_kante", "cdm", false), true);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("ngolo_kante", "shadow_cm", false), false);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("ngolo_kante", "bhagwan", false), false);
};
auto check_muller = [&]() {
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("thomas_muller", "regista", false), false);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("thomas_muller", "makelele", false), false);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("thomas_muller", "raumdeuter", true), true);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("thomas_muller", "cdm", false), false);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("thomas_muller", "shadow_cm", true), false);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("thomas_muller", "shadow_cm", false), true);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("thomas_muller", "bhagwan", false), false);
};
auto check_messi = [&]() {
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("messi", "regista", false), true);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("messi", "makelele", false), true);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("messi", "raumdeuter", false), true);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("messi", "regista", true), false);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("messi", "makelele", true), false);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("messi", "raumdeuter", true), false);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("messi", "cdm", false), true);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("messi", "cdm", true), false);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("messi", "shadow_cm", true), false);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("messi", "shadow_cm", false), true);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("messi", "bhagwan", false), true);
EXPECT_EQ(sys_cat.isRoleGrantedToGrantee("messi", "bhagwan", true), true);
};
auto drop_roles = [&]() {
run_ddl_statement("DROP ROLE regista;");
run_ddl_statement("DROP ROLE makelele;");
run_ddl_statement("DROP ROLE raumdeuter;");
run_ddl_statement("DROP ROLE cdm;");
run_ddl_statement("DROP ROLE shadow_cm;");
run_ddl_statement("DROP ROLE ngolo_kante;");
run_ddl_statement("DROP ROLE thomas_muller;");
run_ddl_statement("DROP ROLE jorginho;");
run_ddl_statement("DROP ROLE bhagwan;");
run_ddl_statement("DROP ROLE messi;");
};
// validate recursive roles
check_jorginho();
check_kante();
check_muller();
check_messi();
// cleanup objects
drop_roles();
}
TEST_F(DatabaseObject, AccessDefaultsTest) {
auto cat_mapd = sys_cat.getCatalog(shared::kDefaultDbName);
DBObject mapd_object(shared::kDefaultDbName, DBObjectType::DatabaseDBObjectType);
privObjects.clear();
mapd_object.loadKey(*cat_mapd);
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
}
TEST_F(DatabaseObject, SqlEditorAccessTest) {
std::unique_ptr<Catalog_Namespace::SessionInfo> session_juve;
CHECK(sys_cat.getMetadataForDB(shared::kDefaultDbName, db_meta));
CHECK(sys_cat.getMetadataForUser("Juventus", user_meta));
session_juve.reset(new Catalog_Namespace::SessionInfo(
sys_cat.getCatalog(db_meta.dbName), user_meta, ExecutorDeviceType::GPU, ""));
auto& cat_mapd = session_juve->getCatalog();
DBObject mapd_object(shared::kDefaultDbName, DBObjectType::DatabaseDBObjectType);
privObjects.clear();
mapd_object.loadKey(cat_mapd);
mapd_object.setPermissionType(DatabaseDBObjectType);
mapd_object.resetPrivileges();
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::VIEW_SQL_EDITOR));
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
mapd_object.resetPrivileges();
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::VIEW_SQL_EDITOR));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivilegesBatch(
{"Chelsea", "Juventus"}, {mapd_object}, cat_mapd));
mapd_object.resetPrivileges();
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::VIEW_SQL_EDITOR));
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
mapd_object.resetPrivileges();
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::VIEW_SQL_EDITOR));
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivilegesBatch(
{"Chelsea", "Juventus"}, {mapd_object}, cat_mapd));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivilegesBatch(
{"Bayern", "Arsenal"}, {mapd_object}, cat_mapd));
mapd_object.resetPrivileges();
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::VIEW_SQL_EDITOR));
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), true);
}
TEST_F(DatabaseObject, DBLoginAccessTest) {
std::unique_ptr<Catalog_Namespace::SessionInfo> session_juve;
CHECK(sys_cat.getMetadataForDB(shared::kDefaultDbName, db_meta));
CHECK(sys_cat.getMetadataForUser("Bayern", user_meta));
session_juve.reset(new Catalog_Namespace::SessionInfo(
sys_cat.getCatalog(db_meta.dbName), user_meta, ExecutorDeviceType::GPU, ""));
auto& cat_mapd = session_juve->getCatalog();
DBObject mapd_object(shared::kDefaultDbName, DBObjectType::DatabaseDBObjectType);
privObjects.clear();
mapd_object.loadKey(cat_mapd);
mapd_object.setPermissionType(DatabaseDBObjectType);
mapd_object.resetPrivileges();
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::ACCESS));
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
mapd_object.resetPrivileges();
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::ACCESS));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivilegesBatch(
{"Arsenal", "Bayern"}, {mapd_object}, cat_mapd));
mapd_object.resetPrivileges();
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::ACCESS));
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), true);
mapd_object.resetPrivileges();
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::ACCESS));
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivilegesBatch(
{"Bayern", "Arsenal"}, {mapd_object}, cat_mapd));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivileges("Juventus", mapd_object, cat_mapd));
mapd_object.resetPrivileges();
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::VIEW_SQL_EDITOR));
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
}
TEST_F(DatabaseObject, TableAccessTest) {
std::unique_ptr<Catalog_Namespace::SessionInfo> session_ars;
CHECK(sys_cat.getMetadataForDB(shared::kDefaultDbName, db_meta));
CHECK(sys_cat.getMetadataForUser("Arsenal", user_meta));
session_ars.reset(new Catalog_Namespace::SessionInfo(
sys_cat.getCatalog(db_meta.dbName), user_meta, ExecutorDeviceType::GPU, ""));
auto& cat_mapd = session_ars->getCatalog();
AccessPrivileges arsenal_privs;
AccessPrivileges bayern_privs;
ASSERT_NO_THROW(arsenal_privs.add(AccessPrivileges::CREATE_TABLE));
ASSERT_NO_THROW(arsenal_privs.add(AccessPrivileges::DROP_TABLE));
ASSERT_NO_THROW(bayern_privs.add(AccessPrivileges::ALTER_TABLE));
DBObject mapd_object(shared::kDefaultDbName, DBObjectType::DatabaseDBObjectType);
privObjects.clear();
mapd_object.loadKey(cat_mapd);
mapd_object.setPermissionType(TableDBObjectType);
mapd_object.resetPrivileges();
ASSERT_NO_THROW(mapd_object.setPrivileges(arsenal_privs));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivileges("Arsenal", mapd_object, cat_mapd));
mapd_object.resetPrivileges();
ASSERT_NO_THROW(mapd_object.setPrivileges(arsenal_privs));
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
mapd_object.resetPrivileges();
privObjects.clear();
ASSERT_NO_THROW(arsenal_privs.remove(AccessPrivileges::CREATE_TABLE));
ASSERT_NO_THROW(mapd_object.setPrivileges(arsenal_privs));
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("Arsenal", mapd_object, cat_mapd));
mapd_object.resetPrivileges();
privObjects.clear();
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::CREATE_TABLE));
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
mapd_object.resetPrivileges();
privObjects.clear();
ASSERT_NO_THROW(mapd_object.setPrivileges(bayern_privs));
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
mapd_object.resetPrivileges();
privObjects.clear();
ASSERT_NO_THROW(mapd_object.setPrivileges(bayern_privs));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivileges("Bayern", mapd_object, cat_mapd));
mapd_object.resetPrivileges();
privObjects.clear();
ASSERT_NO_THROW(mapd_object.setPrivileges(bayern_privs));
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), true);
}
TEST_F(DatabaseObject, ViewAccessTest) {
std::unique_ptr<Catalog_Namespace::SessionInfo> session_ars;
CHECK(sys_cat.getMetadataForDB(shared::kDefaultDbName, db_meta));
CHECK(sys_cat.getMetadataForUser("Arsenal", user_meta));
session_ars.reset(new Catalog_Namespace::SessionInfo(
sys_cat.getCatalog(db_meta.dbName), user_meta, ExecutorDeviceType::GPU, ""));
auto& cat_mapd = session_ars->getCatalog();
AccessPrivileges arsenal_privs;
ASSERT_NO_THROW(arsenal_privs.add(AccessPrivileges::ALL_VIEW));
DBObject mapd_object(shared::kDefaultDbName, DBObjectType::DatabaseDBObjectType);
privObjects.clear();
mapd_object.loadKey(cat_mapd);
mapd_object.setPermissionType(ViewDBObjectType);
mapd_object.resetPrivileges();
ASSERT_NO_THROW(mapd_object.setPrivileges(arsenal_privs));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivileges("Arsenal", mapd_object, cat_mapd));
mapd_object.resetPrivileges();
ASSERT_NO_THROW(mapd_object.setPrivileges(arsenal_privs));
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
mapd_object.resetPrivileges();
privObjects.clear();
ASSERT_NO_THROW(arsenal_privs.remove(AccessPrivileges::DROP_VIEW));
ASSERT_NO_THROW(arsenal_privs.remove(AccessPrivileges::TRUNCATE_VIEW));
ASSERT_NO_THROW(mapd_object.setPrivileges(arsenal_privs));
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("Arsenal", mapd_object, cat_mapd));
mapd_object.resetPrivileges();
privObjects.clear();
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::ALL_VIEW));
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
mapd_object.resetPrivileges();
privObjects.clear();
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::DROP_VIEW));
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
mapd_object.resetPrivileges();
privObjects.clear();
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::TRUNCATE_VIEW));
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
}
TEST_F(DatabaseObject, DashboardAccessTest) {
std::unique_ptr<Catalog_Namespace::SessionInfo> session_ars;
CHECK(sys_cat.getMetadataForDB(shared::kDefaultDbName, db_meta));
CHECK(sys_cat.getMetadataForUser("Arsenal", user_meta));
session_ars.reset(new Catalog_Namespace::SessionInfo(
sys_cat.getCatalog(db_meta.dbName), user_meta, ExecutorDeviceType::GPU, ""));
auto& cat_mapd = session_ars->getCatalog();
AccessPrivileges arsenal_privs;
ASSERT_NO_THROW(arsenal_privs.add(AccessPrivileges::ALL_DASHBOARD));
DBObject mapd_object(shared::kDefaultDbName, DBObjectType::DatabaseDBObjectType);
privObjects.clear();
mapd_object.loadKey(cat_mapd);
mapd_object.setPermissionType(DashboardDBObjectType);
mapd_object.resetPrivileges();
ASSERT_NO_THROW(mapd_object.setPrivileges(arsenal_privs));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivileges("Arsenal", mapd_object, cat_mapd));
mapd_object.resetPrivileges();
ASSERT_NO_THROW(mapd_object.setPrivileges(arsenal_privs));
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
mapd_object.resetPrivileges();
privObjects.clear();
ASSERT_NO_THROW(arsenal_privs.remove(AccessPrivileges::EDIT_DASHBOARD));
ASSERT_NO_THROW(mapd_object.setPrivileges(arsenal_privs));
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("Arsenal", mapd_object, cat_mapd));
mapd_object.resetPrivileges();
privObjects.clear();
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::CREATE_DASHBOARD));
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
mapd_object.resetPrivileges();
privObjects.clear();
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::DELETE_DASHBOARD));
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
mapd_object.resetPrivileges();
privObjects.clear();
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::EDIT_DASHBOARD));
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
}
TEST_F(DatabaseObject, DatabaseAllTest) {
std::unique_ptr<Catalog_Namespace::SessionInfo> session_ars;
CHECK(sys_cat.getMetadataForDB(shared::kDefaultDbName, db_meta));
CHECK(sys_cat.getMetadataForUser("Arsenal", user_meta));
session_ars.reset(new Catalog_Namespace::SessionInfo(
sys_cat.getCatalog(db_meta.dbName), user_meta, ExecutorDeviceType::GPU, ""));
auto& cat_mapd = session_ars->getCatalog();
AccessPrivileges arsenal_privs;
ASSERT_NO_THROW(arsenal_privs.add(AccessPrivileges::ALL_DATABASE));
DBObject mapd_object(shared::kDefaultDbName, DBObjectType::DatabaseDBObjectType);
privObjects.clear();
mapd_object.loadKey(cat_mapd);
mapd_object.resetPrivileges();
ASSERT_NO_THROW(mapd_object.setPrivileges(arsenal_privs));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivileges("Arsenal", mapd_object, cat_mapd));
mapd_object.resetPrivileges();
mapd_object.setPermissionType(TableDBObjectType);
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::ALL_TABLE));
privObjects.push_back(mapd_object);
mapd_object.setPermissionType(ViewDBObjectType);
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::ALL_VIEW));
privObjects.push_back(mapd_object);
mapd_object.setPermissionType(DashboardDBObjectType);
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::ALL_DASHBOARD));
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
mapd_object.resetPrivileges();
privObjects.clear();
mapd_object.setPermissionType(TableDBObjectType);
ASSERT_NO_THROW(arsenal_privs.remove(AccessPrivileges::SELECT_FROM_TABLE));
ASSERT_NO_THROW(mapd_object.setPrivileges(arsenal_privs));
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("Arsenal", mapd_object, cat_mapd));
mapd_object.resetPrivileges();
privObjects.clear();
arsenal_privs.reset();
mapd_object.setPermissionType(DashboardDBObjectType);
ASSERT_NO_THROW(arsenal_privs.add(AccessPrivileges::DELETE_DASHBOARD));
ASSERT_NO_THROW(mapd_object.setPrivileges(arsenal_privs));
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("Arsenal", mapd_object, cat_mapd));
mapd_object.resetPrivileges();
privObjects.clear();
mapd_object.setPermissionType(ViewDBObjectType);
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::ALL_VIEW));
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
mapd_object.resetPrivileges();
privObjects.clear();
mapd_object.setPermissionType(DashboardDBObjectType);
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::DELETE_DASHBOARD));
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
mapd_object.resetPrivileges();
privObjects.clear();
mapd_object.setPermissionType(TableDBObjectType);
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::SELECT_FROM_TABLE));
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
mapd_object.resetPrivileges();
privObjects.clear();
arsenal_privs.reset();
mapd_object.setPermissionType(DatabaseDBObjectType);
ASSERT_NO_THROW(arsenal_privs.add(AccessPrivileges::ALL_DATABASE));
ASSERT_NO_THROW(mapd_object.setPrivileges(arsenal_privs));
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("Arsenal", mapd_object, cat_mapd));
mapd_object.resetPrivileges();
privObjects.clear();
mapd_object.setPermissionType(ViewDBObjectType);
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::ALL_VIEW));
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
mapd_object.resetPrivileges();
privObjects.clear();
mapd_object.setPermissionType(TableDBObjectType);
ASSERT_NO_THROW(mapd_object.setPrivileges(AccessPrivileges::INSERT_INTO_TABLE));
privObjects.push_back(mapd_object);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
}
TEST_F(TableObject, AccessDefaultsTest) {
auto session = QR::get()->getSession();
CHECK(session);
auto& cat = session->getCatalog();
ASSERT_NO_THROW(sys_cat.grantRole("Sudens", "Bayern"));
ASSERT_NO_THROW(sys_cat.grantRole("OldLady", "Juventus"));
AccessPrivileges epl_privs;
AccessPrivileges seriea_privs;
AccessPrivileges bundesliga_privs;
ASSERT_NO_THROW(epl_privs.add(AccessPrivileges::SELECT_FROM_TABLE));
ASSERT_NO_THROW(seriea_privs.add(AccessPrivileges::SELECT_FROM_TABLE));
ASSERT_NO_THROW(bundesliga_privs.add(AccessPrivileges::SELECT_FROM_TABLE));
privObjects.clear();
DBObject epl_object("epl", DBObjectType::TableDBObjectType);
DBObject seriea_object("seriea", DBObjectType::TableDBObjectType);
DBObject bundesliga_object("bundesliga", DBObjectType::TableDBObjectType);
epl_object.loadKey(cat);
seriea_object.loadKey(cat);
bundesliga_object.loadKey(cat);
ASSERT_NO_THROW(epl_object.setPrivileges(epl_privs));
ASSERT_NO_THROW(seriea_object.setPrivileges(seriea_privs));
ASSERT_NO_THROW(bundesliga_object.setPrivileges(bundesliga_privs));
privObjects.push_back(epl_object);
privObjects.push_back(seriea_object);
privObjects.push_back(bundesliga_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
}
TEST_F(TableObject, AccessAfterGrantsTest) {
auto session = QR::get()->getSession();
CHECK(session);
auto& cat = session->getCatalog();
ASSERT_NO_THROW(sys_cat.grantRole("Sudens", "Bayern"));
ASSERT_NO_THROW(sys_cat.grantRole("OldLady", "Juventus"));
AccessPrivileges epl_privs;
AccessPrivileges seriea_privs;
AccessPrivileges bundesliga_privs;
ASSERT_NO_THROW(epl_privs.add(AccessPrivileges::SELECT_FROM_TABLE));
ASSERT_NO_THROW(seriea_privs.add(AccessPrivileges::SELECT_FROM_TABLE));
ASSERT_NO_THROW(bundesliga_privs.add(AccessPrivileges::SELECT_FROM_TABLE));
privObjects.clear();
DBObject epl_object("epl", DBObjectType::TableDBObjectType);
DBObject seriea_object("seriea", DBObjectType::TableDBObjectType);
DBObject bundesliga_object("bundesliga", DBObjectType::TableDBObjectType);
epl_object.loadKey(cat);
seriea_object.loadKey(cat);
bundesliga_object.loadKey(cat);
ASSERT_NO_THROW(epl_object.setPrivileges(epl_privs));
ASSERT_NO_THROW(seriea_object.setPrivileges(seriea_privs));
ASSERT_NO_THROW(bundesliga_object.setPrivileges(bundesliga_privs));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivileges("Arsenal", epl_object, cat));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivileges("Sudens", bundesliga_object, cat));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivileges("OldLady", seriea_object, cat));
privObjects.push_back(epl_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
privObjects.clear();
privObjects.push_back(seriea_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
privObjects.clear();
privObjects.push_back(bundesliga_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), true);
}
TEST_F(TableObject, AccessAfterRevokesTest) {
auto session = QR::get()->getSession();
CHECK(session);
auto& cat = session->getCatalog();
ASSERT_NO_THROW(sys_cat.grantRole("OldLady", "Juventus"));
ASSERT_NO_THROW(sys_cat.grantRole("Gunners", "Arsenal"));
AccessPrivileges epl_privs;
AccessPrivileges seriea_privs;
AccessPrivileges bundesliga_privs;
ASSERT_NO_THROW(epl_privs.add(AccessPrivileges::SELECT_FROM_TABLE));
ASSERT_NO_THROW(epl_privs.add(AccessPrivileges::INSERT_INTO_TABLE));
ASSERT_NO_THROW(seriea_privs.add(AccessPrivileges::SELECT_FROM_TABLE));
ASSERT_NO_THROW(bundesliga_privs.add(AccessPrivileges::ALL_TABLE));
privObjects.clear();
DBObject epl_object("epl", DBObjectType::TableDBObjectType);
DBObject seriea_object("seriea", DBObjectType::TableDBObjectType);
DBObject bundesliga_object("bundesliga", DBObjectType::TableDBObjectType);
epl_object.loadKey(cat);
seriea_object.loadKey(cat);
bundesliga_object.loadKey(cat);
ASSERT_NO_THROW(epl_object.setPrivileges(epl_privs));
ASSERT_NO_THROW(seriea_object.setPrivileges(seriea_privs));
ASSERT_NO_THROW(bundesliga_object.setPrivileges(bundesliga_privs));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivileges("Gunners", epl_object, cat));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivileges("Bayern", bundesliga_object, cat));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivileges("OldLady", seriea_object, cat));
privObjects.push_back(epl_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
privObjects.clear();
privObjects.push_back(seriea_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
privObjects.clear();
privObjects.push_back(bundesliga_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), true);
epl_object.resetPrivileges();
seriea_object.resetPrivileges();
bundesliga_object.resetPrivileges();
ASSERT_NO_THROW(epl_privs.remove(AccessPrivileges::SELECT_FROM_TABLE));
ASSERT_NO_THROW(epl_object.setPrivileges(epl_privs));
ASSERT_NO_THROW(seriea_object.setPrivileges(seriea_privs));
ASSERT_NO_THROW(bundesliga_object.setPrivileges(bundesliga_privs));
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("Gunners", epl_object, cat));
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("Bayern", bundesliga_object, cat));
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("OldLady", seriea_object, cat));
epl_object.resetPrivileges();
ASSERT_NO_THROW(epl_object.setPrivileges(AccessPrivileges::SELECT_FROM_TABLE));
privObjects.clear();
privObjects.push_back(epl_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
epl_object.resetPrivileges();
ASSERT_NO_THROW(epl_object.setPrivileges(AccessPrivileges::INSERT_INTO_TABLE));
privObjects.clear();
privObjects.push_back(epl_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
seriea_object.resetPrivileges();
ASSERT_NO_THROW(seriea_object.setPrivileges(AccessPrivileges::SELECT_FROM_TABLE));
privObjects.clear();
privObjects.push_back(seriea_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
seriea_object.resetPrivileges();
ASSERT_NO_THROW(seriea_object.setPrivileges(AccessPrivileges::INSERT_INTO_TABLE));
privObjects.clear();
privObjects.push_back(seriea_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
bundesliga_object.resetPrivileges();
ASSERT_NO_THROW(bundesliga_object.setPrivileges(AccessPrivileges::ALL_TABLE));
privObjects.clear();
privObjects.push_back(bundesliga_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
}
void testViewPermissions(std::string user, std::string roleToGrant) {
DBObject bill_view("bill_view", DBObjectType::ViewDBObjectType);
auto session = QR::get()->getSession();
CHECK(session);
auto& cat = session->getCatalog();
bill_view.loadKey(cat);
std::vector<DBObject> privs;
bill_view.setPrivileges(AccessPrivileges::CREATE_VIEW);
privs = {bill_view};
EXPECT_EQ(sys_cat.checkPrivileges(user, privs), false);
bill_view.setPrivileges(AccessPrivileges::DROP_VIEW);
privs = {bill_view};
EXPECT_EQ(sys_cat.checkPrivileges(user, privs), false);
bill_view.setPrivileges(AccessPrivileges::SELECT_FROM_VIEW);
privs = {bill_view};
EXPECT_EQ(sys_cat.checkPrivileges(user, privs), false);
bill_view.setPrivileges(AccessPrivileges::CREATE_VIEW);
sys_cat.grantDBObjectPrivileges(roleToGrant, bill_view, cat);
bill_view.setPrivileges(AccessPrivileges::CREATE_VIEW);
privs = {bill_view};
EXPECT_EQ(sys_cat.checkPrivileges(user, privs), true);
bill_view.setPrivileges(AccessPrivileges::DROP_VIEW);
sys_cat.grantDBObjectPrivileges(roleToGrant, bill_view, cat);
bill_view.setPrivileges(AccessPrivileges::DROP_VIEW);
privs = {bill_view};
EXPECT_EQ(sys_cat.checkPrivileges(user, privs), true);
bill_view.setPrivileges(AccessPrivileges::SELECT_FROM_VIEW);
sys_cat.grantDBObjectPrivileges(roleToGrant, bill_view, cat);
bill_view.setPrivileges(AccessPrivileges::SELECT_FROM_VIEW);
privs = {bill_view};
EXPECT_EQ(sys_cat.checkPrivileges(user, privs), true);
bill_view.setPrivileges(AccessPrivileges::CREATE_VIEW);
sys_cat.revokeDBObjectPrivileges(roleToGrant, bill_view, cat);
bill_view.setPrivileges(AccessPrivileges::CREATE_VIEW);
privs = {bill_view};
EXPECT_EQ(sys_cat.checkPrivileges(user, privs), false);
bill_view.setPrivileges(AccessPrivileges::DROP_VIEW);
sys_cat.revokeDBObjectPrivileges(roleToGrant, bill_view, cat);
bill_view.setPrivileges(AccessPrivileges::DROP_VIEW);
privs = {bill_view};
EXPECT_EQ(sys_cat.checkPrivileges(user, privs), false);
bill_view.setPrivileges(AccessPrivileges::SELECT_FROM_VIEW);
sys_cat.revokeDBObjectPrivileges(roleToGrant, bill_view, cat);
bill_view.setPrivileges(AccessPrivileges::SELECT_FROM_VIEW);
privs = {bill_view};
EXPECT_EQ(sys_cat.checkPrivileges(user, privs), false);
}
TEST_F(ViewObject, UserRoleBobGetsGrants) {
if (g_aggregator) {
LOG(ERROR) << "Test not supported in distributed mode.";
return;
}
testViewPermissions("bob", "bob");
}
TEST_F(ViewObject, GroupRoleFooGetsGrants) {
if (g_aggregator) {
LOG(ERROR) << "Test not supported in distributed mode.";
return;
}
testViewPermissions("foo", "salesDept");
}
TEST_F(ViewObject, CalciteViewResolution) {
if (g_aggregator) {
LOG(ERROR) << "Test not supported in distributed mode.";
return;
}
auto calciteQueryParsingOption =
g_calcite->getCalciteQueryParsingOption(true, false, true);
auto calciteOptimizationOption =
g_calcite->getCalciteOptimizationOption(false, false, {});
auto query_state1 =
QR::create_query_state(QR::get()->getSession(), "select * from bill_table");
TPlanResult result = ::g_calcite->process(query_state1->createQueryStateProxy(),
query_state1->getQueryStr(),
calciteQueryParsingOption,
calciteOptimizationOption);
EXPECT_EQ(result.primary_accessed_objects.tables_selected_from.size(), (size_t)1);
EXPECT_EQ(result.primary_accessed_objects.tables_inserted_into.size(), (size_t)0);
EXPECT_EQ(result.primary_accessed_objects.tables_updated_in.size(), (size_t)0);
EXPECT_EQ(result.primary_accessed_objects.tables_deleted_from.size(), (size_t)0);
EXPECT_EQ(result.primary_accessed_objects.tables_selected_from[0][0], "bill_table");
EXPECT_EQ(result.resolved_accessed_objects.tables_selected_from.size(), (size_t)1);
EXPECT_EQ(result.resolved_accessed_objects.tables_inserted_into.size(), (size_t)0);
EXPECT_EQ(result.resolved_accessed_objects.tables_updated_in.size(), (size_t)0);
EXPECT_EQ(result.resolved_accessed_objects.tables_deleted_from.size(), (size_t)0);
EXPECT_EQ(result.resolved_accessed_objects.tables_selected_from[0][0], "bill_table");
auto query_state2 =
QR::create_query_state(QR::get()->getSession(), "select * from bill_view");
result = ::g_calcite->process(query_state2->createQueryStateProxy(),
query_state2->getQueryStr(),
calciteQueryParsingOption,
calciteOptimizationOption);
EXPECT_EQ(result.primary_accessed_objects.tables_selected_from.size(), (size_t)1);
EXPECT_EQ(result.primary_accessed_objects.tables_inserted_into.size(), (size_t)0);
EXPECT_EQ(result.primary_accessed_objects.tables_updated_in.size(), (size_t)0);
EXPECT_EQ(result.primary_accessed_objects.tables_deleted_from.size(), (size_t)0);
EXPECT_EQ(result.primary_accessed_objects.tables_selected_from[0][0], "bill_view");
EXPECT_EQ(result.resolved_accessed_objects.tables_selected_from.size(), (size_t)1);
EXPECT_EQ(result.resolved_accessed_objects.tables_inserted_into.size(), (size_t)0);
EXPECT_EQ(result.resolved_accessed_objects.tables_updated_in.size(), (size_t)0);
EXPECT_EQ(result.resolved_accessed_objects.tables_deleted_from.size(), (size_t)0);
EXPECT_EQ(result.resolved_accessed_objects.tables_selected_from[0][0], "bill_table");
auto query_state3 =
QR::create_query_state(QR::get()->getSession(), "select * from bill_view_outer");
result = ::g_calcite->process(query_state3->createQueryStateProxy(),
query_state3->getQueryStr(),
calciteQueryParsingOption,
calciteOptimizationOption);
EXPECT_EQ(result.primary_accessed_objects.tables_selected_from.size(), (size_t)1);
EXPECT_EQ(result.primary_accessed_objects.tables_inserted_into.size(), (size_t)0);
EXPECT_EQ(result.primary_accessed_objects.tables_updated_in.size(), (size_t)0);
EXPECT_EQ(result.primary_accessed_objects.tables_deleted_from.size(), (size_t)0);
EXPECT_EQ(result.primary_accessed_objects.tables_selected_from[0][0],
"bill_view_outer");
EXPECT_EQ(result.resolved_accessed_objects.tables_selected_from.size(), (size_t)1);
EXPECT_EQ(result.resolved_accessed_objects.tables_inserted_into.size(), (size_t)0);
EXPECT_EQ(result.resolved_accessed_objects.tables_updated_in.size(), (size_t)0);
EXPECT_EQ(result.resolved_accessed_objects.tables_deleted_from.size(), (size_t)0);
EXPECT_EQ(result.resolved_accessed_objects.tables_selected_from[0][0], "bill_table");
}
TEST_F(DashboardObject, AccessDefaultsTest) {
const auto cat = QR::get()->getCatalog();
ASSERT_NO_THROW(sys_cat.grantRole("Gunners", "Bayern"));
ASSERT_NO_THROW(sys_cat.grantRole("Sudens", "Arsenal"));
AccessPrivileges dash_priv;
ASSERT_NO_THROW(dash_priv.add(AccessPrivileges::VIEW_DASHBOARD));
privObjects.clear();
DBObject dash_object(id, DBObjectType::DashboardDBObjectType);
dash_object.loadKey(*cat);
ASSERT_NO_THROW(dash_object.setPrivileges(dash_priv));
privObjects.push_back(dash_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
}
TEST_F(DashboardObject, AccessAfterGrantsTest) {
const auto cat = QR::get()->getCatalog();
ASSERT_NO_THROW(sys_cat.grantRole("Gunners", "Arsenal"));
AccessPrivileges dash_priv;
ASSERT_NO_THROW(dash_priv.add(AccessPrivileges::VIEW_DASHBOARD));
privObjects.clear();
DBObject dash_object(id, DBObjectType::DashboardDBObjectType);
dash_object.loadKey(*cat);
ASSERT_NO_THROW(dash_object.setPrivileges(dash_priv));
privObjects.push_back(dash_object);
ASSERT_NO_THROW(
sys_cat.grantDBObjectPrivilegesBatch({"Gunners", "Juventus"}, {dash_object}, *cat));
privObjects.clear();
privObjects.push_back(dash_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
}
TEST_F(DashboardObject, AccessAfterRevokesTest) {
const auto cat = QR::get()->getCatalog();
ASSERT_NO_THROW(sys_cat.grantRole("OldLady", "Juventus"));
ASSERT_NO_THROW(sys_cat.grantRole("Sudens", "Bayern"));
AccessPrivileges dash_priv;
ASSERT_NO_THROW(dash_priv.add(AccessPrivileges::VIEW_DASHBOARD));
privObjects.clear();
DBObject dash_object(id, DBObjectType::DashboardDBObjectType);
dash_object.loadKey(*cat);
ASSERT_NO_THROW(dash_object.setPrivileges(dash_priv));
privObjects.push_back(dash_object);
ASSERT_NO_THROW(
sys_cat.grantDBObjectPrivilegesBatch({"OldLady", "Arsenal"}, {dash_object}, *cat));
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("OldLady", dash_object, *cat));
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("Arsenal", dash_object, *cat));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivileges("Bayern", dash_object, *cat));
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), true);
}
TEST_F(DashboardObject, GranteesDefaultListTest) {
const auto cat = QR::get()->getCatalog();
auto perms_list =
sys_cat.getMetadataForObject(cat->getCurrentDB().dbId,
static_cast<int>(DBObjectType::DashboardDBObjectType),
id);
int size = static_cast<int>(perms_list.size());
ASSERT_EQ(size, 0);
}
TEST_F(DashboardObject, GranteesListAfterGrantsTest) {
const auto cat = QR::get()->getCatalog();
auto perms_list =
sys_cat.getMetadataForObject(cat->getCurrentDB().dbId,
static_cast<int>(DBObjectType::DashboardDBObjectType),
id);
int recs1 = static_cast<int>(perms_list.size());
ASSERT_NO_THROW(sys_cat.grantRole("OldLady", "Juventus"));
AccessPrivileges dash_priv;
ASSERT_NO_THROW(dash_priv.add(AccessPrivileges::VIEW_DASHBOARD));
privObjects.clear();
DBObject dash_object(id, DBObjectType::DashboardDBObjectType);
dash_object.loadKey(*cat);
ASSERT_NO_THROW(dash_object.setPrivileges(dash_priv));
privObjects.push_back(dash_object);
ASSERT_NO_THROW(
sys_cat.grantDBObjectPrivilegesBatch({"OldLady", "Bayern"}, {dash_object}, *cat));
perms_list =
sys_cat.getMetadataForObject(cat->getCurrentDB().dbId,
static_cast<int>(DBObjectType::DashboardDBObjectType),
id);
int recs2 = static_cast<int>(perms_list.size());
ASSERT_NE(recs1, recs2);
ASSERT_EQ(recs2, 2);
ASSERT_TRUE(perms_list[0]->privs.hasPermission(DashboardPrivileges::VIEW_DASHBOARD));
ASSERT_TRUE(perms_list[1]->privs.hasPermission(DashboardPrivileges::VIEW_DASHBOARD));
ASSERT_FALSE(perms_list[1]->privs.hasPermission(DashboardPrivileges::EDIT_DASHBOARD));
ASSERT_NO_THROW(dash_priv.add(AccessPrivileges::EDIT_DASHBOARD));
ASSERT_NO_THROW(dash_object.setPrivileges(dash_priv));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivileges("Bayern", dash_object, *cat));
perms_list =
sys_cat.getMetadataForObject(cat->getCurrentDB().dbId,
static_cast<int>(DBObjectType::DashboardDBObjectType),
id);
int recs3 = static_cast<int>(perms_list.size());
ASSERT_EQ(recs3, 2);
ASSERT_TRUE(perms_list[0]->privs.hasPermission(DashboardPrivileges::VIEW_DASHBOARD));
ASSERT_TRUE(perms_list[1]->privs.hasPermission(DashboardPrivileges::VIEW_DASHBOARD));
ASSERT_TRUE(perms_list[1]->privs.hasPermission(DashboardPrivileges::EDIT_DASHBOARD));
}
TEST_F(DashboardObject, GranteesListAfterRevokesTest) {
const auto cat = QR::get()->getCatalog();
auto perms_list =
sys_cat.getMetadataForObject(cat->getCurrentDB().dbId,
static_cast<int>(DBObjectType::DashboardDBObjectType),
id);
int recs1 = static_cast<int>(perms_list.size());
ASSERT_NO_THROW(sys_cat.grantRole("Gunners", "Arsenal"));
AccessPrivileges dash_priv;
ASSERT_NO_THROW(dash_priv.add(AccessPrivileges::VIEW_DASHBOARD));
ASSERT_NO_THROW(dash_priv.add(AccessPrivileges::EDIT_DASHBOARD));
privObjects.clear();
DBObject dash_object(id, DBObjectType::DashboardDBObjectType);
dash_object.loadKey(*cat);
ASSERT_NO_THROW(dash_object.setPrivileges(dash_priv));
privObjects.push_back(dash_object);
ASSERT_NO_THROW(
sys_cat.grantDBObjectPrivilegesBatch({"Gunners", "Bayern"}, {dash_object}, *cat));
perms_list =
sys_cat.getMetadataForObject(cat->getCurrentDB().dbId,
static_cast<int>(DBObjectType::DashboardDBObjectType),
id);
int recs2 = static_cast<int>(perms_list.size());
ASSERT_NE(recs1, recs2);
ASSERT_EQ(recs2, 2);
ASSERT_TRUE(perms_list[0]->privs.hasPermission(DashboardPrivileges::VIEW_DASHBOARD));
ASSERT_TRUE(perms_list[0]->privs.hasPermission(DashboardPrivileges::EDIT_DASHBOARD));
ASSERT_TRUE(perms_list[1]->privs.hasPermission(DashboardPrivileges::VIEW_DASHBOARD));
ASSERT_TRUE(perms_list[1]->privs.hasPermission(DashboardPrivileges::EDIT_DASHBOARD));
ASSERT_NO_THROW(dash_priv.remove(AccessPrivileges::VIEW_DASHBOARD));
ASSERT_NO_THROW(dash_object.setPrivileges(dash_priv));
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("Gunners", dash_object, *cat));
perms_list =
sys_cat.getMetadataForObject(cat->getCurrentDB().dbId,
static_cast<int>(DBObjectType::DashboardDBObjectType),
id);
int recs3 = static_cast<int>(perms_list.size());
ASSERT_EQ(recs3, 2);
ASSERT_TRUE(perms_list[0]->privs.hasPermission(DashboardPrivileges::VIEW_DASHBOARD));
ASSERT_FALSE(perms_list[0]->privs.hasPermission(DashboardPrivileges::EDIT_DASHBOARD));
ASSERT_TRUE(perms_list[1]->privs.hasPermission(DashboardPrivileges::VIEW_DASHBOARD));
ASSERT_TRUE(perms_list[1]->privs.hasPermission(DashboardPrivileges::EDIT_DASHBOARD));
ASSERT_NO_THROW(dash_priv.add(AccessPrivileges::VIEW_DASHBOARD));
ASSERT_NO_THROW(dash_object.setPrivileges(dash_priv));
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("Gunners", dash_object, *cat));
perms_list =
sys_cat.getMetadataForObject(cat->getCurrentDB().dbId,
static_cast<int>(DBObjectType::DashboardDBObjectType),
id);
int recs4 = static_cast<int>(perms_list.size());
ASSERT_EQ(recs4, 1);
ASSERT_TRUE(perms_list[0]->privs.hasPermission(DashboardPrivileges::VIEW_DASHBOARD));
ASSERT_TRUE(perms_list[0]->privs.hasPermission(DashboardPrivileges::EDIT_DASHBOARD));
ASSERT_NO_THROW(dash_priv.add(AccessPrivileges::EDIT_DASHBOARD));
ASSERT_NO_THROW(dash_object.setPrivileges(dash_priv));
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("Bayern", dash_object, *cat));
perms_list =
sys_cat.getMetadataForObject(cat->getCurrentDB().dbId,
static_cast<int>(DBObjectType::DashboardDBObjectType),
id);
int recs5 = static_cast<int>(perms_list.size());
ASSERT_EQ(recs1, recs5);
ASSERT_EQ(recs5, 0);
}
TEST_F(ServerObject, AccessDefaultsTest) {
if (g_aggregator) {
LOG(INFO) << "Test not supported in distributed mode.";
return;
}
Catalog_Namespace::Catalog& cat = getCatalog();
AccessPrivileges server_priv;
ASSERT_NO_THROW(server_priv.add(AccessPrivileges::DROP_SERVER));
privObjects.clear();
DBObject server_object("test_server", DBObjectType::ServerDBObjectType);
server_object.loadKey(cat);
ASSERT_NO_THROW(server_object.setPrivileges(server_priv));
privObjects.push_back(server_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
}
TEST_F(ServerObject, AccessAfterGrantsRevokes) {
if (g_aggregator) {
LOG(INFO) << "Test not supported in distributed mode.";
return;
}
Catalog_Namespace::Catalog& cat = getCatalog();
ASSERT_NO_THROW(sys_cat.grantRole("Sudens", "Bayern"));
ASSERT_NO_THROW(sys_cat.grantRole("OldLady", "Juventus"));
AccessPrivileges server_priv;
ASSERT_NO_THROW(server_priv.add(AccessPrivileges::DROP_SERVER));
DBObject server_object("test_server", DBObjectType::ServerDBObjectType);
server_object.loadKey(cat);
ASSERT_NO_THROW(server_object.setPrivileges(server_priv));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivileges("Arsenal", server_object, cat));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivileges("Sudens", server_object, cat));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivileges("OldLady", server_object, cat));
privObjects.clear();
privObjects.push_back(server_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), true);
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("Arsenal", server_object, cat));
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("Sudens", server_object, cat));
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("OldLady", server_object, cat));
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
}
TEST_F(ServerObject, AccessWithGrantRevokeAllCompound) {
if (g_aggregator) {
LOG(INFO) << "Test not supported in distributed mode.";
return;
}
Catalog_Namespace::Catalog& cat = getCatalog();
ASSERT_NO_THROW(sys_cat.grantRole("Sudens", "Bayern"));
ASSERT_NO_THROW(sys_cat.grantRole("OldLady", "Juventus"));
AccessPrivileges server_priv;
ASSERT_NO_THROW(server_priv.add(AccessPrivileges::ALL_SERVER));
DBObject server_object("test_server", DBObjectType::ServerDBObjectType);
server_object.loadKey(cat);
// Effectively give all users ALL_SERVER privileges
ASSERT_NO_THROW(server_object.setPrivileges(server_priv));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivileges("Arsenal", server_object, cat));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivileges("Sudens", server_object, cat));
ASSERT_NO_THROW(sys_cat.grantDBObjectPrivileges("OldLady", server_object, cat));
// All users should now have ALL_SERVER privileges, check this is true
privObjects.clear();
privObjects.push_back(server_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), true);
// Check that all users have a subset of ALL_SERVER privileges, in this case
// check that is true for CREATE_SERVER
server_priv.reset();
ASSERT_NO_THROW(server_priv.add(AccessPrivileges::CREATE_SERVER));
ASSERT_NO_THROW(server_object.setPrivileges(server_priv));
privObjects.clear();
privObjects.push_back(server_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), true);
// Revoke CREATE_SERVER from all users and check that they don't have it
// anymore (expect super-users)
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("Arsenal", server_object, cat));
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("Sudens", server_object, cat));
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("OldLady", server_object, cat));
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
// All users should still have DROP_SERVER privileges, check that this is true
server_priv.reset();
ASSERT_NO_THROW(server_priv.add(AccessPrivileges::DROP_SERVER));
ASSERT_NO_THROW(server_object.setPrivileges(server_priv));
privObjects.clear();
privObjects.push_back(server_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), true);
// All users should still have ALTER_SERVER privileges, check that this is true
server_priv.reset();
ASSERT_NO_THROW(server_priv.add(AccessPrivileges::ALTER_SERVER));
ASSERT_NO_THROW(server_object.setPrivileges(server_priv));
privObjects.clear();
privObjects.push_back(server_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), true);
// All users should still have SERVER_USAGE privileges, check that this is true
server_priv.reset();
ASSERT_NO_THROW(server_priv.add(AccessPrivileges::SERVER_USAGE));
ASSERT_NO_THROW(server_object.setPrivileges(server_priv));
privObjects.clear();
privObjects.push_back(server_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), true);
// Revoke ALL_SERVER privileges
server_priv.reset();
ASSERT_NO_THROW(server_priv.add(AccessPrivileges::ALL_SERVER));
ASSERT_NO_THROW(server_object.setPrivileges(server_priv));
privObjects.clear();
privObjects.push_back(server_object);
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("Arsenal", server_object, cat));
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("Sudens", server_object, cat));
ASSERT_NO_THROW(sys_cat.revokeDBObjectPrivileges("OldLady", server_object, cat));
// Check that after the revoke of ALL_SERVER privileges users no longer
// have the DROP_SERVER privilege (except super-users)
server_priv.reset();
ASSERT_NO_THROW(server_priv.add(AccessPrivileges::DROP_SERVER));
ASSERT_NO_THROW(server_object.setPrivileges(server_priv));
privObjects.clear();
privObjects.push_back(server_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
// users no longer have the ALTER_SERVER privileges, check that this is true
server_priv.reset();
ASSERT_NO_THROW(server_priv.add(AccessPrivileges::ALTER_SERVER));
ASSERT_NO_THROW(server_object.setPrivileges(server_priv));
privObjects.clear();
privObjects.push_back(server_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
// users no longer have the SERVER_USAGE privileges, check that this is true
server_priv.reset();
ASSERT_NO_THROW(server_priv.add(AccessPrivileges::SERVER_USAGE));
ASSERT_NO_THROW(server_object.setPrivileges(server_priv));
privObjects.clear();
privObjects.push_back(server_object);
EXPECT_EQ(sys_cat.checkPrivileges("Chelsea", privObjects), true);
EXPECT_EQ(sys_cat.checkPrivileges("Arsenal", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Juventus", privObjects), false);
EXPECT_EQ(sys_cat.checkPrivileges("Bayern", privObjects), false);
}
void create_tables(std::string prefix, int max) {
const auto cat = QR::get()->getCatalog();
for (int i = 0; i < max; i++) {
std::string name = prefix + std::to_string(i);
run_ddl_statement("CREATE TABLE " + name + " (id integer);");
auto td = cat->getMetadataForTable(name, false);
ASSERT_TRUE(td);
ASSERT_EQ(td->isView, false);
ASSERT_EQ(td->tableName, name);
}
}
void create_views(std::string prefix, int max) {
const auto cat = QR::get()->getCatalog();
for (int i = 0; i < max; i++) {
std::string name = "view_" + prefix + std::to_string(i);
run_ddl_statement("CREATE VIEW " + name + " AS SELECT * FROM " + prefix +
std::to_string(i) + ";");
auto td = cat->getMetadataForTable(name, false);
ASSERT_TRUE(td);
ASSERT_EQ(td->isView, true);
ASSERT_EQ(td->tableName, name);
}
}
void create_dashboards(std::string prefix, int max) {
auto session = QR::get()->getSession();
CHECK(session);
auto& cat = session->getCatalog();
for (int i = 0; i < max; i++) {
std::string name = "dash_" + prefix + std::to_string(i);
DashboardDescriptor vd;
vd.dashboardName = name;
vd.dashboardState = name;
vd.imageHash = name;
vd.dashboardMetadata = name;
vd.userId = session->get_currentUser().userId;
ASSERT_EQ(0, session->get_currentUser().userId);
vd.user = session->get_currentUser().userName;
cat.createDashboard(vd);
auto fvd = cat.getMetadataForDashboard(
std::to_string(session->get_currentUser().userId), name);
ASSERT_TRUE(fvd);
ASSERT_EQ(fvd->dashboardName, name);
}
}
void assert_grants(std::string prefix, int i, bool expected) {
auto session = QR::get()->getSession();
CHECK(session);
auto& cat = session->getCatalog();
DBObject tablePermission(prefix + std::to_string(i), DBObjectType::TableDBObjectType);
try {
sys_cat.getDBObjectPrivileges("bob", tablePermission, cat);
} catch (std::runtime_error& e) {
}
ASSERT_EQ(
expected,
tablePermission.getPrivileges().hasPermission(TablePrivileges::SELECT_FROM_TABLE));
DBObject viewPermission("view_" + prefix + std::to_string(i),
DBObjectType::ViewDBObjectType);
try {
sys_cat.getDBObjectPrivileges("bob", viewPermission, cat);
} catch (std::runtime_error& e) {
}
ASSERT_EQ(
expected,
viewPermission.getPrivileges().hasPermission(ViewPrivileges::SELECT_FROM_VIEW));
auto fvd =
cat.getMetadataForDashboard(std::to_string(session->get_currentUser().userId),
"dash_" + prefix + std::to_string(i));
DBObject dashPermission(fvd->dashboardId, DBObjectType::DashboardDBObjectType);
try {
sys_cat.getDBObjectPrivileges("bob", dashPermission, cat);
} catch (std::runtime_error& e) {
}
ASSERT_EQ(
expected,
dashPermission.getPrivileges().hasPermission(DashboardPrivileges::VIEW_DASHBOARD));
}
void check_grant_access(std::string prefix, int max) {
auto session = QR::get()->getSession();
CHECK(session);
auto& cat = session->getCatalog();
for (int i = 0; i < max; i++) {
assert_grants(prefix, i, false);
auto fvd =
cat.getMetadataForDashboard(std::to_string(session->get_currentUser().userId),
"dash_" + prefix + std::to_string(i));
run_ddl_statement("GRANT SELECT ON TABLE " + prefix + std::to_string(i) + " TO bob;");
run_ddl_statement("GRANT SELECT ON VIEW view_" + prefix + std::to_string(i) +
" TO bob;");
run_ddl_statement("GRANT VIEW ON DASHBOARD " + std::to_string(fvd->dashboardId) +
" TO bob;");
assert_grants(prefix, i, true);
run_ddl_statement("REVOKE SELECT ON TABLE " + prefix + std::to_string(i) +
" FROM bob;");
run_ddl_statement("REVOKE SELECT ON VIEW view_" + prefix + std::to_string(i) +
" FROM bob;");
run_ddl_statement("REVOKE VIEW ON DASHBOARD " + std::to_string(fvd->dashboardId) +
" FROM bob;");
assert_grants(prefix, i, false);
}
}
void drop_dashboards(std::string prefix, int max) {
auto session = QR::get()->getSession();
CHECK(session);
auto& cat = session->getCatalog();
for (int i = 0; i < max; i++) {
std::string name = "dash_" + prefix + std::to_string(i);
auto dash = cat.getMetadataForDashboard(
std::to_string(session->get_currentUser().userId), name);
ASSERT_TRUE(dash);
cat.deleteMetadataForDashboards({dash->dashboardId}, session->get_currentUser());
auto fvd = cat.getMetadataForDashboard(
std::to_string(session->get_currentUser().userId), name);
ASSERT_FALSE(fvd);
}
}
void drop_views(std::string prefix, int max) {
const auto cat = QR::get()->getCatalog();
for (int i = 0; i < max; i++) {
std::string name = "view_" + prefix + std::to_string(i);
run_ddl_statement("DROP VIEW " + name + ";");
auto td = cat->getMetadataForTable(name, false);
ASSERT_FALSE(td);
}
}
void drop_tables(std::string prefix, int max) {
const auto cat = QR::get()->getCatalog();
for (int i = 0; i < max; i++) {
std::string name = prefix + std::to_string(i);
run_ddl_statement("DROP TABLE " + name + ";");
auto td = cat->getMetadataForTable(name, false);
ASSERT_FALSE(td);
}
}
void run_concurrency_test(std::string prefix, int max) {
create_tables(prefix, max);
create_views(prefix, max);
create_dashboards(prefix, max);
check_grant_access(prefix, max);
drop_dashboards(prefix, max);
drop_views(prefix, max);
drop_tables(prefix, max);
}
TEST(Catalog, Concurrency) {
run_ddl_statement("CREATE USER bob (password = 'password', is_super = 'false');");
std::string prefix = "for_bob";
// only a single thread at the moment!
// because calcite access the sqlite-dbs
// directly when started in this mode
int num_threads = 1;
std::vector<std::shared_ptr<std::thread>> my_threads;
for (int i = 0; i < num_threads; i++) {
std::string prefix = "for_bob_" + std::to_string(i) + "_";
my_threads.push_back(
std::make_shared<std::thread>(run_concurrency_test, prefix, 100));
}
for (auto& thread : my_threads) {
thread->join();
}
run_ddl_statement("DROP USER bob;");
}
TEST(DBObject, LoadKey) {
static const std::string tbname{"test_tb"};
static const std::string vwname{"test_vw"};
// cleanup
struct CleanupGuard {
~CleanupGuard() {
run_ddl_statement("DROP VIEW IF EXISTS " + vwname + ";");
run_ddl_statement("DROP TABLE IF EXISTS " + tbname + ";");
}
} cleanupGuard;
// setup
run_ddl_statement("CREATE TABLE IF NOT EXISTS " + tbname + "(id integer);");
run_ddl_statement("CREATE VIEW IF NOT EXISTS " + vwname + " AS SELECT id FROM " +
tbname + ";");
// test the LoadKey() function
auto cat = sys_cat.getCatalog(shared::kDefaultDbName);
DBObject dbo1(shared::kDefaultDbName, DBObjectType::DatabaseDBObjectType);
DBObject dbo2(tbname, DBObjectType::TableDBObjectType);
DBObject dbo3(vwname, DBObjectType::ViewDBObjectType);
ASSERT_NO_THROW(dbo1.loadKey());
ASSERT_NO_THROW(dbo2.loadKey(*cat));
ASSERT_NO_THROW(dbo3.loadKey(*cat));
}
TEST(SysCatalog, RenameUser_Basic) {
using namespace std::string_literals;
auto username = "chuck"s;
auto database_name = "nydb"s;
auto rename_successful = false;
ScopeGuard scope_guard = [&rename_successful] {
if (rename_successful) {
run_ddl_statement("DROP USER cryingchuck;");
} else {
run_ddl_statement("DROP USER chuck");
}
run_ddl_statement("DROP DATABASE nydb;");
};
Catalog_Namespace::UserMetadata user_meta;
auto username_out(username);
auto database_out(database_name);
run_ddl_statement("CREATE USER chuck (password='password');");
run_ddl_statement("CREATE DATABASE nydb (owner='chuck');");
run_ddl_statement("ALTER USER chuck (default_db='nydb')");
// Check ability to login
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta, false));
// Rename should be fine
EXPECT_NO_THROW(run_ddl_statement("ALTER USER chuck RENAME TO cryingchuck;"););
rename_successful = true;
// Check if we can login as the new user
username_out = "cryingchuck"s;
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta, false));
}
TEST(SysCatalog, RenameUser_AlreadyExisting) {
using namespace std::string_literals;
auto username = "chuck"s;
auto new_username = "marcy"s;
ScopeGuard scope_guard = [] {
run_ddl_statement("DROP USER chuck;");
run_ddl_statement("DROP USER marcy;");
};
run_ddl_statement("CREATE USER chuck (password='password');");
run_ddl_statement("CREATE USER marcy (password='password');");
EXPECT_THROW(run_ddl_statement("ALTER USER chuck RENAME TO marcy;"),
std::runtime_error);
}
TEST(SysCatalog, RenameUser_UserDoesntExist) {
using namespace std::string_literals;
EXPECT_THROW(run_ddl_statement("ALTER USER lemont RENAME TO sanford;"),
std::runtime_error);
}
namespace {
std::unique_ptr<QR> get_qr_for_user(
const std::string& user_name,
const Catalog_Namespace::UserMetadata& user_metadata) {
auto session = std::make_unique<Catalog_Namespace::SessionInfo>(
sys_cat.getCatalog(user_name), user_metadata, ExecutorDeviceType::CPU, "");
return std::make_unique<QR>(std::move(session));
}
} // namespace
TEST(SysCatalog, RenameUser_AlreadyLoggedInQueryAfterRename) {
if (g_aggregator) {
LOG(ERROR) << "Test not supported in distributed mode.";
return;
}
using namespace std::string_literals;
auto username = "chuck"s;
auto database_name = "nydb"s;
auto rename_successful = false;
ScopeGuard scope_guard = [&rename_successful] {
if (rename_successful) {
run_ddl_statement("DROP USER cryingchuck;");
} else {
run_ddl_statement("DROP USER chuck");
}
run_ddl_statement("DROP DATABASE nydb;");
};
Catalog_Namespace::UserMetadata user_meta;
auto username_out(username);
auto database_out(database_name);
EXPECT_NO_THROW(run_ddl_statement("CREATE USER chuck (password='password');"));
EXPECT_NO_THROW(run_ddl_statement("CREATE DATABASE nydb (owner='chuck');"));
EXPECT_NO_THROW(run_ddl_statement("ALTER USER chuck (default_db='nydb')"));
// Check ability to login
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta, false));
auto dt = ExecutorDeviceType::CPU;
Catalog_Namespace::UserMetadata user_meta2;
username_out = "chuck"s;
database_out = "nydb"s;
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta2, false));
auto chuck_qr = get_qr_for_user("nydb"s, user_meta2);
EXPECT_NO_THROW(chuck_qr->runDDLStatement("create table chaos ( x integer );"));
EXPECT_NO_THROW(chuck_qr->runSQL("insert into chaos values ( 1234 );", dt));
// Rename should be fine
EXPECT_NO_THROW(run_ddl_statement("ALTER USER chuck RENAME TO cryingchuck;"););
rename_successful = true;
// After the rename, can we query with the old session?
EXPECT_THROW(chuck_qr->runSQL("select x from chaos limit 1;", dt), std::runtime_error);
Catalog_Namespace::UserMetadata user_meta3;
username_out = "cryingchuck"s;
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta3, false));
auto cryingchuck_qr = get_qr_for_user("nydb"s, user_meta3);
// After the rename, can we query with the new session?
auto result = cryingchuck_qr->runSQL("select x from chaos limit 1;", dt);
ASSERT_EQ(result->rowCount(), size_t(1));
const auto crt_row = result->getNextRow(true, true);
ASSERT_EQ(crt_row.size(), size_t(1));
ASSERT_EQ(1234, v<int64_t>(crt_row[0]));
}
TEST(SysCatalog, RenameUser_ReloginWithOldName) {
if (g_aggregator) {
LOG(ERROR) << "Test not supported in distributed mode.";
return;
}
using namespace std::string_literals;
auto username = "chuck"s;
auto database_name = "nydb"s;
auto rename_successful = false;
ScopeGuard scope_guard = [&rename_successful] {
if (rename_successful) {
run_ddl_statement("DROP USER cryingchuck;");
} else {
run_ddl_statement("DROP USER chuck");
}
run_ddl_statement("DROP DATABASE nydb;");
};
Catalog_Namespace::UserMetadata user_meta;
auto username_out(username);
auto database_out(database_name);
EXPECT_NO_THROW(run_ddl_statement("CREATE USER chuck (password='password');"));
EXPECT_NO_THROW(run_ddl_statement("CREATE DATABASE nydb (owner='chuck');"));
EXPECT_NO_THROW(run_ddl_statement("ALTER USER chuck (default_db='nydb')"));
// Check ability to login
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta, false));
Catalog_Namespace::UserMetadata user_meta2;
username_out = "chuck"s;
database_out = "nydb"s;
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta2, false));
auto chuck_session = std::make_unique<Catalog_Namespace::SessionInfo>(
sys_cat.getCatalog("nydb"s), user_meta2, ExecutorDeviceType::CPU, "");
auto chuck_qr = std::make_unique<QR>(std::move(chuck_session));
EXPECT_NO_THROW(chuck_qr->runDDLStatement("create table chaos ( x integer );"));
EXPECT_NO_THROW(
chuck_qr->runSQL("insert into chaos values ( 1234 );", ExecutorDeviceType::CPU));
// Rename should be fine
EXPECT_NO_THROW(run_ddl_statement("ALTER USER chuck RENAME TO cryingchuck;"););
rename_successful = true;
Catalog_Namespace::UserMetadata user_meta3;
EXPECT_THROW(sys_cat.login(database_out, username_out, "password"s, user_meta3, false),
std::runtime_error);
}
TEST(SysCatalog, RenameUser_CheckPrivilegeTransfer) {
if (g_aggregator) {
LOG(ERROR) << "Test not supported in distributed mode.";
return;
}
using namespace std::string_literals;
auto rename_successful = false;
ScopeGuard s = [&rename_successful] {
run_ddl_statement("DROP USER rom;");
if (rename_successful) {
run_ddl_statement("DROP USER renamed_quark;");
} else {
run_ddl_statement("DROP USER quark;");
}
run_ddl_statement("DROP DATABASE Ferengi;");
};
EXPECT_NO_THROW(
run_ddl_statement("CREATE USER quark (password='password',is_super='false');"));
EXPECT_NO_THROW(
run_ddl_statement("CREATE USER rom (password='password',is_super='false');"));
EXPECT_NO_THROW(run_ddl_statement("CREATE DATABASE Ferengi (owner='rom');"));
auto database_out = "Ferengi"s;
auto username_out = "rom"s;
Catalog_Namespace::UserMetadata user_meta;
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta, false));
auto dt = ExecutorDeviceType::CPU;
// Log in as rom, create the database tables
Catalog_Namespace::UserMetadata user_meta2;
username_out = "rom"s;
database_out = "Ferengi"s;
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta2, false));
auto rom_session = std::make_unique<Catalog_Namespace::SessionInfo>(
sys_cat.getCatalog("Ferengi"s), user_meta2, ExecutorDeviceType::CPU, "");
auto rom_qr = std::make_unique<QR>(std::move(rom_session));
EXPECT_NO_THROW(
rom_qr->runDDLStatement("create table bank_account ( latinum integer );"));
EXPECT_NO_THROW(
rom_qr->runDDLStatement("create view riches as select * from bank_account;"));
EXPECT_NO_THROW(rom_qr->runSQL("insert into bank_account values (1234);", dt));
EXPECT_NO_THROW(rom_qr->runDDLStatement("grant access on database Ferengi to quark;"));
EXPECT_NO_THROW(
rom_qr->runDDLStatement("grant select on table bank_account to quark;"));
EXPECT_NO_THROW(rom_qr->runDDLStatement("grant select on view riches to quark;"));
run_ddl_statement("ALTER USER quark RENAME TO renamed_quark;");
rename_successful = true;
Catalog_Namespace::UserMetadata user_meta3;
username_out = "renamed_quark"s;
database_out = "Ferengi"s;
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta3, false));
auto renamed_quark_session = std::make_unique<Catalog_Namespace::SessionInfo>(
sys_cat.getCatalog("Ferengi"s), user_meta3, ExecutorDeviceType::CPU, "");
auto renamed_quark_qr = std::make_unique<QR>(std::move(renamed_quark_session));
EXPECT_NO_THROW(renamed_quark_qr->runSQL("select * from bank_account;", dt));
EXPECT_NO_THROW(renamed_quark_qr->runSQL("select * from riches;", dt));
}
TEST(SysCatalog, RenameUser_SuperUserRenameCheck) {
if (g_aggregator) {
LOG(ERROR) << "Test not supported in distributed mode.";
return;
}
using namespace std::string_literals;
ScopeGuard s = [] {
run_ddl_statement("DROP USER rom;");
run_ddl_statement("DROP USER quark;");
run_ddl_statement("DROP DATABASE Ferengi;");
};
run_ddl_statement("CREATE USER quark (password='password',is_super='false');");
run_ddl_statement("CREATE USER rom (password='password',is_super='false');");
run_ddl_statement("CREATE DATABASE Ferengi (owner='rom');");
auto database_out = "Ferengi"s;
auto username_out = "rom"s;
Catalog_Namespace::UserMetadata user_meta;
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta, false));
// Log in as rom, create the database tables
Catalog_Namespace::UserMetadata user_meta2;
username_out = "rom"s;
database_out = "Ferengi"s;
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta2, false));
auto rom_session = std::make_unique<Catalog_Namespace::SessionInfo>(
sys_cat.getCatalog("Ferengi"s), user_meta2, ExecutorDeviceType::CPU, "");
auto rom_qr = std::make_unique<QR>(std::move(rom_session));
EXPECT_THROW(rom_qr->runDDLStatement("ALTER USER quark RENAME TO renamed_quark;"),
std::runtime_error);
}
TEST(SysCatalog, RenameDatabase_Basic) {
if (g_aggregator) {
LOG(ERROR) << "Test not supported in distributed mode.";
return;
}
using namespace std::string_literals;
auto username = "magicwand"s;
auto database_name = "gdpgrowth"s;
auto rename_successful = false;
ScopeGuard scope_guard = [&rename_successful] {
if (!rename_successful) {
run_ddl_statement("DROP DATABASE gdpgrowth;");
} else {
run_ddl_statement("DROP DATABASE moregdpgrowth;");
}
run_ddl_statement("DROP USER magicwand;");
};
run_ddl_statement("CREATE DATABASE gdpgrowth;");
run_ddl_statement(
"CREATE USER magicwand (password='threepercent', default_db='gdpgrowth');");
Catalog_Namespace::UserMetadata user_meta;
auto username_out(username);
auto database_out(database_name);
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "threepercent"s, user_meta, false));
EXPECT_EQ(database_name, database_out);
rename_successful = true;
run_ddl_statement("ALTER DATABASE gdpgrowth RENAME TO moregdpgrowth;");
username_out = username;
database_out = database_name;
EXPECT_THROW(
sys_cat.login(database_out, username_out, "threepercent"s, user_meta, false),
std::runtime_error);
username_out = username;
database_out = "moregdpgrowth";
// Successfully login
EXPECT_NO_THROW(
sys_cat.login(database_out, username_out, "threepercent"s, user_meta, false));
}
TEST(SysCatalog, RenameDatabase_WrongUser) {
if (g_aggregator) {
LOG(ERROR) << "Test not supported in distributed mode.";
return;
}
using namespace std::string_literals;
auto username = "reader"s;
auto database_name = "fnews"s;
ScopeGuard scope_gard = [] {
run_ddl_statement("DROP USER reader;");
run_ddl_statement("DROP USER jkyle;");
run_ddl_statement("DROP DATABASE qworg;");
run_ddl_statement("DROP DATABASE fnews;");
};
run_ddl_statement("CREATE USER reader (password='rabbit');");
run_ddl_statement("CREATE USER jkyle (password='password');");
run_ddl_statement("CREATE DATABASE fnews (owner='reader');");
run_ddl_statement("CREATE DATABASE qworg (owner='jkyle');");
run_ddl_statement("ALTER USER reader (default_db='fnews');");
run_ddl_statement("ALTER USER jkyle (default_db='qworg');");
Catalog_Namespace::UserMetadata user_meta;
auto username_out(username);
auto database_out(database_name);
ASSERT_NO_THROW(sys_cat.login(database_out, username_out, "rabbit"s, user_meta, false));
EXPECT_EQ(database_name, database_out);
Catalog_Namespace::UserMetadata user_meta2;
username_out = "jkyle"s;
database_out = "qworg"s;
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta2, false));
// Should not be permissable
auto alternate_qr = get_qr_for_user("qworg"s, user_meta2);
EXPECT_THROW(alternate_qr->runDDLStatement("ALTER DATABASE fnews RENAME TO cnn;"),
std::runtime_error);
}
TEST(SysCatalog, RenameDatabase_SuperUser) {
if (g_aggregator) {
LOG(ERROR) << "Test not supported in distributed mode.";
return;
}
using namespace std::string_literals;
auto username = "maurypovich"s;
auto database_name = "paternitydb"s;
auto rename_successful = false;
ScopeGuard scope_guard = [&rename_successful] {
run_ddl_statement("DROP USER maurypovich;");
run_ddl_statement("DROP USER thefather;");
run_ddl_statement("DROP DATABASE trouble;");
if (rename_successful) {
run_ddl_statement("DROP DATABASE nachovater;");
} else {
run_ddl_statement("DROP DATABASE paternitydb;");
}
};
run_ddl_statement("CREATE USER maurypovich (password='password');");
run_ddl_statement("CREATE USER thefather (password='password',is_super='true');");
run_ddl_statement("CREATE DATABASE paternitydb (owner='maurypovich');");
run_ddl_statement("CREATE DATABASE trouble (owner='thefather');");
run_ddl_statement("ALTER USER maurypovich (default_db='paternitydb');");
run_ddl_statement("ALTER USER thefather (default_db='trouble');");
Catalog_Namespace::UserMetadata user_meta;
auto username_out(username);
auto database_out(database_name);
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta, false));
EXPECT_EQ(database_name, database_out);
Catalog_Namespace::UserMetadata user_meta2;
username_out = "thefather"s;
database_out = "trouble"s;
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta2, false));
auto alternate_qr = get_qr_for_user("trouble"s, user_meta2);
EXPECT_NO_THROW(
alternate_qr->runDDLStatement("ALTER DATABASE paternitydb RENAME TO nachovater;"));
rename_successful = true;
}
TEST(SysCatalog, RenameDatabase_ExistingDB) {
using namespace std::string_literals;
auto username = "rickgrimes"s;
auto database_name = "zombies"s;
ScopeGuard scope_guard = [] {
run_ddl_statement("DROP DATABASE zombies;");
run_ddl_statement("DROP DATABASE vampires;");
run_ddl_statement("DROP USER rickgrimes;");
};
run_ddl_statement("CREATE DATABASE zombies;");
run_ddl_statement("CREATE DATABASE vampires;");
run_ddl_statement(
"CREATE USER rickgrimes (password='password', default_db='zombies');");
Catalog_Namespace::UserMetadata user_meta;
auto username_out(username);
auto database_out(database_name);
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta, false));
EXPECT_EQ(database_name, database_out);
EXPECT_THROW(run_ddl_statement("ALTER DATABASE zombies RENAME TO vampires;"),
std::runtime_error);
}
TEST(SysCatalog, RenameDatabase_FailedCopy) {
using namespace std::string_literals;
auto trash_file_path =
sys_cat.getCatalogBasePath() + "/" + shared::kCatalogDirectoryName + "/trash";
ScopeGuard s = [&trash_file_path] {
boost::filesystem::remove(trash_file_path);
run_ddl_statement("DROP DATABASE hatchets;");
run_ddl_statement("DROP USER bury;");
};
std::ofstream trash_file(trash_file_path);
trash_file << "trash!";
trash_file.close();
auto username = "bury"s;
auto database_name = "hatchets"s;
run_ddl_statement("CREATE DATABASE hatchets;");
run_ddl_statement("CREATE USER bury (password='password', default_db='hatchets');");
Catalog_Namespace::UserMetadata user_meta;
auto username_out(username);
auto database_out(database_name);
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta, false));
EXPECT_EQ(database_name, database_out);
// Check that the file inteferes with the copy operation
EXPECT_THROW(run_ddl_statement("ALTER DATABASE hatchets RENAME TO trash;"),
std::runtime_error);
// Now, check to see if we can log back into the original database
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta, false));
}
TEST(SysCatalog, RenameDatabase_PrivsTest) {
if (g_aggregator) {
LOG(ERROR) << "Test not supported in distributed mode.";
return;
}
using namespace std::string_literals;
auto rename_successful = false;
ScopeGuard s = [&rename_successful] {
run_ddl_statement("DROP USER quark;");
run_ddl_statement("DROP USER rom;");
if (rename_successful) {
run_ddl_statement("DROP DATABASE grandnagus;");
} else {
run_ddl_statement("DROP DATABASE Ferengi;");
}
};
run_ddl_statement("CREATE USER quark (password='password',is_super='false');");
run_ddl_statement("CREATE USER rom (password='password',is_super='false');");
run_ddl_statement("CREATE DATABASE Ferengi (owner='rom');");
auto database_out = "Ferengi"s;
auto username_out = "rom"s;
Catalog_Namespace::UserMetadata user_meta;
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta, false));
auto dt = ExecutorDeviceType::CPU;
// Log in as rom, create the database tables
Catalog_Namespace::UserMetadata user_meta2;
username_out = "rom"s;
database_out = "Ferengi"s;
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta2, false));
auto rom_qr = get_qr_for_user("Ferengi"s, user_meta2);
EXPECT_NO_THROW(
rom_qr->runDDLStatement("create table bank_account ( latinum integer );"));
EXPECT_NO_THROW(
rom_qr->runDDLStatement("create view riches as select * from bank_account;"));
EXPECT_NO_THROW(rom_qr->runSQL("insert into bank_account values (1234);", dt));
EXPECT_NO_THROW(rom_qr->runDDLStatement("grant access on database Ferengi to quark;"));
EXPECT_NO_THROW(
rom_qr->runDDLStatement("grant select on table bank_account to quark;"));
EXPECT_NO_THROW(rom_qr->runDDLStatement("grant select on view riches to quark;"));
EXPECT_NO_THROW(
rom_qr->runDDLStatement("ALTER DATABASE Ferengi RENAME TO grandnagus;"));
// Clear session (similar to what is done in DBHandler after a database rename).
rom_qr->clearSessionId();
rename_successful = true;
Catalog_Namespace::UserMetadata user_meta3;
username_out = "quark"s;
database_out = "grandnagus"s;
ASSERT_NO_THROW(
sys_cat.login(database_out, username_out, "password"s, user_meta3, false));
auto quark_qr = get_qr_for_user("grandnagus"s, user_meta3);
EXPECT_NO_THROW(quark_qr->runSQL("select * from bank_account;", dt));
EXPECT_NO_THROW(quark_qr->runSQL("select * from riches;", dt));
}
TEST(SysCatalog, DropDatabase_ByOwner) {
if (g_aggregator) {
LOG(ERROR) << "Test not supported in distributed mode.";
return;
}
const std::string username = "theowner";
const std::string dbname = "thedb";
ScopeGuard scope_guard = [&] {
run_ddl_statement("DROP USER IF EXISTS " + username + ";");
run_ddl_statement("DROP DATABASE IF EXISTS " + dbname + ";");
};
run_ddl_statement("CREATE USER " + username + " (password='password');");
run_ddl_statement("CREATE DATABASE " + dbname + " (owner='" + username + "');");
run_ddl_statement("ALTER USER " + username + " (default_db='" + dbname + "');");
Catalog_Namespace::UserMetadata user_meta;
std::string username_out{username};
std::string dbname_out{dbname};
ASSERT_NO_THROW(sys_cat.login(dbname_out, username_out, "password", user_meta, false));
EXPECT_EQ(dbname, dbname_out);
auto qr = get_qr_for_user(dbname, user_meta);
EXPECT_NO_THROW(qr->runDDLStatement("DROP DATABASE " + dbname + ";"));
}
TEST(SysCatalog, DropDatabase_ByNonOwner) {
if (g_aggregator) {
LOG(ERROR) << "Test not supported in distributed mode.";
return;
}
const std::string username = "theowner";
const std::string dbname = "thedb";
ScopeGuard scope_guard = [&] {
run_ddl_statement("DROP USER IF EXISTS " + username + ";");
run_ddl_statement("DROP USER IF EXISTS not" + username + ";");
run_ddl_statement("DROP DATABASE IF EXISTS " + dbname + ";");
};
run_ddl_statement("CREATE USER " + username + " (password='password');");
run_ddl_statement("CREATE USER not" + username + " (password='password');");
run_ddl_statement("CREATE DATABASE " + dbname + " (owner='" + username + "');");
run_ddl_statement("ALTER USER " + username + " (default_db='" + dbname + "');");
run_ddl_statement("ALTER USER not" + username + " (default_db='" + dbname + "');");
Catalog_Namespace::UserMetadata user_meta;
std::string username_out{"not" + username};
std::string dbname_out{dbname};
ASSERT_NO_THROW(sys_cat.login(dbname_out, username_out, "password", user_meta, false));
EXPECT_EQ(dbname, dbname_out);
auto qr = get_qr_for_user(dbname, user_meta);
EXPECT_THROW(qr->runDDLStatement("DROP DATABASE " + dbname + ";"), std::runtime_error);
}
TEST(SysCatalog, DropDatabase_BySuperUser) {
if (g_aggregator) {
LOG(ERROR) << "Test not supported in distributed mode.";
return;
}
const std::string username = "theowner";
const std::string dbname = "thedb";
ScopeGuard scope_guard = [&] {
run_ddl_statement("DROP USER IF EXISTS " + username + ";");
run_ddl_statement("DROP USER IF EXISTS not" + username + ";");
run_ddl_statement("DROP DATABASE IF EXISTS " + dbname + ";");
};
run_ddl_statement("CREATE USER " + username + " (password='password');");
run_ddl_statement("CREATE USER not" + username +
" (password='password',is_super='true');");
run_ddl_statement("CREATE DATABASE " + dbname + " (owner='" + username + "');");
run_ddl_statement("ALTER USER " + username + " (default_db='" + dbname + "');");
run_ddl_statement("ALTER USER not" + username + " (default_db='" + dbname + "');");
Catalog_Namespace::UserMetadata user_meta;
std::string username_out{"not" + username};
std::string dbname_out{dbname};
ASSERT_NO_THROW(sys_cat.login(dbname_out, username_out, "password", user_meta, false));
EXPECT_EQ(dbname, dbname_out);
auto alternate_qr = get_qr_for_user(dbname, user_meta);
EXPECT_NO_THROW(alternate_qr->runDDLStatement("DROP DATABASE " + dbname + ";"));
}
TEST(SysCatalog, GetDatabaseList) {
static const std::string username{"test_user"};
static const std::string username2{username + "2"};
static const std::string dbname{"test_db"};
static const std::string dbname2{dbname + "2"};
static const std::string dbname3{dbname + "3"};
static const std::string dbname4{dbname + "4"};
// cleanup
struct CleanupGuard {
~CleanupGuard() {
run_ddl_statement("DROP DATABASE IF EXISTS " + dbname4 + ";");
run_ddl_statement("DROP DATABASE IF EXISTS " + dbname3 + ";");
run_ddl_statement("DROP DATABASE IF EXISTS " + dbname2 + ";");
run_ddl_statement("DROP DATABASE IF EXISTS " + dbname + ";");
run_ddl_statement("DROP USER IF EXISTS " + username2 + ";");
run_ddl_statement("DROP USER IF EXISTS " + username + ";");
}
} cleanupGuard;
// setup
run_ddl_statement("CREATE USER " + username + " (password = 'password');");
run_ddl_statement("CREATE USER " + username2 + " (password = 'password');");
run_ddl_statement("CREATE DATABASE " + dbname + "(owner='" + username + "');");
run_ddl_statement("CREATE DATABASE " + dbname2 + "(owner='" + username2 + "');");
run_ddl_statement("CREATE DATABASE " + dbname3 + "(owner='" + username2 + "');");
run_ddl_statement("CREATE DATABASE " + dbname4 + "(owner='" + username + "');");
run_ddl_statement("GRANT ACCESS ON DATABASE " + dbname + " TO " + username2 + ";");
run_ddl_statement("GRANT ACCESS ON DATABASE " + dbname3 + " TO " + username + ";");
Catalog_Namespace::UserMetadata user_meta, user_meta2;
CHECK(sys_cat.getMetadataForUser(username, user_meta));
CHECK(sys_cat.getMetadataForUser(username2, user_meta2));
// test database list for arbitrary user #1
auto dblist = sys_cat.getDatabaseListForUser(user_meta);
EXPECT_EQ(dblist.front().dbName, dbname);
EXPECT_EQ(dblist.front().dbOwnerName, username);
dblist.pop_front();
EXPECT_EQ(dblist.front().dbName, dbname3);
EXPECT_EQ(dblist.front().dbOwnerName, username2);
dblist.pop_front();
EXPECT_EQ(dblist.front().dbName, dbname4);
EXPECT_EQ(dblist.front().dbOwnerName, username);
// test database list for arbitrary user #2
dblist = sys_cat.getDatabaseListForUser(user_meta2);
EXPECT_EQ(dblist.front().dbName, dbname);
EXPECT_EQ(dblist.front().dbOwnerName, username);
dblist.pop_front();
EXPECT_EQ(dblist.front().dbName, dbname2);
EXPECT_EQ(dblist.front().dbOwnerName, username2);
dblist.pop_front();
EXPECT_EQ(dblist.front().dbName, dbname3);
EXPECT_EQ(dblist.front().dbOwnerName, username2);
}
TEST(SysCatalog, LoginWithDefaultDatabase) {
static const std::string username{"test_user"};
static const std::string dbname{"test_db"};
static const std::string dbnamex{dbname + "x"};
// cleanup
struct CleanupGuard {
~CleanupGuard() {
run_ddl_statement("DROP DATABASE IF EXISTS " + dbname + ";");
run_ddl_statement("DROP DATABASE IF EXISTS " + dbnamex + ";");
run_ddl_statement("DROP USER IF EXISTS " + username + ";");
}
} cleanupGuard;
// setup
run_ddl_statement("CREATE DATABASE " + dbname + ";");
run_ddl_statement("CREATE DATABASE " + dbnamex + ";");
run_ddl_statement("CREATE USER " + username +
" (password = 'password', default_db = '" + dbnamex + "');");
Catalog_Namespace::UserMetadata user_meta;
// test the user's default database
std::string username2{username};
std::string dbname2{dbname};
ASSERT_NO_THROW(sys_cat.login(dbname2, username2, "password", user_meta, false));
EXPECT_EQ(dbname2, dbname); // correctly ignored user's default of dbnamex
username2 = username;
dbname2.clear();
ASSERT_NO_THROW(sys_cat.login(dbname2, username2, "password", user_meta, false));
EXPECT_EQ(dbname2, dbnamex); // correctly used user's default of dbnamex
// change the user's default database
ASSERT_NO_THROW(
run_ddl_statement("ALTER USER " + username + " (default_db = '" + dbname + "');"));
// test the user's default database
username2 = username;
dbname2.clear();
ASSERT_NO_THROW(sys_cat.login(dbname2, username2, "password", user_meta, false));
EXPECT_EQ(dbname2, dbname); // correctly used user's default of dbname
// remove the user's default database
ASSERT_NO_THROW(run_ddl_statement("ALTER USER " + username + " (default_db = NULL);"));
// test the user's default database
username2 = username;
dbname2.clear();
ASSERT_NO_THROW(sys_cat.login(dbname2, username2, "password", user_meta, false));
EXPECT_EQ(dbname2,
shared::kDefaultDbName); // correctly fell back to system default
// database
}
TEST(SysCatalog, SwitchDatabase) {
static const std::string username{"test_user"};
static std::string dbname{"test_db"};
static std::string dbname2{dbname + "2"};
static std::string dbname3{dbname + "3"};
// cleanup
sql("DROP DATABASE IF EXISTS " + dbname + ";");
sql("DROP DATABASE IF EXISTS " + dbname2 + ";");
sql("DROP DATABASE IF EXISTS " + dbname3 + ";");
sql("DROP USER IF EXISTS " + username + ";");
// setup
sql("CREATE USER " + username + " (password = 'password');");
sql("CREATE DATABASE " + dbname + "(owner='" + username + "');");
sql("CREATE DATABASE " + dbname2 + "(owner='" + username + "');");
sql("CREATE DATABASE " + dbname3 + "(owner='" + username + "');");
sql("REVOKE ACCESS ON DATABASE " + dbname3 + " FROM " + username + ";");
// test some attempts to switch database
ASSERT_NO_THROW(sys_cat.switchDatabase(dbname, username));
ASSERT_NO_THROW(sys_cat.switchDatabase(dbname, username));
ASSERT_NO_THROW(sys_cat.switchDatabase(dbname2, username));
ASSERT_THROW(sys_cat.switchDatabase(dbname3, username), std::runtime_error);
// // distributed test
// // NOTE(sy): disabling for now due to consistency errors
// if (DQR* dqr = dynamic_cast<DQR*>(QR::get()); g_aggregator && dqr) {
// static const std::string tname{"swdb_test_table"};
// LeafAggregator* agg = dqr->getLeafAggregator();
// agg->switch_database(dqr->getSession()->get_session_id(), dbname);
// sql("CREATE TABLE " + tname + "(i INTEGER);");
// ASSERT_NO_THROW(sql("SELECT i FROM " + tname + ";"));
// agg->switch_database(dqr->getSession()->get_session_id(), dbname2);
// ASSERT_ANY_THROW(agg->leafCatalogConsistencyCheck(*dqr->getSession()));
// agg->switch_database(dqr->getSession()->get_session_id(), dbname);
// ASSERT_NO_THROW(sql("DROP TABLE " + tname + ";"));
// agg->switch_database(dqr->getSession()->get_session_id(), shared::kDefaultDbName);
// }
// cleanup
sql("DROP DATABASE IF EXISTS " + dbname + ";");
sql("DROP DATABASE IF EXISTS " + dbname2 + ";");
sql("DROP DATABASE IF EXISTS " + dbname3 + ";");
sql("DROP USER IF EXISTS " + username + ";");
}
namespace {
void compare_user_lists(const std::vector<std::string>& expected,
const std::list<Catalog_Namespace::UserMetadata>& actual) {
ASSERT_EQ(expected.size(), actual.size());
size_t i = 0;
for (const auto& user : actual) {
ASSERT_EQ(expected[i++], user.userName);
}
}
} // namespace
TEST(SysCatalog, AllUserMetaTest) {
if (g_aggregator) {
LOG(ERROR) << "Test not supported in distributed mode.";
return;
}
using namespace std::string_literals;
Users users_;
static const auto champions = "champions"s;
static const auto europa = "europa"s;
struct ExpectedUserLists {
const std::vector<std::string> super_default = {"admin",
"Chelsea",
"Arsenal",
"Juventus",
"Bayern"};
const std::vector<std::string> user_default = {"Arsenal", "Bayern"};
const std::vector<std::string> user_champions = {"Juventus", "Bayern"};
const std::vector<std::string> user_europa = {"Arsenal", "Juventus"};
} expected;
// cleanup
struct CleanupGuard {
~CleanupGuard() {
run_ddl_statement("DROP DATABASE IF EXISTS " + champions + ";");
run_ddl_statement("DROP DATABASE IF EXISTS " + europa + ";");
}
} cleanupGuard;
run_ddl_statement("DROP DATABASE IF EXISTS " + champions + ";");
run_ddl_statement("DROP DATABASE IF EXISTS " + europa + ";");
run_ddl_statement("CREATE DATABASE " + champions + ";");
run_ddl_statement("CREATE DATABASE " + europa + ";");
run_ddl_statement("GRANT ACCESS ON DATABASE " + champions + " TO Bayern;");
run_ddl_statement("GRANT ACCESS ON DATABASE " + champions + " TO Juventus;");
run_ddl_statement("GRANT ACCESS ON DATABASE " + shared::kDefaultDbName +
" TO Arsenal;");
run_ddl_statement("GRANT CREATE ON DATABASE " + champions + " TO Juventus;");
run_ddl_statement("GRANT SELECT ON DATABASE " + europa + " TO Arsenal;");
run_ddl_statement("GRANT CREATE ON DATABASE " + shared::kDefaultDbName + " TO Bayern;");
run_ddl_statement("GRANT SELECT ON DATABASE " + europa + " TO Juventus;");
Catalog_Namespace::UserMetadata user_meta;
auto db_default(shared::kDefaultDbName);
auto db_champions(champions);
auto db_europa(europa);
auto user_chelsea("Chelsea"s);
auto user_arsenal("Arsenal"s);
auto user_bayern("Bayern"s);
// Super User
ASSERT_NO_THROW(sys_cat.login(db_default, user_chelsea, "password"s, user_meta, false));
const auto suser_list = sys_cat.getAllUserMetadata();
compare_user_lists(expected.super_default, suser_list);
ASSERT_NO_THROW(
sys_cat.login(db_champions, user_chelsea, "password"s, user_meta, false));
const auto suser_list1 = sys_cat.getAllUserMetadata();
compare_user_lists(expected.super_default, suser_list1);
ASSERT_NO_THROW(sys_cat.login(db_europa, user_chelsea, "password"s, user_meta, false));
const auto suser_list2 = sys_cat.getAllUserMetadata();
compare_user_lists(expected.super_default, suser_list2);
// Normal User
Catalog_Namespace::DBMetadata db;
ASSERT_NO_THROW(sys_cat.getMetadataForDB(db_default, db));
ASSERT_NO_THROW(sys_cat.login(db_default, user_arsenal, "password"s, user_meta, false));
const auto nuser_list = sys_cat.getAllUserMetadata(db.dbId);
compare_user_lists(expected.user_default, nuser_list);
ASSERT_NO_THROW(sys_cat.getMetadataForDB(db_champions, db));
ASSERT_NO_THROW(
sys_cat.login(db_champions, user_bayern, "password"s, user_meta, false));
const auto nuser_list1 = sys_cat.getAllUserMetadata(db.dbId);
compare_user_lists(expected.user_champions, nuser_list1);
ASSERT_NO_THROW(sys_cat.getMetadataForDB(db_europa, db));
ASSERT_NO_THROW(sys_cat.login(db_europa, user_arsenal, "password"s, user_meta, false));
const auto nuser_list2 = sys_cat.getAllUserMetadata(db.dbId);
compare_user_lists(expected.user_europa, nuser_list2);
}
TEST(SysCatalog, RecursiveRolesUserMetaData) {
if (g_aggregator) {
LOG(ERROR) << "Test not supported in distributed mode.";
return;
}
using namespace std::string_literals;
Users users_;
Roles roles_;
static const auto champions = "champions"s;
static const auto europa = "europa"s;
static const auto london = "london"s;
static const auto north_london = "north_london"s;
static const auto munich = "munich"s;
static const auto turin = "turin"s;
struct CleanupGuard {
~CleanupGuard() {
run_ddl_statement("DROP ROLE IF EXISTS " + london + ";");
run_ddl_statement("DROP ROLE IF EXISTS " + north_london + ";");
run_ddl_statement("DROP ROLE IF EXISTS " + munich + ";");
run_ddl_statement("DROP ROLE IF EXISTS " + turin + ";");
run_ddl_statement("DROP DATABASE IF EXISTS " + champions + ";");
run_ddl_statement("DROP DATABASE IF EXISTS " + europa + ";");
}
} cleanupGuard;
struct ExpectedUserLists {
const std::vector<std::string> user_default = {"Arsenal", "Bayern"};
const std::vector<std::string> user_champions = {"Juventus", "Bayern"};
const std::vector<std::string> user_europa = {"Arsenal", "Juventus"};
} expected;
run_ddl_statement("CREATE ROLE " + london + ";");
run_ddl_statement("CREATE ROLE " + north_london + ";");
run_ddl_statement("CREATE ROLE " + munich + ";");
run_ddl_statement("CREATE ROLE " + turin + ";");
run_ddl_statement("DROP DATABASE IF EXISTS " + champions + ";");
run_ddl_statement("DROP DATABASE IF EXISTS " + europa + ";");
run_ddl_statement("CREATE DATABASE " + champions + ";");
run_ddl_statement("CREATE DATABASE " + europa + ";");
run_ddl_statement("GRANT ACCESS ON DATABASE " + champions + " TO Sudens;");
run_ddl_statement("GRANT ACCESS ON DATABASE " + champions + " TO OldLady;");
run_ddl_statement("GRANT ACCESS ON DATABASE " + shared::kDefaultDbName +
" TO Gunners;");
run_ddl_statement("GRANT CREATE ON DATABASE " + champions + " TO OldLady;");
run_ddl_statement("GRANT SELECT ON DATABASE " + europa + " TO Gunners;");
run_ddl_statement("GRANT CREATE ON DATABASE " + shared::kDefaultDbName + " TO Sudens;");
run_ddl_statement("GRANT SELECT ON DATABASE " + europa + " TO OldLady;");
Catalog_Namespace::UserMetadata user_meta;
auto db_default(shared::kDefaultDbName);
auto db_champions(champions);
auto db_europa(europa);
auto user_chelsea("Chelsea"s);
auto user_arsenal("Arsenal"s);
auto user_bayern("Bayern"s);
auto user_juventus("Juventus"s);
run_ddl_statement("GRANT Gunners to " + london + ";");
run_ddl_statement("GRANT " + london + " to " + north_london + ";");
run_ddl_statement("GRANT " + north_london + " to " + user_arsenal + ";");
run_ddl_statement("GRANT Sudens to " + user_bayern + ";");
run_ddl_statement("GRANT OldLady to " + user_juventus + ";");
Catalog_Namespace::DBMetadata db;
ASSERT_NO_THROW(sys_cat.getMetadataForDB(db_default, db));
ASSERT_NO_THROW(sys_cat.login(db_default, user_arsenal, "password"s, user_meta, false));
const auto nuser_list = sys_cat.getAllUserMetadata(db.dbId);
compare_user_lists(expected.user_default, nuser_list);
ASSERT_NO_THROW(sys_cat.getMetadataForDB(db_champions, db));
ASSERT_NO_THROW(
sys_cat.login(db_champions, user_bayern, "password"s, user_meta, false));
const auto nuser_list1 = sys_cat.getAllUserMetadata(db.dbId);
compare_user_lists(expected.user_champions, nuser_list1);
ASSERT_NO_THROW(sys_cat.getMetadataForDB(db_europa, db));
ASSERT_NO_THROW(sys_cat.login(db_europa, user_arsenal, "password"s, user_meta, false));
const auto nuser_list2 = sys_cat.getAllUserMetadata(db.dbId);
compare_user_lists(expected.user_europa, nuser_list2);
}
TEST(Login, Deactivation) {
// SysCatalog::login doesn't accept constants
std::string database = shared::kDefaultDbName;
std::string active_user = "active_user";
std::string deactivated_user = "deactivated_user";
run_ddl_statement(
"CREATE USER active_user(password = 'password', is_super = 'false', "
"can_login = 'true');");
run_ddl_statement(
"CREATE USER deactivated_user(password = 'password', is_super = 'false', "
"can_login = 'false');");
run_ddl_statement("GRANT ACCESS ON DATABASE " + database +
" TO active_user, deactivated_user");
Catalog_Namespace::UserMetadata user_meta;
ASSERT_NO_THROW(sys_cat.login(database, active_user, "password", user_meta, true));
ASSERT_THROW(sys_cat.login(database, deactivated_user, "password", user_meta, true),
std::runtime_error);
run_ddl_statement("ALTER USER active_user(can_login='false');");
run_ddl_statement("ALTER USER deactivated_user(can_login='true');");
ASSERT_NO_THROW(sys_cat.login(database, deactivated_user, "password", user_meta, true));
ASSERT_THROW(sys_cat.login(database, active_user, "password", user_meta, true),
std::runtime_error);
run_ddl_statement("DROP USER active_user;");
run_ddl_statement("DROP USER deactivated_user;");
}
class GetDbObjectsForGranteeTest : public DBHandlerTestFixture {
protected:
void SetUp() override {
DBHandlerTestFixture::SetUp();
sql("CREATE USER test_user (password = 'test_pass');");
}
void TearDown() override {
sql("DROP USER test_user;");
DBHandlerTestFixture::TearDown();
}
void allOnDatabase(std::string privilege) {
sql("GRANT " + privilege + " ON DATABASE " + shared::kDefaultDbName +
" TO test_user;");
const auto& [db_handler, session_id] = getDbHandlerAndSessionId();
std::vector<TDBObject> db_objects{};
db_handler->get_db_objects_for_grantee(db_objects, session_id, "test_user");
std::unordered_set<TDBObjectType::type> privilege_types{};
for (const auto& db_object : db_objects) {
ASSERT_EQ(shared::kDefaultDbName, db_object.objectName);
ASSERT_EQ(TDBObjectType::DatabaseDBObjectType, db_object.objectType);
ASSERT_EQ("test_user", db_object.grantee);
if (db_object.privilegeObjectType == TDBObjectType::DatabaseDBObjectType) {
// The first two items represent CREATE and DROP DATABASE privileges, which are
// not granted
std::vector<bool> expected_privileges{false, false, true, true};
ASSERT_EQ(expected_privileges, db_object.privs);
} else {
ASSERT_TRUE(std::all_of(db_object.privs.begin(),
db_object.privs.end(),
[](bool has_privilege) { return has_privilege; }));
}
privilege_types.emplace(db_object.privilegeObjectType);
}
ASSERT_FALSE(privilege_types.find(TDBObjectType::DatabaseDBObjectType) ==
privilege_types.end());
ASSERT_FALSE(privilege_types.find(TDBObjectType::TableDBObjectType) ==
privilege_types.end());
ASSERT_FALSE(privilege_types.find(TDBObjectType::DashboardDBObjectType) ==
privilege_types.end());
ASSERT_FALSE(privilege_types.find(TDBObjectType::ViewDBObjectType) ==
privilege_types.end());
}
};
TEST_F(GetDbObjectsForGranteeTest, UserWithGrantAllOnDatabase) {
allOnDatabase("ALL");
}
TEST_F(GetDbObjectsForGranteeTest, UserWithGrantAllPrivilegesOnDatabase) {
allOnDatabase("ALL PRIVILEGES");
}
TEST(DefaultUser, RoleList) {
auto* grantee = sys_cat.getGrantee(shared::kRootUsername);
EXPECT_TRUE(grantee);
EXPECT_TRUE(grantee->getRoles().empty());
}
class TablePermissionsTest : public DBHandlerTestFixture {
protected:
static void SetUpTestSuite() {
createDBHandler();
switchToAdmin();
createTestUser();
}
void runSelectQueryAsUser(const std::string& query,
const std::string& username,
const std::string& password) {
Catalog_Namespace::UserMetadata user_meta;
std::string db_name = shared::kDefaultDbName;
std::string username_local = username;
ASSERT_NO_THROW(sys_cat.login(db_name, username_local, password, user_meta, false));
auto user_qr = get_qr_for_user(db_name, user_meta);
user_qr->runSQL(query, ExecutorDeviceType::CPU);
}
void runSelectQueryAsTestUser(const std::string& query) {
runSelectQueryAsUser(query, "test_user", "test_pass");
}
void runSelectQueryAsTestUserAndAssertException(const std::string& query,
const std::string& exception) {
executeLambdaAndAssertException([&, this]() { runSelectQueryAsTestUser(query); },
exception);
}
static void TearDownTestSuite() { dropTestUser(); }
void SetUp() override { DBHandlerTestFixture::SetUp(); }
void TearDown() override {
tearDownTable();
DBHandlerTestFixture::TearDown();
}
void runQuery(const std::string& query) {
std::string first_query_term = query.substr(0, query.find(" "));
if (to_upper(first_query_term) == "SELECT") {
// SELECT statements require a different code path due to a conflict with
// QueryRunner
runSelectQueryAsTestUser(query);
} else {
sql(query);
}
}
void runQueryAndAssertException(const std::string& query,
const std::string& exception) {
std::string first_query_term = query.substr(0, query.find(" "));
if (to_upper(first_query_term) == "SELECT") {
// SELECT statements require a different code path due to a conflict with
// QueryRunner
runSelectQueryAsTestUserAndAssertException(query, exception);
} else {
queryAndAssertException(query, exception);
}
}
void queryAsTestUserWithNoPrivilegeAndAssertException(const std::string& query,
const std::string& exception) {
login("test_user", "test_pass");
runQueryAndAssertException(query, exception);
}
void queryAsTestUserWithPrivilege(const std::string& query,
const std::string& privilege) {
switchToAdmin();
sql("GRANT " + privilege + " ON TABLE test_table TO test_user;");
login("test_user", "test_pass");
runQuery(query);
}
void queryAsTestUserWithPrivilegeAndAssertException(const std::string& query,
const std::string& privilege,
const std::string& exception) {
switchToAdmin();
sql("GRANT " + privilege + " ON TABLE test_table TO test_user;");
login("test_user", "test_pass");
runQueryAndAssertException(query, exception);
}
void grantThenRevokePrivilegeToTestUser(const std::string& privilege) {
switchToAdmin();
sql("GRANT " + privilege + " ON TABLE test_table TO test_user;");
sql("REVOKE " + privilege + " ON TABLE test_table FROM test_user;");
}
static void createTestUser() {
sql("CREATE USER test_user (password = 'test_pass');");
sql("GRANT ACCESS ON DATABASE " + shared::kDefaultDbName + " TO test_user;");
}
void createTestForeignTable() {
sql("DROP FOREIGN TABLE IF EXISTS test_table;");
std::string query{
"CREATE FOREIGN TABLE test_table (i BIGINT) SERVER default_local_delimited WITH "
"(file_path = '" +
getDataFilesPath() + "1.csv');"};
sql(query);
is_foreign_table_ = true;
}
void createTestTable() {
sql("DROP TABLE IF EXISTS test_table;");
std::string query{"CREATE TABLE test_table (i BIGINT);"};
sql(query);
sql("INSERT INTO test_table VALUES (1);");
is_foreign_table_ = false;
}
void createTestView() {
sql("DROP VIEW IF EXISTS test_view");
createTestTable();
sql("CREATE VIEW test_view AS SELECT * FROM test_table");
}
void tearDownTable() {
loginAdmin();
if (is_foreign_table_) {
sql("DROP FOREIGN TABLE IF EXISTS test_table;");
} else {
sql("DROP TABLE IF EXISTS test_table;");
}
sql("DROP TABLE IF EXISTS renamed_test_table;");
sql("DROP VIEW IF EXISTS test_view");
}
static void dropTestUser() { sql("DROP USER IF EXISTS test_user;"); }
private:
bool is_foreign_table_;
static std::string getDataFilesPath() {
return boost::filesystem::canonical(g_test_binary_file_path +
"/../../Tests/FsiDataFiles")
.string() +
"/";
}
};
class ForeignTableAndTablePermissionsTest
: public TablePermissionsTest,
public testing::WithParamInterface<ddl_utils::TableType> {
protected:
void SetUp() override {
TablePermissionsTest::SetUp();
if (g_aggregator && GetParam() == ddl_utils::TableType::FOREIGN_TABLE) {
LOG(INFO) << "Test fixture not supported in distributed mode.";
GTEST_SKIP();
return;
}
switch (GetParam()) {
case ddl_utils::TableType::FOREIGN_TABLE:
createTestForeignTable();
break;
case ddl_utils::TableType::TABLE:
createTestTable();
break;
default:
UNREACHABLE();
}
}
};
class ForeignTablePermissionsTest : public TablePermissionsTest {
protected:
void SetUp() override {
TablePermissionsTest::SetUp();
if (g_aggregator) {
LOG(INFO) << "Test not supported in distributed mode.";
GTEST_SKIP();
}
}
};
INSTANTIATE_TEST_SUITE_P(ForeignTableAndTablePermissionsTest,
ForeignTableAndTablePermissionsTest,
::testing::Values(ddl_utils::TableType::FOREIGN_TABLE,
ddl_utils::TableType::TABLE));
TEST_F(ForeignTablePermissionsTest, ForeignTableGrantRevokeDropPrivilege) {
std::string privilege{"DROP"};
std::string query{"DROP FOREIGN TABLE test_table;"};
std::string no_privilege_exception{
"Foreign table \"test_table\" will not be dropped. User has no DROP "
"TABLE privileges."};
createTestForeignTable();
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
grantThenRevokePrivilegeToTestUser(privilege);
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
queryAsTestUserWithPrivilege(query, privilege);
}
TEST_F(TablePermissionsTest, TableGrantRevokeDropPrivilege) {
std::string privilege{"DROP"};
std::string query{"DROP TABLE test_table;"};
std::string no_privilege_exception{
"Table test_table will not be dropped. User has no proper privileges."};
createTestTable();
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
grantThenRevokePrivilegeToTestUser(privilege);
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
queryAsTestUserWithPrivilege(query, privilege);
}
TEST_P(ForeignTableAndTablePermissionsTest, GrantRevokeSelectPrivilege) {
if (g_aggregator) {
// TODO: select queries as a user currently do not work in distributed
// mode for regular tables (DistributedQueryRunner::init can not be run
// more than once.)
LOG(INFO) << "Test not supported in distributed mode.";
GTEST_SKIP();
}
std::string privilege{"SELECT"};
std::string query{"SELECT * FROM test_table;"};
std::string no_privilege_exception{
"Violation of access privileges: user test_user has no proper privileges for "
"object test_table"};
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
grantThenRevokePrivilegeToTestUser(privilege);
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
queryAsTestUserWithPrivilege(query, privilege);
}
TEST_F(ForeignTablePermissionsTest, ForeignTableGrantRevokeDeletePrivilege) {
std::string privilege{"DELETE"};
std::string query{"DELETE FROM test_table WHERE i = 1;"};
std::string no_privilege_exception{
"Violation of access privileges: user test_user has no proper "
"privileges for "
"object test_table"};
std::string query_exception{
"DELETE, INSERT, TRUNCATE, OR UPDATE commands are not "
"supported for foreign tables."};
createTestForeignTable();
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
grantThenRevokePrivilegeToTestUser(privilege);
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
queryAsTestUserWithPrivilegeAndAssertException(query, privilege, query_exception);
}
TEST_F(TablePermissionsTest, TableGrantRevokeDeletePrivilege) {
std::string privilege{"DELETE"};
std::string query{"DELETE FROM test_table WHERE i = 1;"};
std::string no_privilege_exception{
"Violation of access privileges: user test_user has no proper "
"privileges for "
"object test_table"};
createTestTable();
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
grantThenRevokePrivilegeToTestUser(privilege);
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
queryAsTestUserWithPrivilege(query, privilege);
}
TEST_F(ForeignTablePermissionsTest, ForeignTableGrantRevokeInsertPrivilege) {
std::string privilege{"INSERT"};
std::string query{"INSERT INTO test_table VALUES (2);"};
std::string no_privilege_exception{"User has no insert privileges on test_table."};
std::string query_exception{
"DELETE, INSERT, TRUNCATE, OR UPDATE commands are not "
"supported for foreign tables."};
createTestForeignTable();
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
grantThenRevokePrivilegeToTestUser(privilege);
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
queryAsTestUserWithPrivilegeAndAssertException(query, privilege, query_exception);
}
TEST_F(TablePermissionsTest, TableGrantRevokeInsertPrivilege) {
std::string privilege{"INSERT"};
std::string query{"INSERT INTO test_table VALUES (2);"};
std::string no_privilege_exception{"User has no insert privileges on test_table."};
createTestTable();
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
grantThenRevokePrivilegeToTestUser(privilege);
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
queryAsTestUserWithPrivilege(query, privilege);
}
TEST_F(ForeignTablePermissionsTest, ForeignTableGrantRevokeTruncatePrivilege) {
std::string privilege{"TRUNCATE"};
std::string query{"TRUNCATE TABLE test_table;"};
std::string no_privilege_exception{
"Table test_table will not be truncated. User test_user has no proper "
"privileges."};
std::string query_exception{
"DELETE, INSERT, TRUNCATE, OR UPDATE commands are not "
"supported for foreign tables."};
createTestForeignTable();
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
grantThenRevokePrivilegeToTestUser(privilege);
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
queryAsTestUserWithPrivilegeAndAssertException(query, privilege, query_exception);
}
TEST_F(TablePermissionsTest, TableGrantRevokeTruncatePrivilege) {
std::string privilege{"TRUNCATE"};
std::string query{"TRUNCATE TABLE test_table;"};
std::string no_privilege_exception{
"Table test_table will not be truncated. User test_user has no proper "
"privileges."};
createTestTable();
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
grantThenRevokePrivilegeToTestUser(privilege);
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
queryAsTestUserWithPrivilege(query, privilege);
}
TEST_F(ForeignTablePermissionsTest, ForeignTableGrantRevokeUpdatePrivilege) {
std::string privilege{"UPDATE"};
std::string query{"UPDATE test_table SET i = 2 WHERE i = 1;"};
std::string no_privilege_exception{
"Violation of access privileges: user test_user has no proper "
"privileges for "
"object test_table"};
std::string query_exception{
"DELETE, INSERT, TRUNCATE, OR UPDATE commands are not "
"supported for foreign tables."};
createTestForeignTable();
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
grantThenRevokePrivilegeToTestUser(privilege);
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
queryAsTestUserWithPrivilegeAndAssertException(query, privilege, query_exception);
}
TEST_F(TablePermissionsTest, TableGrantRevokeUpdatePrivilege) {
std::string privilege{"UPDATE"};
std::string query{"UPDATE test_table SET i = 2 WHERE i = 1;"};
std::string no_privilege_exception{
"Violation of access privileges: user test_user has no proper "
"privileges for "
"object test_table"};
createTestTable();
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
grantThenRevokePrivilegeToTestUser(privilege);
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
queryAsTestUserWithPrivilege(query, privilege);
}
TEST_P(ForeignTableAndTablePermissionsTest, GrantRevokeShowCreateTablePrivilege) {
if (g_aggregator && GetParam() == ddl_utils::TableType::FOREIGN_TABLE) {
LOG(INFO) << "Test not supported in distributed mode.";
return;
}
std::string privilege{"DROP"};
std::string query{"SHOW CREATE TABLE test_table;"};
std::string no_privilege_exception{"Table/View test_table does not exist."};
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
grantThenRevokePrivilegeToTestUser(privilege);
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
queryAsTestUserWithPrivilege(query, privilege);
}
TEST_F(TablePermissionsTest, TableGrantRevokeAlterTablePrivilege) {
std::string privilege{"ALTER"};
std::string query{"ALTER TABLE test_table RENAME COLUMN i TO j;"};
std::string no_privilege_exception{
"Current user does not have the privilege to alter table: test_table"};
createTestTable();
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
grantThenRevokePrivilegeToTestUser(privilege);
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
queryAsTestUserWithPrivilege(query, privilege);
}
TEST_F(ForeignTablePermissionsTest, TableGrantRevokeAlterForeignTablePrivilege) {
std::string privilege{"ALTER"};
std::string query{
"ALTER FOREIGN TABLE test_table SET (refresh_update_type = 'append');"};
std::string no_privilege_exception{
"Current user does not have the privilege to alter foreign table: "
"test_table"};
createTestForeignTable();
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
grantThenRevokePrivilegeToTestUser(privilege);
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
queryAsTestUserWithPrivilege(query, privilege);
}
TEST_F(TablePermissionsTest, TableRenameTablePrivilege) {
std::string privilege{"ALTER"};
std::string query{"RENAME TABLE test_table TO renamed_test_table;"};
std::string no_privilege_exception{
"Current user does not have the privilege to alter table: test_table"};
createTestTable();
queryAsTestUserWithNoPrivilegeAndAssertException(query, no_privilege_exception);
queryAsTestUserWithPrivilege(query, privilege);
}
TEST_F(ForeignTablePermissionsTest, ForeignTableAllPrivileges) {
createTestForeignTable();
sql("GRANT ALL ON TABLE test_table TO test_user;");
login("test_user", "test_pass");
runQuery("SHOW CREATE TABLE test_table;");
runQuery("SELECT * FROM test_table;");
runQuery("ALTER FOREIGN TABLE test_table SET (refresh_update_type = 'append');");
runQuery("DROP FOREIGN TABLE test_table;");
}
TEST_F(TablePermissionsTest, TableAllPrivileges) {
createTestTable();
sql("GRANT ALL ON TABLE test_table TO test_user;");
login("test_user", "test_pass");
runQuery("SHOW CREATE TABLE test_table;");
runQuery("UPDATE test_table SET i = 2 WHERE i = 1;");
runQuery("TRUNCATE TABLE test_table;");
runQuery("INSERT INTO test_table VALUES (2);");
runQuery("DELETE FROM test_table WHERE i = 2;");
if (!g_aggregator) {
// TODO: select queries as a user currently do not work in distributed
// mode for regular tables (DistributedQueryRunner::init can not be run
// more than once.)
runQuery("SELECT * FROM test_table;");
}
runQuery("ALTER TABLE test_table RENAME COLUMN i TO j;");
runQuery("DROP TABLE test_table;");
}
TEST_F(TablePermissionsTest, ShowCreateView) {
createTestView();
queryAsTestUserWithNoPrivilegeAndAssertException(
"SHOW CREATE TABLE test_view", "Table/View test_view does not exist.");
switchToAdmin();
sql("GRANT ALL ON VIEW test_view TO test_user;");
queryAsTestUserWithNoPrivilegeAndAssertException(
"SHOW CREATE TABLE test_view", "Not enough privileges to show the view SQL");
switchToAdmin();
sql("GRANT ALL ON TABLE test_table TO test_user;");
login("test_user", "test_pass");
TQueryResult result;
EXPECT_NO_THROW(sql(result, "SHOW CREATE TABLE test_view;"));
EXPECT_EQ("CREATE VIEW test_view AS SELECT * FROM test_table;",
result.row_set.columns[0].data.str_col[0]);
switchToAdmin();
sql("REVOKE ALL ON VIEW test_view FROM test_user;");
queryAsTestUserWithNoPrivilegeAndAssertException(
"SHOW CREATE TABLE test_view", "Table/View test_view does not exist.");
}
TEST_F(ForeignTablePermissionsTest, ForeignTableGrantRevokeCreateTablePrivilege) {
login("test_user", "test_pass");
executeLambdaAndAssertException([this] { createTestForeignTable(); },
"Foreign table \"test_table\" will not be "
"created. User has no CREATE TABLE privileges.");
switchToAdmin();
sql("GRANT CREATE TABLE ON DATABASE " + shared::kDefaultDbName + " TO test_user;");
sql("REVOKE CREATE TABLE ON DATABASE " + shared::kDefaultDbName + " FROM test_user;");
login("test_user", "test_pass");
executeLambdaAndAssertException([this] { createTestForeignTable(); },
"Foreign table \"test_table\" will not be "
"created. User has no CREATE TABLE privileges.");
switchToAdmin();
sql("GRANT CREATE TABLE ON DATABASE " + shared::kDefaultDbName + " TO test_user;");
login("test_user", "test_pass");
createTestForeignTable();
// clean up permissions
switchToAdmin();
sql("REVOKE CREATE TABLE ON DATABASE " + shared::kDefaultDbName + " FROM test_user;");
}
TEST_F(ForeignTablePermissionsTest, ForeignTableRefreshOwner) {
sql("GRANT CREATE TABLE ON DATABASE " + shared::kDefaultDbName + " TO test_user;");
login("test_user", "test_pass");
createTestForeignTable();
runQuery("REFRESH FOREIGN TABLES test_table;");
// clean up permissions
switchToAdmin();
sql("REVOKE CREATE TABLE ON DATABASE " + shared::kDefaultDbName + " FROM test_user;");
}
TEST_F(ForeignTablePermissionsTest, ForeignTableRefreshSuperUser) {
sql("GRANT CREATE TABLE ON DATABASE " + shared::kDefaultDbName + " TO test_user;");
login("test_user", "test_pass");
createTestForeignTable();
switchToAdmin();
runQuery("REFRESH FOREIGN TABLES test_table;");
// clean up permissions
sql("REVOKE CREATE TABLE ON DATABASE " + shared::kDefaultDbName + " FROM test_user;");
}
TEST_F(ForeignTablePermissionsTest, ForeignTableRefreshNonOwner) {
createTestForeignTable();
sql("GRANT ALL ON TABLE test_table TO test_user;");
login("test_user", "test_pass");
runQueryAndAssertException(
"REFRESH FOREIGN TABLES test_table;",
"REFRESH FOREIGN TABLES failed on table \"test_table\". It can only be "
"executed by super user or owner of the object.");
}
class ServerPrivApiTest : public DBHandlerTestFixture {
protected:
static void SetUpTestSuite() {
createDBHandler();
switchToAdmin();
createTestUser("test_user");
createTestUser("test_user_2");
}
static void TearDownTestSuite() {
dropTestUser("test_user");
dropTestUser("test_user_2");
}
void SetUp() override {
if (g_aggregator) {
LOG(INFO) << "Test fixture not supported in distributed mode.";
GTEST_SKIP();
return;
}
DBHandlerTestFixture::SetUp();
loginAdmin();
dropServer();
createTestServer();
}
void TearDown() override {
loginAdmin();
dropServer();
revokeTestUserServerPrivileges("test_user");
revokeTestUserServerPrivileges("test_user_2");
}
static void createTestUser(std::string name) {
sql("CREATE USER " + name + " (password = 'test_pass');");
sql("GRANT ACCESS ON DATABASE " + shared::kDefaultDbName + " TO " + name + ";");
}
static void dropTestUser(std::string name) { sql("DROP USER IF EXISTS " + name + ";"); }
void revokeTestUserServerPrivileges(std::string name) {
sql("REVOKE ALL ON DATABASE " + shared::kDefaultDbName + " FROM " + name + ";");
sql("GRANT ACCESS ON DATABASE " + shared::kDefaultDbName + " TO " + name + ";");
}
void createTestServer() {
sql("CREATE SERVER test_server FOREIGN DATA WRAPPER delimited_file "
"WITH (storage_type = 'LOCAL_FILE', base_path = '/test_path/');");
}
void dropServer() { sql("DROP SERVER IF EXISTS test_server;"); }
void assertExpectedDBObj(std::vector<TDBObject>& db_objs,
std::string name,
TDBObjectType::type obj_type,
std::vector<bool> privs,
std::string grantee_name,
TDBObjectType::type priv_type) {
bool obj_found = false;
for (const auto& db_obj : db_objs) {
if ((db_obj.objectName == name) && (db_obj.objectType == obj_type) &&
(db_obj.privs == privs) && (db_obj.grantee == grantee_name) &&
(db_obj.privilegeObjectType == priv_type)) {
obj_found = true;
break;
};
}
ASSERT_TRUE(obj_found);
}
void assertDBAccessObj(std::vector<TDBObject>& db_objs) {
assertExpectedDBObj(db_objs,
shared::kDefaultDbName,
TDBObjectType::DatabaseDBObjectType,
{0, 0, 0, 1},
"test_user",
TDBObjectType::DatabaseDBObjectType);
}
void assertSuperAccessObj(std::vector<TDBObject>& db_objs) {
assertExpectedDBObj(db_objs,
"super",
TDBObjectType::AbstractDBObjectType,
{1, 1, 1, 1},
"admin",
TDBObjectType::ServerDBObjectType);
}
};
TEST_F(ServerPrivApiTest, CreateForGrantee) {
const auto& [db_handler, session_id] = getDbHandlerAndSessionId();
sql("GRANT CREATE SERVER ON DATABASE " + shared::kDefaultDbName + " TO test_user;");
std::vector<TDBObject> priv_objs;
db_handler->get_db_objects_for_grantee(priv_objs, session_id, "test_user");
ASSERT_EQ(priv_objs.size(), 2u);
assertDBAccessObj(priv_objs);
assertExpectedDBObj(priv_objs,
shared::kDefaultDbName,
TDBObjectType::DatabaseDBObjectType,
{1, 0, 0, 0},
"test_user",
TDBObjectType::ServerDBObjectType);
}
TEST_F(ServerPrivApiTest, DropForGrantee) {
const auto& [db_handler, session_id] = getDbHandlerAndSessionId();
sql("GRANT DROP SERVER ON DATABASE " + shared::kDefaultDbName + " TO test_user;");
std::vector<TDBObject> priv_objs;
db_handler->get_db_objects_for_grantee(priv_objs, session_id, "test_user");
ASSERT_EQ(priv_objs.size(), 2u);
assertDBAccessObj(priv_objs);
assertExpectedDBObj(priv_objs,
shared::kDefaultDbName,
TDBObjectType::DatabaseDBObjectType,
{0, 1, 0, 0},
"test_user",
TDBObjectType::ServerDBObjectType);
}
TEST_F(ServerPrivApiTest, AlterForGrantee) {
const auto& [db_handler, session_id] = getDbHandlerAndSessionId();
sql("GRANT ALTER SERVER ON DATABASE " + shared::kDefaultDbName + " TO test_user;");
std::vector<TDBObject> priv_objs;
db_handler->get_db_objects_for_grantee(priv_objs, session_id, "test_user");
ASSERT_EQ(priv_objs.size(), 2u);
assertDBAccessObj(priv_objs);
assertExpectedDBObj(priv_objs,
shared::kDefaultDbName,
TDBObjectType::DatabaseDBObjectType,
{0, 0, 1, 0},
"test_user",
TDBObjectType::ServerDBObjectType);
}
TEST_F(ServerPrivApiTest, AlterOnServerGrantee) {
const auto& [db_handler, session_id] = getDbHandlerAndSessionId();
sql("GRANT ALTER ON SERVER test_server TO test_user;");
std::vector<TDBObject> priv_objs;
db_handler->get_db_objects_for_grantee(priv_objs, session_id, "test_user");
ASSERT_EQ(priv_objs.size(), 2u);
assertDBAccessObj(priv_objs);
assertExpectedDBObj(priv_objs,
"test_server",
TDBObjectType::ServerDBObjectType,
{0, 0, 1, 0},
"test_user",
TDBObjectType::ServerDBObjectType);
}
TEST_F(ServerPrivApiTest, UsageForGrantee) {
const auto& [db_handler, session_id] = getDbHandlerAndSessionId();
sql("GRANT SERVER USAGE ON DATABASE " + shared::kDefaultDbName + " TO test_user;");
std::vector<TDBObject> priv_objs;
db_handler->get_db_objects_for_grantee(priv_objs, session_id, "test_user");
ASSERT_EQ(priv_objs.size(), 2u);
assertDBAccessObj(priv_objs);
assertExpectedDBObj(priv_objs,
shared::kDefaultDbName,
TDBObjectType::DatabaseDBObjectType,
{0, 0, 0, 1},
"test_user",
TDBObjectType::ServerDBObjectType);
}
TEST_F(ServerPrivApiTest, UsageOnServerGrantee) {
const auto& [db_handler, session_id] = getDbHandlerAndSessionId();
sql("GRANT USAGE ON SERVER test_server TO test_user;");
std::vector<TDBObject> priv_objs;
db_handler->get_db_objects_for_grantee(priv_objs, session_id, "test_user");
ASSERT_EQ(priv_objs.size(), 2u);
assertDBAccessObj(priv_objs);
assertExpectedDBObj(priv_objs,
"test_server",
TDBObjectType::ServerDBObjectType,
{0, 0, 0, 1},
"test_user",
TDBObjectType::ServerDBObjectType);
}
TEST_F(ServerPrivApiTest, GetDBObjNonSuser) {
const auto& [db_handler, session_id] = getDbHandlerAndSessionId();
sql("GRANT CREATE SERVER ON DATABASE " + shared::kDefaultDbName + " TO test_user;");
login("test_user", "test_pass");
std::vector<TDBObject> priv_objs;
db_handler->get_db_objects_for_grantee(priv_objs, session_id, "test_user");
ASSERT_EQ(priv_objs.size(), 2u);
assertDBAccessObj(priv_objs);
assertExpectedDBObj(priv_objs,
shared::kDefaultDbName,
TDBObjectType::DatabaseDBObjectType,
{1, 0, 0, 0},
"test_user",
TDBObjectType::ServerDBObjectType);
}
TEST_F(ServerPrivApiTest, GetDBObjNoAccess) {
const auto& [db_handler, session_id] = getDbHandlerAndSessionId();
sql("GRANT CREATE SERVER ON DATABASE " + shared::kDefaultDbName + " TO test_user_2;");
login("test_user", "test_pass");
std::vector<TDBObject> priv_objs;
db_handler->get_db_objects_for_grantee(priv_objs, session_id, "test_user_2");
// no privs returned
ASSERT_EQ(priv_objs.size(), 0u);
}
TEST_F(ServerPrivApiTest, AlterOnServerObjectPrivs) {
sql("GRANT ALTER ON SERVER test_server TO test_user;");
std::vector<TDBObject> priv_objs;
login("test_user", "test_pass");
const auto& [db_handler, session_id] = getDbHandlerAndSessionId();
db_handler->get_db_object_privs(
priv_objs, session_id, "test_server", TDBObjectType::ServerDBObjectType);
ASSERT_EQ(priv_objs.size(), 1u);
assertExpectedDBObj(priv_objs,
"test_server",
TDBObjectType::ServerDBObjectType,
{0, 0, 1, 0},
"test_user",
TDBObjectType::ServerDBObjectType);
}
TEST_F(ServerPrivApiTest, AlterOnServerObjectPrivsSuper) {
const auto& [db_handler, session_id] = getDbHandlerAndSessionId();
sql("GRANT ALTER ON SERVER test_server TO test_user;");
std::vector<TDBObject> priv_objs;
db_handler->get_db_object_privs(
priv_objs, session_id, "test_server", TDBObjectType::ServerDBObjectType);
ASSERT_EQ(priv_objs.size(), 2u);
// Suser access obj returned when calling as suser
assertSuperAccessObj(priv_objs);
assertExpectedDBObj(priv_objs,
"test_server",
TDBObjectType::ServerDBObjectType,
{0, 0, 1, 0},
"test_user",
TDBObjectType::ServerDBObjectType);
}
TEST_F(ServerPrivApiTest, UsageOnServerObjectPrivs) {
sql("GRANT USAGE ON SERVER test_server TO test_user;");
std::vector<TDBObject> priv_objs;
login("test_user", "test_pass");
const auto& [db_handler, session_id] = getDbHandlerAndSessionId();
db_handler->get_db_object_privs(
priv_objs, session_id, "test_server", TDBObjectType::ServerDBObjectType);
ASSERT_EQ(priv_objs.size(), 1u);
assertExpectedDBObj(priv_objs,
"test_server",
TDBObjectType::ServerDBObjectType,
{0, 0, 0, 1},
"test_user",
TDBObjectType::ServerDBObjectType);
}
TEST_F(ServerPrivApiTest, UsageOnServerObjectPrivsSuper) {
const auto& [db_handler, session_id] = getDbHandlerAndSessionId();
sql("GRANT USAGE ON SERVER test_server TO test_user;");
std::vector<TDBObject> priv_objs;
db_handler->get_db_object_privs(
priv_objs, session_id, "test_server", TDBObjectType::ServerDBObjectType);
ASSERT_EQ(priv_objs.size(), 2u);
// Suser access obj returned when calling as suser
assertSuperAccessObj(priv_objs);
assertExpectedDBObj(priv_objs,
"test_server",
TDBObjectType::ServerDBObjectType,
{0, 0, 0, 1},
"test_user",
TDBObjectType::ServerDBObjectType);
}
TEST_F(ServerPrivApiTest, ShowServerRequiresPermission) {
login("test_user", "test_pass");
queryAndAssertException("SHOW CREATE SERVER test_server",
"Foreign server test_server does not exist.");
loginAdmin();
sql("GRANT USAGE ON SERVER test_server TO test_user;");
login("test_user", "test_pass");
ASSERT_NO_THROW(sql("SHOW CREATE SERVER test_server"));
}
TEST(Temporary, Users) {
auto user_cleanup = [] {
if (sys_cat.getMetadataForUser("username1", g_user)) {
sys_cat.dropUser("username1");
}
CHECK(!sys_cat.getMetadataForUser("username1", g_user));
if (sys_cat.getMetadataForUser("username2", g_user)) {
sys_cat.dropUser("username2");
}
CHECK(!sys_cat.getMetadataForUser("username2", g_user));
};
user_cleanup();
auto read_only = g_read_only;
g_read_only = true;
ScopeGuard scope_guard = [&] {
g_read_only = read_only;
user_cleanup();
};
sys_cat.createUser(
"username1",
Catalog_Namespace::UserAlterations{
"password1", /*is_super=*/true, /*dbname=*/"", /*can_login=*/true},
/*is_temporary=*/true);
CHECK(sys_cat.getMetadataForUser("username1", g_user));
EXPECT_TRUE(g_user.is_temporary);
EXPECT_EQ(g_user.can_login, true);
EXPECT_NO_THROW(sys_cat.alterUser(
"username1",
Catalog_Namespace::UserAlterations{
/*password=*/{}, /*is_super=*/{}, /*default_db=*/{}, /*can_login=*/false}));
CHECK(sys_cat.getMetadataForUser("username1", g_user));
EXPECT_EQ(g_user.can_login, false);
EXPECT_NO_THROW(sys_cat.renameUser("username1", "username2"));
CHECK(sys_cat.getMetadataForUser("username2", g_user));
EXPECT_EQ(g_user.userName, "username2");
}
class ObjectDescriptorCleanupTest : public DBHandlerTestFixture {
protected:
void SetUp() override {
sql("DROP TABLE IF EXISTS test_table;");
sql("CREATE TABLE test_table (i INTEGER);");
}
void TearDown() override { sql("DROP TABLE IF EXISTS test_table;"); }
void assertNumObjectDesciptors(size_t num_descriptors) {
auto td = getCatalog().getMetadataForTable("test_table", false);
ASSERT_EQ(sys_cat
.getMetadataForObject(getCatalog().getDatabaseId(),
DBObjectType::TableDBObjectType,
td->tableId)
.size(),
num_descriptors);
}
void assertExpectedDescriptorRole() {
assertNumObjectDesciptors(1);
auto td = getCatalog().getMetadataForTable("test_table", false);
auto object_desc = sys_cat.getMetadataForObject(
getCatalog().getDatabaseId(), DBObjectType::TableDBObjectType, td->tableId)[0];
ASSERT_EQ(object_desc->roleName, "test_role");
ASSERT_EQ(object_desc->roleType, false);
ASSERT_TRUE(
object_desc->privs.hasPermission(AccessPrivileges::SELECT_FROM_TABLE.privileges));
}
void assertExpectedDescriptorUser(std::string username = "test_user") {
assertNumObjectDesciptors(1);
auto td = getCatalog().getMetadataForTable("test_table", false);
auto object_desc = sys_cat.getMetadataForObject(
getCatalog().getDatabaseId(), DBObjectType::TableDBObjectType, td->tableId)[0];
ASSERT_EQ(object_desc->roleName, username);
ASSERT_EQ(object_desc->roleType, true);
ASSERT_TRUE(
object_desc->privs.hasPermission(AccessPrivileges::SELECT_FROM_TABLE.privileges));
}
};
TEST_F(ObjectDescriptorCleanupTest, DeleteObjectDescriptorOnDropRole) {
sql("CREATE ROLE test_role;");
assertNumObjectDesciptors(0);
sql("GRANT SELECT ON TABLE test_table TO test_role");
assertExpectedDescriptorRole();
sql("DROP ROLE test_role;");
assertNumObjectDesciptors(0);
}
TEST_F(ObjectDescriptorCleanupTest, DeleteObjectDescriptorOnDropUser) {
sql("CREATE USER test_user;");
assertNumObjectDesciptors(0);
sql("GRANT SELECT ON TABLE test_table TO test_user");
assertExpectedDescriptorUser();
sql("DROP USER test_user;");
assertNumObjectDesciptors(0);
}
TEST_F(ObjectDescriptorCleanupTest, DeleteObjectDescriptorFromRenamedUser) {
sql("CREATE USER test_user");
assertNumObjectDesciptors(0);
sql("GRANT SELECT ON TABLE test_table TO test_user");
assertExpectedDescriptorUser();
sql("ALTER USER test_user RENAME TO test_user_renamed;");
assertExpectedDescriptorUser("test_user_renamed");
sql("DROP USER test_user_renamed;");
assertNumObjectDesciptors(0);
}
class ReassignOwnedTest : public DBHandlerTestFixture {
protected:
static void SetUpTestSuite() {
createDBHandler();
createTestUser("test_user_1", "test_pass");
createTestUser("test_user_2", "test_pass");
createTestUser("test_user_3", "test_pass");
createTestUser("all_permissions_test_user", "test_pass");
sql("GRANT ALL ON DATABASE " + shared::kDefaultDbName +
" TO all_permissions_test_user;");
}
static void TearDownTestSuite() {
loginAdmin();
dropTestUser("test_user_1");
dropTestUser("test_user_2");
dropTestUser("test_user_3");
dropTestUser("all_permissions_test_user");
}
void SetUp() override { dropAllDatabaseObjects(); }
void TearDown() override { dropAllDatabaseObjects(); }
void dropAllDatabaseObjects() {
loginAdmin();
const auto& [db_handler, session_id] = getDbHandlerAndSessionId();
auto dashboards = getCatalog().getAllDashboardsMetadata();
for (const auto dashboard : dashboards) {
db_handler->delete_dashboard(session_id, dashboard->dashboardId);
}
sql("DROP TABLE IF EXISTS test_table_1;");
sql("DROP TABLE IF EXISTS test_table_2;");
sql("DROP VIEW IF EXISTS test_view_1;");
sql("DROP VIEW IF EXISTS test_view_2;");
sql("DROP SERVER IF EXISTS test_server_1;");
sql("DROP SERVER IF EXISTS test_server_2;");
sql("DROP DATABASE IF EXISTS test_db;");
}
static int32_t createTestUser(const std::string& user_name, const std::string& pass) {
sql("CREATE USER " + user_name + " (password = '" + pass + "');");
sql("GRANT ACCESS, CREATE TABLE, CREATE VIEW, CREATE DASHBOARD ON "
"DATABASE " +
shared::kDefaultDbName + " TO " + user_name + ";");
if (!isDistributedMode()) {
// FSI is currently not supported in distributed mode.
sql("GRANT CREATE SERVER ON DATABASE " + shared::kDefaultDbName + " TO " +
user_name + ";");
}
UserMetadata user_metadata{};
SysCatalog::instance().getMetadataForUser(user_name, user_metadata);
return user_metadata.userId;
}
static void dropTestUser(const std::string& user_name) {
sql("DROP USER IF EXISTS " + user_name + ";");
}
void createDatabaseObjects(const std::string& name_suffix) {
sql("CREATE TABLE test_table_" + name_suffix + " (i INTEGER);");
sql("CREATE VIEW test_view_" + name_suffix + " AS SELECT * FROM test_table_" +
name_suffix + ";");
if (!isDistributedMode()) {
sql("CREATE SERVER test_server_" + name_suffix +
" FOREIGN DATA WRAPPER delimited_file "
"WITH (storage_type = 'LOCAL_FILE', base_path = '/test_path/');");
}
const auto& [db_handler, session_id] = getDbHandlerAndSessionId();
db_handler->create_dashboard(
session_id, "test_dashboard_" + name_suffix, "state", "image", "metadata");
}
void assertDatabaseObjectsOwnership(const std::string& user_name,
const std::string& name_suffix) {
UserMetadata user;
SysCatalog::instance().getMetadataForUser(user_name, user);
auto user_id = user.userId;
const auto& catalog = getCatalog();
auto td = catalog.getMetadataForTable("test_table_" + name_suffix, false);
ASSERT_NE(td, nullptr);
ASSERT_EQ(user_id, td->userId);
auto view = catalog.getMetadataForTable("test_view_" + name_suffix, false);
ASSERT_NE(view, nullptr);
ASSERT_EQ(user_id, view->userId);
auto dashboard = catalog.getMetadataForDashboard(std::to_string(user_id),
"test_dashboard_" + name_suffix);
ASSERT_NE(dashboard, nullptr);
ASSERT_EQ(user_id, dashboard->userId);
ASSERT_EQ(user_name, dashboard->user);
// Permission entries are not added for super users
if (!user.isSuper) {
ASSERT_TRUE(SysCatalog::instance().verifyDBObjectOwnership(
user, DBObject{td->tableId, TableDBObjectType}, catalog));
ASSERT_TRUE(SysCatalog::instance().verifyDBObjectOwnership(
user, DBObject{view->tableId, ViewDBObjectType}, catalog));
ASSERT_TRUE(SysCatalog::instance().verifyDBObjectOwnership(
user, DBObject{dashboard->dashboardId, DashboardDBObjectType}, catalog));
assertObjectRoleDescriptor(DBObjectType::TableDBObjectType, td->tableId, user_id);
assertObjectRoleDescriptor(DBObjectType::ViewDBObjectType, view->tableId, user_id);
assertObjectRoleDescriptor(
DBObjectType::DashboardDBObjectType, dashboard->dashboardId, user_id);
}
if (!isDistributedMode()) {
auto server = catalog.getForeignServer("test_server_" + name_suffix);
ASSERT_NE(server, nullptr);
ASSERT_EQ(user_id, server->user_id);
if (!user.isSuper) {
ASSERT_TRUE(SysCatalog::instance().verifyDBObjectOwnership(
user, DBObject{server->id, ServerDBObjectType}, catalog));
assertObjectRoleDescriptor(DBObjectType::ServerDBObjectType, server->id, user_id);
}
}
}
void assertObjectRoleDescriptor(DBObjectType object_type,
int32_t object_id,
int32_t owner_id) {
auto object_type_id = static_cast<int>(object_type);
int found_objects = 0;
for (const auto object : SysCatalog::instance().getMetadataForObject(
getCatalog().getDatabaseId(), object_type_id, object_id)) {
if (object->objectType == object_type_id && object->objectId == object_id) {
if (object->objectOwnerId != owner_id) {
FAIL() << "ObjectRoleDescriptor found with wrong owner id, object type: "
<< object_type_id << ", object id: " << object_id
<< ", owner id: " << object->objectOwnerId
<< ", expected owner id: " << owner_id
<< " name: " << object->objectName;
}
found_objects++;
}
}
if (found_objects == 0) {
FAIL() << "No ObjectRoleDescriptor found for object type: " << object_type_id
<< ", object id: " << object_id << ", owner id: " << owner_id;
}
}
void assertObjectPermissions(const std::string& user_name,
const std::string& name_suffix,
bool has_object_permissions,
const std::string& owner_user_name) {
const auto& catalog = getCatalog();
auto td = catalog.getMetadataForTable("test_table_" + name_suffix, false);
ASSERT_NE(td, nullptr);
assertObjectPermissions(user_name,
td->tableId,
AccessPrivileges::ALL_TABLE,
DBObjectType::TableDBObjectType,
has_object_permissions);
auto view = catalog.getMetadataForTable("test_view_" + name_suffix, false);
ASSERT_NE(view, nullptr);
assertObjectPermissions(user_name,
view->tableId,
AccessPrivileges::ALL_VIEW,
DBObjectType::ViewDBObjectType,
has_object_permissions);
if (!isDistributedMode()) {
auto server = catalog.getForeignServer("test_server_" + name_suffix);
ASSERT_NE(server, nullptr);
assertObjectPermissions(user_name,
server->id,
AccessPrivileges::ALL_SERVER,
DBObjectType::ServerDBObjectType,
has_object_permissions);
}
UserMetadata user;
SysCatalog::instance().getMetadataForUser(owner_user_name, user);
auto dashboard = catalog.getMetadataForDashboard(std::to_string(user.userId),
"test_dashboard_" + name_suffix);
ASSERT_NE(dashboard, nullptr);
assertObjectPermissions(user_name,
dashboard->dashboardId,
AccessPrivileges::ALL_DASHBOARD,
DBObjectType::DashboardDBObjectType,
has_object_permissions);
}
void assertObjectPermissions(const std::string& user_name,
int32_t object_id,
const AccessPrivileges& privilege_type,
DBObjectType object_type,
bool has_object_permissions) {
AccessPrivileges privileges;
privileges.add(privilege_type);
DBObject object(object_id, object_type);
object.loadKey(getCatalog());
object.setPrivileges(privileges);
ASSERT_EQ(SysCatalog::instance().checkPrivileges(user_name, {object}),
has_object_permissions);
}
void assertNoDashboardsForUsers(const std::vector<std::string>& user_names) {
const auto& catalog = getCatalog();
for (const auto& user_name : user_names) {
UserMetadata user;
SysCatalog::instance().getMetadataForUser(user_name, user);
for (const auto dashboard : catalog.getAllDashboardsMetadata()) {
ASSERT_NE(dashboard->userId, user.userId);
ASSERT_NE(dashboard->user, user_name);
ASSERT_EQ(catalog.getMetadataForDashboard(std::to_string(user.userId),
dashboard->dashboardName),
nullptr);
}
}
}
void assertDatabaseOwnership(const std::string& db_name, const std::string& user_name) {
UserMetadata user;
SysCatalog::instance().getMetadataForUser(user_name, user);
DBMetadata database;
SysCatalog::instance().getMetadataForDB(db_name, database);
ASSERT_EQ(user.userId, database.dbOwner);
auto& catalog = getCatalog();
ASSERT_EQ(db_name, catalog.name());
// Permission entries are not added for super users
if (!user.isSuper) {
ASSERT_TRUE(SysCatalog::instance().verifyDBObjectOwnership(
user, DBObject{db_name, DatabaseDBObjectType}, catalog));
assertObjectRoleDescriptor(DBObjectType::DatabaseDBObjectType, -1, user.userId);
}
}
};
TEST_F(ReassignOwnedTest, SuperUser) {
login("test_user_1", "test_pass");
createDatabaseObjects("1");
assertDatabaseObjectsOwnership("test_user_1", "1");
assertObjectPermissions("test_user_1", "1", true, "test_user_1");
login("test_user_2", "test_pass");
createDatabaseObjects("2");
assertDatabaseObjectsOwnership("test_user_2", "2");
assertObjectPermissions("test_user_2", "2", true, "test_user_2");
loginAdmin();
sql("REASSIGN OWNED BY test_user_1, test_user_2 TO test_user_3;");
assertDatabaseObjectsOwnership("test_user_3", "1");
assertDatabaseObjectsOwnership("test_user_3", "2");
assertObjectPermissions("test_user_3", "1", true, "test_user_3");
assertObjectPermissions("test_user_3", "2", true, "test_user_3");
assertNoDashboardsForUsers({"test_user_1", "test_user_2"});
// Assert that old owners no longer have permissions to database objects
assertObjectPermissions("test_user_1", "1", false, "test_user_3");
assertObjectPermissions("test_user_2", "2", false, "test_user_3");
}
TEST_F(ReassignOwnedTest, UserWithAllPermissions) {
login("all_permissions_test_user", "test_pass");
createDatabaseObjects("1");
assertDatabaseObjectsOwnership("all_permissions_test_user", "1");
assertObjectPermissions(
"all_permissions_test_user", "1", true, "all_permissions_test_user");
loginAdmin();
sql("REASSIGN OWNED BY all_permissions_test_user TO test_user_1;");
assertDatabaseObjectsOwnership("test_user_1", "1");
assertObjectPermissions("test_user_1", "1", true, "test_user_1");
assertNoDashboardsForUsers({"all_permissions_test_user"});
// Assert that old owner still has permissions to database objects because of previous
// grant of all permissions
assertObjectPermissions("all_permissions_test_user", "1", true, "test_user_1");
}
TEST_F(ReassignOwnedTest, ReassignToSameUser) {
login("test_user_1", "test_pass");
createDatabaseObjects("1");
assertDatabaseObjectsOwnership("test_user_1", "1");
assertObjectPermissions("test_user_1", "1", true, "test_user_1");
loginAdmin();
sql("REASSIGN OWNED BY test_user_1 TO test_user_1;");
assertDatabaseObjectsOwnership("test_user_1", "1");
assertObjectPermissions("test_user_1", "1", true, "test_user_1");
}
TEST_F(ReassignOwnedTest, DatabaseOwner) {
loginAdmin();
sql("CREATE DATABASE test_db (owner = 'test_user_1');");
login("test_user_1", "test_pass", "test_db");
createDatabaseObjects("1");
assertDatabaseObjectsOwnership("test_user_1", "1");
assertObjectPermissions("test_user_1", "1", true, "test_user_1");
assertDatabaseOwnership("test_db", "test_user_1");
login("admin", "HyperInteractive", "test_db");
sql("REASSIGN OWNED BY test_user_1 TO test_user_2;");
assertDatabaseObjectsOwnership("test_user_2", "1");
assertObjectPermissions("test_user_2", "1", true, "test_user_2");
assertNoDashboardsForUsers({"test_user_1"});
// Assert that the old owner still owns the database
assertDatabaseOwnership("test_db", "test_user_1");
// Assert that the old owner still has permissions to database objects because of
// database ownership
assertObjectPermissions("test_user_1", "1", true, "test_user_2");
}
TEST_F(ReassignOwnedTest, MultipleDatabases) {
// Create objects in the default database
login("test_user_1", "test_pass");
createDatabaseObjects("1");
assertDatabaseObjectsOwnership("test_user_1", "1");
assertObjectPermissions("test_user_1", "1", true, "test_user_1");
loginAdmin();
sql("CREATE DATABASE test_db;");
sql("GRANT ALL ON DATABASE test_db TO test_user_1;");
// Create objects in the new database
login("test_user_1", "test_pass", "test_db");
createDatabaseObjects("1");
assertDatabaseObjectsOwnership("test_user_1", "1");
assertObjectPermissions("test_user_1", "1", true, "test_user_1");
login("admin", "HyperInteractive", "test_db");
sql("REASSIGN OWNED BY test_user_1 TO test_user_2;");
assertDatabaseObjectsOwnership("test_user_2", "1");
assertObjectPermissions("test_user_2", "1", true, "test_user_2");
assertNoDashboardsForUsers({"test_user_1"});
// Assert that ownership in the default database is not changed
loginAdmin();
assertDatabaseObjectsOwnership("test_user_1", "1");
assertObjectPermissions("test_user_1", "1", true, "test_user_1");
assertNoDashboardsForUsers({"test_user_2"});
}
TEST_F(ReassignOwnedTest, ReassignToSuperUser) {
login("test_user_1", "test_pass");
createDatabaseObjects("1");
assertDatabaseObjectsOwnership("test_user_1", "1");
assertObjectPermissions("test_user_1", "1", true, "test_user_1");
loginAdmin();
sql("REASSIGN OWNED BY test_user_1 TO admin;");
assertDatabaseObjectsOwnership("admin", "1");
assertObjectPermissions("admin", "1", true, "admin");
assertNoDashboardsForUsers({"test_user_1"});
// Assert that the old owner no longer has permissions to database objects
assertObjectPermissions("test_user_1", "1", false, "admin");
}
TEST_F(ReassignOwnedTest, ReassignFromSuperUser) {
loginAdmin();
// Use a different database for this test case in order to avoid changing database
// objects that are created outside the scope of this test in the default database.
sql("CREATE DATABASE test_db;");
login("admin", "HyperInteractive", "test_db");
createDatabaseObjects("1");
assertDatabaseObjectsOwnership("admin", "1");
assertObjectPermissions("admin", "1", true, "admin");
sql("REASSIGN OWNED BY admin TO test_user_1;");
assertDatabaseObjectsOwnership("test_user_1", "1");
assertObjectPermissions("test_user_1", "1", true, "test_user_1");
assertNoDashboardsForUsers({"admin"});
// Assert that the super user/admin still owns the database
assertDatabaseOwnership("test_db", "admin");
// Assert that the super user/admin still has permissions to database objects
assertObjectPermissions("admin", "1", true, "test_user_1");
}
TEST_F(ReassignOwnedTest, NonSuperUser) {
login("test_user_1", "test_pass");
createDatabaseObjects("1");
assertDatabaseObjectsOwnership("test_user_1", "1");
assertObjectPermissions("test_user_1", "1", true, "test_user_1");
login("test_user_2", "test_pass");
queryAndAssertException("REASSIGN OWNED BY test_user_1 TO test_user_2;",
"Only super users can reassign ownership of database objects.");
}
TEST_F(ReassignOwnedTest, NonExistentOldOwner) {
login("test_user_1", "test_pass");
createDatabaseObjects("1");
assertDatabaseObjectsOwnership("test_user_1", "1");
assertObjectPermissions("test_user_1", "1", true, "test_user_1");
loginAdmin();
queryAndAssertException(
"REASSIGN OWNED BY test_user_1, nonexistent_user TO test_user_2;",
"User with username \"nonexistent_user\" does not exist.");
}
TEST_F(ReassignOwnedTest, NonExistentNewOwner) {
login("test_user_1", "test_pass");
createDatabaseObjects("1");
assertDatabaseObjectsOwnership("test_user_1", "1");
assertObjectPermissions("test_user_1", "1", true, "test_user_1");
loginAdmin();
queryAndAssertException("REASSIGN OWNED BY test_user_1 TO nonexistent_user;",
"User with username \"nonexistent_user\" does not exist.");
}
class AlterServerOwnerTest : public ReassignOwnedTest {
protected:
void SetUp() override {
if (g_aggregator) {
LOG(INFO) << "Test fixture not supported in distributed mode.";
GTEST_SKIP();
}
ReassignOwnedTest::dropAllDatabaseObjects();
}
static void createServer() {
sql("CREATE SERVER test_server_1 FOREIGN DATA WRAPPER delimited_file WITH "
"(storage_type "
"= 'LOCAL_FILE', base_path = '/test_path/');");
// grant alter on server to other user to create additional ObjectRoleDescriptor that
// needs to be updated
sql("GRANT ALTER ON SERVER test_server_1 TO test_user_2;");
}
void verifyOwnership(std::string user_name) {
UserMetadata user;
SysCatalog::instance().getMetadataForUser(user_name, user);
auto user_id = user.userId;
auto& catalog = getCatalog();
auto server = catalog.getForeignServer("test_server_1");
ASSERT_NE(server, nullptr);
ASSERT_EQ(user_id, server->user_id);
if (!user.isSuper) {
ASSERT_TRUE(SysCatalog::instance().verifyDBObjectOwnership(
user, DBObject{server->id, DBObjectType::ServerDBObjectType}, catalog));
}
// Assumes additional privileges have been granted if owner is superuser
assertObjectRoleDescriptor(DBObjectType::ServerDBObjectType, server->id, user_id);
}
};
TEST_F(AlterServerOwnerTest, ToRegularUser) {
createServer();
verifyOwnership("admin");
sql("ALTER SERVER test_server_1 OWNER TO test_user_1;");
verifyOwnership("test_user_1");
}
TEST_F(AlterServerOwnerTest, ToSuperUser) {
login("test_user_1", "test_pass");
createServer();
verifyOwnership("test_user_1");
loginAdmin();
sql("ALTER SERVER test_server_1 OWNER TO admin;");
verifyOwnership("admin");
}
TEST(SyncUserWithRemoteProvider, DEFAULT_DB) {
run_ddl_statement("DROP DATABASE IF EXISTS db1;");
run_ddl_statement("DROP DATABASE IF EXISTS db2;");
ScopeGuard dbguard = [] {
run_ddl_statement("DROP DATABASE IF EXISTS db1;");
run_ddl_statement("DROP DATABASE IF EXISTS db2;");
};
run_ddl_statement("CREATE DATABASE db1;");
run_ddl_statement("CREATE DATABASE db2;");
auto db1 = sys_cat.getDB("db1");
ASSERT_TRUE(db1);
auto db2 = sys_cat.getDB("db2");
ASSERT_TRUE(db2);
run_ddl_statement("DROP USER IF EXISTS u1;");
ScopeGuard u1guard = [] { run_ddl_statement("DROP USER IF EXISTS u1;"); };
Catalog_Namespace::UserAlterations alts;
// create u1 w/db1
alts.default_db = "db1";
sys_cat.syncUserWithRemoteProvider("u1", {}, alts);
auto u1 = sys_cat.getUser("u1");
ASSERT_TRUE(u1);
ASSERT_EQ(u1->defaultDbId, db1->dbId);
// alter u1 w/db2
alts.default_db = "db2";
sys_cat.syncUserWithRemoteProvider("u1", {}, alts);
u1 = sys_cat.getUser("u1");
ASSERT_TRUE(u1);
ASSERT_EQ(u1->defaultDbId, db2->dbId);
// alter u1 no-op
alts.default_db = std::nullopt;
sys_cat.syncUserWithRemoteProvider("u1", {}, alts);
u1 = sys_cat.getUser("u1");
ASSERT_TRUE(u1);
ASSERT_EQ(u1->defaultDbId, db2->dbId);
// alter u1 to clear out the default_db
alts.default_db = "";
sys_cat.syncUserWithRemoteProvider("u1", {}, alts);
u1 = sys_cat.getUser("u1");
ASSERT_TRUE(u1);
ASSERT_EQ(u1->defaultDbId, -1);
}
TEST(SyncUserWithRemoteProvider, IS_SUPER) {
run_ddl_statement("DROP USER IF EXISTS u1;");
run_ddl_statement("DROP USER IF EXISTS u2;");
ScopeGuard uguard = [] {
run_ddl_statement("DROP USER IF EXISTS u1;");
run_ddl_statement("DROP USER IF EXISTS u2;");
};
Catalog_Namespace::UserAlterations alts;
// create u1 non-super
alts.is_super = false;
sys_cat.syncUserWithRemoteProvider("u1", {}, alts);
auto u1 = sys_cat.getUser("u1");
ASSERT_TRUE(u1);
ASSERT_EQ(u1->isSuper, false);
// alter u1 no-op
alts.is_super = std::nullopt;
sys_cat.syncUserWithRemoteProvider("u1", {}, alts);
u1 = sys_cat.getUser("u1");
ASSERT_TRUE(u1);
ASSERT_EQ(u1->isSuper, false);
// alter u1 super
alts.is_super = true;
sys_cat.syncUserWithRemoteProvider("u1", {}, alts);
u1 = sys_cat.getUser("u1");
ASSERT_TRUE(u1);
ASSERT_EQ(u1->isSuper, true);
// create u2 super
sys_cat.syncUserWithRemoteProvider("u2", {}, alts);
auto u2 = sys_cat.getUser("u2");
ASSERT_TRUE(u2);
ASSERT_EQ(u2->isSuper, true);
// alter u2 non-super
alts.is_super = false;
sys_cat.syncUserWithRemoteProvider("u2", {}, alts);
u2 = sys_cat.getUser("u2");
ASSERT_TRUE(u2);
ASSERT_EQ(u2->isSuper, false);
}
int main(int argc, char* argv[]) {
testing::InitGoogleTest(&argc, argv);
namespace po = boost::program_options;
po::options_description desc("Options");
// these two are here to allow passing correctly google testing parameters
desc.add_options()("gtest_list_tests", "list all tests");
desc.add_options()("gtest_filter", "filters tests, use --help for details");
desc.add_options()("test-help",
"Print all DBObjectPrivilegesTest specific options (for gtest "
"options use `--help`).");
logger::LogOptions log_options(argv[0]);
log_options.max_files_ = 0; // stderr only by default
desc.add(log_options.get_options());
po::variables_map vm;
po::store(po::command_line_parser(argc, argv).options(desc).run(), vm);
po::notify(vm);
if (vm.count("test-help")) {
std::cout << "Usage: DBObjectPrivilegesTest" << std::endl << std::endl;
std::cout << desc << std::endl;
return 0;
}
logger::init(log_options);
QR::init(BASE_PATH);
g_calcite = QR::get()->getCatalog()->getCalciteMgr();
// get dirname of test binary
g_test_binary_file_path = boost::filesystem::canonical(argv[0]).parent_path().string();
int err{0};
try {
testing::AddGlobalTestEnvironment(new DBHandlerTestEnvironment);
err = RUN_ALL_TESTS();
} catch (const std::exception& e) {
LOG(ERROR) << e.what();
}
QR::reset();
return err;
}
|
; A060374: a(n)=p+q, where n=p-q and p, q, p+q are in A005836 (integers written without 2 in base 3).
; Submitted by Christian Krause
; 0,1,4,3,4,13,12,13,10,9,10,13,12,13,40,39,40,37,36,37,40,39,40,31,30,31,28,27,28,31,30,31,40,39,40,37,36,37,40,39,40,121,120,121,118,117,118,121,120,121,112,111,112,109,108,109,112,111,112,121,120,121,118,117,118,121,120,121,94,93,94,91,90,91,94,93,94,85,84,85,82,81,82,85,84,85,94,93,94,91,90,91,94,93,94,121,120,121,118,117
mov $2,1
lpb $0
mov $3,$0
add $0,1
div $0,3
add $3,$0
mod $3,2
mul $3,$2
add $1,$3
mul $2,3
lpe
mov $0,$1
|
; A173263: Successive numbers n such that ChebyshevT[n/2, n] is not an integer.
; 3,5,9,11,13,15,19,21,23,25,27,29,33,35,37,39,41,43,45,47,51,53,55,57,59,61,63,65,67,69,73,75,77,79,81,83,85,87,89,91,93,95,99,101,103,105,107,109,111,113,115,117,119,121,123,125,129,131,133,135,137,139,141,143,145,147,149,151,153,155,157,159,163,165,167,169,171,173,175,177,179,181,183,185,187,189,191,193,195,197,201,203,205,207,209,211,213,215,217,219
mov $1,$0
div $0,2
lpb $0
add $1,1
add $2,1
sub $0,$2
lpe
mov $0,$1
mul $0,2
add $0,3
|
; A091037: Second column (k=5) of array A090214 ((4,4)-Stirling2) divided by 4*4!=96.
; Submitted by Jamie Morken(s3.)
; 1,144,17856,2156544,259117056,31102009344,3732432224256,447896453382144,53747684481171456,6449724779548114944,773967036949154758656,92876045955579714207744
add $0,1
mov $3,1
lpb $0
sub $0,1
add $2,$3
mul $2,24
mul $3,120
lpe
mov $0,$2
div $0,24
|
; Boot headers for multiboot 2
; This lets the OS boot with any multiboot 2 compatible bootloader
; GRUB is the chosen bootloader for its ubiquity
section .multiboot_header
header_start:
dd 0xe85250d6 ; set magic number
dd 0 ; set protected mode
dd header_end - header_start ; set length of the header
; header checksum (0x100000000 - (magic number + mode + length))
dd 0x100000000 - (0xe85250d6 + 0 + (header_end - header_start))
; end tag
dw 0 ; type
dw 0 ; flags
dd 8 ; size
header_end:
|
#include "../../stdafx.h"
#include "IConnection.h"
#include "Connection.h"
namespace Cobalt
{
namespace Poco
{
namespace Connection
{
Connection::Connection():
connected_( false ),
connection_( nullptr ) {
}
bool Connection::isAvailable() const {
return connection_ != nullptr;
}
bool Connection::isConnected() const {
return connected_;
}
void __stdcall Connection::setConnected(const bool connected) {
connected_ = connected;
}
#pragma warning(disable:4244) //C4244 преобразование "uint64_t" в "std::size_t", возможна потеря данных
size_t __stdcall Connection::parseDate( const char* buffer, const size_t size ) {
return connection_->parse( buffer, size );
}
#pragma warning(default:4244)
void Connection::setConnection( AMQP::Connection* const connection ) {
connection_ = connection;
}
bool Connection::closeConnection() {
return connection_->close();
}
}
}
}
|
.global s_prepare_buffers
s_prepare_buffers:
push %r12
push %r9
push %rax
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_A_ht+0x1822b, %rsi
lea addresses_A_ht+0x532b, %rdi
nop
nop
nop
nop
nop
add $6503, %r12
mov $25, %rcx
rep movsb
nop
nop
cmp $48594, %r9
lea addresses_UC_ht+0x1c7f3, %rax
nop
nop
nop
nop
nop
sub $13280, %rdx
mov (%rax), %di
nop
xor $52704, %r12
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rax
pop %r9
pop %r12
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r12
push %r14
push %r9
push %rbx
push %rsi
// Store
mov $0x37248400000006ab, %r9
nop
nop
nop
nop
dec %r12
movl $0x51525354, (%r9)
inc %r14
// Faulty Load
lea addresses_normal+0xef2b, %r11
nop
nop
xor $8020, %r14
mov (%r11), %r12
lea oracles, %r9
and $0xff, %r12
shlq $12, %r12
mov (%r9,%r12,1), %r12
pop %rsi
pop %rbx
pop %r9
pop %r14
pop %r12
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 32, 'type': 'addresses_normal', 'congruent': 0}}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 4, 'type': 'addresses_NC', 'congruent': 7}, 'OP': 'STOR'}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'NT': False, 'AVXalign': False, 'size': 8, 'type': 'addresses_normal', 'congruent': 0}}
<gen_prepare_buffer>
{'dst': {'same': False, 'congruent': 9, 'type': 'addresses_A_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 6, 'type': 'addresses_A_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_UC_ht', 'congruent': 3}}
{'34': 6656}
34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34
*/
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r14
push %r15
push %r8
push %r9
push %rcx
push %rdi
push %rsi
lea addresses_WT_ht+0xef3b, %r14
nop
nop
nop
nop
sub %r15, %r15
movups (%r14), %xmm0
vpextrq $0, %xmm0, %r8
inc %rdi
lea addresses_normal_ht+0xc323, %rsi
lea addresses_UC_ht+0xe155, %rdi
nop
nop
nop
and %r10, %r10
mov $40, %rcx
rep movsq
nop
nop
add $26315, %r15
lea addresses_normal_ht+0xc633, %r15
nop
nop
xor $15289, %rcx
mov (%r15), %r10d
nop
nop
nop
nop
nop
xor $20083, %r15
lea addresses_WT_ht+0x179e3, %r8
nop
nop
nop
nop
xor %rsi, %rsi
mov $0x6162636465666768, %r14
movq %r14, (%r8)
nop
add $63513, %rsi
lea addresses_D_ht+0x121e7, %r15
nop
nop
nop
and %r8, %r8
mov (%r15), %r14w
nop
nop
nop
sub %rsi, %rsi
lea addresses_WC_ht+0x11843, %rsi
lea addresses_WT_ht+0x1e323, %rdi
clflush (%rdi)
nop
nop
nop
nop
xor $35032, %r9
mov $80, %rcx
rep movsq
nop
nop
nop
mfence
lea addresses_D_ht+0x303, %rsi
lea addresses_UC_ht+0xef23, %rdi
clflush (%rdi)
nop
nop
xor $56907, %r15
mov $0, %rcx
rep movsq
nop
nop
inc %r14
pop %rsi
pop %rdi
pop %rcx
pop %r9
pop %r8
pop %r15
pop %r14
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r14
push %r8
push %rax
push %rcx
push %rdi
// Load
lea addresses_UC+0x1f033, %r8
nop
nop
nop
and $31840, %rax
vmovups (%r8), %ymm5
vextracti128 $1, %ymm5, %xmm5
vpextrq $0, %xmm5, %rcx
cmp %rax, %rax
// Faulty Load
mov $0x28e6f20000000323, %r14
nop
nop
nop
nop
nop
sub %rdi, %rdi
movups (%r14), %xmm2
vpextrq $0, %xmm2, %r11
lea oracles, %r14
and $0xff, %r11
shlq $12, %r11
mov (%r14,%r11,1), %r11
pop %rdi
pop %rcx
pop %rax
pop %r8
pop %r14
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'src': {'same': False, 'congruent': 0, 'NT': False, 'type': 'addresses_NC', 'size': 4, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'same': False, 'congruent': 4, 'NT': False, 'type': 'addresses_UC', 'size': 32, 'AVXalign': False}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'same': True, 'congruent': 0, 'NT': False, 'type': 'addresses_NC', 'size': 16, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'same': False, 'congruent': 3, 'NT': False, 'type': 'addresses_WT_ht', 'size': 16, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_normal_ht', 'congruent': 11, 'same': True}, 'OP': 'REPM', 'dst': {'type': 'addresses_UC_ht', 'congruent': 0, 'same': False}}
{'src': {'same': False, 'congruent': 3, 'NT': False, 'type': 'addresses_normal_ht', 'size': 4, 'AVXalign': False}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 5, 'NT': False, 'type': 'addresses_WT_ht', 'size': 8, 'AVXalign': False}}
{'src': {'same': True, 'congruent': 2, 'NT': False, 'type': 'addresses_D_ht', 'size': 2, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WC_ht', 'congruent': 5, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WT_ht', 'congruent': 10, 'same': False}}
{'src': {'type': 'addresses_D_ht', 'congruent': 3, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_UC_ht', 'congruent': 10, 'same': False}}
{'00': 21829}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
|
;
; Enterprise 64/128 specific routines
; by Stefano Bodrato, 2011
;
; set_exos_variable(unsigned char variable, unsigned char value);
;
;
; $Id: set_exos_variable_callee.asm,v 1.5 2016-06-19 20:17:32 dom Exp $
;
SECTION code_clib
PUBLIC set_exos_variable_callee
PUBLIC _set_exos_variable_callee
PUBLIC ASMDISP_SET_EXOS_VARIABLE_CALLEE
set_exos_variable_callee:
_set_exos_variable_callee:
pop hl
pop de
ex (sp),hl
; enter : e = unsigned char value
; l = unsigned char variable
.asmentry
ld b,1 ; SET mode
ld c,l ; Variable
ld d,e ; Value
rst 30h
defb 16 ; SET_GET_EXOS_VARIABLE
ld h,0
ld l,d
ret
DEFC ASMDISP_SET_EXOS_VARIABLE_CALLEE = asmentry - set_exos_variable_callee
|
copyright zengfr site:http://github.com/zengfr/romhack
00146E movea.w (A4)+, A1 [base+2F4]
001474 subq.w #1, ($306,A5) [base+2F4]
001540 move.w A0, -(A4) [base+2F4]
001546 addq.w #1, ($306,A5) [base+2F4]
01A822 move.w A6, ($2f4,A5) [base+306]
01A826 lea ($99c,A5), A0 [base+2F4]
copyright zengfr site:http://github.com/zengfr/romhack
|
.model small
.data
msg_1 db 10,13,'Enter the Number: $'
msg_2 db 10,13,'0 1 $'
num dw ?
a dw 0h
b dw 01h
.code
mov AX,@data
mov DS,AX
lea DX,msg_1
call printf
call read_8bit
mov cx,num ;counter till nth number
sub cx,02h ;decrement by 2 as first 2 are printed
lea DX,msg_2
call printf
loop1: ;Fibonacci loop
mov AX,a ;temporarily assigning to REG
add AX,b ;a = a + b ; c = AX
mov a,AX ;restoring a as c
mov DI,CX ;storing the counter temporarily in DI
mov DX,AX ;stored in DL to print Number
call print_8bit ;display nth number
mov AX,a
XCHG AX,b ;a=b and b=a(which is c)
mov a,AX
mov CX,DI ;restoring counter
loop loop1
mov AH,4Ch
int 21h
;procedure to display 8 bit character in decimal value in DL
print_8bit proc near
mov ax,0000h
mov al,dl
mov bx,0010d
mov CX,0000h
Loop_push:
mov DX,0000h
div BX
push DX
inc CX
cmp AX,0000h
JNE Loop_push
Loop_pop:
pop DX
add dx,0030h ;converting the number to ASCII value
mov ah,02h ;character display
int 21h
loop Loop_pop
mov dl,' ' ;printing space
mov ah,02h
int 21h
ret
print_8bit endp
;procedure to read 8 bit numbers & store in AL
read_8bit proc near
mov AH,01h ;reading 1st nibble
int 21h
sub AL,30h
mov BL,AL
mov AH,01h ;reading 2nd Nibble
int 21h
sub AL,30h
mov AH,BL
AAD ;ASCCI adjust before division
mov num,AX
ret
read_8bit endp
;procedure to print message
printf proc near
mov AH,09h
int 21h
ret
printf endp
end
|
/**
* bmc API generated from bmc.yang
*
* NOTE: This file is auto generated by polycube-codegen
* https://github.com/polycube-network/polycube-codegen
*/
/* Do not edit this file manually */
#include "PortsBase.h"
#include "../Bmc.h"
PortsBase::PortsBase(polycube::service::Cube<Ports> &parent,
std::shared_ptr<polycube::service::PortIface> port)
: Port(port), parent_(dynamic_cast<Bmc &>(parent)) {}
PortsBase::~PortsBase() {}
void PortsBase::update(const PortsJsonObject &conf) {
set_conf(conf.getBase());
}
PortsJsonObject PortsBase::toJsonObject() {
PortsJsonObject conf;
conf.setBase(to_json());
conf.setName(getName());
return conf;
}
std::shared_ptr<spdlog::logger> PortsBase::logger() {
return parent_.logger();
}
|
.global s_prepare_buffers
s_prepare_buffers:
push %r14
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_D_ht+0x1c8b3, %rsi
lea addresses_WC_ht+0x16eb3, %rdi
nop
nop
nop
xor $54717, %r14
mov $84, %rcx
rep movsb
nop
nop
nop
nop
nop
sub $45437, %r14
lea addresses_A_ht+0x16b3, %rsi
lea addresses_WT_ht+0x55b3, %rdi
nop
cmp %rbp, %rbp
mov $59, %rcx
rep movsb
nop
dec %r14
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %r14
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r13
push %r14
push %r15
push %r8
push %r9
push %rdx
// Load
lea addresses_normal+0x1275f, %r14
nop
add %r15, %r15
movntdqa (%r14), %xmm6
vpextrq $0, %xmm6, %rdx
dec %r15
// Store
lea addresses_D+0x15713, %r8
nop
nop
nop
nop
nop
add %r10, %r10
mov $0x5152535455565758, %r14
movq %r14, (%r8)
nop
add %r14, %r14
// Store
lea addresses_UC+0x1c5b3, %r8
nop
nop
nop
nop
add $36806, %rdx
movb $0x51, (%r8)
nop
nop
nop
nop
cmp %r14, %r14
// Load
lea addresses_UC+0x3cb3, %r10
nop
add %r13, %r13
mov (%r10), %edx
nop
nop
nop
and %r14, %r14
// Faulty Load
lea addresses_D+0x1d4b3, %r15
nop
nop
sub $32145, %r9
mov (%r15), %r14
lea oracles, %r13
and $0xff, %r14
shlq $12, %r14
mov (%r13,%r14,1), %r14
pop %rdx
pop %r9
pop %r8
pop %r15
pop %r14
pop %r13
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 1, 'type': 'addresses_D', 'congruent': 0}}
{'OP': 'LOAD', 'src': {'same': False, 'NT': True, 'AVXalign': False, 'size': 16, 'type': 'addresses_normal', 'congruent': 1}}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 8, 'type': 'addresses_D', 'congruent': 4}, 'OP': 'STOR'}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 1, 'type': 'addresses_UC', 'congruent': 7}, 'OP': 'STOR'}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 4, 'type': 'addresses_UC', 'congruent': 11}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'NT': False, 'AVXalign': False, 'size': 8, 'type': 'addresses_D', 'congruent': 0}}
<gen_prepare_buffer>
{'dst': {'same': False, 'congruent': 8, 'type': 'addresses_WC_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 10, 'type': 'addresses_D_ht'}}
{'dst': {'same': False, 'congruent': 7, 'type': 'addresses_WT_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 8, 'type': 'addresses_A_ht'}}
{'36': 22}
36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36
*/
|
.include "defaults_request.asm"
table_file_jp equ "exe6-utf8.tbl"
table_file_en equ "bn6-utf8.tbl"
game_code_len equ 3
game_code equ 0x4252354A // BR5J
game_code_2 equ 0x42523545 // BR5E
game_code_3 equ 0x42523550 // BR5P
card_type equ 4
card_id equ 8
card_no equ "008"
card_sub equ "Request Event Card 008"
card_sub_x equ 32
card_name_jp_full equ "オフィシャルからの依頼"
card_name_jp_game equ "オフィシャルからのいらい"
card_name_en_full equ "Official Request"
card_name_en_game equ "Official Request"
card_desc_len equ 1
card_desc_1 equ "Official Request"
card_desc_2 equ ""
card_desc_3 equ "" |
; A126271: a(n) = order of Galois group of the polynomial P(x) + n if P(x) + n (after dividing by the gcd of its coefficients) is irreducible, otherwise a(n) = 0, where P(x) = 128*x^8 - 256*x^6 + 160*x^4 - 32*x^2 + 1.
; 32,32,16,32,32,32,32,32,32,16,32,32,32,16,32,32,32,32,32,32,32,32,32,32,32,32,16,16,32,32,32
seq $0,46899 ; Triangle in which n-th row is {binomial(n+k,k), k=0..n}, n >= 0.
pow $0,2
mod $0,11
mod $0,2
mul $0,16
add $0,16
|
; A136289: Start with three pennies touching each other on a tabletop. In each generation, add pennies subject to the rule that a penny can be placed only when (at least) two pennies are already in position to determine its position; sequence gives number of pennies added at generation n.
; 3,3,6,9,9,12,15,15,18,21,21,24,27,27,30,33,33,36,39,39,42,45,45,48,51,51,54,57,57,60,63,63,66,69,69,72,75,75,78,81,81,84,87,87,90,93,93,96,99,99,102,105,105,108,111,111,114,117,117,120,123,123,126,129,129,132
mul $0,2
div $0,3
mov $1,$0
mul $1,3
add $1,3
|
; A199706: Number of -n..n arrays x(0..3) of 4 elements with zero sum and no two neighbors equal.
; 8,52,168,380,724,1236,1940,2872,4068,5552,7360,9528,12080,15052,18480,22388,26812,31788,37340,43504,50316,57800,65992,74928,84632,95140,106488,118700,131812,145860,160868,176872,193908,212000,231184,251496
mov $2,$0
cal $0,1860 ; Number of series-reduced planted trees with n+9 nodes and 4 internal nodes.
mov $1,$0
add $1,$2
mul $1,2
add $0,$1
mov $1,$0
mul $1,4
add $1,8
|
; Day - 20 Date- 01 May,2021
; problem - print Inverted right triangle of numbers where input(0~9)
.model small
.stack 100h
include 'emu8086.inc'
.data
msg db "input only number 0~9 $"
n_line db 0ah,0dh,"$" ;for new line
i db ?
.code
main proc
mov ax,@data
mov ds,ax
@input:
lea dx,msg
mov ah,9
int 21h
mov ah,1
int 21h
sub al,48
cmp al,0
je @stop
printn
@outer_loop_init:
mov i,al
@outer_loop:
cmp i,1d
jl @stop
@inner_loop_init:
xor bx,bx ;clearing bx register
mov bl,1d
@inner_loop:
cmp bl,i
jg @inner_loop_exit
mov dl,bl
add dl,48
mov ah,2
int 21h
mov dl,32
mov ah,2
int 21h
inc bl
jmp @inner_loop
@inner_loop_exit:
lea dx,n_line
mov ah,9
int 21h
dec i
jmp @outer_loop
lea dx,n_line ;print new line
mov ah,9
int 21h
@stop:
mov ah,4ch
int 21h ;terminate with return code
main endp
end main
|
mov ax, 0xb800
mov ds,ax
mov byte[0],'H'
halt:
jmp halt
times 510-($-$$) db 0
db 0x55,0xaa |
assume cs:code, ds:data, ss:stack
code segment
start:mov ax, stack
mov ss, ax
mov sp, 16
mov ax, data
mov ds, ax
push ds:[0]
push ds:[2]
pop ds:[2]
pop ds:[0]
mov ax, 4c00h
int 21h
code ends
data segment
dw 0123h, 0456h
data ends
stack segment
dw 0,0
stack ends
end start |
.gba
.thumb
.open "rom.gba", "test.gba", 0x08000000
// -----------------------------------------------------------------------------
.org allocation
.area allocation_size
.importobj "build/linked.o"
.endarea
// -----------------------------------------------------------------------------
.if INSERT_INGAME_TRADE_HACK
.org 0x08053B48
.area 0x15A, 0xFE
ldr r3, =_CreateInGameTradePokemon |1
bx r3
.pool
.endarea
// skip over constants in the middle of the function
.org 0x08053CB4
.fill 0x1A, 0xFE
.endif
// -----------------------------------------------------------------------------
SIZEOF_INGAME_TRADE equ 0x3C
.org readu32("rom.gba", sInGameTradesPtr & 0x1FFFFFF)
.area NUM_INGAME_TRADES * SIZEOF_INGAME_TRADE
.importobj "build/src/sInGameTrades.o"
.endarea
// -----------------------------------------------------------------------------
.close
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %r12
push %r14
push %rbp
lea addresses_WC_ht+0x1ed74, %r11
nop
nop
nop
nop
nop
and $28745, %r10
mov $0x6162636465666768, %r14
movq %r14, (%r11)
nop
nop
nop
and $45067, %r11
lea addresses_normal_ht+0x1c574, %r12
nop
inc %rbp
mov (%r12), %r10d
and %r12, %r12
pop %rbp
pop %r14
pop %r12
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r14
push %r15
push %rbp
push %rcx
push %rdx
// Faulty Load
lea addresses_PSE+0xe574, %r11
nop
cmp $51770, %r15
vmovups (%r11), %ymm3
vextracti128 $1, %ymm3, %xmm3
vpextrq $0, %xmm3, %rcx
lea oracles, %r11
and $0xff, %rcx
shlq $12, %rcx
mov (%r11,%rcx,1), %rcx
pop %rdx
pop %rcx
pop %rbp
pop %r15
pop %r14
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_PSE', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_PSE', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 11, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_normal_ht', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 11, 'same': False}}
{'33': 1275}
33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33
*/
|
#include <iostream>
using namespace std;
int divisiable(int n, int a, int b){
int c1=n/a;
int c2=n/b;
int c3=n/(a*b);
return c1+c2-c3;
}
int main()
{
int n, a, b;
cin>>n>>a>>b;
cout<<divisiable(n,a,b)<<endl;
return 0;
}
|
; A173384: a(n) = A001803(n) - A046161(n).
; Submitted by Jon Maiga
; 0,1,7,19,187,437,1979,4387,76627,165409,707825,1503829,12706671,26713417,111868243,233431331,7770342787,16124087129,66765132341,137948422657,1138049013461,2343380261227,9636533415373,19787656251221,324664400940311,665130127685341,2722510327359877,5566704368822761,45489721275677143,92858646707575601,378826123178106243,772196882395439395,50336912543779416547,102478682196062899529,417027989153061742301,848079263033206340281,6895262239334859917049,14008790799211673110327,56896740777933350110633
seq $0,172060 ; The number of returns to the origin in all possible one-dimensional walks of length 2n.
lpb $0
dif $0,2
lpe
|
#include <iostream>
#include <string>
#include <jsoncons/json.hpp>
#include "protocol.h"
#include "connection.h"
#include "game_logic.h"
using namespace hwo_protocol;
void run(hwo_connection& connection, const std::string& name,
const std::string& key, const std::string& track = "", const std::string& pwd = "", const std::string& carcount = "")
{
game_logic game;
if (track == "")
connection.send_requests({ make_join(name, key) });
else if (pwd == "")
connection.send_requests({ make_create_single(name, key, track) });
else
connection.send_requests({ make_join_race(name, key, track, pwd, carcount) });
for (;;)
{
boost::system::error_code error;
auto response = connection.receive_response(error);
if (error == boost::asio::error::eof)
{
std::cout << "Connection closed" << std::endl;
break;
}
else if (error)
{
throw boost::system::system_error(error);
}
connection.send_requests(game.react(response));
}
}
int main(int argc, const char* argv[])
{
try
{
if (argc < 5 || argc > 8)
{
std::cerr << "Usage: ./run host port botname botkey [trackname] [pwdname ncars]" << std::endl;
std::cerr << "no track/pwd: join, track only: create single, track+pwd+count: joinrace" << std::endl;
return 1;
}
const std::string host(argv[1]);
const std::string port(argv[2]);
const std::string name(argv[3]);
const std::string key(argv[4]);
const std::string track(argc >= 6 ? argv[5] : "");
const std::string pwd(argc >= 7 ? argv[6] : "");
const std::string carcount(argc >= 8 ? argv[7] : "");
std::cout << "Host: " << host << ", port: " << port << ", name: " << name << ", key: " << key << ", track: " << track << ", pwd: " << pwd << ", count: " << carcount << std::endl;
hwo_connection connection(host, port, track);
run(connection, name, key, track, pwd, carcount);
}
catch (const std::exception& e)
{
std::cerr << e.what() << std::endl;
return 2;
}
return 0;
}
|
# Beginning of the data section
.data
i: .word 0
m0: .word 0
n1: .word 0
num_5: .word 5
num_1: .word 1
# Beginning of the code section
.text
lib_exit:
# Callee Convention (entering exit):
sw $s0, -4($sp)
sw $s1, -8($sp)
sw $s2, -12($sp)
sw $s3, -16($sp)
sw $s4, -20($sp)
sw $s5, -24($sp)
sw $s6, -28($sp)
sw $s7, -32($sp)
addi $sp, $sp, -32
sw $ra, -4($sp)
addi $sp, $sp, -4
li $v0, 17
syscall
addi $sp, $sp, 4
lw $ra, -4($sp)
addi $sp, $sp, 32
lw $s0, -4($sp)
lw $s1, -8($sp)
lw $s2, -12($sp)
lw $s3, -16($sp)
lw $s4, -20($sp)
lw $s5, -24($sp)
lw $s6, -28($sp)
lw $s7, -32($sp)
jr $ra
lib_printi:
# Callee Convention (entering printi):
sw $s0, -4($sp)
sw $s1, -8($sp)
sw $s2, -12($sp)
sw $s3, -16($sp)
sw $s4, -20($sp)
sw $s5, -24($sp)
sw $s6, -28($sp)
sw $s7, -32($sp)
addi $sp, $sp, -32
sw $ra, -4($sp)
addi $sp, $sp, -4
li $v0, 1
syscall
addi $sp, $sp, 4
lw $ra, -4($sp)
addi $sp, $sp, 32
lw $s0, -4($sp)
lw $s1, -8($sp)
lw $s2, -12($sp)
lw $s3, -16($sp)
lw $s4, -20($sp)
lw $s5, -24($sp)
lw $s6, -28($sp)
lw $s7, -32($sp)
jr $ra
lib_not:
sw $s0, -4($sp)
sw $s1, -8($sp)
sw $s2, -12($sp)
sw $s3, -16($sp)
sw $s4, -20($sp)
sw $s5, -24($sp)
sw $s6, -28($sp)
sw $s7, -32($sp)
addi $sp, $sp, -32
sw $ra, -4($sp)
addi $sp, $sp, -4
# IR: assign, var0, 0,
la $t0, num_0
lw $t1, 0($t0)
move $s8, $t1
# IR: brneq, i1, 0, _if_label0
li $t1, 0
bne $a0, $t1, _if_label0
# IR: assign, var0, 1,
li $t1, 1
move $s8, $t1
_if_label0:
# IR: breq, var0, 0, _if_label1
li $t1, 0
beq $s8, $t1, _if_label1
# IR: assign, i1, 1,
li $t1, 1
move $a0, $t1
# IR: goto, _if_label2, ,
j _if_label2
_if_label1:
# IR: assign, i1, 0,
li $t1, 0
move $a0, $t1
_if_label2:
lib_not_end:
# IR: return, i1, ,
# Callee Convention (exiting not):
move $v0, $a0
addi $sp, $sp, 4
lw $ra, -4($sp)
addi $sp, $sp, 32
lw $s0, -4($sp)
lw $s1, -8($sp)
lw $s2, -12($sp)
lw $s3, -16($sp)
lw $s4, -20($sp)
lw $s5, -24($sp)
lw $s6, -28($sp)
lw $s7, -32($sp)
jr $ra
main:
# IR: assign, m0, 5,
la $t0, num_5
lw $t1, 0($t0)
move $s8, $t1
# IR: goto, main0
j main0
print0:
sw $s0, -4($sp)
sw $s1, -8($sp)
sw $s2, -12($sp)
sw $s3, -16($sp)
sw $s4, -20($sp)
sw $s5, -24($sp)
sw $s6, -28($sp)
sw $s7, -32($sp)
addi $sp, $sp, -32
sw $ra, -4($sp)
addi $sp, $sp, -4
# IR: call, printi, n1
sw $t4, -4($sp)
sw $t5, -8($sp)
sw $t6, -12($sp)
sw $t7, -16($sp)
sw $t8, -20($sp)
sw $t9, -24($sp)
addi $sp, $sp, -24
swc1 $f12, -4($sp)
swc1 $f13, -8($sp)
swc1 $f14, -12($sp)
addi $sp, $sp, -12
sw $a0, -4($sp)
sw $a1, -8($sp)
sw $a2, -12($sp)
sw $a3, -16($sp)
addi $sp, $sp, -16
move $a0, $a0
jal lib_printi
addi $sp, $sp, 16
lw $a0, -4($sp)
lw $a1, -8($sp)
lw $a2, -12($sp)
lw $a3, -16($sp)
addi $sp, $sp, 12
lwc1 $f12, -4($sp)
lwc1 $f13, -8($sp)
lwc1 $f14, -12($sp)
addi $sp, $sp, 24
lw $t4, -4($sp)
lw $t5, -8($sp)
lw $t6, -12($sp)
lw $t7, -16($sp)
lw $t8, -20($sp)
lw $t9, -24($sp)
print0_end:
# IR: return, , ,
# Callee Convention (exiting print0):
addi $sp, $sp, 4
lw $ra, -4($sp)
addi $sp, $sp, 32
lw $s0, -4($sp)
lw $s1, -8($sp)
lw $s2, -12($sp)
lw $s3, -16($sp)
lw $s4, -20($sp)
lw $s5, -24($sp)
lw $s6, -28($sp)
lw $s7, -32($sp)
jr $ra
main0:
sw $s0, -4($sp)
sw $s1, -8($sp)
sw $s2, -12($sp)
sw $s3, -16($sp)
sw $s4, -20($sp)
sw $s5, -24($sp)
sw $s6, -28($sp)
sw $s7, -32($sp)
addi $sp, $sp, -32
sw $ra, -4($sp)
addi $sp, $sp, -4
# IR: call, print, m0
sw $t4, -4($sp)
sw $t5, -8($sp)
sw $t6, -12($sp)
sw $t7, -16($sp)
sw $t8, -20($sp)
sw $t9, -24($sp)
addi $sp, $sp, -24
swc1 $f12, -4($sp)
swc1 $f13, -8($sp)
swc1 $f14, -12($sp)
addi $sp, $sp, -12
sw $a0, -4($sp)
sw $a1, -8($sp)
sw $a2, -12($sp)
sw $a3, -16($sp)
addi $sp, $sp, -16
move $a0, $s8
jal print0
addi $sp, $sp, 16
lw $a0, -4($sp)
lw $a1, -8($sp)
lw $a2, -12($sp)
lw $a3, -16($sp)
addi $sp, $sp, 12
lwc1 $f12, -4($sp)
lwc1 $f13, -8($sp)
lwc1 $f14, -12($sp)
addi $sp, $sp, 24
lw $t4, -4($sp)
lw $t5, -8($sp)
lw $t6, -12($sp)
lw $t7, -16($sp)
lw $t8, -20($sp)
lw $t9, -24($sp)
# IR: return, , ,
# Callee Convention (exiting main0):
addi $sp, $sp, 4
lw $ra, -4($sp)
addi $sp, $sp, 32
lw $s0, -4($sp)
lw $s1, -8($sp)
lw $s2, -12($sp)
lw $s3, -16($sp)
lw $s4, -20($sp)
lw $s5, -24($sp)
lw $s6, -28($sp)
lw $s7, -32($sp)
jr $ra
|
.loadtable "m12-give-strings/m12-give-table.tbl"
.str "@\creceiver took\n the \citem\n from \csender's stuff." |
; A004515: Generalized nim sum n + n in base 5.
; Submitted by Christian Krause
; 0,2,4,1,3,10,12,14,11,13,20,22,24,21,23,5,7,9,6,8,15,17,19,16,18,50,52,54,51,53,60,62,64,61,63,70,72,74,71,73,55,57,59,56,58,65,67,69,66,68,100,102,104,101,103,110,112,114,111,113,120,122,124,121,123,105,107,109,106,108,115,117,119,116,118,25,27,29,26,28,35,37,39,36,38,45,47,49,46,48,30,32,34,31,33,40,42,44,41,43
mov $3,1
lpb $0
mov $2,$0
div $0,5
mul $2,2
mod $2,5
mul $2,$3
add $1,$2
mul $3,5
lpe
mov $0,$1
|
.text
addi $t1,$0,-1
addi $t2,$t1,-3
addi $t3,$t2,10
addi $t4,$t2,5
addi $t5,$t4,5
addi $t6,$t5,-125
addi $t7,$t7,1235678 |
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r12
push %r14
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_WT_ht+0x3d4d, %rsi
lea addresses_A_ht+0x1676d, %rdi
nop
nop
nop
cmp %rdx, %rdx
mov $74, %rcx
rep movsq
cmp $48860, %r11
lea addresses_WC_ht+0x516d, %rsi
lea addresses_A_ht+0x88d, %rdi
cmp %rdx, %rdx
mov $100, %rcx
rep movsw
nop
dec %rcx
lea addresses_A_ht+0x12395, %r12
clflush (%r12)
nop
nop
nop
nop
nop
and $46510, %rbx
mov $0x6162636465666768, %rsi
movq %rsi, (%r12)
dec %rbx
lea addresses_UC_ht+0x13aed, %rsi
nop
nop
xor $47510, %rdx
mov (%rsi), %r11
nop
nop
add $45677, %r11
lea addresses_A_ht+0x2e45, %rbx
nop
add $29987, %rdi
mov (%rbx), %si
sub %r12, %r12
lea addresses_A_ht+0x266d, %rbx
nop
nop
nop
nop
cmp $31132, %r12
mov $0x6162636465666768, %rcx
movq %rcx, %xmm2
movups %xmm2, (%rbx)
nop
sub %rsi, %rsi
lea addresses_UC_ht+0x1ba24, %rcx
nop
xor $31110, %rdx
movw $0x6162, (%rcx)
nop
nop
nop
nop
and $24536, %r12
lea addresses_WT_ht+0x15177, %rsi
lea addresses_normal_ht+0x996d, %rdi
nop
cmp $20812, %r14
mov $28, %rcx
rep movsw
nop
nop
nop
nop
nop
and %rsi, %rsi
lea addresses_D_ht+0xe07c, %rdx
nop
nop
nop
nop
nop
sub %r14, %r14
mov $0x6162636465666768, %rbx
movq %rbx, %xmm3
and $0xffffffffffffffc0, %rdx
vmovntdq %ymm3, (%rdx)
nop
nop
nop
add $63793, %r12
lea addresses_A_ht+0x176d, %r14
nop
nop
nop
sub $32929, %r11
mov (%r14), %esi
nop
nop
nop
nop
xor %rcx, %rcx
lea addresses_WT_ht+0x416d, %r14
nop
nop
nop
nop
nop
and %rsi, %rsi
mov $0x6162636465666768, %r12
movq %r12, %xmm3
movups %xmm3, (%r14)
nop
nop
nop
nop
nop
add $38718, %r14
lea addresses_WC_ht+0x1636d, %rdi
add $63881, %rdx
movb $0x61, (%rdi)
nop
nop
nop
nop
nop
cmp $7113, %rdi
lea addresses_normal_ht+0x4a99, %rdx
clflush (%rdx)
nop
dec %rsi
movb (%rdx), %r11b
nop
nop
nop
nop
nop
xor $63434, %rdi
lea addresses_UC_ht+0x1946d, %r14
nop
and $1666, %r12
mov (%r14), %rdx
cmp $34056, %r14
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %r14
pop %r12
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r13
push %r8
push %rbx
push %rcx
// Faulty Load
lea addresses_US+0x1cf6d, %r13
nop
nop
nop
nop
cmp %rcx, %rcx
mov (%r13), %bx
lea oracles, %r8
and $0xff, %rbx
shlq $12, %rbx
mov (%r8,%rbx,1), %rbx
pop %rcx
pop %rbx
pop %r8
pop %r13
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': True, 'NT': False, 'AVXalign': False, 'size': 4, 'type': 'addresses_US', 'congruent': 0}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_US', 'congruent': 0}}
<gen_prepare_buffer>
{'dst': {'same': False, 'congruent': 11, 'type': 'addresses_A_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 3, 'type': 'addresses_WT_ht'}}
{'dst': {'same': False, 'congruent': 5, 'type': 'addresses_A_ht'}, 'OP': 'REPM', 'src': {'same': True, 'congruent': 7, 'type': 'addresses_WC_ht'}}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 8, 'type': 'addresses_A_ht', 'congruent': 3}, 'OP': 'STOR'}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 8, 'type': 'addresses_UC_ht', 'congruent': 4}}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_A_ht', 'congruent': 3}}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 16, 'type': 'addresses_A_ht', 'congruent': 5}, 'OP': 'STOR'}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_UC_ht', 'congruent': 0}, 'OP': 'STOR'}
{'dst': {'same': False, 'congruent': 9, 'type': 'addresses_normal_ht'}, 'OP': 'REPM', 'src': {'same': True, 'congruent': 1, 'type': 'addresses_WT_ht'}}
{'dst': {'same': False, 'NT': True, 'AVXalign': False, 'size': 32, 'type': 'addresses_D_ht', 'congruent': 0}, 'OP': 'STOR'}
{'OP': 'LOAD', 'src': {'same': True, 'NT': True, 'AVXalign': False, 'size': 4, 'type': 'addresses_A_ht', 'congruent': 8}}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 16, 'type': 'addresses_WT_ht', 'congruent': 9}, 'OP': 'STOR'}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 1, 'type': 'addresses_WC_ht', 'congruent': 10}, 'OP': 'STOR'}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 1, 'type': 'addresses_normal_ht', 'congruent': 2}}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 8, 'type': 'addresses_UC_ht', 'congruent': 8}}
{'00': 5138}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
|
// Distributed under the MIT License.
// See LICENSE.txt for details.
#pragma once
namespace Poisson {
/// \brief Types of background geometries for the Poisson equation
enum class Geometry {
/// Euclidean (flat) manifold with Cartesian coordinates, i.e. the metric has
/// components \f$\gamma_{ij} = \delta_{ij}\f$ in these coordinates and thus
/// all Christoffel symbols vanish: \f$\Gamma^i_{jk}=0\f$.
FlatCartesian,
/// The manifold is either curved or employs curved coordinates, so
/// non-vanishing Christoffel symbols must be taken into account.
Curved
};
} // namespace Poisson
|
; A314148: Coordination sequence Gal.4.139.2 where G.u.t.v denotes the coordination sequence for a vertex of type v in tiling number t in the Galebach list of u-uniform tilings.
; 1,5,11,16,22,27,33,38,43,49,54,60,65,71,76,81,87,92,98,103,109,114,119,125,130,136,141,147,152,157,163,168,174,179,185,190,195,201,206,212,217,223,228,233,239,244,250,255,261,266
mul $0,38
sub $0,4
div $0,7
mov $1,$0
add $1,1
|
// Copyright (c) 2011-2015 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#define BOOST_TEST_MODULE Reef Test Suite
#include "test_reef.h"
#include "chainparams.h"
#include "consensus/consensus.h"
#include "consensus/validation.h"
#include "key.h"
#include "main.h"
#include "miner.h"
#include "pubkey.h"
#include "random.h"
#include "txdb.h"
#include "txmempool.h"
#include "ui_interface.h"
#include "util.h"
#ifdef ENABLE_WALLET
#include "wallet/db.h"
#include "wallet/wallet.h"
#endif
#include <boost/filesystem.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/thread.hpp>
CClientUIInterface uiInterface; // Declared but not defined in ui_interface.h
CWallet* pwalletMain;
extern bool fPrintToConsole;
extern void noui_connect();
BasicTestingSetup::BasicTestingSetup(const std::string& chainName)
{
ECC_Start();
SetupEnvironment();
SetupNetworking();
fPrintToDebugLog = false; // don't want to write to debug.log file
fCheckBlockIndex = true;
SelectParams(chainName);
noui_connect();
}
BasicTestingSetup::~BasicTestingSetup()
{
ECC_Stop();
}
TestingSetup::TestingSetup(const std::string& chainName) : BasicTestingSetup(chainName)
{
const CChainParams& chainparams = Params();
#ifdef ENABLE_WALLET
bitdb.MakeMock();
#endif
ClearDatadirCache();
pathTemp = GetTempPath() / strprintf("test_reef_%lu_%i", (unsigned long)GetTime(), (int)(GetRand(100000)));
boost::filesystem::create_directories(pathTemp);
mapArgs["-datadir"] = pathTemp.string();
pblocktree = new CBlockTreeDB(1 << 20, true);
pcoinsdbview = new CCoinsViewDB(1 << 23, true);
pcoinsTip = new CCoinsViewCache(pcoinsdbview);
InitBlockIndex(chainparams);
#ifdef ENABLE_WALLET
bool fFirstRun;
pwalletMain = new CWallet("wallet.dat");
pwalletMain->LoadWallet(fFirstRun);
RegisterValidationInterface(pwalletMain);
#endif
nScriptCheckThreads = 3;
for (int i=0; i < nScriptCheckThreads-1; i++)
threadGroup.create_thread(&ThreadScriptCheck);
RegisterNodeSignals(GetNodeSignals());
}
TestingSetup::~TestingSetup()
{
UnregisterNodeSignals(GetNodeSignals());
threadGroup.interrupt_all();
threadGroup.join_all();
#ifdef ENABLE_WALLET
UnregisterValidationInterface(pwalletMain);
delete pwalletMain;
pwalletMain = NULL;
#endif
UnloadBlockIndex();
delete pcoinsTip;
delete pcoinsdbview;
delete pblocktree;
#ifdef ENABLE_WALLET
bitdb.Flush(true);
bitdb.Reset();
#endif
boost::filesystem::remove_all(pathTemp);
}
TestChain100Setup::TestChain100Setup() : TestingSetup(CBaseChainParams::REGTEST)
{
// Generate a 100-block chain:
coinbaseKey.MakeNewKey(true);
CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
for (int i = 0; i < COINBASE_MATURITY; i++)
{
std::vector<CMutableTransaction> noTxns;
CBlock b = CreateAndProcessBlock(noTxns, scriptPubKey);
coinbaseTxns.push_back(b.vtx[0]);
}
}
//
// Create a new block with just given transactions, coinbase paying to
// scriptPubKey, and try to add it to the current chain.
//
CBlock
TestChain100Setup::CreateAndProcessBlock(const std::vector<CMutableTransaction>& txns, const CScript& scriptPubKey)
{
const CChainParams& chainparams = Params();
CBlockTemplate *pblocktemplate = CreateNewBlock(chainparams, scriptPubKey);
CBlock& block = pblocktemplate->block;
// Replace mempool-selected txns with just coinbase plus passed-in txns:
block.vtx.resize(1);
BOOST_FOREACH(const CMutableTransaction& tx, txns)
block.vtx.push_back(tx);
// IncrementExtraNonce creates a valid coinbase and merkleRoot
unsigned int extraNonce = 0;
IncrementExtraNonce(&block, chainActive.Tip(), extraNonce);
while (!CheckProofOfWork(block.GetHash(), block.nBits, chainparams.GetConsensus())) ++block.nNonce;
CValidationState state;
ProcessNewBlock(state, chainparams, NULL, &block, true, NULL);
CBlock result = block;
delete pblocktemplate;
return result;
}
TestChain100Setup::~TestChain100Setup()
{
}
CTxMemPoolEntry TestMemPoolEntryHelper::FromTx(CMutableTransaction &tx, CTxMemPool *pool) {
CTransaction txn(tx);
bool hasNoDependencies = pool ? pool->HasNoInputsOf(tx) : hadNoDependencies;
// Hack to assume either its completely dependent on other mempool txs or not at all
CAmount inChainValue = hasNoDependencies ? txn.GetValueOut() : 0;
return CTxMemPoolEntry(txn, nFee, nTime, dPriority, nHeight,
hasNoDependencies, inChainValue, spendsCoinbase, sigOpCount, lp);
}
void Shutdown(void* parg)
{
exit(0);
}
void StartShutdown()
{
exit(0);
}
bool ShutdownRequested()
{
return false;
}
|
; A205382: s(k)-s(j), where (s(k),s(j)) is the least such pair for which n divides their difference, and s(j)=(2j-1)^2.
; 8,8,24,8,40,24,56,8,72,40,88,24,104,56,120,16,136,72,152,40,168,88,184,24,200,104,216,56,232,120,248,32,264,136,280,72,296,152,312,40,328,168,344,88,360,184,376,48,392,200,408,104,424,216,440,56,456
add $0,1
dif $0,4
dif $0,2
mov $1,$0
mul $1,8
|
//===- FDRRecordConsumer.h - XRay Flight Data Recorder Mode Records -------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "llvm/XRay/FDRRecordConsumer.h"
namespace llvm {
namespace xray {
Error LogBuilderConsumer::consume(std::unique_ptr<Record> R) {
if (!R)
return createStringError(
std::make_error_code(std::errc::invalid_argument),
"Must not call RecordConsumer::consume() with a null pointer.");
Records.push_back(std::move(R));
return Error::success();
}
Error PipelineConsumer::consume(std::unique_ptr<Record> R) {
if (!R)
return createStringError(
std::make_error_code(std::errc::invalid_argument),
"Must not call RecordConsumer::consume() with a null pointer.");
// We apply all of the visitors in order, and concatenate errors
// appropriately.
Error Result = Error::success();
for (auto *V : Visitors)
Result = joinErrors(std::move(Result), R->apply(*V));
return Result;
}
} // namespace xray
} // namespace llvm
|
ORG #FE00
EI
LD B,8
FAD_ML PUSH BC
HALT
HALT
HALT
HALT
LD HL,#5800
LD BC,#300
FAD_LP LD D,(HL)
LD A,D
AND 1+2+4
OR A
JR Z,NODINK
DEC D
NODINK LD A,D
AND 8+16+32
OR A
JR Z,NODPAP
LD A,D
SUB 8
LD D,A
NODPAP LD (HL),D
INC HL
DEC BC
LD A,B
OR C
JR NZ,FAD_LP
POP BC
DJNZ FAD_ML
RET |
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r12
push %r14
push %r15
push %rax
push %rcx
push %rdi
push %rsi
lea addresses_D_ht+0xab17, %rsi
lea addresses_WT_ht+0xc657, %rdi
nop
nop
nop
nop
lfence
mov $34, %rcx
rep movsw
nop
nop
and %rax, %rax
lea addresses_A_ht+0xa94f, %rsi
lea addresses_WT_ht+0x13487, %rdi
nop
nop
inc %r15
mov $114, %rcx
rep movsw
nop
nop
nop
add %r12, %r12
lea addresses_normal_ht+0x14417, %rsi
clflush (%rsi)
nop
nop
nop
and $37765, %r14
movb $0x61, (%rsi)
nop
cmp %rdi, %rdi
lea addresses_WC_ht+0x8617, %r12
clflush (%r12)
nop
nop
add $20373, %rsi
movw $0x6162, (%r12)
nop
nop
inc %r15
lea addresses_WC_ht+0x15217, %rsi
lea addresses_WC_ht+0x4c17, %rdi
clflush (%rsi)
nop
nop
nop
nop
nop
add $40499, %r10
mov $49, %rcx
rep movsw
nop
nop
nop
cmp $32142, %rsi
lea addresses_WT_ht+0x12617, %rsi
nop
nop
dec %rcx
mov (%rsi), %r12d
nop
and %rax, %rax
pop %rsi
pop %rdi
pop %rcx
pop %rax
pop %r15
pop %r14
pop %r12
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r15
push %rbp
push %rbx
push %rcx
push %rdi
push %rsi
// Store
lea addresses_WC+0x18657, %r15
nop
and $31815, %rsi
movl $0x51525354, (%r15)
nop
nop
nop
nop
xor $27696, %r11
// Faulty Load
lea addresses_US+0x2617, %rbx
nop
nop
nop
cmp $34340, %rcx
movups (%rbx), %xmm2
vpextrq $0, %xmm2, %rbp
lea oracles, %rsi
and $0xff, %rbp
shlq $12, %rbp
mov (%rsi,%rbp,1), %rbp
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %r15
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_US', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WC', 'NT': False, 'AVXalign': True, 'size': 4, 'congruent': 6}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'type': 'addresses_US', 'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'REPM', 'src': {'same': False, 'congruent': 7, 'type': 'addresses_D_ht'}, 'dst': {'same': False, 'congruent': 5, 'type': 'addresses_WT_ht'}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 0, 'type': 'addresses_A_ht'}, 'dst': {'same': False, 'congruent': 4, 'type': 'addresses_WT_ht'}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_normal_ht', 'NT': False, 'AVXalign': True, 'size': 1, 'congruent': 8}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WC_ht', 'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 8}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 10, 'type': 'addresses_WC_ht'}, 'dst': {'same': False, 'congruent': 9, 'type': 'addresses_WC_ht'}}
{'OP': 'LOAD', 'src': {'same': True, 'type': 'addresses_WT_ht', 'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 10}}
{'00': 9}
00 00 00 00 00 00 00 00 00
*/
|
TITLE STRINGFP - Floating Point String Functions
PAGE 56,132
;***
; STRINGFP - Floating Point ST$ functions
;
; Copyright <C> 1986, Microsoft Corporation
;
;Purpose:
;
; BASIC Syntax mapping to included runtime entry points:
;
;
; - STR$ Function -
;
; v$ = STR$(x)
;
; Examples:
;
; v$ = STR$(b@) v$ = STR$(a!) v$ = STR$(x#)
; | | |
; B$STCY B$STR4 B$STR8
;
;
;****
INCLUDE switch.inc
INCLUDE rmacros.inc
useSeg _DATA
USESEG _BSS
useSeg ST_TEXT
INCLUDE seg.inc
INCLUDE rtps.inc
INCLUDE baslibma.inc
sBegin ST_TEXT
ASSUMES CS,ST_TEXT
externNP B$FloatCONASC ;Pull in floating point conversion routines
externNP B$STR_COMMON ;Common support for STR$
SUBTTL STR$ - Create String from number
PAGE
;***
;B$STR4, B$STR8, B$STCY - STR$ function support
;
;Purpose:
; Runtime Entry Points
; Create a string representing the number in ASCII
;
;Entry:
; parameter value is on the stack (R4, R8 or CY)
;
;Exit:
; AX = Address of string descriptor
;
;Uses:
; Per Convention
;
;Exceptions:
; Out of memory
;****
cProc B$STR4,<PUBLIC,FAR>
parmD arg4
cBegin
MOV AL,VT_R4
LEA BX,arg4
cCall B$STR_COMMON
cEnd
cProc B$STR8,<PUBLIC,FAR>
ParmQ R8Arg
cBegin
MOV AL,VT_R8 ;AL = data type
LEA BX,R8Arg ;BX = ptr to data
cCall B$STR_COMMON ;call common routine to convert
cEnd
sEND ST_TEXT
END
|
; Wonderswan test
%include "Wonderswan.inc"
%macro memcopy 4
xor ax,ax
mov es,ax
mov di,%1
mov ax,%2
mov ds,ax
mov si,%3
mov cx,%4
cld
rep movsw
%endmacro
; ================================
section .bss start=0
section .data vfollows=.text
section .text start=0 vstart=0x0F0000
ProgramStart:
cli
xor ax,ax
mov bx,ax
mov cx,ax
mov dx,ax
mov es,ax
out REG_DISP_CTRL,ax
out REG_LCD_CTRL,ax
mov al,0b11100000
out REG_DISP_MODE,ax
xor ax,ax
out REG_SCR1_X,ax
out REG_SCR1_Y,ax
out REG_SCR2_X,ax
out REG_SCR2_Y,ax
out REG_MAP_BASE,al
mov al,DispCtrl_SCR1On
out REG_DISP_CTRL,al
mov al,LCDIcon_BigCircle
out REG_LCD_ICON,al
in al,REG_LCD_CTRL
or al,0b00000001
out REG_LCD_CTRL,al
call DS_Init
mov si,DS_TestSong
call DS_Load
MainLoop:
call DS_Update
push ax
call WaitVBlank
pop ax
inc ax
and ax,0xFF
jmp MainLoop
WaitFrames:
pusha
call WaitVBlank
popa
loop WaitFrames
ret
WaitVBlank:
mov al,100
call WaitLine
mov al,144
WaitLine:
mov bl,al
mov dx,REG_LINE_CUR
.loop:
in al,dx
cmp al,bl
jne .loop
ret
%include "DevSound.asm"
section .footer start=0xFFF0 vstart=0x0FFFF0
CartridgeFooter:
jmp 0xF000:ProgramStart
db 0 ; reserved
db 0 ; developer ID
db 0 ; color support
db 0 ; game ID
db 0 ; reserved
db 2 ; cartridge size
db 0 ; SRAM size
db ROMSPEED_1CYCLE | ORIENTATION_HORIZONTAL
db 0 ; additional capabilities
dw 0 ; checksum
|
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r15
push %r9
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_D_ht+0x15364, %r11
and %rbx, %rbx
mov $0x6162636465666768, %r15
movq %r15, %xmm1
movups %xmm1, (%r11)
nop
nop
nop
nop
dec %rsi
lea addresses_A_ht+0xa1d5, %rsi
lea addresses_A_ht+0x659a, %rdi
nop
nop
nop
inc %r9
mov $22, %rcx
rep movsl
nop
nop
nop
cmp %r9, %r9
lea addresses_WC_ht+0x1c39a, %rcx
add $2678, %r15
movb (%rcx), %r9b
nop
nop
nop
nop
nop
inc %rbx
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %r9
pop %r15
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r13
push %r14
push %r8
push %rax
push %rbp
push %rsi
// Load
lea addresses_A+0x9de2, %rsi
nop
nop
nop
cmp %r8, %r8
mov (%rsi), %r12d
xor $32990, %rsi
// Store
lea addresses_A+0x1fc9a, %r12
nop
nop
xor %r13, %r13
movw $0x5152, (%r12)
nop
nop
nop
nop
nop
add %rax, %rax
// Store
mov $0x62a, %r13
nop
nop
nop
nop
nop
add $57875, %rax
movb $0x51, (%r13)
nop
nop
nop
nop
nop
cmp %rbp, %rbp
// Store
lea addresses_WC+0x971a, %r14
nop
nop
nop
nop
add %r13, %r13
mov $0x5152535455565758, %r8
movq %r8, (%r14)
nop
nop
nop
nop
nop
xor $35887, %rbp
// Faulty Load
lea addresses_WT+0xfb9a, %rbp
nop
nop
cmp $24128, %r8
movb (%rbp), %r12b
lea oracles, %r14
and $0xff, %r12
shlq $12, %r12
mov (%r14,%r12,1), %r12
pop %rsi
pop %rbp
pop %rax
pop %r8
pop %r14
pop %r13
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'src': {'congruent': 0, 'AVXalign': False, 'same': False, 'size': 1, 'NT': False, 'type': 'addresses_WT'}, 'OP': 'LOAD'}
{'src': {'congruent': 3, 'AVXalign': False, 'same': False, 'size': 4, 'NT': False, 'type': 'addresses_A'}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'congruent': 8, 'AVXalign': False, 'same': False, 'size': 2, 'NT': False, 'type': 'addresses_A'}}
{'OP': 'STOR', 'dst': {'congruent': 4, 'AVXalign': False, 'same': False, 'size': 1, 'NT': False, 'type': 'addresses_P'}}
{'OP': 'STOR', 'dst': {'congruent': 7, 'AVXalign': False, 'same': False, 'size': 8, 'NT': False, 'type': 'addresses_WC'}}
[Faulty Load]
{'src': {'congruent': 0, 'AVXalign': True, 'same': True, 'size': 1, 'NT': False, 'type': 'addresses_WT'}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'congruent': 1, 'AVXalign': False, 'same': False, 'size': 16, 'NT': False, 'type': 'addresses_D_ht'}}
{'src': {'congruent': 0, 'same': False, 'type': 'addresses_A_ht'}, 'OP': 'REPM', 'dst': {'congruent': 9, 'same': True, 'type': 'addresses_A_ht'}}
{'src': {'congruent': 8, 'AVXalign': False, 'same': False, 'size': 1, 'NT': True, 'type': 'addresses_WC_ht'}, 'OP': 'LOAD'}
{'00': 21829}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
|
# $s0 = base
main:
lui $s0, 0x1004 # base = 0x10040000
jal input # input()
jal sort # sort()
li $v0, 10 # $v0 = 10
syscall # exit
# $s1 = n, $s2 = i
sort:
subi $sp, $sp, 4 # alloc
sw $ra, ($sp) # store $ra
subi $s1, $s1, 1 # n -= 1
subi $s2, $s1, 1 # i = n - 1
srl $s2, $s2, 1 # i /= 2
for:
sge $t0, $s2, 0 # $t0 = i >= 0
beqz $t0, while1 # if ($t0 == 0) while1()
move $a0, $s2 # $a0 = i
move $a1, $s1 # $a1 = n
jal fixHeap # fixHeap (i, n)
subi $s2, $s2, 1 # i -= 1
j for
while1:
sgt $t0, $s1, 0 # $t0 = n > 0
beqz $t0, done1 # if ($t0 == 0) done1()
li $a0, 0 # $a0 = 0
move $a1, $s1 # $a1 = n
jal swap # swap(0, n)
subi $s1, $s1, 1 # n -= 1
move $a1, $s1 # $a1 = n
jal fixHeap # fixHeap(0, n)
j while1
done1:
lw $ra, ($sp) # load $ra
addi $sp, $sp, 4 # free
jr $ra # return
# $s0 = base, $s3 = index, $s4 = rootValue, $s5 = leftChildIndex, $s6 = rightChildIndex
fixHeap:
subi $sp, $sp, 4 # alloc
sw $ra, ($sp) # store $ra
move $s3, $a0 # index = rootIndex
sll $t0, $s3, 2 # $t0 = index * 4
add $t0, $t0, $s0 # $t0 = &arr[index]
lw $s4, ($t0) # rootValue = arr[index]
while2:
move $a0, $s3 # $a0 = index
jal getLeftChildIndex # getLeftChildIndex(index)
move $s5, $v0 # leftChildIndex = getLeftChildIndex(index)
if1:
sle $t0, $s5, $a1 # $t0 = leftChildIndex <= lastIndex
beqz $t0, done2 # if ($t0 == 0) done2()
jal getRightChildIndex # getRightChildIndex(index)
move $s6, $v0 # rightChildIndex = getRightChildIndex(index)
if2:
sle $t0, $s6, $a1 # $t0 = rightChildIndex <= lastIndex
sll $t1, $s6, 2 # $t1 = rightChildIndex * 4
add $t1, $t1, $s0 # $t1 = &arr[rightChildIndex]
lw $t1, ($t1) # $t1 = arr[rightchildindex]
sll $t2, $s5, 2 # $t2 = leftChildIndex * 4
add $t2, $t2, $s0 # $t2 = &arr[leftChildIndex]
lw $t2, ($t2) # $t2 = arr[leftChildIndex]
sgt $t1, $t1, $t2 # $t1 = $t1 > $t2
and $t0, $t0, $t1 # $t0 = $t0 & $t1
beqz $t0, if3 # if ($t0 == 0) if3()
move $s5, $s6 # leftChildIndex = rightChildIndex
if3:
sll $t0, $s5, 2 # $t0 = leftChildIndex * 4
add $t0, $t0, $s0 # $t0 = &arr[leftChildIndex]
lw $t0, ($t0) # $t0 = arr[leftChildIndex]
sgt $t1, $t0, $s4 # $t1 = arr[leftChildIndex] > rootValue
beqz $t1, done2 # if ($t1 == 0) done2()
sll $t2, $s3, 2 # $t2 = index * 4
add $t2, $t2, $s0 # $t2 = &arr[index]
sw $t0, ($t2) # arr[index] = arr[leftChildIndex]
move $s3, $s5 # index = leftChildIndex
j while2
done2:
sll $t0, $s3, 2 # $t0 = index * 4
add $t0, $t0, $s0 # $t0 = &arr[index]
sw $s4, ($t0) # arr[index] = rootValue
lw $ra, ($sp) # load $ra
addi $sp, $sp, 4 # free
jr $ra # return
|
;--------------------------------------------------------
; Category 7 Function 64 Get event queue status
;--------------------------------------------------------
;
;
;
IOMGETQUESTATUS PROC NEAR
RET
IOMGETQUESTATUS ENDP
|
; A093260: a(n) is the largest number such that all of a(n)'s length-n substrings are distinct and divisible by 60.
; 0,600,96000,9960000,999600000,99996000000,9999960000000,999999600000000,99999996000000000,9999999960000000000,999999999600000000000,99999999996000000000000,9999999999960000000000000,999999999999600000000000000,99999999999996000000000000000
mov $1,10
pow $1,$0
sub $1,2
pow $1,2
div $1,20
mul $1,200
mov $0,$1
|
[bits 32]
[section .text]
INT_VECTOR_SYS_CALL equ 0x80
_NR_LSEEK EQU 14
global lseek
lseek:
mov eax, _NR_LSEEK
mov ebx, [esp + 4]
mov ecx, [esp + 8]
mov edx, [esp + 12]
int INT_VECTOR_SYS_CALL
ret |
#include <Catch.hpp>
#include "polyhook2/PE/EatHook.hpp"
#include "polyhook2/Tests/TestEffectTracker.hpp"
EffectTracker eatEffectTracker;
typedef void(* tEatTestExport)();
tEatTestExport oEatTestExport;
extern "C" __declspec(dllexport) NOINLINE void EatTestExport()
{
}
NOINLINE void hkEatTestExport()
{
eatEffectTracker.PeakEffect().trigger();
}
TEST_CASE("Eat Hook Tests", "[EatHook]") {
SECTION("Verify if export is found and hooked") {
PLH::EatHook hook("EatTestExport", L"", (char*)&hkEatTestExport, (uint64_t*)&oEatTestExport);
REQUIRE(hook.hook());
tEatTestExport pExport = (tEatTestExport)GetProcAddress(GetModuleHandle(nullptr), "EatTestExport");
REQUIRE(pExport);
eatEffectTracker.PushEffect();
pExport();
REQUIRE(eatEffectTracker.PopEffect().didExecute());
REQUIRE(hook.unHook());
}
SECTION("Verify if export is found and hooked when module explicitly named") {
PLH::EatHook hook("EatTestExport", L"Polyhook_2.exe", (char*)&hkEatTestExport, (uint64_t*)&oEatTestExport);
REQUIRE(hook.hook());
tEatTestExport pExport = (tEatTestExport)GetProcAddress(GetModuleHandle(nullptr), "EatTestExport");
REQUIRE(pExport);
eatEffectTracker.PushEffect();
pExport();
REQUIRE(eatEffectTracker.PopEffect().didExecute());
REQUIRE(hook.unHook());
}
}
typedef int(__stdcall* tEatMessageBox)(HWND hWnd,
LPCTSTR lpText,
LPCTSTR lpCaption,
UINT uType);
tEatMessageBox oEatMessageBox;
int __stdcall hkEatMessageBox(HWND hWnd,
LPCTSTR lpText,
LPCTSTR lpCaption,
UINT uType)
{
UNREFERENCED_PARAMETER(lpText);
UNREFERENCED_PARAMETER(lpCaption);
UNREFERENCED_PARAMETER(uType);
UNREFERENCED_PARAMETER(hWnd);
tEatMessageBox MsgBox = (tEatMessageBox)oEatMessageBox;
MsgBox(0, "My Hook", "text", 0);
eatEffectTracker.PeakEffect().trigger();
return 1;
}
TEST_CASE("Eat winapi tests", "[EatHook]") {
LoadLibrary("User32.dll");
PLH::EatHook hook("MessageBoxA", L"User32.dll", (char*)&hkEatMessageBox, (uint64_t*)&oEatMessageBox);
REQUIRE(hook.hook());
eatEffectTracker.PushEffect();
// force walk of EAT
tEatMessageBox MsgBox = (tEatMessageBox)GetProcAddress(GetModuleHandleA("User32.dll"), "MessageBoxA");
MsgBox(0, "test", "test", 0);
REQUIRE(eatEffectTracker.PopEffect().didExecute());
hook.unHook();
}
typedef void(__stdcall* tEatGetSystemTime)(PSYSTEMTIME systemTime);
tEatGetSystemTime oEatGetSystemTime;
void WINAPI hkGetSystemTime(PSYSTEMTIME systemTime)
{
eatEffectTracker.PeakEffect().trigger();
oEatGetSystemTime(systemTime);
}
typedef void(__stdcall* tEatGetLocalTime)(PSYSTEMTIME systemTime);
tEatGetLocalTime oEatGetLocalTime;
void WINAPI hkGetLocalTime(PSYSTEMTIME systemTime)
{
eatEffectTracker.PeakEffect().trigger();
oEatGetLocalTime(systemTime);
}
TEST_CASE("Eat winapi multiple hook", "[EatHook]") {
// These are out of module hooks that require a trampoline stub.
// Multiple hooks can fail if the trampoline region isn't re-used
// across multiple calls. Or if no free block is found at all
PLH::EatHook hook_GST("GetSystemTime", L"kernel32.dll", (char*)&hkGetSystemTime, (uint64_t*)&oEatGetSystemTime);
REQUIRE(hook_GST.hook());
eatEffectTracker.PushEffect();
tEatGetSystemTime GST = (tEatGetSystemTime)GetProcAddress(GetModuleHandleA("kernel32.dll"), "GetSystemTime");
SYSTEMTIME t;
memset(&t, 0, sizeof(t));
GST(&t);
REQUIRE(eatEffectTracker.PopEffect().didExecute());
PLH::EatHook hook_GLT("GetLocalTime", L"kernel32.dll", (char*)&hkGetLocalTime, (uint64_t*)&oEatGetLocalTime);
REQUIRE(hook_GLT.hook());
eatEffectTracker.PushEffect();
tEatGetLocalTime GLT = (tEatGetLocalTime)GetProcAddress(GetModuleHandleA("kernel32.dll"), "GetLocalTime");
memset(&t, 0, sizeof(t));
GLT(&t);
REQUIRE(eatEffectTracker.PopEffect().didExecute());
hook_GLT.unHook();
hook_GST.unHook();
} |
assume cs:code, ds:datasg
datasg segment
db 'BaSic'
db 'iNfOrMaTiOn'
datasg ends
code segment
start:
mov ax, datasg
mov ds, ax
mov bx, 0
mov cx, 5
s: mov dl, ds:[bx]
and dl, 11011111B
mov ds:[bx], dl
inc bx
loop s
mov bx, 5
mov cx, 11
s0: mov dl, ds:[bx]
or dl, 00100000B
mov ds:[bx], dl
inc bx
loop s0
mov ax, 4c00h
int 21h
code ends
end start |
_VictoryRoad1BattleText1::
text "I wonder if you"
line "are good enough"
cont "for me!"
done
_VictoryRoad1EndBattleText1::
text "I"
line "lost out!"
prompt
_VictoryRoad1AfterBattleText1::
text "I never wanted to"
line "lose to anybody!"
done
_VictoryRoad1BattleText2::
text "I can see you're"
line "good! Let me see"
cont "exactly how good!"
done
_VictoryRoad1EndBattleText2::
text "I"
line "had a chance..."
prompt
_VictoryRoad1AfterBattleText2::
text "I concede, you're"
line "better than me!"
done
|
/* TEMPLATE GENERATED TESTCASE FILE
Filename: CWE390_Error_Without_Action__empty_catch_13.cpp
Label Definition File: CWE390_Error_Without_Action__empty_catch.label.xml
Template File: point-flaw-13.tmpl.cpp
*/
/*
* @description
* CWE: 390 Error Without Action
* Sinks:
* GoodSink: Catch and handle the exception if one occurs
* BadSink : Catch, but do not handle the possible exception
* Flow Variant: 13 Control flow: if(GLOBAL_CONST_FIVE==5) and if(GLOBAL_CONST_FIVE!=5)
*
* */
#include "std_testcase.h"
#include <iostream>
#include <stdexcept>
using namespace std;
namespace CWE390_Error_Without_Action__empty_catch_13
{
#ifndef OMITBAD
void bad()
{
if(GLOBAL_CONST_FIVE==5)
{
{
try
{
string stringHello = "hello";
string stringSubstring = stringHello.substr(rand(), rand());
printLine(stringSubstring.c_str());
}
catch (out_of_range &)
{
/* FLAW: Catch, but do not handle the out_of_range error */
}
}
}
}
#endif /* OMITBAD */
#ifndef OMITGOOD
/* good1() uses if(GLOBAL_CONST_FIVE!=5) instead of if(GLOBAL_CONST_FIVE==5) */
static void good1()
{
if(GLOBAL_CONST_FIVE!=5)
{
/* INCIDENTAL: CWE 561 Dead Code, the code below will never run */
printLine("Benign, fixed string");
}
else
{
{
try
{
string stringHello = "hello";
string stringSubstring = stringHello.substr(rand(), rand());
printLine(stringSubstring.c_str());
}
catch (out_of_range &)
{
/* FIX: catch the out_of_range error */
printLine("Range specified was invalid");
exit(1);
}
}
}
}
/* good2() reverses the bodies in the if statement */
static void good2()
{
if(GLOBAL_CONST_FIVE==5)
{
{
try
{
string stringHello = "hello";
string stringSubstring = stringHello.substr(rand(), rand());
printLine(stringSubstring.c_str());
}
catch (out_of_range &)
{
/* FIX: catch the out_of_range error */
printLine("Range specified was invalid");
exit(1);
}
}
}
}
void good()
{
good1();
good2();
}
#endif /* OMITGOOD */
} /* close namespace */
/* Below is the main(). It is only used when building this testcase on
its own for testing or for building a binary to use in testing binary
analysis tools. It is not used when compiling all the testcases as one
application, which is how source code analysis tools are tested. */
#ifdef INCLUDEMAIN
using namespace CWE390_Error_Without_Action__empty_catch_13; /* so that we can use good and bad easily */
int main(int argc, char * argv[])
{
/* seed randomness */
srand( (unsigned)time(NULL) );
#ifndef OMITGOOD
printLine("Calling good()...");
good();
printLine("Finished good()");
#endif /* OMITGOOD */
#ifndef OMITBAD
printLine("Calling bad()...");
bad();
printLine("Finished bad()");
#endif /* OMITBAD */
return 0;
}
#endif
|
dnl Intel Atom mpn_bdiv_q_1, mpn_pi1_bdiv_q_1 -- schoolbook Hensel
dnl division by 1-limb divisor, returning quotient only.
dnl Copyright 2011 Free Software Foundation, Inc.
dnl This file is part of the GNU MP Library.
dnl
dnl The GNU MP Library is free software; you can redistribute it and/or modify
dnl it under the terms of either:
dnl
dnl * the GNU Lesser General Public License as published by the Free
dnl Software Foundation; either version 3 of the License, or (at your
dnl option) any later version.
dnl
dnl or
dnl
dnl * the GNU General Public License as published by the Free Software
dnl Foundation; either version 2 of the License, or (at your option) any
dnl later version.
dnl
dnl or both in parallel, as here.
dnl
dnl The GNU MP Library is distributed in the hope that it will be useful, but
dnl WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
dnl or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
dnl for more details.
dnl
dnl You should have received copies of the GNU General Public License and the
dnl GNU Lesser General Public License along with the GNU MP Library. If not,
dnl see https://www.gnu.org/licenses/.
include(`../config.m4')
MULFUNC_PROLOGUE(mpn_bdiv_q_1 mpn_pi1_bdiv_q_1)
include_mpn(`x86/pentium/bdiv_q_1.asm')
|
; A078642: Numbers with two representations as the sum of two Fibonacci numbers.
; 4,6,10,16,26,42,68,110,178,288,466,754,1220,1974,3194,5168,8362,13530,21892,35422,57314,92736,150050,242786,392836,635622,1028458,1664080,2692538,4356618,7049156,11405774,18454930,29860704,48315634,78176338,126491972,204668310,331160282,535828592,866988874,1402817466,2269806340,3672623806,5942430146,9615053952,15557484098,25172538050,40730022148,65902560198,106632582346,172535142544,279167724890,451702867434,730870592324,1182573459758,1913444052082,3096017511840,5009461563922,8105479075762,13114940639684,21220419715446,34335360355130,55555780070576,89891140425706,145446920496282,235338060921988,380784981418270,616123042340258,996908023758528,1613031066098786,2609939089857314,4222970155956100,6832909245813414
mov $1,4
mov $3,6
lpb $0
sub $0,1
mov $2,$1
mov $1,$3
add $3,$2
lpe
|
// Copyright (c) 2020 The Orbit Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "CaptureWindow.h"
#include "App.h"
#include "Capture.h"
#include "EventTracer.h"
#include "FunctionUtils.h"
#include "GlUtils.h"
#include "absl/strings/str_format.h"
//-----------------------------------------------------------------------------
CaptureWindow::CaptureWindow() {
GCurrentTimeGraph = &time_graph_;
time_graph_.SetTextRenderer(&m_TextRenderer);
time_graph_.SetPickingManager(&m_PickingManager);
time_graph_.SetCanvas(this);
m_DrawUI = false;
m_DrawHelp = true;
m_DrawFilter = false;
m_FirstHelpDraw = true;
m_DrawStats = false;
m_Picking = false;
m_WorldTopLeftX = 0;
m_WorldTopLeftY = 0;
m_WorldMaxY = 0;
m_ProcessX = 0;
m_HoverDelayMs = 300;
m_CanHover = false;
m_IsHovering = false;
ResetHoverTimer();
m_Slider.SetCanvas(this);
m_Slider.SetDragCallback([&](float a_Ratio) { this->OnDrag(a_Ratio); });
m_VerticalSlider.SetCanvas(this);
m_VerticalSlider.SetVertical();
m_VerticalSlider.SetDragCallback(
[&](float a_Ratio) { this->OnVerticalDrag(a_Ratio); });
GOrbitApp->RegisterCaptureWindow(this);
}
//-----------------------------------------------------------------------------
CaptureWindow::~CaptureWindow() {
if (GCurrentTimeGraph == &time_graph_) GCurrentTimeGraph = nullptr;
}
//-----------------------------------------------------------------------------
void CaptureWindow::OnTimer() { GlCanvas::OnTimer(); }
//-----------------------------------------------------------------------------
void CaptureWindow::ZoomAll() {
time_graph_.ZoomAll();
m_WorldTopLeftY = m_WorldMaxY;
ResetHoverTimer();
NeedsUpdate();
}
//-----------------------------------------------------------------------------
void CaptureWindow::UpdateWheelMomentum(float a_DeltaTime) {
GlCanvas::UpdateWheelMomentum(a_DeltaTime);
bool zoomWidth = true; // TODO: !wxGetKeyState(WXK_CONTROL);
if (zoomWidth && m_WheelMomentum != 0.f) {
time_graph_.ZoomTime(m_WheelMomentum, m_MouseRatio);
}
}
//-----------------------------------------------------------------------------
void CaptureWindow::MouseMoved(int a_X, int a_Y, bool a_Left, bool /*a_Right*/,
bool /*a_Middle*/) {
int mousex = a_X;
int mousey = a_Y;
float worldx, worldy;
ScreenToWorld(a_X, a_Y, worldx, worldy);
m_MouseX = worldx;
m_MouseY = worldy;
m_MousePosX = mousex;
m_MousePosY = mousey;
// Pan
if (a_Left && !m_ImguiActive && !m_PickingManager.IsDragging() &&
!Capture::IsCapturing()) {
float worldMin;
float worldMax;
time_graph_.GetWorldMinMax(worldMin, worldMax);
m_WorldTopLeftX =
m_WorldClickX - static_cast<float>(mousex) / getWidth() * m_WorldWidth;
m_WorldTopLeftY = m_WorldClickY +
static_cast<float>(mousey) / getHeight() * m_WorldHeight;
m_WorldTopLeftX = clamp(m_WorldTopLeftX, worldMin, worldMax - m_WorldWidth);
m_WorldTopLeftY =
clamp(m_WorldTopLeftY,
m_WorldHeight - time_graph_.GetThreadTotalHeight(), m_WorldMaxY);
UpdateSceneBox();
time_graph_.PanTime(m_ScreenClickX, a_X, getWidth(),
static_cast<double>(m_RefTimeClick));
UpdateVerticalSlider();
NeedsUpdate();
}
if (m_IsSelecting) {
m_SelectStop = Vec2(worldx, worldy);
m_TimeStop = time_graph_.GetTickFromWorld(worldx);
}
if (a_Left) {
m_PickingManager.Drag(a_X, a_Y);
}
ResetHoverTimer();
NeedsRedraw();
}
//-----------------------------------------------------------------------------
void CaptureWindow::LeftDown(int a_X, int a_Y) {
// Store world clicked pos for panning
ScreenToWorld(a_X, a_Y, m_WorldClickX, m_WorldClickY);
m_ScreenClickX = a_X;
m_ScreenClickY = a_Y;
m_RefTimeClick = static_cast<TickType>(
time_graph_.GetTime(static_cast<double>(a_X) / getWidth()));
m_IsSelecting = false;
Orbit_ImGui_MouseButtonCallback(this, 0, true);
m_Picking = true;
NeedsRedraw();
}
//-----------------------------------------------------------------------------
void CaptureWindow::LeftUp() {
GlCanvas::LeftUp();
NeedsRedraw();
}
//-----------------------------------------------------------------------------
void CaptureWindow::LeftDoubleClick() {
GlCanvas::LeftDoubleClick();
m_DoubleClicking = true;
m_Picking = true;
}
//-----------------------------------------------------------------------------
void CaptureWindow::Pick() {
m_Picking = true;
NeedsRedraw();
}
//-----------------------------------------------------------------------------
void CaptureWindow::Pick(int a_X, int a_Y) {
// 4 bytes per pixel (RGBA), 1x1 bitmap
std::array<uint8_t, 4 * 1 * 1> pixels;
glReadPixels(a_X, m_MainWindowHeight - a_Y, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
&pixels[0]);
uint32_t value;
std::memcpy(&value, &pixels[0], sizeof(uint32_t));
PickingID pickId = PickingID::Get(value);
Capture::GSelectedTextBox = nullptr;
Capture::GSelectedThreadId = 0;
Pick(pickId, a_X, a_Y);
NeedsUpdate();
}
//-----------------------------------------------------------------------------
void CaptureWindow::Pick(PickingID a_PickingID, int a_X, int a_Y) {
uint32_t type = a_PickingID.m_Type;
uint32_t id = a_PickingID.m_Id;
uint32_t batcher_id = a_PickingID.batcher_id_;
Batcher& batcher = (batcher_id == PickingID::TIME_GRAPH)
? time_graph_.GetBatcher()
: ui_batcher_;
switch (type) {
case PickingID::BOX: {
void** textBoxPtr = batcher.GetBoxBuffer().m_UserData.SlowAt(id);
if (textBoxPtr) {
TextBox* textBox = static_cast<TextBox*>(*textBoxPtr);
SelectTextBox(textBox);
}
break;
}
case PickingID::LINE: {
void** textBoxPtr = batcher.GetLineBuffer().m_UserData.SlowAt(id);
if (textBoxPtr) {
TextBox* textBox = static_cast<TextBox*>(*textBoxPtr);
SelectTextBox(textBox);
}
break;
}
case PickingID::TRIANGLE: {
void** textBoxPtr = batcher.GetTriangleBuffer().user_data_.SlowAt(id);
if (textBoxPtr) {
TextBox* textBox = static_cast<TextBox*>(*textBoxPtr);
SelectTextBox(textBox);
}
break;
}
case PickingID::PICKABLE:
m_PickingManager.Pick(a_PickingID.m_Id, a_X, a_Y);
break;
}
}
//-----------------------------------------------------------------------------
void CaptureWindow::SelectTextBox(class TextBox* a_TextBox) {
if (a_TextBox == nullptr) return;
Capture::GSelectedTextBox = a_TextBox;
Capture::GSelectedThreadId = a_TextBox->GetTimer().m_TID;
Capture::GSelectedCallstack =
Capture::GetCallstack(a_TextBox->GetTimer().m_CallstackHash);
GOrbitApp->SetCallStack(Capture::GSelectedCallstack);
const Timer& a_Timer = a_TextBox->GetTimer();
DWORD64 address = a_Timer.m_FunctionAddress;
FindCode(address);
if (m_DoubleClicking && a_TextBox) {
time_graph_.Zoom(a_TextBox);
}
}
//-----------------------------------------------------------------------------
void CaptureWindow::Hover(int a_X, int a_Y) {
// 4 bytes per pixel (RGBA), 1x1 bitmap
std::vector<uint8_t> pixels(1 * 1 * 4);
glReadPixels(a_X, m_MainWindowHeight - a_Y, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
&pixels[0]);
PickingID pickId = *reinterpret_cast<PickingID*>(&pixels[0]);
TextBox* textBox = time_graph_.GetBatcher().GetTextBox(pickId);
if (textBox) {
if (textBox->GetTimer().m_Type != Timer::CORE_ACTIVITY) {
Function* func =
Capture::GSelectedFunctionsMap[textBox->GetTimer().m_FunctionAddress];
m_ToolTip = absl::StrFormat(
"%s %s", func ? FunctionUtils::GetDisplayName(*func) : "",
textBox->GetText());
GOrbitApp->SendTooltipToUi(m_ToolTip);
NeedsRedraw();
}
}
}
//-----------------------------------------------------------------------------
void CaptureWindow::FindCode(DWORD64 /*address*/) {}
//-----------------------------------------------------------------------------
void CaptureWindow::PreRender() {
if (m_CanHover && m_HoverTimer.QueryMillis() > m_HoverDelayMs) {
m_IsHovering = true;
m_Picking = true;
NeedsRedraw();
}
m_NeedsRedraw = m_NeedsRedraw || time_graph_.IsRedrawNeeded();
}
//-----------------------------------------------------------------------------
void CaptureWindow::PostRender() {
if (m_IsHovering) {
m_IsHovering = false;
m_CanHover = false;
m_Picking = false;
m_HoverTimer.Reset();
Hover(m_MousePosX, m_MousePosY);
NeedsUpdate();
GlCanvas::Render(m_Width, m_Height);
m_HoverTimer.Reset();
}
if (m_Picking) {
m_Picking = false;
Pick(m_ScreenClickX, m_ScreenClickY);
NeedsRedraw();
GlCanvas::Render(m_Width, m_Height);
}
}
//-----------------------------------------------------------------------------
void CaptureWindow::Resize(int a_Width, int a_Height) {
GlCanvas::Resize(a_Width, a_Height);
NeedsUpdate();
}
//-----------------------------------------------------------------------------
void CaptureWindow::RightDown(int a_X, int a_Y) {
ScreenToWorld(a_X, a_Y, m_WorldClickX, m_WorldClickY);
m_ScreenClickX = a_X;
m_ScreenClickY = a_Y;
Pick();
m_IsSelecting = true;
m_SelectStart = Vec2(m_WorldClickX, m_WorldClickY);
m_SelectStop = m_SelectStart;
m_TimeStart = time_graph_.GetTickFromWorld(m_WorldClickX);
m_TimeStop = m_TimeStart;
}
//-----------------------------------------------------------------------------
bool CaptureWindow::RightUp() {
if (m_IsSelecting && (m_SelectStart[0] != m_SelectStop[0]) &&
ControlPressed()) {
float minWorld = std::min(m_SelectStop[0], m_SelectStart[0]);
float maxWorld = std::max(m_SelectStop[0], m_SelectStart[0]);
double newMin =
time_graph_.GetTime((minWorld - m_WorldTopLeftX) / m_WorldWidth);
double newMax =
time_graph_.GetTime((maxWorld - m_WorldTopLeftX) / m_WorldWidth);
time_graph_.SetMinMax(newMin, newMax);
m_SelectStart = m_SelectStop;
}
bool showContextMenu = m_SelectStart[0] == m_SelectStop[0];
m_IsSelecting = false;
NeedsRedraw();
return showContextMenu;
}
//-----------------------------------------------------------------------------
void CaptureWindow::MiddleDown(int a_X, int a_Y) {
float worldx, worldy;
ScreenToWorld(a_X, a_Y, worldx, worldy);
m_IsSelecting = true;
m_SelectStart = Vec2(worldx, worldy);
m_SelectStop = m_SelectStart;
}
//-----------------------------------------------------------------------------
void CaptureWindow::MiddleUp(int a_X, int a_Y) {
float worldx, worldy;
ScreenToWorld(a_X, a_Y, worldx, worldy);
m_IsSelecting = false;
m_SelectStop = Vec2(worldx, worldy);
NeedsRedraw();
}
//-----------------------------------------------------------------------------
void CaptureWindow::Zoom(int a_Delta) {
if (a_Delta == 0) return;
a_Delta = -a_Delta;
float worldx;
float worldy;
ScreenToWorld(m_MousePosX, m_MousePosY, worldx, worldy);
m_MouseRatio = static_cast<double>(m_MousePosX) / getWidth();
time_graph_.ZoomTime(a_Delta, m_MouseRatio);
m_WheelMomentum =
a_Delta * m_WheelMomentum < 0 ? 0 : m_WheelMomentum + a_Delta;
NeedsUpdate();
}
//-----------------------------------------------------------------------------
void CaptureWindow::Pan(float a_Ratio) {
double refTime =
time_graph_.GetTime(static_cast<double>(m_MousePosX) / getWidth());
time_graph_.PanTime(m_MousePosX,
m_MousePosX + static_cast<int>(a_Ratio * getWidth()),
getWidth(), refTime);
UpdateSceneBox();
NeedsUpdate();
}
//-----------------------------------------------------------------------------
void CaptureWindow::MouseWheelMoved(int a_X, int a_Y, int a_Delta,
bool a_Ctrl) {
if (a_Delta == 0) return;
// Normalize and invert sign, so that delta < 0 is zoom in.
int delta = a_Delta < 0 ? 1 : -1;
if (delta < m_MinWheelDelta) m_MinWheelDelta = delta;
if (delta > m_MaxWheelDelta) m_MaxWheelDelta = delta;
float mousex = a_X;
float worldx;
float worldy;
ScreenToWorld(a_X, a_Y, worldx, worldy);
m_MouseRatio = static_cast<double>(mousex) / getWidth();
bool zoomWidth = !a_Ctrl;
if (zoomWidth) {
time_graph_.ZoomTime(delta, m_MouseRatio);
m_WheelMomentum = delta * m_WheelMomentum < 0 ? 0 : m_WheelMomentum + delta;
} else {
// TODO: reimplement vertical zoom by scaling track heights.
}
// Use the original sign of a_Delta here.
Orbit_ImGui_ScrollCallback(this, -delta);
m_CanHover = true;
NeedsUpdate();
}
//-----------------------------------------------------------------------------
void CaptureWindow::MouseWheelMovedHorizontally(int /*a_X*/, int /*a_Y*/,
int a_Delta, bool /*a_Ctrl*/) {
if (a_Delta == 0) return;
// Normalize and invert sign, so that delta < 0 is left.
int delta = a_Delta < 0 ? 1 : -1;
if (delta < 0) {
Pan(0.1f);
} else {
Pan(-0.1f);
}
// Use the original sign of a_Delta here.
Orbit_ImGui_ScrollCallback(this, -delta);
}
//-----------------------------------------------------------------------------
void CaptureWindow::KeyPressed(unsigned int a_KeyCode, bool a_Ctrl,
bool a_Shift, bool a_Alt) {
UpdateSpecialKeys(a_Ctrl, a_Shift, a_Alt);
ScopeImguiContext state(m_ImGuiContext);
if (!m_ImguiActive) {
switch (a_KeyCode) {
case ' ':
if (!a_Shift) {
ZoomAll();
}
break;
case 'A':
Pan(0.1f);
break;
case 'D':
Pan(-0.1f);
break;
case 'W':
Zoom(1);
break;
case 'S':
Zoom(-1);
break;
case 'F':
m_DrawFilter = !m_DrawFilter;
break;
case 'I':
m_DrawStats = !m_DrawStats;
break;
case 'H':
m_DrawHelp = !m_DrawHelp;
break;
case 'X':
GOrbitApp->ToggleCapture();
m_DrawHelp = false;
#ifdef __linux__
ZoomAll();
#endif
break;
case 'O':
if (a_Ctrl) {
m_TextRenderer.ToggleDrawOutline();
}
break;
case 18: // Left
if (a_Shift) {
time_graph_.OnShiftLeft();
} else {
time_graph_.OnLeft();
}
break;
case 20: // Right
if (a_Shift) {
time_graph_.OnShiftRight();
} else {
time_graph_.OnRight();
}
break;
case 19: // Up
time_graph_.OnUp();
break;
case 21: // Down
time_graph_.OnDown();
break;
}
}
ImGuiIO& io = ImGui::GetIO();
io.KeyCtrl = a_Ctrl;
io.KeyShift = a_Shift;
io.KeyAlt = a_Alt;
Orbit_ImGui_KeyCallback(this, a_KeyCode, true);
NeedsRedraw();
}
//-----------------------------------------------------------------------------
std::vector<std::string> CaptureWindow::GetContextMenu() {
return std::vector<std::string>{};
}
//-----------------------------------------------------------------------------
void CaptureWindow::OnContextMenu(const std::string& /*a_Action*/,
int /*a_MenuIndex*/) {}
//-----------------------------------------------------------------------------
void CaptureWindow::OnCaptureStarted() {
time_graph_.ZoomAll();
NeedsRedraw();
}
//-----------------------------------------------------------------------------
void CaptureWindow::ResetHoverTimer() {
m_HoverTimer.Reset();
m_CanHover = true;
}
//-----------------------------------------------------------------------------
void CaptureWindow::Draw() {
m_WorldMaxY =
1.5f * ScreenToWorldHeight(static_cast<int>(m_Slider.GetPixelHeight()));
if (Capture::IsCapturing()) {
ZoomAll();
}
// Reset picking manager before each draw.
m_PickingManager.Reset();
time_graph_.Draw(this, m_Picking);
if (m_SelectStart[0] != m_SelectStop[0]) {
TickType minTime = std::min(m_TimeStart, m_TimeStop);
TickType maxTime = std::max(m_TimeStart, m_TimeStop);
float from = time_graph_.GetWorldFromTick(minTime);
float to = time_graph_.GetWorldFromTick(maxTime);
double micros = MicroSecondsFromTicks(minTime, maxTime);
float sizex = to - from;
Vec2 pos(from, m_WorldTopLeftY - m_WorldHeight);
Vec2 size(sizex, m_WorldHeight);
std::string time = GetPrettyTime(micros * 0.001);
TextBox box(pos, size, time, Color(0, 128, 0, 128));
box.SetTextY(m_SelectStop[1]);
box.Draw(&ui_batcher_, m_TextRenderer, -FLT_MAX, true, true);
}
if (!m_Picking && !m_IsHovering) {
DrawStatus();
RenderTimeBar();
Vec2 pos(m_MouseX, m_WorldTopLeftY);
ui_batcher_.AddVerticalLine(pos, -m_WorldHeight, Z_VALUE_TEXT,
Color(0, 255, 0, 127), PickingID::LINE);
}
}
//-----------------------------------------------------------------------------
void CaptureWindow::DrawScreenSpace() {
double timeSpan = time_graph_.GetSessionTimeSpanUs();
Color col = m_Slider.GetBarColor();
float height = m_Slider.GetPixelHeight();
float canvasHeight = getHeight();
float z = GlCanvas::Z_VALUE_TEXT_UI_BG;
const TimeGraphLayout& layout = time_graph_.GetLayout();
float vertical_margin = layout.GetVerticalMargin();
if (timeSpan > 0) {
double start = time_graph_.GetMinTimeUs();
double stop = time_graph_.GetMaxTimeUs();
double width = stop - start;
double maxStart = timeSpan - width;
double ratio =
Capture::IsCapturing() ? 1 : (maxStart != 0 ? start / maxStart : 0);
float slider_width = layout.GetSliderWidth();
m_Slider.SetPixelHeight(slider_width);
m_Slider.SetSliderRatio(static_cast<float>(ratio));
m_Slider.SetSliderWidthRatio(static_cast<float>(width / timeSpan));
m_Slider.Draw(this, m_Picking);
float verticalRatio = m_WorldHeight / time_graph_.GetThreadTotalHeight();
if (verticalRatio < 1.f) {
m_VerticalSlider.SetPixelHeight(slider_width);
m_VerticalSlider.SetSliderWidthRatio(verticalRatio);
m_VerticalSlider.Draw(this, m_Picking);
vertical_margin += slider_width;
}
}
// Right vertical margin.
time_graph_.SetVerticalMargin(vertical_margin);
const Color kBackgroundColor(70, 70, 70, 255);
float margin_x1 = getWidth();
float margin_x0 = margin_x1 - vertical_margin;
Box box(Vec2(margin_x0, 0),
Vec2(margin_x1 - margin_x0, canvasHeight - height), z);
ui_batcher_.AddBox(box, kBackgroundColor, PickingID::BOX);
// Time bar
if (time_graph_.GetSessionTimeSpanUs() > 0) {
Box box(Vec2(0, height), Vec2(getWidth(), height), z);
ui_batcher_.AddBox(box, Color(70, 70, 70, 200), PickingID::BOX);
}
}
//-----------------------------------------------------------------------------
void CaptureWindow::OnDrag(float a_Ratio) {
time_graph_.OnDrag(a_Ratio);
NeedsUpdate();
}
//-----------------------------------------------------------------------------
void CaptureWindow::OnVerticalDrag(float a_Ratio) {
float min = m_WorldMaxY;
float max = m_WorldHeight - time_graph_.GetThreadTotalHeight();
float range = max - min;
m_WorldTopLeftY = min + a_Ratio * range;
NeedsUpdate();
}
//-----------------------------------------------------------------------------
void CaptureWindow::UpdateVerticalSlider() {
float min = m_WorldMaxY;
float max = m_WorldHeight - time_graph_.GetThreadTotalHeight();
float ratio = (m_WorldTopLeftY - min) / (max - min);
m_VerticalSlider.SetSliderRatio(ratio);
}
void CaptureWindow::ToggleDrawHelp() {
m_DrawHelp = !m_DrawHelp;
NeedsRedraw();
}
//-----------------------------------------------------------------------------
void CaptureWindow::NeedsUpdate() {
time_graph_.NeedsUpdate();
m_NeedsRedraw = true;
}
//-----------------------------------------------------------------------------
float CaptureWindow::GetTopBarTextY() {
return m_Slider.GetPixelHeight() * 0.5f +
m_TextRenderer.GetStringHeight("FpjT_H") * 0.5f;
}
//-----------------------------------------------------------------------------
void CaptureWindow::DrawStatus() {
int s_PosX = 0;
int s_PosY = static_cast<int>(GetTopBarTextY());
static int s_IncY = 20;
static Color s_Color(255, 255, 255, 255);
int PosX = getWidth() - s_PosX;
int PosY = s_PosY;
int LeftY = s_PosY;
LeftY += s_IncY;
if (Capture::GInjected) {
std::string injectStr =
absl::StrFormat(" %s", Capture::GInjectedProcess.c_str());
m_ProcessX = m_TextRenderer.AddText2D(injectStr.c_str(), PosX, PosY,
Z_VALUE_TEXT_UI, s_Color, -1, true);
PosY += s_IncY;
}
}
//-----------------------------------------------------------------------------
void CaptureWindow::RenderUI() {
ScopeImguiContext state(m_ImGuiContext);
Orbit_ImGui_NewFrame(this);
if (m_DrawStats) {
ImGui::ShowDemoWindow();
if (time_graph_.GetLayout().DrawProperties()) {
NeedsUpdate();
}
m_StatsWindow.Clear();
m_StatsWindow.AddLine(VAR_TO_STR(m_Width));
m_StatsWindow.AddLine(VAR_TO_STR(m_Height));
m_StatsWindow.AddLine(VAR_TO_STR(m_WorldHeight));
m_StatsWindow.AddLine(VAR_TO_STR(m_WorldWidth));
m_StatsWindow.AddLine(VAR_TO_STR(m_WorldTopLeftX));
m_StatsWindow.AddLine(VAR_TO_STR(m_WorldTopLeftY));
m_StatsWindow.AddLine(VAR_TO_STR(m_WorldMinWidth));
m_StatsWindow.AddLine(VAR_TO_STR(m_MouseX));
m_StatsWindow.AddLine(VAR_TO_STR(m_MouseY));
m_StatsWindow.AddLine(VAR_TO_STR(Capture::GNumContextSwitches));
m_StatsWindow.AddLine(VAR_TO_STR(Capture::GNumLinuxEvents));
m_StatsWindow.AddLine(VAR_TO_STR(Capture::GNumProfileEvents));
m_StatsWindow.AddLine(VAR_TO_STR(Capture::GNumInstalledHooks));
m_StatsWindow.AddLine(VAR_TO_STR(Capture::GSelectedFunctionsMap.size()));
m_StatsWindow.AddLine(VAR_TO_STR(Capture::GVisibleFunctionsMap.size()));
m_StatsWindow.AddLine(VAR_TO_STR(time_graph_.GetNumDrawnTextBoxes()));
m_StatsWindow.AddLine(VAR_TO_STR(time_graph_.GetNumTimers()));
m_StatsWindow.AddLine(VAR_TO_STR(time_graph_.GetThreadTotalHeight()));
#ifndef WIN32
m_StatsWindow.AddLine(
VAR_TO_STR(GEventTracer.GetEventBuffer().GetCallstacks().size()));
m_StatsWindow.AddLine(
VAR_TO_STR(GEventTracer.GetEventBuffer().GetNumEvents()));
#endif
m_StatsWindow.Draw("Capture Stats", &m_DrawStats);
}
if (m_DrawHelp) {
RenderHelpUi();
if (m_FirstHelpDraw) {
// Redraw so that Imgui resizes the
// window properly on first draw
NeedsRedraw();
m_FirstHelpDraw = false;
}
}
// Rendering
glViewport(0, 0, getWidth(), getHeight());
ImGui::Render();
}
//-----------------------------------------------------------------------------
void CaptureWindow::RenderText() {
if (!m_Picking) {
time_graph_.DrawText(this);
}
}
//-----------------------------------------------------------------------------
void ColorToFloat(Color a_Color, float* o_Float) {
for (size_t i = 0; i < 4; ++i) {
o_Float[i] = a_Color[i] / 255.f;
}
}
//-----------------------------------------------------------------------------
void CaptureWindow::RenderHelpUi() {
constexpr float kYOffset = 8.f;
ImGui::SetNextWindowPos(ImVec2(0, kYOffset));
ImVec4 color(1.f, 0, 0, 1.f);
ColorToFloat(m_Slider.GetBarColor(), &color.x);
ImGui::PushStyleColor(ImGuiCol_WindowBg, color);
if (!ImGui::Begin("Help Overlay", &m_DrawHelp, ImVec2(0, 0), 1.f,
ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
ImGuiWindowFlags_NoMove |
ImGuiWindowFlags_NoSavedSettings)) {
ImGui::PopStyleColor();
ImGui::End();
return;
}
ImGui::Text("Start/Stop Capture: 'X'");
ImGui::Text("Pan: 'A','D' or \"Left Click + Drag\"");
ImGui::Text("Zoom: 'W', 'S', Scroll or \"Ctrl + Right Click + Drag\"");
ImGui::Text("Select: Left Click");
ImGui::Text("Measure: \"Right Click + Drag\"");
ImGui::Text("Toggle Help: 'H'");
ImGui::End();
ImGui::PopStyleColor();
}
//-----------------------------------------------------------------------------
ImTextureID TextureId(uint64_t id) {
return reinterpret_cast<ImTextureID>(static_cast<uintptr_t>(id));
}
//-----------------------------------------------------------------------------
bool IconButton(uint64_t texture_id, const char* tooltip, ImVec2 size,
bool enabled) {
ImTextureID imgui_texture_id = TextureId(texture_id);
if (!enabled) {
ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true);
ImGui::PushStyleVar(ImGuiStyleVar_Alpha, ImGui::GetStyle().Alpha * 0.4f);
}
bool clicked = ImGui::ImageButton(imgui_texture_id, size);
if (tooltip != nullptr &&
ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
ImGui::SetTooltip("%s", tooltip);
}
if (!enabled) {
ImGui::PopItemFlag();
ImGui::PopStyleVar();
}
return clicked;
}
//-----------------------------------------------------------------------------
inline double GetIncrementMs(double a_MilliSeconds) {
const double Day = 24 * 60 * 60 * 1000;
const double Hour = 60 * 60 * 1000;
const double Minute = 60 * 1000;
const double Second = 1000;
const double Milli = 1;
const double Micro = 0.001;
const double Nano = 0.000001;
std::string res;
if (a_MilliSeconds < Micro)
return Nano;
else if (a_MilliSeconds < Milli)
return Micro;
else if (a_MilliSeconds < Second)
return Milli;
else if (a_MilliSeconds < Minute)
return Second;
else if (a_MilliSeconds < Hour)
return Minute;
else if (a_MilliSeconds < Day)
return Hour;
else
return Day;
}
//-----------------------------------------------------------------------------
void CaptureWindow::RenderTimeBar() {
static int numTimePoints = 10;
if (time_graph_.GetSessionTimeSpanUs() > 0) {
double millis = time_graph_.GetCurrentTimeSpanUs() * 0.001;
double incr = millis / float(numTimePoints - 1);
double unit = GetIncrementMs(incr);
double normInc = static_cast<int>((incr + unit) / unit) * unit;
double startMs = time_graph_.GetMinTimeUs() * 0.001;
double normStartUs = 1000.0 * static_cast<int>(startMs / normInc) * normInc;
static int pixelMargin = 2;
int screenY =
getHeight() - static_cast<int>(m_Slider.GetPixelHeight()) - pixelMargin;
float dummy, worldY;
ScreenToWorld(0, screenY, dummy, worldY);
float height =
ScreenToWorldHeight(static_cast<int>(GParams.font_size) + pixelMargin);
float xMargin = ScreenToworldWidth(4);
for (int i = 0; i < numTimePoints; ++i) {
double currentMicros = normStartUs + i * 1000 * normInc;
if (currentMicros < 0) continue;
double currentMillis = currentMicros * 0.001;
std::string text = GetPrettyTime(currentMillis);
float worldX = time_graph_.GetWorldFromUs(currentMicros);
m_TextRenderer.AddText(text.c_str(), worldX + xMargin, worldY,
GlCanvas::Z_VALUE_TEXT_UI,
Color(255, 255, 255, 255));
Vec2 pos(worldX, worldY);
ui_batcher_.AddVerticalLine(pos, height, Z_VALUE_UI,
Color(255, 255, 255, 255), PickingID::LINE);
}
}
}
//-----------------------------------------------------------------------------
void CaptureWindow::Initialize() { GlCanvas::Initialize(); }
|
; A344444: Completely additive with a(2) = 12, a(3) = 19; for prime p > 3, a(p) = ceiling((a(p-1) + a(p+1))/2).
; Submitted by Jamie Morken(s4)
; 0,12,19,24,28,31,34,36,38,40,42,43,45,46,47,48,49,50,51,52,53,54,55,55,56,57,57,58,59,59,60,60,61,61,62,62,63,63,64,64,65,65,66,66,66,67,67,67,68,68,68,69,69,69,70,70,70,71,71,71,72,72,72,72,73,73,73,73,74,74
mul $0,2
add $0,2
pow $0,12
bin $0,2
lpb $0
div $0,4
trn $0,1
add $1,1
lpe
mov $0,$1
sub $0,11
|
; unsigned int zxn_addr_from_mmu(unsigned char mmu)
SECTION code_clib
SECTION code_arch
PUBLIC _zxn_addr_from_mmu_fastcall
EXTERN asm_zxn_addr_from_mmu
defc _zxn_addr_from_mmu_fastcall = asm_zxn_addr_from_mmu
|
;
; This file is part of QBDI.
;
; Copyright 2017 Quarkslab
;
; Licensed under the Apache License, Version 2.0 (the "License");
; you may not use this file except in compliance with the License.
; You may obtain a copy of the License at
;
; http://www.apache.org/licenses/LICENSE-2.0
;
; Unless required by applicable law or agreed to in writing, software
; distributed under the License is distributed on an "AS IS" BASIS,
; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
; See the License for the specific language governing permissions and
; limitations under the License.
;
.386
.model flat, C
_TEXT segment
PUBLIC runRealExec
.CODE
runRealExec PROC
push ebp;
mov ebp, esp;
pushad;
mov eax, [ebp+8];
mov edi, [ebp+12];
call eax;
popad;
mov esp, ebp;
pop ebp;
ret;
runRealExec ENDP
END
|
#define TELEOP_DURATION 2.0
#include "vehicles/multirotor/api/MultirotorRpcLibClient.hpp"
#include "common/Common.hpp"
#include <ros/ros.h>
#include <geometry_msgs/Twist.h>
#include <cmath>
using namespace std;
string localization_method;
msr::airlib::MultirotorRpcLibClient * client;
int main(int argc, char **argv)
{
//Start ROS ----------------------------------------------------------------
ros::init(argc, argv, "airsim_teleop");
ros::NodeHandle n("~");
ros::Rate loop_rate(60);
//Parameters for communicating with Airsim
string ip_addr;
int portParam;
ros::param::param<std::string>("~Airsim_ip",ip_addr,"localhost");
ros::param::param<int>("~Airsim_port", portParam, 0);
uint16_t port = portParam;
int is_startup_takeoff=0;
ros::param::param<int>("~Airsim_startup_takeoff", is_startup_takeoff, 0);
//Verbose
ROS_INFO("Image publisher connecting to:");
ROS_INFO("IP: %s", ip_addr.c_str());
ROS_INFO("Port: %d", port);
ROS_INFO("is_startup_takeoff: %d", is_startup_takeoff);
//this connects us to the drone
if (!port)
{
client = new msr::airlib::MultirotorRpcLibClient(ip_addr);
}
else
{
client = new msr::airlib::MultirotorRpcLibClient(ip_addr, port);
}
//client->enableApiControl(false);
client->confirmConnection();
client->enableApiControl(true);
if (is_startup_takeoff)
{
ROS_INFO("Waiting to take off");
client->takeoff(2);
ROS_INFO("took off");
}
auto drive_train = msr::airlib::DrivetrainType::MaxDegreeOfFreedom;
msr::airlib::YawMode yaw_mode(true, 0);
ros::Subscriber cmd_vel_sub = n.subscribe<geometry_msgs::Twist>(
"cmd_vel", 100,
[&](const geometry_msgs::TwistConstPtr &twist_msg) {
if (twist_msg->angular.z)
{
client->rotateByYawRate(-twist_msg->angular.z*180/M_PI, TELEOP_DURATION);
}
else
{
using namespace msr::airlib;
auto global_velocity = VectorMathT<Vector3r, Quaternionr, real_T>::transformToWorldFrame(
(Vector3r() << twist_msg->linear.x, twist_msg->linear.y, -twist_msg->linear.z).finished(),
client->getOrientation()
);
client->moveByVelocity(
global_velocity(0), global_velocity(1), global_velocity(2),
TELEOP_DURATION, drive_train, yaw_mode
);
}
}
);
ros::spin();
//poll_frame_thread.join();
return 0;
}
|
###############################################################################
# Copyright 2018 Intel Corporation
# All Rights Reserved.
#
# If this software was obtained under the Intel Simplified Software License,
# the following terms apply:
#
# The source code, information and material ("Material") contained herein is
# owned by Intel Corporation or its suppliers or licensors, and title to such
# Material remains with Intel Corporation or its suppliers or licensors. The
# Material contains proprietary information of Intel or its suppliers and
# licensors. The Material is protected by worldwide copyright laws and treaty
# provisions. No part of the Material may be used, copied, reproduced,
# modified, published, uploaded, posted, transmitted, distributed or disclosed
# in any way without Intel's prior express written permission. No license under
# any patent, copyright or other intellectual property rights in the Material
# is granted to or conferred upon you, either expressly, by implication,
# inducement, estoppel or otherwise. Any license under such intellectual
# property rights must be express and approved by Intel in writing.
#
# Unless otherwise agreed by Intel in writing, you may not remove or alter this
# notice or any other notice embedded in Materials by Intel or Intel's
# suppliers or licensors in any way.
#
#
# If this software was obtained under the Apache License, Version 2.0 (the
# "License"), the following terms apply:
#
# You may not use this file except in compliance with the License. You may
# obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
#
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
# See the License for the specific language governing permissions and
# limitations under the License.
###############################################################################
.text
.p2align 4, 0x90
Lpoly:
.quad 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFF, 0x0, 0xFFFFFFFF00000001
LRR:
.quad 0x3, 0xfffffffbffffffff, 0xfffffffffffffffe, 0x4fffffffd
LOne:
.long 1,1,1,1,1,1,1,1
LTwo:
.long 2,2,2,2,2,2,2,2
LThree:
.long 3,3,3,3,3,3,3,3
.p2align 4, 0x90
.globl _p256r1_mul_by_2
_p256r1_mul_by_2:
push %r12
push %r13
xor %r13, %r13
movq (%rsi), %r8
movq (8)(%rsi), %r9
movq (16)(%rsi), %r10
movq (24)(%rsi), %r11
shld $(1), %r11, %r13
shld $(1), %r10, %r11
shld $(1), %r9, %r10
shld $(1), %r8, %r9
shl $(1), %r8
mov %r8, %rax
mov %r9, %rdx
mov %r10, %rcx
mov %r11, %r12
subq Lpoly+0(%rip), %rax
sbbq Lpoly+8(%rip), %rdx
sbbq Lpoly+16(%rip), %rcx
sbbq Lpoly+24(%rip), %r12
sbb $(0), %r13
cmove %rax, %r8
cmove %rdx, %r9
cmove %rcx, %r10
cmove %r12, %r11
movq %r8, (%rdi)
movq %r9, (8)(%rdi)
movq %r10, (16)(%rdi)
movq %r11, (24)(%rdi)
pop %r13
pop %r12
ret
.p2align 4, 0x90
.globl _p256r1_div_by_2
_p256r1_div_by_2:
push %r12
push %r13
push %r14
movq (%rsi), %r8
movq (8)(%rsi), %r9
movq (16)(%rsi), %r10
movq (24)(%rsi), %r11
xor %r13, %r13
xor %r14, %r14
mov %r8, %rax
mov %r9, %rdx
mov %r10, %rcx
mov %r11, %r12
addq Lpoly+0(%rip), %rax
adcq Lpoly+8(%rip), %rdx
adcq Lpoly+16(%rip), %rcx
adcq Lpoly+24(%rip), %r12
adc $(0), %r13
test $(1), %r8
cmovne %rax, %r8
cmovne %rdx, %r9
cmovne %rcx, %r10
cmovne %r12, %r11
cmovne %r13, %r14
shrd $(1), %r9, %r8
shrd $(1), %r10, %r9
shrd $(1), %r11, %r10
shrd $(1), %r14, %r11
movq %r8, (%rdi)
movq %r9, (8)(%rdi)
movq %r10, (16)(%rdi)
movq %r11, (24)(%rdi)
pop %r14
pop %r13
pop %r12
ret
.p2align 4, 0x90
.globl _p256r1_mul_by_3
_p256r1_mul_by_3:
push %r12
push %r13
xor %r13, %r13
movq (%rsi), %r8
movq (8)(%rsi), %r9
movq (16)(%rsi), %r10
movq (24)(%rsi), %r11
shld $(1), %r11, %r13
shld $(1), %r10, %r11
shld $(1), %r9, %r10
shld $(1), %r8, %r9
shl $(1), %r8
mov %r8, %rax
mov %r9, %rdx
mov %r10, %rcx
mov %r11, %r12
subq Lpoly+0(%rip), %rax
sbbq Lpoly+8(%rip), %rdx
sbbq Lpoly+16(%rip), %rcx
sbbq Lpoly+24(%rip), %r12
sbb $(0), %r13
cmove %rax, %r8
cmove %rdx, %r9
cmove %rcx, %r10
cmove %r12, %r11
xor %r13, %r13
addq (%rsi), %r8
adcq (8)(%rsi), %r9
adcq (16)(%rsi), %r10
adcq (24)(%rsi), %r11
adc $(0), %r13
mov %r8, %rax
mov %r9, %rdx
mov %r10, %rcx
mov %r11, %r12
subq Lpoly+0(%rip), %rax
sbbq Lpoly+8(%rip), %rdx
sbbq Lpoly+16(%rip), %rcx
sbbq Lpoly+24(%rip), %r12
sbb $(0), %r13
cmove %rax, %r8
cmove %rdx, %r9
cmove %rcx, %r10
cmove %r12, %r11
movq %r8, (%rdi)
movq %r9, (8)(%rdi)
movq %r10, (16)(%rdi)
movq %r11, (24)(%rdi)
pop %r13
pop %r12
ret
.p2align 4, 0x90
.globl _p256r1_add
_p256r1_add:
push %r12
push %r13
xor %r13, %r13
movq (%rsi), %r8
movq (8)(%rsi), %r9
movq (16)(%rsi), %r10
movq (24)(%rsi), %r11
addq (%rdx), %r8
adcq (8)(%rdx), %r9
adcq (16)(%rdx), %r10
adcq (24)(%rdx), %r11
adc $(0), %r13
mov %r8, %rax
mov %r9, %rdx
mov %r10, %rcx
mov %r11, %r12
subq Lpoly+0(%rip), %rax
sbbq Lpoly+8(%rip), %rdx
sbbq Lpoly+16(%rip), %rcx
sbbq Lpoly+24(%rip), %r12
sbb $(0), %r13
cmove %rax, %r8
cmove %rdx, %r9
cmove %rcx, %r10
cmove %r12, %r11
movq %r8, (%rdi)
movq %r9, (8)(%rdi)
movq %r10, (16)(%rdi)
movq %r11, (24)(%rdi)
pop %r13
pop %r12
ret
.p2align 4, 0x90
.globl _p256r1_sub
_p256r1_sub:
push %r12
push %r13
xor %r13, %r13
movq (%rsi), %r8
movq (8)(%rsi), %r9
movq (16)(%rsi), %r10
movq (24)(%rsi), %r11
subq (%rdx), %r8
sbbq (8)(%rdx), %r9
sbbq (16)(%rdx), %r10
sbbq (24)(%rdx), %r11
sbb $(0), %r13
mov %r8, %rax
mov %r9, %rdx
mov %r10, %rcx
mov %r11, %r12
addq Lpoly+0(%rip), %rax
adcq Lpoly+8(%rip), %rdx
adcq Lpoly+16(%rip), %rcx
adcq Lpoly+24(%rip), %r12
test %r13, %r13
cmovne %rax, %r8
cmovne %rdx, %r9
cmovne %rcx, %r10
cmovne %r12, %r11
movq %r8, (%rdi)
movq %r9, (8)(%rdi)
movq %r10, (16)(%rdi)
movq %r11, (24)(%rdi)
pop %r13
pop %r12
ret
.p2align 4, 0x90
.globl _p256r1_neg
_p256r1_neg:
push %r12
push %r13
xor %r13, %r13
xor %r8, %r8
xor %r9, %r9
xor %r10, %r10
xor %r11, %r11
subq (%rsi), %r8
sbbq (8)(%rsi), %r9
sbbq (16)(%rsi), %r10
sbbq (24)(%rsi), %r11
sbb $(0), %r13
mov %r8, %rax
mov %r9, %rdx
mov %r10, %rcx
mov %r11, %r12
addq Lpoly+0(%rip), %rax
adcq Lpoly+8(%rip), %rdx
adcq Lpoly+16(%rip), %rcx
adcq Lpoly+24(%rip), %r12
test %r13, %r13
cmovne %rax, %r8
cmovne %rdx, %r9
cmovne %rcx, %r10
cmovne %r12, %r11
movq %r8, (%rdi)
movq %r9, (8)(%rdi)
movq %r10, (16)(%rdi)
movq %r11, (24)(%rdi)
pop %r13
pop %r12
ret
.p2align 4, 0x90
p256r1_mmull:
xor %r13, %r13
movq (%rbx), %rax
mulq (%rsi)
mov %rax, %r8
mov %rdx, %r9
movq (%rbx), %rax
mulq (8)(%rsi)
add %rax, %r9
adc $(0), %rdx
mov %rdx, %r10
movq (%rbx), %rax
mulq (16)(%rsi)
add %rax, %r10
adc $(0), %rdx
mov %rdx, %r11
movq (%rbx), %rax
mulq (24)(%rsi)
add %rax, %r11
adc $(0), %rdx
mov %rdx, %r12
mov %r8, %rax
shl $(32), %rax
mov %r8, %rdx
shr $(32), %rdx
mov %r8, %rcx
mov %r8, %rbp
xor %r8, %r8
sub %rax, %rcx
sbb %rdx, %rbp
add %rax, %r9
adc %rdx, %r10
adc %rcx, %r11
adc %rbp, %r12
adc $(0), %r13
movq (8)(%rbx), %rax
mulq (%rsi)
add %rax, %r9
adc $(0), %rdx
mov %rdx, %rcx
movq (8)(%rbx), %rax
mulq (8)(%rsi)
add %rcx, %r10
adc $(0), %rdx
add %rax, %r10
adc $(0), %rdx
mov %rdx, %rcx
movq (8)(%rbx), %rax
mulq (16)(%rsi)
add %rcx, %r11
adc $(0), %rdx
add %rax, %r11
adc $(0), %rdx
mov %rdx, %rcx
movq (8)(%rbx), %rax
mulq (24)(%rsi)
add %rcx, %r12
adc $(0), %rdx
add %rax, %r12
adc %rdx, %r13
adc $(0), %r8
mov %r9, %rax
shl $(32), %rax
mov %r9, %rdx
shr $(32), %rdx
mov %r9, %rcx
mov %r9, %rbp
xor %r9, %r9
sub %rax, %rcx
sbb %rdx, %rbp
add %rax, %r10
adc %rdx, %r11
adc %rcx, %r12
adc %rbp, %r13
adc $(0), %r8
movq (16)(%rbx), %rax
mulq (%rsi)
add %rax, %r10
adc $(0), %rdx
mov %rdx, %rcx
movq (16)(%rbx), %rax
mulq (8)(%rsi)
add %rcx, %r11
adc $(0), %rdx
add %rax, %r11
adc $(0), %rdx
mov %rdx, %rcx
movq (16)(%rbx), %rax
mulq (16)(%rsi)
add %rcx, %r12
adc $(0), %rdx
add %rax, %r12
adc $(0), %rdx
mov %rdx, %rcx
movq (16)(%rbx), %rax
mulq (24)(%rsi)
add %rcx, %r13
adc $(0), %rdx
add %rax, %r13
adc %rdx, %r8
adc $(0), %r9
mov %r10, %rax
shl $(32), %rax
mov %r10, %rdx
shr $(32), %rdx
mov %r10, %rcx
mov %r10, %rbp
xor %r10, %r10
sub %rax, %rcx
sbb %rdx, %rbp
add %rax, %r11
adc %rdx, %r12
adc %rcx, %r13
adc %rbp, %r8
adc $(0), %r9
movq (24)(%rbx), %rax
mulq (%rsi)
add %rax, %r11
adc $(0), %rdx
mov %rdx, %rcx
movq (24)(%rbx), %rax
mulq (8)(%rsi)
add %rcx, %r12
adc $(0), %rdx
add %rax, %r12
adc $(0), %rdx
mov %rdx, %rcx
movq (24)(%rbx), %rax
mulq (16)(%rsi)
add %rcx, %r13
adc $(0), %rdx
add %rax, %r13
adc $(0), %rdx
mov %rdx, %rcx
movq (24)(%rbx), %rax
mulq (24)(%rsi)
add %rcx, %r8
adc $(0), %rdx
add %rax, %r8
adc %rdx, %r9
adc $(0), %r10
mov %r11, %rax
shl $(32), %rax
mov %r11, %rdx
shr $(32), %rdx
mov %r11, %rcx
mov %r11, %rbp
xor %r11, %r11
sub %rax, %rcx
sbb %rdx, %rbp
add %rax, %r12
adc %rdx, %r13
adc %rcx, %r8
adc %rbp, %r9
adc $(0), %r10
movq Lpoly+0(%rip), %rax
movq Lpoly+8(%rip), %rdx
movq Lpoly+16(%rip), %rcx
movq Lpoly+24(%rip), %rbp
mov %r12, %rbx
mov %r13, %r11
mov %r8, %r14
mov %r9, %r15
sub %rax, %rbx
sbb %rdx, %r11
sbb %rcx, %r14
sbb %rbp, %r15
sbb $(0), %r10
cmovnc %rbx, %r12
cmovnc %r11, %r13
cmovnc %r14, %r8
cmovnc %r15, %r9
movq %r12, (%rdi)
movq %r13, (8)(%rdi)
movq %r8, (16)(%rdi)
movq %r9, (24)(%rdi)
ret
.p2align 4, 0x90
.globl _p256r1_mul_montl
_p256r1_mul_montl:
push %rbp
push %rbx
push %r12
push %r13
push %r14
push %r15
mov %rdx, %rbx
call p256r1_mmull
pop %r15
pop %r14
pop %r13
pop %r12
pop %rbx
pop %rbp
ret
.p2align 4, 0x90
.globl _p256r1_to_mont
_p256r1_to_mont:
push %rbp
push %rbx
push %r12
push %r13
push %r14
push %r15
lea LRR(%rip), %rbx
call p256r1_mmull
pop %r15
pop %r14
pop %r13
pop %r12
pop %rbx
pop %rbp
ret
.p2align 4, 0x90
.globl _p256r1_sqr_montl
_p256r1_sqr_montl:
push %rbp
push %rbx
push %r12
push %r13
push %r14
push %r15
movq (%rsi), %rbx
movq (8)(%rsi), %rax
mul %rbx
mov %rax, %r9
mov %rdx, %r10
movq (16)(%rsi), %rax
mul %rbx
add %rax, %r10
adc $(0), %rdx
mov %rdx, %r11
movq (24)(%rsi), %rax
mul %rbx
add %rax, %r11
adc $(0), %rdx
mov %rdx, %r12
movq (8)(%rsi), %rbx
movq (16)(%rsi), %rax
mul %rbx
add %rax, %r11
adc $(0), %rdx
mov %rdx, %rbp
movq (24)(%rsi), %rax
mul %rbx
add %rax, %r12
adc $(0), %rdx
add %rbp, %r12
adc $(0), %rdx
mov %rdx, %r13
movq (16)(%rsi), %rbx
movq (24)(%rsi), %rax
mul %rbx
add %rax, %r13
adc $(0), %rdx
mov %rdx, %r14
xor %r15, %r15
shld $(1), %r14, %r15
shld $(1), %r13, %r14
shld $(1), %r12, %r13
shld $(1), %r11, %r12
shld $(1), %r10, %r11
shld $(1), %r9, %r10
shl $(1), %r9
movq (%rsi), %rax
mul %rax
mov %rax, %r8
add %rdx, %r9
adc $(0), %r10
movq (8)(%rsi), %rax
mul %rax
add %rax, %r10
adc %rdx, %r11
adc $(0), %r12
movq (16)(%rsi), %rax
mul %rax
add %rax, %r12
adc %rdx, %r13
adc $(0), %r14
movq (24)(%rsi), %rax
mul %rax
add %rax, %r14
adc %rdx, %r15
mov %r8, %rcx
shl $(32), %rcx
mov %r8, %rbp
shr $(32), %rbp
mov %r8, %rbx
mov %r8, %rdx
xor %r8, %r8
sub %rcx, %rbx
sbb %rbp, %rdx
add %rcx, %r9
adc %rbp, %r10
adc %rbx, %r11
adc %rdx, %r12
adc $(0), %r8
mov %r9, %rcx
shl $(32), %rcx
mov %r9, %rbp
shr $(32), %rbp
mov %r9, %rbx
mov %r9, %rdx
xor %r9, %r9
sub %rcx, %rbx
sbb %rbp, %rdx
add %rcx, %r10
adc %rbp, %r11
adc %rbx, %r12
adc %rdx, %r13
adc $(0), %r9
add %r8, %r13
adc $(0), %r9
mov %r10, %rcx
shl $(32), %rcx
mov %r10, %rbp
shr $(32), %rbp
mov %r10, %rbx
mov %r10, %rdx
xor %r10, %r10
sub %rcx, %rbx
sbb %rbp, %rdx
add %rcx, %r11
adc %rbp, %r12
adc %rbx, %r13
adc %rdx, %r14
adc $(0), %r10
add %r9, %r14
adc $(0), %r10
mov %r11, %rcx
shl $(32), %rcx
mov %r11, %rbp
shr $(32), %rbp
mov %r11, %rbx
mov %r11, %rdx
xor %r11, %r11
sub %rcx, %rbx
sbb %rbp, %rdx
add %rcx, %r12
adc %rbp, %r13
adc %rbx, %r14
adc %rdx, %r15
adc $(0), %r11
add %r10, %r15
adc $(0), %r11
movq Lpoly+0(%rip), %rcx
movq Lpoly+8(%rip), %rbp
movq Lpoly+16(%rip), %rbx
movq Lpoly+24(%rip), %rdx
mov %r12, %rax
mov %r13, %r8
mov %r14, %r9
mov %r15, %r10
sub %rcx, %rax
sbb %rbp, %r8
sbb %rbx, %r9
sbb %rdx, %r10
sbb $(0), %r11
cmovnc %rax, %r12
cmovnc %r8, %r13
cmovnc %r9, %r14
cmovnc %r10, %r15
movq %r12, (%rdi)
movq %r13, (8)(%rdi)
movq %r14, (16)(%rdi)
movq %r15, (24)(%rdi)
pop %r15
pop %r14
pop %r13
pop %r12
pop %rbx
pop %rbp
ret
.p2align 4, 0x90
.globl _p256r1_mont_back
_p256r1_mont_back:
push %r12
push %r13
movq (%rsi), %r10
movq (8)(%rsi), %r11
movq (16)(%rsi), %r12
movq (24)(%rsi), %r13
xor %r8, %r8
xor %r9, %r9
mov %r10, %rax
shl $(32), %rax
mov %r10, %rdx
shr $(32), %rdx
mov %r10, %rcx
mov %r10, %rsi
xor %r10, %r10
sub %rax, %rcx
sbb %rdx, %rsi
add %rax, %r11
adc %rdx, %r12
adc %rcx, %r13
adc %rsi, %r8
adc $(0), %r9
mov %r11, %rax
shl $(32), %rax
mov %r11, %rdx
shr $(32), %rdx
mov %r11, %rcx
mov %r11, %rsi
xor %r11, %r11
sub %rax, %rcx
sbb %rdx, %rsi
add %rax, %r12
adc %rdx, %r13
adc %rcx, %r8
adc %rsi, %r9
adc $(0), %r10
mov %r12, %rax
shl $(32), %rax
mov %r12, %rdx
shr $(32), %rdx
mov %r12, %rcx
mov %r12, %rsi
xor %r12, %r12
sub %rax, %rcx
sbb %rdx, %rsi
add %rax, %r13
adc %rdx, %r8
adc %rcx, %r9
adc %rsi, %r10
adc $(0), %r11
mov %r13, %rax
shl $(32), %rax
mov %r13, %rdx
shr $(32), %rdx
mov %r13, %rcx
mov %r13, %rsi
xor %r13, %r13
sub %rax, %rcx
sbb %rdx, %rsi
add %rax, %r8
adc %rdx, %r9
adc %rcx, %r10
adc %rsi, %r11
adc $(0), %r12
mov %r8, %rax
mov %r9, %rdx
mov %r10, %rcx
mov %r11, %rsi
subq Lpoly+0(%rip), %rax
sbbq Lpoly+8(%rip), %rdx
sbbq Lpoly+16(%rip), %rcx
sbbq Lpoly+24(%rip), %rsi
sbb $(0), %r12
cmovnc %rax, %r8
cmovnc %rdx, %r9
cmovnc %rcx, %r10
cmovnc %rsi, %r11
movq %r8, (%rdi)
movq %r9, (8)(%rdi)
movq %r10, (16)(%rdi)
movq %r11, (24)(%rdi)
pop %r13
pop %r12
ret
.p2align 4, 0x90
.globl _p256r1_select_pp_w5
_p256r1_select_pp_w5:
push %r12
push %r13
movdqa LOne(%rip), %xmm0
movdqa %xmm0, %xmm8
movd %edx, %xmm1
pshufd $(0), %xmm1, %xmm1
pxor %xmm2, %xmm2
pxor %xmm3, %xmm3
pxor %xmm4, %xmm4
pxor %xmm5, %xmm5
pxor %xmm6, %xmm6
pxor %xmm7, %xmm7
mov $(16), %rcx
.Lselect_loop_sse_w5gas_11:
movdqa %xmm8, %xmm15
pcmpeqd %xmm1, %xmm15
paddd %xmm0, %xmm8
movdqa (%rsi), %xmm9
movdqa (16)(%rsi), %xmm10
movdqa (32)(%rsi), %xmm11
movdqa (48)(%rsi), %xmm12
movdqa (64)(%rsi), %xmm13
movdqa (80)(%rsi), %xmm14
add $(96), %rsi
pand %xmm15, %xmm9
pand %xmm15, %xmm10
pand %xmm15, %xmm11
pand %xmm15, %xmm12
pand %xmm15, %xmm13
pand %xmm15, %xmm14
por %xmm9, %xmm2
por %xmm10, %xmm3
por %xmm11, %xmm4
por %xmm12, %xmm5
por %xmm13, %xmm6
por %xmm14, %xmm7
dec %rcx
jnz .Lselect_loop_sse_w5gas_11
movdqu %xmm2, (%rdi)
movdqu %xmm3, (16)(%rdi)
movdqu %xmm4, (32)(%rdi)
movdqu %xmm5, (48)(%rdi)
movdqu %xmm6, (64)(%rdi)
movdqu %xmm7, (80)(%rdi)
pop %r13
pop %r12
ret
.p2align 4, 0x90
.globl _p256r1_select_ap_w7
_p256r1_select_ap_w7:
push %r12
push %r13
movdqa LOne(%rip), %xmm0
pxor %xmm2, %xmm2
pxor %xmm3, %xmm3
pxor %xmm4, %xmm4
pxor %xmm5, %xmm5
movdqa %xmm0, %xmm8
movd %edx, %xmm1
pshufd $(0), %xmm1, %xmm1
mov $(64), %rcx
.Lselect_loop_sse_w7gas_12:
movdqa %xmm8, %xmm15
pcmpeqd %xmm1, %xmm15
paddd %xmm0, %xmm8
movdqa (%rsi), %xmm9
movdqa (16)(%rsi), %xmm10
movdqa (32)(%rsi), %xmm11
movdqa (48)(%rsi), %xmm12
add $(64), %rsi
pand %xmm15, %xmm9
pand %xmm15, %xmm10
pand %xmm15, %xmm11
pand %xmm15, %xmm12
por %xmm9, %xmm2
por %xmm10, %xmm3
por %xmm11, %xmm4
por %xmm12, %xmm5
dec %rcx
jnz .Lselect_loop_sse_w7gas_12
movdqu %xmm2, (%rdi)
movdqu %xmm3, (16)(%rdi)
movdqu %xmm4, (32)(%rdi)
movdqu %xmm5, (48)(%rdi)
pop %r13
pop %r12
ret
|
.size 8000
.text@48
jp lstatint
.text@100
jp lbegin
.data@143
80
.text@150
lbegin:
ld a, ff
ldff(45), a
ld b, 96
call lwaitly_b
ld a, 40
ldff(41), a
ld a, 02
ldff(ff), a
xor a, a
ldff(0f), a
ei
ld a, b
inc a
inc a
ldff(45), a
ld c, 41
.text@1000
lstatint:
ld a, 99
ldff(45), a
.text@1067
ldff a, (c)
jp lprint_a
.text@7000
lprint_a:
push af
ld b, 91
call lwaitly_b
xor a, a
ldff(40), a
ld bc, 7a00
ld hl, 8000
ld d, 00
lprint_copytiles:
ld a, (bc)
inc bc
ld(hl++), a
dec d
jrnz lprint_copytiles
pop af
ld b, a
srl a
srl a
srl a
srl a
ld(9800), a
ld a, b
and a, 0f
ld(9801), a
ld a, c0
ldff(47), a
ld a, 80
ldff(68), a
ld a, ff
ldff(69), a
ldff(69), a
ldff(69), a
ldff(69), a
ldff(69), a
ldff(69), a
xor a, a
ldff(69), a
ldff(69), a
ldff(43), a
ld a, 91
ldff(40), a
lprint_limbo:
jr lprint_limbo
.text@7400
lwaitly_b:
ld c, 44
lwaitly_b_loop:
ldff a, (c)
cmp a, b
jrnz lwaitly_b_loop
ret
.data@7a00
00 00 7f 7f 41 41 41 41
41 41 41 41 41 41 7f 7f
00 00 08 08 08 08 08 08
08 08 08 08 08 08 08 08
00 00 7f 7f 01 01 01 01
7f 7f 40 40 40 40 7f 7f
00 00 7f 7f 01 01 01 01
3f 3f 01 01 01 01 7f 7f
00 00 41 41 41 41 41 41
7f 7f 01 01 01 01 01 01
00 00 7f 7f 40 40 40 40
7e 7e 01 01 01 01 7e 7e
00 00 7f 7f 40 40 40 40
7f 7f 41 41 41 41 7f 7f
00 00 7f 7f 01 01 02 02
04 04 08 08 10 10 10 10
00 00 3e 3e 41 41 41 41
3e 3e 41 41 41 41 3e 3e
00 00 7f 7f 41 41 41 41
7f 7f 01 01 01 01 7f 7f
00 00 08 08 22 22 41 41
7f 7f 41 41 41 41 41 41
00 00 7e 7e 41 41 41 41
7e 7e 41 41 41 41 7e 7e
00 00 3e 3e 41 41 40 40
40 40 40 40 41 41 3e 3e
00 00 7e 7e 41 41 41 41
41 41 41 41 41 41 7e 7e
00 00 7f 7f 40 40 40 40
7f 7f 40 40 40 40 7f 7f
00 00 7f 7f 40 40 40 40
7f 7f 40 40 40 40 40 40
|
; Kernel error screen - give error code in A. Will not return.
; Set bit 7 of A if it may be possible to recover
panic:
di
ld sp, kernelGarbage + kernelGarbageSize
push af
#ifdef COLOR
; Set GPIO config
ld a, 0xE0
out (PORT_GPIO_CONFIG), a
call colorLcdOn
call clearColorLcd
call setLegacyLcdMode
#else
; Reset the screen to a usable state
ld a, 1 + LCD_CMD_AUTOINCDEC_SETX
call lcdDelay
out (PORT_LCD_CMD), a
ld a, 1 + LCD_CMD_SETOUTPUTMODE
call lcdDelay
out (PORT_LCD_CMD), a
ld a, 1 + LCD_CMD_SETDISPLAY
call lcdDelay
out (PORT_LCD_CMD), a
ld a, 7 + LCD_CMD_POWERSUPPLY_SETLEVEL
call lcdDelay
out (PORT_LCD_CMD), a
ld a, 3 + LCD_CMD_POWERSUPPLY_SETENHANCEMENT
call lcdDelay
out (PORT_LCD_CMD), a
#endif
pop af
bit 7, a
jr z, _
call allocScreenBuffer
jr z, ++_
_: ld iy, 0xC000
_: call clearBuffer
; Draw sad calculator
ld de, 2 << 8 | 2
ld b, 22
ld hl, sad_calc
call putSprite16OR
; Find the appropriate error message
ld de, 16 << 8 | 6
ld b, 16
ld hl, errorMessage
rst 0x20
.dw drawStr
push af
rst 0x20
.dw drawHexA
pop af
ld c, 0
bit 7, a
jr z, _
ld c, 1 ; Save this for later, we can recover from this crash
res 7, a
_: ld hl, errorTable
add a
add l
ld l, a
jr nc, _
inc h
_: ld e, (hl)
inc hl
ld d, (hl)
ex de, hl
ld de, 16 << 8 | 12
rst 0x20
.dw drawStr
ld a, c
cp 1
jr z, attemptRecovery
ld de, 1 << 8 | 36
ld hl, continueMessage
rst 0x20
.dw drawStr
; We could just directly output to the screen and maybe be a
; little safer, but we need to clear the screen as well and
; this saves enough space to make it worth doing.
call fastCopy_skipCheck
call flushkeys_skipCheck
_: call getKey_skipCheck
or a
jr z, -_
call flushkeys_skipCheck
jp boot
attemptRecovery:
ld de, 1 << 8 | 29
ld b , 10
ld hl, recoveryMessage
rst 0x20
.dw drawStr
call fastCopy_skipCheck
_: call getKey_skipCheck
cp kPlus
jr z, recover
cp kMinus
jp z, boot
jr -_
recover:
; Give the first thread in the thread table control and hope for the best
ld a, (threadTable)
ld (hwLockLCD), a
ld (hwLockKeypad), a
call resumeThread
; TODO: Clean up unclaimed memory
jp contextSwitch_manual
errorMessage:
.db "::Kernel Error ", 0
continueMessage:
.db "Press a key to shut down", 0
recoveryMessage:
.db "Recovery may be possible\n"
.db "+: Attempt recovery\n"
.db "-: Shut down\n"
.db "\n Press a key", 0
errorTable:
.dw init_not_found_text
.dw no_threads_text
.dw no_active_threads_text
.dw library_not_found_text
init_not_found_text:
.db "/bin/init not found", 0
no_threads_text:
.db "No running threads", 0
no_active_threads_text:
.db "No active threads", 0
library_not_found_text:
.db "Library not loaded", 0
sad_calc:
.db 0x7f,0xc0
.db 0xff,0xe0
.db 0xc0,0x60
.db 0xd1,0x60
.db 0xc0,0x60
.db 0xce,0x60
.db 0xd1,0x60
.db 0xc0,0x60
.db 0xff,0xe0
.db 0xff,0xe0
.db 0x80,0x20
.db 0xa9,0x20
.db 0x83,0xa0
.db 0xa9,0x20
.db 0x80,0x20
.db 0xaa,0xa0
.db 0x80,0x20
.db 0xaa,0xa0
.db 0x80,0x20
.db 0x80,0x20
.db 0x7f,0xc0
.db 0x00,0x00
|
; A108122: G.f.: (1-2*x^2)/(1-x-2*x^2-x^3).
; 1,1,1,4,7,16,34,73,157,337,724,1555,3340,7174,15409,33097,71089,152692,327967,704440,1513066,3249913,6980485,14993377,32204260,69171499,148573396,319120654,685438945,1472253649,3162252193,6792198436,14588956471,31335605536,67305716914,144565884457,310512923821,666950409649,1432542141748,3076955884867,6608990578012,14195444489494,30490381530385,65490261087385,140666468637649,302137372342804,648960570705487,1393901784028744,2993960297782522,6430724436545497,13812546816139285,29667955987012801
mul $0,2
trn $0,5
seq $0,23435 ; Dying rabbits: a(n) = a(n-1) + a(n-2) - a(n-5).
mul $0,3
add $0,1
|
; All header by CodePulse
section .multiboot_header
header_start:
; magic number
dd 0xe85250d6 ; multiboot2
; architecture
dd 0 ; protected mode i386
; header length
dd header_end - header_start
; checksum
dd 0x100000000 - (0xe85250d6 + 0 + (header_end - header_start))
; end tag
dw 0
dw 0
dd 8
header_end:
|
#include<iostream>
#include<memory>
using namespace std;
class User{
public:
User(){
cout<<"User Created\n";
}
~User(){
cout<<"User Destroyed\n";
}
void testFunc(){
cout<<"I am a test function\n";
}
};
int main(){
{
shared_ptr<User> tim = make_shared<User>();
tim->testFunc();
shared_ptr<User> timm = tim; //Allowed here
timm->testFunc();
}
cout<<"Outside scope\n";
return 0;
} |
;
; Copyright (c) 2010 The WebM project authors. All Rights Reserved.
;
; Use of this source code is governed by a BSD-style license
; that can be found in the LICENSE file in the root of the source
; tree. An additional intellectual property rights grant can be found
; in the file PATENTS. All contributing project authors may
; be found in the AUTHORS file in the root of the source tree.
;
EXPORT |vp8_loop_filter_horizontal_edge_armv6|
EXPORT |vp8_mbloop_filter_horizontal_edge_armv6|
EXPORT |vp8_loop_filter_vertical_edge_armv6|
EXPORT |vp8_mbloop_filter_vertical_edge_armv6|
AREA |.text|, CODE, READONLY ; name this block of code
MACRO
TRANSPOSE_MATRIX $a0, $a1, $a2, $a3, $b0, $b1, $b2, $b3
; input: $a0, $a1, $a2, $a3; output: $b0, $b1, $b2, $b3
; a0: 03 02 01 00
; a1: 13 12 11 10
; a2: 23 22 21 20
; a3: 33 32 31 30
; b3 b2 b1 b0
uxtb16 $b1, $a1 ; xx 12 xx 10
uxtb16 $b0, $a0 ; xx 02 xx 00
uxtb16 $b3, $a3 ; xx 32 xx 30
uxtb16 $b2, $a2 ; xx 22 xx 20
orr $b1, $b0, $b1, lsl #8 ; 12 02 10 00
orr $b3, $b2, $b3, lsl #8 ; 32 22 30 20
uxtb16 $a1, $a1, ror #8 ; xx 13 xx 11
uxtb16 $a3, $a3, ror #8 ; xx 33 xx 31
uxtb16 $a0, $a0, ror #8 ; xx 03 xx 01
uxtb16 $a2, $a2, ror #8 ; xx 23 xx 21
orr $a0, $a0, $a1, lsl #8 ; 13 03 11 01
orr $a2, $a2, $a3, lsl #8 ; 33 23 31 21
pkhtb $b2, $b3, $b1, asr #16 ; 32 22 12 02 -- p1
pkhbt $b0, $b1, $b3, lsl #16 ; 30 20 10 00 -- p3
pkhtb $b3, $a2, $a0, asr #16 ; 33 23 13 03 -- p0
pkhbt $b1, $a0, $a2, lsl #16 ; 31 21 11 01 -- p2
MEND
src RN r0
pstep RN r1
count RN r5
;r0 unsigned char *src_ptr,
;r1 int src_pixel_step,
;r2 const char *flimit,
;r3 const char *limit,
;stack const char *thresh,
;stack int count
;Note: All 16 elements in flimit are equal. So, in the code, only one load is needed
;for flimit. Same way applies to limit and thresh.
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|vp8_loop_filter_horizontal_edge_armv6| PROC
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
stmdb sp!, {r4 - r11, lr}
sub src, src, pstep, lsl #2 ; move src pointer down by 4 lines
ldr count, [sp, #40] ; count for 8-in-parallel
ldr r6, [sp, #36] ; load thresh address
sub sp, sp, #16 ; create temp buffer
ldr r9, [src], pstep ; p3
ldr r4, [r2], #4 ; flimit
ldr r10, [src], pstep ; p2
ldr r2, [r3], #4 ; limit
ldr r11, [src], pstep ; p1
uadd8 r4, r4, r4 ; flimit * 2
ldr r3, [r6], #4 ; thresh
mov count, count, lsl #1 ; 4-in-parallel
uadd8 r4, r4, r2 ; flimit * 2 + limit
|Hnext8|
; vp8_filter_mask() function
; calculate breakout conditions
ldr r12, [src], pstep ; p0
uqsub8 r6, r9, r10 ; p3 - p2
uqsub8 r7, r10, r9 ; p2 - p3
uqsub8 r8, r10, r11 ; p2 - p1
uqsub8 r10, r11, r10 ; p1 - p2
orr r6, r6, r7 ; abs (p3-p2)
orr r8, r8, r10 ; abs (p2-p1)
uqsub8 lr, r6, r2 ; compare to limit. lr: vp8_filter_mask
uqsub8 r8, r8, r2 ; compare to limit
uqsub8 r6, r11, r12 ; p1 - p0
orr lr, lr, r8
uqsub8 r7, r12, r11 ; p0 - p1
ldr r9, [src], pstep ; q0
ldr r10, [src], pstep ; q1
orr r6, r6, r7 ; abs (p1-p0)
uqsub8 r7, r6, r2 ; compare to limit
uqsub8 r8, r6, r3 ; compare to thresh -- save r8 for later
orr lr, lr, r7
uqsub8 r6, r11, r10 ; p1 - q1
uqsub8 r7, r10, r11 ; q1 - p1
uqsub8 r11, r12, r9 ; p0 - q0
uqsub8 r12, r9, r12 ; q0 - p0
orr r6, r6, r7 ; abs (p1-q1)
ldr r7, c0x7F7F7F7F
orr r12, r11, r12 ; abs (p0-q0)
ldr r11, [src], pstep ; q2
uqadd8 r12, r12, r12 ; abs (p0-q0) * 2
and r6, r7, r6, lsr #1 ; abs (p1-q1) / 2
uqsub8 r7, r9, r10 ; q0 - q1
uqadd8 r12, r12, r6 ; abs (p0-q0)*2 + abs (p1-q1)/2
uqsub8 r6, r10, r9 ; q1 - q0
uqsub8 r12, r12, r4 ; compare to flimit
uqsub8 r9, r11, r10 ; q2 - q1
orr lr, lr, r12
ldr r12, [src], pstep ; q3
uqsub8 r10, r10, r11 ; q1 - q2
orr r6, r7, r6 ; abs (q1-q0)
orr r10, r9, r10 ; abs (q2-q1)
uqsub8 r7, r6, r2 ; compare to limit
uqsub8 r10, r10, r2 ; compare to limit
uqsub8 r6, r6, r3 ; compare to thresh -- save r6 for later
orr lr, lr, r7
orr lr, lr, r10
uqsub8 r10, r12, r11 ; q3 - q2
uqsub8 r9, r11, r12 ; q2 - q3
mvn r11, #0 ; r11 == -1
orr r10, r10, r9 ; abs (q3-q2)
uqsub8 r10, r10, r2 ; compare to limit
mov r12, #0
orr lr, lr, r10
sub src, src, pstep, lsl #2
usub8 lr, r12, lr ; use usub8 instead of ssub8
sel lr, r11, r12 ; filter mask: lr
cmp lr, #0
beq hskip_filter ; skip filtering
sub src, src, pstep, lsl #1 ; move src pointer down by 6 lines
;vp8_hevmask() function
;calculate high edge variance
orr r10, r6, r8 ; calculate vp8_hevmask
ldr r7, [src], pstep ; p1
usub8 r10, r12, r10 ; use usub8 instead of ssub8
sel r6, r12, r11 ; obtain vp8_hevmask: r6
;vp8_filter() function
ldr r8, [src], pstep ; p0
ldr r12, c0x80808080
ldr r9, [src], pstep ; q0
ldr r10, [src], pstep ; q1
eor r7, r7, r12 ; p1 offset to convert to a signed value
eor r8, r8, r12 ; p0 offset to convert to a signed value
eor r9, r9, r12 ; q0 offset to convert to a signed value
eor r10, r10, r12 ; q1 offset to convert to a signed value
str r9, [sp] ; store qs0 temporarily
str r8, [sp, #4] ; store ps0 temporarily
str r10, [sp, #8] ; store qs1 temporarily
str r7, [sp, #12] ; store ps1 temporarily
qsub8 r7, r7, r10 ; vp8_signed_char_clamp(ps1-qs1)
qsub8 r8, r9, r8 ; vp8_signed_char_clamp(vp8_filter + 3 * ( qs0 - ps0))
and r7, r7, r6 ; vp8_filter (r7) &= hev
qadd8 r7, r7, r8
ldr r9, c0x03030303 ; r9 = 3 --modified for vp8
qadd8 r7, r7, r8
ldr r10, c0x04040404
qadd8 r7, r7, r8
and r7, r7, lr ; vp8_filter &= mask;
;modify code for vp8 -- Filter1 = vp8_filter (r7)
qadd8 r8 , r7 , r9 ; Filter2 (r8) = vp8_signed_char_clamp(vp8_filter+3)
qadd8 r7 , r7 , r10 ; vp8_filter = vp8_signed_char_clamp(vp8_filter+4)
mov r9, #0
shadd8 r8 , r8 , r9 ; Filter2 >>= 3
shadd8 r7 , r7 , r9 ; vp8_filter >>= 3
shadd8 r8 , r8 , r9
shadd8 r7 , r7 , r9
shadd8 lr , r8 , r9 ; lr: Filter2
shadd8 r7 , r7 , r9 ; r7: filter
;usub8 lr, r8, r10 ; s = (s==4)*-1
;sel lr, r11, r9
;usub8 r8, r10, r8
;sel r8, r11, r9
;and r8, r8, lr ; -1 for each element that equals 4
;calculate output
;qadd8 lr, r8, r7 ; u = vp8_signed_char_clamp(s + vp8_filter)
ldr r8, [sp] ; load qs0
ldr r9, [sp, #4] ; load ps0
ldr r10, c0x01010101
qsub8 r8 ,r8, r7 ; u = vp8_signed_char_clamp(qs0 - vp8_filter)
qadd8 r9, r9, lr ; u = vp8_signed_char_clamp(ps0 + Filter2)
;end of modification for vp8
mov lr, #0
sadd8 r7, r7 , r10 ; vp8_filter += 1
shadd8 r7, r7, lr ; vp8_filter >>= 1
ldr r11, [sp, #12] ; load ps1
ldr r10, [sp, #8] ; load qs1
bic r7, r7, r6 ; vp8_filter &= ~hev
sub src, src, pstep, lsl #2
qadd8 r11, r11, r7 ; u = vp8_signed_char_clamp(ps1 + vp8_filter)
qsub8 r10, r10,r7 ; u = vp8_signed_char_clamp(qs1 - vp8_filter)
eor r11, r11, r12 ; *op1 = u^0x80
str r11, [src], pstep ; store op1
eor r9, r9, r12 ; *op0 = u^0x80
str r9, [src], pstep ; store op0 result
eor r8, r8, r12 ; *oq0 = u^0x80
str r8, [src], pstep ; store oq0 result
eor r10, r10, r12 ; *oq1 = u^0x80
str r10, [src], pstep ; store oq1
sub src, src, pstep, lsl #1
|hskip_filter|
add src, src, #4
sub src, src, pstep, lsl #2
subs count, count, #1
;pld [src]
;pld [src, pstep]
;pld [src, pstep, lsl #1]
;pld [src, pstep, lsl #2]
;pld [src, pstep, lsl #3]
ldrne r9, [src], pstep ; p3
ldrne r10, [src], pstep ; p2
ldrne r11, [src], pstep ; p1
bne Hnext8
add sp, sp, #16
ldmia sp!, {r4 - r11, pc}
ENDP ; |vp8_loop_filter_horizontal_edge_armv6|
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|vp8_mbloop_filter_horizontal_edge_armv6| PROC
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
stmdb sp!, {r4 - r11, lr}
sub src, src, pstep, lsl #2 ; move src pointer down by 4 lines
ldr count, [sp, #40] ; count for 8-in-parallel
ldr r6, [sp, #36] ; load thresh address
sub sp, sp, #16 ; create temp buffer
ldr r9, [src], pstep ; p3
ldr r4, [r2], #4 ; flimit
ldr r10, [src], pstep ; p2
ldr r2, [r3], #4 ; limit
ldr r11, [src], pstep ; p1
uadd8 r4, r4, r4 ; flimit * 2
ldr r3, [r6], #4 ; thresh
mov count, count, lsl #1 ; 4-in-parallel
uadd8 r4, r4, r2 ; flimit * 2 + limit
|MBHnext8|
; vp8_filter_mask() function
; calculate breakout conditions
ldr r12, [src], pstep ; p0
uqsub8 r6, r9, r10 ; p3 - p2
uqsub8 r7, r10, r9 ; p2 - p3
uqsub8 r8, r10, r11 ; p2 - p1
uqsub8 r10, r11, r10 ; p1 - p2
orr r6, r6, r7 ; abs (p3-p2)
orr r8, r8, r10 ; abs (p2-p1)
uqsub8 lr, r6, r2 ; compare to limit. lr: vp8_filter_mask
uqsub8 r8, r8, r2 ; compare to limit
uqsub8 r6, r11, r12 ; p1 - p0
orr lr, lr, r8
uqsub8 r7, r12, r11 ; p0 - p1
ldr r9, [src], pstep ; q0
ldr r10, [src], pstep ; q1
orr r6, r6, r7 ; abs (p1-p0)
uqsub8 r7, r6, r2 ; compare to limit
uqsub8 r8, r6, r3 ; compare to thresh -- save r8 for later
orr lr, lr, r7
uqsub8 r6, r11, r10 ; p1 - q1
uqsub8 r7, r10, r11 ; q1 - p1
uqsub8 r11, r12, r9 ; p0 - q0
uqsub8 r12, r9, r12 ; q0 - p0
orr r6, r6, r7 ; abs (p1-q1)
ldr r7, c0x7F7F7F7F
orr r12, r11, r12 ; abs (p0-q0)
ldr r11, [src], pstep ; q2
uqadd8 r12, r12, r12 ; abs (p0-q0) * 2
and r6, r7, r6, lsr #1 ; abs (p1-q1) / 2
uqsub8 r7, r9, r10 ; q0 - q1
uqadd8 r12, r12, r6 ; abs (p0-q0)*2 + abs (p1-q1)/2
uqsub8 r6, r10, r9 ; q1 - q0
uqsub8 r12, r12, r4 ; compare to flimit
uqsub8 r9, r11, r10 ; q2 - q1
orr lr, lr, r12
ldr r12, [src], pstep ; q3
uqsub8 r10, r10, r11 ; q1 - q2
orr r6, r7, r6 ; abs (q1-q0)
orr r10, r9, r10 ; abs (q2-q1)
uqsub8 r7, r6, r2 ; compare to limit
uqsub8 r10, r10, r2 ; compare to limit
uqsub8 r6, r6, r3 ; compare to thresh -- save r6 for later
orr lr, lr, r7
orr lr, lr, r10
uqsub8 r10, r12, r11 ; q3 - q2
uqsub8 r9, r11, r12 ; q2 - q3
mvn r11, #0 ; r11 == -1
orr r10, r10, r9 ; abs (q3-q2)
uqsub8 r10, r10, r2 ; compare to limit
mov r12, #0
orr lr, lr, r10
usub8 lr, r12, lr ; use usub8 instead of ssub8
sel lr, r11, r12 ; filter mask: lr
cmp lr, #0
beq mbhskip_filter ; skip filtering
;vp8_hevmask() function
;calculate high edge variance
sub src, src, pstep, lsl #2 ; move src pointer down by 6 lines
sub src, src, pstep, lsl #1
orr r10, r6, r8
ldr r7, [src], pstep ; p1
usub8 r10, r12, r10
sel r6, r12, r11 ; hev mask: r6
;vp8_mbfilter() function
;p2, q2 are only needed at the end. Don't need to load them in now.
ldr r8, [src], pstep ; p0
ldr r12, c0x80808080
ldr r9, [src], pstep ; q0
ldr r10, [src] ; q1
eor r7, r7, r12 ; ps1
eor r8, r8, r12 ; ps0
eor r9, r9, r12 ; qs0
eor r10, r10, r12 ; qs1
qsub8 r12, r9, r8 ; vp8_signed_char_clamp(vp8_filter + 3 * ( qs0 - ps0))
str r7, [sp, #12] ; store ps1 temporarily
qsub8 r7, r7, r10 ; vp8_signed_char_clamp(ps1-qs1)
str r10, [sp, #8] ; store qs1 temporarily
qadd8 r7, r7, r12
str r9, [sp] ; store qs0 temporarily
qadd8 r7, r7, r12
str r8, [sp, #4] ; store ps0 temporarily
qadd8 r7, r7, r12 ; vp8_filter: r7
ldr r10, c0x03030303 ; r10 = 3 --modified for vp8
ldr r9, c0x04040404
and r7, r7, lr ; vp8_filter &= mask (lr is free)
mov r12, r7 ; Filter2: r12
and r12, r12, r6 ; Filter2 &= hev
;modify code for vp8
;save bottom 3 bits so that we round one side +4 and the other +3
qadd8 r8 , r12 , r9 ; Filter1 (r8) = vp8_signed_char_clamp(Filter2+4)
qadd8 r12 , r12 , r10 ; Filter2 (r12) = vp8_signed_char_clamp(Filter2+3)
mov r10, #0
shadd8 r8 , r8 , r10 ; Filter1 >>= 3
shadd8 r12 , r12 , r10 ; Filter2 >>= 3
shadd8 r8 , r8 , r10
shadd8 r12 , r12 , r10
shadd8 r8 , r8 , r10 ; r8: Filter1
shadd8 r12 , r12 , r10 ; r12: Filter2
ldr r9, [sp] ; load qs0
ldr r11, [sp, #4] ; load ps0
qsub8 r9 , r9, r8 ; qs0 = vp8_signed_char_clamp(qs0 - Filter1)
qadd8 r11, r11, r12 ; ps0 = vp8_signed_char_clamp(ps0 + Filter2)
;save bottom 3 bits so that we round one side +4 and the other +3
;and r8, r12, r10 ; s = Filter2 & 7 (s: r8)
;qadd8 r12 , r12 , r9 ; Filter2 = vp8_signed_char_clamp(Filter2+4)
;mov r10, #0
;shadd8 r12 , r12 , r10 ; Filter2 >>= 3
;usub8 lr, r8, r9 ; s = (s==4)*-1
;sel lr, r11, r10
;shadd8 r12 , r12 , r10
;usub8 r8, r9, r8
;sel r8, r11, r10
;ldr r9, [sp] ; load qs0
;ldr r11, [sp, #4] ; load ps0
;shadd8 r12 , r12 , r10
;and r8, r8, lr ; -1 for each element that equals 4
;qadd8 r10, r8, r12 ; u = vp8_signed_char_clamp(s + Filter2)
;qsub8 r9 , r9, r12 ; qs0 = vp8_signed_char_clamp(qs0 - Filter2)
;qadd8 r11, r11, r10 ; ps0 = vp8_signed_char_clamp(ps0 + u)
;end of modification for vp8
bic r12, r7, r6 ; vp8_filter &= ~hev ( r6 is free)
;mov r12, r7
;roughly 3/7th difference across boundary
mov lr, #0x1b ; 27
mov r7, #0x3f ; 63
sxtb16 r6, r12
sxtb16 r10, r12, ror #8
smlabb r8, r6, lr, r7
smlatb r6, r6, lr, r7
smlabb r7, r10, lr, r7
smultb r10, r10, lr
ssat r8, #8, r8, asr #7
ssat r6, #8, r6, asr #7
add r10, r10, #63
ssat r7, #8, r7, asr #7
ssat r10, #8, r10, asr #7
ldr lr, c0x80808080
pkhbt r6, r8, r6, lsl #16
pkhbt r10, r7, r10, lsl #16
uxtb16 r6, r6
uxtb16 r10, r10
sub src, src, pstep
orr r10, r6, r10, lsl #8 ; u = vp8_signed_char_clamp((63 + Filter2 * 27)>>7)
qsub8 r8, r9, r10 ; s = vp8_signed_char_clamp(qs0 - u)
qadd8 r10, r11, r10 ; s = vp8_signed_char_clamp(ps0 + u)
eor r8, r8, lr ; *oq0 = s^0x80
str r8, [src] ; store *oq0
sub src, src, pstep
eor r10, r10, lr ; *op0 = s^0x80
str r10, [src] ; store *op0
;roughly 2/7th difference across boundary
mov lr, #0x12 ; 18
mov r7, #0x3f ; 63
sxtb16 r6, r12
sxtb16 r10, r12, ror #8
smlabb r8, r6, lr, r7
smlatb r6, r6, lr, r7
smlabb r9, r10, lr, r7
smlatb r10, r10, lr, r7
ssat r8, #8, r8, asr #7
ssat r6, #8, r6, asr #7
ssat r9, #8, r9, asr #7
ssat r10, #8, r10, asr #7
ldr lr, c0x80808080
pkhbt r6, r8, r6, lsl #16
pkhbt r10, r9, r10, lsl #16
ldr r9, [sp, #8] ; load qs1
ldr r11, [sp, #12] ; load ps1
uxtb16 r6, r6
uxtb16 r10, r10
sub src, src, pstep
orr r10, r6, r10, lsl #8 ; u = vp8_signed_char_clamp((63 + Filter2 * 18)>>7)
qadd8 r11, r11, r10 ; s = vp8_signed_char_clamp(ps1 + u)
qsub8 r8, r9, r10 ; s = vp8_signed_char_clamp(qs1 - u)
eor r11, r11, lr ; *op1 = s^0x80
str r11, [src], pstep ; store *op1
eor r8, r8, lr ; *oq1 = s^0x80
add src, src, pstep, lsl #1
mov r7, #0x3f ; 63
str r8, [src], pstep ; store *oq1
;roughly 1/7th difference across boundary
mov lr, #0x9 ; 9
ldr r9, [src] ; load q2
sxtb16 r6, r12
sxtb16 r10, r12, ror #8
smlabb r8, r6, lr, r7
smlatb r6, r6, lr, r7
smlabb r12, r10, lr, r7
smlatb r10, r10, lr, r7
ssat r8, #8, r8, asr #7
ssat r6, #8, r6, asr #7
ssat r12, #8, r12, asr #7
ssat r10, #8, r10, asr #7
sub src, src, pstep, lsl #2
pkhbt r6, r8, r6, lsl #16
pkhbt r10, r12, r10, lsl #16
sub src, src, pstep
ldr lr, c0x80808080
ldr r11, [src] ; load p2
uxtb16 r6, r6
uxtb16 r10, r10
eor r9, r9, lr
eor r11, r11, lr
orr r10, r6, r10, lsl #8 ; u = vp8_signed_char_clamp((63 + Filter2 * 9)>>7)
qadd8 r8, r11, r10 ; s = vp8_signed_char_clamp(ps2 + u)
qsub8 r10, r9, r10 ; s = vp8_signed_char_clamp(qs2 - u)
eor r8, r8, lr ; *op2 = s^0x80
str r8, [src], pstep, lsl #2 ; store *op2
add src, src, pstep
eor r10, r10, lr ; *oq2 = s^0x80
str r10, [src], pstep, lsl #1 ; store *oq2
|mbhskip_filter|
add src, src, #4
sub src, src, pstep, lsl #3
subs count, count, #1
ldrne r9, [src], pstep ; p3
ldrne r10, [src], pstep ; p2
ldrne r11, [src], pstep ; p1
bne MBHnext8
add sp, sp, #16
ldmia sp!, {r4 - r11, pc}
ENDP ; |vp8_mbloop_filter_horizontal_edge_armv6|
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|vp8_loop_filter_vertical_edge_armv6| PROC
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
stmdb sp!, {r4 - r11, lr}
sub src, src, #4 ; move src pointer down by 4
ldr count, [sp, #40] ; count for 8-in-parallel
ldr r12, [sp, #36] ; load thresh address
sub sp, sp, #16 ; create temp buffer
ldr r6, [src], pstep ; load source data
ldr r4, [r2], #4 ; flimit
ldr r7, [src], pstep
ldr r2, [r3], #4 ; limit
ldr r8, [src], pstep
uadd8 r4, r4, r4 ; flimit * 2
ldr r3, [r12], #4 ; thresh
ldr lr, [src], pstep
mov count, count, lsl #1 ; 4-in-parallel
uadd8 r4, r4, r2 ; flimit * 2 + limit
|Vnext8|
; vp8_filter_mask() function
; calculate breakout conditions
; transpose the source data for 4-in-parallel operation
TRANSPOSE_MATRIX r6, r7, r8, lr, r9, r10, r11, r12
uqsub8 r7, r9, r10 ; p3 - p2
uqsub8 r8, r10, r9 ; p2 - p3
uqsub8 r9, r10, r11 ; p2 - p1
uqsub8 r10, r11, r10 ; p1 - p2
orr r7, r7, r8 ; abs (p3-p2)
orr r10, r9, r10 ; abs (p2-p1)
uqsub8 lr, r7, r2 ; compare to limit. lr: vp8_filter_mask
uqsub8 r10, r10, r2 ; compare to limit
sub src, src, pstep, lsl #2 ; move src pointer down by 4 lines
orr lr, lr, r10
uqsub8 r6, r11, r12 ; p1 - p0
uqsub8 r7, r12, r11 ; p0 - p1
add src, src, #4 ; move src pointer up by 4
orr r6, r6, r7 ; abs (p1-p0)
str r11, [sp, #12] ; save p1
uqsub8 r10, r6, r2 ; compare to limit
uqsub8 r11, r6, r3 ; compare to thresh
orr lr, lr, r10
; transpose uses 8 regs(r6 - r12 and lr). Need to save reg value now
; transpose the source data for 4-in-parallel operation
ldr r6, [src], pstep ; load source data
str r11, [sp] ; push r11 to stack
ldr r7, [src], pstep
str r12, [sp, #4] ; save current reg before load q0 - q3 data
ldr r8, [src], pstep
str lr, [sp, #8]
ldr lr, [src], pstep
TRANSPOSE_MATRIX r6, r7, r8, lr, r9, r10, r11, r12
ldr lr, [sp, #8] ; load back (f)limit accumulator
uqsub8 r6, r12, r11 ; q3 - q2
uqsub8 r7, r11, r12 ; q2 - q3
uqsub8 r12, r11, r10 ; q2 - q1
uqsub8 r11, r10, r11 ; q1 - q2
orr r6, r6, r7 ; abs (q3-q2)
orr r7, r12, r11 ; abs (q2-q1)
uqsub8 r6, r6, r2 ; compare to limit
uqsub8 r7, r7, r2 ; compare to limit
ldr r11, [sp, #4] ; load back p0
ldr r12, [sp, #12] ; load back p1
orr lr, lr, r6
orr lr, lr, r7
uqsub8 r6, r11, r9 ; p0 - q0
uqsub8 r7, r9, r11 ; q0 - p0
uqsub8 r8, r12, r10 ; p1 - q1
uqsub8 r11, r10, r12 ; q1 - p1
orr r6, r6, r7 ; abs (p0-q0)
ldr r7, c0x7F7F7F7F
orr r8, r8, r11 ; abs (p1-q1)
uqadd8 r6, r6, r6 ; abs (p0-q0) * 2
and r8, r7, r8, lsr #1 ; abs (p1-q1) / 2
uqsub8 r11, r10, r9 ; q1 - q0
uqadd8 r6, r8, r6 ; abs (p0-q0)*2 + abs (p1-q1)/2
uqsub8 r12, r9, r10 ; q0 - q1
uqsub8 r6, r6, r4 ; compare to flimit
orr r9, r11, r12 ; abs (q1-q0)
uqsub8 r8, r9, r2 ; compare to limit
uqsub8 r10, r9, r3 ; compare to thresh
orr lr, lr, r6
orr lr, lr, r8
mvn r11, #0 ; r11 == -1
mov r12, #0
usub8 lr, r12, lr
ldr r9, [sp] ; load the compared result
sel lr, r11, r12 ; filter mask: lr
cmp lr, #0
beq vskip_filter ; skip filtering
;vp8_hevmask() function
;calculate high edge variance
sub src, src, pstep, lsl #2 ; move src pointer down by 4 lines
orr r9, r9, r10
ldrh r7, [src, #-2]
ldrh r8, [src], pstep
usub8 r9, r12, r9
sel r6, r12, r11 ; hev mask: r6
;vp8_filter() function
; load soure data to r6, r11, r12, lr
ldrh r9, [src, #-2]
ldrh r10, [src], pstep
pkhbt r12, r7, r8, lsl #16
ldrh r7, [src, #-2]
ldrh r8, [src], pstep
pkhbt r11, r9, r10, lsl #16
ldrh r9, [src, #-2]
ldrh r10, [src], pstep
; Transpose needs 8 regs(r6 - r12, and lr). Save r6 and lr first
str r6, [sp]
str lr, [sp, #4]
pkhbt r6, r7, r8, lsl #16
pkhbt lr, r9, r10, lsl #16
;transpose r12, r11, r6, lr to r7, r8, r9, r10
TRANSPOSE_MATRIX r12, r11, r6, lr, r7, r8, r9, r10
;load back hev_mask r6 and filter_mask lr
ldr r12, c0x80808080
ldr r6, [sp]
ldr lr, [sp, #4]
eor r7, r7, r12 ; p1 offset to convert to a signed value
eor r8, r8, r12 ; p0 offset to convert to a signed value
eor r9, r9, r12 ; q0 offset to convert to a signed value
eor r10, r10, r12 ; q1 offset to convert to a signed value
str r9, [sp] ; store qs0 temporarily
str r8, [sp, #4] ; store ps0 temporarily
str r10, [sp, #8] ; store qs1 temporarily
str r7, [sp, #12] ; store ps1 temporarily
qsub8 r7, r7, r10 ; vp8_signed_char_clamp(ps1-qs1)
qsub8 r8, r9, r8 ; vp8_signed_char_clamp(vp8_filter + 3 * ( qs0 - ps0))
and r7, r7, r6 ; vp8_filter (r7) &= hev (r7 : filter)
qadd8 r7, r7, r8
ldr r9, c0x03030303 ; r9 = 3 --modified for vp8
qadd8 r7, r7, r8
ldr r10, c0x04040404
qadd8 r7, r7, r8
;mvn r11, #0 ; r11 == -1
and r7, r7, lr ; vp8_filter &= mask
;modify code for vp8 -- Filter1 = vp8_filter (r7)
qadd8 r8 , r7 , r9 ; Filter2 (r8) = vp8_signed_char_clamp(vp8_filter+3)
qadd8 r7 , r7 , r10 ; vp8_filter = vp8_signed_char_clamp(vp8_filter+4)
mov r9, #0
shadd8 r8 , r8 , r9 ; Filter2 >>= 3
shadd8 r7 , r7 , r9 ; vp8_filter >>= 3
shadd8 r8 , r8 , r9
shadd8 r7 , r7 , r9
shadd8 lr , r8 , r9 ; lr: filter2
shadd8 r7 , r7 , r9 ; r7: filter
;usub8 lr, r8, r10 ; s = (s==4)*-1
;sel lr, r11, r9
;usub8 r8, r10, r8
;sel r8, r11, r9
;and r8, r8, lr ; -1 for each element that equals 4 -- r8: s
;calculate output
;qadd8 lr, r8, r7 ; u = vp8_signed_char_clamp(s + vp8_filter)
ldr r8, [sp] ; load qs0
ldr r9, [sp, #4] ; load ps0
ldr r10, c0x01010101
qsub8 r8, r8, r7 ; u = vp8_signed_char_clamp(qs0 - vp8_filter)
qadd8 r9, r9, lr ; u = vp8_signed_char_clamp(ps0 + Filter2)
;end of modification for vp8
eor r8, r8, r12
eor r9, r9, r12
mov lr, #0
sadd8 r7, r7, r10
shadd8 r7, r7, lr
ldr r10, [sp, #8] ; load qs1
ldr r11, [sp, #12] ; load ps1
bic r7, r7, r6 ; r7: vp8_filter
qsub8 r10 , r10, r7 ; u = vp8_signed_char_clamp(qs1 - vp8_filter)
qadd8 r11, r11, r7 ; u = vp8_signed_char_clamp(ps1 + vp8_filter)
eor r10, r10, r12
eor r11, r11, r12
sub src, src, pstep, lsl #2
;we can use TRANSPOSE_MATRIX macro to transpose output - input: q1, q0, p0, p1
;output is b0, b1, b2, b3
;b0: 03 02 01 00
;b1: 13 12 11 10
;b2: 23 22 21 20
;b3: 33 32 31 30
; p1 p0 q0 q1
; (a3 a2 a1 a0)
TRANSPOSE_MATRIX r11, r9, r8, r10, r6, r7, r12, lr
strh r6, [src, #-2] ; store the result
mov r6, r6, lsr #16
strh r6, [src], pstep
strh r7, [src, #-2]
mov r7, r7, lsr #16
strh r7, [src], pstep
strh r12, [src, #-2]
mov r12, r12, lsr #16
strh r12, [src], pstep
strh lr, [src, #-2]
mov lr, lr, lsr #16
strh lr, [src], pstep
|vskip_filter|
sub src, src, #4
subs count, count, #1
ldrne r6, [src], pstep ; load source data
ldrne r7, [src], pstep
ldrne r8, [src], pstep
ldrne lr, [src], pstep
bne Vnext8
add sp, sp, #16
ldmia sp!, {r4 - r11, pc}
ENDP ; |vp8_loop_filter_vertical_edge_armv6|
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|vp8_mbloop_filter_vertical_edge_armv6| PROC
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
stmdb sp!, {r4 - r11, lr}
sub src, src, #4 ; move src pointer down by 4
ldr count, [sp, #40] ; count for 8-in-parallel
ldr r12, [sp, #36] ; load thresh address
sub sp, sp, #16 ; create temp buffer
ldr r6, [src], pstep ; load source data
ldr r4, [r2], #4 ; flimit
ldr r7, [src], pstep
ldr r2, [r3], #4 ; limit
ldr r8, [src], pstep
uadd8 r4, r4, r4 ; flimit * 2
ldr r3, [r12], #4 ; thresh
ldr lr, [src], pstep
mov count, count, lsl #1 ; 4-in-parallel
uadd8 r4, r4, r2 ; flimit * 2 + limit
|MBVnext8|
; vp8_filter_mask() function
; calculate breakout conditions
; transpose the source data for 4-in-parallel operation
TRANSPOSE_MATRIX r6, r7, r8, lr, r9, r10, r11, r12
uqsub8 r7, r9, r10 ; p3 - p2
uqsub8 r8, r10, r9 ; p2 - p3
uqsub8 r9, r10, r11 ; p2 - p1
uqsub8 r10, r11, r10 ; p1 - p2
orr r7, r7, r8 ; abs (p3-p2)
orr r10, r9, r10 ; abs (p2-p1)
uqsub8 lr, r7, r2 ; compare to limit. lr: vp8_filter_mask
uqsub8 r10, r10, r2 ; compare to limit
sub src, src, pstep, lsl #2 ; move src pointer down by 4 lines
orr lr, lr, r10
uqsub8 r6, r11, r12 ; p1 - p0
uqsub8 r7, r12, r11 ; p0 - p1
add src, src, #4 ; move src pointer up by 4
orr r6, r6, r7 ; abs (p1-p0)
str r11, [sp, #12] ; save p1
uqsub8 r10, r6, r2 ; compare to limit
uqsub8 r11, r6, r3 ; compare to thresh
orr lr, lr, r10
; transpose uses 8 regs(r6 - r12 and lr). Need to save reg value now
; transpose the source data for 4-in-parallel operation
ldr r6, [src], pstep ; load source data
str r11, [sp] ; push r11 to stack
ldr r7, [src], pstep
str r12, [sp, #4] ; save current reg before load q0 - q3 data
ldr r8, [src], pstep
str lr, [sp, #8]
ldr lr, [src], pstep
TRANSPOSE_MATRIX r6, r7, r8, lr, r9, r10, r11, r12
ldr lr, [sp, #8] ; load back (f)limit accumulator
uqsub8 r6, r12, r11 ; q3 - q2
uqsub8 r7, r11, r12 ; q2 - q3
uqsub8 r12, r11, r10 ; q2 - q1
uqsub8 r11, r10, r11 ; q1 - q2
orr r6, r6, r7 ; abs (q3-q2)
orr r7, r12, r11 ; abs (q2-q1)
uqsub8 r6, r6, r2 ; compare to limit
uqsub8 r7, r7, r2 ; compare to limit
ldr r11, [sp, #4] ; load back p0
ldr r12, [sp, #12] ; load back p1
orr lr, lr, r6
orr lr, lr, r7
uqsub8 r6, r11, r9 ; p0 - q0
uqsub8 r7, r9, r11 ; q0 - p0
uqsub8 r8, r12, r10 ; p1 - q1
uqsub8 r11, r10, r12 ; q1 - p1
orr r6, r6, r7 ; abs (p0-q0)
ldr r7, c0x7F7F7F7F
orr r8, r8, r11 ; abs (p1-q1)
uqadd8 r6, r6, r6 ; abs (p0-q0) * 2
and r8, r7, r8, lsr #1 ; abs (p1-q1) / 2
uqsub8 r11, r10, r9 ; q1 - q0
uqadd8 r6, r8, r6 ; abs (p0-q0)*2 + abs (p1-q1)/2
uqsub8 r12, r9, r10 ; q0 - q1
uqsub8 r6, r6, r4 ; compare to flimit
orr r9, r11, r12 ; abs (q1-q0)
uqsub8 r8, r9, r2 ; compare to limit
uqsub8 r10, r9, r3 ; compare to thresh
orr lr, lr, r6
orr lr, lr, r8
mvn r11, #0 ; r11 == -1
mov r12, #0
usub8 lr, r12, lr
ldr r9, [sp] ; load the compared result
sel lr, r11, r12 ; filter mask: lr
cmp lr, #0
beq mbvskip_filter ; skip filtering
;vp8_hevmask() function
;calculate high edge variance
sub src, src, pstep, lsl #2 ; move src pointer down by 4 lines
orr r9, r9, r10
ldrh r7, [src, #-2]
ldrh r8, [src], pstep
usub8 r9, r12, r9
sel r6, r12, r11 ; hev mask: r6
; vp8_mbfilter() function
; p2, q2 are only needed at the end. Don't need to load them in now.
; Transpose needs 8 regs(r6 - r12, and lr). Save r6 and lr first
; load soure data to r6, r11, r12, lr
ldrh r9, [src, #-2]
ldrh r10, [src], pstep
pkhbt r12, r7, r8, lsl #16
ldrh r7, [src, #-2]
ldrh r8, [src], pstep
pkhbt r11, r9, r10, lsl #16
ldrh r9, [src, #-2]
ldrh r10, [src], pstep
str r6, [sp] ; save r6
str lr, [sp, #4] ; save lr
pkhbt r6, r7, r8, lsl #16
pkhbt lr, r9, r10, lsl #16
;transpose r12, r11, r6, lr to p1, p0, q0, q1
TRANSPOSE_MATRIX r12, r11, r6, lr, r7, r8, r9, r10
;load back hev_mask r6 and filter_mask lr
ldr r12, c0x80808080
ldr r6, [sp]
ldr lr, [sp, #4]
eor r7, r7, r12 ; ps1
eor r8, r8, r12 ; ps0
eor r9, r9, r12 ; qs0
eor r10, r10, r12 ; qs1
qsub8 r12, r9, r8 ; vp8_signed_char_clamp(vp8_filter + 3 * ( qs0 - ps0))
str r7, [sp, #12] ; store ps1 temporarily
qsub8 r7, r7, r10 ; vp8_signed_char_clamp(ps1-qs1)
str r10, [sp, #8] ; store qs1 temporarily
qadd8 r7, r7, r12
str r9, [sp] ; store qs0 temporarily
qadd8 r7, r7, r12
str r8, [sp, #4] ; store ps0 temporarily
qadd8 r7, r7, r12 ; vp8_filter: r7
ldr r10, c0x03030303 ; r10 = 3 --modified for vp8
ldr r9, c0x04040404
;mvn r11, #0 ; r11 == -1
and r7, r7, lr ; vp8_filter &= mask (lr is free)
mov r12, r7 ; Filter2: r12
and r12, r12, r6 ; Filter2 &= hev
;modify code for vp8
;save bottom 3 bits so that we round one side +4 and the other +3
qadd8 r8 , r12 , r9 ; Filter1 (r8) = vp8_signed_char_clamp(Filter2+4)
qadd8 r12 , r12 , r10 ; Filter2 (r12) = vp8_signed_char_clamp(Filter2+3)
mov r10, #0
shadd8 r8 , r8 , r10 ; Filter1 >>= 3
shadd8 r12 , r12 , r10 ; Filter2 >>= 3
shadd8 r8 , r8 , r10
shadd8 r12 , r12 , r10
shadd8 r8 , r8 , r10 ; r8: Filter1
shadd8 r12 , r12 , r10 ; r12: Filter2
ldr r9, [sp] ; load qs0
ldr r11, [sp, #4] ; load ps0
qsub8 r9 , r9, r8 ; qs0 = vp8_signed_char_clamp(qs0 - Filter1)
qadd8 r11, r11, r12 ; ps0 = vp8_signed_char_clamp(ps0 + Filter2)
;save bottom 3 bits so that we round one side +4 and the other +3
;and r8, r12, r10 ; s = Filter2 & 7 (s: r8)
;qadd8 r12 , r12 , r9 ; Filter2 = vp8_signed_char_clamp(Filter2+4)
;mov r10, #0
;shadd8 r12 , r12 , r10 ; Filter2 >>= 3
;usub8 lr, r8, r9 ; s = (s==4)*-1
;sel lr, r11, r10
;shadd8 r12 , r12 , r10
;usub8 r8, r9, r8
;sel r8, r11, r10
;ldr r9, [sp] ; load qs0
;ldr r11, [sp, #4] ; load ps0
;shadd8 r12 , r12 , r10
;and r8, r8, lr ; -1 for each element that equals 4
;qadd8 r10, r8, r12 ; u = vp8_signed_char_clamp(s + Filter2)
;qsub8 r9 , r9, r12 ; qs0 = vp8_signed_char_clamp(qs0 - Filter2)
;qadd8 r11, r11, r10 ; ps0 = vp8_signed_char_clamp(ps0 + u)
;end of modification for vp8
bic r12, r7, r6 ;vp8_filter &= ~hev ( r6 is free)
;mov r12, r7
;roughly 3/7th difference across boundary
mov lr, #0x1b ; 27
mov r7, #0x3f ; 63
sxtb16 r6, r12
sxtb16 r10, r12, ror #8
smlabb r8, r6, lr, r7
smlatb r6, r6, lr, r7
smlabb r7, r10, lr, r7
smultb r10, r10, lr
ssat r8, #8, r8, asr #7
ssat r6, #8, r6, asr #7
add r10, r10, #63
ssat r7, #8, r7, asr #7
ssat r10, #8, r10, asr #7
ldr lr, c0x80808080
pkhbt r6, r8, r6, lsl #16
pkhbt r10, r7, r10, lsl #16
uxtb16 r6, r6
uxtb16 r10, r10
sub src, src, pstep, lsl #2 ; move src pointer down by 4 lines
orr r10, r6, r10, lsl #8 ; u = vp8_signed_char_clamp((63 + Filter2 * 27)>>7)
qsub8 r8, r9, r10 ; s = vp8_signed_char_clamp(qs0 - u)
qadd8 r10, r11, r10 ; s = vp8_signed_char_clamp(ps0 + u)
eor r8, r8, lr ; *oq0 = s^0x80
eor r10, r10, lr ; *op0 = s^0x80
strb r10, [src, #-1] ; store op0 result
strb r8, [src], pstep ; store oq0 result
mov r10, r10, lsr #8
mov r8, r8, lsr #8
strb r10, [src, #-1]
strb r8, [src], pstep
mov r10, r10, lsr #8
mov r8, r8, lsr #8
strb r10, [src, #-1]
strb r8, [src], pstep
mov r10, r10, lsr #8
mov r8, r8, lsr #8
strb r10, [src, #-1]
strb r8, [src], pstep
;roughly 2/7th difference across boundary
mov lr, #0x12 ; 18
mov r7, #0x3f ; 63
sxtb16 r6, r12
sxtb16 r10, r12, ror #8
smlabb r8, r6, lr, r7
smlatb r6, r6, lr, r7
smlabb r9, r10, lr, r7
smlatb r10, r10, lr, r7
ssat r8, #8, r8, asr #7
ssat r6, #8, r6, asr #7
ssat r9, #8, r9, asr #7
ssat r10, #8, r10, asr #7
sub src, src, pstep, lsl #2 ; move src pointer down by 4 lines
pkhbt r6, r8, r6, lsl #16
pkhbt r10, r9, r10, lsl #16
ldr r9, [sp, #8] ; load qs1
ldr r11, [sp, #12] ; load ps1
ldr lr, c0x80808080
uxtb16 r6, r6
uxtb16 r10, r10
add src, src, #2
orr r10, r6, r10, lsl #8 ; u = vp8_signed_char_clamp((63 + Filter2 * 18)>>7)
qsub8 r8, r9, r10 ; s = vp8_signed_char_clamp(qs1 - u)
qadd8 r10, r11, r10 ; s = vp8_signed_char_clamp(ps1 + u)
eor r8, r8, lr ; *oq1 = s^0x80
eor r10, r10, lr ; *op1 = s^0x80
ldrb r11, [src, #-5] ; load p2 for 1/7th difference across boundary
strb r10, [src, #-4] ; store op1
strb r8, [src, #-1] ; store oq1
ldrb r9, [src], pstep ; load q2 for 1/7th difference across boundary
mov r10, r10, lsr #8
mov r8, r8, lsr #8
ldrb r6, [src, #-5]
strb r10, [src, #-4]
strb r8, [src, #-1]
ldrb r7, [src], pstep
mov r10, r10, lsr #8
mov r8, r8, lsr #8
orr r11, r11, r6, lsl #8
orr r9, r9, r7, lsl #8
ldrb r6, [src, #-5]
strb r10, [src, #-4]
strb r8, [src, #-1]
ldrb r7, [src], pstep
mov r10, r10, lsr #8
mov r8, r8, lsr #8
orr r11, r11, r6, lsl #16
orr r9, r9, r7, lsl #16
ldrb r6, [src, #-5]
strb r10, [src, #-4]
strb r8, [src, #-1]
ldrb r7, [src], pstep
orr r11, r11, r6, lsl #24
orr r9, r9, r7, lsl #24
;roughly 1/7th difference across boundary
eor r9, r9, lr
eor r11, r11, lr
mov lr, #0x9 ; 9
mov r7, #0x3f ; 63
sxtb16 r6, r12
sxtb16 r10, r12, ror #8
smlabb r8, r6, lr, r7
smlatb r6, r6, lr, r7
smlabb r12, r10, lr, r7
smlatb r10, r10, lr, r7
ssat r8, #8, r8, asr #7
ssat r6, #8, r6, asr #7
ssat r12, #8, r12, asr #7
ssat r10, #8, r10, asr #7
sub src, src, pstep, lsl #2
pkhbt r6, r8, r6, lsl #16
pkhbt r10, r12, r10, lsl #16
uxtb16 r6, r6
uxtb16 r10, r10
ldr lr, c0x80808080
orr r10, r6, r10, lsl #8 ; u = vp8_signed_char_clamp((63 + Filter2 * 9)>>7)
qadd8 r8, r11, r10 ; s = vp8_signed_char_clamp(ps2 + u)
qsub8 r10, r9, r10 ; s = vp8_signed_char_clamp(qs2 - u)
eor r8, r8, lr ; *op2 = s^0x80
eor r10, r10, lr ; *oq2 = s^0x80
strb r8, [src, #-5] ; store *op2
strb r10, [src], pstep ; store *oq2
mov r8, r8, lsr #8
mov r10, r10, lsr #8
strb r8, [src, #-5]
strb r10, [src], pstep
mov r8, r8, lsr #8
mov r10, r10, lsr #8
strb r8, [src, #-5]
strb r10, [src], pstep
mov r8, r8, lsr #8
mov r10, r10, lsr #8
strb r8, [src, #-5]
strb r10, [src], pstep
;adjust src pointer for next loop
sub src, src, #2
|mbvskip_filter|
sub src, src, #4
subs count, count, #1
ldrne r6, [src], pstep ; load source data
ldrne r7, [src], pstep
ldrne r8, [src], pstep
ldrne lr, [src], pstep
bne MBVnext8
add sp, sp, #16
ldmia sp!, {r4 - r11, pc}
ENDP ; |vp8_mbloop_filter_vertical_edge_armv6|
; Constant Pool
c0x80808080 DCD 0x80808080
c0x03030303 DCD 0x03030303
c0x04040404 DCD 0x04040404
c0x01010101 DCD 0x01010101
c0x7F7F7F7F DCD 0x7F7F7F7F
END
|
; Copyright © 2020, VideoLAN and dav1d authors
; Copyright © 2020, Two Orioles, LLC
; All rights reserved.
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions are met:
;
; 1. Redistributions of source code must retain the above copyright notice, this
; list of conditions and the following disclaimer.
;
; 2. Redistributions in binary form must reproduce the above copyright notice,
; this list of conditions and the following disclaimer in the documentation
; and/or other materials provided with the distribution.
;
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
; ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
; DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
; ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
; (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
; ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
%include "config.asm"
%include "ext/x86/x86inc.asm"
%if HAVE_AVX512ICL && ARCH_X86_64
%macro DUP4 1-*
%rep %0
times 4 db %1
%rotate 1
%endrep
%endmacro
%macro DIRS 16 ; cdef_directions[]
%rep 4 + 16 + 4 ; 6 7 0 1 2 3 4 5 6 7 0 1
; masking away unused bits allows us to use a single vpaddd {1to16}
; instruction instead of having to do vpbroadcastd + paddb
db %13 & 0x3f, -%13 & 0x3f
%rotate 1
%endrep
%endmacro
SECTION_RODATA 64
lut_perm_4x4: db 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79
db 16, 17, 0, 1, 2, 3, 4, 5, 18, 19, 8, 9, 10, 11, 12, 13
db 20, 21, 80, 81, 82, 83, 84, 85, 22, 23, 32, 33, 34, 35, 36, 37
db 98, 99,100,101,102,103,104,105, 50, 51, 52, 53, 54, 55, 56, 57
lut_perm_4x8a: db 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79
db 96, 97, 0, 1, 2, 3, 4, 5, 98, 99, 8, 9, 10, 11, 12, 13
lut_perm_4x8b:db 100,101, 16, 17, 18, 19, 20, 21,102,103, 24, 25, 26, 27, 28, 29
db 104,105, 32, 33, 34, 35, 36, 37,106,107, 40, 41, 42, 43, 44, 45
db 108,109, 48, 49, 50, 51, 52, 53,110,111, 56, 57, 58, 59, 60, 61
db 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95
pd_01234567: dd 0, 1, 2, 3, 4, 5, 6, 7
lut_perm_8x8a: db 0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23
db -1, -1, 34, 35, 36, 37, 38, 39, -1, -1, 50, 51, 52, 53, 54, 55
db -1, -1, 66, 67, 68, 69, 70, 71, -1, -1, 82, 83, 84, 85, 86, 87
db 96, 97, 98, 99,100,101,102,103,112,113,114,115,116,117,118,119
lut_perm_8x8b: db 4, 5, 6, 7, 8, 9, 10, 11, 20, 21, 22, 23, 24, 25, 26, 27
db 36, 37, 38, 39, 40, 41, 42, 43, 52, 53, 54, 55, 56, 57, 58, 59
db 68, 69, 70, 71, 72, 73, 74, 75, 84, 85, 86, 87, 88, 89, 90, 91
db 100,101,102,103,104,105,106,107,116,117,118,119,120,121,122,123
edge_mask: dq 0x00003c3c3c3c0000, 0x00003f3f3f3f0000 ; 0000, 0001
dq 0x0000fcfcfcfc0000, 0x0000ffffffff0000 ; 0010, 0011
dq 0x00003c3c3c3c3c3c, 0x00003f3f3f3f3f3f ; 0100, 0101
dq 0x0000fcfcfcfcfcfc, 0x0000ffffffffffff ; 0110, 0111
dq 0x3c3c3c3c3c3c0000, 0x3f3f3f3f3f3f0000 ; 1000, 1001
dq 0xfcfcfcfcfcfc0000, 0xffffffffffff0000 ; 1010, 1011
dq 0x3c3c3c3c3c3c3c3c, 0x3f3f3f3f3f3f3f3f ; 1100, 1101
dq 0xfcfcfcfcfcfcfcfc, 0xffffffffffffffff ; 1110, 1111
px_idx: DUP4 18, 19, 20, 21, 26, 27, 28, 29, 34, 35, 36, 37, 42, 43, 44, 45
cdef_dirs: DIRS -7,-14, 1, -6, 1, 2, 1, 10, 9, 18, 8, 17, 8, 16, 8, 15
gf_shr: dq 0x0102040810204080, 0x0102040810204080 ; >> 0, >> 0
dq 0x0204081020408000, 0x0408102040800000 ; >> 1, >> 2
dq 0x0810204080000000, 0x1020408000000000 ; >> 3, >> 4
dq 0x2040800000000000, 0x4080000000000000 ; >> 5, >> 6
times 16 db 0 ; realign (introduced by cdef_dirs)
end_perm_w8clip:db 0, 4, 8, 12, 2, 6, 10, 14, 16, 20, 24, 28, 18, 22, 26, 30
db 32, 36, 40, 44, 34, 38, 42, 46, 48, 52, 56, 60, 50, 54, 58, 62
db 1, 5, 9, 13, 3, 7, 11, 15, 17, 21, 25, 29, 19, 23, 27, 31
db 33, 37, 41, 45, 35, 39, 43, 47, 49, 53, 57, 61, 51, 55, 59, 63
end_perm: db 1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61
db 3, 7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47, 51, 55, 59, 63
pri_tap: db 64, 64, 32, 32, 48, 48, 48, 48 ; left-shifted by 4
sec_tap: db 32, 32, 16, 16
pd_268435568: dd 268435568
SECTION .text
%if WIN64
DECLARE_REG_TMP 5, 6
%else
DECLARE_REG_TMP 8, 5
%endif
; lut:
; t0 t1 t2 t3 t4 t5 t6 t7
; T0 T1 T2 T3 T4 T5 T6 T7
; L0 L1 00 01 02 03 04 05
; L2 L3 10 11 12 13 14 15
; L4 L5 20 21 22 23 24 25
; L6 L7 30 31 32 33 34 35
; 4e 4f 40 41 42 43 44 45
; 5e 5f 50 51 52 53 54 55
INIT_ZMM avx512icl
cglobal cdef_filter_4x4_8bpc, 4, 8, 13, dst, stride, left, top, \
pri, sec, dir, damping, edge
%define base r7-edge_mask
movq xmm0, [dstq+strideq*0]
movhps xmm0, [dstq+strideq*1]
lea r7, [edge_mask]
movq xmm1, [topq+strideq*0-2]
movhps xmm1, [topq+strideq*1-2]
mov r6d, edgem
vinserti32x4 ym0, ymm0, [leftq], 1
lea r2, [strideq*3]
vinserti32x4 ym1, ymm1, [dstq+strideq*2], 1
mova m5, [base+lut_perm_4x4]
vinserti32x4 m0, [dstq+r2], 2
test r6b, 0x08 ; avoid buffer overread
jz .main
lea r3, [dstq+strideq*4-4]
vinserti32x4 m1, [r3+strideq*0], 2
vinserti32x4 m0, [r3+strideq*1], 3
.main:
movifnidn prid, prim
mov t0d, dirm
mova m3, [base+px_idx]
mov r3d, dampingm
vpermi2b m5, m0, m1 ; lut
vpbroadcastd m0, [base+pd_268435568] ; (1 << 28) + (7 << 4)
pxor m7, m7
lea r3, [r7+r3*8] ; gf_shr + (damping - 30) * 8
vpermb m6, m3, m5 ; px
cmp r6d, 0x0f
jne .mask_edges ; mask edges only if required
test prid, prid
jz .sec_only
vpaddd m1, m3, [base+cdef_dirs+(t0+2)*4] {1to16} ; dir
vpermb m1, m1, m5 ; k0p0 k0p1 k1p0 k1p1
%macro CDEF_FILTER_4x4_PRI 0
vpcmpub k1, m6, m1, 6 ; px > pN
psubb m2, m1, m6
lzcnt r6d, prid
vpsubb m2{k1}, m6, m1 ; abs(diff)
vpbroadcastb m4, prid
and prid, 1
vgf2p8affineqb m9, m2, [r3+r6*8] {1to8}, 0 ; abs(diff) >> shift
movifnidn t1d, secm
vpbroadcastd m10, [base+pri_tap+priq*4]
vpsubb m10{k1}, m7, m10 ; apply_sign(pri_tap)
psubusb m4, m9 ; imax(0, pri_strength - (abs(diff) >> shift)))
pminub m2, m4
vpdpbusd m0, m2, m10 ; sum
%endmacro
CDEF_FILTER_4x4_PRI
test t1d, t1d ; sec
jz .end_no_clip
call .sec
.end_clip:
pminub m4, m6, m1
pmaxub m1, m6
pminub m5, m2, m3
pmaxub m2, m3
pminub m4, m5
pmaxub m2, m1
psrldq m1, m4, 2
psrldq m3, m2, 2
pminub m1, m4
vpcmpw k1, m0, m7, 1
vpshldd m6, m0, 8
pmaxub m2, m3
pslldq m3, m1, 1
psubw m7, m0
paddusw m0, m6 ; clip >0xff
vpsubusw m0{k1}, m6, m7 ; clip <0x00
pslldq m4, m2, 1
pminub m1, m3
pmaxub m2, m4
pmaxub m0, m1
pminub m0, m2
jmp .end
.sec_only:
movifnidn t1d, secm
call .sec
.end_no_clip:
vpshldd m6, m0, 8 ; (px << 8) + ((sum > -8) << 4)
paddw m0, m6 ; (px << 8) + ((sum + (sum > -8) + 7) << 4)
.end:
mova xm1, [base+end_perm]
vpermb m0, m1, m0 ; output in bits 8-15 of each dword
movd [dstq+strideq*0], xm0
pextrd [dstq+strideq*1], xm0, 1
pextrd [dstq+strideq*2], xm0, 2
pextrd [dstq+r2 ], xm0, 3
RET
.mask_edges_sec_only:
movifnidn t1d, secm
call .mask_edges_sec
jmp .end_no_clip
ALIGN function_align
.mask_edges:
vpbroadcastq m8, [base+edge_mask+r6*8]
test prid, prid
jz .mask_edges_sec_only
vpaddd m2, m3, [base+cdef_dirs+(t0+2)*4] {1to16}
vpshufbitqmb k1, m8, m2 ; index in-range
mova m1, m6
vpermb m1{k1}, m2, m5
CDEF_FILTER_4x4_PRI
test t1d, t1d
jz .end_no_clip
call .mask_edges_sec
jmp .end_clip
.mask_edges_sec:
vpaddd m4, m3, [base+cdef_dirs+(t0+4)*4] {1to16}
vpaddd m9, m3, [base+cdef_dirs+(t0+0)*4] {1to16}
vpshufbitqmb k1, m8, m4
mova m2, m6
vpermb m2{k1}, m4, m5
vpshufbitqmb k1, m8, m9
mova m3, m6
vpermb m3{k1}, m9, m5
jmp .sec_main
ALIGN function_align
.sec:
vpaddd m2, m3, [base+cdef_dirs+(t0+4)*4] {1to16} ; dir + 2
vpaddd m3, [base+cdef_dirs+(t0+0)*4] {1to16} ; dir - 2
vpermb m2, m2, m5 ; k0s0 k0s1 k1s0 k1s1
vpermb m3, m3, m5 ; k0s2 k0s3 k1s2 k1s3
.sec_main:
vpbroadcastd m8, [base+sec_tap]
vpcmpub k1, m6, m2, 6
psubb m4, m2, m6
vpbroadcastb m12, t1d
lzcnt t1d, t1d
vpsubb m4{k1}, m6, m2
vpcmpub k2, m6, m3, 6
vpbroadcastq m11, [r3+t1*8]
gf2p8affineqb m10, m4, m11, 0
psubb m5, m3, m6
mova m9, m8
vpsubb m8{k1}, m7, m8
psubusb m10, m12, m10
vpsubb m5{k2}, m6, m3
pminub m4, m10
vpdpbusd m0, m4, m8
gf2p8affineqb m11, m5, m11, 0
vpsubb m9{k2}, m7, m9
psubusb m12, m11
pminub m5, m12
vpdpbusd m0, m5, m9
ret
DECLARE_REG_TMP 2, 7
; lut top lut bottom
; t0 t1 t2 t3 t4 t5 t6 t7 L4 L5 20 21 22 23 24 25
; T0 T1 T2 T3 T4 T5 T6 T7 L6 L7 30 31 32 33 34 35
; L0 L1 00 01 02 03 04 05 L8 L9 40 41 42 43 44 45
; L2 L3 10 11 12 13 14 15 La Lb 50 51 52 53 54 55
; L4 L5 20 21 22 23 24 25 Lc Ld 60 61 62 63 64 65
; L6 L7 30 31 32 33 34 35 Le Lf 70 71 72 73 74 75
; L8 L9 40 41 42 43 44 45 8e 8f 80 81 82 83 84 85
; La Lb 50 51 52 53 54 55 9e 9f 90 91 92 93 94 95
cglobal cdef_filter_4x8_8bpc, 4, 9, 22, dst, stride, left, top, pri, sec, dir, damping, edge
%define base r8-edge_mask
vpbroadcastd ym21, strided
mov r6d, edgem
lea r8, [edge_mask]
movq xm1, [topq+strideq*0-2]
pmulld ym21, [base+pd_01234567]
kxnorb k1, k1, k1
movq xm2, [topq+strideq*1-2]
vpgatherdq m0{k1}, [dstq+ym21] ; +0+1 +2+3 +4+5 +6+7
mova m14, [base+lut_perm_4x8a]
movu m15, [base+lut_perm_4x8b]
test r6b, 0x08 ; avoid buffer overread
jz .main
lea r7, [dstq+strideq*8-2]
vinserti32x4 ym1, [r7+strideq*0], 1
vinserti32x4 ym2, [r7+strideq*1], 1
.main:
punpcklqdq ym1, ym2
vinserti32x4 m1, [leftq], 2 ; -2-1 +8+9 left ____
movifnidn prid, prim
mov t0d, dirm
mova m16, [base+px_idx]
mov r3d, dampingm
vpermi2b m14, m0, m1 ; lut top
vpermi2b m15, m0, m1 ; lut bottom
vpbroadcastd m0, [base+pd_268435568] ; (1 << 28) + (7 << 4)
pxor m20, m20
lea r3, [r8+r3*8] ; gf_shr + (damping - 30) * 8
vpermb m2, m16, m14 ; pxt
vpermb m3, m16, m15 ; pxb
mova m1, m0
cmp r6b, 0x0f
jne .mask_edges ; mask edges only if required
test prid, prid
jz .sec_only
vpaddd m6, m16, [base+cdef_dirs+(t0+2)*4] {1to16} ; dir
vpermb m4, m6, m14 ; pNt k0p0 k0p1 k1p0 k1p1
vpermb m5, m6, m15 ; pNb
%macro CDEF_FILTER_4x8_PRI 0
vpcmpub k1, m2, m4, 6 ; pxt > pNt
vpcmpub k2, m3, m5, 6 ; pxb > pNb
psubb m6, m4, m2
psubb m7, m5, m3
lzcnt r6d, prid
vpsubb m6{k1}, m2, m4 ; abs(diff_top)
vpsubb m7{k2}, m3, m5 ; abs(diff_bottom)
vpbroadcastb m13, prid
vpbroadcastq m9, [r3+r6*8]
and prid, 1
vpbroadcastd m11, [base+pri_tap+priq*4]
vgf2p8affineqb m8, m6, m9, 0 ; abs(dt) >> shift
vgf2p8affineqb m9, m7, m9, 0 ; abs(db) >> shift
mova m10, m11
movifnidn t1d, secm
vpsubb m10{k1}, m20, m11 ; apply_sign(pri_tap_top)
vpsubb m11{k2}, m20, m11 ; apply_sign(pri_tap_bottom)
psubusb m12, m13, m8 ; imax(0, pri_strength - (abs(dt) >> shift)))
psubusb m13, m13, m9 ; imax(0, pri_strength - (abs(db) >> shift)))
pminub m6, m12
pminub m7, m13
vpdpbusd m0, m6, m10 ; sum top
vpdpbusd m1, m7, m11 ; sum bottom
%endmacro
CDEF_FILTER_4x8_PRI
test t1d, t1d ; sec
jz .end_no_clip
call .sec
.end_clip:
pminub m10, m4, m2
pminub m12, m6, m8
pminub m11, m5, m3
pminub m13, m7, m9
pmaxub m4, m2
pmaxub m6, m8
pmaxub m5, m3
pmaxub m7, m9
pminub m10, m12
pminub m11, m13
pmaxub m4, m6
pmaxub m5, m7
mov r2d, 0xAAAAAAAA
kmovd k1, r2d
kxnorb k2, k2, k2 ; hw lw
vpshrdd m12, m0, m1, 16 ; m1lw m0hw
vpshrdd m6, m10, m11, 16 ; m11lw m10hw
vpshrdd m8, m4, m5, 16 ; m5lw m4hw
vpblendmw m7{k1}, m10, m11 ; m11hw m10lw
vpblendmw m9{k1}, m4, m5 ; m5hw m4lw
vpblendmw m4{k1}, m0, m12 ; m1lw m0lw
vpblendmw m5{k1}, m12, m1 ; m1hw m0hw
vpshrdd m2, m3, 16
pminub m6, m7
pmaxub m8, m9
mova ym14, [base+end_perm]
vpcmpw k1, m4, m20, 1
vpshldw m2, m5, 8
pslldq m7, m6, 1
pslldq m9, m8, 1
psubw m5, m20, m4
paddusw m0, m4, m2 ; clip >0xff
pminub m6, m7
pmaxub m8, m9
psubusw m0{k1}, m2, m5 ; clip <0x00
pmaxub m0, m6
pminub m0, m8
vpermb m0, m14, m0
vpscatterdd [dstq+ym21]{k2}, ym0
RET
.sec_only:
movifnidn t1d, secm
call .sec
.end_no_clip:
mova ym4, [base+end_perm]
kxnorb k1, k1, k1
vpshldd m2, m0, 8 ; (px << 8) + ((sum > -8) << 4)
vpshldd m3, m1, 8
paddw m0, m2 ; (px << 8) + ((sum + (sum > -8) + 7) << 4)
paddw m1, m3
pslld m0, 16
vpshrdd m0, m1, 16
vpermb m0, m4, m0 ; output in bits 8-15 of each word
vpscatterdd [dstq+ym21]{k1}, ym0
RET
.mask_edges_sec_only:
movifnidn t1d, secm
call .mask_edges_sec
jmp .end_no_clip
ALIGN function_align
.mask_edges:
mov t1d, r6d
or r6d, 8 ; top 4x4 has bottom
or t1d, 4 ; bottom 4x4 has top
vpbroadcastq m17, [base+edge_mask+r6*8]
vpbroadcastq m18, [base+edge_mask+t1*8]
test prid, prid
jz .mask_edges_sec_only
vpaddd m6, m16, [base+cdef_dirs+(t0+2)*4] {1to16}
vpshufbitqmb k1, m17, m6 ; index in-range
vpshufbitqmb k2, m18, m6
mova m4, m2
mova m5, m3
vpermb m4{k1}, m6, m14
vpermb m5{k2}, m6, m15
CDEF_FILTER_4x8_PRI
test t1d, t1d
jz .end_no_clip
call .mask_edges_sec
jmp .end_clip
.mask_edges_sec:
vpaddd m10, m16, [base+cdef_dirs+(t0+4)*4] {1to16}
vpaddd m11, m16, [base+cdef_dirs+(t0+0)*4] {1to16}
vpshufbitqmb k1, m17, m10
vpshufbitqmb k2, m18, m10
vpshufbitqmb k3, m17, m11
vpshufbitqmb k4, m18, m11
mova m6, m2
mova m7, m3
mova m8, m2
mova m9, m3
vpermb m6{k1}, m10, m14
vpermb m7{k2}, m10, m15
vpermb m8{k3}, m11, m14
vpermb m9{k4}, m11, m15
jmp .sec_main
ALIGN function_align
.sec:
vpaddd m8, m16, [base+cdef_dirs+(t0+4)*4] {1to16} ; dir + 2
vpaddd m9, m16, [base+cdef_dirs+(t0+0)*4] {1to16} ; dir - 2
vpermb m6, m8, m14 ; pNt k0s0 k0s1 k1s0 k1s1
vpermb m7, m8, m15 ; pNb
vpermb m8, m9, m14 ; pNt k0s2 k0s3 k1s2 k1s3
vpermb m9, m9, m15 ; pNb
.sec_main:
vpbroadcastb m18, t1d
lzcnt t1d, t1d
vpcmpub k1, m2, m6, 6
vpcmpub k2, m3, m7, 6
vpcmpub k3, m2, m8, 6
vpcmpub k4, m3, m9, 6
vpbroadcastq m17, [r3+t1*8]
psubb m10, m6, m2
psubb m11, m7, m3
psubb m12, m8, m2
psubb m13, m9, m3
vpsubb m10{k1}, m2, m6 ; abs(dt0)
vpsubb m11{k2}, m3, m7 ; abs(db0)
vpsubb m12{k3}, m2, m8 ; abs(dt1)
vpsubb m13{k4}, m3, m9 ; abs(db1)
vpbroadcastd m19, [base+sec_tap]
gf2p8affineqb m14, m10, m17, 0 ; abs(dt0) >> shift
gf2p8affineqb m15, m11, m17, 0 ; abs(db0) >> shift
gf2p8affineqb m16, m12, m17, 0 ; abs(dt1) >> shift
gf2p8affineqb m17, m13, m17, 0 ; abs(db1) >> shift
psubusb m14, m18, m14 ; imax(0, sec_strength - (abs(dt0) >> shift)))
psubusb m15, m18, m15 ; imax(0, sec_strength - (abs(db0) >> shift)))
psubusb m16, m18, m16 ; imax(0, sec_strength - (abs(dt1) >> shift)))
psubusb m17, m18, m17 ; imax(0, sec_strength - (abs(db1) >> shift)))
pminub m10, m14
pminub m11, m15
pminub m12, m16
pminub m13, m17
mova m14, m19
mova m15, m19
mova m16, m19
vpsubb m14{k1}, m20, m19 ; apply_sign(sec_tap_top_0)
vpsubb m15{k2}, m20, m19 ; apply_sign(sec_tap_bottom_0)
vpsubb m16{k3}, m20, m19 ; apply_sign(sec_tap_top_1)
vpsubb m19{k4}, m20, m19 ; apply_sign(sec_tap_bottom_1)
vpdpbusd m0, m10, m14
vpdpbusd m1, m11, m15
vpdpbusd m0, m12, m16
vpdpbusd m1, m13, m19
ret
; lut tl lut tr
; t0 t1 t2 t3 t4 t5 t6 t7 t6 t7 t8 t9 ta tb tc td
; T0 T1 T2 T3 T4 T5 T6 T7 T6 T7 T8 T9 TA TB TC TD
; L0 L1 00 01 02 03 04 05 04 05 06 07 08 09 0a 0b
; L2 L3 10 11 12 13 14 15 14 15 16 17 18 19 1a 1b
; L4 L5 20 21 22 23 24 25 24 25 26 27 28 29 2a 2b
; L6 L7 30 31 32 33 34 35 34 35 36 37 38 39 3a 3b
; L8 L9 40 41 42 43 44 45 44 45 46 47 48 49 4a 4b
; La Lb 50 51 52 53 54 55 54 55 56 57 58 59 5a 5b
; lut bl lut br
; L4 L5 20 21 22 23 24 25 24 25 26 27 28 29 2a 2b
; L6 L7 30 31 32 33 34 35 34 35 36 37 38 39 3a 3b
; L8 L9 40 41 42 43 44 45 44 45 46 47 48 49 4a 4b
; La Lb 50 51 52 53 54 55 54 55 56 57 58 59 5a 5b
; Lc Ld 60 61 62 63 64 65 64 65 66 67 68 69 6a 6b
; Le Lf 70 71 72 73 74 75 74 75 76 77 78 79 7a 7b
; 8e 8f 80 81 82 83 84 85 84 85 86 87 88 89 8a 8b
; 9e 9f 90 91 92 93 94 95 94 95 96 97 98 99 9a 9b
cglobal cdef_filter_8x8_8bpc, 4, 11, 32, 4*64, dst, stride, left, top, \
pri, sec, dir, damping, edge
%define base r8-edge_mask
mov r6d, edgem
lea r10, [dstq+strideq*4-2]
movu xmm0, [topq+strideq*0-2]
movu xmm1, [dstq+strideq*2-2]
movu xmm2, [r10 +strideq*2 ]
lea r8, [edge_mask]
lea r9, [strideq*3]
pmovzxwq m10, [leftq-4]
vinserti32x4 ym0, ymm0, [topq+strideq*1-2], 1
vinserti32x4 ym1, ymm1, [dstq+r9 -2], 1
vinserti32x4 ym2, ymm2, [r10 +r9 ], 1
lea r7, [r10 +strideq*4 ]
pmovzxwq m11, [leftq+4]
vinserti32x4 m0, [dstq+strideq*0-2], 2
vinserti32x4 m1, [r10 +strideq*0 ], 2
mova m12, [base+lut_perm_8x8a]
movu m13, [base+lut_perm_8x8b]
vinserti32x4 m0, [dstq+strideq*1-2], 3
vinserti32x4 m1, [r10 +strideq*1 ], 3
test r6b, 0x08 ; avoid buffer overread
jz .main
vinserti32x4 m2, [r7 +strideq*0], 2
vinserti32x4 m2, [r7 +strideq*1], 3
.main:
mov t1d, 0x11111100
mova m14, m12
mova m15, m13
kmovd k1, t1d
kshiftrd k2, k1, 8
movifnidn prid, prim
mov t0d, dirm
mova m30, [base+px_idx]
mov r3d, dampingm
vpermi2b m12, m0, m1 ; lut tl
vpermi2b m14, m1, m2 ; lut bl
vpermi2b m13, m0, m1 ; lut tr
vpermi2b m15, m1, m2 ; lut br
vpblendmw m12{k1}, m12, m10
vpblendmw m14{k2}, m14, m11
vpbroadcastd m0, [base+pd_268435568] ; (1 << 28) + (7 << 4)
pxor m31, m31
lea r3, [r8+r3*8] ; gf_shr + (damping - 30) * 8
vpermb m4, m30, m12 ; pxtl
vpermb m5, m30, m13 ; pxtr
vpermb m6, m30, m14 ; pxbl
vpermb m7, m30, m15 ; pxbr
mova m1, m0
mova m2, m0
mova m3, m0
cmp r6b, 0x0f
jne .mask_edges ; mask edges only if required
test prid, prid
jz .sec_only
vpaddd m11, m30, [base+cdef_dirs+(t0+2)*4] {1to16} ; dir
vpermb m8, m11, m12 ; pNtl k0p0 k0p1 k1p0 k1p1
vpermb m9, m11, m13 ; pNtr
vpermb m10, m11, m14 ; pNbl
vpermb m11, m11, m15 ; pNbr
%macro CDEF_FILTER_8x8_PRI 0
vpcmpub k1, m4, m8, 6 ; pxtl > pNtl
vpcmpub k2, m5, m9, 6 ; pxtr > pNtr
vpcmpub k3, m6, m10, 6 ; pxbl > pNbl
vpcmpub k4, m7, m11, 6 ; pxbr > pNbr
psubb m16, m8, m4
psubb m17, m9, m5
psubb m18, m10, m6
psubb m19, m11, m7
lzcnt r6d, prid
vpsubb m16{k1}, m4, m8 ; abs(diff_tl)
vpsubb m17{k2}, m5, m9 ; abs(diff_tr)
vpsubb m18{k3}, m6, m10 ; abs(diff_bl)
vpsubb m19{k4}, m7, m11 ; abs(diff_br)
vpbroadcastq m28, [r3+r6*8]
vpbroadcastb m29, prid
and prid, 1
vpbroadcastd m27, [base+pri_tap+priq*4]
vgf2p8affineqb m20, m16, m28, 0 ; abs(dtl) >> shift
vgf2p8affineqb m21, m17, m28, 0 ; abs(dtr) >> shift
vgf2p8affineqb m22, m18, m28, 0 ; abs(dbl) >> shift
vgf2p8affineqb m23, m19, m28, 0 ; abs(dbl) >> shift
mova m24, m27
mova m25, m27
mova m26, m27
movifnidn t1d, secm
vpsubb m24{k1}, m31, m27 ; apply_sign(pri_tap_tl)
vpsubb m25{k2}, m31, m27 ; apply_sign(pri_tap_tr)
vpsubb m26{k3}, m31, m27 ; apply_sign(pri_tap_tl)
vpsubb m27{k4}, m31, m27 ; apply_sign(pri_tap_tr)
psubusb m20, m29, m20 ; imax(0, pri_strength - (abs(dtl) >> shift)))
psubusb m21, m29, m21 ; imax(0, pri_strength - (abs(dtr) >> shift)))
psubusb m22, m29, m22 ; imax(0, pri_strength - (abs(dbl) >> shift)))
psubusb m23, m29, m23 ; imax(0, pri_strength - (abs(dbr) >> shift)))
pminub m16, m20
pminub m17, m21
pminub m18, m22
pminub m19, m23
vpdpbusd m0, m16, m24 ; sum tl
vpdpbusd m1, m17, m25 ; sum tr
vpdpbusd m2, m18, m26 ; sum bl
vpdpbusd m3, m19, m27 ; sum br
%endmacro
CDEF_FILTER_8x8_PRI
test t1d, t1d ; sec
jz .end_no_clip
call .sec
.end_clip:
pminub m20, m8, m4
pminub m24, m12, m16
pminub m21, m9, m5
pminub m25, m13, m17
pminub m22, m10, m6
pminub m26, m14, m18
pminub m23, m11, m7
pminub m27, m15, m19
pmaxub m8, m4
pmaxub m12, m16
pmaxub m9, m5
pmaxub m13, m17
pmaxub m10, m6
pmaxub m14, m18
pmaxub m11, m7
pmaxub m15, m19
pminub m20, m24
pminub m21, m25
pminub m22, m26
pminub m23, m27
pmaxub m8, m12
pmaxub m9, m13
pmaxub m10, m14
pmaxub m11, m15
mov r2d, 0xAAAAAAAA
kmovd k1, r2d
vpshrdd m24, m0, m1, 16
vpshrdd m25, m2, m3, 16
vpshrdd m12, m20, m21, 16
vpshrdd m14, m22, m23, 16
vpshrdd m16, m8, m9, 16
vpshrdd m18, m10, m11, 16
vpblendmw m13{k1}, m20, m21
vpblendmw m15{k1}, m22, m23
vpblendmw m17{k1}, m8, m9
vpblendmw m19{k1}, m10, m11
vpblendmw m20{k1}, m0, m24
vpblendmw m21{k1}, m24, m1
vpblendmw m22{k1}, m2, m25
vpblendmw m23{k1}, m25, m3
vpshrdd m4, m5, 16
vpshrdd m6, m7, 16
pminub m12, m13
pminub m14, m15
pmaxub m16, m17
pmaxub m18, m19
mova m8, [base+end_perm_w8clip]
vpcmpw k2, m20, m31, 1
vpcmpw k3, m22, m31, 1
vpshldw m4, m21, 8
vpshldw m6, m23, 8
kunpckdq k1, k1, k1
kxnorb k4, k4, k4
vpshrdw m11, m12, m14, 8
vpshrdw m15, m16, m18, 8
vpblendmb m13{k1}, m12, m14
vpblendmb m17{k1}, m16, m18
psubw m21, m31, m20
psubw m23, m31, m22
paddusw m0, m20, m4 ; clip >0xff
paddusw m1, m22, m6
pminub m11, m13
pmaxub m15, m17
psubusw m0{k2}, m4, m21 ; clip <0x00
psubusw m1{k3}, m6, m23
psrlw m0, 8
vmovdqu8 m0{k1}, m1
pmaxub m0, m11
pminub m0, m15
vpermb m0, m8, m0
add r10, 2
vextracti32x4 xm1, m0, 1
vextracti32x4 xm2, m0, 2
vextracti32x4 xm3, m0, 3
movq [dstq+strideq*0], xm0
movq [dstq+strideq*2], xm1
movq [r10 +strideq*0], xm2
movq [r10 +strideq*2], xm3
movhps [dstq+strideq*1], xm0
movhps [dstq+r9 ], xm1
movhps [r10 +strideq*1], xm2
movhps [r10 +r9 ], xm3
RET
.sec_only:
movifnidn t1d, secm
call .sec
.end_no_clip:
mova xm8, [base+end_perm]
kxnorb k1, k1, k1
vpshldd m4, m0, 8 ; (px << 8) + ((sum > -8) << 4)
vpshldd m5, m1, 8
vpshldd m6, m2, 8
vpshldd m7, m3, 8
paddw m0, m4 ; (px << 8) + ((sum + (sum > -8) + 7) << 4)
paddw m1, m5
paddw m2, m6
paddw m3, m7
vpermb m0, m8, m0
vpermb m1, m8, m1
vpermb m2, m8, m2
vpermb m3, m8, m3
add r10, 2
punpckldq m4, m0, m1
punpckhdq m0, m1
punpckldq m5, m2, m3
punpckhdq m2, m3
movq [dstq+strideq*0], xm4
movq [dstq+strideq*2], xm0
movq [r10 +strideq*0], xm5
movq [r10 +strideq*2], xm2
movhps [dstq+strideq*1], xm4
movhps [dstq+r9 ], xm0
movhps [r10 +strideq*1], xm5
movhps [r10 +r9 ], xm2
RET
.mask_edges_sec_only:
movifnidn t1d, secm
call .mask_edges_sec
jmp .end_no_clip
ALIGN function_align
.mask_edges:
mov t0d, r6d
mov t1d, r6d
or t0d, 0xA ; top-left 4x4 has bottom and right
or t1d, 0x9 ; top-right 4x4 has bottom and left
vpbroadcastq m26, [base+edge_mask+t0*8]
vpbroadcastq m27, [base+edge_mask+t1*8]
mov t1d, r6d
or r6d, 0x6 ; bottom-left 4x4 has top and right
or t1d, 0x5 ; bottom-right 4x4 has top and left
vpbroadcastq m28, [base+edge_mask+r6*8]
vpbroadcastq m29, [base+edge_mask+t1*8]
mov t0d, dirm
test prid, prid
jz .mask_edges_sec_only
vpaddd m20, m30, [base+cdef_dirs+(t0+2)*4] {1to16}
vpshufbitqmb k1, m26, m20 ; index in-range
vpshufbitqmb k2, m27, m20
vpshufbitqmb k3, m28, m20
vpshufbitqmb k4, m29, m20
mova m8, m4
mova m9, m5
mova m10, m6
mova m11, m7
vpermb m8{k1}, m20, m12
vpermb m9{k2}, m20, m13
vpermb m10{k3}, m20, m14
vpermb m11{k4}, m20, m15
mova [rsp+0x00], m26
mova [rsp+0x40], m27
mova [rsp+0x80], m28
mova [rsp+0xC0], m29
CDEF_FILTER_8x8_PRI
test t1d, t1d
jz .end_no_clip
mova m26, [rsp+0x00]
mova m27, [rsp+0x40]
mova m28, [rsp+0x80]
mova m29, [rsp+0xC0]
call .mask_edges_sec
jmp .end_clip
.mask_edges_sec:
vpaddd m20, m30, [base+cdef_dirs+(t0+4)*4] {1to16}
vpaddd m21, m30, [base+cdef_dirs+(t0+0)*4] {1to16}
vpshufbitqmb k1, m26, m20
vpshufbitqmb k2, m27, m20
vpshufbitqmb k3, m28, m20
vpshufbitqmb k4, m29, m20
mova m16, m4
mova m17, m5
mova m18, m6
mova m19, m7
vpermb m16{k1}, m20, m12
vpermb m17{k2}, m20, m13
vpermb m18{k3}, m20, m14
vpermb m19{k4}, m20, m15
vpshufbitqmb k1, m26, m21
vpshufbitqmb k2, m27, m21
vpshufbitqmb k3, m28, m21
vpshufbitqmb k4, m29, m21
vpermb m12, m21, m12
vpermb m13, m21, m13
vpermb m14, m21, m14
vpermb m15, m21, m15
vpblendmb m12{k1}, m4, m12
vpblendmb m13{k2}, m5, m13
vpblendmb m14{k3}, m6, m14
vpblendmb m15{k4}, m7, m15
jmp .sec_main
ALIGN function_align
.sec:
vpaddd m20, m30, [base+cdef_dirs+(t0+4)*4] {1to16} ; dir + 2
vpaddd m21, m30, [base+cdef_dirs+(t0+0)*4] {1to16} ; dir - 2
vpermb m16, m20, m12 ; pNtl k0s0 k0s1 k1s0 k1s1
vpermb m17, m20, m13 ; pNtr
vpermb m18, m20, m14 ; pNbl
vpermb m19, m20, m15 ; pNbr
vpermb m12, m21, m12 ; pNtl k0s2 k0s3 k1s2 k1s3
vpermb m13, m21, m13 ; pNtr
vpermb m14, m21, m14 ; pNbl
vpermb m15, m21, m15 ; pNbr
.sec_main:
%macro CDEF_FILTER_8x8_SEC 4-5 0 ; load constants
vpcmpub k1, m4, %1, 6
vpcmpub k2, m5, %2, 6
vpcmpub k3, m6, %3, 6
vpcmpub k4, m7, %4, 6
psubb m20, %1, m4
psubb m21, %2, m5
psubb m22, %3, m6
psubb m23, %4, m7
%if %5
vpbroadcastb m28, t1d
lzcnt t1d, t1d
vpbroadcastq m29, [r3+t1*8]
%endif
vpsubb m20{k1}, m4, %1
vpsubb m21{k2}, m5, %2
vpsubb m22{k3}, m6, %3
vpsubb m23{k4}, m7, %4
gf2p8affineqb m24, m20, m29, 0
gf2p8affineqb m25, m21, m29, 0
gf2p8affineqb m26, m22, m29, 0
gf2p8affineqb m27, m23, m29, 0
%if %5
vpbroadcastd m30, [base+sec_tap]
%endif
psubusb m24, m28, m24
psubusb m25, m28, m25
psubusb m26, m28, m26
psubusb m27, m28, m27
pminub m20, m24
pminub m21, m25
pminub m22, m26
pminub m23, m27
mova m24, m30
mova m25, m30
mova m26, m30
mova m27, m30
vpsubb m24{k1}, m31, m30
vpsubb m25{k2}, m31, m30
vpsubb m26{k3}, m31, m30
vpsubb m27{k4}, m31, m30
vpdpbusd m0, m20, m24
vpdpbusd m1, m21, m25
vpdpbusd m2, m22, m26
vpdpbusd m3, m23, m27
%endmacro
CDEF_FILTER_8x8_SEC m16, m17, m18, m19, 1
CDEF_FILTER_8x8_SEC m12, m13, m14, m15
ret
%endif ; HAVE_AVX512ICL && ARCH_X86_64
|
.ORIG x3000
AND R5, R5, #0
AND R3, R3, #0
ADD R3, R3, #8
LEA R0, B
LDW R1, R0, #1
LDW R1, R1, #0
ADD R2, R1, #0
AGAIN ADD R2, R2, R2
ADD R3, R3, #-1
BRp AGAIN
LDW R4, R0, #0
AND R1, R1, R4
NOT R1, R1
ADD R1, R1, #1
ADD R2, R2, R1
BRnp NO
ADD R5, R5, #1
NO HALT
B .FILL XFF00
A .FILL X4000
.END
|
; A284404: Binary representation of the x-axis, from the origin to the right edge, of the n-th stage of growth of the two-dimensional cellular automaton defined by "Rule 913", based on the 5-celled von Neumann neighborhood.
; Submitted by Christian Krause
; 1,0,101,111,11111,111111,1111111,11111111,111111111,1111111111,11111111111,111111111111,1111111111111,11111111111111,111111111111111,1111111111111111,11111111111111111,111111111111111111,1111111111111111111,11111111111111111111,111111111111111111111,1111111111111111111111,11111111111111111111111,111111111111111111111111,1111111111111111111111111,11111111111111111111111111,111111111111111111111111111,1111111111111111111111111111,11111111111111111111111111111,111111111111111111111111111111
seq $0,284403 ; Binary representation of the x-axis, from the left edge to the origin, of the n-th stage of growth of the two-dimensional cellular automaton defined by "Rule 913", based on the 5-celled von Neumann neighborhood.
seq $0,4086 ; Read n backwards (referred to as R(n) in many sequences).
|
; A017342: a(n) = (10*n + 6)^2.
; 36,256,676,1296,2116,3136,4356,5776,7396,9216,11236,13456,15876,18496,21316,24336,27556,30976,34596,38416,42436,46656,51076,55696,60516,65536,70756,76176,81796,87616,93636,99856,106276,112896,119716,126736,133956,141376,148996,156816,164836,173056,181476,190096,198916,207936,217156,226576,236196,246016,256036,266256,276676,287296,298116,309136,320356,331776,343396,355216,367236,379456,391876,404496,417316,430336,443556,456976,470596,484416,498436,512656,527076,541696,556516,571536,586756,602176,617796,633616,649636,665856,682276,698896,715716,732736,749956,767376,784996,802816,820836,839056,857476,876096,894916,913936,933156,952576,972196,992016,1012036,1032256,1052676,1073296,1094116,1115136,1136356,1157776,1179396,1201216,1223236,1245456,1267876,1290496,1313316,1336336,1359556,1382976,1406596,1430416,1454436,1478656,1503076,1527696,1552516,1577536,1602756,1628176,1653796,1679616,1705636,1731856,1758276,1784896,1811716,1838736,1865956,1893376,1920996,1948816,1976836,2005056,2033476,2062096,2090916,2119936,2149156,2178576,2208196,2238016,2268036,2298256,2328676,2359296,2390116,2421136,2452356,2483776,2515396,2547216,2579236,2611456,2643876,2676496,2709316,2742336,2775556,2808976,2842596,2876416,2910436,2944656,2979076,3013696,3048516,3083536,3118756,3154176,3189796,3225616,3261636,3297856,3334276,3370896,3407716,3444736,3481956,3519376,3556996,3594816,3632836,3671056,3709476,3748096,3786916,3825936,3865156,3904576,3944196,3984016,4024036,4064256,4104676,4145296,4186116,4227136,4268356,4309776,4351396,4393216,4435236,4477456,4519876,4562496,4605316,4648336,4691556,4734976,4778596,4822416,4866436,4910656,4955076,4999696,5044516,5089536,5134756,5180176,5225796,5271616,5317636,5363856,5410276,5456896,5503716,5550736,5597956,5645376,5692996,5740816,5788836,5837056,5885476,5934096,5982916,6031936,6081156,6130576,6180196,6230016
mul $0,10
add $0,6
mov $1,$0
pow $1,2
|
; A050484: Partial sums of A051946.
; 1,12,68,264,810,2112,4884,10296,20163,37180,65208,109616,177684,279072,426360,635664,927333,1326732,1865116,2580600,3519230,4736160,6296940,8278920,10772775,13884156,17735472,22467808,28242984,35245760,43686192,53802144,65861961,80167308,97056180,116906088,140137426,167217024,198661892,235043160,276990219,325195068,380416872,443486736,515312700,596884960,689281320,793672880,911329965,1043628300,1192055436,1358217432,1543845798,1750804704,1981098460,2236879272,2520455279,2834298876,3181055328,3563551680,3984805968,4448036736,4956672864,5514363712,6124989585,6792672524,7521787428,8316973512,9183146106,10125508800,11149565940,12261135480,13466362195,14771731260,16184082200,17710623216,19358945892,21137040288,23053310424,25116590160,27336159477,29721761164,32283617916,35032449848,37979492430,41136514848,44515838796,48130357704,51993556407,56119531260,60523010704,65219376288,70224684152,75555686976,81229856400,87265405920,93681314265,100497349260,107734092180,115412962600,123556243746,132187108352,141329645028,151008885144,161250830235,172082479932,183531860424,195628053456,208401225868,221882659680,236104782728,251101199856,266906724669,283557411852,301090590060,319544895384,338960305398,359378173792,380841265596,403393793000,427081451775,451951458300,478052587200,505435209600,534151332000,564254635776,595800517312,628846128768,663450419489,699674178060,737580075012,777232706184,818698636746,862046445888,907346772180,954672359608,1004098104291,1055701101884,1109560695672,1165758525360,1224378576564,1285507231008,1349233317432,1415648163216,1484845646725,1556922250380,1631977114460,1710112091640,1791431802270,1876043690400,1964058080556,2055588235272,2150750413383,2249663929084,2352451211760,2459237866592,2570152735944,2685327961536,2804899047408,2929004923680,3057788011113,3191394286476,3329973348724,3473678485992,3622666743410,3777098991744,3937139996868,4102958490072,4274727239211,4452623120700,4636827192360,4827524767120,5024905487580,5229163401440,5440497037800,5659109484336,5885208465357,6119006420748,6360720585804,6610573071960,6868790948422,7135606324704,7411256434076,7695983717928,7990035911055,8293666127868,8607132949536,8930700512064,9264638595312,9609222712960,9964734203424,10331460321728,10709694332337,11099735602956,11501889699300,11916468480840,12343790197530,12784179587520,13237967975860,13705493374200,14187100581491,14683141285692,15193974166488,15719964999024,16261486758660,16818919726752,17392651597464,17983077585616,18590600535573,19215631031180,19858587506748,20519896359096,21199992060654,21899317273632,22618322965260,23357468524104,24117221877463,24898059609852,25700467082576,26524938554400,27371977303320,28242095749440,29135815578960,30053667869280,30996193215225,31963941856396,32957473805652,33977358978728,35024177324994,36098518959360,37200984295332,38332184179224,39492740025531,40683283953468,41904458924680,43156918882128,44441328890156,45758365275744,47108715770952,48493079656560,49912167906909,51366703335948,52857420744492,54385067068696,55950401529750,57554195784800,59197234079100,60880313399400,62604243628575,64369847701500
lpb $0,1
mov $2,$0
cal $2,51946 ; Expansion of g.f.: (1+4*x)/(1-x)^7.
sub $0,1
mul $2,2
add $3,$2
mov $1,$3
lpe
div $1,2
add $1,1
|
push 0
push 1
push 2
push 3
push 4
push 5
push 6
push 7
push 8
push 9
push 10
l1: print
push 0
bleq l2
b l1
l2: halt
|
; A054074: Position of n-th 1 in A054073.
; 1,2,5,8,13,18,24,32,40,50,60,71,84,97,112,127,144,161,179,199,219,241,263,286,311,336,363,390,419,448,478,510,542,576,610,645,682,719,758,797,837,879,921,965,1009,1055,1101,1148,1197
mov $2,$0
add $2,1
mov $5,$0
lpb $2
mov $0,$5
sub $2,1
sub $0,$2
sub $0,1
mov $3,$0
mov $4,$0
add $4,2
cal $4,285073 ; 0-limiting word of the morphism 0->10, 1-> 010.
add $3,1
add $3,$4
add $1,$3
lpe
|
global start
section .text ;read-only section
start:
mov rax, 0x02000004 ;write system call
mov rdi, 1 ;file handle set to 1 : stdout
mov rsi, message ;rsi을 message 주소값으로 정의
mov rdx, 13 ;13바이트로 쓰기 크기 정의
syscall ;쓰기 실행
mov rax, 0x02000001 ;exit system call
xor rdi, rdi ;exit handle 0
syscall ;exit 실행
section .data ;runtime에 바뀌지 않는 상수 값을 초기에 정의해주기 위한 섹션
message:
db "Hello, World", 0x10 ;db stands for 'data byte'
;writes to address `message` "Hello, World",
;and a white space(0x10) after it
|
/**
* Appcelerator Titanium - licensed under the Apache Public License 2
* see LICENSE in the root folder for details on the license.
* Copyright (c) 2009 Appcelerator, Inc. All Rights Reserved.
*/
#include "../ui_module.h"
namespace ti {
void menu_callback(gpointer data);
GtkMenuItemImpl::GtkMenuItemImpl()
: parent(NULL)
{
}
void GtkMenuItemImpl::SetParent(GtkMenuItemImpl* parent)
{
this->parent = parent;
}
GtkMenuItemImpl* GtkMenuItemImpl::GetParent()
{
return this->parent;
}
SharedValue GtkMenuItemImpl::AddSeparator()
{
GtkMenuItemImpl* item = new GtkMenuItemImpl();
item->MakeSeparator();
return this->AppendItem(item);
}
SharedValue GtkMenuItemImpl::AddItem(SharedValue label,
SharedValue callback,
SharedValue icon_url)
{
GtkMenuItemImpl* item = new GtkMenuItemImpl();
item->MakeItem(label, callback, icon_url);
return this->AppendItem(item);
}
SharedValue GtkMenuItemImpl::AddSubMenu(SharedValue label,
SharedValue icon_url)
{
GtkMenuItemImpl* item = new GtkMenuItemImpl();
item->MakeSubMenu(label, icon_url);
return this->AppendItem(item);
}
SharedValue GtkMenuItemImpl::AppendItem(GtkMenuItemImpl* item)
{
item->SetParent(this);
this->children.push_back(item);
/* Realize the new item and add it to all existing instances */
std::vector<MenuPieces*>::iterator i = this->instances.begin();
while (i != this->instances.end())
{
MenuPieces *pieces = item->Realize(false);
gtk_menu_shell_append(GTK_MENU_SHELL((*i)->menu), pieces->item);
gtk_widget_show(pieces->item);
i++;
}
return MenuItem::AddToListModel(item);
}
GtkWidget* GtkMenuItemImpl::GetMenu()
{
if (this->parent == NULL) // top-level
{
MenuPieces* pieces = this->Realize(false);
return pieces->menu;
}
else
{
// For now we do not support using a submenu as a menu,
// as that makes determining parent-child relationships
// really hard, so just return NULL and check above.
return NULL;
}
}
GtkWidget* GtkMenuItemImpl::GetMenuBar()
{
if (this->parent == NULL) // top level
{
MenuPieces* pieces = this->Realize(true);
return pieces->menu;
}
else
{
// For now we do not support using a submenu as a menu,
// as that makes determining parent-child relationships
// really hard, so just return NULL and check above.
return NULL;
}
}
void GtkMenuItemImpl::AddChildrenTo(GtkWidget* menu)
{
std::vector<GtkMenuItemImpl*>::iterator c;
for (c = this->children.begin(); c != this->children.end(); c++)
{
MenuPieces* pieces = new MenuPieces();
(*c)->MakeMenuPieces(*pieces);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), pieces->item);
gtk_widget_show(pieces->item);
if (this->IsSubMenu() || this->parent == NULL)
{
(*c)->AddChildrenTo(pieces->menu);
}
delete pieces;
}
}
void GtkMenuItemImpl::ClearRealization(GtkWidget *parent_menu)
{
std::vector<MenuPieces*>::iterator i;
std::vector<GtkMenuItemImpl*>::iterator c;
// Find the instance which is contained in parent_menu or,
// if we are the root, find the instance which uses this
// menu to contain it's children.
for (i = this->instances.begin(); i != this->instances.end(); i++)
{
if ((*i)->parent_menu == parent_menu
|| (this->parent == NULL && (*i)->menu == parent_menu))
break;
}
// Could not find an instance which uses the menu.
if (i == this->instances.end()) return;
// Erase all children which use
// the sub-menu as their parent.
for (c = this->children.begin(); c != this->children.end(); c++)
{
(*c)->ClearRealization((*i)->menu);
}
this->instances.erase(i); // Erase the instance
}
GtkMenuItemImpl::MenuPieces* GtkMenuItemImpl::Realize(bool is_menu_bar)
{
MenuPieces* pieces = new MenuPieces();
if (this->parent == NULL) // top-level
{
if (is_menu_bar)
pieces->menu = gtk_menu_bar_new();
else
pieces->menu = gtk_menu_new();
}
else
{
this->MakeMenuPieces(*pieces);
}
/* Realize this widget's children */
if (this->IsSubMenu() || this->parent == NULL)
{
std::vector<GtkMenuItemImpl*>::iterator i = this->children.begin();
while (i != this->children.end())
{
MenuPieces* child_pieces = (*i)->Realize(false);
child_pieces->parent_menu = pieces->menu;
gtk_menu_shell_append(
GTK_MENU_SHELL(pieces->menu),
child_pieces->item);
gtk_widget_show(child_pieces->item);
i++;
}
}
this->instances.push_back(pieces);
return pieces;
}
void GtkMenuItemImpl::MakeMenuPieces(MenuPieces& pieces)
{
const char* label = this->GetLabel();
const char* icon_url = this->GetIconURL();
SharedString icon_path = UIModule::GetResourcePath(icon_url);
SharedValue callback_val = this->RawGet("callback");
if (this->IsSeparator())
{
pieces.item = gtk_separator_menu_item_new();
}
else if (icon_path.isNull())
{
pieces.item = gtk_menu_item_new_with_label(label);
}
else
{
pieces.item = gtk_image_menu_item_new_with_label(label);
GtkWidget* image = gtk_image_new_from_file(icon_path->c_str());
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(pieces.item), image);
}
if (callback_val->IsMethod())
{
// The callback is stored as a property of this MenuItem
// so we do not need to worry about the pointer being freed
// out from under us. At some point, in threaded code we will
// have to protect it with a mutex though, in the case that
// the callback is fired after it has been reassigned.
BoundMethod* cb = callback_val->ToMethod().get();
g_signal_connect_swapped(
G_OBJECT (pieces.item), "activate",
G_CALLBACK(menu_callback),
(gpointer) cb);
}
if (this->IsSubMenu())
{
pieces.menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(pieces.item), pieces.menu);
}
}
/* Crazy mutations below */
void GtkMenuItemImpl::Enable()
{
std::vector<MenuPieces*>::iterator i = this->instances.begin();
while (i != this->instances.end())
{
GtkWidget *w = (*i)->item;
if (w != NULL)
gtk_widget_set_sensitive(w, TRUE);
i++;
}
}
void GtkMenuItemImpl::Disable()
{
std::vector<MenuPieces*>::iterator i = this->instances.begin();
while (i != this->instances.end())
{
GtkWidget *w = (*i)->item;
if (w != NULL)
gtk_widget_set_sensitive(w, FALSE);
i++;
}
}
void GtkMenuItemImpl::SetLabel(std::string label)
{
std::vector<MenuPieces*>::iterator i = this->instances.begin();
while (i != this->instances.end())
{
GtkWidget *w = (*i)->item;
if (w != NULL)
{
GtkWidget *menu_label = gtk_bin_get_child(GTK_BIN(w));
gtk_label_set_text(GTK_LABEL(menu_label), label.c_str());
}
i++;
}
}
void GtkMenuItemImpl::SetIcon(std::string icon_url)
{
std::vector<MenuPieces*>::iterator i = this->instances.begin();
SharedString icon_path = UIModule::GetResourcePath(icon_url.c_str());
while (i != this->instances.end())
{
GtkWidget *w = (*i)->item;
if (w != NULL && G_TYPE_FROM_INSTANCE(w) == GTK_TYPE_IMAGE_MENU_ITEM)
{
GtkWidget* image = gtk_image_new_from_file(icon_path->c_str());
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(w), image);
}
i++;
}
}
/* Le callback */
void menu_callback(gpointer data)
{
BoundMethod* cb = (BoundMethod*) data;
// TODO: Handle exceptions in some way
try
{
ValueList args;
cb->Call(args);
}
catch(...)
{
std::cerr << "Menu callback failed" << std::endl;
}
}
}
|
; A321014: Number of divisors of n which are greater than 3.
; 0,0,0,1,1,1,1,2,1,2,1,3,1,2,2,3,1,3,1,4,2,2,1,5,2,2,2,4,1,5,1,4,2,2,3,6,1,2,2,6,1,5,1,4,4,2,1,7,2,4,2,4,1,5,3,6,2,2,1,9,1,2,4,5,3,5,1,4,2,6,1,9,1,2,4,4,3,5,1,8,3,2,1,9,3,2,2,6,1,9,3,4,2,2
mov $4,$0
mov $6,2
lpb $6,1
clr $0,4
mov $0,$4
sub $6,1
add $0,$6
sub $0,1
lpb $0,1
mov $1,$0
sub $0,3
sub $1,2
add $2,1
div $1,$2
add $3,$1
lpe
mov $1,$3
mov $7,$6
lpb $7,1
mov $5,$1
sub $7,1
lpe
lpe
lpb $4,1
mov $4,0
sub $5,$1
lpe
mov $1,$5
|
.sect ".ivars"
.align 2
dl: .word 0x0FFF
G: .word 0x3000 ;Signed Q15
D: .word 0x7FFF ;Signed Q15
;.def echo_effect
.ref xn
*********************************************************************
* echo_effect *
* Adds echo effect to input sample *
* Takes paramters: *
* D - Delay, DG - Delay Gain *
* Difference equation: *
* y[n] = x[n] + DG * y[n-d] *
*********************************************************************
.text
echo_effect:
*Setup for echo_effect
AMOV #xn, XAR0
MOV *(#dl), T0
*Calculate Echo effect: y[n] = D*(x[n] + DG * y[n-d])
BSET FRCT
MOV *AR6(T0) << #16, AC0 ; move y[n-d] into accumulator
MPYM *(#G), AC0 ; multiply G and y[n-d]
SFTS AC0, #-16 ; Shift the output down so we can get it out. 15 = 16 right (to mov hi to low part) - 1 to remove extra sign bit.
ADD *AR0, AC0 ; add x[n] to get y[n]
MPYM *(#D), AC0 ; multiply D and x[n] + DG * y[n-d]
MOV HI(AC0), *AR0 ; move y[n] into x[n] = AR0 for next effect to use
BCLR FRCT
RET
|
;------------------------------------------------------------------------------
;
; Copyright (c) 2006, Intel Corporation. All rights reserved.<BR>
; This program and the accompanying materials
; are licensed and made available under the terms and conditions of the BSD License
; which accompanies this distribution. The full text of the license may be found at
; http://opensource.org/licenses/bsd-license.php.
;
; THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
; WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
;
; Module Name:
;
; WriteMm7.Asm
;
; Abstract:
;
; AsmWriteMm7 function
;
; Notes:
;
;------------------------------------------------------------------------------
.586
.model flat,C
.mmx
.code
;------------------------------------------------------------------------------
; VOID
; EFIAPI
; AsmWriteMm7 (
; IN UINT64 Value
; );
;------------------------------------------------------------------------------
AsmWriteMm7 PROC
movq mm7, [esp + 4]
ret
AsmWriteMm7 ENDP
END
|
//==================================================================================================
/*
EVE - Expressive Vector Engine
Copyright : EVE Contributors & Maintainers
SPDX-License-Identifier: MIT
*/
//==================================================================================================
#pragma once
#include <eve/concept/compatible.hpp>
#include <eve/concept/value.hpp>
#include <eve/detail/apply_over.hpp>
#include <eve/detail/implementation.hpp>
#include <eve/detail/skeleton_calls.hpp>
#include <eve/function/abs.hpp>
#include <eve/function/if_else.hpp>
#include <eve/function/is_nan.hpp>
#include <eve/function/numeric.hpp>
#include <eve/function/numeric/min.hpp>
#include <eve/function/pedantic.hpp>
#include <eve/platform.hpp>
#include <type_traits>
namespace eve::detail
{
template<real_value T, real_value U>
EVE_FORCEINLINE auto minabs_(EVE_SUPPORTS(cpu_), numeric_type const &
, T const &a, U const &b) noexcept
requires compatible_values<T, U>
{
return arithmetic_call(numeric(minabs), a, b);
}
template<real_value T>
EVE_FORCEINLINE auto minabs_(EVE_SUPPORTS(cpu_), numeric_type const &
, T const &a, T const &b) noexcept
{
return eve::numeric(min)(eve::abs(a), eve::abs(b));
}
//================================================================================================
//N parameters
//================================================================================================
template<real_value T0, real_value T1, real_value ...Ts>
auto minabs_(EVE_SUPPORTS(cpu_), numeric_type const &, T0 a0, T1 a1, Ts... args)
{
using r_t = common_compatible_t<T0,T1,Ts...>;
r_t that(numeric(minabs)(r_t(a0),r_t(a1)));
((that = numeric(minabs)(that,r_t(args))),...);
return that;
}
}
|
Museum2F_h:
db MUSEUM ; tileset
db MUSEUM_2F_HEIGHT, MUSEUM_2F_WIDTH ; dimensions (y, x)
dw Museum2FBlocks, Museum2FTextPointers, Museum2FScript ; blocks, texts, scripts
db $00 ; connections
dw Museum2FObject ; objects
|
.global s_prepare_buffers
s_prepare_buffers:
push %r14
push %r15
push %rax
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_normal_ht+0x1ef3b, %r15
and $6265, %r14
movw $0x6162, (%r15)
nop
nop
nop
nop
nop
xor $35076, %rbx
lea addresses_UC_ht+0x4bbb, %rbx
nop
nop
nop
nop
and %rdx, %rdx
mov $0x6162636465666768, %rcx
movq %rcx, (%rbx)
nop
nop
and $40512, %rdi
lea addresses_normal_ht+0x15bbb, %rsi
lea addresses_WT_ht+0xe31b, %rdi
nop
nop
cmp %rax, %rax
mov $93, %rcx
rep movsl
nop
nop
nop
add $53979, %rbx
lea addresses_WC_ht+0x130df, %rsi
lea addresses_WC_ht+0x148a3, %rdi
nop
nop
add %r15, %r15
mov $8, %rcx
rep movsb
nop
nop
sub $877, %r15
lea addresses_normal_ht+0x7abb, %rsi
lea addresses_normal_ht+0xffbb, %rdi
nop
and $3291, %r14
mov $78, %rcx
rep movsl
nop
nop
nop
add $56053, %r15
lea addresses_UC_ht+0x13, %rsi
lea addresses_UC_ht+0xbbbb, %rdi
clflush (%rsi)
nop
nop
nop
nop
nop
cmp $63530, %rbx
mov $71, %rcx
rep movsl
nop
nop
nop
add $1144, %rax
lea addresses_WC_ht+0x10ebb, %rsi
lea addresses_A_ht+0x4fbb, %rdi
nop
sub $19299, %r14
mov $0, %rcx
rep movsl
nop
sub %rsi, %rsi
lea addresses_WT_ht+0xd5b, %rcx
nop
nop
nop
and $20881, %rsi
mov (%rcx), %r15
and $18385, %rbx
lea addresses_WC_ht+0x5bbb, %rsi
lea addresses_normal_ht+0x13983, %rdi
nop
nop
nop
add $24721, %rdx
mov $14, %rcx
rep movsw
nop
nop
nop
cmp $48622, %r15
lea addresses_WT_ht+0x16f3b, %rcx
clflush (%rcx)
nop
nop
nop
nop
nop
and $51821, %rax
mov (%rcx), %edx
nop
nop
add $32473, %rax
lea addresses_UC_ht+0x1babb, %rdi
nop
nop
nop
nop
nop
and %rdx, %rdx
mov (%rdi), %rsi
nop
nop
nop
cmp $21841, %r15
lea addresses_A_ht+0x11abb, %rdi
nop
nop
nop
nop
inc %r15
mov $0x6162636465666768, %rcx
movq %rcx, %xmm5
movups %xmm5, (%rdi)
nop
nop
nop
nop
add $1842, %r14
lea addresses_D_ht+0x32cb, %rax
inc %r15
mov $0x6162636465666768, %rbx
movq %rbx, %xmm7
vmovups %ymm7, (%rax)
nop
nop
nop
nop
and %rdx, %rdx
lea addresses_WC_ht+0x47db, %r15
nop
nop
nop
nop
nop
and $57474, %rax
vmovups (%r15), %ymm4
vextracti128 $0, %ymm4, %xmm4
vpextrq $1, %xmm4, %rdx
nop
nop
nop
dec %rbx
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %rax
pop %r15
pop %r14
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r13
push %r14
push %r9
push %rax
push %rsi
// Load
lea addresses_PSE+0x55fb, %r9
nop
cmp %r13, %r13
mov (%r9), %esi
nop
nop
sub %rsi, %rsi
// Store
lea addresses_D+0x1e25a, %r10
clflush (%r10)
nop
nop
nop
nop
nop
sub %r11, %r11
mov $0x5152535455565758, %r9
movq %r9, %xmm4
movups %xmm4, (%r10)
nop
add %r13, %r13
// Load
lea addresses_RW+0x3c4b, %rax
nop
nop
nop
nop
nop
sub $17512, %r9
mov (%rax), %si
nop
nop
nop
nop
nop
cmp %r11, %r11
// Store
lea addresses_normal+0x7c3, %r14
nop
add $35313, %r9
movw $0x5152, (%r14)
nop
nop
dec %r14
// Store
lea addresses_RW+0x14bbb, %r10
clflush (%r10)
nop
nop
dec %rax
movb $0x51, (%r10)
dec %r11
// Store
mov $0x719241000000093b, %r10
nop
nop
nop
add %r11, %r11
mov $0x5152535455565758, %rsi
movq %rsi, %xmm1
vmovups %ymm1, (%r10)
nop
nop
nop
xor %r13, %r13
// Load
lea addresses_WT+0x3675, %r9
nop
cmp %r13, %r13
mov (%r9), %si
nop
xor %r11, %r11
// Load
lea addresses_US+0x119bb, %rax
nop
nop
nop
cmp $18978, %rsi
mov (%rax), %r14d
sub $52321, %rsi
// Faulty Load
lea addresses_RW+0x14bbb, %rsi
nop
xor %r13, %r13
movb (%rsi), %r9b
lea oracles, %r10
and $0xff, %r9
shlq $12, %r9
mov (%r10,%r9,1), %r9
pop %rsi
pop %rax
pop %r9
pop %r14
pop %r13
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'congruent': 0, 'AVXalign': False, 'same': False, 'size': 16, 'NT': False, 'type': 'addresses_RW'}, 'OP': 'LOAD'}
{'src': {'congruent': 2, 'AVXalign': False, 'same': False, 'size': 4, 'NT': False, 'type': 'addresses_PSE'}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'congruent': 0, 'AVXalign': False, 'same': False, 'size': 16, 'NT': False, 'type': 'addresses_D'}}
{'src': {'congruent': 4, 'AVXalign': False, 'same': False, 'size': 2, 'NT': False, 'type': 'addresses_RW'}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'congruent': 3, 'AVXalign': False, 'same': False, 'size': 2, 'NT': False, 'type': 'addresses_normal'}}
{'OP': 'STOR', 'dst': {'congruent': 0, 'AVXalign': False, 'same': True, 'size': 1, 'NT': False, 'type': 'addresses_RW'}}
{'OP': 'STOR', 'dst': {'congruent': 7, 'AVXalign': False, 'same': False, 'size': 32, 'NT': False, 'type': 'addresses_NC'}}
{'src': {'congruent': 1, 'AVXalign': False, 'same': False, 'size': 2, 'NT': False, 'type': 'addresses_WT'}, 'OP': 'LOAD'}
{'src': {'congruent': 9, 'AVXalign': False, 'same': False, 'size': 4, 'NT': False, 'type': 'addresses_US'}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'congruent': 0, 'AVXalign': False, 'same': True, 'size': 1, 'NT': False, 'type': 'addresses_RW'}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'congruent': 6, 'AVXalign': False, 'same': False, 'size': 2, 'NT': False, 'type': 'addresses_normal_ht'}}
{'OP': 'STOR', 'dst': {'congruent': 11, 'AVXalign': False, 'same': False, 'size': 8, 'NT': False, 'type': 'addresses_UC_ht'}}
{'src': {'congruent': 5, 'same': False, 'type': 'addresses_normal_ht'}, 'OP': 'REPM', 'dst': {'congruent': 5, 'same': False, 'type': 'addresses_WT_ht'}}
{'src': {'congruent': 1, 'same': False, 'type': 'addresses_WC_ht'}, 'OP': 'REPM', 'dst': {'congruent': 2, 'same': False, 'type': 'addresses_WC_ht'}}
{'src': {'congruent': 8, 'same': False, 'type': 'addresses_normal_ht'}, 'OP': 'REPM', 'dst': {'congruent': 9, 'same': False, 'type': 'addresses_normal_ht'}}
{'src': {'congruent': 3, 'same': False, 'type': 'addresses_UC_ht'}, 'OP': 'REPM', 'dst': {'congruent': 11, 'same': False, 'type': 'addresses_UC_ht'}}
{'src': {'congruent': 8, 'same': False, 'type': 'addresses_WC_ht'}, 'OP': 'REPM', 'dst': {'congruent': 10, 'same': False, 'type': 'addresses_A_ht'}}
{'src': {'congruent': 4, 'AVXalign': False, 'same': False, 'size': 8, 'NT': False, 'type': 'addresses_WT_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 10, 'same': False, 'type': 'addresses_WC_ht'}, 'OP': 'REPM', 'dst': {'congruent': 0, 'same': False, 'type': 'addresses_normal_ht'}}
{'src': {'congruent': 7, 'AVXalign': False, 'same': False, 'size': 4, 'NT': False, 'type': 'addresses_WT_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 7, 'AVXalign': False, 'same': False, 'size': 8, 'NT': False, 'type': 'addresses_UC_ht'}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'congruent': 6, 'AVXalign': False, 'same': False, 'size': 16, 'NT': False, 'type': 'addresses_A_ht'}}
{'OP': 'STOR', 'dst': {'congruent': 2, 'AVXalign': False, 'same': True, 'size': 32, 'NT': False, 'type': 'addresses_D_ht'}}
{'src': {'congruent': 3, 'AVXalign': False, 'same': False, 'size': 32, 'NT': False, 'type': 'addresses_WC_ht'}, 'OP': 'LOAD'}
{'51': 13}
51 51 51 51 51 51 51 51 51 51 51 51 51
*/
|
_wc: file format elf32-i386
Disassembly of section .text:
00000000 <main>:
printf(1, "%d %d %d %s\n", l, w, c, name);
}
int
main(int argc, char *argv[])
{
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 57 push %edi
4: 56 push %esi
int fd, i;
if(argc <= 1){
5: be 01 00 00 00 mov $0x1,%esi
printf(1, "%d %d %d %s\n", l, w, c, name);
}
int
main(int argc, char *argv[])
{
a: 53 push %ebx
b: 83 e4 f0 and $0xfffffff0,%esp
e: 83 ec 10 sub $0x10,%esp
11: 8b 45 0c mov 0xc(%ebp),%eax
int fd, i;
if(argc <= 1){
14: 83 7d 08 01 cmpl $0x1,0x8(%ebp)
18: 8d 58 04 lea 0x4(%eax),%ebx
1b: 7e 60 jle 7d <main+0x7d>
1d: 8d 76 00 lea 0x0(%esi),%esi
wc(0, "");
exit();
}
for(i = 1; i < argc; i++){
if((fd = open(argv[i], 0)) < 0){
20: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
27: 00
28: 8b 03 mov (%ebx),%eax
2a: 89 04 24 mov %eax,(%esp)
2d: e8 c0 03 00 00 call 3f2 <open>
32: 85 c0 test %eax,%eax
34: 89 c7 mov %eax,%edi
36: 78 26 js 5e <main+0x5e>
printf(1, "wc: cannot open %s\n", argv[i]);
exit();
}
wc(fd, argv[i]);
38: 8b 13 mov (%ebx),%edx
if(argc <= 1){
wc(0, "");
exit();
}
for(i = 1; i < argc; i++){
3a: 83 c6 01 add $0x1,%esi
3d: 83 c3 04 add $0x4,%ebx
if((fd = open(argv[i], 0)) < 0){
printf(1, "wc: cannot open %s\n", argv[i]);
exit();
}
wc(fd, argv[i]);
40: 89 04 24 mov %eax,(%esp)
43: 89 54 24 04 mov %edx,0x4(%esp)
47: e8 54 00 00 00 call a0 <wc>
close(fd);
4c: 89 3c 24 mov %edi,(%esp)
4f: e8 86 03 00 00 call 3da <close>
if(argc <= 1){
wc(0, "");
exit();
}
for(i = 1; i < argc; i++){
54: 3b 75 08 cmp 0x8(%ebp),%esi
57: 75 c7 jne 20 <main+0x20>
exit();
}
wc(fd, argv[i]);
close(fd);
}
exit();
59: e8 54 03 00 00 call 3b2 <exit>
exit();
}
for(i = 1; i < argc; i++){
if((fd = open(argv[i], 0)) < 0){
printf(1, "wc: cannot open %s\n", argv[i]);
5e: 8b 03 mov (%ebx),%eax
60: c7 44 24 04 99 08 00 movl $0x899,0x4(%esp)
67: 00
68: c7 04 24 01 00 00 00 movl $0x1,(%esp)
6f: 89 44 24 08 mov %eax,0x8(%esp)
73: e8 98 04 00 00 call 510 <printf>
exit();
78: e8 35 03 00 00 call 3b2 <exit>
main(int argc, char *argv[])
{
int fd, i;
if(argc <= 1){
wc(0, "");
7d: c7 44 24 04 8b 08 00 movl $0x88b,0x4(%esp)
84: 00
85: c7 04 24 00 00 00 00 movl $0x0,(%esp)
8c: e8 0f 00 00 00 call a0 <wc>
exit();
91: e8 1c 03 00 00 call 3b2 <exit>
96: 66 90 xchg %ax,%ax
98: 66 90 xchg %ax,%ax
9a: 66 90 xchg %ax,%ax
9c: 66 90 xchg %ax,%ax
9e: 66 90 xchg %ax,%ax
000000a0 <wc>:
char buf[512];
void
wc(int fd, char *name)
{
a0: 55 push %ebp
a1: 89 e5 mov %esp,%ebp
a3: 57 push %edi
a4: 56 push %esi
int i, n;
int l, w, c, inword;
l = w = c = 0;
inword = 0;
a5: 31 f6 xor %esi,%esi
char buf[512];
void
wc(int fd, char *name)
{
a7: 53 push %ebx
int i, n;
int l, w, c, inword;
l = w = c = 0;
a8: 31 db xor %ebx,%ebx
char buf[512];
void
wc(int fd, char *name)
{
aa: 83 ec 3c sub $0x3c,%esp
int i, n;
int l, w, c, inword;
l = w = c = 0;
ad: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
b4: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
bb: 90 nop
bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
inword = 0;
while((n = read(fd, buf, sizeof(buf))) > 0){
c0: 8b 45 08 mov 0x8(%ebp),%eax
c3: c7 44 24 08 00 02 00 movl $0x200,0x8(%esp)
ca: 00
cb: c7 44 24 04 a0 0b 00 movl $0xba0,0x4(%esp)
d2: 00
d3: 89 04 24 mov %eax,(%esp)
d6: e8 ef 02 00 00 call 3ca <read>
db: 83 f8 00 cmp $0x0,%eax
de: 89 45 e4 mov %eax,-0x1c(%ebp)
e1: 7e 54 jle 137 <wc+0x97>
e3: 31 ff xor %edi,%edi
e5: eb 0b jmp f2 <wc+0x52>
e7: 90 nop
for(i=0; i<n; i++){
c++;
if(buf[i] == '\n')
l++;
if(strchr(" \r\t\n\v", buf[i]))
inword = 0;
e8: 31 f6 xor %esi,%esi
int l, w, c, inword;
l = w = c = 0;
inword = 0;
while((n = read(fd, buf, sizeof(buf))) > 0){
for(i=0; i<n; i++){
ea: 83 c7 01 add $0x1,%edi
ed: 3b 7d e4 cmp -0x1c(%ebp),%edi
f0: 74 38 je 12a <wc+0x8a>
c++;
if(buf[i] == '\n')
f2: 0f be 87 a0 0b 00 00 movsbl 0xba0(%edi),%eax
l++;
f9: 31 c9 xor %ecx,%ecx
if(strchr(" \r\t\n\v", buf[i]))
fb: c7 04 24 76 08 00 00 movl $0x876,(%esp)
inword = 0;
while((n = read(fd, buf, sizeof(buf))) > 0){
for(i=0; i<n; i++){
c++;
if(buf[i] == '\n')
l++;
102: 3c 0a cmp $0xa,%al
104: 0f 94 c1 sete %cl
if(strchr(" \r\t\n\v", buf[i]))
107: 89 44 24 04 mov %eax,0x4(%esp)
inword = 0;
while((n = read(fd, buf, sizeof(buf))) > 0){
for(i=0; i<n; i++){
c++;
if(buf[i] == '\n')
l++;
10b: 01 cb add %ecx,%ebx
if(strchr(" \r\t\n\v", buf[i]))
10d: e8 4e 01 00 00 call 260 <strchr>
112: 85 c0 test %eax,%eax
114: 75 d2 jne e8 <wc+0x48>
inword = 0;
else if(!inword){
116: 85 f6 test %esi,%esi
118: 75 16 jne 130 <wc+0x90>
w++;
11a: 83 45 e0 01 addl $0x1,-0x20(%ebp)
int l, w, c, inword;
l = w = c = 0;
inword = 0;
while((n = read(fd, buf, sizeof(buf))) > 0){
for(i=0; i<n; i++){
11e: 83 c7 01 add $0x1,%edi
121: 3b 7d e4 cmp -0x1c(%ebp),%edi
l++;
if(strchr(" \r\t\n\v", buf[i]))
inword = 0;
else if(!inword){
w++;
inword = 1;
124: 66 be 01 00 mov $0x1,%si
int l, w, c, inword;
l = w = c = 0;
inword = 0;
while((n = read(fd, buf, sizeof(buf))) > 0){
for(i=0; i<n; i++){
128: 75 c8 jne f2 <wc+0x52>
12a: 01 7d dc add %edi,-0x24(%ebp)
12d: eb 91 jmp c0 <wc+0x20>
12f: 90 nop
130: be 01 00 00 00 mov $0x1,%esi
135: eb b3 jmp ea <wc+0x4a>
w++;
inword = 1;
}
}
}
if(n < 0){
137: 75 35 jne 16e <wc+0xce>
printf(1, "wc: read error\n");
exit();
}
printf(1, "%d %d %d %s\n", l, w, c, name);
139: 8b 45 0c mov 0xc(%ebp),%eax
13c: 89 5c 24 08 mov %ebx,0x8(%esp)
140: c7 44 24 04 8c 08 00 movl $0x88c,0x4(%esp)
147: 00
148: c7 04 24 01 00 00 00 movl $0x1,(%esp)
14f: 89 44 24 14 mov %eax,0x14(%esp)
153: 8b 45 dc mov -0x24(%ebp),%eax
156: 89 44 24 10 mov %eax,0x10(%esp)
15a: 8b 45 e0 mov -0x20(%ebp),%eax
15d: 89 44 24 0c mov %eax,0xc(%esp)
161: e8 aa 03 00 00 call 510 <printf>
}
166: 83 c4 3c add $0x3c,%esp
169: 5b pop %ebx
16a: 5e pop %esi
16b: 5f pop %edi
16c: 5d pop %ebp
16d: c3 ret
inword = 1;
}
}
}
if(n < 0){
printf(1, "wc: read error\n");
16e: c7 44 24 04 7c 08 00 movl $0x87c,0x4(%esp)
175: 00
176: c7 04 24 01 00 00 00 movl $0x1,(%esp)
17d: e8 8e 03 00 00 call 510 <printf>
exit();
182: e8 2b 02 00 00 call 3b2 <exit>
187: 66 90 xchg %ax,%ax
189: 66 90 xchg %ax,%ax
18b: 66 90 xchg %ax,%ax
18d: 66 90 xchg %ax,%ax
18f: 90 nop
00000190 <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, char *t)
{
190: 55 push %ebp
191: 89 e5 mov %esp,%ebp
193: 8b 45 08 mov 0x8(%ebp),%eax
196: 8b 4d 0c mov 0xc(%ebp),%ecx
199: 53 push %ebx
char *os;
os = s;
while((*s++ = *t++) != 0)
19a: 89 c2 mov %eax,%edx
19c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1a0: 83 c1 01 add $0x1,%ecx
1a3: 0f b6 59 ff movzbl -0x1(%ecx),%ebx
1a7: 83 c2 01 add $0x1,%edx
1aa: 84 db test %bl,%bl
1ac: 88 5a ff mov %bl,-0x1(%edx)
1af: 75 ef jne 1a0 <strcpy+0x10>
;
return os;
}
1b1: 5b pop %ebx
1b2: 5d pop %ebp
1b3: c3 ret
1b4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
1ba: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
000001c0 <strcmp>:
int
strcmp(const char *p, const char *q)
{
1c0: 55 push %ebp
1c1: 89 e5 mov %esp,%ebp
1c3: 8b 55 08 mov 0x8(%ebp),%edx
1c6: 53 push %ebx
1c7: 8b 4d 0c mov 0xc(%ebp),%ecx
while(*p && *p == *q)
1ca: 0f b6 02 movzbl (%edx),%eax
1cd: 84 c0 test %al,%al
1cf: 74 2d je 1fe <strcmp+0x3e>
1d1: 0f b6 19 movzbl (%ecx),%ebx
1d4: 38 d8 cmp %bl,%al
1d6: 74 0e je 1e6 <strcmp+0x26>
1d8: eb 2b jmp 205 <strcmp+0x45>
1da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
1e0: 38 c8 cmp %cl,%al
1e2: 75 15 jne 1f9 <strcmp+0x39>
p++, q++;
1e4: 89 d9 mov %ebx,%ecx
1e6: 83 c2 01 add $0x1,%edx
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
1e9: 0f b6 02 movzbl (%edx),%eax
p++, q++;
1ec: 8d 59 01 lea 0x1(%ecx),%ebx
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
1ef: 0f b6 49 01 movzbl 0x1(%ecx),%ecx
1f3: 84 c0 test %al,%al
1f5: 75 e9 jne 1e0 <strcmp+0x20>
1f7: 31 c0 xor %eax,%eax
p++, q++;
return (uchar)*p - (uchar)*q;
1f9: 29 c8 sub %ecx,%eax
}
1fb: 5b pop %ebx
1fc: 5d pop %ebp
1fd: c3 ret
1fe: 0f b6 09 movzbl (%ecx),%ecx
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
201: 31 c0 xor %eax,%eax
203: eb f4 jmp 1f9 <strcmp+0x39>
205: 0f b6 cb movzbl %bl,%ecx
208: eb ef jmp 1f9 <strcmp+0x39>
20a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
00000210 <strlen>:
return (uchar)*p - (uchar)*q;
}
uint
strlen(char *s)
{
210: 55 push %ebp
211: 89 e5 mov %esp,%ebp
213: 8b 4d 08 mov 0x8(%ebp),%ecx
int n;
for(n = 0; s[n]; n++)
216: 80 39 00 cmpb $0x0,(%ecx)
219: 74 12 je 22d <strlen+0x1d>
21b: 31 d2 xor %edx,%edx
21d: 8d 76 00 lea 0x0(%esi),%esi
220: 83 c2 01 add $0x1,%edx
223: 80 3c 11 00 cmpb $0x0,(%ecx,%edx,1)
227: 89 d0 mov %edx,%eax
229: 75 f5 jne 220 <strlen+0x10>
;
return n;
}
22b: 5d pop %ebp
22c: c3 ret
uint
strlen(char *s)
{
int n;
for(n = 0; s[n]; n++)
22d: 31 c0 xor %eax,%eax
;
return n;
}
22f: 5d pop %ebp
230: c3 ret
231: eb 0d jmp 240 <memset>
233: 90 nop
234: 90 nop
235: 90 nop
236: 90 nop
237: 90 nop
238: 90 nop
239: 90 nop
23a: 90 nop
23b: 90 nop
23c: 90 nop
23d: 90 nop
23e: 90 nop
23f: 90 nop
00000240 <memset>:
void*
memset(void *dst, int c, uint n)
{
240: 55 push %ebp
241: 89 e5 mov %esp,%ebp
243: 8b 55 08 mov 0x8(%ebp),%edx
246: 57 push %edi
}
static inline void
stosb(void *addr, int data, int cnt)
{
asm volatile("cld; rep stosb" :
247: 8b 4d 10 mov 0x10(%ebp),%ecx
24a: 8b 45 0c mov 0xc(%ebp),%eax
24d: 89 d7 mov %edx,%edi
24f: fc cld
250: f3 aa rep stos %al,%es:(%edi)
stosb(dst, c, n);
return dst;
}
252: 89 d0 mov %edx,%eax
254: 5f pop %edi
255: 5d pop %ebp
256: c3 ret
257: 89 f6 mov %esi,%esi
259: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000260 <strchr>:
char*
strchr(const char *s, char c)
{
260: 55 push %ebp
261: 89 e5 mov %esp,%ebp
263: 8b 45 08 mov 0x8(%ebp),%eax
266: 53 push %ebx
267: 8b 55 0c mov 0xc(%ebp),%edx
for(; *s; s++)
26a: 0f b6 18 movzbl (%eax),%ebx
26d: 84 db test %bl,%bl
26f: 74 1d je 28e <strchr+0x2e>
if(*s == c)
271: 38 d3 cmp %dl,%bl
273: 89 d1 mov %edx,%ecx
275: 75 0d jne 284 <strchr+0x24>
277: eb 17 jmp 290 <strchr+0x30>
279: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
280: 38 ca cmp %cl,%dl
282: 74 0c je 290 <strchr+0x30>
}
char*
strchr(const char *s, char c)
{
for(; *s; s++)
284: 83 c0 01 add $0x1,%eax
287: 0f b6 10 movzbl (%eax),%edx
28a: 84 d2 test %dl,%dl
28c: 75 f2 jne 280 <strchr+0x20>
if(*s == c)
return (char*)s;
return 0;
28e: 31 c0 xor %eax,%eax
}
290: 5b pop %ebx
291: 5d pop %ebp
292: c3 ret
293: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
299: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000002a0 <gets>:
char*
gets(char *buf, int max)
{
2a0: 55 push %ebp
2a1: 89 e5 mov %esp,%ebp
2a3: 57 push %edi
2a4: 56 push %esi
int i, cc;
char c;
for(i=0; i+1 < max; ){
2a5: 31 f6 xor %esi,%esi
return 0;
}
char*
gets(char *buf, int max)
{
2a7: 53 push %ebx
2a8: 83 ec 2c sub $0x2c,%esp
int i, cc;
char c;
for(i=0; i+1 < max; ){
cc = read(0, &c, 1);
2ab: 8d 7d e7 lea -0x19(%ebp),%edi
gets(char *buf, int max)
{
int i, cc;
char c;
for(i=0; i+1 < max; ){
2ae: eb 31 jmp 2e1 <gets+0x41>
cc = read(0, &c, 1);
2b0: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
2b7: 00
2b8: 89 7c 24 04 mov %edi,0x4(%esp)
2bc: c7 04 24 00 00 00 00 movl $0x0,(%esp)
2c3: e8 02 01 00 00 call 3ca <read>
if(cc < 1)
2c8: 85 c0 test %eax,%eax
2ca: 7e 1d jle 2e9 <gets+0x49>
break;
buf[i++] = c;
2cc: 0f b6 45 e7 movzbl -0x19(%ebp),%eax
gets(char *buf, int max)
{
int i, cc;
char c;
for(i=0; i+1 < max; ){
2d0: 89 de mov %ebx,%esi
cc = read(0, &c, 1);
if(cc < 1)
break;
buf[i++] = c;
2d2: 8b 55 08 mov 0x8(%ebp),%edx
if(c == '\n' || c == '\r')
2d5: 3c 0d cmp $0xd,%al
for(i=0; i+1 < max; ){
cc = read(0, &c, 1);
if(cc < 1)
break;
buf[i++] = c;
2d7: 88 44 1a ff mov %al,-0x1(%edx,%ebx,1)
if(c == '\n' || c == '\r')
2db: 74 0c je 2e9 <gets+0x49>
2dd: 3c 0a cmp $0xa,%al
2df: 74 08 je 2e9 <gets+0x49>
gets(char *buf, int max)
{
int i, cc;
char c;
for(i=0; i+1 < max; ){
2e1: 8d 5e 01 lea 0x1(%esi),%ebx
2e4: 3b 5d 0c cmp 0xc(%ebp),%ebx
2e7: 7c c7 jl 2b0 <gets+0x10>
break;
buf[i++] = c;
if(c == '\n' || c == '\r')
break;
}
buf[i] = '\0';
2e9: 8b 45 08 mov 0x8(%ebp),%eax
2ec: c6 04 30 00 movb $0x0,(%eax,%esi,1)
return buf;
}
2f0: 83 c4 2c add $0x2c,%esp
2f3: 5b pop %ebx
2f4: 5e pop %esi
2f5: 5f pop %edi
2f6: 5d pop %ebp
2f7: c3 ret
2f8: 90 nop
2f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00000300 <stat>:
int
stat(char *n, struct stat *st)
{
300: 55 push %ebp
301: 89 e5 mov %esp,%ebp
303: 56 push %esi
304: 53 push %ebx
305: 83 ec 10 sub $0x10,%esp
int fd;
int r;
fd = open(n, O_RDONLY);
308: 8b 45 08 mov 0x8(%ebp),%eax
30b: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
312: 00
313: 89 04 24 mov %eax,(%esp)
316: e8 d7 00 00 00 call 3f2 <open>
if(fd < 0)
31b: 85 c0 test %eax,%eax
stat(char *n, struct stat *st)
{
int fd;
int r;
fd = open(n, O_RDONLY);
31d: 89 c3 mov %eax,%ebx
if(fd < 0)
31f: 78 27 js 348 <stat+0x48>
return -1;
r = fstat(fd, st);
321: 8b 45 0c mov 0xc(%ebp),%eax
324: 89 1c 24 mov %ebx,(%esp)
327: 89 44 24 04 mov %eax,0x4(%esp)
32b: e8 da 00 00 00 call 40a <fstat>
close(fd);
330: 89 1c 24 mov %ebx,(%esp)
int r;
fd = open(n, O_RDONLY);
if(fd < 0)
return -1;
r = fstat(fd, st);
333: 89 c6 mov %eax,%esi
close(fd);
335: e8 a0 00 00 00 call 3da <close>
return r;
33a: 89 f0 mov %esi,%eax
}
33c: 83 c4 10 add $0x10,%esp
33f: 5b pop %ebx
340: 5e pop %esi
341: 5d pop %ebp
342: c3 ret
343: 90 nop
344: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
int fd;
int r;
fd = open(n, O_RDONLY);
if(fd < 0)
return -1;
348: b8 ff ff ff ff mov $0xffffffff,%eax
34d: eb ed jmp 33c <stat+0x3c>
34f: 90 nop
00000350 <atoi>:
return r;
}
int
atoi(const char *s)
{
350: 55 push %ebp
351: 89 e5 mov %esp,%ebp
353: 8b 4d 08 mov 0x8(%ebp),%ecx
356: 53 push %ebx
int n;
n = 0;
while('0' <= *s && *s <= '9')
357: 0f be 11 movsbl (%ecx),%edx
35a: 8d 42 d0 lea -0x30(%edx),%eax
35d: 3c 09 cmp $0x9,%al
int
atoi(const char *s)
{
int n;
n = 0;
35f: b8 00 00 00 00 mov $0x0,%eax
while('0' <= *s && *s <= '9')
364: 77 17 ja 37d <atoi+0x2d>
366: 66 90 xchg %ax,%ax
n = n*10 + *s++ - '0';
368: 83 c1 01 add $0x1,%ecx
36b: 8d 04 80 lea (%eax,%eax,4),%eax
36e: 8d 44 42 d0 lea -0x30(%edx,%eax,2),%eax
atoi(const char *s)
{
int n;
n = 0;
while('0' <= *s && *s <= '9')
372: 0f be 11 movsbl (%ecx),%edx
375: 8d 5a d0 lea -0x30(%edx),%ebx
378: 80 fb 09 cmp $0x9,%bl
37b: 76 eb jbe 368 <atoi+0x18>
n = n*10 + *s++ - '0';
return n;
}
37d: 5b pop %ebx
37e: 5d pop %ebp
37f: c3 ret
00000380 <memmove>:
void*
memmove(void *vdst, void *vsrc, int n)
{
380: 55 push %ebp
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
381: 31 d2 xor %edx,%edx
return n;
}
void*
memmove(void *vdst, void *vsrc, int n)
{
383: 89 e5 mov %esp,%ebp
385: 56 push %esi
386: 8b 45 08 mov 0x8(%ebp),%eax
389: 53 push %ebx
38a: 8b 5d 10 mov 0x10(%ebp),%ebx
38d: 8b 75 0c mov 0xc(%ebp),%esi
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
390: 85 db test %ebx,%ebx
392: 7e 12 jle 3a6 <memmove+0x26>
394: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
*dst++ = *src++;
398: 0f b6 0c 16 movzbl (%esi,%edx,1),%ecx
39c: 88 0c 10 mov %cl,(%eax,%edx,1)
39f: 83 c2 01 add $0x1,%edx
{
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
3a2: 39 da cmp %ebx,%edx
3a4: 75 f2 jne 398 <memmove+0x18>
*dst++ = *src++;
return vdst;
}
3a6: 5b pop %ebx
3a7: 5e pop %esi
3a8: 5d pop %ebp
3a9: c3 ret
000003aa <fork>:
name: \
movl $SYS_ ## name, %eax; \
int $T_SYSCALL; \
ret
SYSCALL(fork)
3aa: b8 01 00 00 00 mov $0x1,%eax
3af: cd 40 int $0x40
3b1: c3 ret
000003b2 <exit>:
SYSCALL(exit)
3b2: b8 02 00 00 00 mov $0x2,%eax
3b7: cd 40 int $0x40
3b9: c3 ret
000003ba <wait>:
SYSCALL(wait)
3ba: b8 03 00 00 00 mov $0x3,%eax
3bf: cd 40 int $0x40
3c1: c3 ret
000003c2 <pipe>:
SYSCALL(pipe)
3c2: b8 04 00 00 00 mov $0x4,%eax
3c7: cd 40 int $0x40
3c9: c3 ret
000003ca <read>:
SYSCALL(read)
3ca: b8 05 00 00 00 mov $0x5,%eax
3cf: cd 40 int $0x40
3d1: c3 ret
000003d2 <write>:
SYSCALL(write)
3d2: b8 10 00 00 00 mov $0x10,%eax
3d7: cd 40 int $0x40
3d9: c3 ret
000003da <close>:
SYSCALL(close)
3da: b8 15 00 00 00 mov $0x15,%eax
3df: cd 40 int $0x40
3e1: c3 ret
000003e2 <kill>:
SYSCALL(kill)
3e2: b8 06 00 00 00 mov $0x6,%eax
3e7: cd 40 int $0x40
3e9: c3 ret
000003ea <exec>:
SYSCALL(exec)
3ea: b8 07 00 00 00 mov $0x7,%eax
3ef: cd 40 int $0x40
3f1: c3 ret
000003f2 <open>:
SYSCALL(open)
3f2: b8 0f 00 00 00 mov $0xf,%eax
3f7: cd 40 int $0x40
3f9: c3 ret
000003fa <mknod>:
SYSCALL(mknod)
3fa: b8 11 00 00 00 mov $0x11,%eax
3ff: cd 40 int $0x40
401: c3 ret
00000402 <unlink>:
SYSCALL(unlink)
402: b8 12 00 00 00 mov $0x12,%eax
407: cd 40 int $0x40
409: c3 ret
0000040a <fstat>:
SYSCALL(fstat)
40a: b8 08 00 00 00 mov $0x8,%eax
40f: cd 40 int $0x40
411: c3 ret
00000412 <link>:
SYSCALL(link)
412: b8 13 00 00 00 mov $0x13,%eax
417: cd 40 int $0x40
419: c3 ret
0000041a <mkdir>:
SYSCALL(mkdir)
41a: b8 14 00 00 00 mov $0x14,%eax
41f: cd 40 int $0x40
421: c3 ret
00000422 <chdir>:
SYSCALL(chdir)
422: b8 09 00 00 00 mov $0x9,%eax
427: cd 40 int $0x40
429: c3 ret
0000042a <dup>:
SYSCALL(dup)
42a: b8 0a 00 00 00 mov $0xa,%eax
42f: cd 40 int $0x40
431: c3 ret
00000432 <getpid>:
SYSCALL(getpid)
432: b8 0b 00 00 00 mov $0xb,%eax
437: cd 40 int $0x40
439: c3 ret
0000043a <random>:
SYSCALL(random) // This is the system call that we are adding for XOR_SHIFT
43a: b8 16 00 00 00 mov $0x16,%eax
43f: cd 40 int $0x40
441: c3 ret
00000442 <sbrk>:
SYSCALL(sbrk)
442: b8 0c 00 00 00 mov $0xc,%eax
447: cd 40 int $0x40
449: c3 ret
0000044a <sleep>:
SYSCALL(sleep)
44a: b8 0d 00 00 00 mov $0xd,%eax
44f: cd 40 int $0x40
451: c3 ret
00000452 <uptime>:
SYSCALL(uptime)
452: b8 0e 00 00 00 mov $0xe,%eax
457: cd 40 int $0x40
459: c3 ret
0000045a <cps>:
SYSCALL(cps)
45a: b8 17 00 00 00 mov $0x17,%eax
45f: cd 40 int $0x40
461: c3 ret
00000462 <chpr>:
SYSCALL(chpr)
462: b8 18 00 00 00 mov $0x18,%eax
467: cd 40 int $0x40
469: c3 ret
46a: 66 90 xchg %ax,%ax
46c: 66 90 xchg %ax,%ax
46e: 66 90 xchg %ax,%ax
00000470 <printint>:
write(fd, &c, 1);
}
static void
printint(int fd, int xx, int base, int sgn)
{
470: 55 push %ebp
471: 89 e5 mov %esp,%ebp
473: 57 push %edi
474: 56 push %esi
475: 89 c6 mov %eax,%esi
477: 53 push %ebx
478: 83 ec 4c sub $0x4c,%esp
char buf[16];
int i, neg;
uint x;
neg = 0;
if(sgn && xx < 0){
47b: 8b 5d 08 mov 0x8(%ebp),%ebx
47e: 85 db test %ebx,%ebx
480: 74 09 je 48b <printint+0x1b>
482: 89 d0 mov %edx,%eax
484: c1 e8 1f shr $0x1f,%eax
487: 84 c0 test %al,%al
489: 75 75 jne 500 <printint+0x90>
neg = 1;
x = -xx;
} else {
x = xx;
48b: 89 d0 mov %edx,%eax
static char digits[] = "0123456789ABCDEF";
char buf[16];
int i, neg;
uint x;
neg = 0;
48d: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
494: 89 75 c0 mov %esi,-0x40(%ebp)
x = -xx;
} else {
x = xx;
}
i = 0;
497: 31 ff xor %edi,%edi
499: 89 ce mov %ecx,%esi
49b: 8d 5d d7 lea -0x29(%ebp),%ebx
49e: eb 02 jmp 4a2 <printint+0x32>
do{
buf[i++] = digits[x % base];
4a0: 89 cf mov %ecx,%edi
4a2: 31 d2 xor %edx,%edx
4a4: f7 f6 div %esi
4a6: 8d 4f 01 lea 0x1(%edi),%ecx
4a9: 0f b6 92 b4 08 00 00 movzbl 0x8b4(%edx),%edx
}while((x /= base) != 0);
4b0: 85 c0 test %eax,%eax
x = xx;
}
i = 0;
do{
buf[i++] = digits[x % base];
4b2: 88 14 0b mov %dl,(%ebx,%ecx,1)
}while((x /= base) != 0);
4b5: 75 e9 jne 4a0 <printint+0x30>
if(neg)
4b7: 8b 55 c4 mov -0x3c(%ebp),%edx
x = xx;
}
i = 0;
do{
buf[i++] = digits[x % base];
4ba: 89 c8 mov %ecx,%eax
4bc: 8b 75 c0 mov -0x40(%ebp),%esi
}while((x /= base) != 0);
if(neg)
4bf: 85 d2 test %edx,%edx
4c1: 74 08 je 4cb <printint+0x5b>
buf[i++] = '-';
4c3: 8d 4f 02 lea 0x2(%edi),%ecx
4c6: c6 44 05 d8 2d movb $0x2d,-0x28(%ebp,%eax,1)
while(--i >= 0)
4cb: 8d 79 ff lea -0x1(%ecx),%edi
4ce: 66 90 xchg %ax,%ax
4d0: 0f b6 44 3d d8 movzbl -0x28(%ebp,%edi,1),%eax
4d5: 83 ef 01 sub $0x1,%edi
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
4d8: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
4df: 00
4e0: 89 5c 24 04 mov %ebx,0x4(%esp)
4e4: 89 34 24 mov %esi,(%esp)
4e7: 88 45 d7 mov %al,-0x29(%ebp)
4ea: e8 e3 fe ff ff call 3d2 <write>
buf[i++] = digits[x % base];
}while((x /= base) != 0);
if(neg)
buf[i++] = '-';
while(--i >= 0)
4ef: 83 ff ff cmp $0xffffffff,%edi
4f2: 75 dc jne 4d0 <printint+0x60>
putc(fd, buf[i]);
}
4f4: 83 c4 4c add $0x4c,%esp
4f7: 5b pop %ebx
4f8: 5e pop %esi
4f9: 5f pop %edi
4fa: 5d pop %ebp
4fb: c3 ret
4fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
uint x;
neg = 0;
if(sgn && xx < 0){
neg = 1;
x = -xx;
500: 89 d0 mov %edx,%eax
502: f7 d8 neg %eax
int i, neg;
uint x;
neg = 0;
if(sgn && xx < 0){
neg = 1;
504: c7 45 c4 01 00 00 00 movl $0x1,-0x3c(%ebp)
50b: eb 87 jmp 494 <printint+0x24>
50d: 8d 76 00 lea 0x0(%esi),%esi
00000510 <printf>:
}
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
510: 55 push %ebp
511: 89 e5 mov %esp,%ebp
513: 57 push %edi
char *s;
int c, i, state;
uint *ap;
state = 0;
514: 31 ff xor %edi,%edi
}
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
516: 56 push %esi
517: 53 push %ebx
518: 83 ec 3c sub $0x3c,%esp
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
51b: 8b 5d 0c mov 0xc(%ebp),%ebx
char *s;
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
51e: 8d 45 10 lea 0x10(%ebp),%eax
}
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
521: 8b 75 08 mov 0x8(%ebp),%esi
char *s;
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
524: 89 45 d4 mov %eax,-0x2c(%ebp)
for(i = 0; fmt[i]; i++){
527: 0f b6 13 movzbl (%ebx),%edx
52a: 83 c3 01 add $0x1,%ebx
52d: 84 d2 test %dl,%dl
52f: 75 39 jne 56a <printf+0x5a>
531: e9 c2 00 00 00 jmp 5f8 <printf+0xe8>
536: 66 90 xchg %ax,%ax
c = fmt[i] & 0xff;
if(state == 0){
if(c == '%'){
538: 83 fa 25 cmp $0x25,%edx
53b: 0f 84 bf 00 00 00 je 600 <printf+0xf0>
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
541: 8d 45 e2 lea -0x1e(%ebp),%eax
544: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
54b: 00
54c: 89 44 24 04 mov %eax,0x4(%esp)
550: 89 34 24 mov %esi,(%esp)
c = fmt[i] & 0xff;
if(state == 0){
if(c == '%'){
state = '%';
} else {
putc(fd, c);
553: 88 55 e2 mov %dl,-0x1e(%ebp)
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
556: e8 77 fe ff ff call 3d2 <write>
55b: 83 c3 01 add $0x1,%ebx
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
55e: 0f b6 53 ff movzbl -0x1(%ebx),%edx
562: 84 d2 test %dl,%dl
564: 0f 84 8e 00 00 00 je 5f8 <printf+0xe8>
c = fmt[i] & 0xff;
if(state == 0){
56a: 85 ff test %edi,%edi
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
c = fmt[i] & 0xff;
56c: 0f be c2 movsbl %dl,%eax
if(state == 0){
56f: 74 c7 je 538 <printf+0x28>
if(c == '%'){
state = '%';
} else {
putc(fd, c);
}
} else if(state == '%'){
571: 83 ff 25 cmp $0x25,%edi
574: 75 e5 jne 55b <printf+0x4b>
if(c == 'd'){
576: 83 fa 64 cmp $0x64,%edx
579: 0f 84 31 01 00 00 je 6b0 <printf+0x1a0>
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
57f: 25 f7 00 00 00 and $0xf7,%eax
584: 83 f8 70 cmp $0x70,%eax
587: 0f 84 83 00 00 00 je 610 <printf+0x100>
printint(fd, *ap, 16, 0);
ap++;
} else if(c == 's'){
58d: 83 fa 73 cmp $0x73,%edx
590: 0f 84 a2 00 00 00 je 638 <printf+0x128>
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
596: 83 fa 63 cmp $0x63,%edx
599: 0f 84 35 01 00 00 je 6d4 <printf+0x1c4>
putc(fd, *ap);
ap++;
} else if(c == '%'){
59f: 83 fa 25 cmp $0x25,%edx
5a2: 0f 84 e0 00 00 00 je 688 <printf+0x178>
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
5a8: 8d 45 e6 lea -0x1a(%ebp),%eax
5ab: 83 c3 01 add $0x1,%ebx
5ae: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
5b5: 00
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
}
state = 0;
5b6: 31 ff xor %edi,%edi
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
5b8: 89 44 24 04 mov %eax,0x4(%esp)
5bc: 89 34 24 mov %esi,(%esp)
5bf: 89 55 d0 mov %edx,-0x30(%ebp)
5c2: c6 45 e6 25 movb $0x25,-0x1a(%ebp)
5c6: e8 07 fe ff ff call 3d2 <write>
} else if(c == '%'){
putc(fd, c);
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
5cb: 8b 55 d0 mov -0x30(%ebp),%edx
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
5ce: 8d 45 e7 lea -0x19(%ebp),%eax
5d1: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
5d8: 00
5d9: 89 44 24 04 mov %eax,0x4(%esp)
5dd: 89 34 24 mov %esi,(%esp)
} else if(c == '%'){
putc(fd, c);
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
5e0: 88 55 e7 mov %dl,-0x19(%ebp)
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
5e3: e8 ea fd ff ff call 3d2 <write>
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
5e8: 0f b6 53 ff movzbl -0x1(%ebx),%edx
5ec: 84 d2 test %dl,%dl
5ee: 0f 85 76 ff ff ff jne 56a <printf+0x5a>
5f4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
putc(fd, c);
}
state = 0;
}
}
}
5f8: 83 c4 3c add $0x3c,%esp
5fb: 5b pop %ebx
5fc: 5e pop %esi
5fd: 5f pop %edi
5fe: 5d pop %ebp
5ff: c3 ret
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
c = fmt[i] & 0xff;
if(state == 0){
if(c == '%'){
state = '%';
600: bf 25 00 00 00 mov $0x25,%edi
605: e9 51 ff ff ff jmp 55b <printf+0x4b>
60a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
} else if(state == '%'){
if(c == 'd'){
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
printint(fd, *ap, 16, 0);
610: 8b 45 d4 mov -0x2c(%ebp),%eax
613: b9 10 00 00 00 mov $0x10,%ecx
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
}
state = 0;
618: 31 ff xor %edi,%edi
} else if(state == '%'){
if(c == 'd'){
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
printint(fd, *ap, 16, 0);
61a: c7 04 24 00 00 00 00 movl $0x0,(%esp)
621: 8b 10 mov (%eax),%edx
623: 89 f0 mov %esi,%eax
625: e8 46 fe ff ff call 470 <printint>
ap++;
62a: 83 45 d4 04 addl $0x4,-0x2c(%ebp)
62e: e9 28 ff ff ff jmp 55b <printf+0x4b>
633: 90 nop
634: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
} else if(c == 's'){
s = (char*)*ap;
638: 8b 45 d4 mov -0x2c(%ebp),%eax
ap++;
63b: 83 45 d4 04 addl $0x4,-0x2c(%ebp)
ap++;
} else if(c == 'x' || c == 'p'){
printint(fd, *ap, 16, 0);
ap++;
} else if(c == 's'){
s = (char*)*ap;
63f: 8b 38 mov (%eax),%edi
ap++;
if(s == 0)
s = "(null)";
641: b8 ad 08 00 00 mov $0x8ad,%eax
646: 85 ff test %edi,%edi
648: 0f 44 f8 cmove %eax,%edi
while(*s != 0){
64b: 0f b6 07 movzbl (%edi),%eax
64e: 84 c0 test %al,%al
650: 74 2a je 67c <printf+0x16c>
652: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
658: 88 45 e3 mov %al,-0x1d(%ebp)
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
65b: 8d 45 e3 lea -0x1d(%ebp),%eax
ap++;
if(s == 0)
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
65e: 83 c7 01 add $0x1,%edi
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
661: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
668: 00
669: 89 44 24 04 mov %eax,0x4(%esp)
66d: 89 34 24 mov %esi,(%esp)
670: e8 5d fd ff ff call 3d2 <write>
} else if(c == 's'){
s = (char*)*ap;
ap++;
if(s == 0)
s = "(null)";
while(*s != 0){
675: 0f b6 07 movzbl (%edi),%eax
678: 84 c0 test %al,%al
67a: 75 dc jne 658 <printf+0x148>
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
}
state = 0;
67c: 31 ff xor %edi,%edi
67e: e9 d8 fe ff ff jmp 55b <printf+0x4b>
683: 90 nop
684: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
688: 8d 45 e5 lea -0x1b(%ebp),%eax
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
}
state = 0;
68b: 31 ff xor %edi,%edi
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
68d: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
694: 00
695: 89 44 24 04 mov %eax,0x4(%esp)
699: 89 34 24 mov %esi,(%esp)
69c: c6 45 e5 25 movb $0x25,-0x1b(%ebp)
6a0: e8 2d fd ff ff call 3d2 <write>
6a5: e9 b1 fe ff ff jmp 55b <printf+0x4b>
6aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
} else {
putc(fd, c);
}
} else if(state == '%'){
if(c == 'd'){
printint(fd, *ap, 10, 1);
6b0: 8b 45 d4 mov -0x2c(%ebp),%eax
6b3: b9 0a 00 00 00 mov $0xa,%ecx
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
}
state = 0;
6b8: 66 31 ff xor %di,%di
} else {
putc(fd, c);
}
} else if(state == '%'){
if(c == 'd'){
printint(fd, *ap, 10, 1);
6bb: c7 04 24 01 00 00 00 movl $0x1,(%esp)
6c2: 8b 10 mov (%eax),%edx
6c4: 89 f0 mov %esi,%eax
6c6: e8 a5 fd ff ff call 470 <printint>
ap++;
6cb: 83 45 d4 04 addl $0x4,-0x2c(%ebp)
6cf: e9 87 fe ff ff jmp 55b <printf+0x4b>
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
putc(fd, *ap);
6d4: 8b 45 d4 mov -0x2c(%ebp),%eax
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
}
state = 0;
6d7: 31 ff xor %edi,%edi
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
putc(fd, *ap);
6d9: 8b 00 mov (%eax),%eax
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
6db: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
6e2: 00
6e3: 89 34 24 mov %esi,(%esp)
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
putc(fd, *ap);
6e6: 88 45 e4 mov %al,-0x1c(%ebp)
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
6e9: 8d 45 e4 lea -0x1c(%ebp),%eax
6ec: 89 44 24 04 mov %eax,0x4(%esp)
6f0: e8 dd fc ff ff call 3d2 <write>
putc(fd, *s);
s++;
}
} else if(c == 'c'){
putc(fd, *ap);
ap++;
6f5: 83 45 d4 04 addl $0x4,-0x2c(%ebp)
6f9: e9 5d fe ff ff jmp 55b <printf+0x4b>
6fe: 66 90 xchg %ax,%ax
00000700 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
700: 55 push %ebp
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
701: a1 80 0b 00 00 mov 0xb80,%eax
static Header base;
static Header *freep;
void
free(void *ap)
{
706: 89 e5 mov %esp,%ebp
708: 57 push %edi
709: 56 push %esi
70a: 53 push %ebx
70b: 8b 5d 08 mov 0x8(%ebp),%ebx
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
70e: 8b 08 mov (%eax),%ecx
void
free(void *ap)
{
Header *bp, *p;
bp = (Header*)ap - 1;
710: 8d 53 f8 lea -0x8(%ebx),%edx
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
713: 39 d0 cmp %edx,%eax
715: 72 11 jb 728 <free+0x28>
717: 90 nop
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
718: 39 c8 cmp %ecx,%eax
71a: 72 04 jb 720 <free+0x20>
71c: 39 ca cmp %ecx,%edx
71e: 72 10 jb 730 <free+0x30>
720: 89 c8 mov %ecx,%eax
free(void *ap)
{
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
722: 39 d0 cmp %edx,%eax
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
724: 8b 08 mov (%eax),%ecx
free(void *ap)
{
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
726: 73 f0 jae 718 <free+0x18>
728: 39 ca cmp %ecx,%edx
72a: 72 04 jb 730 <free+0x30>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
72c: 39 c8 cmp %ecx,%eax
72e: 72 f0 jb 720 <free+0x20>
break;
if(bp + bp->s.size == p->s.ptr){
730: 8b 73 fc mov -0x4(%ebx),%esi
733: 8d 3c f2 lea (%edx,%esi,8),%edi
736: 39 cf cmp %ecx,%edi
738: 74 1e je 758 <free+0x58>
bp->s.size += p->s.ptr->s.size;
bp->s.ptr = p->s.ptr->s.ptr;
} else
bp->s.ptr = p->s.ptr;
73a: 89 4b f8 mov %ecx,-0x8(%ebx)
if(p + p->s.size == bp){
73d: 8b 48 04 mov 0x4(%eax),%ecx
740: 8d 34 c8 lea (%eax,%ecx,8),%esi
743: 39 f2 cmp %esi,%edx
745: 74 28 je 76f <free+0x6f>
p->s.size += bp->s.size;
p->s.ptr = bp->s.ptr;
} else
p->s.ptr = bp;
747: 89 10 mov %edx,(%eax)
freep = p;
749: a3 80 0b 00 00 mov %eax,0xb80
}
74e: 5b pop %ebx
74f: 5e pop %esi
750: 5f pop %edi
751: 5d pop %ebp
752: c3 ret
753: 90 nop
754: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
break;
if(bp + bp->s.size == p->s.ptr){
bp->s.size += p->s.ptr->s.size;
758: 03 71 04 add 0x4(%ecx),%esi
75b: 89 73 fc mov %esi,-0x4(%ebx)
bp->s.ptr = p->s.ptr->s.ptr;
75e: 8b 08 mov (%eax),%ecx
760: 8b 09 mov (%ecx),%ecx
762: 89 4b f8 mov %ecx,-0x8(%ebx)
} else
bp->s.ptr = p->s.ptr;
if(p + p->s.size == bp){
765: 8b 48 04 mov 0x4(%eax),%ecx
768: 8d 34 c8 lea (%eax,%ecx,8),%esi
76b: 39 f2 cmp %esi,%edx
76d: 75 d8 jne 747 <free+0x47>
p->s.size += bp->s.size;
76f: 03 4b fc add -0x4(%ebx),%ecx
p->s.ptr = bp->s.ptr;
} else
p->s.ptr = bp;
freep = p;
772: a3 80 0b 00 00 mov %eax,0xb80
bp->s.size += p->s.ptr->s.size;
bp->s.ptr = p->s.ptr->s.ptr;
} else
bp->s.ptr = p->s.ptr;
if(p + p->s.size == bp){
p->s.size += bp->s.size;
777: 89 48 04 mov %ecx,0x4(%eax)
p->s.ptr = bp->s.ptr;
77a: 8b 53 f8 mov -0x8(%ebx),%edx
77d: 89 10 mov %edx,(%eax)
} else
p->s.ptr = bp;
freep = p;
}
77f: 5b pop %ebx
780: 5e pop %esi
781: 5f pop %edi
782: 5d pop %ebp
783: c3 ret
784: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
78a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
00000790 <malloc>:
return freep;
}
void*
malloc(uint nbytes)
{
790: 55 push %ebp
791: 89 e5 mov %esp,%ebp
793: 57 push %edi
794: 56 push %esi
795: 53 push %ebx
796: 83 ec 1c sub $0x1c,%esp
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
799: 8b 45 08 mov 0x8(%ebp),%eax
if((prevp = freep) == 0){
79c: 8b 1d 80 0b 00 00 mov 0xb80,%ebx
malloc(uint nbytes)
{
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
7a2: 8d 48 07 lea 0x7(%eax),%ecx
7a5: c1 e9 03 shr $0x3,%ecx
if((prevp = freep) == 0){
7a8: 85 db test %ebx,%ebx
malloc(uint nbytes)
{
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
7aa: 8d 71 01 lea 0x1(%ecx),%esi
if((prevp = freep) == 0){
7ad: 0f 84 9b 00 00 00 je 84e <malloc+0xbe>
7b3: 8b 13 mov (%ebx),%edx
7b5: 8b 7a 04 mov 0x4(%edx),%edi
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
if(p->s.size >= nunits){
7b8: 39 fe cmp %edi,%esi
7ba: 76 64 jbe 820 <malloc+0x90>
7bc: 8d 04 f5 00 00 00 00 lea 0x0(,%esi,8),%eax
morecore(uint nu)
{
char *p;
Header *hp;
if(nu < 4096)
7c3: bb 00 80 00 00 mov $0x8000,%ebx
7c8: 89 45 e4 mov %eax,-0x1c(%ebp)
7cb: eb 0e jmp 7db <malloc+0x4b>
7cd: 8d 76 00 lea 0x0(%esi),%esi
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
7d0: 8b 02 mov (%edx),%eax
if(p->s.size >= nunits){
7d2: 8b 78 04 mov 0x4(%eax),%edi
7d5: 39 fe cmp %edi,%esi
7d7: 76 4f jbe 828 <malloc+0x98>
7d9: 89 c2 mov %eax,%edx
p->s.size = nunits;
}
freep = prevp;
return (void*)(p + 1);
}
if(p == freep)
7db: 3b 15 80 0b 00 00 cmp 0xb80,%edx
7e1: 75 ed jne 7d0 <malloc+0x40>
morecore(uint nu)
{
char *p;
Header *hp;
if(nu < 4096)
7e3: 8b 45 e4 mov -0x1c(%ebp),%eax
7e6: 81 fe 00 10 00 00 cmp $0x1000,%esi
7ec: bf 00 10 00 00 mov $0x1000,%edi
7f1: 0f 43 fe cmovae %esi,%edi
7f4: 0f 42 c3 cmovb %ebx,%eax
nu = 4096;
p = sbrk(nu * sizeof(Header));
7f7: 89 04 24 mov %eax,(%esp)
7fa: e8 43 fc ff ff call 442 <sbrk>
if(p == (char*)-1)
7ff: 83 f8 ff cmp $0xffffffff,%eax
802: 74 18 je 81c <malloc+0x8c>
return 0;
hp = (Header*)p;
hp->s.size = nu;
804: 89 78 04 mov %edi,0x4(%eax)
free((void*)(hp + 1));
807: 83 c0 08 add $0x8,%eax
80a: 89 04 24 mov %eax,(%esp)
80d: e8 ee fe ff ff call 700 <free>
return freep;
812: 8b 15 80 0b 00 00 mov 0xb80,%edx
}
freep = prevp;
return (void*)(p + 1);
}
if(p == freep)
if((p = morecore(nunits)) == 0)
818: 85 d2 test %edx,%edx
81a: 75 b4 jne 7d0 <malloc+0x40>
return 0;
81c: 31 c0 xor %eax,%eax
81e: eb 20 jmp 840 <malloc+0xb0>
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
if(p->s.size >= nunits){
820: 89 d0 mov %edx,%eax
822: 89 da mov %ebx,%edx
824: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(p->s.size == nunits)
828: 39 fe cmp %edi,%esi
82a: 74 1c je 848 <malloc+0xb8>
prevp->s.ptr = p->s.ptr;
else {
p->s.size -= nunits;
82c: 29 f7 sub %esi,%edi
82e: 89 78 04 mov %edi,0x4(%eax)
p += p->s.size;
831: 8d 04 f8 lea (%eax,%edi,8),%eax
p->s.size = nunits;
834: 89 70 04 mov %esi,0x4(%eax)
}
freep = prevp;
837: 89 15 80 0b 00 00 mov %edx,0xb80
return (void*)(p + 1);
83d: 83 c0 08 add $0x8,%eax
}
if(p == freep)
if((p = morecore(nunits)) == 0)
return 0;
}
}
840: 83 c4 1c add $0x1c,%esp
843: 5b pop %ebx
844: 5e pop %esi
845: 5f pop %edi
846: 5d pop %ebp
847: c3 ret
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
if(p->s.size >= nunits){
if(p->s.size == nunits)
prevp->s.ptr = p->s.ptr;
848: 8b 08 mov (%eax),%ecx
84a: 89 0a mov %ecx,(%edx)
84c: eb e9 jmp 837 <malloc+0xa7>
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
84e: c7 05 80 0b 00 00 84 movl $0xb84,0xb80
855: 0b 00 00
base.s.size = 0;
858: ba 84 0b 00 00 mov $0xb84,%edx
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
85d: c7 05 84 0b 00 00 84 movl $0xb84,0xb84
864: 0b 00 00
base.s.size = 0;
867: c7 05 88 0b 00 00 00 movl $0x0,0xb88
86e: 00 00 00
871: e9 46 ff ff ff jmp 7bc <malloc+0x2c>
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Copyright(c) 2011-2014 Intel Corporation All rights reserved.
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions
; are met:
; * Redistributions of source code must retain the above copyright
; notice, this list of conditions and the following disclaimer.
; * Redistributions in binary form must reproduce the above copyright
; notice, this list of conditions and the following disclaimer in
; the documentation and/or other materials provided with the
; distribution.
; * Neither the name of Intel Corporation nor the names of its
; contributors may be used to endorse or promote products derived
; from this software without specific prior written permission.
;
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; gf_2vect_dot_prod_sse(len, vec, *g_tbls, **buffs, **dests);
;;;
;;; Author: Gregory Tucker
%ifidn __OUTPUT_FORMAT__, macho64
%define GF_2VECT_DOT_PROD_SSE _gf_2vect_dot_prod_sse
%else
%define GF_2VECT_DOT_PROD_SSE gf_2vect_dot_prod_sse
%endif
%ifidn __OUTPUT_FORMAT__, elf64
%define arg0 rdi
%define arg1 rsi
%define arg2 rdx
%define arg3 rcx
%define arg4 r8
%define arg5 r9
%define tmp r11
%define tmp2 r10
%define tmp3 r9
%define tmp4 r12 ; must be saved and restored
%define return rax
%define PS 8
%define LOG_PS 3
%define func(x) x:
%macro FUNC_SAVE 0
push r12
%endmacro
%macro FUNC_RESTORE 0
pop r12
%endmacro
%endif
%ifidn __OUTPUT_FORMAT__, macho64
%define arg0 rdi
%define arg1 rsi
%define arg2 rdx
%define arg3 rcx
%define arg4 r8
%define arg5 r9
%define tmp r11
%define tmp2 r10
%define tmp3 r9
%define tmp4 r12 ; must be saved and restored
%define return rax
%define PS 8
%define LOG_PS 3
%define func(x) x:
%macro FUNC_SAVE 0
push r12
%endmacro
%macro FUNC_RESTORE 0
pop r12
%endmacro
%endif
%ifidn __OUTPUT_FORMAT__, win64
%define arg0 rcx
%define arg1 rdx
%define arg2 r8
%define arg3 r9
%define arg4 r12 ; must be saved, loaded and restored
%define tmp r11
%define tmp2 r10
%define tmp3 r13 ; must be saved and restored
%define tmp4 r14 ; must be saved and restored
%define return rax
%define PS 8
%define LOG_PS 3
%define stack_size 3*16 + 3*8 ; must be an odd multiple of 8
%define arg(x) [rsp + stack_size + PS + PS*x]
%define func(x) proc_frame x
%macro FUNC_SAVE 0
alloc_stack stack_size
save_xmm128 xmm6, 0*16
save_xmm128 xmm7, 1*16
save_xmm128 xmm8, 2*16
save_reg r12, 3*16 + 0*8
save_reg r13, 3*16 + 1*8
save_reg r14, 3*16 + 2*8
end_prolog
mov arg4, arg(4)
%endmacro
%macro FUNC_RESTORE 0
movdqa xmm6, [rsp + 0*16]
movdqa xmm7, [rsp + 1*16]
movdqa xmm8, [rsp + 2*16]
mov r12, [rsp + 3*16 + 0*8]
mov r13, [rsp + 3*16 + 1*8]
mov r14, [rsp + 3*16 + 2*8]
add rsp, stack_size
%endmacro
%endif
%define len arg0
%define vec arg1
%define mul_array arg2
%define src arg3
%define dest1 arg4
%define vec_i tmp2
%define ptr tmp3
%define dest2 tmp4
%define pos return
%ifndef EC_ALIGNED_ADDR
;;; Use Un-aligned load/store
%define XLDR movdqu
%define XSTR movdqu
%else
;;; Use Non-temporal load/stor
%ifdef NO_NT_LDST
%define XLDR movdqa
%define XSTR movdqa
%else
%define XLDR movntdqa
%define XSTR movntdq
%endif
%endif
default rel
[bits 64]
section .text
%define xmask0f xmm8
%define xgft1_lo xmm7
%define xgft1_hi xmm6
%define xgft2_lo xmm5
%define xgft2_hi xmm4
%define x0 xmm0
%define xtmpa xmm1
%define xp1 xmm2
%define xp2 xmm3
align 16
global GF_2VECT_DOT_PROD_SSE:function
func(GF_2VECT_DOT_PROD_SSE)
FUNC_SAVE
sub len, 16
jl .return_fail
xor pos, pos
movdqa xmask0f, [mask0f] ;Load mask of lower nibble in each byte
sal vec, LOG_PS ;vec *= PS. Make vec_i count by PS
mov dest2, [dest1+PS]
mov dest1, [dest1]
.loop16
pxor xp1, xp1
pxor xp2, xp2
mov tmp, mul_array
xor vec_i, vec_i
.next_vect
mov ptr, [src+vec_i]
movdqu xgft1_lo, [tmp] ;Load array Ax{00}, Ax{01}, ..., Ax{0f}
movdqu xgft1_hi, [tmp+16] ; " Ax{00}, Ax{10}, ..., Ax{f0}
movdqu xgft2_lo, [tmp+vec*(32/PS)] ;Load array Bx{00}, Bx{01}, ..., Bx{0f}
movdqu xgft2_hi, [tmp+vec*(32/PS)+16] ; " Bx{00}, Bx{10}, ..., Bx{f0}
XLDR x0, [ptr+pos] ;Get next source vector
add tmp, 32
add vec_i, PS
movdqa xtmpa, x0 ;Keep unshifted copy of src
psraw x0, 4 ;Shift to put high nibble into bits 4-0
pand x0, xmask0f ;Mask high src nibble in bits 4-0
pand xtmpa, xmask0f ;Mask low src nibble in bits 4-0
pshufb xgft1_hi, x0 ;Lookup mul table of high nibble
pshufb xgft1_lo, xtmpa ;Lookup mul table of low nibble
pxor xgft1_hi, xgft1_lo ;GF add high and low partials
pxor xp1, xgft1_hi ;xp1 += partial
pshufb xgft2_hi, x0 ;Lookup mul table of high nibble
pshufb xgft2_lo, xtmpa ;Lookup mul table of low nibble
pxor xgft2_hi, xgft2_lo ;GF add high and low partials
pxor xp2, xgft2_hi ;xp2 += partial
cmp vec_i, vec
jl .next_vect
XSTR [dest1+pos], xp1
XSTR [dest2+pos], xp2
add pos, 16 ;Loop on 16 bytes at a time
cmp pos, len
jle .loop16
lea tmp, [len + 16]
cmp pos, tmp
je .return_pass
;; Tail len
mov pos, len ;Overlapped offset length-16
jmp .loop16 ;Do one more overlap pass
.return_pass:
mov return, 0
FUNC_RESTORE
ret
.return_fail:
mov return, 1
FUNC_RESTORE
ret
endproc_frame
section .data
align 16
mask0f: ddq 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f
%macro slversion 4
global %1_slver_%2%3%4
global %1_slver
%1_slver:
%1_slver_%2%3%4:
dw 0x%4
db 0x%3, 0x%2
%endmacro
;;; func core, ver, snum
slversion GF_2VECT_DOT_PROD_SSE, 00, 02, 0062
|
//
// ex9_20.cpp
// Exercise 9.20
//
// Created by pezy on 12/3/14.
//
// @Brief Write a program to copy elements from a list<int> into two deques.
// The even-valued elements should go into one deque and the odd ones into the other.
#include <iostream>
#include <deque>
#include <list>
using std::deque; using std::list; using std::cout; using std::cin; using std::endl;
int main()
{
list<int> l{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
deque<int> odd, even;
for (auto i : l)
(i & 0x1 ? odd : even).push_back(i);
for (auto i : odd) cout << i << " ";
cout << endl;
for (auto i : even)cout << i << " ";
cout << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.