text
stringlengths 2
100k
| meta
dict |
|---|---|
; RUN: opt -basicaa -print-memoryssa -verify-memoryssa -analyze < %s 2>&1 | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s
; %ptr can't alias %local, so we should be able to optimize the use of %local to
; point to the store to %local.
; CHECK-LABEL: define void @check
define void @check(i8* %ptr, i1 %bool) {
entry:
%local = alloca i8, align 1
; CHECK: 1 = MemoryDef(liveOnEntry)
; CHECK-NEXT: store i8 0, i8* %local, align 1
store i8 0, i8* %local, align 1
br i1 %bool, label %if.then, label %if.end
if.then:
%p2 = getelementptr inbounds i8, i8* %ptr, i32 1
; CHECK: 2 = MemoryDef(1)
; CHECK-NEXT: store i8 0, i8* %p2, align 1
store i8 0, i8* %p2, align 1
br label %if.end
if.end:
; CHECK: 3 = MemoryPhi({entry,1},{if.then,2})
; CHECK: MemoryUse(1)
; CHECK-NEXT: load i8, i8* %local, align 1
load i8, i8* %local, align 1
ret void
}
; CHECK-LABEL: define void @check2
define void @check2(i1 %val1, i1 %val2, i1 %val3) {
entry:
%local = alloca i8, align 1
%local2 = alloca i8, align 1
; CHECK: 1 = MemoryDef(liveOnEntry)
; CHECK-NEXT: store i8 0, i8* %local
store i8 0, i8* %local
br i1 %val1, label %if.then, label %phi.3
if.then:
; CHECK: 2 = MemoryDef(1)
; CHECK-NEXT: store i8 2, i8* %local2
store i8 2, i8* %local2
br i1 %val2, label %phi.2, label %phi.3
phi.3:
; CHECK: 6 = MemoryPhi({entry,1},{if.then,2})
; CHECK: 3 = MemoryDef(6)
; CHECK-NEXT: store i8 3, i8* %local2
store i8 3, i8* %local2
br i1 %val3, label %phi.2, label %phi.1
phi.2:
; CHECK: 5 = MemoryPhi({if.then,2},{phi.3,3})
; CHECK: 4 = MemoryDef(5)
; CHECK-NEXT: store i8 4, i8* %local2
store i8 4, i8* %local2
br label %phi.1
phi.1:
; Order matters here; phi.2 needs to come before phi.3, because that's the order
; they're visited in.
; CHECK: 7 = MemoryPhi({phi.2,4},{phi.3,3})
; CHECK: MemoryUse(1)
; CHECK-NEXT: load i8, i8* %local
load i8, i8* %local
ret void
}
; CHECK-LABEL: define void @cross_phi
define void @cross_phi(i8* noalias %p1, i8* noalias %p2) {
; CHECK: 1 = MemoryDef(liveOnEntry)
; CHECK-NEXT: store i8 0, i8* %p1
store i8 0, i8* %p1
; CHECK: MemoryUse(1)
; CHECK-NEXT: load i8, i8* %p1
load i8, i8* %p1
br i1 undef, label %a, label %b
a:
; CHECK: 2 = MemoryDef(1)
; CHECK-NEXT: store i8 0, i8* %p2
store i8 0, i8* %p2
br i1 undef, label %c, label %d
b:
; CHECK: 3 = MemoryDef(1)
; CHECK-NEXT: store i8 1, i8* %p2
store i8 1, i8* %p2
br i1 undef, label %c, label %d
c:
; CHECK: 6 = MemoryPhi({a,2},{b,3})
; CHECK: 4 = MemoryDef(6)
; CHECK-NEXT: store i8 2, i8* %p2
store i8 2, i8* %p2
br label %e
d:
; CHECK: 7 = MemoryPhi({a,2},{b,3})
; CHECK: 5 = MemoryDef(7)
; CHECK-NEXT: store i8 3, i8* %p2
store i8 3, i8* %p2
br label %e
e:
; 8 = MemoryPhi({c,4},{d,5})
; CHECK: MemoryUse(1)
; CHECK-NEXT: load i8, i8* %p1
load i8, i8* %p1
ret void
}
; CHECK-LABEL: define void @looped
define void @looped(i8* noalias %p1, i8* noalias %p2) {
; CHECK: 1 = MemoryDef(liveOnEntry)
; CHECK-NEXT: store i8 0, i8* %p1
store i8 0, i8* %p1
br label %loop.1
loop.1:
; CHECK: 7 = MemoryPhi({%0,1},{loop.3,4})
; CHECK: 2 = MemoryDef(7)
; CHECK-NEXT: store i8 0, i8* %p2
store i8 0, i8* %p2
br i1 undef, label %loop.2, label %loop.3
loop.2:
; CHECK: 6 = MemoryPhi({loop.1,2},{loop.3,4})
; CHECK: 3 = MemoryDef(6)
; CHECK-NEXT: store i8 1, i8* %p2
store i8 1, i8* %p2
br label %loop.3
loop.3:
; CHECK: 5 = MemoryPhi({loop.1,2},{loop.2,3})
; CHECK: 4 = MemoryDef(5)
; CHECK-NEXT: store i8 2, i8* %p2
store i8 2, i8* %p2
; FIXME: This should be MemoryUse(1)
; CHECK: MemoryUse(5)
; CHECK-NEXT: load i8, i8* %p1
load i8, i8* %p1
br i1 undef, label %loop.2, label %loop.1
}
; CHECK-LABEL: define void @looped_visitedonlyonce
define void @looped_visitedonlyonce(i8* noalias %p1, i8* noalias %p2) {
br label %while.cond
while.cond:
; CHECK: 5 = MemoryPhi({%0,liveOnEntry},{if.end,3})
; CHECK-NEXT: br i1 undef, label %if.then, label %if.end
br i1 undef, label %if.then, label %if.end
if.then:
; CHECK: 1 = MemoryDef(5)
; CHECK-NEXT: store i8 0, i8* %p1
store i8 0, i8* %p1
br i1 undef, label %if.end, label %if.then2
if.then2:
; CHECK: 2 = MemoryDef(1)
; CHECK-NEXT: store i8 1, i8* %p2
store i8 1, i8* %p2
br label %if.end
if.end:
; CHECK: 4 = MemoryPhi({while.cond,5},{if.then,1},{if.then2,2})
; CHECK: MemoryUse(4)
; CHECK-NEXT: load i8, i8* %p1
load i8, i8* %p1
; CHECK: 3 = MemoryDef(4)
; CHECK-NEXT: store i8 2, i8* %p2
store i8 2, i8* %p2
; CHECK: MemoryUse(4)
; CHECK-NEXT: load i8, i8* %p1
load i8, i8* %p1
br label %while.cond
}
| {
"language": "Assembly"
} |
#include <stdio.h>
#include "structs.h"
#include "common.h"
#include "txtfile.h"
#include "service.h"
#include "casdem.h"
#include "b1.h"
#define __FILENUM__ 16
__declspec( naked ) void ArtMove1(void)
{
__asm{
cmp eax,0x1680
jae l_New
sub edx,[eax+0x67FFA0]
jmp l_All
}
l_New: __asm sub edx,0x16
l_All:
__asm ret;
}
__declspec( naked ) void ArtMove2(void)
{
__asm{
cmp eax,0x1680
jae l_New
mov edx,[eax+0x67FFA4]
jmp l_All
}
l_New: __asm mov edx,0x16
l_All:
__asm ret;
}
//static AAIA_Ret;
// ecx,edx should be set
int __stdcall ArtAIAnal(Dword ArtNum,Dword par2,Dword par1)
{
__asm mov eax,ArtNum
__asm cmp eax,0x91
__asm ja l_No
__asm push par1
__asm push par2
__asm push ArtNum
__asm mov eax,0x4336C0
__asm call eax
__asm jmp l_Yes
l_No:;
__asm xor eax,eax
l_Yes:;
// return _EAX;
__asm mov DDummy,eax
return DDummy;
}
static Dword HA157_Ret;
// esi -> our mon, edi ->attaker mon
__declspec( naked ) void HasArt157(void)
{
__asm{
pusha
mov edx, [edi+84h]
mov HA157_Ret,edx
mov eax, [esi+0x288] // Hypnotized?
test eax, eax
jz loc_0044585C
mov ecx, [esi+0xF4] // mon side
mov eax, 1
sub eax, ecx // reverse it
jmp loc_00445862
}
loc_0044585C:
__asm{
mov eax, [esi+0xF4] // side
}
loc_00445862:
__asm{
mov ecx, 0x699420
mov ecx, [ecx]
mov eax, [ecx+eax*4+53CCh] // Hero Po
test eax, eax
jz loc_004458C3 // no hero
push 157
mov ecx, eax
mov eax, 0x4D9460
call eax // HeroHasArt ?
test al, al
jz loc_004458C3 // no
// has art
mov edx,HA157_Ret
and edx,0xFFFEFFFF // reset "no retailate bit"
mov HA157_Ret,edx
}
loc_004458C3:
__asm{
popa
mov edx,HA157_Ret
ret
}
}
static float HA158_Fl=150;
// edi -> our mon esi -> defender mon
__declspec( naked ) void HasArt158(void)
{
__asm{
pusha
mov Byte ptr [esi+0x4C0], 0
mov Byte ptr [esi+0x4C1], 0
mov ecx, [esi+0x4C] // no defending creatures
test ecx, ecx
jle loc_00441C01
mov eax, [edi+0x84]
shr eax, 2 // shooter?
test al, 1
jnz loc_00441C01
mov eax, [edi+0x290] // Blind?
test eax, eax
jnz loc_00441C01
mov eax, [edi+0x2B0] // Stoned?
test eax, eax
jnz loc_00441C01
mov eax, [edi+0x2C0] // Paralized?
test eax, eax
jnz loc_00441C01
mov eax, [edi+0x4C] // No creatures?
test eax, eax
jle loc_00441C01
mov eax, [edi+0x288] // Hypnotized?
test eax, eax
jz loc_0044585C
mov ecx, [edi+0xF4] // mon side
mov eax, 1
sub eax, ecx // reverse it
jmp loc_00445862
}
loc_0044585C:
__asm{
mov eax, [edi+0xF4] // side
}
loc_00445862:
__asm{
mov ecx, 0x699420
mov ecx, [ecx]
mov eax, [ecx+eax*4+53CCh] // Hero Po
test eax, eax
jz loc_00441C01 // no hero
push 158
mov ecx, eax
mov eax, 0x4D9460
call eax // HeroHasArt ?
test al, al
jz short loc_00441C01
mov edx, 0x69883C
mov edx, [edx]
fld Dword ptr [0x63CF7C+edx*4]
fmul HA158_Fl
mov eax,0x617F94 // ftol
call eax
mov ecx, eax
mov eax,0x4F8A50
call eax
mov eax, [ebp+8]
mov ecx, edi
push eax
push esi
mov eax,0x441330
call eax
}
loc_00441C01:
__asm{
popa
mov ecx, [esi+0x84]
ret
}
}
struct _ClosedTowns_ {
char Closed; // 0 -нет, длит в дн€х закрыти€
char HoldLen; // длит в дн€х задержки дл€ возврата ключа
char Owner; // хоз€ин
Byte Hero; // герой - хоз€ин ключа
Byte X,Y,L; //
Byte _r;
} ClosedTowns[48];
static char Buf[256];
void CloseCastleGate(_Hero_ *hp,_CastleSetup_ *Cstr)
{
STARTNA(__LINE__, 0)
_MapItem_ *MIp0,*MIp;
int ArtSlot=-1,ex,ey,el,MapSize;
int This=IsThis(hp->Owner);
int AI=IsAI(hp->Owner);
for(int i=0;i<19;i++){ if(hp->IArt[i][0]==160) ArtSlot=i; }
/*
hp->OArt[i][0]=-1;
hp->OArt[i][1]=-1;
hp->OANum=(Byte)(hp->OANum-1);
}
}
*/
if(This&& !AI){ // human
if(ArtSlot!=-1){ // has art
if(ClosedTowns[Cstr->Number].Closed!=0) RETURNV // закрыт
if(ClosedTowns[Cstr->Number].HoldLen!=0){ // ключ еще не возвращен
sprintf(Buf,ITxt(238,0,&Strings),ClosedTowns[Cstr->Number].HoldLen);
Request2Pic(Buf,22+Cstr->Type,7,8,160,1);
RETURNV
}
if(Request2Pic(ITxt(237,0,&Strings),22+Cstr->Type,7,8,160,2)){
ClosedTowns[Cstr->Number].Closed=5;
ClosedTowns[Cstr->Number].HoldLen=5;
ClosedTowns[Cstr->Number].Hero=(Byte)hp->Number;
ClosedTowns[Cstr->Number].Owner=hp->Owner;
hp->IArt[ArtSlot][0]=-1;
ex=Cstr->x; ey=Cstr->y; el=Cstr->l;
ClosedTowns[Cstr->Number].X=ex; ClosedTowns[Cstr->Number].Y=ey; ClosedTowns[Cstr->Number].L=el;
__asm{
mov ecx,BASE
mov ecx,[ecx]
mov eax,[ecx+0x1FC40]
mov MIp0,eax
mov eax,[ecx+0x1FC44]
mov MapSize,eax
}
MIp=&MIp0[ex+(ey+el*MapSize)*MapSize];
MIp->Attrib|=0x01; // закрываем
}
}
}else{ // AI
}
RETURNV
}
void DaylyCastleKey(void/*int User*/)
{
STARTNA(__LINE__, 0)
_CastleSetup_ *Castle, *End;
int i,Num,Cnum,DoIt;
_ClosedTowns_ *csp;
_MapItem_ *MIp0,*MIp;
_Hero_ *hp;
int MapSize,ex,ey,el/*,Date*/;
__asm{
mov ecx,BASE
mov ecx,[ecx]
mov eax,[ecx+0x021614]
mov Castle,eax
mov eax,[ecx+0x021618]
mov End,eax
}
Num=End-Castle;
// Date=GetCurDate();
//__asm int 3
for(i=0;i<Num;i++,Castle++){
DoIt=0;
if((Cnum=GetCastleNumber(Castle))<0) RETURNV
csp=&ClosedTowns[Cnum];
ex=Castle->x; ey=Castle->y; el=Castle->l;
if(csp->Closed){ // закрыт
csp->Closed--;
// if(csp->Closed==1){
// if(csp->Owner==User){ // если этот игрок закрывал
// DoIt=1; // откроем
// }
// }
if(csp->Closed==0){
DoIt=1; // откроем
}
}else{
if(csp->HoldLen){ // еще задержан
csp->HoldLen--;
if(csp->HoldLen==0){
hp=GetHeroStr(csp->Hero);
if(hp->OANum<64){ //добавим арт в рюкзак
for(i=0;i<64;i++){
if(hp->OArt[i][0]==-1){
hp->OArt[i][0]=160;
hp->OArt[i][1]=-1;
hp->OANum=(Byte)(hp->OANum+1);
csp->Hero=0;
csp->Owner=0;
break;
}
}
}else{ // некуда добавить - подождем еще денек
csp->HoldLen=1;
}
}
}
}
if(DoIt!=0){
__asm{
mov ecx,BASE
mov ecx,[ecx]
mov eax,[ecx+0x1FC40]
mov MIp0,eax
mov eax,[ecx+0x1FC44]
mov MapSize,eax
}
MIp=&MIp0[ex+(ey+el*MapSize)*MapSize];
if(DoIt==1){
MIp->Attrib&=0xFE; // открываем
// }else{
// MIp->Attrib|=0x01; // закрываем
}
}
}
RETURNV
}
/*
static Dword CMS_Ecx;
void CorrectMapSquares(void)
{
_ECX(CMS_Ecx); // [BASE]
__asm{
mov ecx,CMS_Ecx
mov eax,0x4CA0D0
call eax
}
_CastleSetup_ *Castle, *End;
_ClosedTowns_ *csp;
int i,Num,Cnum,ex,ey,el;
__asm{
mov ecx,BASE
mov ecx,[ecx]
mov eax,[ecx+0x021614]
mov Castle,eax
mov eax,[ecx+0x021618]
mov End,eax
}
Num=End-Castle;
for(i=0;i<Num;i++,Castle++){
if((Cnum=GetCastleNumber(Castle))<0) RETURNV
csp=&ClosedTowns[Cnum];
ex=Castle->x; ey=Castle->y; el=Castle->l;
if(csp->Closed){ // закрыт
Word *VisWord=GetVisabilityPosByXYL(ex,ey,el);
}
}
}
*/
static Dword ASP_Ecx;
void __stdcall AdjustSquarePassability(_MapItem_ *MIp,int ADDremove)
{
_ECX(ASP_Ecx);
STARTNA(__LINE__, 0)
__asm{
push ADDremove
push MIp
mov ecx,ASP_Ecx
mov eax,0x505C60
call eax
}
int x=0,y=0,l=0; Map2Coord(MIp,&x,&y,&l);
for(int i=0;i<48;i++){
_ClosedTowns_ *cp=&ClosedTowns[i];
if(cp->Closed==0) continue;
if(cp->X!=x) continue;
if(cp->Y!=y) continue;
if(cp->L!=l) continue;
MIp->Attrib|=0x01; // закрываем
break;
}
RETURNV
}
void ResetA160(void){
STARTNA(__LINE__, 0)
FillMem(ClosedTowns,sizeof(ClosedTowns),0);
RETURNV
}
int LoadA160(int /*ver*/)
{
STARTNA(__LINE__, 0)
ResetA160();
char buf[4]; if(Loader(buf,4)) RETURN(1)
if(buf[0]!='A'||buf[1]!='1'||buf[2]!='6'||buf[3]!='0') {MError("LoadA160 cannot start loading"); RETURN(1)}
if(Loader(ClosedTowns,sizeof(ClosedTowns))) RETURN(1)
RETURN(0)
}
int SaveA160(void)
{
STARTNA(__LINE__, 0)
if(Saver("A160",4)) RETURN(1)
if(Saver(ClosedTowns,sizeof(ClosedTowns))) RETURN(1)
RETURN(0)
}
__declspec( naked ) void SoDArtMenchHintFix(void)
{
__asm{
mov edx,esi
sub edx,0x12 // slot index in the screen
mov eax,0x6AAAD8 // shift of the slot according a backpack
add edx,[eax]
mov ecx,0x6AAAE0
mov ecx,[ecx]
ret
}
} | {
"language": "Assembly"
} |
db DEX_PUCHICORN ; 204
db 50, 50, 50, 50, 50, 50
; hp atk def spd sat sdf
db TYPE_NORMAL, TYPE_NORMAL ; type
db 255 ; catch rate
db 100 ; base exp
db ITEM_BERRY, ITEM_FIRE_MANE ; items
db GENDER_50_50 ; gender ratio
db 100, 4, 70 ; unknown
dn 5, 5 ; sprite dimensions
dw PuchicornPicFront, PuchicornPicBack ; sprites
db GROWTH_MEDIUM_SLOW ; growth rate
; tm/hm learnset
tmhm 1, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 17, 18, 19, 20, 22, 24, 25, 29, 30, 31, 32, 33, 34, 35, 36, 38, 40, 44, 45, 46, 49, 50, 54, 55
; end
| {
"language": "Assembly"
} |
/*-----------------------------------------------------------------------*/
/* Low level disk I/O module skeleton for FatFs (C)ChaN, 2016 */
/*-----------------------------------------------------------------------*/
/* If a working storage control module is available, it should be */
/* attached to the FatFs via a glue function rather than modifying it. */
/* This is an example of glue functions to attach various exsisting */
/* storage control modules to the FatFs module with a defined API. */
/*-----------------------------------------------------------------------*/
#include "ff.h" /* Obtains integer types */
#include "diskio.h" /* Declarations of disk functions */
/* Definitions of physical drive number for each drive */
#define DEV_RAM 0 /* Example: Map Ramdisk to physical drive 0 */
#define DEV_MMC 1 /* Example: Map MMC/SD card to physical drive 1 */
#define DEV_USB 2 /* Example: Map USB MSD to physical drive 2 */
/*-----------------------------------------------------------------------*/
/* Get Drive Status */
/*-----------------------------------------------------------------------*/
DSTATUS disk_status (
BYTE pdrv /* Physical drive nmuber to identify the drive */
)
{
DSTATUS stat;
int result;
switch (pdrv) {
case DEV_RAM :
result = RAM_disk_status();
// translate the reslut code here
return stat;
case DEV_MMC :
result = MMC_disk_status();
// translate the reslut code here
return stat;
case DEV_USB :
result = USB_disk_status();
// translate the reslut code here
return stat;
}
return STA_NOINIT;
}
/*-----------------------------------------------------------------------*/
/* Inidialize a Drive */
/*-----------------------------------------------------------------------*/
DSTATUS disk_initialize (
BYTE pdrv /* Physical drive nmuber to identify the drive */
)
{
DSTATUS stat;
int result;
switch (pdrv) {
case DEV_RAM :
result = RAM_disk_initialize();
// translate the reslut code here
return stat;
case DEV_MMC :
result = MMC_disk_initialize();
// translate the reslut code here
return stat;
case DEV_USB :
result = USB_disk_initialize();
// translate the reslut code here
return stat;
}
return STA_NOINIT;
}
/*-----------------------------------------------------------------------*/
/* Read Sector(s) */
/*-----------------------------------------------------------------------*/
DRESULT disk_read (
BYTE pdrv, /* Physical drive nmuber to identify the drive */
BYTE *buff, /* Data buffer to store read data */
DWORD sector, /* Start sector in LBA */
UINT count /* Number of sectors to read */
)
{
DRESULT res;
int result;
switch (pdrv) {
case DEV_RAM :
// translate the arguments here
result = RAM_disk_read(buff, sector, count);
// translate the reslut code here
return res;
case DEV_MMC :
// translate the arguments here
result = MMC_disk_read(buff, sector, count);
// translate the reslut code here
return res;
case DEV_USB :
// translate the arguments here
result = USB_disk_read(buff, sector, count);
// translate the reslut code here
return res;
}
return RES_PARERR;
}
/*-----------------------------------------------------------------------*/
/* Write Sector(s) */
/*-----------------------------------------------------------------------*/
#if FF_FS_READONLY == 0
DRESULT disk_write (
BYTE pdrv, /* Physical drive nmuber to identify the drive */
const BYTE *buff, /* Data to be written */
DWORD sector, /* Start sector in LBA */
UINT count /* Number of sectors to write */
)
{
DRESULT res;
int result;
switch (pdrv) {
case DEV_RAM :
// translate the arguments here
result = RAM_disk_write(buff, sector, count);
// translate the reslut code here
return res;
case DEV_MMC :
// translate the arguments here
result = MMC_disk_write(buff, sector, count);
// translate the reslut code here
return res;
case DEV_USB :
// translate the arguments here
result = USB_disk_write(buff, sector, count);
// translate the reslut code here
return res;
}
return RES_PARERR;
}
#endif
/*-----------------------------------------------------------------------*/
/* Miscellaneous Functions */
/*-----------------------------------------------------------------------*/
DRESULT disk_ioctl (
BYTE pdrv, /* Physical drive nmuber (0..) */
BYTE cmd, /* Control code */
void *buff /* Buffer to send/receive control data */
)
{
DRESULT res;
int result;
switch (pdrv) {
case DEV_RAM :
// Process of the command for the RAM drive
return res;
case DEV_MMC :
// Process of the command for the MMC/SD card
return res;
case DEV_USB :
// Process of the command the USB drive
return res;
}
return RES_PARERR;
}
| {
"language": "Assembly"
} |
/* Lazy binding test with auditing.
Copyright (C) 2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include "tst-dl-runtime.c"
| {
"language": "Assembly"
} |
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Prs3d_BasicAspect.ixx>
| {
"language": "Assembly"
} |
; imported symbols
.import init_early
.import init_hardware
.import _fuzix_main
.import kstack_top
.import kstackc_top
.import vector
.import nmi_handler
.import interrupt_handler
.import emulation
.import illegal_inst
.import trap_inst
.import abort_inst
.import __BSS_RUN__, __BSS_SIZE__
.importzp ptr1, ptr2, tmp1
; startup code @0200
.include "kernel.def"
.include "../kernel816.def"
.include "zeropage.inc"
;
; So we end up first in the image
;
.segment "START"
.byte 65
.byte 81
.p816
.a8
.i8
entry:
;
; We are entered at $0102 just after the required magic number
;
; We get run from bank 0, our I/O writes would otherwise need to be
; 24bit
;
sep #$30 ; ensure we are in 8bit mode
lda #'F'
sta $FE20 ; signal our arrival
sei ; interrupts off
cld ; decimal off
; vectors is packed in DP, move it to FF00
rep #$30
.a16
.i16
lda #255
ldx #0
ldy #$FF00
mvn #KERNEL_FAR,#KERNEL_FAR
sep #$30
.a8
.i8
lda #'u'
sta $FE20
rep #$10
.i16
ldx #kstack_top-1
txs ; Stack (6502 not C)
lda #'z'
sta $FE20
ldx #kstackc_top-1 ; C stack
stx sp
ldx #__BSS_RUN__
lda #'i'
sta $FE20
txy
iny
; Wipe the BSS
rep #$20
.a16
lda #__BSS_SIZE__-2 ; must be >=2 bytes or else
stz a:0,x
mvn #0,#0
sep #$30
.a8
.i8
lda #'x'
sta $FE20
jsr init_early
lda #'.'
sta $FE20
jsr init_hardware
jmp code
.code
.a8
.i8
code:
lda #13
sta $FE20
lda #10
sta $FE20
jsr _fuzix_main ; Should never return
sei ; Spin
stop: bra stop
;
; Processor vector table (0xFFE0)
;
.segment "VECTORS"
.word 0 ; unused
.word 0 ; unused
.word illegal_inst ; COP
.word trap_inst ; BRK
.word abort_inst ; ABORT
.word nmi_handler ; NMI
.word 0 ; Unused (native reset)
.word interrupt_handler
;
; Emulation mode vectors. If called badness occurred
;
.word emulation
.word emulation
.word emulation
.word emulation
.word emulation
.word emulation
.word emulation
.word emulation
| {
"language": "Assembly"
} |
OUTPUT_ARCH( "riscv" )
ENTRY(_Reset)
SECTIONS
{
. = 0x80000000;
.text.init : { *(.text.init) }
.tohost ALIGN(0x1000) : { *(.tohost) }
.text ALIGN(0x1000) : { *(.text) }
.data ALIGN(0x1000) : { *(.data) }
.bss : { *(.bss) }
.note.gnu.build-id : {}
. = ALIGN(8);
. = . + 0x8000; /* 32kB of stack memory */
stack_top = .;
_end = .;
}
| {
"language": "Assembly"
} |
# RUN: llvm-mc -triple=x86_64-apple-macosx10.10.0 -filetype=obj -o %t %s
# RUN: llvm-rtdyld -print-alloc-requests -triple=x86_64-pc-linux -dummy-extern _g=196608 -verify %t
# Compiled from Inputs/ELF/ELF_x86_64_StubBuf.ll
# CHECK: allocateCodeSection(Size = 42, Alignment = 16, SectionName = __text)
.section __TEXT,__text,regular,pure_instructions
.macosx_version_min 10, 10
.globl _f
.align 4, 0x90
_f: ## @f
.cfi_startproc
## %bb.0: ## %entry
pushq %rax
Ltmp0:
.cfi_def_cfa_offset 16
callq _g
callq _g
callq _g
popq %rax
retq
.cfi_endproc
.subsections_via_symbols
| {
"language": "Assembly"
} |
.text
.globl target
.type target, @function
#! file-offset 0
#! rip-offset 0
#! capacity 5 bytes
# Text # Line RIP Bytes Opcode
.target: # 0 0 OPC=<label>
callq .move_128_064_xmm2_r8_r9 # 1 0 5 OPC=callq_label
vzeroall # 2 0x5 3 OPC=vzeroall
callq .move_064_128_r8_r9_xmm1 # 3 0x8 5 OPC=callq_label
retq # 4 0xd 1 OPC=retq
.size target, .-target
| {
"language": "Assembly"
} |
/*
* (C) Copyright 2000
* Rob Taylor, Flying Pig Systems Ltd. robt@flyingpig.com
*
* SPDX-License-Identifier: GPL-2.0+
*/
OUTPUT_ARCH(powerpc)
MEMORY {
ram (!rx) : org = 0x00000000 , LENGTH = 8M
code (!rx) : org = 0x00002000 , LENGTH = (4M - 0x2000)
rom (rx) : org = 0xfff00000 , LENGTH = 512K
}
SECTIONS
{
_f_init = .;
PROVIDE(_f_init = .);
_f_init_rom = .;
PROVIDE(_f_init_rom = .);
.init : {
arch/powerpc/cpu/mpc824x/start.o (.text)
*(.init)
} > ram
_init_size = SIZEOF(.init);
PROVIDE(_init_size = SIZEOF(.init));
ENTRY(_start)
/* _ftext = .;
_ftext_rom = .;
_text_size = SIZEOF(.text);
*/
.text : {
*(.text)
*(.got1)
} > ram
.rodata : { *(.rodata) } > ram
.dtors : { *(.dtors) } > ram
.data : { *(.data) } > ram
.sdata : { *(.sdata) } > ram
.sdata2 : { *(.sdata2)
*(.got)
_GOT2_TABLE_ = .;
*(.got2)
_FIXUP_TABLE_ = .;
*(.fixup)
} > ram
__got2_entries = (_FIXUP_TABLE_ - _GOT2_TABLE_) >>2;
__fixup_entries = (. - _FIXUP_TABLE_)>>2;
.sbss : { *(.sbss) } > ram
.sbss2 : { *(.sbss2) } > ram
.bss : { *(.bss) } > ram
.debug : { *(.debug) } > ram
.line : { *(.line) } > ram
.symtab : { *(.symtab) } > ram
.shrstrtab : { *(.shstrtab) } > ram
.strtab : { *(.strtab) } > ram
/* .reloc :
{
*(.got)
_GOT2_TABLE_ = .;
*(.got2)
_FIXUP_TABLE_ = .;
*(.fixup)
} > ram
*/
__start___ex_table = .;
__ex_table : { *(__ex_table) } > ram
__stop___ex_table = .;
.ppcenv :
{
common/env_embedded.o (.ppcenv)
} > ram
__bss_end = . ;
PROVIDE (end = .);
}
| {
"language": "Assembly"
} |
/*
* Copyright (c) 2013 Miodrag Vallat. <miod@openbsd.org>
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* ``Software''), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/*
* vax Foreign Function Interface
*/
#define LIBFFI_ASM
#include <fficonfig.h>
#include <ffi.h>
.text
/*
* void * %r0
* ffi_call_elfbsd(extended_cif *ecif, 4(%ap)
* unsigned bytes, 8(%ap)
* unsigned flags, 12(%ap)
* void *rvalue, 16(%ap)
* void (*fn)()); 20(%ap)
*/
.globl ffi_call_elfbsd
.type ffi_call_elfbsd,@function
.align 2
ffi_call_elfbsd:
.word 0x00c # save R2 and R3
# Allocate stack space for the args
subl2 8(%ap), %sp
# Call ffi_prep_args
pushl %sp
pushl 4(%ap)
calls $2, ffi_prep_args
# Get function pointer
movl 20(%ap), %r1
# Build a CALLS frame
ashl $-2, 8(%ap), %r0
pushl %r0 # argument stack usage
movl %sp, %r0 # future %ap
# saved registers
bbc $11, 0(%r1), 1f
pushl %r11
1: bbc $10, 0(%r1), 1f
pushl %r10
1: bbc $9, 0(%r1), 1f
pushl %r9
1: bbc $8, 0(%r1), 1f
pushl %r8
1: bbc $7, 0(%r1), 1f
pushl %r7
1: bbc $6, 0(%r1), 1f
pushl %r6
1: bbc $5, 0(%r1), 1f
pushl %r5
1: bbc $4, 0(%r1), 1f
pushl %r4
1: bbc $3, 0(%r1), 1f
pushl %r3
1: bbc $2, 0(%r1), 1f
pushl %r2
1:
pushal 9f
pushl %fp
pushl %ap
movl 16(%ap), %r3 # struct return address, if needed
movl %r0, %ap
movzwl 4(%fp), %r0 # previous PSW, without the saved registers mask
bisl2 $0x20000000, %r0 # calls frame
movzwl 0(%r1), %r2
bicw2 $0xf003, %r2 # only keep R11-R2
ashl $16, %r2, %r2
bisl2 %r2, %r0 # saved register mask of the called function
pushl %r0
pushl $0
movl %sp, %fp
# Invoke the function
pushal 2(%r1) # skip procedure entry mask
movl %r3, %r1
bicpsw $0x000f
rsb
9:
# Copy return value if necessary
tstl 16(%ap)
jeql 9f
movl 16(%ap), %r2
bbc $0, 12(%ap), 1f # CIF_FLAGS_CHAR
movb %r0, 0(%r2)
brb 9f
1:
bbc $1, 12(%ap), 1f # CIF_FLAGS_SHORT
movw %r0, 0(%r2)
brb 9f
1:
bbc $2, 12(%ap), 1f # CIF_FLAGS_INT
movl %r0, 0(%r2)
brb 9f
1:
bbc $3, 12(%ap), 1f # CIF_FLAGS_DINT
movq %r0, 0(%r2)
brb 9f
1:
movl %r1, %r0 # might have been a struct
#brb 9f
9:
ret
/*
* ffi_closure_elfbsd(void);
* invoked with %r0: ffi_closure *closure
*/
.globl ffi_closure_elfbsd
.type ffi_closure_elfbsd, @function
.align 2
ffi_closure_elfbsd:
.word 0
# Allocate room on stack for return value
subl2 $8, %sp
# Invoke the closure function
pushal 4(%ap) # calling stack
pushal 4(%sp) # return value
pushl %r0 # closure
calls $3, ffi_closure_elfbsd_inner
# Copy return value if necessary
bitb $1, %r0 # CIF_FLAGS_CHAR
beql 1f
movb 0(%sp), %r0
brb 9f
1:
bitb $2, %r0 # CIF_FLAGS_SHORT
beql 1f
movw 0(%sp), %r0
brb 9f
1:
bitb $4, %r0 # CIF_FLAGS_INT
beql 1f
movl 0(%sp), %r0
brb 9f
1:
bitb $8, %r0 # CIF_FLAGS_DINT
beql 1f
movq 0(%sp), %r0
#brb 9f
1:
9:
ret
/*
* ffi_closure_struct_elfbsd(void);
* invoked with %r0: ffi_closure *closure
* %r1: struct return address
*/
.globl ffi_closure_struct_elfbsd
.type ffi_closure_struct_elfbsd, @function
.align 2
ffi_closure_struct_elfbsd:
.word 0
# Invoke the closure function
pushal 4(%ap) # calling stack
pushl %r1 # return value
pushl %r0 # closure
calls $3, ffi_closure_elfbsd_inner
ret
| {
"language": "Assembly"
} |
; RUN: opt < %s -licm -loop-unswitch -disable-output
@g_56 = external global i16 ; <i16*> [#uses=2]
define i32 @func_67(i32 %p_68, i8 signext %p_69, i8 signext %p_71) nounwind {
entry:
br label %bb
bb: ; preds = %bb44, %entry
br label %bb3
bb3: ; preds = %bb36, %bb
%bothcond = or i1 false, false ; <i1> [#uses=1]
br i1 %bothcond, label %bb29, label %bb19
bb19: ; preds = %bb3
br i1 false, label %bb36, label %bb29
bb29: ; preds = %bb19, %bb3
ret i32 0
bb36: ; preds = %bb19
store i16 0, i16* @g_56, align 2
br i1 false, label %bb44, label %bb3
bb44: ; preds = %bb44, %bb36
%tmp46 = load i16, i16* @g_56, align 2 ; <i16> [#uses=0]
br i1 false, label %bb, label %bb44
}
| {
"language": "Assembly"
} |
; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
; RUN: llvm-profdata merge %S/Inputs/landingpad.proftext -o %t.profdata
; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
@val = global i32 0, align 4
@_ZTIi = external constant i8*
; GEN: $__llvm_profile_raw_version = comdat any
; GEN: @__llvm_profile_raw_version = constant i64 {{[0-9]+}}, comdat
; GEN: @__profn_bar = private constant [3 x i8] c"bar"
; GEN: @__profn_foo = private constant [3 x i8] c"foo"
define i32 @bar(i32 %i) {
entry:
; GEN: entry:
; GEN: call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__profn_bar, i32 0, i32 0), i64 24868915205, i32 2, i32 0)
%rem = srem i32 %i, 3
%tobool = icmp ne i32 %rem, 0
br i1 %tobool, label %if.then, label %if.end
; USE: br i1 %tobool, label %if.then, label %if.end
; USE-SAME: !prof ![[BW_BAR_ENTRY:[0-9]+]]
if.then:
; GEN: if.then:
; GEN: call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__profn_bar, i32 0, i32 0), i64 24868915205, i32 2, i32 1)
%exception = call i8* @__cxa_allocate_exception(i64 4)
%tmp = bitcast i8* %exception to i32*
store i32 %i, i32* %tmp, align 16
call void @__cxa_throw(i8* %exception, i8* bitcast (i8** @_ZTIi to i8*), i8* null)
unreachable
if.end:
; GEN: if.end:
; GEN-NOT: call void @llvm.instrprof.increment
; GEN: ret i32
ret i32 0
}
declare i8* @__cxa_allocate_exception(i64)
declare void @__cxa_throw(i8*, i8*, i8*)
define i32 @foo(i32 %i) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
entry:
; GEN: entry:
; GEN-NOT: call void @llvm.instrprof.increment
%rem = srem i32 %i, 2
%tobool = icmp ne i32 %rem, 0
br i1 %tobool, label %if.then, label %if.end
; USE: br i1 %tobool, label %if.then, label %if.end
; USE-SAME: !prof ![[BW_FOO_ENTRY:[0-9]+]]
if.then:
; GEN: if.then:
; GEN-NOT: call void @llvm.instrprof.increment
%mul = mul nsw i32 %i, 7
%call = invoke i32 @bar(i32 %mul)
to label %invoke.cont unwind label %lpad
invoke.cont:
; GEN: invoke.cont:
; GEN: call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__profn_foo, i32 0, i32 0), i64 59130013419, i32 4, i32 1)
br label %if.end
lpad:
; GEN: lpad:
; GEN-NOT: call void @llvm.instrprof.increment
%tmp = landingpad { i8*, i32 }
catch i8* bitcast (i8** @_ZTIi to i8*)
%tmp1 = extractvalue { i8*, i32 } %tmp, 0
%tmp2 = extractvalue { i8*, i32 } %tmp, 1
br label %catch.dispatch
catch.dispatch:
; GEN: catch.dispatch:
; GEN-NOT: call void @llvm.instrprof.increment
%tmp3 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*))
%matches = icmp eq i32 %tmp2, %tmp3
br i1 %matches, label %catch, label %eh.resume
; USE: br i1 %matches, label %catch, label %eh.resume
; USE-SAME: !prof ![[BW_CATCH_DISPATCH:[0-9]+]]
catch:
; GEN: catch:
; GEN: call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__profn_foo, i32 0, i32 0), i64 59130013419, i32 4, i32 2)
%tmp4 = call i8* @__cxa_begin_catch(i8* %tmp1)
%tmp5 = bitcast i8* %tmp4 to i32*
%tmp6 = load i32, i32* %tmp5, align 4
%tmp7 = load i32, i32* @val, align 4
%sub = sub nsw i32 %tmp7, %tmp6
store i32 %sub, i32* @val, align 4
call void @__cxa_end_catch()
br label %try.cont
try.cont:
; GEN: try.cont:
; GEN-NOT: call void @llvm.instrprof.increment
ret i32 -1
if.end:
; GEN: if.end:
; GEN: call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__profn_foo, i32 0, i32 0), i64 59130013419, i32 4, i32 0)
%tmp8 = load i32, i32* @val, align 4
%add = add nsw i32 %tmp8, %i
store i32 %add, i32* @val, align 4
br label %try.cont
eh.resume:
; GEN: eh.resume:
; GEN: call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__profn_foo, i32 0, i32 0), i64 59130013419, i32 4, i32 3)
%lpad.val = insertvalue { i8*, i32 } undef, i8* %tmp1, 0
%lpad.val3 = insertvalue { i8*, i32 } %lpad.val, i32 %tmp2, 1
resume { i8*, i32 } %lpad.val3
}
declare i32 @__gxx_personality_v0(...)
declare i32 @llvm.eh.typeid.for(i8*)
declare i8* @__cxa_begin_catch(i8*)
declare void @__cxa_end_catch()
; USE: ![[BW_BAR_ENTRY]] = !{!"branch_weights", i32 2, i32 1}
; USE: ![[BW_FOO_ENTRY]] = !{!"branch_weights", i32 3, i32 2}
; USE: ![[BW_CATCH_DISPATCH]] = !{!"branch_weights", i32 2, i32 0}
| {
"language": "Assembly"
} |
StartChar: Lacute.sq
Encoding: 1114215 -1 704
Width: 1024
VWidth: 0
Flags: W
HStem: 0 240<448 1024> 1408 21G<192 424.844>
VStem: 192 256<240 1280>
LayerCount: 5
Back
Fore
SplineSet
192 0 m 1
192 1280 l 5
448 1280 l 5
448 240 l 1
1024 240 l 1
1024 0 l 1
192 0 l 1
192 1408 m 1
334 1664 l 1
600 1664 l 1
410 1408 l 1
192 1408 l 1
EndSplineSet
Validated: 1
Layer: 2
Layer: 3
Layer: 4
EndChar
| {
"language": "Assembly"
} |
glabel func_80AFDD30
/* 01390 80AFDD30 27BDFFB8 */ addiu $sp, $sp, 0xFFB8 ## $sp = FFFFFFB8
/* 01394 80AFDD34 2401000B */ addiu $at, $zero, 0x000B ## $at = 0000000B
/* 01398 80AFDD38 AFBF0014 */ sw $ra, 0x0014($sp)
/* 0139C 80AFDD3C AFA40048 */ sw $a0, 0x0048($sp)
/* 013A0 80AFDD40 14A1006B */ bne $a1, $at, .L80AFDEF0
/* 013A4 80AFDD44 AFA70054 */ sw $a3, 0x0054($sp)
/* 013A8 80AFDD48 8FAE005C */ lw $t6, 0x005C($sp)
/* 013AC 80AFDD4C 240703CC */ addiu $a3, $zero, 0x03CC ## $a3 = 000003CC
/* 013B0 80AFDD50 91CF0283 */ lbu $t7, 0x0283($t6) ## 00000283
/* 013B4 80AFDD54 31F80002 */ andi $t8, $t7, 0x0002 ## $t8 = 00000000
/* 013B8 80AFDD58 17000063 */ bne $t8, $zero, .L80AFDEE8
/* 013BC 80AFDD5C 00000000 */ nop
/* 013C0 80AFDD60 8C850000 */ lw $a1, 0x0000($a0) ## 00000000
/* 013C4 80AFDD64 3C0680B0 */ lui $a2, %hi(D_80AFE0E0) ## $a2 = 80B00000
/* 013C8 80AFDD68 24C6E0E0 */ addiu $a2, $a2, %lo(D_80AFE0E0) ## $a2 = 80AFE0E0
/* 013CC 80AFDD6C 27A40028 */ addiu $a0, $sp, 0x0028 ## $a0 = FFFFFFE0
/* 013D0 80AFDD70 0C031AB1 */ jal func_800C6AC4
/* 013D4 80AFDD74 AFA50038 */ sw $a1, 0x0038($sp)
/* 013D8 80AFDD78 8FA20048 */ lw $v0, 0x0048($sp)
/* 013DC 80AFDD7C 3C010001 */ lui $at, 0x0001 ## $at = 00010000
/* 013E0 80AFDD80 00411021 */ addu $v0, $v0, $at
/* 013E4 80AFDD84 8C441DE4 */ lw $a0, 0x1DE4($v0) ## 00001DE4
/* 013E8 80AFDD88 AFA20018 */ sw $v0, 0x0018($sp)
/* 013EC 80AFDD8C 00800821 */ addu $at, $a0, $zero
/* 013F0 80AFDD90 00042080 */ sll $a0, $a0, 2
/* 013F4 80AFDD94 00812023 */ subu $a0, $a0, $at
/* 013F8 80AFDD98 00042100 */ sll $a0, $a0, 4
/* 013FC 80AFDD9C 00812023 */ subu $a0, $a0, $at
/* 01400 80AFDDA0 000420C0 */ sll $a0, $a0, 3
/* 01404 80AFDDA4 00812023 */ subu $a0, $a0, $at
/* 01408 80AFDDA8 00042100 */ sll $a0, $a0, 4
/* 0140C 80AFDDAC 00042400 */ sll $a0, $a0, 16
/* 01410 80AFDDB0 0C01DE1C */ jal Math_Sins
## sins?
/* 01414 80AFDDB4 00042403 */ sra $a0, $a0, 16
/* 01418 80AFDDB8 3C0142BE */ lui $at, 0x42BE ## $at = 42BE0000
/* 0141C 80AFDDBC 44812000 */ mtc1 $at, $f4 ## $f4 = 95.00
/* 01420 80AFDDC0 8FA20018 */ lw $v0, 0x0018($sp)
/* 01424 80AFDDC4 24031770 */ addiu $v1, $zero, 0x1770 ## $v1 = 00001770
/* 01428 80AFDDC8 46040182 */ mul.s $f6, $f0, $f4
/* 0142C 80AFDDCC 4600320D */ trunc.w.s $f8, $f6
/* 01430 80AFDDD0 44094000 */ mfc1 $t1, $f8
/* 01434 80AFDDD4 00000000 */ nop
/* 01438 80AFDDD8 00095400 */ sll $t2, $t1, 16
/* 0143C 80AFDDDC 000A5C03 */ sra $t3, $t2, 16
/* 01440 80AFDDE0 05620012 */ bltzl $t3, .L80AFDE2C
/* 01444 80AFDDE4 8C4E1DE4 */ lw $t6, 0x1DE4($v0) ## 00001DE4
/* 01448 80AFDDE8 8C4C1DE4 */ lw $t4, 0x1DE4($v0) ## 00001DE4
/* 0144C 80AFDDEC 01830019 */ multu $t4, $v1
/* 01450 80AFDDF0 00002012 */ mflo $a0
/* 01454 80AFDDF4 00042400 */ sll $a0, $a0, 16
/* 01458 80AFDDF8 0C01DE1C */ jal Math_Sins
## sins?
/* 0145C 80AFDDFC 00042403 */ sra $a0, $a0, 16
/* 01460 80AFDE00 3C0142BE */ lui $at, 0x42BE ## $at = 42BE0000
/* 01464 80AFDE04 44815000 */ mtc1 $at, $f10 ## $f10 = 95.00
/* 01468 80AFDE08 00000000 */ nop
/* 0146C 80AFDE0C 460A0402 */ mul.s $f16, $f0, $f10
/* 01470 80AFDE10 4600848D */ trunc.w.s $f18, $f16
/* 01474 80AFDE14 44059000 */ mfc1 $a1, $f18
/* 01478 80AFDE18 00000000 */ nop
/* 0147C 80AFDE1C 00052C00 */ sll $a1, $a1, 16
/* 01480 80AFDE20 10000011 */ beq $zero, $zero, .L80AFDE68
/* 01484 80AFDE24 00052C03 */ sra $a1, $a1, 16
/* 01488 80AFDE28 8C4E1DE4 */ lw $t6, 0x1DE4($v0) ## 00001DE4
.L80AFDE2C:
/* 0148C 80AFDE2C 01C30019 */ multu $t6, $v1
/* 01490 80AFDE30 00002012 */ mflo $a0
/* 01494 80AFDE34 00042400 */ sll $a0, $a0, 16
/* 01498 80AFDE38 0C01DE1C */ jal Math_Sins
## sins?
/* 0149C 80AFDE3C 00042403 */ sra $a0, $a0, 16
/* 014A0 80AFDE40 3C0142BE */ lui $at, 0x42BE ## $at = 42BE0000
/* 014A4 80AFDE44 44812000 */ mtc1 $at, $f4 ## $f4 = 95.00
/* 014A8 80AFDE48 00000000 */ nop
/* 014AC 80AFDE4C 46040182 */ mul.s $f6, $f0, $f4
/* 014B0 80AFDE50 4600320D */ trunc.w.s $f8, $f6
/* 014B4 80AFDE54 44054000 */ mfc1 $a1, $f8
/* 014B8 80AFDE58 00000000 */ nop
/* 014BC 80AFDE5C 00052C00 */ sll $a1, $a1, 16
/* 014C0 80AFDE60 00052C03 */ sra $a1, $a1, 16
/* 014C4 80AFDE64 00052823 */ subu $a1, $zero, $a1
.L80AFDE68:
/* 014C8 80AFDE68 8FA60038 */ lw $a2, 0x0038($sp)
/* 014CC 80AFDE6C 24A200A0 */ addiu $v0, $a1, 0x00A0 ## $v0 = 000000A0
/* 014D0 80AFDE70 3C19E700 */ lui $t9, 0xE700 ## $t9 = E7000000
/* 014D4 80AFDE74 8CC302C0 */ lw $v1, 0x02C0($a2) ## 000002C0
/* 014D8 80AFDE78 00021400 */ sll $v0, $v0, 16
/* 014DC 80AFDE7C 00021403 */ sra $v0, $v0, 16
/* 014E0 80AFDE80 24780008 */ addiu $t8, $v1, 0x0008 ## $t8 = 00000008
/* 014E4 80AFDE84 ACD802C0 */ sw $t8, 0x02C0($a2) ## 000002C0
/* 014E8 80AFDE88 AC600004 */ sw $zero, 0x0004($v1) ## 00000004
/* 014EC 80AFDE8C AC790000 */ sw $t9, 0x0000($v1) ## 00000000
/* 014F0 80AFDE90 8CC302C0 */ lw $v1, 0x02C0($a2) ## 000002C0
/* 014F4 80AFDE94 304200FF */ andi $v0, $v0, 0x00FF ## $v0 = 000000A0
/* 014F8 80AFDE98 00025600 */ sll $t2, $v0, 24
/* 014FC 80AFDE9C 00025C00 */ sll $t3, $v0, 16
/* 01500 80AFDEA0 014B6025 */ or $t4, $t2, $t3 ## $t4 = 00000000
/* 01504 80AFDEA4 00026A00 */ sll $t5, $v0, 8
/* 01508 80AFDEA8 24680008 */ addiu $t0, $v1, 0x0008 ## $t0 = 00000008
/* 0150C 80AFDEAC 018D7025 */ or $t6, $t4, $t5 ## $t6 = 00000000
/* 01510 80AFDEB0 ACC802C0 */ sw $t0, 0x02C0($a2) ## 000002C0
/* 01514 80AFDEB4 35CF00FF */ ori $t7, $t6, 0x00FF ## $t7 = 000000FF
/* 01518 80AFDEB8 3C09FB00 */ lui $t1, 0xFB00 ## $t1 = FB000000
/* 0151C 80AFDEBC AC690000 */ sw $t1, 0x0000($v1) ## 00000000
/* 01520 80AFDEC0 AC6F0004 */ sw $t7, 0x0004($v1) ## 00000004
/* 01524 80AFDEC4 8FB80048 */ lw $t8, 0x0048($sp)
/* 01528 80AFDEC8 3C0680B0 */ lui $a2, %hi(D_80AFE0F0) ## $a2 = 80B00000
/* 0152C 80AFDECC 24C6E0F0 */ addiu $a2, $a2, %lo(D_80AFE0F0) ## $a2 = 80AFE0F0
/* 01530 80AFDED0 27A40028 */ addiu $a0, $sp, 0x0028 ## $a0 = FFFFFFE0
/* 01534 80AFDED4 240703D2 */ addiu $a3, $zero, 0x03D2 ## $a3 = 000003D2
/* 01538 80AFDED8 0C031AD5 */ jal func_800C6B54
/* 0153C 80AFDEDC 8F050000 */ lw $a1, 0x0000($t8) ## 00000008
/* 01540 80AFDEE0 1000000C */ beq $zero, $zero, .L80AFDF14
/* 01544 80AFDEE4 8FBF0014 */ lw $ra, 0x0014($sp)
.L80AFDEE8:
/* 01548 80AFDEE8 10000009 */ beq $zero, $zero, .L80AFDF10
/* 0154C 80AFDEEC ACC00000 */ sw $zero, 0x0000($a2) ## 00000000
.L80AFDEF0:
/* 01550 80AFDEF0 2401000C */ addiu $at, $zero, 0x000C ## $at = 0000000C
/* 01554 80AFDEF4 14A10006 */ bne $a1, $at, .L80AFDF10
/* 01558 80AFDEF8 8FB9005C */ lw $t9, 0x005C($sp)
/* 0155C 80AFDEFC 93280283 */ lbu $t0, 0x0283($t9) ## 00000283
/* 01560 80AFDF00 31090002 */ andi $t1, $t0, 0x0002 ## $t1 = 00000000
/* 01564 80AFDF04 51200003 */ beql $t1, $zero, .L80AFDF14
/* 01568 80AFDF08 8FBF0014 */ lw $ra, 0x0014($sp)
/* 0156C 80AFDF0C ACC00000 */ sw $zero, 0x0000($a2) ## 00000000
.L80AFDF10:
/* 01570 80AFDF10 8FBF0014 */ lw $ra, 0x0014($sp)
.L80AFDF14:
/* 01574 80AFDF14 27BD0048 */ addiu $sp, $sp, 0x0048 ## $sp = 00000000
/* 01578 80AFDF18 00001025 */ or $v0, $zero, $zero ## $v0 = 00000000
/* 0157C 80AFDF1C 03E00008 */ jr $ra
/* 01580 80AFDF20 00000000 */ nop
| {
"language": "Assembly"
} |
# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py
# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -iterations=1500 -timeline -timeline-max-iterations=3 < %s | FileCheck %s
# Each lzcnt has a false dependency on %ecx; the first lzcnt has to wait on the
# imul. However, the folded load can start immediately.
# The last lzcnt has a false dependency on %cx. However, even in this case, the
# folded load can start immediately.
imul %edx, %ecx
lzcnt (%rsp), %cx
lzcnt 2(%rsp), %cx
# CHECK: Iterations: 1500
# CHECK-NEXT: Instructions: 4500
# CHECK-NEXT: Total Cycles: 4510
# CHECK-NEXT: Total uOps: 7500
# CHECK: Dispatch Width: 4
# CHECK-NEXT: uOps Per Cycle: 1.66
# CHECK-NEXT: IPC: 1.00
# CHECK-NEXT: Block RThroughput: 3.0
# CHECK: Instruction Info:
# CHECK-NEXT: [1]: #uOps
# CHECK-NEXT: [2]: Latency
# CHECK-NEXT: [3]: RThroughput
# CHECK-NEXT: [4]: MayLoad
# CHECK-NEXT: [5]: MayStore
# CHECK-NEXT: [6]: HasSideEffects (U)
# CHECK: [1] [2] [3] [4] [5] [6] Instructions:
# CHECK-NEXT: 1 3 1.00 imull %edx, %ecx
# CHECK-NEXT: 2 8 1.00 * lzcntw (%rsp), %cx
# CHECK-NEXT: 2 8 1.00 * lzcntw 2(%rsp), %cx
# CHECK: Resources:
# CHECK-NEXT: [0] - SBDivider
# CHECK-NEXT: [1] - SBFPDivider
# CHECK-NEXT: [2] - SBPort0
# CHECK-NEXT: [3] - SBPort1
# CHECK-NEXT: [4] - SBPort4
# CHECK-NEXT: [5] - SBPort5
# CHECK-NEXT: [6.0] - SBPort23
# CHECK-NEXT: [6.1] - SBPort23
# CHECK: Resource pressure per iteration:
# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6.0] [6.1]
# CHECK-NEXT: - - - 3.00 - - 1.00 1.00
# CHECK: Resource pressure by instruction:
# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6.0] [6.1] Instructions:
# CHECK-NEXT: - - - 1.00 - - - - imull %edx, %ecx
# CHECK-NEXT: - - - 1.00 - - - 1.00 lzcntw (%rsp), %cx
# CHECK-NEXT: - - - 1.00 - - 1.00 - lzcntw 2(%rsp), %cx
# CHECK: Timeline view:
# CHECK-NEXT: 012345678
# CHECK-NEXT: Index 0123456789
# CHECK: [0,0] DeeeER . . . imull %edx, %ecx
# CHECK-NEXT: [0,1] D=eeeeeeeeER . . lzcntw (%rsp), %cx
# CHECK-NEXT: [0,2] .D=eeeeeeeeER . . lzcntw 2(%rsp), %cx
# CHECK-NEXT: [1,0] .D=========eeeER . imull %edx, %ecx
# CHECK-NEXT: [1,1] . D=eeeeeeeeE--R . lzcntw (%rsp), %cx
# CHECK-NEXT: [1,2] . D==eeeeeeeeE-R . lzcntw 2(%rsp), %cx
# CHECK-NEXT: [2,0] . D==========eeeER imull %edx, %ecx
# CHECK-NEXT: [2,1] . D==eeeeeeeeE---R lzcntw (%rsp), %cx
# CHECK-NEXT: [2,2] . D==eeeeeeeeE--R lzcntw 2(%rsp), %cx
# CHECK: Average Wait times (based on the timeline view):
# CHECK-NEXT: [0]: Executions
# CHECK-NEXT: [1]: Average time spent waiting in a scheduler's queue
# CHECK-NEXT: [2]: Average time spent waiting in a scheduler's queue while ready
# CHECK-NEXT: [3]: Average time elapsed from WB until retire stage
# CHECK: [0] [1] [2] [3]
# CHECK-NEXT: 0. 3 7.3 0.3 0.0 imull %edx, %ecx
# CHECK-NEXT: 1. 3 2.3 2.3 1.7 lzcntw (%rsp), %cx
# CHECK-NEXT: 2. 3 2.7 2.7 1.0 lzcntw 2(%rsp), %cx
| {
"language": "Assembly"
} |
C = terralib.includecstring [[
#include <stdio.h>
]]
C.fopen("broken.t","r")
| {
"language": "Assembly"
} |
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2019, Michael Neuling, IBM Corporation.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#define STACK_TOP 0x60000
#define FIXUP_ENDIAN \
tdi 0,0,0x48; /* Reverse endian of b . + 8 */ \
b 191f; /* Skip trampoline if endian is good */ \
.long 0xa600607d; /* mfmsr r11 */ \
.long 0x01006b69; /* xori r11,r11,1 */ \
.long 0x05009f42; /* bcl 20,31,$+4 */ \
.long 0xa602487d; /* mflr r10 */ \
.long 0x14004a39; /* addi r10,r10,20 */ \
.long 0xa64b5a7d; /* mthsrr0 r10 */ \
.long 0xa64b7b7d; /* mthsrr1 r11 */ \
.long 0x2402004c; /* hrfid */ \
191:
/* Load an immediate 64-bit value into a register */
#define LOAD_IMM64(r, e) \
lis r,(e)@highest; \
ori r,r,(e)@higher; \
rldicr r,r, 32, 31; \
oris r,r, (e)@h; \
ori r,r, (e)@l;
.section ".head","ax"
/*
* Microwatt comes in at 0 as little endian so we do not need to worry up
* FIXUP_ENDIAN.
*/
. = 0
.global _start
_start:
b boot_entry
/* QEMU comes in at 0x10. Put a value in argc/r3 to distingush from
* microwatt. */
. = 0x10
FIXUP_ENDIAN
LOAD_IMM64(%r3, 1)
b boot_entry
.global boot_entry
boot_entry:
/* Save R3 to non-volatile register */
mr %r14, %r3
restart:
/*
* setup stack with a safety gap, since we might write to the
* previous frame.
*/
LOAD_IMM64(%r1, STACK_TOP - 0x100)
LOAD_IMM64(%r12, main)
mtctr %r12
bctrl
/* On exit, restart */
mr %r3, %r14
b restart
#define EXCEPTION(nr) \
.= nr; \
b .
/* More exception stubs */
EXCEPTION(0x300)
EXCEPTION(0x380)
EXCEPTION(0x400)
EXCEPTION(0x480)
EXCEPTION(0x500)
EXCEPTION(0x600)
EXCEPTION(0x700)
EXCEPTION(0x800)
EXCEPTION(0x900)
EXCEPTION(0x980)
EXCEPTION(0xa00)
EXCEPTION(0xb00)
EXCEPTION(0xc00)
EXCEPTION(0xd00)
EXCEPTION(0xe00)
EXCEPTION(0xe20)
EXCEPTION(0xe40)
EXCEPTION(0xe60)
EXCEPTION(0xe80)
EXCEPTION(0xf00)
EXCEPTION(0xf20)
EXCEPTION(0xf40)
EXCEPTION(0xf60)
EXCEPTION(0xf80)
EXCEPTION(0x1000)
EXCEPTION(0x1100)
EXCEPTION(0x1200)
EXCEPTION(0x1300)
EXCEPTION(0x1400)
EXCEPTION(0x1500)
EXCEPTION(0x1600)
| {
"language": "Assembly"
} |
// ACP 5.18: Shifter uses wrong shift value
# mach: bfin
.include "testutils.inc"
start
r0=0;
r0.h=0x8000;
r1=0x20 (z);
r0 >>>= r1;
dbga (r0.h, 0xffff);
dbga (r0.l, 0xffff);
r0=0;
r0.h=0x7fff;
r0 >>>= r1;
dbga (r0.h, 0x0000);
dbga (r0.l, 0x0000);
r0.l=0xffff;
r0.h=0xffff;
r0 >>= r1;
dbga (r0.h, 0x0000);
dbga (r0.l, 0x0000);
r0.l=0xffff;
r0.h=0xffff;
r0 <<= r1;
dbga (r0.h, 0x0000);
dbga (r0.l, 0x0000);
pass;
| {
"language": "Assembly"
} |
# Test the hi16/lo16 relocations
.text
.global __start
__start:
movih r1, (long_symbol) >> 16
ori r1, r1, (long_symbol) & 0xffff
| {
"language": "Assembly"
} |
#ifdef GL_ES
precision mediump float;
precision mediump int;
#endif
#define PROCESSING_TEXTURE_SHADER
uniform sampler2D texture;
uniform vec2 texOffset;
varying vec4 vertColor;
varying vec4 vertTexCoord;
void main(void) {
// Grouping texcoord variables in order to make it work in the GMA 950. See post #13
// in this thread:
// http://www.idevgames.com/forums/thread-3467.html
vec2 tc0 = vertTexCoord.st + vec2(-texOffset.s, -texOffset.t);
vec2 tc1 = vertTexCoord.st + vec2( 0.0, -texOffset.t);
vec2 tc2 = vertTexCoord.st + vec2(+texOffset.s, -texOffset.t);
vec2 tc3 = vertTexCoord.st + vec2(-texOffset.s, 0.0);
vec2 tc4 = vertTexCoord.st + vec2( 0.0, 0.0);
vec2 tc5 = vertTexCoord.st + vec2(+texOffset.s, 0.0);
vec2 tc6 = vertTexCoord.st + vec2(-texOffset.s, +texOffset.t);
vec2 tc7 = vertTexCoord.st + vec2( 0.0, +texOffset.t);
vec2 tc8 = vertTexCoord.st + vec2(+texOffset.s, +texOffset.t);
vec4 col0 = texture2D(texture, tc0);
vec4 col1 = texture2D(texture, tc1);
vec4 col2 = texture2D(texture, tc2);
vec4 col3 = texture2D(texture, tc3);
vec4 col4 = texture2D(texture, tc4);
vec4 col5 = texture2D(texture, tc5);
vec4 col6 = texture2D(texture, tc6);
vec4 col7 = texture2D(texture, tc7);
vec4 col8 = texture2D(texture, tc8);
vec4 sum = (1.0 * col0 + 2.0 * col1 + 1.0 * col2 +
2.0 * col3 + 4.0 * col4 + 2.0 * col4 +
1.0 * col5 + 2.0 * col6 + 1.0 * col7) / 16.0;
gl_FragColor = vec4(sum.rgb, 1.0) * vertColor;
}
| {
"language": "Assembly"
} |
.define Blm, Blmnp
.sect .text
.sect .rom
.sect .data
.sect .bss
.sect .text
! This subroutine copies bytes from one place in memory to
! another. The source address is in registerpair AX and is stored
! in zeropage locations ADDR and ADDR+1.
! The destination address is popped from the stack and stored in
! zeropage locations ADDR+2 and ADDR+3.
! The number of bytes to be copied is in register Y (lowbyte) and
! zeropage location NBYTES+1 (highbyte).
! The subroutine Blmnp is used when the source and destination
! addresses are already in zeropage.
Blm:
stx ADDR+2 ! source address (lowbyte)
sta ADDR+3 ! source address (highbyte)
jsr Pop
stx ADDR ! destination address (lowbyte)
sta ADDR+1 ! destination address (highbyte)
Blmnp: ldx NBYTES+1
1: dey
lda (ADDR),y ! get source byte
sta (ADDR+2),y ! copy to destination
tya
bne 1b
dec ADDR+1 ! 256 bytes copied
dec ADDR+3 ! decrement source and destination address
ldy #0
dex
bne 1b ! do it n times
rts
| {
"language": "Assembly"
} |
add pipe_filter_tbl 0 key.headers_ipv4_srcAddr:0x01020304 pipe_set_ipv4_version(version:0x6)
add pipe_filter_tbl 0 key.headers_ipv4_srcAddr:0x01020305 pipe_set_ihl(ihl:0x3)
add pipe_filter_tbl 0 key.headers_ipv4_srcAddr:0x01020306 pipe_set_diffserv(diffserv:0x1)
add pipe_filter_tbl 0 key.headers_ipv4_srcAddr:0x01020307 pipe_set_identification(identification:0x0011)
add pipe_filter_tbl 0 key.headers_ipv4_srcAddr:0x01020308 pipe_set_flags(flags:0x3)
add pipe_filter_tbl 0 key.headers_ipv4_srcAddr:0x01020309 pipe_set_fragOffset(fragOffset:0x1)
add pipe_filter_tbl 0 key.headers_ipv4_srcAddr:0x0102030a pipe_set_ttl(ttl:63)
add pipe_filter_tbl 0 key.headers_ipv4_srcAddr:0x0102030b pipe_set_protocol(protocol:0x5)
add pipe_filter_tbl 0 key.headers_ipv4_srcAddr:0x0102030c pipe_set_srcAddr(srcAddr:0xffffffff)
add pipe_filter_tbl 0 key.headers_ipv4_srcAddr:0x0102030d pipe_set_dstAddr(dstAddr:0xffffffff)
add pipe_filter_tbl 0 key.headers_ipv4_srcAddr:0x0102030e pipe_set_srcAddr_dstAddr(srcAddr:0xffffffff,dstAddr:0xffffffff)
packet 0 00000000 00000000 00000000 00000000 00000000 ABCDEF01
expect 0 00000000 00000000 00000000 00000000 00000000 ABCDEF01
packet 0 001b1700 0130b881 98b7aeb7 08004500 00344a6f 40004011 49fe0102 03040a01 9845cf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
expect 0 001b1700 0130b881 98b7aeb7 08006500 00344a6f 40004011 49fe0102 03040a01 9845cf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
packet 0 00000000 00000000 00000000 00000000 00000000 ABCDEF01
expect 0 00000000 00000000 00000000 00000000 00000000 ABCDEF01
packet 0 001b1700 0130b881 98b7aeb7 08004500 00344a6f 40004011 49fe0102 03050a01 9845cf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
expect 0 001b1700 0130b881 98b7aeb7 08004300 00344a6f 40004011 49fe0102 03050a01 9845cf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
packet 0 00000000 00000000 00000000 00000000 00000000 ABCDEF01
expect 0 00000000 00000000 00000000 00000000 00000000 ABCDEF01
packet 0 001b1700 0130b881 98b7aeb7 08004500 00344a6f 40004011 49fe0102 03060a01 9845cf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
expect 0 001b1700 0130b881 98b7aeb7 08004501 00344a6f 40004011 49fe0102 03060a01 9845cf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
packet 0 001b1700 0130b881 98b7aeb7 08004500 00344a6f 40004011 49fe0102 03070a01 9845cf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
expect 0 001b1700 0130b881 98b7aeb7 08004500 00340011 40004011 49fe0102 03070a01 9845cf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
packet 0 001b1700 0130b881 98b7aeb7 08004500 00344a6f 40004011 49fe0102 03080a01 9845cf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
expect 0 001b1700 0130b881 98b7aeb7 08004500 00344a6f 60004011 49fe0102 03080a01 9845cf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
packet 0 001b1700 0130b881 98b7aeb7 08004500 00344a6f 40004011 49fe0102 03090a01 9845cf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
expect 0 001b1700 0130b881 98b7aeb7 08004500 00344a6f 40014011 49fe0102 03090a01 9845cf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
packet 0 001b1700 0130b881 98b7aeb7 08004500 00344a6f 40004011 49fe0102 030a0a01 9845cf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
expect 0 001b1700 0130b881 98b7aeb7 08004500 00344a6f 40003f11 49fe0102 030a0a01 9845cf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
packet 0 001b1700 0130b881 98b7aeb7 08004500 00344a6f 40004011 49fe0102 030b0a01 9845cf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
expect 0 001b1700 0130b881 98b7aeb7 08004500 00344a6f 40004005 49fe0102 030b0a01 9845cf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
packet 0 001b1700 0130b881 98b7aeb7 08004500 00344a6f 40004011 49fe0102 030c0a01 9845cf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
expect 0 001b1700 0130b881 98b7aeb7 08004500 00344a6f 40004011 49feffff ffff0a01 9845cf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
packet 0 001b1700 0130b881 98b7aeb7 08004500 00344a6f 40004011 49fe0102 030d0a01 9845cf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
expect 0 001b1700 0130b881 98b7aeb7 08004500 00344a6f 40004011 49fe0102 030dffff ffffcf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
packet 0 001b1700 0130b881 98b7aeb7 08004500 00344a6f 40004011 49fe0102 030e0a01 9845cf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
expect 0 001b1700 0130b881 98b7aeb7 08004500 00344a6f 40004011 49feffff ffffffff ffffcf2c 04000020 26e74ccc b2ac8010 0353c314 00000101 080a0192 463911a0 c06f
| {
"language": "Assembly"
} |
;
; Copyright (c) 2008-2012 Stefan Krah. 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 AUTHOR 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 AUTHOR 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.
;
PUBLIC _mpd_div_words
_TEXT SEGMENT
q$ = 8
r$ = 16
hi$ = 24
lo$ = 32
d$ = 40
_mpd_div_words PROC
mov r10, rdx
mov rdx, r8
mov rax, r9
div QWORD PTR d$[rsp]
mov QWORD PTR [r10], rdx
mov QWORD PTR [rcx], rax
ret 0
_mpd_div_words ENDP
_TEXT ENDS
END
| {
"language": "Assembly"
} |
; Test that we can inline a simple function, turning the calls in it into invoke
; instructions
; RUN: opt < %s -inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
declare void @might_throw()
define internal void @callee() {
entry:
call void @might_throw()
ret void
}
; caller returns true if might_throw throws an exception...
define i32 @caller() personality i32 (...)* @__gxx_personality_v0 {
; CHECK-LABEL: define i32 @caller() personality i32 (...)* @__gxx_personality_v0
entry:
invoke void @callee()
to label %cont unwind label %exc
; CHECK-NOT: @callee
; CHECK: invoke void @might_throw()
cont:
ret i32 0
exc:
%exn = landingpad {i8*, i32}
cleanup
ret i32 1
}
declare i32 @__gxx_personality_v0(...)
| {
"language": "Assembly"
} |
/*
Description: Foundation 4 docs style for highlight.js
Author: Dan Allen <dan.j.allen@gmail.com>
Website: http://foundation.zurb.com/docs/
Version: 1.0
Date: 2013-04-02
*/
.highlight
color: black
background: #eee
.code
.link,
.emphasis,
.attribute,
.addition
color: #070
.emphasis
font-style: italic
.strong,
.string,
.deletion
color: #d14
.strong
font-weight: bold
.quote,
.comment
color: #998
font-style: italic
.section,
.title
color: #900
.class .title,
.type
color: #458
.variable,
.template-variable
color: #336699
.bullet
color: #997700
.meta
color: #3344bb
.code,
.number,
.literal,
.keyword,
.selector-tag
color: #099
.regexp
background-color: #fff0ff
color: #880088
.symbol
color: #990073
.tag,
.name,
.selector-id,
.selector-class
color: #007700
| {
"language": "Assembly"
} |
; vim: ft=nasm
section .text
global _start
_start:
nop
.gai_s:
mov ah, 0x1
not ah
mov ch, 0x1
not ch
mov bh, 0x1
not bh
mov dh, 0x1
not dh
mov al, 0x1
not al
mov cl, 0x1
not cl
mov bl, 0x1
not bl
mov dl, 0x1
not dl
mov ah, 0x2
not ah
mov ch, 0x1
not ch
mov bh, 0x1
not bh
mov dh, 0x0
not dh
mov ah, 0x2
not ah
mov ch, 0x1
not ch
mov bh, 0x1
not bh
mov dh, 0x0
not dh
.gai_e:
mov eax,1
mov ebx,0
int 80H
| {
"language": "Assembly"
} |
dnl Copyright © 2003-2007 Keith Packard, Daniel Stone
dnl
dnl Permission is hereby granted, free of charge, to any person obtaining a
dnl copy of this software and associated documentation files (the "Software"),
dnl to deal in the Software without restriction, including without limitation
dnl the rights to use, copy, modify, merge, publish, distribute, sublicense,
dnl and/or sell copies of the Software, and to permit persons to whom the
dnl Software is furnished to do so, subject to the following conditions:
dnl
dnl The above copyright notice and this permission notice (including the next
dnl paragraph) shall be included in all copies or substantial portions of the
dnl Software.
dnl
dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
dnl IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
dnl FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
dnl THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
dnl LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
dnl FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
dnl DEALINGS IN THE SOFTWARE.
dnl
dnl Authors: Keith Packard <keithp@keithp.com>
dnl Daniel Stone <daniel@fooishbar.org>
dnl an unwitting cast of miscellaneous others
dnl
dnl Process this file with autoconf to create configure.
AC_PREREQ(2.60)
AC_INIT([xorg-server], 1.20.99.1, [https://gitlab.freedesktop.org/xorg/xserver/issues], xorg-server)
RELEASE_DATE="2018-05-14"
RELEASE_NAME="Carrot and Ginger Soup"
AC_CONFIG_SRCDIR([Makefile.am])
AC_CONFIG_MACRO_DIR([m4])
AM_INIT_AUTOMAKE([foreign dist-bzip2])
AC_USE_SYSTEM_EXTENSIONS
# Require xorg-macros minimum of 1.14 for XORG_COMPILER_BRAND in XORG_DEFAULT_OPTIONS
m4_ifndef([XORG_MACROS_VERSION],
[m4_fatal([must install xorg-macros 1.14 or later before running autoconf/autogen])])
XORG_MACROS_VERSION(1.14)
XORG_DEFAULT_OPTIONS
XORG_WITH_DOXYGEN(1.6.1)
XORG_CHECK_SGML_DOCTOOLS(1.8)
XORG_ENABLE_DOCS
XORG_ENABLE_DEVEL_DOCS
XORG_WITH_XMLTO(0.0.20)
XORG_WITH_FOP
XORG_WITH_XSLTPROC
XORG_ENABLE_UNIT_TESTS
XORG_LD_WRAP([optional])
m4_ifndef([XORG_FONT_MACROS_VERSION], [m4_fatal([must install font-util 1.1 or later before running autoconf/autogen])])
XORG_FONT_MACROS_VERSION(1.1)
dnl this gets generated by autoheader, and thus contains all the defines. we
dnl don't ever actually use it, internally.
AC_CONFIG_HEADERS(include/do-not-use-config.h)
dnl xorg-server.h is an external header, designed to be included by loadable
dnl drivers.
AC_CONFIG_HEADERS(include/xorg-server.h)
dnl dix-config.h covers most of the DIX (i.e. everything but the DDX, not just
dnl dix/).
AC_CONFIG_HEADERS(include/dix-config.h)
dnl xorg-config.h covers the Xorg DDX.
AC_CONFIG_HEADERS(include/xorg-config.h)
dnl xkb-config.h covers XKB for the Xorg and Xnest DDXs.
AC_CONFIG_HEADERS(include/xkb-config.h)
dnl xwin-config.h covers the XWin DDX.
AC_CONFIG_HEADERS(include/xwin-config.h)
dnl xwayland-config.h covers Xwayland.
AC_CONFIG_HEADERS(include/xwayland-config.h)
dnl version-config.h covers the version numbers so they can be bumped without
dnl forcing an entire recompile.x
AC_CONFIG_HEADERS(include/version-config.h)
AM_PROG_AS
AC_PROG_LN_S
LT_PREREQ([2.2])
LT_INIT([disable-static win32-dll])
PKG_PROG_PKG_CONFIG
AC_PROG_LEX
AC_PROG_YACC
AC_SYS_LARGEFILE
XORG_PROG_RAWCPP
# Quoted so that make will expand $(CWARNFLAGS) in makefiles to allow
# easier overrides at build time.
XSERVER_CFLAGS='$(CWARNFLAGS)'
dnl Explicitly add -fno-strict-aliasing since this option should disappear
dnl from util-macros CWARNFLAGS
if test "x$GCC" = xyes ; then
XSERVER_CFLAGS="$XSERVER_CFLAGS -fno-strict-aliasing"
fi
dnl Check for dtrace program (needed to build Xserver dtrace probes)
dnl Also checks for <sys/sdt.h>, since some Linux distros have an
dnl ISDN trace program named dtrace
AC_ARG_WITH(dtrace, AS_HELP_STRING([--with-dtrace=PATH],
[Enable dtrace probes (default: enabled if dtrace found)]),
[WDTRACE=$withval], [WDTRACE=auto])
if test "x$WDTRACE" = "xyes" -o "x$WDTRACE" = "xauto" ; then
AC_PATH_PROG(DTRACE, [dtrace], [not_found], [$PATH:/usr/sbin])
if test "x$DTRACE" = "xnot_found" ; then
if test "x$WDTRACE" = "xyes" ; then
AC_MSG_FAILURE([dtrace requested but not found])
fi
WDTRACE="no"
else
AC_CHECK_HEADER(sys/sdt.h, [HAS_SDT_H="yes"], [HAS_SDT_H="no"])
if test "x$WDTRACE" = "xauto" -a "x$HAS_SDT_H" = "xno" ; then
WDTRACE="no"
fi
fi
fi
if test "x$WDTRACE" != "xno" ; then
AC_DEFINE(XSERVER_DTRACE, 1,
[Define to 1 if the DTrace Xserver provider probes should be built in.])
# Solaris/OpenSolaris require dtrace -G to build dtrace probe information into
# object files, and require linking with those as relocatable objects, not .a
# archives. MacOS X handles all this in the normal compiler toolchain, and on
# some releases (like Tiger), will error out on dtrace -G. For now, other
# platforms with Dtrace ports are assumed to support -G (the FreeBSD and Linux
# ports appear to, based on my web searches, but have not yet been tested).
case $host_os in
darwin*) SPECIAL_DTRACE_OBJECTS=no ;;
*) SPECIAL_DTRACE_OBJECTS=yes ;;
esac
fi
AM_CONDITIONAL(XSERVER_DTRACE, [test "x$WDTRACE" != "xno"])
AM_CONDITIONAL(SPECIAL_DTRACE_OBJECTS, [test "x$SPECIAL_DTRACE_OBJECTS" = "xyes"])
AC_HEADER_DIRENT
AC_HEADER_STDC
AC_CHECK_HEADERS([fcntl.h stdlib.h string.h unistd.h dlfcn.h stropts.h \
fnmatch.h sys/mkdev.h sys/sysmacros.h sys/utsname.h])
dnl Checks for typedefs, structures, and compiler characteristics.
AC_C_CONST
AC_C_TYPEOF
AC_C_BIGENDIAN(AC_DEFINE(X_BYTE_ORDER, X_BIG_ENDIAN, [byte order]),
AC_DEFINE(X_BYTE_ORDER, X_LITTLE_ENDIAN, [byte order]))
AC_CHECK_SIZEOF([unsigned long])
if test "$ac_cv_sizeof_unsigned_long" = 8; then
AC_DEFINE(_XSERVER64, 1, [Define to 1 if unsigned long is 64 bits.])
fi
AC_TYPE_PID_T
dnl Check to see if dlopen is in default libraries (like Solaris, which
dnl has it in libc), or if libdl is needed to get it.
AC_CHECK_FUNC([dlopen], [],
AC_CHECK_LIB([dl], [dlopen], DLOPEN_LIBS="-ldl"))
AC_SUBST(DLOPEN_LIBS)
dnl Checks for library functions.
AC_CHECK_FUNCS([backtrace geteuid getuid issetugid getresuid \
getdtablesize getifaddrs getpeereid getpeerucred getprogname getzoneid \
mmap posix_fallocate seteuid shmctl64 strncasecmp vasprintf vsnprintf \
walkcontext setitimer poll epoll_create1 mkostemp memfd_create \
sigprocmask])
AC_CONFIG_LIBOBJ_DIR([os])
AC_REPLACE_FUNCS([reallocarray strcasecmp strcasestr strlcat strlcpy strndup\
timingsafe_memcmp])
AM_CONDITIONAL(POLL, [test "x$ac_cv_func_poll" = "xyes"])
AC_CHECK_LIB([bsd], [arc4random_buf])
AC_CHECK_FUNCS([arc4random_buf])
AC_CHECK_DECLS([program_invocation_short_name], [], [], [[#include <errno.h>]])
dnl Check for SO_PEERCRED #define
AC_CACHE_CHECK([for SO_PEERCRED in sys/socket.h],
[xorg_cv_sys_have_so_peercred],
[AC_EGREP_CPP(yes_have_so_peercred,[
#include <sys/types.h>
#include <sys/socket.h>
#ifdef SO_PEERCRED
yes_have_so_peercred
#endif
],
[xorg_cv_sys_have_so_peercred=yes],
[xorg_cv_sys_have_so_peercred=no])])
dnl define NO_LOCAL_CLIENT_CRED if no getpeereid, getpeerucred or SO_PEERCRED
if test "x$ac_cv_func_getpeereid" = xno && test "x$ac_cv_func_getpeerucred" = xno && test "x$xorg_cv_sys_have_so_peercred" = xno ; then
AC_DEFINE([NO_LOCAL_CLIENT_CRED], 1, [Define to 1 if no local socket credentials interface exists])
fi
dnl Find the math libary, then check for cbrt function in it.
AC_CHECK_LIB(m, sqrt)
AC_CHECK_FUNCS([cbrt])
dnl AGPGART headers
AC_ARG_ENABLE(agp, AS_HELP_STRING([--enable-agp],
[Enable AGP support (default: auto)]),
[AGP=$enableval], [AGP=auto])
if test "x$AGP" = "xauto" ; then
AC_CHECK_HEADERS([linux/agpgart.h sys/agpio.h sys/agpgart.h], AGP=yes)
fi
AM_CONDITIONAL(AGP, [test "x$AGP" = xyes])
dnl fbdev header
AC_CHECK_HEADERS([linux/fb.h], FBDEV=yes)
AM_CONDITIONAL(FBDEVHW, [test "x$FBDEV" = xyes])
dnl FreeBSD kldload support (sys/linker.h)
AC_CHECK_HEADERS([sys/linker.h],
[ac_cv_sys_linker_h=yes],
[ac_cv_sys_linker_h=no],
[#include <sys/param.h>])
AM_CONDITIONAL(FREEBSD_KLDLOAD, [test "x$ac_cv_sys_linker_h" = xyes])
AC_CACHE_CHECK([for SYSV IPC],
ac_cv_sysv_ipc,
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/stat.h>
]],[[
{
int id;
id = shmget(IPC_PRIVATE, 512, S_IRUSR | S_IWUSR);
if (id < 0) return -1;
return shmctl(id, IPC_RMID, 0);
}]])],
[ac_cv_sysv_ipc=yes],
[ac_cv_sysv_ipc=no])])
if test "x$ac_cv_sysv_ipc" = xyes; then
AC_DEFINE(HAVE_SYSV_IPC, 1, [Define to 1 if SYSV IPC is available])
fi
dnl OpenBSD /dev/xf86 aperture driver
if test -c /dev/xf86 ; then
AC_DEFINE(HAS_APERTURE_DRV, 1, [System has /dev/xf86 aperture driver])
fi
dnl BSD APM support
AC_CHECK_HEADER([machine/apmvar.h],[
AC_CHECK_HEADER([sys/event.h],
ac_cv_BSD_KQUEUE_APM=yes,
ac_cv_BSD_APM=yes)])
AM_CONDITIONAL(BSD_APM, [test "x$ac_cv_BSD_APM" = xyes])
AM_CONDITIONAL(BSD_KQUEUE_APM, [test "x$ac_cv_BSD_KQUEUE_APM" = xyes])
dnl glibc backtrace support check
AC_CHECK_HEADER([execinfo.h],[
AC_CHECK_LIB(c, backtrace, [
AC_DEFINE(HAVE_BACKTRACE, 1, [Has backtrace support])
AC_DEFINE(HAVE_EXECINFO_H, 1, [Have execinfo.h])
])]
)
dnl ---------------------------------------------------------------------------
dnl Bus options and CPU capabilities. Replaces logic in
dnl hw/xfree86/os-support/bus/Makefile.am, among others.
dnl ---------------------------------------------------------------------------
DEFAULT_INT10="x86emu"
dnl Override defaults as needed for specific platforms:
case $host_cpu in
alpha*)
ALPHA_VIDEO=yes
case $host_os in
*freebsd*) SYS_LIBS=-lio ;;
*netbsd*) AC_DEFINE(USE_ALPHA_PIO, 1, [NetBSD PIO alpha IO]) ;;
esac
GLX_ARCH_DEFINES="-D__GLX_ALIGN64 -mieee"
;;
arm*)
ARM_VIDEO=yes
DEFAULT_INT10="stub"
;;
i*86)
I386_VIDEO=yes
case $host_os in
*freebsd*) AC_DEFINE(USE_DEV_IO) ;;
*dragonfly*) AC_DEFINE(USE_DEV_IO) ;;
*netbsd*) AC_DEFINE(USE_I386_IOPL)
SYS_LIBS=-li386
;;
*openbsd*) AC_DEFINE(USE_I386_IOPL)
SYS_LIBS=-li386
;;
esac
;;
powerpc*)
PPC_VIDEO=yes
case $host_os in
*freebsd*) DEFAULT_INT10=stub ;;
esac
;;
sparc*)
SPARC64_VIDEO=yes
BSD_ARCH_SOURCES="sparc64_video.c ioperm_noop.c"
GLX_ARCH_DEFINES="-D__GLX_ALIGN64"
;;
x86_64*|amd64*)
I386_VIDEO=yes
case $host_os in
*freebsd*) AC_DEFINE(USE_DEV_IO, 1, [BSD /dev/io]) ;;
*dragonfly*) AC_DEFINE(USE_DEV_IO, 1, [BSD /dev/io]) ;;
*netbsd*) AC_DEFINE(USE_I386_IOPL, 1, [BSD i386 iopl])
SYS_LIBS=-lx86_64
;;
*openbsd*) AC_DEFINE(USE_AMD64_IOPL, 1, [BSD AMD64 iopl])
SYS_LIBS=-lamd64
;;
esac
GLX_ARCH_DEFINES="-D__GLX_ALIGN64"
;;
ia64*)
GLX_ARCH_DEFINES="-D__GLX_ALIGN64"
;;
s390*)
GLX_ARCH_DEFINES="-D__GLX_ALIGN64"
;;
esac
AC_SUBST(GLX_ARCH_DEFINES)
dnl BSD *_video.c selection
AM_CONDITIONAL(ALPHA_VIDEO, [test "x$ALPHA_VIDEO" = xyes])
AM_CONDITIONAL(ARM_VIDEO, [test "x$ARM_VIDEO" = xyes])
AM_CONDITIONAL(I386_VIDEO, [test "x$I386_VIDEO" = xyes])
AM_CONDITIONAL(PPC_VIDEO, [test "x$PPC_VIDEO" = xyes])
AM_CONDITIONAL(SPARC64_VIDEO, [test "x$SPARC64_VIDEO" = xyes])
DRI=no
dnl it would be nice to autodetect these *CONS_SUPPORTs
case $host_os in
*freebsd* | *dragonfly*)
case $host_os in
kfreebsd*-gnu) ;;
*) AC_DEFINE(CSRG_BASED, 1, [System is BSD-like]) ;;
esac
AC_DEFINE(PCCONS_SUPPORT, 1, [System has PC console])
AC_DEFINE(PCVT_SUPPORT, 1, [System has PCVT console])
AC_DEFINE(SYSCONS_SUPPORT, 1, [System has syscons console])
DRI=yes
;;
*netbsd*)
AC_DEFINE(CSRG_BASED, 1, [System is BSD-like])
AC_DEFINE(PCCONS_SUPPORT, 1, [System has PC console])
AC_DEFINE(PCVT_SUPPORT, 1, [System has PCVT console])
AC_DEFINE(WSCONS_SUPPORT, 1, [System has wscons console])
DRI=yes
;;
*openbsd*)
AC_DEFINE(CSRG_BASED, 1, [System is BSD-like])
AC_DEFINE(PCVT_SUPPORT, 1, [System has PC console])
AC_DEFINE(WSCONS_SUPPORT, 1, [System has wscons console])
;;
*linux*)
DRI=yes
;;
*solaris*)
DRI=yes
;;
darwin*)
AC_DEFINE(CSRG_BASED, 1, [System is BSD-like])
;;
cygwin*|mingw*)
CFLAGS="$CFLAGS -DFD_SETSIZE=512"
;;
esac
dnl augment XORG_RELEASE_VERSION for our snapshot number and to expose the
dnl major number
PVMAJOR=`echo $PACKAGE_VERSION | cut -d . -f 1`
PVS=`echo $PACKAGE_VERSION | cut -d . -f 4 | cut -d - -f 1`
if test "x$PVS" = "x"; then
PVS="0"
fi
VENDOR_RELEASE="((($PVMAJOR) * 10000000) + (($PVM) * 100000) + (($PVP) * 1000) + $PVS)"
VENDOR_MAN_VERSION="Version ${PACKAGE_VERSION}"
VENDOR_NAME="The X.Org Foundation"
VENDOR_NAME_SHORT="X.Org"
VENDOR_WEB="http://wiki.x.org"
dnl Build options.
AC_ARG_ENABLE(werror, AS_HELP_STRING([--enable-werror],
[Obsolete - use --enable-strict-compilation instead]),
AC_MSG_ERROR([--enable-werror has been replaced by --enable-strict-compilation]))
AC_ARG_ENABLE(debug, AS_HELP_STRING([--enable-debug],
[Enable debugging (default: disabled)]),
[DEBUGGING=$enableval], [DEBUGGING=no])
AC_ARG_WITH(int10, AS_HELP_STRING([--with-int10=BACKEND], [int10 backend: vm86, x86emu or stub]),
[INT10="$withval"],
[INT10="$DEFAULT_INT10"])
AC_ARG_WITH(vendor-name, AS_HELP_STRING([--with-vendor-name=VENDOR],
[Vendor string reported by the server]),
[ VENDOR_NAME="$withval" ], [])
AC_ARG_WITH(vendor-name-short, AS_HELP_STRING([--with-vendor-name-short=VENDOR],
[Short version of vendor string reported by the server]),
[ VENDOR_NAME_SHORT="$withval" ], [])
AC_ARG_WITH(vendor-web, AS_HELP_STRING([--with-vendor-web=URL],
[Vendor web address reported by the server]),
[ VENDOR_WEB="$withval" ], [])
AC_ARG_WITH(module-dir, AS_HELP_STRING([--with-module-dir=DIR],
[Directory where modules are installed (default: $libdir/xorg/modules)]),
[ moduledir="$withval" ],
[ moduledir="${libdir}/xorg/modules" ])
AC_ARG_WITH(log-dir, AS_HELP_STRING([--with-log-dir=DIR],
[Directory where log files are kept (default: $localstatedir/log)]),
[ logdir="$withval" ],
[ logdir="$localstatedir/log" ])
AC_ARG_WITH(builder-addr, AS_HELP_STRING([--with-builder-addr=ADDRESS],
[Builder address (default: xorg@lists.freedesktop.org)]),
[ BUILDERADDR="$withval" ],
[ BUILDERADDR="xorg@lists.freedesktop.org" ])
AC_ARG_WITH(builderstring, AS_HELP_STRING([--with-builderstring=BUILDERSTRING], [Additional builder string]),
[ BUILDERSTRING="$withval" ]
[ ])
AC_ARG_ENABLE(listen-tcp, AS_HELP_STRING([--enable-listen-tcp],
[Listen on TCP by default (default:disabled)]),
[LISTEN_TCP=$enableval], [LISTEN_TCP=no])
AC_ARG_ENABLE(listen-unix, AS_HELP_STRING([--disable-listen-unix],
[Listen on Unix by default (default:enabled)]),
[LISTEN_UNIX=$enableval], [LISTEN_UNIX=yes])
AC_ARG_ENABLE(listen-local, AS_HELP_STRING([--disable-listen-local],
[Listen on local by default (default:enabled)]),
[LISTEN_LOCAL=$enableval], [LISTEN_LOCAL=yes])
case $host_os in
linux*)
FALLBACK_INPUT_DRIVER="libinput"
;;
*)
FALLBACK_INPUT_DRIVER=""
;;
esac
AC_ARG_WITH(fallback-input-driver,
AC_HELP_STRING([--with-fallback-input-driver=$FALLBACK_INPUT_DRIVER],
[Input driver fallback if the requested driver for a device is unavailable]),
[ FALLBACK_INPUT_DRIVER=$withval ], [])
if test "x$FALLBACK_INPUT_DRIVER" = "xno"; then
FALLBACK_INPUT_DRIVER=""
fi
AC_MSG_CHECKING([for fallback input driver])
AC_MSG_RESULT([$FALLBACK_INPUT_DRIVER])
AC_DEFINE_UNQUOTED(FALLBACK_INPUT_DRIVER, ["$FALLBACK_INPUT_DRIVER"], [ Fallback input driver ])
dnl Determine font path
XORG_FONTROOTDIR
XORG_FONTSUBDIR(FONTMISCDIR, fontmiscdir, misc)
XORG_FONTSUBDIR(FONTOTFDIR, fontotfdir, OTF)
XORG_FONTSUBDIR(FONTTTFDIR, fontttfdir, TTF)
XORG_FONTSUBDIR(FONTTYPE1DIR, fonttype1dir, Type1)
XORG_FONTSUBDIR(FONT75DPIDIR, font75dpidir, 75dpi)
XORG_FONTSUBDIR(FONT100DPIDIR, font100dpidir, 100dpi)
dnl Uses --with-default-font-path if set, otherwise uses standard
dnl subdirectories of FONTROOTDIR. Some distros set the default font path to
dnl "catalogue:/etc/X11/fontpath.d,built-ins"
DEFAULT_FONT_PATH="${FONTMISCDIR}/,${FONTTTFDIR}/,${FONTOTFDIR}/,${FONTTYPE1DIR}/,${FONT100DPIDIR}/,${FONT75DPIDIR}/"
case $host_os in
darwin*) DEFAULT_FONT_PATH="${DEFAULT_FONT_PATH},/Library/Fonts,/System/Library/Fonts" ;;
esac
AC_ARG_WITH(default-font-path, AS_HELP_STRING([--with-default-font-path=PATH], [Comma separated list of font dirs]),
[ FONTPATH="$withval" ],
[ FONTPATH="${DEFAULT_FONT_PATH}" ])
AC_MSG_CHECKING([for default font path])
AC_MSG_RESULT([$FONTPATH])
AC_ARG_WITH(xkb-path, AS_HELP_STRING([--with-xkb-path=PATH], [Path to XKB base dir (default: auto)]),
[ XKBPATH="$withval" ],
[ XKBPATH="auto" ])
AC_ARG_WITH(xkb-output, AS_HELP_STRING([--with-xkb-output=PATH], [Path to XKB output dir (default: ${datadir}/X11/xkb/compiled)]),
[ XKBOUTPUT="$withval" ],
[ XKBOUTPUT="compiled" ])
AC_ARG_WITH(default-xkb-rules, AS_HELP_STRING([--with-default-xkb-rules=RULES],
[Keyboard ruleset (default: base/evdev)]),
[ XKB_DFLT_RULES="$withval" ],
[ XKB_DFLT_RULES="" ])
AC_ARG_WITH(default-xkb-model, AS_HELP_STRING([--with-default-xkb-model=MODEL],
[Keyboard model (default: pc105)]),
[ XKB_DFLT_MODEL="$withval" ],
[ XKB_DFLT_MODEL="pc105" ])
AC_ARG_WITH(default-xkb-layout, AS_HELP_STRING([--with-default-xkb-layout=LAYOUT],
[Keyboard layout (default: us)]),
[ XKB_DFLT_LAYOUT="$withval" ],
[ XKB_DFLT_LAYOUT="us" ])
AC_ARG_WITH(default-xkb-variant, AS_HELP_STRING([--with-default-xkb-variant=VARIANT],
[Keyboard variant (default: (none))]),
[ XKB_DFLT_VARIANT="$withval" ],
[ XKB_DFLT_VARIANT="" ])
AC_ARG_WITH(default-xkb-options, AS_HELP_STRING([--with-default-xkb-options=OPTIONS],
[Keyboard layout options (default: (none))]),
[ XKB_DFLT_OPTIONS="$withval" ],
[ XKB_DFLT_OPTIONS="" ])
AC_ARG_WITH(serverconfig-path, AS_HELP_STRING([--with-serverconfig-path=PATH],
[Directory where ancillary server config files are installed (default: ${libdir}/xorg)]),
[ SERVERCONFIG="$withval" ],
[ SERVERCONFIG="${libdir}/xorg" ])
AC_ARG_WITH(apple-applications-dir,AS_HELP_STRING([--with-apple-applications-dir=PATH], [Path to the Applications directory (default: /Applications/Utilities)]),
[ APPLE_APPLICATIONS_DIR="${withval}" ],
[ APPLE_APPLICATIONS_DIR="/Applications/Utilities" ])
AC_SUBST([APPLE_APPLICATIONS_DIR])
AC_ARG_WITH(apple-application-name,AS_HELP_STRING([--with-apple-application-name=NAME], [Name for the .app (default: X11)]),
[ APPLE_APPLICATION_NAME="${withval}" ],
[ APPLE_APPLICATION_NAME="X11" ])
AC_SUBST([APPLE_APPLICATION_NAME])
AC_ARG_WITH(bundle-id-prefix, AS_HELP_STRING([--with-bundle-id-prefix=RDNS_PREFIX], [Prefix to use for bundle identifiers (default: org.x)]),
[ BUNDLE_ID_PREFIX="${withval}" ])
AC_SUBST([BUNDLE_ID_PREFIX])
AC_DEFINE_UNQUOTED(BUNDLE_ID_PREFIX, "$BUNDLE_ID_PREFIX", [Prefix to use for bundle identifiers])
m4_define(DEFAULT_BUNDLE_VERSION, m4_esyscmd([echo ]AC_PACKAGE_VERSION[ | cut -f1-3 -d. | tr -d '\n']))
AC_ARG_WITH(bundle-version, AS_HELP_STRING([--with-bundle-version=VERSION], [Version to use for X11.app's CFBundleVersion (default: ]DEFAULT_BUNDLE_VERSION[)]),
[ BUNDLE_VERSION="${withval}" ],
[ BUNDLE_VERSION="DEFAULT_BUNDLE_VERSION" ])
AC_SUBST([BUNDLE_VERSION])
AC_ARG_WITH(bundle-version-string, AS_HELP_STRING([--with-bundle-version-string=VERSION], [Version to use for X11.app's CFBundleShortVersionString (default: ]AC_PACKAGE_VERSION[)]),
[ BUNDLE_VERSION_STRING="${withval}" ],
[ BUNDLE_VERSION_STRING="${PACKAGE_VERSION}" ])
AC_SUBST([BUNDLE_VERSION_STRING])
AC_ARG_ENABLE(sparkle,AS_HELP_STRING([--enable-sparkle], [Enable updating of X11.app using the Sparkle Framework (default: disabled)]),
[ XQUARTZ_SPARKLE="${enableval}" ],
[ XQUARTZ_SPARKLE="no" ])
AC_SUBST([XQUARTZ_SPARKLE])
AC_ARG_WITH(sparkle-feed-url, AS_HELP_STRING([--with-sparkle-feed-url=URL], [URL for the Sparkle feed (default: https://www.xquartz.org/releases/sparkle/release.xml)]),
[ XQUARTZ_SPARKLE_FEED_URL="${withval}" ],
[ XQUARTZ_SPARKLE_FEED_URL="https://www.xquartz.org/releases/sparkle/release.xml" ])
AC_SUBST([XQUARTZ_SPARKLE_FEED_URL])
AC_ARG_ENABLE(visibility, AS_HELP_STRING([--enable-visibility], [Enable symbol visibility (default: auto)]),
[SYMBOL_VISIBILITY=$enableval],
[SYMBOL_VISIBILITY=auto])
dnl GLX build options
AC_ARG_WITH(khronos-spec-dir, AS_HELP_STRING([--with-khronos-spec-dir=PATH], [Path to Khronos OpenGL registry database files (default: auto)]),
[KHRONOS_SPEC_DIR="${withval}"],
[KHRONOS_SPEC_DIR=auto])
dnl Extensions.
AC_ARG_ENABLE(composite, AS_HELP_STRING([--disable-composite], [Build Composite extension (default: enabled)]), [COMPOSITE=$enableval], [COMPOSITE=yes])
AC_ARG_ENABLE(mitshm, AS_HELP_STRING([--disable-mitshm], [Build SHM extension (default: auto)]), [MITSHM=$enableval], [MITSHM=auto])
AC_ARG_ENABLE(xres, AS_HELP_STRING([--disable-xres], [Build XRes extension (default: enabled)]), [RES=$enableval], [RES=yes])
AC_ARG_ENABLE(record, AS_HELP_STRING([--disable-record], [Build Record extension (default: enabled)]), [RECORD=$enableval], [RECORD=yes])
AC_ARG_ENABLE(xv, AS_HELP_STRING([--disable-xv], [Build Xv extension (default: enabled)]), [XV=$enableval], [XV=yes])
AC_ARG_ENABLE(xvmc, AS_HELP_STRING([--disable-xvmc], [Build XvMC extension (default: enabled)]), [XVMC=$enableval], [XVMC=yes])
AC_ARG_ENABLE(dga, AS_HELP_STRING([--disable-dga], [Build DGA extension (default: auto)]), [DGA=$enableval], [DGA=auto])
AC_ARG_ENABLE(screensaver, AS_HELP_STRING([--disable-screensaver], [Build ScreenSaver extension (default: enabled)]), [SCREENSAVER=$enableval], [SCREENSAVER=yes])
AC_ARG_ENABLE(xdmcp, AS_HELP_STRING([--disable-xdmcp], [Build XDMCP extension (default: auto)]), [XDMCP=$enableval], [XDMCP=auto])
AC_ARG_ENABLE(xdm-auth-1, AS_HELP_STRING([--disable-xdm-auth-1], [Build XDM-Auth-1 extension (default: auto)]), [XDMAUTH=$enableval], [XDMAUTH=auto])
AC_ARG_ENABLE(glx, AS_HELP_STRING([--disable-glx], [Build GLX extension (default: enabled)]), [GLX=$enableval], [GLX=yes])
AC_ARG_ENABLE(dri, AS_HELP_STRING([--enable-dri], [Build DRI extension (default: auto)]), [DRI=$enableval])
AC_ARG_ENABLE(dri2, AS_HELP_STRING([--enable-dri2], [Build DRI2 extension (default: auto)]), [DRI2=$enableval], [DRI2=auto])
AC_ARG_ENABLE(dri3, AS_HELP_STRING([--enable-dri3], [Build DRI3 extension (default: auto)]), [DRI3=$enableval], [DRI3=auto])
AC_ARG_ENABLE(present, AS_HELP_STRING([--disable-present], [Build Present extension (default: enabled)]), [PRESENT=$enableval], [PRESENT=yes])
AC_ARG_ENABLE(xinerama, AS_HELP_STRING([--disable-xinerama], [Build Xinerama extension (default: enabled)]), [XINERAMA=$enableval], [XINERAMA=yes])
AC_ARG_ENABLE(xf86vidmode, AS_HELP_STRING([--disable-xf86vidmode], [Build XF86VidMode extension (default: auto)]), [XF86VIDMODE=$enableval], [XF86VIDMODE=auto])
AC_ARG_ENABLE(xace, AS_HELP_STRING([--disable-xace], [Build X-ACE extension (default: enabled)]), [XACE=$enableval], [XACE=yes])
AC_ARG_ENABLE(xselinux, AS_HELP_STRING([--enable-xselinux], [Build SELinux extension (default: disabled)]), [XSELINUX=$enableval], [XSELINUX=no])
AC_ARG_ENABLE(xcsecurity, AS_HELP_STRING([--enable-xcsecurity], [Build Security extension (default: disabled)]), [XCSECURITY=$enableval], [XCSECURITY=no])
AC_ARG_ENABLE(dbe, AS_HELP_STRING([--disable-dbe], [Build DBE extension (default: enabled)]), [DBE=$enableval], [DBE=yes])
AC_ARG_ENABLE(xf86bigfont, AS_HELP_STRING([--enable-xf86bigfont], [Build XF86 Big Font extension (default: disabled)]), [XF86BIGFONT=$enableval], [XF86BIGFONT=no])
AC_ARG_ENABLE(dpms, AS_HELP_STRING([--disable-dpms], [Build DPMS extension (default: enabled)]), [DPMSExtension=$enableval], [DPMSExtension=yes])
AC_ARG_ENABLE(config-udev, AS_HELP_STRING([--enable-config-udev], [Build udev support (default: auto)]), [CONFIG_UDEV=$enableval], [CONFIG_UDEV=auto])
AC_ARG_ENABLE(config-udev-kms, AS_HELP_STRING([--enable-config-udev-kms], [Build udev kms support (default: auto)]), [CONFIG_UDEV_KMS=$enableval], [CONFIG_UDEV_KMS=auto])
AC_ARG_ENABLE(config-hal, AS_HELP_STRING([--disable-config-hal], [Build HAL support (default: auto)]), [CONFIG_HAL=$enableval], [CONFIG_HAL=auto])
AC_ARG_ENABLE(config-wscons, AS_HELP_STRING([--enable-config-wscons], [Build wscons config support (default: auto)]), [CONFIG_WSCONS=$enableval], [CONFIG_WSCONS=auto])
AC_ARG_ENABLE(xfree86-utils, AS_HELP_STRING([--enable-xfree86-utils], [Build xfree86 DDX utilities (default: enabled)]), [XF86UTILS=$enableval], [XF86UTILS=yes])
AC_ARG_ENABLE(vgahw, AS_HELP_STRING([--enable-vgahw], [Build Xorg with vga access (default: enabled)]), [VGAHW=$enableval], [VGAHW=yes])
AC_ARG_ENABLE(vbe, AS_HELP_STRING([--enable-vbe], [Build Xorg with VBE module (default: enabled)]), [VBE=$enableval], [VBE=yes])
AC_ARG_ENABLE(int10-module, AS_HELP_STRING([--enable-int10-module], [Build Xorg with int10 module (default: enabled)]), [INT10MODULE=$enableval], [INT10MODULE=yes])
AC_ARG_ENABLE(windowsdri, AS_HELP_STRING([--enable-windowsdri], [Build XWin with WindowsDRI extension (default: auto)]), [WINDOWSDRI=$enableval], [WINDOWSDRI=auto])
AC_ARG_ENABLE(libdrm, AS_HELP_STRING([--enable-libdrm], [Build Xorg with libdrm support (default: enabled)]), [DRM=$enableval],[DRM=yes])
AC_ARG_ENABLE(clientids, AS_HELP_STRING([--disable-clientids], [Build Xorg with client ID tracking (default: enabled)]), [CLIENTIDS=$enableval], [CLIENTIDS=yes])
AC_ARG_ENABLE(pciaccess, AS_HELP_STRING([--enable-pciaccess], [Build Xorg with pciaccess library (default: enabled)]), [PCI=$enableval], [PCI=yes])
AC_ARG_ENABLE(linux_acpi, AS_HELP_STRING([--disable-linux-acpi], [Disable building ACPI support on Linux (if available).]), [enable_linux_acpi=$enableval], [enable_linux_acpi=yes])
AC_ARG_ENABLE(linux_apm, AS_HELP_STRING([--disable-linux-apm], [Disable building APM support on Linux (if available).]), [enable_linux_apm=$enableval], [enable_linux_apm=yes])
AC_ARG_ENABLE(systemd-logind, AS_HELP_STRING([--enable-systemd-logind], [Build systemd-logind support (default: auto)]), [SYSTEMD_LOGIND=$enableval], [SYSTEMD_LOGIND=auto])
AC_ARG_ENABLE(suid-wrapper, AS_HELP_STRING([--enable-suid-wrapper], [Build suid-root wrapper for legacy driver support on rootless xserver systems (default: no)]), [SUID_WRAPPER=$enableval], [SUID_WRAPPER=no])
dnl DDXes.
AC_ARG_ENABLE(xorg, AS_HELP_STRING([--enable-xorg], [Build Xorg server (default: auto)]), [XORG=$enableval], [XORG=auto])
AC_ARG_ENABLE(dmx, AS_HELP_STRING([--enable-dmx], [Build DMX server (default: no)]), [DMX=$enableval], [DMX=no])
AC_ARG_ENABLE(xvfb, AS_HELP_STRING([--enable-xvfb], [Build Xvfb server (default: yes)]), [XVFB=$enableval], [XVFB=yes])
AC_ARG_ENABLE(xnest, AS_HELP_STRING([--enable-xnest], [Build Xnest server (default: auto)]), [XNEST=$enableval], [XNEST=auto])
AC_ARG_ENABLE(xquartz, AS_HELP_STRING([--enable-xquartz], [Build Xquartz server for OS-X (default: auto)]), [XQUARTZ=$enableval], [XQUARTZ=auto])
AC_ARG_ENABLE(xwayland, AS_HELP_STRING([--enable-xwayland], [Build Xwayland server (default: auto)]), [XWAYLAND=$enableval], [XWAYLAND=auto])
AC_ARG_ENABLE(xwayland-eglstream, AS_HELP_STRING([--enable-xwayland-eglstream], [Build Xwayland eglstream support (default: no)]), [XWAYLAND_EGLSTREAM=$enableval], [XWAYLAND_EGLSTREAM=no])
AC_ARG_ENABLE(standalone-xpbproxy, AS_HELP_STRING([--enable-standalone-xpbproxy], [Build a standalone xpbproxy (in addition to the one integrated into Xquartz as a separate thread) (default: no)]), [STANDALONE_XPBPROXY=$enableval], [STANDALONE_XPBPROXY=no])
AC_ARG_ENABLE(xwin, AS_HELP_STRING([--enable-xwin], [Build XWin server (default: auto)]), [XWIN=$enableval], [XWIN=auto])
AC_ARG_ENABLE(glamor, AS_HELP_STRING([--enable-glamor], [Build glamor dix module (default: auto)]), [GLAMOR=$enableval], [GLAMOR=auto])
dnl kdrive and its subsystems
AC_ARG_ENABLE(kdrive, AS_HELP_STRING([--enable-kdrive], [Build kdrive servers (default: no)]), [KDRIVE=$enableval], [KDRIVE=no])
AC_ARG_ENABLE(xephyr, AS_HELP_STRING([--enable-xephyr], [Build the kdrive Xephyr server (default: auto)]), [XEPHYR=$enableval], [XEPHYR=auto])
dnl kdrive options
AC_ARG_ENABLE(libunwind, AS_HELP_STRING([--enable-libunwind], [Use libunwind for backtracing (default: auto)]), [LIBUNWIND="$enableval"], [LIBUNWIND="auto"])
AC_ARG_ENABLE(xshmfence, AS_HELP_STRING([--disable-xshmfence], [Disable xshmfence (default: auto)]), [XSHMFENCE="$enableval"], [XSHMFENCE="auto"])
dnl chown/chmod to be setuid root as part of build
dnl Replaces InstallXserverSetUID in imake
AC_ARG_ENABLE(install-setuid,
AS_HELP_STRING([--enable-install-setuid],
[Install Xorg server as owned by root with setuid bit (default: auto)]),
[SETUID=$enableval], [SETUID=auto])
AC_MSG_CHECKING([to see if we can install the Xorg server as root])
if test "x$SETUID" = "xauto" ; then
case $host_os in
cygwin*) SETUID="no" ;;
mingw*) SETUID="no" ;;
darwin*) SETUID="no" ;;
*)
case $host_cpu in
sparc) SETUID="no" ;;
*) SETUID="yes" ;;
esac
esac
if test "x$SETUID" = xyes; then
touch testfile
chown root testfile > /dev/null 2>&1 || SETUID="no"
rm -f testfile
fi
fi
AC_MSG_RESULT([$SETUID])
AM_CONDITIONAL(INSTALL_SETUID, [test "x$SETUID" = "xyes"])
dnl Issue an error if xtrans.m4 was not found and XTRANS_CONNECTION_FLAGS macro
dnl was not expanded, since xorg-server with no transport types is rather useless.
dnl
dnl If you're seeing an error here, be sure you installed the lib/xtrans module
dnl first and if it's not in the default location, that you set the ACLOCAL
dnl environment variable to find it, such as:
dnl ACLOCAL="aclocal -I ${PREFIX}/share/aclocal"
m4_pattern_forbid([^XTRANS_CONNECTION_FLAGS$])
# Transport selection macro from xtrans.m4
XTRANS_CONNECTION_FLAGS
# Secure RPC detection macro from xtrans.m4
XTRANS_SECURE_RPC_FLAGS
AM_CONDITIONAL(SECURE_RPC, [test "x$SECURE_RPC" = xyes])
AM_CONDITIONAL(INT10_VM86, [test "x$INT10" = xvm86])
AM_CONDITIONAL(INT10_X86EMU, [test "x$INT10" = xx86emu])
AM_CONDITIONAL(INT10_STUB, [test "x$INT10" = xstub])
dnl DDX Detection... Yes, it's ugly to have it here... but we need to
dnl handle this early on so that we don't require unsupported extensions
case $host_os in
cygwin* | mingw*)
CONFIG_HAL=no
CONFIG_UDEV=no
CONFIG_UDEV_KMS=no
DGA=no
DRM=no
DRI2=no
DRI3=no
INT10MODULE=no
PCI=no
VGAHW=no
VBE=no
XF86UTILS=no
XF86VIDMODE=no
XSELINUX=no
SYMBOL_VISIBILITY=no
;;
darwin*)
PCI=no
INT10MODULE=no
VGAHW=no
VBE=no
DRM=no
DRI2=no
DRI3=no
if test x$XQUARTZ = xauto; then
AC_CACHE_CHECK([whether to build Xquartz],xorg_cv_Carbon_framework,[
save_LDFLAGS=$LDFLAGS
LDFLAGS="$LDFLAGS -framework Carbon"
AC_LINK_IFELSE([AC_LANG_SOURCE([char FSFindFolder(); int main() { FSFindFolder(); return 0;}])],
[xorg_cv_Carbon_framework=yes],
[xorg_cv_Carbon_framework=no])
LDFLAGS=$save_LDFLAGS])
if test "X$xorg_cv_Carbon_framework" = Xyes; then
XQUARTZ=yes
else
XQUARTZ=no
fi
fi
AC_CHECK_FUNC(dispatch_async,
AC_DEFINE([HAVE_LIBDISPATCH], 1, [Define to 1 if you have the libdispatch (GCD) available]),
[])
if test "x$XQUARTZ" = xyes ; then
XQUARTZ=yes
XVFB=no
XNEST=no
XWAYLAND=no
COMPOSITE=no
DGA=no
DPMSExtension=no
XF86VIDMODE=no
fi
;;
gnu*)
DRM=no
DRI2=no
DRI3=no
;;
*) XQUARTZ=no ;;
esac
dnl ---------------------------------------------------------------------------
dnl Extension section
dnl ---------------------------------------------------------------------------
XEXT_INC='-I$(top_srcdir)/Xext'
XEXT_LIB='$(top_builddir)/Xext/libXext.la'
dnl Optional modules
VIDEOPROTO="videoproto"
COMPOSITEPROTO="compositeproto >= 0.4"
RECORDPROTO="recordproto >= 1.13.99.1"
SCRNSAVERPROTO="scrnsaverproto >= 1.1"
RESOURCEPROTO="resourceproto >= 1.2.0"
DRIPROTO="xf86driproto >= 2.1.0"
DRI2PROTO="dri2proto >= 2.8"
DRI3PROTO="dri3proto >= 1.2"
XINERAMAPROTO="xineramaproto"
BIGFONTPROTO="xf86bigfontproto >= 1.2.0"
DGAPROTO="xf86dgaproto >= 2.0.99.1"
GLPROTO="glproto >= 1.4.17"
DMXPROTO="dmxproto >= 2.2.99.1"
VIDMODEPROTO="xf86vidmodeproto >= 2.2.99.1"
APPLEWMPROTO="applewmproto >= 1.4"
LIBXSHMFENCE="xshmfence >= 1.1"
dnl Required modules
XPROTO="xproto >= 7.0.31"
RANDRPROTO="randrproto >= 1.6.0"
RENDERPROTO="renderproto >= 0.11"
XEXTPROTO="xextproto >= 7.2.99.901"
INPUTPROTO="inputproto >= 2.3"
KBPROTO="kbproto >= 1.0.3"
FONTSPROTO="fontsproto >= 2.1.3"
FIXESPROTO="fixesproto >= 5.0"
DAMAGEPROTO="damageproto >= 1.1"
XCMISCPROTO="xcmiscproto >= 1.2.0"
BIGREQSPROTO="bigreqsproto >= 1.1.0"
XTRANS="xtrans >= 1.3.5"
PRESENTPROTO="presentproto >= 1.2"
dnl List of libraries that require a specific version
LIBAPPLEWM="applewm >= 1.4"
LIBDMX="dmx >= 1.0.99.1"
LIBDRI="dri >= 7.8.0"
LIBDRM="libdrm >= 2.4.89"
LIBEGL="egl"
LIBGBM="gbm >= 10.2.0"
LIBGL="gl >= 7.1.0"
LIBXEXT="xext >= 1.0.99.4"
LIBXFONT="xfont2 >= 2.0.0"
LIBXI="xi >= 1.2.99.1"
LIBXTST="xtst >= 1.0.99.2"
LIBPCIACCESS="pciaccess >= 0.12.901"
LIBUDEV="libudev >= 143"
LIBSELINUX="libselinux >= 2.0.86"
LIBDBUS="dbus-1 >= 1.0"
LIBPIXMAN="pixman-1 >= 0.27.2"
dnl Pixman is always required, but we separate it out so we can link
dnl specific modules against it
PKG_CHECK_MODULES(PIXMAN, $LIBPIXMAN)
REQUIRED_LIBS="$REQUIRED_LIBS $LIBPIXMAN $LIBXFONT xau"
dnl Core modules for most extensions, et al.
SDK_REQUIRED_MODULES="$XPROTO $RANDRPROTO $RENDERPROTO $XEXTPROTO $INPUTPROTO $KBPROTO $FONTSPROTO $LIBPIXMAN"
# Make SDK_REQUIRED_MODULES available for inclusion in xorg-server.pc
AC_SUBST(SDK_REQUIRED_MODULES)
AC_CHECK_DECL([PTHREAD_MUTEX_RECURSIVE], [HAVE_RECURSIVE_MUTEX=yes], [HAVE_RECURSIVE_MUTEX=no], [[#include <pthread.h>]])
THREAD_DEFAULT=no
if test "x$HAVE_RECURSIVE_MUTEX" = "xyes" ; then
THREAD_DEFAULT=yes
fi
case $host_os in
mingw*) THREAD_DEFAULT=no ;;
*)
esac
AC_ARG_ENABLE(input-thread, AS_HELP_STRING([--enable-input-thread],
[Enable input threads]),
[INPUTTHREAD=$enableval], [INPUTTHREAD=$THREAD_DEFAULT])
if test "x$INPUTTHREAD" = "xyes" ; then
AX_PTHREAD(,AC_MSG_ERROR([threaded input requested but no pthread support has been found]))
SYS_LIBS="$SYS_LIBS $PTHREAD_LIBS"
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
AC_DEFINE(INPUTTHREAD, 1, [Use a separate input thread])
save_LIBS="$LIBS"
LIBS="$LIBS $SYS_LIBS"
dnl MacOS X 10.6 & higher
AC_MSG_CHECKING(for pthread_setname_np(const char*))
AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>],
[pthread_setname_np("example")])],
[AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_PTHREAD_SETNAME_NP_WITHOUT_TID,1,
[Have function pthread_setname_np(const char*)])],
[AC_MSG_RESULT(no)])
dnl GNU libc 2.12 & higher, Solaris 11.3 & higher
AC_MSG_CHECKING(for pthread_setname_np(pthread_t, const char*))
AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>],
[pthread_setname_np(pthread_self(), "example")])],
[AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_PTHREAD_SETNAME_NP_WITH_TID,1,
[Have function pthread_setname_np(pthread_t, const char*)])],
[AC_MSG_RESULT(no)])
LIBS="$save_LIBS"
fi
REQUIRED_MODULES="$FIXESPROTO $DAMAGEPROTO $XCMISCPROTO $XTRANS $BIGREQSPROTO $SDK_REQUIRED_MODULES"
dnl systemd socket activation
dnl activate the code in libxtrans that grabs systemd's socket fds
dnl libsystemd-daemon was moved into libsystemd in version 209
LIBSYSTEMD="libsystemd >= 209"
AC_ARG_WITH([systemd-daemon],
AS_HELP_STRING([--with-systemd-daemon],
[support systemd socket activation (default: auto)]),
[WITH_SYSTEMD_DAEMON=$withval], [WITH_SYSTEMD_DAEMON=auto])
if test "x$WITH_SYSTEMD_DAEMON" = "xyes" -o "x$WITH_SYSTEMD_DAEMON" = "xauto" ; then
PKG_CHECK_MODULES([SYSTEMD_DAEMON], [$LIBSYSTEMD],
[HAVE_SYSTEMD_DAEMON=yes;
LIBSYSTEMD_DAEMON="$LIBSYSTEMD"],
[PKG_CHECK_MODULES([SYSTEMD_DAEMON], [libsystemd-daemon],
[HAVE_SYSTEMD_DAEMON=yes;
LIBSYSTEMD_DAEMON=libsystemd-daemon],
[HAVE_SYSTEMD_DAEMON=no])])
if test "x$HAVE_SYSTEMD_DAEMON" = xyes; then
AC_DEFINE(HAVE_SYSTEMD_DAEMON, 1, [Define to 1 if libsystemd-daemon is available])
REQUIRED_LIBS="$REQUIRED_LIBS $LIBSYSTEMD_DAEMON"
elif test "x$WITH_SYSTEMD_DAEMON" = xyes; then
AC_MSG_ERROR([systemd support requested but no library has been found])
fi
fi
AM_CONDITIONAL([HAVE_SYSTEMD_DAEMON], [test "x$HAVE_SYSTEMD_DAEMON" = "xyes"])
if test "x$CONFIG_UDEV" = xyes && test "x$CONFIG_HAL" = xyes; then
AC_MSG_ERROR([Hotplugging through both libudev and hal not allowed])
fi
PKG_CHECK_MODULES(UDEV, $LIBUDEV, [HAVE_LIBUDEV=yes], [HAVE_LIBUDEV=no])
if test "x$CONFIG_UDEV" = xauto; then
CONFIG_UDEV="$HAVE_LIBUDEV"
fi
AM_CONDITIONAL(CONFIG_UDEV, [test "x$CONFIG_UDEV" = xyes])
if test "x$CONFIG_UDEV" = xyes; then
CONFIG_HAL=no
if test "x$CONFIG_UDEV_KMS" = xauto; then
CONFIG_UDEV_KMS="$HAVE_LIBUDEV"
fi
if ! test "x$HAVE_LIBUDEV" = xyes; then
AC_MSG_ERROR([udev configuration API requested, but libudev is not installed])
fi
AC_DEFINE(CONFIG_UDEV, 1, [Use libudev for input hotplug])
if test "x$CONFIG_UDEV_KMS" = xyes; then
AC_DEFINE(CONFIG_UDEV_KMS, 1, [Use libudev for kms enumeration])
fi
SAVE_LIBS=$LIBS
SAVE_CFLAGS=$CFLAGS
CFLAGS="$CFLAGS $UDEV_CFLAGS"
LIBS=$UDEV_LIBS
AC_CHECK_FUNCS([udev_monitor_filter_add_match_tag])
AC_CHECK_FUNCS([udev_enumerate_add_match_tag])
LIBS=$SAVE_LIBS
CFLAGS=$SAVE_CFLAGS
fi
AM_CONDITIONAL(CONFIG_UDEV_KMS, [test "x$CONFIG_UDEV_KMS" = xyes])
PKG_CHECK_MODULES(DBUS, $LIBDBUS, [HAVE_DBUS=yes], [HAVE_DBUS=no])
if test "x$HAVE_DBUS" = xyes; then
AC_DEFINE(HAVE_DBUS, 1, [Have D-Bus support])
fi
AM_CONDITIONAL(HAVE_DBUS, [test "x$HAVE_DBUS" = xyes])
PKG_CHECK_MODULES(HAL, hal, [HAVE_HAL=yes], [HAVE_HAL=no])
if test "x$CONFIG_HAL" = xauto; then
CONFIG_HAL="$HAVE_HAL"
fi
if test "x$CONFIG_HAL" = xyes; then
if ! test "x$HAVE_HAL" = xyes; then
AC_MSG_ERROR([HAL hotplug API requested, but HAL is not installed.])
fi
AC_DEFINE(CONFIG_HAL, 1, [Use the HAL hotplug API])
NEED_DBUS="yes"
fi
AM_CONDITIONAL(CONFIG_HAL, [test "x$CONFIG_HAL" = xyes])
if test "x$SYSTEMD_LOGIND" = xauto; then
if test "x$HAVE_DBUS" = xyes -a "x$CONFIG_UDEV" = xyes ; then
SYSTEMD_LOGIND=yes
else
SYSTEMD_LOGIND=no
fi
fi
if test "x$SYSTEMD_LOGIND" = xyes; then
if ! test "x$HAVE_DBUS" = xyes; then
AC_MSG_ERROR([systemd-logind requested, but D-Bus is not installed.])
fi
if ! test "x$CONFIG_UDEV" = xyes ; then
AC_MSG_ERROR([systemd-logind is only supported in combination with udev configuration.])
fi
AC_DEFINE(SYSTEMD_LOGIND, 1, [Enable systemd-logind integration])
NEED_DBUS="yes"
fi
AM_CONDITIONAL(SYSTEMD_LOGIND, [test "x$SYSTEMD_LOGIND" = xyes])
if test "x$SUID_WRAPPER" = xyes; then
dnl This is a define so that if some platforms want to put the wrapper
dnl somewhere else this can be easily changed
AC_DEFINE_DIR(SUID_WRAPPER_DIR, libexecdir, [Where to install the Xorg binary and Xorg.wrap])
SETUID="no"
fi
AM_CONDITIONAL(SUID_WRAPPER, [test "x$SUID_WRAPPER" = xyes])
if test "x$NEED_DBUS" = xyes; then
AC_DEFINE(NEED_DBUS, 1, [Enable D-Bus core])
fi
AM_CONDITIONAL(NEED_DBUS, [test "x$NEED_DBUS" = xyes])
if test "x$CONFIG_WSCONS" = xauto; then
case $host_os in
*openbsd*)
CONFIG_WSCONS=yes;
;;
*)
CONFIG_WSCONS=no;
;;
esac
fi
AM_CONDITIONAL(CONFIG_WSCONS, [test "x$CONFIG_WSCONS" = xyes])
if test "x$CONFIG_WSCONS" = xyes; then
AC_DEFINE(CONFIG_WSCONS, 1, [Use wscons for input auto configuration])
fi
AC_MSG_CHECKING([for glibc...])
AC_PREPROC_IFELSE([AC_LANG_SOURCE([
#include <features.h>
#ifndef __GLIBC__
#error
#endif
])], glibc=yes, glibc=no)
AC_MSG_RESULT([$glibc])
AC_CHECK_FUNCS([clock_gettime], [have_clock_gettime=yes],
[AC_CHECK_LIB([rt], [clock_gettime], [have_clock_gettime=-lrt],
[have_clock_gettime=no])])
AC_MSG_CHECKING([for a useful monotonic clock ...])
if ! test "x$have_clock_gettime" = xno; then
if ! test "x$have_clock_gettime" = xyes; then
CLOCK_LIBS="$have_clock_gettime"
else
CLOCK_LIBS=""
fi
LIBS_SAVE="$LIBS"
LIBS="$CLOCK_LIBS"
CPPFLAGS_SAVE="$CPPFLAGS"
if test x"$glibc" = xyes; then
CPPFLAGS="$CPPFLAGS -D_POSIX_C_SOURCE=200112L"
fi
AC_RUN_IFELSE([AC_LANG_SOURCE([
#include <time.h>
int main(int argc, char *argv[[]]) {
struct timespec tp;
if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0)
return 0;
else
return 1;
}
])], [MONOTONIC_CLOCK=yes], [MONOTONIC_CLOCK=no],
[MONOTONIC_CLOCK="cross compiling"])
if test "$MONOTONIC_CLOCK" = "cross compiling"; then
AC_CHECK_DECL([CLOCK_MONOTONIC],[MONOTONIC_CLOCK="guessing yes"],[MONOTONIC_CLOCK=no],[#include <time.h>])
fi
LIBS="$LIBS_SAVE"
CPPFLAGS="$CPPFLAGS_SAVE"
else
MONOTONIC_CLOCK=no
fi
AC_MSG_RESULT([$MONOTONIC_CLOCK])
if test "$MONOTONIC_CLOCK" = "guessing yes"; then
MONOTONIC_CLOCK=yes
fi
if test "x$MONOTONIC_CLOCK" = xyes; then
AC_DEFINE(MONOTONIC_CLOCK, 1, [Have monotonic clock from clock_gettime()])
LIBS="$LIBS $CLOCK_LIBS"
fi
AM_CONDITIONAL(XV, [test "x$XV" = xyes])
if test "x$XV" = xyes; then
AC_DEFINE(XV, 1, [Support Xv extension])
AC_DEFINE(XvExtension, 1, [Build Xv extension])
REQUIRED_MODULES="$REQUIRED_MODULES $VIDEOPROTO"
SDK_REQUIRED_MODULES="$SDK_REQUIRED_MODULES $VIDEOPROTO"
else
XVMC=no
fi
AM_CONDITIONAL(XVMC, [test "x$XVMC" = xyes])
if test "x$XVMC" = xyes; then
AC_DEFINE(XvMCExtension, 1, [Build XvMC extension])
fi
AM_CONDITIONAL(COMPOSITE, [test "x$COMPOSITE" = xyes])
if test "x$COMPOSITE" = xyes; then
AC_DEFINE(COMPOSITE, 1, [Support Composite Extension])
REQUIRED_MODULES="$REQUIRED_MODULES $COMPOSITEPROTO"
COMPOSITE_LIB='$(top_builddir)/composite/libcomposite.la'
COMPOSITE_INC='-I$(top_srcdir)/composite'
fi
if test "x$MITSHM" = xauto; then
MITSHM="$ac_cv_sysv_ipc"
fi
AM_CONDITIONAL(MITSHM, [test "x$MITSHM" = xyes])
if test "x$MITSHM" = xyes; then
AC_DEFINE(MITSHM, 1, [Support MIT-SHM extension])
AC_DEFINE(HAS_SHM, 1, [Support SHM])
fi
AM_CONDITIONAL(RECORD, [test "x$RECORD" = xyes])
if test "x$RECORD" = xyes; then
AC_DEFINE(XRECORD, 1, [Support Record extension])
REQUIRED_MODULES="$REQUIRED_MODULES $RECORDPROTO"
RECORD_LIB='$(top_builddir)/record/librecord.la'
fi
AM_CONDITIONAL(SCREENSAVER, [test "x$SCREENSAVER" = xyes])
if test "x$SCREENSAVER" = xyes; then
AC_DEFINE(SCREENSAVER, 1, [Support MIT-SCREEN-SAVER extension])
REQUIRED_MODULES="$REQUIRED_MODULES $SCRNSAVERPROTO"
SDK_REQUIRED_MODULES="$SDK_REQUIRED_MODULES $SCRNSAVERPROTO"
fi
AM_CONDITIONAL(RES, [test "x$RES" = xyes])
if test "x$RES" = xyes; then
AC_DEFINE(RES, 1, [Support X resource extension])
REQUIRED_MODULES="$REQUIRED_MODULES $RESOURCEPROTO"
SDK_REQUIRED_MODULES="$SDK_REQUIRED_MODULES $RESOURCEPROTO"
fi
if test "x$LISTEN_TCP" = xyes; then
AC_DEFINE(LISTEN_TCP, 1, [Listen on TCP socket])
fi
if test "x$LISTEN_UNIX" = xyes; then
AC_DEFINE(LISTEN_UNIX, 1, [Listen on Unix socket])
fi
if test "x$LISTEN_LOCAL" = xyes; then
AC_DEFINE(LISTEN_LOCAL, 1, [Listen on local socket])
fi
# The XRes extension may support client ID tracking only if it has
# been specifically enabled. Client ID tracking is implicitly not
# supported if XRes extension is disabled.
AC_MSG_CHECKING([whether to track client ids])
if test "x$RES" = xyes && test "x$CLIENTIDS" = xyes; then
AC_DEFINE(CLIENTIDS, 1, [Support client ID tracking])
else
CLIENTIDS=no
fi
if test "x$CLIENTIDS" = xyes; then
case $host_os in
openbsd*)
SYS_LIBS="$SYS_LIBS -lkvm"
;;
esac
fi
AC_MSG_RESULT([$CLIENTIDS])
AM_CONDITIONAL(CLIENTIDS, [test "x$CLIENTIDS" = xyes])
AM_CONDITIONAL(DRI, test "x$DRI" = xyes)
if test "x$DRI" = xyes; then
AC_DEFINE(XF86DRI, 1, [Build DRI extension])
REQUIRED_MODULES="$REQUIRED_MODULES $DRIPROTO $GLPROTO $LIBDRI"
SDK_REQUIRED_MODULES="$SDK_REQUIRED_MODULES $DRIPROTO $GLPROTO $LIBDRI"
fi
PKG_CHECK_MODULES([DRI2PROTO], $DRI2PROTO,
[HAVE_DRI2PROTO=yes], [HAVE_DRI2PROTO=no])
case "$DRI2,$HAVE_DRI2PROTO" in
yes,no)
AC_MSG_ERROR([DRI2 requested, but dri2proto not found.])
;;
yes,yes | auto,yes)
AC_DEFINE(DRI2, 1, [Build DRI2 extension])
DRI2=yes
LIBGL="gl >= 9.2.0"
SDK_REQUIRED_MODULES="$SDK_REQUIRED_MODULES $DRI2PROTO"
;;
esac
AM_CONDITIONAL(DRI2, test "x$DRI2" = xyes)
AC_ARG_ENABLE(xtrans-send-fds, AS_HELP_STRING([--disable-xtrans-send-fds], [Use Xtrans support for fd passing (default: auto)]), [XTRANS_SEND_FDS=$enableval], [XTRANS_SEND_FDS=auto])
case "x$XTRANS_SEND_FDS" in
xauto)
case "$host_os" in
linux*|solaris*|freebsd*|dragonfly*|openbsd*)
XTRANS_SEND_FDS=yes
;;
*)
XTRANS_SEND_FDS=no
;;
esac
esac
case "x$XTRANS_SEND_FDS" in
xyes)
AC_DEFINE(XTRANS_SEND_FDS, 1, [Enable xtrans fd passing support])
;;
esac
case "$DRI3,$XTRANS_SEND_FDS" in
yes,yes | auto,yes)
;;
yes,no)
AC_MSG_ERROR([DRI3 requested, but xtrans fd passing support not found.])
DRI3=no
;;
no,*)
;;
*)
AC_MSG_NOTICE([DRI3 disabled because xtrans fd passing support not found.])
DRI3=no
;;
esac
PKG_CHECK_MODULES([DRI3PROTO], $DRI3PROTO,
[HAVE_DRI3PROTO=yes], [HAVE_DRI3PROTO=no])
case "$DRI3,$HAVE_DRI3PROTO" in
yes,yes | auto,yes)
REQUIRED_MODULES="$REQUIRED_MODULES dri3proto"
;;
yes,no)
AC_MSG_ERROR([DRI3 requested, but dri3proto not found.])
DRI3=no
;;
no,*)
;;
*)
AC_MSG_NOTICE([DRI3 disabled because dri3proto not found.])
DRI3=no
;;
esac
AC_CHECK_FUNCS([sigaction])
BUSFAULT=no
case x"$ac_cv_func_sigaction" in
xyes)
AC_DEFINE(HAVE_SIGACTION, 1, [Have sigaction function])
BUSFAULT=yes
;;
esac
case x"$BUSFAULT" in
xyes)
AC_DEFINE(BUSFAULT, 1, [Include busfault OS API])
;;
esac
AM_CONDITIONAL(BUSFAULT, test x"$BUSFAULT" = xyes)
PKG_CHECK_MODULES([XSHMFENCE], $LIBXSHMFENCE, [HAVE_XSHMFENCE=yes], [HAVE_XSHMFENCE=no])
if test "x$XSHMFENCE" = "xauto"; then
XSHMFENCE="$HAVE_XSHMFENCE"
fi
if test "x$XSHMFENCE" = "xyes"; then
if test "x$HAVE_XSHMFENCE" != "xyes"; then
AC_MSG_ERROR([xshmfence requested but not installed.])
fi
AC_DEFINE(HAVE_XSHMFENCE, 1, [Have xshmfence support])
REQUIRED_LIBS="$REQUIRED_LIBS $LIBXSHMFENCE"
fi
AM_CONDITIONAL(XSHMFENCE, [test "x$XSHMFENCE" = xyes])
case "$DRI3,$XSHMFENCE" in
yes,yes | auto,yes)
;;
yes,no)
AC_MSG_ERROR([DRI3 requested, but xshmfence not found.])
DRI3=no
;;
no,*)
;;
*)
AC_MSG_NOTICE([DRI3 disabled because xshmfence not found.])
DRI3=no
;;
esac
case x"$DRI3" in
xyes|xauto)
DRI3=yes
AC_DEFINE(DRI3, 1, [Build DRI3 extension])
DRI3_LIB='$(top_builddir)/dri3/libdri3.la'
SDK_REQUIRED_MODULES="$SDK_REQUIRED_MODULES $DRI3PROTO"
AC_MSG_NOTICE([DRI3 enabled]);
;;
esac
AM_CONDITIONAL(DRI3, test "x$DRI3" = xyes)
if test "x$DRI" = xyes || test "x$DRI2" = xyes || test "x$DRI3" = xyes || test "x$CONFIG_UDEV_KMS" = xyes; then
if test "x$DRM" = xyes; then
AC_DEFINE(WITH_LIBDRM, 1, [Building with libdrm support])
PKG_CHECK_MODULES([LIBDRM], $LIBDRM)
fi
fi
if test "x$GLX" = xyes; then
PKG_CHECK_MODULES([XLIB], [x11])
PKG_CHECK_MODULES([GL], $GLPROTO $LIBGL)
AC_SUBST(XLIB_CFLAGS)
AC_DEFINE(GLXEXT, 1, [Build GLX extension])
GLX_LIBS='$(top_builddir)/glx/libglx.la $(top_builddir)/glx/libglxvnd.la'
GLX_SYS_LIBS="$GLX_SYS_LIBS $GL_LIBS"
else
GLX=no
fi
AM_CONDITIONAL(GLX, test "x$GLX" = xyes)
AC_SUBST([GLX_DEFINES])
AC_SUBST([GLX_SYS_LIBS])
AM_CONDITIONAL(PRESENT, [test "x$PRESENT" = xyes])
if test "x$PRESENT" = xyes; then
AC_DEFINE(PRESENT, 1, [Support Present extension])
REQUIRED_MODULES="$REQUIRED_MODULES $PRESENTPROTO"
SDK_REQUIRED_MODULES="$SDK_REQUIRED_MODULES $PRESENTPROTO"
PRESENT_INC='-I$(top_srcdir)/present'
PRESENT_LIB='$(top_builddir)/present/libpresent.la'
fi
AM_CONDITIONAL(XINERAMA, [test "x$XINERAMA" = xyes])
if test "x$XINERAMA" = xyes; then
AC_DEFINE(XINERAMA, 1, [Support Xinerama extension])
AC_DEFINE(PANORAMIX, 1, [Internal define for Xinerama])
REQUIRED_MODULES="$REQUIRED_MODULES $XINERAMAPROTO"
SDK_REQUIRED_MODULES="$SDK_REQUIRED_MODULES $XINERAMAPROTO"
fi
AM_CONDITIONAL(XACE, [test "x$XACE" = xyes])
if test "x$XACE" = xyes; then
AC_DEFINE(XACE, 1, [Build X-ACE extension])
fi
AM_CONDITIONAL(XSELINUX, [test "x$XSELINUX" = xyes])
if test "x$XSELINUX" = xyes; then
if test "x$XACE" != xyes; then
AC_MSG_ERROR([cannot build SELinux extension without X-ACE])
fi
AC_CHECK_HEADERS([libaudit.h], [], AC_MSG_ERROR([SELinux extension requires audit system headers]))
AC_CHECK_LIB(audit, audit_open, [], AC_MSG_ERROR([SELinux extension requires audit system library]))
PKG_CHECK_MODULES([SELINUX], $LIBSELINUX)
SELINUX_LIBS="$SELINUX_LIBS -laudit"
AC_DEFINE(XSELINUX, 1, [Build SELinux extension])
fi
AM_CONDITIONAL(XCSECURITY, [test "x$XCSECURITY" = xyes])
if test "x$XCSECURITY" = xyes; then
if test "x$XACE" != xyes; then
AC_MSG_ERROR([cannot build Security extension without X-ACE])
fi
AC_DEFINE(XCSECURITY, 1, [Build Security extension])
fi
AM_CONDITIONAL(DBE, [test "x$DBE" = xyes])
if test "x$DBE" = xyes; then
AC_DEFINE(DBE, 1, [Support DBE extension])
DBE_LIB='$(top_builddir)/dbe/libdbe.la'
DBE_INC='-I$(top_srcdir)/dbe'
fi
AM_CONDITIONAL(XF86BIGFONT, [test "x$XF86BIGFONT" = xyes])
if test "x$XF86BIGFONT" = xyes; then
AC_DEFINE(XF86BIGFONT, 1, [Support XF86 Big font extension])
REQUIRED_MODULES="$REQUIRED_MODULES $BIGFONTPROTO"
SDK_REQUIRED_MODULES="$SDK_REQUIRED_MODULES $BIGFONTPROTO"
fi
AM_CONDITIONAL(DPMSExtension, [test "x$DPMSExtension" = xyes])
if test "x$DPMSExtension" = xyes; then
AC_DEFINE(DPMSExtension, 1, [Support DPMS extension])
fi
AC_DEFINE(RENDER, 1, [Support RENDER extension])
RENDER_LIB='$(top_builddir)/render/librender.la'
RENDER_INC='-I$(top_srcdir)/render'
AC_DEFINE(RANDR, 1, [Support RANDR extension])
RANDR_LIB='$(top_builddir)/randr/librandr.la'
RANDR_INC='-I$(top_srcdir)/randr'
AC_DEFINE(XFIXES,1,[Support XFixes extension])
FIXES_LIB='$(top_builddir)/xfixes/libxfixes.la'
FIXES_INC='-I$(top_srcdir)/xfixes'
AC_DEFINE(DAMAGE,1,[Support Damage extension])
DAMAGE_LIB='$(top_builddir)/damageext/libdamageext.la'
DAMAGE_INC='-I$(top_srcdir)/damageext'
MIEXT_DAMAGE_LIB='$(top_builddir)/miext/damage/libdamage.la'
MIEXT_DAMAGE_INC='-I$(top_srcdir)/miext/damage'
# XINPUT extension is integral part of the server
AC_DEFINE(XINPUT, 1, [Support X Input extension])
XI_LIB='$(top_builddir)/Xi/libXi.la'
XI_INC='-I$(top_srcdir)/Xi'
AM_CONDITIONAL(XF86UTILS, test "x$XF86UTILS" = xyes)
AM_CONDITIONAL(VGAHW, test "x$VGAHW" = xyes)
AM_CONDITIONAL(VBE, test "x$VBE" = xyes)
AM_CONDITIONAL(INT10MODULE, test "x$INT10MODULE" = xyes)
AC_DEFINE(SHAPE, 1, [Support SHAPE extension])
if test "x$XKBPATH" = "xauto"; then
XKBPATH=$(pkg-config --variable datadir xkbcomp || echo ${datadir})/X11/xkb
fi
AC_DEFINE_DIR(XKB_BASE_DIRECTORY, XKBPATH, [Path to XKB data])
AC_ARG_WITH(xkb-bin-directory,
AS_HELP_STRING([--with-xkb-bin-directory=DIR], [Directory containing xkbcomp program (default: auto)]),
[XKB_BIN_DIRECTORY="$withval"],
[XKB_BIN_DIRECTORY="auto"])
if test "x$XKB_BIN_DIRECTORY" = "xauto"; then
XKB_BIN_DIRECTORY=$(pkg-config --variable bindir xkbcomp)
if test -z $XKB_BIN_DIRECTORY; then
XKB_BIN_DIRECTORY="$bindir"
fi
fi
AC_DEFINE_DIR(XKB_BIN_DIRECTORY, XKB_BIN_DIRECTORY, [Path to XKB bin dir])
dnl Make sure XKM_OUTPUT_DIR is an absolute path
XKBOUTPUT_FIRSTCHAR=`echo $XKBOUTPUT | cut -b 1`
if [[ x$XKBOUTPUT_FIRSTCHAR != x/ -a x$XKBOUTPUT_FIRSTCHAR != 'x$' ]] ; then
XKBOUTPUT="$XKB_BASE_DIRECTORY/$XKBOUTPUT"
fi
dnl XKM_OUTPUT_DIR (used in code) must end in / or file names get hosed
dnl XKB_COMPILED_DIR (used in Makefiles) must not or install-sh gets confused
XKBOUTPUT=`echo $XKBOUTPUT/ | $SED 's|/*$|/|'`
XKB_COMPILED_DIR=`echo $XKBOUTPUT | $SED 's|/*$||'`
AC_DEFINE_DIR(XKM_OUTPUT_DIR, XKBOUTPUT, [Path to XKB output dir])
AC_SUBST(XKB_COMPILED_DIR)
if test "x$XKB_DFLT_RULES" = x; then
case $host_os in
linux*)
dnl doesn't take AutoAddDevices into account, but whatever.
XKB_DFLT_RULES="evdev"
;;
*)
XKB_DFLT_RULES="base"
;;
esac
fi
AC_DEFINE_UNQUOTED(XKB_DFLT_RULES, ["$XKB_DFLT_RULES"], [Default XKB ruleset])
AC_DEFINE_UNQUOTED(XKB_DFLT_MODEL, ["$XKB_DFLT_MODEL"], [Default XKB model])
AC_DEFINE_UNQUOTED(XKB_DFLT_LAYOUT, ["$XKB_DFLT_LAYOUT"], [Default XKB layout])
AC_DEFINE_UNQUOTED(XKB_DFLT_VARIANT, ["$XKB_DFLT_VARIANT"], [Default XKB variant])
AC_DEFINE_UNQUOTED(XKB_DFLT_OPTIONS, ["$XKB_DFLT_OPTIONS"], [Default XKB options])
AC_SUBST([XKB_DFLT_RULES])
AC_SUBST([XKB_DFLT_MODEL])
AC_SUBST([XKB_DFLT_LAYOUT])
AC_SUBST([XKB_DFLT_VARIANT])
AC_SUBST([XKB_DFLT_OPTIONS])
XKB_LIB='$(top_builddir)/xkb/libxkb.la'
XKB_STUB_LIB='$(top_builddir)/xkb/libxkbstubs.la'
REQUIRED_MODULES="$REQUIRED_MODULES xkbfile"
PKG_CHECK_MODULES([XDMCP], [xdmcp], [have_libxdmcp="yes"], [have_libxdmcp="no"])
if test "x$XDMCP" = xauto; then
if test "x$have_libxdmcp" = xyes; then
XDMCP=yes
else
XDMCP=no
fi
fi
if test "x$XDMAUTH" = xauto; then
if test "x$have_libxdmcp" = xyes; then
XDMAUTH=yes
else
XDMAUTH=no
fi
fi
AM_CONDITIONAL(XDMCP, [test "x$XDMCP" = xyes])
if test "x$XDMCP" = xyes; then
AC_DEFINE(XDMCP, 1, [Support XDM Control Protocol])
REQUIRED_LIBS="$REQUIRED_LIBS xdmcp"
XDMCP_MODULES="xdmcp"
fi
AM_CONDITIONAL(XDMAUTH, [test "x$XDMAUTH" = xyes])
if test "x$XDMAUTH" = xyes; then
AC_DEFINE(HASXDMAUTH,1,[Support XDM-AUTH*-1])
if ! test "x$XDMCP" = xyes; then
REQUIRED_LIBS="$REQUIRED_LIBS xdmcp"
XDMCP_MODULES="xdmcp"
fi
fi
if test "x$XF86VIDMODE" = xauto; then
PKG_CHECK_EXISTS($VIDMODEPROTO, [XF86VIDMODE=yes], [XF86VIDMODE=no])
fi
if test "x$XF86VIDMODE" = xyes; then
AC_DEFINE(XF86VIDMODE, 1, [Support XFree86 Video Mode extension])
fi
AM_CONDITIONAL([XF86VIDMODE], [test "x$XF86VIDMODE" = xyes])
AC_DEFINE_DIR(COMPILEDDEFAULTFONTPATH, FONTPATH, [Default font path])
AC_DEFINE_DIR(SERVER_MISC_CONFIG_PATH, SERVERCONFIG, [Server miscellaneous config path])
AC_DEFINE_DIR(BASE_FONT_PATH, FONTROOTDIR, [Default base font path])
dridriverdir=`$PKG_CONFIG --variable=dridriverdir dri`
AC_DEFINE_DIR(DRI_DRIVER_PATH, dridriverdir, [Default DRI driver path])
AC_DEFINE_UNQUOTED(XVENDORNAME, ["$VENDOR_NAME"], [Vendor name])
AC_DEFINE_UNQUOTED(XVENDORNAMESHORT, ["$VENDOR_NAME_SHORT"], [Short vendor name])
AC_DEFINE_UNQUOTED(XORG_MAN_VERSION, ["$VENDOR_MAN_VERSION"], [Vendor man version])
AC_DEFINE_UNQUOTED(BUILDERADDR, ["$BUILDERADDR"], [Builder address])
AC_DEFINE_UNQUOTED(BUILDERSTRING, ["$BUILDERSTRING"], [Builder string])
AC_SUBST([VENDOR_NAME_SHORT])
AC_DEFINE_UNQUOTED(VENDOR_NAME, ["$VENDOR_NAME"], [Vendor name])
AC_DEFINE_UNQUOTED(VENDOR_NAME_SHORT, ["$VENDOR_NAME_SHORT"], [Vendor name])
AC_DEFINE_UNQUOTED(VENDOR_RELEASE, [$VENDOR_RELEASE], [Vendor release])
AC_DEFINE_UNQUOTED(VENDOR_MAN_VERSION, ["$VENDOR_MAN_VERSION"], [Vendor man version])
if test "x$DEBUGGING" = xyes; then
AC_DEFINE(DEBUG, 1, [Enable debugging code])
fi
AM_CONDITIONAL(DEBUG, [test "x$DEBUGGING" = xyes])
AC_DEFINE(XTEST, 1, [Support XTest extension])
AC_DEFINE(XSYNC, 1, [Support XSync extension])
AC_DEFINE(XCMISC, 1, [Support XCMisc extension])
AC_DEFINE(BIGREQS, 1, [Support BigRequests extension])
if test "x$SPECIAL_DTRACE_OBJECTS" = "xyes" ; then
DIX_LIB='$(top_builddir)/dix/dix.O'
OS_LIB='$(top_builddir)/os/os.O $(SHA1_LIBS) $(DLOPEN_LIBS) $(LIBUNWIND_LIBS)'
else
DIX_LIB='$(top_builddir)/dix/libdix.la'
OS_LIB='$(top_builddir)/os/libos.la'
fi
AC_SUBST([DIX_LIB])
AC_SUBST([OS_LIB])
MAIN_LIB='$(top_builddir)/dix/libmain.la'
AC_SUBST([MAIN_LIB])
MI_LIB='$(top_builddir)/mi/libmi.la'
MI_EXT_LIB='$(top_builddir)/mi/libmiext.la'
MI_INC='-I$(top_srcdir)/mi'
FB_LIB='$(top_builddir)/fb/libfb.la'
FB_INC='-I$(top_srcdir)/fb'
MIEXT_SHADOW_INC='-I$(top_srcdir)/miext/shadow'
MIEXT_SHADOW_LIB='$(top_builddir)/miext/shadow/libshadow.la'
MIEXT_SYNC_INC='-I$(top_srcdir)/miext/sync'
MIEXT_SYNC_LIB='$(top_builddir)/miext/sync/libsync.la'
CORE_INCS='-I$(top_srcdir)/include -I$(top_builddir)/include'
# SHA1 hashing
AC_ARG_WITH([sha1],
[AS_HELP_STRING([--with-sha1=libc|libmd|libnettle|libgcrypt|libcrypto|libsha1|CommonCrypto|CryptoAPI],
[choose SHA1 implementation])])
AC_CHECK_FUNC([SHA1Init], [HAVE_SHA1_IN_LIBC=yes])
if test "x$with_sha1" = x && test "x$HAVE_SHA1_IN_LIBC" = xyes; then
with_sha1=libc
fi
if test "x$with_sha1" = xlibc && test "x$HAVE_SHA1_IN_LIBC" != xyes; then
AC_MSG_ERROR([libc requested but not found])
fi
if test "x$with_sha1" = xlibc; then
AC_DEFINE([HAVE_SHA1_IN_LIBC], [1],
[Use libc SHA1 functions])
SHA1_LIBS=""
fi
AC_CHECK_FUNC([CC_SHA1_Init], [HAVE_SHA1_IN_COMMONCRYPTO=yes])
if test "x$with_sha1" = x && test "x$HAVE_SHA1_IN_COMMONCRYPTO" = xyes; then
with_sha1=CommonCrypto
fi
if test "x$with_sha1" = xCommonCrypto && test "x$HAVE_SHA1_IN_COMMONCRYPTO" != xyes; then
AC_MSG_ERROR([CommonCrypto requested but not found])
fi
if test "x$with_sha1" = xCommonCrypto; then
AC_DEFINE([HAVE_SHA1_IN_COMMONCRYPTO], [1],
[Use CommonCrypto SHA1 functions])
SHA1_LIBS=""
fi
dnl stdcall functions cannot be tested with AC_CHECK_LIB
AC_CHECK_HEADER([wincrypt.h], [HAVE_SHA1_IN_CRYPTOAPI=yes], [], [#include <windows.h>])
if test "x$with_sha1" = x && test "x$HAVE_SHA1_IN_CRYPTOAPI" = xyes; then
with_sha1=CryptoAPI
fi
if test "x$with_sha1" = xCryptoAPI && test "x$HAVE_SHA1_IN_CRYPTOAPI" != xyes; then
AC_MSG_ERROR([CryptoAPI requested but not found])
fi
if test "x$with_sha1" = xCryptoAPI; then
AC_DEFINE([HAVE_SHA1_IN_CRYPTOAPI], [1],
[Use CryptoAPI SHA1 functions])
SHA1_LIBS=""
fi
AC_CHECK_LIB([md], [SHA1Init], [HAVE_LIBMD=yes])
if test "x$with_sha1" = x && test "x$HAVE_LIBMD" = xyes; then
with_sha1=libmd
fi
if test "x$with_sha1" = xlibmd && test "x$HAVE_LIBMD" != xyes; then
AC_MSG_ERROR([libmd requested but not found])
fi
if test "x$with_sha1" = xlibmd; then
AC_DEFINE([HAVE_SHA1_IN_LIBMD], [1],
[Use libmd SHA1 functions])
SHA1_LIBS=-lmd
fi
PKG_CHECK_MODULES([LIBSHA1], [libsha1], [HAVE_LIBSHA1=yes], [HAVE_LIBSHA1=no])
if test "x$with_sha1" = x && test "x$HAVE_LIBSHA1" = xyes; then
with_sha1=libsha1
fi
if test "x$with_sha1" = xlibsha1 && test "x$HAVE_LIBSHA1" != xyes; then
AC_MSG_ERROR([libsha1 requested but not found])
fi
if test "x$with_sha1" = xlibsha1; then
AC_DEFINE([HAVE_SHA1_IN_LIBSHA1], [1],
[Use libsha1 for SHA1])
SHA1_LIBS=-lsha1
fi
AC_CHECK_LIB([nettle], [nettle_sha1_init], [HAVE_LIBNETTLE=yes])
if test "x$with_sha1" = x && test "x$HAVE_LIBNETTLE" = xyes; then
with_sha1=libnettle
fi
if test "x$with_sha1" = xlibnettle && test "x$HAVE_LIBNETTLE" != xyes; then
AC_MSG_ERROR([libnettle requested but not found])
fi
if test "x$with_sha1" = xlibnettle; then
AC_DEFINE([HAVE_SHA1_IN_LIBNETTLE], [1],
[Use libnettle SHA1 functions])
SHA1_LIBS=-lnettle
fi
AC_CHECK_LIB([gcrypt], [gcry_md_open], [HAVE_LIBGCRYPT=yes])
if test "x$with_sha1" = x && test "x$HAVE_LIBGCRYPT" = xyes; then
with_sha1=libgcrypt
fi
if test "x$with_sha1" = xlibgcrypt && test "x$HAVE_LIBGCRYPT" != xyes; then
AC_MSG_ERROR([libgcrypt requested but not found])
fi
if test "x$with_sha1" = xlibgcrypt; then
AC_DEFINE([HAVE_SHA1_IN_LIBGCRYPT], [1],
[Use libgcrypt SHA1 functions])
SHA1_LIBS=-lgcrypt
fi
# We don't need all of the OpenSSL libraries, just libcrypto
AC_CHECK_LIB([crypto], [SHA1_Init], [HAVE_LIBCRYPTO=yes])
PKG_CHECK_MODULES([OPENSSL], [openssl], [HAVE_OPENSSL_PKC=yes],
[HAVE_OPENSSL_PKC=no])
if test "x$HAVE_LIBCRYPTO" = xyes || test "x$HAVE_OPENSSL_PKC" = xyes; then
if test "x$with_sha1" = x; then
with_sha1=libcrypto
fi
else
if test "x$with_sha1" = xlibcrypto; then
AC_MSG_ERROR([OpenSSL libcrypto requested but not found])
fi
fi
if test "x$with_sha1" = xlibcrypto; then
if test "x$HAVE_LIBCRYPTO" = xyes; then
SHA1_LIBS=-lcrypto
else
SHA1_LIBS="$OPENSSL_LIBS"
SHA1_CFLAGS="$OPENSSL_CFLAGS"
fi
fi
AC_MSG_CHECKING([for SHA1 implementation])
if test "x$with_sha1" = x; then
AC_MSG_ERROR([No suitable SHA1 implementation found])
fi
AC_MSG_RESULT([$with_sha1])
AC_SUBST(SHA1_LIBS)
AC_SUBST(SHA1_CFLAGS)
PKG_CHECK_MODULES([XSERVERCFLAGS], [$REQUIRED_MODULES $REQUIRED_LIBS])
PKG_CHECK_MODULES([XSERVERLIBS], [$REQUIRED_LIBS])
PKG_CHECK_MODULES(LIBUNWIND, libunwind, [HAVE_LIBUNWIND=yes], [HAVE_LIBUNWIND=no])
if test "x$LIBUNWIND" = "xauto"; then
LIBUNWIND="$HAVE_LIBUNWIND"
fi
if test "x$LIBUNWIND" = "xyes"; then
if test "x$HAVE_LIBUNWIND" != "xyes"; then
AC_MSG_ERROR([libunwind requested but not installed.])
fi
AC_DEFINE(HAVE_LIBUNWIND, 1, [Have libunwind support])
fi
AM_CONDITIONAL(HAVE_LIBUNWIND, [test "x$LIBUNWIND" = xyes])
# Autotools has some unfortunate issues with library handling. In order to
# get a server to rebuild when a dependency in the tree is changed, it must
# be listed in SERVERNAME_DEPENDENCIES. However, no system libraries may be
# listed there, or some versions of autotools will break (especially if a -L
# is required to find the library). So, we keep two sets of libraries
# detected: NAMESPACE_LIBS for in-tree libraries to be linked against, which
# will go into the _DEPENDENCIES and _LDADD of the server, and
# NAMESPACE_SYS_LIBS which will go into only the _LDADD. The
# NAMESPACEMODULES_LIBS detected from pkgconfig should always go in
# NAMESPACE_SYS_LIBS.
#
# XSERVER_LIBS is the set of in-tree libraries which all servers require.
# XSERVER_SYS_LIBS is the set of out-of-tree libraries which all servers
# require.
#
XSERVER_CFLAGS="${XSERVER_CFLAGS} ${XSERVERCFLAGS_CFLAGS}"
XSERVER_LIBS="$DIX_LIB $MI_LIB $OS_LIB"
XSERVER_SYS_LIBS="${XSERVERLIBS_LIBS} ${SYS_LIBS} ${LIBS}"
AC_SUBST([XSERVER_LIBS])
AC_SUBST([XSERVER_SYS_LIBS])
UTILS_SYS_LIBS="${SYS_LIBS}"
AC_SUBST([UTILS_SYS_LIBS])
# The Xorg binary needs to export symbols so that they can be used from modules
# Some platforms require extra flags to do this. libtool should set the
# necessary flags for each platform when -export-dynamic is passed to it.
LD_EXPORT_SYMBOLS_FLAG="-export-dynamic"
LD_NO_UNDEFINED_FLAG=
XORG_DRIVER_LIBS=
case "$host_os" in
cygwin*)
LD_EXPORT_SYMBOLS_FLAG="-Wl,--export-all,--out-implib,lib\$@.a"
LD_NO_UNDEFINED_FLAG="-no-undefined -Wl,\$(top_builddir)/hw/xfree86/libXorg.exe.a"
XORG_DRIVER_LIBS="-lXorg.exe -L\${moduledir} -lshadow -lfb -no-undefined"
CYGWIN=yes
;;
solaris*)
# We use AC_LINK_IFELSE to generate a temporary program conftest$EXEEXT
# that we can link against for testing if the system linker is new
# enough to support -z parent=<program> for verifying loadable modules
# are only calling functions defined in either the loading program or
# the libraries they're linked with.
AC_LINK_IFELSE(
[AC_LANG_SOURCE([int main(int argc, char **argv) { return 0; }])],
[mv conftest$EXEEXT conftest.parent
XORG_CHECK_LINKER_FLAGS([-Wl,-z,parent=conftest.parent -G],
[LD_NO_UNDEFINED_FLAG="-Wl,-z,defs -Wl,-z,parent=\$(top_builddir)/hw/xfree86/Xorg"
# Not set yet, since this gets exported in xorg-server.pc to all the drivers,
# and they're not all fixed to build correctly with it yet.
# XORG_DRIVER_LIBS="-Wl,-z,defs -Wl,-z,parent=${bindir}/Xorg"
],[],
[AC_LANG_SOURCE([extern int main(int argc, char **argv);
int call_main(void) { return main(0, (void *)0); }])])
rm -f conftest.parent
])
;;
esac
AC_SUBST([LD_EXPORT_SYMBOLS_FLAG])
AC_SUBST([LD_NO_UNDEFINED_FLAG])
AC_SUBST([XORG_DRIVER_LIBS])
AM_CONDITIONAL([CYGWIN], [test x"$CYGWIN" = xyes])
AM_CONDITIONAL([NO_UNDEFINED], [test x"$LD_NO_UNDEFINED_FLAG" != x])
dnl Imake defines SVR4 on SVR4 systems, and many files check for it, so
dnl we need to replicate that here until those can all be fixed
AC_MSG_CHECKING([if SVR4 needs to be defined])
AC_EGREP_CPP([I_AM_SVR4],[
#if defined(SVR4) || defined(__svr4__) || defined(__SVR4)
I_AM_SVR4
#endif
],[
AC_DEFINE([SVR4],1,[Define to 1 on systems derived from System V Release 4])
AC_MSG_RESULT([yes])], AC_MSG_RESULT([no]))
XSERVER_CFLAGS="$XSERVER_CFLAGS $CORE_INCS $XEXT_INC $COMPOSITE_INC $DAMAGE_INC $FIXES_INC $XI_INC $MI_INC $MIEXT_SYNC_INC $MIEXT_SHADOW_INC $MIEXT_LAYER_INC $MIEXT_DAMAGE_INC $RENDER_INC $RANDR_INC $FB_INC $DBE_INC $PRESENT_INC"
dnl ---------------------------------------------------------------------------
dnl DDX section.
dnl ---------------------------------------------------------------------------
dnl Xvfb DDX
AC_MSG_CHECKING([whether to build Xvfb DDX])
AC_MSG_RESULT([$XVFB])
AM_CONDITIONAL(XVFB, [test "x$XVFB" = xyes])
if test "x$XVFB" = xyes; then
XVFB_LIBS="$FB_LIB $FIXES_LIB $XEXT_LIB $DBE_LIB $RECORD_LIB $GLX_LIBS $RANDR_LIB $RENDER_LIB $DAMAGE_LIB $DRI3_LIB $PRESENT_LIB $MIEXT_SYNC_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB"
XVFB_SYS_LIBS="$XVFBMODULES_LIBS $GLX_SYS_LIBS"
AC_SUBST([XVFB_LIBS])
AC_SUBST([XVFB_SYS_LIBS])
fi
dnl Xnest DDX
PKG_CHECK_MODULES(XNESTMODULES, [$LIBXEXT x11 xau $XDMCP_MODULES], [have_xnest=yes], [have_xnest=no])
AC_MSG_CHECKING([whether to build Xnest DDX])
if test "x$XNEST" = xauto; then
XNEST="$have_xnest"
fi
AC_MSG_RESULT([$XNEST])
AM_CONDITIONAL(XNEST, [test "x$XNEST" = xyes])
if test "x$XNEST" = xyes; then
if test "x$have_xnest" = xno; then
AC_MSG_ERROR([Xnest build explicitly requested, but required modules not found.])
fi
XNEST_LIBS="$FB_LIB $FIXES_LIB $MI_LIB $XEXT_LIB $DBE_LIB $RECORD_LIB $GLX_LIBS $RANDR_LIB $DAMAGE_LIB $DRI3_LIB $PRESENT_LIB $MIEXT_SYNC_LIB $MIEXT_DAMAGE_LIB $RENDER_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $MAIN_LIB $DIX_LIB $OS_LIB"
XNEST_SYS_LIBS="$XNESTMODULES_LIBS $GLX_SYS_LIBS"
AC_SUBST([XNEST_LIBS])
AC_SUBST([XNEST_SYS_LIBS])
fi
dnl Xorg DDX
AC_MSG_CHECKING([whether to build Xorg DDX])
if test "x$XORG" = xauto; then
XORG="yes"
case $host_os in
cygwin*) XORG="no" ;;
mingw*) XORG="no" ;;
darwin*) XORG="no" ;;
esac
fi
AC_MSG_RESULT([$XORG])
if test "x$XORG" = xyes; then
XORG_DDXINCS='-I$(top_srcdir)/hw/xfree86 -I$(top_srcdir)/hw/xfree86/include -I$(top_srcdir)/hw/xfree86/common'
XORG_OSINCS='-I$(top_srcdir)/hw/xfree86/os-support -I$(top_srcdir)/hw/xfree86/os-support/bus -I$(top_srcdir)/os'
XORG_INCS="$XORG_DDXINCS $XORG_OSINCS"
XORG_CFLAGS="$XORGSERVER_CFLAGS -DHAVE_XORG_CONFIG_H"
XORG_LIBS="$COMPOSITE_LIB $FIXES_LIB $XEXT_LIB $DBE_LIB $RECORD_LIB $RANDR_LIB $RENDER_LIB $DAMAGE_LIB $DRI3_LIB $PRESENT_LIB $MIEXT_SYNC_LIB $MIEXT_DAMAGE_LIB $XI_LIB $XKB_LIB"
dnl ==================================================================
dnl symbol visibility
symbol_visibility=
have_visibility=disabled
if test x$SYMBOL_VISIBILITY != xno; then
AC_MSG_CHECKING(for symbol visibility support)
if test x$GCC = xyes; then
VISIBILITY_CFLAGS="-fvisibility=hidden"
else
if test x$SUNCC = xyes; then
VISIBILITY_CFLAGS="-xldscope=hidden"
else
have_visibility=no
fi
fi
if test x$have_visibility != xno; then
save_CFLAGS="$CFLAGS"
proto_inc=`$PKG_CONFIG --cflags xproto`
CFLAGS="$CFLAGS $VISIBILITY_CFLAGS $proto_inc"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
[#include <X11/Xfuncproto.h>
extern _X_HIDDEN int hidden_int;
extern _X_EXPORT int public_int;
extern _X_HIDDEN int hidden_int_func(void);
extern _X_EXPORT int public_int_func(void);]],
[])],
have_visibility=yes,
have_visibility=no)
CFLAGS=$save_CFLAGS
fi
AC_MSG_RESULT([$have_visibility])
if test x$have_visibility != xno; then
symbol_visibility=$VISIBILITY_CFLAGS
XORG_CFLAGS="$XORG_CFLAGS $VISIBILITY_CFLAGS"
XSERVER_CFLAGS="$XSERVER_CFLAGS $VISIBILITY_CFLAGS"
fi
fi
dnl added to xorg-server.pc
AC_SUBST([symbol_visibility])
dnl ===================================================================
dnl ===================================================================
dnl ================= beginning of PCI configuration ==================
dnl ===================================================================
xorg_bus_bsdpci=no
xorg_bus_sparc=no
AC_MSG_CHECKING([whether to build Xorg PCI functions])
if test "x$PCI" = xyes; then
PKG_CHECK_MODULES([PCIACCESS], $LIBPCIACCESS)
SDK_REQUIRED_MODULES="$SDK_REQUIRED_MODULES $LIBPCIACCESS"
XORG_SYS_LIBS="$XORG_SYS_LIBS $PCIACCESS_LIBS $LIBDRM_LIBS"
XORG_CFLAGS="$XORG_CFLAGS $PCIACCESS_CFLAGS $LIBDRM_CFLAGS"
AC_DEFINE(XSERVER_LIBPCIACCESS, 1, [Use libpciaccess for all pci manipulation])
AC_DEFINE_DIR(PCI_TXT_IDS_PATH, PCI_TXT_IDS_DIR, [Default PCI text file ID path])
case $host_os in
gnu* | freebsd* | kfreebsd*-gnu | netbsd* | openbsd* | solaris* | dragonfly*)
xorg_bus_bsdpci="yes"
;;
esac
case $host_cpu in
sparc*)
xorg_bus_sparc="yes"
;;
esac
else
if test "x$CONFIG_UDEV_KMS" = xyes; then
AC_MSG_ERROR([Platform device enumeration requires libpciaccess])
fi
if test "x$INT10MODULE" = xyes && test "x$INT10" != xstub; then
AC_MSG_ERROR([Cannot build int10 without libpciaccess])
fi
fi
AC_MSG_RESULT([$PCI])
if test "x$CONFIG_UDEV_KMS" = xyes; then
AC_DEFINE(XSERVER_PLATFORM_BUS, 1, [X server supports platform device enumeration])
fi
AC_MSG_RESULT([$XSERVER_PLATFORM_BUS])
dnl ===================================================================
dnl ==================== end of PCI configuration =====================
dnl ===================================================================
case $host_os in
linux*)
XORG_OS_SUBDIR="linux"
linux_acpi="no"
case $host_cpu in
i*86|amd64*|x86_64*|ia64*)
linux_acpi=$enable_linux_acpi
;;
*)
;;
esac
dnl APM header
AC_CHECK_HEADERS([linux/apm_bios.h], [linux_apm=$enable_linux_apm])
;;
freebsd* | kfreebsd*-gnu | dragonfly*)
XORG_OS_SUBDIR="bsd"
;;
netbsd*)
XORG_OS_SUBDIR="bsd"
;;
openbsd*)
XORG_OS_SUBDIR="bsd"
;;
solaris*)
XORG_OS_SUBDIR="solaris"
AC_CHECK_HEADERS([sys/kd.h])
AC_CHECK_HEADERS([sys/vt.h], [solaris_vt=yes], [solaris_vt=no])
# Check for minimum supported release
AC_MSG_CHECKING([Solaris version])
OS_MINOR=`echo ${host_os}|$SED -e 's/^.*solaris2\.//' -e s'/\..*$//'`
if test "${OS_MINOR}" -ge 7 ; then
AC_MSG_RESULT(Solaris ${OS_MINOR})
else
AC_MSG_RESULT(Solaris `echo ${host_os}|$SED -e 's/^.*solaris//`)
fi
if test "${OS_MINOR}" -lt 8 ; then
AC_MSG_ERROR([This release no longer supports Solaris versions older than Solaris 8.])
fi
AC_CHECK_DECL([_LP64], [SOLARIS_64="yes"], [SOLARIS_64="no"])
case $host_cpu in
sparc*)
SOLARIS_INOUT_ARCH="sparcv8plus"
;;
i*86|x86_64*)
if test x$SOLARIS_64 = xyes ; then
SOLARIS_INOUT_ARCH="amd64"
else
SOLARIS_INOUT_ARCH="ia32"
fi
;;
*)
AC_MSG_ERROR([Unsupported Solaris platform. Only SPARC & x86 \
are supported on Solaris in this release. If you are \
interested in porting Xorg to your platform, please email \
xorg@lists.freedesktop.org.]) ;;
esac
AC_SUBST([SOLARIS_INOUT_ARCH])
;;
gnu*)
XORG_OS_SUBDIR="hurd"
;;
cygwin*)
XORG_OS_SUBDIR="stub"
;;
*)
XORG_OS_SUBDIR="stub"
AC_MSG_NOTICE([m4_text_wrap(m4_join([ ],
[Your OS is unknown.],
[If you are interested in porting Xorg to your platform,],
[please email xorg@lists.freedesktop.org.]))])
;;
esac
if test "x$DGA" = xauto; then
PKG_CHECK_MODULES(DGA, $DGAPROTO, [DGA=yes], [DGA=no])
fi
if test "x$DGA" = xyes; then
XORG_MODULES="$XORG_MODULES $DGAPROTO"
PKG_CHECK_MODULES(DGA, $DGAPROTO)
AC_DEFINE(DGA, 1, [Support DGA extension])
AC_DEFINE(XFreeXDGA, 1, [Build XDGA support])
fi
if test "x$XF86VIDMODE" = xyes; then
XORG_MODULES="$XORG_MODULES $VIDMODEPROTO"
fi
if test -n "$XORG_MODULES"; then
PKG_CHECK_MODULES(XORG_MODULES, [$XORG_MODULES])
XORG_CFLAGS="$XORG_CFLAGS $XORG_MODULES_CFLAGS"
XORG_SYS_LIBS="$XORG_SYS_LIBS $XORG_MODULES_LIBS"
fi
if test "x$DRM" = xyes; then
XORG_DRIVER_MODESETTING=yes
fi
AC_SUBST([XORG_LIBS])
AC_SUBST([XORG_SYS_LIBS])
AC_SUBST([XORG_INCS])
AC_SUBST([XORG_OS_SUBDIR])
AC_SUBST([XORG_CFLAGS])
dnl these only go in xorg-config.h
XF86CONFIGFILE="xorg.conf"
XF86CONFIGDIR="xorg.conf.d"
AC_SUBST(XF86CONFIGDIR)
LOGPREFIX="Xorg."
XDG_DATA_HOME=".local/share"
XDG_DATA_HOME_LOGDIR="xorg"
AC_DEFINE(XORG_SERVER, 1, [Building Xorg server])
AC_DEFINE(XORGSERVER, 1, [Building Xorg server])
AC_DEFINE(XFree86Server, 1, [Building XFree86 server])
AC_DEFINE_UNQUOTED(XORG_VERSION_CURRENT, [$VENDOR_RELEASE], [Current Xorg version])
AC_DEFINE(NEED_XF86_TYPES, 1, [Need XFree86 typedefs])
AC_DEFINE(NEED_XF86_PROTOTYPES, 1, [Need XFree86 helper functions])
AC_DEFINE(__XSERVERNAME__, "Xorg", [Name of X server])
AC_DEFINE_DIR(XCONFIGFILE, XF86CONFIGFILE, [Name of configuration file])
AC_DEFINE_DIR(XF86CONFIGFILE, XF86CONFIGFILE, [Name of configuration file])
AC_DEFINE_DIR(XCONFIGDIR, XF86CONFIGDIR, [Name of configuration directory])
AC_DEFINE_DIR(DEFAULT_MODULE_PATH, moduledir, [Default module search path])
AC_DEFINE_DIR(DEFAULT_LIBRARY_PATH, libdir, [Default library install path])
AC_DEFINE_DIR(DEFAULT_LOGDIR, logdir, [Default log location])
AC_DEFINE_DIR(DEFAULT_LOGPREFIX, LOGPREFIX, [Default logfile prefix])
AC_DEFINE_DIR(DEFAULT_XDG_DATA_HOME, XDG_DATA_HOME, [Default XDG_DATA dir under HOME])
AC_DEFINE_DIR(DEFAULT_XDG_DATA_HOME_LOGDIR, XDG_DATA_HOME_LOGDIR, [Default log dir under XDG_DATA_HOME])
AC_DEFINE_UNQUOTED(__VENDORDWEBSUPPORT__, ["$VENDOR_WEB"], [Vendor web address for support])
if test "x$VGAHW" = xyes; then
AC_DEFINE(WITH_VGAHW, 1, [Building vgahw module])
fi
driverdir="$moduledir/drivers"
AC_SUBST([moduledir])
AC_SUBST([driverdir])
sdkdir="$includedir/xorg"
extdir="$includedir/X11/extensions"
sysconfigdir="$datadir/X11/$XF86CONFIGDIR"
AC_SUBST([sdkdir])
AC_SUBST([extdir])
AC_SUBST([sysconfigdir])
AC_SUBST([logdir])
# stuff the ABI versions into the pc file too
extract_abi() {
grep ^.define.*${1}_VERSION ${srcdir}/hw/xfree86/common/xf86Module.h | tr '(),' ' .' | awk '{ print $4$5 }'
}
abi_ansic=`extract_abi ANSIC`
abi_videodrv=`extract_abi VIDEODRV`
abi_xinput=`extract_abi XINPUT`
abi_extension=`extract_abi EXTENSION`
AC_SUBST([abi_ansic])
AC_SUBST([abi_videodrv])
AC_SUBST([abi_xinput])
AC_SUBST([abi_extension])
fi
AM_CONDITIONAL([XORG], [test "x$XORG" = xyes])
AM_CONDITIONAL([XORG_BUS_PCI], [test "x$PCI" = xyes])
AM_CONDITIONAL([XORG_BUS_BSDPCI], [test "x$xorg_bus_bsdpci" = xyes])
AM_CONDITIONAL([XORG_BUS_SPARC], [test "x$xorg_bus_sparc" = xyes])
AM_CONDITIONAL([LNXACPI], [test "x$linux_acpi" = xyes])
AM_CONDITIONAL([LNXAPM], [test "x$linux_apm" = xyes])
AM_CONDITIONAL([SOLARIS_VT], [test "x$solaris_vt" = xyes])
AM_CONDITIONAL([DGA], [test "x$DGA" = xyes])
AM_CONDITIONAL([XORG_BUS_PLATFORM], [test "x$CONFIG_UDEV_KMS" = xyes])
AM_CONDITIONAL([XORG_DRIVER_MODESETTING], [test "x$XORG_DRIVER_MODESETTING" = xyes])
dnl glamor
if test "x$GLAMOR" = xauto; then
if echo "$XORG" "$XEPHYR" "$XWAYLAND" | grep -q yes ; then
GLAMOR=yes
fi
fi
AM_CONDITIONAL([GLAMOR], [test "x$GLAMOR" = xyes])
if test "x$GLAMOR" = xyes; then
AC_DEFINE(GLAMOR, 1, [Build glamor])
PKG_CHECK_MODULES([GLAMOR], [epoxy])
PKG_CHECK_EXISTS(epoxy >= 1.4.4,
[AC_DEFINE(GLAMOR_HAS_EGL_QUERY_DMABUF, 1, [Have GLAMOR_HAS_EGL_QUERY_DMABUF])],
[])
PKG_CHECK_MODULES(GBM, "$LIBGBM", [GBM=yes], [GBM=no])
if test "x$GBM" = xyes; then
AC_DEFINE(GLAMOR_HAS_GBM, 1,
[Build glamor with GBM-based EGL support])
AC_CHECK_DECL(GBM_BO_USE_LINEAR,
[AC_DEFINE(GLAMOR_HAS_GBM_LINEAR, 1, [Have GBM_BO_USE_LINEAR])], [],
[#include <stdlib.h>
#include <gbm.h>])
dnl 17.1.0 is required for gbm_bo_create_with_modifiers
PKG_CHECK_EXISTS(gbm >= 17.1.0,
[AC_DEFINE(GBM_BO_WITH_MODIFIERS, 1, [Have gbm_bo_create_with_modifiers])],
[])
else
if test "x$XORG" = xyes; then
AC_MSG_ERROR([Glamor for Xorg requires $LIBGBM])
fi
fi
fi
AM_CONDITIONAL([GLAMOR_EGL], [test "x$GBM" = xyes])
dnl XWin DDX
AC_MSG_CHECKING([whether to build XWin DDX])
if test "x$XWIN" = xauto; then
case $host_os in
cygwin*) XWIN="yes" ;;
mingw*) XWIN="yes" ;;
*) XWIN="no" ;;
esac
fi
AC_MSG_RESULT([$XWIN])
if test "x$XWIN" = xyes; then
AC_DEFINE_DIR(DEFAULT_LOGDIR, logdir, [Default log location])
AC_DEFINE_UNQUOTED(XORG_VERSION_CURRENT, [$VENDOR_RELEASE], [Current Xorg version])
AC_DEFINE_UNQUOTED(__VENDORDWEBSUPPORT__, ["$VENDOR_WEB"], [Vendor web address for support])
AC_CHECK_TOOL(WINDRES, windres)
PKG_CHECK_MODULES([XWINMODULES],[x11 xau xdmcp xfixes x11-xcb xcb-aux xcb-composite xcb-image xcb-ewmh xcb-icccm])
if test "x$WINDOWSDRI" = xauto; then
PKG_CHECK_EXISTS([windowsdriproto], [WINDOWSDRI=yes], [WINDOWSDRI=no])
fi
if test "x$WINDOWSDRI" = xyes ; then
PKG_CHECK_MODULES(WINDOWSDRI, [windowsdriproto])
fi
case $host_os in
cygwin*)
XWIN_SERVER_NAME=XWin
AC_DEFINE(HAS_DEVWINDOWS,1,[Cygwin has /dev/windows for signaling new win32 messages])
;;
mingw*)
XWIN_SERVER_NAME=Xming
AC_DEFINE(RELOCATE_PROJECTROOT,1,[Make PROJECT_ROOT relative to the xserver location])
AC_DEFINE(HAS_WINSOCK,1,[Use Windows sockets])
XWIN_SYS_LIBS="-lpthread -lws2_32"
;;
esac
XWIN_LIBS="$FB_LIB $MI_LIB $FIXES_LIB $XEXT_LIB $RANDR_LIB $RENDER_LIB $DBE_LIB $RECORD_LIB $GLX_LIBS $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $DAMAGE_LIB $PRESENT_LIB $MIEXT_SYNC_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $OS_LIB"
XWIN_SYS_LIBS="$XWIN_SYS_LIBS $XWINMODULES_LIBS"
AC_SUBST(XWIN_LIBS)
AC_SUBST(XWIN_SERVER_NAME)
AC_SUBST(XWIN_SYS_LIBS)
if test "x$DEBUGGING" = xyes; then
AC_DEFINE(CYGDEBUG, 1, [Simple debug messages])
AC_DEFINE(CYGWINDOWING_DEBUG, 1, [Debug messages for window handling])
AC_DEFINE(CYGMULTIWINDOW_DEBUG, 1, [Debug window manager])
fi
AC_DEFINE(DDXOSVERRORF, 1, [Use OsVendorVErrorF])
AC_DEFINE(DDXBEFORERESET, 1, [Use ddxBeforeReset ])
dnl XWin requires OpenGL spec files in order to generate wrapper code for native GL functions
if [test "x$XWIN" = xyes && test "x$GLX" = xyes] ; then
AC_CHECK_PROG(PYTHON3, python3, python3)
if test -z "$PYTHON3"; then
AC_MSG_ERROR([python3 not found])
fi
AC_MSG_CHECKING(for python module lxml)
$PYTHON3 -c "import lxml;"
if test $? -ne 0 ; then
AC_MSG_ERROR([not found])
fi
AC_MSG_RESULT(yes)
if test "x$KHRONOS_SPEC_DIR" = "xauto" ; then
PKG_CHECK_MODULES([KHRONOS_OPENGL_REGISTRY], [khronos-opengl-registry])
KHRONOS_SPEC_DIR=`pkg-config khronos-opengl-registry --variable=specdir`
fi
AC_SUBST(KHRONOS_SPEC_DIR)
fi
fi
AM_CONDITIONAL(XWIN, [test "x$XWIN" = xyes])
AM_CONDITIONAL(XWIN_GLX_WINDOWS, [test "x$XWIN" = xyes && test "x$GLX" = xyes])
AM_CONDITIONAL(XWIN_WINDOWS_DRI, [test "x$XWIN" = xyes && test "x$WINDOWSDRI" = xyes])
dnl Darwin / OS X DDX
if test "x$XQUARTZ" = xyes; then
AC_DEFINE(XQUARTZ,1,[Have Quartz])
AC_DEFINE(ROOTLESS,1,[Build Rootless code])
XQUARTZ_LIBS="$FB_LIB $FIXES_LIB $XEXT_LIB $DBE_LIB $RECORD_LIB $RANDR_LIB $RENDER_LIB $DAMAGE_LIB $MIEXT_SYNC_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $XPSTUBS_LIB $PRESENT_LIB"
AC_SUBST([XQUARTZ_LIBS])
AC_CHECK_LIB([Xplugin],[xp_init],[:])
CFLAGS="${CFLAGS} -DROOTLESS_WORKAROUND -DROOTLESS_SAFEALPHA -DNO_ALLOCA"
PKG_CHECK_MODULES(XPBPROXY, $APPLEWMPROTO $LIBAPPLEWM xfixes x11)
if test "x$XQUARTZ_SPARKLE" = xyes ; then
AC_DEFINE(XQUARTZ_SPARKLE,1,[Support application updating through sparkle.])
fi
if test "x$STANDALONE_XPBPROXY" = xyes ; then
AC_DEFINE(STANDALONE_XPBPROXY,1,[Build a standalone xpbproxy])
fi
fi
AM_CONDITIONAL(PSEUDORAMIX, [test "x$XQUARTZ" = xyes -o "x$XWIN" = xyes ])
# Support for objc in autotools is minimal and not documented.
OBJC='$(CC)'
OBJCLD='$(CCLD)'
OBJCLINK='$(LINK)'
OBJCFLAGS='$(CFLAGS)'
AC_SUBST([OBJC])
AC_SUBST([OBJCCLD])
AC_SUBST([OBJCLINK])
AC_SUBST([OBJCFLAGS])
# internal, undocumented automake func follows :(
_AM_DEPENDENCIES([OBJC])
AM_CONDITIONAL(XQUARTZ, [test "x$XQUARTZ" = xyes])
AM_CONDITIONAL(XQUARTZ_SPARKLE, [test "x$XQUARTZ_SPARKLE" != "xno"])
AM_CONDITIONAL(STANDALONE_XPBPROXY, [test "x$STANDALONE_XPBPROXY" = xyes])
dnl DMX DDX
PKG_CHECK_MODULES(
[DMXMODULES],
[xmuu $LIBXEXT x11 >= 1.6 xrender xfixes $LIBXI $DMXPROTO xau $XDMCP_MODULES],
[PKG_CHECK_MODULES(
[XDMXCONFIG_DEP],
[xaw7 xmu xt xpm x11],
[have_dmx=yes],
[have_dmx=no])],
[have_dmx=no])
AC_MSG_CHECKING([whether to build Xdmx DDX])
if test "x$DMX" = xauto; then
DMX="$have_dmx"
case $host_os in
cygwin*) DMX="no" ;;
mingw*) DMX="no" ;;
darwin*) DMX="no" ;;
esac
fi
AC_MSG_RESULT([$DMX])
AM_CONDITIONAL(DMX, [test "x$DMX" = xyes])
if test "x$DMX" = xyes; then
if test "x$have_dmx" = xno; then
AC_MSG_ERROR([Xdmx build explicitly requested, but required
modules not found.])
fi
DMX_INCLUDES="$XEXT_INC $RENDER_INC $RECORD_INC"
XDMX_CFLAGS="$DMXMODULES_CFLAGS"
XDMX_LIBS="$FB_LIB $MI_LIB $XEXT_LIB $RENDER_LIB $RECORD_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $DRI3_LIB $PRESENT_LIB $MIEXT_SYNC_LIB $MIEXT_SHADOW_LIB $MIEXT_DAMAGE_LIB $COMPOSITE_LIB $DAMAGE_LIB $MAIN_LIB $DIX_LIB $RANDR_LIB $CONFIG_LIB $OS_LIB $FIXES_LIB"
XDMX_SYS_LIBS="$DMXMODULES_LIBS"
AC_SUBST([XDMX_CFLAGS])
AC_SUBST([XDMX_LIBS])
AC_SUBST([XDMX_SYS_LIBS])
dnl USB sources in DMX require <linux/input.h>
AC_CHECK_HEADER([linux/input.h], DMX_BUILD_USB="yes",
DMX_BUILD_USB="no")
AC_SUBST(XDMXCONFIG_DEP_CFLAGS)
AC_SUBST(XDMXCONFIG_DEP_LIBS)
PKG_CHECK_MODULES([DMXEXAMPLES_DEP], [$LIBDMX $LIBXEXT x11])
AC_SUBST(DMXEXAMPLES_DEP_LIBS)
PKG_CHECK_MODULES([DMXXMUEXAMPLES_DEP], [$LIBDMX xmu $LIBXEXT x11])
AC_SUBST(DMXXMUEXAMPLES_DEP_LIBS)
PKG_CHECK_MODULES([DMXXIEXAMPLES_DEP], [$LIBDMX $LIBXI $LIBXEXT x11])
AC_SUBST(DMXXIEXAMPLES_DEP_LIBS)
PKG_CHECK_MODULES([XTSTEXAMPLES_DEP], [$LIBXTST $LIBXEXT x11])
AC_SUBST(XTSTEXAMPLES_DEP_LIBS)
PKG_CHECK_MODULES([XRESEXAMPLES_DEP], [xres $LIBXEXT x11])
AC_SUBST(XRESEXAMPLES_DEP_LIBS)
PKG_CHECK_MODULES([X11EXAMPLES_DEP], [$LIBXEXT x11])
AC_SUBST(X11EXAMPLES_DEP_LIBS)
fi
AM_CONDITIONAL([DMX_BUILD_USB], [test "x$DMX_BUILD_USB" = xyes])
dnl kdrive DDX
XEPHYR_LIBS=
XEPHYR_INCS=
AM_CONDITIONAL(KDRIVE, [test x$KDRIVE = xyes])
if test "$KDRIVE" = yes; then
XEPHYR_REQUIRED_LIBS="xau xdmcp xcb xcb-shape xcb-render xcb-renderutil xcb-aux xcb-image xcb-icccm xcb-shm >= 1.9.3 xcb-keysyms xcb-randr xcb-xkb"
if test "x$XV" = xyes; then
XEPHYR_REQUIRED_LIBS="$XEPHYR_REQUIRED_LIBS xcb-xv"
fi
if test "x$DRI" = xyes && test "x$GLX" = xyes; then
XEPHYR_REQUIRED_LIBS="$XEPHYR_REQUIRED_LIBS $LIBDRM xcb-glx xcb-xf86dri > 1.6"
fi
if test "x$GLAMOR" = xyes; then
XEPHYR_REQUIRED_LIBS="$XEPHYR_REQUIRED_LIBS x11-xcb"
fi
if test "x$XEPHYR" = xauto; then
PKG_CHECK_MODULES(XEPHYR, $XEPHYR_REQUIRED_LIBS, [XEPHYR="yes"], [XEPHYR="no"])
elif test "x$XEPHYR" = xyes ; then
PKG_CHECK_MODULES(XEPHYR, $XEPHYR_REQUIRED_LIBS)
fi
# Xephyr needs nanosleep() which is in librt on Solaris
AC_CHECK_FUNC([nanosleep], [],
AC_CHECK_LIB([rt], [nanosleep], XEPHYR_LIBS="$XEPHYR_LIBS -lrt"))
# damage shadow extension glx (NOTYET) fb mi
KDRIVE_INC='-I$(top_srcdir)/hw/kdrive/src'
KDRIVE_PURE_INCS="$KDRIVE_INC $MIEXT_SYNC_INC $MIEXT_DAMAGE_INC $MIEXT_SHADOW_INC $XEXT_INC $FB_INC $MI_INC"
KDRIVE_OS_INC='-I$(top_srcdir)/hw/kdrive/linux'
KDRIVE_INCS="$KDRIVE_PURE_INCS $KDRIVE_OS_INC"
KDRIVE_CFLAGS="$XSERVER_CFLAGS"
KDRIVE_PURE_LIBS="$FB_LIB $MI_LIB $FIXES_LIB $XEXT_LIB $DBE_LIB $RECORD_LIB $GLX_LIBS $RANDR_LIB $RENDER_LIB $DAMAGE_LIB $DRI3_LIB $PRESENT_LIB $MIEXT_SYNC_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $OS_LIB"
KDRIVE_LIB='$(top_builddir)/hw/kdrive/src/libkdrive.la'
KDRIVE_MAIN_LIB="$MAIN_LIB"
KDRIVE_LOCAL_LIBS="$DIX_LIB $KDRIVE_LIB"
KDRIVE_LOCAL_LIBS="$KDRIVE_LOCAL_LIBS $FB_LIB $MI_LIB $KDRIVE_PURE_LIBS"
KDRIVE_LOCAL_LIBS="$KDRIVE_LOCAL_LIBS $KDRIVE_OS_LIB"
KDRIVE_LIBS="$KDRIVE_LOCAL_LIBS $XSERVER_SYS_LIBS $GLX_SYS_LIBS $DLOPEN_LIBS"
AC_SUBST([XEPHYR_LIBS])
AC_SUBST([XEPHYR_INCS])
fi
AC_SUBST([KDRIVE_INCS])
AC_SUBST([KDRIVE_PURE_INCS])
AC_SUBST([KDRIVE_CFLAGS])
AC_SUBST([KDRIVE_PURE_LIBS])
AC_SUBST([KDRIVE_MAIN_LIB])
AC_SUBST([KDRIVE_LOCAL_LIBS])
AC_SUBST([KDRIVE_LIBS])
AM_CONDITIONAL(XEPHYR, [test "x$KDRIVE" = xyes && test "x$XEPHYR" = xyes])
dnl Xwayland DDX
XWAYLANDMODULES="wayland-client >= 1.3.0 wayland-protocols >= 1.10 $LIBDRM epoxy"
if test "x$XF86VIDMODE" = xyes; then
XWAYLANDMODULES="$XWAYLANDMODULES $VIDMODEPROTO"
fi
PKG_CHECK_MODULES(XWAYLANDMODULES, [$XWAYLANDMODULES], [have_xwayland=yes], [have_xwayland=no])
AC_MSG_CHECKING([whether to build Xwayland DDX])
if test "x$XWAYLAND" = xauto; then
XWAYLAND="$have_xwayland"
fi
AC_MSG_RESULT([$XWAYLAND])
AM_CONDITIONAL(XWAYLAND, [test "x$XWAYLAND" = xyes])
if test "x$XWAYLAND" = xyes; then
if test "x$have_xwayland" = xno; then
AC_MSG_ERROR([Xwayland build explicitly requested, but required modules not found.])
fi
if test "x$GLAMOR" = xyes && test "x$GBM" = xyes; then
AC_DEFINE(XWL_HAS_GLAMOR, 1,
[Build xwayland with glamor support])
fi
PKG_CHECK_MODULES(WAYLAND_EGLSTREAM, [wayland-eglstream-protocols >= 1.0.2], [have_wl_eglstream=yes], [have_wl_eglstream=no])
if test "x$XWAYLAND_EGLSTREAM" = xauto; then
if test "x$have_wl_eglstream" = xyes && test "x$GLAMOR" = xyes; then
XWAYLAND_EGLSTREAM=yes
fi
fi
if test "x$XWAYLAND_EGLSTREAM" = xyes; then
if test "x$GLAMOR" != xyes; then
AC_MSG_ERROR([Xwayland eglstream support explicitly requested, but required modules not found.])
fi
if test "x$have_wl_eglstream" = xno; then
AC_MSG_ERROR([Xwayland eglstream support requires wayland-eglstream-protocols >= 1.0.2])
fi
AC_SUBST(WAYLAND_EGLSTREAM_DATADIR, `$PKG_CONFIG --variable=pkgdatadir wayland-eglstream-protocols`)
AC_DEFINE(XWL_HAS_EGLSTREAM, 1,
[Build xwayland with eglstream support])
fi
XWAYLAND_LIBS="$FB_LIB $FIXES_LIB $MI_LIB $XEXT_LIB $DBE_LIB $RECORD_LIB $GLX_LIBS $RANDR_LIB $RENDER_LIB $DAMAGE_LIB $DRI3_LIB $PRESENT_LIB $MIEXT_SYNC_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $MAIN_LIB $DIX_LIB $OS_LIB"
XWAYLAND_SYS_LIBS="$XWAYLANDMODULES_LIBS $GLX_SYS_LIBS"
AC_SUBST([XWAYLAND_LIBS])
AC_SUBST([XWAYLAND_SYS_LIBS])
if test "x$MONOTONIC_CLOCK" != xyes; then
AC_MSG_ERROR([Xwayland requires CLOCK_MONOTONIC support.])
fi
AC_PATH_PROG([WAYLAND_SCANNER], [wayland-scanner])
if test "x$WAYLAND_SCANNER" = x; then
PKG_CHECK_MODULES(WAYLAND_SCANNER, [wayland-scanner])
AC_SUBST(WAYLAND_SCANNER, `$PKG_CONFIG --variable=wayland_scanner wayland-scanner`)
fi
PKG_CHECK_MODULES(WAYLAND_SCANNER, [wayland-scanner >= 1.14.91],
AC_SUBST(SCANNER_ARG, 'private-code'),
AC_SUBST(SCANNER_ARG, 'code'))
AC_SUBST(WAYLAND_PROTOCOLS_DATADIR, `$PKG_CONFIG --variable=pkgdatadir wayland-protocols`)
fi
AM_CONDITIONAL(XWAYLAND_EGLSTREAM, [test "x$XWAYLAND_EGLSTREAM" = "xyes"])
dnl and the rest of these are generic, so they're in config.h
dnl
dnl though, thanks to the passing of some significant amount of time, the
dnl above is probably a complete fallacy, and you should not rely on it.
dnl but this is still actually better than imake, honest. -daniels
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <features.h>
#ifndef __GLIBC__
#error not glibc
#endif
]], [])], [AC_DEFINE(_GNU_SOURCE, 1,
[ Enable GNU and other extensions to the C environment for glibc])])
AC_DEFINE_DIR(PROJECTROOT, prefix, [Overall prefix])
AC_DEFINE_DIR(SYSCONFDIR, sysconfdir, [sysconfdir])
AC_SUBST([RELEASE_DATE])
DATE_FMT="%Y%m%d"
TIME_FMT="1%H%M%S"
BUILD_DATE="`date "+$DATE_FMT"`"
BUILD_TIME="`date "+$TIME_FMT"`"
if test "x$SOURCE_DATE_EPOCH" != "x"; then
BUILD_DATE="`date -u -d "@$SOURCE_DATE_EPOCH" "+$DATE_FMT" 2>/dev/null || date -u -r "$SOURCE_DATE_EPOCH" "+$DATE_FMT" 2>/dev/null || date -u "+$DATE_FMT"`"
BUILD_TIME="`date -u -d "@$SOURCE_DATE_EPOCH" "+$TIME_FMT" 2>/dev/null || date -u -r "$SOURCE_DATE_EPOCH" "+$TIME_FMT" 2>/dev/null || date -u "+$TIME_FMT"`"
fi
AC_SUBST([BUILD_DATE])
AC_SUBST([BUILD_TIME])
DIX_CFLAGS="-DHAVE_DIX_CONFIG_H $XSERVER_CFLAGS"
AC_SUBST([DIX_CFLAGS])
AC_SUBST([libdir])
AC_SUBST([exec_prefix])
AC_SUBST([prefix])
AC_CONFIG_COMMANDS([sdksyms], [touch hw/xfree86/sdksyms.dep])
if test "x$CONFIG_HAL" = xno && test "x$CONFIG_UDEV" = xno; then
AC_MSG_WARN([
***********************************************
Neither HAL nor udev backend will be enabled.
Input device hotplugging will not be available!
***********************************************])
fi
AC_CONFIG_FILES([
buildDateTime.h
Makefile
glx/Makefile
include/Makefile
composite/Makefile
damageext/Makefile
dbe/Makefile
dix/Makefile
doc/Makefile
doc/dtrace/Makefile
man/Makefile
fb/Makefile
glamor/Makefile
record/Makefile
config/Makefile
mi/Makefile
miext/Makefile
miext/sync/Makefile
miext/damage/Makefile
miext/shadow/Makefile
miext/rootless/Makefile
os/Makefile
pseudoramiX/Makefile
randr/Makefile
render/Makefile
xkb/Makefile
Xext/Makefile
Xi/Makefile
xfixes/Makefile
exa/Makefile
dri3/Makefile
present/Makefile
hw/Makefile
hw/xfree86/Makefile
hw/xfree86/Xorg.sh
hw/xfree86/common/Makefile
hw/xfree86/ddc/Makefile
hw/xfree86/dixmods/Makefile
hw/xfree86/doc/Makefile
hw/xfree86/dri/Makefile
hw/xfree86/dri2/Makefile
hw/xfree86/dri2/pci_ids/Makefile
hw/xfree86/drivers/Makefile
hw/xfree86/drivers/modesetting/Makefile
hw/xfree86/exa/Makefile
hw/xfree86/exa/man/Makefile
hw/xfree86/fbdevhw/Makefile
hw/xfree86/fbdevhw/man/Makefile
hw/xfree86/glamor_egl/Makefile
hw/xfree86/i2c/Makefile
hw/xfree86/int10/Makefile
hw/xfree86/loader/Makefile
hw/xfree86/man/Makefile
hw/xfree86/modes/Makefile
hw/xfree86/os-support/Makefile
hw/xfree86/os-support/bsd/Makefile
hw/xfree86/os-support/bus/Makefile
hw/xfree86/os-support/hurd/Makefile
hw/xfree86/os-support/misc/Makefile
hw/xfree86/os-support/linux/Makefile
hw/xfree86/os-support/solaris/Makefile
hw/xfree86/os-support/stub/Makefile
hw/xfree86/parser/Makefile
hw/xfree86/ramdac/Makefile
hw/xfree86/shadowfb/Makefile
hw/xfree86/vbe/Makefile
hw/xfree86/vgahw/Makefile
hw/xfree86/x86emu/Makefile
hw/xfree86/xkb/Makefile
hw/xfree86/utils/Makefile
hw/xfree86/utils/man/Makefile
hw/xfree86/utils/cvt/Makefile
hw/xfree86/utils/gtf/Makefile
hw/dmx/config/Makefile
hw/dmx/config/man/Makefile
hw/dmx/doc/Makefile
hw/dmx/doxygen/doxygen.conf
hw/dmx/doxygen/Makefile
hw/dmx/examples/Makefile
hw/dmx/input/Makefile
hw/dmx/glxProxy/Makefile
hw/dmx/Makefile
hw/dmx/man/Makefile
hw/vfb/Makefile
hw/vfb/man/Makefile
hw/xnest/Makefile
hw/xnest/man/Makefile
hw/xwin/Makefile
hw/xwin/dri/Makefile
hw/xwin/glx/Makefile
hw/xwin/man/Makefile
hw/xwin/winclipboard/Makefile
hw/xquartz/Makefile
hw/xquartz/GL/Makefile
hw/xquartz/bundle/Makefile
hw/xquartz/man/Makefile
hw/xquartz/mach-startup/Makefile
hw/xquartz/pbproxy/Makefile
hw/xquartz/xpr/Makefile
hw/kdrive/Makefile
hw/kdrive/ephyr/Makefile
hw/kdrive/ephyr/man/Makefile
hw/kdrive/src/Makefile
hw/xwayland/Makefile
test/Makefile
xserver.ent
xorg-server.pc
])
AC_OUTPUT
| {
"language": "Assembly"
} |
/* misc.c
*
* Copyright (C) 2006-2017 wolfSSL Inc.
*
* This file is part of wolfSSL.
*
* wolfSSL is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* wolfSSL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
*/
#ifdef NO_INLINE
#include <wolfssl/wolfcrypt/misc.h>
#else
/* for inline includes */
#define WOLFSSL_MISC_INCLUDED
#include <wolfcrypt/src/misc.c>
#endif
| {
"language": "Assembly"
} |
; RUN: opt < %s -instcombine -S | FileCheck %s
define i32 @t1(i16 zeroext %x, i32 %y) nounwind {
entry:
; CHECK: t1
; CHECK-NOT: sdiv
; CHECK: lshr i32 %conv
%conv = zext i16 %x to i32
%s = shl i32 2, %y
%d = sdiv i32 %conv, %s
ret i32 %d
}
; rdar://11721329
define i64 @t2(i64 %x, i32 %y) nounwind {
; CHECK: t2
; CHECK-NOT: udiv
; CHECK: lshr i64 %x
%1 = shl i32 1, %y
%2 = zext i32 %1 to i64
%3 = udiv i64 %x, %2
ret i64 %3
}
; PR13250
define i64 @t3(i64 %x, i32 %y) nounwind {
; CHECK: t3
; CHECK-NOT: udiv
; CHECK-NEXT: %1 = add i32 %y, 2
; CHECK-NEXT: %2 = zext i32 %1 to i64
; CHECK-NEXT: %3 = lshr i64 %x, %2
; CHECK-NEXT: ret i64 %3
%1 = shl i32 4, %y
%2 = zext i32 %1 to i64
%3 = udiv i64 %x, %2
ret i64 %3
}
define i32 @t4(i32 %x, i32 %y) nounwind {
; CHECK: t4
; CHECK-NOT: udiv
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 %y, 5
; CHECK-NEXT: [[SEL:%.*]] = select i1 [[CMP]], i32 5, i32 %y
; CHECK-NEXT: [[SHR:%.*]] = lshr i32 %x, [[SEL]]
; CHECK-NEXT: ret i32 [[SHR]]
%1 = shl i32 1, %y
%2 = icmp ult i32 %1, 32
%3 = select i1 %2, i32 32, i32 %1
%4 = udiv i32 %x, %3
ret i32 %4
}
define i32 @t5(i1 %x, i1 %y, i32 %V) nounwind {
; CHECK: t5
; CHECK-NOT: udiv
; CHECK-NEXT: [[SEL1:%.*]] = select i1 %x, i32 5, i32 6
; CHECK-NEXT: [[LSHR:%.*]] = lshr i32 %V, [[SEL1]]
; CHECK-NEXT: [[SEL2:%.*]] = select i1 %y, i32 [[LSHR]], i32 0
; CHECK-NEXT: ret i32 [[SEL2]]
%1 = shl i32 1, %V
%2 = select i1 %x, i32 32, i32 64
%3 = select i1 %y, i32 %2, i32 %1
%4 = udiv i32 %V, %3
ret i32 %4
}
define i32 @t6(i32 %x, i32 %z) nounwind{
; CHECK: t6
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 %x, 0
; CHECK-NOT: udiv i32 %z, %x
%x_is_zero = icmp eq i32 %x, 0
%divisor = select i1 %x_is_zero, i32 1, i32 %x
%y = udiv i32 %z, %divisor
ret i32 %y
}
| {
"language": "Assembly"
} |
#include "arm/sysregs.h"
#include "mm.h"
.section ".text.boot"
.globl _start
_start:
mrs x0, mpidr_el1
and x0, x0,#0xFF // Check processor id
cbz x0, master // Hang for all non-primary CPU
b proc_hang
proc_hang:
b proc_hang
master:
ldr x0, =SCTLR_VALUE_MMU_DISABLED
msr sctlr_el1, x0
ldr x0, =HCR_VALUE
msr hcr_el2, x0
ldr x0, =SCR_VALUE
msr scr_el3, x0
ldr x0, =SPSR_VALUE
msr spsr_el3, x0
adr x0, el1_entry
msr elr_el3, x0
eret
el1_entry:
adr x0, bss_begin
adr x1, bss_end
sub x1, x1, x0
bl memzero
mov sp, #LOW_MEMORY
bl kernel_main
b proc_hang // should never come here
| {
"language": "Assembly"
} |
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build !gccgo
#include "textflag.h"
//
// System call support for AMD64, DragonFly
//
// Just jump to package syscall's implementation for all these functions.
// The runtime may know about them.
TEXT ·Syscall(SB),NOSPLIT,$0-56
JMP syscall·Syscall(SB)
TEXT ·Syscall6(SB),NOSPLIT,$0-80
JMP syscall·Syscall6(SB)
TEXT ·Syscall9(SB),NOSPLIT,$0-104
JMP syscall·Syscall9(SB)
TEXT ·RawSyscall(SB),NOSPLIT,$0-56
JMP syscall·RawSyscall(SB)
TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
JMP syscall·RawSyscall6(SB)
| {
"language": "Assembly"
} |
SECTION code_clib
PUBLIC txtwrchar
PUBLIC _txtwrchar
; fastcall so in HL!
.txtwrchar
._txtwrchar
ld a, l
jp 0xB83C
| {
"language": "Assembly"
} |
; boardcore.inc dummy file
;===============================================================
.ifne HAS_LED7SEG
; LED_MPX driver ( -- )
; Code called from ISR for LED MPX
LED_MPX:
RET
.endif
;===============================================================
.ifne HAS_OUTPUTS
; OUT! ( c -- )
; Put c to board outputs, storing a copy in OUTPUTS
.dw LINK
LINK = .
.db (4)
.ascii "OUT!"
OUTSTOR:
RET
.endif
;===============================================================
.ifne HAS_KEYS
; BKEY ( -- f ) ( TOS STM8: -- A,Z,N )
; Read board key state as a bitfield
.dw LINK
LINK = .
.db (4)
.ascii "BKEY"
BKEY:
CLR A
JP ASTOR
; BKEYC ( -- c ) ( TOS STM8: -- A,Z,N )
; Read and translate board dependent key bitmap into char
BKEYCHAR:
JRA BKEY ; Dummy: get "no key" and leave it as it is
.endif
;===============================================================
; BOARDINIT ( -- )
; Init board GPIO (except COM ports)
BOARDINIT:
; Board I/O initialization
RET
| {
"language": "Assembly"
} |
;
; Ullrich von Bassewitz, 31.05.1998
;
; Data for the stdio file stream.
;
.export __filetab
.include "stdio.inc"
.include "fcntl.inc"
.include "_file.inc"
;----------------------------------------------------------------------------
; File data
.data
__filetab:
.byte 0, _FOPEN, 0 ; stdin
.byte 1, _FOPEN, 0 ; stdout
.byte 2, _FOPEN, 0 ; stderr
.repeat FOPEN_MAX - 3
.byte 0, _FCLOSED, 0 ; free slot
.endrepeat
; Standard file descriptors
_stdin:
.word __filetab + (STDIN_FILENO * .sizeof(_FILE))
_stdout:
.word __filetab + (STDOUT_FILENO * .sizeof(_FILE))
_stderr:
.word __filetab + (STDERR_FILENO * .sizeof(_FILE))
| {
"language": "Assembly"
} |
// General tests that as(1) invocations on AIX targets are sane. Note that we
// only test assembler functionalities in this suite.
// Check powerpc-ibm-aix7.1.0.0, 32-bit.
// RUN: %clang -no-canonical-prefixes %s -### -c -o %t.o 2>&1 \
// RUN: -target powerpc-ibm-aix7.1.0.0 \
// RUN: | FileCheck --check-prefix=CHECK-AS32 %s
// CHECK-AS32-NOT: warning:
// CHECK-AS32: {{.*}}clang{{(.exe)?}}" "-cc1" "-triple" "powerpc-ibm-aix7.1.0.0"
// CHECK-AS32: "{{.*}}as{{(.exe)?}}"
// CHECK-AS32: "-a32"
// CHECK-AS32: "-u"
// CHECK-AS32: "-many"
// Check powerpc64-ibm-aix7.1.0.0, 64-bit.
// RUN: %clang -no-canonical-prefixes %s -### -c -o %t.o 2>&1 \
// RUN: -target powerpc64-ibm-aix7.1.0.0 \
// RUN: | FileCheck --check-prefix=CHECK-AS64 %s
// CHECK-AS64-NOT: warning:
// CHECK-AS64: {{.*}}clang{{(.exe)?}}" "-cc1" "-triple" "powerpc64-ibm-aix7.1.0.0"
// CHECK-AS64: "{{.*}}as{{(.exe)?}}"
// CHECK-AS64: "-a64"
// CHECK-AS64: "-u"
// CHECK-AS64: "-many"
// Check powerpc-ibm-aix7.1.0.0, 32-bit. -Xassembler <arg> option.
// RUN: %clang -no-canonical-prefixes %s -### -c -o %t.o 2>&1 \
// RUN: -Xassembler -w \
// RUN: -target powerpc-ibm-aix7.1.0.0 \
// RUN: | FileCheck --check-prefix=CHECK-AS32-Xassembler %s
// CHECK-AS32-Xassembler-NOT: warning:
// CHECK-AS32-Xassembler: {{.*}}clang{{(.exe)?}}" "-cc1" "-triple" "powerpc-ibm-aix7.1.0.0"
// CHECK-AS32-Xassembler: "{{.*}}as{{(.exe)?}}"
// CHECK-AS32-Xassembler: "-a32"
// CHECK-AS32-Xassembler: "-u"
// CHECK-AS32-Xassembler: "-many"
// CHECK-AS32-Xassembler: "-w"
// Check powerpc64-ibm-aix7.1.0.0, 64-bit. -Wa,<arg>,<arg> option.
// RUN: %clang -no-canonical-prefixes %s -### -c -o %t.o 2>&1 \
// RUN: -Wa,-v,-w \
// RUN: -target powerpc64-ibm-aix7.1.0.0 \
// RUN: | FileCheck --check-prefix=CHECK-AS64-Wa %s
// CHECK-AS64-Wa-NOT: warning:
// CHECK-AS64-Wa: {{.*}}clang{{(.exe)?}}" "-cc1" "-triple" "powerpc64-ibm-aix7.1.0.0"
// CHECK-AS64-Wa: "{{.*}}as{{(.exe)?}}"
// CHECK-AS64-Wa: "-a64"
// CHECK-AS64-Wa: "-u"
// CHECK-AS64-Wa: "-many"
// CHECK-AS64-Wa: "-v"
// CHECK-AS64-Wa: "-w"
// Check powerpc-ibm-aix7.1.0.0, 32-bit. Multiple input files.
// RUN: %clang -no-canonical-prefixes -### -c \
// RUN: %S/Inputs/aix_ppc_tree/dummy0.s \
// RUN: %S/Inputs/aix_ppc_tree/dummy1.s \
// RUN: %S/Inputs/aix_ppc_tree/dummy2.s 2>&1 \
// RUN: -target powerpc-ibm-aix7.1.0.0 \
// RUN: | FileCheck --check-prefix=CHECK-AS32-MultiInput %s
// CHECK-AS32-MultiInput-NOT: warning:
// CHECK-AS32-MultiInput: "{{.*}}as{{(.exe)?}}"
// CHECK-AS32-MultiInput: "-a32"
// CHECK-AS32-MultiInput: "-u"
// CHECK-AS32-MultiInput: "-many"
// CHECK-AS32-MultiInput: "{{.*}}as{{(.exe)?}}"
// CHECK-AS32-MultiInput: "-a32"
// CHECK-AS32-MultiInput: "-u"
// CHECK-AS32-MultiInput: "-many"
// CHECK-AS32-MultiInput: "{{.*}}as{{(.exe)?}}"
// CHECK-AS32-MultiInput: "-a32"
// CHECK-AS32-MultiInput: "-u"
// CHECK-AS32-MultiInput: "-many"
| {
"language": "Assembly"
} |
/*!
* \copy
* Copyright (c) 2013, Cisco Systems
* 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.
*
* 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 HOLDER 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.
*
*/
#ifdef HAVE_NEON
#include "arm_arch_common_macro.S"
.macro LOAD_4x4_DATA_FOR_DCT arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7
// { // input: \arg0~\arg3, src1*, src1_stride, src2*, src2_stride
vld2.16 {\arg0[0],\arg1[0]}, [\arg4], \arg5
vld2.16 {\arg2[0],\arg3[0]}, [\arg6], \arg7
vld2.16 {\arg0[1],\arg1[1]}, [\arg4], \arg5
vld2.16 {\arg2[1],\arg3[1]}, [\arg6], \arg7
vld2.16 {\arg0[2],\arg1[2]}, [\arg4], \arg5
vld2.16 {\arg2[2],\arg3[2]}, [\arg6], \arg7
vld2.16 {\arg0[3],\arg1[3]}, [\arg4], \arg5
vld2.16 {\arg2[3],\arg3[3]}, [\arg6], \arg7
// }
.endm
.macro LOAD_8x8_DATA_FOR_DCT arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9
// { // input: \arg0~\arg3, src1*, src2*; untouched r2:src1_stride &r4:src2_stride
vld1.64 {\arg0}, [\arg8], r2
vld1.64 {\arg4}, [\arg9], r4
vld1.64 {\arg1}, [\arg8], r2
vld1.64 {\arg5}, [\arg9], r4
vld1.64 {\arg2}, [\arg8], r2
vld1.64 {\arg6}, [\arg9], r4
vld1.64 {\arg3}, [\arg8], r2
vld1.64 {\arg7}, [\arg9], r4
// }
.endm
.macro DCT_ROW_TRANSFORM_TOTAL_16BITS arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7
// { // input: src_d[0]~[3], working: [4]~[7]
vadd.s16 \arg4, \arg0, \arg3 //int16 s[0] = data[i] + data[i3];
vsub.s16 \arg7, \arg0, \arg3 //int16 s[3] = data[i] - data[i3];
vadd.s16 \arg5, \arg1, \arg2 //int16 s[1] = data[i1] + data[i2];
vsub.s16 \arg6, \arg1, \arg2 //int16 s[2] = data[i1] - data[i2];
vadd.s16 \arg0, \arg4, \arg5 //int16 dct[i ] = s[0] + s[1];
vsub.s16 \arg2, \arg4, \arg5 //int16 dct[i2] = s[0] - s[1];
vshl.s16 \arg1, \arg7, #1
vshl.s16 \arg3, \arg6, #1
vadd.s16 \arg1, \arg1, \arg6 //int16 dct[i1] = (s[3] << 1) + s[2];
vsub.s16 \arg3, \arg7, \arg3 //int16 dct[i3] = s[3] - (s[2] << 1);
// }
.endm
.macro MATRIX_TRANSFORM_EACH_16BITS arg0, arg1, arg2, arg3
// { // input & output: src_d[0]~[3];[0 1 2 3]+[4 5 6 7]+[8 9 10 11]+[12 13 14 15]
vtrn.s16 \arg0, \arg1 //[0 1 2 3]+[4 5 6 7]-->[0 4 2 6]+[1 5 3 7]
vtrn.s16 \arg2, \arg3 //[8 9 10 11]+[12 13 14 15]-->[8 12 10 14]+[9 13 11 15]
vtrn.32 \arg0, \arg2 //[0 4 2 6]+[8 12 10 14]-->[0 4 8 12]+[2 6 10 14]
vtrn.32 \arg1, \arg3 //[1 5 3 7]+[9 13 11 15]-->[1 5 9 13]+[3 7 11 15]
// }
.endm
.macro NEWQUANT_COEF_EACH_16BITS arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8
// { // input: coef, ff (dst), ff_d0, ff_d1, mf_d0, md_d1
veor.s16 \arg6, \arg6 // init 0 , and keep 0;
vaba.s16 \arg1, \arg0, \arg6 // f + abs(coef - 0)
vmull.s16 \arg7, \arg2, \arg4
vmull.s16 \arg8, \arg3, \arg5
vshr.s32 \arg7, #16
vshr.s32 \arg8, #16
vmovn.s32 \arg2, \arg7
vmovn.s32 \arg3, \arg8
vcgt.s16 \arg7, \arg0, #0 // if true, location of coef == 11111111
vbif.s16 \arg6, \arg1, \arg7 // if (x<0) reserved part; else keep 0 untouched
vshl.s16 \arg6, #1
vsub.s16 \arg1, \arg1, \arg6 // if x > 0, -= 0; else x-= 2x
// }
.endm
.macro NEWQUANT_COEF_EACH_16BITS_MAX arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9
// { // input: coef, ff (dst), ff_d0, ff_d1, mf_d0(max), md_d1
veor.s16 \arg6, \arg6 // init 0 , and keep 0;
vaba.s16 \arg1, \arg0, \arg6 // f + abs(coef - 0)
vmull.s16 \arg7, \arg2, \arg4
vmull.s16 \arg8, \arg3, \arg5
vshr.s32 \arg7, #16
vshr.s32 \arg8, #16
vmovn.s32 \arg2, \arg7
vmovn.s32 \arg3, \arg8
vcgt.s16 \arg7, \arg0, #0 // if true, location of coef == 11111111
vbif.s16 \arg6, \arg1, \arg7 // if (x<0) reserved part; else keep 0 untouched
vshl.s16 \arg6, #1
vmax.s16 \arg9, \arg2, \arg3
vsub.s16 \arg1, \arg1, \arg6 // if x > 0, -= 0; else x-= 2x
// }
.endm
.macro QUANT_DUALWORD_COEF_EACH_16BITS arg0, arg1, arg2, arg3, arg4
// { // input: coef, ff (dst), mf , working_d (all 0), working_q
vaba.s16 \arg1, \arg0, \arg3 // f + abs(coef - 0)
vmull.s16 \arg4, \arg1, \arg2 // *= mf
vshr.s32 \arg4, #16
vmovn.s32 \arg1, \arg4 // >> 16
vcgt.s16 \arg2, \arg0, #0 // if true, location of coef == 11111111
vbif.s16 \arg3, \arg1, \arg2 // if (x<0) reserved part; else keep 0 untouched
vshl.s16 \arg3, #1
vsub.s16 \arg1, \arg1, \arg3 // if x > 0, -= 0; else x-= 2x
// }
.endm
.macro DC_ZERO_COUNT_IN_DUALWORD arg0, arg1, arg2
// { // input: coef, dst_d, working_d (all 0x01)
vceq.s16 \arg1, \arg0, #0
vand.s16 \arg1, \arg2
vpadd.s16 \arg1, \arg1, \arg1
vpadd.s16 \arg1, \arg1, \arg1
// }
.endm
.macro SELECT_MAX_IN_ABS_COEF arg0, arg1, arg2, arg3, arg4
// { // input: coef_0, coef_1, max_q (identy to follow two), output: max_d0, max_d1
vmax.s16 \arg2, \arg0, \arg1 // max 1st in \arg3 & max 2nd in \arg4
vpmax.s16 \arg3, \arg3, \arg4 // max 1st in \arg3[0][1] & max 2nd in \arg3[2][3]
vpmax.s16 \arg3, \arg3, \arg4 // max 1st in \arg3[0][1]
// }
.endm
.macro ZERO_COUNT_IN_2_QUARWORD arg0, arg1, arg2, arg3, arg4, arg5, arg6
// { // input: coef_0 (identy to \arg3 \arg4), coef_1(identy to \arg5 \arg6), mask_q
vceq.s16 \arg0, #0
vceq.s16 \arg1, #0
vand.s16 \arg0, \arg2
vand.s16 \arg1, \arg2
vpadd.s16 \arg3, \arg3, \arg5
vpadd.s16 \arg4, \arg4, \arg6
vpadd.s16 \arg3, \arg3, \arg4 // 8-->4
vpadd.s16 \arg3, \arg3, \arg3
vpadd.s16 \arg3, \arg3, \arg3
// }
.endm
.macro HDM_QUANT_2x2_TOTAL_16BITS arg0, arg1, arg2
// { // input: src_d[0]~[3], working_d, dst_d
vshr.s64 \arg1, \arg0, #32
vadd.s16 \arg2, \arg0, \arg1 // [0] = rs[0] + rs[32];[1] = rs[16] + rs[48];
vsub.s16 \arg1, \arg0, \arg1 // [0] = rs[0] - rs[32];[1] = rs[16] - rs[48];
vtrn.s16 \arg2, \arg1
vtrn.s32 \arg2, \arg1
// }
.endm
.macro IHDM_4x4_TOTAL_16BITS arg0, arg1, arg2
// { // input: each src_d[0]~[3](dst), working_q0, working_q1, working_q2
vshr.s64 \arg1, \arg0, #32
vadd.s16 \arg2, \arg0, \arg1 // [0] = rs[0] + rs[2];[1] = rs[1] + rs[3];
vsub.s16 \arg1, \arg0, \arg1 // [0] = rs[0] - rs[2];[1] = rs[1] - rs[3];
vtrn.s16 \arg2, \arg1
vrev32.16 \arg1, \arg1
vtrn.s32 \arg2, \arg1 // [0] = rs[0] + rs[2];[1] = rs[0] - rs[2];[2] = rs[1] - rs[3];[3] = rs[1] + rs[3];
vrev64.16 \arg1, \arg2
vadd.s16 \arg0, \arg2, \arg1 // [0] = rs[0] + rs[3];[1] = rs[1] + rs[2];
vsub.s16 \arg1, \arg2, \arg1
vrev32.16 \arg1, \arg1 // [0] = rs[1] - rs[2];[1] = rs[0] - rs[3];
vtrn.s32 \arg0, \arg1 // [0] = rs[0] + rs[3];[1] = rs[1] + rs[2];[2] = rs[1] - rs[2];[3] = rs[0] - rs[3];
// }
.endm
.macro MB_PRED_8BITS_ADD_DCT_16BITS_CLIP arg0, arg1, arg2, arg3, arg4, arg5
// { // input: pred_d[0]/[1](output), dct_q0/1, working_q0/1;
vmovl.u8 \arg4,\arg0
vmovl.u8 \arg5,\arg1
vadd.s16 \arg4,\arg2
vadd.s16 \arg5,\arg3
vqmovun.s16 \arg0,\arg4
vqmovun.s16 \arg1,\arg5
// }
.endm
.macro ROW_TRANSFORM_1_STEP_TOTAL_16BITS arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7
// { // input: src_d[0]~[3], output: e_d[0]~[3];
vadd.s16 \arg4, \arg0, \arg2 //int16 e[i][0] = src[0] + src[2];
vsub.s16 \arg5, \arg0, \arg2 //int16 e[i][1] = src[0] - src[2];
vshr.s16 \arg6, \arg1, #1
vshr.s16 \arg7, \arg3, #1
vsub.s16 \arg6, \arg6, \arg3 //int16 e[i][2] = (src[1]>>1)-src[3];
vadd.s16 \arg7, \arg1, \arg7 //int16 e[i][3] = src[1] + (src[3]>>1);
// }
.endm
.macro TRANSFORM_TOTAL_16BITS arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7 // both row & col transform used
// { // output: f_q[0]~[3], input: e_q[0]~[3];
vadd.s16 \arg0, \arg4, \arg7 //int16 f[i][0] = e[i][0] + e[i][3];
vadd.s16 \arg1, \arg5, \arg6 //int16 f[i][1] = e[i][1] + e[i][2];
vsub.s16 \arg2, \arg5, \arg6 //int16 f[i][2] = e[i][1] - e[i][2];
vsub.s16 \arg3, \arg4, \arg7 //int16 f[i][3] = e[i][0] - e[i][3];
// }
.endm
.macro ROW_TRANSFORM_0_STEP arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7
// { // input: src_d[0]~[3], output: e_q[0]~[3];
vaddl.s16 \arg4, \arg0, \arg2 //int32 e[i][0] = src[0] + src[2];
vsubl.s16 \arg5, \arg0, \arg2 //int32 e[i][1] = src[0] - src[2];
vsubl.s16 \arg6, \arg1, \arg3 //int32 e[i][2] = src[1] - src[3];
vaddl.s16 \arg7, \arg1, \arg3 //int32 e[i][3] = src[1] + src[3];
// }
.endm
.macro ROW_TRANSFORM_1_STEP arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9
// { // input: src_d[0]~[3], output: e_q[0]~[3]; working: \arg8 \arg9
vaddl.s16 \arg4, \arg0, \arg2 //int32 e[i][0] = src[0] + src[2];
vsubl.s16 \arg5, \arg0, \arg2 //int32 e[i][1] = src[0] - src[2];
vshr.s16 \arg8, \arg1, #1
vshr.s16 \arg9, \arg3, #1
vsubl.s16 \arg6, \arg8, \arg3 //int32 e[i][2] = (src[1]>>1)-src[3];
vaddl.s16 \arg7, \arg1, \arg9 //int32 e[i][3] = src[1] + (src[3]>>1);
// }
.endm
.macro TRANSFORM_4BYTES arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7 // both row & col transform used
// { // output: f_q[0]~[3], input: e_q[0]~[3];
vadd.s32 \arg0, \arg4, \arg7 //int16 f[i][0] = e[i][0] + e[i][3];
vadd.s32 \arg1, \arg5, \arg6 //int16 f[i][1] = e[i][1] + e[i][2];
vsub.s32 \arg2, \arg5, \arg6 //int16 f[i][2] = e[i][1] - e[i][2];
vsub.s32 \arg3, \arg4, \arg7 //int16 f[i][3] = e[i][0] - e[i][3];
// }
.endm
.macro COL_TRANSFORM_0_STEP arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7
// { // input: src_q[0]~[3], output: e_q[0]~[3];
vadd.s32 \arg4, \arg0, \arg2 //int32 e[0][j] = f[0][j] + f[2][j];
vsub.s32 \arg5, \arg0, \arg2 //int32 e[1][j] = f[0][j] - f[2][j];
vsub.s32 \arg6, \arg1, \arg3 //int32 e[2][j] = (f[1][j]>>1) - f[3][j];
vadd.s32 \arg7, \arg1, \arg3 //int32 e[3][j] = f[1][j] + (f[3][j]>>1);
// }
.endm
.macro COL_TRANSFORM_1_STEP arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7
// { // input: src_q[0]~[3], output: e_q[0]~[3];
vadd.s32 \arg4, \arg0, \arg2 //int32 e[0][j] = f[0][j] + f[2][j];
vsub.s32 \arg5, \arg0, \arg2 //int32 e[1][j] = f[0][j] - f[2][j];
vshr.s32 \arg6, \arg1, #1
vshr.s32 \arg7, \arg3, #1
vsub.s32 \arg6, \arg6, \arg3 //int32 e[2][j] = (f[1][j]>>1) - f[3][j];
vadd.s32 \arg7, \arg1, \arg7 //int32 e[3][j] = f[1][j] + (f[3][j]>>1);
// }
.endm
WELS_ASM_FUNC_BEGIN WelsDctT4_neon
push {r4}
ldr r4, [sp, #4]
LOAD_4x4_DATA_FOR_DCT d4, d5, d6, d7, r1, r2, r3, r4
vsubl.u8 q0, d4, d6
vsubl.u8 q1, d5, d7
vtrn.s32 q0, q1
vswp d1, d2
// horizontal transform
DCT_ROW_TRANSFORM_TOTAL_16BITS d0, d1, d2, d3, d4, d5, d6, d7
// transform element
MATRIX_TRANSFORM_EACH_16BITS d0, d1, d2, d3
// vertical transform
DCT_ROW_TRANSFORM_TOTAL_16BITS d0, d1, d2, d3, d4, d5, d6, d7
// transform element
MATRIX_TRANSFORM_EACH_16BITS d0, d1, d2, d3
vst1.s16 {q0, q1}, [r0]!
pop {r4}
WELS_ASM_FUNC_END
WELS_ASM_FUNC_BEGIN WelsDctFourT4_neon
push {r4}
ldr r4, [sp, #4]
LOAD_8x8_DATA_FOR_DCT d16, d17, d18, d19, d20, d21, d22, d23, r1, r3
vsubl.u8 q0, d16, d20
vsubl.u8 q1, d17, d21
vsubl.u8 q2, d18, d22
vsubl.u8 q3, d19, d23
MATRIX_TRANSFORM_EACH_16BITS q0, q1, q2, q3
// horizontal transform
DCT_ROW_TRANSFORM_TOTAL_16BITS q0, q1, q2, q3, q8, q9, q10, q11
// transform element
MATRIX_TRANSFORM_EACH_16BITS q0, q1, q2, q3
// vertical transform
DCT_ROW_TRANSFORM_TOTAL_16BITS q0, q1, q2, q3, q8, q9, q10, q11
vswp d1, d2
vswp d5, d6
vswp q1, q2
vst1.s16 {q0, q1}, [r0]!
vst1.s16 {q2, q3}, [r0]!
////////////////
LOAD_8x8_DATA_FOR_DCT d16, d17, d18, d19, d20, d21, d22, d23, r1, r3
vsubl.u8 q0, d16, d20
vsubl.u8 q1, d17, d21
vsubl.u8 q2, d18, d22
vsubl.u8 q3, d19, d23
MATRIX_TRANSFORM_EACH_16BITS q0, q1, q2, q3
// horizontal transform
DCT_ROW_TRANSFORM_TOTAL_16BITS q0, q1, q2, q3, q8, q9, q10, q11
// transform element
MATRIX_TRANSFORM_EACH_16BITS q0, q1, q2, q3
// vertical transform
DCT_ROW_TRANSFORM_TOTAL_16BITS q0, q1, q2, q3, q8, q9, q10, q11
vswp d1, d2
vswp d5, d6
vswp q1, q2
vst1.s16 {q0, q1}, [r0]!
vst1.s16 {q2, q3}, [r0]!
pop {r4}
WELS_ASM_FUNC_END
WELS_ASM_FUNC_BEGIN WelsQuant4x4_neon
vld1.s16 {q2}, [r1]
vld1.s16 {q0, q1}, [r0]
vld1.s16 {q3}, [r2]
vmov q8, q2
NEWQUANT_COEF_EACH_16BITS q0, q2, d4, d5, d6, d7, q9, q10, q11
vst1.s16 {q2}, [r0]!
NEWQUANT_COEF_EACH_16BITS q1, q8, d16, d17, d6, d7, q9, q10, q11
vst1.s16 {q8}, [r0]!
WELS_ASM_FUNC_END
WELS_ASM_FUNC_BEGIN WelsQuant4x4Dc_neon
vld1.s16 {q0, q1}, [r0]
vdup.s16 q2, r1 // even ff range [0, 768]
vdup.s16 q3, r2
vmov q8, q2
NEWQUANT_COEF_EACH_16BITS q0, q2, d4, d5, d6, d7, q9, q10, q11
vst1.s16 {q2}, [r0]!
NEWQUANT_COEF_EACH_16BITS q1, q8, d16, d17, d6, d7, q9, q10, q11
vst1.s16 {q8}, [r0]!
WELS_ASM_FUNC_END
WELS_ASM_FUNC_BEGIN WelsQuantFour4x4_neon
vld1.s16 {q2}, [r1]
vld1.s16 {q3}, [r2]
mov r1, r0
vld1.s16 {q0, q1}, [r0]!
vmov q8, q2
NEWQUANT_COEF_EACH_16BITS q0, q8, d16, d17, d6, d7, q9, q10, q11
vst1.s16 {q8}, [r1]!
vmov q8, q2
NEWQUANT_COEF_EACH_16BITS q1, q8, d16, d17, d6, d7, q9, q10, q11
vst1.s16 {q8}, [r1]!
vld1.s16 {q0, q1}, [r0]!
vmov q8, q2
NEWQUANT_COEF_EACH_16BITS q0, q8, d16, d17, d6, d7, q9, q10, q11
vst1.s16 {q8}, [r1]!
vmov q8, q2
NEWQUANT_COEF_EACH_16BITS q1, q8, d16, d17, d6, d7, q9, q10, q11
vst1.s16 {q8}, [r1]!
vld1.s16 {q0, q1}, [r0]!
vmov q8, q2
NEWQUANT_COEF_EACH_16BITS q0, q8, d16, d17, d6, d7, q9, q10, q11
vst1.s16 {q8}, [r1]!
vmov q8, q2
NEWQUANT_COEF_EACH_16BITS q1, q8, d16, d17, d6, d7, q9, q10, q11
vst1.s16 {q8}, [r1]!
vld1.s16 {q0, q1}, [r0]!
vmov q8, q2
NEWQUANT_COEF_EACH_16BITS q0, q8, d16, d17, d6, d7, q9, q10, q11
vst1.s16 {q8}, [r1]!
vmov q8, q2
NEWQUANT_COEF_EACH_16BITS q1, q8, d16, d17, d6, d7, q9, q10, q11
vst1.s16 {q8}, [r1]!
WELS_ASM_FUNC_END
WELS_ASM_FUNC_BEGIN WelsQuantFour4x4Max_neon
vld1.s16 {q2}, [r1]
vld1.s16 {q3}, [r2]
mov r1, r0
vld1.s16 {q0, q1}, [r0]!
vmov q8, q2
NEWQUANT_COEF_EACH_16BITS_MAX q0, q8, d16, d17, d6, d7, q9, q10, q11, d26
vst1.s16 {q8}, [r1]!
vmov q12, q2
NEWQUANT_COEF_EACH_16BITS_MAX q1, q12, d24, d25, d6, d7, q9, q10, q11, d28
vst1.s16 {q12}, [r1]! // then 1st 16 elem in d26 & d28
vld1.s16 {q0, q1}, [r0]!
vmov q8, q2
NEWQUANT_COEF_EACH_16BITS_MAX q0, q8, d16, d17, d6, d7, q9, q10, q11, d27
vst1.s16 {q8}, [r1]!
vmov q12, q2
NEWQUANT_COEF_EACH_16BITS_MAX q1, q12, d24, d25, d6, d7, q9, q10, q11, d29
vst1.s16 {q12}, [r1]! // then 2nd 16 elem in d27 & d29
SELECT_MAX_IN_ABS_COEF q13, q14, q0, d0, d1
vst1.s32 {d0[0]}, [r3]!
///////////
vld1.s16 {q0, q1}, [r0]!
vmov q8, q2
NEWQUANT_COEF_EACH_16BITS_MAX q0, q8, d16, d17, d6, d7, q9, q10, q11, d26
vst1.s16 {q8}, [r1]!
vmov q12, q2
NEWQUANT_COEF_EACH_16BITS_MAX q1, q12, d24, d25, d6, d7, q9, q10, q11, d28
vst1.s16 {q12}, [r1]! // then 3rd 16 elem in d26 & d28
vld1.s16 {q0, q1}, [r0]!
vmov q8, q2
NEWQUANT_COEF_EACH_16BITS_MAX q0, q8, d16, d17, d6, d7, q9, q10, q11, d27
vst1.s16 {q8}, [r1]!
vmov q12, q2
NEWQUANT_COEF_EACH_16BITS_MAX q1, q12, d24, d25, d6, d7, q9, q10, q11, d29
vst1.s16 {q12}, [r1]! // then 4th 16 elem in d27 & d29
SELECT_MAX_IN_ABS_COEF q13, q14, q0, d0, d1
vst1.s32 {d0[0]}, [r3]!
WELS_ASM_FUNC_END
WELS_ASM_FUNC_BEGIN WelsHadamardT4Dc_neon
push {r2,r3}
mov r2, #64 // 2*16*sizeof(int16_t)
add r3, r1, #32
vld1.s16 {d0}, [r1], r2
vld1.s16 {d1}, [r3], r2
vld1.s16 {d4}, [r1], r2
vld1.s16 {d5}, [r3], r2
vld1.s16 {d2}, [r1], r2
vld1.s16 {d3}, [r3], r2
vld1.s16 {d6}, [r1], r2
vld1.s16 {d7}, [r3], r2
vtrn.16 q0, q2 // d0[0 4], d1[1 5]
vtrn.16 q1, q3 // d2[2 6], d3[3 7]
vld1.s16 {d16}, [r1], r2
vld1.s16 {d17}, [r3], r2
vld1.s16 {d20}, [r1], r2
vld1.s16 {d21}, [r3], r2
vld1.s16 {d18}, [r1], r2
vld1.s16 {d19}, [r3], r2
vld1.s16 {d22}, [r1], r2
vld1.s16 {d23}, [r3], r2
vtrn.16 q8, q10 //d16[08 12],d17[09 13]
vtrn.16 q9, q11 //d18[10 14],d19[11 15]
vtrn.32 q0, q8 // d0 [0 4 08 12] = dct[idx], d1[1 5 09 13] = dct[idx+16]
vtrn.32 q1, q9 // d2 [2 6 10 14] = dct[idx+64], d3[3 7 11 15] = dct[idx+80]
ROW_TRANSFORM_0_STEP d0, d1, d3, d2, q8, q11, q10, q9
TRANSFORM_4BYTES q0, q1, q3, q2, q8, q11, q10, q9
// transform element 32bits
vtrn.s32 q0, q1 //[0 1 2 3]+[4 5 6 7]-->[0 4 2 6]+[1 5 3 7]
vtrn.s32 q2, q3 //[8 9 10 11]+[12 13 14 15]-->[8 12 10 14]+[9 13 11 15]
vswp d1, d4 //[0 4 2 6]+[8 12 10 14]-->[0 4 8 12]+[2 6 10 14]
vswp d3, d6 //[1 5 3 7]+[9 13 11 15]-->[1 5 9 13]+[3 7 11 15]
COL_TRANSFORM_0_STEP q0, q1, q3, q2, q8, q11, q10, q9
TRANSFORM_4BYTES q0, q1, q3, q2, q8, q11, q10, q9
vrshrn.s32 d16, q0, #1
vrshrn.s32 d17, q1, #1
vrshrn.s32 d18, q2, #1
vrshrn.s32 d19, q3, #1
vst1.16 {q8, q9}, [r0] //store
pop {r2,r3}
WELS_ASM_FUNC_END
WELS_ASM_FUNC_BEGIN WelsHadamardQuant2x2_neon
vdup.s16 d1, r1 //ff
vdup.s16 d2, r2 //mf
veor d3, d3
mov r1, #32
mov r2, r0
vld1.s16 {d0[0]}, [r0], r1 //rs[00]
vst1.s16 {d3[0]}, [r2], r1 //rs[00]=0
vld1.s16 {d0[1]}, [r0], r1 //rs[16]
vst1.s16 {d3[0]}, [r2], r1 //rs[16]=0
vld1.s16 {d0[2]}, [r0], r1 //rs[32]
vst1.s16 {d3[0]}, [r2], r1 //rs[32]=0
vld1.s16 {d0[3]}, [r0], r1 //rs[48]
vst1.s16 {d3[0]}, [r2], r1 //rs[48]=0
HDM_QUANT_2x2_TOTAL_16BITS d0, d4, d5 // output d5
HDM_QUANT_2x2_TOTAL_16BITS d5, d4, d0 // output d0
QUANT_DUALWORD_COEF_EACH_16BITS d0, d1, d2, d3, q2
vst1.s16 d1, [r3] // store to dct
ldr r2, [sp, #0]
vst1.s16 d1, [r2] // store to block
mov r1, #1
vdup.s16 d3, r1
DC_ZERO_COUNT_IN_DUALWORD d1, d0, d3
vmov r0, r1, d0
and r0, #0x07 // range [0~4]
rsb r0, #4
WELS_ASM_FUNC_END
WELS_ASM_FUNC_BEGIN WelsHadamardQuant2x2SkipKernel_neon
vdup.s16 d3, r1
mov r1, #32
vld1.s16 {d0[0]}, [r0], r1 //rs[00]
vld1.s16 {d0[1]}, [r0], r1 //rs[16]
vld1.s16 {d0[2]}, [r0], r1 //rs[32]
vld1.s16 {d0[3]}, [r0], r1 //rs[48]
HDM_QUANT_2x2_TOTAL_16BITS d0, d1, d2 // output d2
HDM_QUANT_2x2_TOTAL_16BITS d2, d1, d0 // output d0
vabs.s16 d1, d0
vcgt.s16 d1, d1, d3 // abs(dct[i])>threshold;
vmov r0, r1, d1
orr r0, r1
WELS_ASM_FUNC_END
WELS_ASM_FUNC_BEGIN WelsGetNoneZeroCount_neon
push {r1}
vld1.s16 {q0, q1}, [r0]
vmov.s16 q8, #1
ZERO_COUNT_IN_2_QUARWORD q0, q1, q8, d0, d1, d2, d3
vmov r0, r1, d0
and r0, #0x1F // range [0~16]
rsb r0, #16
pop {r1}
WELS_ASM_FUNC_END
WELS_ASM_FUNC_BEGIN WelsDequant4x4_neon
vld1.s16 {q0, q1}, [r0]
vld1.u16 {q2}, [r1]
vmul.s16 q8, q0, q2
vmul.s16 q9, q1, q2
vst1.s16 {q8, q9}, [r0]
WELS_ASM_FUNC_END
WELS_ASM_FUNC_BEGIN WelsDequantFour4x4_neon
vld1.u16 {q12}, [r1]
mov r1, r0
vld1.s16 {q0, q1}, [r0]!
vld1.s16 {q2, q3}, [r0]!
vmul.s16 q0, q0, q12
vld1.s16 {q8, q9}, [r0]!
vmul.s16 q1, q1, q12
vld1.s16 {q10, q11}, [r0]!
vst1.s16 {q0, q1}, [r1]!
vmul.s16 q2, q2, q12
vmul.s16 q3, q3, q12
vmul.s16 q8, q8, q12
vst1.s16 {q2, q3}, [r1]!
vmul.s16 q9, q9, q12
vmul.s16 q10, q10, q12
vmul.s16 q11, q11, q12
vst1.s16 {q8, q9}, [r1]!
vst1.s16 {q10, q11}, [r1]!
WELS_ASM_FUNC_END
WELS_ASM_FUNC_BEGIN WelsDequantIHadamard4x4_neon
vld1.s16 {q0, q1}, [r0]
vdup.s16 q8, r1
IHDM_4x4_TOTAL_16BITS q0, q2, q3
IHDM_4x4_TOTAL_16BITS q1, q2, q3
MATRIX_TRANSFORM_EACH_16BITS d0, d1, d2, d3
IHDM_4x4_TOTAL_16BITS q0, q2, q3
vmul.s16 q0, q8
IHDM_4x4_TOTAL_16BITS q1, q2, q3
vmul.s16 q1, q8
MATRIX_TRANSFORM_EACH_16BITS d0, d1, d2, d3
vst1.s16 {q0, q1}, [r0]
WELS_ASM_FUNC_END
WELS_ASM_FUNC_BEGIN WelsIDctT4Rec_neon
vld1.u32 {d16[0]}, [r2], r3
push {r4}
ldr r4, [sp, #4]
vld1.u32 {d16[1]}, [r2], r3
vld4.s16 {d0, d1, d2, d3}, [r4] // cost 3 cycles!
vld1.u32 {d17[0]}, [r2], r3
vld1.u32 {d17[1]}, [r2], r3 // q7 is pred
ROW_TRANSFORM_1_STEP_TOTAL_16BITS d0, d1, d2, d3, d4, d5, d6, d7
TRANSFORM_TOTAL_16BITS d0, d1, d2, d3, d4, d5, d6, d7
MATRIX_TRANSFORM_EACH_16BITS d0, d1, d2, d3
ROW_TRANSFORM_1_STEP_TOTAL_16BITS d0, d1, d2, d3, d4, d5, d6, d7
TRANSFORM_TOTAL_16BITS d0, d1, d2, d3, d4, d5, d6, d7
vrshr.s16 d0, d0, #6
vrshr.s16 d1, d1, #6
vrshr.s16 d2, d2, #6
vrshr.s16 d3, d3, #6
//after rounding 6, clip into [0, 255]
vmovl.u8 q2,d16
vadd.s16 q0,q2
vqmovun.s16 d16,q0
vst1.32 {d16[0]},[r0],r1
vst1.32 {d16[1]},[r0],r1
vmovl.u8 q2,d17
vadd.s16 q1,q2
vqmovun.s16 d17,q1
vst1.32 {d17[0]},[r0],r1
vst1.32 {d17[1]},[r0]
pop {r4}
WELS_ASM_FUNC_END
WELS_ASM_FUNC_BEGIN WelsIDctFourT4Rec_neon
vld1.u64 {d24}, [r2], r3
push {r4}
ldr r4, [sp, #4]
vld1.u64 {d25}, [r2], r3
vld4.s16 {d0, d1, d2, d3}, [r4]! // cost 3 cycles!
vld1.u64 {d26}, [r2], r3
vld1.u64 {d27}, [r2], r3
vld4.s16 {d4, d5, d6, d7}, [r4]! // cost 3 cycles!
vswp d1, d4
vswp d3, d6
vswp q1, q2 // q0~q3
ROW_TRANSFORM_1_STEP_TOTAL_16BITS q0, q1, q2, q3, q8, q9, q10, q11
TRANSFORM_TOTAL_16BITS q0, q1, q2, q3, q8, q9, q10, q11
MATRIX_TRANSFORM_EACH_16BITS q0, q1, q2, q3
ROW_TRANSFORM_1_STEP_TOTAL_16BITS q0, q1, q2, q3, q8, q9, q10, q11
TRANSFORM_TOTAL_16BITS q0, q1, q2, q3, q8, q9, q10, q11
vrshr.s16 q0, q0, #6
vrshr.s16 q1, q1, #6
vrshr.s16 q2, q2, #6
vrshr.s16 q3, q3, #6
//after rounding 6, clip into [0, 255]
vmovl.u8 q8,d24
vadd.s16 q0,q8
vqmovun.s16 d24,q0
vst1.u8 {d24},[r0],r1
vmovl.u8 q8,d25
vadd.s16 q1,q8
vqmovun.s16 d25,q1
vst1.u8 {d25},[r0],r1
vmovl.u8 q8,d26
vadd.s16 q2,q8
vqmovun.s16 d26,q2
vst1.u8 {d26},[r0],r1
vmovl.u8 q8,d27
vadd.s16 q3,q8
vqmovun.s16 d27,q3
vst1.u8 {d27},[r0],r1
vld1.u64 {d24}, [r2], r3
vld1.u64 {d25}, [r2], r3
vld4.s16 {d0, d1, d2, d3}, [r4]! // cost 3 cycles!
vld1.u64 {d26}, [r2], r3
vld1.u64 {d27}, [r2], r3
vld4.s16 {d4, d5, d6, d7}, [r4]! // cost 3 cycles!
vswp d1, d4
vswp d3, d6
vswp q1, q2 // q0~q3
ROW_TRANSFORM_1_STEP_TOTAL_16BITS q0, q1, q2, q3, q8, q9, q10, q11
TRANSFORM_TOTAL_16BITS q0, q1, q2, q3, q8, q9, q10, q11
MATRIX_TRANSFORM_EACH_16BITS q0, q1, q2, q3
ROW_TRANSFORM_1_STEP_TOTAL_16BITS q0, q1, q2, q3, q8, q9, q10, q11
TRANSFORM_TOTAL_16BITS q0, q1, q2, q3, q8, q9, q10, q11
vrshr.s16 q0, q0, #6
vrshr.s16 q1, q1, #6
vrshr.s16 q2, q2, #6
vrshr.s16 q3, q3, #6
//after rounding 6, clip into [0, 255]
vmovl.u8 q8,d24
vadd.s16 q0,q8
vqmovun.s16 d24,q0
vst1.u8 {d24},[r0],r1
vmovl.u8 q8,d25
vadd.s16 q1,q8
vqmovun.s16 d25,q1
vst1.u8 {d25},[r0],r1
vmovl.u8 q8,d26
vadd.s16 q2,q8
vqmovun.s16 d26,q2
vst1.u8 {d26},[r0],r1
vmovl.u8 q8,d27
vadd.s16 q3,q8
vqmovun.s16 d27,q3
vst1.u8 {d27},[r0],r1
pop {r4}
WELS_ASM_FUNC_END
WELS_ASM_FUNC_BEGIN WelsIDctRecI16x16Dc_neon
push {r4}
ldr r4, [sp, #4]
vld1.s16 {q8,q9}, [r4]
vrshr.s16 q8, q8, #6
vrshr.s16 q9, q9, #6
vdup.s16 d20, d16[0]
vdup.s16 d21, d16[1]
vdup.s16 d22, d16[2]
vdup.s16 d23, d16[3]
vld1.u8 {q0}, [r2], r3
MB_PRED_8BITS_ADD_DCT_16BITS_CLIP d0, d1, q10, q11, q12, q13
vst1.u8 {q0}, [r0], r1
vld1.u8 {q0}, [r2], r3
MB_PRED_8BITS_ADD_DCT_16BITS_CLIP d0, d1, q10, q11, q12, q13
vst1.u8 {q0}, [r0], r1
vld1.u8 {q0}, [r2], r3
MB_PRED_8BITS_ADD_DCT_16BITS_CLIP d0, d1, q10, q11, q12, q13
vst1.u8 {q0}, [r0], r1
vld1.u8 {q0}, [r2], r3
MB_PRED_8BITS_ADD_DCT_16BITS_CLIP d0, d1, q10, q11, q12, q13
vst1.u8 {q0}, [r0], r1
vdup.s16 d20, d17[0]
vdup.s16 d21, d17[1]
vdup.s16 d22, d17[2]
vdup.s16 d23, d17[3]
vld1.u8 {q0}, [r2], r3
MB_PRED_8BITS_ADD_DCT_16BITS_CLIP d0, d1, q10, q11, q12, q13
vst1.u8 {q0}, [r0], r1
vld1.u8 {q0}, [r2], r3
MB_PRED_8BITS_ADD_DCT_16BITS_CLIP d0, d1, q10, q11, q12, q13
vst1.u8 {q0}, [r0], r1
vld1.u8 {q0}, [r2], r3
MB_PRED_8BITS_ADD_DCT_16BITS_CLIP d0, d1, q10, q11, q12, q13
vst1.u8 {q0}, [r0], r1
vld1.u8 {q0}, [r2], r3
MB_PRED_8BITS_ADD_DCT_16BITS_CLIP d0, d1, q10, q11, q12, q13
vst1.u8 {q0}, [r0], r1
vdup.s16 d20, d18[0]
vdup.s16 d21, d18[1]
vdup.s16 d22, d18[2]
vdup.s16 d23, d18[3]
vld1.u8 {q0}, [r2], r3
MB_PRED_8BITS_ADD_DCT_16BITS_CLIP d0, d1, q10, q11, q12, q13
vst1.u8 {q0}, [r0], r1
vld1.u8 {q0}, [r2], r3
MB_PRED_8BITS_ADD_DCT_16BITS_CLIP d0, d1, q10, q11, q12, q13
vst1.u8 {q0}, [r0], r1
vld1.u8 {q0}, [r2], r3
MB_PRED_8BITS_ADD_DCT_16BITS_CLIP d0, d1, q10, q11, q12, q13
vst1.u8 {q0}, [r0], r1
vld1.u8 {q0}, [r2], r3
MB_PRED_8BITS_ADD_DCT_16BITS_CLIP d0, d1, q10, q11, q12, q13
vst1.u8 {q0}, [r0], r1
vdup.s16 d20, d19[0]
vdup.s16 d21, d19[1]
vdup.s16 d22, d19[2]
vdup.s16 d23, d19[3]
vld1.u8 {q0}, [r2], r3
MB_PRED_8BITS_ADD_DCT_16BITS_CLIP d0, d1, q10, q11, q12, q13
vst1.u8 {q0}, [r0], r1
vld1.u8 {q0}, [r2], r3
MB_PRED_8BITS_ADD_DCT_16BITS_CLIP d0, d1, q10, q11, q12, q13
vst1.u8 {q0}, [r0], r1
vld1.u8 {q0}, [r2], r3
MB_PRED_8BITS_ADD_DCT_16BITS_CLIP d0, d1, q10, q11, q12, q13
vst1.u8 {q0}, [r0], r1
vld1.u8 {q0}, [r2], r3
MB_PRED_8BITS_ADD_DCT_16BITS_CLIP d0, d1, q10, q11, q12, q13
vst1.u8 {q0}, [r0], r1
pop {r4}
WELS_ASM_FUNC_END
#endif
| {
"language": "Assembly"
} |
// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build !gccgo
#include "textflag.h"
//
// System calls for ppc64, AIX are implemented in runtime/syscall_aix.go
//
TEXT ·syscall6(SB),NOSPLIT,$0-88
JMP syscall·syscall6(SB)
TEXT ·rawSyscall6(SB),NOSPLIT,$0-88
JMP syscall·rawSyscall6(SB)
| {
"language": "Assembly"
} |
65A011223344
ICLASS: MOV
CATEGORY: DATAXFER
EXTENSION: BASE
IFORM: MOV_AL_MEMb
ISA_SET: I86
ATTRIBUTES: BYTEOP FIXED_BASE0
SHORT: mov al, byte ptr gs:[0x44332211]
Encodable! 65A011223344
Identical re-encoding
| {
"language": "Assembly"
} |
$NetBSD: patch-src_libgame_joystick.h,v 1.1 2019/05/05 07:59:38 adam Exp $
Allow joystick on NetBSD.
--- src/libgame/joystick.h.orig 2017-09-12 20:17:10.000000000 +0000
+++ src/libgame/joystick.h
@@ -23,7 +23,7 @@
#define MAX_JOYSTICK_NAME_LEN 40
-#if defined(PLATFORM_FREEBSD)
+#if defined(PLATFORM_FREEBSD) || (defined(PLATFORM_NETBSD) && defined(HAVE_JOYSTICK))
#define DEV_JOYSTICK_0 "/dev/joy0"
#define DEV_JOYSTICK_1 "/dev/joy1"
#define DEV_JOYSTICK_2 "/dev/joy2"
| {
"language": "Assembly"
} |
/*
* Copyright 2008 Free Software Foundation, Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* This use of this software may be subject to additional restrictions.
* See the LEGAL file in the main directory for details.
*/
#include "GSM610Tables.h"
/*
RFC 3551 RTP A/V Profile July 2003
Octet Bit 0 Bit 1 Bit 2 Bit 3 Bit 4 Bit 5 Bit 6 Bit 7
_____________________________________________________________________
0 1 1 0 1 LARc0.0 LARc0.1 LARc0.2 LARc0.3
1 LARc0.4 LARc0.5 LARc1.0 LARc1.1 LARc1.2 LARc1.3 LARc1.4 LARc1.5
2 LARc2.0 LARc2.1 LARc2.2 LARc2.3 LARc2.4 LARc3.0 LARc3.1 LARc3.2
3 LARc3.3 LARc3.4 LARc4.0 LARc4.1 LARc4.2 LARc4.3 LARc5.0 LARc5.1
4 LARc5.2 LARc5.3 LARc6.0 LARc6.1 LARc6.2 LARc7.0 LARc7.1 LARc7.2
5 Nc0.0 Nc0.1 Nc0.2 Nc0.3 Nc0.4 Nc0.5 Nc0.6 bc0.0
6 bc0.1 Mc0.0 Mc0.1 xmaxc00 xmaxc01 xmaxc02 xmaxc03 xmaxc04
7 xmaxc05 xmc0.0 xmc0.1 xmc0.2 xmc1.0 xmc1.1 xmc1.2 xmc2.0
8 xmc2.1 xmc2.2 xmc3.0 xmc3.1 xmc3.2 xmc4.0 xmc4.1 xmc4.2
9 xmc5.0 xmc5.1 xmc5.2 xmc6.0 xmc6.1 xmc6.2 xmc7.0 xmc7.1
10 xmc7.2 xmc8.0 xmc8.1 xmc8.2 xmc9.0 xmc9.1 xmc9.2 xmc10.0
11 xmc10.1 xmc10.2 xmc11.0 xmc11.1 xmc11.2 xmc12.0 xmc12.1 xcm12.2
12 Nc1.0 Nc1.1 Nc1.2 Nc1.3 Nc1.4 Nc1.5 Nc1.6 bc1.0
13 bc1.1 Mc1.0 Mc1.1 xmaxc10 xmaxc11 xmaxc12 xmaxc13 xmaxc14
14 xmax15 xmc13.0 xmc13.1 xmc13.2 xmc14.0 xmc14.1 xmc14.2 xmc15.0
15 xmc15.1 xmc15.2 xmc16.0 xmc16.1 xmc16.2 xmc17.0 xmc17.1 xmc17.2
16 xmc18.0 xmc18.1 xmc18.2 xmc19.0 xmc19.1 xmc19.2 xmc20.0 xmc20.1
17 xmc20.2 xmc21.0 xmc21.1 xmc21.2 xmc22.0 xmc22.1 xmc22.2 xmc23.0
18 xmc23.1 xmc23.2 xmc24.0 xmc24.1 xmc24.2 xmc25.0 xmc25.1 xmc25.2
19 Nc2.0 Nc2.1 Nc2.2 Nc2.3 Nc2.4 Nc2.5 Nc2.6 bc2.0
20 bc2.1 Mc2.0 Mc2.1 xmaxc20 xmaxc21 xmaxc22 xmaxc23 xmaxc24
21 xmaxc25 xmc26.0 xmc26.1 xmc26.2 xmc27.0 xmc27.1 xmc27.2 xmc28.0
22 xmc28.1 xmc28.2 xmc29.0 xmc29.1 xmc29.2 xmc30.0 xmc30.1 xmc30.2
23 xmc31.0 xmc31.1 xmc31.2 xmc32.0 xmc32.1 xmc32.2 xmc33.0 xmc33.1
24 xmc33.2 xmc34.0 xmc34.1 xmc34.2 xmc35.0 xmc35.1 xmc35.2 xmc36.0
25 Xmc36.1 xmc36.2 xmc37.0 xmc37.1 xmc37.2 xmc38.0 xmc38.1 xmc38.2
26 Nc3.0 Nc3.1 Nc3.2 Nc3.3 Nc3.4 Nc3.5 Nc3.6 bc3.0
27 bc3.1 Mc3.0 Mc3.1 xmaxc30 xmaxc31 xmaxc32 xmaxc33 xmaxc34
28 xmaxc35 xmc39.0 xmc39.1 xmc39.2 xmc40.0 xmc40.1 xmc40.2 xmc41.0
29 xmc41.1 xmc41.2 xmc42.0 xmc42.1 xmc42.2 xmc43.0 xmc43.1 xmc43.2
30 xmc44.0 xmc44.1 xmc44.2 xmc45.0 xmc45.1 xmc45.2 xmc46.0 xmc46.1
31 xmc46.2 xmc47.0 xmc47.1 xmc47.2 xmc48.0 xmc48.1 xmc48.2 xmc49.0
32 xmc49.1 xmc49.2 xmc50.0 xmc50.1 xmc50.2 xmc51.0 xmc51.1 xmc51.2
Table 3: GSM payload format
*/
/*
This file encodes a mapping between
GSM 05.03 Table 2 and RFC-3551 Table 3.
*/
/*
Naming convention:
xxx_p position (bit index)
xxx_l length (bit field length)
LAR log area ratio
N LTP lag
b LTP gain
M grid
Xmax block amplitude
x RPE pulses
*/
/**@name Lengths of GSM 06.10 fields */
//@{
const unsigned int LAR1_l=6; ///< log area ratio
const unsigned int LAR2_l=6; ///< log area ratio
const unsigned int LAR3_l=5; ///< log area ratio
const unsigned int LAR4_l=5; ///< log area ratio
const unsigned int LAR5_l=4; ///< log area ratio
const unsigned int LAR6_l=4; ///< log area ratio
const unsigned int LAR7_l=3; ///< log area ratio
const unsigned int LAR8_l=3; ///< log area ratio
const unsigned int N_l=7; ///< LTP lag
const unsigned int b_l=2; ///< LTP gain
const unsigned int M_l=2; ///< grid position
const unsigned int Xmax_l=6; ///< block amplitude
const unsigned int x_l=3; ///< RPE pulses
//@}
/*@name Indecies of GSM 06.10 fields as they appear in RFC-3551 Table 3. */
//@{
/**@name Log area ratios, apply to whole frame. */
//@{
const unsigned int LAR1_p = 0;
const unsigned int LAR2_p = LAR1_p + LAR1_l;
const unsigned int LAR3_p = LAR2_p + LAR2_l;
const unsigned int LAR4_p = LAR3_p + LAR3_l;
const unsigned int LAR5_p = LAR4_p + LAR4_l;
const unsigned int LAR6_p = LAR5_p + LAR5_l;
const unsigned int LAR7_p = LAR6_p + LAR6_l;
const unsigned int LAR8_p = LAR7_p + LAR7_l;
//@}
/**@name Subframe 1 */
//@{
const unsigned int N1_p = LAR8_p + LAR8_l;
const unsigned int b1_p = N1_p + N_l;
const unsigned int M1_p = b1_p + b_l;
const unsigned int Xmax1_p = M1_p + M_l;
const unsigned int x1_0_p = Xmax1_p + Xmax_l;
const unsigned int x1_1_p = x1_0_p + x_l;
const unsigned int x1_2_p = x1_1_p + x_l;
const unsigned int x1_3_p = x1_2_p + x_l;
const unsigned int x1_4_p = x1_3_p + x_l;
const unsigned int x1_5_p = x1_4_p + x_l;
const unsigned int x1_6_p = x1_5_p + x_l;
const unsigned int x1_7_p = x1_6_p + x_l;
const unsigned int x1_8_p = x1_7_p + x_l;
const unsigned int x1_9_p = x1_8_p + x_l;
const unsigned int x1_10_p = x1_9_p + x_l;
const unsigned int x1_11_p = x1_10_p + x_l;
const unsigned int x1_12_p = x1_11_p + x_l;
//@}
/**@name Subframe 2 */
//@{
const unsigned int N2_p = x1_12_p + x_l;
const unsigned int b2_p = N2_p + N_l;
const unsigned int M2_p = b2_p + b_l;
const unsigned int Xmax2_p = M2_p + M_l;
const unsigned int x2_0_p = Xmax2_p + Xmax_l;
const unsigned int x2_1_p = x2_0_p + x_l;
const unsigned int x2_2_p = x2_1_p + x_l;
const unsigned int x2_3_p = x2_2_p + x_l;
const unsigned int x2_4_p = x2_3_p + x_l;
const unsigned int x2_5_p = x2_4_p + x_l;
const unsigned int x2_6_p = x2_5_p + x_l;
const unsigned int x2_7_p = x2_6_p + x_l;
const unsigned int x2_8_p = x2_7_p + x_l;
const unsigned int x2_9_p = x2_8_p + x_l;
const unsigned int x2_10_p = x2_9_p + x_l;
const unsigned int x2_11_p = x2_10_p + x_l;
const unsigned int x2_12_p = x2_11_p + x_l;
//@}
/**@mame Subframe 3 */
//@{
const unsigned int N3_p = x2_12_p + x_l;
const unsigned int b3_p = N3_p + N_l;
const unsigned int M3_p = b3_p + b_l;
const unsigned int Xmax3_p = M3_p + M_l;
const unsigned int x3_0_p = Xmax3_p + Xmax_l;
const unsigned int x3_1_p = x3_0_p + x_l;
const unsigned int x3_2_p = x3_1_p + x_l;
const unsigned int x3_3_p = x3_2_p + x_l;
const unsigned int x3_4_p = x3_3_p + x_l;
const unsigned int x3_5_p = x3_4_p + x_l;
const unsigned int x3_6_p = x3_5_p + x_l;
const unsigned int x3_7_p = x3_6_p + x_l;
const unsigned int x3_8_p = x3_7_p + x_l;
const unsigned int x3_9_p = x3_8_p + x_l;
const unsigned int x3_10_p = x3_9_p + x_l;
const unsigned int x3_11_p = x3_10_p + x_l;
const unsigned int x3_12_p = x3_11_p + x_l;
//@}
/**@name Subframe 4 */
//@{
const unsigned int N4_p = x3_12_p + x_l;
const unsigned int b4_p = N4_p + N_l;
const unsigned int M4_p = b4_p + b_l;
const unsigned int Xmax4_p = M4_p + M_l;
const unsigned int x4_0_p = Xmax4_p + Xmax_l;
const unsigned int x4_1_p = x4_0_p + x_l;
const unsigned int x4_2_p = x4_1_p + x_l;
const unsigned int x4_3_p = x4_2_p + x_l;
const unsigned int x4_4_p = x4_3_p + x_l;
const unsigned int x4_5_p = x4_4_p + x_l;
const unsigned int x4_6_p = x4_5_p + x_l;
const unsigned int x4_7_p = x4_6_p + x_l;
const unsigned int x4_8_p = x4_7_p + x_l;
const unsigned int x4_9_p = x4_8_p + x_l;
const unsigned int x4_10_p = x4_9_p + x_l;
const unsigned int x4_11_p = x4_10_p + x_l;
const unsigned int x4_12_p = x4_11_p + x_l;
//@}
//@}
/*
This array encodes GSM 05.03 Table 2.
It's also GSM 06.10 Table A2.1a.
This is the order of bits as they appear in
the d[] bits of the GSM TCH/F.
RTP[4+g610BitOrder[i]] <=> GSM[i]
*/
unsigned int GSM::g610BitOrder[260] = {
/**@name importance class 1 */
//@{
/** LAR1:5 */ LAR1_p+LAR1_l-1-5, /* bit 0 */
/** Xmax1:5 */ Xmax1_p+Xmax_l-1-5,
/** Xmax2:5 */ Xmax2_p+Xmax_l-1-5,
/** Xmax3:5 */ Xmax3_p+Xmax_l-1-5,
/** Xmax4:5 */ Xmax4_p+Xmax_l-1-5,
//@}
/**@name importance class 2 */
//@{
/** LAR1:4 */ LAR1_p+LAR1_l-1-4,
/** LAR2:5 */ LAR2_p+LAR2_l-1-5,
/** LAR3:4 */ LAR3_p+LAR3_l-1-4,
//@}
/**@name importance class 3 */
//@{
/** LAR1:3 */ LAR1_p+LAR1_l-1-3,
/** LAR2:4 */ LAR2_p+LAR2_l-1-4,
/** LAR3:3 */ LAR3_p+LAR3_l-1-3, /* bit 10 */
/** LAR4:4 */ LAR4_p+LAR4_l-1-4,
/** N1:6 */ N1_p+N_l-1-6,
/** N2:6 */ N2_p+N_l-1-6,
/** N3:6 */ N3_p+N_l-1-6,
/** N4:6 */ N4_p+N_l-1-6,
/** Xmax1:4 */ Xmax1_p+Xmax_l-1-4,
/** Xmax2:4 */ Xmax2_p+Xmax_l-1-4,
/** Xmax3:4 */ Xmax3_p+Xmax_l-1-4,
/** Xmax4:4 */ Xmax4_p+Xmax_l-1-4,
/** LAR2:3 */ LAR2_p+LAR2_l-1-3, /* bit 20 */
/** LAR5:3 */ LAR5_p+LAR5_l-1-3,
/** LAR6:3 */ LAR6_p+LAR6_l-1-3,
/** N1:5 */ N1_p+N_l-1-5,
/** N2:5 */ N2_p+N_l-1-5,
/** N3:5 */ N3_p+N_l-1-5,
/** N4:5 */ N4_p+N_l-1-5,
/** N1:4 */ N1_p+N_l-1-4,
/** N2:4 */ N2_p+N_l-1-4,
/** N3:4 */ N3_p+N_l-1-4,
/** N4:4 */ N4_p+N_l-1-4, /* bit 30 */
/** N1:3 */ N1_p+N_l-1-3,
/** N2:3 */ N2_p+N_l-1-3,
/** N3:3 */ N3_p+N_l-1-3,
/** N4:3 */ N4_p+N_l-1-3,
/** N1:2 */ N1_p+N_l-1-2,
/** N2:2 */ N2_p+N_l-1-2,
/** N3:2 */ N3_p+N_l-1-2,
/** N4:2 */ N4_p+N_l-1-2,
//@}
/**@name importance class 4 */
//@{
/** Xmax1:3 */ Xmax1_p+Xmax_l-1-3,
/** Xmax2:3 */ Xmax2_p+Xmax_l-1-3, /* bit 40 */
/** Xmax3:3 */ Xmax3_p+Xmax_l-1-3,
/** Xmax4:3 */ Xmax4_p+Xmax_l-1-3,
/** LAR1:2 */ LAR1_p+LAR1_l-1-2,
/** LAR4:3 */ LAR4_p+LAR4_l-1-3,
/** LAR7:2 */ LAR7_p+LAR7_l-1-2,
/** N1:1 */ N1_p+N_l-1-1,
/** N2:1 */ N2_p+N_l-1-1,
/** N3:1 */ N3_p+N_l-1-1,
/** N4:1 */ N4_p+N_l-1-1,
/** LAR5:2 */ LAR5_p+LAR5_l-1-2, /* bit 50 */
/** LAR6:2 */ LAR6_p+LAR6_l-1-2,
/** b1:1 */ b1_p+b_l-1-1,
/** b2:1 */ b2_p+b_l-1-1,
/** b3:1 */ b3_p+b_l-1-1,
/** b4:1 */ b4_p+b_l-1-1,
/** N1:0 */ N1_p+N_l-1-0,
/** N2:0 */ N2_p+N_l-1-0,
/** N3:0 */ N3_p+N_l-1-0,
/** N4:0 */ N4_p+N_l-1-0,
/** M1:1 */ M1_p+M_l-1-1, /* bit 60 */
/** M2:1 */ M2_p+M_l-1-1,
/** M3:1 */ M3_p+M_l-1-1,
/** M4:1 */ M4_p+M_l-1-1,
//@}
/**@name importance class 5 */
//@{
/** LAR1:1 */ LAR1_p+LAR1_l-1-1,
/** LAR2:2 */ LAR2_p+LAR2_l-1-2,
/** LAR3:2 */ LAR3_p+LAR3_l-1-2,
/** LAR8:2 */ LAR8_p+LAR8_l-1-2,
/** LAR4:2 */ LAR4_p+LAR4_l-1-2,
/** LAR5:1 */ LAR5_p+LAR5_l-1-1,
/** LAR7:1 */ LAR7_p+LAR7_l-1-1, /* bit 70 */
/** b1:0 */ b1_p+b_l-1-0,
/** b2:0 */ b2_p+b_l-1-0,
/** b3:0 */ b3_p+b_l-1-0,
/** b4:0 */ b4_p+b_l-1-0,
/** Xmax1:2 */ Xmax1_p+Xmax_l-1-2,
/** Xmax2:2 */ Xmax2_p+Xmax_l-1-2,
/** Xmax3:2 */ Xmax3_p+Xmax_l-1-2,
/** Xmax4:2 */ Xmax4_p+Xmax_l-1-2,
/** x1_0:2 */ x1_0_p+x_l-1-2,
/** x1_1:2 */ x1_1_p+x_l-1-2, /* bit 80 */
/** x1_2:2 */ x1_2_p+x_l-1-2,
/** x1_3:2 */ x1_3_p+x_l-1-2,
/** x1_4:2 */ x1_4_p+x_l-1-2,
/** x1_5:2 */ x1_5_p+x_l-1-2,
/** x1_6:2 */ x1_6_p+x_l-1-2,
/** x1_7:2 */ x1_7_p+x_l-1-2,
/** x1_8:2 */ x1_8_p+x_l-1-2,
/** x1_9:2 */ x1_9_p+x_l-1-2,
/** x1_10:2 */ x1_10_p+x_l-1-2,
/** x1_11:2 */ x1_11_p+x_l-1-2, /* bit 90 */
/** x1_12:2 */ x1_12_p+x_l-1-2,
/** x2_0:2 */ x2_0_p+x_l-1-2,
/** x2_1:2 */ x2_1_p+x_l-1-2,
/** x2_2:2 */ x2_2_p+x_l-1-2,
/** x2_3:2 */ x2_3_p+x_l-1-2,
/** x2_4:2 */ x2_4_p+x_l-1-2,
/** x2_5:2 */ x2_5_p+x_l-1-2,
/** x2_6:2 */ x2_6_p+x_l-1-2,
/** x2_7:2 */ x2_7_p+x_l-1-2,
/** x2_8:2 */ x2_8_p+x_l-1-2, /* bit 100 */
/** x2_9:2 */ x2_9_p+x_l-1-2,
/** x2_10:2 */ x2_10_p+x_l-1-2,
/** x2_11:2 */ x2_11_p+x_l-1-2,
/** x2_12:2 */ x2_12_p+x_l-1-2,
/** x3_0:2 */ x3_0_p+x_l-1-2,
/** x3_1:2 */ x3_1_p+x_l-1-2,
/** x3_2:2 */ x3_2_p+x_l-1-2,
/** x3_3:2 */ x3_3_p+x_l-1-2,
/** x3_4:2 */ x3_4_p+x_l-1-2,
/** x3_5:2 */ x3_5_p+x_l-1-2, /* bit 110 */
/** x3_6:2 */ x3_6_p+x_l-1-2,
/** x3_7:2 */ x3_7_p+x_l-1-2,
/** x3_8:2 */ x3_8_p+x_l-1-2,
/** x3_9:2 */ x3_9_p+x_l-1-2,
/** x3_10:2 */ x3_10_p+x_l-1-2,
/** x3_11:2 */ x3_11_p+x_l-1-2,
/** x3_12:2 */ x3_12_p+x_l-1-2,
/** x4_0:2 */ x4_0_p+x_l-1-2,
/** x4_1:2 */ x4_1_p+x_l-1-2,
/** x4_2:2 */ x4_2_p+x_l-1-2, /* bit 120 */
/** x4_3:2 */ x4_3_p+x_l-1-2,
/** x4_4:2 */ x4_4_p+x_l-1-2,
/** x4_5:2 */ x4_5_p+x_l-1-2,
/** x4_6:2 */ x4_6_p+x_l-1-2,
/** x4_7:2 */ x4_7_p+x_l-1-2,
/** x4_8:2 */ x4_8_p+x_l-1-2,
/** x4_9:2 */ x4_9_p+x_l-1-2,
/** x4_10:2 */ x4_10_p+x_l-1-2,
/** x4_11:2 */ x4_11_p+x_l-1-2,
/** x4_12:2 */ x4_12_p+x_l-1-2, /* bit 130 */
/** M1:0 */ M1_p+M_l-1-0,
/** M2:0 */ M2_p+M_l-1-0,
/** M3:0 */ M3_p+M_l-1-0,
/** M4:0 */ M4_p+M_l-1-0,
/** Xmax1:1 */ Xmax1_p+Xmax_l-1-1,
/** Xmax2:1 */ Xmax2_p+Xmax_l-1-1,
/** Xmax3:1 */ Xmax3_p+Xmax_l-1-1,
/** Xmax4:1 */ Xmax4_p+Xmax_l-1-1,
/** x1_0:1 */ x1_0_p+x_l-1-1,
/** x1_1:1 */ x1_1_p+x_l-1-1, /* bit 140 */
/** x1_2:1 */ x1_2_p+x_l-1-1,
/** x1_3:1 */ x1_3_p+x_l-1-1,
/** x1_4:1 */ x1_4_p+x_l-1-1,
/** x1_5:1 */ x1_5_p+x_l-1-1,
/** x1_6:1 */ x1_6_p+x_l-1-1,
/** x1_7:1 */ x1_7_p+x_l-1-1,
/** x1_8:1 */ x1_8_p+x_l-1-1,
/** x1_9:1 */ x1_9_p+x_l-1-1,
/** x1_10:1 */ x1_10_p+x_l-1-1,
/** x1_11:1 */ x1_11_p+x_l-1-1, /* bit 150 */
/** x1_12:1 */ x1_12_p+x_l-1-1,
/** x2_0:1 */ x2_0_p+x_l-1-1,
/** x2_1:1 */ x2_1_p+x_l-1-1,
/** x2_2:1 */ x2_2_p+x_l-1-1,
/** x2_3:1 */ x2_3_p+x_l-1-1,
/** x2_4:1 */ x2_4_p+x_l-1-1,
/** x2_5:1 */ x2_5_p+x_l-1-1,
/** x2_6:1 */ x2_6_p+x_l-1-1,
/** x2_7:1 */ x2_7_p+x_l-1-1,
/** x2_8:1 */ x2_8_p+x_l-1-1, /* bit 160 */
/** x2_9:1 */ x2_9_p+x_l-1-1,
/** x2_10:1 */ x2_10_p+x_l-1-1,
/** x2_11:1 */ x2_11_p+x_l-1-1,
/** x2_12:1 */ x2_12_p+x_l-1-1,
/** x3_0:1 */ x3_0_p+x_l-1-1,
/** x3_1:1 */ x3_1_p+x_l-1-1,
/** x3_2:1 */ x3_2_p+x_l-1-1,
/** x3_3:1 */ x3_3_p+x_l-1-1,
/** x3_4:1 */ x3_4_p+x_l-1-1,
/** x3_5:1 */ x3_5_p+x_l-1-1, /* bit 170 */
/** x3_6:1 */ x3_6_p+x_l-1-1,
/** x3_7:1 */ x3_7_p+x_l-1-1,
/** x3_8:1 */ x3_8_p+x_l-1-1,
/** x3_9:1 */ x3_9_p+x_l-1-1,
/** x3_10:1 */ x3_10_p+x_l-1-1,
/** x3_11:1 */ x3_11_p+x_l-1-1,
/** x3_12:1 */ x3_12_p+x_l-1-1,
/** x4_0:1 */ x4_0_p+x_l-1-1,
/** x4_1:1 */ x4_1_p+x_l-1-1,
/** x4_2:1 */ x4_2_p+x_l-1-1, /* bit 180 */
/** x4_3:1 */ x4_3_p+x_l-1-1,
//@}
/**@name importance class 6 */
//@{
/** x4_4:1 */ x4_4_p+x_l-1-1,
/** x4_5:1 */ x4_5_p+x_l-1-1,
/** x4_6:1 */ x4_6_p+x_l-1-1,
/** x4_7:1 */ x4_7_p+x_l-1-1,
/** x4_8:1 */ x4_8_p+x_l-1-1,
/** x4_9:1 */ x4_9_p+x_l-1-1,
/** x4_10:1 */ x4_10_p+x_l-1-1,
/** x4_11:1 */ x4_11_p+x_l-1-1,
/** x4_12:1 */ x4_12_p+x_l-1-1, /* bit 190 */
/** LAR1:0 */ LAR1_p+LAR1_l-1-0,
/** LAR2:1 */ LAR2_p+LAR2_l-1-1,
/** LAR3:1 */ LAR3_p+LAR3_l-1-1,
/** LAR6:1 */ LAR6_p+LAR6_l-1-1,
/** LAR7:0 */ LAR7_p+LAR7_l-1-0,
/** LAR8:1 */ LAR8_p+LAR8_l-1-1,
/** LAR8:0 */ LAR8_p+LAR8_l-1-0,
/** LAR3:0 */ LAR3_p+LAR3_l-1-0,
/** LAR4:1 */ LAR4_p+LAR4_l-1-1,
/** LAR4:0 */ LAR4_p+LAR4_l-1-0,
/** LAR5:0 */ LAR5_p+LAR5_l-1-0,
/** Xmax1:0 */ Xmax1_p+Xmax_l-1-0,
/** Xmax2:0 */ Xmax2_p+Xmax_l-1-0,
/** Xmax3:0 */ Xmax3_p+Xmax_l-1-0,
/** Xmax4:0 */ Xmax4_p+Xmax_l-1-0,
/** x1_0:0 */ x1_0_p+x_l-1-0,
/** x1_1:0 */ x1_1_p+x_l-1-0,
/** x1_2:0 */ x1_2_p+x_l-1-0,
/** x1_3:0 */ x1_3_p+x_l-1-0,
/** x1_4:0 */ x1_4_p+x_l-1-0,
/** x1_5:0 */ x1_5_p+x_l-1-0,
/** x1_6:0 */ x1_6_p+x_l-1-0,
/** x1_7:0 */ x1_7_p+x_l-1-0,
/** x1_8:0 */ x1_8_p+x_l-1-0,
/** x1_9:0 */ x1_9_p+x_l-1-0,
/** x1_10:0 */ x1_10_p+x_l-1-0,
/** x1_11:0 */ x1_11_p+x_l-1-0,
/** x1_12:0 */ x1_12_p+x_l-1-0,
/** x2_0:0 */ x2_0_p+x_l-1-0,
/** x2_1:0 */ x2_1_p+x_l-1-0,
/** x2_2:0 */ x2_2_p+x_l-1-0,
/** x2_3:0 */ x2_3_p+x_l-1-0,
/** x2_4:0 */ x2_4_p+x_l-1-0,
/** x2_5:0 */ x2_5_p+x_l-1-0,
/** x2_6:0 */ x2_6_p+x_l-1-0,
/** x2_7:0 */ x2_7_p+x_l-1-0,
/** x2_8:0 */ x2_8_p+x_l-1-0,
/** x2_9:0 */ x2_9_p+x_l-1-0,
/** x2_10:0 */ x2_10_p+x_l-1-0,
/** x2_11:0 */ x2_11_p+x_l-1-0,
/** x2_12:0 */ x2_12_p+x_l-1-0,
/** x3_0:0 */ x3_0_p+x_l-1-0,
/** x3_1:0 */ x3_1_p+x_l-1-0,
/** x3_2:0 */ x3_2_p+x_l-1-0,
/** x3_3:0 */ x3_3_p+x_l-1-0,
/** x3_4:0 */ x3_4_p+x_l-1-0,
/** x3_5:0 */ x3_5_p+x_l-1-0,
/** x3_6:0 */ x3_6_p+x_l-1-0,
/** x3_7:0 */ x3_7_p+x_l-1-0,
/** x3_8:0 */ x3_8_p+x_l-1-0,
/** x3_9:0 */ x3_9_p+x_l-1-0,
/** x3_10:0 */ x3_10_p+x_l-1-0,
/** x3_11:0 */ x3_11_p+x_l-1-0,
/** x3_12:0 */ x3_12_p+x_l-1-0,
/** x4_0:0 */ x4_0_p+x_l-1-0,
/** x4_1:0 */ x4_1_p+x_l-1-0,
/** x4_2:0 */ x4_2_p+x_l-1-0,
/** x4_3:0 */ x4_3_p+x_l-1-0,
/** x4_4:0 */ x4_4_p+x_l-1-0,
/** x4_5:0 */ x4_5_p+x_l-1-0,
/** x4_6:0 */ x4_6_p+x_l-1-0,
/** x4_7:0 */ x4_7_p+x_l-1-0,
/** x4_8:0 */ x4_8_p+x_l-1-0,
/** x4_9:0 */ x4_9_p+x_l-1-0,
/** x4_10:0 */ x4_10_p+x_l-1-0,
/** x4_11:0 */ x4_11_p+x_l-1-0,
/** x4_12:0 */ x4_12_p+x_l-1-0,
/** LAR2:0 */ LAR2_p+LAR2_l-1-0,
/** LAR6:0 */ LAR6_p+LAR6_l-1-0
//@}
};
| {
"language": "Assembly"
} |
// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build linux
// +build ppc64 ppc64le
// +build !gccgo
#include "textflag.h"
//
// System calls for ppc64, Linux
//
// Just jump to package syscall's implementation for all these functions.
// The runtime may know about them.
TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
BL runtime·entersyscall(SB)
MOVD a1+8(FP), R3
MOVD a2+16(FP), R4
MOVD a3+24(FP), R5
MOVD R0, R6
MOVD R0, R7
MOVD R0, R8
MOVD trap+0(FP), R9 // syscall entry
SYSCALL R9
MOVD R3, r1+32(FP)
MOVD R4, r2+40(FP)
BL runtime·exitsyscall(SB)
RET
TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
MOVD a1+8(FP), R3
MOVD a2+16(FP), R4
MOVD a3+24(FP), R5
MOVD R0, R6
MOVD R0, R7
MOVD R0, R8
MOVD trap+0(FP), R9 // syscall entry
SYSCALL R9
MOVD R3, r1+32(FP)
MOVD R4, r2+40(FP)
RET
| {
"language": "Assembly"
} |
# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py
# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=bdver2 -iterations=500 -timeline -timeline-max-iterations=3 < %s | FileCheck %s
add %eax, %eax
vpinsrb $0, %eax, %xmm0, %xmm0
vpinsrb $1, %eax, %xmm0, %xmm0
# CHECK: Iterations: 500
# CHECK-NEXT: Instructions: 1500
# CHECK-NEXT: Total Cycles: 2014
# CHECK-NEXT: Total uOps: 2500
# CHECK: Dispatch Width: 4
# CHECK-NEXT: uOps Per Cycle: 1.24
# CHECK-NEXT: IPC: 0.74
# CHECK-NEXT: Block RThroughput: 3.0
# CHECK: Instruction Info:
# CHECK-NEXT: [1]: #uOps
# CHECK-NEXT: [2]: Latency
# CHECK-NEXT: [3]: RThroughput
# CHECK-NEXT: [4]: MayLoad
# CHECK-NEXT: [5]: MayStore
# CHECK-NEXT: [6]: HasSideEffects (U)
# CHECK: [1] [2] [3] [4] [5] [6] Instructions:
# CHECK-NEXT: 1 1 1.00 addl %eax, %eax
# CHECK-NEXT: 2 12 1.50 vpinsrb $0, %eax, %xmm0, %xmm0
# CHECK-NEXT: 2 12 1.50 vpinsrb $1, %eax, %xmm0, %xmm0
# CHECK: Resources:
# CHECK-NEXT: [0.0] - PdAGLU01
# CHECK-NEXT: [0.1] - PdAGLU01
# CHECK-NEXT: [1] - PdBranch
# CHECK-NEXT: [2] - PdCount
# CHECK-NEXT: [3] - PdDiv
# CHECK-NEXT: [4] - PdEX0
# CHECK-NEXT: [5] - PdEX1
# CHECK-NEXT: [6] - PdFPCVT
# CHECK-NEXT: [7.0] - PdFPFMA
# CHECK-NEXT: [7.1] - PdFPFMA
# CHECK-NEXT: [8.0] - PdFPMAL
# CHECK-NEXT: [8.1] - PdFPMAL
# CHECK-NEXT: [9] - PdFPMMA
# CHECK-NEXT: [10] - PdFPSTO
# CHECK-NEXT: [11] - PdFPU0
# CHECK-NEXT: [12] - PdFPU1
# CHECK-NEXT: [13] - PdFPU2
# CHECK-NEXT: [14] - PdFPU3
# CHECK-NEXT: [15] - PdFPXBR
# CHECK-NEXT: [16.0] - PdLoad
# CHECK-NEXT: [16.1] - PdLoad
# CHECK-NEXT: [17] - PdMul
# CHECK-NEXT: [18] - PdStore
# CHECK: Resource pressure per iteration:
# CHECK-NEXT: [0.0] [0.1] [1] [2] [3] [4] [5] [6] [7.0] [7.1] [8.0] [8.1] [9] [10] [11] [12] [13] [14] [15] [16.0] [16.1] [17] [18]
# CHECK-NEXT: - - - - - 1.00 1.00 - - - 3.00 3.00 - - 1.00 1.00 - - - - - - -
# CHECK: Resource pressure by instruction:
# CHECK-NEXT: [0.0] [0.1] [1] [2] [3] [4] [5] [6] [7.0] [7.1] [8.0] [8.1] [9] [10] [11] [12] [13] [14] [15] [16.0] [16.1] [17] [18] Instructions:
# CHECK-NEXT: - - - - - 1.00 1.00 - - - - - - - - - - - - - - - - addl %eax, %eax
# CHECK-NEXT: - - - - - - - - - - - 3.00 - - - 1.00 - - - - - - - vpinsrb $0, %eax, %xmm0, %xmm0
# CHECK-NEXT: - - - - - - - - - - 3.00 - - - 1.00 - - - - - - - - vpinsrb $1, %eax, %xmm0, %xmm0
# CHECK: Timeline view:
# CHECK-NEXT: 0123456789
# CHECK-NEXT: Index 0123456789 012345
# CHECK: [0,0] DeER . . . . . addl %eax, %eax
# CHECK-NEXT: [0,1] D===========eeER . . vpinsrb $0, %eax, %xmm0, %xmm0
# CHECK-NEXT: [0,2] .D============eeER . . vpinsrb $1, %eax, %xmm0, %xmm0
# CHECK-NEXT: [1,0] .DeE-------------R . . addl %eax, %eax
# CHECK-NEXT: [1,1] . D=============eeER. . vpinsrb $0, %eax, %xmm0, %xmm0
# CHECK-NEXT: [1,2] . D===============eeER . vpinsrb $1, %eax, %xmm0, %xmm0
# CHECK-NEXT: [2,0] . DeE---------------R . addl %eax, %eax
# CHECK-NEXT: [2,1] . D================eeER . vpinsrb $0, %eax, %xmm0, %xmm0
# CHECK-NEXT: [2,2] . D=================eeER vpinsrb $1, %eax, %xmm0, %xmm0
# CHECK: Average Wait times (based on the timeline view):
# CHECK-NEXT: [0]: Executions
# CHECK-NEXT: [1]: Average time spent waiting in a scheduler's queue
# CHECK-NEXT: [2]: Average time spent waiting in a scheduler's queue while ready
# CHECK-NEXT: [3]: Average time elapsed from WB until retire stage
# CHECK: [0] [1] [2] [3]
# CHECK-NEXT: 0. 3 1.0 0.7 9.3 addl %eax, %eax
# CHECK-NEXT: 1. 3 14.3 0.0 0.0 vpinsrb $0, %eax, %xmm0, %xmm0
# CHECK-NEXT: 2. 3 15.7 0.0 0.0 vpinsrb $1, %eax, %xmm0, %xmm0
| {
"language": "Assembly"
} |
glabel func_80981E44
/* 047D4 80981E44 27BDFFE8 */ addiu $sp, $sp, 0xFFE8 ## $sp = FFFFFFE8
/* 047D8 80981E48 AFBF0014 */ sw $ra, 0x0014($sp)
/* 047DC 80981E4C AFA40018 */ sw $a0, 0x0018($sp)
/* 047E0 80981E50 0C260748 */ jal func_80981D20
/* 047E4 80981E54 AFA5001C */ sw $a1, 0x001C($sp)
/* 047E8 80981E58 8FA40018 */ lw $a0, 0x0018($sp)
/* 047EC 80981E5C 8FA5001C */ lw $a1, 0x001C($sp)
/* 047F0 80981E60 0C25FB59 */ jal func_8097ED64
/* 047F4 80981E64 24060007 */ addiu $a2, $zero, 0x0007 ## $a2 = 00000007
/* 047F8 80981E68 8FA40018 */ lw $a0, 0x0018($sp)
/* 047FC 80981E6C 0C26073B */ jal func_80981CEC
/* 04800 80981E70 8FA5001C */ lw $a1, 0x001C($sp)
/* 04804 80981E74 8FBF0014 */ lw $ra, 0x0014($sp)
/* 04808 80981E78 27BD0018 */ addiu $sp, $sp, 0x0018 ## $sp = 00000000
/* 0480C 80981E7C 03E00008 */ jr $ra
/* 04810 80981E80 00000000 */ nop
| {
"language": "Assembly"
} |
polygon
1
1.386712E+01 4.945998E+01
1.386832E+01 4.945999E+01
1.386916E+01 4.946012E+01
1.386930E+01 4.946018E+01
1.386947E+01 4.946029E+01
1.386976E+01 4.946043E+01
1.387009E+01 4.946070E+01
1.387020E+01 4.946076E+01
1.387031E+01 4.946078E+01
1.387078E+01 4.946075E+01
1.387123E+01 4.946073E+01
1.387188E+01 4.946056E+01
1.387270E+01 4.946060E+01
1.387326E+01 4.946058E+01
1.387381E+01 4.946058E+01
1.387491E+01 4.946058E+01
1.387522E+01 4.946069E+01
1.387631E+01 4.946126E+01
1.387753E+01 4.946160E+01
1.387778E+01 4.946165E+01
1.387805E+01 4.946183E+01
1.387847E+01 4.946203E+01
1.387911E+01 4.946224E+01
1.387949E+01 4.946249E+01
1.388011E+01 4.946282E+01
1.388066E+01 4.946320E+01
1.388096E+01 4.946338E+01
1.388105E+01 4.946360E+01
1.388117E+01 4.946369E+01
1.388137E+01 4.946377E+01
1.388183E+01 4.946393E+01
1.388219E+01 4.946407E+01
1.388239E+01 4.946407E+01
1.388299E+01 4.946395E+01
1.388342E+01 4.946374E+01
1.388371E+01 4.946364E+01
1.388394E+01 4.946356E+01
1.388428E+01 4.946356E+01
1.388457E+01 4.946348E+01
1.388491E+01 4.946343E+01
1.388556E+01 4.946332E+01
1.388562E+01 4.946331E+01
1.388567E+01 4.946330E+01
1.388602E+01 4.946368E+01
1.388717E+01 4.946393E+01
1.388813E+01 4.946386E+01
1.388898E+01 4.946367E+01
1.388982E+01 4.946363E+01
1.389065E+01 4.946344E+01
1.389115E+01 4.946317E+01
1.389162E+01 4.946287E+01
1.389239E+01 4.946257E+01
1.389309E+01 4.946227E+01
1.389361E+01 4.946216E+01
1.389393E+01 4.946225E+01
1.389446E+01 4.946243E+01
1.389658E+01 4.946232E+01
1.389783E+01 4.946239E+01
1.389911E+01 4.946215E+01
1.390001E+01 4.946195E+01
1.390093E+01 4.946167E+01
1.390119E+01 4.946157E+01
1.390160E+01 4.946141E+01
1.390240E+01 4.946111E+01
1.390292E+01 4.946092E+01
1.390270E+01 4.946020E+01
1.390243E+01 4.945937E+01
1.390239E+01 4.945932E+01
1.390210E+01 4.945863E+01
1.390183E+01 4.945801E+01
1.390167E+01 4.945747E+01
1.390169E+01 4.945721E+01
1.390174E+01 4.945722E+01
1.390295E+01 4.945697E+01
1.390320E+01 4.945686E+01
1.390378E+01 4.945670E+01
1.390458E+01 4.945649E+01
1.390526E+01 4.945631E+01
1.390615E+01 4.945612E+01
1.390670E+01 4.945601E+01
1.390637E+01 4.945494E+01
1.390532E+01 4.945497E+01
1.390488E+01 4.945468E+01
1.390434E+01 4.945419E+01
1.390433E+01 4.945397E+01
1.390439E+01 4.945390E+01
1.390439E+01 4.945345E+01
1.390378E+01 4.945346E+01
1.390345E+01 4.945299E+01
1.390363E+01 4.945294E+01
1.390361E+01 4.945242E+01
1.390388E+01 4.945217E+01
1.390440E+01 4.945184E+01
1.390434E+01 4.945151E+01
1.390436E+01 4.945144E+01
1.390431E+01 4.945120E+01
1.390428E+01 4.945085E+01
1.390424E+01 4.945078E+01
1.390421E+01 4.945056E+01
1.390424E+01 4.945032E+01
1.390429E+01 4.945015E+01
1.390423E+01 4.945008E+01
1.390427E+01 4.944992E+01
1.390422E+01 4.944984E+01
1.390420E+01 4.944980E+01
1.390411E+01 4.944955E+01
1.390404E+01 4.944921E+01
1.390406E+01 4.944902E+01
1.390434E+01 4.944878E+01
1.390410E+01 4.944858E+01
1.390401E+01 4.944849E+01
1.390387E+01 4.944828E+01
1.390371E+01 4.944805E+01
1.390362E+01 4.944790E+01
1.390403E+01 4.944791E+01
1.390426E+01 4.944791E+01
1.390432E+01 4.944770E+01
1.390432E+01 4.944767E+01
1.390438E+01 4.944706E+01
1.390421E+01 4.944700E+01
1.390388E+01 4.944687E+01
1.390308E+01 4.944663E+01
1.390247E+01 4.944638E+01
1.390208E+01 4.944616E+01
1.390140E+01 4.944572E+01
1.390122E+01 4.944553E+01
1.390116E+01 4.944548E+01
1.390103E+01 4.944525E+01
1.390092E+01 4.944503E+01
1.390090E+01 4.944488E+01
1.390093E+01 4.944469E+01
1.390101E+01 4.944450E+01
1.390115E+01 4.944449E+01
1.390151E+01 4.944442E+01
1.390188E+01 4.944443E+01
1.390189E+01 4.944438E+01
1.390197E+01 4.944433E+01
1.390201E+01 4.944419E+01
1.390192E+01 4.944410E+01
1.390229E+01 4.944400E+01
1.390255E+01 4.944387E+01
1.390303E+01 4.944382E+01
1.390337E+01 4.944370E+01
1.390368E+01 4.944358E+01
1.390388E+01 4.944355E+01
1.390448E+01 4.944334E+01
1.390474E+01 4.944312E+01
1.390481E+01 4.944289E+01
1.390505E+01 4.944248E+01
1.390503E+01 4.944224E+01
1.390474E+01 4.944195E+01
1.390464E+01 4.944189E+01
1.390425E+01 4.944176E+01
1.390393E+01 4.944172E+01
1.390394E+01 4.944151E+01
1.390405E+01 4.944152E+01
1.390404E+01 4.944133E+01
1.390321E+01 4.944117E+01
1.390249E+01 4.944124E+01
1.390229E+01 4.944129E+01
1.390195E+01 4.944132E+01
1.390186E+01 4.944103E+01
1.390184E+01 4.944099E+01
1.390270E+01 4.944080E+01
1.390294E+01 4.944085E+01
1.390324E+01 4.944085E+01
1.390361E+01 4.944080E+01
1.390409E+01 4.944067E+01
1.390457E+01 4.944058E+01
1.390503E+01 4.944053E+01
1.390552E+01 4.944046E+01
1.390579E+01 4.944038E+01
1.390618E+01 4.944034E+01
1.390698E+01 4.944025E+01
1.390702E+01 4.944019E+01
1.390739E+01 4.944011E+01
1.390766E+01 4.944008E+01
1.390769E+01 4.944006E+01
1.390741E+01 4.943985E+01
1.390698E+01 4.943963E+01
1.390671E+01 4.943946E+01
1.390666E+01 4.943940E+01
1.390656E+01 4.943919E+01
1.390646E+01 4.943897E+01
1.390630E+01 4.943882E+01
1.390564E+01 4.943846E+01
1.390528E+01 4.943834E+01
1.390493E+01 4.943825E+01
1.390456E+01 4.943808E+01
1.390455E+01 4.943809E+01
1.390448E+01 4.943807E+01
1.390398E+01 4.943800E+01
1.390365E+01 4.943799E+01
1.390342E+01 4.943812E+01
1.390330E+01 4.943827E+01
1.390326E+01 4.943843E+01
1.390288E+01 4.943842E+01
1.390160E+01 4.943840E+01
1.390092E+01 4.943828E+01
1.390070E+01 4.943818E+01
1.390006E+01 4.943788E+01
1.390001E+01 4.943777E+01
1.390036E+01 4.943748E+01
1.390064E+01 4.943728E+01
1.390047E+01 4.943722E+01
1.390012E+01 4.943727E+01
1.390004E+01 4.943723E+01
1.389973E+01 4.943728E+01
1.389969E+01 4.943707E+01
1.389967E+01 4.943698E+01
1.389928E+01 4.943699E+01
1.389923E+01 4.943668E+01
1.389922E+01 4.943664E+01
1.389829E+01 4.943651E+01
1.389816E+01 4.943648E+01
1.389757E+01 4.943642E+01
1.389756E+01 4.943641E+01
1.389732E+01 4.943638E+01
1.389715E+01 4.943635E+01
1.389684E+01 4.943627E+01
1.389644E+01 4.943612E+01
1.389594E+01 4.943599E+01
1.389607E+01 4.943616E+01
1.389626E+01 4.943627E+01
1.389641E+01 4.943642E+01
1.389635E+01 4.943657E+01
1.389536E+01 4.943677E+01
1.389572E+01 4.943740E+01
1.389444E+01 4.943759E+01
1.389383E+01 4.943773E+01
1.389385E+01 4.943812E+01
1.389394E+01 4.943831E+01
1.389411E+01 4.943844E+01
1.389425E+01 4.943859E+01
1.389438E+01 4.943867E+01
1.389369E+01 4.943931E+01
1.389374E+01 4.943931E+01
1.389498E+01 4.943931E+01
1.389554E+01 4.943948E+01
1.389530E+01 4.943989E+01
1.389503E+01 4.943980E+01
1.389480E+01 4.943975E+01
1.389442E+01 4.943969E+01
1.389430E+01 4.943976E+01
1.389428E+01 4.943980E+01
1.389365E+01 4.943964E+01
1.389340E+01 4.943954E+01
1.389323E+01 4.943945E+01
1.389260E+01 4.943905E+01
1.389244E+01 4.943893E+01
1.389227E+01 4.943878E+01
1.389207E+01 4.943854E+01
1.389193E+01 4.943831E+01
1.389186E+01 4.943833E+01
1.389126E+01 4.943819E+01
1.389077E+01 4.943814E+01
1.389028E+01 4.943816E+01
1.388997E+01 4.943818E+01
1.388999E+01 4.943845E+01
1.388849E+01 4.943865E+01
1.388851E+01 4.943919E+01
1.388855E+01 4.943953E+01
1.388871E+01 4.943995E+01
1.388957E+01 4.943979E+01
1.388965E+01 4.943969E+01
1.388977E+01 4.943960E+01
1.389001E+01 4.943965E+01
1.389050E+01 4.943980E+01
1.389087E+01 4.943994E+01
1.389138E+01 4.944017E+01
1.389142E+01 4.944019E+01
1.389158E+01 4.944029E+01
1.389185E+01 4.944037E+01
1.389169E+01 4.944046E+01
1.389013E+01 4.944066E+01
1.389010E+01 4.944066E+01
1.389013E+01 4.944092E+01
1.389016E+01 4.944114E+01
1.388959E+01 4.944127E+01
1.388910E+01 4.944136E+01
1.388862E+01 4.944143E+01
1.388719E+01 4.944155E+01
1.388584E+01 4.944151E+01
1.388539E+01 4.944149E+01
1.388517E+01 4.944150E+01
1.388515E+01 4.944151E+01
1.388506E+01 4.944129E+01
1.388513E+01 4.944094E+01
1.388484E+01 4.944069E+01
1.388453E+01 4.944025E+01
1.388439E+01 4.944010E+01
1.388426E+01 4.944002E+01
1.388388E+01 4.943986E+01
1.388385E+01 4.943983E+01
1.388374E+01 4.943988E+01
1.388374E+01 4.943993E+01
1.388388E+01 4.943999E+01
1.388405E+01 4.944009E+01
1.388332E+01 4.944046E+01
1.388344E+01 4.944064E+01
1.388306E+01 4.944071E+01
1.388313E+01 4.944082E+01
1.388310E+01 4.944094E+01
1.388317E+01 4.944111E+01
1.388310E+01 4.944116E+01
1.388294E+01 4.944131E+01
1.388284E+01 4.944135E+01
1.388278E+01 4.944142E+01
1.388279E+01 4.944147E+01
1.388284E+01 4.944153E+01
1.388283E+01 4.944160E+01
1.388278E+01 4.944167E+01
1.388265E+01 4.944174E+01
1.388248E+01 4.944201E+01
1.388232E+01 4.944209E+01
1.388221E+01 4.944220E+01
1.388196E+01 4.944238E+01
1.388201E+01 4.944247E+01
1.388207E+01 4.944257E+01
1.388249E+01 4.944243E+01
1.388264E+01 4.944237E+01
1.388307E+01 4.944236E+01
1.388307E+01 4.944238E+01
1.388305E+01 4.944241E+01
1.388280E+01 4.944245E+01
1.388265E+01 4.944247E+01
1.388214E+01 4.944263E+01
1.388188E+01 4.944286E+01
1.388180E+01 4.944290E+01
1.388152E+01 4.944295E+01
1.388120E+01 4.944303E+01
1.388097E+01 4.944306E+01
1.388058E+01 4.944316E+01
1.388026E+01 4.944328E+01
1.387999E+01 4.944342E+01
1.387989E+01 4.944338E+01
1.387955E+01 4.944337E+01
1.387942E+01 4.944340E+01
1.387922E+01 4.944339E+01
1.387897E+01 4.944345E+01
1.387888E+01 4.944348E+01
1.387884E+01 4.944358E+01
1.387875E+01 4.944372E+01
1.387861E+01 4.944373E+01
1.387852E+01 4.944378E+01
1.387829E+01 4.944393E+01
1.387810E+01 4.944406E+01
1.387796E+01 4.944411E+01
1.387788E+01 4.944427E+01
1.387775E+01 4.944424E+01
1.387762E+01 4.944424E+01
1.387744E+01 4.944428E+01
1.387732E+01 4.944434E+01
1.387727E+01 4.944438E+01
1.387703E+01 4.944421E+01
1.387673E+01 4.944436E+01
1.387643E+01 4.944450E+01
1.387643E+01 4.944463E+01
1.387642E+01 4.944478E+01
1.387638E+01 4.944486E+01
1.387630E+01 4.944487E+01
1.387623E+01 4.944498E+01
1.387604E+01 4.944513E+01
1.387613E+01 4.944527E+01
1.387626E+01 4.944538E+01
1.387639E+01 4.944544E+01
1.387613E+01 4.944563E+01
1.387596E+01 4.944585E+01
1.387568E+01 4.944606E+01
1.387547E+01 4.944632E+01
1.387531E+01 4.944649E+01
1.387525E+01 4.944658E+01
1.387425E+01 4.944710E+01
1.387395E+01 4.944722E+01
1.387389E+01 4.944724E+01
1.387329E+01 4.944769E+01
1.387308E+01 4.944775E+01
1.387266E+01 4.944816E+01
1.387247E+01 4.944821E+01
1.387240E+01 4.944834E+01
1.387222E+01 4.944844E+01
1.387204E+01 4.944852E+01
1.387192E+01 4.944858E+01
1.387190E+01 4.944864E+01
1.387183E+01 4.944876E+01
1.387182E+01 4.944882E+01
1.387157E+01 4.944898E+01
1.387160E+01 4.944903E+01
1.387176E+01 4.944918E+01
1.387170E+01 4.944927E+01
1.387136E+01 4.944930E+01
1.387124E+01 4.944925E+01
1.387111E+01 4.944928E+01
1.387093E+01 4.944949E+01
1.387061E+01 4.944950E+01
1.387059E+01 4.944956E+01
1.387047E+01 4.944963E+01
1.387002E+01 4.944961E+01
1.386995E+01 4.944953E+01
1.386987E+01 4.944950E+01
1.386972E+01 4.944957E+01
1.386956E+01 4.944990E+01
1.386953E+01 4.944995E+01
1.386983E+01 4.945005E+01
1.387017E+01 4.945039E+01
1.387014E+01 4.945083E+01
1.386991E+01 4.945100E+01
1.387042E+01 4.945136E+01
1.387053E+01 4.945147E+01
1.387066E+01 4.945161E+01
1.387091E+01 4.945178E+01
1.387102E+01 4.945197E+01
1.387109E+01 4.945225E+01
1.387115E+01 4.945240E+01
1.387121E+01 4.945261E+01
1.387110E+01 4.945296E+01
1.387072E+01 4.945316E+01
1.387031E+01 4.945342E+01
1.387016E+01 4.945350E+01
1.386986E+01 4.945364E+01
1.386964E+01 4.945383E+01
1.386842E+01 4.945322E+01
1.386836E+01 4.945325E+01
1.386821E+01 4.945335E+01
1.386811E+01 4.945332E+01
1.386789E+01 4.945357E+01
1.386789E+01 4.945365E+01
1.386798E+01 4.945366E+01
1.386810E+01 4.945356E+01
1.386826E+01 4.945364E+01
1.386825E+01 4.945384E+01
1.386814E+01 4.945397E+01
1.386814E+01 4.945407E+01
1.386819E+01 4.945429E+01
1.386829E+01 4.945478E+01
1.386833E+01 4.945500E+01
1.386819E+01 4.945509E+01
1.386816E+01 4.945514E+01
1.386841E+01 4.945531E+01
1.386867E+01 4.945529E+01
1.386878E+01 4.945536E+01
1.386887E+01 4.945569E+01
1.386880E+01 4.945571E+01
1.386878E+01 4.945576E+01
1.386902E+01 4.945595E+01
1.386897E+01 4.945599E+01
1.386890E+01 4.945606E+01
1.386877E+01 4.945625E+01
1.386863E+01 4.945627E+01
1.386852E+01 4.945630E+01
1.386843E+01 4.945638E+01
1.386843E+01 4.945648E+01
1.386848E+01 4.945655E+01
1.386848E+01 4.945665E+01
1.386843E+01 4.945675E+01
1.386836E+01 4.945683E+01
1.386839E+01 4.945704E+01
1.386825E+01 4.945706E+01
1.386813E+01 4.945694E+01
1.386806E+01 4.945693E+01
1.386785E+01 4.945696E+01
1.386767E+01 4.945705E+01
1.386755E+01 4.945717E+01
1.386756E+01 4.945726E+01
1.386762E+01 4.945731E+01
1.386756E+01 4.945744E+01
1.386738E+01 4.945756E+01
1.386732E+01 4.945774E+01
1.386735E+01 4.945780E+01
1.386723E+01 4.945790E+01
1.386718E+01 4.945800E+01
1.386707E+01 4.945808E+01
1.386665E+01 4.945820E+01
1.386664E+01 4.945825E+01
1.386672E+01 4.945832E+01
1.386679E+01 4.945861E+01
1.386663E+01 4.945876E+01
1.386642E+01 4.945876E+01
1.386643E+01 4.945873E+01
1.386638E+01 4.945874E+01
1.386631E+01 4.945882E+01
1.386632E+01 4.945895E+01
1.386635E+01 4.945901E+01
1.386636E+01 4.945898E+01
1.386648E+01 4.945907E+01
1.386650E+01 4.945920E+01
1.386647E+01 4.945936E+01
1.386660E+01 4.945944E+01
1.386663E+01 4.945957E+01
1.386661E+01 4.945969E+01
1.386656E+01 4.945985E+01
1.386665E+01 4.945985E+01
1.386677E+01 4.945985E+01
1.386712E+01 4.945998E+01
END
END
| {
"language": "Assembly"
} |
/** @file
Parts of the SMM/MM implementation that are specific to standalone MM
Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>
Copyright (c) 2018, Linaro, Ltd. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#include <Library/SmmMemLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include "FaultTolerantWrite.h"
#include "FaultTolerantWriteSmmCommon.h"
/**
This function checks if the buffer is valid per processor architecture and
does not overlap with SMRAM.
@param Buffer The buffer start address to be checked.
@param Length The buffer length to be checked.
@retval TRUE This buffer is valid per processor architecture and does not
overlap with SMRAM.
@retval FALSE This buffer is not valid per processor architecture or overlaps
with SMRAM.
**/
BOOLEAN
FtwSmmIsBufferOutsideSmmValid (
IN EFI_PHYSICAL_ADDRESS Buffer,
IN UINT64 Length
)
{
return TRUE;
}
/**
Internal implementation of CRC32. Depending on the execution context
(standalone SMM or DXE vs standalone MM), this function is implemented
via a call to the CalculateCrc32 () boot service, or via a library
call.
If Buffer is NULL, then ASSERT().
If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
@param[in] Buffer A pointer to the buffer on which the 32-bit CRC is to be computed.
@param[in] Length The number of bytes in the buffer Data.
@retval Crc32 The 32-bit CRC was computed for the data buffer.
**/
UINT32
FtwCalculateCrc32 (
IN VOID *Buffer,
IN UINTN Length
)
{
return CalculateCrc32 (Buffer, Length);
}
/**
Notify the system that the SMM FTW driver is ready.
**/
VOID
FtwNotifySmmReady (
VOID
)
{
}
/**
This function is the entry point of the Fault Tolerant Write driver.
@param[in] ImageHandle A handle for the image that is initializing this driver
@param[in] MmSystemTable A pointer to the MM system table
@retval EFI_SUCCESS The initialization finished successfully.
@retval EFI_OUT_OF_RESOURCES Allocate memory error
@retval EFI_INVALID_PARAMETER Workspace or Spare block does not exist
**/
EFI_STATUS
EFIAPI
StandaloneMmFaultTolerantWriteInitialize (
IN EFI_HANDLE ImageHandle,
IN EFI_MM_SYSTEM_TABLE *MmSystemTable
)
{
return MmFaultTolerantWriteInitialize ();
}
| {
"language": "Assembly"
} |
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build !gccgo
#include "textflag.h"
//
// System call support for AMD64, NetBSD
//
// Just jump to package syscall's implementation for all these functions.
// The runtime may know about them.
TEXT ·Syscall(SB),NOSPLIT,$0-56
JMP syscall·Syscall(SB)
TEXT ·Syscall6(SB),NOSPLIT,$0-80
JMP syscall·Syscall6(SB)
TEXT ·Syscall9(SB),NOSPLIT,$0-104
JMP syscall·Syscall9(SB)
TEXT ·RawSyscall(SB),NOSPLIT,$0-56
JMP syscall·RawSyscall(SB)
TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
JMP syscall·RawSyscall6(SB)
| {
"language": "Assembly"
} |
/*
* SYSCALL_DEFINE1(mq_unlink, const char __user *, u_name)
*/
#include "sanitise.h"
struct syscallentry syscall_mq_unlink = {
.name = "mq_unlink",
.num_args = 1,
.arg1name = "u_name",
.arg1type = ARG_ADDRESS,
};
| {
"language": "Assembly"
} |
/*
** ###################################################################
** Processors: MIMXRT1062CVJ5A
** MIMXRT1062CVL5A
** MIMXRT1062DVJ6A
** MIMXRT1062DVL6A
**
** Compiler: GNU C Compiler
** Reference manual: IMXRT1060RM Rev.1, 12/2018 | IMXRT1060SRM Rev.3
** Version: rev. 0.1, 2017-01-10
** Build: b191015
**
** Abstract:
** Linker file for the GNU C Compiler
**
** Copyright 2016 Freescale Semiconductor, Inc.
** Copyright 2016-2019 NXP
** All rights reserved.
**
** SPDX-License-Identifier: BSD-3-Clause
**
** http: www.nxp.com
** mail: support@nxp.com
**
** ###################################################################
*/
/* Entry Point */
ENTRY(Reset_Handler)
HEAP_SIZE = DEFINED(__heap_size__) ? __heap_size__ : 0x0400;
STACK_SIZE = DEFINED(__stack_size__) ? __stack_size__ : 0x0400;
/* Specify the memory areas */
MEMORY
{
m_interrupts (RX) : ORIGIN = 0x00000000, LENGTH = 0x00000400
m_text (RX) : ORIGIN = 0x00000400, LENGTH = 0x0001FC00
m_data (RW) : ORIGIN = 0x20000000, LENGTH = 0x00020000
m_data2 (RW) : ORIGIN = 0x20200000, LENGTH = 0x000C0000
}
/* Define output sections */
SECTIONS
{
__NCACHE_REGION_START = ORIGIN(m_data2);
__NCACHE_REGION_SIZE = 0;
/* The startup code goes first into internal RAM */
.interrupts :
{
__VECTOR_TABLE = .;
. = ALIGN(4);
KEEP(*(.isr_vector)) /* Startup code */
. = ALIGN(4);
} > m_interrupts
/* The program code and other data goes into internal RAM */
.text :
{
. = ALIGN(4);
*(.text) /* .text sections (code) */
*(.text*) /* .text* sections (code) */
*(.rodata) /* .rodata sections (constants, strings, etc.) */
*(.rodata*) /* .rodata* sections (constants, strings, etc.) */
*(.glue_7) /* glue arm to thumb code */
*(.glue_7t) /* glue thumb to arm code */
*(.eh_frame)
KEEP (*(.init))
KEEP (*(.fini))
. = ALIGN(4);
} > m_text
.ARM.extab :
{
*(.ARM.extab* .gnu.linkonce.armextab.*)
} > m_text
.ARM :
{
__exidx_start = .;
*(.ARM.exidx*)
__exidx_end = .;
} > m_text
.ctors :
{
__CTOR_LIST__ = .;
/* gcc uses crtbegin.o to find the start of
the constructors, so we make sure it is
first. Because this is a wildcard, it
doesn't matter if the user does not
actually link against crtbegin.o; the
linker won't look for a file to match a
wildcard. The wildcard also means that it
doesn't matter which directory crtbegin.o
is in. */
KEEP (*crtbegin.o(.ctors))
KEEP (*crtbegin?.o(.ctors))
/* We don't want to include the .ctor section from
from the crtend.o file until after the sorted ctors.
The .ctor section from the crtend file contains the
end of ctors marker and it must be last */
KEEP (*(EXCLUDE_FILE(*crtend?.o *crtend.o) .ctors))
KEEP (*(SORT(.ctors.*)))
KEEP (*(.ctors))
__CTOR_END__ = .;
} > m_text
.dtors :
{
__DTOR_LIST__ = .;
KEEP (*crtbegin.o(.dtors))
KEEP (*crtbegin?.o(.dtors))
KEEP (*(EXCLUDE_FILE(*crtend?.o *crtend.o) .dtors))
KEEP (*(SORT(.dtors.*)))
KEEP (*(.dtors))
__DTOR_END__ = .;
} > m_text
.preinit_array :
{
PROVIDE_HIDDEN (__preinit_array_start = .);
KEEP (*(.preinit_array*))
PROVIDE_HIDDEN (__preinit_array_end = .);
} > m_text
.init_array :
{
PROVIDE_HIDDEN (__init_array_start = .);
KEEP (*(SORT(.init_array.*)))
KEEP (*(.init_array*))
PROVIDE_HIDDEN (__init_array_end = .);
} > m_text
.fini_array :
{
PROVIDE_HIDDEN (__fini_array_start = .);
KEEP (*(SORT(.fini_array.*)))
KEEP (*(.fini_array*))
PROVIDE_HIDDEN (__fini_array_end = .);
} > m_text
__etext = .; /* define a global symbol at end of code */
__DATA_ROM = .; /* Symbol is used by startup for data initialization */
__VECTOR_RAM = ORIGIN(m_interrupts);
__RAM_VECTOR_TABLE_SIZE_BYTES = 0x0;
.data : AT(__DATA_ROM)
{
. = ALIGN(4);
__DATA_RAM = .;
__data_start__ = .; /* create a global symbol at data start */
*(m_usb_dma_init_data)
*(.data) /* .data sections */
*(.data*) /* .data* sections */
KEEP(*(.jcr*))
. = ALIGN(4);
__data_end__ = .; /* define a global symbol at data end */
} > m_data
__NDATA_ROM = __DATA_ROM + (__data_end__ - __data_start__);
.ncache.init : AT(__NDATA_ROM)
{
__noncachedata_start__ = .; /* create a global symbol at ncache data start */
*(NonCacheable.init)
. = ALIGN(4);
__noncachedata_init_end__ = .; /* create a global symbol at initialized ncache data end */
} > m_data
. = __noncachedata_init_end__;
.ncache :
{
*(NonCacheable)
. = ALIGN(4);
__noncachedata_end__ = .; /* define a global symbol at ncache data end */
} > m_data
__DATA_END = __NDATA_ROM + (__noncachedata_init_end__ - __noncachedata_start__);
text_end = ORIGIN(m_text) + LENGTH(m_text);
ASSERT(__DATA_END <= text_end, "region m_text overflowed with text and data")
/* Uninitialized data section */
.bss :
{
/* This is used by the startup in order to initialize the .bss section */
. = ALIGN(4);
__START_BSS = .;
__bss_start__ = .;
*(m_usb_dma_noninit_data)
*(.bss)
*(.bss*)
*(COMMON)
. = ALIGN(4);
__bss_end__ = .;
__END_BSS = .;
} > m_data
.heap :
{
. = ALIGN(8);
__end__ = .;
PROVIDE(end = .);
__HeapBase = .;
. += HEAP_SIZE;
__HeapLimit = .;
__heap_limit = .; /* Add for _sbrk */
} > m_data
.stack :
{
. = ALIGN(8);
. += STACK_SIZE;
} > m_data
/* Initializes stack on the end of block */
__StackTop = ORIGIN(m_data) + LENGTH(m_data);
__StackLimit = __StackTop - STACK_SIZE;
PROVIDE(__stack = __StackTop);
.ARM.attributes 0 : { *(.ARM.attributes) }
ASSERT(__StackLimit >= __HeapLimit, "region m_data overflowed with stack and heap")
}
| {
"language": "Assembly"
} |
# Instructions that are invalid
#
# FIXME: This test should be moved to the mips5 directory when mips5 is supported
# RUN: not llvm-mc %s -triple=mips64-unknown-linux -show-encoding -mcpu=mips4 \
# RUN: 2>%t1
# RUN: FileCheck %s < %t1
.set noat
clo $t3,$a1 # CHECK: :[[@LINE]]:{{[0-9]+}}: error: instruction requires a CPU feature not currently enabled
clz $sp,$gp # CHECK: :[[@LINE]]:{{[0-9]+}}: error: instruction requires a CPU feature not currently enabled
dclo $s2,$a2 # CHECK: :[[@LINE]]:{{[0-9]+}}: error: instruction requires a CPU feature not currently enabled
dclz $s0,$t9 # CHECK: :[[@LINE]]:{{[0-9]+}}: error: instruction requires a CPU feature not currently enabled
| {
"language": "Assembly"
} |
/*############################################################################
# Copyright 2016 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.
############################################################################*/
/*!
* \file
*
* \brief Intel(R) EPID 1.1 constant parameters data.
*
*/
{{{ // p
0x00, 0x00, 0x89, 0x57, 0x3F, 0x17, 0x47, 0x30, 0x8C, 0x43, 0xD5, 0xEE,
0x41, 0x97, 0x96, 0x19, 0x72, 0xBB, 0x86, 0x88, 0xED, 0x4B, 0xEF, 0x04,
0xAB, 0xAE, 0xC3, 0x8E, 0xEC, 0x51, 0xC3, 0xD3
}}},
{{{ // q
0x09, 0xF9, 0x24, 0xE5, 0xD9, 0xBC, 0x67, 0x7F, 0x81, 0x0D, 0xF0, 0x25,
0x58, 0xF7, 0x53, 0x13, 0xA9, 0x8A, 0xA6, 0x10, 0x47, 0x65, 0x5D, 0x73,
0x9E, 0xF1, 0x94, 0xEB, 0x05, 0xB1, 0xA7, 0x11
}}},
{{ // h
0x00, 0x00, 0x12, 0x97
}},
{{{ // a
0x05, 0x53, 0xD7, 0xC8, 0x81, 0xF7, 0x78, 0xC2, 0x2C, 0x37, 0xB6, 0xC0,
0x16, 0x3E, 0x68, 0x24, 0x3A, 0x84, 0x78, 0x1C, 0x0A, 0xDF, 0x9B, 0xB3,
0xED, 0x21, 0xC4, 0x46, 0xE5, 0xA7, 0xA3, 0x92
}}},
{{{ // b
0x00, 0x3A, 0x2E, 0x39, 0x0E, 0x10, 0xD8, 0xAC, 0x47, 0xCB, 0x29, 0xC8,
0xF1, 0x2C, 0x7F, 0x11, 0x99, 0x2A, 0x18, 0xB7, 0xEF, 0x73, 0x48, 0xA6,
0xBE, 0x70, 0xA6, 0x8B, 0x97, 0x34, 0x8A, 0xB1
}}},
{ // coeff
{{{ // coeff[0]
0x02, 0x16, 0x7A, 0x61, 0x53, 0xDD, 0xF6, 0xE2, 0x89, 0x15, 0xA0, 0x94,
0xF1, 0xB5, 0xDC, 0x65, 0x21, 0x15, 0x62, 0xE1, 0x7D, 0xC5, 0x43, 0x89,
0xEE, 0xB4, 0xEF, 0xC8, 0xA0, 0x8E, 0x34, 0x0F
}}},
{{{ // coeff[1]
0x04, 0x82, 0x27, 0xE1, 0xEB, 0x98, 0x64, 0xC2, 0x8D, 0x8F, 0xDD, 0x0E,
0x82, 0x40, 0xAE, 0xD4, 0x31, 0x63, 0xD6, 0x46, 0x32, 0x16, 0x85, 0x7A,
0xB7, 0x18, 0x68, 0xB8, 0x17, 0x02, 0x81, 0xA6
}}},
{{{ // coeff[2]
0x06, 0x20, 0x76, 0xE8, 0x54, 0x54, 0x53, 0xB4, 0xA9, 0xD8, 0x44, 0x4B,
0xAA, 0xFB, 0x1C, 0xFD, 0xAE, 0x15, 0xCA, 0x29, 0x79, 0xA6, 0x24, 0xA4,
0x0A, 0xF6, 0x1E, 0xAC, 0xED, 0xFB, 0x10, 0x41
}}},
},
{{{ // qnr
0x08, 0x66, 0xA7, 0x67, 0x36, 0x6E, 0x62, 0x71, 0xB7, 0xA6, 0x52, 0x94,
0x8F, 0xFB, 0x25, 0x9E, 0xE6, 0x4F, 0x25, 0xE5, 0x26, 0x9A, 0x2B, 0x6E,
0x7E, 0xF8, 0xA6, 0x39, 0xAE, 0x46, 0xAA, 0x24
}}},
{{ // orderG2
0x00, 0x03, 0xDF, 0xFC, 0xBE, 0x2F, 0x5C, 0x2E, 0x45, 0x49, 0x7A, 0x2A,
0x91, 0xBA, 0xD1, 0x3E, 0x01, 0xEC, 0x5F, 0xC2, 0x15, 0x14, 0x10, 0xB3,
0x28, 0x5E, 0x56, 0xCC, 0x26, 0x51, 0x24, 0x93, 0x0E, 0x6C, 0x99, 0x96,
0x38, 0xE0, 0x7D, 0x68, 0x8C, 0xB7, 0x97, 0x23, 0xF4, 0xAC, 0x4D, 0xBC,
0x5E, 0x01, 0x15, 0xFF, 0x45, 0x60, 0x08, 0x13, 0xCD, 0x59, 0xD7, 0x73,
0xB0, 0x0C, 0x20, 0x5E, 0xAB, 0xAA, 0x24, 0x31, 0xE2, 0x2A, 0xA2, 0x53,
0x8A, 0xF7, 0x86, 0xD5, 0x19, 0x78, 0xC5, 0x55, 0x9C, 0x08, 0xB7, 0xE2,
0xF4, 0xD0, 0x37, 0x74, 0x93, 0x56, 0x62, 0x7B, 0x95, 0xCC, 0x2C, 0xB0
}},
{{{ // p_tick
0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84,
0xF3, 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51
}}},
{{{ // q_tick
0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
}}},
{{ // h_tick
0x00, 0x00, 0x00, 0x01
}},
{{{ // a_tick
0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC
}}},
{{{ // b_tick
0x5A, 0xC6, 0x35, 0xD8, 0xAA, 0x3A, 0x93, 0xE7, 0xB3, 0xEB, 0xBD, 0x55,
0x76, 0x98, 0x86, 0xBC, 0x65, 0x1D, 0x06, 0xB0, 0xCC, 0x53, 0xB0, 0xF6,
0x3B, 0xCE, 0x3C, 0x3E, 0x27, 0xD2, 0x60, 0x4B
}}},
{ // g1
{{{ // x
0x07, 0x78, 0x3B, 0x0D, 0xFE, 0x4A, 0xA3, 0x19, 0x49, 0xB0, 0xCE, 0xAF,
0x3F, 0x74, 0x0F, 0x32, 0x16, 0x0C, 0x8B, 0x46, 0x94, 0x5B, 0xA5, 0xB0,
0xE4, 0x8A, 0xDA, 0xD8, 0x88, 0x32, 0x90, 0x53
}}},
{{{ // y
0x08, 0xF7, 0xA2, 0xAA, 0xBA, 0x62, 0xB3, 0xFE, 0x29, 0x80, 0xC9, 0x5B,
0x63, 0x53, 0xC8, 0x24, 0x3C, 0x7C, 0x1F, 0x4C, 0xDA, 0xCD, 0xE5, 0x5F,
0xA2, 0x36, 0x93, 0x04, 0x3C, 0x3A, 0xBC, 0x2E
}}},
},
{ // g2
{ // x
{{{ // x[0]
0x02, 0x10, 0x9A, 0xF4, 0x06, 0x32, 0x30, 0x89, 0xCB, 0x95, 0xE9, 0x55,
0x0E, 0x9D, 0xAF, 0x0E, 0x98, 0xCD, 0xCA, 0xDC, 0xB1, 0xFF, 0xFC, 0xD1,
0x45, 0x66, 0xBB, 0x86, 0x46, 0x1E, 0x8C, 0x30
}}},
{{{ // x[1]
0x04, 0x78, 0x53, 0xE1, 0x3F, 0x96, 0xC5, 0xE4, 0x15, 0x23, 0x7B, 0x1F,
0x3F, 0x2C, 0xD3, 0x95, 0x40, 0xBC, 0x7A, 0x31, 0x1F, 0x14, 0x38, 0x9E,
0x1A, 0xA5, 0xD6, 0x63, 0x10, 0x91, 0xE4, 0xD3
}}},
{{{ // x[2]
0x00, 0xB4, 0x02, 0xBC, 0x47, 0xFA, 0xA6, 0x29, 0x82, 0x0B, 0xB1, 0xD5,
0xFF, 0xF2, 0xE6, 0xB0, 0xC6, 0xAE, 0xE8, 0x7B, 0x91, 0xD9, 0xEE, 0x66,
0x07, 0x1F, 0xFD, 0xA2, 0xE7, 0x02, 0x66, 0xDD
}}},
},
{ // y
{{{ // y[0]
0x05, 0x2E, 0xF8, 0xC6, 0xC1, 0x6A, 0xEF, 0x3C, 0xC1, 0x95, 0xF6, 0x26,
0xCE, 0x5E, 0x55, 0xD1, 0x64, 0x13, 0x28, 0xB1, 0x18, 0x57, 0xD8, 0x1B,
0x84, 0xFA, 0xEC, 0x7E, 0x5D, 0x99, 0x06, 0x49
}}},
{{{ // y[1]
0x05, 0x73, 0x35, 0xA9, 0xA7, 0xF2, 0xA1, 0x92, 0x5F, 0x3E, 0x7C, 0xDF,
0xAC, 0xFE, 0x0F, 0xF5, 0x08, 0xD0, 0x3C, 0xAE, 0xCD, 0x58, 0x00, 0x5F,
0xD0, 0x84, 0x7E, 0xEA, 0x63, 0x57, 0xFE, 0xC6
}}},
{{{ // y[2]
0x01, 0x56, 0xDA, 0xF3, 0x72, 0x61, 0xDA, 0xC6, 0x93, 0xB0, 0xAC, 0xEF,
0xAA, 0xD4, 0x51, 0x6D, 0xCA, 0x71, 0x1E, 0x06, 0x73, 0xEA, 0x83, 0xB2,
0xB1, 0x99, 0x4A, 0x4D, 0x4A, 0x0D, 0x35, 0x07
}}},
},
},
{ // g3
{{{ // x
0x6B, 0x17, 0xD1, 0xF2, 0xE1, 0x2C, 0x42, 0x47, 0xF8, 0xBC, 0xE6, 0xE5,
0x63, 0xA4, 0x40, 0xF2, 0x77, 0x03, 0x7D, 0x81, 0x2D, 0xEB, 0x33, 0xA0,
0xF4, 0xA1, 0x39, 0x45, 0xD8, 0x98, 0xC2, 0x96
}}},
{{{ // y
0x4F, 0xE3, 0x42, 0xE2, 0xFE, 0x1A, 0x7F, 0x9B, 0x8E, 0xE7, 0xEB, 0x4A,
0x7C, 0x0F, 0x9E, 0x16, 0x2B, 0xCE, 0x33, 0x57, 0x6B, 0x31, 0x5E, 0xCE,
0xCB, 0xB6, 0x40, 0x68, 0x37, 0xBF, 0x51, 0xF5
}}},
}
| {
"language": "Assembly"
} |
/**
******************************************************************************
* @file startup_stm32f10x_md_vl.s
* @author MCD Application Team
* @version V3.5.0
* @date 11-March-2011
* @brief STM32F10x Medium Density Value Line Devices vector table for RIDE7
* toolchain.
* This module performs:
* - Set the initial SP
* - Set the initial PC == Reset_Handler,
* - Set the vector table entries with the exceptions ISR address
* - Configure the clock system
* - Branches to main in the C library (which eventually
* calls main()).
* After Reset the Cortex-M3 processor is in Thread mode,
* priority is Privileged, and the Stack is set to Main.
******************************************************************************
* @attention
*
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
* TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*
* <h2><center>© COPYRIGHT 2011 STMicroelectronics</center></h2>
******************************************************************************
*/
.syntax unified
.cpu cortex-m3
.fpu softvfp
.thumb
.global g_pfnVectors
.global Default_Handler
/* start address for the initialization values of the .data section.
defined in linker script */
.word _sidata
/* start address for the .data section. defined in linker script */
.word _sdata
/* end address for the .data section. defined in linker script */
.word _edata
/* start address for the .bss section. defined in linker script */
.word _sbss
/* end address for the .bss section. defined in linker script */
.word _ebss
.equ BootRAM, 0xF108F85F
/**
* @brief This is the code that gets called when the processor first
* starts execution following a reset event. Only the absolutely
* necessary set is performed, after which the application
* supplied main() routine is called.
* @param None
* @retval None
*/
.section .text.Reset_Handler
.weak Reset_Handler
.type Reset_Handler, %function
Reset_Handler:
/* Copy the data segment initializers from flash to SRAM */
movs r1, #0
b LoopCopyDataInit
CopyDataInit:
ldr r3, =_sidata
ldr r3, [r3, r1]
str r3, [r0, r1]
adds r1, r1, #4
LoopCopyDataInit:
ldr r0, =_sdata
ldr r3, =_edata
adds r2, r0, r1
cmp r2, r3
bcc CopyDataInit
ldr r2, =_sbss
b LoopFillZerobss
/* Zero fill the bss segment. */
FillZerobss:
movs r3, #0
str r3, [r2], #4
LoopFillZerobss:
ldr r3, = _ebss
cmp r2, r3
bcc FillZerobss
/* Call the clock system intitialization function.*/
bl SystemInit
/* Call the application's entry point.*/
bl main
bx lr
.size Reset_Handler, .-Reset_Handler
/**
* @brief This is the code that gets called when the processor receives an
* unexpected interrupt. This simply enters an infinite loop, preserving
* the system state for examination by a debugger.
* @param None
* @retval None
*/
.section .text.Default_Handler,"ax",%progbits
Default_Handler:
Infinite_Loop:
b Infinite_Loop
.size Default_Handler, .-Default_Handler
/******************************************************************************
*
* The minimal vector table for a Cortex M3. Note that the proper constructs
* must be placed on this to ensure that it ends up at physical address
* 0x0000.0000.
*
******************************************************************************/
.section .isr_vector,"a",%progbits
.type g_pfnVectors, %object
.size g_pfnVectors, .-g_pfnVectors
g_pfnVectors:
.word _estack
.word Reset_Handler
.word NMI_Handler
.word HardFault_Handler
.word MemManage_Handler
.word BusFault_Handler
.word UsageFault_Handler
.word 0
.word 0
.word 0
.word 0
.word SVC_Handler
.word DebugMon_Handler
.word 0
.word PendSV_Handler
.word SysTick_Handler
.word WWDG_IRQHandler
.word PVD_IRQHandler
.word TAMPER_IRQHandler
.word RTC_IRQHandler
.word FLASH_IRQHandler
.word RCC_IRQHandler
.word EXTI0_IRQHandler
.word EXTI1_IRQHandler
.word EXTI2_IRQHandler
.word EXTI3_IRQHandler
.word EXTI4_IRQHandler
.word DMA1_Channel1_IRQHandler
.word DMA1_Channel2_IRQHandler
.word DMA1_Channel3_IRQHandler
.word DMA1_Channel4_IRQHandler
.word DMA1_Channel5_IRQHandler
.word DMA1_Channel6_IRQHandler
.word DMA1_Channel7_IRQHandler
.word ADC1_IRQHandler
.word 0
.word 0
.word 0
.word 0
.word EXTI9_5_IRQHandler
.word TIM1_BRK_TIM15_IRQHandler
.word TIM1_UP_TIM16_IRQHandler
.word TIM1_TRG_COM_TIM17_IRQHandler
.word TIM1_CC_IRQHandler
.word TIM2_IRQHandler
.word TIM3_IRQHandler
.word TIM4_IRQHandler
.word I2C1_EV_IRQHandler
.word I2C1_ER_IRQHandler
.word I2C2_EV_IRQHandler
.word I2C2_ER_IRQHandler
.word SPI1_IRQHandler
.word SPI2_IRQHandler
.word USART1_IRQHandler
.word USART2_IRQHandler
.word USART3_IRQHandler
.word EXTI15_10_IRQHandler
.word RTCAlarm_IRQHandler
.word CEC_IRQHandler
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word TIM6_DAC_IRQHandler
.word TIM7_IRQHandler
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word BootRAM /* @0x01CC. This is for boot in RAM mode for
STM32F10x Medium Value Line Density devices. */
/*******************************************************************************
* Provide weak aliases for each Exception handler to the Default_Handler.
* As they are weak aliases, any function with the same name will override
* this definition.
*******************************************************************************/
.weak NMI_Handler
.thumb_set NMI_Handler,Default_Handler
.weak HardFault_Handler
.thumb_set HardFault_Handler,Default_Handler
.weak MemManage_Handler
.thumb_set MemManage_Handler,Default_Handler
.weak BusFault_Handler
.thumb_set BusFault_Handler,Default_Handler
.weak UsageFault_Handler
.thumb_set UsageFault_Handler,Default_Handler
.weak SVC_Handler
.thumb_set SVC_Handler,Default_Handler
.weak DebugMon_Handler
.thumb_set DebugMon_Handler,Default_Handler
.weak PendSV_Handler
.thumb_set PendSV_Handler,Default_Handler
/*
* SysTick_Handler in stm32plus is now marked 'weak' so that compatibility with other
* frameworks is made possible.
.weak SysTick_Handler
.thumb_set SysTick_Handler,Default_Handler
*/
.weak WWDG_IRQHandler
.thumb_set WWDG_IRQHandler,Default_Handler
.weak PVD_IRQHandler
.thumb_set PVD_IRQHandler,Default_Handler
.weak TAMPER_IRQHandler
.thumb_set TAMPER_IRQHandler,Default_Handler
.weak RTC_IRQHandler
.thumb_set RTC_IRQHandler,Default_Handler
.weak FLASH_IRQHandler
.thumb_set FLASH_IRQHandler,Default_Handler
.weak RCC_IRQHandler
.thumb_set RCC_IRQHandler,Default_Handler
.weak EXTI0_IRQHandler
.thumb_set EXTI0_IRQHandler,Default_Handler
.weak EXTI1_IRQHandler
.thumb_set EXTI1_IRQHandler,Default_Handler
.weak EXTI2_IRQHandler
.thumb_set EXTI2_IRQHandler,Default_Handler
.weak EXTI3_IRQHandler
.thumb_set EXTI3_IRQHandler,Default_Handler
.weak EXTI4_IRQHandler
.thumb_set EXTI4_IRQHandler,Default_Handler
.weak DMA1_Channel1_IRQHandler
.thumb_set DMA1_Channel1_IRQHandler,Default_Handler
.weak DMA1_Channel2_IRQHandler
.thumb_set DMA1_Channel2_IRQHandler,Default_Handler
.weak DMA1_Channel3_IRQHandler
.thumb_set DMA1_Channel3_IRQHandler,Default_Handler
.weak DMA1_Channel4_IRQHandler
.thumb_set DMA1_Channel4_IRQHandler,Default_Handler
.weak DMA1_Channel5_IRQHandler
.thumb_set DMA1_Channel5_IRQHandler,Default_Handler
.weak DMA1_Channel6_IRQHandler
.thumb_set DMA1_Channel6_IRQHandler,Default_Handler
.weak DMA1_Channel7_IRQHandler
.thumb_set DMA1_Channel7_IRQHandler,Default_Handler
.weak ADC1_IRQHandler
.thumb_set ADC1_IRQHandler,Default_Handler
.weak EXTI9_5_IRQHandler
.thumb_set EXTI9_5_IRQHandler,Default_Handler
.weak TIM1_BRK_TIM15_IRQHandler
.thumb_set TIM1_BRK_TIM15_IRQHandler,Default_Handler
.weak TIM1_UP_TIM16_IRQHandler
.thumb_set TIM1_UP_TIM16_IRQHandler,Default_Handler
.weak TIM1_TRG_COM_TIM17_IRQHandler
.thumb_set TIM1_TRG_COM_TIM17_IRQHandler,Default_Handler
.weak TIM1_CC_IRQHandler
.thumb_set TIM1_CC_IRQHandler,Default_Handler
.weak TIM2_IRQHandler
.thumb_set TIM2_IRQHandler,Default_Handler
.weak TIM3_IRQHandler
.thumb_set TIM3_IRQHandler,Default_Handler
.weak TIM4_IRQHandler
.thumb_set TIM4_IRQHandler,Default_Handler
.weak I2C1_EV_IRQHandler
.thumb_set I2C1_EV_IRQHandler,Default_Handler
.weak I2C1_ER_IRQHandler
.thumb_set I2C1_ER_IRQHandler,Default_Handler
.weak I2C2_EV_IRQHandler
.thumb_set I2C2_EV_IRQHandler,Default_Handler
.weak I2C2_ER_IRQHandler
.thumb_set I2C2_ER_IRQHandler,Default_Handler
.weak SPI1_IRQHandler
.thumb_set SPI1_IRQHandler,Default_Handler
.weak SPI2_IRQHandler
.thumb_set SPI2_IRQHandler,Default_Handler
.weak USART1_IRQHandler
.thumb_set USART1_IRQHandler,Default_Handler
.weak USART2_IRQHandler
.thumb_set USART2_IRQHandler,Default_Handler
.weak USART3_IRQHandler
.thumb_set USART3_IRQHandler,Default_Handler
.weak EXTI15_10_IRQHandler
.thumb_set EXTI15_10_IRQHandler,Default_Handler
.weak RTCAlarm_IRQHandler
.thumb_set RTCAlarm_IRQHandler,Default_Handler
.weak CEC_IRQHandler
.thumb_set CEC_IRQHandler,Default_Handler
.weak TIM6_DAC_IRQHandler
.thumb_set TIM6_DAC_IRQHandler,Default_Handler
.weak TIM7_IRQHandler
.thumb_set TIM7_IRQHandler,Default_Handler
/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
| {
"language": "Assembly"
} |
[0.2.0 release]
2007-06-19 Vincent Gramoli <vincent.gramoli@epfl.ch>
* Common interface TX_START/TX_LOAD/TX_STORE/TX_END
for any type of transactions (elastic/normal)
2007-06-10 Vincent Gramoli <vincent.gramoli@epfl.ch>
* Removed ro mode
* Adapting hash table and skip list tests
[0.1.8 release]
2007-06-10 Vincent Gramoli <vincent.gramoli@epfl.ch>
* Enhance efficiency for elastic functions.
* stm_normal_load/store for normal transactions.
* Removed support for stm_unit_write
(elastic_store switches to tx type to normal).
[0.1.7 release]
2007-05-23 Vincent Gramoli <vincent.gramoli@epfl.ch>
* Debug of function stm_elastic_load.
* Added stm_elastic_store functions.
2007-05-20 Vincent Gramoli <vincent.gramoli@epfl.ch>
* Added stm_unit_load/stm_unit_write to stm.c
* Upgrade normal transactions to tinySTM-v0.9.9
[0.1.4 release]
2007-04-25 Vincent Gramoli <vincent.gramoli@epfl.ch>
* Added red-black tree test.
2009-02-02 Vincent Gramoli <vincent.gramoli@epfl.ch>
* Added skip list test.
* Added hash table test w/ move and sum operations.
2008-12-01 Vincent Gramoli <vincent.gramoli@epfl.ch>
* Added -x option for unit load/store.
[0.1.0 release]
2008-11-01 Vincent Gramoli <vincent.gramoli@epfl.ch>
* Initial release.
| {
"language": "Assembly"
} |
; REQUIRES: asserts
; RUN: llc < %s -march=ppc32 -stats 2>&1 | \
; RUN: grep "4 .*Number of machine instrs printed"
;; Integer absolute value, should produce something as good as:
;; srawi r2, r3, 31
;; add r3, r3, r2
;; xor r3, r3, r2
;; blr
define i32 @test(i32 %a) {
%tmp1neg = sub i32 0, %a
%b = icmp sgt i32 %a, -1
%abs = select i1 %b, i32 %a, i32 %tmp1neg
ret i32 %abs
}
| {
"language": "Assembly"
} |
/* File: startup_ARMCM0.S
* Purpose: startup file for Cortex-M0 devices. Should use with
* GCC for ARM Embedded Processors
* Version: V1.2
* Date: 15 Nov 2011
*
* Copyright (c) 2011, ARM Limited
* 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 the ARM Limited 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 ARM LIMITED 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.
*/
.syntax unified
.arch armv6-m
/* Memory Model
The HEAP starts at the end of the DATA section and grows upward.
The STACK starts at the end of the RAM and grows downward.
The HEAP and stack STACK are only checked at compile time:
(DATA_SIZE + HEAP_SIZE + STACK_SIZE) < RAM_SIZE
This is just a check for the bare minimum for the Heap+Stack area before
aborting compilation, it is not the run time limit:
Heap_Size + Stack_Size = 0x80 + 0x80 = 0x100
*/
.section .stack
.align 3
#ifdef __STACK_SIZE
.equ Stack_Size, __STACK_SIZE
#else
.equ Stack_Size, 0x80
#endif
.globl __StackTop
.globl __StackLimit
__StackLimit:
.space Stack_Size
.size __StackLimit, . - __StackLimit
__StackTop:
.size __StackTop, . - __StackTop
.section .heap
.align 3
#ifdef __HEAP_SIZE
.equ Heap_Size, __HEAP_SIZE
#else
.equ Heap_Size, 0x80
#endif
.globl __HeapBase
.globl __HeapLimit
__HeapBase:
.space Heap_Size
.size __HeapBase, . - __HeapBase
__HeapLimit:
.size __HeapLimit, . - __HeapLimit
.section .isr_vector
.align 2
.globl __isr_vector
__isr_vector:
.long __StackTop /* Top of Stack */
.long Reset_Handler /* Reset Handler */
.long NMI_Handler /* NMI Handler */
.long HardFault_Handler /* Hard Fault Handler */
.long 0 /* Reserved */
.long 0 /* Reserved */
.long 0 /* Reserved */
.long 0 /* Reserved */
.long 0 /* Reserved */
.long 0 /* Reserved */
.long 0 /* Reserved */
.long SVC_Handler /* SVCall Handler */
.long 0 /* Reserved */
.long 0 /* Reserved */
.long PendSV_Handler /* PendSV Handler */
.long SysTick_Handler /* SysTick Handler */
/* External interrupts */
.long DMA0_IRQHandler /* DMA channel 0 transfer complete interrupt */
.long DMA1_IRQHandler /* DMA channel 1 transfer complete interrupt */
.long DMA2_IRQHandler /* DMA channel 2 transfer complete interrupt */
.long DMA3_IRQHandler /* DMA channel 3 transfer complete interrupt */
.long Reserved20_IRQHandler /* Reserved interrupt 20 */
.long FTFA_IRQHandler /* FTFA interrupt */
.long LVD_LVW_IRQHandler /* Low Voltage Detect, Low Voltage Warning */
.long LLW_IRQHandler /* Low Leakage Wakeup */
.long I2C0_IRQHandler /* I2C0 interrupt */
.long I2C1_IRQHandler /* I2C0 interrupt 25 */
.long SPI0_IRQHandler /* SPI0 interrupt */
.long SPI1_IRQHandler /* SPI1 interrupt */
.long UART0_IRQHandler /* UART0 status/error interrupt */
.long UART1_IRQHandler /* UART1 status/error interrupt */
.long UART2_IRQHandler /* UART2 status/error interrupt */
.long ADC0_IRQHandler /* ADC0 interrupt */
.long CMP0_IRQHandler /* CMP0 interrupt */
.long TPM0_IRQHandler /* TPM0 fault, overflow and channels interrupt */
.long TPM1_IRQHandler /* TPM1 fault, overflow and channels interrupt */
.long TPM2_IRQHandler /* TPM2 fault, overflow and channels interrupt */
.long RTC_IRQHandler /* RTC interrupt */
.long RTC_Seconds_IRQHandler /* RTC seconds interrupt */
.long PIT_IRQHandler /* PIT timer interrupt */
.long Reserved39_IRQHandler /* Reserved interrupt 39 */
.long USB0_IRQHandler /* USB0 interrupt */
.long DAC0_IRQHandler /* DAC interrupt */
.long TSI0_IRQHandler /* TSI0 interrupt */
.long MCG_IRQHandler /* MCG interrupt */
.long LPTimer_IRQHandler /* LPTimer interrupt */
.long Reserved45_IRQHandler /* Reserved interrupt 45 */
.long PORTA_IRQHandler /* Port A interrupt */
.long PORTD_IRQHandler /* Port D interrupt */
.size __isr_vector, . - __isr_vector
.section .text.Reset_Handler
.thumb
.thumb_func
.align 2
.globl Reset_Handler
.type Reset_Handler, %function
Reset_Handler:
/* Loop to copy data from read only memory to RAM. The ranges
* of copy from/to are specified by following symbols evaluated in
* linker script.
* __etext: End of code section, i.e., begin of data sections to copy from.
* __data_start__/__data_end__: RAM address range that data should be
* copied to. Both must be aligned to 4 bytes boundary. */
ldr r1, =__etext
ldr r2, =__data_start__
ldr r3, =__data_end__
subs r3, r2
ble .flash_to_ram_loop_end
movs r4, 0
.flash_to_ram_loop:
ldr r0, [r1,r4]
str r0, [r2,r4]
adds r4, 4
cmp r4, r3
blt .flash_to_ram_loop
.flash_to_ram_loop_end:
ldr r0, =SystemInit
blx r0
ldr r0, =_start
bx r0
.pool
.size Reset_Handler, . - Reset_Handler
.text
/* Macro to define default handlers. Default handler
* will be weak symbol and just dead loops. They can be
* overwritten by other handlers */
.macro def_default_handler handler_name
.align 1
.thumb_func
.weak \handler_name
.type \handler_name, %function
\handler_name :
b .
.size \handler_name, . - \handler_name
.endm
def_default_handler NMI_Handler
def_default_handler HardFault_Handler
def_default_handler SVC_Handler
def_default_handler PendSV_Handler
def_default_handler SysTick_Handler
def_default_handler DMA0_IRQHandler
def_default_handler DMA1_IRQHandler
def_default_handler DMA2_IRQHandler
def_default_handler DMA3_IRQHandler
def_default_handler Reserved20_IRQHandler
def_default_handler FTFA_IRQHandler
def_default_handler LVD_LVW_IRQHandler
def_default_handler LLW_IRQHandler
def_default_handler I2C0_IRQHandler
def_default_handler I2C1_IRQHandler
def_default_handler SPI0_IRQHandler
def_default_handler SPI1_IRQHandler
def_default_handler UART0_IRQHandler
def_default_handler UART1_IRQHandler
def_default_handler UART2_IRQHandler
def_default_handler ADC0_IRQHandler
def_default_handler CMP0_IRQHandler
def_default_handler TPM0_IRQHandler
def_default_handler TPM1_IRQHandler
def_default_handler TPM2_IRQHandler
def_default_handler RTC_IRQHandler
def_default_handler RTC_Seconds_IRQHandler
def_default_handler PIT_IRQHandler
def_default_handler Reserved39_IRQHandler
def_default_handler USB0_IRQHandler
def_default_handler DAC0_IRQHandler
def_default_handler TSI0_IRQHandler
def_default_handler MCG_IRQHandler
def_default_handler LPTimer_IRQHandler
def_default_handler Reserved45_IRQHandler
def_default_handler PORTA_IRQHandler
def_default_handler PORTD_IRQHandler
.weak DEF_IRQHandler
.set DEF_IRQHandler, Default_Handler
.end
| {
"language": "Assembly"
} |
glabel func_809416D0
/* 08A00 809416D0 24010015 */ addiu $at, $zero, 0x0015 ## $at = 00000015
/* 08A04 809416D4 AFA40000 */ sw $a0, 0x0000($sp)
/* 08A08 809416D8 14A1000E */ bne $a1, $at, .L80941714
/* 08A0C 809416DC AFA7000C */ sw $a3, 0x000C($sp)
/* 08A10 809416E0 8FA20014 */ lw $v0, 0x0014($sp)
/* 08A14 809416E4 904E05F8 */ lbu $t6, 0x05F8($v0) ## 000005F8
/* 08A18 809416E8 55C0000B */ bnel $t6, $zero, .L80941718
/* 08A1C 809416EC 2401000E */ addiu $at, $zero, 0x000E ## $at = 0000000E
/* 08A20 809416F0 844F001C */ lh $t7, 0x001C($v0) ## 0000001C
/* 08A24 809416F4 3C190601 */ lui $t9, 0x0601 ## $t9 = 06010000
/* 08A28 809416F8 3C180601 */ lui $t8, 0x0601 ## $t8 = 06010000
/* 08A2C 809416FC 15E00004 */ bne $t7, $zero, .L80941710
/* 08A30 80941700 273934B8 */ addiu $t9, $t9, 0x34B8 ## $t9 = 060134B8
/* 08A34 80941704 27182CE0 */ addiu $t8, $t8, 0x2CE0 ## $t8 = 06012CE0
/* 08A38 80941708 10000002 */ beq $zero, $zero, .L80941714
/* 08A3C 8094170C ACD80000 */ sw $t8, 0x0000($a2) ## 00000000
.L80941710:
/* 08A40 80941710 ACD90000 */ sw $t9, 0x0000($a2) ## 00000000
.L80941714:
/* 08A44 80941714 2401000E */ addiu $at, $zero, 0x000E ## $at = 0000000E
.L80941718:
/* 08A48 80941718 14A10019 */ bne $a1, $at, .L80941780
/* 08A4C 8094171C 8FA20014 */ lw $v0, 0x0014($sp)
/* 08A50 80941720 8C49014C */ lw $t1, 0x014C($v0) ## 0000014C
/* 08A54 80941724 3C088094 */ lui $t0, %hi(func_8093D444) ## $t0 = 80940000
/* 08A58 80941728 2508D444 */ addiu $t0, $t0, %lo(func_8093D444) ## $t0 = 8093D444
/* 08A5C 8094172C 55090005 */ bnel $t0, $t1, .L80941744
/* 08A60 80941730 44802000 */ mtc1 $zero, $f4 ## $f4 = 0.00
/* 08A64 80941734 ACC00000 */ sw $zero, 0x0000($a2) ## 00000000
/* 08A68 80941738 03E00008 */ jr $ra
/* 08A6C 8094173C 00001025 */ or $v0, $zero, $zero ## $v0 = 00000000
.L80941740:
/* 08A70 80941740 44802000 */ mtc1 $zero, $f4 ## $f4 = 0.00
.L80941744:
/* 08A74 80941744 C44604D0 */ lwc1 $f6, 0x04D0($v0) ## 000004D0
/* 08A78 80941748 46062032 */ c.eq.s $f4, $f6
/* 08A7C 8094174C 00000000 */ nop
/* 08A80 80941750 4500000B */ bc1f .L80941780
/* 08A84 80941754 00000000 */ nop
/* 08A88 80941758 844A001C */ lh $t2, 0x001C($v0) ## 0000001C
/* 08A8C 8094175C 3C0C0601 */ lui $t4, 0x0601 ## $t4 = 06010000
/* 08A90 80941760 3C0B0601 */ lui $t3, 0x0601 ## $t3 = 06010000
/* 08A94 80941764 15400005 */ bne $t2, $zero, .L8094177C
/* 08A98 80941768 258C3310 */ addiu $t4, $t4, 0x3310 ## $t4 = 06013310
/* 08A9C 8094176C 256B2B38 */ addiu $t3, $t3, 0x2B38 ## $t3 = 06012B38
/* 08AA0 80941770 ACCB0000 */ sw $t3, 0x0000($a2) ## 00000000
/* 08AA4 80941774 03E00008 */ jr $ra
/* 08AA8 80941778 00001025 */ or $v0, $zero, $zero ## $v0 = 00000000
.L8094177C:
/* 08AAC 8094177C ACCC0000 */ sw $t4, 0x0000($a2) ## 00000000
.L80941780:
/* 08AB0 80941780 03E00008 */ jr $ra
/* 08AB4 80941784 00001025 */ or $v0, $zero, $zero ## $v0 = 00000000
| {
"language": "Assembly"
} |
SFX_Cry22_4_Ch5:
duty_cycle_pattern 0, 1, 0, 1
square_note 2, 3, -5, 897
square_note 7, 15, 5, 1537
square_note 1, 12, 2, 1153
square_note 8, 9, 1, 897
sound_ret
SFX_Cry22_4_Ch6:
duty_cycle_pattern 3, 2, 3, 2
square_note 2, 3, -6, 1456
square_note 7, 13, 5, 1885
square_note 1, 11, 2, 1712
square_note 8, 6, 1, 1456
sound_ret
SFX_Cry22_4_Ch8:
noise_note 2, 9, 2, 73
noise_note 7, 11, 5, 41
noise_note 1, 10, 2, 57
noise_note 8, 9, 1, 73
sound_ret
| {
"language": "Assembly"
} |
dnl SPARC v7 __udiv_qrnnd division support, used from longlong.h.
dnl This is for v7 CPUs without a floating-point unit.
dnl Copyright 1993, 1994, 1996, 2000 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')
C INPUT PARAMETERS
C rem_ptr o0
C n1 o1
C n0 o2
C d o3
ASM_START()
PROLOGUE(mpn_udiv_qrnnd)
tst %o3
bneg L(largedivisor)
mov 8,%g1
b L(p1)
addxcc %o2,%o2,%o2
L(plop):
bcc L(n1)
addxcc %o2,%o2,%o2
L(p1): addx %o1,%o1,%o1
subcc %o1,%o3,%o4
bcc L(n2)
addxcc %o2,%o2,%o2
L(p2): addx %o1,%o1,%o1
subcc %o1,%o3,%o4
bcc L(n3)
addxcc %o2,%o2,%o2
L(p3): addx %o1,%o1,%o1
subcc %o1,%o3,%o4
bcc L(n4)
addxcc %o2,%o2,%o2
L(p4): addx %o1,%o1,%o1
addcc %g1,-1,%g1
bne L(plop)
subcc %o1,%o3,%o4
bcc L(n5)
addxcc %o2,%o2,%o2
L(p5): st %o1,[%o0]
retl
xnor %g0,%o2,%o0
L(nlop):
bcc L(p1)
addxcc %o2,%o2,%o2
L(n1): addx %o4,%o4,%o4
subcc %o4,%o3,%o1
bcc L(p2)
addxcc %o2,%o2,%o2
L(n2): addx %o4,%o4,%o4
subcc %o4,%o3,%o1
bcc L(p3)
addxcc %o2,%o2,%o2
L(n3): addx %o4,%o4,%o4
subcc %o4,%o3,%o1
bcc L(p4)
addxcc %o2,%o2,%o2
L(n4): addx %o4,%o4,%o4
addcc %g1,-1,%g1
bne L(nlop)
subcc %o4,%o3,%o1
bcc L(p5)
addxcc %o2,%o2,%o2
L(n5): st %o4,[%o0]
retl
xnor %g0,%o2,%o0
L(largedivisor):
and %o2,1,%o5 C %o5 = n0 & 1
srl %o2,1,%o2
sll %o1,31,%g2
or %g2,%o2,%o2 C %o2 = lo(n1n0 >> 1)
srl %o1,1,%o1 C %o1 = hi(n1n0 >> 1)
and %o3,1,%g2
srl %o3,1,%g3 C %g3 = floor(d / 2)
add %g3,%g2,%g3 C %g3 = ceil(d / 2)
b L(Lp1)
addxcc %o2,%o2,%o2
L(Lplop):
bcc L(Ln1)
addxcc %o2,%o2,%o2
L(Lp1): addx %o1,%o1,%o1
subcc %o1,%g3,%o4
bcc L(Ln2)
addxcc %o2,%o2,%o2
L(Lp2): addx %o1,%o1,%o1
subcc %o1,%g3,%o4
bcc L(Ln3)
addxcc %o2,%o2,%o2
L(Lp3): addx %o1,%o1,%o1
subcc %o1,%g3,%o4
bcc L(Ln4)
addxcc %o2,%o2,%o2
L(Lp4): addx %o1,%o1,%o1
addcc %g1,-1,%g1
bne L(Lplop)
subcc %o1,%g3,%o4
bcc L(Ln5)
addxcc %o2,%o2,%o2
L(Lp5): add %o1,%o1,%o1 C << 1
tst %g2
bne L(oddp)
add %o5,%o1,%o1
st %o1,[%o0]
retl
xnor %g0,%o2,%o0
L(Lnlop):
bcc L(Lp1)
addxcc %o2,%o2,%o2
L(Ln1): addx %o4,%o4,%o4
subcc %o4,%g3,%o1
bcc L(Lp2)
addxcc %o2,%o2,%o2
L(Ln2): addx %o4,%o4,%o4
subcc %o4,%g3,%o1
bcc L(Lp3)
addxcc %o2,%o2,%o2
L(Ln3): addx %o4,%o4,%o4
subcc %o4,%g3,%o1
bcc L(Lp4)
addxcc %o2,%o2,%o2
L(Ln4): addx %o4,%o4,%o4
addcc %g1,-1,%g1
bne L(Lnlop)
subcc %o4,%g3,%o1
bcc L(Lp5)
addxcc %o2,%o2,%o2
L(Ln5): add %o4,%o4,%o4 C << 1
tst %g2
bne L(oddn)
add %o5,%o4,%o4
st %o4,[%o0]
retl
xnor %g0,%o2,%o0
L(oddp):
xnor %g0,%o2,%o2
C q' in %o2. r' in %o1
addcc %o1,%o2,%o1
bcc L(Lp6)
addx %o2,0,%o2
sub %o1,%o3,%o1
L(Lp6): subcc %o1,%o3,%g0
bcs L(Lp7)
subx %o2,-1,%o2
sub %o1,%o3,%o1
L(Lp7): st %o1,[%o0]
retl
mov %o2,%o0
L(oddn):
xnor %g0,%o2,%o2
C q' in %o2. r' in %o4
addcc %o4,%o2,%o4
bcc L(Ln6)
addx %o2,0,%o2
sub %o4,%o3,%o4
L(Ln6): subcc %o4,%o3,%g0
bcs L(Ln7)
subx %o2,-1,%o2
sub %o4,%o3,%o4
L(Ln7): st %o4,[%o0]
retl
mov %o2,%o0
EPILOGUE(mpn_udiv_qrnnd)
| {
"language": "Assembly"
} |
/* .include "vector_defns.h" */
.section .privileged_code, "ax"
.arm
.weak __mbed_fiq
.weak __mbed_undef
.weak __mbed_prefetch_abort
.weak __mbed_data_abort
.weak __mbed_irq
.weak __mbed_swi
.weak __mbed_dcc_irq
.weak __mbed_reset
.global __mbed_init_realmonitor
.weak SVC_Handler
.weak IRQ_Handler
/* .global __mbed_init */
__mbed_fiq:
B __mbed_fiq
__mbed_undef:
LDR PC, =0x7fffffa0
__mbed_prefetch_abort:
LDR PC, =0x7fffffb0
__mbed_data_abort:
LDR PC, =0x7fffffc0
__mbed_irq:
/*
If RTOS is enabled then goto RTOS IRQ handler
*/
PUSH {R0}
LDR R0, =IRQ_Handler
CMP R0, #0
POP {R0}
BNE IRQ_Handler
/*
else use CMSIS IRQ handler
*/
MSR CPSR_c, #0x1F|0x80|0x40
STMDB sp!, {r0-r3,r12,lr}
MOV r0, #0xFFFFFF00
LDR r0, [r0]
MOV lr, pc
BX r0
MOV r0, #0xFFFFFF00
STR r0, [r0]
LDMFD sp!,{r0-r3,r12,lr}
MSR CPSR_c, #0x12|0x80|0x40
SUBS pc, lr, #4
__mbed_swi:
/*
If RTOS is enabled then goto RTOS SVC handler
*/
PUSH {R0}
LDR R0, =SVC_Handler
CMP R0, #0
POP {R0}
BNE SVC_Handler
/*
else use CMSIS SVC handler
*/
STMFD sp!, {a4, r4, ip, lr}
LDR r4, =0x40000040
LDR a4, =0x00940000
LDR PC, =0x7ffff820
__mbed_dcc_irq:
LDMFD sp!,{r0-r3,r12,lr}
MSR CPSR_c, #0x12|0x80|0x40
SUB lr, lr, #4
STMFD sp!, {ip,lr}
LDR LR, =0xfffff000
STR LR, [LR, #0xf00]
LDR PC, =0x7fffffe0
/*
__mbed_reset is called after reset
we setup the stacks and realmonitor, then call Reset_Handler like on M3
*/
.section .text, "ax"
.arm
.global Reset_handler
Reset_Handler:
.extern __libc_init_array
.extern SystemInit
.weak software_init_hook
LDR R0, =SystemInit
MOV LR, PC
BX R0
/* if (software_init_hook) // give control to the RTOS
software_init_hook(); // this will also call __libc_init_array
*/
LDR R0, =software_init_hook
CMP R0, #0
BEQ nortos
ORR R0,R0,#1 /* set thumb address */
BX R0
/* else */
nortos:
LDR R0, =__libc_init_array
MOV LR, PC
BX R0
MSR CPSR_c, #0x1F /* enable irq */
LDR R0, =main
BX R0
__mbed_reset:
LDR R0, =( __SRAM_segment_end__ )
MSR CPSR_c, #0x1B|0x80|0x40
MOV SP, R0
SUB R0, R0, #0x00000040
MSR CPSR_c, #0x17|0x80|0x40
MOV SP, R0
SUB R0, R0, #0x00000040
MSR CPSR_c, #0x11|0x80|0x40
MOV SP, R0
SUB R0, R0, #0x00000040
MSR CPSR_c, #0x12|0x80|0x40
MOV SP, R0
SUB R0, R0, #0x00000040
MSR CPSR_c, #0x13|0x80|0x40
MOV SP, R0
SUB R0, R0, #0x00000040
/*
MSR CPSR_c, #0x10|0x80|0x40
MOV SP, R0
*/
MSR CPSR_c, #0x1F|0x80|0x40
MOV SP, R0
MSR CPSR_c, #0x13|0x80|0x40 /* execute in Supervisor mode */
/* Relocate .data section (Copy from ROM to RAM) */
LDR R1, =__text_end__ /* _etext */
LDR R2, =__data_start__ /* _data */
LDR R3, =__data_end__ /* _edata */
CMP R2, R3
BEQ DataIsEmpty
LoopRel: CMP R2, R3
LDRLO R0, [R1], #4
STRLO R0, [R2], #4
BLO LoopRel
DataIsEmpty:
/* Clear .bss section (Zero init) */
MOV R0, #0
LDR R1, =__bss_start__
LDR R2, =__bss_end__
CMP R1,R2
BEQ BSSIsEmpty
LoopZI: CMP R1, R2
STRLO R0, [R1], #4
BLO LoopZI
BSSIsEmpty:
/* Init realmonitor */
/*
LDR R0, =__mbed_init_realmonitor
MOV LR, PC
BX R0
*/
/* Go to Reset_Handler */
LDR R0, =Reset_Handler
BX R0
| {
"language": "Assembly"
} |
; NOTE: Assertions have been autogenerated by update_test_checks.py
; RUN: opt -S -instsimplify < %s | FileCheck %s
define i1 @test(i32 %a) {
; CHECK-LABEL: @test(
; CHECK: ret i1 false
;
%rhs = add i32 %a, -1
%and = and i32 %a, %rhs
%res = icmp eq i32 %and, 1
ret i1 %res
}
define i1 @test2(i32 %a) {
; CHECK-LABEL: @test2(
; CHECK: ret i1 false
;
%rhs = add i32 %a, 1
%and = and i32 %a, %rhs
%res = icmp eq i32 %and, 1
ret i1 %res
}
define i1 @test3(i32 %a) {
; CHECK-LABEL: @test3(
; CHECK: ret i1 false
;
%rhs = add i32 %a, 7
%and = and i32 %a, %rhs
%res = icmp eq i32 %and, 1
ret i1 %res
}
@B = external global i32
declare void @llvm.assume(i1)
; Known bits without a constant
define i1 @test4(i32 %a) {
; CHECK-LABEL: @test4(
; CHECK: [[B:%.*]] = load i32, i32* @B
; CHECK-NEXT: [[B_AND:%.*]] = and i32 [[B]], 1
; CHECK-NEXT: [[B_CND:%.*]] = icmp eq i32 [[B_AND]], 1
; CHECK-NEXT: call void @llvm.assume(i1 [[B_CND]])
; CHECK-NEXT: ret i1 false
;
%b = load i32, i32* @B
%b.and = and i32 %b, 1
%b.cnd = icmp eq i32 %b.and, 1
call void @llvm.assume(i1 %b.cnd)
%rhs = add i32 %a, %b
%and = and i32 %a, %rhs
%res = icmp eq i32 %and, 1
ret i1 %res
}
; Negative test - even number
define i1 @test5(i32 %a) {
; CHECK-LABEL: @test5(
; CHECK: [[RHS:%.*]] = add i32 %a, 2
; CHECK-NEXT: [[AND:%.*]] = and i32 %a, [[RHS]]
; CHECK-NEXT: [[RES:%.*]] = icmp eq i32 [[AND]], 1
; CHECK-NEXT: ret i1 [[RES]]
;
%rhs = add i32 %a, 2
%and = and i32 %a, %rhs
%res = icmp eq i32 %and, 1
ret i1 %res
}
define i1 @test6(i32 %a) {
; CHECK-LABEL: @test6(
; CHECK: ret i1 false
;
%lhs = add i32 %a, -1
%and = and i32 %lhs, %a
%res = icmp eq i32 %and, 1
ret i1 %res
}
| {
"language": "Assembly"
} |
// RUN: %clang_cc1 -emit-llvm -g %s -o - | FileCheck %s
typedef int v4si __attribute__((__vector_size__(16)));
v4si a;
// Test that we get an array type that's also a vector out of debug.
// CHECK: [ DW_TAG_array_type ] [line 0, size 128, align 128, offset 0] [vector] [from int]
| {
"language": "Assembly"
} |
// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build 386 amd64 amd64p32
// +build !gccgo
#include "textflag.h"
// func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32)
TEXT ·cpuid(SB), NOSPLIT, $0-24
MOVL eaxArg+0(FP), AX
MOVL ecxArg+4(FP), CX
CPUID
MOVL AX, eax+8(FP)
MOVL BX, ebx+12(FP)
MOVL CX, ecx+16(FP)
MOVL DX, edx+20(FP)
RET
// func xgetbv() (eax, edx uint32)
TEXT ·xgetbv(SB),NOSPLIT,$0-8
MOVL $0, CX
XGETBV
MOVL AX, eax+0(FP)
MOVL DX, edx+4(FP)
RET
| {
"language": "Assembly"
} |
/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
/* vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef __avmplus_system_selection__
#define __avmplus_system_selection__
// Standard operating system, CPU, word size, and endianness selection
// for tier-one AVM platforms. This file defines all the AVMSYSTEM_
// names. It would normally be included into a feature definition file.
// operating system
#ifdef UNIX
#define AVMSYSTEM_UNIX 1
#else
#define AVMSYSTEM_UNIX 0
#endif
#ifdef _MAC
#define AVMSYSTEM_MAC 1
#else
#define AVMSYSTEM_MAC 0
#endif
#ifdef WIN32
#define AVMSYSTEM_WIN32 1
#else
#define AVMSYSTEM_WIN32 0
#endif
#ifdef WINDOWS_STORE_APP // For Windows Store Apps both AVMSYSTEM_WIN32 and AVMSYSTEM_WINDOWSSTOREAPP are defined.
#define AVMSYSTEM_WINDOWSSTOREAPP 1
#else
#define AVMSYSTEM_WINDOWSSTOREAPP 0
#endif
#ifdef __SYMBIAN32__ // defined by Symbian S60 tool chain
#define AVMSYSTEM_SYMBIAN 1
#else
#define AVMSYSTEM_SYMBIAN 0
#endif
#ifdef WEBOS
#define AVMSYSTEM_WEBOS 1
#else
#define AVMSYSTEM_WEBOS 0
#endif
// cpu, word size
#undef SIXTYFOURBIT
#if AVMSYSTEM_MAC || AVMSYSTEM_UNIX
#if defined(__i386__) || defined(__i386)
#define AVMSYSTEM_IA32 1
#else
#define AVMSYSTEM_IA32 0
#endif
#if defined(__x86_64__)
#define AVMSYSTEM_AMD64 1
#define SIXTYFOURBIT
#else
#define AVMSYSTEM_AMD64 0
#endif
#if defined(__ppc__) || defined(__powerpc__) || (__ppc64__) || (__powerpc64__)
#define AVMSYSTEM_PPC 1
#if (__ppc64__) || (__powerpc64__)
#define SIXTYFOURBIT
#endif
#else
#define AVMSYSTEM_PPC 0
#endif
#if defined(__arm__) || defined(__ARM__)
#define AVMSYSTEM_ARM 1
#elif defined(__arm64__)
#define SIXTYFOURBIT
#define AVMSYSTEM_ARM 1
#else
#define AVMSYSTEM_ARM 0
#endif
#if defined(__sparc__) || defined(__sparc)
#define AVMSYSTEM_SPARC 1
#else
#define AVMSYSTEM_SPARC 0
#endif
#if defined(__mips__) || defined(__MIPS__)
#define AVMSYSTEM_MIPS 1
#else
#define AVMSYSTEM_MIPS 0
#endif
#if defined(__SH4__)
#define AVMSYSTEM_SH4 1
#else
#define AVMSYSTEM_SH4 0
#endif
#if defined(PEPPER_MAC)
#define AVMTWEAK_PEPPER_MAC 1
#endif
#endif // mac || unix
#if AVMSYSTEM_WIN32
#ifdef _M_X64
#define AVMSYSTEM_AMD64 1
#define SIXTYFOURBIT
#else
#define AVMSYSTEM_AMD64 0
#endif
#if defined(_ARM_)
#define AVMSYSTEM_ARM 1
#else
#define AVMSYSTEM_ARM 0
#endif
#if !AVMSYSTEM_AMD64 && !AVMSYSTEM_ARM
#define AVMSYSTEM_IA32 1
#else
#define AVMSYSTEM_IA32 0
#endif
#define AVMSYSTEM_PPC 0
#define AVMSYSTEM_SPARC 0
#define AVMSYSTEM_SH4 0
#define AVMSYSTEM_MIPS 0
#endif // win32
#if AVMSYSTEM_SYMBIAN
#define AVMSYSTEM_PPC 0
#define AVMSYSTEM_AMD64 0
#define AVMSYSTEM_SPARC 0
#define AVMSYSTEM_MIPS 0
#define AVMSYSTEM_SH4 0
#if defined(__ARMCC__)
#define AVMSYSTEM_ARM 1
#else
#define AVMSYSTEM_ARM 0
#endif
#if !AVMSYSTEM_ARM
#define AVMSYSTEM_IA32 1
#else
#define AVMSYSTEM_IA32 0
#endif
#ifdef __WINSCW__
#define AVMTWEAK_EPOC_EMULATOR 1
#endif
#endif // symbian
#ifdef SIXTYFOURBIT
#define AVMSYSTEM_32BIT 0
#define AVMSYSTEM_64BIT 1
#else
#define AVMSYSTEM_32BIT 1
#define AVMSYSTEM_64BIT 0
#endif
#undef SIXTYFOURBIT
// endianness
#if AVMSYSTEM_IA32 || AVMSYSTEM_AMD64
#define AVMSYSTEM_LITTLE_ENDIAN 1
#define AVMSYSTEM_BIG_ENDIAN 0
#elif AVMSYSTEM_ARM
#if defined _MSC_VER
#define AVMSYSTEM_LITTLE_ENDIAN 1
#define AVMSYSTEM_BIG_ENDIAN 0
#elif defined __GNUC__
#if AVMSYSTEM_MAC && AVMSYSTEM_ARM
#include <machine/endian.h>
#define __BYTE_ORDER BYTE_ORDER
#else
#include <endian.h>
#endif
#if __BYTE_ORDER == LITTLE_ENDIAN
#define AVMSYSTEM_LITTLE_ENDIAN 1
#define AVMSYSTEM_BIG_ENDIAN 0
#if __FLOAT_WORD_ORDER == BIG_ENDIAN
#define AVMSYSTEM_DOUBLE_MSW_FIRST 1
#endif
#else
#define AVMSYSTEM_LITTLE_ENDIAN 0
#define AVMSYSTEM_BIG_ENDIAN 1
#endif
#elif defined __ARMCC__
#define AVMSYSTEM_LITTLE_ENDIAN 1
#define AVMSYSTEM_BIG_ENDIAN 0
#endif
#elif AVMSYSTEM_PPC || AVMSYSTEM_SPARC
#define AVMSYSTEM_LITTLE_ENDIAN 0
#define AVMSYSTEM_BIG_ENDIAN 1
#elif AVMSYSTEM_MIPS || AVMSYSTEM_SH4
#if defined __GNUC__
#include <endian.h>
#if __BYTE_ORDER == LITTLE_ENDIAN
#define AVMSYSTEM_LITTLE_ENDIAN 1
#define AVMSYSTEM_BIG_ENDIAN 0
#else
#define AVMSYSTEM_LITTLE_ENDIAN 0
#define AVMSYSTEM_BIG_ENDIAN 1
#endif
#endif
#else
#error "Error in test to determine endianness"
#endif
// unaligned access
#if AVMSYSTEM_IA32 || AVMSYSTEM_AMD64
#define AVMSYSTEM_UNALIGNED_INT_ACCESS 1
#define AVMSYSTEM_UNALIGNED_FP_ACCESS 1
#elif AVMSYSTEM_ARM
#if AVMSYSTEM_WEBOS
// At the time of this writing (Feb 2010), Palm's webOS deliberately enables software interrupts
// for all unaligned accesses, apparently in the name of promoting "clean code", making unaligned
// accesses vastly slower than aligned (reportedly on the order of 1000x). Unless they change this
// policy (or give us a way to change it selectively) we will consider all webOS builds not to
// support unaligned access, regardless of the processor variant.
#define AVMSYSTEM_UNALIGNED_INT_ACCESS 0
#else
//
// ARM is a little complicated:
//
// ARMv5 (e.g. ARM926): No support for unaligned accesses.
// ARMv6 (e.g. ARM1176): Optional support that must be enabled by the OS.
// ARMv7 (e.g. Cortex-A8): Unaligned access support cannot be disabled; you always have it.
//
// GCC and RealView usually define __ARM_ARCH__,
// otherwise try well-known GCC flags ( see http://gcc.gnu.org/onlinedocs/gcc/ARM-Options.html )
#if __ARM_ARCH__ >= 7 || defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7M__) || \
defined(__ARM_ARCH_7R__) || defined(_ARM_ARCH_7) || defined(UNDER_RT)
#define AVMSYSTEM_UNALIGNED_INT_ACCESS 1
#else
#define AVMSYSTEM_UNALIGNED_INT_ACCESS 0
#endif
#endif
// VFP rules are different from int rules on ARM
#define AVMSYSTEM_UNALIGNED_FP_ACCESS 0
#elif AVMSYSTEM_PPC || AVMSYSTEM_SPARC || AVMSYSTEM_MIPS || AVMSYSTEM_SH4
#define AVMSYSTEM_UNALIGNED_INT_ACCESS 0
#define AVMSYSTEM_UNALIGNED_FP_ACCESS 0
#else
#error "Error in test to determine endianness"
#endif
#ifndef AVMSYSTEM_DOUBLE_MSW_FIRST
#define AVMSYSTEM_DOUBLE_MSW_FIRST 0
#endif
#endif
| {
"language": "Assembly"
} |
/*
* Copyright (C) 2017 Apple Inc. 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 APPLE INC. AND ITS 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 APPLE INC. OR ITS 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.
*/
#if USE(APPLE_INTERNAL_SDK)
#include <sqlite3_private.h>
#else
#define SQLITE_FCNTL_TRUNCATE_DATABASE 101
#define SQLITE_TRUNCATE_DATABASE SQLITE_FCNTL_TRUNCATE_DATABASE
#endif
| {
"language": "Assembly"
} |
# Hitachi H8 testcase 'or.w'
# mach(): h8300h h8300s h8sx
# as(h8300): --defsym sim_cpu=0
# as(h8300h): --defsym sim_cpu=1
# as(h8300s): --defsym sim_cpu=2
# as(h8sx): --defsym sim_cpu=3
# ld(h8300h): -m h8300helf
# ld(h8300s): -m h8300self
# ld(h8sx): -m h8300sxelf
.include "testutils.inc"
start
.if (sim_cpu) ; non-zero means h8300h, s, or sx
or_w_imm16:
set_grs_a5a5 ; Fill all general regs with a fixed pattern
;; fixme set ccr
;; or.w #xx:16,Rd
or.w #0xaaaa, r0 ; Immediate 16-bit operand
;; fixme test ccr ; H=0 N=1 Z=0 V=0 C=0
test_h_gr16 0xafaf r0 ; or result: a5a5 | aaaa
.if (sim_cpu) ; non-zero means h8300h, s, or sx
test_h_gr32 0xa5a5afaf er0 ; or result: a5a5 | aaaa
.endif
test_gr_a5a5 1 ; Make sure other general regs not disturbed
test_gr_a5a5 2
test_gr_a5a5 3
test_gr_a5a5 4
test_gr_a5a5 5
test_gr_a5a5 6
test_gr_a5a5 7
.endif
or_w_reg:
set_grs_a5a5 ; Fill all general regs with a fixed pattern
;; fixme set ccr
;; or.w Rs,Rd
mov.w #0xaaaa, r1
or.w r1, r0 ; Register operand
;; fixme test ccr ; H=0 N=1 Z=0 V=0 C=0
test_h_gr16 0xafaf r0 ; or result: a5a5 | aaaa
test_h_gr16 0xaaaa r1 ; Make sure r1 is unchanged
.if (sim_cpu) ; non-zero means h8300h, s, or sx
test_h_gr32 0xa5a5afaf er0 ; or result: a5a5 | aaaa
test_h_gr32 0xa5a5aaaa er1 ; Make sure er1 is unchanged
.endif
test_gr_a5a5 2 ; Make sure other general regs not disturbed
test_gr_a5a5 3
test_gr_a5a5 4
test_gr_a5a5 5
test_gr_a5a5 6
test_gr_a5a5 7
pass
exit 0
| {
"language": "Assembly"
} |
;
; Ullrich von Bassewitz, 07.08.1998
;
; CC65 runtime: helper stuff for mod/div with signed ints
;
; When negating values, we will ignore the possibility here, that one of the
; values is $8000, in which case the negate will fail.
.export popsargsudiv16
.import negax, popax, udiv16
.importzp tmp1, tmp2, ptr1, ptr4
popsargsudiv16:
stx tmp2 ; Remember sign
cpx #0
bpl L1
jsr negax ; Negate accumulator
L1: sta ptr4
stx ptr4+1 ; Save right operand
jsr popax
stx tmp1 ; Remember sign
cpx #0
bpl L2
jsr negax
L2: sta ptr1
stx ptr1+1
jmp udiv16 ; Call the division
| {
"language": "Assembly"
} |
target datalayout = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64"
target triple = "powerpc64-unknown-linux-gnu"
; RUN: llc < %s | FileCheck %s
define void @test1(i8* %a, ...) nounwind {
entry:
call void @llvm.prefetch(i8* %a, i32 0, i32 3, i32 1)
ret void
}
declare void @llvm.prefetch(i8*, i32, i32, i32)
; CHECK: @test1
; CHECK: dcbt
| {
"language": "Assembly"
} |
px4_add_board(
PLATFORM posix
VENDOR px4
MODEL sitl
ROMFSROOT px4fmu_common
LABEL rtps
EMBEDDED_METADATA parameters
TESTING
DRIVERS
#barometer # all available barometer drivers
#batt_smbus
camera_capture
camera_trigger
#differential_pressure # all available differential pressure drivers
#distance_sensor # all available distance sensor drivers
gps
#imu # all available imu drivers
#magnetometer # all available magnetometer drivers
#protocol_splitter
pwm_out_sim
rpm/rpm_simulator
#telemetry # all available telemetry drivers
tone_alarm
#uavcan
MODULES
airship_att_control
airspeed_selector
attitude_estimator_q
camera_feedback
commander
dataman
ekf2
events
fw_att_control
fw_pos_control_l1
land_detector
landing_target_estimator
#load_mon
local_position_estimator
logger
mavlink
mc_att_control
mc_hover_thrust_estimator
mc_pos_control
mc_rate_control
micrortps_bridge
navigator
rc_update
replay
rover_pos_control
sensors
#sih
simulator
temperature_compensation
uuv_att_control
vmount
vtol_att_control
SYSTEMCMDS
#dumpfile
dyn
esc_calib
led_control
mixer
motor_ramp
motor_test
#mtd
#nshterm
param
perf
pwm
sd_bench
shutdown
system_time
tests # tests and test runner
#top
topic_listener
tune_control
ver
work_queue
EXAMPLES
dyn_hello # dynamically loading modules example
fake_magnetometer
fixedwing_control # Tutorial code from https://px4.io/dev/example_fixedwing_control
hello
#hwtest # Hardware test
#matlab_csv_serial
px4_mavlink_debug # Tutorial code from http://dev.px4.io/en/debug/debug_values.html
px4_simple_app # Tutorial code from http://dev.px4.io/en/apps/hello_sky.html
rover_steering_control # Rover example app
uuv_example_app
work_item
)
set(config_sitl_viewer jmavsim CACHE STRING "viewer for sitl")
set_property(CACHE config_sitl_viewer PROPERTY STRINGS "jmavsim;none")
set(config_sitl_debugger disable CACHE STRING "debugger for sitl")
set_property(CACHE config_sitl_debugger PROPERTY STRINGS "disable;gdb;lldb")
# If the environment variable 'replay' is defined, we are building with replay
# support. In this case, we enable the orb publisher rules.
set(REPLAY_FILE "$ENV{replay}")
if(REPLAY_FILE)
message(STATUS "Building with uorb publisher rules support")
add_definitions(-DORB_USE_PUBLISHER_RULES)
message(STATUS "Building without lockstep for replay")
set(ENABLE_LOCKSTEP_SCHEDULER no)
else()
set(ENABLE_LOCKSTEP_SCHEDULER yes)
endif()
| {
"language": "Assembly"
} |
# /* **************************************************************************
# * *
# * (C) Copyright Paul Mensonides 2002.
# * Distributed under the Boost Software License, Version 1.0. (See
# * accompanying file LICENSE_1_0.txt or copy at
# * http://www.boost.org/LICENSE_1_0.txt)
# * *
# ************************************************************************** */
#
# /* See http://www.boost.org for most recent version. */
#
# if defined(MSGPACK_PP_ITERATION_LIMITS)
# if !defined(MSGPACK_PP_FILENAME_1)
# error MSGPACK_PP_ERROR: depth #1 filename is not defined
# endif
# define MSGPACK_PP_VALUE MSGPACK_PP_TUPLE_ELEM(2, 0, MSGPACK_PP_ITERATION_LIMITS)
# include "../bounds/lower1.hpp"
# define MSGPACK_PP_VALUE MSGPACK_PP_TUPLE_ELEM(2, 1, MSGPACK_PP_ITERATION_LIMITS)
# include "../bounds/upper1.hpp"
# define MSGPACK_PP_ITERATION_FLAGS_1() 0
# undef MSGPACK_PP_ITERATION_LIMITS
# elif defined(MSGPACK_PP_ITERATION_PARAMS_1)
# define MSGPACK_PP_VALUE MSGPACK_PP_ARRAY_ELEM(0, MSGPACK_PP_ITERATION_PARAMS_1)
# include "../bounds/lower1.hpp"
# define MSGPACK_PP_VALUE MSGPACK_PP_ARRAY_ELEM(1, MSGPACK_PP_ITERATION_PARAMS_1)
# include "../bounds/upper1.hpp"
# define MSGPACK_PP_FILENAME_1 MSGPACK_PP_ARRAY_ELEM(2, MSGPACK_PP_ITERATION_PARAMS_1)
# if MSGPACK_PP_ARRAY_SIZE(MSGPACK_PP_ITERATION_PARAMS_1) >= 4
# define MSGPACK_PP_ITERATION_FLAGS_1() MSGPACK_PP_ARRAY_ELEM(3, MSGPACK_PP_ITERATION_PARAMS_1)
# else
# define MSGPACK_PP_ITERATION_FLAGS_1() 0
# endif
# else
# error MSGPACK_PP_ERROR: depth #1 iteration boundaries or filename not defined
# endif
#
# undef MSGPACK_PP_ITERATION_DEPTH
# define MSGPACK_PP_ITERATION_DEPTH() 1
#
# define MSGPACK_PP_IS_ITERATING 1
#
# if (MSGPACK_PP_ITERATION_START_1) > (MSGPACK_PP_ITERATION_FINISH_1)
# include "../iter/reverse1.hpp"
# else
# if MSGPACK_PP_ITERATION_START_1 <= 0 && MSGPACK_PP_ITERATION_FINISH_1 >= 0
# define MSGPACK_PP_ITERATION_1 0
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 1 && MSGPACK_PP_ITERATION_FINISH_1 >= 1
# define MSGPACK_PP_ITERATION_1 1
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 2 && MSGPACK_PP_ITERATION_FINISH_1 >= 2
# define MSGPACK_PP_ITERATION_1 2
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 3 && MSGPACK_PP_ITERATION_FINISH_1 >= 3
# define MSGPACK_PP_ITERATION_1 3
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 4 && MSGPACK_PP_ITERATION_FINISH_1 >= 4
# define MSGPACK_PP_ITERATION_1 4
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 5 && MSGPACK_PP_ITERATION_FINISH_1 >= 5
# define MSGPACK_PP_ITERATION_1 5
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 6 && MSGPACK_PP_ITERATION_FINISH_1 >= 6
# define MSGPACK_PP_ITERATION_1 6
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 7 && MSGPACK_PP_ITERATION_FINISH_1 >= 7
# define MSGPACK_PP_ITERATION_1 7
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 8 && MSGPACK_PP_ITERATION_FINISH_1 >= 8
# define MSGPACK_PP_ITERATION_1 8
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 9 && MSGPACK_PP_ITERATION_FINISH_1 >= 9
# define MSGPACK_PP_ITERATION_1 9
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 10 && MSGPACK_PP_ITERATION_FINISH_1 >= 10
# define MSGPACK_PP_ITERATION_1 10
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 11 && MSGPACK_PP_ITERATION_FINISH_1 >= 11
# define MSGPACK_PP_ITERATION_1 11
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 12 && MSGPACK_PP_ITERATION_FINISH_1 >= 12
# define MSGPACK_PP_ITERATION_1 12
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 13 && MSGPACK_PP_ITERATION_FINISH_1 >= 13
# define MSGPACK_PP_ITERATION_1 13
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 14 && MSGPACK_PP_ITERATION_FINISH_1 >= 14
# define MSGPACK_PP_ITERATION_1 14
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 15 && MSGPACK_PP_ITERATION_FINISH_1 >= 15
# define MSGPACK_PP_ITERATION_1 15
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 16 && MSGPACK_PP_ITERATION_FINISH_1 >= 16
# define MSGPACK_PP_ITERATION_1 16
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 17 && MSGPACK_PP_ITERATION_FINISH_1 >= 17
# define MSGPACK_PP_ITERATION_1 17
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 18 && MSGPACK_PP_ITERATION_FINISH_1 >= 18
# define MSGPACK_PP_ITERATION_1 18
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 19 && MSGPACK_PP_ITERATION_FINISH_1 >= 19
# define MSGPACK_PP_ITERATION_1 19
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 20 && MSGPACK_PP_ITERATION_FINISH_1 >= 20
# define MSGPACK_PP_ITERATION_1 20
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 21 && MSGPACK_PP_ITERATION_FINISH_1 >= 21
# define MSGPACK_PP_ITERATION_1 21
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 22 && MSGPACK_PP_ITERATION_FINISH_1 >= 22
# define MSGPACK_PP_ITERATION_1 22
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 23 && MSGPACK_PP_ITERATION_FINISH_1 >= 23
# define MSGPACK_PP_ITERATION_1 23
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 24 && MSGPACK_PP_ITERATION_FINISH_1 >= 24
# define MSGPACK_PP_ITERATION_1 24
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 25 && MSGPACK_PP_ITERATION_FINISH_1 >= 25
# define MSGPACK_PP_ITERATION_1 25
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 26 && MSGPACK_PP_ITERATION_FINISH_1 >= 26
# define MSGPACK_PP_ITERATION_1 26
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 27 && MSGPACK_PP_ITERATION_FINISH_1 >= 27
# define MSGPACK_PP_ITERATION_1 27
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 28 && MSGPACK_PP_ITERATION_FINISH_1 >= 28
# define MSGPACK_PP_ITERATION_1 28
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 29 && MSGPACK_PP_ITERATION_FINISH_1 >= 29
# define MSGPACK_PP_ITERATION_1 29
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 30 && MSGPACK_PP_ITERATION_FINISH_1 >= 30
# define MSGPACK_PP_ITERATION_1 30
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 31 && MSGPACK_PP_ITERATION_FINISH_1 >= 31
# define MSGPACK_PP_ITERATION_1 31
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 32 && MSGPACK_PP_ITERATION_FINISH_1 >= 32
# define MSGPACK_PP_ITERATION_1 32
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 33 && MSGPACK_PP_ITERATION_FINISH_1 >= 33
# define MSGPACK_PP_ITERATION_1 33
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 34 && MSGPACK_PP_ITERATION_FINISH_1 >= 34
# define MSGPACK_PP_ITERATION_1 34
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 35 && MSGPACK_PP_ITERATION_FINISH_1 >= 35
# define MSGPACK_PP_ITERATION_1 35
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 36 && MSGPACK_PP_ITERATION_FINISH_1 >= 36
# define MSGPACK_PP_ITERATION_1 36
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 37 && MSGPACK_PP_ITERATION_FINISH_1 >= 37
# define MSGPACK_PP_ITERATION_1 37
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 38 && MSGPACK_PP_ITERATION_FINISH_1 >= 38
# define MSGPACK_PP_ITERATION_1 38
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 39 && MSGPACK_PP_ITERATION_FINISH_1 >= 39
# define MSGPACK_PP_ITERATION_1 39
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 40 && MSGPACK_PP_ITERATION_FINISH_1 >= 40
# define MSGPACK_PP_ITERATION_1 40
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 41 && MSGPACK_PP_ITERATION_FINISH_1 >= 41
# define MSGPACK_PP_ITERATION_1 41
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 42 && MSGPACK_PP_ITERATION_FINISH_1 >= 42
# define MSGPACK_PP_ITERATION_1 42
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 43 && MSGPACK_PP_ITERATION_FINISH_1 >= 43
# define MSGPACK_PP_ITERATION_1 43
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 44 && MSGPACK_PP_ITERATION_FINISH_1 >= 44
# define MSGPACK_PP_ITERATION_1 44
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 45 && MSGPACK_PP_ITERATION_FINISH_1 >= 45
# define MSGPACK_PP_ITERATION_1 45
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 46 && MSGPACK_PP_ITERATION_FINISH_1 >= 46
# define MSGPACK_PP_ITERATION_1 46
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 47 && MSGPACK_PP_ITERATION_FINISH_1 >= 47
# define MSGPACK_PP_ITERATION_1 47
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 48 && MSGPACK_PP_ITERATION_FINISH_1 >= 48
# define MSGPACK_PP_ITERATION_1 48
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 49 && MSGPACK_PP_ITERATION_FINISH_1 >= 49
# define MSGPACK_PP_ITERATION_1 49
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 50 && MSGPACK_PP_ITERATION_FINISH_1 >= 50
# define MSGPACK_PP_ITERATION_1 50
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 51 && MSGPACK_PP_ITERATION_FINISH_1 >= 51
# define MSGPACK_PP_ITERATION_1 51
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 52 && MSGPACK_PP_ITERATION_FINISH_1 >= 52
# define MSGPACK_PP_ITERATION_1 52
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 53 && MSGPACK_PP_ITERATION_FINISH_1 >= 53
# define MSGPACK_PP_ITERATION_1 53
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 54 && MSGPACK_PP_ITERATION_FINISH_1 >= 54
# define MSGPACK_PP_ITERATION_1 54
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 55 && MSGPACK_PP_ITERATION_FINISH_1 >= 55
# define MSGPACK_PP_ITERATION_1 55
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 56 && MSGPACK_PP_ITERATION_FINISH_1 >= 56
# define MSGPACK_PP_ITERATION_1 56
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 57 && MSGPACK_PP_ITERATION_FINISH_1 >= 57
# define MSGPACK_PP_ITERATION_1 57
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 58 && MSGPACK_PP_ITERATION_FINISH_1 >= 58
# define MSGPACK_PP_ITERATION_1 58
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 59 && MSGPACK_PP_ITERATION_FINISH_1 >= 59
# define MSGPACK_PP_ITERATION_1 59
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 60 && MSGPACK_PP_ITERATION_FINISH_1 >= 60
# define MSGPACK_PP_ITERATION_1 60
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 61 && MSGPACK_PP_ITERATION_FINISH_1 >= 61
# define MSGPACK_PP_ITERATION_1 61
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 62 && MSGPACK_PP_ITERATION_FINISH_1 >= 62
# define MSGPACK_PP_ITERATION_1 62
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 63 && MSGPACK_PP_ITERATION_FINISH_1 >= 63
# define MSGPACK_PP_ITERATION_1 63
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 64 && MSGPACK_PP_ITERATION_FINISH_1 >= 64
# define MSGPACK_PP_ITERATION_1 64
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 65 && MSGPACK_PP_ITERATION_FINISH_1 >= 65
# define MSGPACK_PP_ITERATION_1 65
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 66 && MSGPACK_PP_ITERATION_FINISH_1 >= 66
# define MSGPACK_PP_ITERATION_1 66
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 67 && MSGPACK_PP_ITERATION_FINISH_1 >= 67
# define MSGPACK_PP_ITERATION_1 67
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 68 && MSGPACK_PP_ITERATION_FINISH_1 >= 68
# define MSGPACK_PP_ITERATION_1 68
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 69 && MSGPACK_PP_ITERATION_FINISH_1 >= 69
# define MSGPACK_PP_ITERATION_1 69
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 70 && MSGPACK_PP_ITERATION_FINISH_1 >= 70
# define MSGPACK_PP_ITERATION_1 70
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 71 && MSGPACK_PP_ITERATION_FINISH_1 >= 71
# define MSGPACK_PP_ITERATION_1 71
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 72 && MSGPACK_PP_ITERATION_FINISH_1 >= 72
# define MSGPACK_PP_ITERATION_1 72
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 73 && MSGPACK_PP_ITERATION_FINISH_1 >= 73
# define MSGPACK_PP_ITERATION_1 73
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 74 && MSGPACK_PP_ITERATION_FINISH_1 >= 74
# define MSGPACK_PP_ITERATION_1 74
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 75 && MSGPACK_PP_ITERATION_FINISH_1 >= 75
# define MSGPACK_PP_ITERATION_1 75
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 76 && MSGPACK_PP_ITERATION_FINISH_1 >= 76
# define MSGPACK_PP_ITERATION_1 76
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 77 && MSGPACK_PP_ITERATION_FINISH_1 >= 77
# define MSGPACK_PP_ITERATION_1 77
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 78 && MSGPACK_PP_ITERATION_FINISH_1 >= 78
# define MSGPACK_PP_ITERATION_1 78
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 79 && MSGPACK_PP_ITERATION_FINISH_1 >= 79
# define MSGPACK_PP_ITERATION_1 79
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 80 && MSGPACK_PP_ITERATION_FINISH_1 >= 80
# define MSGPACK_PP_ITERATION_1 80
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 81 && MSGPACK_PP_ITERATION_FINISH_1 >= 81
# define MSGPACK_PP_ITERATION_1 81
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 82 && MSGPACK_PP_ITERATION_FINISH_1 >= 82
# define MSGPACK_PP_ITERATION_1 82
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 83 && MSGPACK_PP_ITERATION_FINISH_1 >= 83
# define MSGPACK_PP_ITERATION_1 83
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 84 && MSGPACK_PP_ITERATION_FINISH_1 >= 84
# define MSGPACK_PP_ITERATION_1 84
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 85 && MSGPACK_PP_ITERATION_FINISH_1 >= 85
# define MSGPACK_PP_ITERATION_1 85
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 86 && MSGPACK_PP_ITERATION_FINISH_1 >= 86
# define MSGPACK_PP_ITERATION_1 86
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 87 && MSGPACK_PP_ITERATION_FINISH_1 >= 87
# define MSGPACK_PP_ITERATION_1 87
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 88 && MSGPACK_PP_ITERATION_FINISH_1 >= 88
# define MSGPACK_PP_ITERATION_1 88
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 89 && MSGPACK_PP_ITERATION_FINISH_1 >= 89
# define MSGPACK_PP_ITERATION_1 89
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 90 && MSGPACK_PP_ITERATION_FINISH_1 >= 90
# define MSGPACK_PP_ITERATION_1 90
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 91 && MSGPACK_PP_ITERATION_FINISH_1 >= 91
# define MSGPACK_PP_ITERATION_1 91
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 92 && MSGPACK_PP_ITERATION_FINISH_1 >= 92
# define MSGPACK_PP_ITERATION_1 92
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 93 && MSGPACK_PP_ITERATION_FINISH_1 >= 93
# define MSGPACK_PP_ITERATION_1 93
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 94 && MSGPACK_PP_ITERATION_FINISH_1 >= 94
# define MSGPACK_PP_ITERATION_1 94
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 95 && MSGPACK_PP_ITERATION_FINISH_1 >= 95
# define MSGPACK_PP_ITERATION_1 95
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 96 && MSGPACK_PP_ITERATION_FINISH_1 >= 96
# define MSGPACK_PP_ITERATION_1 96
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 97 && MSGPACK_PP_ITERATION_FINISH_1 >= 97
# define MSGPACK_PP_ITERATION_1 97
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 98 && MSGPACK_PP_ITERATION_FINISH_1 >= 98
# define MSGPACK_PP_ITERATION_1 98
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 99 && MSGPACK_PP_ITERATION_FINISH_1 >= 99
# define MSGPACK_PP_ITERATION_1 99
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 100 && MSGPACK_PP_ITERATION_FINISH_1 >= 100
# define MSGPACK_PP_ITERATION_1 100
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 101 && MSGPACK_PP_ITERATION_FINISH_1 >= 101
# define MSGPACK_PP_ITERATION_1 101
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 102 && MSGPACK_PP_ITERATION_FINISH_1 >= 102
# define MSGPACK_PP_ITERATION_1 102
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 103 && MSGPACK_PP_ITERATION_FINISH_1 >= 103
# define MSGPACK_PP_ITERATION_1 103
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 104 && MSGPACK_PP_ITERATION_FINISH_1 >= 104
# define MSGPACK_PP_ITERATION_1 104
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 105 && MSGPACK_PP_ITERATION_FINISH_1 >= 105
# define MSGPACK_PP_ITERATION_1 105
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 106 && MSGPACK_PP_ITERATION_FINISH_1 >= 106
# define MSGPACK_PP_ITERATION_1 106
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 107 && MSGPACK_PP_ITERATION_FINISH_1 >= 107
# define MSGPACK_PP_ITERATION_1 107
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 108 && MSGPACK_PP_ITERATION_FINISH_1 >= 108
# define MSGPACK_PP_ITERATION_1 108
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 109 && MSGPACK_PP_ITERATION_FINISH_1 >= 109
# define MSGPACK_PP_ITERATION_1 109
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 110 && MSGPACK_PP_ITERATION_FINISH_1 >= 110
# define MSGPACK_PP_ITERATION_1 110
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 111 && MSGPACK_PP_ITERATION_FINISH_1 >= 111
# define MSGPACK_PP_ITERATION_1 111
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 112 && MSGPACK_PP_ITERATION_FINISH_1 >= 112
# define MSGPACK_PP_ITERATION_1 112
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 113 && MSGPACK_PP_ITERATION_FINISH_1 >= 113
# define MSGPACK_PP_ITERATION_1 113
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 114 && MSGPACK_PP_ITERATION_FINISH_1 >= 114
# define MSGPACK_PP_ITERATION_1 114
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 115 && MSGPACK_PP_ITERATION_FINISH_1 >= 115
# define MSGPACK_PP_ITERATION_1 115
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 116 && MSGPACK_PP_ITERATION_FINISH_1 >= 116
# define MSGPACK_PP_ITERATION_1 116
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 117 && MSGPACK_PP_ITERATION_FINISH_1 >= 117
# define MSGPACK_PP_ITERATION_1 117
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 118 && MSGPACK_PP_ITERATION_FINISH_1 >= 118
# define MSGPACK_PP_ITERATION_1 118
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 119 && MSGPACK_PP_ITERATION_FINISH_1 >= 119
# define MSGPACK_PP_ITERATION_1 119
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 120 && MSGPACK_PP_ITERATION_FINISH_1 >= 120
# define MSGPACK_PP_ITERATION_1 120
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 121 && MSGPACK_PP_ITERATION_FINISH_1 >= 121
# define MSGPACK_PP_ITERATION_1 121
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 122 && MSGPACK_PP_ITERATION_FINISH_1 >= 122
# define MSGPACK_PP_ITERATION_1 122
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 123 && MSGPACK_PP_ITERATION_FINISH_1 >= 123
# define MSGPACK_PP_ITERATION_1 123
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 124 && MSGPACK_PP_ITERATION_FINISH_1 >= 124
# define MSGPACK_PP_ITERATION_1 124
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 125 && MSGPACK_PP_ITERATION_FINISH_1 >= 125
# define MSGPACK_PP_ITERATION_1 125
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 126 && MSGPACK_PP_ITERATION_FINISH_1 >= 126
# define MSGPACK_PP_ITERATION_1 126
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 127 && MSGPACK_PP_ITERATION_FINISH_1 >= 127
# define MSGPACK_PP_ITERATION_1 127
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 128 && MSGPACK_PP_ITERATION_FINISH_1 >= 128
# define MSGPACK_PP_ITERATION_1 128
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 129 && MSGPACK_PP_ITERATION_FINISH_1 >= 129
# define MSGPACK_PP_ITERATION_1 129
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 130 && MSGPACK_PP_ITERATION_FINISH_1 >= 130
# define MSGPACK_PP_ITERATION_1 130
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 131 && MSGPACK_PP_ITERATION_FINISH_1 >= 131
# define MSGPACK_PP_ITERATION_1 131
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 132 && MSGPACK_PP_ITERATION_FINISH_1 >= 132
# define MSGPACK_PP_ITERATION_1 132
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 133 && MSGPACK_PP_ITERATION_FINISH_1 >= 133
# define MSGPACK_PP_ITERATION_1 133
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 134 && MSGPACK_PP_ITERATION_FINISH_1 >= 134
# define MSGPACK_PP_ITERATION_1 134
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 135 && MSGPACK_PP_ITERATION_FINISH_1 >= 135
# define MSGPACK_PP_ITERATION_1 135
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 136 && MSGPACK_PP_ITERATION_FINISH_1 >= 136
# define MSGPACK_PP_ITERATION_1 136
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 137 && MSGPACK_PP_ITERATION_FINISH_1 >= 137
# define MSGPACK_PP_ITERATION_1 137
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 138 && MSGPACK_PP_ITERATION_FINISH_1 >= 138
# define MSGPACK_PP_ITERATION_1 138
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 139 && MSGPACK_PP_ITERATION_FINISH_1 >= 139
# define MSGPACK_PP_ITERATION_1 139
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 140 && MSGPACK_PP_ITERATION_FINISH_1 >= 140
# define MSGPACK_PP_ITERATION_1 140
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 141 && MSGPACK_PP_ITERATION_FINISH_1 >= 141
# define MSGPACK_PP_ITERATION_1 141
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 142 && MSGPACK_PP_ITERATION_FINISH_1 >= 142
# define MSGPACK_PP_ITERATION_1 142
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 143 && MSGPACK_PP_ITERATION_FINISH_1 >= 143
# define MSGPACK_PP_ITERATION_1 143
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 144 && MSGPACK_PP_ITERATION_FINISH_1 >= 144
# define MSGPACK_PP_ITERATION_1 144
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 145 && MSGPACK_PP_ITERATION_FINISH_1 >= 145
# define MSGPACK_PP_ITERATION_1 145
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 146 && MSGPACK_PP_ITERATION_FINISH_1 >= 146
# define MSGPACK_PP_ITERATION_1 146
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 147 && MSGPACK_PP_ITERATION_FINISH_1 >= 147
# define MSGPACK_PP_ITERATION_1 147
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 148 && MSGPACK_PP_ITERATION_FINISH_1 >= 148
# define MSGPACK_PP_ITERATION_1 148
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 149 && MSGPACK_PP_ITERATION_FINISH_1 >= 149
# define MSGPACK_PP_ITERATION_1 149
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 150 && MSGPACK_PP_ITERATION_FINISH_1 >= 150
# define MSGPACK_PP_ITERATION_1 150
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 151 && MSGPACK_PP_ITERATION_FINISH_1 >= 151
# define MSGPACK_PP_ITERATION_1 151
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 152 && MSGPACK_PP_ITERATION_FINISH_1 >= 152
# define MSGPACK_PP_ITERATION_1 152
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 153 && MSGPACK_PP_ITERATION_FINISH_1 >= 153
# define MSGPACK_PP_ITERATION_1 153
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 154 && MSGPACK_PP_ITERATION_FINISH_1 >= 154
# define MSGPACK_PP_ITERATION_1 154
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 155 && MSGPACK_PP_ITERATION_FINISH_1 >= 155
# define MSGPACK_PP_ITERATION_1 155
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 156 && MSGPACK_PP_ITERATION_FINISH_1 >= 156
# define MSGPACK_PP_ITERATION_1 156
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 157 && MSGPACK_PP_ITERATION_FINISH_1 >= 157
# define MSGPACK_PP_ITERATION_1 157
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 158 && MSGPACK_PP_ITERATION_FINISH_1 >= 158
# define MSGPACK_PP_ITERATION_1 158
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 159 && MSGPACK_PP_ITERATION_FINISH_1 >= 159
# define MSGPACK_PP_ITERATION_1 159
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 160 && MSGPACK_PP_ITERATION_FINISH_1 >= 160
# define MSGPACK_PP_ITERATION_1 160
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 161 && MSGPACK_PP_ITERATION_FINISH_1 >= 161
# define MSGPACK_PP_ITERATION_1 161
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 162 && MSGPACK_PP_ITERATION_FINISH_1 >= 162
# define MSGPACK_PP_ITERATION_1 162
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 163 && MSGPACK_PP_ITERATION_FINISH_1 >= 163
# define MSGPACK_PP_ITERATION_1 163
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 164 && MSGPACK_PP_ITERATION_FINISH_1 >= 164
# define MSGPACK_PP_ITERATION_1 164
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 165 && MSGPACK_PP_ITERATION_FINISH_1 >= 165
# define MSGPACK_PP_ITERATION_1 165
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 166 && MSGPACK_PP_ITERATION_FINISH_1 >= 166
# define MSGPACK_PP_ITERATION_1 166
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 167 && MSGPACK_PP_ITERATION_FINISH_1 >= 167
# define MSGPACK_PP_ITERATION_1 167
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 168 && MSGPACK_PP_ITERATION_FINISH_1 >= 168
# define MSGPACK_PP_ITERATION_1 168
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 169 && MSGPACK_PP_ITERATION_FINISH_1 >= 169
# define MSGPACK_PP_ITERATION_1 169
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 170 && MSGPACK_PP_ITERATION_FINISH_1 >= 170
# define MSGPACK_PP_ITERATION_1 170
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 171 && MSGPACK_PP_ITERATION_FINISH_1 >= 171
# define MSGPACK_PP_ITERATION_1 171
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 172 && MSGPACK_PP_ITERATION_FINISH_1 >= 172
# define MSGPACK_PP_ITERATION_1 172
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 173 && MSGPACK_PP_ITERATION_FINISH_1 >= 173
# define MSGPACK_PP_ITERATION_1 173
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 174 && MSGPACK_PP_ITERATION_FINISH_1 >= 174
# define MSGPACK_PP_ITERATION_1 174
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 175 && MSGPACK_PP_ITERATION_FINISH_1 >= 175
# define MSGPACK_PP_ITERATION_1 175
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 176 && MSGPACK_PP_ITERATION_FINISH_1 >= 176
# define MSGPACK_PP_ITERATION_1 176
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 177 && MSGPACK_PP_ITERATION_FINISH_1 >= 177
# define MSGPACK_PP_ITERATION_1 177
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 178 && MSGPACK_PP_ITERATION_FINISH_1 >= 178
# define MSGPACK_PP_ITERATION_1 178
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 179 && MSGPACK_PP_ITERATION_FINISH_1 >= 179
# define MSGPACK_PP_ITERATION_1 179
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 180 && MSGPACK_PP_ITERATION_FINISH_1 >= 180
# define MSGPACK_PP_ITERATION_1 180
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 181 && MSGPACK_PP_ITERATION_FINISH_1 >= 181
# define MSGPACK_PP_ITERATION_1 181
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 182 && MSGPACK_PP_ITERATION_FINISH_1 >= 182
# define MSGPACK_PP_ITERATION_1 182
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 183 && MSGPACK_PP_ITERATION_FINISH_1 >= 183
# define MSGPACK_PP_ITERATION_1 183
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 184 && MSGPACK_PP_ITERATION_FINISH_1 >= 184
# define MSGPACK_PP_ITERATION_1 184
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 185 && MSGPACK_PP_ITERATION_FINISH_1 >= 185
# define MSGPACK_PP_ITERATION_1 185
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 186 && MSGPACK_PP_ITERATION_FINISH_1 >= 186
# define MSGPACK_PP_ITERATION_1 186
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 187 && MSGPACK_PP_ITERATION_FINISH_1 >= 187
# define MSGPACK_PP_ITERATION_1 187
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 188 && MSGPACK_PP_ITERATION_FINISH_1 >= 188
# define MSGPACK_PP_ITERATION_1 188
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 189 && MSGPACK_PP_ITERATION_FINISH_1 >= 189
# define MSGPACK_PP_ITERATION_1 189
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 190 && MSGPACK_PP_ITERATION_FINISH_1 >= 190
# define MSGPACK_PP_ITERATION_1 190
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 191 && MSGPACK_PP_ITERATION_FINISH_1 >= 191
# define MSGPACK_PP_ITERATION_1 191
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 192 && MSGPACK_PP_ITERATION_FINISH_1 >= 192
# define MSGPACK_PP_ITERATION_1 192
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 193 && MSGPACK_PP_ITERATION_FINISH_1 >= 193
# define MSGPACK_PP_ITERATION_1 193
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 194 && MSGPACK_PP_ITERATION_FINISH_1 >= 194
# define MSGPACK_PP_ITERATION_1 194
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 195 && MSGPACK_PP_ITERATION_FINISH_1 >= 195
# define MSGPACK_PP_ITERATION_1 195
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 196 && MSGPACK_PP_ITERATION_FINISH_1 >= 196
# define MSGPACK_PP_ITERATION_1 196
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 197 && MSGPACK_PP_ITERATION_FINISH_1 >= 197
# define MSGPACK_PP_ITERATION_1 197
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 198 && MSGPACK_PP_ITERATION_FINISH_1 >= 198
# define MSGPACK_PP_ITERATION_1 198
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 199 && MSGPACK_PP_ITERATION_FINISH_1 >= 199
# define MSGPACK_PP_ITERATION_1 199
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 200 && MSGPACK_PP_ITERATION_FINISH_1 >= 200
# define MSGPACK_PP_ITERATION_1 200
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 201 && MSGPACK_PP_ITERATION_FINISH_1 >= 201
# define MSGPACK_PP_ITERATION_1 201
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 202 && MSGPACK_PP_ITERATION_FINISH_1 >= 202
# define MSGPACK_PP_ITERATION_1 202
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 203 && MSGPACK_PP_ITERATION_FINISH_1 >= 203
# define MSGPACK_PP_ITERATION_1 203
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 204 && MSGPACK_PP_ITERATION_FINISH_1 >= 204
# define MSGPACK_PP_ITERATION_1 204
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 205 && MSGPACK_PP_ITERATION_FINISH_1 >= 205
# define MSGPACK_PP_ITERATION_1 205
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 206 && MSGPACK_PP_ITERATION_FINISH_1 >= 206
# define MSGPACK_PP_ITERATION_1 206
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 207 && MSGPACK_PP_ITERATION_FINISH_1 >= 207
# define MSGPACK_PP_ITERATION_1 207
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 208 && MSGPACK_PP_ITERATION_FINISH_1 >= 208
# define MSGPACK_PP_ITERATION_1 208
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 209 && MSGPACK_PP_ITERATION_FINISH_1 >= 209
# define MSGPACK_PP_ITERATION_1 209
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 210 && MSGPACK_PP_ITERATION_FINISH_1 >= 210
# define MSGPACK_PP_ITERATION_1 210
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 211 && MSGPACK_PP_ITERATION_FINISH_1 >= 211
# define MSGPACK_PP_ITERATION_1 211
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 212 && MSGPACK_PP_ITERATION_FINISH_1 >= 212
# define MSGPACK_PP_ITERATION_1 212
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 213 && MSGPACK_PP_ITERATION_FINISH_1 >= 213
# define MSGPACK_PP_ITERATION_1 213
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 214 && MSGPACK_PP_ITERATION_FINISH_1 >= 214
# define MSGPACK_PP_ITERATION_1 214
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 215 && MSGPACK_PP_ITERATION_FINISH_1 >= 215
# define MSGPACK_PP_ITERATION_1 215
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 216 && MSGPACK_PP_ITERATION_FINISH_1 >= 216
# define MSGPACK_PP_ITERATION_1 216
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 217 && MSGPACK_PP_ITERATION_FINISH_1 >= 217
# define MSGPACK_PP_ITERATION_1 217
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 218 && MSGPACK_PP_ITERATION_FINISH_1 >= 218
# define MSGPACK_PP_ITERATION_1 218
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 219 && MSGPACK_PP_ITERATION_FINISH_1 >= 219
# define MSGPACK_PP_ITERATION_1 219
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 220 && MSGPACK_PP_ITERATION_FINISH_1 >= 220
# define MSGPACK_PP_ITERATION_1 220
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 221 && MSGPACK_PP_ITERATION_FINISH_1 >= 221
# define MSGPACK_PP_ITERATION_1 221
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 222 && MSGPACK_PP_ITERATION_FINISH_1 >= 222
# define MSGPACK_PP_ITERATION_1 222
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 223 && MSGPACK_PP_ITERATION_FINISH_1 >= 223
# define MSGPACK_PP_ITERATION_1 223
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 224 && MSGPACK_PP_ITERATION_FINISH_1 >= 224
# define MSGPACK_PP_ITERATION_1 224
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 225 && MSGPACK_PP_ITERATION_FINISH_1 >= 225
# define MSGPACK_PP_ITERATION_1 225
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 226 && MSGPACK_PP_ITERATION_FINISH_1 >= 226
# define MSGPACK_PP_ITERATION_1 226
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 227 && MSGPACK_PP_ITERATION_FINISH_1 >= 227
# define MSGPACK_PP_ITERATION_1 227
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 228 && MSGPACK_PP_ITERATION_FINISH_1 >= 228
# define MSGPACK_PP_ITERATION_1 228
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 229 && MSGPACK_PP_ITERATION_FINISH_1 >= 229
# define MSGPACK_PP_ITERATION_1 229
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 230 && MSGPACK_PP_ITERATION_FINISH_1 >= 230
# define MSGPACK_PP_ITERATION_1 230
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 231 && MSGPACK_PP_ITERATION_FINISH_1 >= 231
# define MSGPACK_PP_ITERATION_1 231
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 232 && MSGPACK_PP_ITERATION_FINISH_1 >= 232
# define MSGPACK_PP_ITERATION_1 232
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 233 && MSGPACK_PP_ITERATION_FINISH_1 >= 233
# define MSGPACK_PP_ITERATION_1 233
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 234 && MSGPACK_PP_ITERATION_FINISH_1 >= 234
# define MSGPACK_PP_ITERATION_1 234
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 235 && MSGPACK_PP_ITERATION_FINISH_1 >= 235
# define MSGPACK_PP_ITERATION_1 235
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 236 && MSGPACK_PP_ITERATION_FINISH_1 >= 236
# define MSGPACK_PP_ITERATION_1 236
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 237 && MSGPACK_PP_ITERATION_FINISH_1 >= 237
# define MSGPACK_PP_ITERATION_1 237
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 238 && MSGPACK_PP_ITERATION_FINISH_1 >= 238
# define MSGPACK_PP_ITERATION_1 238
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 239 && MSGPACK_PP_ITERATION_FINISH_1 >= 239
# define MSGPACK_PP_ITERATION_1 239
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 240 && MSGPACK_PP_ITERATION_FINISH_1 >= 240
# define MSGPACK_PP_ITERATION_1 240
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 241 && MSGPACK_PP_ITERATION_FINISH_1 >= 241
# define MSGPACK_PP_ITERATION_1 241
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 242 && MSGPACK_PP_ITERATION_FINISH_1 >= 242
# define MSGPACK_PP_ITERATION_1 242
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 243 && MSGPACK_PP_ITERATION_FINISH_1 >= 243
# define MSGPACK_PP_ITERATION_1 243
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 244 && MSGPACK_PP_ITERATION_FINISH_1 >= 244
# define MSGPACK_PP_ITERATION_1 244
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 245 && MSGPACK_PP_ITERATION_FINISH_1 >= 245
# define MSGPACK_PP_ITERATION_1 245
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 246 && MSGPACK_PP_ITERATION_FINISH_1 >= 246
# define MSGPACK_PP_ITERATION_1 246
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 247 && MSGPACK_PP_ITERATION_FINISH_1 >= 247
# define MSGPACK_PP_ITERATION_1 247
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 248 && MSGPACK_PP_ITERATION_FINISH_1 >= 248
# define MSGPACK_PP_ITERATION_1 248
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 249 && MSGPACK_PP_ITERATION_FINISH_1 >= 249
# define MSGPACK_PP_ITERATION_1 249
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 250 && MSGPACK_PP_ITERATION_FINISH_1 >= 250
# define MSGPACK_PP_ITERATION_1 250
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 251 && MSGPACK_PP_ITERATION_FINISH_1 >= 251
# define MSGPACK_PP_ITERATION_1 251
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 252 && MSGPACK_PP_ITERATION_FINISH_1 >= 252
# define MSGPACK_PP_ITERATION_1 252
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 253 && MSGPACK_PP_ITERATION_FINISH_1 >= 253
# define MSGPACK_PP_ITERATION_1 253
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 254 && MSGPACK_PP_ITERATION_FINISH_1 >= 254
# define MSGPACK_PP_ITERATION_1 254
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 255 && MSGPACK_PP_ITERATION_FINISH_1 >= 255
# define MSGPACK_PP_ITERATION_1 255
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# if MSGPACK_PP_ITERATION_START_1 <= 256 && MSGPACK_PP_ITERATION_FINISH_1 >= 256
# define MSGPACK_PP_ITERATION_1 256
# include MSGPACK_PP_FILENAME_1
# undef MSGPACK_PP_ITERATION_1
# endif
# endif
#
# undef MSGPACK_PP_IS_ITERATING
#
# undef MSGPACK_PP_ITERATION_DEPTH
# define MSGPACK_PP_ITERATION_DEPTH() 0
#
# undef MSGPACK_PP_ITERATION_START_1
# undef MSGPACK_PP_ITERATION_FINISH_1
# undef MSGPACK_PP_FILENAME_1
#
# undef MSGPACK_PP_ITERATION_FLAGS_1
# undef MSGPACK_PP_ITERATION_PARAMS_1
| {
"language": "Assembly"
} |
/* -----------------------------------------------------------------------
sysv.S - Copyright (c) 1998, 2008, 2011 Red Hat, Inc.
Copyright (c) 2011 Plausible Labs Cooperative, Inc.
ARM Foreign Function Interface
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
``Software''), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
----------------------------------------------------------------------- */
#define LIBFFI_ASM
#include <fficonfig.h>
#include <ffi.h>
#ifdef HAVE_MACHINE_ASM_H
#include <machine/asm.h>
#else
#ifdef __USER_LABEL_PREFIX__
#define CONCAT1(a, b) CONCAT2(a, b)
#define CONCAT2(a, b) a ## b
/* Use the right prefix for global labels. */
#define CNAME(x) CONCAT1 (__USER_LABEL_PREFIX__, x)
#else
#define CNAME(x) x
#endif
#ifdef __APPLE__
#define ENTRY(x) .globl _##x; _##x:
#else
#define ENTRY(x) .globl CNAME(x); .type CNAME(x),%function; CNAME(x):
#endif /* __APPLE__ */
#endif
#ifdef __ELF__
#define LSYM(x) .x
#else
#define LSYM(x) x
#endif
/* Use the SOFTFP return value ABI on Mac OS X, as per the iOS ABI
Function Call Guide */
#ifdef __APPLE__
#define __SOFTFP__
#endif
/* We need a better way of testing for this, but for now, this is all
we can do. */
@ This selects the minimum architecture level required.
#define __ARM_ARCH__ 3
#if defined(__ARM_ARCH_4__) || defined(__ARM_ARCH_4T__)
# undef __ARM_ARCH__
# define __ARM_ARCH__ 4
#endif
#if defined(__ARM_ARCH_5__) || defined(__ARM_ARCH_5T__) \
|| defined(__ARM_ARCH_5E__) || defined(__ARM_ARCH_5TE__) \
|| defined(__ARM_ARCH_5TEJ__)
# undef __ARM_ARCH__
# define __ARM_ARCH__ 5
#endif
#if defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) \
|| defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) \
|| defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) \
|| defined(__ARM_ARCH_6M__)
# undef __ARM_ARCH__
# define __ARM_ARCH__ 6
#endif
#if defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) \
|| defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) \
|| defined(__ARM_ARCH_7EM__)
# undef __ARM_ARCH__
# define __ARM_ARCH__ 7
#endif
#if __ARM_ARCH__ >= 5
# define call_reg(x) blx x
#elif defined (__ARM_ARCH_4T__)
# define call_reg(x) mov lr, pc ; bx x
# if defined(__thumb__) || defined(__THUMB_INTERWORK__)
# define __INTERWORKING__
# endif
#else
# define call_reg(x) mov lr, pc ; mov pc, x
#endif
/* Conditionally compile unwinder directives. */
#ifdef __ARM_EABI__
#define UNWIND
#else
#define UNWIND @
#endif
.syntax unified
#if defined(__thumb__) && !defined(__THUMB_INTERWORK__)
#define ARM_FUNC_START(name) \
.text; \
.align 2; \
.thumb; \
.thumb_func; \
ENTRY(name); \
bx pc; \
nop; \
.arm; \
UNWIND .fnstart; \
_L__##name:
#else
#define ARM_FUNC_START(name) \
.text; \
.align 2; \
.arm; \
ENTRY(name); \
UNWIND .fnstart
#endif
.macro RETLDM regs=, cond=, dirn=ia
#if defined (__INTERWORKING__)
.ifc "\regs",""
ldr\cond lr, [sp], #4
.else
ldm\cond\dirn sp!, {\regs, lr}
.endif
bx\cond lr
#else
.ifc "\regs",""
ldr\cond pc, [sp], #4
.else
ldm\cond\dirn sp!, {\regs, pc}
.endif
#endif
.endm
@ r0: ffi_prep_args
@ r1: &ecif
@ r2: cif->bytes
@ r3: fig->flags
@ sp+0: ecif.rvalue
@ This assumes we are using gas.
ARM_FUNC_START(ffi_call_SYSV)
@ Save registers
stmfd sp!, {r0-r3, fp, lr}
UNWIND .save {r0-r3, fp, lr}
mov fp, sp
UNWIND .setfp fp, sp
@ Make room for all of the new args.
sub sp, fp, r2
@ Place all of the ffi_prep_args in position
mov r0, sp
@ r1 already set
@ Call ffi_prep_args(stack, &ecif)
bl CNAME(ffi_prep_args_SYSV)
@ move first 4 parameters in registers
ldmia sp, {r0-r3}
@ and adjust stack
sub lr, fp, sp @ cif->bytes == fp - sp
ldr ip, [fp] @ load fn() in advance
cmp lr, #16
movhs lr, #16
add sp, sp, lr
@ call (fn) (...)
call_reg(ip)
@ Remove the space we pushed for the args
mov sp, fp
@ Load r2 with the pointer to storage for the return value
ldr r2, [sp, #24]
@ Load r3 with the return type code
ldr r3, [sp, #12]
@ If the return value pointer is NULL, assume no return value.
cmp r2, #0
beq LSYM(Lepilogue)
@ return INT
cmp r3, #FFI_TYPE_INT
#if defined(__SOFTFP__) || defined(__ARM_EABI__)
cmpne r3, #FFI_TYPE_FLOAT
#endif
streq r0, [r2]
beq LSYM(Lepilogue)
@ return INT64
cmp r3, #FFI_TYPE_SINT64
#if defined(__SOFTFP__) || defined(__ARM_EABI__)
cmpne r3, #FFI_TYPE_DOUBLE
#endif
stmiaeq r2, {r0, r1}
#if !defined(__SOFTFP__) && !defined(__ARM_EABI__)
beq LSYM(Lepilogue)
@ return FLOAT
cmp r3, #FFI_TYPE_FLOAT
stfeqs f0, [r2]
beq LSYM(Lepilogue)
@ return DOUBLE or LONGDOUBLE
cmp r3, #FFI_TYPE_DOUBLE
stfeqd f0, [r2]
#endif
LSYM(Lepilogue):
#if defined (__INTERWORKING__)
ldmia sp!, {r0-r3,fp, lr}
bx lr
#else
ldmia sp!, {r0-r3,fp, pc}
#endif
.ffi_call_SYSV_end:
UNWIND .fnend
#ifdef __ELF__
.size CNAME(ffi_call_SYSV),.ffi_call_SYSV_end-CNAME(ffi_call_SYSV)
#endif
/*
unsigned int FFI_HIDDEN
ffi_closure_inner (closure, respp, args)
ffi_closure *closure;
void **respp;
void *args;
*/
ARM_FUNC_START(ffi_closure_SYSV)
UNWIND .pad #16
add ip, sp, #16
stmfd sp!, {ip, lr}
UNWIND .save {r0, lr}
add r2, sp, #8
UNWIND .pad #16
sub sp, sp, #16
str sp, [sp, #8]
add r1, sp, #8
bl CNAME(ffi_closure_inner)
cmp r0, #FFI_TYPE_INT
beq .Lretint
cmp r0, #FFI_TYPE_FLOAT
#if defined(__SOFTFP__) || defined(__ARM_EABI__)
beq .Lretint
#else
beq .Lretfloat
#endif
cmp r0, #FFI_TYPE_DOUBLE
#if defined(__SOFTFP__) || defined(__ARM_EABI__)
beq .Lretlonglong
#else
beq .Lretdouble
#endif
cmp r0, #FFI_TYPE_LONGDOUBLE
#if defined(__SOFTFP__) || defined(__ARM_EABI__)
beq .Lretlonglong
#else
beq .Lretlongdouble
#endif
cmp r0, #FFI_TYPE_SINT64
beq .Lretlonglong
.Lclosure_epilogue:
add sp, sp, #16
ldmfd sp, {sp, pc}
.Lretint:
ldr r0, [sp]
b .Lclosure_epilogue
.Lretlonglong:
ldr r0, [sp]
ldr r1, [sp, #4]
b .Lclosure_epilogue
#if !defined(__SOFTFP__) && !defined(__ARM_EABI__)
.Lretfloat:
ldfs f0, [sp]
b .Lclosure_epilogue
.Lretdouble:
ldfd f0, [sp]
b .Lclosure_epilogue
.Lretlongdouble:
ldfd f0, [sp]
b .Lclosure_epilogue
#endif
.ffi_closure_SYSV_end:
UNWIND .fnend
#ifdef __ELF__
.size CNAME(ffi_closure_SYSV),.ffi_closure_SYSV_end-CNAME(ffi_closure_SYSV)
#endif
/* Below are VFP hard-float ABI call and closure implementations.
Add VFP FPU directive here. This is only compiled into the library
under EABI. */
#ifdef __ARM_EABI__
.fpu vfp
@ r0: fn
@ r1: &ecif
@ r2: cif->bytes
@ r3: fig->flags
@ sp+0: ecif.rvalue
ARM_FUNC_START(ffi_call_VFP)
@ Save registers
stmfd sp!, {r0-r3, fp, lr}
UNWIND .save {r0-r3, fp, lr}
mov fp, sp
UNWIND .setfp fp, sp
@ Make room for all of the new args.
sub sp, sp, r2
@ Make room for loading VFP args
sub sp, sp, #64
@ Place all of the ffi_prep_args in position
mov r0, sp
@ r1 already set
sub r2, fp, #64 @ VFP scratch space
@ Call ffi_prep_args(stack, &ecif, vfp_space)
bl CNAME(ffi_prep_args_VFP)
@ Load VFP register args if needed
cmp r0, #0
mov ip, fp
beq LSYM(Lbase_args)
@ Load only d0 if possible
cmp r0, #3
sub ip, fp, #64
flddle d0, [ip]
fldmiadgt ip, {d0-d7}
LSYM(Lbase_args):
@ move first 4 parameters in registers
ldmia sp, {r0-r3}
@ and adjust stack
sub lr, ip, sp @ cif->bytes == (fp - 64) - sp
ldr ip, [fp] @ load fn() in advance
cmp lr, #16
movhs lr, #16
add sp, sp, lr
@ call (fn) (...)
call_reg(ip)
@ Remove the space we pushed for the args
mov sp, fp
@ Load r2 with the pointer to storage for
@ the return value
ldr r2, [sp, #24]
@ Load r3 with the return type code
ldr r3, [sp, #12]
@ If the return value pointer is NULL,
@ assume no return value.
cmp r2, #0
beq LSYM(Lepilogue_vfp)
cmp r3, #FFI_TYPE_INT
streq r0, [r2]
beq LSYM(Lepilogue_vfp)
cmp r3, #FFI_TYPE_SINT64
stmeqia r2, {r0, r1}
beq LSYM(Lepilogue_vfp)
cmp r3, #FFI_TYPE_FLOAT
fstseq s0, [r2]
beq LSYM(Lepilogue_vfp)
cmp r3, #FFI_TYPE_DOUBLE
fstdeq d0, [r2]
beq LSYM(Lepilogue_vfp)
cmp r3, #FFI_TYPE_STRUCT_VFP_FLOAT
cmpne r3, #FFI_TYPE_STRUCT_VFP_DOUBLE
fstmiadeq r2, {d0-d3}
LSYM(Lepilogue_vfp):
RETLDM "r0-r3,fp"
.ffi_call_VFP_end:
UNWIND .fnend
.size CNAME(ffi_call_VFP),.ffi_call_VFP_end-CNAME(ffi_call_VFP)
ARM_FUNC_START(ffi_closure_VFP)
fstmfdd sp!, {d0-d7}
@ r0-r3, then d0-d7
UNWIND .pad #80
add ip, sp, #80
stmfd sp!, {ip, lr}
UNWIND .save {r0, lr}
add r2, sp, #72
add r3, sp, #8
UNWIND .pad #72
sub sp, sp, #72
str sp, [sp, #64]
add r1, sp, #64
bl CNAME(ffi_closure_inner)
cmp r0, #FFI_TYPE_INT
beq .Lretint_vfp
cmp r0, #FFI_TYPE_FLOAT
beq .Lretfloat_vfp
cmp r0, #FFI_TYPE_DOUBLE
cmpne r0, #FFI_TYPE_LONGDOUBLE
beq .Lretdouble_vfp
cmp r0, #FFI_TYPE_SINT64
beq .Lretlonglong_vfp
cmp r0, #FFI_TYPE_STRUCT_VFP_FLOAT
beq .Lretfloat_struct_vfp
cmp r0, #FFI_TYPE_STRUCT_VFP_DOUBLE
beq .Lretdouble_struct_vfp
.Lclosure_epilogue_vfp:
add sp, sp, #72
ldmfd sp, {sp, pc}
.Lretfloat_vfp:
flds s0, [sp]
b .Lclosure_epilogue_vfp
.Lretdouble_vfp:
fldd d0, [sp]
b .Lclosure_epilogue_vfp
.Lretint_vfp:
ldr r0, [sp]
b .Lclosure_epilogue_vfp
.Lretlonglong_vfp:
ldmia sp, {r0, r1}
b .Lclosure_epilogue_vfp
.Lretfloat_struct_vfp:
fldmiad sp, {d0-d1}
b .Lclosure_epilogue_vfp
.Lretdouble_struct_vfp:
fldmiad sp, {d0-d3}
b .Lclosure_epilogue_vfp
.ffi_closure_VFP_end:
UNWIND .fnend
.size CNAME(ffi_closure_VFP),.ffi_closure_VFP_end-CNAME(ffi_closure_VFP)
#endif
ENTRY(ffi_arm_trampoline)
stmfd sp!, {r0-r3}
ldr r0, [pc]
ldr pc, [pc]
#if defined __ELF__ && defined __linux__
.section .note.GNU-stack,"",%progbits
#endif
| {
"language": "Assembly"
} |
/**
******************************************************************************
* @file startup_stm32f10x_md_vl.s
* @author MCD Application Team
* @version V3.5.0
* @date 11-March-2011
* @brief STM32F10x Medium Density Value Line Devices vector table for RIDE7
* toolchain.
* This module performs:
* - Set the initial SP
* - Set the initial PC == Reset_Handler,
* - Set the vector table entries with the exceptions ISR address
* - Configure the clock system
* - Branches to main in the C library (which eventually
* calls main()).
* After Reset the Cortex-M3 processor is in Thread mode,
* priority is Privileged, and the Stack is set to Main.
******************************************************************************
* @attention
*
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
* TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*
* <h2><center>© COPYRIGHT 2011 STMicroelectronics</center></h2>
******************************************************************************
*/
.syntax unified
.cpu cortex-m3
.fpu softvfp
.thumb
.global g_pfnVectors
.global Default_Handler
/* start address for the initialization values of the .data section.
defined in linker script */
.word _sidata
/* start address for the .data section. defined in linker script */
.word _sdata
/* end address for the .data section. defined in linker script */
.word _edata
/* start address for the .bss section. defined in linker script */
.word _sbss
/* end address for the .bss section. defined in linker script */
.word _ebss
.equ BootRAM, 0xF108F85F
/**
* @brief This is the code that gets called when the processor first
* starts execution following a reset event. Only the absolutely
* necessary set is performed, after which the application
* supplied main() routine is called.
* @param None
* @retval None
*/
.section .text.Reset_Handler
.weak Reset_Handler
.type Reset_Handler, %function
Reset_Handler:
/* Copy the data segment initializers from flash to SRAM */
movs r1, #0
b LoopCopyDataInit
CopyDataInit:
ldr r3, =_sidata
ldr r3, [r3, r1]
str r3, [r0, r1]
adds r1, r1, #4
LoopCopyDataInit:
ldr r0, =_sdata
ldr r3, =_edata
adds r2, r0, r1
cmp r2, r3
bcc CopyDataInit
ldr r2, =_sbss
b LoopFillZerobss
/* Zero fill the bss segment. */
FillZerobss:
movs r3, #0
str r3, [r2], #4
LoopFillZerobss:
ldr r3, = _ebss
cmp r2, r3
bcc FillZerobss
/* Call the clock system intitialization function.*/
bl SystemInit
/* Call the application's entry point.*/
bl main
bx lr
.size Reset_Handler, .-Reset_Handler
/**
* @brief This is the code that gets called when the processor receives an
* unexpected interrupt. This simply enters an infinite loop, preserving
* the system state for examination by a debugger.
* @param None
* @retval None
*/
.section .text.Default_Handler,"ax",%progbits
Default_Handler:
Infinite_Loop:
b Infinite_Loop
.size Default_Handler, .-Default_Handler
/******************************************************************************
*
* The minimal vector table for a Cortex M3. Note that the proper constructs
* must be placed on this to ensure that it ends up at physical address
* 0x0000.0000.
*
******************************************************************************/
.section .isr_vector,"a",%progbits
.type g_pfnVectors, %object
.size g_pfnVectors, .-g_pfnVectors
g_pfnVectors:
.word _estack
.word Reset_Handler
.word NMI_Handler
.word HardFault_Handler
.word MemManage_Handler
.word BusFault_Handler
.word UsageFault_Handler
.word 0
.word 0
.word 0
.word 0
.word SVC_Handler
.word DebugMon_Handler
.word 0
.word PendSV_Handler
.word SysTick_Handler
.word WWDG_IRQHandler
.word PVD_IRQHandler
.word TAMPER_IRQHandler
.word RTC_IRQHandler
.word FLASH_IRQHandler
.word RCC_IRQHandler
.word EXTI0_IRQHandler
.word EXTI1_IRQHandler
.word EXTI2_IRQHandler
.word EXTI3_IRQHandler
.word EXTI4_IRQHandler
.word DMA1_Channel1_IRQHandler
.word DMA1_Channel2_IRQHandler
.word DMA1_Channel3_IRQHandler
.word DMA1_Channel4_IRQHandler
.word DMA1_Channel5_IRQHandler
.word DMA1_Channel6_IRQHandler
.word DMA1_Channel7_IRQHandler
.word ADC1_IRQHandler
.word 0
.word 0
.word 0
.word 0
.word EXTI9_5_IRQHandler
.word TIM1_BRK_TIM15_IRQHandler
.word TIM1_UP_TIM16_IRQHandler
.word TIM1_TRG_COM_TIM17_IRQHandler
.word TIM1_CC_IRQHandler
.word TIM2_IRQHandler
.word TIM3_IRQHandler
.word TIM4_IRQHandler
.word I2C1_EV_IRQHandler
.word I2C1_ER_IRQHandler
.word I2C2_EV_IRQHandler
.word I2C2_ER_IRQHandler
.word SPI1_IRQHandler
.word SPI2_IRQHandler
.word USART1_IRQHandler
.word USART2_IRQHandler
.word USART3_IRQHandler
.word EXTI15_10_IRQHandler
.word RTCAlarm_IRQHandler
.word CEC_IRQHandler
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word TIM6_DAC_IRQHandler
.word TIM7_IRQHandler
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word 0
.word BootRAM /* @0x01CC. This is for boot in RAM mode for
STM32F10x Medium Value Line Density devices. */
/*******************************************************************************
* Provide weak aliases for each Exception handler to the Default_Handler.
* As they are weak aliases, any function with the same name will override
* this definition.
*******************************************************************************/
.weak NMI_Handler
.thumb_set NMI_Handler,Default_Handler
.weak HardFault_Handler
.thumb_set HardFault_Handler,Default_Handler
.weak MemManage_Handler
.thumb_set MemManage_Handler,Default_Handler
.weak BusFault_Handler
.thumb_set BusFault_Handler,Default_Handler
.weak UsageFault_Handler
.thumb_set UsageFault_Handler,Default_Handler
.weak SVC_Handler
.thumb_set SVC_Handler,Default_Handler
.weak DebugMon_Handler
.thumb_set DebugMon_Handler,Default_Handler
.weak PendSV_Handler
.thumb_set PendSV_Handler,Default_Handler
/*
* SysTick_Handler in stm32plus is now marked 'weak' so that compatibility with other
* frameworks is made possible.
.weak SysTick_Handler
.thumb_set SysTick_Handler,Default_Handler
*/
.weak WWDG_IRQHandler
.thumb_set WWDG_IRQHandler,Default_Handler
.weak PVD_IRQHandler
.thumb_set PVD_IRQHandler,Default_Handler
.weak TAMPER_IRQHandler
.thumb_set TAMPER_IRQHandler,Default_Handler
.weak RTC_IRQHandler
.thumb_set RTC_IRQHandler,Default_Handler
.weak FLASH_IRQHandler
.thumb_set FLASH_IRQHandler,Default_Handler
.weak RCC_IRQHandler
.thumb_set RCC_IRQHandler,Default_Handler
.weak EXTI0_IRQHandler
.thumb_set EXTI0_IRQHandler,Default_Handler
.weak EXTI1_IRQHandler
.thumb_set EXTI1_IRQHandler,Default_Handler
.weak EXTI2_IRQHandler
.thumb_set EXTI2_IRQHandler,Default_Handler
.weak EXTI3_IRQHandler
.thumb_set EXTI3_IRQHandler,Default_Handler
.weak EXTI4_IRQHandler
.thumb_set EXTI4_IRQHandler,Default_Handler
.weak DMA1_Channel1_IRQHandler
.thumb_set DMA1_Channel1_IRQHandler,Default_Handler
.weak DMA1_Channel2_IRQHandler
.thumb_set DMA1_Channel2_IRQHandler,Default_Handler
.weak DMA1_Channel3_IRQHandler
.thumb_set DMA1_Channel3_IRQHandler,Default_Handler
.weak DMA1_Channel4_IRQHandler
.thumb_set DMA1_Channel4_IRQHandler,Default_Handler
.weak DMA1_Channel5_IRQHandler
.thumb_set DMA1_Channel5_IRQHandler,Default_Handler
.weak DMA1_Channel6_IRQHandler
.thumb_set DMA1_Channel6_IRQHandler,Default_Handler
.weak DMA1_Channel7_IRQHandler
.thumb_set DMA1_Channel7_IRQHandler,Default_Handler
.weak ADC1_IRQHandler
.thumb_set ADC1_IRQHandler,Default_Handler
.weak EXTI9_5_IRQHandler
.thumb_set EXTI9_5_IRQHandler,Default_Handler
.weak TIM1_BRK_TIM15_IRQHandler
.thumb_set TIM1_BRK_TIM15_IRQHandler,Default_Handler
.weak TIM1_UP_TIM16_IRQHandler
.thumb_set TIM1_UP_TIM16_IRQHandler,Default_Handler
.weak TIM1_TRG_COM_TIM17_IRQHandler
.thumb_set TIM1_TRG_COM_TIM17_IRQHandler,Default_Handler
.weak TIM1_CC_IRQHandler
.thumb_set TIM1_CC_IRQHandler,Default_Handler
.weak TIM2_IRQHandler
.thumb_set TIM2_IRQHandler,Default_Handler
.weak TIM3_IRQHandler
.thumb_set TIM3_IRQHandler,Default_Handler
.weak TIM4_IRQHandler
.thumb_set TIM4_IRQHandler,Default_Handler
.weak I2C1_EV_IRQHandler
.thumb_set I2C1_EV_IRQHandler,Default_Handler
.weak I2C1_ER_IRQHandler
.thumb_set I2C1_ER_IRQHandler,Default_Handler
.weak I2C2_EV_IRQHandler
.thumb_set I2C2_EV_IRQHandler,Default_Handler
.weak I2C2_ER_IRQHandler
.thumb_set I2C2_ER_IRQHandler,Default_Handler
.weak SPI1_IRQHandler
.thumb_set SPI1_IRQHandler,Default_Handler
.weak SPI2_IRQHandler
.thumb_set SPI2_IRQHandler,Default_Handler
.weak USART1_IRQHandler
.thumb_set USART1_IRQHandler,Default_Handler
.weak USART2_IRQHandler
.thumb_set USART2_IRQHandler,Default_Handler
.weak USART3_IRQHandler
.thumb_set USART3_IRQHandler,Default_Handler
.weak EXTI15_10_IRQHandler
.thumb_set EXTI15_10_IRQHandler,Default_Handler
.weak RTCAlarm_IRQHandler
.thumb_set RTCAlarm_IRQHandler,Default_Handler
.weak CEC_IRQHandler
.thumb_set CEC_IRQHandler,Default_Handler
.weak TIM6_DAC_IRQHandler
.thumb_set TIM6_DAC_IRQHandler,Default_Handler
.weak TIM7_IRQHandler
.thumb_set TIM7_IRQHandler,Default_Handler
/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
| {
"language": "Assembly"
} |
/* Default strnlen implementation for PowerPC32.
Copyright (C) 2013-2020 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
#define STRNLEN __strnlen_ppc
#ifdef SHARED
# undef libc_hidden_def
# define libc_hidden_def(name) \
__hidden_ver1 (__strnlen_ppc, __GI_strnlen, __strnlen_ppc); \
strong_alias (__strnlen_ppc, __strnlen_ppc_1); \
__hidden_ver1 (__strnlen_ppc_1, __GI___strnlen, __strnlen_ppc_1);
#endif
#include <string/strnlen.c>
| {
"language": "Assembly"
} |
;/******************** (C) COPYRIGHT 2017 STMicroelectronics ********************
;* File Name : startup_stm32f429xx.s
;* Author : MCD Application Team
;* Description : STM32F429xx devices vector table for EWARM toolchain.
;* This module performs:
;* - Set the initial SP
;* - Set the initial PC == _iar_program_start,
;* - Set the vector table entries with the exceptions ISR
;* address.
;* - Branches to main in the C library (which eventually
;* calls main()).
;* After Reset the Cortex-M4 processor is in Thread mode,
;* priority is Privileged, and the Stack is set to Main.
;********************************************************************************
;*
;* 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.
;* 3. Neither the name of STMicroelectronics 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 HOLDER 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.
;*
;*******************************************************************************
;
;
; The modules in this file are included in the libraries, and may be replaced
; by any user-defined modules that define the PUBLIC symbol _program_start or
; a user defined start symbol.
; To override the cstartup defined in the library, simply add your modified
; version to the workbench project.
;
; The vector table is normally located at address 0.
; When debugging in RAM, it can be located in RAM, aligned to at least 2^6.
; The name "__vector_table" has special meaning for C-SPY:
; it is where the SP start value is found, and the NVIC vector
; table register (VTOR) is initialized to this address if != 0.
;
; Cortex-M version
;
MODULE ?cstartup
;; Forward declaration of sections.
SECTION CSTACK:DATA:NOROOT(3)
SECTION .intvec:CODE:NOROOT(2)
EXTERN __iar_program_start
EXTERN SystemInit
PUBLIC __vector_table
DATA
__vector_table
DCD sfe(CSTACK)
DCD Reset_Handler ; Reset Handler
DCD NMI_Handler ; NMI Handler
DCD HardFault_Handler ; Hard Fault Handler
DCD MemManage_Handler ; MPU Fault Handler
DCD BusFault_Handler ; Bus Fault Handler
DCD UsageFault_Handler ; Usage Fault Handler
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD SVC_Handler ; SVCall Handler
DCD DebugMon_Handler ; Debug Monitor Handler
DCD 0 ; Reserved
DCD PendSV_Handler ; PendSV Handler
DCD SysTick_Handler ; SysTick Handler
; External Interrupts
DCD WWDG_IRQHandler ; Window WatchDog
DCD PVD_IRQHandler ; PVD through EXTI Line detection
DCD TAMP_STAMP_IRQHandler ; Tamper and TimeStamps through the EXTI line
DCD RTC_WKUP_IRQHandler ; RTC Wakeup through the EXTI line
DCD FLASH_IRQHandler ; FLASH
DCD RCC_IRQHandler ; RCC
DCD EXTI0_IRQHandler ; EXTI Line0
DCD EXTI1_IRQHandler ; EXTI Line1
DCD EXTI2_IRQHandler ; EXTI Line2
DCD EXTI3_IRQHandler ; EXTI Line3
DCD EXTI4_IRQHandler ; EXTI Line4
DCD DMA1_Stream0_IRQHandler ; DMA1 Stream 0
DCD DMA1_Stream1_IRQHandler ; DMA1 Stream 1
DCD DMA1_Stream2_IRQHandler ; DMA1 Stream 2
DCD DMA1_Stream3_IRQHandler ; DMA1 Stream 3
DCD DMA1_Stream4_IRQHandler ; DMA1 Stream 4
DCD DMA1_Stream5_IRQHandler ; DMA1 Stream 5
DCD DMA1_Stream6_IRQHandler ; DMA1 Stream 6
DCD ADC_IRQHandler ; ADC1, ADC2 and ADC3s
DCD CAN1_TX_IRQHandler ; CAN1 TX
DCD CAN1_RX0_IRQHandler ; CAN1 RX0
DCD CAN1_RX1_IRQHandler ; CAN1 RX1
DCD CAN1_SCE_IRQHandler ; CAN1 SCE
DCD EXTI9_5_IRQHandler ; External Line[9:5]s
DCD TIM1_BRK_TIM9_IRQHandler ; TIM1 Break and TIM9
DCD TIM1_UP_TIM10_IRQHandler ; TIM1 Update and TIM10
DCD TIM1_TRG_COM_TIM11_IRQHandler ; TIM1 Trigger and Commutation and TIM11
DCD TIM1_CC_IRQHandler ; TIM1 Capture Compare
DCD TIM2_IRQHandler ; TIM2
DCD TIM3_IRQHandler ; TIM3
DCD TIM4_IRQHandler ; TIM4
DCD I2C1_EV_IRQHandler ; I2C1 Event
DCD I2C1_ER_IRQHandler ; I2C1 Error
DCD I2C2_EV_IRQHandler ; I2C2 Event
DCD I2C2_ER_IRQHandler ; I2C2 Error
DCD SPI1_IRQHandler ; SPI1
DCD SPI2_IRQHandler ; SPI2
DCD USART1_IRQHandler ; USART1
DCD USART2_IRQHandler ; USART2
DCD USART3_IRQHandler ; USART3
DCD EXTI15_10_IRQHandler ; External Line[15:10]s
DCD RTC_Alarm_IRQHandler ; RTC Alarm (A and B) through EXTI Line
DCD OTG_FS_WKUP_IRQHandler ; USB OTG FS Wakeup through EXTI line
DCD TIM8_BRK_TIM12_IRQHandler ; TIM8 Break and TIM12
DCD TIM8_UP_TIM13_IRQHandler ; TIM8 Update and TIM13
DCD TIM8_TRG_COM_TIM14_IRQHandler ; TIM8 Trigger and Commutation and TIM14
DCD TIM8_CC_IRQHandler ; TIM8 Capture Compare
DCD DMA1_Stream7_IRQHandler ; DMA1 Stream7
DCD FMC_IRQHandler ; FMC
DCD SDIO_IRQHandler ; SDIO
DCD TIM5_IRQHandler ; TIM5
DCD SPI3_IRQHandler ; SPI3
DCD UART4_IRQHandler ; UART4
DCD UART5_IRQHandler ; UART5
DCD TIM6_DAC_IRQHandler ; TIM6 and DAC1&2 underrun errors
DCD TIM7_IRQHandler ; TIM7
DCD DMA2_Stream0_IRQHandler ; DMA2 Stream 0
DCD DMA2_Stream1_IRQHandler ; DMA2 Stream 1
DCD DMA2_Stream2_IRQHandler ; DMA2 Stream 2
DCD DMA2_Stream3_IRQHandler ; DMA2 Stream 3
DCD DMA2_Stream4_IRQHandler ; DMA2 Stream 4
DCD ETH_IRQHandler ; Ethernet
DCD ETH_WKUP_IRQHandler ; Ethernet Wakeup through EXTI line
DCD CAN2_TX_IRQHandler ; CAN2 TX
DCD CAN2_RX0_IRQHandler ; CAN2 RX0
DCD CAN2_RX1_IRQHandler ; CAN2 RX1
DCD CAN2_SCE_IRQHandler ; CAN2 SCE
DCD OTG_FS_IRQHandler ; USB OTG FS
DCD DMA2_Stream5_IRQHandler ; DMA2 Stream 5
DCD DMA2_Stream6_IRQHandler ; DMA2 Stream 6
DCD DMA2_Stream7_IRQHandler ; DMA2 Stream 7
DCD USART6_IRQHandler ; USART6
DCD I2C3_EV_IRQHandler ; I2C3 event
DCD I2C3_ER_IRQHandler ; I2C3 error
DCD OTG_HS_EP1_OUT_IRQHandler ; USB OTG HS End Point 1 Out
DCD OTG_HS_EP1_IN_IRQHandler ; USB OTG HS End Point 1 In
DCD OTG_HS_WKUP_IRQHandler ; USB OTG HS Wakeup through EXTI
DCD OTG_HS_IRQHandler ; USB OTG HS
DCD DCMI_IRQHandler ; DCMI
DCD 0 ; Reserved
DCD HASH_RNG_IRQHandler ; Hash and Rng
DCD FPU_IRQHandler ; FPU
DCD UART7_IRQHandler ; UART7
DCD UART8_IRQHandler ; UART8
DCD SPI4_IRQHandler ; SPI4
DCD SPI5_IRQHandler ; SPI5
DCD SPI6_IRQHandler ; SPI6
DCD SAI1_IRQHandler ; SAI1
DCD LTDC_IRQHandler ; LTDC
DCD LTDC_ER_IRQHandler ; LTDC error
DCD DMA2D_IRQHandler ; DMA2D
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Default interrupt handlers.
;;
THUMB
PUBWEAK Reset_Handler
SECTION .text:CODE:REORDER:NOROOT(2)
Reset_Handler
LDR R0, =SystemInit
BLX R0
LDR R0, =__iar_program_start
BX R0
PUBWEAK NMI_Handler
SECTION .text:CODE:REORDER:NOROOT(1)
NMI_Handler
B NMI_Handler
PUBWEAK HardFault_Handler
SECTION .text:CODE:REORDER:NOROOT(1)
HardFault_Handler
B HardFault_Handler
PUBWEAK MemManage_Handler
SECTION .text:CODE:REORDER:NOROOT(1)
MemManage_Handler
B MemManage_Handler
PUBWEAK BusFault_Handler
SECTION .text:CODE:REORDER:NOROOT(1)
BusFault_Handler
B BusFault_Handler
PUBWEAK UsageFault_Handler
SECTION .text:CODE:REORDER:NOROOT(1)
UsageFault_Handler
B UsageFault_Handler
PUBWEAK SVC_Handler
SECTION .text:CODE:REORDER:NOROOT(1)
SVC_Handler
B SVC_Handler
PUBWEAK DebugMon_Handler
SECTION .text:CODE:REORDER:NOROOT(1)
DebugMon_Handler
B DebugMon_Handler
PUBWEAK PendSV_Handler
SECTION .text:CODE:REORDER:NOROOT(1)
PendSV_Handler
B PendSV_Handler
PUBWEAK SysTick_Handler
SECTION .text:CODE:REORDER:NOROOT(1)
SysTick_Handler
B SysTick_Handler
PUBWEAK WWDG_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
WWDG_IRQHandler
B WWDG_IRQHandler
PUBWEAK PVD_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
PVD_IRQHandler
B PVD_IRQHandler
PUBWEAK TAMP_STAMP_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TAMP_STAMP_IRQHandler
B TAMP_STAMP_IRQHandler
PUBWEAK RTC_WKUP_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
RTC_WKUP_IRQHandler
B RTC_WKUP_IRQHandler
PUBWEAK FLASH_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
FLASH_IRQHandler
B FLASH_IRQHandler
PUBWEAK RCC_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
RCC_IRQHandler
B RCC_IRQHandler
PUBWEAK EXTI0_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
EXTI0_IRQHandler
B EXTI0_IRQHandler
PUBWEAK EXTI1_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
EXTI1_IRQHandler
B EXTI1_IRQHandler
PUBWEAK EXTI2_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
EXTI2_IRQHandler
B EXTI2_IRQHandler
PUBWEAK EXTI3_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
EXTI3_IRQHandler
B EXTI3_IRQHandler
PUBWEAK EXTI4_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
EXTI4_IRQHandler
B EXTI4_IRQHandler
PUBWEAK DMA1_Stream0_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA1_Stream0_IRQHandler
B DMA1_Stream0_IRQHandler
PUBWEAK DMA1_Stream1_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA1_Stream1_IRQHandler
B DMA1_Stream1_IRQHandler
PUBWEAK DMA1_Stream2_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA1_Stream2_IRQHandler
B DMA1_Stream2_IRQHandler
PUBWEAK DMA1_Stream3_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA1_Stream3_IRQHandler
B DMA1_Stream3_IRQHandler
PUBWEAK DMA1_Stream4_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA1_Stream4_IRQHandler
B DMA1_Stream4_IRQHandler
PUBWEAK DMA1_Stream5_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA1_Stream5_IRQHandler
B DMA1_Stream5_IRQHandler
PUBWEAK DMA1_Stream6_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA1_Stream6_IRQHandler
B DMA1_Stream6_IRQHandler
PUBWEAK ADC_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
ADC_IRQHandler
B ADC_IRQHandler
PUBWEAK CAN1_TX_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
CAN1_TX_IRQHandler
B CAN1_TX_IRQHandler
PUBWEAK CAN1_RX0_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
CAN1_RX0_IRQHandler
B CAN1_RX0_IRQHandler
PUBWEAK CAN1_RX1_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
CAN1_RX1_IRQHandler
B CAN1_RX1_IRQHandler
PUBWEAK CAN1_SCE_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
CAN1_SCE_IRQHandler
B CAN1_SCE_IRQHandler
PUBWEAK EXTI9_5_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
EXTI9_5_IRQHandler
B EXTI9_5_IRQHandler
PUBWEAK TIM1_BRK_TIM9_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM1_BRK_TIM9_IRQHandler
B TIM1_BRK_TIM9_IRQHandler
PUBWEAK TIM1_UP_TIM10_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM1_UP_TIM10_IRQHandler
B TIM1_UP_TIM10_IRQHandler
PUBWEAK TIM1_TRG_COM_TIM11_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM1_TRG_COM_TIM11_IRQHandler
B TIM1_TRG_COM_TIM11_IRQHandler
PUBWEAK TIM1_CC_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM1_CC_IRQHandler
B TIM1_CC_IRQHandler
PUBWEAK TIM2_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM2_IRQHandler
B TIM2_IRQHandler
PUBWEAK TIM3_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM3_IRQHandler
B TIM3_IRQHandler
PUBWEAK TIM4_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM4_IRQHandler
B TIM4_IRQHandler
PUBWEAK I2C1_EV_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
I2C1_EV_IRQHandler
B I2C1_EV_IRQHandler
PUBWEAK I2C1_ER_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
I2C1_ER_IRQHandler
B I2C1_ER_IRQHandler
PUBWEAK I2C2_EV_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
I2C2_EV_IRQHandler
B I2C2_EV_IRQHandler
PUBWEAK I2C2_ER_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
I2C2_ER_IRQHandler
B I2C2_ER_IRQHandler
PUBWEAK SPI1_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
SPI1_IRQHandler
B SPI1_IRQHandler
PUBWEAK SPI2_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
SPI2_IRQHandler
B SPI2_IRQHandler
PUBWEAK USART1_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
USART1_IRQHandler
B USART1_IRQHandler
PUBWEAK USART2_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
USART2_IRQHandler
B USART2_IRQHandler
PUBWEAK USART3_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
USART3_IRQHandler
B USART3_IRQHandler
PUBWEAK EXTI15_10_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
EXTI15_10_IRQHandler
B EXTI15_10_IRQHandler
PUBWEAK RTC_Alarm_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
RTC_Alarm_IRQHandler
B RTC_Alarm_IRQHandler
PUBWEAK OTG_FS_WKUP_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
OTG_FS_WKUP_IRQHandler
B OTG_FS_WKUP_IRQHandler
PUBWEAK TIM8_BRK_TIM12_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM8_BRK_TIM12_IRQHandler
B TIM8_BRK_TIM12_IRQHandler
PUBWEAK TIM8_UP_TIM13_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM8_UP_TIM13_IRQHandler
B TIM8_UP_TIM13_IRQHandler
PUBWEAK TIM8_TRG_COM_TIM14_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM8_TRG_COM_TIM14_IRQHandler
B TIM8_TRG_COM_TIM14_IRQHandler
PUBWEAK TIM8_CC_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM8_CC_IRQHandler
B TIM8_CC_IRQHandler
PUBWEAK DMA1_Stream7_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA1_Stream7_IRQHandler
B DMA1_Stream7_IRQHandler
PUBWEAK FMC_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
FMC_IRQHandler
B FMC_IRQHandler
PUBWEAK SDIO_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
SDIO_IRQHandler
B SDIO_IRQHandler
PUBWEAK TIM5_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM5_IRQHandler
B TIM5_IRQHandler
PUBWEAK SPI3_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
SPI3_IRQHandler
B SPI3_IRQHandler
PUBWEAK UART4_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
UART4_IRQHandler
B UART4_IRQHandler
PUBWEAK UART5_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
UART5_IRQHandler
B UART5_IRQHandler
PUBWEAK TIM6_DAC_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM6_DAC_IRQHandler
B TIM6_DAC_IRQHandler
PUBWEAK TIM7_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM7_IRQHandler
B TIM7_IRQHandler
PUBWEAK DMA2_Stream0_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA2_Stream0_IRQHandler
B DMA2_Stream0_IRQHandler
PUBWEAK DMA2_Stream1_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA2_Stream1_IRQHandler
B DMA2_Stream1_IRQHandler
PUBWEAK DMA2_Stream2_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA2_Stream2_IRQHandler
B DMA2_Stream2_IRQHandler
PUBWEAK DMA2_Stream3_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA2_Stream3_IRQHandler
B DMA2_Stream3_IRQHandler
PUBWEAK DMA2_Stream4_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA2_Stream4_IRQHandler
B DMA2_Stream4_IRQHandler
PUBWEAK ETH_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
ETH_IRQHandler
B ETH_IRQHandler
PUBWEAK ETH_WKUP_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
ETH_WKUP_IRQHandler
B ETH_WKUP_IRQHandler
PUBWEAK CAN2_TX_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
CAN2_TX_IRQHandler
B CAN2_TX_IRQHandler
PUBWEAK CAN2_RX0_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
CAN2_RX0_IRQHandler
B CAN2_RX0_IRQHandler
PUBWEAK CAN2_RX1_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
CAN2_RX1_IRQHandler
B CAN2_RX1_IRQHandler
PUBWEAK CAN2_SCE_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
CAN2_SCE_IRQHandler
B CAN2_SCE_IRQHandler
PUBWEAK OTG_FS_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
OTG_FS_IRQHandler
B OTG_FS_IRQHandler
PUBWEAK DMA2_Stream5_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA2_Stream5_IRQHandler
B DMA2_Stream5_IRQHandler
PUBWEAK DMA2_Stream6_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA2_Stream6_IRQHandler
B DMA2_Stream6_IRQHandler
PUBWEAK DMA2_Stream7_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA2_Stream7_IRQHandler
B DMA2_Stream7_IRQHandler
PUBWEAK USART6_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
USART6_IRQHandler
B USART6_IRQHandler
PUBWEAK I2C3_EV_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
I2C3_EV_IRQHandler
B I2C3_EV_IRQHandler
PUBWEAK I2C3_ER_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
I2C3_ER_IRQHandler
B I2C3_ER_IRQHandler
PUBWEAK OTG_HS_EP1_OUT_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
OTG_HS_EP1_OUT_IRQHandler
B OTG_HS_EP1_OUT_IRQHandler
PUBWEAK OTG_HS_EP1_IN_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
OTG_HS_EP1_IN_IRQHandler
B OTG_HS_EP1_IN_IRQHandler
PUBWEAK OTG_HS_WKUP_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
OTG_HS_WKUP_IRQHandler
B OTG_HS_WKUP_IRQHandler
PUBWEAK OTG_HS_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
OTG_HS_IRQHandler
B OTG_HS_IRQHandler
PUBWEAK DCMI_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DCMI_IRQHandler
B DCMI_IRQHandler
PUBWEAK HASH_RNG_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
HASH_RNG_IRQHandler
B HASH_RNG_IRQHandler
PUBWEAK FPU_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
FPU_IRQHandler
B FPU_IRQHandler
PUBWEAK UART7_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
UART7_IRQHandler
B UART7_IRQHandler
PUBWEAK UART8_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
UART8_IRQHandler
B UART8_IRQHandler
PUBWEAK SPI4_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
SPI4_IRQHandler
B SPI4_IRQHandler
PUBWEAK SPI5_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
SPI5_IRQHandler
B SPI5_IRQHandler
PUBWEAK SPI6_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
SPI6_IRQHandler
B SPI6_IRQHandler
PUBWEAK SAI1_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
SAI1_IRQHandler
B SAI1_IRQHandler
PUBWEAK LTDC_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
LTDC_IRQHandler
B LTDC_IRQHandler
PUBWEAK LTDC_ER_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
LTDC_ER_IRQHandler
B LTDC_ER_IRQHandler
PUBWEAK DMA2D_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA2D_IRQHandler
B DMA2D_IRQHandler
END
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
| {
"language": "Assembly"
} |
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the mingw-w64 runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#include <_mingw_mac.h>
.file "sinl_internal.S"
.text
#ifdef __x86_64__
.align 8
#else
.align 4
#endif
.globl __MINGW_USYMBOL(__sinl_internal)
.def __MINGW_USYMBOL(__sinl_internal); .scl 2; .type 32; .endef
__MINGW_USYMBOL(__sinl_internal):
#ifdef __x86_64__
fldt (%rdx)
fsin
fnstsw %ax
testl $0x400,%eax
jnz 1f
movq %rcx,%rax
movq $0,8(%rcx)
fstpt (%rcx)
ret
1: fldpi
fadd %st(0)
fxch %st(1)
2: fprem1
fnstsw %ax
testl $0x400,%eax
jnz 2b
fstp %st(1)
fsin
movq %rcx,%rax
movq $0,8(%rcx)
fstpt (%rcx)
ret
#else
fldt 4(%esp)
fsin
fnstsw %ax
testl $0x400,%eax
jnz 1f
ret
1: fldpi
fadd %st(0)
fxch %st(1)
2: fprem1
fnstsw %ax
testl $0x400,%eax
jnz 2b
fstp %st(1)
fsin
ret
#endif
| {
"language": "Assembly"
} |
/* SPDX-License-Identifier: GPL-2.0+ */
/*
* Copyright (C) 2013 Boundary Devices
*/
/* ZQ Calibration */
DATA 4, MX6_MMDC_P0_MPZQHWCTRL, 0xa1390003
DATA 4, MX6_MMDC_P0_MPWLDECTRL0, 0x001F001F
DATA 4, MX6_MMDC_P0_MPWLDECTRL1, 0x001F001F
DATA 4, MX6_MMDC_P1_MPWLDECTRL0, 0x001F001F
DATA 4, MX6_MMDC_P1_MPWLDECTRL1, 0x001F001F
/*
* DQS gating, read delay, write delay calibration values
*/
DATA 4, MX6_MMDC_P0_MPDGCTRL0, 0x42190217
DATA 4, MX6_MMDC_P0_MPDGCTRL1, 0x017B017B
DATA 4, MX6_MMDC_P1_MPDGCTRL0, 0x4176017B
DATA 4, MX6_MMDC_P1_MPDGCTRL1, 0x015F016C
DATA 4, MX6_MMDC_P0_MPRDDLCTL, 0x4C4C4D4C
DATA 4, MX6_MMDC_P1_MPRDDLCTL, 0x4A4D4C48
DATA 4, MX6_MMDC_P0_MPWRDLCTL, 0x3F3F3F40
DATA 4, MX6_MMDC_P1_MPWRDLCTL, 0x3538382E
/* read data bit delay */
DATA 4, MX6_MMDC_P0_MPRDDQBY0DL, 0x33333333
DATA 4, MX6_MMDC_P0_MPRDDQBY1DL, 0x33333333
DATA 4, MX6_MMDC_P0_MPRDDQBY2DL, 0x33333333
DATA 4, MX6_MMDC_P0_MPRDDQBY3DL, 0x33333333
DATA 4, MX6_MMDC_P1_MPRDDQBY0DL, 0x33333333
DATA 4, MX6_MMDC_P1_MPRDDQBY1DL, 0x33333333
DATA 4, MX6_MMDC_P1_MPRDDQBY2DL, 0x33333333
DATA 4, MX6_MMDC_P1_MPRDDQBY3DL, 0x33333333
/* Complete calibration by forced measurment */
DATA 4, MX6_MMDC_P0_MPMUR0, 0x00000800
DATA 4, MX6_MMDC_P1_MPMUR0, 0x00000800
/* in DDR3, 64-bit mode, only MMDC0 is initiated */
DATA 4, MX6_MMDC_P0_MDPDC, 0x00020025
DATA 4, MX6_MMDC_P0_MDOTC, 0x00333030
DATA 4, MX6_MMDC_P0_MDCFG0, 0x676B5313
DATA 4, MX6_MMDC_P0_MDCFG1, 0xB66E8B63
DATA 4, MX6_MMDC_P0_MDCFG2, 0x01FF00DB
DATA 4, MX6_MMDC_P0_MDMISC, 0x00001740
DATA 4, MX6_MMDC_P0_MDSCR, 0x00008000
DATA 4, MX6_MMDC_P0_MDRWD, 0x000026d2
DATA 4, MX6_MMDC_P0_MDOR, 0x006B1023
DATA 4, MX6_MMDC_P0_MDASP, 0x00000027
DATA 4, MX6_MMDC_P0_MDCTL, 0x84190000
DATA 4, MX6_MMDC_P0_MDSCR, 0x04008032
DATA 4, MX6_MMDC_P0_MDSCR, 0x00008033
DATA 4, MX6_MMDC_P0_MDSCR, 0x00048031
DATA 4, MX6_MMDC_P0_MDSCR, 0x05208030
DATA 4, MX6_MMDC_P0_MDSCR, 0x04008040
/* final ddr setup */
DATA 4, MX6_MMDC_P0_MDREF, 0x00005800
DATA 4, MX6_MMDC_P0_MPODTCTRL, 0x00011117
DATA 4, MX6_MMDC_P1_MPODTCTRL, 0x00011117
DATA 4, MX6_MMDC_P0_MDPDC, 0x00025565
DATA 4, MX6_MMDC_P0_MAPSR, 0x00011006
DATA 4, MX6_MMDC_P0_MDSCR, 0x00000000
| {
"language": "Assembly"
} |
Notebook = {};
//////////////////////////////////////////////////////////////////////////////
//
// roughly a MVC-kinda-thing per cell, plus a MVC for all the cells
//
| {
"language": "Assembly"
} |
# Copyright 2013 the V8 project authors. All rights reserved.
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Apple Inc. 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 APPLE INC. AND ITS 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 APPLE INC. OR ITS 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.
This tests that an early return in the first basic block does not crash the DFG's bytecode parser whilst inlining.
On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
PASS foo(42) is 42
PASS bar(42) is 42
PASS successfullyParsed is true
TEST COMPLETE
| {
"language": "Assembly"
} |
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instcombine -S -mtriple "i386-pc-linux" | FileCheck %s
; RUN: opt < %s -instcombine -S -mtriple "i386-pc-win32" | FileCheck %s
; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-win32" | FileCheck %s
; RUN: opt < %s -instcombine -S -mtriple "i386-pc-mingw32" | FileCheck %s
; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-mingw32" | FileCheck %s
; RUN: opt < %s -instcombine -S -mtriple "sparc-sun-solaris" | FileCheck %s
; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-win32" -enable-debugify 2>&1 | FileCheck --check-prefix=DBG-VALID %s
declare double @floor(double)
declare double @ceil(double)
declare double @round(double)
declare double @nearbyint(double)
declare double @trunc(double)
declare double @fabs(double)
declare double @llvm.ceil.f64(double)
declare <2 x double> @llvm.ceil.v2f64(<2 x double>)
declare double @llvm.fabs.f64(double)
declare <2 x double> @llvm.fabs.v2f64(<2 x double>)
declare double @llvm.floor.f64(double)
declare <2 x double> @llvm.floor.v2f64(<2 x double>)
declare double @llvm.nearbyint.f64(double)
declare <2 x double> @llvm.nearbyint.v2f64(<2 x double>)
declare float @llvm.rint.f32(float)
declare <2 x float> @llvm.rint.v2f32(<2 x float>)
declare double @llvm.round.f64(double)
declare <2 x double> @llvm.round.v2f64(<2 x double>)
declare double @llvm.trunc.f64(double)
declare <2 x double> @llvm.trunc.v2f64(<2 x double>)
define float @test_shrink_libcall_floor(float %C) {
; CHECK-LABEL: @test_shrink_libcall_floor(
; CHECK-NEXT: [[F:%.*]] = call float @llvm.floor.f32(float [[C:%.*]])
; CHECK-NEXT: ret float [[F]]
;
%D = fpext float %C to double
; --> floorf
%E = call double @floor(double %D)
%F = fptrunc double %E to float
ret float %F
}
define float @test_shrink_libcall_ceil(float %C) {
; CHECK-LABEL: @test_shrink_libcall_ceil(
; CHECK-NEXT: [[F:%.*]] = call float @llvm.ceil.f32(float [[C:%.*]])
; CHECK-NEXT: ret float [[F]]
;
%D = fpext float %C to double
; --> ceilf
%E = call double @ceil(double %D)
%F = fptrunc double %E to float
ret float %F
}
define float @test_shrink_libcall_round(float %C) {
; CHECK-LABEL: @test_shrink_libcall_round(
; CHECK-NEXT: [[F:%.*]] = call float @llvm.round.f32(float [[C:%.*]])
; CHECK-NEXT: ret float [[F]]
;
%D = fpext float %C to double
; --> roundf
%E = call double @round(double %D)
%F = fptrunc double %E to float
ret float %F
}
define float @test_shrink_libcall_nearbyint(float %C) {
; CHECK-LABEL: @test_shrink_libcall_nearbyint(
; CHECK-NEXT: [[F:%.*]] = call float @llvm.nearbyint.f32(float [[C:%.*]])
; CHECK-NEXT: ret float [[F]]
;
%D = fpext float %C to double
; --> nearbyintf
%E = call double @nearbyint(double %D)
%F = fptrunc double %E to float
ret float %F
}
define float @test_shrink_libcall_trunc(float %C) {
; CHECK-LABEL: @test_shrink_libcall_trunc(
; CHECK-NEXT: [[F:%.*]] = call float @llvm.trunc.f32(float [[C:%.*]])
; CHECK-NEXT: ret float [[F]]
;
%D = fpext float %C to double
; --> truncf
%E = call double @trunc(double %D)
%F = fptrunc double %E to float
ret float %F
}
; This is replaced with the intrinsic, which does the right thing on
; CHECK platforms.
define float @test_shrink_libcall_fabs(float %C) {
; CHECK-LABEL: @test_shrink_libcall_fabs(
; CHECK-NEXT: [[F:%.*]] = call float @llvm.fabs.f32(float [[C:%.*]])
; CHECK-NEXT: ret float [[F]]
;
%D = fpext float %C to double
%E = call double @fabs(double %D)
%F = fptrunc double %E to float
ret float %F
}
; Make sure fast math flags are preserved
define float @test_shrink_libcall_fabs_fast(float %C) {
; CHECK-LABEL: @test_shrink_libcall_fabs_fast(
; CHECK-NEXT: [[F:%.*]] = call fast float @llvm.fabs.f32(float [[C:%.*]])
; CHECK-NEXT: ret float [[F]]
;
%D = fpext float %C to double
%E = call fast double @fabs(double %D)
%F = fptrunc double %E to float
ret float %F
}
define float @test_shrink_intrin_ceil(float %C) {
; CHECK-LABEL: @test_shrink_intrin_ceil(
; CHECK-NEXT: [[TMP1:%.*]] = call float @llvm.ceil.f32(float [[C:%.*]])
; CHECK-NEXT: ret float [[TMP1]]
;
%D = fpext float %C to double
%E = call double @llvm.ceil.f64(double %D)
%F = fptrunc double %E to float
ret float %F
}
define float @test_shrink_intrin_fabs(float %C) {
; CHECK-LABEL: @test_shrink_intrin_fabs(
; CHECK-NEXT: [[TMP1:%.*]] = call float @llvm.fabs.f32(float [[C:%.*]])
; CHECK-NEXT: ret float [[TMP1]]
;
%D = fpext float %C to double
%E = call double @llvm.fabs.f64(double %D)
%F = fptrunc double %E to float
ret float %F
}
define float @test_shrink_intrin_floor(float %C) {
; CHECK-LABEL: @test_shrink_intrin_floor(
; CHECK-NEXT: [[TMP1:%.*]] = call float @llvm.floor.f32(float [[C:%.*]])
; CHECK-NEXT: ret float [[TMP1]]
;
%D = fpext float %C to double
%E = call double @llvm.floor.f64(double %D)
%F = fptrunc double %E to float
ret float %F
}
define float @test_shrink_intrin_nearbyint(float %C) {
; CHECK-LABEL: @test_shrink_intrin_nearbyint(
; CHECK-NEXT: [[TMP1:%.*]] = call float @llvm.nearbyint.f32(float [[C:%.*]])
; CHECK-NEXT: ret float [[TMP1]]
;
%D = fpext float %C to double
%E = call double @llvm.nearbyint.f64(double %D)
%F = fptrunc double %E to float
ret float %F
}
define half @test_shrink_intrin_rint(half %C) {
; CHECK-LABEL: @test_shrink_intrin_rint(
; CHECK-NEXT: [[TMP1:%.*]] = call half @llvm.rint.f16(half [[C:%.*]])
; CHECK-NEXT: ret half [[TMP1]]
;
%D = fpext half %C to float
%E = call float @llvm.rint.f32(float %D)
%F = fptrunc float %E to half
ret half %F
}
define float @test_shrink_intrin_round(float %C) {
; CHECK-LABEL: @test_shrink_intrin_round(
; CHECK-NEXT: [[TMP1:%.*]] = call float @llvm.round.f32(float [[C:%.*]])
; CHECK-NEXT: ret float [[TMP1]]
;
%D = fpext float %C to double
%E = call double @llvm.round.f64(double %D)
%F = fptrunc double %E to float
ret float %F
}
define float @test_shrink_intrin_trunc(float %C) {
; CHECK-LABEL: @test_shrink_intrin_trunc(
; CHECK-NEXT: [[TMP1:%.*]] = call float @llvm.trunc.f32(float [[C:%.*]])
; CHECK-NEXT: ret float [[TMP1]]
;
%D = fpext float %C to double
%E = call double @llvm.trunc.f64(double %D)
%F = fptrunc double %E to float
ret float %F
}
declare void @use_v2f64(<2 x double>)
declare void @use_v2f32(<2 x float>)
define <2 x float> @test_shrink_intrin_ceil_multi_use(<2 x float> %C) {
; CHECK-LABEL: @test_shrink_intrin_ceil_multi_use(
; CHECK-NEXT: [[D:%.*]] = fpext <2 x float> [[C:%.*]] to <2 x double>
; CHECK-NEXT: [[E:%.*]] = call <2 x double> @llvm.ceil.v2f64(<2 x double> [[D]])
; CHECK-NEXT: [[F:%.*]] = fptrunc <2 x double> [[E]] to <2 x float>
; CHECK-NEXT: call void @use_v2f64(<2 x double> [[D]])
; CHECK-NEXT: ret <2 x float> [[F]]
;
%D = fpext <2 x float> %C to <2 x double>
%E = call <2 x double> @llvm.ceil.v2f64(<2 x double> %D)
%F = fptrunc <2 x double> %E to <2 x float>
call void @use_v2f64(<2 x double> %D)
ret <2 x float> %F
}
define <2 x float> @test_shrink_intrin_fabs_multi_use(<2 x float> %C) {
; CHECK-LABEL: @test_shrink_intrin_fabs_multi_use(
; CHECK-NEXT: [[TMP1:%.*]] = call <2 x float> @llvm.fabs.v2f32(<2 x float> [[C:%.*]])
; CHECK-NEXT: [[E:%.*]] = fpext <2 x float> [[TMP1]] to <2 x double>
; CHECK-NEXT: call void @use_v2f64(<2 x double> [[E]])
; CHECK-NEXT: ret <2 x float> [[TMP1]]
;
%D = fpext <2 x float> %C to <2 x double>
%E = call <2 x double> @llvm.fabs.v2f64(<2 x double> %D)
%F = fptrunc <2 x double> %E to <2 x float>
call void @use_v2f64(<2 x double> %E)
ret <2 x float> %F
}
define <2 x float> @test_shrink_intrin_floor_multi_use(<2 x float> %C) {
; CHECK-LABEL: @test_shrink_intrin_floor_multi_use(
; CHECK-NEXT: [[D:%.*]] = fpext <2 x float> [[C:%.*]] to <2 x double>
; CHECK-NEXT: [[E:%.*]] = call <2 x double> @llvm.floor.v2f64(<2 x double> [[D]])
; CHECK-NEXT: [[F:%.*]] = fptrunc <2 x double> [[E]] to <2 x float>
; CHECK-NEXT: call void @use_v2f64(<2 x double> [[D]])
; CHECK-NEXT: call void @use_v2f64(<2 x double> [[E]])
; CHECK-NEXT: ret <2 x float> [[F]]
;
%D = fpext <2 x float> %C to <2 x double>
%E = call <2 x double> @llvm.floor.v2f64(<2 x double> %D)
%F = fptrunc <2 x double> %E to <2 x float>
call void @use_v2f64(<2 x double> %D)
call void @use_v2f64(<2 x double> %E)
ret <2 x float> %F
}
define <2 x float> @test_shrink_intrin_nearbyint_multi_use(<2 x float> %C) {
; CHECK-LABEL: @test_shrink_intrin_nearbyint_multi_use(
; CHECK-NEXT: [[D:%.*]] = fpext <2 x float> [[C:%.*]] to <2 x double>
; CHECK-NEXT: [[E:%.*]] = call <2 x double> @llvm.nearbyint.v2f64(<2 x double> [[D]])
; CHECK-NEXT: [[F:%.*]] = fptrunc <2 x double> [[E]] to <2 x float>
; CHECK-NEXT: call void @use_v2f64(<2 x double> [[D]])
; CHECK-NEXT: ret <2 x float> [[F]]
;
%D = fpext <2 x float> %C to <2 x double>
%E = call <2 x double> @llvm.nearbyint.v2f64(<2 x double> %D)
%F = fptrunc <2 x double> %E to <2 x float>
call void @use_v2f64(<2 x double> %D)
ret <2 x float> %F
}
define <2 x half> @test_shrink_intrin_rint_multi_use(<2 x half> %C) {
; CHECK-LABEL: @test_shrink_intrin_rint_multi_use(
; CHECK-NEXT: [[TMP1:%.*]] = call <2 x half> @llvm.rint.v2f16(<2 x half> [[C:%.*]])
; CHECK-NEXT: [[E:%.*]] = fpext <2 x half> [[TMP1]] to <2 x float>
; CHECK-NEXT: call void @use_v2f32(<2 x float> [[E]])
; CHECK-NEXT: ret <2 x half> [[TMP1]]
;
%D = fpext <2 x half> %C to <2 x float>
%E = call <2 x float> @llvm.rint.v2f32(<2 x float> %D)
%F = fptrunc <2 x float> %E to <2 x half>
call void @use_v2f32(<2 x float> %E)
ret <2 x half> %F
}
define <2 x float> @test_shrink_intrin_round_multi_use(<2 x float> %C) {
; CHECK-LABEL: @test_shrink_intrin_round_multi_use(
; CHECK-NEXT: [[D:%.*]] = fpext <2 x float> [[C:%.*]] to <2 x double>
; CHECK-NEXT: [[E:%.*]] = call <2 x double> @llvm.round.v2f64(<2 x double> [[D]])
; CHECK-NEXT: [[F:%.*]] = fptrunc <2 x double> [[E]] to <2 x float>
; CHECK-NEXT: call void @use_v2f64(<2 x double> [[D]])
; CHECK-NEXT: call void @use_v2f64(<2 x double> [[E]])
; CHECK-NEXT: ret <2 x float> [[F]]
;
%D = fpext <2 x float> %C to <2 x double>
%E = call <2 x double> @llvm.round.v2f64(<2 x double> %D)
%F = fptrunc <2 x double> %E to <2 x float>
call void @use_v2f64(<2 x double> %D)
call void @use_v2f64(<2 x double> %E)
ret <2 x float> %F
}
define <2 x float> @test_shrink_intrin_trunc_multi_use(<2 x float> %C) {
; CHECK-LABEL: @test_shrink_intrin_trunc_multi_use(
; CHECK-NEXT: [[D:%.*]] = fpext <2 x float> [[C:%.*]] to <2 x double>
; CHECK-NEXT: [[E:%.*]] = call <2 x double> @llvm.trunc.v2f64(<2 x double> [[D]])
; CHECK-NEXT: [[F:%.*]] = fptrunc <2 x double> [[E]] to <2 x float>
; CHECK-NEXT: call void @use_v2f64(<2 x double> [[D]])
; CHECK-NEXT: ret <2 x float> [[F]]
;
%D = fpext <2 x float> %C to <2 x double>
%E = call <2 x double> @llvm.trunc.v2f64(<2 x double> %D)
%F = fptrunc <2 x double> %E to <2 x float>
call void @use_v2f64(<2 x double> %D)
ret <2 x float> %F
}
; Make sure fast math flags are preserved
define float @test_shrink_intrin_fabs_fast(float %C) {
; CHECK-LABEL: @test_shrink_intrin_fabs_fast(
; CHECK-NEXT: [[TMP1:%.*]] = call fast float @llvm.fabs.f32(float [[C:%.*]])
; CHECK-NEXT: ret float [[TMP1]]
;
%D = fpext float %C to double
%E = call fast double @llvm.fabs.f64(double %D)
%F = fptrunc double %E to float
ret float %F
}
define float @test_no_shrink_intrin_floor(double %D) {
; CHECK-LABEL: @test_no_shrink_intrin_floor(
; CHECK-NEXT: [[E:%.*]] = call double @llvm.floor.f64(double [[D:%.*]])
; CHECK-NEXT: [[F:%.*]] = fptrunc double [[E]] to float
; CHECK-NEXT: ret float [[F]]
;
%E = call double @llvm.floor.f64(double %D)
%F = fptrunc double %E to float
ret float %F
}
define float @test_no_shrink_intrin_ceil(double %D) {
; CHECK-LABEL: @test_no_shrink_intrin_ceil(
; CHECK-NEXT: [[E:%.*]] = call double @llvm.ceil.f64(double [[D:%.*]])
; CHECK-NEXT: [[F:%.*]] = fptrunc double [[E]] to float
; CHECK-NEXT: ret float [[F]]
;
%E = call double @llvm.ceil.f64(double %D)
%F = fptrunc double %E to float
ret float %F
}
define float @test_no_shrink_intrin_round(double %D) {
; CHECK-LABEL: @test_no_shrink_intrin_round(
; CHECK-NEXT: [[E:%.*]] = call double @llvm.round.f64(double [[D:%.*]])
; CHECK-NEXT: [[F:%.*]] = fptrunc double [[E]] to float
; CHECK-NEXT: ret float [[F]]
;
%E = call double @llvm.round.f64(double %D)
%F = fptrunc double %E to float
ret float %F
}
define float @test_no_shrink_intrin_nearbyint(double %D) {
; CHECK-LABEL: @test_no_shrink_intrin_nearbyint(
; CHECK-NEXT: [[E:%.*]] = call double @llvm.nearbyint.f64(double [[D:%.*]])
; CHECK-NEXT: [[F:%.*]] = fptrunc double [[E]] to float
; CHECK-NEXT: ret float [[F]]
;
%E = call double @llvm.nearbyint.f64(double %D)
%F = fptrunc double %E to float
ret float %F
}
define float @test_no_shrink_intrin_trunc(double %D) {
; CHECK-LABEL: @test_no_shrink_intrin_trunc(
; CHECK-NEXT: [[E:%.*]] = call double @llvm.trunc.f64(double [[D:%.*]])
; CHECK-NEXT: [[F:%.*]] = fptrunc double [[E]] to float
; CHECK-NEXT: ret float [[F]]
;
%E = call double @llvm.trunc.f64(double %D)
%F = fptrunc double %E to float
ret float %F
}
define float @test_shrink_intrin_fabs_double_src(double %D) {
; CHECK-LABEL: @test_shrink_intrin_fabs_double_src(
; CHECK-NEXT: [[TMP1:%.*]] = fptrunc double [[D:%.*]] to float
; CHECK-NEXT: [[F:%.*]] = call float @llvm.fabs.f32(float [[TMP1]])
; CHECK-NEXT: ret float [[F]]
;
%E = call double @llvm.fabs.f64(double %D)
%F = fptrunc double %E to float
ret float %F
}
; Make sure fast math flags are preserved
define float @test_shrink_intrin_fabs_fast_double_src(double %D) {
; CHECK-LABEL: @test_shrink_intrin_fabs_fast_double_src(
; CHECK-NEXT: [[TMP1:%.*]] = fptrunc double [[D:%.*]] to float
; CHECK-NEXT: [[F:%.*]] = call fast float @llvm.fabs.f32(float [[TMP1]])
; CHECK-NEXT: ret float [[F]]
;
%E = call fast double @llvm.fabs.f64(double %D)
%F = fptrunc double %E to float
ret float %F
}
define float @test_shrink_float_convertible_constant_intrin_floor() {
; CHECK-LABEL: @test_shrink_float_convertible_constant_intrin_floor(
; CHECK-NEXT: ret float 2.000000e+00
;
%E = call double @llvm.floor.f64(double 2.1)
%F = fptrunc double %E to float
ret float %F
}
define float @test_shrink_float_convertible_constant_intrin_ceil() {
; CHECK-LABEL: @test_shrink_float_convertible_constant_intrin_ceil(
; CHECK-NEXT: ret float 3.000000e+00
;
%E = call double @llvm.ceil.f64(double 2.1)
%F = fptrunc double %E to float
ret float %F
}
define float @test_shrink_float_convertible_constant_intrin_round() {
; CHECK-LABEL: @test_shrink_float_convertible_constant_intrin_round(
; CHECK-NEXT: ret float 2.000000e+00
;
%E = call double @llvm.round.f64(double 2.1)
%F = fptrunc double %E to float
ret float %F
}
define float @test_shrink_float_convertible_constant_intrin_nearbyint() {
; CHECK-LABEL: @test_shrink_float_convertible_constant_intrin_nearbyint(
; CHECK-NEXT: ret float 2.000000e+00
;
%E = call double @llvm.nearbyint.f64(double 2.1)
%F = fptrunc double %E to float
ret float %F
}
define float @test_shrink_float_convertible_constant_intrin_trunc() {
; CHECK-LABEL: @test_shrink_float_convertible_constant_intrin_trunc(
; CHECK-NEXT: ret float 2.000000e+00
;
%E = call double @llvm.trunc.f64(double 2.1)
%F = fptrunc double %E to float
ret float %F
}
define float @test_shrink_float_convertible_constant_intrin_fabs() {
; CHECK-LABEL: @test_shrink_float_convertible_constant_intrin_fabs(
; CHECK-NEXT: ret float 0x4000CCCCC0000000
;
%E = call double @llvm.fabs.f64(double 2.1)
%F = fptrunc double %E to float
ret float %F
}
; Make sure fast math flags are preserved
define float @test_shrink_float_convertible_constant_intrin_fabs_fast() {
; CHECK-LABEL: @test_shrink_float_convertible_constant_intrin_fabs_fast(
; CHECK-NEXT: ret float 0x4000CCCCC0000000
;
%E = call fast double @llvm.fabs.f64(double 2.1)
%F = fptrunc double %E to float
ret float %F
}
define half @test_no_shrink_mismatched_type_intrin_floor(double %D) {
; CHECK-LABEL: @test_no_shrink_mismatched_type_intrin_floor(
; CHECK-NEXT: [[E:%.*]] = call double @llvm.floor.f64(double [[D:%.*]])
; CHECK-NEXT: [[F:%.*]] = fptrunc double [[E]] to half
; CHECK-NEXT: ret half [[F]]
;
%E = call double @llvm.floor.f64(double %D)
%F = fptrunc double %E to half
ret half %F
}
define half @test_no_shrink_mismatched_type_intrin_ceil(double %D) {
; CHECK-LABEL: @test_no_shrink_mismatched_type_intrin_ceil(
; CHECK-NEXT: [[E:%.*]] = call double @llvm.ceil.f64(double [[D:%.*]])
; CHECK-NEXT: [[F:%.*]] = fptrunc double [[E]] to half
; CHECK-NEXT: ret half [[F]]
;
%E = call double @llvm.ceil.f64(double %D)
%F = fptrunc double %E to half
ret half %F
}
define half @test_no_shrink_mismatched_type_intrin_round(double %D) {
; CHECK-LABEL: @test_no_shrink_mismatched_type_intrin_round(
; CHECK-NEXT: [[E:%.*]] = call double @llvm.round.f64(double [[D:%.*]])
; CHECK-NEXT: [[F:%.*]] = fptrunc double [[E]] to half
; CHECK-NEXT: ret half [[F]]
;
%E = call double @llvm.round.f64(double %D)
%F = fptrunc double %E to half
ret half %F
}
define half @test_no_shrink_mismatched_type_intrin_nearbyint(double %D) {
; CHECK-LABEL: @test_no_shrink_mismatched_type_intrin_nearbyint(
; CHECK-NEXT: [[E:%.*]] = call double @llvm.nearbyint.f64(double [[D:%.*]])
; CHECK-NEXT: [[F:%.*]] = fptrunc double [[E]] to half
; CHECK-NEXT: ret half [[F]]
;
%E = call double @llvm.nearbyint.f64(double %D)
%F = fptrunc double %E to half
ret half %F
}
define half @test_no_shrink_mismatched_type_intrin_trunc(double %D) {
; CHECK-LABEL: @test_no_shrink_mismatched_type_intrin_trunc(
; CHECK-NEXT: [[E:%.*]] = call double @llvm.trunc.f64(double [[D:%.*]])
; CHECK-NEXT: [[F:%.*]] = fptrunc double [[E]] to half
; CHECK-NEXT: ret half [[F]]
;
%E = call double @llvm.trunc.f64(double %D)
%F = fptrunc double %E to half
ret half %F
}
define half @test_shrink_mismatched_type_intrin_fabs_double_src(double %D) {
; CHECK-LABEL: @test_shrink_mismatched_type_intrin_fabs_double_src(
; CHECK-NEXT: [[TMP1:%.*]] = fptrunc double [[D:%.*]] to half
; CHECK-NEXT: [[F:%.*]] = call half @llvm.fabs.f16(half [[TMP1]])
; CHECK-NEXT: ret half [[F]]
;
%E = call double @llvm.fabs.f64(double %D)
%F = fptrunc double %E to half
ret half %F
}
; Make sure fast math flags are preserved
define half @test_mismatched_type_intrin_fabs_fast_double_src(double %D) {
; CHECK-LABEL: @test_mismatched_type_intrin_fabs_fast_double_src(
; CHECK-NEXT: [[TMP1:%.*]] = fptrunc double [[D:%.*]] to half
; CHECK-NEXT: [[F:%.*]] = call fast half @llvm.fabs.f16(half [[TMP1]])
; CHECK-NEXT: ret half [[F]]
;
%E = call fast double @llvm.fabs.f64(double %D)
%F = fptrunc double %E to half
ret half %F
}
define <2 x double> @test_shrink_intrin_floor_fp16_vec(<2 x half> %C) {
; CHECK-LABEL: @test_shrink_intrin_floor_fp16_vec(
; CHECK-NEXT: [[TMP1:%.*]] = call arcp <2 x half> @llvm.floor.v2f16(<2 x half> [[C:%.*]])
; CHECK-NEXT: [[E:%.*]] = fpext <2 x half> [[TMP1]] to <2 x double>
; CHECK-NEXT: ret <2 x double> [[E]]
;
%D = fpext <2 x half> %C to <2 x double>
%E = call arcp <2 x double> @llvm.floor.v2f64(<2 x double> %D)
ret <2 x double> %E
}
define float @test_shrink_intrin_ceil_fp16_src(half %C) {
; CHECK-LABEL: @test_shrink_intrin_ceil_fp16_src(
; CHECK-NEXT: [[TMP1:%.*]] = call half @llvm.ceil.f16(half [[C:%.*]])
; CHECK-NEXT: [[F:%.*]] = fpext half [[TMP1]] to float
; CHECK-NEXT: ret float [[F]]
;
%D = fpext half %C to double
%E = call double @llvm.ceil.f64(double %D)
%F = fptrunc double %E to float
ret float %F
}
define <2 x double> @test_shrink_intrin_round_fp16_vec(<2 x half> %C) {
; CHECK-LABEL: @test_shrink_intrin_round_fp16_vec(
; CHECK-NEXT: [[TMP1:%.*]] = call <2 x half> @llvm.round.v2f16(<2 x half> [[C:%.*]])
; CHECK-NEXT: [[E:%.*]] = fpext <2 x half> [[TMP1]] to <2 x double>
; CHECK-NEXT: ret <2 x double> [[E]]
;
%D = fpext <2 x half> %C to <2 x double>
%E = call <2 x double> @llvm.round.v2f64(<2 x double> %D)
ret <2 x double> %E
}
define float @test_shrink_intrin_nearbyint_fp16_src(half %C) {
; CHECK-LABEL: @test_shrink_intrin_nearbyint_fp16_src(
; CHECK-NEXT: [[TMP1:%.*]] = call half @llvm.nearbyint.f16(half [[C:%.*]])
; CHECK-NEXT: [[F:%.*]] = fpext half [[TMP1]] to float
; CHECK-NEXT: ret float [[F]]
;
%D = fpext half %C to double
%E = call double @llvm.nearbyint.f64(double %D)
%F = fptrunc double %E to float
ret float %F
}
define <2 x double> @test_shrink_intrin_trunc_fp16_src(<2 x half> %C) {
; CHECK-LABEL: @test_shrink_intrin_trunc_fp16_src(
; CHECK-NEXT: [[TMP1:%.*]] = call <2 x half> @llvm.trunc.v2f16(<2 x half> [[C:%.*]])
; CHECK-NEXT: [[E:%.*]] = fpext <2 x half> [[TMP1]] to <2 x double>
; CHECK-NEXT: ret <2 x double> [[E]]
;
%D = fpext <2 x half> %C to <2 x double>
%E = call <2 x double> @llvm.trunc.v2f64(<2 x double> %D)
ret <2 x double> %E
}
define float @test_shrink_intrin_fabs_fp16_src(half %C) {
; CHECK-LABEL: @test_shrink_intrin_fabs_fp16_src(
; CHECK-NEXT: [[TMP1:%.*]] = call half @llvm.fabs.f16(half [[C:%.*]])
; CHECK-NEXT: [[F:%.*]] = fpext half [[TMP1]] to float
; CHECK-NEXT: ret float [[F]]
;
%D = fpext half %C to double
%E = call double @llvm.fabs.f64(double %D)
%F = fptrunc double %E to float
ret float %F
}
; Make sure fast math flags are preserved
define float @test_shrink_intrin_fabs_fast_fp16_src(half %C) {
; CHECK-LABEL: @test_shrink_intrin_fabs_fast_fp16_src(
; CHECK-NEXT: [[TMP1:%.*]] = call fast half @llvm.fabs.f16(half [[C:%.*]])
; CHECK-NEXT: [[F:%.*]] = fpext half [[TMP1]] to float
; CHECK-NEXT: ret float [[F]]
;
%D = fpext half %C to double
%E = call fast double @llvm.fabs.f64(double %D)
%F = fptrunc double %E to float
ret float %F
}
define float @test_no_shrink_intrin_floor_multi_use_fpext(half %C) {
; CHECK-LABEL: @test_no_shrink_intrin_floor_multi_use_fpext(
; CHECK-NEXT: [[D:%.*]] = fpext half [[C:%.*]] to double
; CHECK-NEXT: store volatile double [[D]], double* undef, align 8
; CHECK-NEXT: [[E:%.*]] = call double @llvm.floor.f64(double [[D]])
; CHECK-NEXT: [[F:%.*]] = fptrunc double [[E]] to float
; CHECK-NEXT: ret float [[F]]
;
%D = fpext half %C to double
store volatile double %D, double* undef
%E = call double @llvm.floor.f64(double %D)
%F = fptrunc double %E to float
ret float %F
}
define float @test_no_shrink_intrin_fabs_multi_use_fpext(half %C) {
; CHECK-LABEL: @test_no_shrink_intrin_fabs_multi_use_fpext(
; CHECK-NEXT: [[D:%.*]] = fpext half [[C:%.*]] to double
; CHECK-NEXT: store volatile double [[D]], double* undef, align 8
; CHECK-NEXT: [[E:%.*]] = call double @llvm.fabs.f64(double [[D]])
; CHECK-NEXT: [[F:%.*]] = fptrunc double [[E]] to float
; CHECK-NEXT: ret float [[F]]
;
%D = fpext half %C to double
store volatile double %D, double* undef
%E = call double @llvm.fabs.f64(double %D)
%F = fptrunc double %E to float
ret float %F
}
; DBG-VALID: CheckModuleDebugify: PASS
| {
"language": "Assembly"
} |
;-----------------------------------------------------------------------------;
; Authors: Stephen Fewer (stephen_fewer[at]harmonysecurity[dot]com)
; Borja Merino (bmerinofe[at]gmail[dot]com) [Hidden ACL support]]
; Compatible: Windows 7, 2008, Vista, 2003, XP, 2000, NT4
; Version: 1.0 (27 May 2014)
; Size: 352 bytes
; Build: >build.py stager_hidden_bind_tcp
;-----------------------------------------------------------------------------;
[BITS 32]
[ORG 0]
cld ; Clear the direction flag.
call start ; Call start, this pushes the address of 'api_call' onto the stack.
%include "./src/block/block_api.asm"
start: ;
pop ebp ; pop off the address of 'api_call' for calling later.
%include "./src/block/block_hidden_bind_tcp.asm"
; By here we will have performed the bind_tcp connection and EDI will be our socket.
%include "./src/block/block_recv.asm"
; By now we will have received in the second stage into a RWX buffer and be executing it
| {
"language": "Assembly"
} |
# RUN: llvm-mc -triple i386-unknown-unknown %s > %t
# RUN: FileCheck < %t %s
// CHECK: .globl $foo
.globl $foo
// CHECK: .long ($foo)
.long ($foo)
| {
"language": "Assembly"
} |
/******************** (C) COPYRIGHT 2016 STMicroelectronics ********************
;* File Name : startup_stm32f429_439xx.s
;* Author : MCD Application Team
;* @version : V1.8.0
;* @date : 09-November-2016
;* Description : STM32F429xx/439xx devices vector table for EWARM toolchain.
;* This module performs:
;* - Set the initial SP
;* - Set the initial PC == _iar_program_start,
;* - Set the vector table entries with the exceptions ISR
;* address.
;* - Configure the system clock and the external SRAM/SDRAM mounted
;* on STM324x9I-EVAL board to be used as data memory (optional,
;* to be enabled by user)
;* - Branches to main in the C library (which eventually
;* calls main()).
;* After Reset the Cortex-M4 processor is in Thread mode,
;* priority is Privileged, and the Stack is set to Main.
;********************************************************************************
;*
;* Licensed under MCD-ST Liberty SW License Agreement V2, (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.st.com/software_license_agreement_liberty_v2
;*
;* 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.
;*
;*******************************************************************************/
;
;
; The modules in this file are included in the libraries, and may be replaced
; by any user-defined modules that define the PUBLIC symbol _program_start or
; a user defined start symbol.
; To override the cstartup defined in the library, simply add your modified
; version to the workbench project.
;
; The vector table is normally located at address 0.
; When debugging in RAM, it can be located in RAM, aligned to at least 2^6.
; The name "__vector_table" has special meaning for C-SPY:
; it is where the SP start value is found, and the NVIC vector
; table register (VTOR) is initialized to this address if != 0.
;
; Cortex-M version
;
MODULE ?cstartup
;; Forward declaration of sections.
SECTION CSTACK:DATA:NOROOT(3)
SECTION .intvec:CODE:NOROOT(2)
EXTERN __iar_program_start
EXTERN SystemInit
PUBLIC __vector_table
DATA
__vector_table
DCD sfe(CSTACK)
DCD Reset_Handler ; Reset Handler
DCD NMI_Handler ; NMI Handler
DCD HardFault_Handler ; Hard Fault Handler
DCD MemManage_Handler ; MPU Fault Handler
DCD BusFault_Handler ; Bus Fault Handler
DCD UsageFault_Handler ; Usage Fault Handler
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD SVC_Handler ; SVCall Handler
DCD DebugMon_Handler ; Debug Monitor Handler
DCD 0 ; Reserved
DCD PendSV_Handler ; PendSV Handler
DCD SysTick_Handler ; SysTick Handler
; External Interrupts
DCD WWDG_IRQHandler ; Window WatchDog
DCD PVD_IRQHandler ; PVD through EXTI Line detection
DCD TAMP_STAMP_IRQHandler ; Tamper and TimeStamps through the EXTI line
DCD RTC_WKUP_IRQHandler ; RTC Wakeup through the EXTI line
DCD FLASH_IRQHandler ; FLASH
DCD RCC_IRQHandler ; RCC
DCD EXTI0_IRQHandler ; EXTI Line0
DCD EXTI1_IRQHandler ; EXTI Line1
DCD EXTI2_IRQHandler ; EXTI Line2
DCD EXTI3_IRQHandler ; EXTI Line3
DCD EXTI4_IRQHandler ; EXTI Line4
DCD DMA1_Stream0_IRQHandler ; DMA1 Stream 0
DCD DMA1_Stream1_IRQHandler ; DMA1 Stream 1
DCD DMA1_Stream2_IRQHandler ; DMA1 Stream 2
DCD DMA1_Stream3_IRQHandler ; DMA1 Stream 3
DCD DMA1_Stream4_IRQHandler ; DMA1 Stream 4
DCD DMA1_Stream5_IRQHandler ; DMA1 Stream 5
DCD DMA1_Stream6_IRQHandler ; DMA1 Stream 6
DCD ADC_IRQHandler ; ADC1, ADC2 and ADC3s
DCD CAN1_TX_IRQHandler ; CAN1 TX
DCD CAN1_RX0_IRQHandler ; CAN1 RX0
DCD CAN1_RX1_IRQHandler ; CAN1 RX1
DCD CAN1_SCE_IRQHandler ; CAN1 SCE
DCD EXTI9_5_IRQHandler ; External Line[9:5]s
DCD TIM1_BRK_TIM9_IRQHandler ; TIM1 Break and TIM9
DCD TIM1_UP_TIM10_IRQHandler ; TIM1 Update and TIM10
DCD TIM1_TRG_COM_TIM11_IRQHandler ; TIM1 Trigger and Commutation and TIM11
DCD TIM1_CC_IRQHandler ; TIM1 Capture Compare
DCD TIM2_IRQHandler ; TIM2
DCD TIM3_IRQHandler ; TIM3
DCD TIM4_IRQHandler ; TIM4
DCD I2C1_EV_IRQHandler ; I2C1 Event
DCD I2C1_ER_IRQHandler ; I2C1 Error
DCD I2C2_EV_IRQHandler ; I2C2 Event
DCD I2C2_ER_IRQHandler ; I2C2 Error
DCD SPI1_IRQHandler ; SPI1
DCD SPI2_IRQHandler ; SPI2
DCD USART1_IRQHandler ; USART1
DCD USART2_IRQHandler ; USART2
DCD USART3_IRQHandler ; USART3
DCD EXTI15_10_IRQHandler ; External Line[15:10]s
DCD RTC_Alarm_IRQHandler ; RTC Alarm (A and B) through EXTI Line
DCD OTG_FS_WKUP_IRQHandler ; USB OTG FS Wakeup through EXTI line
DCD TIM8_BRK_TIM12_IRQHandler ; TIM8 Break and TIM12
DCD TIM8_UP_TIM13_IRQHandler ; TIM8 Update and TIM13
DCD TIM8_TRG_COM_TIM14_IRQHandler ; TIM8 Trigger and Commutation and TIM14
DCD TIM8_CC_IRQHandler ; TIM8 Capture Compare
DCD DMA1_Stream7_IRQHandler ; DMA1 Stream7
DCD FMC_IRQHandler ; FMC
DCD SDIO_IRQHandler ; SDIO
DCD TIM5_IRQHandler ; TIM5
DCD SPI3_IRQHandler ; SPI3
DCD UART4_IRQHandler ; UART4
DCD UART5_IRQHandler ; UART5
DCD TIM6_DAC_IRQHandler ; TIM6 and DAC1&2 underrun errors
DCD TIM7_IRQHandler ; TIM7
DCD DMA2_Stream0_IRQHandler ; DMA2 Stream 0
DCD DMA2_Stream1_IRQHandler ; DMA2 Stream 1
DCD DMA2_Stream2_IRQHandler ; DMA2 Stream 2
DCD DMA2_Stream3_IRQHandler ; DMA2 Stream 3
DCD DMA2_Stream4_IRQHandler ; DMA2 Stream 4
DCD ETH_IRQHandler ; Ethernet
DCD ETH_WKUP_IRQHandler ; Ethernet Wakeup through EXTI line
DCD CAN2_TX_IRQHandler ; CAN2 TX
DCD CAN2_RX0_IRQHandler ; CAN2 RX0
DCD CAN2_RX1_IRQHandler ; CAN2 RX1
DCD CAN2_SCE_IRQHandler ; CAN2 SCE
DCD OTG_FS_IRQHandler ; USB OTG FS
DCD DMA2_Stream5_IRQHandler ; DMA2 Stream 5
DCD DMA2_Stream6_IRQHandler ; DMA2 Stream 6
DCD DMA2_Stream7_IRQHandler ; DMA2 Stream 7
DCD USART6_IRQHandler ; USART6
DCD I2C3_EV_IRQHandler ; I2C3 event
DCD I2C3_ER_IRQHandler ; I2C3 error
DCD OTG_HS_EP1_OUT_IRQHandler ; USB OTG HS End Point 1 Out
DCD OTG_HS_EP1_IN_IRQHandler ; USB OTG HS End Point 1 In
DCD OTG_HS_WKUP_IRQHandler ; USB OTG HS Wakeup through EXTI
DCD OTG_HS_IRQHandler ; USB OTG HS
DCD DCMI_IRQHandler ; DCMI
DCD CRYP_IRQHandler ; CRYP crypto
DCD HASH_RNG_IRQHandler ; Hash and Rng
DCD FPU_IRQHandler ; FPU
DCD UART7_IRQHandler ; UART7
DCD UART8_IRQHandler ; UART8
DCD SPI4_IRQHandler ; SPI4
DCD SPI5_IRQHandler ; SPI5
DCD SPI6_IRQHandler ; SPI6
DCD SAI1_IRQHandler ; SAI1
DCD LTDC_IRQHandler ; LTDC
DCD LTDC_ER_IRQHandler ; LTDC error
DCD DMA2D_IRQHandler ; DMA2D
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Default interrupt handlers.
;;
THUMB
PUBWEAK Reset_Handler
SECTION .text:CODE:REORDER:NOROOT(2)
Reset_Handler
LDR R0, =SystemInit
BLX R0
LDR R0, =__iar_program_start
BX R0
PUBWEAK NMI_Handler
SECTION .text:CODE:REORDER:NOROOT(1)
NMI_Handler
B NMI_Handler
PUBWEAK HardFault_Handler
SECTION .text:CODE:REORDER:NOROOT(1)
HardFault_Handler
B HardFault_Handler
PUBWEAK MemManage_Handler
SECTION .text:CODE:REORDER:NOROOT(1)
MemManage_Handler
B MemManage_Handler
PUBWEAK BusFault_Handler
SECTION .text:CODE:REORDER:NOROOT(1)
BusFault_Handler
B BusFault_Handler
PUBWEAK UsageFault_Handler
SECTION .text:CODE:REORDER:NOROOT(1)
UsageFault_Handler
B UsageFault_Handler
PUBWEAK SVC_Handler
SECTION .text:CODE:REORDER:NOROOT(1)
SVC_Handler
B SVC_Handler
PUBWEAK DebugMon_Handler
SECTION .text:CODE:REORDER:NOROOT(1)
DebugMon_Handler
B DebugMon_Handler
PUBWEAK PendSV_Handler
SECTION .text:CODE:REORDER:NOROOT(1)
PendSV_Handler
B PendSV_Handler
PUBWEAK SysTick_Handler
SECTION .text:CODE:REORDER:NOROOT(1)
SysTick_Handler
B SysTick_Handler
PUBWEAK WWDG_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
WWDG_IRQHandler
B WWDG_IRQHandler
PUBWEAK PVD_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
PVD_IRQHandler
B PVD_IRQHandler
PUBWEAK TAMP_STAMP_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TAMP_STAMP_IRQHandler
B TAMP_STAMP_IRQHandler
PUBWEAK RTC_WKUP_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
RTC_WKUP_IRQHandler
B RTC_WKUP_IRQHandler
PUBWEAK FLASH_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
FLASH_IRQHandler
B FLASH_IRQHandler
PUBWEAK RCC_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
RCC_IRQHandler
B RCC_IRQHandler
PUBWEAK EXTI0_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
EXTI0_IRQHandler
B EXTI0_IRQHandler
PUBWEAK EXTI1_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
EXTI1_IRQHandler
B EXTI1_IRQHandler
PUBWEAK EXTI2_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
EXTI2_IRQHandler
B EXTI2_IRQHandler
PUBWEAK EXTI3_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
EXTI3_IRQHandler
B EXTI3_IRQHandler
PUBWEAK EXTI4_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
EXTI4_IRQHandler
B EXTI4_IRQHandler
PUBWEAK DMA1_Stream0_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA1_Stream0_IRQHandler
B DMA1_Stream0_IRQHandler
PUBWEAK DMA1_Stream1_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA1_Stream1_IRQHandler
B DMA1_Stream1_IRQHandler
PUBWEAK DMA1_Stream2_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA1_Stream2_IRQHandler
B DMA1_Stream2_IRQHandler
PUBWEAK DMA1_Stream3_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA1_Stream3_IRQHandler
B DMA1_Stream3_IRQHandler
PUBWEAK DMA1_Stream4_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA1_Stream4_IRQHandler
B DMA1_Stream4_IRQHandler
PUBWEAK DMA1_Stream5_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA1_Stream5_IRQHandler
B DMA1_Stream5_IRQHandler
PUBWEAK DMA1_Stream6_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA1_Stream6_IRQHandler
B DMA1_Stream6_IRQHandler
PUBWEAK ADC_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
ADC_IRQHandler
B ADC_IRQHandler
PUBWEAK CAN1_TX_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
CAN1_TX_IRQHandler
B CAN1_TX_IRQHandler
PUBWEAK CAN1_RX0_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
CAN1_RX0_IRQHandler
B CAN1_RX0_IRQHandler
PUBWEAK CAN1_RX1_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
CAN1_RX1_IRQHandler
B CAN1_RX1_IRQHandler
PUBWEAK CAN1_SCE_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
CAN1_SCE_IRQHandler
B CAN1_SCE_IRQHandler
PUBWEAK EXTI9_5_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
EXTI9_5_IRQHandler
B EXTI9_5_IRQHandler
PUBWEAK TIM1_BRK_TIM9_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM1_BRK_TIM9_IRQHandler
B TIM1_BRK_TIM9_IRQHandler
PUBWEAK TIM1_UP_TIM10_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM1_UP_TIM10_IRQHandler
B TIM1_UP_TIM10_IRQHandler
PUBWEAK TIM1_TRG_COM_TIM11_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM1_TRG_COM_TIM11_IRQHandler
B TIM1_TRG_COM_TIM11_IRQHandler
PUBWEAK TIM1_CC_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM1_CC_IRQHandler
B TIM1_CC_IRQHandler
PUBWEAK TIM2_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM2_IRQHandler
B TIM2_IRQHandler
PUBWEAK TIM3_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM3_IRQHandler
B TIM3_IRQHandler
PUBWEAK TIM4_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM4_IRQHandler
B TIM4_IRQHandler
PUBWEAK I2C1_EV_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
I2C1_EV_IRQHandler
B I2C1_EV_IRQHandler
PUBWEAK I2C1_ER_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
I2C1_ER_IRQHandler
B I2C1_ER_IRQHandler
PUBWEAK I2C2_EV_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
I2C2_EV_IRQHandler
B I2C2_EV_IRQHandler
PUBWEAK I2C2_ER_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
I2C2_ER_IRQHandler
B I2C2_ER_IRQHandler
PUBWEAK SPI1_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
SPI1_IRQHandler
B SPI1_IRQHandler
PUBWEAK SPI2_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
SPI2_IRQHandler
B SPI2_IRQHandler
PUBWEAK USART1_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
USART1_IRQHandler
B USART1_IRQHandler
PUBWEAK USART2_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
USART2_IRQHandler
B USART2_IRQHandler
PUBWEAK USART3_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
USART3_IRQHandler
B USART3_IRQHandler
PUBWEAK EXTI15_10_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
EXTI15_10_IRQHandler
B EXTI15_10_IRQHandler
PUBWEAK RTC_Alarm_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
RTC_Alarm_IRQHandler
B RTC_Alarm_IRQHandler
PUBWEAK OTG_FS_WKUP_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
OTG_FS_WKUP_IRQHandler
B OTG_FS_WKUP_IRQHandler
PUBWEAK TIM8_BRK_TIM12_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM8_BRK_TIM12_IRQHandler
B TIM8_BRK_TIM12_IRQHandler
PUBWEAK TIM8_UP_TIM13_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM8_UP_TIM13_IRQHandler
B TIM8_UP_TIM13_IRQHandler
PUBWEAK TIM8_TRG_COM_TIM14_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM8_TRG_COM_TIM14_IRQHandler
B TIM8_TRG_COM_TIM14_IRQHandler
PUBWEAK TIM8_CC_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM8_CC_IRQHandler
B TIM8_CC_IRQHandler
PUBWEAK DMA1_Stream7_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA1_Stream7_IRQHandler
B DMA1_Stream7_IRQHandler
PUBWEAK FMC_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
FMC_IRQHandler
B FMC_IRQHandler
PUBWEAK SDIO_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
SDIO_IRQHandler
B SDIO_IRQHandler
PUBWEAK TIM5_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM5_IRQHandler
B TIM5_IRQHandler
PUBWEAK SPI3_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
SPI3_IRQHandler
B SPI3_IRQHandler
PUBWEAK UART4_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
UART4_IRQHandler
B UART4_IRQHandler
PUBWEAK UART5_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
UART5_IRQHandler
B UART5_IRQHandler
PUBWEAK TIM6_DAC_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM6_DAC_IRQHandler
B TIM6_DAC_IRQHandler
PUBWEAK TIM7_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
TIM7_IRQHandler
B TIM7_IRQHandler
PUBWEAK DMA2_Stream0_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA2_Stream0_IRQHandler
B DMA2_Stream0_IRQHandler
PUBWEAK DMA2_Stream1_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA2_Stream1_IRQHandler
B DMA2_Stream1_IRQHandler
PUBWEAK DMA2_Stream2_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA2_Stream2_IRQHandler
B DMA2_Stream2_IRQHandler
PUBWEAK DMA2_Stream3_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA2_Stream3_IRQHandler
B DMA2_Stream3_IRQHandler
PUBWEAK DMA2_Stream4_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA2_Stream4_IRQHandler
B DMA2_Stream4_IRQHandler
PUBWEAK ETH_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
ETH_IRQHandler
B ETH_IRQHandler
PUBWEAK ETH_WKUP_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
ETH_WKUP_IRQHandler
B ETH_WKUP_IRQHandler
PUBWEAK CAN2_TX_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
CAN2_TX_IRQHandler
B CAN2_TX_IRQHandler
PUBWEAK CAN2_RX0_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
CAN2_RX0_IRQHandler
B CAN2_RX0_IRQHandler
PUBWEAK CAN2_RX1_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
CAN2_RX1_IRQHandler
B CAN2_RX1_IRQHandler
PUBWEAK CAN2_SCE_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
CAN2_SCE_IRQHandler
B CAN2_SCE_IRQHandler
PUBWEAK OTG_FS_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
OTG_FS_IRQHandler
B OTG_FS_IRQHandler
PUBWEAK DMA2_Stream5_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA2_Stream5_IRQHandler
B DMA2_Stream5_IRQHandler
PUBWEAK DMA2_Stream6_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA2_Stream6_IRQHandler
B DMA2_Stream6_IRQHandler
PUBWEAK DMA2_Stream7_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA2_Stream7_IRQHandler
B DMA2_Stream7_IRQHandler
PUBWEAK USART6_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
USART6_IRQHandler
B USART6_IRQHandler
PUBWEAK I2C3_EV_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
I2C3_EV_IRQHandler
B I2C3_EV_IRQHandler
PUBWEAK I2C3_ER_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
I2C3_ER_IRQHandler
B I2C3_ER_IRQHandler
PUBWEAK OTG_HS_EP1_OUT_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
OTG_HS_EP1_OUT_IRQHandler
B OTG_HS_EP1_OUT_IRQHandler
PUBWEAK OTG_HS_EP1_IN_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
OTG_HS_EP1_IN_IRQHandler
B OTG_HS_EP1_IN_IRQHandler
PUBWEAK OTG_HS_WKUP_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
OTG_HS_WKUP_IRQHandler
B OTG_HS_WKUP_IRQHandler
PUBWEAK OTG_HS_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
OTG_HS_IRQHandler
B OTG_HS_IRQHandler
PUBWEAK DCMI_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DCMI_IRQHandler
B DCMI_IRQHandler
PUBWEAK CRYP_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
CRYP_IRQHandler
B CRYP_IRQHandler
PUBWEAK HASH_RNG_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
HASH_RNG_IRQHandler
B HASH_RNG_IRQHandler
PUBWEAK FPU_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
FPU_IRQHandler
B FPU_IRQHandler
PUBWEAK UART7_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
UART7_IRQHandler
B UART7_IRQHandler
PUBWEAK UART8_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
UART8_IRQHandler
B UART8_IRQHandler
PUBWEAK SPI4_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
SPI4_IRQHandler
B SPI4_IRQHandler
PUBWEAK SPI5_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
SPI5_IRQHandler
B SPI5_IRQHandler
PUBWEAK SPI6_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
SPI6_IRQHandler
B SPI6_IRQHandler
PUBWEAK SAI1_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
SAI1_IRQHandler
B SAI1_IRQHandler
PUBWEAK LTDC_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
LTDC_IRQHandler
B LTDC_IRQHandler
PUBWEAK LTDC_ER_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
LTDC_ER_IRQHandler
B LTDC_ER_IRQHandler
PUBWEAK DMA2D_IRQHandler
SECTION .text:CODE:REORDER:NOROOT(1)
DMA2D_IRQHandler
B DMA2D_IRQHandler
END
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
| {
"language": "Assembly"
} |
## ## () ## ^^ ## ## ## ##
## H1 C2 S1 <> S2 H2 DN ##
## %U <> %D *2 %L IZ .. ##
## ## ## .. ## DN *3 ## ##
## ## ## %R C1 IZ () ## ##
## ## ## ## >/ *1
## () *3 *1 %L ()
// Set divisor and dividend
S1-> = 9
S2-> = 24
// Holding cells
H1-> IF *1 THEN %R ELSE %N
H2-> IF *2 THEN %R ELSE %N
// Arithmetic
DN-> -= 1
IZ-> IF <= 0 THEN %D ELSE %U
C1-> IF *3 THEN %D ELSE %R
C2-> IF *3 THEN %U ELSE %D
| {
"language": "Assembly"
} |
; AI_SMART knows these moves are usable all-around.
UsefulMoves:
db DOUBLE_EDGE
db SING
db FLAMETHROWER
db HYDRO_PUMP
db SURF
db ICE_BEAM
db BLIZZARD
db HYPER_BEAM
db SLEEP_POWDER
db THUNDERBOLT
db THUNDER
db EARTHQUAKE
db TOXIC
db PSYCHIC_M
db HYPNOSIS
db RECOVER
db FIRE_BLAST
db SOFTBOILED
db SUPER_FANG
db -1 ; end
| {
"language": "Assembly"
} |
/*
* vp3_idct BlackFin
*
* Copyright (C) 2007 Marc Hoffman <marc.hoffman@analog.com>
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/*
This blackfin DSP code implements an 8x8 inverse type II DCT.
Prototype : void ff_bfin_vp3_idct(DCTELEM *in)
Registers Used : A0, A1, R0-R7, I0-I3, B0, B2, B3, M0-M2, L0-L3, P0-P5, LC0.
*/
#include "config.h"
#include "config_bfin.h"
#if defined(__FDPIC__) && CONFIG_SRAM
.section .l1.data.B,"aw",@progbits
#else
.data
#endif
.align 4;
coefs:
.short 0x5a82; // C4
.short 0x5a82; // C4
.short 0x30FC; //cos(3pi/8) C6
.short 0x7642; //cos(pi/8) C2
.short 0x18F9; //cos(7pi/16)
.short 0x7D8A; //cos(pi/16)
.short 0x471D; //cos(5pi/16)
.short 0x6A6E; //cos(3pi/16)
.short 0x18F9; //cos(7pi/16)
.short 0x7D8A; //cos(pi/16)
#if defined(__FDPIC__) && CONFIG_SRAM
.section .l1.data.A
#endif
vtmp: .space 256
#define TMP0 FP-8
#define TMP1 FP-12
#define TMP2 FP-16
.text
DEFUN(vp3_idct,mL1,
(DCTELEM *block)):
/********************** Function Prologue *********************************/
link 16;
[--SP] = (R7:4, P5:3); // Push the registers onto the stack.
B0 = R0; // Pointer to Input matrix
RELOC(R1, P3, coefs); // Pointer to Coefficients
RELOC(R2, P3, vtmp); // Pointer to Temporary matrix
B3 = R1;
B2 = R2;
L3 = 20; // L3 is used for making the coefficient array
// circular.
// MUST BE RESTORED TO ZERO at function exit.
M1 = 16 (X); // All these registers are initialized for
M3 = 8(X); // modifying address offsets.
I0 = B0; // I0 points to Input Element (0, 0).
I2 = B0; // I2 points to Input Element (0, 0).
I2 += M3 || R0.H = W[I0];
// Element 0 is read into R0.H
I1 = I2; // I1 points to input Element (0, 6).
I1 += 4 || R0.L = W[I2++];
// I2 points to input Element (0, 4).
// Element 4 is read into R0.L.
P2 = 8 (X);
P3 = 32 (X);
P4 = -32 (X);
P5 = 98 (X);
R7 = 0x8000(Z);
I3 = B3; // I3 points to Coefficients
P0 = B2; // P0 points to array Element (0, 0) of temp
P1 = B2;
R7 = [I3++] || [TMP2]=R7; // Coefficient C4 is read into R7.H and R7.L.
MNOP;
NOP;
/*
* A1 = Y0 * cos(pi/4)
* A0 = Y0 * cos(pi/4)
* A1 = A1 + Y4 * cos(pi/4)
* A0 = A0 - Y4 * cos(pi/4)
* load:
* R1=(Y2,Y6)
* R7=(C2,C6)
* res:
* R3=Y0, R2=Y4
*/
A1=R7.H*R0.H, A0=R7.H*R0.H (IS) || I0+= 4 || R1.L=W[I1++];
R3=(A1+=R7.H*R0.L), R2=(A0-=R7.H*R0.L) (IS) || R1.H=W[I0--] || R7=[I3++];
LSETUP (.0, .1) LC0 = P2; // perform 8 1d idcts
P2 = 112 (X);
P1 = P1 + P2; // P1 points to element (7, 0) of temp buffer.
P2 = -94(X);
.0:
/*
* A1 = Y2 * cos(3pi/8)
* A0 = Y2 * cos(pi/8)
* A1 = A1 - Y6 * cos(pi/8)
* A0 = A0 + Y6 * cos(3pi/8)
* R5 = (Y1,Y7)
* R7 = (C1,C7)
* res:
* R1=Y2, R0=Y6
*/
A1=R7.L*R1.H, A0=R7.H*R1.H (IS) || I0+=4 || R5.H=W[I0];
R1=(A1-=R7.H*R1.L), R0=(A0+=R7.L*R1.L) (IS) || R5.L=W[I1--] || R7=[I3++];
/*
* Y0 = Y0 + Y6.
* Y4 = Y4 + Y2.
* Y2 = Y4 - Y2.
* Y6 = Y0 - Y6.
* R3 is saved
* R6.l=Y3
* note: R3: Y0, R2: Y4, R1: Y2, R0: Y6
*/
R3=R3+R0, R0=R3-R0;
R2=R2+R1, R1=R2-R1 || [TMP0]=R3 || R6.L=W[I0--];
/*
* Compute the odd portion (1,3,5,7) even is done.
*
* Y1 = C7 * Y1 - C1 * Y7 + C3 * Y5 - C5 * Y3.
* Y7 = C1 * Y1 + C7 * Y7 + C5 * Y5 + C3 * Y3.
* Y5 = C5 * Y1 + C3 * Y7 + C7 * Y5 - C1 * Y3.
* Y3 = C3 * Y1 - C5 * Y7 - C1 * Y5 - C7 * Y3.
*/
// R5=(Y1,Y7) R6=(Y5,Y3) // R7=(C1,C7)
A1 =R7.L*R5.H, A0 =R7.H*R5.H (IS) || [TMP1]=R2 || R6.H=W[I2--];
A1-=R7.H*R5.L, A0+=R7.L*R5.L (IS) || I0-=4 || R7=[I3++];
A1+=R7.H*R6.H, A0+=R7.L*R6.H (IS) || I0+=M1; // R7=(C3,C5)
R3 =(A1-=R7.L*R6.L), R2 =(A0+=R7.H*R6.L) (IS);
A1 =R7.L*R5.H, A0 =R7.H*R5.H (IS) || R4=[TMP0];
A1+=R7.H*R5.L, A0-=R7.L*R5.L (IS) || I1+=M1 || R7=[I3++]; // R7=(C1,C7)
A1+=R7.L*R6.H, A0-=R7.H*R6.H (IS);
R7 =(A1-=R7.H*R6.L), R6 =(A0-=R7.L*R6.L) (IS) || I2+=M1;
// R3=Y1, R2=Y7, R7=Y5, R6=Y3
/* Transpose write column. */
R5.H=R4+R2 (RND12); // Y0=Y0+Y7
R5.L=R4-R2 (RND12) || R4 = [TMP1]; // Y7=Y7-Y0
R2.H=R1+R7 (RND12) || W[P0++P3]=R5.H; // Y2=Y2+Y5 st Y0
R2.L=R1-R7 (RND12) || W[P1++P4]=R5.L || R7=[I3++]; // Y5=Y2-Y5 st Y7
R5.H=R0-R3 (RND12) || W[P0++P3]=R2.H || R1.L=W[I1++]; // Y1=Y6-Y1 st Y2
R5.L=R0+R3 (RND12) || W[P1++P4]=R2.L || R0.H=W[I0++]; // Y6=Y6+Y1 st Y5
R3.H=R4-R6 (RND12) || W[P0++P3]=R5.H || R0.L=W[I2++]; // Y3=Y3-Y4 st Y1
R3.L=R4+R6 (RND12) || W[P1++P4]=R5.L || R1.H=W[I0++]; // Y4=Y3+Y4 st Y6
/* pipeline loop start, + drain Y3, Y4 */
A1=R7.H*R0.H, A0=R7.H*R0.H (IS) || W[P0++P2]= R3.H || R1.H = W[I0--];
.1: R3=(A1+=R7.H*R0.L), R2=(A0-=R7.H*R0.L) (IS) || W[P1++P5]= R3.L || R7 = [I3++];
I0 = B2; // I0 points to Input Element (0, 0)
I2 = B2; // I2 points to Input Element (0, 0)
I2 += M3 || R0.H = W[I0];
// Y0 is read in R0.H
I1 = I2; // I1 points to input Element (0, 6)
I1 += 4 || R0.L = W[I2++];
// I2 points to input Element (0, 4)
// Y4 is read in R0.L
P2 = 8 (X);
I3 = B3; // I3 points to Coefficients
P0 = B0; // P0 points to array Element (0, 0) for writing
// output
P1 = B0;
R7 = [I3++]; // R7.H = C4 and R7.L = C4
NOP;
/*
* A1 = Y0 * cos(pi/4)
* A0 = Y0 * cos(pi/4)
* A1 = A1 + Y4 * cos(pi/4)
* A0 = A0 - Y4 * cos(pi/4)
* load:
* R1=(Y2,Y6)
* R7=(C2,C6)
* res:
* R3=Y0, R2=Y4
*/
A1=R7.H*R0.H, A0=R7.H*R0.H (IS) || I0+=4 || R1.L=W[I1++];
R3=(A1+=R7.H*R0.L), R2=(A0-=R7.H*R0.L) (IS) || R1.H=W[I0--] || R7=[I3++];
LSETUP (.2, .3) LC0 = P2; // peform 8 1d idcts
P2 = 112 (X);
P1 = P1 + P2;
P2 = -94(X);
.2:
/*
* A1 = Y2 * cos(3pi/8)
* A0 = Y2 * cos(pi/8)
* A1 = A1 - Y6 * cos(pi/8)
* A0 = A0 + Y6 * cos(3pi/8)
* R5 = (Y1,Y7)
* R7 = (C1,C7)
* res:
* R1=Y2, R0=Y6
*/
A1=R7.L*R1.H, A0=R7.H*R1.H (IS) || I0+=4 || R5.H=W[I0];
R1=(A1-=R7.H*R1.L), R0=(A0+=R7.L*R1.L) (IS) || R5.L=W[I1--] || R7=[I3++];
/*
* Y0 = Y0 + Y6.
* Y4 = Y4 + Y2.
* Y2 = Y4 - Y2.
* Y6 = Y0 - Y6.
* R3 is saved
* R6.l=Y3
* note: R3: Y0, R2: Y4, R1: Y2, R0: Y6
*/
R3=R3+R0, R0=R3-R0;
R2=R2+R1, R1=R2-R1 || [TMP0]=R3 || R6.L=W[I0--];
/*
* Compute the odd portion (1,3,5,7) even is done.
*
* Y1 = C7 * Y1 - C1 * Y7 + C3 * Y5 - C5 * Y3.
* Y7 = C1 * Y1 + C7 * Y7 + C5 * Y5 + C3 * Y3.
* Y5 = C5 * Y1 + C3 * Y7 + C7 * Y5 - C1 * Y3.
* Y3 = C3 * Y1 - C5 * Y7 - C1 * Y5 - C7 * Y3.
*/
// R5=(Y1,Y7) R6=(Y5,Y3) // R7=(C1,C7)
A1 =R7.L*R5.H, A0 =R7.H*R5.H (IS) || [TMP1]=R2 || R6.H=W[I2--];
A1-=R7.H*R5.L, A0+=R7.L*R5.L (IS) || I0-=4 || R7=[I3++];
A1+=R7.H*R6.H, A0+=R7.L*R6.H (IS) || I0+=M1; // R7=(C3,C5)
R3 =(A1-=R7.L*R6.L), R2 =(A0+=R7.H*R6.L) (IS);
A1 =R7.L*R5.H, A0 =R7.H*R5.H (IS) || R4=[TMP0];
A1+=R7.H*R5.L, A0-=R7.L*R5.L (IS) || I1+=M1 || R7=[I3++]; // R7=(C1,C7)
A1+=R7.L*R6.H, A0-=R7.H*R6.H (IS);
R7 =(A1-=R7.H*R6.L), R6 =(A0-=R7.L*R6.L) (IS) || I2+=M1;
// R3=Y1, R2=Y7, R7=Y5, R6=Y3
/* Transpose write column. */
R5.H=R4+R2 (RND20); // Y0=Y0+Y7
R5.L=R4-R2 (RND20) || R4 = [TMP1]; // Y7=Y7-Y0
R5=R5>>>2(v);
R2.H=R1+R7 (RND20) || W[P0++P3]=R5.H; // Y2=Y2+Y5 st Y0
R2.L=R1-R7 (RND20) || W[P1++P4]=R5.L || R7=[I3++]; // Y5=Y2-Y5 st Y7
R2=R2>>>2(v);
R5.H=R0-R3 (RND20) || W[P0++P3]=R2.H || R1.L=W[I1++]; // Y1=Y6-Y1 st Y2
R5.L=R0+R3 (RND20) || W[P1++P4]=R2.L || R0.H=W[I0++]; // Y6=Y6+Y1 st Y5
R5=R5>>>2(v);
R3.H=R4-R6 (RND20) || W[P0++P3]=R5.H || R0.L=W[I2++]; // Y3=Y3-Y4 st Y1
R3.L=R4+R6 (RND20) || W[P1++P4]=R5.L || R1.H=W[I0++]; // Y4=Y3+Y4 st Y6
R3=R3>>>2(v);
/* pipeline loop start, + drain Y3, Y4 */
A1=R7.H*R0.H, A0=R7.H*R0.H (IS) || W[P0++P2]= R3.H || R1.H = W[I0--];
.3: R3=(A1+=R7.H*R0.L), R2=(A0-=R7.H*R0.L) (IS) || W[P1++P5]= R3.L || R7 = [I3++];
L3 = 0;
(R7:4,P5:3)=[SP++];
unlink;
RTS;
DEFUN_END(vp3_idct)
| {
"language": "Assembly"
} |
:mod:`binascii` --- Convert between binary and ASCII
====================================================
.. module:: binascii
:synopsis: Tools for converting between binary and various ASCII-encoded binary
representations.
.. index::
module: uu
module: base64
module: binhex
The :mod:`binascii` module contains a number of methods to convert between
binary and various ASCII-encoded binary representations. Normally, you will not
use these functions directly but use wrapper modules like :mod:`uu`,
:mod:`base64`, or :mod:`binhex` instead. The :mod:`binascii` module contains
low-level functions written in C for greater speed that are used by the
higher-level modules.
The :mod:`binascii` module defines the following functions:
.. function:: a2b_uu(string)
Convert a single line of uuencoded data back to binary and return the binary
data. Lines normally contain 45 (binary) bytes, except for the last line. Line
data may be followed by whitespace.
.. function:: b2a_uu(data)
Convert binary data to a line of ASCII characters, the return value is the
converted line, including a newline char. The length of *data* should be at most
45.
.. function:: a2b_base64(string)
Convert a block of base64 data back to binary and return the binary data. More
than one line may be passed at a time.
.. function:: b2a_base64(data)
Convert binary data to a line of ASCII characters in base64 coding. The return
value is the converted line, including a newline char. The length of *data*
should be at most 57 to adhere to the base64 standard.
.. function:: a2b_qp(string[, header])
Convert a block of quoted-printable data back to binary and return the binary
data. More than one line may be passed at a time. If the optional argument
*header* is present and true, underscores will be decoded as spaces.
.. function:: b2a_qp(data[, quotetabs, istext, header])
Convert binary data to a line(s) of ASCII characters in quoted-printable
encoding. The return value is the converted line(s). If the optional argument
*quotetabs* is present and true, all tabs and spaces will be encoded. If the
optional argument *istext* is present and true, newlines are not encoded but
trailing whitespace will be encoded. If the optional argument *header* is
present and true, spaces will be encoded as underscores per RFC1522. If the
optional argument *header* is present and false, newline characters will be
encoded as well; otherwise linefeed conversion might corrupt the binary data
stream.
.. function:: a2b_hqx(string)
Convert binhex4 formatted ASCII data to binary, without doing RLE-decompression.
The string should contain a complete number of binary bytes, or (in case of the
last portion of the binhex4 data) have the remaining bits zero.
.. function:: rledecode_hqx(data)
Perform RLE-decompression on the data, as per the binhex4 standard. The
algorithm uses ``0x90`` after a byte as a repeat indicator, followed by a count.
A count of ``0`` specifies a byte value of ``0x90``. The routine returns the
decompressed data, unless data input data ends in an orphaned repeat indicator,
in which case the :exc:`Incomplete` exception is raised.
.. function:: rlecode_hqx(data)
Perform binhex4 style RLE-compression on *data* and return the result.
.. function:: b2a_hqx(data)
Perform hexbin4 binary-to-ASCII translation and return the resulting string. The
argument should already be RLE-coded, and have a length divisible by 3 (except
possibly the last fragment).
.. function:: crc_hqx(data, crc)
Compute the binhex4 crc value of *data*, starting with an initial *crc* and
returning the result.
.. function:: crc32(data[, crc])
Compute CRC-32, the 32-bit checksum of data, starting with an initial crc. This
is consistent with the ZIP file checksum. Since the algorithm is designed for
use as a checksum algorithm, it is not suitable for use as a general hash
algorithm. Use as follows::
print binascii.crc32("hello world")
# Or, in two pieces:
crc = binascii.crc32("hello")
crc = binascii.crc32(" world", crc) & 0xffffffff
print 'crc32 = 0x%08x' % crc
.. note::
To generate the same numeric value across all Python versions and
platforms use crc32(data) & 0xffffffff. If you are only using
the checksum in packed binary format this is not necessary as the
return value is the correct 32bit binary representation
regardless of sign.
.. versionchanged:: 2.6
The return value is in the range [-2**31, 2**31-1]
regardless of platform. In the past the value would be signed on
some platforms and unsigned on others. Use & 0xffffffff on the
value if you want it to match Python 3 behavior.
.. versionchanged:: 3.0
The return value is unsigned and in the range [0, 2**32-1]
regardless of platform.
.. function:: b2a_hex(data)
hexlify(data)
Return the hexadecimal representation of the binary *data*. Every byte of
*data* is converted into the corresponding 2-digit hex representation. The
resulting string is therefore twice as long as the length of *data*.
.. function:: a2b_hex(hexstr)
unhexlify(hexstr)
Return the binary data represented by the hexadecimal string *hexstr*. This
function is the inverse of :func:`b2a_hex`. *hexstr* must contain an even number
of hexadecimal digits (which can be upper or lower case), otherwise a
:exc:`TypeError` is raised.
.. exception:: Error
Exception raised on errors. These are usually programming errors.
.. exception:: Incomplete
Exception raised on incomplete data. These are usually not programming errors,
but may be handled by reading a little more data and trying again.
.. seealso::
Module :mod:`base64`
Support for base64 encoding used in MIME email messages.
Module :mod:`binhex`
Support for the binhex format used on the Macintosh.
Module :mod:`uu`
Support for UU encoding used on Unix.
Module :mod:`quopri`
Support for quoted-printable encoding used in MIME email messages.
| {
"language": "Assembly"
} |
;*******************************************************************************
;* File Name : startup_stm32f746xx.s
;* Author : MCD Application Team
;* Description : STM32F746xx devices vector table for MDK-ARM toolchain.
;* This module performs:
;* - Set the initial SP
;* - Set the initial PC == Reset_Handler
;* - Set the vector table entries with the exceptions ISR address
;* - Branches to __main in the C library (which eventually
;* calls main()).
;* After Reset the CortexM7 processor is in Thread mode,
;* priority is Privileged, and the Stack is set to Main.
;*******************************************************************************
;* @attention
;*
;* <h2><center>© Copyright (c) 2016 STMicroelectronics.
;* All rights reserved.</center></h2>
;*
;* This software component is licensed by ST under BSD 3-Clause license,
;* the "License"; You may not use this file except in compliance with the
;* License. You may obtain a copy of the License at:
;* opensource.org/licenses/BSD-3-Clause
;*
;*******************************************************************************
;* <<< Use Configuration Wizard in Context Menu >>>
;
PRESERVE8
THUMB
; Vector Table Mapped to Address 0 at Reset
AREA RESET, DATA, READONLY
EXPORT __Vectors
EXPORT __Vectors_End
EXPORT __Vectors_Size
IMPORT |Image$$ARM_LIB_STACK$$ZI$$Limit|
__Vectors DCD |Image$$ARM_LIB_STACK$$ZI$$Limit| ; Top of Stack
DCD Reset_Handler ; Reset Handler
DCD NMI_Handler ; NMI Handler
DCD HardFault_Handler ; Hard Fault Handler
DCD MemManage_Handler ; MPU Fault Handler
DCD BusFault_Handler ; Bus Fault Handler
DCD UsageFault_Handler ; Usage Fault Handler
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD SVC_Handler ; SVCall Handler
DCD DebugMon_Handler ; Debug Monitor Handler
DCD 0 ; Reserved
DCD PendSV_Handler ; PendSV Handler
DCD SysTick_Handler ; SysTick Handler
; External Interrupts
DCD WWDG_IRQHandler ; Window WatchDog
DCD PVD_IRQHandler ; PVD through EXTI Line detection
DCD TAMP_STAMP_IRQHandler ; Tamper and TimeStamps through the EXTI line
DCD RTC_WKUP_IRQHandler ; RTC Wakeup through the EXTI line
DCD FLASH_IRQHandler ; FLASH
DCD RCC_IRQHandler ; RCC
DCD EXTI0_IRQHandler ; EXTI Line0
DCD EXTI1_IRQHandler ; EXTI Line1
DCD EXTI2_IRQHandler ; EXTI Line2
DCD EXTI3_IRQHandler ; EXTI Line3
DCD EXTI4_IRQHandler ; EXTI Line4
DCD DMA1_Stream0_IRQHandler ; DMA1 Stream 0
DCD DMA1_Stream1_IRQHandler ; DMA1 Stream 1
DCD DMA1_Stream2_IRQHandler ; DMA1 Stream 2
DCD DMA1_Stream3_IRQHandler ; DMA1 Stream 3
DCD DMA1_Stream4_IRQHandler ; DMA1 Stream 4
DCD DMA1_Stream5_IRQHandler ; DMA1 Stream 5
DCD DMA1_Stream6_IRQHandler ; DMA1 Stream 6
DCD ADC_IRQHandler ; ADC1, ADC2 and ADC3s
DCD CAN1_TX_IRQHandler ; CAN1 TX
DCD CAN1_RX0_IRQHandler ; CAN1 RX0
DCD CAN1_RX1_IRQHandler ; CAN1 RX1
DCD CAN1_SCE_IRQHandler ; CAN1 SCE
DCD EXTI9_5_IRQHandler ; External Line[9:5]s
DCD TIM1_BRK_TIM9_IRQHandler ; TIM1 Break and TIM9
DCD TIM1_UP_TIM10_IRQHandler ; TIM1 Update and TIM10
DCD TIM1_TRG_COM_TIM11_IRQHandler ; TIM1 Trigger and Commutation and TIM11
DCD TIM1_CC_IRQHandler ; TIM1 Capture Compare
DCD TIM2_IRQHandler ; TIM2
DCD TIM3_IRQHandler ; TIM3
DCD TIM4_IRQHandler ; TIM4
DCD I2C1_EV_IRQHandler ; I2C1 Event
DCD I2C1_ER_IRQHandler ; I2C1 Error
DCD I2C2_EV_IRQHandler ; I2C2 Event
DCD I2C2_ER_IRQHandler ; I2C2 Error
DCD SPI1_IRQHandler ; SPI1
DCD SPI2_IRQHandler ; SPI2
DCD USART1_IRQHandler ; USART1
DCD USART2_IRQHandler ; USART2
DCD USART3_IRQHandler ; USART3
DCD EXTI15_10_IRQHandler ; External Line[15:10]s
DCD RTC_Alarm_IRQHandler ; RTC Alarm (A and B) through EXTI Line
DCD OTG_FS_WKUP_IRQHandler ; USB OTG FS Wakeup through EXTI line
DCD TIM8_BRK_TIM12_IRQHandler ; TIM8 Break and TIM12
DCD TIM8_UP_TIM13_IRQHandler ; TIM8 Update and TIM13
DCD TIM8_TRG_COM_TIM14_IRQHandler ; TIM8 Trigger and Commutation and TIM14
DCD TIM8_CC_IRQHandler ; TIM8 Capture Compare
DCD DMA1_Stream7_IRQHandler ; DMA1 Stream7
DCD FMC_IRQHandler ; FMC
DCD SDMMC1_IRQHandler ; SDMMC1
DCD TIM5_IRQHandler ; TIM5
DCD SPI3_IRQHandler ; SPI3
DCD UART4_IRQHandler ; UART4
DCD UART5_IRQHandler ; UART5
DCD TIM6_DAC_IRQHandler ; TIM6 and DAC1&2 underrun errors
DCD TIM7_IRQHandler ; TIM7
DCD DMA2_Stream0_IRQHandler ; DMA2 Stream 0
DCD DMA2_Stream1_IRQHandler ; DMA2 Stream 1
DCD DMA2_Stream2_IRQHandler ; DMA2 Stream 2
DCD DMA2_Stream3_IRQHandler ; DMA2 Stream 3
DCD DMA2_Stream4_IRQHandler ; DMA2 Stream 4
DCD ETH_IRQHandler ; Ethernet
DCD ETH_WKUP_IRQHandler ; Ethernet Wakeup through EXTI line
DCD CAN2_TX_IRQHandler ; CAN2 TX
DCD CAN2_RX0_IRQHandler ; CAN2 RX0
DCD CAN2_RX1_IRQHandler ; CAN2 RX1
DCD CAN2_SCE_IRQHandler ; CAN2 SCE
DCD OTG_FS_IRQHandler ; USB OTG FS
DCD DMA2_Stream5_IRQHandler ; DMA2 Stream 5
DCD DMA2_Stream6_IRQHandler ; DMA2 Stream 6
DCD DMA2_Stream7_IRQHandler ; DMA2 Stream 7
DCD USART6_IRQHandler ; USART6
DCD I2C3_EV_IRQHandler ; I2C3 event
DCD I2C3_ER_IRQHandler ; I2C3 error
DCD OTG_HS_EP1_OUT_IRQHandler ; USB OTG HS End Point 1 Out
DCD OTG_HS_EP1_IN_IRQHandler ; USB OTG HS End Point 1 In
DCD OTG_HS_WKUP_IRQHandler ; USB OTG HS Wakeup through EXTI
DCD OTG_HS_IRQHandler ; USB OTG HS
DCD DCMI_IRQHandler ; DCMI
DCD 0 ; Reserved
DCD RNG_IRQHandler ; Rng
DCD FPU_IRQHandler ; FPU
DCD UART7_IRQHandler ; UART7
DCD UART8_IRQHandler ; UART8
DCD SPI4_IRQHandler ; SPI4
DCD SPI5_IRQHandler ; SPI5
DCD SPI6_IRQHandler ; SPI6
DCD SAI1_IRQHandler ; SAI1
DCD LTDC_IRQHandler ; LTDC
DCD LTDC_ER_IRQHandler ; LTDC error
DCD DMA2D_IRQHandler ; DMA2D
DCD SAI2_IRQHandler ; SAI2
DCD QUADSPI_IRQHandler ; QUADSPI
DCD LPTIM1_IRQHandler ; LPTIM1
DCD CEC_IRQHandler ; HDMI_CEC
DCD I2C4_EV_IRQHandler ; I2C4 Event
DCD I2C4_ER_IRQHandler ; I2C4 Error
DCD SPDIF_RX_IRQHandler ; SPDIF_RX
__Vectors_End
__Vectors_Size EQU __Vectors_End - __Vectors
AREA |.text|, CODE, READONLY
; Reset handler
Reset_Handler PROC
EXPORT Reset_Handler [WEAK]
IMPORT SystemInit
IMPORT __main
LDR R0, =SystemInit
BLX R0
LDR R0, =__main
BX R0
ENDP
; Dummy Exception Handlers (infinite loops which can be modified)
NMI_Handler PROC
EXPORT NMI_Handler [WEAK]
B .
ENDP
HardFault_Handler\
PROC
EXPORT HardFault_Handler [WEAK]
B .
ENDP
MemManage_Handler\
PROC
EXPORT MemManage_Handler [WEAK]
B .
ENDP
BusFault_Handler\
PROC
EXPORT BusFault_Handler [WEAK]
B .
ENDP
UsageFault_Handler\
PROC
EXPORT UsageFault_Handler [WEAK]
B .
ENDP
SVC_Handler PROC
EXPORT SVC_Handler [WEAK]
B .
ENDP
DebugMon_Handler\
PROC
EXPORT DebugMon_Handler [WEAK]
B .
ENDP
PendSV_Handler PROC
EXPORT PendSV_Handler [WEAK]
B .
ENDP
SysTick_Handler PROC
EXPORT SysTick_Handler [WEAK]
B .
ENDP
Default_Handler PROC
EXPORT WWDG_IRQHandler [WEAK]
EXPORT PVD_IRQHandler [WEAK]
EXPORT TAMP_STAMP_IRQHandler [WEAK]
EXPORT RTC_WKUP_IRQHandler [WEAK]
EXPORT FLASH_IRQHandler [WEAK]
EXPORT RCC_IRQHandler [WEAK]
EXPORT EXTI0_IRQHandler [WEAK]
EXPORT EXTI1_IRQHandler [WEAK]
EXPORT EXTI2_IRQHandler [WEAK]
EXPORT EXTI3_IRQHandler [WEAK]
EXPORT EXTI4_IRQHandler [WEAK]
EXPORT DMA1_Stream0_IRQHandler [WEAK]
EXPORT DMA1_Stream1_IRQHandler [WEAK]
EXPORT DMA1_Stream2_IRQHandler [WEAK]
EXPORT DMA1_Stream3_IRQHandler [WEAK]
EXPORT DMA1_Stream4_IRQHandler [WEAK]
EXPORT DMA1_Stream5_IRQHandler [WEAK]
EXPORT DMA1_Stream6_IRQHandler [WEAK]
EXPORT ADC_IRQHandler [WEAK]
EXPORT CAN1_TX_IRQHandler [WEAK]
EXPORT CAN1_RX0_IRQHandler [WEAK]
EXPORT CAN1_RX1_IRQHandler [WEAK]
EXPORT CAN1_SCE_IRQHandler [WEAK]
EXPORT EXTI9_5_IRQHandler [WEAK]
EXPORT TIM1_BRK_TIM9_IRQHandler [WEAK]
EXPORT TIM1_UP_TIM10_IRQHandler [WEAK]
EXPORT TIM1_TRG_COM_TIM11_IRQHandler [WEAK]
EXPORT TIM1_CC_IRQHandler [WEAK]
EXPORT TIM2_IRQHandler [WEAK]
EXPORT TIM3_IRQHandler [WEAK]
EXPORT TIM4_IRQHandler [WEAK]
EXPORT I2C1_EV_IRQHandler [WEAK]
EXPORT I2C1_ER_IRQHandler [WEAK]
EXPORT I2C2_EV_IRQHandler [WEAK]
EXPORT I2C2_ER_IRQHandler [WEAK]
EXPORT SPI1_IRQHandler [WEAK]
EXPORT SPI2_IRQHandler [WEAK]
EXPORT USART1_IRQHandler [WEAK]
EXPORT USART2_IRQHandler [WEAK]
EXPORT USART3_IRQHandler [WEAK]
EXPORT EXTI15_10_IRQHandler [WEAK]
EXPORT RTC_Alarm_IRQHandler [WEAK]
EXPORT OTG_FS_WKUP_IRQHandler [WEAK]
EXPORT TIM8_BRK_TIM12_IRQHandler [WEAK]
EXPORT TIM8_UP_TIM13_IRQHandler [WEAK]
EXPORT TIM8_TRG_COM_TIM14_IRQHandler [WEAK]
EXPORT TIM8_CC_IRQHandler [WEAK]
EXPORT DMA1_Stream7_IRQHandler [WEAK]
EXPORT FMC_IRQHandler [WEAK]
EXPORT SDMMC1_IRQHandler [WEAK]
EXPORT TIM5_IRQHandler [WEAK]
EXPORT SPI3_IRQHandler [WEAK]
EXPORT UART4_IRQHandler [WEAK]
EXPORT UART5_IRQHandler [WEAK]
EXPORT TIM6_DAC_IRQHandler [WEAK]
EXPORT TIM7_IRQHandler [WEAK]
EXPORT DMA2_Stream0_IRQHandler [WEAK]
EXPORT DMA2_Stream1_IRQHandler [WEAK]
EXPORT DMA2_Stream2_IRQHandler [WEAK]
EXPORT DMA2_Stream3_IRQHandler [WEAK]
EXPORT DMA2_Stream4_IRQHandler [WEAK]
EXPORT ETH_IRQHandler [WEAK]
EXPORT ETH_WKUP_IRQHandler [WEAK]
EXPORT CAN2_TX_IRQHandler [WEAK]
EXPORT CAN2_RX0_IRQHandler [WEAK]
EXPORT CAN2_RX1_IRQHandler [WEAK]
EXPORT CAN2_SCE_IRQHandler [WEAK]
EXPORT OTG_FS_IRQHandler [WEAK]
EXPORT DMA2_Stream5_IRQHandler [WEAK]
EXPORT DMA2_Stream6_IRQHandler [WEAK]
EXPORT DMA2_Stream7_IRQHandler [WEAK]
EXPORT USART6_IRQHandler [WEAK]
EXPORT I2C3_EV_IRQHandler [WEAK]
EXPORT I2C3_ER_IRQHandler [WEAK]
EXPORT OTG_HS_EP1_OUT_IRQHandler [WEAK]
EXPORT OTG_HS_EP1_IN_IRQHandler [WEAK]
EXPORT OTG_HS_WKUP_IRQHandler [WEAK]
EXPORT OTG_HS_IRQHandler [WEAK]
EXPORT DCMI_IRQHandler [WEAK]
EXPORT RNG_IRQHandler [WEAK]
EXPORT FPU_IRQHandler [WEAK]
EXPORT UART7_IRQHandler [WEAK]
EXPORT UART8_IRQHandler [WEAK]
EXPORT SPI4_IRQHandler [WEAK]
EXPORT SPI5_IRQHandler [WEAK]
EXPORT SPI6_IRQHandler [WEAK]
EXPORT SAI1_IRQHandler [WEAK]
EXPORT LTDC_IRQHandler [WEAK]
EXPORT LTDC_ER_IRQHandler [WEAK]
EXPORT DMA2D_IRQHandler [WEAK]
EXPORT SAI2_IRQHandler [WEAK]
EXPORT QUADSPI_IRQHandler [WEAK]
EXPORT LPTIM1_IRQHandler [WEAK]
EXPORT CEC_IRQHandler [WEAK]
EXPORT I2C4_EV_IRQHandler [WEAK]
EXPORT I2C4_ER_IRQHandler [WEAK]
EXPORT SPDIF_RX_IRQHandler [WEAK]
WWDG_IRQHandler
PVD_IRQHandler
TAMP_STAMP_IRQHandler
RTC_WKUP_IRQHandler
FLASH_IRQHandler
RCC_IRQHandler
EXTI0_IRQHandler
EXTI1_IRQHandler
EXTI2_IRQHandler
EXTI3_IRQHandler
EXTI4_IRQHandler
DMA1_Stream0_IRQHandler
DMA1_Stream1_IRQHandler
DMA1_Stream2_IRQHandler
DMA1_Stream3_IRQHandler
DMA1_Stream4_IRQHandler
DMA1_Stream5_IRQHandler
DMA1_Stream6_IRQHandler
ADC_IRQHandler
CAN1_TX_IRQHandler
CAN1_RX0_IRQHandler
CAN1_RX1_IRQHandler
CAN1_SCE_IRQHandler
EXTI9_5_IRQHandler
TIM1_BRK_TIM9_IRQHandler
TIM1_UP_TIM10_IRQHandler
TIM1_TRG_COM_TIM11_IRQHandler
TIM1_CC_IRQHandler
TIM2_IRQHandler
TIM3_IRQHandler
TIM4_IRQHandler
I2C1_EV_IRQHandler
I2C1_ER_IRQHandler
I2C2_EV_IRQHandler
I2C2_ER_IRQHandler
SPI1_IRQHandler
SPI2_IRQHandler
USART1_IRQHandler
USART2_IRQHandler
USART3_IRQHandler
EXTI15_10_IRQHandler
RTC_Alarm_IRQHandler
OTG_FS_WKUP_IRQHandler
TIM8_BRK_TIM12_IRQHandler
TIM8_UP_TIM13_IRQHandler
TIM8_TRG_COM_TIM14_IRQHandler
TIM8_CC_IRQHandler
DMA1_Stream7_IRQHandler
FMC_IRQHandler
SDMMC1_IRQHandler
TIM5_IRQHandler
SPI3_IRQHandler
UART4_IRQHandler
UART5_IRQHandler
TIM6_DAC_IRQHandler
TIM7_IRQHandler
DMA2_Stream0_IRQHandler
DMA2_Stream1_IRQHandler
DMA2_Stream2_IRQHandler
DMA2_Stream3_IRQHandler
DMA2_Stream4_IRQHandler
ETH_IRQHandler
ETH_WKUP_IRQHandler
CAN2_TX_IRQHandler
CAN2_RX0_IRQHandler
CAN2_RX1_IRQHandler
CAN2_SCE_IRQHandler
OTG_FS_IRQHandler
DMA2_Stream5_IRQHandler
DMA2_Stream6_IRQHandler
DMA2_Stream7_IRQHandler
USART6_IRQHandler
I2C3_EV_IRQHandler
I2C3_ER_IRQHandler
OTG_HS_EP1_OUT_IRQHandler
OTG_HS_EP1_IN_IRQHandler
OTG_HS_WKUP_IRQHandler
OTG_HS_IRQHandler
DCMI_IRQHandler
RNG_IRQHandler
FPU_IRQHandler
UART7_IRQHandler
UART8_IRQHandler
SPI4_IRQHandler
SPI5_IRQHandler
SPI6_IRQHandler
SAI1_IRQHandler
LTDC_IRQHandler
LTDC_ER_IRQHandler
DMA2D_IRQHandler
SAI2_IRQHandler
QUADSPI_IRQHandler
LPTIM1_IRQHandler
CEC_IRQHandler
I2C4_EV_IRQHandler
I2C4_ER_IRQHandler
SPDIF_RX_IRQHandler
B .
ENDP
ALIGN
;*******************************************************************************
; User Stack and Heap initialization
;*******************************************************************************
END
;************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE*****
| {
"language": "Assembly"
} |
dnl X86-64 mpn_lshift optimised for Intel Sandy Bridge.
dnl Copyright 2012 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')
ABI_SUPPORT(DOS64)
ABI_SUPPORT(STD64)
MULFUNC_PROLOGUE(mpn_lshift)
include_mpn(`x86_64/fastsse/lshift-movdqu2.asm')
| {
"language": "Assembly"
} |
// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin %s -o - | FileCheck %s
template<class X> class B {
public:
explicit B(X* p = 0);
};
class A
{
public:
A(int value) : m_a_value(value) {};
A(int value, A* client_A) : m_a_value (value), m_client_A (client_A) {}
virtual ~A() {}
private:
int m_a_value;
B<A> m_client_A;
};
int main(int argc, char **argv) {
A reallyA (500);
}
// CHECK: ![[CLASSTYPE:.*]] = {{.*}}, metadata !"_ZTS1A"} ; [ DW_TAG_class_type ] [A]
// CHECK: ![[ARTARG:.*]] = {{.*}} ; [ DW_TAG_pointer_type ] [line 0, size 64, align 64, offset 0] [artificial] [from _ZTS1A]
// CHECK: metadata !"_ZTS1A", {{.*}} ; [ DW_TAG_subprogram ] [line 12] [A]
// CHECK: metadata [[FUNCTYPE:![0-9]*]], i32 0, null, null, null} ; [ DW_TAG_subroutine_type ]
// CHECK: [[FUNCTYPE]] = metadata !{null, metadata ![[ARTARG]], metadata !{{.*}}, metadata !{{.*}}}
| {
"language": "Assembly"
} |
/*
* Copyright (c) 2000, 2003, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* FUNCTION
* Internal functions for mlib_ImageConv* on U8 type
* and MLIB_EDGE_DST_NO_WRITE mask
*
*/
/***************************************************************/
#include <vis_proto.h>
#include <mlib_image.h>
#include <mlib_ImageCheck.h>
#include <mlib_ImageColormap.h>
/*
This defines switches between functions in
files: mlib_v_ImageConv_8nw.c,
mlib_v_ImageConvIndex3_8_16nw.c,
mlib_v_ImageConvIndex4_8_16nw.c,
mlib_v_ImageConvIndex3_8_16nw.c,
mlib_v_ImageConvIndex4_8_16nw.c
*/
#define CONV_INDEX
#define DTYPE mlib_s16
#define LTYPE mlib_u8
/***************************************************************/
#ifdef CONV_INDEX
#define CONV_FUNC(KERN) \
mlib_conv##KERN##_Index3_8_16nw(mlib_image *dst, \
mlib_image *src, \
mlib_s32 *kern, \
mlib_s32 scale, \
void *colormap)
#else
#define CONV_FUNC(KERN) \
mlib_conv##KERN##_8nw_f(mlib_image *dst, \
mlib_image *src, \
mlib_s32 *kern, \
mlib_s32 scale)
#endif
/***************************************************************/
#ifdef CONV_INDEX
#define NCHAN 3
#else
#define NCHAN nchan
#endif
/***************************************************************/
#define DEF_VARS \
DTYPE *sl, *sp, *dl; \
mlib_s32 hgt = mlib_ImageGetHeight(src); \
mlib_s32 wid = mlib_ImageGetWidth(src); \
mlib_s32 sll = mlib_ImageGetStride(src) / sizeof(DTYPE); \
mlib_s32 dll = mlib_ImageGetStride(dst) / sizeof(DTYPE); \
DTYPE *adr_src = (DTYPE *)mlib_ImageGetData(src); \
DTYPE *adr_dst = (DTYPE *)mlib_ImageGetData(dst); \
mlib_s32 ssize, xsize, dsize, esize, emask, buff_ind = 0; \
mlib_d64 *pbuff, *dp; \
mlib_f32 *karr = (mlib_f32 *)kern; \
mlib_s32 gsr_scale = (31 - scale) << 3; \
mlib_d64 drnd = vis_to_double_dup(mlib_round_8[31 - scale]); \
mlib_s32 i, j, l
/***************************************************************/
#ifdef CONV_INDEX
#define DEF_EXTRA_VARS \
int offset = mlib_ImageGetLutOffset(colormap); \
LTYPE **lut_table = (LTYPE**)mlib_ImageGetLutData(colormap); \
LTYPE *ltbl0 = lut_table[0] - offset; \
LTYPE *ltbl1 = lut_table[1] - offset; \
LTYPE *ltbl2 = lut_table[2] - offset; \
LTYPE *ltbl3 = (NCHAN > 3) ? lut_table[3] - offset : ltbl2
#else
#define DEF_EXTRA_VARS \
mlib_s32 nchan = mlib_ImageGetChannels(dst)
#endif
/***************************************************************/
#if NCHAN == 3
#define LOAD_SRC() { \
mlib_s32 s0 = sp[0], s1 = sp[1], s2 = sp[2], s3 = sp[3]; \
mlib_s32 s4 = sp[4], s5 = sp[5], s6 = sp[6], s7 = sp[7]; \
mlib_d64 t0, t1, t2; \
\
t2 = vis_faligndata(vis_ld_u8_i(ltbl2, s7), t2); \
t2 = vis_faligndata(vis_ld_u8_i(ltbl1, s7), t2); \
t2 = vis_faligndata(vis_ld_u8_i(ltbl0, s7), t2); \
t2 = vis_faligndata(vis_ld_u8_i(ltbl2, s6), t2); \
t2 = vis_faligndata(vis_ld_u8_i(ltbl1, s6), t2); \
t2 = vis_faligndata(vis_ld_u8_i(ltbl0, s6), t2); \
t2 = vis_faligndata(vis_ld_u8_i(ltbl2, s5), t2); \
t2 = vis_faligndata(vis_ld_u8_i(ltbl1, s5), t2); \
t1 = vis_faligndata(vis_ld_u8_i(ltbl0, s5), t1); \
t1 = vis_faligndata(vis_ld_u8_i(ltbl2, s4), t1); \
t1 = vis_faligndata(vis_ld_u8_i(ltbl1, s4), t1); \
t1 = vis_faligndata(vis_ld_u8_i(ltbl0, s4), t1); \
t1 = vis_faligndata(vis_ld_u8_i(ltbl2, s3), t1); \
t1 = vis_faligndata(vis_ld_u8_i(ltbl1, s3), t1); \
t1 = vis_faligndata(vis_ld_u8_i(ltbl0, s3), t1); \
t1 = vis_faligndata(vis_ld_u8_i(ltbl2, s2), t1); \
t0 = vis_faligndata(vis_ld_u8_i(ltbl1, s2), t0); \
t0 = vis_faligndata(vis_ld_u8_i(ltbl0, s2), t0); \
t0 = vis_faligndata(vis_ld_u8_i(ltbl2, s1), t0); \
t0 = vis_faligndata(vis_ld_u8_i(ltbl1, s1), t0); \
t0 = vis_faligndata(vis_ld_u8_i(ltbl0, s1), t0); \
t0 = vis_faligndata(vis_ld_u8_i(ltbl2, s0), t0); \
t0 = vis_faligndata(vis_ld_u8_i(ltbl1, s0), t0); \
t0 = vis_faligndata(vis_ld_u8_i(ltbl0, s0), t0); \
\
buffn[i] = t0; \
buffn[i + 1] = t1; \
buffn[i + 2] = t2; \
\
sp += 8; \
}
#else
#define LOAD_SRC() { \
mlib_s32 s0 = sp[0], s1 = sp[1], s2 = sp[2], s3 = sp[3]; \
mlib_s32 s4 = sp[4], s5 = sp[5], s6 = sp[6], s7 = sp[7]; \
mlib_d64 t0, t1, t2; \
\
t2 = vis_faligndata(vis_ld_u8_i(ltbl3, s5), t2); \
t2 = vis_faligndata(vis_ld_u8_i(ltbl2, s5), t2); \
t2 = vis_faligndata(vis_ld_u8_i(ltbl1, s5), t2); \
t2 = vis_faligndata(vis_ld_u8_i(ltbl0, s5), t2); \
t2 = vis_faligndata(vis_ld_u8_i(ltbl3, s4), t2); \
t2 = vis_faligndata(vis_ld_u8_i(ltbl2, s4), t2); \
t2 = vis_faligndata(vis_ld_u8_i(ltbl1, s4), t2); \
t2 = vis_faligndata(vis_ld_u8_i(ltbl0, s4), t2); \
t1 = vis_faligndata(vis_ld_u8_i(ltbl3, s3), t1); \
t1 = vis_faligndata(vis_ld_u8_i(ltbl2, s3), t1); \
t1 = vis_faligndata(vis_ld_u8_i(ltbl1, s3), t1); \
t1 = vis_faligndata(vis_ld_u8_i(ltbl0, s3), t1); \
t1 = vis_faligndata(vis_ld_u8_i(ltbl3, s2), t1); \
t1 = vis_faligndata(vis_ld_u8_i(ltbl2, s2), t1); \
t1 = vis_faligndata(vis_ld_u8_i(ltbl1, s2), t1); \
t1 = vis_faligndata(vis_ld_u8_i(ltbl0, s2), t1); \
t0 = vis_faligndata(vis_ld_u8_i(ltbl3, s1), t0); \
t0 = vis_faligndata(vis_ld_u8_i(ltbl2, s1), t0); \
t0 = vis_faligndata(vis_ld_u8_i(ltbl1, s1), t0); \
t0 = vis_faligndata(vis_ld_u8_i(ltbl0, s1), t0); \
t0 = vis_faligndata(vis_ld_u8_i(ltbl3, s0), t0); \
t0 = vis_faligndata(vis_ld_u8_i(ltbl2, s0), t0); \
t0 = vis_faligndata(vis_ld_u8_i(ltbl1, s0), t0); \
t0 = vis_faligndata(vis_ld_u8_i(ltbl0, s0), t0); \
\
buffn[i] = t0; \
buffn[i + 1] = t1; \
buffn[i + 2] = t2; \
\
sp += 6; \
}
#endif
/***************************************************************/
static mlib_s32 mlib_round_8[16] = { 0x00400040, 0x00200020, 0x00100010, 0x00080008,
0x00040004, 0x00020002, 0x00010001, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000 };
/***************************************************************/
void mlib_ImageCopy_na(mlib_u8 *sa, mlib_u8 *da, int size);
/***************************************************************/
#define KSIZE 2
mlib_status CONV_FUNC(2x2)
{
mlib_d64 *buffs[2*(KSIZE + 1)];
mlib_d64 *buff0, *buff1, *buffn, *buffd, *buffe;
mlib_d64 s00, s01, s10, s11, s0, s1;
mlib_d64 d0, d1, d00, d01, d10, d11;
DEF_VARS;
DEF_EXTRA_VARS;
sl = adr_src;
dl = adr_dst;
ssize = NCHAN*wid;
dsize = (ssize + 7)/8;
esize = dsize + 4;
pbuff = mlib_malloc((KSIZE + 4)*esize*sizeof(mlib_d64));
if (pbuff == NULL) return MLIB_FAILURE;
for (i = 0; i < (KSIZE + 1); i++) buffs[i] = pbuff + i*esize;
for (i = 0; i < (KSIZE + 1); i++) buffs[(KSIZE + 1) + i] = buffs[i];
buffd = buffs[KSIZE] + esize;
buffe = buffd + 2*esize;
wid -= (KSIZE - 1);
hgt -= (KSIZE - 1);
xsize = ssize - NCHAN*(KSIZE - 1);
emask = (0xFF00 >> (xsize & 7)) & 0xFF;
vis_write_gsr(gsr_scale + 7);
for (l = 0; l < KSIZE; l++) {
mlib_d64 *buffn = buffs[l];
sp = sl + l*sll;
#ifndef CONV_INDEX
if ((mlib_addr)sp & 7) mlib_ImageCopy_na((void*)sp, (void*)buffn, ssize);
#else
#pragma pipeloop(0)
for (i = 0; i < dsize; i += 3) {
LOAD_SRC();
}
#endif /* CONV_INDEX */
}
for (j = 0; j < hgt; j++) {
mlib_d64 **buffc = buffs + buff_ind;
mlib_f32 *pk = karr, k0, k1;
sp = sl + KSIZE*sll;
buff0 = buffc[0];
buff1 = buffc[1];
buffn = buffc[KSIZE];
#ifndef CONV_INDEX
if ((((mlib_addr)(sl )) & 7) == 0) buff0 = (mlib_d64*)sl;
if ((((mlib_addr)(sl + sll)) & 7) == 0) buff1 = (mlib_d64*)(sl + sll);
if ((mlib_addr)sp & 7) mlib_ImageCopy_na((void*)sp, (void*)buffn, ssize);
#endif
k0 = pk[1];
k1 = pk[3];
vis_write_gsr(gsr_scale + NCHAN);
s01 = buff0[0];
s11 = buff1[0];
#pragma pipeloop(0)
for (i = 0; i < (xsize + 7)/8; i++) {
s00 = s01;
s10 = s11;
s01 = buff0[i + 1];
s11 = buff1[i + 1];
s0 = vis_faligndata(s00, s01);
s1 = vis_faligndata(s10, s11);
d00 = vis_fmul8x16au(vis_read_hi(s0), k0);
d01 = vis_fmul8x16au(vis_read_lo(s0), k0);
d10 = vis_fmul8x16au(vis_read_hi(s1), k1);
d11 = vis_fmul8x16au(vis_read_lo(s1), k1);
d0 = vis_fpadd16(d00, d10);
d1 = vis_fpadd16(d01, d11);
buffd[2*i] = d0;
buffd[2*i + 1] = d1;
}
k0 = pk[0];
k1 = pk[2];
#ifndef CONV_INDEX
dp = ((mlib_addr)dl & 7) ? buffe : (mlib_d64*)dl;
#pragma pipeloop(0)
for (i = 0; i < xsize/8; i++) {
s0 = buff0[i];
s1 = buff1[i];
d00 = vis_fmul8x16au(vis_read_hi(s0), k0);
d01 = vis_fmul8x16au(vis_read_lo(s0), k0);
d10 = vis_fmul8x16au(vis_read_hi(s1), k1);
d11 = vis_fmul8x16au(vis_read_lo(s1), k1);
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
d00 = vis_fpadd16(d00, d10);
d0 = vis_fpadd16(d0, drnd);
d0 = vis_fpadd16(d0, d00);
d01 = vis_fpadd16(d01, d11);
d1 = vis_fpadd16(d1, drnd);
d1 = vis_fpadd16(d1, d01);
dp[i] = vis_fpack16_pair(d0, d1);
}
if (emask) {
s0 = buff0[i];
s1 = buff1[i];
d00 = vis_fmul8x16au(vis_read_hi(s0), k0);
d01 = vis_fmul8x16au(vis_read_lo(s0), k0);
d10 = vis_fmul8x16au(vis_read_hi(s1), k1);
d11 = vis_fmul8x16au(vis_read_lo(s1), k1);
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
d00 = vis_fpadd16(d00, d10);
d0 = vis_fpadd16(d0, drnd);
d0 = vis_fpadd16(d0, d00);
d01 = vis_fpadd16(d01, d11);
d1 = vis_fpadd16(d1, drnd);
d1 = vis_fpadd16(d1, d01);
d0 = vis_fpack16_pair(d0, d1);
vis_pst_8(d0, dp + i, emask);
}
if ((mlib_u8*)dp != dl) mlib_ImageCopy_na((void*)buffe, dl, xsize);
#else
vis_write_gsr(gsr_scale + 7);
#pragma pipeloop(0)
for (i = 0; i < dsize; i += 3) {
mlib_d64 d00, d01, d02, d03, d04, d05;
mlib_d64 d10, d11, d12, d13, d14, d15;
mlib_d64 d0, d1, d2, d3, d4, d5;
mlib_d64 s00 = buff0[i];
mlib_d64 s01 = buff0[i + 1];
mlib_d64 s02 = buff0[i + 2];
mlib_d64 s10 = buff1[i];
mlib_d64 s11 = buff1[i + 1];
mlib_d64 s12 = buff1[i + 2];
d00 = vis_fmul8x16au(vis_read_hi(s00), k0);
d01 = vis_fmul8x16au(vis_read_lo(s00), k0);
d02 = vis_fmul8x16au(vis_read_hi(s01), k0);
d03 = vis_fmul8x16au(vis_read_lo(s01), k0);
d04 = vis_fmul8x16au(vis_read_hi(s02), k0);
d05 = vis_fmul8x16au(vis_read_lo(s02), k0);
d10 = vis_fmul8x16au(vis_read_hi(s10), k1);
d11 = vis_fmul8x16au(vis_read_lo(s10), k1);
d12 = vis_fmul8x16au(vis_read_hi(s11), k1);
d13 = vis_fmul8x16au(vis_read_lo(s11), k1);
d14 = vis_fmul8x16au(vis_read_hi(s12), k1);
d15 = vis_fmul8x16au(vis_read_lo(s12), k1);
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
d2 = buffd[2*i + 2];
d3 = buffd[2*i + 3];
d4 = buffd[2*i + 4];
d5 = buffd[2*i + 5];
d00 = vis_fpadd16(d00, d10);
d0 = vis_fpadd16(d0, drnd);
d0 = vis_fpadd16(d0, d00);
d01 = vis_fpadd16(d01, d11);
d1 = vis_fpadd16(d1, drnd);
d1 = vis_fpadd16(d1, d01);
d02 = vis_fpadd16(d02, d12);
d2 = vis_fpadd16(d2, drnd);
d2 = vis_fpadd16(d2, d02);
d03 = vis_fpadd16(d03, d13);
d3 = vis_fpadd16(d3, drnd);
d3 = vis_fpadd16(d3, d03);
d04 = vis_fpadd16(d04, d14);
d4 = vis_fpadd16(d4, drnd);
d4 = vis_fpadd16(d4, d04);
d05 = vis_fpadd16(d05, d15);
d5 = vis_fpadd16(d5, drnd);
d5 = vis_fpadd16(d5, d05);
buffe[i ] = vis_fpack16_pair(d0, d1);
buffe[i + 1] = vis_fpack16_pair(d2, d3);
buffe[i + 2] = vis_fpack16_pair(d4, d5);
LOAD_SRC();
}
mlib_ImageColorTrue2IndexLine_U8_S16_3((void*)buffe, dl, wid, colormap);
#endif /* CONV_INDEX */
sl += sll;
dl += dll;
buff_ind++;
if (buff_ind >= (KSIZE + 1)) buff_ind = 0;
}
mlib_free(pbuff);
return MLIB_SUCCESS;
}
/***************************************************************/
#undef KSIZE
#define KSIZE 3
mlib_status CONV_FUNC(3x3)
{
mlib_d64 *buffs[2*(KSIZE + 1)];
mlib_d64 *buff0, *buff1, *buff2, *buffn, *buffd, *buffe;
mlib_d64 s00, s01, s10, s11, s20, s21, s0, s1, s2;
mlib_d64 dd, d0, d1, d00, d01, d10, d11, d20, d21;
mlib_s32 ik, ik_last, off, doff;
DEF_VARS;
DEF_EXTRA_VARS;
sl = adr_src;
#ifdef CONV_INDEX
dl = adr_dst + ((KSIZE - 1)/2)*(dll + 1);
#else
dl = adr_dst + ((KSIZE - 1)/2)*(dll + NCHAN);
#endif
ssize = NCHAN*wid;
dsize = (ssize + 7)/8;
esize = dsize + 4;
pbuff = mlib_malloc((KSIZE + 4)*esize*sizeof(mlib_d64));
if (pbuff == NULL) return MLIB_FAILURE;
for (i = 0; i < (KSIZE + 1); i++) buffs[i] = pbuff + i*esize;
for (i = 0; i < (KSIZE + 1); i++) buffs[(KSIZE + 1) + i] = buffs[i];
buffd = buffs[KSIZE] + esize;
buffe = buffd + 2*esize;
wid -= (KSIZE - 1);
hgt -= (KSIZE - 1);
xsize = ssize - NCHAN*(KSIZE - 1);
emask = (0xFF00 >> (xsize & 7)) & 0xFF;
vis_write_gsr(gsr_scale + 7);
for (l = 0; l < KSIZE; l++) {
mlib_d64 *buffn = buffs[l];
sp = sl + l*sll;
#ifndef CONV_INDEX
if ((mlib_addr)sp & 7) mlib_ImageCopy_na((void*)sp, (void*)buffn, ssize);
#else
#pragma pipeloop(0)
for (i = 0; i < dsize; i += 3) {
LOAD_SRC();
}
#endif /* CONV_INDEX */
}
/* init buffer */
#pragma pipeloop(0)
for (i = 0; i < (xsize + 7)/8; i++) {
buffd[2*i ] = drnd;
buffd[2*i + 1] = drnd;
}
for (j = 0; j < hgt; j++) {
mlib_d64 **buffc = buffs + buff_ind, *pbuff0, *pbuff1, *pbuff2;
mlib_f32 *pk = karr, k0, k1, k2;
sp = sl + KSIZE*sll;
pbuff0 = buffc[0];
pbuff1 = buffc[1];
pbuff2 = buffc[2];
buffn = buffc[KSIZE];
#ifndef CONV_INDEX
if ((((mlib_addr)(sl )) & 7) == 0) pbuff0 = (mlib_d64*)sl;
if ((((mlib_addr)(sl + sll)) & 7) == 0) pbuff1 = (mlib_d64*)(sl + sll);
if ((((mlib_addr)(sl + 2*sll)) & 7) == 0) pbuff2 = (mlib_d64*)(sl + 2*sll);
if ((mlib_addr)sp & 7) mlib_ImageCopy_na((void*)sp, (void*)buffn, ssize);
#endif
#ifdef CONV_INDEX
ik_last = 0;
#else
ik_last = (KSIZE - 1);
#endif
for (ik = 0; ik < KSIZE; ik++) {
k0 = pk[ik];
k1 = pk[ik + KSIZE];
k2 = pk[ik + 2*KSIZE];
off = ik*NCHAN;
doff = off/8;
off &= 7;
buff0 = pbuff0 + doff;
buff1 = pbuff1 + doff;
buff2 = pbuff2 + doff;
vis_write_gsr(gsr_scale + off);
if (ik == ik_last) continue;
/*if (!ik_last) {
if ((off & 3) || (ik == (KSIZE - 1))) {
ik_last = ik;
continue;
}
}*/
if (off == 0) {
#pragma pipeloop(0)
for (i = 0; i < (xsize + 7)/8; i++) {
s0 = buff0[i];
s1 = buff1[i];
s2 = buff2[i];
d00 = vis_fmul8x16au(vis_read_hi(s0), k0);
d01 = vis_fmul8x16au(vis_read_lo(s0), k0);
d10 = vis_fmul8x16au(vis_read_hi(s1), k1);
d11 = vis_fmul8x16au(vis_read_lo(s1), k1);
d20 = vis_fmul8x16au(vis_read_hi(s2), k2);
d21 = vis_fmul8x16au(vis_read_lo(s2), k2);
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
d0 = vis_fpadd16(d00, d0);
d0 = vis_fpadd16(d10, d0);
d0 = vis_fpadd16(d20, d0);
d1 = vis_fpadd16(d01, d1);
d1 = vis_fpadd16(d11, d1);
d1 = vis_fpadd16(d21, d1);
buffd[2*i] = d0;
buffd[2*i + 1] = d1;
}
} else if (off == 4) {
s01 = buff0[0];
s11 = buff1[0];
s21 = buff2[0];
#pragma pipeloop(0)
for (i = 0; i < (xsize + 7)/8; i++) {
s00 = s01;
s10 = s11;
s20 = s21;
s01 = buff0[i + 1];
s11 = buff1[i + 1];
s21 = buff2[i + 1];
d00 = vis_fmul8x16au(vis_read_lo(s00), k0);
d01 = vis_fmul8x16au(vis_read_hi(s01), k0);
d10 = vis_fmul8x16au(vis_read_lo(s10), k1);
d11 = vis_fmul8x16au(vis_read_hi(s11), k1);
d20 = vis_fmul8x16au(vis_read_lo(s20), k2);
d21 = vis_fmul8x16au(vis_read_hi(s21), k2);
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
d0 = vis_fpadd16(d00, d0);
d0 = vis_fpadd16(d10, d0);
d0 = vis_fpadd16(d20, d0);
d1 = vis_fpadd16(d01, d1);
d1 = vis_fpadd16(d11, d1);
d1 = vis_fpadd16(d21, d1);
buffd[2*i] = d0;
buffd[2*i + 1] = d1;
}
} else {
s01 = buff0[0];
s11 = buff1[0];
s21 = buff2[0];
#pragma pipeloop(0)
for (i = 0; i < (xsize + 7)/8; i++) {
s00 = s01;
s10 = s11;
s20 = s21;
s01 = buff0[i + 1];
s11 = buff1[i + 1];
s21 = buff2[i + 1];
s0 = vis_faligndata(s00, s01);
s1 = vis_faligndata(s10, s11);
s2 = vis_faligndata(s20, s21);
d00 = vis_fmul8x16au(vis_read_hi(s0), k0);
d01 = vis_fmul8x16au(vis_read_lo(s0), k0);
d10 = vis_fmul8x16au(vis_read_hi(s1), k1);
d11 = vis_fmul8x16au(vis_read_lo(s1), k1);
d20 = vis_fmul8x16au(vis_read_hi(s2), k2);
d21 = vis_fmul8x16au(vis_read_lo(s2), k2);
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
d0 = vis_fpadd16(d00, d0);
d0 = vis_fpadd16(d10, d0);
d0 = vis_fpadd16(d20, d0);
d1 = vis_fpadd16(d01, d1);
d1 = vis_fpadd16(d11, d1);
d1 = vis_fpadd16(d21, d1);
buffd[2*i] = d0;
buffd[2*i + 1] = d1;
}
}
}
k0 = pk[ik_last];
k1 = pk[ik_last + KSIZE];
k2 = pk[ik_last + 2*KSIZE];
off = ik_last*NCHAN;
doff = off/8;
off &= 7;
buff0 = pbuff0 + doff;
buff1 = pbuff1 + doff;
buff2 = pbuff2 + doff;
vis_write_gsr(gsr_scale + off);
#ifndef CONV_INDEX
dp = ((mlib_addr)dl & 7) ? buffe : (mlib_d64*)dl;
s01 = buff0[0];
s11 = buff1[0];
s21 = buff2[0];
#pragma pipeloop(0)
for (i = 0; i < xsize/8; i++) {
s00 = s01;
s10 = s11;
s20 = s21;
s01 = buff0[i + 1];
s11 = buff1[i + 1];
s21 = buff2[i + 1];
s0 = vis_faligndata(s00, s01);
s1 = vis_faligndata(s10, s11);
s2 = vis_faligndata(s20, s21);
d00 = vis_fmul8x16au(vis_read_hi(s0), k0);
d01 = vis_fmul8x16au(vis_read_lo(s0), k0);
d10 = vis_fmul8x16au(vis_read_hi(s1), k1);
d11 = vis_fmul8x16au(vis_read_lo(s1), k1);
d20 = vis_fmul8x16au(vis_read_hi(s2), k2);
d21 = vis_fmul8x16au(vis_read_lo(s2), k2);
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
d0 = vis_fpadd16(d0, d00);
d0 = vis_fpadd16(d0, d10);
d0 = vis_fpadd16(d0, d20);
d1 = vis_fpadd16(d1, d01);
d1 = vis_fpadd16(d1, d11);
d1 = vis_fpadd16(d1, d21);
dd = vis_fpack16_pair(d0, d1);
dp[i] = dd;
buffd[2*i ] = drnd;
buffd[2*i + 1] = drnd;
}
if (emask) {
s00 = s01;
s10 = s11;
s20 = s21;
s01 = buff0[i + 1];
s11 = buff1[i + 1];
s21 = buff2[i + 1];
s0 = vis_faligndata(s00, s01);
s1 = vis_faligndata(s10, s11);
s2 = vis_faligndata(s20, s21);
d00 = vis_fmul8x16au(vis_read_hi(s0), k0);
d01 = vis_fmul8x16au(vis_read_lo(s0), k0);
d10 = vis_fmul8x16au(vis_read_hi(s1), k1);
d11 = vis_fmul8x16au(vis_read_lo(s1), k1);
d20 = vis_fmul8x16au(vis_read_hi(s2), k2);
d21 = vis_fmul8x16au(vis_read_lo(s2), k2);
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
d0 = vis_fpadd16(d0, d00);
d0 = vis_fpadd16(d0, d10);
d0 = vis_fpadd16(d0, d20);
d1 = vis_fpadd16(d1, d01);
d1 = vis_fpadd16(d1, d11);
d1 = vis_fpadd16(d1, d21);
dd = vis_fpack16_pair(d0, d1);
vis_pst_8(dd, dp + i, emask);
buffd[2*i ] = drnd;
buffd[2*i + 1] = drnd;
}
if ((mlib_u8*)dp != dl) mlib_ImageCopy_na((void*)buffe, dl, xsize);
#else
vis_write_gsr(gsr_scale + 7);
#pragma pipeloop(0)
for (i = 0; i < dsize; i += 3) {
mlib_d64 d00, d01, d02, d03, d04, d05;
mlib_d64 d10, d11, d12, d13, d14, d15;
mlib_d64 d20, d21, d22, d23, d24, d25;
mlib_d64 d0, d1, d2, d3, d4, d5;
mlib_d64 s00 = buff0[i];
mlib_d64 s01 = buff0[i + 1];
mlib_d64 s02 = buff0[i + 2];
mlib_d64 s10 = buff1[i];
mlib_d64 s11 = buff1[i + 1];
mlib_d64 s12 = buff1[i + 2];
mlib_d64 s20 = buff2[i];
mlib_d64 s21 = buff2[i + 1];
mlib_d64 s22 = buff2[i + 2];
d00 = vis_fmul8x16au(vis_read_hi(s00), k0);
d01 = vis_fmul8x16au(vis_read_lo(s00), k0);
d02 = vis_fmul8x16au(vis_read_hi(s01), k0);
d03 = vis_fmul8x16au(vis_read_lo(s01), k0);
d04 = vis_fmul8x16au(vis_read_hi(s02), k0);
d05 = vis_fmul8x16au(vis_read_lo(s02), k0);
d10 = vis_fmul8x16au(vis_read_hi(s10), k1);
d11 = vis_fmul8x16au(vis_read_lo(s10), k1);
d12 = vis_fmul8x16au(vis_read_hi(s11), k1);
d13 = vis_fmul8x16au(vis_read_lo(s11), k1);
d14 = vis_fmul8x16au(vis_read_hi(s12), k1);
d15 = vis_fmul8x16au(vis_read_lo(s12), k1);
d20 = vis_fmul8x16au(vis_read_hi(s20), k2);
d21 = vis_fmul8x16au(vis_read_lo(s20), k2);
d22 = vis_fmul8x16au(vis_read_hi(s21), k2);
d23 = vis_fmul8x16au(vis_read_lo(s21), k2);
d24 = vis_fmul8x16au(vis_read_hi(s22), k2);
d25 = vis_fmul8x16au(vis_read_lo(s22), k2);
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
d2 = buffd[2*i + 2];
d3 = buffd[2*i + 3];
d4 = buffd[2*i + 4];
d5 = buffd[2*i + 5];
d0 = vis_fpadd16(d0, d00);
d0 = vis_fpadd16(d0, d10);
d0 = vis_fpadd16(d0, d20);
d1 = vis_fpadd16(d1, d01);
d1 = vis_fpadd16(d1, d11);
d1 = vis_fpadd16(d1, d21);
d2 = vis_fpadd16(d2, d02);
d2 = vis_fpadd16(d2, d12);
d2 = vis_fpadd16(d2, d22);
d3 = vis_fpadd16(d3, d03);
d3 = vis_fpadd16(d3, d13);
d3 = vis_fpadd16(d3, d23);
d4 = vis_fpadd16(d4, d04);
d4 = vis_fpadd16(d4, d14);
d4 = vis_fpadd16(d4, d24);
d5 = vis_fpadd16(d5, d05);
d5 = vis_fpadd16(d5, d15);
d5 = vis_fpadd16(d5, d25);
buffe[i ] = vis_fpack16_pair(d0, d1);
buffe[i + 1] = vis_fpack16_pair(d2, d3);
buffe[i + 2] = vis_fpack16_pair(d4, d5);
buffd[2*i ] = drnd;
buffd[2*i + 1] = drnd;
buffd[2*i + 2] = drnd;
buffd[2*i + 3] = drnd;
buffd[2*i + 4] = drnd;
buffd[2*i + 5] = drnd;
LOAD_SRC();
}
mlib_ImageColorTrue2IndexLine_U8_S16_3((void*)buffe, dl, wid, colormap);
#endif /* CONV_INDEX */
sl += sll;
dl += dll;
buff_ind++;
if (buff_ind >= (KSIZE + 1)) buff_ind = 0;
}
mlib_free(pbuff);
return MLIB_SUCCESS;
}
/***************************************************************/
#undef KSIZE
#define MAX_N 11
#ifdef CONV_INDEX
mlib_status mlib_convMxN_Index3_8_16nw(mlib_image *dst,
mlib_image *src,
mlib_s32 m,
mlib_s32 n,
mlib_s32 dm,
mlib_s32 dn,
mlib_s32 *kern,
mlib_s32 scale,
void *colormap)
#else
mlib_status mlib_convMxN_8nw_f(mlib_image *dst,
mlib_image *src,
mlib_s32 m,
mlib_s32 n,
mlib_s32 dm,
mlib_s32 dn,
mlib_s32 *kern,
mlib_s32 scale)
#endif
{
mlib_d64 *buffs_local[3*(MAX_N + 1)], **buffs = buffs_local, **buff;
mlib_d64 *buff0, *buff1, *buff2, *buff3, *buffn, *buffd, *buffe;
mlib_d64 s00, s01, s10, s11, s20, s21, s30, s31, s0, s1, s2, s3;
mlib_d64 d00, d01, d10, d11, d20, d21, d30, d31;
mlib_d64 dd, d0, d1;
mlib_s32 ik, jk, ik_last, jk_size, coff, off, doff;
DEF_VARS;
DEF_EXTRA_VARS;
if (n > MAX_N) {
buffs = mlib_malloc(3*(n + 1)*sizeof(mlib_d64*));
if (buffs == NULL) return MLIB_FAILURE;
}
buff = buffs + 2*(n + 1);
sl = adr_src;
#ifdef CONV_INDEX
dl = adr_dst + dn*dll + dm;
#else
dl = adr_dst + dn*dll + dm*NCHAN;
#endif
ssize = NCHAN*wid;
dsize = (ssize + 7)/8;
esize = dsize + 4;
pbuff = mlib_malloc((n + 4)*esize*sizeof(mlib_d64));
if (pbuff == NULL) {
if (buffs != buffs_local) mlib_free(buffs);
return MLIB_FAILURE;
}
for (i = 0; i < (n + 1); i++) buffs[i] = pbuff + i*esize;
for (i = 0; i < (n + 1); i++) buffs[(n + 1) + i] = buffs[i];
buffd = buffs[n] + esize;
buffe = buffd + 2*esize;
wid -= (m - 1);
hgt -= (n - 1);
xsize = ssize - NCHAN*(m - 1);
emask = (0xFF00 >> (xsize & 7)) & 0xFF;
vis_write_gsr(gsr_scale + 7);
for (l = 0; l < n; l++) {
mlib_d64 *buffn = buffs[l];
sp = sl + l*sll;
#ifndef CONV_INDEX
if ((mlib_addr)sp & 7) mlib_ImageCopy_na((void*)sp, (void*)buffn, ssize);
#else
#pragma pipeloop(0)
for (i = 0; i < dsize; i += 3) {
LOAD_SRC();
}
#endif /* CONV_INDEX */
}
/* init buffer */
#pragma pipeloop(0)
for (i = 0; i < (xsize + 7)/8; i++) {
buffd[2*i ] = drnd;
buffd[2*i + 1] = drnd;
}
for (j = 0; j < hgt; j++) {
mlib_d64 **buffc = buffs + buff_ind;
mlib_f32 *pk = karr, k0, k1, k2, k3;
sp = sl + n*sll;
for (l = 0; l < n; l++) {
buff[l] = buffc[l];
}
buffn = buffc[n];
#ifndef CONV_INDEX
for (l = 0; l < n; l++) {
if ((((mlib_addr)(sl + l*sll)) & 7) == 0) buff[l] = (mlib_d64*)(sl + l*sll);
}
if ((mlib_addr)sp & 7) mlib_ImageCopy_na((void*)sp, (void*)buffn, ssize);
#endif
#ifdef CONV_INDEX
ik_last = 0;
#else
ik_last = (m - 1);
#endif
for (jk = 0; jk < n; jk += jk_size) {
jk_size = n - jk;
#ifdef CONV_INDEX
if (jk_size >= 5) jk_size = 3;
if (jk_size == 4) jk_size = 2;
#else
if (jk_size >= 6) jk_size = 4;
if (jk_size == 5) jk_size = 3;
#endif
coff = 0;
if (jk_size == 2) {
for (ik = 0; ik < m; ik++, coff += NCHAN) {
if (!jk && ik == ik_last) continue;
k0 = pk[ik];
k1 = pk[ik + m];
doff = coff/8;
buff0 = buff[jk ] + doff;
buff1 = buff[jk + 1] + doff;
off = coff & 7;
vis_write_gsr(gsr_scale + off);
s01 = buff0[0];
s11 = buff1[0];
#pragma pipeloop(0)
for (i = 0; i < (xsize + 7)/8; i++) {
s00 = s01;
s10 = s11;
s01 = buff0[i + 1];
s11 = buff1[i + 1];
s0 = vis_faligndata(s00, s01);
s1 = vis_faligndata(s10, s11);
d00 = vis_fmul8x16au(vis_read_hi(s0), k0);
d01 = vis_fmul8x16au(vis_read_lo(s0), k0);
d10 = vis_fmul8x16au(vis_read_hi(s1), k1);
d11 = vis_fmul8x16au(vis_read_lo(s1), k1);
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
d0 = vis_fpadd16(d00, d0);
d0 = vis_fpadd16(d10, d0);
d1 = vis_fpadd16(d01, d1);
d1 = vis_fpadd16(d11, d1);
buffd[2*i] = d0;
buffd[2*i + 1] = d1;
}
}
pk += 2*m;
} else if (jk_size == 3) {
for (ik = 0; ik < m; ik++, coff += NCHAN) {
if (!jk && ik == ik_last) continue;
k0 = pk[ik];
k1 = pk[ik + m];
k2 = pk[ik + 2*m];
doff = coff/8;
buff0 = buff[jk ] + doff;
buff1 = buff[jk + 1] + doff;
buff2 = buff[jk + 2] + doff;
off = coff & 7;
vis_write_gsr(gsr_scale + off);
if (off == 0) {
#pragma pipeloop(0)
for (i = 0; i < (xsize + 7)/8; i++) {
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
s0 = buff0[i];
s1 = buff1[i];
s2 = buff2[i];
d00 = vis_fmul8x16au(vis_read_hi(s0), k0);
d01 = vis_fmul8x16au(vis_read_lo(s0), k0);
d10 = vis_fmul8x16au(vis_read_hi(s1), k1);
d11 = vis_fmul8x16au(vis_read_lo(s1), k1);
d20 = vis_fmul8x16au(vis_read_hi(s2), k2);
d21 = vis_fmul8x16au(vis_read_lo(s2), k2);
d00 = vis_fpadd16(d00, d10);
d0 = vis_fpadd16(d20, d0);
d0 = vis_fpadd16(d00, d0);
d01 = vis_fpadd16(d01, d11);
d1 = vis_fpadd16(d21, d1);
d1 = vis_fpadd16(d01, d1);
buffd[2*i] = d0;
buffd[2*i + 1] = d1;
}
} else if (off == 4) {
s01 = buff0[0];
s11 = buff1[0];
s21 = buff2[0];
#pragma pipeloop(0)
for (i = 0; i < (xsize + 7)/8; i++) {
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
s00 = s01;
s10 = s11;
s20 = s21;
s01 = buff0[i + 1];
s11 = buff1[i + 1];
s21 = buff2[i + 1];
d00 = vis_fmul8x16au(vis_read_lo(s00), k0);
d01 = vis_fmul8x16au(vis_read_hi(s01), k0);
d10 = vis_fmul8x16au(vis_read_lo(s10), k1);
d11 = vis_fmul8x16au(vis_read_hi(s11), k1);
d20 = vis_fmul8x16au(vis_read_lo(s20), k2);
d21 = vis_fmul8x16au(vis_read_hi(s21), k2);
d00 = vis_fpadd16(d00, d10);
d0 = vis_fpadd16(d20, d0);
d0 = vis_fpadd16(d00, d0);
d01 = vis_fpadd16(d01, d11);
d1 = vis_fpadd16(d21, d1);
d1 = vis_fpadd16(d01, d1);
buffd[2*i] = d0;
buffd[2*i + 1] = d1;
}
} else {
s01 = buff0[0];
s11 = buff1[0];
s21 = buff2[0];
#pragma pipeloop(0)
for (i = 0; i < (xsize + 7)/8; i++) {
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
s00 = s01;
s10 = s11;
s20 = s21;
s01 = buff0[i + 1];
s11 = buff1[i + 1];
s21 = buff2[i + 1];
s0 = vis_faligndata(s00, s01);
s1 = vis_faligndata(s10, s11);
s2 = vis_faligndata(s20, s21);
d00 = vis_fmul8x16au(vis_read_hi(s0), k0);
d01 = vis_fmul8x16au(vis_read_lo(s0), k0);
d10 = vis_fmul8x16au(vis_read_hi(s1), k1);
d11 = vis_fmul8x16au(vis_read_lo(s1), k1);
d20 = vis_fmul8x16au(vis_read_hi(s2), k2);
d21 = vis_fmul8x16au(vis_read_lo(s2), k2);
d00 = vis_fpadd16(d00, d10);
d0 = vis_fpadd16(d20, d0);
d0 = vis_fpadd16(d00, d0);
d01 = vis_fpadd16(d01, d11);
d1 = vis_fpadd16(d21, d1);
d1 = vis_fpadd16(d01, d1);
buffd[2*i] = d0;
buffd[2*i + 1] = d1;
}
}
}
pk += 3*m;
} else { /* jk_size == 4 */
for (ik = 0; ik < m; ik++, coff += NCHAN) {
if (!jk && ik == ik_last) continue;
k0 = pk[ik];
k1 = pk[ik + m];
k2 = pk[ik + 2*m];
k3 = pk[ik + 3*m];
doff = coff/8;
buff0 = buff[jk ] + doff;
buff1 = buff[jk + 1] + doff;
buff2 = buff[jk + 2] + doff;
buff3 = buff[jk + 3] + doff;
off = coff & 7;
vis_write_gsr(gsr_scale + off);
if (off == 0) {
#pragma pipeloop(0)
for (i = 0; i < (xsize + 7)/8; i++) {
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
s0 = buff0[i];
s1 = buff1[i];
s2 = buff2[i];
s3 = buff3[i];
d00 = vis_fmul8x16au(vis_read_hi(s0), k0);
d01 = vis_fmul8x16au(vis_read_lo(s0), k0);
d10 = vis_fmul8x16au(vis_read_hi(s1), k1);
d11 = vis_fmul8x16au(vis_read_lo(s1), k1);
d20 = vis_fmul8x16au(vis_read_hi(s2), k2);
d21 = vis_fmul8x16au(vis_read_lo(s2), k2);
d30 = vis_fmul8x16au(vis_read_hi(s3), k3);
d31 = vis_fmul8x16au(vis_read_lo(s3), k3);
d00 = vis_fpadd16(d00, d10);
d20 = vis_fpadd16(d20, d30);
d0 = vis_fpadd16(d0, d00);
d0 = vis_fpadd16(d0, d20);
d01 = vis_fpadd16(d01, d11);
d21 = vis_fpadd16(d21, d31);
d1 = vis_fpadd16(d1, d01);
d1 = vis_fpadd16(d1, d21);
buffd[2*i] = d0;
buffd[2*i + 1] = d1;
}
} else if (off == 4) {
s01 = buff0[0];
s11 = buff1[0];
s21 = buff2[0];
s31 = buff3[0];
#pragma pipeloop(0)
for (i = 0; i < (xsize + 7)/8; i++) {
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
s00 = s01;
s10 = s11;
s20 = s21;
s30 = s31;
s01 = buff0[i + 1];
s11 = buff1[i + 1];
s21 = buff2[i + 1];
s31 = buff3[i + 1];
d00 = vis_fmul8x16au(vis_read_lo(s00), k0);
d01 = vis_fmul8x16au(vis_read_hi(s01), k0);
d10 = vis_fmul8x16au(vis_read_lo(s10), k1);
d11 = vis_fmul8x16au(vis_read_hi(s11), k1);
d20 = vis_fmul8x16au(vis_read_lo(s20), k2);
d21 = vis_fmul8x16au(vis_read_hi(s21), k2);
d30 = vis_fmul8x16au(vis_read_lo(s30), k3);
d31 = vis_fmul8x16au(vis_read_hi(s31), k3);
d00 = vis_fpadd16(d00, d10);
d20 = vis_fpadd16(d20, d30);
d0 = vis_fpadd16(d0, d00);
d0 = vis_fpadd16(d0, d20);
d01 = vis_fpadd16(d01, d11);
d21 = vis_fpadd16(d21, d31);
d1 = vis_fpadd16(d1, d01);
d1 = vis_fpadd16(d1, d21);
buffd[2*i] = d0;
buffd[2*i + 1] = d1;
}
} else {
s01 = buff0[0];
s11 = buff1[0];
s21 = buff2[0];
s31 = buff3[0];
#pragma pipeloop(0)
for (i = 0; i < (xsize + 7)/8; i++) {
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
s00 = s01;
s10 = s11;
s20 = s21;
s30 = s31;
s01 = buff0[i + 1];
s11 = buff1[i + 1];
s21 = buff2[i + 1];
s31 = buff3[i + 1];
s0 = vis_faligndata(s00, s01);
s1 = vis_faligndata(s10, s11);
s2 = vis_faligndata(s20, s21);
s3 = vis_faligndata(s30, s31);
d00 = vis_fmul8x16au(vis_read_hi(s0), k0);
d01 = vis_fmul8x16au(vis_read_lo(s0), k0);
d10 = vis_fmul8x16au(vis_read_hi(s1), k1);
d11 = vis_fmul8x16au(vis_read_lo(s1), k1);
d20 = vis_fmul8x16au(vis_read_hi(s2), k2);
d21 = vis_fmul8x16au(vis_read_lo(s2), k2);
d30 = vis_fmul8x16au(vis_read_hi(s3), k3);
d31 = vis_fmul8x16au(vis_read_lo(s3), k3);
d00 = vis_fpadd16(d00, d10);
d20 = vis_fpadd16(d20, d30);
d0 = vis_fpadd16(d0, d00);
d0 = vis_fpadd16(d0, d20);
d01 = vis_fpadd16(d01, d11);
d21 = vis_fpadd16(d21, d31);
d1 = vis_fpadd16(d1, d01);
d1 = vis_fpadd16(d1, d21);
buffd[2*i] = d0;
buffd[2*i + 1] = d1;
}
}
}
pk += 4*m;
}
}
/*****************************************
*****************************************
** Final iteration **
*****************************************
*****************************************/
jk_size = n;
#ifdef CONV_INDEX
if (jk_size >= 5) jk_size = 3;
if (jk_size == 4) jk_size = 2;
#else
if (jk_size >= 6) jk_size = 4;
if (jk_size == 5) jk_size = 3;
#endif
k0 = karr[ik_last];
k1 = karr[ik_last + m];
k2 = karr[ik_last + 2*m];
k3 = karr[ik_last + 3*m];
off = ik_last*NCHAN;
doff = off/8;
off &= 7;
buff0 = buff[0] + doff;
buff1 = buff[1] + doff;
buff2 = buff[2] + doff;
buff3 = buff[3] + doff;
vis_write_gsr(gsr_scale + off);
#ifndef CONV_INDEX
if (jk_size == 2) {
dp = ((mlib_addr)dl & 7) ? buffe : (mlib_d64*)dl;
s01 = buff0[0];
s11 = buff1[0];
#pragma pipeloop(0)
for (i = 0; i < xsize/8; i++) {
s00 = s01;
s10 = s11;
s01 = buff0[i + 1];
s11 = buff1[i + 1];
s0 = vis_faligndata(s00, s01);
s1 = vis_faligndata(s10, s11);
d00 = vis_fmul8x16au(vis_read_hi(s0), k0);
d01 = vis_fmul8x16au(vis_read_lo(s0), k0);
d10 = vis_fmul8x16au(vis_read_hi(s1), k1);
d11 = vis_fmul8x16au(vis_read_lo(s1), k1);
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
d0 = vis_fpadd16(d0, d00);
d0 = vis_fpadd16(d0, d10);
d1 = vis_fpadd16(d1, d01);
d1 = vis_fpadd16(d1, d11);
dd = vis_fpack16_pair(d0, d1);
dp[i] = dd;
buffd[2*i ] = drnd;
buffd[2*i + 1] = drnd;
}
if (emask) {
s00 = s01;
s10 = s11;
s01 = buff0[i + 1];
s11 = buff1[i + 1];
s0 = vis_faligndata(s00, s01);
s1 = vis_faligndata(s10, s11);
d00 = vis_fmul8x16au(vis_read_hi(s0), k0);
d01 = vis_fmul8x16au(vis_read_lo(s0), k0);
d10 = vis_fmul8x16au(vis_read_hi(s1), k1);
d11 = vis_fmul8x16au(vis_read_lo(s1), k1);
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
d0 = vis_fpadd16(d0, d00);
d0 = vis_fpadd16(d0, d10);
d1 = vis_fpadd16(d1, d01);
d1 = vis_fpadd16(d1, d11);
dd = vis_fpack16_pair(d0, d1);
vis_pst_8(dd, dp + i, emask);
buffd[2*i ] = drnd;
buffd[2*i + 1] = drnd;
}
if ((mlib_u8*)dp != dl) mlib_ImageCopy_na((void*)buffe, dl, xsize);
} else if (jk_size == 3) {
dp = ((mlib_addr)dl & 7) ? buffe : (mlib_d64*)dl;
s01 = buff0[0];
s11 = buff1[0];
s21 = buff2[0];
#pragma pipeloop(0)
for (i = 0; i < xsize/8; i++) {
s00 = s01;
s10 = s11;
s20 = s21;
s01 = buff0[i + 1];
s11 = buff1[i + 1];
s21 = buff2[i + 1];
s0 = vis_faligndata(s00, s01);
s1 = vis_faligndata(s10, s11);
s2 = vis_faligndata(s20, s21);
d00 = vis_fmul8x16au(vis_read_hi(s0), k0);
d01 = vis_fmul8x16au(vis_read_lo(s0), k0);
d10 = vis_fmul8x16au(vis_read_hi(s1), k1);
d11 = vis_fmul8x16au(vis_read_lo(s1), k1);
d20 = vis_fmul8x16au(vis_read_hi(s2), k2);
d21 = vis_fmul8x16au(vis_read_lo(s2), k2);
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
d0 = vis_fpadd16(d0, d00);
d0 = vis_fpadd16(d0, d10);
d0 = vis_fpadd16(d0, d20);
d1 = vis_fpadd16(d1, d01);
d1 = vis_fpadd16(d1, d11);
d1 = vis_fpadd16(d1, d21);
dd = vis_fpack16_pair(d0, d1);
dp[i] = dd;
buffd[2*i ] = drnd;
buffd[2*i + 1] = drnd;
}
if (emask) {
s00 = s01;
s10 = s11;
s20 = s21;
s01 = buff0[i + 1];
s11 = buff1[i + 1];
s21 = buff2[i + 1];
s0 = vis_faligndata(s00, s01);
s1 = vis_faligndata(s10, s11);
s2 = vis_faligndata(s20, s21);
d00 = vis_fmul8x16au(vis_read_hi(s0), k0);
d01 = vis_fmul8x16au(vis_read_lo(s0), k0);
d10 = vis_fmul8x16au(vis_read_hi(s1), k1);
d11 = vis_fmul8x16au(vis_read_lo(s1), k1);
d20 = vis_fmul8x16au(vis_read_hi(s2), k2);
d21 = vis_fmul8x16au(vis_read_lo(s2), k2);
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
d0 = vis_fpadd16(d0, d00);
d0 = vis_fpadd16(d0, d10);
d0 = vis_fpadd16(d0, d20);
d1 = vis_fpadd16(d1, d01);
d1 = vis_fpadd16(d1, d11);
d1 = vis_fpadd16(d1, d21);
dd = vis_fpack16_pair(d0, d1);
vis_pst_8(dd, dp + i, emask);
buffd[2*i ] = drnd;
buffd[2*i + 1] = drnd;
}
if ((mlib_u8*)dp != dl) mlib_ImageCopy_na((void*)buffe, dl, xsize);
} else /* if (jk_size == 4) */ {
dp = ((mlib_addr)dl & 7) ? buffe : (mlib_d64*)dl;
s01 = buff0[0];
s11 = buff1[0];
s21 = buff2[0];
s31 = buff3[0];
#pragma pipeloop(0)
for (i = 0; i < xsize/8; i++) {
s00 = s01;
s10 = s11;
s20 = s21;
s30 = s31;
s01 = buff0[i + 1];
s11 = buff1[i + 1];
s21 = buff2[i + 1];
s31 = buff3[i + 1];
s0 = vis_faligndata(s00, s01);
s1 = vis_faligndata(s10, s11);
s2 = vis_faligndata(s20, s21);
s3 = vis_faligndata(s30, s31);
d00 = vis_fmul8x16au(vis_read_hi(s0), k0);
d01 = vis_fmul8x16au(vis_read_lo(s0), k0);
d10 = vis_fmul8x16au(vis_read_hi(s1), k1);
d11 = vis_fmul8x16au(vis_read_lo(s1), k1);
d20 = vis_fmul8x16au(vis_read_hi(s2), k2);
d21 = vis_fmul8x16au(vis_read_lo(s2), k2);
d30 = vis_fmul8x16au(vis_read_hi(s3), k3);
d31 = vis_fmul8x16au(vis_read_lo(s3), k3);
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
d0 = vis_fpadd16(d0, d00);
d0 = vis_fpadd16(d0, d10);
d0 = vis_fpadd16(d0, d20);
d0 = vis_fpadd16(d0, d30);
d1 = vis_fpadd16(d1, d01);
d1 = vis_fpadd16(d1, d11);
d1 = vis_fpadd16(d1, d21);
d1 = vis_fpadd16(d1, d31);
dd = vis_fpack16_pair(d0, d1);
dp[i] = dd;
buffd[2*i ] = drnd;
buffd[2*i + 1] = drnd;
}
if (emask) {
s00 = s01;
s10 = s11;
s20 = s21;
s30 = s31;
s01 = buff0[i + 1];
s11 = buff1[i + 1];
s21 = buff2[i + 1];
s31 = buff3[i + 1];
s0 = vis_faligndata(s00, s01);
s1 = vis_faligndata(s10, s11);
s2 = vis_faligndata(s20, s21);
s3 = vis_faligndata(s30, s31);
d00 = vis_fmul8x16au(vis_read_hi(s0), k0);
d01 = vis_fmul8x16au(vis_read_lo(s0), k0);
d10 = vis_fmul8x16au(vis_read_hi(s1), k1);
d11 = vis_fmul8x16au(vis_read_lo(s1), k1);
d20 = vis_fmul8x16au(vis_read_hi(s2), k2);
d21 = vis_fmul8x16au(vis_read_lo(s2), k2);
d30 = vis_fmul8x16au(vis_read_hi(s3), k3);
d31 = vis_fmul8x16au(vis_read_lo(s3), k3);
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
d0 = vis_fpadd16(d0, d00);
d0 = vis_fpadd16(d0, d10);
d0 = vis_fpadd16(d0, d20);
d0 = vis_fpadd16(d0, d30);
d1 = vis_fpadd16(d1, d01);
d1 = vis_fpadd16(d1, d11);
d1 = vis_fpadd16(d1, d21);
d1 = vis_fpadd16(d1, d31);
dd = vis_fpack16_pair(d0, d1);
vis_pst_8(dd, dp + i, emask);
buffd[2*i ] = drnd;
buffd[2*i + 1] = drnd;
}
if ((mlib_u8*)dp != dl) mlib_ImageCopy_na((void*)buffe, dl, xsize);
}
#else /* CONV_INDEX */
if (jk_size == 2) {
vis_write_gsr(gsr_scale + 7);
#pragma pipeloop(0)
for (i = 0; i < dsize; i += 3) {
mlib_d64 d00, d01, d02, d03, d04, d05;
mlib_d64 d10, d11, d12, d13, d14, d15;
mlib_d64 d0, d1, d2, d3, d4, d5;
mlib_d64 s00 = buff0[i];
mlib_d64 s01 = buff0[i + 1];
mlib_d64 s02 = buff0[i + 2];
mlib_d64 s10 = buff1[i];
mlib_d64 s11 = buff1[i + 1];
mlib_d64 s12 = buff1[i + 2];
d00 = vis_fmul8x16au(vis_read_hi(s00), k0);
d01 = vis_fmul8x16au(vis_read_lo(s00), k0);
d02 = vis_fmul8x16au(vis_read_hi(s01), k0);
d03 = vis_fmul8x16au(vis_read_lo(s01), k0);
d04 = vis_fmul8x16au(vis_read_hi(s02), k0);
d05 = vis_fmul8x16au(vis_read_lo(s02), k0);
d10 = vis_fmul8x16au(vis_read_hi(s10), k1);
d11 = vis_fmul8x16au(vis_read_lo(s10), k1);
d12 = vis_fmul8x16au(vis_read_hi(s11), k1);
d13 = vis_fmul8x16au(vis_read_lo(s11), k1);
d14 = vis_fmul8x16au(vis_read_hi(s12), k1);
d15 = vis_fmul8x16au(vis_read_lo(s12), k1);
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
d2 = buffd[2*i + 2];
d3 = buffd[2*i + 3];
d4 = buffd[2*i + 4];
d5 = buffd[2*i + 5];
d0 = vis_fpadd16(d0, d00);
d0 = vis_fpadd16(d0, d10);
d1 = vis_fpadd16(d1, d01);
d1 = vis_fpadd16(d1, d11);
d2 = vis_fpadd16(d2, d02);
d2 = vis_fpadd16(d2, d12);
d3 = vis_fpadd16(d3, d03);
d3 = vis_fpadd16(d3, d13);
d4 = vis_fpadd16(d4, d04);
d4 = vis_fpadd16(d4, d14);
d5 = vis_fpadd16(d5, d05);
d5 = vis_fpadd16(d5, d15);
buffe[i ] = vis_fpack16_pair(d0, d1);
buffe[i + 1] = vis_fpack16_pair(d2, d3);
buffe[i + 2] = vis_fpack16_pair(d4, d5);
buffd[2*i ] = drnd;
buffd[2*i + 1] = drnd;
buffd[2*i + 2] = drnd;
buffd[2*i + 3] = drnd;
buffd[2*i + 4] = drnd;
buffd[2*i + 5] = drnd;
LOAD_SRC();
}
} else /* if (jk_size == 3) */ {
vis_write_gsr(gsr_scale + 7);
#pragma pipeloop(0)
for (i = 0; i < dsize; i += 3) {
mlib_d64 d00, d01, d02, d03, d04, d05;
mlib_d64 d10, d11, d12, d13, d14, d15;
mlib_d64 d20, d21, d22, d23, d24, d25;
mlib_d64 d0, d1, d2, d3, d4, d5;
mlib_d64 s00 = buff0[i];
mlib_d64 s01 = buff0[i + 1];
mlib_d64 s02 = buff0[i + 2];
mlib_d64 s10 = buff1[i];
mlib_d64 s11 = buff1[i + 1];
mlib_d64 s12 = buff1[i + 2];
mlib_d64 s20 = buff2[i];
mlib_d64 s21 = buff2[i + 1];
mlib_d64 s22 = buff2[i + 2];
d00 = vis_fmul8x16au(vis_read_hi(s00), k0);
d01 = vis_fmul8x16au(vis_read_lo(s00), k0);
d02 = vis_fmul8x16au(vis_read_hi(s01), k0);
d03 = vis_fmul8x16au(vis_read_lo(s01), k0);
d04 = vis_fmul8x16au(vis_read_hi(s02), k0);
d05 = vis_fmul8x16au(vis_read_lo(s02), k0);
d10 = vis_fmul8x16au(vis_read_hi(s10), k1);
d11 = vis_fmul8x16au(vis_read_lo(s10), k1);
d12 = vis_fmul8x16au(vis_read_hi(s11), k1);
d13 = vis_fmul8x16au(vis_read_lo(s11), k1);
d14 = vis_fmul8x16au(vis_read_hi(s12), k1);
d15 = vis_fmul8x16au(vis_read_lo(s12), k1);
d20 = vis_fmul8x16au(vis_read_hi(s20), k2);
d21 = vis_fmul8x16au(vis_read_lo(s20), k2);
d22 = vis_fmul8x16au(vis_read_hi(s21), k2);
d23 = vis_fmul8x16au(vis_read_lo(s21), k2);
d24 = vis_fmul8x16au(vis_read_hi(s22), k2);
d25 = vis_fmul8x16au(vis_read_lo(s22), k2);
d0 = buffd[2*i];
d1 = buffd[2*i + 1];
d2 = buffd[2*i + 2];
d3 = buffd[2*i + 3];
d4 = buffd[2*i + 4];
d5 = buffd[2*i + 5];
d0 = vis_fpadd16(d0, d00);
d0 = vis_fpadd16(d0, d10);
d0 = vis_fpadd16(d0, d20);
d1 = vis_fpadd16(d1, d01);
d1 = vis_fpadd16(d1, d11);
d1 = vis_fpadd16(d1, d21);
d2 = vis_fpadd16(d2, d02);
d2 = vis_fpadd16(d2, d12);
d2 = vis_fpadd16(d2, d22);
d3 = vis_fpadd16(d3, d03);
d3 = vis_fpadd16(d3, d13);
d3 = vis_fpadd16(d3, d23);
d4 = vis_fpadd16(d4, d04);
d4 = vis_fpadd16(d4, d14);
d4 = vis_fpadd16(d4, d24);
d5 = vis_fpadd16(d5, d05);
d5 = vis_fpadd16(d5, d15);
d5 = vis_fpadd16(d5, d25);
buffe[i ] = vis_fpack16_pair(d0, d1);
buffe[i + 1] = vis_fpack16_pair(d2, d3);
buffe[i + 2] = vis_fpack16_pair(d4, d5);
buffd[2*i ] = drnd;
buffd[2*i + 1] = drnd;
buffd[2*i + 2] = drnd;
buffd[2*i + 3] = drnd;
buffd[2*i + 4] = drnd;
buffd[2*i + 5] = drnd;
LOAD_SRC();
}
}
#endif /* CONV_INDEX */
#ifdef CONV_INDEX
mlib_ImageColorTrue2IndexLine_U8_S16_3((void*)buffe, dl, wid, colormap);
#endif /* CONV_INDEX */
sl += sll;
dl += dll;
buff_ind++;
if (buff_ind >= (n + 1)) buff_ind = 0;
}
mlib_free(pbuff);
if (buffs != buffs_local) mlib_free(buffs);
return MLIB_SUCCESS;
}
/***************************************************************/
| {
"language": "Assembly"
} |
; RUN: llc -march=mipsel -mcpu=mips16 -relocation-model=static < %s | FileCheck %s -check-prefix=16
@i = global i32 25, align 4
@.str = private unnamed_addr constant [5 x i8] c"%i \0A\00", align 1
define void @p(i32* %i) nounwind {
entry:
ret void
}
define void @foo() nounwind {
entry:
%y = alloca [512 x i32], align 4
%x = alloca i32, align 8
%zz = alloca i32, align 4
%z = alloca i32, align 4
%0 = load i32* @i, align 4
%arrayidx = getelementptr inbounds [512 x i32]* %y, i32 0, i32 10
store i32 %0, i32* %arrayidx, align 4
%1 = load i32* @i, align 4
store i32 %1, i32* %x, align 8
call void @p(i32* %x)
%arrayidx1 = getelementptr inbounds [512 x i32]* %y, i32 0, i32 10
call void @p(i32* %arrayidx1)
ret void
}
; 16: save $ra, 2040
; 16: addiu $sp, -40 # 16 bit inst
; 16: addiu $sp, 40 # 16 bit inst
; 16: restore $ra, 2040
| {
"language": "Assembly"
} |
;Imports of unzip:
extern fread
extern ferror
extern fseek
extern memcpy
extern free
extern fclose
extern inflateEnd
extern __i686.get_pc_thunk.bx
extern fopen
extern fileno
extern fcntl
extern FS_FileGetFileSize
extern malloc
extern inflateInit2_
extern Com_Memcpy
extern inflate
;Exports of unzip:
global unzlocal_getLong
global unzlocal_GetCurrentFileInfoInternal
global unzClose
global unzCloseCurrentFile
global unzGetCurrentFileInfo
global unzGetCurrentFileInfoPosition
global unzGetGlobalInfo
global unzGoToFirstFile
global unzGoToNextFile
global unzOpen
global unzOpenCurrentFile
global unzReOpen
global unzReadCurrentFile
global unzSetCurrentFileInfoPosition
global unztell
SECTION .text
;unzlocal_getLong
unzlocal_getLong:
push ebp
mov ebp, esp
push edi
push esi
sub esp, 0x40
mov edi, eax
mov [ebp-0x2c], edx
mov [esp+0xc], eax
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
lea eax, [ebp-0x9]
mov [ebp-0x30], eax
mov [esp], eax
call fread
sub eax, 0x1
jz unzlocal_getLong_10
mov [esp], edi
call ferror
test eax, eax
jz unzlocal_getLong_20
mov dword [ebp-0x24], 0xffffffff
mov esi, [ebp-0x28]
unzlocal_getLong_120:
mov eax, esi
shl eax, 0x8
add eax, [ebp-0x28]
mov [ebp-0x20], eax
mov ecx, [ebp-0x24]
test ecx, ecx
jz unzlocal_getLong_30
unzlocal_getLong_60:
mov eax, esi
shl eax, 0x10
add eax, [ebp-0x20]
mov [ebp-0x1c], eax
mov edx, [ebp-0x24]
test edx, edx
jz unzlocal_getLong_40
unzlocal_getLong_80:
mov edx, eax
shl esi, 0x18
add edx, esi
xor eax, eax
mov esi, [ebp-0x24]
test esi, esi
cmovz eax, edx
mov edx, [ebp-0x2c]
mov [edx], eax
mov eax, [ebp-0x24]
add esp, 0x40
pop esi
pop edi
pop ebp
ret
unzlocal_getLong_20:
mov dword [ebp-0x24], 0x0
mov [esp+0xc], edi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov eax, [ebp-0x30]
mov [esp], eax
call fread
sub eax, 0x1
jnz unzlocal_getLong_50
unzlocal_getLong_100:
movzx esi, byte [ebp-0x9]
mov eax, esi
shl eax, 0x8
add eax, [ebp-0x28]
mov [ebp-0x20], eax
mov ecx, [ebp-0x24]
test ecx, ecx
jnz unzlocal_getLong_60
unzlocal_getLong_30:
mov [esp+0xc], edi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov edx, [ebp-0x30]
mov [esp], edx
call fread
sub eax, 0x1
jz unzlocal_getLong_70
mov [esp], edi
call ferror
test eax, eax
mov eax, 0xffffffff
cmovz eax, [ebp-0x24]
mov [ebp-0x24], eax
mov eax, esi
shl eax, 0x10
add eax, [ebp-0x20]
mov [ebp-0x1c], eax
mov edx, [ebp-0x24]
test edx, edx
jnz unzlocal_getLong_80
unzlocal_getLong_40:
mov [esp+0xc], edi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov eax, [ebp-0x30]
mov [esp], eax
call fread
sub eax, 0x1
jz unzlocal_getLong_90
mov [esp], edi
call ferror
test eax, eax
mov eax, 0xffffffff
cmovz eax, [ebp-0x24]
mov [ebp-0x24], eax
mov edx, [ebp-0x1c]
shl esi, 0x18
add edx, esi
xor eax, eax
mov esi, [ebp-0x24]
test esi, esi
cmovz eax, edx
mov edx, [ebp-0x2c]
mov [edx], eax
mov eax, [ebp-0x24]
add esp, 0x40
pop esi
pop edi
pop ebp
ret
unzlocal_getLong_10:
movzx edx, byte [ebp-0x9]
mov [ebp-0x28], edx
mov dword [ebp-0x24], 0x0
mov [esp+0xc], edi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov eax, [ebp-0x30]
mov [esp], eax
call fread
sub eax, 0x1
jz unzlocal_getLong_100
unzlocal_getLong_50:
mov [esp], edi
call ferror
test eax, eax
jnz unzlocal_getLong_110
mov esi, [ebp-0x28]
jmp unzlocal_getLong_120
unzlocal_getLong_110:
mov esi, [ebp-0x28]
mov dword [ebp-0x24], 0xffffffff
jmp unzlocal_getLong_120
unzlocal_getLong_70:
movzx esi, byte [ebp-0x9]
jmp unzlocal_getLong_60
unzlocal_getLong_90:
movzx esi, byte [ebp-0x9]
mov edx, [ebp-0x1c]
shl esi, 0x18
add edx, esi
xor eax, eax
mov esi, [ebp-0x24]
test esi, esi
cmovz eax, edx
mov edx, [ebp-0x2c]
mov [edx], eax
mov eax, [ebp-0x24]
add esp, 0x40
pop esi
pop edi
pop ebp
ret
;unzlocal_GetCurrentFileInfoInternal
unzlocal_GetCurrentFileInfoInternal:
push ebp
mov ebp, esp
push edi
push esi
sub esp, 0xd0
mov edi, eax
mov [ebp-0xc0], edx
mov [ebp-0xc4], ecx
test eax, eax
jz unzlocal_GetCurrentFileInfoInternal_10
mov dword [esp+0x8], 0x0
mov eax, [eax+0x14]
add eax, [edi+0xc]
mov [esp+0x4], eax
mov eax, [edi]
mov [esp], eax
call fseek
test eax, eax
jz unzlocal_GetCurrentFileInfoInternal_20
unzlocal_GetCurrentFileInfoInternal_870:
mov dword [ebp-0xbc], 0xffffffff
unzlocal_GetCurrentFileInfoInternal_880:
mov esi, [edi]
mov [esp+0xc], esi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
lea eax, [ebp-0x9]
mov [ebp-0xc8], eax
mov [esp], eax
call fread
sub eax, 0x1
jz unzlocal_GetCurrentFileInfoInternal_30
mov [esp], esi
call ferror
test eax, eax
jz unzlocal_GetCurrentFileInfoInternal_40
mov dword [ebp-0xb4], 0xffffffff
mov eax, [ebp-0xb8]
unzlocal_GetCurrentFileInfoInternal_760:
shl eax, 0x8
add eax, [ebp-0xb8]
mov ecx, [ebp-0xb4]
test ecx, ecx
jnz unzlocal_GetCurrentFileInfoInternal_50
unzlocal_GetCurrentFileInfoInternal_430:
mov [ebp-0x64], eax
unzlocal_GetCurrentFileInfoInternal_440:
mov esi, [edi]
mov [esp+0xc], esi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov eax, [ebp-0xc8]
mov [esp], eax
call fread
sub eax, 0x1
jnz unzlocal_GetCurrentFileInfoInternal_60
movzx edx, byte [ebp-0x9]
mov [ebp-0xb0], edx
mov dword [ebp-0xac], 0x0
unzlocal_GetCurrentFileInfoInternal_1000:
mov [esp+0xc], esi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov ecx, [ebp-0xc8]
mov [esp], ecx
call fread
sub eax, 0x1
jnz unzlocal_GetCurrentFileInfoInternal_70
movzx eax, byte [ebp-0x9]
unzlocal_GetCurrentFileInfoInternal_820:
shl eax, 0x8
add eax, [ebp-0xb0]
mov edx, [ebp-0xac]
test edx, edx
jnz unzlocal_GetCurrentFileInfoInternal_80
unzlocal_GetCurrentFileInfoInternal_640:
mov [ebp-0x60], eax
unzlocal_GetCurrentFileInfoInternal_650:
mov esi, [edi]
mov [esp+0xc], esi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov eax, [ebp-0xc8]
mov [esp], eax
call fread
sub eax, 0x1
jnz unzlocal_GetCurrentFileInfoInternal_90
movzx edx, byte [ebp-0x9]
mov [ebp-0xa8], edx
mov dword [ebp-0xa4], 0x0
unzlocal_GetCurrentFileInfoInternal_970:
mov [esp+0xc], esi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov ecx, [ebp-0xc8]
mov [esp], ecx
call fread
sub eax, 0x1
jnz unzlocal_GetCurrentFileInfoInternal_100
movzx eax, byte [ebp-0x9]
unzlocal_GetCurrentFileInfoInternal_860:
shl eax, 0x8
add eax, [ebp-0xa8]
mov esi, [ebp-0xa4]
test esi, esi
jnz unzlocal_GetCurrentFileInfoInternal_110
unzlocal_GetCurrentFileInfoInternal_580:
mov [ebp-0x5c], eax
unzlocal_GetCurrentFileInfoInternal_590:
mov esi, [edi]
mov [esp+0xc], esi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov eax, [ebp-0xc8]
mov [esp], eax
call fread
sub eax, 0x1
jnz unzlocal_GetCurrentFileInfoInternal_120
movzx edx, byte [ebp-0x9]
mov [ebp-0xa0], edx
mov dword [ebp-0x9c], 0x0
unzlocal_GetCurrentFileInfoInternal_980:
mov [esp+0xc], esi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov ecx, [ebp-0xc8]
mov [esp], ecx
call fread
sub eax, 0x1
jnz unzlocal_GetCurrentFileInfoInternal_130
movzx eax, byte [ebp-0x9]
unzlocal_GetCurrentFileInfoInternal_740:
shl eax, 0x8
add eax, [ebp-0xa0]
mov ecx, [ebp-0x9c]
test ecx, ecx
jnz unzlocal_GetCurrentFileInfoInternal_140
unzlocal_GetCurrentFileInfoInternal_670:
mov [ebp-0x58], eax
unzlocal_GetCurrentFileInfoInternal_680:
lea edx, [ebp-0x54]
mov eax, [edi]
call unzlocal_getLong
mov esi, 0xffffffff
test eax, eax
mov eax, [ebp-0xbc]
cmovnz eax, esi
mov [ebp-0xbc], eax
mov ecx, [ebp-0x54]
mov edx, ecx
shr edx, 0x10
mov eax, edx
and eax, 0x1f
mov [ebp-0x20], eax
mov eax, edx
and eax, 0x1e0
shr eax, 0x5
sub eax, 0x1
mov [ebp-0x1c], eax
shr edx, 0x9
add edx, 0x7bc
mov [ebp-0x18], edx
mov eax, ecx
and eax, 0xf800
shr eax, 0xb
mov [ebp-0x24], eax
mov eax, ecx
and eax, 0x7e0
shr eax, 0x5
mov [ebp-0x28], eax
and ecx, 0x1f
add ecx, ecx
mov [ebp-0x2c], ecx
lea edx, [ebp-0x50]
mov eax, [edi]
call unzlocal_getLong
test eax, eax
mov edx, [ebp-0xbc]
cmovnz edx, esi
mov [ebp-0xbc], edx
lea edx, [ebp-0x4c]
mov eax, [edi]
call unzlocal_getLong
test eax, eax
mov ecx, [ebp-0xbc]
cmovnz ecx, esi
mov [ebp-0xbc], ecx
lea edx, [ebp-0x48]
mov eax, [edi]
call unzlocal_getLong
test eax, eax
cmovz esi, [ebp-0xbc]
mov [ebp-0xbc], esi
mov esi, [edi]
mov [esp+0xc], esi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov eax, [ebp-0xc8]
mov [esp], eax
call fread
sub eax, 0x1
jnz unzlocal_GetCurrentFileInfoInternal_150
movzx edx, byte [ebp-0x9]
mov [ebp-0x98], edx
mov dword [ebp-0x94], 0x0
unzlocal_GetCurrentFileInfoInternal_1010:
mov [esp+0xc], esi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov ecx, [ebp-0xc8]
mov [esp], ecx
call fread
sub eax, 0x1
jnz unzlocal_GetCurrentFileInfoInternal_160
movzx eax, byte [ebp-0x9]
unzlocal_GetCurrentFileInfoInternal_720:
shl eax, 0x8
add eax, [ebp-0x98]
mov edx, [ebp-0x94]
test edx, edx
jnz unzlocal_GetCurrentFileInfoInternal_170
unzlocal_GetCurrentFileInfoInternal_610:
mov [ebp-0x44], eax
unzlocal_GetCurrentFileInfoInternal_620:
mov esi, [edi]
mov [esp+0xc], esi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov eax, [ebp-0xc8]
mov [esp], eax
call fread
sub eax, 0x1
jnz unzlocal_GetCurrentFileInfoInternal_180
movzx edx, byte [ebp-0x9]
mov [ebp-0x90], edx
mov dword [ebp-0x8c], 0x0
unzlocal_GetCurrentFileInfoInternal_1020:
mov [esp+0xc], esi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov ecx, [ebp-0xc8]
mov [esp], ecx
call fread
sub eax, 0x1
jnz unzlocal_GetCurrentFileInfoInternal_190
movzx eax, byte [ebp-0x9]
unzlocal_GetCurrentFileInfoInternal_700:
shl eax, 0x8
add eax, [ebp-0x90]
mov esi, [ebp-0x8c]
test esi, esi
jnz unzlocal_GetCurrentFileInfoInternal_200
unzlocal_GetCurrentFileInfoInternal_550:
mov [ebp-0x40], eax
unzlocal_GetCurrentFileInfoInternal_560:
mov esi, [edi]
mov [esp+0xc], esi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov eax, [ebp-0xc8]
mov [esp], eax
call fread
sub eax, 0x1
jnz unzlocal_GetCurrentFileInfoInternal_210
movzx edx, byte [ebp-0x9]
mov [ebp-0x88], edx
mov dword [ebp-0x84], 0x0
unzlocal_GetCurrentFileInfoInternal_960:
mov [esp+0xc], esi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov ecx, [ebp-0xc8]
mov [esp], ecx
call fread
sub eax, 0x1
jnz unzlocal_GetCurrentFileInfoInternal_220
movzx eax, byte [ebp-0x9]
unzlocal_GetCurrentFileInfoInternal_840:
shl eax, 0x8
add eax, [ebp-0x88]
mov ecx, [ebp-0x84]
test ecx, ecx
jnz unzlocal_GetCurrentFileInfoInternal_230
unzlocal_GetCurrentFileInfoInternal_520:
mov [ebp-0x3c], eax
unzlocal_GetCurrentFileInfoInternal_530:
mov esi, [edi]
mov [esp+0xc], esi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov eax, [ebp-0xc8]
mov [esp], eax
call fread
sub eax, 0x1
jnz unzlocal_GetCurrentFileInfoInternal_240
movzx edx, byte [ebp-0x9]
mov [ebp-0x80], edx
mov dword [ebp-0x7c], 0x0
unzlocal_GetCurrentFileInfoInternal_950:
mov [esp+0xc], esi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov ecx, [ebp-0xc8]
mov [esp], ecx
call fread
sub eax, 0x1
jnz unzlocal_GetCurrentFileInfoInternal_250
movzx eax, byte [ebp-0x9]
unzlocal_GetCurrentFileInfoInternal_800:
shl eax, 0x8
add eax, [ebp-0x80]
mov edx, [ebp-0x7c]
test edx, edx
jnz unzlocal_GetCurrentFileInfoInternal_260
unzlocal_GetCurrentFileInfoInternal_490:
mov [ebp-0x38], eax
unzlocal_GetCurrentFileInfoInternal_500:
mov esi, [edi]
mov [esp+0xc], esi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov eax, [ebp-0xc8]
mov [esp], eax
call fread
sub eax, 0x1
jnz unzlocal_GetCurrentFileInfoInternal_270
movzx edx, byte [ebp-0x9]
mov [ebp-0x78], edx
mov dword [ebp-0x74], 0x0
unzlocal_GetCurrentFileInfoInternal_990:
mov [esp+0xc], esi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov ecx, [ebp-0xc8]
mov [esp], ecx
call fread
sub eax, 0x1
jnz unzlocal_GetCurrentFileInfoInternal_280
movzx eax, byte [ebp-0x9]
unzlocal_GetCurrentFileInfoInternal_780:
shl eax, 0x8
add eax, [ebp-0x78]
mov esi, [ebp-0x74]
test esi, esi
jnz unzlocal_GetCurrentFileInfoInternal_290
unzlocal_GetCurrentFileInfoInternal_460:
mov [ebp-0x34], eax
unzlocal_GetCurrentFileInfoInternal_470:
lea edx, [ebp-0x30]
mov eax, [edi]
call unzlocal_getLong
mov esi, 0xffffffff
test eax, eax
mov eax, [ebp-0xbc]
cmovnz eax, esi
mov [ebp-0xbc], eax
lea edx, [ebp-0x10]
mov eax, [edi]
call unzlocal_getLong
test eax, eax
cmovz esi, [ebp-0xbc]
mov [ebp-0xbc], esi
mov esi, [ebp-0x44]
mov ecx, [ebp-0xbc]
test ecx, ecx
jnz unzlocal_GetCurrentFileInfoInternal_300
mov edx, [ebp+0x8]
test edx, edx
jz unzlocal_GetCurrentFileInfoInternal_310
cmp esi, [ebp+0xc]
jb unzlocal_GetCurrentFileInfoInternal_320
mov edx, [ebp+0xc]
mov [ebp-0x70], edx
unzlocal_GetCurrentFileInfoInternal_1040:
mov eax, [ebp-0x44]
test eax, eax
jz unzlocal_GetCurrentFileInfoInternal_330
mov eax, [ebp+0xc]
test eax, eax
jnz unzlocal_GetCurrentFileInfoInternal_340
unzlocal_GetCurrentFileInfoInternal_330:
mov dword [ebp-0xbc], 0x0
unzlocal_GetCurrentFileInfoInternal_1070:
sub esi, [ebp-0x70]
mov eax, [ebp-0xbc]
test eax, eax
jz unzlocal_GetCurrentFileInfoInternal_310
unzlocal_GetCurrentFileInfoInternal_300:
mov edx, esi
add edx, [ebp-0x40]
unzlocal_GetCurrentFileInfoInternal_920:
mov esi, [ebp-0xbc]
test esi, esi
jnz unzlocal_GetCurrentFileInfoInternal_350
mov ecx, [ebp+0x18]
test ecx, ecx
jz unzlocal_GetCurrentFileInfoInternal_360
mov eax, [ebp-0x3c]
cmp eax, [ebp+0x1c]
jb unzlocal_GetCurrentFileInfoInternal_370
mov esi, [ebp+0x1c]
test edx, edx
jnz unzlocal_GetCurrentFileInfoInternal_380
unzlocal_GetCurrentFileInfoInternal_930:
mov dword [ebp-0xbc], 0x0
unzlocal_GetCurrentFileInfoInternal_940:
mov eax, [ebp-0x3c]
test eax, eax
jz unzlocal_GetCurrentFileInfoInternal_390
mov eax, [ebp+0x1c]
test eax, eax
jnz unzlocal_GetCurrentFileInfoInternal_400
unzlocal_GetCurrentFileInfoInternal_390:
mov eax, [ebp-0xbc]
test eax, eax
jnz unzlocal_GetCurrentFileInfoInternal_350
unzlocal_GetCurrentFileInfoInternal_360:
mov eax, [ebp-0xc0]
test eax, eax
jz unzlocal_GetCurrentFileInfoInternal_410
lea eax, [ebp-0x64]
mov dword [esp+0x8], 0x50
mov [esp+0x4], eax
mov edx, [ebp-0xc0]
mov [esp], edx
call memcpy
unzlocal_GetCurrentFileInfoInternal_410:
mov eax, [ebp-0xc4]
test eax, eax
jz unzlocal_GetCurrentFileInfoInternal_350
mov eax, [ebp-0x10]
mov ecx, [ebp-0xc4]
mov [ecx], eax
unzlocal_GetCurrentFileInfoInternal_350:
mov eax, [ebp-0xbc]
add esp, 0xd0
pop esi
pop edi
pop ebp
ret
unzlocal_GetCurrentFileInfoInternal_30:
movzx edx, byte [ebp-0x9]
mov [ebp-0xb8], edx
mov dword [ebp-0xb4], 0x0
unzlocal_GetCurrentFileInfoInternal_1030:
mov [esp+0xc], esi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov ecx, [ebp-0xc8]
mov [esp], ecx
call fread
sub eax, 0x1
jnz unzlocal_GetCurrentFileInfoInternal_420
movzx eax, byte [ebp-0x9]
shl eax, 0x8
add eax, [ebp-0xb8]
mov ecx, [ebp-0xb4]
test ecx, ecx
jz unzlocal_GetCurrentFileInfoInternal_430
unzlocal_GetCurrentFileInfoInternal_50:
mov dword [ebp-0x64], 0x0
mov dword [ebp-0xbc], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_440
unzlocal_GetCurrentFileInfoInternal_270:
mov [esp], esi
call ferror
test eax, eax
jz unzlocal_GetCurrentFileInfoInternal_450
mov dword [ebp-0x74], 0xffffffff
mov eax, [ebp-0x78]
shl eax, 0x8
add eax, [ebp-0x78]
mov esi, [ebp-0x74]
test esi, esi
jz unzlocal_GetCurrentFileInfoInternal_460
unzlocal_GetCurrentFileInfoInternal_290:
mov dword [ebp-0x34], 0x0
mov dword [ebp-0xbc], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_470
unzlocal_GetCurrentFileInfoInternal_240:
mov [esp], esi
call ferror
test eax, eax
jz unzlocal_GetCurrentFileInfoInternal_480
mov dword [ebp-0x7c], 0xffffffff
mov eax, [ebp-0x80]
shl eax, 0x8
add eax, [ebp-0x80]
mov edx, [ebp-0x7c]
test edx, edx
jz unzlocal_GetCurrentFileInfoInternal_490
unzlocal_GetCurrentFileInfoInternal_260:
mov dword [ebp-0x38], 0x0
mov dword [ebp-0xbc], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_500
unzlocal_GetCurrentFileInfoInternal_210:
mov [esp], esi
call ferror
test eax, eax
jz unzlocal_GetCurrentFileInfoInternal_510
mov dword [ebp-0x84], 0xffffffff
mov eax, [ebp-0x88]
shl eax, 0x8
add eax, [ebp-0x88]
mov ecx, [ebp-0x84]
test ecx, ecx
jz unzlocal_GetCurrentFileInfoInternal_520
unzlocal_GetCurrentFileInfoInternal_230:
mov dword [ebp-0x3c], 0x0
mov dword [ebp-0xbc], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_530
unzlocal_GetCurrentFileInfoInternal_180:
mov [esp], esi
call ferror
test eax, eax
jz unzlocal_GetCurrentFileInfoInternal_540
mov dword [ebp-0x8c], 0xffffffff
mov eax, [ebp-0x90]
shl eax, 0x8
add eax, [ebp-0x90]
mov esi, [ebp-0x8c]
test esi, esi
jz unzlocal_GetCurrentFileInfoInternal_550
unzlocal_GetCurrentFileInfoInternal_200:
mov dword [ebp-0x40], 0x0
mov dword [ebp-0xbc], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_560
unzlocal_GetCurrentFileInfoInternal_90:
mov [esp], esi
call ferror
test eax, eax
jz unzlocal_GetCurrentFileInfoInternal_570
mov dword [ebp-0xa4], 0xffffffff
mov eax, [ebp-0xa8]
shl eax, 0x8
add eax, [ebp-0xa8]
mov esi, [ebp-0xa4]
test esi, esi
jz unzlocal_GetCurrentFileInfoInternal_580
unzlocal_GetCurrentFileInfoInternal_110:
mov dword [ebp-0x5c], 0x0
mov dword [ebp-0xbc], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_590
unzlocal_GetCurrentFileInfoInternal_150:
mov [esp], esi
call ferror
test eax, eax
jz unzlocal_GetCurrentFileInfoInternal_600
mov dword [ebp-0x94], 0xffffffff
mov eax, [ebp-0x98]
shl eax, 0x8
add eax, [ebp-0x98]
mov edx, [ebp-0x94]
test edx, edx
jz unzlocal_GetCurrentFileInfoInternal_610
unzlocal_GetCurrentFileInfoInternal_170:
mov dword [ebp-0x44], 0x0
mov dword [ebp-0xbc], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_620
unzlocal_GetCurrentFileInfoInternal_60:
mov [esp], esi
call ferror
test eax, eax
jz unzlocal_GetCurrentFileInfoInternal_630
mov dword [ebp-0xac], 0xffffffff
mov eax, [ebp-0xb0]
shl eax, 0x8
add eax, [ebp-0xb0]
mov edx, [ebp-0xac]
test edx, edx
jz unzlocal_GetCurrentFileInfoInternal_640
unzlocal_GetCurrentFileInfoInternal_80:
mov dword [ebp-0x60], 0x0
mov dword [ebp-0xbc], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_650
unzlocal_GetCurrentFileInfoInternal_120:
mov [esp], esi
call ferror
test eax, eax
jz unzlocal_GetCurrentFileInfoInternal_660
mov dword [ebp-0x9c], 0xffffffff
mov eax, [ebp-0xa0]
shl eax, 0x8
add eax, [ebp-0xa0]
mov ecx, [ebp-0x9c]
test ecx, ecx
jz unzlocal_GetCurrentFileInfoInternal_670
unzlocal_GetCurrentFileInfoInternal_140:
mov dword [ebp-0x58], 0x0
mov dword [ebp-0xbc], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_680
unzlocal_GetCurrentFileInfoInternal_190:
mov [esp], esi
call ferror
test eax, eax
jnz unzlocal_GetCurrentFileInfoInternal_690
mov eax, [ebp-0x90]
jmp unzlocal_GetCurrentFileInfoInternal_700
unzlocal_GetCurrentFileInfoInternal_160:
mov [esp], esi
call ferror
test eax, eax
jnz unzlocal_GetCurrentFileInfoInternal_710
mov eax, [ebp-0x98]
jmp unzlocal_GetCurrentFileInfoInternal_720
unzlocal_GetCurrentFileInfoInternal_130:
mov [esp], esi
call ferror
test eax, eax
jnz unzlocal_GetCurrentFileInfoInternal_730
mov eax, [ebp-0xa0]
jmp unzlocal_GetCurrentFileInfoInternal_740
unzlocal_GetCurrentFileInfoInternal_420:
mov [esp], esi
call ferror
test eax, eax
jnz unzlocal_GetCurrentFileInfoInternal_750
mov eax, [ebp-0xb8]
jmp unzlocal_GetCurrentFileInfoInternal_760
unzlocal_GetCurrentFileInfoInternal_280:
mov [esp], esi
call ferror
test eax, eax
jnz unzlocal_GetCurrentFileInfoInternal_770
mov eax, [ebp-0x78]
jmp unzlocal_GetCurrentFileInfoInternal_780
unzlocal_GetCurrentFileInfoInternal_250:
mov [esp], esi
call ferror
test eax, eax
jnz unzlocal_GetCurrentFileInfoInternal_790
mov eax, [ebp-0x80]
jmp unzlocal_GetCurrentFileInfoInternal_800
unzlocal_GetCurrentFileInfoInternal_70:
mov [esp], esi
call ferror
test eax, eax
jnz unzlocal_GetCurrentFileInfoInternal_810
mov eax, [ebp-0xb0]
jmp unzlocal_GetCurrentFileInfoInternal_820
unzlocal_GetCurrentFileInfoInternal_220:
mov [esp], esi
call ferror
test eax, eax
jnz unzlocal_GetCurrentFileInfoInternal_830
mov eax, [ebp-0x88]
jmp unzlocal_GetCurrentFileInfoInternal_840
unzlocal_GetCurrentFileInfoInternal_100:
mov [esp], esi
call ferror
test eax, eax
jnz unzlocal_GetCurrentFileInfoInternal_850
mov eax, [ebp-0xa8]
jmp unzlocal_GetCurrentFileInfoInternal_860
unzlocal_GetCurrentFileInfoInternal_20:
lea edx, [ebp-0x14]
mov eax, [edi]
call unzlocal_getLong
test eax, eax
jnz unzlocal_GetCurrentFileInfoInternal_870
mov dword [ebp-0xbc], 0xffffff99
cmp dword [ebp-0x14], 0x2014b50
cmovnz eax, [ebp-0xbc]
mov [ebp-0xbc], eax
jmp unzlocal_GetCurrentFileInfoInternal_880
unzlocal_GetCurrentFileInfoInternal_310:
mov eax, [ebp+0x10]
test eax, eax
jz unzlocal_GetCurrentFileInfoInternal_300
mov ecx, [ebp-0x40]
mov eax, [ebp+0x14]
cmp ecx, eax
cmovb eax, ecx
mov [ebp-0x6c], eax
test esi, esi
jnz unzlocal_GetCurrentFileInfoInternal_890
unzlocal_GetCurrentFileInfoInternal_1050:
mov dword [ebp-0xbc], 0x0
xor esi, esi
unzlocal_GetCurrentFileInfoInternal_1060:
mov eax, [ebp-0x40]
test eax, eax
jz unzlocal_GetCurrentFileInfoInternal_900
mov eax, [ebp+0x14]
test eax, eax
jnz unzlocal_GetCurrentFileInfoInternal_910
unzlocal_GetCurrentFileInfoInternal_900:
mov eax, [ebp-0x40]
sub eax, [ebp-0x6c]
lea edx, [esi+eax]
jmp unzlocal_GetCurrentFileInfoInternal_920
unzlocal_GetCurrentFileInfoInternal_370:
mov ecx, [ebp+0x18]
mov byte [ecx+eax], 0x0
mov esi, eax
test edx, edx
jz unzlocal_GetCurrentFileInfoInternal_930
unzlocal_GetCurrentFileInfoInternal_380:
mov dword [esp+0x8], 0x1
mov [esp+0x4], edx
mov eax, [edi]
mov [esp], eax
call fseek
test eax, eax
jz unzlocal_GetCurrentFileInfoInternal_930
mov dword [ebp-0xbc], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_940
unzlocal_GetCurrentFileInfoInternal_10:
mov dword [ebp-0xbc], 0xffffff9a
mov eax, [ebp-0xbc]
add esp, 0xd0
pop esi
pop edi
pop ebp
ret
unzlocal_GetCurrentFileInfoInternal_480:
mov dword [ebp-0x7c], 0x0
jmp unzlocal_GetCurrentFileInfoInternal_950
unzlocal_GetCurrentFileInfoInternal_510:
mov dword [ebp-0x84], 0x0
jmp unzlocal_GetCurrentFileInfoInternal_960
unzlocal_GetCurrentFileInfoInternal_570:
mov dword [ebp-0xa4], 0x0
jmp unzlocal_GetCurrentFileInfoInternal_970
unzlocal_GetCurrentFileInfoInternal_660:
mov dword [ebp-0x9c], 0x0
jmp unzlocal_GetCurrentFileInfoInternal_980
unzlocal_GetCurrentFileInfoInternal_450:
mov dword [ebp-0x74], 0x0
jmp unzlocal_GetCurrentFileInfoInternal_990
unzlocal_GetCurrentFileInfoInternal_630:
mov dword [ebp-0xac], 0x0
jmp unzlocal_GetCurrentFileInfoInternal_1000
unzlocal_GetCurrentFileInfoInternal_600:
mov dword [ebp-0x94], 0x0
jmp unzlocal_GetCurrentFileInfoInternal_1010
unzlocal_GetCurrentFileInfoInternal_540:
mov dword [ebp-0x8c], 0x0
jmp unzlocal_GetCurrentFileInfoInternal_1020
unzlocal_GetCurrentFileInfoInternal_40:
mov dword [ebp-0xb4], 0x0
jmp unzlocal_GetCurrentFileInfoInternal_1030
unzlocal_GetCurrentFileInfoInternal_320:
mov ecx, [ebp+0x8]
mov byte [ecx+esi], 0x0
mov [ebp-0x70], esi
jmp unzlocal_GetCurrentFileInfoInternal_1040
unzlocal_GetCurrentFileInfoInternal_710:
mov eax, [ebp-0x98]
mov dword [ebp-0x94], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_720
unzlocal_GetCurrentFileInfoInternal_690:
mov eax, [ebp-0x90]
mov dword [ebp-0x8c], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_700
unzlocal_GetCurrentFileInfoInternal_850:
mov eax, [ebp-0xa8]
mov dword [ebp-0xa4], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_860
unzlocal_GetCurrentFileInfoInternal_830:
mov eax, [ebp-0x88]
mov dword [ebp-0x84], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_840
unzlocal_GetCurrentFileInfoInternal_810:
mov eax, [ebp-0xb0]
mov dword [ebp-0xac], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_820
unzlocal_GetCurrentFileInfoInternal_790:
mov eax, [ebp-0x80]
mov dword [ebp-0x7c], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_800
unzlocal_GetCurrentFileInfoInternal_770:
mov eax, [ebp-0x78]
mov dword [ebp-0x74], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_780
unzlocal_GetCurrentFileInfoInternal_750:
mov eax, [ebp-0xb8]
mov dword [ebp-0xb4], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_760
unzlocal_GetCurrentFileInfoInternal_730:
mov eax, [ebp-0xa0]
mov dword [ebp-0x9c], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_740
unzlocal_GetCurrentFileInfoInternal_400:
mov eax, [edi]
mov [esp+0xc], eax
mov [esp+0x8], esi
mov dword [esp+0x4], 0x1
mov eax, [ebp+0x18]
mov [esp], eax
call fread
cmp esi, eax
jz unzlocal_GetCurrentFileInfoInternal_390
mov dword [ebp-0xbc], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_350
unzlocal_GetCurrentFileInfoInternal_890:
mov dword [esp+0x8], 0x1
mov [esp+0x4], esi
mov eax, [edi]
mov [esp], eax
call fseek
test eax, eax
jz unzlocal_GetCurrentFileInfoInternal_1050
mov dword [ebp-0xbc], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_1060
unzlocal_GetCurrentFileInfoInternal_340:
mov eax, [edi]
mov [esp+0xc], eax
mov eax, [ebp-0x70]
mov [esp+0x8], eax
mov dword [esp+0x4], 0x1
mov edx, [ebp+0x8]
mov [esp], edx
call fread
cmp [ebp-0x70], eax
jz unzlocal_GetCurrentFileInfoInternal_330
mov dword [ebp-0xbc], 0xffffffff
jmp unzlocal_GetCurrentFileInfoInternal_1070
unzlocal_GetCurrentFileInfoInternal_910:
mov eax, [edi]
mov [esp+0xc], eax
mov edx, [ebp-0x6c]
mov [esp+0x8], edx
mov dword [esp+0x4], 0x1
mov ecx, [ebp+0x10]
mov [esp], ecx
call fread
cmp [ebp-0x6c], eax
mov eax, 0xffffffff
cmovz eax, [ebp-0xbc]
mov [ebp-0xbc], eax
jmp unzlocal_GetCurrentFileInfoInternal_900
;unzClose
unzClose:
push ebp
mov ebp, esp
push edi
push esi
sub esp, 0x10
mov edi, [ebp+0x8]
test edi, edi
jz unzClose_10
mov esi, [edi+0x7c]
test esi, esi
jz unzClose_20
mov eax, [esi]
mov [esp], eax
call free
mov dword [esi], 0x0
mov eax, [esi+0x3c]
test eax, eax
jnz unzClose_30
unzClose_40:
mov dword [esi+0x3c], 0x0
mov [esp], esi
call free
mov dword [edi+0x7c], 0x0
unzClose_20:
mov eax, [edi]
mov [esp], eax
call fclose
mov [esp], edi
call free
xor eax, eax
add esp, 0x10
pop esi
pop edi
pop ebp
ret
unzClose_30:
lea eax, [esi+0x4]
mov [esp], eax
call inflateEnd
jmp unzClose_40
unzClose_10:
mov eax, 0xffffff9a
add esp, 0x10
pop esi
pop edi
pop ebp
ret
;unzCloseCurrentFile
unzCloseCurrentFile:
push ebp
mov ebp, esp
push edi
push esi
sub esp, 0x10
mov edi, [ebp+0x8]
test edi, edi
jnz unzCloseCurrentFile_10
unzCloseCurrentFile_20:
mov eax, 0xffffff9a
add esp, 0x10
pop esi
pop edi
pop ebp
ret
unzCloseCurrentFile_10:
mov esi, [edi+0x7c]
test esi, esi
jz unzCloseCurrentFile_20
mov eax, [esi]
mov [esp], eax
call free
mov dword [esi], 0x0
mov edx, [esi+0x3c]
test edx, edx
jnz unzCloseCurrentFile_30
unzCloseCurrentFile_40:
mov dword [esi+0x3c], 0x0
mov [esp], esi
call free
mov dword [edi+0x7c], 0x0
xor eax, eax
add esp, 0x10
pop esi
pop edi
pop ebp
ret
unzCloseCurrentFile_30:
lea eax, [esi+0x4]
mov [esp], eax
call inflateEnd
jmp unzCloseCurrentFile_40
;unzGetCurrentFileInfo
unzGetCurrentFileInfo:
push ebp
mov ebp, esp
push edi
push esi
mov eax, [ebp+0x8]
mov edx, [ebp+0xc]
mov ecx, [ebp+0x10]
mov [ebp+0x8], ecx
mov ecx, [ebp+0x14]
mov [ebp+0xc], ecx
mov edi, [ebp+0x18]
mov esi, [ebp+0x1c]
mov ecx, [ebp+0x24]
mov [ebp+0x1c], ecx
mov ecx, [ebp+0x20]
mov [ebp+0x18], ecx
mov [ebp+0x14], esi
mov [ebp+0x10], edi
xor ecx, ecx
pop esi
pop edi
pop ebp
jmp unzlocal_GetCurrentFileInfoInternal
;unzGetCurrentFileInfoPosition
unzGetCurrentFileInfoPosition:
push ebp
mov ebp, esp
mov eax, [ebp+0x8]
test eax, eax
jz unzGetCurrentFileInfoPosition_10
mov eax, [eax+0x14]
mov edx, [ebp+0xc]
mov [edx], eax
xor eax, eax
pop ebp
ret
unzGetCurrentFileInfoPosition_10:
mov eax, 0xffffff9a
pop ebp
ret
;unzGetGlobalInfo
unzGetGlobalInfo:
push ebp
mov ebp, esp
mov eax, [ebp+0x8]
test eax, eax
jz unzGetGlobalInfo_10
mov edx, [eax+0x8]
mov eax, [eax+0x4]
mov ecx, [ebp+0xc]
mov [ecx], eax
mov [ecx+0x4], edx
xor eax, eax
pop ebp
ret
unzGetGlobalInfo_10:
mov eax, 0xffffff9a
pop ebp
ret
;unzGoToFirstFile
unzGoToFirstFile:
push ebp
mov ebp, esp
push esi
sub esp, 0x24
mov esi, [ebp+0x8]
test esi, esi
jz unzGoToFirstFile_10
mov eax, [esi+0x24]
mov [esi+0x14], eax
mov dword [esi+0x10], 0x0
lea ecx, [esi+0x78]
lea edx, [esi+0x28]
mov dword [esp+0x14], 0x0
mov dword [esp+0x10], 0x0
mov dword [esp+0xc], 0x0
mov dword [esp+0x8], 0x0
mov dword [esp+0x4], 0x0
mov dword [esp], 0x0
mov eax, esi
call unzlocal_GetCurrentFileInfoInternal
mov edx, eax
xor eax, eax
test edx, edx
setz al
mov [esi+0x18], eax
mov eax, edx
add esp, 0x24
pop esi
pop ebp
ret
unzGoToFirstFile_10:
mov edx, 0xffffff9a
mov eax, edx
add esp, 0x24
pop esi
pop ebp
ret
;unzGoToNextFile
unzGoToNextFile:
push ebp
mov ebp, esp
push esi
sub esp, 0x24
mov esi, [ebp+0x8]
test esi, esi
jnz unzGoToNextFile_10
mov edx, 0xffffff9a
unzGoToNextFile_40:
mov eax, edx
add esp, 0x24
pop esi
pop ebp
ret
unzGoToNextFile_10:
mov eax, [esi+0x18]
test eax, eax
jnz unzGoToNextFile_20
unzGoToNextFile_30:
mov edx, 0xffffff9c
mov eax, edx
add esp, 0x24
pop esi
pop ebp
ret
unzGoToNextFile_20:
mov edx, [esi+0x10]
add edx, 0x1
cmp edx, [esi+0x4]
jz unzGoToNextFile_30
mov eax, [esi+0x48]
add eax, [esi+0x4c]
add eax, [esi+0x50]
add eax, [esi+0x14]
add eax, 0x2e
mov [esi+0x14], eax
mov [esi+0x10], edx
lea ecx, [esi+0x78]
lea edx, [esi+0x28]
mov dword [esp+0x14], 0x0
mov dword [esp+0x10], 0x0
mov dword [esp+0xc], 0x0
mov dword [esp+0x8], 0x0
mov dword [esp+0x4], 0x0
mov dword [esp], 0x0
mov eax, esi
call unzlocal_GetCurrentFileInfoInternal
mov edx, eax
xor eax, eax
test edx, edx
setz al
mov [esi+0x18], eax
jmp unzGoToNextFile_40
;unzOpen
unzOpen:
push ebp
mov ebp, esp
push edi
push esi
push ebx
sub esp, 0xfc
call __i686.get_pc_thunk.bx
lea eax, [ebx+0x203ac]
mov [esp+0x4], eax
mov eax, [ebp+0x8]
mov [esp], eax
call fopen
mov [ebp-0xd8], eax
test eax, eax
jz unzOpen_10
mov [esp], eax
call fileno
cmp eax, 0xffffffff
jz unzOpen_20
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x2d
mov [esp], eax
call fcntl
unzOpen_20:
mov eax, [ebp-0xd8]
mov [esp], eax
call FS_FileGetFileSize
mov [ebp-0xac], eax
cmp eax, 0xfffe
ja unzOpen_30
mov [ebp-0xc8], eax
mov dword [esp], 0x404
call malloc
mov [ebp-0xe0], eax
test eax, eax
jz unzOpen_40
unzOpen_310:
cmp dword [ebp-0xc8], 0x4
jbe unzOpen_50
mov edi, 0x4
unzOpen_90:
add edi, 0x400
cmp [ebp-0xc8], edi
cmovb edi, [ebp-0xc8]
mov edx, [ebp-0xac]
sub edx, edi
mov [ebp-0xc4], edx
mov esi, [ebp-0xac]
sub esi, edx
cmp esi, 0x405
mov eax, 0x404
cmovae esi, eax
mov dword [esp+0x8], 0x0
mov [esp+0x4], edx
mov eax, [ebp-0xd8]
mov [esp], eax
call fseek
test eax, eax
jnz unzOpen_50
mov edx, [ebp-0xd8]
mov [esp+0xc], edx
mov [esp+0x8], esi
mov dword [esp+0x4], 0x1
mov eax, [ebp-0xe0]
mov [esp], eax
call fread
cmp esi, eax
jnz unzOpen_50
lea ecx, [esi-0x3]
mov edx, [ebp-0xe0]
add edx, ecx
sub ecx, 0x1
lea eax, [ecx+0x1]
test eax, eax
jle unzOpen_60
unzOpen_80:
cmp byte [edx-0x1], 0x50
jz unzOpen_70
unzOpen_290:
sub edx, 0x1
sub ecx, 0x1
lea eax, [ecx+0x1]
test eax, eax
jg unzOpen_80
unzOpen_60:
cmp [ebp-0xc8], edi
ja unzOpen_90
unzOpen_50:
mov dword [ebp-0xdc], 0x0
unzOpen_300:
mov edx, [ebp-0xe0]
mov [esp], edx
call free
mov edi, [ebp-0xdc]
test edi, edi
jnz unzOpen_100
mov dword [ebp-0xcc], 0xffffffff
xor eax, eax
unzOpen_320:
mov dword [esp+0x8], 0x0
mov [esp+0x4], eax
mov eax, [ebp-0xd8]
mov [esp], eax
call fseek
mov esi, 0xffffffff
test eax, eax
mov edx, [ebp-0xcc]
cmovnz edx, esi
mov [ebp-0xcc], edx
lea edx, [ebp-0x20]
mov eax, [ebp-0xd8]
call unzlocal_getLong
test eax, eax
cmovz esi, [ebp-0xcc]
mov [ebp-0xcc], esi
mov eax, [ebp-0xd8]
mov [esp+0xc], eax
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
lea edi, [ebp-0x19]
mov [esp], edi
call fread
sub eax, 0x1
jnz unzOpen_110
movzx edx, byte [ebp-0x19]
mov [ebp-0xc0], edx
xor esi, esi
unzOpen_380:
mov edx, [ebp-0xd8]
mov [esp+0xc], edx
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov [esp], edi
call fread
sub eax, 0x1
jnz unzOpen_120
movzx eax, byte [ebp-0x19]
unzOpen_480:
shl eax, 0x8
add eax, [ebp-0xc0]
mov [ebp-0xd4], eax
test esi, esi
jz unzOpen_130
mov dword [ebp-0xcc], 0xffffffff
mov dword [ebp-0xd4], 0x0
unzOpen_130:
mov edx, [ebp-0xd8]
mov [esp+0xc], edx
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov [esp], edi
call fread
sub eax, 0x1
jnz unzOpen_140
movzx eax, byte [ebp-0x19]
mov [ebp-0xbc], eax
xor esi, esi
unzOpen_420:
mov eax, [ebp-0xd8]
mov [esp+0xc], eax
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov [esp], edi
call fread
sub eax, 0x1
jnz unzOpen_150
movzx eax, byte [ebp-0x19]
unzOpen_540:
shl eax, 0x8
add eax, [ebp-0xbc]
mov [ebp-0xd0], eax
test esi, esi
jz unzOpen_160
mov dword [ebp-0xcc], 0xffffffff
mov dword [ebp-0xd0], 0x0
unzOpen_160:
mov eax, [ebp-0xd8]
mov [esp+0xc], eax
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov [esp], edi
call fread
sub eax, 0x1
jnz unzOpen_170
movzx edx, byte [ebp-0x19]
mov [ebp-0xb8], edx
xor esi, esi
unzOpen_400:
mov edx, [ebp-0xd8]
mov [esp+0xc], edx
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov [esp], edi
call fread
sub eax, 0x1
jnz unzOpen_180
movzx eax, byte [ebp-0x19]
unzOpen_520:
shl eax, 0x8
add eax, [ebp-0xb8]
test esi, esi
jnz unzOpen_190
mov [ebp-0x9c], eax
unzOpen_430:
mov edx, [ebp-0xd8]
mov [esp+0xc], edx
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov [esp], edi
call fread
sub eax, 0x1
jnz unzOpen_200
movzx eax, byte [ebp-0x19]
mov [ebp-0xb4], eax
xor esi, esi
unzOpen_360:
mov eax, [ebp-0xd8]
mov [esp+0xc], eax
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov [esp], edi
call fread
sub eax, 0x1
jnz unzOpen_210
movzx eax, byte [ebp-0x19]
unzOpen_460:
shl eax, 0x8
add eax, [ebp-0xb4]
test esi, esi
jz unzOpen_220
mov dword [ebp-0xcc], 0xffffffff
xor eax, eax
unzOpen_220:
cmp [ebp-0x9c], eax
jz unzOpen_230
unzOpen_550:
mov dword [ebp-0xcc], 0xffffff99
unzOpen_560:
lea edx, [ebp-0x80]
mov eax, [ebp-0xd8]
call unzlocal_getLong
mov esi, 0xffffffff
test eax, eax
mov eax, [ebp-0xcc]
cmovnz eax, esi
mov [ebp-0xcc], eax
lea edx, [ebp-0x7c]
mov eax, [ebp-0xd8]
call unzlocal_getLong
test eax, eax
cmovz esi, [ebp-0xcc]
mov [ebp-0xcc], esi
mov edx, [ebp-0xd8]
mov [esp+0xc], edx
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov [esp], edi
call fread
sub eax, 0x1
jnz unzOpen_240
movzx eax, byte [ebp-0x19]
mov [ebp-0xb0], eax
xor esi, esi
unzOpen_340:
mov eax, [ebp-0xd8]
mov [esp+0xc], eax
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov [esp], edi
call fread
sub eax, 0x1
jnz unzOpen_250
movzx eax, byte [ebp-0x19]
unzOpen_500:
shl eax, 0x8
add eax, [ebp-0xb0]
test esi, esi
jnz unzOpen_260
mov [ebp-0x98], eax
unzOpen_440:
mov eax, [ebp-0x7c]
add eax, [ebp-0x80]
cmp eax, [ebp-0xdc]
ja unzOpen_270
mov edx, [ebp-0xcc]
test edx, edx
jz unzOpen_280
unzOpen_270:
mov eax, [ebp-0xd8]
mov [esp], eax
call fclose
xor esi, esi
mov eax, esi
add esp, 0xfc
pop ebx
pop esi
pop edi
pop ebp
ret
unzOpen_70:
cmp byte [edx], 0x4b
jnz unzOpen_290
cmp byte [edx+0x1], 0x5
jnz unzOpen_290
cmp byte [edx+0x2], 0x6
jnz unzOpen_290
add ecx, [ebp-0xc4]
mov [ebp-0xdc], ecx
jz unzOpen_60
jmp unzOpen_300
unzOpen_30:
mov dword [ebp-0xc8], 0xffff
mov dword [esp], 0x404
call malloc
mov [ebp-0xe0], eax
test eax, eax
jnz unzOpen_310
unzOpen_40:
mov dword [ebp-0xcc], 0xffffffff
mov dword [ebp-0xdc], 0x0
jmp unzOpen_320
unzOpen_10:
xor esi, esi
mov eax, esi
add esp, 0xfc
pop ebx
pop esi
pop edi
pop ebp
ret
unzOpen_240:
mov edx, [ebp-0xd8]
mov [esp], edx
call ferror
test eax, eax
jnz unzOpen_330
xor esi, esi
jmp unzOpen_340
unzOpen_200:
mov edx, [ebp-0xd8]
mov [esp], edx
call ferror
test eax, eax
jnz unzOpen_350
xor esi, esi
jmp unzOpen_360
unzOpen_110:
mov eax, [ebp-0xd8]
mov [esp], eax
call ferror
test eax, eax
jnz unzOpen_370
xor esi, esi
jmp unzOpen_380
unzOpen_170:
mov eax, [ebp-0xd8]
mov [esp], eax
call ferror
test eax, eax
jnz unzOpen_390
xor esi, esi
jmp unzOpen_400
unzOpen_140:
mov edx, [ebp-0xd8]
mov [esp], edx
call ferror
test eax, eax
jnz unzOpen_410
xor esi, esi
jmp unzOpen_420
unzOpen_190:
mov dword [ebp-0x9c], 0x0
mov dword [ebp-0xcc], 0xffffffff
jmp unzOpen_430
unzOpen_260:
mov dword [ebp-0x98], 0x0
mov dword [ebp-0xcc], 0xffffffff
jmp unzOpen_440
unzOpen_100:
mov eax, [ebp-0xdc]
mov dword [ebp-0xcc], 0x0
jmp unzOpen_320
unzOpen_210:
mov edx, [ebp-0xd8]
mov [esp], edx
call ferror
test eax, eax
jnz unzOpen_450
mov eax, [ebp-0xb4]
jmp unzOpen_460
unzOpen_120:
mov eax, [ebp-0xd8]
mov [esp], eax
call ferror
test eax, eax
jnz unzOpen_470
mov eax, [ebp-0xc0]
jmp unzOpen_480
unzOpen_250:
mov edx, [ebp-0xd8]
mov [esp], edx
call ferror
test eax, eax
jnz unzOpen_490
mov eax, [ebp-0xb0]
jmp unzOpen_500
unzOpen_180:
mov eax, [ebp-0xd8]
mov [esp], eax
call ferror
test eax, eax
jnz unzOpen_510
mov eax, [ebp-0xb8]
jmp unzOpen_520
unzOpen_150:
mov edx, [ebp-0xd8]
mov [esp], edx
call ferror
test eax, eax
jnz unzOpen_530
mov eax, [ebp-0xbc]
jmp unzOpen_540
unzOpen_410:
mov esi, 0xffffffff
mov eax, [ebp-0xbc]
jmp unzOpen_540
unzOpen_390:
mov esi, 0xffffffff
mov eax, [ebp-0xb8]
jmp unzOpen_520
unzOpen_370:
mov esi, 0xffffffff
mov eax, [ebp-0xc0]
jmp unzOpen_480
unzOpen_350:
mov esi, 0xffffffff
mov eax, [ebp-0xb4]
jmp unzOpen_460
unzOpen_330:
mov esi, 0xffffffff
mov eax, [ebp-0xb0]
jmp unzOpen_500
unzOpen_530:
mov eax, [ebp-0xbc]
mov esi, 0xffffffff
jmp unzOpen_540
unzOpen_510:
mov eax, [ebp-0xb8]
mov esi, 0xffffffff
jmp unzOpen_520
unzOpen_490:
mov eax, [ebp-0xb0]
mov esi, 0xffffffff
jmp unzOpen_500
unzOpen_470:
mov eax, [ebp-0xc0]
mov esi, 0xffffffff
jmp unzOpen_480
unzOpen_450:
mov eax, [ebp-0xb4]
mov esi, 0xffffffff
jmp unzOpen_460
unzOpen_230:
mov esi, [ebp-0xd0]
test esi, esi
jnz unzOpen_550
mov ecx, [ebp-0xd4]
test ecx, ecx
jz unzOpen_560
jmp unzOpen_550
unzOpen_280:
mov edx, [ebp-0xd8]
mov [ebp-0xa0], edx
mov edx, [ebp-0xdc]
sub edx, eax
mov [ebp-0x94], edx
mov eax, [ebp-0xdc]
mov [ebp-0x84], eax
mov dword [ebp-0x24], 0x0
mov dword [esp], 0x80
call malloc
mov esi, eax
lea eax, [ebp-0xa0]
mov dword [esp+0x8], 0x80
mov [esp+0x4], eax
mov [esp], esi
call memcpy
mov eax, [esi+0x24]
mov [esi+0x14], eax
mov dword [esi+0x10], 0x0
lea ecx, [esi+0x78]
lea edx, [esi+0x28]
mov dword [esp+0x14], 0x0
mov dword [esp+0x10], 0x0
mov dword [esp+0xc], 0x0
mov dword [esp+0x8], 0x0
mov dword [esp+0x4], 0x0
mov dword [esp], 0x0
mov eax, esi
call unzlocal_GetCurrentFileInfoInternal
test eax, eax
setz al
movzx eax, al
mov [esi+0x18], eax
mov eax, esi
add esp, 0xfc
pop ebx
pop esi
pop edi
pop ebp
ret
add [eax], al
;unzOpenCurrentFile
unzOpenCurrentFile:
push ebp
mov ebp, esp
push edi
push esi
push ebx
sub esp, 0x7c
call __i686.get_pc_thunk.bx
mov esi, [ebp+0x8]
test esi, esi
jnz unzOpenCurrentFile_10
unzOpenCurrentFile_20:
mov eax, 0xffffff9a
unzOpenCurrentFile_60:
add esp, 0x7c
pop ebx
pop esi
pop edi
pop ebp
ret
unzOpenCurrentFile_10:
mov edi, [esi+0x18]
test edi, edi
jz unzOpenCurrentFile_20
mov edi, [esi+0x7c]
test edi, edi
jz unzOpenCurrentFile_30
mov eax, [edi]
mov [esp], eax
call free
mov dword [edi], 0x0
mov ecx, [edi+0x3c]
test ecx, ecx
jnz unzOpenCurrentFile_40
unzOpenCurrentFile_320:
mov dword [edi+0x3c], 0x0
mov [esp], edi
call free
mov dword [esi+0x7c], 0x0
unzOpenCurrentFile_30:
mov dword [esp+0x8], 0x0
mov eax, [esi+0x78]
add eax, [esi+0xc]
mov [esp+0x4], eax
mov eax, [esi]
mov [esp], eax
call fseek
test eax, eax
jz unzOpenCurrentFile_50
unzOpenCurrentFile_280:
mov eax, 0xffffff99
jmp unzOpenCurrentFile_60
unzOpenCurrentFile_50:
lea edx, [ebp-0x24]
mov eax, [esi]
call unzlocal_getLong
test eax, eax
jz unzOpenCurrentFile_70
mov dword [ebp-0x54], 0xffffffff
unzOpenCurrentFile_440:
mov edi, [esi]
mov [esp+0xc], edi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
lea eax, [ebp-0x19]
mov [ebp-0x6c], eax
mov [esp], eax
call fread
sub eax, 0x1
jnz unzOpenCurrentFile_80
movzx eax, byte [ebp-0x19]
mov [ebp-0x50], eax
mov dword [ebp-0x4c], 0x0
unzOpenCurrentFile_540:
mov [esp+0xc], edi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov eax, [ebp-0x6c]
mov [esp], eax
call fread
sub eax, 0x1
jnz unzOpenCurrentFile_90
movzx eax, byte [ebp-0x19]
unzOpenCurrentFile_370:
shl eax, 0x8
add eax, [ebp-0x50]
mov edx, [ebp-0x4c]
test edx, edx
jnz unzOpenCurrentFile_100
mov [ebp-0x20], eax
unzOpenCurrentFile_490:
mov edi, [esi]
mov [esp+0xc], edi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov eax, [ebp-0x6c]
mov [esp], eax
call fread
sub eax, 0x1
jnz unzOpenCurrentFile_110
movzx eax, byte [ebp-0x19]
mov [ebp-0x48], eax
mov dword [ebp-0x44], 0x0
unzOpenCurrentFile_580:
mov [esp+0xc], edi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov eax, [ebp-0x6c]
mov [esp], eax
call fread
sub eax, 0x1
jnz unzOpenCurrentFile_120
movzx eax, byte [ebp-0x19]
unzOpenCurrentFile_410:
shl eax, 0x8
add eax, [ebp-0x48]
mov [ebp-0x60], eax
mov edi, [ebp-0x44]
test edi, edi
jz unzOpenCurrentFile_130
mov dword [ebp-0x54], 0xffffffff
mov dword [ebp-0x60], 0x0
unzOpenCurrentFile_130:
mov edi, [esi]
mov [esp+0xc], edi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov eax, [ebp-0x6c]
mov [esp], eax
call fread
sub eax, 0x1
jnz unzOpenCurrentFile_140
movzx eax, byte [ebp-0x19]
mov [ebp-0x40], eax
mov dword [ebp-0x3c], 0x0
unzOpenCurrentFile_590:
mov [esp+0xc], edi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov eax, [ebp-0x6c]
mov [esp], eax
call fread
sub eax, 0x1
jnz unzOpenCurrentFile_150
movzx eax, byte [ebp-0x19]
unzOpenCurrentFile_510:
shl eax, 0x8
add eax, [ebp-0x40]
mov ecx, [ebp-0x3c]
test ecx, ecx
jnz unzOpenCurrentFile_160
mov [ebp-0x20], eax
mov edx, [ebp-0x54]
test edx, edx
jnz unzOpenCurrentFile_170
cmp eax, [esi+0x34]
jz unzOpenCurrentFile_180
unzOpenCurrentFile_610:
mov dword [ebp-0x54], 0xffffff99
unzOpenCurrentFile_170:
lea edi, [ebp-0x20]
mov edx, edi
mov eax, [esi]
call unzlocal_getLong
test eax, eax
mov eax, 0xffffffff
cmovz eax, [ebp-0x54]
mov [ebp-0x54], eax
mov edx, edi
mov eax, [esi]
call unzlocal_getLong
test eax, eax
jz unzOpenCurrentFile_190
mov dword [ebp-0x54], 0xffffffff
unzOpenCurrentFile_420:
mov edx, edi
mov eax, [esi]
call unzlocal_getLong
test eax, eax
jz unzOpenCurrentFile_200
mov dword [ebp-0x54], 0xffffffff
unzOpenCurrentFile_470:
mov edx, edi
mov eax, [esi]
call unzlocal_getLong
test eax, eax
jz unzOpenCurrentFile_210
mov dword [ebp-0x54], 0xffffffff
unzOpenCurrentFile_450:
mov edi, [esi]
mov [esp+0xc], edi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov eax, [ebp-0x6c]
mov [esp], eax
call fread
sub eax, 0x1
jnz unzOpenCurrentFile_220
movzx eax, byte [ebp-0x19]
mov [ebp-0x38], eax
mov dword [ebp-0x34], 0x0
unzOpenCurrentFile_630:
mov [esp+0xc], edi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov eax, [ebp-0x6c]
mov [esp], eax
call fread
sub eax, 0x1
jnz unzOpenCurrentFile_230
movzx eax, byte [ebp-0x19]
unzOpenCurrentFile_390:
shl eax, 0x8
add eax, [ebp-0x38]
mov [ebp-0x5c], eax
mov ecx, [ebp-0x34]
test ecx, ecx
jz unzOpenCurrentFile_240
mov dword [ebp-0x54], 0xffffffff
mov dword [ebp-0x5c], 0x0
unzOpenCurrentFile_350:
mov edi, [esi]
mov [esp+0xc], edi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov eax, [ebp-0x6c]
mov [esp], eax
call fread
sub eax, 0x1
jnz unzOpenCurrentFile_250
movzx eax, byte [ebp-0x19]
mov [ebp-0x30], eax
mov dword [ebp-0x2c], 0x0
unzOpenCurrentFile_570:
mov [esp+0xc], edi
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x1
mov eax, [ebp-0x6c]
mov [esp], eax
call fread
sub eax, 0x1
jnz unzOpenCurrentFile_260
movzx eax, byte [ebp-0x19]
unzOpenCurrentFile_340:
shl eax, 0x8
add eax, [ebp-0x30]
mov [ebp-0x58], eax
mov eax, [ebp-0x2c]
test eax, eax
jz unzOpenCurrentFile_270
mov dword [ebp-0x54], 0xffffffff
mov dword [ebp-0x58], 0x0
unzOpenCurrentFile_270:
mov eax, [ebp-0x5c]
add eax, [esi+0x78]
add eax, 0x1e
mov [ebp-0x64], eax
mov eax, [ebp-0x58]
add eax, [ebp-0x5c]
mov [ebp-0x68], eax
mov eax, [ebp-0x54]
test eax, eax
jnz unzOpenCurrentFile_280
mov dword [esp], 0x60
call malloc
mov edi, eax
test eax, eax
jz unzOpenCurrentFile_290
mov dword [esp], 0x4000
call malloc
mov [edi], eax
mov eax, [ebp-0x64]
mov [edi+0x40], eax
mov eax, [ebp-0x58]
mov [edi+0x44], eax
mov dword [edi+0x48], 0x0
mov eax, [edi]
test eax, eax
jz unzOpenCurrentFile_300
mov dword [edi+0x3c], 0x0
mov eax, [esi+0x34]
mov [edi+0x58], eax
mov edx, [esi]
mov [edi+0x54], edx
mov edx, [esi+0xc]
mov [edi+0x5c], edx
mov dword [edi+0x18], 0x0
test eax, eax
jnz unzOpenCurrentFile_310
unzOpenCurrentFile_620:
mov eax, [esi+0x40]
mov [edi+0x4c], eax
mov eax, [esi+0x44]
mov [edi+0x50], eax
mov eax, [esi+0x78]
add [ebp-0x68], eax
mov eax, [ebp-0x68]
add eax, 0x1e
mov [edi+0x38], eax
mov dword [edi+0x8], 0x0
mov [esi+0x7c], edi
xor eax, eax
jmp unzOpenCurrentFile_60
unzOpenCurrentFile_40:
lea eax, [edi+0x4]
mov [esp], eax
call inflateEnd
jmp unzOpenCurrentFile_320
unzOpenCurrentFile_250:
mov [esp], edi
call ferror
test eax, eax
jz unzOpenCurrentFile_330
mov dword [ebp-0x2c], 0xffffffff
mov eax, [ebp-0x30]
jmp unzOpenCurrentFile_340
unzOpenCurrentFile_240:
mov edx, [ebp-0x54]
test edx, edx
jnz unzOpenCurrentFile_350
mov eax, [ebp-0x5c]
cmp eax, [esi+0x48]
mov eax, 0xffffff99
cmovz eax, [ebp-0x54]
mov [ebp-0x54], eax
jmp unzOpenCurrentFile_350
unzOpenCurrentFile_80:
mov [esp], edi
call ferror
test eax, eax
jz unzOpenCurrentFile_360
mov dword [ebp-0x4c], 0xffffffff
mov eax, [ebp-0x50]
jmp unzOpenCurrentFile_370
unzOpenCurrentFile_220:
mov [esp], edi
call ferror
test eax, eax
jz unzOpenCurrentFile_380
mov dword [ebp-0x34], 0xffffffff
mov eax, [ebp-0x38]
jmp unzOpenCurrentFile_390
unzOpenCurrentFile_110:
mov [esp], edi
call ferror
test eax, eax
jz unzOpenCurrentFile_400
mov dword [ebp-0x44], 0xffffffff
mov eax, [ebp-0x48]
jmp unzOpenCurrentFile_410
unzOpenCurrentFile_190:
mov eax, [ebp-0x54]
test eax, eax
jnz unzOpenCurrentFile_420
mov eax, [esi+0x3c]
cmp eax, [ebp-0x20]
jz unzOpenCurrentFile_430
test byte [ebp-0x60], 0x8
jnz unzOpenCurrentFile_430
mov dword [ebp-0x54], 0xffffff99
jmp unzOpenCurrentFile_420
unzOpenCurrentFile_70:
mov dword [ebp-0x54], 0xffffff99
cmp dword [ebp-0x24], 0x4034b50
cmovnz eax, [ebp-0x54]
mov [ebp-0x54], eax
jmp unzOpenCurrentFile_440
unzOpenCurrentFile_210:
mov edi, [ebp-0x54]
test edi, edi
jnz unzOpenCurrentFile_450
mov eax, [esi+0x44]
cmp eax, [ebp-0x20]
jz unzOpenCurrentFile_460
test byte [ebp-0x60], 0x8
jnz unzOpenCurrentFile_460
mov dword [ebp-0x54], 0xffffff99
jmp unzOpenCurrentFile_450
unzOpenCurrentFile_200:
mov eax, [ebp-0x54]
test eax, eax
jnz unzOpenCurrentFile_470
mov eax, [esi+0x40]
cmp eax, [ebp-0x20]
jz unzOpenCurrentFile_480
test byte [ebp-0x60], 0x8
jnz unzOpenCurrentFile_480
mov dword [ebp-0x54], 0xffffff99
jmp unzOpenCurrentFile_470
unzOpenCurrentFile_100:
mov dword [ebp-0x20], 0x0
mov dword [ebp-0x54], 0xffffffff
jmp unzOpenCurrentFile_490
unzOpenCurrentFile_140:
mov [esp], edi
call ferror
test eax, eax
jz unzOpenCurrentFile_500
mov dword [ebp-0x3c], 0xffffffff
mov eax, [ebp-0x40]
jmp unzOpenCurrentFile_510
unzOpenCurrentFile_160:
mov dword [ebp-0x20], 0x0
mov dword [ebp-0x54], 0xffffffff
jmp unzOpenCurrentFile_170
unzOpenCurrentFile_150:
mov [esp], edi
call ferror
test eax, eax
jz unzOpenCurrentFile_520
mov eax, [ebp-0x40]
mov dword [ebp-0x3c], 0xffffffff
jmp unzOpenCurrentFile_510
unzOpenCurrentFile_300:
mov [esp], edi
call free
unzOpenCurrentFile_290:
mov eax, 0xffffff98
jmp unzOpenCurrentFile_60
unzOpenCurrentFile_520:
mov eax, [ebp-0x40]
jmp unzOpenCurrentFile_510
unzOpenCurrentFile_230:
mov [esp], edi
call ferror
test eax, eax
jz unzOpenCurrentFile_530
mov eax, [ebp-0x38]
mov dword [ebp-0x34], 0xffffffff
jmp unzOpenCurrentFile_390
unzOpenCurrentFile_360:
mov dword [ebp-0x4c], 0x0
jmp unzOpenCurrentFile_540
unzOpenCurrentFile_530:
mov eax, [ebp-0x38]
jmp unzOpenCurrentFile_390
unzOpenCurrentFile_90:
mov [esp], edi
call ferror
test eax, eax
jz unzOpenCurrentFile_550
mov eax, [ebp-0x50]
mov dword [ebp-0x4c], 0xffffffff
jmp unzOpenCurrentFile_370
unzOpenCurrentFile_460:
mov dword [ebp-0x54], 0x0
jmp unzOpenCurrentFile_450
unzOpenCurrentFile_550:
mov eax, [ebp-0x50]
jmp unzOpenCurrentFile_370
unzOpenCurrentFile_260:
mov [esp], edi
call ferror
test eax, eax
jz unzOpenCurrentFile_560
mov eax, [ebp-0x30]
mov dword [ebp-0x2c], 0xffffffff
jmp unzOpenCurrentFile_340
unzOpenCurrentFile_330:
mov dword [ebp-0x2c], 0x0
jmp unzOpenCurrentFile_570
unzOpenCurrentFile_560:
mov eax, [ebp-0x30]
jmp unzOpenCurrentFile_340
unzOpenCurrentFile_400:
mov dword [ebp-0x44], 0x0
jmp unzOpenCurrentFile_580
unzOpenCurrentFile_500:
mov dword [ebp-0x3c], 0x0
jmp unzOpenCurrentFile_590
unzOpenCurrentFile_120:
mov [esp], edi
call ferror
test eax, eax
jz unzOpenCurrentFile_600
mov eax, [ebp-0x48]
mov dword [ebp-0x44], 0xffffffff
jmp unzOpenCurrentFile_410
unzOpenCurrentFile_180:
test eax, eax
jz unzOpenCurrentFile_170
cmp eax, 0x8
jnz unzOpenCurrentFile_610
jmp unzOpenCurrentFile_170
unzOpenCurrentFile_600:
mov eax, [ebp-0x48]
jmp unzOpenCurrentFile_410
unzOpenCurrentFile_310:
mov dword [edi+0x24], 0x0
mov dword [edi+0x28], 0x0
mov dword [edi+0x2c], 0x0
mov dword [esp+0xc], 0x34
lea eax, [ebx+0x528c4]
mov [esp+0x8], eax
mov dword [esp+0x4], 0xfffffff1
lea eax, [edi+0x4]
mov [esp], eax
call inflateInit2_
test eax, eax
jnz unzOpenCurrentFile_620
mov dword [edi+0x3c], 0x1
jmp unzOpenCurrentFile_620
unzOpenCurrentFile_430:
mov dword [ebp-0x54], 0x0
jmp unzOpenCurrentFile_420
unzOpenCurrentFile_380:
mov dword [ebp-0x34], 0x0
jmp unzOpenCurrentFile_630
unzOpenCurrentFile_480:
mov dword [ebp-0x54], 0x0
jmp unzOpenCurrentFile_470
;unzReOpen
unzReOpen:
push ebp
mov ebp, esp
push edi
push esi
push ebx
sub esp, 0x1c
call __i686.get_pc_thunk.bx
lea eax, [ebx+0x215ff]
mov [esp+0x4], eax
mov eax, [ebp+0x8]
mov [esp], eax
call fopen
mov edi, eax
test eax, eax
jz unzReOpen_10
mov [esp], eax
call fileno
cmp eax, 0xffffffff
jz unzReOpen_20
mov dword [esp+0x8], 0x1
mov dword [esp+0x4], 0x2d
mov [esp], eax
call fcntl
unzReOpen_20:
mov dword [esp], 0x80
call malloc
mov esi, eax
mov dword [esp+0x8], 0x80
mov eax, [ebp+0xc]
mov [esp+0x4], eax
mov [esp], esi
call Com_Memcpy
mov [esi], edi
mov dword [esi+0x7c], 0x0
mov eax, esi
add esp, 0x1c
pop ebx
pop esi
pop edi
pop ebp
ret
unzReOpen_10:
xor eax, eax
add esp, 0x1c
pop ebx
pop esi
pop edi
pop ebp
ret
;unzReadCurrentFile
unzReadCurrentFile:
push ebp
mov ebp, esp
push edi
push esi
sub esp, 0x20
mov eax, [ebp+0x8]
test eax, eax
jnz unzReadCurrentFile_10
unzReadCurrentFile_20:
mov dword [ebp-0x10], 0xffffff9a
mov eax, [ebp-0x10]
unzReadCurrentFile_140:
add esp, 0x20
pop esi
pop edi
pop ebp
ret
unzReadCurrentFile_10:
mov edi, [eax+0x7c]
test edi, edi
jz unzReadCurrentFile_20
mov eax, [edi]
test eax, eax
jz unzReadCurrentFile_30
mov eax, [ebp+0x10]
test eax, eax
jz unzReadCurrentFile_40
mov eax, [ebp+0xc]
mov [edi+0x10], eax
mov edx, [ebp+0x10]
mov [edi+0x14], edx
mov eax, [edi+0x50]
cmp edx, eax
jbe unzReadCurrentFile_50
mov [edi+0x14], eax
unzReadCurrentFile_50:
mov dword [ebp-0x10], 0x0
mov dword [ebp-0xc], 0x0
unzReadCurrentFile_120:
mov esi, [edi+0x14]
test esi, esi
jz unzReadCurrentFile_60
mov eax, [edi+0x8]
test eax, eax
jnz unzReadCurrentFile_70
mov eax, [edi+0x4c]
test eax, eax
jnz unzReadCurrentFile_80
unzReadCurrentFile_70:
mov eax, [edi+0x58]
test eax, eax
jnz unzReadCurrentFile_90
mov esi, [edi+0x14]
mov edx, esi
mov eax, [edi+0x8]
cmp esi, eax
cmovae esi, eax
test esi, esi
jz unzReadCurrentFile_100
xor ecx, ecx
unzReadCurrentFile_110:
mov eax, [edi+0x10]
mov edx, [edi+0x4]
movzx edx, byte [edx+ecx]
mov [eax+ecx], dl
add ecx, 0x1
cmp esi, ecx
jnz unzReadCurrentFile_110
mov edx, [edi+0x14]
mov eax, [edi+0x8]
unzReadCurrentFile_100:
sub [edi+0x50], esi
sub eax, esi
mov [edi+0x8], eax
sub edx, esi
mov [edi+0x14], edx
add [edi+0x10], esi
add [edi+0x4], esi
add [edi+0x18], esi
add [ebp-0xc], esi
jmp unzReadCurrentFile_120
unzReadCurrentFile_90:
mov esi, [edi+0x18]
mov dword [esp+0x4], 0x2
lea eax, [edi+0x4]
mov [esp], eax
call inflate
mov [ebp-0x10], eax
mov eax, [edi+0x18]
sub eax, esi
sub [edi+0x50], eax
add [ebp-0xc], eax
cmp dword [ebp-0x10], 0x1
jz unzReadCurrentFile_130
mov eax, [ebp-0x10]
test eax, eax
jz unzReadCurrentFile_120
unzReadCurrentFile_150:
mov eax, [ebp-0x10]
jmp unzReadCurrentFile_140
unzReadCurrentFile_60:
mov ecx, [ebp-0x10]
test ecx, ecx
jnz unzReadCurrentFile_150
mov eax, [ebp-0xc]
mov [ebp-0x10], eax
jmp unzReadCurrentFile_140
unzReadCurrentFile_80:
mov esi, 0x4000
cmp eax, 0x3fff
cmovbe esi, eax
mov dword [esp+0x8], 0x0
mov eax, [edi+0x38]
add eax, [edi+0x5c]
mov [esp+0x4], eax
mov eax, [edi+0x54]
mov [esp], eax
call fseek
test eax, eax
jnz unzReadCurrentFile_160
mov eax, [edi+0x54]
mov [esp+0xc], eax
mov [esp+0x8], esi
mov dword [esp+0x4], 0x1
mov eax, [edi]
mov [esp], eax
call fread
cmp esi, eax
jnz unzReadCurrentFile_160
add [edi+0x38], esi
sub [edi+0x4c], esi
mov eax, [edi]
mov [edi+0x4], eax
mov [edi+0x8], esi
jmp unzReadCurrentFile_70
unzReadCurrentFile_40:
mov dword [ebp-0x10], 0x0
mov eax, [ebp-0x10]
jmp unzReadCurrentFile_140
unzReadCurrentFile_130:
mov edx, [ebp-0xc]
mov [ebp-0x10], edx
mov eax, edx
jmp unzReadCurrentFile_140
unzReadCurrentFile_30:
mov dword [ebp-0x10], 0xffffff9c
mov eax, [ebp-0x10]
jmp unzReadCurrentFile_140
unzReadCurrentFile_160:
mov dword [ebp-0x10], 0xffffffff
mov eax, [ebp-0x10]
jmp unzReadCurrentFile_140
add [eax], al
;unzSetCurrentFileInfoPosition
unzSetCurrentFileInfoPosition:
push ebp
mov ebp, esp
push esi
sub esp, 0x24
mov esi, [ebp+0x8]
test esi, esi
jz unzSetCurrentFileInfoPosition_10
mov eax, [ebp+0xc]
mov [esi+0x14], eax
lea ecx, [esi+0x78]
lea edx, [esi+0x28]
mov dword [esp+0x14], 0x0
mov dword [esp+0x10], 0x0
mov dword [esp+0xc], 0x0
mov dword [esp+0x8], 0x0
mov dword [esp+0x4], 0x0
mov dword [esp], 0x0
mov eax, esi
call unzlocal_GetCurrentFileInfoInternal
test eax, eax
setz al
movzx eax, al
mov [esi+0x18], eax
xor eax, eax
add esp, 0x24
pop esi
pop ebp
ret
unzSetCurrentFileInfoPosition_10:
mov eax, 0xffffff9a
add esp, 0x24
pop esi
pop ebp
ret
;unztell
unztell:
push ebp
mov ebp, esp
mov eax, [ebp+0x8]
test eax, eax
jnz unztell_10
unztell_20:
mov eax, 0xffffff9a
pop ebp
ret
unztell_10:
mov eax, [eax+0x7c]
test eax, eax
jz unztell_20
mov eax, [eax+0x18]
pop ebp
ret
;Initialized global or static variables of unzip:
SECTION .data
;Initialized constant data of unzip:
SECTION .rdata
;Zero initialized global or static variables of unzip:
SECTION .bss
;All cstrings:
SECTION .rdata
;All constant floats and doubles:
SECTION .rdata
| {
"language": "Assembly"
} |
.size 8000
.text@48
jp lstatint
.text@100
jp lbegin
.data@143
c0
.text@150
lbegin:
ld a, 00
ldff(ff), a
ld a, 30
ldff(00), a
ld a, 01
ldff(4d), a
stop, 00
ld a, ff
ldff(45), a
ld b, 91
call lwaitly_b
ld hl, fe00
ld d, 10
ld a, d
ld(hl++), a
ld a, 08
ld(hl++), a
inc l
inc l
ld a, d
ld(hl++), a
ld(hl++), a
inc l
inc l
ld(hl++), a
ld a, 18
ld(hl++), a
inc l
inc l
ld a, d
ld(hl++), a
ld a, 20
ld(hl++), a
inc l
inc l
ld a, d
ld(hl++), a
ld a, 28
ld(hl++), a
inc l
inc l
ld a, d
ld(hl++), a
ld a, 30
ld(hl++), a
inc l
inc l
ld a, d
ld(hl++), a
ld a, 38
ld(hl++), a
inc l
inc l
ld a, d
ld(hl++), a
ld a, 40
ld(hl++), a
inc l
inc l
ld a, d
ld(hl++), a
ld a, 48
ld(hl++), a
ld a, 40
ldff(41), a
ld a, 02
ldff(ff), a
xor a, a
ldff(0f), a
ei
ld a, 01
ldff(45), a
ld c, 41
ld a, 93
ldff(40), a
.text@1000
lstatint:
nop
.text@10a6
ldff a, (c)
and a, 03
jp lprint_a
.text@7000
lprint_a:
push af
ld b, 91
call lwaitly_b
xor a, a
ldff(40), a
pop af
ld(9800), a
ld bc, 7a00
ld hl, 8000
ld d, a0
lprint_copytiles:
ld a, (bc)
inc bc
ld(hl++), a
dec d
jrnz lprint_copytiles
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
| {
"language": "Assembly"
} |
/*
* This file is part of the libopencm3 project.
*
* Copyright (C) 2009 Uwe Hermann <uwe@hermann-uwe.de>
*
* This library is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
/* Generic linker script for LPC13XX targets using libopencm3. */
/* Memory regions must be defined in the ld script which includes this one. */
/* Enforce emmition of the vector table. */
EXTERN (vector_table)
/* Define the entry point of the output file. */
ENTRY(reset_handler)
/* Define sections. */
SECTIONS
{
.text : {
*(.vectors) /* Vector table */
*(.text*) /* Program code */
. = ALIGN(4);
*(.rodata*) /* Read-only data */
. = ALIGN(4);
} >rom
/* C++ Static constructors/destructors, also used for __attribute__
* ((constructor)) and the likes */
.preinit_array : {
. = ALIGN(4);
__preinit_array_start = .;
KEEP (*(.preinit_array))
__preinit_array_end = .;
} >rom
.init_array : {
. = ALIGN(4);
__init_array_start = .;
KEEP (*(SORT(.init_array.*)))
KEEP (*(.init_array))
__init_array_end = .;
} >rom
.fini_array : {
. = ALIGN(4);
__fini_array_start = .;
KEEP (*(.fini_array))
KEEP (*(SORT(.fini_array.*)))
__fini_array_end = .;
} >rom
/*
* Another section used by C++ stuff, appears when using newlib with
* 64bit (long long) printf support
*/
.ARM.extab : {
*(.ARM.extab*)
} >rom
.ARM.exidx : {
__exidx_start = .;
*(.ARM.exidx*)
__exidx_end = .;
} >rom
. = ALIGN(4);
_etext = .;
.data : {
_data = .;
*(.data*) /* Read-write initialized data */
. = ALIGN(4);
_edata = .;
} >ram AT >rom
_data_loadaddr = LOADADDR(.data);
.bss : {
*(.bss*) /* Read-write zero initialized data */
*(COMMON)
. = ALIGN(4);
_ebss = .;
} >ram
/*
* The .eh_frame section appears to be used for C++ exception handling.
* You may need to fix this if you're using C++.
*/
/DISCARD/ : { *(.eh_frame) }
. = ALIGN(4);
end = .;
}
PROVIDE(_stack = ORIGIN(ram) + LENGTH(ram));
| {
"language": "Assembly"
} |
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -codegenprepare < %s | FileCheck %s
target datalayout = "e-i64:64-v16:16-v32:32-n16:32:64"
target triple = "nvptx64-nvidia-cuda"
; No bypassing should be done in apparently unsuitable cases.
define void @Test_no_bypassing(i32 %a, i64 %b, i64* %retptr) {
; CHECK-LABEL: @Test_no_bypassing(
; CHECK-NEXT: [[A_1:%.*]] = zext i32 [[A:%.*]] to i64
; CHECK-NEXT: [[A_2:%.*]] = sub i64 -1, [[A_1]]
; CHECK-NEXT: [[RES:%.*]] = srem i64 [[A_2]], [[B:%.*]]
; CHECK-NEXT: store i64 [[RES]], i64* [[RETPTR:%.*]]
; CHECK-NEXT: ret void
;
%a.1 = zext i32 %a to i64
; %a.2 is always negative so the division cannot be bypassed.
%a.2 = sub i64 -1, %a.1
%res = srem i64 %a.2, %b
store i64 %res, i64* %retptr
ret void
}
; No OR instruction is needed if one of the operands (divisor) is known
; to fit into 32 bits.
define void @Test_check_one_operand(i64 %a, i32 %b, i64* %retptr) {
; CHECK-LABEL: @Test_check_one_operand(
; CHECK-NEXT: [[B_1:%.*]] = zext i32 [[B:%.*]] to i64
; CHECK-NEXT: [[TMP1:%.*]] = and i64 [[A:%.*]], -4294967296
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i64 [[TMP1]], 0
; CHECK-NEXT: br i1 [[TMP2]], label [[TMP3:%.*]], label [[TMP8:%.*]]
; CHECK: [[TMP4:%.*]] = trunc i64 [[B_1]] to i32
; CHECK-NEXT: [[TMP5:%.*]] = trunc i64 [[A]] to i32
; CHECK-NEXT: [[TMP6:%.*]] = udiv i32 [[TMP5]], [[TMP4]]
; CHECK-NEXT: [[TMP7:%.*]] = zext i32 [[TMP6]] to i64
; CHECK-NEXT: br label [[TMP10:%.*]]
; CHECK: [[TMP9:%.*]] = sdiv i64 [[A]], [[B_1]]
; CHECK-NEXT: br label [[TMP10]]
; CHECK: [[TMP11:%.*]] = phi i64 [ [[TMP7]], [[TMP3]] ], [ [[TMP9]], [[TMP8]] ]
; CHECK-NEXT: store i64 [[TMP11]], i64* [[RETPTR:%.*]]
; CHECK-NEXT: ret void
;
%b.1 = zext i32 %b to i64
%res = sdiv i64 %a, %b.1
store i64 %res, i64* %retptr
ret void
}
; If both operands are known to fit into 32 bits, then replace the division
; in-place without CFG modification.
define void @Test_check_none(i64 %a, i32 %b, i64* %retptr) {
; CHECK-LABEL: @Test_check_none(
; CHECK-NEXT: [[A_1:%.*]] = and i64 [[A:%.*]], 4294967295
; CHECK-NEXT: [[B_1:%.*]] = zext i32 [[B:%.*]] to i64
; CHECK-NEXT: [[TMP1:%.*]] = trunc i64 [[A_1]] to i32
; CHECK-NEXT: [[TMP2:%.*]] = trunc i64 [[B_1]] to i32
; CHECK-NEXT: [[TMP3:%.*]] = udiv i32 [[TMP1]], [[TMP2]]
; CHECK-NEXT: [[TMP4:%.*]] = zext i32 [[TMP3]] to i64
; CHECK-NEXT: store i64 [[TMP4]], i64* [[RETPTR:%.*]]
; CHECK-NEXT: ret void
;
%a.1 = and i64 %a, 4294967295
%b.1 = zext i32 %b to i64
%res = udiv i64 %a.1, %b.1
store i64 %res, i64* %retptr
ret void
}
; In case of unsigned long division with a short dividend,
; the long division is not needed any more.
define void @Test_special_case(i32 %a, i64 %b, i64* %retptr) {
; CHECK-LABEL: @Test_special_case(
; CHECK-NEXT: [[A_1:%.*]] = zext i32 [[A:%.*]] to i64
; CHECK-NEXT: [[TMP1:%.*]] = icmp uge i64 [[A_1]], [[B:%.*]]
; CHECK-NEXT: br i1 [[TMP1]], label [[TMP2:%.*]], label [[TMP9:%.*]]
; CHECK: [[TMP3:%.*]] = trunc i64 [[B]] to i32
; CHECK-NEXT: [[TMP4:%.*]] = trunc i64 [[A_1]] to i32
; CHECK-NEXT: [[TMP5:%.*]] = udiv i32 [[TMP4]], [[TMP3]]
; CHECK-NEXT: [[TMP6:%.*]] = urem i32 [[TMP4]], [[TMP3]]
; CHECK-NEXT: [[TMP7:%.*]] = zext i32 [[TMP5]] to i64
; CHECK-NEXT: [[TMP8:%.*]] = zext i32 [[TMP6]] to i64
; CHECK-NEXT: br label [[TMP9]]
; CHECK: [[TMP10:%.*]] = phi i64 [ [[TMP7]], [[TMP2]] ], [ 0, [[TMP0:%.*]] ]
; CHECK-NEXT: [[TMP11:%.*]] = phi i64 [ [[TMP8]], [[TMP2]] ], [ [[A_1]], [[TMP0]] ]
; CHECK-NEXT: [[RES:%.*]] = add i64 [[TMP10]], [[TMP11]]
; CHECK-NEXT: store i64 [[RES]], i64* [[RETPTR:%.*]]
; CHECK-NEXT: ret void
;
%a.1 = zext i32 %a to i64
%div = udiv i64 %a.1, %b
%rem = urem i64 %a.1, %b
%res = add i64 %div, %rem
store i64 %res, i64* %retptr
ret void
}
; Do not bypass a division if one of the operands looks like a hash value.
define void @Test_dont_bypass_xor(i64 %a, i64 %b, i64 %l, i64* %retptr) {
; CHECK-LABEL: @Test_dont_bypass_xor(
; CHECK-NEXT: [[C:%.*]] = xor i64 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[RES:%.*]] = udiv i64 [[C]], [[L:%.*]]
; CHECK-NEXT: store i64 [[RES]], i64* [[RETPTR:%.*]]
; CHECK-NEXT: ret void
;
%c = xor i64 %a, %b
%res = udiv i64 %c, %l
store i64 %res, i64* %retptr
ret void
}
define void @Test_dont_bypass_phi_xor(i64 %a, i64 %b, i64 %l, i64* %retptr) {
; CHECK-LABEL: @Test_dont_bypass_phi_xor(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 [[B:%.*]], 0
; CHECK-NEXT: br i1 [[CMP]], label [[MERGE:%.*]], label [[XORPATH:%.*]]
; CHECK: xorpath:
; CHECK-NEXT: [[C:%.*]] = xor i64 [[A:%.*]], [[B]]
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
; CHECK-NEXT: [[E:%.*]] = phi i64 [ undef, [[ENTRY:%.*]] ], [ [[C]], [[XORPATH]] ]
; CHECK-NEXT: [[RES:%.*]] = sdiv i64 [[E]], [[L:%.*]]
; CHECK-NEXT: store i64 [[RES]], i64* [[RETPTR:%.*]]
; CHECK-NEXT: ret void
;
entry:
%cmp = icmp eq i64 %b, 0
br i1 %cmp, label %merge, label %xorpath
xorpath:
%c = xor i64 %a, %b
br label %merge
merge:
%e = phi i64 [ undef, %entry ], [ %c, %xorpath ]
%res = sdiv i64 %e, %l
store i64 %res, i64* %retptr
ret void
}
define void @Test_dont_bypass_mul_long_const(i64 %a, i64 %l, i64* %retptr) {
; CHECK-LABEL: @Test_dont_bypass_mul_long_const(
; CHECK-NEXT: [[C:%.*]] = mul i64 [[A:%.*]], 5229553307
; CHECK-NEXT: [[RES:%.*]] = urem i64 [[C]], [[L:%.*]]
; CHECK-NEXT: store i64 [[RES]], i64* [[RETPTR:%.*]]
; CHECK-NEXT: ret void
;
%c = mul i64 %a, 5229553307 ; the constant doesn't fit 32 bits
%res = urem i64 %c, %l
store i64 %res, i64* %retptr
ret void
}
define void @Test_bypass_phi_mul_const(i64 %a, i64 %b, i64* %retptr) {
; CHECK-LABEL: @Test_bypass_phi_mul_const(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_MUL:%.*]] = mul nsw i64 [[A:%.*]], 34806414968801
; CHECK-NEXT: [[P:%.*]] = icmp sgt i64 [[A]], [[B:%.*]]
; CHECK-NEXT: br i1 [[P]], label [[BRANCH:%.*]], label [[MERGE:%.*]]
; CHECK: branch:
; CHECK-NEXT: br label [[MERGE]]
; CHECK: merge:
; CHECK-NEXT: [[LHS:%.*]] = phi i64 [ 42, [[BRANCH]] ], [ [[A_MUL]], [[ENTRY:%.*]] ]
; CHECK-NEXT: [[TMP0:%.*]] = or i64 [[LHS]], [[B]]
; CHECK-NEXT: [[TMP1:%.*]] = and i64 [[TMP0]], -4294967296
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i64 [[TMP1]], 0
; CHECK-NEXT: br i1 [[TMP2]], label [[TMP3:%.*]], label [[TMP8:%.*]]
; CHECK: [[TMP4:%.*]] = trunc i64 [[B]] to i32
; CHECK-NEXT: [[TMP5:%.*]] = trunc i64 [[LHS]] to i32
; CHECK-NEXT: [[TMP6:%.*]] = udiv i32 [[TMP5]], [[TMP4]]
; CHECK-NEXT: [[TMP7:%.*]] = zext i32 [[TMP6]] to i64
; CHECK-NEXT: br label [[TMP10:%.*]]
; CHECK: [[TMP9:%.*]] = sdiv i64 [[LHS]], [[B]]
; CHECK-NEXT: br label [[TMP10]]
; CHECK: [[TMP11:%.*]] = phi i64 [ [[TMP7]], [[TMP3]] ], [ [[TMP9]], [[TMP8]] ]
; CHECK-NEXT: store i64 [[TMP11]], i64* [[RETPTR:%.*]]
; CHECK-NEXT: ret void
;
entry:
%a.mul = mul nsw i64 %a, 34806414968801
%p = icmp sgt i64 %a, %b
br i1 %p, label %branch, label %merge
branch:
br label %merge
merge:
%lhs = phi i64 [ 42, %branch ], [ %a.mul, %entry ]
%res = sdiv i64 %lhs, %b
store i64 %res, i64* %retptr
ret void
}
define void @Test_bypass_mul_short_const(i64 %a, i64 %l, i64* %retptr) {
; CHECK-LABEL: @Test_bypass_mul_short_const(
; CHECK-NEXT: [[C:%.*]] = mul i64 [[A:%.*]], -42
; CHECK-NEXT: [[TMP1:%.*]] = or i64 [[C]], [[L:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = and i64 [[TMP1]], -4294967296
; CHECK-NEXT: [[TMP3:%.*]] = icmp eq i64 [[TMP2]], 0
; CHECK-NEXT: br i1 [[TMP3]], label [[TMP4:%.*]], label [[TMP9:%.*]]
; CHECK: [[TMP5:%.*]] = trunc i64 [[L]] to i32
; CHECK-NEXT: [[TMP6:%.*]] = trunc i64 [[C]] to i32
; CHECK-NEXT: [[TMP7:%.*]] = urem i32 [[TMP6]], [[TMP5]]
; CHECK-NEXT: [[TMP8:%.*]] = zext i32 [[TMP7]] to i64
; CHECK-NEXT: br label [[TMP11:%.*]]
; CHECK: [[TMP10:%.*]] = urem i64 [[C]], [[L]]
; CHECK-NEXT: br label [[TMP11]]
; CHECK: [[TMP12:%.*]] = phi i64 [ [[TMP8]], [[TMP4]] ], [ [[TMP10]], [[TMP9]] ]
; CHECK-NEXT: store i64 [[TMP12]], i64* [[RETPTR:%.*]]
; CHECK-NEXT: ret void
;
%c = mul i64 %a, -42
%res = urem i64 %c, %l
store i64 %res, i64* %retptr
ret void
}
| {
"language": "Assembly"
} |
; Uninitialized values are not handled correctly.
;
; RUN: opt < %s -mem2reg -disable-output
;
define i32 @test() {
; To be promoted
%X = alloca i32 ; <i32*> [#uses=1]
%Y = load i32, i32* %X ; <i32> [#uses=1]
ret i32 %Y
}
| {
"language": "Assembly"
} |
; RUN: opt -basicaa -print-memoryssa -verify-memoryssa -analyze < %s 2>&1 | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s
; hfinkel's case
; [entry]
; |
; .....
; (clobbering access - b)
; |
; .... ________________________________
; \ / |
; (x) |
; ...... |
; | |
; | ______________________ |
; \ / | |
; (starting access) | |
; ... | |
; (clobbering access - a) | |
; ... | |
; | | | |
; | |_______________________| |
; | |
; |_________________________________|
;
; More specifically, one access, with multiple clobbering accesses. One of
; which strictly dominates the access, the other of which has a backedge
; readnone so we don't have a 1:1 mapping of MemorySSA edges to Instructions.
declare void @doThingWithoutReading() readnone
declare i8 @getValue() readnone
declare i1 @getBool() readnone
define hidden void @testcase(i8* %Arg) {
Entry:
call void @doThingWithoutReading()
%Val.Entry = call i8 @getValue()
; CHECK: 1 = MemoryDef(liveOnEntry)
; CHECK-NEXT: store i8 %Val.Entry
store i8 %Val.Entry, i8* %Arg
call void @doThingWithoutReading()
br label %OuterLoop
OuterLoop:
; CHECK: 5 = MemoryPhi({Entry,1},{InnerLoop.Tail,3})
; CHECK-NEXT: %Val.Outer =
%Val.Outer = call i8 @getValue()
; CHECK: 2 = MemoryDef(5)
; CHECK-NEXT: store i8 %Val.Outer
store i8 %Val.Outer, i8* %Arg
call void @doThingWithoutReading()
br label %InnerLoop
InnerLoop:
; CHECK: 4 = MemoryPhi({OuterLoop,2},{InnerLoop,3})
; CHECK-NEXT: ; MemoryUse(4)
; CHECK-NEXT: %StartingAccess = load
%StartingAccess = load i8, i8* %Arg, align 4
%Val.Inner = call i8 @getValue()
; CHECK: 3 = MemoryDef(4)
; CHECK-NEXT: store i8 %Val.Inner
store i8 %Val.Inner, i8* %Arg
call void @doThingWithoutReading()
%KeepGoing = call i1 @getBool()
br i1 %KeepGoing, label %InnerLoop.Tail, label %InnerLoop
InnerLoop.Tail:
%KeepGoing.Tail = call i1 @getBool()
br i1 %KeepGoing.Tail, label %End, label %OuterLoop
End:
ret void
}
| {
"language": "Assembly"
} |
#source: dsov32-1.s
#source: dsov32-2.s
#source: dsofng.s
#as: --pic --no-underscore --march=v32 --em=criself
#ld: --shared -m crislinux --hash-style=sysv
#objdump: -d
# Complement to dso-pltdis1.d; merging the other .got.plt entry.
# Depending on reloc order, one of the tests would fail.
.*: file format elf32-cris
Disassembly of section \.plt:
0+160 <.*>:
160: 84e2 subq 4,\$sp
162: 0401 addoq 4,\$r0,\$acr
164: 7e7a move \$mof,\[\$sp\]
166: 3f7a move \[\$acr\],\$mof
168: 04f2 addq 4,\$acr
16a: 6ffa move\.d \[\$acr\],\$acr
16c: bf09 jump \$acr
16e: b005 nop
\.\.\.
0000017a <dsofn4@plt>:
17a: 6f0d ..00 0000 addo\.d .*
180: 6ffa move\.d \[\$acr\],\$acr
182: bf09 jump \$acr
184: b005 nop
186: 3f7e .... .... move .*,\$mof
18c: bf0e .... .... ba .*
192: b005 nop
#...
194: 6f0d ..00 0000 addo\.d .*
19a: 6ffa move\.d \[\$acr\],\$acr
19c: bf09 jump \$acr
19e: b005 nop
1a0: 3f7e .... .... move .*,\$mof
1a6: bf0e .... .... ba .*
1ac: b005 nop
Disassembly of section \.text:
#...
0+1ae <dsofn3>:
1ae: bfbe e6ff ffff bsr 194 <.*>
1b4: b005 nop
0+1b6 <dsofn4>:
1b6: 7f0d ae20 0000 lapc 2264 <_GLOBAL_OFFSET_TABLE_>,\$r0
1bc: 5f0d ..00 addo\.w 0x..,\$r0,\$acr
1c0: bfbe baff ffff bsr 17a <dsofn4@plt>
#pass
| {
"language": "Assembly"
} |
// TR1 limits.h -*- C++ -*-
// Copyright (C) 2006-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file tr1/limits.h
* This is a TR1 C++ Library header.
*/
#ifndef _TR1_LIMITS_H
#define _TR1_LIMITS_H 1
#include <tr1/climits>
#endif
| {
"language": "Assembly"
} |
/**
* \file
*
* \brief Linker script for running in internal SRAM on the SAMD21E16A
*
* Copyright (c) 2016 Atmel Corporation,
* a wholly owned subsidiary of Microchip Technology Inc.
*
* \asf_license_start
*
* \page License
*
* 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 Licence 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.
*
* \asf_license_stop
*
*/
OUTPUT_FORMAT("elf32-littlearm", "elf32-littlearm", "elf32-littlearm")
OUTPUT_ARCH(arm)
SEARCH_DIR(.)
/* Memory Spaces Definitions */
MEMORY
{
ram (rwx) : ORIGIN = 0x20000000, LENGTH = 0x00002000
}
/* The stack size used by the application. NOTE: you need to adjust according to your application. */
STACK_SIZE = DEFINED(STACK_SIZE) ? STACK_SIZE : DEFINED(__stack_size__) ? __stack_size__ : 0x800;
/* Section Definitions */
SECTIONS
{
.text :
{
. = ALIGN(4);
_sfixed = .;
KEEP(*(.vectors .vectors.*))
*(.text .text.* .gnu.linkonce.t.*)
*(.glue_7t) *(.glue_7)
*(.rodata .rodata* .gnu.linkonce.r.*)
*(.ARM.extab* .gnu.linkonce.armextab.*)
/* Support C constructors, and C destructors in both user code
and the C library. This also provides support for C++ code. */
. = ALIGN(4);
KEEP(*(.init))
. = ALIGN(4);
__preinit_array_start = .;
KEEP (*(.preinit_array))
__preinit_array_end = .;
. = ALIGN(4);
__init_array_start = .;
KEEP (*(SORT(.init_array.*)))
KEEP (*(.init_array))
__init_array_end = .;
. = ALIGN(4);
KEEP (*crtbegin.o(.ctors))
KEEP (*(EXCLUDE_FILE (*crtend.o) .ctors))
KEEP (*(SORT(.ctors.*)))
KEEP (*crtend.o(.ctors))
. = ALIGN(4);
KEEP(*(.fini))
. = ALIGN(4);
__fini_array_start = .;
KEEP (*(.fini_array))
KEEP (*(SORT(.fini_array.*)))
__fini_array_end = .;
KEEP (*crtbegin.o(.dtors))
KEEP (*(EXCLUDE_FILE (*crtend.o) .dtors))
KEEP (*(SORT(.dtors.*)))
KEEP (*crtend.o(.dtors))
. = ALIGN(4);
_efixed = .; /* End of text section */
} > ram
/* .ARM.exidx is sorted, so has to go in its own output section. */
PROVIDE_HIDDEN (__exidx_start = .);
.ARM.exidx :
{
*(.ARM.exidx* .gnu.linkonce.armexidx.*)
} > ram
PROVIDE_HIDDEN (__exidx_end = .);
. = ALIGN(4);
_etext = .;
.relocate : AT (_etext)
{
. = ALIGN(4);
_srelocate = .;
*(.ramfunc .ramfunc.*);
*(.data .data.*);
. = ALIGN(4);
_erelocate = .;
} > ram
/* .bss section which is used for uninitialized data */
.bss (NOLOAD) :
{
. = ALIGN(4);
_sbss = . ;
_szero = .;
*(.bss .bss.*)
*(COMMON)
. = ALIGN(4);
_ebss = . ;
_ezero = .;
} > ram
/* stack section */
.stack (NOLOAD):
{
. = ALIGN(8);
_sstack = .;
. = . + STACK_SIZE;
. = ALIGN(8);
_estack = .;
} > ram
. = ALIGN(4);
_end = . ;
}
| {
"language": "Assembly"
} |