max_stars_repo_path
stringlengths 4
261
| max_stars_repo_name
stringlengths 6
106
| max_stars_count
int64 0
38.8k
| id
stringlengths 1
6
| text
stringlengths 7
1.05M
|
|---|---|---|---|---|
libsrc/_DEVELOPMENT/adt/wv_stack/c/sccz80/wv_stack_reserve.asm | jpoikela/z88dk | 640 | 80307 | <filename>libsrc/_DEVELOPMENT/adt/wv_stack/c/sccz80/wv_stack_reserve.asm
; int wv_stack_reserve(wv_stack_t *s, size_t n)
SECTION code_clib
SECTION code_adt_wv_stack
PUBLIC wv_stack_reserve
EXTERN w_vector_reserve
defc wv_stack_reserve = w_vector_reserve
; SDCC bridge for Classic
IF __CLASSIC
PUBLIC _wv_stack_reserve
defc _wv_stack_reserve = wv_stack_reserve
ENDIF
|
programs/oeis/038/A038845.asm | jmorken/loda | 1 | 95588 | ; A038845: 3-fold convolution of A000302 (powers of 4).
; 1,12,96,640,3840,21504,114688,589824,2949120,14417920,69206016,327155712,1526726656,7046430720,32212254720,146028888064,657129996288,2937757630464,13056700579840,57724360458240,253987186016256,1112705767309312,4855443348258816
add $0,2
mov $3,4
pow $3,$0
bin $0,2
mov $2,$3
lpb $2
mul $0,$2
mod $2,5
lpe
mov $1,$0
div $1,16
|
programs/oeis/272/A272100.asm | karttu/loda | 1 | 93098 | ; A272100: Integers n that are the sum of three nonzero squares while n*(n+1) is not.
; 12,19,44,51,76,83,108,115,140,147,172,179,204,211,236,243,268,275,300,307,332,339,364,371,396,403,428,435,460,467,492,499,524,531,556,563,588,595,620,627,652,659,684,691,716,723,748,755,780,787,812,819,844,851,876,883,908,915,940,947,972,979,1004,1011,1036,1043,1068,1075,1100,1107,1132,1139,1164,1171,1196,1203,1228,1235,1260,1267,1292,1299,1324,1331,1356,1363,1388,1395,1420,1427,1452,1459,1484,1491,1516,1523,1548,1555,1580,1587,1612,1619,1644,1651,1676,1683,1708,1715,1740,1747,1772,1779,1804,1811,1836,1843,1868,1875,1900,1907,1932,1939,1964,1971,1996,2003,2028,2035,2060,2067,2092,2099,2124,2131,2156,2163,2188,2195,2220,2227,2252,2259,2284,2291,2316,2323,2348,2355,2380,2387,2412,2419,2444,2451,2476,2483,2508,2515,2540,2547,2572,2579,2604,2611,2636,2643,2668,2675,2700,2707,2732,2739,2764,2771,2796,2803,2828,2835,2860,2867,2892,2899,2924,2931,2956,2963,2988,2995,3020,3027,3052,3059,3084,3091,3116,3123,3148,3155,3180,3187,3212,3219,3244,3251,3276,3283,3308,3315,3340,3347,3372,3379,3404,3411,3436,3443,3468,3475,3500,3507,3532,3539,3564,3571,3596,3603,3628,3635,3660,3667,3692,3699,3724,3731,3756,3763,3788,3795,3820,3827,3852,3859,3884,3891,3916,3923,3948,3955,3980,3987
mov $3,$0
gcd $0,2
mov $1,9
mul $1,$0
sub $1,6
mov $2,$3
mul $2,16
add $1,$2
|
programs/oeis/168/A168122.asm | neoneye/loda | 22 | 244739 | ; A168122: n^2*(n^4+1)/2.
; 0,1,34,369,2056,7825,23346,58849,131104,265761,500050,885841,1493064,2413489,3764866,5695425,8388736,12068929,17006274,23523121,32000200,42883281,56690194,74018209,95551776,122070625,154458226,193710609,240945544,297412081,364500450,443752321,536871424,645734529,772402786,919133425,1088391816,1282863889,1505468914,1759372641,2048000800,2375052961,2744516754,3160682449,3628157896,4151883825,4737149506,5389608769,6115296384,6920644801,7812501250,8798145201,9885306184,11082181969,12397457106,13840321825,15420491296,17148225249,19034347954,21090268561,23328001800,25760189041,28400119714,31261753089,34359740416,37709447425,41326977186,45229193329,49433743624,53959083921,58824502450,64050144481,69657037344,75667115809,82103247826,88989260625,96349967176,104211193009,112599803394,121543730881,131072003200,141214771521,152003339074,163470190129,175649019336,188574761425,202283621266,216813104289,232202047264,248490649441,265720504050,283934630161,303177504904,323495096049,344934894946,367545949825,391378899456,416486007169,442921195234,470740079601
pow $0,2
mov $1,$0
pow $1,3
add $0,$1
div $0,2
|
head/contrib/gcc/config/rs6000/tramp.asm | dplbsd/soc2013 | 4 | 80658 | <reponame>dplbsd/soc2013<filename>head/contrib/gcc/config/rs6000/tramp.asm
/* Special support for trampolines
*
* Copyright (C) 1996, 1997, 2000 Free Software Foundation, Inc.
* Written By <NAME>
*
* This file 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, or (at your option) any
* later version.
*
* In addition to the permissions in the GNU General Public License, the
* Free Software Foundation gives you unlimited permission to link the
* compiled version of this file with other programs, and to distribute
* those programs without any restriction coming from the use of this
* file. (The General Public License restrictions do apply in other
* respects; for example, they cover modification of the file, and
* distribution when not linked into another program.)
*
* This file 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; see the file COPYING. If not, write to
* the Free Software Foundation, 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
* As a special exception, if you link this library with files
* compiled with GCC to produce an executable, this does not cause
* the resulting executable to be covered by the GNU General Public License.
* This exception does not however invalidate any other reasons why
* the executable file might be covered by the GNU General Public License.
*/
/* Set up trampolines. */
.file "tramp.asm"
.section ".text"
#include "ppc-asm.h"
#ifndef __powerpc64__
.type trampoline_initial,@object
.align 2
trampoline_initial:
mflr r0
bcl 20,31,1f
.Lfunc = .-trampoline_initial
.long 0 /* will be replaced with function address */
.Lchain = .-trampoline_initial
.long 0 /* will be replaced with static chain */
1: mflr r11
mtlr r0
lwz r0,0(r11) /* function address */
lwz r11,4(r11) /* static chain */
mtctr r0
bctr
trampoline_size = .-trampoline_initial
.size trampoline_initial,trampoline_size
/* R3 = stack address to store trampoline */
/* R4 = length of trampoline area */
/* R5 = function address */
/* R6 = static chain */
FUNC_START(__trampoline_setup)
mflr r0 /* save return address */
bcl 20,31,.LCF0 /* load up __trampoline_initial into r7 */
.LCF0:
mflr r11
addi r7,r11,trampoline_initial-4-.LCF0 /* trampoline address -4 */
li r8,trampoline_size /* verify that the trampoline is big enough */
cmpw cr1,r8,r4
srwi r4,r4,2 /* # words to move */
addi r9,r3,-4 /* adjust pointer for lwzu */
mtctr r4
blt cr1,.Labort
mtlr r0
/* Copy the instructions to the stack */
.Lmove:
lwzu r10,4(r7)
stwu r10,4(r9)
bdnz .Lmove
/* Store correct function and static chain */
stw r5,.Lfunc(r3)
stw r6,.Lchain(r3)
/* Now flush both caches */
mtctr r4
.Lcache:
icbi 0,r3
dcbf 0,r3
addi r3,r3,4
bdnz .Lcache
/* Finally synchronize things & return */
sync
isync
blr
.Labort:
#if defined SHARED && defined HAVE_AS_REL16
bcl 20,31,1f
1: mflr r30
addis r30,r30,_GLOBAL_OFFSET_TABLE_-1b@ha
addi r30,r30,_GLOBAL_OFFSET_TABLE_-1b@l
#endif
bl JUMP_TARGET(abort)
FUNC_END(__trampoline_setup)
#endif
.section .note.GNU-stack,"",%progbits
|
src/net-protos-dispatchers.adb | stcarrez/ada-enet | 16 | 28995 | -----------------------------------------------------------------------
-- net-protos-dispatchers -- Network protocol dispatchers
-- Copyright (C) 2016, 2017 <NAME>
-- Written by <NAME> (<EMAIL>)
--
-- 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.
-----------------------------------------------------------------------
with Net.Headers;
with Net.Protos.IPv4;
with Net.Protos.Icmp;
with Net.Sockets.Udp;
package body Net.Protos.Dispatchers is
procedure Default_Receive (Ifnet : in out Net.Interfaces.Ifnet_Type'Class;
Packet : in out Net.Buffers.Buffer_Type);
Igmp_Receive : Receive_Handler := Default_Receive'Access;
Icmp_Receive : Receive_Handler := Net.Protos.Icmp.Receive'Access;
Udp_Receive : Receive_Handler := Net.Sockets.Udp.Input'Access;
Other_Receive : Receive_Handler := Default_Receive'Access;
-- ------------------------------
-- Set a protocol handler to deal with a packet of the given protocol when it is received.
-- Return the previous protocol handler.
-- ------------------------------
procedure Set_Handler (Proto : in Net.Uint8;
Handler : in Receive_Handler;
Previous : out Receive_Handler) is
begin
case Proto is
when Net.Protos.IPv4.P_ICMP =>
Previous := Icmp_Receive;
Icmp_Receive := Handler;
when Net.Protos.IPv4.P_IGMP =>
Previous := Igmp_Receive;
Igmp_Receive := Handler;
when Net.Protos.IPv4.P_UDP =>
Previous := Udp_Receive;
Udp_Receive := Handler;
when others =>
Previous := Other_Receive;
Other_Receive := Handler;
end case;
end Set_Handler;
procedure Default_Receive (Ifnet : in out Net.Interfaces.Ifnet_Type'Class;
Packet : in out Net.Buffers.Buffer_Type) is
begin
null;
end Default_Receive;
-- ------------------------------
-- Receive an IPv4 packet and dispatch it according to the protocol.
-- ------------------------------
procedure Receive (Ifnet : in out Net.Interfaces.Ifnet_Type'Class;
Packet : in out Net.Buffers.Buffer_Type) is
Ip_Hdr : constant Net.Headers.IP_Header_Access := Packet.IP;
begin
case Ip_Hdr.Ip_P is
when Net.Protos.IPv4.P_ICMP =>
Icmp_Receive (Ifnet, Packet);
when Net.Protos.IPv4.P_IGMP =>
Igmp_Receive (Ifnet, Packet);
when Net.Protos.IPv4.P_UDP =>
Udp_Receive (Ifnet, Packet);
when others =>
Other_Receive (Ifnet, Packet);
end case;
end Receive;
end Net.Protos.Dispatchers;
|
src/public/src/FM7/util/T77ToRS232C/bioshook_small.asm | rothberg-cmu/rothberg-run | 1 | 246850 | <reponame>rothberg-cmu/rothberg-run
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
DEF_BRIDGE_OFFSET EQU $0
BIOS_HOOK ; Typical way of handling I/O can bd
; LDA #$FD
; TFR A,DP
; and then use direct-page access.
; But, it takes 4 bytes.
; If I use U register, I can set #$FD00 to U in 3 bytes.
; Bridge code assumes U=#$FD00 on return.
LDU #$FD00
LDA #$B7
; #$B7 will be written to RS232C command
; in BIOS_CTBWRT and BIOS_CTBRED
; In "Dig Dug" (COMPAC) loader, subsequent LOADM commands call
; MOTOR OFF and then start reading without calling MOTOR ON.
; Need to guarantee to enable RS232C Rx/Tx by writing #$B7 to 7,U.
LDB ,X
DECB
BEQ BIOS_MOTOR
DECB
BEQ BIOS_CTBWRT
DECB
BEQ BIOS_CTBRED
COMA ; ORCC #1 <- COM always raise Carry.
RTS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; If [2,X] is $FF, turn on motor, turn off otherwise.
; When motor is turned off, reset RS232C so that it won't fire IRQ any more.
BIOS_MOTOR LDA 2,X
INCA
BNE BIOS_MOTOR_OFF
BIOS_MOTOR_ON LEAX RS232C_RESET_CMD,PCR
; According to http://vorkosigan.cocolog-nifty.com/blog/2009/12/a-b085.html
; Need to wait 8 clocks between writes.
MOTOR_RS232C_RESET_LOOP
CLRA ; 2 clocks
LDA ,X+ ; 5 clocks
STA 7,U ; IO_RS232C_COMMAND
BPL MOTOR_RS232C_RESET_LOOP ; Only last command is negative ; 3 clocks
; CLRA clears carry flag.
; LDA, STA, and BPL does not change.
; Can take 10 clocks after each STA 7,U
RTS
; 8251A Data Sheet pp.12 'NOTE' paragraph
; Regarding Internal Reset on Power-up.
RS232C_RESET_CMD FCB 0,0,0,$40,$4E,$B7
; Need to make sure RS232C does nothing after MOTOR OFF.
; "Emergency" (COMPAC) cannot take key inputs unless
; RS232C is set to do nothing.
BIOS_MOTOR_OFF
; Commonly known I/O map tells bit1 of $FD00 means
; 1: Motor off
; 0: Motor on
; which is flipped from actual. Actual FM-7 write 1 to bit1 of $FD00 to MOTOR-ON.
; Also, F-BASIC "SAVE" command write $42 outside of BIOS. Overriding the BIOS
; does not stop F-BASIC from MOTOR-ON. Therefore, after loading, it must be set
; to OFF.
; To motor off, $40 needs to be written to $FD00. Bit6 carries a printer strobe
; I need that 1 bit to prevent printer confusion.
; I don't want to do it, but it wastes another 4 bytes.
LDA #$40
STA ,U
CLR 2,U ; Re-clear IRQ
CLR 7,U ; IO_RS232C_COMMAND
RTS ; Previous CLR 7,U also clears carry
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; 8251A Data Sheet pp.16 "NOTES" #4
; Recovery time between writes for asynchronous mode is 8 tCY
; Probably it is recovery time between sends.
; May not need wait after setting the status bits.
BIOS_CTBWRT STA 7,U ; IO_RS232C_COMMAND
; A=#$B7=WRITE_REQUEST
BSR RS232C_WRITE ; 7 clocks
LDA 2,X
RS232C_WRITE LDB 7,U ; IO_RS232C_COMMAND
LSRB
BCC RS232C_WRITE
STA 6,U ; IO_RS232C_DATA
CLRA
RTS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
BIOS_CTBRED STA 7,U ; IO_RS232C_COMMAND
DECA ; A=#$B7 -> #$B6
; A=#$B6=READ_REQUEST
BSR RS232C_WRITE ; 7 clocks
RS232C_READ LDA #2
ANDA 7,U ; IO_RS232C_COMMAND
BEQ RS232C_READ
LDA 6,U ; IO_RS232C_DATA
BIOS_CTBRED_EXIT STA 2,X
CLRA
RTS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
BIOS_HOOK_END
END_OF_PROGRAM
|
sh.asm | dylsugar/cs461_hw5 | 0 | 161377 | <reponame>dylsugar/cs461_hw5
_sh: file format elf64-x86-64
Disassembly of section .text:
0000000000001000 <runcmd>:
struct cmd *parsecmd(char*);
// Execute cmd. Never returns.
void
runcmd(struct cmd *cmd)
{
1000: f3 0f 1e fa endbr64
1004: 55 push %rbp
1005: 48 89 e5 mov %rsp,%rbp
1008: 48 83 ec 40 sub $0x40,%rsp
100c: 48 89 7d c8 mov %rdi,-0x38(%rbp)
struct execcmd *ecmd;
struct listcmd *lcmd;
struct pipecmd *pcmd;
struct redircmd *rcmd;
if(cmd == 0)
1010: 48 83 7d c8 00 cmpq $0x0,-0x38(%rbp)
1015: 75 0c jne 1023 <runcmd+0x23>
exit();
1017: 48 b8 83 25 00 00 00 movabs $0x2583,%rax
101e: 00 00 00
1021: ff d0 callq *%rax
switch(cmd->type){
1023: 48 8b 45 c8 mov -0x38(%rbp),%rax
1027: 8b 00 mov (%rax),%eax
1029: 83 f8 05 cmp $0x5,%eax
102c: 77 1d ja 104b <runcmd+0x4b>
102e: 89 c0 mov %eax,%eax
1030: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
1037: 00
1038: 48 b8 d0 2f 00 00 00 movabs $0x2fd0,%rax
103f: 00 00 00
1042: 48 01 d0 add %rdx,%rax
1045: 48 8b 00 mov (%rax),%rax
1048: 3e ff e0 notrack jmpq *%rax
default:
panic("runcmd");
104b: 48 bf a0 2f 00 00 00 movabs $0x2fa0,%rdi
1052: 00 00 00
1055: 48 b8 33 15 00 00 00 movabs $0x1533,%rax
105c: 00 00 00
105f: ff d0 callq *%rax
case EXEC:
ecmd = (struct execcmd*)cmd;
1061: 48 8b 45 c8 mov -0x38(%rbp),%rax
1065: 48 89 45 d8 mov %rax,-0x28(%rbp)
if(ecmd->argv[0] == 0)
1069: 48 8b 45 d8 mov -0x28(%rbp),%rax
106d: 48 8b 40 08 mov 0x8(%rax),%rax
1071: 48 85 c0 test %rax,%rax
1074: 75 0c jne 1082 <runcmd+0x82>
exit();
1076: 48 b8 83 25 00 00 00 movabs $0x2583,%rax
107d: 00 00 00
1080: ff d0 callq *%rax
exec(ecmd->argv[0], ecmd->argv);
1082: 48 8b 45 d8 mov -0x28(%rbp),%rax
1086: 48 8d 50 08 lea 0x8(%rax),%rdx
108a: 48 8b 45 d8 mov -0x28(%rbp),%rax
108e: 48 8b 40 08 mov 0x8(%rax),%rax
1092: 48 89 d6 mov %rdx,%rsi
1095: 48 89 c7 mov %rax,%rdi
1098: 48 b8 de 25 00 00 00 movabs $0x25de,%rax
109f: 00 00 00
10a2: ff d0 callq *%rax
printf(2, "exec %s failed\n", ecmd->argv[0]);
10a4: 48 8b 45 d8 mov -0x28(%rbp),%rax
10a8: 48 8b 40 08 mov 0x8(%rax),%rax
10ac: 48 89 c2 mov %rax,%rdx
10af: 48 be a7 2f 00 00 00 movabs $0x2fa7,%rsi
10b6: 00 00 00
10b9: bf 02 00 00 00 mov $0x2,%edi
10be: b8 00 00 00 00 mov $0x0,%eax
10c3: 48 b9 87 28 00 00 00 movabs $0x2887,%rcx
10ca: 00 00 00
10cd: ff d1 callq *%rcx
break;
10cf: e9 62 02 00 00 jmpq 1336 <runcmd+0x336>
case REDIR:
rcmd = (struct redircmd*)cmd;
10d4: 48 8b 45 c8 mov -0x38(%rbp),%rax
10d8: 48 89 45 e0 mov %rax,-0x20(%rbp)
close(rcmd->fd);
10dc: 48 8b 45 e0 mov -0x20(%rbp),%rax
10e0: 8b 40 24 mov 0x24(%rax),%eax
10e3: 89 c7 mov %eax,%edi
10e5: 48 b8 c4 25 00 00 00 movabs $0x25c4,%rax
10ec: 00 00 00
10ef: ff d0 callq *%rax
if(open(rcmd->file, rcmd->mode) < 0){
10f1: 48 8b 45 e0 mov -0x20(%rbp),%rax
10f5: 8b 50 20 mov 0x20(%rax),%edx
10f8: 48 8b 45 e0 mov -0x20(%rbp),%rax
10fc: 48 8b 40 10 mov 0x10(%rax),%rax
1100: 89 d6 mov %edx,%esi
1102: 48 89 c7 mov %rax,%rdi
1105: 48 b8 eb 25 00 00 00 movabs $0x25eb,%rax
110c: 00 00 00
110f: ff d0 callq *%rax
1111: 85 c0 test %eax,%eax
1113: 79 37 jns 114c <runcmd+0x14c>
printf(2, "open %s failed\n", rcmd->file);
1115: 48 8b 45 e0 mov -0x20(%rbp),%rax
1119: 48 8b 40 10 mov 0x10(%rax),%rax
111d: 48 89 c2 mov %rax,%rdx
1120: 48 be b7 2f 00 00 00 movabs $0x2fb7,%rsi
1127: 00 00 00
112a: bf 02 00 00 00 mov $0x2,%edi
112f: b8 00 00 00 00 mov $0x0,%eax
1134: 48 b9 87 28 00 00 00 movabs $0x2887,%rcx
113b: 00 00 00
113e: ff d1 callq *%rcx
exit();
1140: 48 b8 83 25 00 00 00 movabs $0x2583,%rax
1147: 00 00 00
114a: ff d0 callq *%rax
}
runcmd(rcmd->cmd);
114c: 48 8b 45 e0 mov -0x20(%rbp),%rax
1150: 48 8b 40 08 mov 0x8(%rax),%rax
1154: 48 89 c7 mov %rax,%rdi
1157: 48 b8 00 10 00 00 00 movabs $0x1000,%rax
115e: 00 00 00
1161: ff d0 callq *%rax
break;
1163: e9 ce 01 00 00 jmpq 1336 <runcmd+0x336>
case LIST:
lcmd = (struct listcmd*)cmd;
1168: 48 8b 45 c8 mov -0x38(%rbp),%rax
116c: 48 89 45 f0 mov %rax,-0x10(%rbp)
if(fork1() == 0)
1170: 48 b8 76 15 00 00 00 movabs $0x1576,%rax
1177: 00 00 00
117a: ff d0 callq *%rax
117c: 85 c0 test %eax,%eax
117e: 75 17 jne 1197 <runcmd+0x197>
runcmd(lcmd->left);
1180: 48 8b 45 f0 mov -0x10(%rbp),%rax
1184: 48 8b 40 08 mov 0x8(%rax),%rax
1188: 48 89 c7 mov %rax,%rdi
118b: 48 b8 00 10 00 00 00 movabs $0x1000,%rax
1192: 00 00 00
1195: ff d0 callq *%rax
wait();
1197: 48 b8 90 25 00 00 00 movabs $0x2590,%rax
119e: 00 00 00
11a1: ff d0 callq *%rax
runcmd(lcmd->right);
11a3: 48 8b 45 f0 mov -0x10(%rbp),%rax
11a7: 48 8b 40 10 mov 0x10(%rax),%rax
11ab: 48 89 c7 mov %rax,%rdi
11ae: 48 b8 00 10 00 00 00 movabs $0x1000,%rax
11b5: 00 00 00
11b8: ff d0 callq *%rax
break;
11ba: e9 77 01 00 00 jmpq 1336 <runcmd+0x336>
case PIPE:
pcmd = (struct pipecmd*)cmd;
11bf: 48 8b 45 c8 mov -0x38(%rbp),%rax
11c3: 48 89 45 e8 mov %rax,-0x18(%rbp)
if(pipe(p) < 0)
11c7: 48 8d 45 d0 lea -0x30(%rbp),%rax
11cb: 48 89 c7 mov %rax,%rdi
11ce: 48 b8 9d 25 00 00 00 movabs $0x259d,%rax
11d5: 00 00 00
11d8: ff d0 callq *%rax
11da: 85 c0 test %eax,%eax
11dc: 79 16 jns 11f4 <runcmd+0x1f4>
panic("pipe");
11de: 48 bf c7 2f 00 00 00 movabs $0x2fc7,%rdi
11e5: 00 00 00
11e8: 48 b8 33 15 00 00 00 movabs $0x1533,%rax
11ef: 00 00 00
11f2: ff d0 callq *%rax
if(fork1() == 0){
11f4: 48 b8 76 15 00 00 00 movabs $0x1576,%rax
11fb: 00 00 00
11fe: ff d0 callq *%rax
1200: 85 c0 test %eax,%eax
1202: 75 5b jne 125f <runcmd+0x25f>
close(1);
1204: bf 01 00 00 00 mov $0x1,%edi
1209: 48 b8 c4 25 00 00 00 movabs $0x25c4,%rax
1210: 00 00 00
1213: ff d0 callq *%rax
dup(p[1]);
1215: 8b 45 d4 mov -0x2c(%rbp),%eax
1218: 89 c7 mov %eax,%edi
121a: 48 b8 46 26 00 00 00 movabs $0x2646,%rax
1221: 00 00 00
1224: ff d0 callq *%rax
close(p[0]);
1226: 8b 45 d0 mov -0x30(%rbp),%eax
1229: 89 c7 mov %eax,%edi
122b: 48 b8 c4 25 00 00 00 movabs $0x25c4,%rax
1232: 00 00 00
1235: ff d0 callq *%rax
close(p[1]);
1237: 8b 45 d4 mov -0x2c(%rbp),%eax
123a: 89 c7 mov %eax,%edi
123c: 48 b8 c4 25 00 00 00 movabs $0x25c4,%rax
1243: 00 00 00
1246: ff d0 callq *%rax
runcmd(pcmd->left);
1248: 48 8b 45 e8 mov -0x18(%rbp),%rax
124c: 48 8b 40 08 mov 0x8(%rax),%rax
1250: 48 89 c7 mov %rax,%rdi
1253: 48 b8 00 10 00 00 00 movabs $0x1000,%rax
125a: 00 00 00
125d: ff d0 callq *%rax
}
if(fork1() == 0){
125f: 48 b8 76 15 00 00 00 movabs $0x1576,%rax
1266: 00 00 00
1269: ff d0 callq *%rax
126b: 85 c0 test %eax,%eax
126d: 75 5b jne 12ca <runcmd+0x2ca>
close(0);
126f: bf 00 00 00 00 mov $0x0,%edi
1274: 48 b8 c4 25 00 00 00 movabs $0x25c4,%rax
127b: 00 00 00
127e: ff d0 callq *%rax
dup(p[0]);
1280: 8b 45 d0 mov -0x30(%rbp),%eax
1283: 89 c7 mov %eax,%edi
1285: 48 b8 46 26 00 00 00 movabs $0x2646,%rax
128c: 00 00 00
128f: ff d0 callq *%rax
close(p[0]);
1291: 8b 45 d0 mov -0x30(%rbp),%eax
1294: 89 c7 mov %eax,%edi
1296: 48 b8 c4 25 00 00 00 movabs $0x25c4,%rax
129d: 00 00 00
12a0: ff d0 callq *%rax
close(p[1]);
12a2: 8b 45 d4 mov -0x2c(%rbp),%eax
12a5: 89 c7 mov %eax,%edi
12a7: 48 b8 c4 25 00 00 00 movabs $0x25c4,%rax
12ae: 00 00 00
12b1: ff d0 callq *%rax
runcmd(pcmd->right);
12b3: 48 8b 45 e8 mov -0x18(%rbp),%rax
12b7: 48 8b 40 10 mov 0x10(%rax),%rax
12bb: 48 89 c7 mov %rax,%rdi
12be: 48 b8 00 10 00 00 00 movabs $0x1000,%rax
12c5: 00 00 00
12c8: ff d0 callq *%rax
}
close(p[0]);
12ca: 8b 45 d0 mov -0x30(%rbp),%eax
12cd: 89 c7 mov %eax,%edi
12cf: 48 b8 c4 25 00 00 00 movabs $0x25c4,%rax
12d6: 00 00 00
12d9: ff d0 callq *%rax
close(p[1]);
12db: 8b 45 d4 mov -0x2c(%rbp),%eax
12de: 89 c7 mov %eax,%edi
12e0: 48 b8 c4 25 00 00 00 movabs $0x25c4,%rax
12e7: 00 00 00
12ea: ff d0 callq *%rax
wait();
12ec: 48 b8 90 25 00 00 00 movabs $0x2590,%rax
12f3: 00 00 00
12f6: ff d0 callq *%rax
wait();
12f8: 48 b8 90 25 00 00 00 movabs $0x2590,%rax
12ff: 00 00 00
1302: ff d0 callq *%rax
break;
1304: eb 30 jmp 1336 <runcmd+0x336>
case BACK:
bcmd = (struct backcmd*)cmd;
1306: 48 8b 45 c8 mov -0x38(%rbp),%rax
130a: 48 89 45 f8 mov %rax,-0x8(%rbp)
if(fork1() == 0)
130e: 48 b8 76 15 00 00 00 movabs $0x1576,%rax
1315: 00 00 00
1318: ff d0 callq *%rax
131a: 85 c0 test %eax,%eax
131c: 75 17 jne 1335 <runcmd+0x335>
runcmd(bcmd->cmd);
131e: 48 8b 45 f8 mov -0x8(%rbp),%rax
1322: 48 8b 40 08 mov 0x8(%rax),%rax
1326: 48 89 c7 mov %rax,%rdi
1329: 48 b8 00 10 00 00 00 movabs $0x1000,%rax
1330: 00 00 00
1333: ff d0 callq *%rax
break;
1335: 90 nop
}
exit();
1336: 48 b8 83 25 00 00 00 movabs $0x2583,%rax
133d: 00 00 00
1340: ff d0 callq *%rax
0000000000001342 <getcmd>:
}
int
getcmd(char *buf, int nbuf)
{
1342: f3 0f 1e fa endbr64
1346: 55 push %rbp
1347: 48 89 e5 mov %rsp,%rbp
134a: 48 83 ec 10 sub $0x10,%rsp
134e: 48 89 7d f8 mov %rdi,-0x8(%rbp)
1352: 89 75 f4 mov %esi,-0xc(%rbp)
printf(2, "$ ");
1355: 48 be 00 30 00 00 00 movabs $0x3000,%rsi
135c: 00 00 00
135f: bf 02 00 00 00 mov $0x2,%edi
1364: b8 00 00 00 00 mov $0x0,%eax
1369: 48 ba 87 28 00 00 00 movabs $0x2887,%rdx
1370: 00 00 00
1373: ff d2 callq *%rdx
memset(buf, 0, nbuf);
1375: 8b 55 f4 mov -0xc(%rbp),%edx
1378: 48 8b 45 f8 mov -0x8(%rbp),%rax
137c: be 00 00 00 00 mov $0x0,%esi
1381: 48 89 c7 mov %rax,%rdi
1384: 48 b8 4e 23 00 00 00 movabs $0x234e,%rax
138b: 00 00 00
138e: ff d0 callq *%rax
gets(buf, nbuf);
1390: 8b 55 f4 mov -0xc(%rbp),%edx
1393: 48 8b 45 f8 mov -0x8(%rbp),%rax
1397: 89 d6 mov %edx,%esi
1399: 48 89 c7 mov %rax,%rdi
139c: 48 b8 c5 23 00 00 00 movabs $0x23c5,%rax
13a3: 00 00 00
13a6: ff d0 callq *%rax
if(buf[0] == 0) // EOF
13a8: 48 8b 45 f8 mov -0x8(%rbp),%rax
13ac: 0f b6 00 movzbl (%rax),%eax
13af: 84 c0 test %al,%al
13b1: 75 07 jne 13ba <getcmd+0x78>
return -1;
13b3: b8 ff ff ff ff mov $0xffffffff,%eax
13b8: eb 05 jmp 13bf <getcmd+0x7d>
return 0;
13ba: b8 00 00 00 00 mov $0x0,%eax
}
13bf: c9 leaveq
13c0: c3 retq
00000000000013c1 <main>:
int
main(void)
{
13c1: f3 0f 1e fa endbr64
13c5: 55 push %rbp
13c6: 48 89 e5 mov %rsp,%rbp
13c9: 48 83 ec 10 sub $0x10,%rsp
static char buf[100];
int fd;
// Ensure that three file descriptors are open.
while((fd = open("console", O_RDWR)) >= 0){
13cd: eb 19 jmp 13e8 <main+0x27>
if(fd >= 3){
13cf: 83 7d fc 02 cmpl $0x2,-0x4(%rbp)
13d3: 7e 13 jle 13e8 <main+0x27>
close(fd);
13d5: 8b 45 fc mov -0x4(%rbp),%eax
13d8: 89 c7 mov %eax,%edi
13da: 48 b8 c4 25 00 00 00 movabs $0x25c4,%rax
13e1: 00 00 00
13e4: ff d0 callq *%rax
break;
13e6: eb 24 jmp 140c <main+0x4b>
while((fd = open("console", O_RDWR)) >= 0){
13e8: be 02 00 00 00 mov $0x2,%esi
13ed: 48 bf 03 30 00 00 00 movabs $0x3003,%rdi
13f4: 00 00 00
13f7: 48 b8 eb 25 00 00 00 movabs $0x25eb,%rax
13fe: 00 00 00
1401: ff d0 callq *%rax
1403: 89 45 fc mov %eax,-0x4(%rbp)
1406: 83 7d fc 00 cmpl $0x0,-0x4(%rbp)
140a: 79 c3 jns 13cf <main+0xe>
}
}
// Read and run input commands.
while(getcmd(buf, sizeof(buf)) >= 0){
140c: e9 f3 00 00 00 jmpq 1504 <main+0x143>
if(buf[0] == 'c' && buf[1] == 'd' && buf[2] == ' '){
1411: 48 b8 60 36 00 00 00 movabs $0x3660,%rax
1418: 00 00 00
141b: 0f b6 00 movzbl (%rax),%eax
141e: 3c 63 cmp $0x63,%al
1420: 0f 85 9d 00 00 00 jne 14c3 <main+0x102>
1426: 48 b8 60 36 00 00 00 movabs $0x3660,%rax
142d: 00 00 00
1430: 0f b6 40 01 movzbl 0x1(%rax),%eax
1434: 3c 64 cmp $0x64,%al
1436: 0f 85 87 00 00 00 jne 14c3 <main+0x102>
143c: 48 b8 60 36 00 00 00 movabs $0x3660,%rax
1443: 00 00 00
1446: 0f b6 40 02 movzbl 0x2(%rax),%eax
144a: 3c 20 cmp $0x20,%al
144c: 75 75 jne 14c3 <main+0x102>
// Chdir must be called by the parent, not the child.
buf[strlen(buf)-1] = 0; // chop \n
144e: 48 bf 60 36 00 00 00 movabs $0x3660,%rdi
1455: 00 00 00
1458: 48 b8 18 23 00 00 00 movabs $0x2318,%rax
145f: 00 00 00
1462: ff d0 callq *%rax
1464: 8d 50 ff lea -0x1(%rax),%edx
1467: 48 b8 60 36 00 00 00 movabs $0x3660,%rax
146e: 00 00 00
1471: 89 d2 mov %edx,%edx
1473: c6 04 10 00 movb $0x0,(%rax,%rdx,1)
if(chdir(buf+3) < 0)
1477: 48 b8 63 36 00 00 00 movabs $0x3663,%rax
147e: 00 00 00
1481: 48 89 c7 mov %rax,%rdi
1484: 48 b8 39 26 00 00 00 movabs $0x2639,%rax
148b: 00 00 00
148e: ff d0 callq *%rax
1490: 85 c0 test %eax,%eax
1492: 79 70 jns 1504 <main+0x143>
printf(2, "cannot cd %s\n", buf+3);
1494: 48 b8 63 36 00 00 00 movabs $0x3663,%rax
149b: 00 00 00
149e: 48 89 c2 mov %rax,%rdx
14a1: 48 be 0b 30 00 00 00 movabs $0x300b,%rsi
14a8: 00 00 00
14ab: bf 02 00 00 00 mov $0x2,%edi
14b0: b8 00 00 00 00 mov $0x0,%eax
14b5: 48 b9 87 28 00 00 00 movabs $0x2887,%rcx
14bc: 00 00 00
14bf: ff d1 callq *%rcx
continue;
14c1: eb 41 jmp 1504 <main+0x143>
}
if(fork1() == 0)
14c3: 48 b8 76 15 00 00 00 movabs $0x1576,%rax
14ca: 00 00 00
14cd: ff d0 callq *%rax
14cf: 85 c0 test %eax,%eax
14d1: 75 25 jne 14f8 <main+0x137>
runcmd(parsecmd(buf));
14d3: 48 bf 60 36 00 00 00 movabs $0x3660,%rdi
14da: 00 00 00
14dd: 48 b8 24 1a 00 00 00 movabs $0x1a24,%rax
14e4: 00 00 00
14e7: ff d0 callq *%rax
14e9: 48 89 c7 mov %rax,%rdi
14ec: 48 b8 00 10 00 00 00 movabs $0x1000,%rax
14f3: 00 00 00
14f6: ff d0 callq *%rax
wait();
14f8: 48 b8 90 25 00 00 00 movabs $0x2590,%rax
14ff: 00 00 00
1502: ff d0 callq *%rax
while(getcmd(buf, sizeof(buf)) >= 0){
1504: be 64 00 00 00 mov $0x64,%esi
1509: 48 bf 60 36 00 00 00 movabs $0x3660,%rdi
1510: 00 00 00
1513: 48 b8 42 13 00 00 00 movabs $0x1342,%rax
151a: 00 00 00
151d: ff d0 callq *%rax
151f: 85 c0 test %eax,%eax
1521: 0f 89 ea fe ff ff jns 1411 <main+0x50>
}
exit();
1527: 48 b8 83 25 00 00 00 movabs $0x2583,%rax
152e: 00 00 00
1531: ff d0 callq *%rax
0000000000001533 <panic>:
}
void
panic(char *s)
{
1533: f3 0f 1e fa endbr64
1537: 55 push %rbp
1538: 48 89 e5 mov %rsp,%rbp
153b: 48 83 ec 10 sub $0x10,%rsp
153f: 48 89 7d f8 mov %rdi,-0x8(%rbp)
printf(2, "%s\n", s);
1543: 48 8b 45 f8 mov -0x8(%rbp),%rax
1547: 48 89 c2 mov %rax,%rdx
154a: 48 be 19 30 00 00 00 movabs $0x3019,%rsi
1551: 00 00 00
1554: bf 02 00 00 00 mov $0x2,%edi
1559: b8 00 00 00 00 mov $0x0,%eax
155e: 48 b9 87 28 00 00 00 movabs $0x2887,%rcx
1565: 00 00 00
1568: ff d1 callq *%rcx
exit();
156a: 48 b8 83 25 00 00 00 movabs $0x2583,%rax
1571: 00 00 00
1574: ff d0 callq *%rax
0000000000001576 <fork1>:
}
int
fork1(void)
{
1576: f3 0f 1e fa endbr64
157a: 55 push %rbp
157b: 48 89 e5 mov %rsp,%rbp
157e: 48 83 ec 10 sub $0x10,%rsp
int pid;
pid = fork();
1582: 48 b8 76 25 00 00 00 movabs $0x2576,%rax
1589: 00 00 00
158c: ff d0 callq *%rax
158e: 89 45 fc mov %eax,-0x4(%rbp)
if(pid == -1)
1591: 83 7d fc ff cmpl $0xffffffff,-0x4(%rbp)
1595: 75 16 jne 15ad <fork1+0x37>
panic("fork");
1597: 48 bf 1d 30 00 00 00 movabs $0x301d,%rdi
159e: 00 00 00
15a1: 48 b8 33 15 00 00 00 movabs $0x1533,%rax
15a8: 00 00 00
15ab: ff d0 callq *%rax
return pid;
15ad: 8b 45 fc mov -0x4(%rbp),%eax
}
15b0: c9 leaveq
15b1: c3 retq
00000000000015b2 <execcmd>:
//PAGEBREAK!
// Constructors
struct cmd*
execcmd(void)
{
15b2: f3 0f 1e fa endbr64
15b6: 55 push %rbp
15b7: 48 89 e5 mov %rsp,%rbp
15ba: 48 83 ec 10 sub $0x10,%rsp
struct execcmd *cmd;
cmd = malloc(sizeof(*cmd));
15be: bf a8 00 00 00 mov $0xa8,%edi
15c3: 48 b8 4c 2e 00 00 00 movabs $0x2e4c,%rax
15ca: 00 00 00
15cd: ff d0 callq *%rax
15cf: 48 89 45 f8 mov %rax,-0x8(%rbp)
memset(cmd, 0, sizeof(*cmd));
15d3: 48 8b 45 f8 mov -0x8(%rbp),%rax
15d7: ba a8 00 00 00 mov $0xa8,%edx
15dc: be 00 00 00 00 mov $0x0,%esi
15e1: 48 89 c7 mov %rax,%rdi
15e4: 48 b8 4e 23 00 00 00 movabs $0x234e,%rax
15eb: 00 00 00
15ee: ff d0 callq *%rax
cmd->type = EXEC;
15f0: 48 8b 45 f8 mov -0x8(%rbp),%rax
15f4: c7 00 01 00 00 00 movl $0x1,(%rax)
return (struct cmd*)cmd;
15fa: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
15fe: c9 leaveq
15ff: c3 retq
0000000000001600 <redircmd>:
struct cmd*
redircmd(struct cmd *subcmd, char *file, char *efile, int mode, int fd)
{
1600: f3 0f 1e fa endbr64
1604: 55 push %rbp
1605: 48 89 e5 mov %rsp,%rbp
1608: 48 83 ec 30 sub $0x30,%rsp
160c: 48 89 7d e8 mov %rdi,-0x18(%rbp)
1610: 48 89 75 e0 mov %rsi,-0x20(%rbp)
1614: 48 89 55 d8 mov %rdx,-0x28(%rbp)
1618: 89 4d d4 mov %ecx,-0x2c(%rbp)
161b: 44 89 45 d0 mov %r8d,-0x30(%rbp)
struct redircmd *cmd;
cmd = malloc(sizeof(*cmd));
161f: bf 28 00 00 00 mov $0x28,%edi
1624: 48 b8 4c 2e 00 00 00 movabs $0x2e4c,%rax
162b: 00 00 00
162e: ff d0 callq *%rax
1630: 48 89 45 f8 mov %rax,-0x8(%rbp)
memset(cmd, 0, sizeof(*cmd));
1634: 48 8b 45 f8 mov -0x8(%rbp),%rax
1638: ba 28 00 00 00 mov $0x28,%edx
163d: be 00 00 00 00 mov $0x0,%esi
1642: 48 89 c7 mov %rax,%rdi
1645: 48 b8 4e 23 00 00 00 movabs $0x234e,%rax
164c: 00 00 00
164f: ff d0 callq *%rax
cmd->type = REDIR;
1651: 48 8b 45 f8 mov -0x8(%rbp),%rax
1655: c7 00 02 00 00 00 movl $0x2,(%rax)
cmd->cmd = subcmd;
165b: 48 8b 45 f8 mov -0x8(%rbp),%rax
165f: 48 8b 55 e8 mov -0x18(%rbp),%rdx
1663: 48 89 50 08 mov %rdx,0x8(%rax)
cmd->file = file;
1667: 48 8b 45 f8 mov -0x8(%rbp),%rax
166b: 48 8b 55 e0 mov -0x20(%rbp),%rdx
166f: 48 89 50 10 mov %rdx,0x10(%rax)
cmd->efile = efile;
1673: 48 8b 45 f8 mov -0x8(%rbp),%rax
1677: 48 8b 55 d8 mov -0x28(%rbp),%rdx
167b: 48 89 50 18 mov %rdx,0x18(%rax)
cmd->mode = mode;
167f: 48 8b 45 f8 mov -0x8(%rbp),%rax
1683: 8b 55 d4 mov -0x2c(%rbp),%edx
1686: 89 50 20 mov %edx,0x20(%rax)
cmd->fd = fd;
1689: 48 8b 45 f8 mov -0x8(%rbp),%rax
168d: 8b 55 d0 mov -0x30(%rbp),%edx
1690: 89 50 24 mov %edx,0x24(%rax)
return (struct cmd*)cmd;
1693: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
1697: c9 leaveq
1698: c3 retq
0000000000001699 <pipecmd>:
struct cmd*
pipecmd(struct cmd *left, struct cmd *right)
{
1699: f3 0f 1e fa endbr64
169d: 55 push %rbp
169e: 48 89 e5 mov %rsp,%rbp
16a1: 48 83 ec 20 sub $0x20,%rsp
16a5: 48 89 7d e8 mov %rdi,-0x18(%rbp)
16a9: 48 89 75 e0 mov %rsi,-0x20(%rbp)
struct pipecmd *cmd;
cmd = malloc(sizeof(*cmd));
16ad: bf 18 00 00 00 mov $0x18,%edi
16b2: 48 b8 4c 2e 00 00 00 movabs $0x2e4c,%rax
16b9: 00 00 00
16bc: ff d0 callq *%rax
16be: 48 89 45 f8 mov %rax,-0x8(%rbp)
memset(cmd, 0, sizeof(*cmd));
16c2: 48 8b 45 f8 mov -0x8(%rbp),%rax
16c6: ba 18 00 00 00 mov $0x18,%edx
16cb: be 00 00 00 00 mov $0x0,%esi
16d0: 48 89 c7 mov %rax,%rdi
16d3: 48 b8 4e 23 00 00 00 movabs $0x234e,%rax
16da: 00 00 00
16dd: ff d0 callq *%rax
cmd->type = PIPE;
16df: 48 8b 45 f8 mov -0x8(%rbp),%rax
16e3: c7 00 03 00 00 00 movl $0x3,(%rax)
cmd->left = left;
16e9: 48 8b 45 f8 mov -0x8(%rbp),%rax
16ed: 48 8b 55 e8 mov -0x18(%rbp),%rdx
16f1: 48 89 50 08 mov %rdx,0x8(%rax)
cmd->right = right;
16f5: 48 8b 45 f8 mov -0x8(%rbp),%rax
16f9: 48 8b 55 e0 mov -0x20(%rbp),%rdx
16fd: 48 89 50 10 mov %rdx,0x10(%rax)
return (struct cmd*)cmd;
1701: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
1705: c9 leaveq
1706: c3 retq
0000000000001707 <listcmd>:
struct cmd*
listcmd(struct cmd *left, struct cmd *right)
{
1707: f3 0f 1e fa endbr64
170b: 55 push %rbp
170c: 48 89 e5 mov %rsp,%rbp
170f: 48 83 ec 20 sub $0x20,%rsp
1713: 48 89 7d e8 mov %rdi,-0x18(%rbp)
1717: 48 89 75 e0 mov %rsi,-0x20(%rbp)
struct listcmd *cmd;
cmd = malloc(sizeof(*cmd));
171b: bf 18 00 00 00 mov $0x18,%edi
1720: 48 b8 4c 2e 00 00 00 movabs $0x2e4c,%rax
1727: 00 00 00
172a: ff d0 callq *%rax
172c: 48 89 45 f8 mov %rax,-0x8(%rbp)
memset(cmd, 0, sizeof(*cmd));
1730: 48 8b 45 f8 mov -0x8(%rbp),%rax
1734: ba 18 00 00 00 mov $0x18,%edx
1739: be 00 00 00 00 mov $0x0,%esi
173e: 48 89 c7 mov %rax,%rdi
1741: 48 b8 4e 23 00 00 00 movabs $0x234e,%rax
1748: 00 00 00
174b: ff d0 callq *%rax
cmd->type = LIST;
174d: 48 8b 45 f8 mov -0x8(%rbp),%rax
1751: c7 00 04 00 00 00 movl $0x4,(%rax)
cmd->left = left;
1757: 48 8b 45 f8 mov -0x8(%rbp),%rax
175b: 48 8b 55 e8 mov -0x18(%rbp),%rdx
175f: 48 89 50 08 mov %rdx,0x8(%rax)
cmd->right = right;
1763: 48 8b 45 f8 mov -0x8(%rbp),%rax
1767: 48 8b 55 e0 mov -0x20(%rbp),%rdx
176b: 48 89 50 10 mov %rdx,0x10(%rax)
return (struct cmd*)cmd;
176f: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
1773: c9 leaveq
1774: c3 retq
0000000000001775 <backcmd>:
struct cmd*
backcmd(struct cmd *subcmd)
{
1775: f3 0f 1e fa endbr64
1779: 55 push %rbp
177a: 48 89 e5 mov %rsp,%rbp
177d: 48 83 ec 20 sub $0x20,%rsp
1781: 48 89 7d e8 mov %rdi,-0x18(%rbp)
struct backcmd *cmd;
cmd = malloc(sizeof(*cmd));
1785: bf 10 00 00 00 mov $0x10,%edi
178a: 48 b8 4c 2e 00 00 00 movabs $0x2e4c,%rax
1791: 00 00 00
1794: ff d0 callq *%rax
1796: 48 89 45 f8 mov %rax,-0x8(%rbp)
memset(cmd, 0, sizeof(*cmd));
179a: 48 8b 45 f8 mov -0x8(%rbp),%rax
179e: ba 10 00 00 00 mov $0x10,%edx
17a3: be 00 00 00 00 mov $0x0,%esi
17a8: 48 89 c7 mov %rax,%rdi
17ab: 48 b8 4e 23 00 00 00 movabs $0x234e,%rax
17b2: 00 00 00
17b5: ff d0 callq *%rax
cmd->type = BACK;
17b7: 48 8b 45 f8 mov -0x8(%rbp),%rax
17bb: c7 00 05 00 00 00 movl $0x5,(%rax)
cmd->cmd = subcmd;
17c1: 48 8b 45 f8 mov -0x8(%rbp),%rax
17c5: 48 8b 55 e8 mov -0x18(%rbp),%rdx
17c9: 48 89 50 08 mov %rdx,0x8(%rax)
return (struct cmd*)cmd;
17cd: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
17d1: c9 leaveq
17d2: c3 retq
00000000000017d3 <gettoken>:
char whitespace[] = " \t\r\n\v";
char symbols[] = "<|>&;()";
int
gettoken(char **ps, char *es, char **q, char **eq)
{
17d3: f3 0f 1e fa endbr64
17d7: 55 push %rbp
17d8: 48 89 e5 mov %rsp,%rbp
17db: 48 83 ec 30 sub $0x30,%rsp
17df: 48 89 7d e8 mov %rdi,-0x18(%rbp)
17e3: 48 89 75 e0 mov %rsi,-0x20(%rbp)
17e7: 48 89 55 d8 mov %rdx,-0x28(%rbp)
17eb: 48 89 4d d0 mov %rcx,-0x30(%rbp)
char *s;
int ret;
s = *ps;
17ef: 48 8b 45 e8 mov -0x18(%rbp),%rax
17f3: 48 8b 00 mov (%rax),%rax
17f6: 48 89 45 f8 mov %rax,-0x8(%rbp)
while(s < es && strchr(whitespace, *s))
17fa: eb 05 jmp 1801 <gettoken+0x2e>
s++;
17fc: 48 83 45 f8 01 addq $0x1,-0x8(%rbp)
while(s < es && strchr(whitespace, *s))
1801: 48 8b 45 f8 mov -0x8(%rbp),%rax
1805: 48 3b 45 e0 cmp -0x20(%rbp),%rax
1809: 73 27 jae 1832 <gettoken+0x5f>
180b: 48 8b 45 f8 mov -0x8(%rbp),%rax
180f: 0f b6 00 movzbl (%rax),%eax
1812: 0f be c0 movsbl %al,%eax
1815: 89 c6 mov %eax,%esi
1817: 48 bf 30 36 00 00 00 movabs $0x3630,%rdi
181e: 00 00 00
1821: 48 b8 85 23 00 00 00 movabs $0x2385,%rax
1828: 00 00 00
182b: ff d0 callq *%rax
182d: 48 85 c0 test %rax,%rax
1830: 75 ca jne 17fc <gettoken+0x29>
if(q)
1832: 48 83 7d d8 00 cmpq $0x0,-0x28(%rbp)
1837: 74 0b je 1844 <gettoken+0x71>
*q = s;
1839: 48 8b 45 d8 mov -0x28(%rbp),%rax
183d: 48 8b 55 f8 mov -0x8(%rbp),%rdx
1841: 48 89 10 mov %rdx,(%rax)
ret = *s;
1844: 48 8b 45 f8 mov -0x8(%rbp),%rax
1848: 0f b6 00 movzbl (%rax),%eax
184b: 0f be c0 movsbl %al,%eax
184e: 89 45 f4 mov %eax,-0xc(%rbp)
switch(*s){
1851: 48 8b 45 f8 mov -0x8(%rbp),%rax
1855: 0f b6 00 movzbl (%rax),%eax
1858: 0f be c0 movsbl %al,%eax
185b: 83 f8 7c cmp $0x7c,%eax
185e: 74 30 je 1890 <gettoken+0xbd>
1860: 83 f8 7c cmp $0x7c,%eax
1863: 7f 53 jg 18b8 <gettoken+0xe5>
1865: 83 f8 3e cmp $0x3e,%eax
1868: 74 30 je 189a <gettoken+0xc7>
186a: 83 f8 3e cmp $0x3e,%eax
186d: 7f 49 jg 18b8 <gettoken+0xe5>
186f: 83 f8 3c cmp $0x3c,%eax
1872: 7f 44 jg 18b8 <gettoken+0xe5>
1874: 83 f8 3b cmp $0x3b,%eax
1877: 7d 17 jge 1890 <gettoken+0xbd>
1879: 83 f8 29 cmp $0x29,%eax
187c: 7f 3a jg 18b8 <gettoken+0xe5>
187e: 83 f8 28 cmp $0x28,%eax
1881: 7d 0d jge 1890 <gettoken+0xbd>
1883: 85 c0 test %eax,%eax
1885: 0f 84 95 00 00 00 je 1920 <gettoken+0x14d>
188b: 83 f8 26 cmp $0x26,%eax
188e: 75 28 jne 18b8 <gettoken+0xe5>
case '(':
case ')':
case ';':
case '&':
case '<':
s++;
1890: 48 83 45 f8 01 addq $0x1,-0x8(%rbp)
break;
1895: e9 8d 00 00 00 jmpq 1927 <gettoken+0x154>
case '>':
s++;
189a: 48 83 45 f8 01 addq $0x1,-0x8(%rbp)
if(*s == '>'){
189f: 48 8b 45 f8 mov -0x8(%rbp),%rax
18a3: 0f b6 00 movzbl (%rax),%eax
18a6: 3c 3e cmp $0x3e,%al
18a8: 75 79 jne 1923 <gettoken+0x150>
ret = '+';
18aa: c7 45 f4 2b 00 00 00 movl $0x2b,-0xc(%rbp)
s++;
18b1: 48 83 45 f8 01 addq $0x1,-0x8(%rbp)
}
break;
18b6: eb 6b jmp 1923 <gettoken+0x150>
default:
ret = 'a';
18b8: c7 45 f4 61 00 00 00 movl $0x61,-0xc(%rbp)
while(s < es && !strchr(whitespace, *s) && !strchr(symbols, *s))
18bf: eb 05 jmp 18c6 <gettoken+0xf3>
s++;
18c1: 48 83 45 f8 01 addq $0x1,-0x8(%rbp)
while(s < es && !strchr(whitespace, *s) && !strchr(symbols, *s))
18c6: 48 8b 45 f8 mov -0x8(%rbp),%rax
18ca: 48 3b 45 e0 cmp -0x20(%rbp),%rax
18ce: 73 56 jae 1926 <gettoken+0x153>
18d0: 48 8b 45 f8 mov -0x8(%rbp),%rax
18d4: 0f b6 00 movzbl (%rax),%eax
18d7: 0f be c0 movsbl %al,%eax
18da: 89 c6 mov %eax,%esi
18dc: 48 bf 30 36 00 00 00 movabs $0x3630,%rdi
18e3: 00 00 00
18e6: 48 b8 85 23 00 00 00 movabs $0x2385,%rax
18ed: 00 00 00
18f0: ff d0 callq *%rax
18f2: 48 85 c0 test %rax,%rax
18f5: 75 2f jne 1926 <gettoken+0x153>
18f7: 48 8b 45 f8 mov -0x8(%rbp),%rax
18fb: 0f b6 00 movzbl (%rax),%eax
18fe: 0f be c0 movsbl %al,%eax
1901: 89 c6 mov %eax,%esi
1903: 48 bf 38 36 00 00 00 movabs $0x3638,%rdi
190a: 00 00 00
190d: 48 b8 85 23 00 00 00 movabs $0x2385,%rax
1914: 00 00 00
1917: ff d0 callq *%rax
1919: 48 85 c0 test %rax,%rax
191c: 74 a3 je 18c1 <gettoken+0xee>
break;
191e: eb 06 jmp 1926 <gettoken+0x153>
break;
1920: 90 nop
1921: eb 04 jmp 1927 <gettoken+0x154>
break;
1923: 90 nop
1924: eb 01 jmp 1927 <gettoken+0x154>
break;
1926: 90 nop
}
if(eq)
1927: 48 83 7d d0 00 cmpq $0x0,-0x30(%rbp)
192c: 74 12 je 1940 <gettoken+0x16d>
*eq = s;
192e: 48 8b 45 d0 mov -0x30(%rbp),%rax
1932: 48 8b 55 f8 mov -0x8(%rbp),%rdx
1936: 48 89 10 mov %rdx,(%rax)
while(s < es && strchr(whitespace, *s))
1939: eb 05 jmp 1940 <gettoken+0x16d>
s++;
193b: 48 83 45 f8 01 addq $0x1,-0x8(%rbp)
while(s < es && strchr(whitespace, *s))
1940: 48 8b 45 f8 mov -0x8(%rbp),%rax
1944: 48 3b 45 e0 cmp -0x20(%rbp),%rax
1948: 73 27 jae 1971 <gettoken+0x19e>
194a: 48 8b 45 f8 mov -0x8(%rbp),%rax
194e: 0f b6 00 movzbl (%rax),%eax
1951: 0f be c0 movsbl %al,%eax
1954: 89 c6 mov %eax,%esi
1956: 48 bf 30 36 00 00 00 movabs $0x3630,%rdi
195d: 00 00 00
1960: 48 b8 85 23 00 00 00 movabs $0x2385,%rax
1967: 00 00 00
196a: ff d0 callq *%rax
196c: 48 85 c0 test %rax,%rax
196f: 75 ca jne 193b <gettoken+0x168>
*ps = s;
1971: 48 8b 45 e8 mov -0x18(%rbp),%rax
1975: 48 8b 55 f8 mov -0x8(%rbp),%rdx
1979: 48 89 10 mov %rdx,(%rax)
return ret;
197c: 8b 45 f4 mov -0xc(%rbp),%eax
}
197f: c9 leaveq
1980: c3 retq
0000000000001981 <peek>:
int
peek(char **ps, char *es, char *toks)
{
1981: f3 0f 1e fa endbr64
1985: 55 push %rbp
1986: 48 89 e5 mov %rsp,%rbp
1989: 48 83 ec 30 sub $0x30,%rsp
198d: 48 89 7d e8 mov %rdi,-0x18(%rbp)
1991: 48 89 75 e0 mov %rsi,-0x20(%rbp)
1995: 48 89 55 d8 mov %rdx,-0x28(%rbp)
char *s;
s = *ps;
1999: 48 8b 45 e8 mov -0x18(%rbp),%rax
199d: 48 8b 00 mov (%rax),%rax
19a0: 48 89 45 f8 mov %rax,-0x8(%rbp)
while(s < es && strchr(whitespace, *s))
19a4: eb 05 jmp 19ab <peek+0x2a>
s++;
19a6: 48 83 45 f8 01 addq $0x1,-0x8(%rbp)
while(s < es && strchr(whitespace, *s))
19ab: 48 8b 45 f8 mov -0x8(%rbp),%rax
19af: 48 3b 45 e0 cmp -0x20(%rbp),%rax
19b3: 73 27 jae 19dc <peek+0x5b>
19b5: 48 8b 45 f8 mov -0x8(%rbp),%rax
19b9: 0f b6 00 movzbl (%rax),%eax
19bc: 0f be c0 movsbl %al,%eax
19bf: 89 c6 mov %eax,%esi
19c1: 48 bf 30 36 00 00 00 movabs $0x3630,%rdi
19c8: 00 00 00
19cb: 48 b8 85 23 00 00 00 movabs $0x2385,%rax
19d2: 00 00 00
19d5: ff d0 callq *%rax
19d7: 48 85 c0 test %rax,%rax
19da: 75 ca jne 19a6 <peek+0x25>
*ps = s;
19dc: 48 8b 45 e8 mov -0x18(%rbp),%rax
19e0: 48 8b 55 f8 mov -0x8(%rbp),%rdx
19e4: 48 89 10 mov %rdx,(%rax)
return *s && strchr(toks, *s);
19e7: 48 8b 45 f8 mov -0x8(%rbp),%rax
19eb: 0f b6 00 movzbl (%rax),%eax
19ee: 84 c0 test %al,%al
19f0: 74 2b je 1a1d <peek+0x9c>
19f2: 48 8b 45 f8 mov -0x8(%rbp),%rax
19f6: 0f b6 00 movzbl (%rax),%eax
19f9: 0f be d0 movsbl %al,%edx
19fc: 48 8b 45 d8 mov -0x28(%rbp),%rax
1a00: 89 d6 mov %edx,%esi
1a02: 48 89 c7 mov %rax,%rdi
1a05: 48 b8 85 23 00 00 00 movabs $0x2385,%rax
1a0c: 00 00 00
1a0f: ff d0 callq *%rax
1a11: 48 85 c0 test %rax,%rax
1a14: 74 07 je 1a1d <peek+0x9c>
1a16: b8 01 00 00 00 mov $0x1,%eax
1a1b: eb 05 jmp 1a22 <peek+0xa1>
1a1d: b8 00 00 00 00 mov $0x0,%eax
}
1a22: c9 leaveq
1a23: c3 retq
0000000000001a24 <parsecmd>:
struct cmd *parseexec(char**, char*);
struct cmd *nulterminate(struct cmd*);
struct cmd*
parsecmd(char *s)
{
1a24: f3 0f 1e fa endbr64
1a28: 55 push %rbp
1a29: 48 89 e5 mov %rsp,%rbp
1a2c: 53 push %rbx
1a2d: 48 83 ec 28 sub $0x28,%rsp
1a31: 48 89 7d d8 mov %rdi,-0x28(%rbp)
char *es;
struct cmd *cmd;
es = s + strlen(s);
1a35: 48 8b 5d d8 mov -0x28(%rbp),%rbx
1a39: 48 8b 45 d8 mov -0x28(%rbp),%rax
1a3d: 48 89 c7 mov %rax,%rdi
1a40: 48 b8 18 23 00 00 00 movabs $0x2318,%rax
1a47: 00 00 00
1a4a: ff d0 callq *%rax
1a4c: 89 c0 mov %eax,%eax
1a4e: 48 01 d8 add %rbx,%rax
1a51: 48 89 45 e8 mov %rax,-0x18(%rbp)
cmd = parseline(&s, es);
1a55: 48 8b 55 e8 mov -0x18(%rbp),%rdx
1a59: 48 8d 45 d8 lea -0x28(%rbp),%rax
1a5d: 48 89 d6 mov %rdx,%rsi
1a60: 48 89 c7 mov %rax,%rdi
1a63: 48 b8 fc 1a 00 00 00 movabs $0x1afc,%rax
1a6a: 00 00 00
1a6d: ff d0 callq *%rax
1a6f: 48 89 45 e0 mov %rax,-0x20(%rbp)
peek(&s, es, "");
1a73: 48 8b 4d e8 mov -0x18(%rbp),%rcx
1a77: 48 8d 45 d8 lea -0x28(%rbp),%rax
1a7b: 48 ba 22 30 00 00 00 movabs $0x3022,%rdx
1a82: 00 00 00
1a85: 48 89 ce mov %rcx,%rsi
1a88: 48 89 c7 mov %rax,%rdi
1a8b: 48 b8 81 19 00 00 00 movabs $0x1981,%rax
1a92: 00 00 00
1a95: ff d0 callq *%rax
if(s != es){
1a97: 48 8b 45 d8 mov -0x28(%rbp),%rax
1a9b: 48 39 45 e8 cmp %rax,-0x18(%rbp)
1a9f: 74 3d je 1ade <parsecmd+0xba>
printf(2, "leftovers: %s\n", s);
1aa1: 48 8b 45 d8 mov -0x28(%rbp),%rax
1aa5: 48 89 c2 mov %rax,%rdx
1aa8: 48 be 23 30 00 00 00 movabs $0x3023,%rsi
1aaf: 00 00 00
1ab2: bf 02 00 00 00 mov $0x2,%edi
1ab7: b8 00 00 00 00 mov $0x0,%eax
1abc: 48 b9 87 28 00 00 00 movabs $0x2887,%rcx
1ac3: 00 00 00
1ac6: ff d1 callq *%rcx
panic("syntax");
1ac8: 48 bf 32 30 00 00 00 movabs $0x3032,%rdi
1acf: 00 00 00
1ad2: 48 b8 33 15 00 00 00 movabs $0x1533,%rax
1ad9: 00 00 00
1adc: ff d0 callq *%rax
}
nulterminate(cmd);
1ade: 48 8b 45 e0 mov -0x20(%rbp),%rax
1ae2: 48 89 c7 mov %rax,%rdi
1ae5: 48 b8 ea 20 00 00 00 movabs $0x20ea,%rax
1aec: 00 00 00
1aef: ff d0 callq *%rax
return cmd;
1af1: 48 8b 45 e0 mov -0x20(%rbp),%rax
}
1af5: 48 83 c4 28 add $0x28,%rsp
1af9: 5b pop %rbx
1afa: 5d pop %rbp
1afb: c3 retq
0000000000001afc <parseline>:
struct cmd*
parseline(char **ps, char *es)
{
1afc: f3 0f 1e fa endbr64
1b00: 55 push %rbp
1b01: 48 89 e5 mov %rsp,%rbp
1b04: 48 83 ec 20 sub $0x20,%rsp
1b08: 48 89 7d e8 mov %rdi,-0x18(%rbp)
1b0c: 48 89 75 e0 mov %rsi,-0x20(%rbp)
struct cmd *cmd;
cmd = parsepipe(ps, es);
1b10: 48 8b 55 e0 mov -0x20(%rbp),%rdx
1b14: 48 8b 45 e8 mov -0x18(%rbp),%rax
1b18: 48 89 d6 mov %rdx,%rsi
1b1b: 48 89 c7 mov %rax,%rdi
1b1e: 48 b8 16 1c 00 00 00 movabs $0x1c16,%rax
1b25: 00 00 00
1b28: ff d0 callq *%rax
1b2a: 48 89 45 f8 mov %rax,-0x8(%rbp)
while(peek(ps, es, "&")){
1b2e: eb 38 jmp 1b68 <parseline+0x6c>
gettoken(ps, es, 0, 0);
1b30: 48 8b 75 e0 mov -0x20(%rbp),%rsi
1b34: 48 8b 45 e8 mov -0x18(%rbp),%rax
1b38: b9 00 00 00 00 mov $0x0,%ecx
1b3d: ba 00 00 00 00 mov $0x0,%edx
1b42: 48 89 c7 mov %rax,%rdi
1b45: 48 b8 d3 17 00 00 00 movabs $0x17d3,%rax
1b4c: 00 00 00
1b4f: ff d0 callq *%rax
cmd = backcmd(cmd);
1b51: 48 8b 45 f8 mov -0x8(%rbp),%rax
1b55: 48 89 c7 mov %rax,%rdi
1b58: 48 b8 75 17 00 00 00 movabs $0x1775,%rax
1b5f: 00 00 00
1b62: ff d0 callq *%rax
1b64: 48 89 45 f8 mov %rax,-0x8(%rbp)
while(peek(ps, es, "&")){
1b68: 48 8b 4d e0 mov -0x20(%rbp),%rcx
1b6c: 48 8b 45 e8 mov -0x18(%rbp),%rax
1b70: 48 ba 39 30 00 00 00 movabs $0x3039,%rdx
1b77: 00 00 00
1b7a: 48 89 ce mov %rcx,%rsi
1b7d: 48 89 c7 mov %rax,%rdi
1b80: 48 b8 81 19 00 00 00 movabs $0x1981,%rax
1b87: 00 00 00
1b8a: ff d0 callq *%rax
1b8c: 85 c0 test %eax,%eax
1b8e: 75 a0 jne 1b30 <parseline+0x34>
}
if(peek(ps, es, ";")){
1b90: 48 8b 4d e0 mov -0x20(%rbp),%rcx
1b94: 48 8b 45 e8 mov -0x18(%rbp),%rax
1b98: 48 ba 3b 30 00 00 00 movabs $0x303b,%rdx
1b9f: 00 00 00
1ba2: 48 89 ce mov %rcx,%rsi
1ba5: 48 89 c7 mov %rax,%rdi
1ba8: 48 b8 81 19 00 00 00 movabs $0x1981,%rax
1baf: 00 00 00
1bb2: ff d0 callq *%rax
1bb4: 85 c0 test %eax,%eax
1bb6: 74 58 je 1c10 <parseline+0x114>
gettoken(ps, es, 0, 0);
1bb8: 48 8b 75 e0 mov -0x20(%rbp),%rsi
1bbc: 48 8b 45 e8 mov -0x18(%rbp),%rax
1bc0: b9 00 00 00 00 mov $0x0,%ecx
1bc5: ba 00 00 00 00 mov $0x0,%edx
1bca: 48 89 c7 mov %rax,%rdi
1bcd: 48 b8 d3 17 00 00 00 movabs $0x17d3,%rax
1bd4: 00 00 00
1bd7: ff d0 callq *%rax
cmd = listcmd(cmd, parseline(ps, es));
1bd9: 48 8b 55 e0 mov -0x20(%rbp),%rdx
1bdd: 48 8b 45 e8 mov -0x18(%rbp),%rax
1be1: 48 89 d6 mov %rdx,%rsi
1be4: 48 89 c7 mov %rax,%rdi
1be7: 48 b8 fc 1a 00 00 00 movabs $0x1afc,%rax
1bee: 00 00 00
1bf1: ff d0 callq *%rax
1bf3: 48 89 c2 mov %rax,%rdx
1bf6: 48 8b 45 f8 mov -0x8(%rbp),%rax
1bfa: 48 89 d6 mov %rdx,%rsi
1bfd: 48 89 c7 mov %rax,%rdi
1c00: 48 b8 07 17 00 00 00 movabs $0x1707,%rax
1c07: 00 00 00
1c0a: ff d0 callq *%rax
1c0c: 48 89 45 f8 mov %rax,-0x8(%rbp)
}
return cmd;
1c10: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
1c14: c9 leaveq
1c15: c3 retq
0000000000001c16 <parsepipe>:
struct cmd*
parsepipe(char **ps, char *es)
{
1c16: f3 0f 1e fa endbr64
1c1a: 55 push %rbp
1c1b: 48 89 e5 mov %rsp,%rbp
1c1e: 48 83 ec 20 sub $0x20,%rsp
1c22: 48 89 7d e8 mov %rdi,-0x18(%rbp)
1c26: 48 89 75 e0 mov %rsi,-0x20(%rbp)
struct cmd *cmd;
cmd = parseexec(ps, es);
1c2a: 48 8b 55 e0 mov -0x20(%rbp),%rdx
1c2e: 48 8b 45 e8 mov -0x18(%rbp),%rax
1c32: 48 89 d6 mov %rdx,%rsi
1c35: 48 89 c7 mov %rax,%rdi
1c38: 48 b8 36 1f 00 00 00 movabs $0x1f36,%rax
1c3f: 00 00 00
1c42: ff d0 callq *%rax
1c44: 48 89 45 f8 mov %rax,-0x8(%rbp)
if(peek(ps, es, "|")){
1c48: 48 8b 4d e0 mov -0x20(%rbp),%rcx
1c4c: 48 8b 45 e8 mov -0x18(%rbp),%rax
1c50: 48 ba 3d 30 00 00 00 movabs $0x303d,%rdx
1c57: 00 00 00
1c5a: 48 89 ce mov %rcx,%rsi
1c5d: 48 89 c7 mov %rax,%rdi
1c60: 48 b8 81 19 00 00 00 movabs $0x1981,%rax
1c67: 00 00 00
1c6a: ff d0 callq *%rax
1c6c: 85 c0 test %eax,%eax
1c6e: 74 58 je 1cc8 <parsepipe+0xb2>
gettoken(ps, es, 0, 0);
1c70: 48 8b 75 e0 mov -0x20(%rbp),%rsi
1c74: 48 8b 45 e8 mov -0x18(%rbp),%rax
1c78: b9 00 00 00 00 mov $0x0,%ecx
1c7d: ba 00 00 00 00 mov $0x0,%edx
1c82: 48 89 c7 mov %rax,%rdi
1c85: 48 b8 d3 17 00 00 00 movabs $0x17d3,%rax
1c8c: 00 00 00
1c8f: ff d0 callq *%rax
cmd = pipecmd(cmd, parsepipe(ps, es));
1c91: 48 8b 55 e0 mov -0x20(%rbp),%rdx
1c95: 48 8b 45 e8 mov -0x18(%rbp),%rax
1c99: 48 89 d6 mov %rdx,%rsi
1c9c: 48 89 c7 mov %rax,%rdi
1c9f: 48 b8 16 1c 00 00 00 movabs $0x1c16,%rax
1ca6: 00 00 00
1ca9: ff d0 callq *%rax
1cab: 48 89 c2 mov %rax,%rdx
1cae: 48 8b 45 f8 mov -0x8(%rbp),%rax
1cb2: 48 89 d6 mov %rdx,%rsi
1cb5: 48 89 c7 mov %rax,%rdi
1cb8: 48 b8 99 16 00 00 00 movabs $0x1699,%rax
1cbf: 00 00 00
1cc2: ff d0 callq *%rax
1cc4: 48 89 45 f8 mov %rax,-0x8(%rbp)
}
return cmd;
1cc8: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
1ccc: c9 leaveq
1ccd: c3 retq
0000000000001cce <parseredirs>:
struct cmd*
parseredirs(struct cmd *cmd, char **ps, char *es)
{
1cce: f3 0f 1e fa endbr64
1cd2: 55 push %rbp
1cd3: 48 89 e5 mov %rsp,%rbp
1cd6: 48 83 ec 40 sub $0x40,%rsp
1cda: 48 89 7d d8 mov %rdi,-0x28(%rbp)
1cde: 48 89 75 d0 mov %rsi,-0x30(%rbp)
1ce2: 48 89 55 c8 mov %rdx,-0x38(%rbp)
int tok;
char *q, *eq;
while(peek(ps, es, "<>")){
1ce6: e9 01 01 00 00 jmpq 1dec <parseredirs+0x11e>
tok = gettoken(ps, es, 0, 0);
1ceb: 48 8b 75 c8 mov -0x38(%rbp),%rsi
1cef: 48 8b 45 d0 mov -0x30(%rbp),%rax
1cf3: b9 00 00 00 00 mov $0x0,%ecx
1cf8: ba 00 00 00 00 mov $0x0,%edx
1cfd: 48 89 c7 mov %rax,%rdi
1d00: 48 b8 d3 17 00 00 00 movabs $0x17d3,%rax
1d07: 00 00 00
1d0a: ff d0 callq *%rax
1d0c: 89 45 fc mov %eax,-0x4(%rbp)
if(gettoken(ps, es, &q, &eq) != 'a')
1d0f: 48 8d 4d e8 lea -0x18(%rbp),%rcx
1d13: 48 8d 55 f0 lea -0x10(%rbp),%rdx
1d17: 48 8b 75 c8 mov -0x38(%rbp),%rsi
1d1b: 48 8b 45 d0 mov -0x30(%rbp),%rax
1d1f: 48 89 c7 mov %rax,%rdi
1d22: 48 b8 d3 17 00 00 00 movabs $0x17d3,%rax
1d29: 00 00 00
1d2c: ff d0 callq *%rax
1d2e: 83 f8 61 cmp $0x61,%eax
1d31: 74 16 je 1d49 <parseredirs+0x7b>
panic("missing file for redirection");
1d33: 48 bf 3f 30 00 00 00 movabs $0x303f,%rdi
1d3a: 00 00 00
1d3d: 48 b8 33 15 00 00 00 movabs $0x1533,%rax
1d44: 00 00 00
1d47: ff d0 callq *%rax
switch(tok){
1d49: 83 7d fc 3e cmpl $0x3e,-0x4(%rbp)
1d4d: 74 46 je 1d95 <parseredirs+0xc7>
1d4f: 83 7d fc 3e cmpl $0x3e,-0x4(%rbp)
1d53: 0f 8f 93 00 00 00 jg 1dec <parseredirs+0x11e>
1d59: 83 7d fc 2b cmpl $0x2b,-0x4(%rbp)
1d5d: 74 62 je 1dc1 <parseredirs+0xf3>
1d5f: 83 7d fc 3c cmpl $0x3c,-0x4(%rbp)
1d63: 0f 85 83 00 00 00 jne 1dec <parseredirs+0x11e>
case '<':
cmd = redircmd(cmd, q, eq, O_RDONLY, 0);
1d69: 48 8b 55 e8 mov -0x18(%rbp),%rdx
1d6d: 48 8b 75 f0 mov -0x10(%rbp),%rsi
1d71: 48 8b 45 d8 mov -0x28(%rbp),%rax
1d75: 41 b8 00 00 00 00 mov $0x0,%r8d
1d7b: b9 00 00 00 00 mov $0x0,%ecx
1d80: 48 89 c7 mov %rax,%rdi
1d83: 48 b8 00 16 00 00 00 movabs $0x1600,%rax
1d8a: 00 00 00
1d8d: ff d0 callq *%rax
1d8f: 48 89 45 d8 mov %rax,-0x28(%rbp)
break;
1d93: eb 57 jmp 1dec <parseredirs+0x11e>
case '>':
cmd = redircmd(cmd, q, eq, O_WRONLY|O_CREATE, 1);
1d95: 48 8b 55 e8 mov -0x18(%rbp),%rdx
1d99: 48 8b 75 f0 mov -0x10(%rbp),%rsi
1d9d: 48 8b 45 d8 mov -0x28(%rbp),%rax
1da1: 41 b8 01 00 00 00 mov $0x1,%r8d
1da7: b9 01 02 00 00 mov $0x201,%ecx
1dac: 48 89 c7 mov %rax,%rdi
1daf: 48 b8 00 16 00 00 00 movabs $0x1600,%rax
1db6: 00 00 00
1db9: ff d0 callq *%rax
1dbb: 48 89 45 d8 mov %rax,-0x28(%rbp)
break;
1dbf: eb 2b jmp 1dec <parseredirs+0x11e>
case '+': // >>
cmd = redircmd(cmd, q, eq, O_WRONLY|O_CREATE, 1);
1dc1: 48 8b 55 e8 mov -0x18(%rbp),%rdx
1dc5: 48 8b 75 f0 mov -0x10(%rbp),%rsi
1dc9: 48 8b 45 d8 mov -0x28(%rbp),%rax
1dcd: 41 b8 01 00 00 00 mov $0x1,%r8d
1dd3: b9 01 02 00 00 mov $0x201,%ecx
1dd8: 48 89 c7 mov %rax,%rdi
1ddb: 48 b8 00 16 00 00 00 movabs $0x1600,%rax
1de2: 00 00 00
1de5: ff d0 callq *%rax
1de7: 48 89 45 d8 mov %rax,-0x28(%rbp)
break;
1deb: 90 nop
while(peek(ps, es, "<>")){
1dec: 48 8b 4d c8 mov -0x38(%rbp),%rcx
1df0: 48 8b 45 d0 mov -0x30(%rbp),%rax
1df4: 48 ba 5c 30 00 00 00 movabs $0x305c,%rdx
1dfb: 00 00 00
1dfe: 48 89 ce mov %rcx,%rsi
1e01: 48 89 c7 mov %rax,%rdi
1e04: 48 b8 81 19 00 00 00 movabs $0x1981,%rax
1e0b: 00 00 00
1e0e: ff d0 callq *%rax
1e10: 85 c0 test %eax,%eax
1e12: 0f 85 d3 fe ff ff jne 1ceb <parseredirs+0x1d>
}
}
return cmd;
1e18: 48 8b 45 d8 mov -0x28(%rbp),%rax
}
1e1c: c9 leaveq
1e1d: c3 retq
0000000000001e1e <parseblock>:
struct cmd*
parseblock(char **ps, char *es)
{
1e1e: f3 0f 1e fa endbr64
1e22: 55 push %rbp
1e23: 48 89 e5 mov %rsp,%rbp
1e26: 48 83 ec 20 sub $0x20,%rsp
1e2a: 48 89 7d e8 mov %rdi,-0x18(%rbp)
1e2e: 48 89 75 e0 mov %rsi,-0x20(%rbp)
struct cmd *cmd;
if(!peek(ps, es, "("))
1e32: 48 8b 4d e0 mov -0x20(%rbp),%rcx
1e36: 48 8b 45 e8 mov -0x18(%rbp),%rax
1e3a: 48 ba 5f 30 00 00 00 movabs $0x305f,%rdx
1e41: 00 00 00
1e44: 48 89 ce mov %rcx,%rsi
1e47: 48 89 c7 mov %rax,%rdi
1e4a: 48 b8 81 19 00 00 00 movabs $0x1981,%rax
1e51: 00 00 00
1e54: ff d0 callq *%rax
1e56: 85 c0 test %eax,%eax
1e58: 75 16 jne 1e70 <parseblock+0x52>
panic("parseblock");
1e5a: 48 bf 61 30 00 00 00 movabs $0x3061,%rdi
1e61: 00 00 00
1e64: 48 b8 33 15 00 00 00 movabs $0x1533,%rax
1e6b: 00 00 00
1e6e: ff d0 callq *%rax
gettoken(ps, es, 0, 0);
1e70: 48 8b 75 e0 mov -0x20(%rbp),%rsi
1e74: 48 8b 45 e8 mov -0x18(%rbp),%rax
1e78: b9 00 00 00 00 mov $0x0,%ecx
1e7d: ba 00 00 00 00 mov $0x0,%edx
1e82: 48 89 c7 mov %rax,%rdi
1e85: 48 b8 d3 17 00 00 00 movabs $0x17d3,%rax
1e8c: 00 00 00
1e8f: ff d0 callq *%rax
cmd = parseline(ps, es);
1e91: 48 8b 55 e0 mov -0x20(%rbp),%rdx
1e95: 48 8b 45 e8 mov -0x18(%rbp),%rax
1e99: 48 89 d6 mov %rdx,%rsi
1e9c: 48 89 c7 mov %rax,%rdi
1e9f: 48 b8 fc 1a 00 00 00 movabs $0x1afc,%rax
1ea6: 00 00 00
1ea9: ff d0 callq *%rax
1eab: 48 89 45 f8 mov %rax,-0x8(%rbp)
if(!peek(ps, es, ")"))
1eaf: 48 8b 4d e0 mov -0x20(%rbp),%rcx
1eb3: 48 8b 45 e8 mov -0x18(%rbp),%rax
1eb7: 48 ba 6c 30 00 00 00 movabs $0x306c,%rdx
1ebe: 00 00 00
1ec1: 48 89 ce mov %rcx,%rsi
1ec4: 48 89 c7 mov %rax,%rdi
1ec7: 48 b8 81 19 00 00 00 movabs $0x1981,%rax
1ece: 00 00 00
1ed1: ff d0 callq *%rax
1ed3: 85 c0 test %eax,%eax
1ed5: 75 16 jne 1eed <parseblock+0xcf>
panic("syntax - missing )");
1ed7: 48 bf 6e 30 00 00 00 movabs $0x306e,%rdi
1ede: 00 00 00
1ee1: 48 b8 33 15 00 00 00 movabs $0x1533,%rax
1ee8: 00 00 00
1eeb: ff d0 callq *%rax
gettoken(ps, es, 0, 0);
1eed: 48 8b 75 e0 mov -0x20(%rbp),%rsi
1ef1: 48 8b 45 e8 mov -0x18(%rbp),%rax
1ef5: b9 00 00 00 00 mov $0x0,%ecx
1efa: ba 00 00 00 00 mov $0x0,%edx
1eff: 48 89 c7 mov %rax,%rdi
1f02: 48 b8 d3 17 00 00 00 movabs $0x17d3,%rax
1f09: 00 00 00
1f0c: ff d0 callq *%rax
cmd = parseredirs(cmd, ps, es);
1f0e: 48 8b 55 e0 mov -0x20(%rbp),%rdx
1f12: 48 8b 4d e8 mov -0x18(%rbp),%rcx
1f16: 48 8b 45 f8 mov -0x8(%rbp),%rax
1f1a: 48 89 ce mov %rcx,%rsi
1f1d: 48 89 c7 mov %rax,%rdi
1f20: 48 b8 ce 1c 00 00 00 movabs $0x1cce,%rax
1f27: 00 00 00
1f2a: ff d0 callq *%rax
1f2c: 48 89 45 f8 mov %rax,-0x8(%rbp)
return cmd;
1f30: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
1f34: c9 leaveq
1f35: c3 retq
0000000000001f36 <parseexec>:
struct cmd*
parseexec(char **ps, char *es)
{
1f36: f3 0f 1e fa endbr64
1f3a: 55 push %rbp
1f3b: 48 89 e5 mov %rsp,%rbp
1f3e: 48 83 ec 40 sub $0x40,%rsp
1f42: 48 89 7d c8 mov %rdi,-0x38(%rbp)
1f46: 48 89 75 c0 mov %rsi,-0x40(%rbp)
char *q, *eq;
int tok, argc;
struct execcmd *cmd;
struct cmd *ret;
if(peek(ps, es, "("))
1f4a: 48 8b 4d c0 mov -0x40(%rbp),%rcx
1f4e: 48 8b 45 c8 mov -0x38(%rbp),%rax
1f52: 48 ba 5f 30 00 00 00 movabs $0x305f,%rdx
1f59: 00 00 00
1f5c: 48 89 ce mov %rcx,%rsi
1f5f: 48 89 c7 mov %rax,%rdi
1f62: 48 b8 81 19 00 00 00 movabs $0x1981,%rax
1f69: 00 00 00
1f6c: ff d0 callq *%rax
1f6e: 85 c0 test %eax,%eax
1f70: 74 1f je 1f91 <parseexec+0x5b>
return parseblock(ps, es);
1f72: 48 8b 55 c0 mov -0x40(%rbp),%rdx
1f76: 48 8b 45 c8 mov -0x38(%rbp),%rax
1f7a: 48 89 d6 mov %rdx,%rsi
1f7d: 48 89 c7 mov %rax,%rdi
1f80: 48 b8 1e 1e 00 00 00 movabs $0x1e1e,%rax
1f87: 00 00 00
1f8a: ff d0 callq *%rax
1f8c: e9 57 01 00 00 jmpq 20e8 <parseexec+0x1b2>
ret = execcmd();
1f91: 48 b8 b2 15 00 00 00 movabs $0x15b2,%rax
1f98: 00 00 00
1f9b: ff d0 callq *%rax
1f9d: 48 89 45 f0 mov %rax,-0x10(%rbp)
cmd = (struct execcmd*)ret;
1fa1: 48 8b 45 f0 mov -0x10(%rbp),%rax
1fa5: 48 89 45 e8 mov %rax,-0x18(%rbp)
argc = 0;
1fa9: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
ret = parseredirs(ret, ps, es);
1fb0: 48 8b 55 c0 mov -0x40(%rbp),%rdx
1fb4: 48 8b 4d c8 mov -0x38(%rbp),%rcx
1fb8: 48 8b 45 f0 mov -0x10(%rbp),%rax
1fbc: 48 89 ce mov %rcx,%rsi
1fbf: 48 89 c7 mov %rax,%rdi
1fc2: 48 b8 ce 1c 00 00 00 movabs $0x1cce,%rax
1fc9: 00 00 00
1fcc: ff d0 callq *%rax
1fce: 48 89 45 f0 mov %rax,-0x10(%rbp)
while(!peek(ps, es, "|)&;")){
1fd2: e9 b4 00 00 00 jmpq 208b <parseexec+0x155>
if((tok=gettoken(ps, es, &q, &eq)) == 0)
1fd7: 48 8d 4d d0 lea -0x30(%rbp),%rcx
1fdb: 48 8d 55 d8 lea -0x28(%rbp),%rdx
1fdf: 48 8b 75 c0 mov -0x40(%rbp),%rsi
1fe3: 48 8b 45 c8 mov -0x38(%rbp),%rax
1fe7: 48 89 c7 mov %rax,%rdi
1fea: 48 b8 d3 17 00 00 00 movabs $0x17d3,%rax
1ff1: 00 00 00
1ff4: ff d0 callq *%rax
1ff6: 89 45 e4 mov %eax,-0x1c(%rbp)
1ff9: 83 7d e4 00 cmpl $0x0,-0x1c(%rbp)
1ffd: 0f 84 b6 00 00 00 je 20b9 <parseexec+0x183>
break;
if(tok != 'a')
2003: 83 7d e4 61 cmpl $0x61,-0x1c(%rbp)
2007: 74 16 je 201f <parseexec+0xe9>
panic("syntax");
2009: 48 bf 32 30 00 00 00 movabs $0x3032,%rdi
2010: 00 00 00
2013: 48 b8 33 15 00 00 00 movabs $0x1533,%rax
201a: 00 00 00
201d: ff d0 callq *%rax
cmd->argv[argc] = q;
201f: 48 8b 4d d8 mov -0x28(%rbp),%rcx
2023: 48 8b 45 e8 mov -0x18(%rbp),%rax
2027: 8b 55 fc mov -0x4(%rbp),%edx
202a: 48 63 d2 movslq %edx,%rdx
202d: 48 89 4c d0 08 mov %rcx,0x8(%rax,%rdx,8)
cmd->eargv[argc] = eq;
2032: 48 8b 55 d0 mov -0x30(%rbp),%rdx
2036: 48 8b 45 e8 mov -0x18(%rbp),%rax
203a: 8b 4d fc mov -0x4(%rbp),%ecx
203d: 48 63 c9 movslq %ecx,%rcx
2040: 48 83 c1 0a add $0xa,%rcx
2044: 48 89 54 c8 08 mov %rdx,0x8(%rax,%rcx,8)
argc++;
2049: 83 45 fc 01 addl $0x1,-0x4(%rbp)
if(argc >= MAXARGS)
204d: 83 7d fc 09 cmpl $0x9,-0x4(%rbp)
2051: 7e 16 jle 2069 <parseexec+0x133>
panic("too many args");
2053: 48 bf 81 30 00 00 00 movabs $0x3081,%rdi
205a: 00 00 00
205d: 48 b8 33 15 00 00 00 movabs $0x1533,%rax
2064: 00 00 00
2067: ff d0 callq *%rax
ret = parseredirs(ret, ps, es);
2069: 48 8b 55 c0 mov -0x40(%rbp),%rdx
206d: 48 8b 4d c8 mov -0x38(%rbp),%rcx
2071: 48 8b 45 f0 mov -0x10(%rbp),%rax
2075: 48 89 ce mov %rcx,%rsi
2078: 48 89 c7 mov %rax,%rdi
207b: 48 b8 ce 1c 00 00 00 movabs $0x1cce,%rax
2082: 00 00 00
2085: ff d0 callq *%rax
2087: 48 89 45 f0 mov %rax,-0x10(%rbp)
while(!peek(ps, es, "|)&;")){
208b: 48 8b 4d c0 mov -0x40(%rbp),%rcx
208f: 48 8b 45 c8 mov -0x38(%rbp),%rax
2093: 48 ba 8f 30 00 00 00 movabs $0x308f,%rdx
209a: 00 00 00
209d: 48 89 ce mov %rcx,%rsi
20a0: 48 89 c7 mov %rax,%rdi
20a3: 48 b8 81 19 00 00 00 movabs $0x1981,%rax
20aa: 00 00 00
20ad: ff d0 callq *%rax
20af: 85 c0 test %eax,%eax
20b1: 0f 84 20 ff ff ff je 1fd7 <parseexec+0xa1>
20b7: eb 01 jmp 20ba <parseexec+0x184>
break;
20b9: 90 nop
}
cmd->argv[argc] = 0;
20ba: 48 8b 45 e8 mov -0x18(%rbp),%rax
20be: 8b 55 fc mov -0x4(%rbp),%edx
20c1: 48 63 d2 movslq %edx,%rdx
20c4: 48 c7 44 d0 08 00 00 movq $0x0,0x8(%rax,%rdx,8)
20cb: 00 00
cmd->eargv[argc] = 0;
20cd: 48 8b 45 e8 mov -0x18(%rbp),%rax
20d1: 8b 55 fc mov -0x4(%rbp),%edx
20d4: 48 63 d2 movslq %edx,%rdx
20d7: 48 83 c2 0a add $0xa,%rdx
20db: 48 c7 44 d0 08 00 00 movq $0x0,0x8(%rax,%rdx,8)
20e2: 00 00
return ret;
20e4: 48 8b 45 f0 mov -0x10(%rbp),%rax
}
20e8: c9 leaveq
20e9: c3 retq
00000000000020ea <nulterminate>:
// NUL-terminate all the counted strings.
struct cmd*
nulterminate(struct cmd *cmd)
{
20ea: f3 0f 1e fa endbr64
20ee: 55 push %rbp
20ef: 48 89 e5 mov %rsp,%rbp
20f2: 48 83 ec 40 sub $0x40,%rsp
20f6: 48 89 7d c8 mov %rdi,-0x38(%rbp)
struct execcmd *ecmd;
struct listcmd *lcmd;
struct pipecmd *pcmd;
struct redircmd *rcmd;
if(cmd == 0)
20fa: 48 83 7d c8 00 cmpq $0x0,-0x38(%rbp)
20ff: 75 0a jne 210b <nulterminate+0x21>
return 0;
2101: b8 00 00 00 00 mov $0x0,%eax
2106: e9 33 01 00 00 jmpq 223e <nulterminate+0x154>
switch(cmd->type){
210b: 48 8b 45 c8 mov -0x38(%rbp),%rax
210f: 8b 00 mov (%rax),%eax
2111: 83 f8 05 cmp $0x5,%eax
2114: 0f 87 20 01 00 00 ja 223a <nulterminate+0x150>
211a: 89 c0 mov %eax,%eax
211c: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
2123: 00
2124: 48 b8 98 30 00 00 00 movabs $0x3098,%rax
212b: 00 00 00
212e: 48 01 d0 add %rdx,%rax
2131: 48 8b 00 mov (%rax),%rax
2134: 3e ff e0 notrack jmpq *%rax
case EXEC:
ecmd = (struct execcmd*)cmd;
2137: 48 8b 45 c8 mov -0x38(%rbp),%rax
213b: 48 89 45 d0 mov %rax,-0x30(%rbp)
for(i=0; ecmd->argv[i]; i++)
213f: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
2146: eb 1a jmp 2162 <nulterminate+0x78>
*ecmd->eargv[i] = 0;
2148: 48 8b 45 d0 mov -0x30(%rbp),%rax
214c: 8b 55 fc mov -0x4(%rbp),%edx
214f: 48 63 d2 movslq %edx,%rdx
2152: 48 83 c2 0a add $0xa,%rdx
2156: 48 8b 44 d0 08 mov 0x8(%rax,%rdx,8),%rax
215b: c6 00 00 movb $0x0,(%rax)
for(i=0; ecmd->argv[i]; i++)
215e: 83 45 fc 01 addl $0x1,-0x4(%rbp)
2162: 48 8b 45 d0 mov -0x30(%rbp),%rax
2166: 8b 55 fc mov -0x4(%rbp),%edx
2169: 48 63 d2 movslq %edx,%rdx
216c: 48 8b 44 d0 08 mov 0x8(%rax,%rdx,8),%rax
2171: 48 85 c0 test %rax,%rax
2174: 75 d2 jne 2148 <nulterminate+0x5e>
break;
2176: e9 bf 00 00 00 jmpq 223a <nulterminate+0x150>
case REDIR:
rcmd = (struct redircmd*)cmd;
217b: 48 8b 45 c8 mov -0x38(%rbp),%rax
217f: 48 89 45 d8 mov %rax,-0x28(%rbp)
nulterminate(rcmd->cmd);
2183: 48 8b 45 d8 mov -0x28(%rbp),%rax
2187: 48 8b 40 08 mov 0x8(%rax),%rax
218b: 48 89 c7 mov %rax,%rdi
218e: 48 b8 ea 20 00 00 00 movabs $0x20ea,%rax
2195: 00 00 00
2198: ff d0 callq *%rax
*rcmd->efile = 0;
219a: 48 8b 45 d8 mov -0x28(%rbp),%rax
219e: 48 8b 40 18 mov 0x18(%rax),%rax
21a2: c6 00 00 movb $0x0,(%rax)
break;
21a5: e9 90 00 00 00 jmpq 223a <nulterminate+0x150>
case PIPE:
pcmd = (struct pipecmd*)cmd;
21aa: 48 8b 45 c8 mov -0x38(%rbp),%rax
21ae: 48 89 45 e0 mov %rax,-0x20(%rbp)
nulterminate(pcmd->left);
21b2: 48 8b 45 e0 mov -0x20(%rbp),%rax
21b6: 48 8b 40 08 mov 0x8(%rax),%rax
21ba: 48 89 c7 mov %rax,%rdi
21bd: 48 b8 ea 20 00 00 00 movabs $0x20ea,%rax
21c4: 00 00 00
21c7: ff d0 callq *%rax
nulterminate(pcmd->right);
21c9: 48 8b 45 e0 mov -0x20(%rbp),%rax
21cd: 48 8b 40 10 mov 0x10(%rax),%rax
21d1: 48 89 c7 mov %rax,%rdi
21d4: 48 b8 ea 20 00 00 00 movabs $0x20ea,%rax
21db: 00 00 00
21de: ff d0 callq *%rax
break;
21e0: eb 58 jmp 223a <nulterminate+0x150>
case LIST:
lcmd = (struct listcmd*)cmd;
21e2: 48 8b 45 c8 mov -0x38(%rbp),%rax
21e6: 48 89 45 e8 mov %rax,-0x18(%rbp)
nulterminate(lcmd->left);
21ea: 48 8b 45 e8 mov -0x18(%rbp),%rax
21ee: 48 8b 40 08 mov 0x8(%rax),%rax
21f2: 48 89 c7 mov %rax,%rdi
21f5: 48 b8 ea 20 00 00 00 movabs $0x20ea,%rax
21fc: 00 00 00
21ff: ff d0 callq *%rax
nulterminate(lcmd->right);
2201: 48 8b 45 e8 mov -0x18(%rbp),%rax
2205: 48 8b 40 10 mov 0x10(%rax),%rax
2209: 48 89 c7 mov %rax,%rdi
220c: 48 b8 ea 20 00 00 00 movabs $0x20ea,%rax
2213: 00 00 00
2216: ff d0 callq *%rax
break;
2218: eb 20 jmp 223a <nulterminate+0x150>
case BACK:
bcmd = (struct backcmd*)cmd;
221a: 48 8b 45 c8 mov -0x38(%rbp),%rax
221e: 48 89 45 f0 mov %rax,-0x10(%rbp)
nulterminate(bcmd->cmd);
2222: 48 8b 45 f0 mov -0x10(%rbp),%rax
2226: 48 8b 40 08 mov 0x8(%rax),%rax
222a: 48 89 c7 mov %rax,%rdi
222d: 48 b8 ea 20 00 00 00 movabs $0x20ea,%rax
2234: 00 00 00
2237: ff d0 callq *%rax
break;
2239: 90 nop
}
return cmd;
223a: 48 8b 45 c8 mov -0x38(%rbp),%rax
}
223e: c9 leaveq
223f: c3 retq
0000000000002240 <stosb>:
"cc");
}
static inline void
stosb(void *addr, int data, int cnt)
{
2240: f3 0f 1e fa endbr64
2244: 55 push %rbp
2245: 48 89 e5 mov %rsp,%rbp
2248: 48 83 ec 10 sub $0x10,%rsp
224c: 48 89 7d f8 mov %rdi,-0x8(%rbp)
2250: 89 75 f4 mov %esi,-0xc(%rbp)
2253: 89 55 f0 mov %edx,-0x10(%rbp)
asm volatile("cld; rep stosb" :
2256: 48 8b 4d f8 mov -0x8(%rbp),%rcx
225a: 8b 55 f0 mov -0x10(%rbp),%edx
225d: 8b 45 f4 mov -0xc(%rbp),%eax
2260: 48 89 ce mov %rcx,%rsi
2263: 48 89 f7 mov %rsi,%rdi
2266: 89 d1 mov %edx,%ecx
2268: fc cld
2269: f3 aa rep stos %al,%es:(%rdi)
226b: 89 ca mov %ecx,%edx
226d: 48 89 fe mov %rdi,%rsi
2270: 48 89 75 f8 mov %rsi,-0x8(%rbp)
2274: 89 55 f0 mov %edx,-0x10(%rbp)
"=D" (addr), "=c" (cnt) :
"0" (addr), "1" (cnt), "a" (data) :
"memory", "cc");
}
2277: 90 nop
2278: c9 leaveq
2279: c3 retq
000000000000227a <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, char *t)
{
227a: f3 0f 1e fa endbr64
227e: 55 push %rbp
227f: 48 89 e5 mov %rsp,%rbp
2282: 48 83 ec 20 sub $0x20,%rsp
2286: 48 89 7d e8 mov %rdi,-0x18(%rbp)
228a: 48 89 75 e0 mov %rsi,-0x20(%rbp)
char *os;
os = s;
228e: 48 8b 45 e8 mov -0x18(%rbp),%rax
2292: 48 89 45 f8 mov %rax,-0x8(%rbp)
while((*s++ = *t++) != 0)
2296: 90 nop
2297: 48 8b 55 e0 mov -0x20(%rbp),%rdx
229b: 48 8d 42 01 lea 0x1(%rdx),%rax
229f: 48 89 45 e0 mov %rax,-0x20(%rbp)
22a3: 48 8b 45 e8 mov -0x18(%rbp),%rax
22a7: 48 8d 48 01 lea 0x1(%rax),%rcx
22ab: 48 89 4d e8 mov %rcx,-0x18(%rbp)
22af: 0f b6 12 movzbl (%rdx),%edx
22b2: 88 10 mov %dl,(%rax)
22b4: 0f b6 00 movzbl (%rax),%eax
22b7: 84 c0 test %al,%al
22b9: 75 dc jne 2297 <strcpy+0x1d>
;
return os;
22bb: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
22bf: c9 leaveq
22c0: c3 retq
00000000000022c1 <strcmp>:
int
strcmp(const char *p, const char *q)
{
22c1: f3 0f 1e fa endbr64
22c5: 55 push %rbp
22c6: 48 89 e5 mov %rsp,%rbp
22c9: 48 83 ec 10 sub $0x10,%rsp
22cd: 48 89 7d f8 mov %rdi,-0x8(%rbp)
22d1: 48 89 75 f0 mov %rsi,-0x10(%rbp)
while(*p && *p == *q)
22d5: eb 0a jmp 22e1 <strcmp+0x20>
p++, q++;
22d7: 48 83 45 f8 01 addq $0x1,-0x8(%rbp)
22dc: 48 83 45 f0 01 addq $0x1,-0x10(%rbp)
while(*p && *p == *q)
22e1: 48 8b 45 f8 mov -0x8(%rbp),%rax
22e5: 0f b6 00 movzbl (%rax),%eax
22e8: 84 c0 test %al,%al
22ea: 74 12 je 22fe <strcmp+0x3d>
22ec: 48 8b 45 f8 mov -0x8(%rbp),%rax
22f0: 0f b6 10 movzbl (%rax),%edx
22f3: 48 8b 45 f0 mov -0x10(%rbp),%rax
22f7: 0f b6 00 movzbl (%rax),%eax
22fa: 38 c2 cmp %al,%dl
22fc: 74 d9 je 22d7 <strcmp+0x16>
return (uchar)*p - (uchar)*q;
22fe: 48 8b 45 f8 mov -0x8(%rbp),%rax
2302: 0f b6 00 movzbl (%rax),%eax
2305: 0f b6 d0 movzbl %al,%edx
2308: 48 8b 45 f0 mov -0x10(%rbp),%rax
230c: 0f b6 00 movzbl (%rax),%eax
230f: 0f b6 c0 movzbl %al,%eax
2312: 29 c2 sub %eax,%edx
2314: 89 d0 mov %edx,%eax
}
2316: c9 leaveq
2317: c3 retq
0000000000002318 <strlen>:
uint
strlen(char *s)
{
2318: f3 0f 1e fa endbr64
231c: 55 push %rbp
231d: 48 89 e5 mov %rsp,%rbp
2320: 48 83 ec 18 sub $0x18,%rsp
2324: 48 89 7d e8 mov %rdi,-0x18(%rbp)
int n;
for(n = 0; s[n]; n++)
2328: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
232f: eb 04 jmp 2335 <strlen+0x1d>
2331: 83 45 fc 01 addl $0x1,-0x4(%rbp)
2335: 8b 45 fc mov -0x4(%rbp),%eax
2338: 48 63 d0 movslq %eax,%rdx
233b: 48 8b 45 e8 mov -0x18(%rbp),%rax
233f: 48 01 d0 add %rdx,%rax
2342: 0f b6 00 movzbl (%rax),%eax
2345: 84 c0 test %al,%al
2347: 75 e8 jne 2331 <strlen+0x19>
;
return n;
2349: 8b 45 fc mov -0x4(%rbp),%eax
}
234c: c9 leaveq
234d: c3 retq
000000000000234e <memset>:
void*
memset(void *dst, int c, uint n)
{
234e: f3 0f 1e fa endbr64
2352: 55 push %rbp
2353: 48 89 e5 mov %rsp,%rbp
2356: 48 83 ec 10 sub $0x10,%rsp
235a: 48 89 7d f8 mov %rdi,-0x8(%rbp)
235e: 89 75 f4 mov %esi,-0xc(%rbp)
2361: 89 55 f0 mov %edx,-0x10(%rbp)
stosb(dst, c, n);
2364: 8b 55 f0 mov -0x10(%rbp),%edx
2367: 8b 4d f4 mov -0xc(%rbp),%ecx
236a: 48 8b 45 f8 mov -0x8(%rbp),%rax
236e: 89 ce mov %ecx,%esi
2370: 48 89 c7 mov %rax,%rdi
2373: 48 b8 40 22 00 00 00 movabs $0x2240,%rax
237a: 00 00 00
237d: ff d0 callq *%rax
return dst;
237f: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
2383: c9 leaveq
2384: c3 retq
0000000000002385 <strchr>:
char*
strchr(const char *s, char c)
{
2385: f3 0f 1e fa endbr64
2389: 55 push %rbp
238a: 48 89 e5 mov %rsp,%rbp
238d: 48 83 ec 10 sub $0x10,%rsp
2391: 48 89 7d f8 mov %rdi,-0x8(%rbp)
2395: 89 f0 mov %esi,%eax
2397: 88 45 f4 mov %al,-0xc(%rbp)
for(; *s; s++)
239a: eb 17 jmp 23b3 <strchr+0x2e>
if(*s == c)
239c: 48 8b 45 f8 mov -0x8(%rbp),%rax
23a0: 0f b6 00 movzbl (%rax),%eax
23a3: 38 45 f4 cmp %al,-0xc(%rbp)
23a6: 75 06 jne 23ae <strchr+0x29>
return (char*)s;
23a8: 48 8b 45 f8 mov -0x8(%rbp),%rax
23ac: eb 15 jmp 23c3 <strchr+0x3e>
for(; *s; s++)
23ae: 48 83 45 f8 01 addq $0x1,-0x8(%rbp)
23b3: 48 8b 45 f8 mov -0x8(%rbp),%rax
23b7: 0f b6 00 movzbl (%rax),%eax
23ba: 84 c0 test %al,%al
23bc: 75 de jne 239c <strchr+0x17>
return 0;
23be: b8 00 00 00 00 mov $0x0,%eax
}
23c3: c9 leaveq
23c4: c3 retq
00000000000023c5 <gets>:
char*
gets(char *buf, int max)
{
23c5: f3 0f 1e fa endbr64
23c9: 55 push %rbp
23ca: 48 89 e5 mov %rsp,%rbp
23cd: 48 83 ec 20 sub $0x20,%rsp
23d1: 48 89 7d e8 mov %rdi,-0x18(%rbp)
23d5: 89 75 e4 mov %esi,-0x1c(%rbp)
int i, cc;
char c;
for(i=0; i+1 < max; ){
23d8: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
23df: eb 4f jmp 2430 <gets+0x6b>
cc = read(0, &c, 1);
23e1: 48 8d 45 f7 lea -0x9(%rbp),%rax
23e5: ba 01 00 00 00 mov $0x1,%edx
23ea: 48 89 c6 mov %rax,%rsi
23ed: bf 00 00 00 00 mov $0x0,%edi
23f2: 48 b8 aa 25 00 00 00 movabs $0x25aa,%rax
23f9: 00 00 00
23fc: ff d0 callq *%rax
23fe: 89 45 f8 mov %eax,-0x8(%rbp)
if(cc < 1)
2401: 83 7d f8 00 cmpl $0x0,-0x8(%rbp)
2405: 7e 36 jle 243d <gets+0x78>
break;
buf[i++] = c;
2407: 8b 45 fc mov -0x4(%rbp),%eax
240a: 8d 50 01 lea 0x1(%rax),%edx
240d: 89 55 fc mov %edx,-0x4(%rbp)
2410: 48 63 d0 movslq %eax,%rdx
2413: 48 8b 45 e8 mov -0x18(%rbp),%rax
2417: 48 01 c2 add %rax,%rdx
241a: 0f b6 45 f7 movzbl -0x9(%rbp),%eax
241e: 88 02 mov %al,(%rdx)
if(c == '\n' || c == '\r')
2420: 0f b6 45 f7 movzbl -0x9(%rbp),%eax
2424: 3c 0a cmp $0xa,%al
2426: 74 16 je 243e <gets+0x79>
2428: 0f b6 45 f7 movzbl -0x9(%rbp),%eax
242c: 3c 0d cmp $0xd,%al
242e: 74 0e je 243e <gets+0x79>
for(i=0; i+1 < max; ){
2430: 8b 45 fc mov -0x4(%rbp),%eax
2433: 83 c0 01 add $0x1,%eax
2436: 39 45 e4 cmp %eax,-0x1c(%rbp)
2439: 7f a6 jg 23e1 <gets+0x1c>
243b: eb 01 jmp 243e <gets+0x79>
break;
243d: 90 nop
break;
}
buf[i] = '\0';
243e: 8b 45 fc mov -0x4(%rbp),%eax
2441: 48 63 d0 movslq %eax,%rdx
2444: 48 8b 45 e8 mov -0x18(%rbp),%rax
2448: 48 01 d0 add %rdx,%rax
244b: c6 00 00 movb $0x0,(%rax)
return buf;
244e: 48 8b 45 e8 mov -0x18(%rbp),%rax
}
2452: c9 leaveq
2453: c3 retq
0000000000002454 <stat>:
int
stat(char *n, struct stat *st)
{
2454: f3 0f 1e fa endbr64
2458: 55 push %rbp
2459: 48 89 e5 mov %rsp,%rbp
245c: 48 83 ec 20 sub $0x20,%rsp
2460: 48 89 7d e8 mov %rdi,-0x18(%rbp)
2464: 48 89 75 e0 mov %rsi,-0x20(%rbp)
int fd;
int r;
fd = open(n, O_RDONLY);
2468: 48 8b 45 e8 mov -0x18(%rbp),%rax
246c: be 00 00 00 00 mov $0x0,%esi
2471: 48 89 c7 mov %rax,%rdi
2474: 48 b8 eb 25 00 00 00 movabs $0x25eb,%rax
247b: 00 00 00
247e: ff d0 callq *%rax
2480: 89 45 fc mov %eax,-0x4(%rbp)
if(fd < 0)
2483: 83 7d fc 00 cmpl $0x0,-0x4(%rbp)
2487: 79 07 jns 2490 <stat+0x3c>
return -1;
2489: b8 ff ff ff ff mov $0xffffffff,%eax
248e: eb 2f jmp 24bf <stat+0x6b>
r = fstat(fd, st);
2490: 48 8b 55 e0 mov -0x20(%rbp),%rdx
2494: 8b 45 fc mov -0x4(%rbp),%eax
2497: 48 89 d6 mov %rdx,%rsi
249a: 89 c7 mov %eax,%edi
249c: 48 b8 12 26 00 00 00 movabs $0x2612,%rax
24a3: 00 00 00
24a6: ff d0 callq *%rax
24a8: 89 45 f8 mov %eax,-0x8(%rbp)
close(fd);
24ab: 8b 45 fc mov -0x4(%rbp),%eax
24ae: 89 c7 mov %eax,%edi
24b0: 48 b8 c4 25 00 00 00 movabs $0x25c4,%rax
24b7: 00 00 00
24ba: ff d0 callq *%rax
return r;
24bc: 8b 45 f8 mov -0x8(%rbp),%eax
}
24bf: c9 leaveq
24c0: c3 retq
00000000000024c1 <atoi>:
int
atoi(const char *s)
{
24c1: f3 0f 1e fa endbr64
24c5: 55 push %rbp
24c6: 48 89 e5 mov %rsp,%rbp
24c9: 48 83 ec 18 sub $0x18,%rsp
24cd: 48 89 7d e8 mov %rdi,-0x18(%rbp)
int n;
n = 0;
24d1: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
while('0' <= *s && *s <= '9')
24d8: eb 28 jmp 2502 <atoi+0x41>
n = n*10 + *s++ - '0';
24da: 8b 55 fc mov -0x4(%rbp),%edx
24dd: 89 d0 mov %edx,%eax
24df: c1 e0 02 shl $0x2,%eax
24e2: 01 d0 add %edx,%eax
24e4: 01 c0 add %eax,%eax
24e6: 89 c1 mov %eax,%ecx
24e8: 48 8b 45 e8 mov -0x18(%rbp),%rax
24ec: 48 8d 50 01 lea 0x1(%rax),%rdx
24f0: 48 89 55 e8 mov %rdx,-0x18(%rbp)
24f4: 0f b6 00 movzbl (%rax),%eax
24f7: 0f be c0 movsbl %al,%eax
24fa: 01 c8 add %ecx,%eax
24fc: 83 e8 30 sub $0x30,%eax
24ff: 89 45 fc mov %eax,-0x4(%rbp)
while('0' <= *s && *s <= '9')
2502: 48 8b 45 e8 mov -0x18(%rbp),%rax
2506: 0f b6 00 movzbl (%rax),%eax
2509: 3c 2f cmp $0x2f,%al
250b: 7e 0b jle 2518 <atoi+0x57>
250d: 48 8b 45 e8 mov -0x18(%rbp),%rax
2511: 0f b6 00 movzbl (%rax),%eax
2514: 3c 39 cmp $0x39,%al
2516: 7e c2 jle 24da <atoi+0x19>
return n;
2518: 8b 45 fc mov -0x4(%rbp),%eax
}
251b: c9 leaveq
251c: c3 retq
000000000000251d <memmove>:
void*
memmove(void *vdst, void *vsrc, int n)
{
251d: f3 0f 1e fa endbr64
2521: 55 push %rbp
2522: 48 89 e5 mov %rsp,%rbp
2525: 48 83 ec 28 sub $0x28,%rsp
2529: 48 89 7d e8 mov %rdi,-0x18(%rbp)
252d: 48 89 75 e0 mov %rsi,-0x20(%rbp)
2531: 89 55 dc mov %edx,-0x24(%rbp)
char *dst, *src;
dst = vdst;
2534: 48 8b 45 e8 mov -0x18(%rbp),%rax
2538: 48 89 45 f8 mov %rax,-0x8(%rbp)
src = vsrc;
253c: 48 8b 45 e0 mov -0x20(%rbp),%rax
2540: 48 89 45 f0 mov %rax,-0x10(%rbp)
while(n-- > 0)
2544: eb 1d jmp 2563 <memmove+0x46>
*dst++ = *src++;
2546: 48 8b 55 f0 mov -0x10(%rbp),%rdx
254a: 48 8d 42 01 lea 0x1(%rdx),%rax
254e: 48 89 45 f0 mov %rax,-0x10(%rbp)
2552: 48 8b 45 f8 mov -0x8(%rbp),%rax
2556: 48 8d 48 01 lea 0x1(%rax),%rcx
255a: 48 89 4d f8 mov %rcx,-0x8(%rbp)
255e: 0f b6 12 movzbl (%rdx),%edx
2561: 88 10 mov %dl,(%rax)
while(n-- > 0)
2563: 8b 45 dc mov -0x24(%rbp),%eax
2566: 8d 50 ff lea -0x1(%rax),%edx
2569: 89 55 dc mov %edx,-0x24(%rbp)
256c: 85 c0 test %eax,%eax
256e: 7f d6 jg 2546 <memmove+0x29>
return vdst;
2570: 48 8b 45 e8 mov -0x18(%rbp),%rax
}
2574: c9 leaveq
2575: c3 retq
0000000000002576 <fork>:
mov $SYS_ ## name, %rax; \
mov %rcx, %r10 ;\
syscall ;\
ret
SYSCALL(fork)
2576: 48 c7 c0 01 00 00 00 mov $0x1,%rax
257d: 49 89 ca mov %rcx,%r10
2580: 0f 05 syscall
2582: c3 retq
0000000000002583 <exit>:
SYSCALL(exit)
2583: 48 c7 c0 02 00 00 00 mov $0x2,%rax
258a: 49 89 ca mov %rcx,%r10
258d: 0f 05 syscall
258f: c3 retq
0000000000002590 <wait>:
SYSCALL(wait)
2590: 48 c7 c0 03 00 00 00 mov $0x3,%rax
2597: 49 89 ca mov %rcx,%r10
259a: 0f 05 syscall
259c: c3 retq
000000000000259d <pipe>:
SYSCALL(pipe)
259d: 48 c7 c0 04 00 00 00 mov $0x4,%rax
25a4: 49 89 ca mov %rcx,%r10
25a7: 0f 05 syscall
25a9: c3 retq
00000000000025aa <read>:
SYSCALL(read)
25aa: 48 c7 c0 05 00 00 00 mov $0x5,%rax
25b1: 49 89 ca mov %rcx,%r10
25b4: 0f 05 syscall
25b6: c3 retq
00000000000025b7 <write>:
SYSCALL(write)
25b7: 48 c7 c0 10 00 00 00 mov $0x10,%rax
25be: 49 89 ca mov %rcx,%r10
25c1: 0f 05 syscall
25c3: c3 retq
00000000000025c4 <close>:
SYSCALL(close)
25c4: 48 c7 c0 15 00 00 00 mov $0x15,%rax
25cb: 49 89 ca mov %rcx,%r10
25ce: 0f 05 syscall
25d0: c3 retq
00000000000025d1 <kill>:
SYSCALL(kill)
25d1: 48 c7 c0 06 00 00 00 mov $0x6,%rax
25d8: 49 89 ca mov %rcx,%r10
25db: 0f 05 syscall
25dd: c3 retq
00000000000025de <exec>:
SYSCALL(exec)
25de: 48 c7 c0 07 00 00 00 mov $0x7,%rax
25e5: 49 89 ca mov %rcx,%r10
25e8: 0f 05 syscall
25ea: c3 retq
00000000000025eb <open>:
SYSCALL(open)
25eb: 48 c7 c0 0f 00 00 00 mov $0xf,%rax
25f2: 49 89 ca mov %rcx,%r10
25f5: 0f 05 syscall
25f7: c3 retq
00000000000025f8 <mknod>:
SYSCALL(mknod)
25f8: 48 c7 c0 11 00 00 00 mov $0x11,%rax
25ff: 49 89 ca mov %rcx,%r10
2602: 0f 05 syscall
2604: c3 retq
0000000000002605 <unlink>:
SYSCALL(unlink)
2605: 48 c7 c0 12 00 00 00 mov $0x12,%rax
260c: 49 89 ca mov %rcx,%r10
260f: 0f 05 syscall
2611: c3 retq
0000000000002612 <fstat>:
SYSCALL(fstat)
2612: 48 c7 c0 08 00 00 00 mov $0x8,%rax
2619: 49 89 ca mov %rcx,%r10
261c: 0f 05 syscall
261e: c3 retq
000000000000261f <link>:
SYSCALL(link)
261f: 48 c7 c0 13 00 00 00 mov $0x13,%rax
2626: 49 89 ca mov %rcx,%r10
2629: 0f 05 syscall
262b: c3 retq
000000000000262c <mkdir>:
SYSCALL(mkdir)
262c: 48 c7 c0 14 00 00 00 mov $0x14,%rax
2633: 49 89 ca mov %rcx,%r10
2636: 0f 05 syscall
2638: c3 retq
0000000000002639 <chdir>:
SYSCALL(chdir)
2639: 48 c7 c0 09 00 00 00 mov $0x9,%rax
2640: 49 89 ca mov %rcx,%r10
2643: 0f 05 syscall
2645: c3 retq
0000000000002646 <dup>:
SYSCALL(dup)
2646: 48 c7 c0 0a 00 00 00 mov $0xa,%rax
264d: 49 89 ca mov %rcx,%r10
2650: 0f 05 syscall
2652: c3 retq
0000000000002653 <getpid>:
SYSCALL(getpid)
2653: 48 c7 c0 0b 00 00 00 mov $0xb,%rax
265a: 49 89 ca mov %rcx,%r10
265d: 0f 05 syscall
265f: c3 retq
0000000000002660 <sbrk>:
SYSCALL(sbrk)
2660: 48 c7 c0 0c 00 00 00 mov $0xc,%rax
2667: 49 89 ca mov %rcx,%r10
266a: 0f 05 syscall
266c: c3 retq
000000000000266d <sleep>:
SYSCALL(sleep)
266d: 48 c7 c0 0d 00 00 00 mov $0xd,%rax
2674: 49 89 ca mov %rcx,%r10
2677: 0f 05 syscall
2679: c3 retq
000000000000267a <uptime>:
SYSCALL(uptime)
267a: 48 c7 c0 0e 00 00 00 mov $0xe,%rax
2681: 49 89 ca mov %rcx,%r10
2684: 0f 05 syscall
2686: c3 retq
0000000000002687 <dedup>:
SYSCALL(dedup)
2687: 48 c7 c0 16 00 00 00 mov $0x16,%rax
268e: 49 89 ca mov %rcx,%r10
2691: 0f 05 syscall
2693: c3 retq
0000000000002694 <freepages>:
SYSCALL(freepages)
2694: 48 c7 c0 17 00 00 00 mov $0x17,%rax
269b: 49 89 ca mov %rcx,%r10
269e: 0f 05 syscall
26a0: c3 retq
00000000000026a1 <putc>:
#include <stdarg.h>
static void
putc(int fd, char c)
{
26a1: f3 0f 1e fa endbr64
26a5: 55 push %rbp
26a6: 48 89 e5 mov %rsp,%rbp
26a9: 48 83 ec 10 sub $0x10,%rsp
26ad: 89 7d fc mov %edi,-0x4(%rbp)
26b0: 89 f0 mov %esi,%eax
26b2: 88 45 f8 mov %al,-0x8(%rbp)
write(fd, &c, 1);
26b5: 48 8d 4d f8 lea -0x8(%rbp),%rcx
26b9: 8b 45 fc mov -0x4(%rbp),%eax
26bc: ba 01 00 00 00 mov $0x1,%edx
26c1: 48 89 ce mov %rcx,%rsi
26c4: 89 c7 mov %eax,%edi
26c6: 48 b8 b7 25 00 00 00 movabs $0x25b7,%rax
26cd: 00 00 00
26d0: ff d0 callq *%rax
}
26d2: 90 nop
26d3: c9 leaveq
26d4: c3 retq
00000000000026d5 <print_x64>:
static char digits[] = "0123456789abcdef";
static void
print_x64(int fd, addr_t x)
{
26d5: f3 0f 1e fa endbr64
26d9: 55 push %rbp
26da: 48 89 e5 mov %rsp,%rbp
26dd: 48 83 ec 20 sub $0x20,%rsp
26e1: 89 7d ec mov %edi,-0x14(%rbp)
26e4: 48 89 75 e0 mov %rsi,-0x20(%rbp)
int i;
for (i = 0; i < (sizeof(addr_t) * 2); i++, x <<= 4)
26e8: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
26ef: eb 35 jmp 2726 <print_x64+0x51>
putc(fd, digits[x >> (sizeof(addr_t) * 8 - 4)]);
26f1: 48 8b 45 e0 mov -0x20(%rbp),%rax
26f5: 48 c1 e8 3c shr $0x3c,%rax
26f9: 48 ba 40 36 00 00 00 movabs $0x3640,%rdx
2700: 00 00 00
2703: 0f b6 04 02 movzbl (%rdx,%rax,1),%eax
2707: 0f be d0 movsbl %al,%edx
270a: 8b 45 ec mov -0x14(%rbp),%eax
270d: 89 d6 mov %edx,%esi
270f: 89 c7 mov %eax,%edi
2711: 48 b8 a1 26 00 00 00 movabs $0x26a1,%rax
2718: 00 00 00
271b: ff d0 callq *%rax
for (i = 0; i < (sizeof(addr_t) * 2); i++, x <<= 4)
271d: 83 45 fc 01 addl $0x1,-0x4(%rbp)
2721: 48 c1 65 e0 04 shlq $0x4,-0x20(%rbp)
2726: 8b 45 fc mov -0x4(%rbp),%eax
2729: 83 f8 0f cmp $0xf,%eax
272c: 76 c3 jbe 26f1 <print_x64+0x1c>
}
272e: 90 nop
272f: 90 nop
2730: c9 leaveq
2731: c3 retq
0000000000002732 <print_x32>:
static void
print_x32(int fd, uint x)
{
2732: f3 0f 1e fa endbr64
2736: 55 push %rbp
2737: 48 89 e5 mov %rsp,%rbp
273a: 48 83 ec 20 sub $0x20,%rsp
273e: 89 7d ec mov %edi,-0x14(%rbp)
2741: 89 75 e8 mov %esi,-0x18(%rbp)
int i;
for (i = 0; i < (sizeof(uint) * 2); i++, x <<= 4)
2744: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
274b: eb 36 jmp 2783 <print_x32+0x51>
putc(fd, digits[x >> (sizeof(uint) * 8 - 4)]);
274d: 8b 45 e8 mov -0x18(%rbp),%eax
2750: c1 e8 1c shr $0x1c,%eax
2753: 89 c2 mov %eax,%edx
2755: 48 b8 40 36 00 00 00 movabs $0x3640,%rax
275c: 00 00 00
275f: 89 d2 mov %edx,%edx
2761: 0f b6 04 10 movzbl (%rax,%rdx,1),%eax
2765: 0f be d0 movsbl %al,%edx
2768: 8b 45 ec mov -0x14(%rbp),%eax
276b: 89 d6 mov %edx,%esi
276d: 89 c7 mov %eax,%edi
276f: 48 b8 a1 26 00 00 00 movabs $0x26a1,%rax
2776: 00 00 00
2779: ff d0 callq *%rax
for (i = 0; i < (sizeof(uint) * 2); i++, x <<= 4)
277b: 83 45 fc 01 addl $0x1,-0x4(%rbp)
277f: c1 65 e8 04 shll $0x4,-0x18(%rbp)
2783: 8b 45 fc mov -0x4(%rbp),%eax
2786: 83 f8 07 cmp $0x7,%eax
2789: 76 c2 jbe 274d <print_x32+0x1b>
}
278b: 90 nop
278c: 90 nop
278d: c9 leaveq
278e: c3 retq
000000000000278f <print_d>:
static void
print_d(int fd, int v)
{
278f: f3 0f 1e fa endbr64
2793: 55 push %rbp
2794: 48 89 e5 mov %rsp,%rbp
2797: 48 83 ec 30 sub $0x30,%rsp
279b: 89 7d dc mov %edi,-0x24(%rbp)
279e: 89 75 d8 mov %esi,-0x28(%rbp)
char buf[16];
int64 x = v;
27a1: 8b 45 d8 mov -0x28(%rbp),%eax
27a4: 48 98 cltq
27a6: 48 89 45 f8 mov %rax,-0x8(%rbp)
if (v < 0)
27aa: 83 7d d8 00 cmpl $0x0,-0x28(%rbp)
27ae: 79 04 jns 27b4 <print_d+0x25>
x = -x;
27b0: 48 f7 5d f8 negq -0x8(%rbp)
int i = 0;
27b4: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%rbp)
do {
buf[i++] = digits[x % 10];
27bb: 48 8b 4d f8 mov -0x8(%rbp),%rcx
27bf: 48 ba 67 66 66 66 66 movabs $0x6666666666666667,%rdx
27c6: 66 66 66
27c9: 48 89 c8 mov %rcx,%rax
27cc: 48 f7 ea imul %rdx
27cf: 48 c1 fa 02 sar $0x2,%rdx
27d3: 48 89 c8 mov %rcx,%rax
27d6: 48 c1 f8 3f sar $0x3f,%rax
27da: 48 29 c2 sub %rax,%rdx
27dd: 48 89 d0 mov %rdx,%rax
27e0: 48 c1 e0 02 shl $0x2,%rax
27e4: 48 01 d0 add %rdx,%rax
27e7: 48 01 c0 add %rax,%rax
27ea: 48 29 c1 sub %rax,%rcx
27ed: 48 89 ca mov %rcx,%rdx
27f0: 8b 45 f4 mov -0xc(%rbp),%eax
27f3: 8d 48 01 lea 0x1(%rax),%ecx
27f6: 89 4d f4 mov %ecx,-0xc(%rbp)
27f9: 48 b9 40 36 00 00 00 movabs $0x3640,%rcx
2800: 00 00 00
2803: 0f b6 14 11 movzbl (%rcx,%rdx,1),%edx
2807: 48 98 cltq
2809: 88 54 05 e0 mov %dl,-0x20(%rbp,%rax,1)
x /= 10;
280d: 48 8b 4d f8 mov -0x8(%rbp),%rcx
2811: 48 ba 67 66 66 66 66 movabs $0x6666666666666667,%rdx
2818: 66 66 66
281b: 48 89 c8 mov %rcx,%rax
281e: 48 f7 ea imul %rdx
2821: 48 c1 fa 02 sar $0x2,%rdx
2825: 48 89 c8 mov %rcx,%rax
2828: 48 c1 f8 3f sar $0x3f,%rax
282c: 48 29 c2 sub %rax,%rdx
282f: 48 89 d0 mov %rdx,%rax
2832: 48 89 45 f8 mov %rax,-0x8(%rbp)
} while(x != 0);
2836: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
283b: 0f 85 7a ff ff ff jne 27bb <print_d+0x2c>
if (v < 0)
2841: 83 7d d8 00 cmpl $0x0,-0x28(%rbp)
2845: 79 32 jns 2879 <print_d+0xea>
buf[i++] = '-';
2847: 8b 45 f4 mov -0xc(%rbp),%eax
284a: 8d 50 01 lea 0x1(%rax),%edx
284d: 89 55 f4 mov %edx,-0xc(%rbp)
2850: 48 98 cltq
2852: c6 44 05 e0 2d movb $0x2d,-0x20(%rbp,%rax,1)
while (--i >= 0)
2857: eb 20 jmp 2879 <print_d+0xea>
putc(fd, buf[i]);
2859: 8b 45 f4 mov -0xc(%rbp),%eax
285c: 48 98 cltq
285e: 0f b6 44 05 e0 movzbl -0x20(%rbp,%rax,1),%eax
2863: 0f be d0 movsbl %al,%edx
2866: 8b 45 dc mov -0x24(%rbp),%eax
2869: 89 d6 mov %edx,%esi
286b: 89 c7 mov %eax,%edi
286d: 48 b8 a1 26 00 00 00 movabs $0x26a1,%rax
2874: 00 00 00
2877: ff d0 callq *%rax
while (--i >= 0)
2879: 83 6d f4 01 subl $0x1,-0xc(%rbp)
287d: 83 7d f4 00 cmpl $0x0,-0xc(%rbp)
2881: 79 d6 jns 2859 <print_d+0xca>
}
2883: 90 nop
2884: 90 nop
2885: c9 leaveq
2886: c3 retq
0000000000002887 <printf>:
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
2887: f3 0f 1e fa endbr64
288b: 55 push %rbp
288c: 48 89 e5 mov %rsp,%rbp
288f: 48 81 ec f0 00 00 00 sub $0xf0,%rsp
2896: 89 bd 1c ff ff ff mov %edi,-0xe4(%rbp)
289c: 48 89 b5 10 ff ff ff mov %rsi,-0xf0(%rbp)
28a3: 48 89 95 60 ff ff ff mov %rdx,-0xa0(%rbp)
28aa: 48 89 8d 68 ff ff ff mov %rcx,-0x98(%rbp)
28b1: 4c 89 85 70 ff ff ff mov %r8,-0x90(%rbp)
28b8: 4c 89 8d 78 ff ff ff mov %r9,-0x88(%rbp)
28bf: 84 c0 test %al,%al
28c1: 74 20 je 28e3 <printf+0x5c>
28c3: 0f 29 45 80 movaps %xmm0,-0x80(%rbp)
28c7: 0f 29 4d 90 movaps %xmm1,-0x70(%rbp)
28cb: 0f 29 55 a0 movaps %xmm2,-0x60(%rbp)
28cf: 0f 29 5d b0 movaps %xmm3,-0x50(%rbp)
28d3: 0f 29 65 c0 movaps %xmm4,-0x40(%rbp)
28d7: 0f 29 6d d0 movaps %xmm5,-0x30(%rbp)
28db: 0f 29 75 e0 movaps %xmm6,-0x20(%rbp)
28df: 0f 29 7d f0 movaps %xmm7,-0x10(%rbp)
va_list ap;
int i, c;
char *s;
va_start(ap, fmt);
28e3: c7 85 20 ff ff ff 10 movl $0x10,-0xe0(%rbp)
28ea: 00 00 00
28ed: c7 85 24 ff ff ff 30 movl $0x30,-0xdc(%rbp)
28f4: 00 00 00
28f7: 48 8d 45 10 lea 0x10(%rbp),%rax
28fb: 48 89 85 28 ff ff ff mov %rax,-0xd8(%rbp)
2902: 48 8d 85 50 ff ff ff lea -0xb0(%rbp),%rax
2909: 48 89 85 30 ff ff ff mov %rax,-0xd0(%rbp)
for (i = 0; (c = fmt[i] & 0xff) != 0; i++) {
2910: c7 85 4c ff ff ff 00 movl $0x0,-0xb4(%rbp)
2917: 00 00 00
291a: e9 41 03 00 00 jmpq 2c60 <printf+0x3d9>
if (c != '%') {
291f: 83 bd 3c ff ff ff 25 cmpl $0x25,-0xc4(%rbp)
2926: 74 24 je 294c <printf+0xc5>
putc(fd, c);
2928: 8b 85 3c ff ff ff mov -0xc4(%rbp),%eax
292e: 0f be d0 movsbl %al,%edx
2931: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
2937: 89 d6 mov %edx,%esi
2939: 89 c7 mov %eax,%edi
293b: 48 b8 a1 26 00 00 00 movabs $0x26a1,%rax
2942: 00 00 00
2945: ff d0 callq *%rax
continue;
2947: e9 0d 03 00 00 jmpq 2c59 <printf+0x3d2>
}
c = fmt[++i] & 0xff;
294c: 83 85 4c ff ff ff 01 addl $0x1,-0xb4(%rbp)
2953: 8b 85 4c ff ff ff mov -0xb4(%rbp),%eax
2959: 48 63 d0 movslq %eax,%rdx
295c: 48 8b 85 10 ff ff ff mov -0xf0(%rbp),%rax
2963: 48 01 d0 add %rdx,%rax
2966: 0f b6 00 movzbl (%rax),%eax
2969: 0f be c0 movsbl %al,%eax
296c: 25 ff 00 00 00 and $0xff,%eax
2971: 89 85 3c ff ff ff mov %eax,-0xc4(%rbp)
if (c == 0)
2977: 83 bd 3c ff ff ff 00 cmpl $0x0,-0xc4(%rbp)
297e: 0f 84 0f 03 00 00 je 2c93 <printf+0x40c>
break;
switch(c) {
2984: 83 bd 3c ff ff ff 25 cmpl $0x25,-0xc4(%rbp)
298b: 0f 84 74 02 00 00 je 2c05 <printf+0x37e>
2991: 83 bd 3c ff ff ff 25 cmpl $0x25,-0xc4(%rbp)
2998: 0f 8c 82 02 00 00 jl 2c20 <printf+0x399>
299e: 83 bd 3c ff ff ff 78 cmpl $0x78,-0xc4(%rbp)
29a5: 0f 8f 75 02 00 00 jg 2c20 <printf+0x399>
29ab: 83 bd 3c ff ff ff 63 cmpl $0x63,-0xc4(%rbp)
29b2: 0f 8c 68 02 00 00 jl 2c20 <printf+0x399>
29b8: 8b 85 3c ff ff ff mov -0xc4(%rbp),%eax
29be: 83 e8 63 sub $0x63,%eax
29c1: 83 f8 15 cmp $0x15,%eax
29c4: 0f 87 56 02 00 00 ja 2c20 <printf+0x399>
29ca: 89 c0 mov %eax,%eax
29cc: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
29d3: 00
29d4: 48 b8 d0 30 00 00 00 movabs $0x30d0,%rax
29db: 00 00 00
29de: 48 01 d0 add %rdx,%rax
29e1: 48 8b 00 mov (%rax),%rax
29e4: 3e ff e0 notrack jmpq *%rax
case 'c':
putc(fd, va_arg(ap, int));
29e7: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax
29ed: 83 f8 2f cmp $0x2f,%eax
29f0: 77 23 ja 2a15 <printf+0x18e>
29f2: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax
29f9: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
29ff: 89 d2 mov %edx,%edx
2a01: 48 01 d0 add %rdx,%rax
2a04: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
2a0a: 83 c2 08 add $0x8,%edx
2a0d: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp)
2a13: eb 12 jmp 2a27 <printf+0x1a0>
2a15: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
2a1c: 48 8d 50 08 lea 0x8(%rax),%rdx
2a20: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp)
2a27: 8b 00 mov (%rax),%eax
2a29: 0f be d0 movsbl %al,%edx
2a2c: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
2a32: 89 d6 mov %edx,%esi
2a34: 89 c7 mov %eax,%edi
2a36: 48 b8 a1 26 00 00 00 movabs $0x26a1,%rax
2a3d: 00 00 00
2a40: ff d0 callq *%rax
break;
2a42: e9 12 02 00 00 jmpq 2c59 <printf+0x3d2>
case 'd':
print_d(fd, va_arg(ap, int));
2a47: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax
2a4d: 83 f8 2f cmp $0x2f,%eax
2a50: 77 23 ja 2a75 <printf+0x1ee>
2a52: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax
2a59: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
2a5f: 89 d2 mov %edx,%edx
2a61: 48 01 d0 add %rdx,%rax
2a64: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
2a6a: 83 c2 08 add $0x8,%edx
2a6d: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp)
2a73: eb 12 jmp 2a87 <printf+0x200>
2a75: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
2a7c: 48 8d 50 08 lea 0x8(%rax),%rdx
2a80: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp)
2a87: 8b 10 mov (%rax),%edx
2a89: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
2a8f: 89 d6 mov %edx,%esi
2a91: 89 c7 mov %eax,%edi
2a93: 48 b8 8f 27 00 00 00 movabs $0x278f,%rax
2a9a: 00 00 00
2a9d: ff d0 callq *%rax
break;
2a9f: e9 b5 01 00 00 jmpq 2c59 <printf+0x3d2>
case 'x':
print_x32(fd, va_arg(ap, uint));
2aa4: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax
2aaa: 83 f8 2f cmp $0x2f,%eax
2aad: 77 23 ja 2ad2 <printf+0x24b>
2aaf: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax
2ab6: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
2abc: 89 d2 mov %edx,%edx
2abe: 48 01 d0 add %rdx,%rax
2ac1: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
2ac7: 83 c2 08 add $0x8,%edx
2aca: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp)
2ad0: eb 12 jmp 2ae4 <printf+0x25d>
2ad2: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
2ad9: 48 8d 50 08 lea 0x8(%rax),%rdx
2add: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp)
2ae4: 8b 10 mov (%rax),%edx
2ae6: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
2aec: 89 d6 mov %edx,%esi
2aee: 89 c7 mov %eax,%edi
2af0: 48 b8 32 27 00 00 00 movabs $0x2732,%rax
2af7: 00 00 00
2afa: ff d0 callq *%rax
break;
2afc: e9 58 01 00 00 jmpq 2c59 <printf+0x3d2>
case 'p':
print_x64(fd, va_arg(ap, addr_t));
2b01: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax
2b07: 83 f8 2f cmp $0x2f,%eax
2b0a: 77 23 ja 2b2f <printf+0x2a8>
2b0c: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax
2b13: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
2b19: 89 d2 mov %edx,%edx
2b1b: 48 01 d0 add %rdx,%rax
2b1e: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
2b24: 83 c2 08 add $0x8,%edx
2b27: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp)
2b2d: eb 12 jmp 2b41 <printf+0x2ba>
2b2f: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
2b36: 48 8d 50 08 lea 0x8(%rax),%rdx
2b3a: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp)
2b41: 48 8b 10 mov (%rax),%rdx
2b44: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
2b4a: 48 89 d6 mov %rdx,%rsi
2b4d: 89 c7 mov %eax,%edi
2b4f: 48 b8 d5 26 00 00 00 movabs $0x26d5,%rax
2b56: 00 00 00
2b59: ff d0 callq *%rax
break;
2b5b: e9 f9 00 00 00 jmpq 2c59 <printf+0x3d2>
case 's':
if ((s = va_arg(ap, char*)) == 0)
2b60: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax
2b66: 83 f8 2f cmp $0x2f,%eax
2b69: 77 23 ja 2b8e <printf+0x307>
2b6b: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax
2b72: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
2b78: 89 d2 mov %edx,%edx
2b7a: 48 01 d0 add %rdx,%rax
2b7d: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
2b83: 83 c2 08 add $0x8,%edx
2b86: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp)
2b8c: eb 12 jmp 2ba0 <printf+0x319>
2b8e: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
2b95: 48 8d 50 08 lea 0x8(%rax),%rdx
2b99: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp)
2ba0: 48 8b 00 mov (%rax),%rax
2ba3: 48 89 85 40 ff ff ff mov %rax,-0xc0(%rbp)
2baa: 48 83 bd 40 ff ff ff cmpq $0x0,-0xc0(%rbp)
2bb1: 00
2bb2: 75 41 jne 2bf5 <printf+0x36e>
s = "(null)";
2bb4: 48 b8 c8 30 00 00 00 movabs $0x30c8,%rax
2bbb: 00 00 00
2bbe: 48 89 85 40 ff ff ff mov %rax,-0xc0(%rbp)
while (*s)
2bc5: eb 2e jmp 2bf5 <printf+0x36e>
putc(fd, *(s++));
2bc7: 48 8b 85 40 ff ff ff mov -0xc0(%rbp),%rax
2bce: 48 8d 50 01 lea 0x1(%rax),%rdx
2bd2: 48 89 95 40 ff ff ff mov %rdx,-0xc0(%rbp)
2bd9: 0f b6 00 movzbl (%rax),%eax
2bdc: 0f be d0 movsbl %al,%edx
2bdf: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
2be5: 89 d6 mov %edx,%esi
2be7: 89 c7 mov %eax,%edi
2be9: 48 b8 a1 26 00 00 00 movabs $0x26a1,%rax
2bf0: 00 00 00
2bf3: ff d0 callq *%rax
while (*s)
2bf5: 48 8b 85 40 ff ff ff mov -0xc0(%rbp),%rax
2bfc: 0f b6 00 movzbl (%rax),%eax
2bff: 84 c0 test %al,%al
2c01: 75 c4 jne 2bc7 <printf+0x340>
break;
2c03: eb 54 jmp 2c59 <printf+0x3d2>
case '%':
putc(fd, '%');
2c05: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
2c0b: be 25 00 00 00 mov $0x25,%esi
2c10: 89 c7 mov %eax,%edi
2c12: 48 b8 a1 26 00 00 00 movabs $0x26a1,%rax
2c19: 00 00 00
2c1c: ff d0 callq *%rax
break;
2c1e: eb 39 jmp 2c59 <printf+0x3d2>
default:
// Print unknown % sequence to draw attention.
putc(fd, '%');
2c20: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
2c26: be 25 00 00 00 mov $0x25,%esi
2c2b: 89 c7 mov %eax,%edi
2c2d: 48 b8 a1 26 00 00 00 movabs $0x26a1,%rax
2c34: 00 00 00
2c37: ff d0 callq *%rax
putc(fd, c);
2c39: 8b 85 3c ff ff ff mov -0xc4(%rbp),%eax
2c3f: 0f be d0 movsbl %al,%edx
2c42: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
2c48: 89 d6 mov %edx,%esi
2c4a: 89 c7 mov %eax,%edi
2c4c: 48 b8 a1 26 00 00 00 movabs $0x26a1,%rax
2c53: 00 00 00
2c56: ff d0 callq *%rax
break;
2c58: 90 nop
for (i = 0; (c = fmt[i] & 0xff) != 0; i++) {
2c59: 83 85 4c ff ff ff 01 addl $0x1,-0xb4(%rbp)
2c60: 8b 85 4c ff ff ff mov -0xb4(%rbp),%eax
2c66: 48 63 d0 movslq %eax,%rdx
2c69: 48 8b 85 10 ff ff ff mov -0xf0(%rbp),%rax
2c70: 48 01 d0 add %rdx,%rax
2c73: 0f b6 00 movzbl (%rax),%eax
2c76: 0f be c0 movsbl %al,%eax
2c79: 25 ff 00 00 00 and $0xff,%eax
2c7e: 89 85 3c ff ff ff mov %eax,-0xc4(%rbp)
2c84: 83 bd 3c ff ff ff 00 cmpl $0x0,-0xc4(%rbp)
2c8b: 0f 85 8e fc ff ff jne 291f <printf+0x98>
}
}
}
2c91: eb 01 jmp 2c94 <printf+0x40d>
break;
2c93: 90 nop
}
2c94: 90 nop
2c95: c9 leaveq
2c96: c3 retq
0000000000002c97 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
2c97: f3 0f 1e fa endbr64
2c9b: 55 push %rbp
2c9c: 48 89 e5 mov %rsp,%rbp
2c9f: 48 83 ec 18 sub $0x18,%rsp
2ca3: 48 89 7d e8 mov %rdi,-0x18(%rbp)
Header *bp, *p;
bp = (Header*)ap - 1;
2ca7: 48 8b 45 e8 mov -0x18(%rbp),%rax
2cab: 48 83 e8 10 sub $0x10,%rax
2caf: 48 89 45 f0 mov %rax,-0x10(%rbp)
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
2cb3: 48 b8 e0 36 00 00 00 movabs $0x36e0,%rax
2cba: 00 00 00
2cbd: 48 8b 00 mov (%rax),%rax
2cc0: 48 89 45 f8 mov %rax,-0x8(%rbp)
2cc4: eb 2f jmp 2cf5 <free+0x5e>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
2cc6: 48 8b 45 f8 mov -0x8(%rbp),%rax
2cca: 48 8b 00 mov (%rax),%rax
2ccd: 48 39 45 f8 cmp %rax,-0x8(%rbp)
2cd1: 72 17 jb 2cea <free+0x53>
2cd3: 48 8b 45 f0 mov -0x10(%rbp),%rax
2cd7: 48 3b 45 f8 cmp -0x8(%rbp),%rax
2cdb: 77 2f ja 2d0c <free+0x75>
2cdd: 48 8b 45 f8 mov -0x8(%rbp),%rax
2ce1: 48 8b 00 mov (%rax),%rax
2ce4: 48 39 45 f0 cmp %rax,-0x10(%rbp)
2ce8: 72 22 jb 2d0c <free+0x75>
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
2cea: 48 8b 45 f8 mov -0x8(%rbp),%rax
2cee: 48 8b 00 mov (%rax),%rax
2cf1: 48 89 45 f8 mov %rax,-0x8(%rbp)
2cf5: 48 8b 45 f0 mov -0x10(%rbp),%rax
2cf9: 48 3b 45 f8 cmp -0x8(%rbp),%rax
2cfd: 76 c7 jbe 2cc6 <free+0x2f>
2cff: 48 8b 45 f8 mov -0x8(%rbp),%rax
2d03: 48 8b 00 mov (%rax),%rax
2d06: 48 39 45 f0 cmp %rax,-0x10(%rbp)
2d0a: 73 ba jae 2cc6 <free+0x2f>
break;
if(bp + bp->s.size == p->s.ptr){
2d0c: 48 8b 45 f0 mov -0x10(%rbp),%rax
2d10: 8b 40 08 mov 0x8(%rax),%eax
2d13: 89 c0 mov %eax,%eax
2d15: 48 c1 e0 04 shl $0x4,%rax
2d19: 48 89 c2 mov %rax,%rdx
2d1c: 48 8b 45 f0 mov -0x10(%rbp),%rax
2d20: 48 01 c2 add %rax,%rdx
2d23: 48 8b 45 f8 mov -0x8(%rbp),%rax
2d27: 48 8b 00 mov (%rax),%rax
2d2a: 48 39 c2 cmp %rax,%rdx
2d2d: 75 2d jne 2d5c <free+0xc5>
bp->s.size += p->s.ptr->s.size;
2d2f: 48 8b 45 f0 mov -0x10(%rbp),%rax
2d33: 8b 50 08 mov 0x8(%rax),%edx
2d36: 48 8b 45 f8 mov -0x8(%rbp),%rax
2d3a: 48 8b 00 mov (%rax),%rax
2d3d: 8b 40 08 mov 0x8(%rax),%eax
2d40: 01 c2 add %eax,%edx
2d42: 48 8b 45 f0 mov -0x10(%rbp),%rax
2d46: 89 50 08 mov %edx,0x8(%rax)
bp->s.ptr = p->s.ptr->s.ptr;
2d49: 48 8b 45 f8 mov -0x8(%rbp),%rax
2d4d: 48 8b 00 mov (%rax),%rax
2d50: 48 8b 10 mov (%rax),%rdx
2d53: 48 8b 45 f0 mov -0x10(%rbp),%rax
2d57: 48 89 10 mov %rdx,(%rax)
2d5a: eb 0e jmp 2d6a <free+0xd3>
} else
bp->s.ptr = p->s.ptr;
2d5c: 48 8b 45 f8 mov -0x8(%rbp),%rax
2d60: 48 8b 10 mov (%rax),%rdx
2d63: 48 8b 45 f0 mov -0x10(%rbp),%rax
2d67: 48 89 10 mov %rdx,(%rax)
if(p + p->s.size == bp){
2d6a: 48 8b 45 f8 mov -0x8(%rbp),%rax
2d6e: 8b 40 08 mov 0x8(%rax),%eax
2d71: 89 c0 mov %eax,%eax
2d73: 48 c1 e0 04 shl $0x4,%rax
2d77: 48 89 c2 mov %rax,%rdx
2d7a: 48 8b 45 f8 mov -0x8(%rbp),%rax
2d7e: 48 01 d0 add %rdx,%rax
2d81: 48 39 45 f0 cmp %rax,-0x10(%rbp)
2d85: 75 27 jne 2dae <free+0x117>
p->s.size += bp->s.size;
2d87: 48 8b 45 f8 mov -0x8(%rbp),%rax
2d8b: 8b 50 08 mov 0x8(%rax),%edx
2d8e: 48 8b 45 f0 mov -0x10(%rbp),%rax
2d92: 8b 40 08 mov 0x8(%rax),%eax
2d95: 01 c2 add %eax,%edx
2d97: 48 8b 45 f8 mov -0x8(%rbp),%rax
2d9b: 89 50 08 mov %edx,0x8(%rax)
p->s.ptr = bp->s.ptr;
2d9e: 48 8b 45 f0 mov -0x10(%rbp),%rax
2da2: 48 8b 10 mov (%rax),%rdx
2da5: 48 8b 45 f8 mov -0x8(%rbp),%rax
2da9: 48 89 10 mov %rdx,(%rax)
2dac: eb 0b jmp 2db9 <free+0x122>
} else
p->s.ptr = bp;
2dae: 48 8b 45 f8 mov -0x8(%rbp),%rax
2db2: 48 8b 55 f0 mov -0x10(%rbp),%rdx
2db6: 48 89 10 mov %rdx,(%rax)
freep = p;
2db9: 48 ba e0 36 00 00 00 movabs $0x36e0,%rdx
2dc0: 00 00 00
2dc3: 48 8b 45 f8 mov -0x8(%rbp),%rax
2dc7: 48 89 02 mov %rax,(%rdx)
}
2dca: 90 nop
2dcb: c9 leaveq
2dcc: c3 retq
0000000000002dcd <morecore>:
static Header*
morecore(uint nu)
{
2dcd: f3 0f 1e fa endbr64
2dd1: 55 push %rbp
2dd2: 48 89 e5 mov %rsp,%rbp
2dd5: 48 83 ec 20 sub $0x20,%rsp
2dd9: 89 7d ec mov %edi,-0x14(%rbp)
char *p;
Header *hp;
if(nu < 4096)
2ddc: 81 7d ec ff 0f 00 00 cmpl $0xfff,-0x14(%rbp)
2de3: 77 07 ja 2dec <morecore+0x1f>
nu = 4096;
2de5: c7 45 ec 00 10 00 00 movl $0x1000,-0x14(%rbp)
p = sbrk(nu * sizeof(Header));
2dec: 8b 45 ec mov -0x14(%rbp),%eax
2def: 48 c1 e0 04 shl $0x4,%rax
2df3: 48 89 c7 mov %rax,%rdi
2df6: 48 b8 60 26 00 00 00 movabs $0x2660,%rax
2dfd: 00 00 00
2e00: ff d0 callq *%rax
2e02: 48 89 45 f8 mov %rax,-0x8(%rbp)
if(p == (char*)-1)
2e06: 48 83 7d f8 ff cmpq $0xffffffffffffffff,-0x8(%rbp)
2e0b: 75 07 jne 2e14 <morecore+0x47>
return 0;
2e0d: b8 00 00 00 00 mov $0x0,%eax
2e12: eb 36 jmp 2e4a <morecore+0x7d>
hp = (Header*)p;
2e14: 48 8b 45 f8 mov -0x8(%rbp),%rax
2e18: 48 89 45 f0 mov %rax,-0x10(%rbp)
hp->s.size = nu;
2e1c: 48 8b 45 f0 mov -0x10(%rbp),%rax
2e20: 8b 55 ec mov -0x14(%rbp),%edx
2e23: 89 50 08 mov %edx,0x8(%rax)
free((void*)(hp + 1));
2e26: 48 8b 45 f0 mov -0x10(%rbp),%rax
2e2a: 48 83 c0 10 add $0x10,%rax
2e2e: 48 89 c7 mov %rax,%rdi
2e31: 48 b8 97 2c 00 00 00 movabs $0x2c97,%rax
2e38: 00 00 00
2e3b: ff d0 callq *%rax
return freep;
2e3d: 48 b8 e0 36 00 00 00 movabs $0x36e0,%rax
2e44: 00 00 00
2e47: 48 8b 00 mov (%rax),%rax
}
2e4a: c9 leaveq
2e4b: c3 retq
0000000000002e4c <malloc>:
void*
malloc(uint nbytes)
{
2e4c: f3 0f 1e fa endbr64
2e50: 55 push %rbp
2e51: 48 89 e5 mov %rsp,%rbp
2e54: 48 83 ec 30 sub $0x30,%rsp
2e58: 89 7d dc mov %edi,-0x24(%rbp)
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
2e5b: 8b 45 dc mov -0x24(%rbp),%eax
2e5e: 48 83 c0 0f add $0xf,%rax
2e62: 48 c1 e8 04 shr $0x4,%rax
2e66: 83 c0 01 add $0x1,%eax
2e69: 89 45 ec mov %eax,-0x14(%rbp)
if((prevp = freep) == 0){
2e6c: 48 b8 e0 36 00 00 00 movabs $0x36e0,%rax
2e73: 00 00 00
2e76: 48 8b 00 mov (%rax),%rax
2e79: 48 89 45 f0 mov %rax,-0x10(%rbp)
2e7d: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
2e82: 75 4a jne 2ece <malloc+0x82>
base.s.ptr = freep = prevp = &base;
2e84: 48 b8 d0 36 00 00 00 movabs $0x36d0,%rax
2e8b: 00 00 00
2e8e: 48 89 45 f0 mov %rax,-0x10(%rbp)
2e92: 48 ba e0 36 00 00 00 movabs $0x36e0,%rdx
2e99: 00 00 00
2e9c: 48 8b 45 f0 mov -0x10(%rbp),%rax
2ea0: 48 89 02 mov %rax,(%rdx)
2ea3: 48 b8 e0 36 00 00 00 movabs $0x36e0,%rax
2eaa: 00 00 00
2ead: 48 8b 00 mov (%rax),%rax
2eb0: 48 ba d0 36 00 00 00 movabs $0x36d0,%rdx
2eb7: 00 00 00
2eba: 48 89 02 mov %rax,(%rdx)
base.s.size = 0;
2ebd: 48 b8 d0 36 00 00 00 movabs $0x36d0,%rax
2ec4: 00 00 00
2ec7: c7 40 08 00 00 00 00 movl $0x0,0x8(%rax)
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
2ece: 48 8b 45 f0 mov -0x10(%rbp),%rax
2ed2: 48 8b 00 mov (%rax),%rax
2ed5: 48 89 45 f8 mov %rax,-0x8(%rbp)
if(p->s.size >= nunits){
2ed9: 48 8b 45 f8 mov -0x8(%rbp),%rax
2edd: 8b 40 08 mov 0x8(%rax),%eax
2ee0: 39 45 ec cmp %eax,-0x14(%rbp)
2ee3: 77 65 ja 2f4a <malloc+0xfe>
if(p->s.size == nunits)
2ee5: 48 8b 45 f8 mov -0x8(%rbp),%rax
2ee9: 8b 40 08 mov 0x8(%rax),%eax
2eec: 39 45 ec cmp %eax,-0x14(%rbp)
2eef: 75 10 jne 2f01 <malloc+0xb5>
prevp->s.ptr = p->s.ptr;
2ef1: 48 8b 45 f8 mov -0x8(%rbp),%rax
2ef5: 48 8b 10 mov (%rax),%rdx
2ef8: 48 8b 45 f0 mov -0x10(%rbp),%rax
2efc: 48 89 10 mov %rdx,(%rax)
2eff: eb 2e jmp 2f2f <malloc+0xe3>
else {
p->s.size -= nunits;
2f01: 48 8b 45 f8 mov -0x8(%rbp),%rax
2f05: 8b 40 08 mov 0x8(%rax),%eax
2f08: 2b 45 ec sub -0x14(%rbp),%eax
2f0b: 89 c2 mov %eax,%edx
2f0d: 48 8b 45 f8 mov -0x8(%rbp),%rax
2f11: 89 50 08 mov %edx,0x8(%rax)
p += p->s.size;
2f14: 48 8b 45 f8 mov -0x8(%rbp),%rax
2f18: 8b 40 08 mov 0x8(%rax),%eax
2f1b: 89 c0 mov %eax,%eax
2f1d: 48 c1 e0 04 shl $0x4,%rax
2f21: 48 01 45 f8 add %rax,-0x8(%rbp)
p->s.size = nunits;
2f25: 48 8b 45 f8 mov -0x8(%rbp),%rax
2f29: 8b 55 ec mov -0x14(%rbp),%edx
2f2c: 89 50 08 mov %edx,0x8(%rax)
}
freep = prevp;
2f2f: 48 ba e0 36 00 00 00 movabs $0x36e0,%rdx
2f36: 00 00 00
2f39: 48 8b 45 f0 mov -0x10(%rbp),%rax
2f3d: 48 89 02 mov %rax,(%rdx)
return (void*)(p + 1);
2f40: 48 8b 45 f8 mov -0x8(%rbp),%rax
2f44: 48 83 c0 10 add $0x10,%rax
2f48: eb 4e jmp 2f98 <malloc+0x14c>
}
if(p == freep)
2f4a: 48 b8 e0 36 00 00 00 movabs $0x36e0,%rax
2f51: 00 00 00
2f54: 48 8b 00 mov (%rax),%rax
2f57: 48 39 45 f8 cmp %rax,-0x8(%rbp)
2f5b: 75 23 jne 2f80 <malloc+0x134>
if((p = morecore(nunits)) == 0)
2f5d: 8b 45 ec mov -0x14(%rbp),%eax
2f60: 89 c7 mov %eax,%edi
2f62: 48 b8 cd 2d 00 00 00 movabs $0x2dcd,%rax
2f69: 00 00 00
2f6c: ff d0 callq *%rax
2f6e: 48 89 45 f8 mov %rax,-0x8(%rbp)
2f72: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
2f77: 75 07 jne 2f80 <malloc+0x134>
return 0;
2f79: b8 00 00 00 00 mov $0x0,%eax
2f7e: eb 18 jmp 2f98 <malloc+0x14c>
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
2f80: 48 8b 45 f8 mov -0x8(%rbp),%rax
2f84: 48 89 45 f0 mov %rax,-0x10(%rbp)
2f88: 48 8b 45 f8 mov -0x8(%rbp),%rax
2f8c: 48 8b 00 mov (%rax),%rax
2f8f: 48 89 45 f8 mov %rax,-0x8(%rbp)
if(p->s.size >= nunits){
2f93: e9 41 ff ff ff jmpq 2ed9 <malloc+0x8d>
}
}
2f98: c9 leaveq
2f99: c3 retq
|
resources/imp.asm | dgtized/redwall | 0 | 171934 | ;redcode-94
;name Imp
;author <NAME>
imp: mov $0, $1
end imp
|
examples/ex.asm | Nibble-Knowledge/cpu-assembler | 0 | 11591 | INF
PINF
BLERG 0b110
HOOP 0o11
BADR 0x40
EPINF
DSEC datastart
DNUM 0x2
DSIZE 0x3
EINF
LOD hello
LOD isitmeyourelookingfor
datastart:
hello: .data 3 0x2
isitmeyourelookingfor: .data 3 0x2
|
test/fail/Issue659.agda | dagit/agda | 1 | 6049 | <filename>test/fail/Issue659.agda
-- {-# OPTIONS --show-implicit #-}
-- {-# OPTIONS -v tc.meta:50 -v tc.conv:20 -v tc.conv.type:50 #-}
module Issue659 where
postulate
Level : Set
lzero : Level
lsuc : Level → Level
_⊔_ : Level → Level → Level
{-# BUILTIN LEVEL Level #-}
{-# BUILTIN LEVELZERO lzero #-}
{-# BUILTIN LEVELSUC lsuc #-}
{-# BUILTIN LEVELMAX _⊔_ #-}
record R (ℓ : Level) : Set ℓ where
postulate
r : ∀ ℓ → R ℓ
module M (r : ∀ ℓ → R ℓ) where
data D (ℓ : Level) : Set ℓ where
id : ∀ {a} {A : Set a} → A → A
id x = x
data K : Set where
k₁ k₂ : K
P : ∀ {ℓ} → K → Set ℓ → Set ℓ
P k₁ A = A → A
P k₂ A = D _
open M r
postulate
Foo : ∀ {k a} {A : Set a} → P k A → Set
Bar : Set
Bar = Foo M.id
-- Could this error message be improved?
-- Setω is not a valid type.
-- when checking that the expression M.id has type P M.k₁ _34
-- New error:
--
-- ((r₁ : (ℓ : Level) → R ℓ) {a : Level} {A : Set a} → A → A) !=<
-- (P {_33} _32 _34)
-- because this would result in an invalid use of Setω
-- when checking that the expression M.id has type (P {_33} _32 _34)
|
src/Consistency.agda | andreasabel/ipl | 19 | 5969 | <filename>src/Consistency.agda
-- Logical consistency of IPL
open import Library
module Consistency (Base : Set) where
import Formulas ; open module Form = Formulas Base
import Derivations ; open module Der = Derivations Base
import NfModelMonad; open module NfM = NfModelMonad Base
open Normalization caseTreeMonad using (norm)
-- No variable in the empty context.
noVar : ∀{A} → Hyp A ε → ⊥
noVar ()
-- No neutral in the empty context.
noNe : ∀{A} → Ne ε A → ⊥
noNe (hyp ())
noNe (impE t u) = noNe t
noNe (andE₁ t) = noNe t
noNe (andE₂ t) = noNe t
-- No normal proof of False in the empty context.
noNf : Nf ε False → ⊥
noNf (orE t t₁ t₂) = noNe t
noNf (falseE t) = noNe t
-- No proof of False in the empty context.
consistency : ε ⊢ False → ⊥
consistency = noNf ∘ norm
|
test/Common/Size.agda | redfish64/autonomic-agda | 4 | 15561 | <reponame>redfish64/autonomic-agda
------------------------------------------------------------------------
-- From the Agda standard library
--
-- Sizes for Agda's sized types
------------------------------------------------------------------------
module Common.Size where
open import Agda.Builtin.Size public renaming (ω to ∞; SizeU to SizeUniv)
|
oeis/227/A227881.asm | neoneye/loda-programs | 11 | 173485 | ; A227881: Sum of digits of 17^n.
; 1,8,19,17,19,35,37,35,55,71,55,62,64,80,91,80,109,98,91,98,82,116,136,143,109,152,163,152,145,152,172,170,172,170,208,215,199,197,226,233,217,206,271,224,244,242,253,287,244,305,271,269,298,305,325,314,307,350,307,332,334,296,352,359,334,350,334,314,388,404,433,386,379,377,424,431,424,422,451,440,442,449,469,422,442,458,460,566,469,521,442,512,496,467,487,503,487,521,577,557
mov $4,$0
mov $0,17
pow $0,$4
lpb $0
mov $2,$0
div $0,10
mod $2,10
add $3,$2
lpe
mov $0,$3
|
source/required/s-secsta.adb | ytomino/drake | 33 | 26410 | with System.Runtime_Context;
package body System.Secondary_Stack is
pragma Suppress (All_Checks);
use type Storage_Elements.Storage_Offset;
type Unsigned is mod 2 ** Integer'Size;
function clz (X : Unsigned) return Unsigned
with Import, Convention => Intrinsic, External_Name => "__builtin_clz";
procedure unreachable
with Import,
Convention => Intrinsic, External_Name => "__builtin_unreachable";
pragma No_Return (unreachable);
-- implementation
procedure SS_Allocate (
Addr : out Address;
Storage_Size : Storage_Elements.Storage_Count)
is
TLS : constant not null Runtime_Context.Task_Local_Storage_Access :=
Runtime_Context.Get_Task_Local_Storage;
Alignment : Storage_Elements.Storage_Count;
begin
-- alignment
if Storage_Size <= Standard'Maximum_Alignment / 2 then
declare
H : constant Integer :=
Integer (
clz (Unsigned (Storage_Size) * 2 - 1)
xor (Unsigned'Size - 1)); -- cancel wordy xor
begin
if H not in 0 .. Standard'Address_Size - 1 then
unreachable; -- assume H is in address-width
end if;
Alignment := Storage_Elements.Storage_Offset (
Storage_Elements.Integer_Address'(
Storage_Elements.Shift_Left (1, H)));
end;
else
Alignment := Standard'Maximum_Alignment;
end if;
Unbounded_Stack_Allocators.Allocate (
TLS.Secondary_Stack,
Addr,
Storage_Size,
Alignment);
end SS_Allocate;
function SS_Mark return Mark_Id is
TLS : constant not null Runtime_Context.Task_Local_Storage_Access :=
Runtime_Context.Get_Task_Local_Storage;
begin
return Unbounded_Stack_Allocators.Mark (TLS.Secondary_Stack);
end SS_Mark;
procedure SS_Release (M : Mark_Id) is
TLS : constant not null Runtime_Context.Task_Local_Storage_Access :=
Runtime_Context.Get_Task_Local_Storage;
begin
Unbounded_Stack_Allocators.Release (TLS.Secondary_Stack, M);
end SS_Release;
end System.Secondary_Stack;
|
data/sprites/map_objects.asm | Dev727/ancientplatinum | 28 | 16410 | SpriteMovementData::
; entries correspond to SPRITEMOVEDATA_* constants
; SPRITEMOVEDATA_00
db SPRITEMOVEFN_00 ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db WONT_DELETE ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_STILL
db SPRITEMOVEFN_STANDING ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db FIXED_FACING | SLIDING ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_WANDER
db SPRITEMOVEFN_RANDOM_WALK_XY ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db 0 ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_SPINRANDOM_SLOW
db SPRITEMOVEFN_SLOW_RANDOM_SPIN ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db 0 ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_WALK_UP_DOWN
db SPRITEMOVEFN_RANDOM_WALK_Y ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db 0 ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_WALK_LEFT_RIGHT
db SPRITEMOVEFN_RANDOM_WALK_X ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db 0 ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_STANDING_DOWN
db SPRITEMOVEFN_STANDING ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db 0 ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_STANDING_UP
db SPRITEMOVEFN_STANDING ; movement function
db UP ; facing
db OBJECT_ACTION_STAND ; action
db 0 ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_STANDING_LEFT
db SPRITEMOVEFN_STANDING ; movement function
db LEFT ; facing
db OBJECT_ACTION_STAND ; action
db 0 ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_STANDING_RIGHT
db SPRITEMOVEFN_STANDING ; movement function
db RIGHT ; facing
db OBJECT_ACTION_STAND ; action
db 0 ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_SPINRANDOM_FAST
db SPRITEMOVEFN_FAST_RANDOM_SPIN ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db 0 ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_PLAYER
db SPRITEMOVEFN_OBEY_DPAD ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db WONT_DELETE ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_0C
db SPRITEMOVEFN_08 ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db 0 ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_0D
db SPRITEMOVEFN_09 ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db 0 ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_0E
db SPRITEMOVEFN_0A ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db 0 ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_0F
db SPRITEMOVEFN_0B ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db 0 ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_10
db SPRITEMOVEFN_0C ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db 0 ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_11
db SPRITEMOVEFN_0D ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db 0 ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_12
db SPRITEMOVEFN_0E ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db 0 ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_FOLLOWING
db SPRITEMOVEFN_FOLLOW ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db WONT_DELETE ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_SCRIPTED
db SPRITEMOVEFN_SCRIPTED ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db WONT_DELETE ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_BIGDOLLSYM
db SPRITEMOVEFN_BIG_SNORLAX ; movement function
db DOWN ; facing
db OBJECT_ACTION_BIG_DOLL_SYM ; action
db WONT_DELETE | FIXED_FACING | SLIDING | MOVE_ANYWHERE ; flags1
db LOW_PRIORITY ; flags2
db STRENGTH_BOULDER | BIG_OBJECT ; palette flags
; SPRITEMOVEDATA_POKEMON
db SPRITEMOVEFN_BOUNCE ; movement function
db DOWN ; facing
db OBJECT_ACTION_BOUNCE ; action
db WONT_DELETE | FIXED_FACING | SLIDING | MOVE_ANYWHERE ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_SUDOWOODO
db SPRITEMOVEFN_STANDING ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db FIXED_FACING | SLIDING ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_SMASHABLE_ROCK
db SPRITEMOVEFN_STANDING ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db WONT_DELETE | FIXED_FACING | SLIDING | MOVE_ANYWHERE ; flags1
db USE_OBP1 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_STRENGTH_BOULDER
db SPRITEMOVEFN_STRENGTH ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db WONT_DELETE | FIXED_FACING | SLIDING | MOVE_ANYWHERE ; flags1
db 0 ; flags2
db STRENGTH_BOULDER ; palette flags
; SPRITEMOVEDATA_FOLLOWNOTEXACT
db SPRITEMOVEFN_FOLLOWNOTEXACT ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db WONT_DELETE ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_SHADOW
db SPRITEMOVEFN_SHADOW ; movement function
db DOWN ; facing
db OBJECT_ACTION_00 ; action
db WONT_DELETE | FIXED_FACING | SLIDING | EMOTE_OBJECT ; flags1
db LOW_PRIORITY ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_EMOTE
db SPRITEMOVEFN_EMOTE ; movement function
db DOWN ; facing
db OBJECT_ACTION_EMOTE ; action
db WONT_DELETE | FIXED_FACING | SLIDING | EMOTE_OBJECT ; flags1
db HIGH_PRIORITY ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_SCREENSHAKE
db SPRITEMOVEFN_SCREENSHAKE ; movement function
db DOWN ; facing
db OBJECT_ACTION_00 ; action
db WONT_DELETE | EMOTE_OBJECT ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_SPINCOUNTERCLOCKWISE
db SPRITEMOVEFN_SPIN_COUNTERCLOCKWISE ; movement function
db LEFT ; facing
db OBJECT_ACTION_STAND ; action
db 0 ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_SPINCLOCKWISE
db SPRITEMOVEFN_SPIN_CLOCKWISE ; movement function
db RIGHT ; facing
db OBJECT_ACTION_STAND ; action
db 0 ; flags1
db 0 ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_BIGDOLLASYM
db SPRITEMOVEFN_STRENGTH ; movement function
db DOWN ; facing
db OBJECT_ACTION_BIG_DOLL_ASYM ; action
db WONT_DELETE | FIXED_FACING | SLIDING | MOVE_ANYWHERE ; flags1
db LOW_PRIORITY ; flags2
db STRENGTH_BOULDER | BIG_OBJECT ; palette flags
; SPRITEMOVEDATA_BIGDOLL
db SPRITEMOVEFN_STRENGTH ; movement function
db DOWN ; facing
db OBJECT_ACTION_BIG_DOLL ; action
db WONT_DELETE | FIXED_FACING | SLIDING | MOVE_ANYWHERE ; flags1
db LOW_PRIORITY ; flags2
db STRENGTH_BOULDER | BIG_OBJECT ; palette flags
; SPRITEMOVEDATA_BOULDERDUST
db SPRITEMOVEFN_BOULDERDUST ; movement function
db DOWN ; facing
db OBJECT_ACTION_BOULDER_DUST ; action
db WONT_DELETE | FIXED_FACING | SLIDING | EMOTE_OBJECT ; flags1
db LOW_PRIORITY ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_GRASS
db SPRITEMOVEFN_GRASS ; movement function
db DOWN ; facing
db OBJECT_ACTION_GRASS_SHAKE ; action
db WONT_DELETE | FIXED_FACING | SLIDING | EMOTE_OBJECT ; flags1
db HIGH_PRIORITY ; flags2
db 0 ; palette flags
; SPRITEMOVEDATA_SWIM_WANDER
db SPRITEMOVEFN_RANDOM_WALK_XY ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db 0 ; flags1
db 0 ; flags2
db SWIMMING ; palette flags
; 25
db SPRITEMOVEFN_00 ; movement function
db DOWN ; facing
db OBJECT_ACTION_STAND ; action
db 0 ; flags1
db 0 ; flags2
db 0 ; palette flags
|
Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0x84_notsx.log_43_1904.asm | ljhsiun2/medusa | 9 | 90158 | .global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %rbp
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_WC_ht+0xf682, %r10
nop
nop
nop
xor $27193, %r11
mov (%r10), %rcx
nop
nop
nop
nop
cmp $60841, %rdi
lea addresses_WT_ht+0x1b38, %rbx
clflush (%rbx)
nop
and $35462, %rsi
mov (%rbx), %rbp
nop
and $17565, %r10
lea addresses_A_ht+0x9ca8, %rdi
nop
nop
sub $33627, %rbx
mov $0x6162636465666768, %r10
movq %r10, (%rdi)
nop
nop
dec %r11
lea addresses_D_ht+0x218, %rsi
lea addresses_WT_ht+0x1ab38, %rdi
nop
nop
sub %r10, %r10
mov $119, %rcx
rep movsl
nop
nop
nop
xor $52066, %rcx
lea addresses_normal_ht+0x7ada, %rsi
lea addresses_WC_ht+0x96b8, %rdi
clflush (%rdi)
nop
and $53819, %r11
mov $52, %rcx
rep movsb
nop
nop
nop
nop
nop
cmp %rdi, %rdi
lea addresses_D_ht+0x13aec, %rsi
lea addresses_WT_ht+0x5298, %rdi
inc %rdx
mov $63, %rcx
rep movsb
nop
nop
nop
nop
nop
and %rcx, %rcx
lea addresses_normal_ht+0x16038, %rsi
lea addresses_normal_ht+0x10a68, %rdi
nop
nop
nop
nop
lfence
mov $107, %rcx
rep movsw
nop
nop
nop
and %r10, %r10
lea addresses_WT_ht+0x4838, %rsi
lea addresses_A_ht+0x8038, %rdi
nop
nop
nop
and $64971, %rbx
mov $97, %rcx
rep movsw
nop
nop
nop
nop
sub %rcx, %rcx
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r13
push %r8
push %rax
push %rbp
push %rbx
push %rcx
push %rsi
// Store
lea addresses_WC+0x1e838, %r13
nop
nop
nop
nop
nop
cmp $12959, %rsi
mov $0x5152535455565758, %rcx
movq %rcx, %xmm7
vmovaps %ymm7, (%r13)
nop
inc %r13
// Store
lea addresses_normal+0x9738, %rbx
nop
cmp $42338, %rbp
movl $0x51525354, (%rbx)
nop
cmp %rbx, %rbx
// Faulty Load
lea addresses_normal+0x4038, %rbx
nop
nop
add %rsi, %rsi
vmovups (%rbx), %ymm3
vextracti128 $1, %ymm3, %xmm3
vpextrq $1, %xmm3, %rcx
lea oracles, %r13
and $0xff, %rcx
shlq $12, %rcx
mov (%r13,%rcx,1), %rcx
pop %rsi
pop %rcx
pop %rbx
pop %rbp
pop %rax
pop %r8
pop %r13
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_normal', 'same': False, 'size': 1, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_WC', 'same': False, 'size': 32, 'congruent': 8, 'NT': False, 'AVXalign': True}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_normal', 'same': False, 'size': 4, 'congruent': 8, 'NT': True, 'AVXalign': True}, 'OP': 'STOR'}
[Faulty Load]
{'src': {'type': 'addresses_normal', 'same': True, 'size': 32, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_WC_ht', 'same': False, 'size': 8, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WT_ht', 'same': False, 'size': 8, 'congruent': 8, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_A_ht', 'same': False, 'size': 8, 'congruent': 3, 'NT': True, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_D_ht', 'congruent': 0, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 7, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_normal_ht', 'congruent': 0, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 6, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_D_ht', 'congruent': 0, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 3, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_normal_ht', 'congruent': 11, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 4, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_WT_ht', 'congruent': 8, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 11, 'same': False}, 'OP': 'REPM'}
{'34': 43}
34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34
*/
|
test/asset/agda-stdlib-1.0/Codata/Covec/Categorical.agda | omega12345/agda-mode | 5 | 1003 | <reponame>omega12345/agda-mode
------------------------------------------------------------------------
-- The Agda standard library
--
-- A categorical view of Covec
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe --sized-types #-}
module Codata.Covec.Categorical where
open import Codata.Conat
open import Codata.Covec
open import Category.Functor
open import Category.Applicative
functor : ∀ {ℓ i n} → RawFunctor {ℓ} (λ A → Covec A n i)
functor = record { _<$>_ = map }
applicative : ∀ {ℓ i n} → RawApplicative {ℓ} (λ A → Covec A n i)
applicative = record
{ pure = replicate _
; _⊛_ = ap
}
|
oeis/142/A142021.asm | neoneye/loda-programs | 11 | 242341 | ; A142021: Primes congruent to 17 mod 31.
; Submitted by <NAME>
; 17,79,389,761,823,947,1009,1319,1381,1567,1753,1877,2063,2311,2621,2683,3613,3923,4357,4481,4729,5039,5101,5659,5783,6217,6899,6961,7333,7457,7643,7829,8263,8387,8573,8821,9007,9689,10061,10247,10433,10867,11177,11239,11549,12107,12479,12541,13037,13099,13781,13967,14029,14153,14401,14897,15083,15269,15331,15641,15889,16447,16633,16943,17191,17377,17749,18059,18121,18307,18493,18617,18679,18803,19051,19237,19423,19609,19919,20353,20477,20663,20849,21221,21283,21407,21841,22027,22709,23081,23143
mov $2,$0
add $2,6
pow $2,2
lpb $2
mov $3,$4
add $3,16
seq $3,10051 ; Characteristic function of primes: 1 if n is prime, else 0.
sub $0,$3
mov $1,$0
max $1,0
cmp $1,$0
mul $2,$1
sub $2,1
add $4,62
lpe
mov $0,$4
add $0,17
|
src/fot/FOL/README.agda | asr/fotc | 11 | 11265 | ------------------------------------------------------------------------------
-- First-order logic
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module FOL.README where
------------------------------------------------------------------------------
-- Description
-- Formalization of first-order logic using Agda's inductive notions.
------------------------------------------------------------------------------
-- Definition of the connectives and quantifiers
open import FOL.Base
-- Propositional logic theorems
open import FOL.ExclusiveDisjunction.TheoremsATP
open import FOL.ExclusiveDisjunction.TheoremsI
open import FOL.PropositionalLogic.TheoremsATP
open import FOL.PropositionalLogic.TheoremsI
-- First-order logic theorems
open import FOL.TheoremsATP
open import FOL.TheoremsI
-- Logical schemata
open import FOL.SchemataATP
-- Non-empty domains
open import FOL.NonEmptyDomain.TheoremsATP
open import FOL.NonEmptyDomain.TheoremsI
-- Non-intuitionistic logic theorems
open import FOL.NonIntuitionistic.TheoremsATP
open import FOL.NonIntuitionistic.TheoremsI
|
programs/oeis/011/A011851.asm | karttu/loda | 1 | 242372 | ; A011851: a(n) = floor(binomial(n,5)/5).
; 0,0,0,0,0,0,1,4,11,25,50,92,158,257,400,600,873,1237,1713,2325,3100,4069,5266,6729,8500,10626,13156,16146,19656,23751,28501,33982,40275,47467,55651,64926,75398,87179,100388,115151,131601,149879,170133,192519,217201,244351,274150,306787,342460,381376,423752,469812,519792,573937,632502,695752,763963,837421,916423,1001277,1092302,1189829,1294200,1405769,1524902,1651977,1787385,1931529,2084825,2247702,2420602,2603981,2798308,3004066,3221752,3451878,3694968,3951563,4222218,4507503,4808003,5124319,5457067,5806879,6174403,6560303,6965260,7389971,7835150,8301528,8789853,9300891,9835425,10394256,10978203,11588103,12224812,12889204,13582172,14304628,15057504,15841749,16658334,17508249,18392504,19312129,20268175,21261713,22293835,23365654,24478304,25632941,26830742,28072906,29360654,30695229,32077897,33509946,34992687,36527454,38115604,39758518,41457600,43214278,45030004,46906255,48844530,50846355,52913280,55046880,57248755,59520531,61863859,64280416,66771905,69340055,71986622,74713388,77522162,80414780,83393105,86459028,89614467,92861368,96201705,99637480,103170724,106803496,110537884,114376005,118320006,122372061,126534376,130809186,135198756,139705381,144331387,149079130,153950997,158949406,164076806,169335678,174728534,180257918,185926406,191736606,197691159,203792738,210044049,216447831,223006856,229723930,236601892,243643615,250852006,258230007,265780592,273506772,281411592,289498132,297769507,306228868,314879401,323724328,332766907,342010432,351458234,361113680,370980174,381061157,391360107,401880540,412626009,423600105,434806457,446248732,457930636,469855913,482028346,494451757,507130008,520066998,533266668,546732998,560470008,574481758,588772349,603345922,618206659,633358783,648806558,664554290,680606326,696967055,713640908,730632358,747945921,765586155,783557661,801865083,820513108,839506467,858849934,878548327,898606508,919029384,939821904,960989064,982535904,1004467509,1026789009,1049505580,1072622443,1096144865,1120078159,1144427684,1169198846,1194397097,1220027936,1246096909,1272609609,1299571677,1326988801,1354866717,1383211209,1412028109,1441323298,1471102705,1501372308,1532138134
mov $1,$0
bin $1,5
div $1,5
|
P6/data_P6_2/cal_R_test38.asm | alxzzhou/BUAA_CO_2020 | 1 | 176711 | lui $1,16233
ori $1,$1,64024
lui $2,27571
ori $2,$2,2583
lui $3,3371
ori $3,$3,46713
lui $4,9598
ori $4,$4,3820
lui $5,49697
ori $5,$5,19145
lui $6,5253
ori $6,$6,16253
mthi $1
mtlo $2
sec0:
nop
nop
nop
xor $3,$6,$2
sec1:
nop
nop
subu $6,$4,$3
xor $3,$6,$2
sec2:
nop
nop
slti $6,$1,25562
xor $2,$6,$2
sec3:
nop
nop
mflo $6
xor $2,$6,$2
sec4:
nop
nop
lb $6,5($0)
xor $3,$6,$2
sec5:
nop
addu $6,$4,$3
nop
xor $2,$6,$2
sec6:
nop
subu $6,$6,$4
nor $6,$0,$1
xor $3,$6,$2
sec7:
nop
or $6,$5,$3
slti $6,$3,25794
xor $3,$6,$2
sec8:
nop
slt $6,$4,$3
mflo $6
xor $1,$6,$2
sec9:
nop
xor $6,$5,$5
lh $6,12($0)
xor $2,$6,$2
sec10:
nop
lui $6,50865
nop
xor $2,$6,$2
sec11:
nop
ori $6,$0,16410
xor $6,$4,$4
xor $6,$6,$2
sec12:
nop
xori $6,$4,42576
xori $6,$2,44349
xor $5,$6,$2
sec13:
nop
slti $6,$2,-15752
mflo $6
xor $3,$6,$2
sec14:
nop
ori $6,$3,1710
lh $6,6($0)
xor $3,$6,$2
sec15:
nop
mflo $6
nop
xor $5,$6,$2
sec16:
nop
mflo $6
subu $6,$4,$1
xor $4,$6,$2
sec17:
nop
mfhi $6
lui $6,48106
xor $6,$6,$2
sec18:
nop
mfhi $6
mfhi $6
xor $1,$6,$2
sec19:
nop
mflo $6
lh $6,16($0)
xor $4,$6,$2
sec20:
nop
lh $6,4($0)
nop
xor $5,$6,$2
sec21:
nop
lb $6,1($0)
sltu $6,$6,$6
xor $4,$6,$2
sec22:
nop
lb $6,4($0)
xori $6,$3,46463
xor $3,$6,$2
sec23:
nop
lw $6,4($0)
mflo $6
xor $4,$6,$2
sec24:
nop
lb $6,7($0)
lb $6,11($0)
xor $2,$6,$2
sec25:
subu $2,$4,$6
nop
nop
xor $3,$6,$2
sec26:
nor $2,$5,$5
nop
or $6,$1,$2
xor $5,$6,$2
sec27:
nor $2,$3,$3
nop
sltiu $6,$2,23380
xor $3,$6,$2
sec28:
addu $2,$6,$2
nop
mfhi $6
xor $4,$6,$2
sec29:
xor $2,$5,$6
nop
lh $6,14($0)
xor $1,$6,$2
sec30:
or $2,$1,$1
slt $6,$1,$3
nop
xor $3,$6,$2
sec31:
and $2,$2,$3
and $6,$2,$1
and $6,$0,$2
xor $2,$6,$2
sec32:
nor $2,$0,$3
slt $6,$3,$3
andi $6,$5,24069
xor $4,$6,$2
sec33:
subu $2,$1,$0
or $6,$6,$1
mflo $6
xor $1,$6,$2
sec34:
subu $2,$0,$3
and $6,$1,$1
lw $6,4($0)
xor $4,$6,$2
sec35:
sltu $2,$0,$6
lui $6,12109
nop
xor $3,$6,$2
sec36:
and $2,$2,$3
sltiu $6,$5,-297
or $6,$3,$4
xor $3,$6,$2
sec37:
addu $2,$2,$3
sltiu $6,$0,25568
slti $6,$4,-30712
xor $0,$6,$2
sec38:
addu $2,$5,$4
ori $6,$3,29998
mfhi $6
xor $4,$6,$2
sec39:
and $2,$3,$3
sltiu $6,$3,-31533
lw $6,12($0)
xor $4,$6,$2
sec40:
or $2,$3,$4
mflo $6
nop
xor $2,$6,$2
sec41:
xor $2,$6,$3
mfhi $6
sltu $6,$4,$2
xor $0,$6,$2
sec42:
xor $2,$1,$0
mflo $6
lui $6,48662
xor $2,$6,$2
sec43:
addu $2,$4,$1
mflo $6
mflo $6
xor $5,$6,$2
sec44:
xor $2,$2,$3
mfhi $6
lw $6,4($0)
xor $3,$6,$2
sec45:
addu $2,$1,$1
lbu $6,13($0)
nop
xor $4,$6,$2
sec46:
nor $2,$6,$0
lbu $6,11($0)
or $6,$3,$1
xor $5,$6,$2
sec47:
or $2,$5,$3
lw $6,0($0)
andi $6,$0,26397
xor $2,$6,$2
sec48:
nor $2,$3,$3
lh $6,12($0)
mflo $6
xor $5,$6,$2
sec49:
nor $2,$3,$0
lb $6,3($0)
lbu $6,8($0)
xor $1,$6,$2
sec50:
lui $2,62323
nop
nop
xor $2,$6,$2
sec51:
slti $2,$6,-2056
nop
nor $6,$0,$1
xor $4,$6,$2
sec52:
xori $2,$5,53522
nop
sltiu $6,$1,5788
xor $3,$6,$2
sec53:
sltiu $2,$4,-25904
nop
mflo $6
xor $2,$6,$2
sec54:
ori $2,$4,63810
nop
lhu $6,2($0)
xor $3,$6,$2
sec55:
andi $2,$3,5959
nor $6,$3,$3
nop
xor $5,$6,$2
sec56:
lui $2,32828
nor $6,$5,$6
xor $6,$3,$4
xor $4,$6,$2
sec57:
sltiu $2,$3,-4740
slt $6,$2,$2
sltiu $6,$0,3277
xor $4,$6,$2
sec58:
andi $2,$0,6239
slt $6,$3,$0
mflo $6
xor $5,$6,$2
sec59:
sltiu $2,$4,-28943
slt $6,$3,$4
lhu $6,16($0)
xor $2,$6,$2
sec60:
xori $2,$1,35393
addiu $6,$3,14960
nop
xor $2,$6,$2
sec61:
andi $2,$1,56224
xori $6,$2,2271
subu $6,$1,$3
xor $4,$6,$2
sec62:
slti $2,$3,-28608
ori $6,$2,59414
lui $6,2770
xor $2,$6,$2
sec63:
xori $2,$2,26183
lui $6,45340
mfhi $6
xor $6,$6,$2
sec64:
slti $2,$5,2112
slti $6,$2,-14437
lbu $6,3($0)
xor $3,$6,$2
sec65:
lui $2,28596
mflo $6
nop
xor $3,$6,$2
sec66:
addiu $2,$4,28467
mflo $6
addu $6,$1,$2
xor $1,$6,$2
sec67:
addiu $2,$2,-30606
mfhi $6
addiu $6,$3,12103
xor $2,$6,$2
sec68:
andi $2,$5,15340
mflo $6
mfhi $6
xor $5,$6,$2
sec69:
andi $2,$2,43074
mfhi $6
lb $6,3($0)
xor $1,$6,$2
sec70:
slti $2,$4,7870
lbu $6,6($0)
nop
xor $4,$6,$2
sec71:
ori $2,$3,64235
lb $6,7($0)
subu $6,$3,$4
xor $6,$6,$2
sec72:
xori $2,$0,58092
lhu $6,2($0)
ori $6,$0,35277
xor $1,$6,$2
sec73:
lui $2,57017
lhu $6,6($0)
mflo $6
xor $4,$6,$2
sec74:
sltiu $2,$5,-31407
lb $6,14($0)
lh $6,10($0)
xor $2,$6,$2
sec75:
mfhi $2
nop
nop
xor $3,$6,$2
sec76:
mflo $2
nop
sltu $6,$1,$3
xor $1,$6,$2
sec77:
mfhi $2
nop
ori $6,$3,30962
xor $2,$6,$2
sec78:
mfhi $2
nop
mflo $6
xor $3,$6,$2
sec79:
mfhi $2
nop
lhu $6,16($0)
xor $4,$6,$2
sec80:
mflo $2
nor $6,$1,$3
nop
xor $4,$6,$2
sec81:
mflo $2
and $6,$5,$6
xor $6,$5,$2
xor $5,$6,$2
sec82:
mflo $2
subu $6,$4,$2
addiu $6,$2,-23500
xor $6,$6,$2
sec83:
mfhi $2
or $6,$4,$2
mflo $6
xor $3,$6,$2
sec84:
mflo $2
and $6,$4,$3
lb $6,9($0)
xor $2,$6,$2
sec85:
mflo $2
sltiu $6,$2,31560
nop
xor $3,$6,$2
sec86:
mflo $2
slti $6,$3,14106
subu $6,$4,$5
xor $1,$6,$2
sec87:
mfhi $2
andi $6,$3,62493
slti $6,$6,-21190
xor $4,$6,$2
sec88:
mfhi $2
addiu $6,$1,-19836
mflo $6
xor $5,$6,$2
sec89:
mflo $2
addiu $6,$2,-27741
lw $6,0($0)
xor $1,$6,$2
sec90:
mflo $2
mflo $6
nop
xor $1,$6,$2
sec91:
mfhi $2
mflo $6
sltu $6,$1,$4
xor $3,$6,$2
sec92:
mflo $2
mflo $6
xori $6,$3,57126
xor $6,$6,$2
sec93:
mflo $2
mflo $6
mfhi $6
xor $4,$6,$2
sec94:
mflo $2
mfhi $6
lbu $6,6($0)
xor $3,$6,$2
sec95:
mfhi $2
lbu $6,14($0)
nop
xor $3,$6,$2
sec96:
mfhi $2
lbu $6,13($0)
slt $6,$5,$2
xor $5,$6,$2
sec97:
mflo $2
lhu $6,8($0)
sltiu $6,$0,-13635
xor $3,$6,$2
sec98:
mfhi $2
lbu $6,16($0)
mflo $6
xor $0,$6,$2
sec99:
mflo $2
lb $6,12($0)
lw $6,0($0)
xor $6,$6,$2
sec100:
lw $2,8($0)
nop
nop
xor $5,$6,$2
sec101:
lw $2,4($0)
nop
slt $6,$3,$1
xor $0,$6,$2
sec102:
lhu $2,4($0)
nop
slti $6,$4,-30446
xor $3,$6,$2
sec103:
lh $2,2($0)
nop
mflo $6
xor $2,$6,$2
sec104:
lh $2,16($0)
nop
lb $6,5($0)
xor $4,$6,$2
sec105:
lbu $2,5($0)
nor $6,$4,$5
nop
xor $5,$6,$2
sec106:
lh $2,8($0)
and $6,$3,$1
and $6,$2,$3
xor $2,$6,$2
sec107:
lb $2,15($0)
or $6,$4,$1
xori $6,$3,14522
xor $0,$6,$2
sec108:
lbu $2,3($0)
xor $6,$1,$4
mflo $6
xor $4,$6,$2
sec109:
lb $2,6($0)
and $6,$4,$0
lh $6,0($0)
xor $4,$6,$2
sec110:
lh $2,16($0)
addiu $6,$0,-13432
nop
xor $5,$6,$2
sec111:
lbu $2,12($0)
ori $6,$1,35688
addu $6,$0,$4
xor $3,$6,$2
sec112:
lw $2,12($0)
ori $6,$3,27995
andi $6,$3,17614
xor $2,$6,$2
sec113:
lhu $2,16($0)
slti $6,$0,-18097
mflo $6
xor $3,$6,$2
sec114:
lb $2,8($0)
lui $6,59039
lhu $6,14($0)
xor $3,$6,$2
sec115:
lb $2,1($0)
mflo $6
nop
xor $2,$6,$2
sec116:
lw $2,0($0)
mflo $6
and $6,$2,$4
xor $5,$6,$2
sec117:
lhu $2,12($0)
mfhi $6
sltiu $6,$2,-29220
xor $4,$6,$2
sec118:
lbu $2,2($0)
mflo $6
mflo $6
xor $3,$6,$2
sec119:
lhu $2,12($0)
mflo $6
lh $6,2($0)
xor $3,$6,$2
sec120:
lbu $2,1($0)
lh $6,8($0)
nop
xor $4,$6,$2
sec121:
lh $2,12($0)
lhu $6,6($0)
xor $6,$2,$3
xor $6,$6,$2
sec122:
lh $2,16($0)
lw $6,0($0)
ori $6,$4,46164
xor $4,$6,$2
sec123:
lbu $2,10($0)
lhu $6,8($0)
mfhi $6
xor $1,$6,$2
sec124:
lbu $2,5($0)
lh $6,8($0)
lh $6,16($0)
xor $5,$6,$2
|
ada/original_2008/ada-gui/agar-gui-widget-scrollbar.adb | auzkok/libagar | 286 | 7020 | package body agar.gui.widget.scrollbar is
use type c.int;
package cbinds is
procedure set_size
(scrollbar : scrollbar_access_t;
size : c.int);
pragma import (c, set_size, "agar_gui_widget_scrollbar_set_size");
function get_size (scrollbar : scrollbar_access_t) return c.int;
pragma import (c, get_size, "agar_gui_widget_scrollbar_get_size");
function visible (scrollbar : scrollbar_access_t) return c.int;
pragma import (c, visible, "AG_ScrollbarVisible");
procedure set_int_increment
(scrollbar : scrollbar_access_t;
increment : c.int);
pragma import (c, set_int_increment, "AG_ScrollbarSetIntIncrement");
procedure set_real_increment
(scrollbar : scrollbar_access_t;
increment : c.double);
pragma import (c, set_real_increment, "AG_ScrollbarSetRealIncrement");
end cbinds;
procedure set_size
(scrollbar : scrollbar_access_t;
size : natural) is
begin
cbinds.set_size
(scrollbar => scrollbar,
size => c.int (size));
end set_size;
function get_size (scrollbar : scrollbar_access_t) return natural is
begin
return natural (cbinds.get_size (scrollbar));
end get_size;
function visible (scrollbar : scrollbar_access_t) return boolean is
begin
return cbinds.visible (scrollbar) = 1;
end visible;
procedure set_increment
(scrollbar : scrollbar_access_t;
increment : positive) is
begin
cbinds.set_int_increment
(scrollbar => scrollbar,
increment => c.int (increment));
end set_increment;
procedure set_increment
(scrollbar : scrollbar_access_t;
increment : long_float) is
begin
cbinds.set_real_increment
(scrollbar => scrollbar,
increment => c.double (increment));
end set_increment;
function widget (scrollbar : scrollbar_access_t) return widget_access_t is
begin
return scrollbar.widget'access;
end widget;
end agar.gui.widget.scrollbar;
|
tools/scitools/conf/understand/ada/ada05/a-exctra.ads | brucegua/moocos | 1 | 18841 | <gh_stars>1-10
------------------------------------------------------------------------------
-- --
-- GNAT RUN-TIME COMPONENTS --
-- --
-- A D A . E X C E P T I O N S . T R A C E B A C K --
-- --
-- S p e c --
-- --
-- Copyright (C) 1999-2005, Free Software Foundation, Inc. --
-- --
-- This specification is derived from the Ada Reference Manual for use with --
-- GNAT. The copyright notice above, and the license provisions that follow --
-- apply solely to the contents of the part following the private keyword. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
-- ware Foundation; either version 2, or (at your option) any later ver- --
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT 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 distributed with GNAT; see file COPYING. If not, write --
-- to the Free Software Foundation, 51 Franklin Street, Fifth Floor, --
-- Boston, MA 02110-1301, USA. --
-- --
--
--
--
--
--
--
--
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
-- This package is part of the support for tracebacks on exceptions
with System.Traceback_Entries;
package Ada.Exceptions.Traceback is
package TBE renames System.Traceback_Entries;
subtype Code_Loc is System.Address;
-- Code location in executing program
type Tracebacks_Array is array (Positive range <>) of TBE.Traceback_Entry;
-- A traceback array is an array of traceback entries
function Tracebacks (E : Exception_Occurrence) return Tracebacks_Array;
-- This function extracts the traceback information from an exception
-- occurrence, and returns it formatted in the manner required for
-- processing in GNAT.Traceback. See g-traceb.ads for further details.
end Ada.Exceptions.Traceback;
|
test/asset/agda-stdlib-1.0/Relation/Binary/Reasoning/PartialOrder.agda | omega12345/agda-mode | 5 | 541 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Convenient syntax for "equational reasoning" using a partial order
------------------------------------------------------------------------
-- Example uses:
--
-- u≤x : u ≤ x
-- u≤x = begin
-- u ≈⟨ u≈v ⟩
-- v ≡⟨ v≡w ⟩
-- w <⟨ w≤x ⟩
-- x ∎
--
-- u<x : u < x
-- u<x = begin-strict
-- u ≈⟨ u≈v ⟩
-- v ≡⟨ v≡w ⟩
-- w <⟨ w≤x ⟩
-- x ∎
--
-- u<e : u < e
-- u<e = begin-strict
-- u ≈⟨ u≈v ⟩
-- v ≡⟨ v≡w ⟩
-- w <⟨ w<x ⟩
-- x ≤⟨ x≤y ⟩
-- y <⟨ y<z ⟩
-- z ≡˘⟨ d≡z ⟩
-- d ≈˘⟨ e≈d ⟩
-- e ∎
--
-- u≈w : u ≈ w
-- u≈w = begin-equality
-- u ≈⟨ u≈v ⟩
-- v ≡⟨ v≡w ⟩
-- w ∎
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary
module Relation.Binary.Reasoning.PartialOrder
{p₁ p₂ p₃} (P : Poset p₁ p₂ p₃) where
open Poset P
import Relation.Binary.Construct.NonStrictToStrict _≈_ _≤_ as Strict
------------------------------------------------------------------------
-- Re-export contents of base module
open import Relation.Binary.Reasoning.Base.Triple
isPreorder
(Strict.trans isPartialOrder)
(Strict.<-resp-≈ isEquivalence ≤-resp-≈)
Strict.<⇒≤
(Strict.<-≤-trans Eq.sym trans antisym ≤-respʳ-≈)
(Strict.≤-<-trans trans antisym ≤-respˡ-≈)
public
------------------------------------------------------------------------
-- DEPRECATED NAMES
------------------------------------------------------------------------
-- Please use the new names as continuing support for the old names is
-- not guaranteed.
-- Version 1.0
infixr 2 _≈⟨⟩_
_≈⟨⟩_ = _≡⟨⟩_
{-# WARNING_ON_USAGE _≈⟨⟩_
"Warning: _≈⟨⟩_ was deprecated in v1.0.
Please use _≡⟨⟩_ instead."
#-}
|
base/mvdm/dos/v86/cmd/edlin/edlequ.asm | npocmaka/Windows-Server-2003 | 17 | 18187 | page 60,132 ;
;/*
; * Microsoft Confidential
; * Copyright (C) Microsoft Corporation 1991
; * All Rights Reserved.
; */
.xlist
include version.inc
include DOSSYM.INC
include EDLSTDSW.INC
.list
;======================= START OF SPECIFICATIONS =========================
;
; MODULE NAME: EDLEQU.SAL
;
; DESCRIPTIVE NAME: EQUATES FOR EDLIN
;
; FUNCTION: PROVIDES EQUATES FOR EDLIN. IT ALSO PROVIDES THE MACRO
; VAL_YN.
;
; ENTRY POINT: NA
;
; INPUT: NA
;
; EXIT NORMAL: NA
;
; EXIT ERROR: NA
;
; INTERNAL REFERENCES:
;
; ROUTINE: VAL_YN - VALIDATES Y/N RESPONSES FROM THE KEYBOARD
;
; EXTERNAL REFERENCES:
;
; ROUTINE: NA
;
; NOTES: THIS MODULE IS TO BE PREPPED BY SALUT WITH THE "PR" OPTIONS.
; LINK EDLIN+EDLCMD1+EDLCMD2+EDLMES+EDLPARSE
;
; REVISION HISTORY:
;
; AN000 VERSION 4.00 - REVISIONS MADE RELATE TO THE FOLLOWING:
;
; - IMPLEMENT SYSPARSE
; - IMPLEMENT MESSAGE RETRIEVER
; - IMPLEMENT DBCS ENABLING
; - ENHANCED VIDEO SUPPORT
; - EXTENDED OPENS
; - SCROLLING ERROR
;
; COPYRIGHT: "MS DOS EDLIN UTILITY"
; "VERSION 4.00 (C) COPYRIGHT 1988 Microsoft"
;
;======================= END OF SPECIFICATIONS ===========================
COMAND_LINE_LENGTH EQU 128
QUOTE_CHAR EQU 16H ;Quote character = ^V
CR EQU 13
STKSIZ EQU 200h
STACK equ stksiz
asian_blk equ DB_SP_LO ;an000;asian blank 2nd. byte
dbcs_lead_byte equ DB_SP_HI ;an000;asian blank lead byte
nul equ 00h ;an000;nul character
Access_Denied equ 0005h ;an000;extended error code for access denied
;======== Y/N validation equates =========================================
yn_chk equ 23h ;an000;check for Y/N response
max_len equ 01h ;an000;max. len. for Y/N char.
yes equ 01h ;an000;boolean yes value
no equ 00h ;an000;boolean no value
;======== text display values for initialization =========================
video_get equ 0fh ;an000;int 10 get video attributes
video_set equ 00h ;an000;int 10 set video attributes
video_text equ 03h ;an000;80 X 25 color monitor
;======== code page values for functions =================================
get_set_cp equ 66h ;an000;get or set code page
get_cp equ 01h ;an000;get active code page
set_cp equ 02h ;an000;set active code page
;======== screen length & width defaults =================================
std_out equ 01h ;an000;console output
display_attr equ 03h ;an000;display for IOCTL
Get_Display equ 7fh ;an000;Get display for IOCTL
ifndef JAPAN
Def_Disp_Len equ 25 ;an000;default display length
else ; if JAPAN
Def_Disp_Len equ 24
endif
Def_Disp_Width equ 80 ;an000;default display width
;======== extended open equates ==========================================
rw equ 0082h ;an000;read/write
; compatibility
; noinherit
; int 24h handler
; no commit
ext_read equ 0080h ;an000;read
; compatibility
; noinherit
; int 24h handler
; no commit
rw_flag equ 0101h ;an000;fail if file not exist
; open if file exists
; don't validate code page
creat_flag equ 0110h ;an000;create if file does not exist
; fail if file exists
; don't validate code page
open_flag equ 0101h ;an000;fail if file not exist
; open if file exists
; don't validate code page
creat_open_flag equ 0112h ;an000;create if file does not exist
; open/replace if file exists
; don't validate code page
attr equ 00h ;an000;attributes set to 0
;======== parse value equates ============================================
nrm_parse_exit equ 0ffffh ;an000;normal exit from sysparse
too_many equ 01h ;an000;too many parms entered
op_missing equ 02h ;an000;required operand missing
sw_missing equ 03h ;an000;not a valid switch
;======== Strucs =========================================================
Display_Buffer_Struc Struc ;an000;dms;
Display_Info_Level db ? ;an000;dms;
Display_Reserved db ? ;an000;dms;
Display_Buffer_Size dw ? ;an000;dms;
Display_Flags dw ? ;an000;dms;
Display_Mode db ? ;an000;dms;
; TEXT=01
; APA =02
Display_Mode_Reserved db ? ;an000;dms;
Display_Colors dw ? ;an000;dms;# of colors
Display_Width_Pixels dw ? ;an000;dms;# of pixels in width
Display_Length_Pixels dw ? ;an000;dms;# of pixels in len.
Display_Width_Char dw ? ;an000;dms;# of chars in width
Display_Length_Char dw ? ;an000;dms;# of chars in length
Display_Buffer_Struc ends ;an000;dms;
|
fiat-amd64/67.75_ratio11130_seed3548740702652650_mul_curve25519.asm | dderjoel/fiat-crypto | 491 | 102514 | <reponame>dderjoel/fiat-crypto
SECTION .text
GLOBAL mul_curve25519
mul_curve25519:
sub rsp, 0x48 ; last 0x30 (6) for Caller - save regs
mov [ rsp + 0x18 ], rbx; saving to stack
mov [ rsp + 0x20 ], rbp; saving to stack
mov [ rsp + 0x28 ], r12; saving to stack
mov [ rsp + 0x30 ], r13; saving to stack
mov [ rsp + 0x38 ], r14; saving to stack
mov [ rsp + 0x40 ], r15; saving to stack
mov rax, rdx; preserving value of arg2 into a new reg
mov rdx, [ rsi + 0x0 ]; saving arg1[0] in rdx.
mulx r10, r11, [ rax + 0x0 ]; x50, x49<- arg1[0] * arg2[0]
imul rbx, [ rax + 0x8 ], 0x13; x10003 <- arg2[1] * 0x13
imul rbp, [ rax + 0x10 ], 0x13; x10002 <- arg2[2] * 0x13
imul r12, [ rax + 0x20 ], 0x13; x10000 <- arg2[4] * 0x13
imul r13, [ rax + 0x18 ], 0x13; x10001 <- arg2[3] * 0x13
mov rdx, rbx; x10003 to rdx
mulx rdx, rbx, [ rsi + 0x20 ]; x8, x7<- arg1[4] * x10003
xchg rdx, rbp; x10002, swapping with x8, which is currently in rdx
mulx r14, r15, [ rsi + 0x18 ]; x14, x13<- arg1[3] * x10002
test al, al
adox rbx, r15
mov rcx, rdx; preserving value of x10002 into a new reg
mov rdx, [ rsi + 0x10 ]; saving arg1[2] in rdx.
mulx r8, r9, r13; x18, x17<- arg1[2] * x10001
mov rdx, [ rsi + 0x8 ]; arg1[1] to rdx
mov [ rsp + 0x0 ], rdi; spilling out1 to mem
mulx r15, rdi, r12; x20, x19<- arg1[1] * x10000
adcx rbx, r9
adox r14, rbp
mov rbp, -0x2 ; moving imm to reg
inc rbp; OF<-0x0, preserve CF (debug: 6; load -2, increase it, save as -1)
adox rbx, rdi
adcx r8, r14
clc;
adcx rbx, r11
adox r15, r8
mov rdx, [ rax + 0x0 ]; arg2[0] to rdx
mulx r11, r9, [ rsi + 0x8 ]; x40, x39<- arg1[1] * arg2[0]
adcx r10, r15
mov rdx, rcx; x10002 to rdx
mulx rdx, rcx, [ rsi + 0x20 ]; x6, x5<- arg1[4] * x10002
mov rdi, rdx; preserving value of x6 into a new reg
mov rdx, [ rax + 0x8 ]; saving arg2[1] in rdx.
mulx r14, r8, [ rsi + 0x0 ]; x48, x47<- arg1[0] * arg2[1]
mov r15, rbx; x67, copying x63 here, cause x63 is needed in a reg for other than x67, namely all: , x68, x67, size: 2
shrd r15, r10, 51; x67 <- x65||x63 >> 51
mov rdx, [ rsi + 0x18 ]; arg1[3] to rdx
mulx r10, rbp, r13; x12, x11<- arg1[3] * x10001
test al, al
adox rcx, rbp
adox r10, rdi
mov rdx, [ rsi + 0x10 ]; arg1[2] to rdx
mulx rdi, rbp, r12; x16, x15<- arg1[2] * x10000
adcx rcx, rbp
mov rbp, -0x2 ; moving imm to reg
inc rbp; OF<-0x0, preserve CF (debug: 6; load -2, increase it, save as -1)
adox rcx, r9
adcx rdi, r10
adox r11, rdi
mov rdx, [ rsi + 0x18 ]; arg1[3] to rdx
mulx r9, r10, r12; x10, x9<- arg1[3] * x10000
add rcx, r8; could be done better, if r0 has been u8 as well
adcx r14, r11
test al, al
adox rcx, r15
mov rdx, [ rsi + 0x20 ]; arg1[4] to rdx
mulx r13, r8, r13; x4, x3<- arg1[4] * x10001
mov r15, 0x0 ; moving imm to reg
adox r14, r15
mov rdx, [ rax + 0x0 ]; arg2[0] to rdx
mulx rdi, r11, [ rsi + 0x10 ]; x32, x31<- arg1[2] * arg2[0]
adcx r8, r10
adcx r9, r13
mov r10, rcx; x136, copying x133 here, cause x133 is needed in a reg for other than x136, namely all: , x136, x137, size: 2
shrd r10, r14, 51; x136 <- x135||x133 >> 51
mov rdx, [ rax + 0x8 ]; arg2[1] to rdx
mulx r13, r14, [ rsi + 0x8 ]; x38, x37<- arg1[1] * arg2[1]
xor rbp, rbp
adox r8, r11
adox rdi, r9
adcx r8, r14
mov rdx, [ rax + 0x10 ]; arg2[2] to rdx
mulx r15, r11, [ rsi + 0x0 ]; x46, x45<- arg1[0] * arg2[2]
mov rdx, [ rsi + 0x0 ]; arg1[0] to rdx
mulx r9, r14, [ rax + 0x18 ]; x44, x43<- arg1[0] * arg2[3]
mov [ rsp + 0x8 ], r9; spilling x44 to mem
mov r9, -0x3 ; moving imm to reg
inc r9; OF<-0x0, preserve CF (debug 7; load -3, increase it, save it as -2). #last resort
adox r8, r11
mov rdx, [ rsi + 0x20 ]; arg1[4] to rdx
mulx r12, r11, r12; x2, x1<- arg1[4] * x10000
adcx r13, rdi
adox r15, r13
mov rdx, [ rax + 0x0 ]; arg2[0] to rdx
mulx rdi, r13, [ rsi + 0x18 ]; x26, x25<- arg1[3] * arg2[0]
xor r9, r9
adox r8, r10
adox r15, r9
mov rdx, [ rax + 0x8 ]; arg2[1] to rdx
mulx rbp, r10, [ rsi + 0x10 ]; x30, x29<- arg1[2] * arg2[1]
mov r9, r8; x141, copying x138 here, cause x138 is needed in a reg for other than x141, namely all: , x141, x142, size: 2
shrd r9, r15, 51; x141 <- x140||x138 >> 51
add r11, r13; could be done better, if r0 has been u8 as well
adcx rdi, r12
add r11, r10; could be done better, if r0 has been u8 as well
mov rdx, [ rax + 0x10 ]; arg2[2] to rdx
mulx r12, r13, [ rsi + 0x8 ]; x36, x35<- arg1[1] * arg2[2]
adcx rbp, rdi
xor r15, r15
adox r11, r13
adox r12, rbp
mov rdx, [ rax + 0x18 ]; arg2[3] to rdx
mulx r10, rdi, [ rsi + 0x8 ]; x34, x33<- arg1[1] * arg2[3]
mov rdx, [ rax + 0x20 ]; arg2[4] to rdx
mulx rdx, r13, [ rsi + 0x0 ]; x42, x41<- arg1[0] * arg2[4]
adcx r11, r14
mov r14, -0x3 ; moving imm to reg
inc r14; OF<-0x0, preserve CF (debug 7; load -3, increase it, save it as -2). #last resort
adox r11, r9
mov r9, rdx; preserving value of x42 into a new reg
mov rdx, [ rax + 0x0 ]; saving arg2[0] in rdx.
mulx rbp, r15, [ rsi + 0x20 ]; x22, x21<- arg1[4] * arg2[0]
adcx r12, [ rsp + 0x8 ]
mov rdx, [ rsi + 0x18 ]; arg1[3] to rdx
mov [ rsp + 0x10 ], rbx; spilling x63 to mem
mulx r14, rbx, [ rax + 0x8 ]; x24, x23<- arg1[3] * arg2[1]
clc;
adcx r15, rbx
adcx r14, rbp
mov rbp, 0x0 ; moving imm to reg
adox r12, rbp
mov rdx, [ rsi + 0x10 ]; arg1[2] to rdx
mulx rbx, rbp, [ rax + 0x10 ]; x28, x27<- arg1[2] * arg2[2]
add r15, rbp; could be done better, if r0 has been u8 as well
adcx rbx, r14
xor r14, r14
adox r15, rdi
adox r10, rbx
mov rdi, r11; x146, copying x143 here, cause x143 is needed in a reg for other than x146, namely all: , x147, x146, size: 2
shrd rdi, r12, 51; x146 <- x145||x143 >> 51
xor r12, r12
adox r15, r13
adox r9, r10
adcx r15, rdi
adc r9, 0x0
mov r14, 0x7ffffffffffff ; moving imm to reg
and r8, r14; x142 <- x138&0x7ffffffffffff
mov r13, [ rsp + 0x10 ]; x68, copying x63 here, cause x63 is needed in a reg for other than x68, namely all: , x68, size: 1
and r13, r14; x68 <- x63&0x7ffffffffffff
mov rbp, r15; x152, copying x148 here, cause x148 is needed in a reg for other than x152, namely all: , x151, x152, size: 2
and rbp, r14; x152 <- x148&0x7ffffffffffff
shrd r15, r9, 51; x151 <- x150||x148 >> 51
imul r15, r15, 0x13; x153 <- x151 * 0x13
mov rbx, 0x33 ; moving imm to reg
bzhi rcx, rcx, rbx; x137 <- x133 (only least 0x33 bits)
mov r10, [ rsp + 0x0 ]; load m64 out1 to register64
mov [ r10 + 0x20 ], rbp; out1[4] = x152
lea r13, [ r13 + r15 ]
mov rdi, r13; x155, copying x154 here, cause x154 is needed in a reg for other than x155, namely all: , x156, x155, size: 2
shr rdi, 51; x155 <- x154>> 51
lea rdi, [ rdi + rcx ]
bzhi r13, r13, rbx; x156 <- x154 (only least 0x33 bits)
mov r9, rdi; x158, copying x157 here, cause x157 is needed in a reg for other than x158, namely all: , x158, x159, size: 2
shr r9, 51; x158 <- x157>> 51
mov [ r10 + 0x0 ], r13; out1[0] = x156
bzhi r11, r11, rbx; x147 <- x143 (only least 0x33 bits)
lea r9, [ r9 + r8 ]
bzhi rdi, rdi, rbx; x159 <- x157 (only least 0x33 bits)
mov [ r10 + 0x10 ], r9; out1[2] = x160
mov [ r10 + 0x18 ], r11; out1[3] = x147
mov [ r10 + 0x8 ], rdi; out1[1] = x159
mov rbx, [ rsp + 0x18 ]; restoring from stack
mov rbp, [ rsp + 0x20 ]; restoring from stack
mov r12, [ rsp + 0x28 ]; restoring from stack
mov r13, [ rsp + 0x30 ]; restoring from stack
mov r14, [ rsp + 0x38 ]; restoring from stack
mov r15, [ rsp + 0x40 ]; restoring from stack
add rsp, 0x48
ret
; cpu AMD Ryzen Threadripper 1900X 8-Core Processor
; clocked at 3000 MHz
; first cyclecount 91.2, best 66.86821705426357, lastGood 67.75193798449612
; seed 3548740702652650
; CC / CFLAGS clang / -march=native -mtune=native -O3
; time needed: 858457 ms / 60000 runs=> 14.307616666666666ms/run
; Time spent for assembling and measureing (initial batch_size=126, initial num_batches=101): 352412 ms
; Ratio (time for assembling + measure)/(total runtime for 60000runs): 0.41051794091026106
; number reverted permutation/ tried permutation: 25193 / 30093 =83.717%
; number reverted decision/ tried decision: 19539 / 29908 =65.330% |
alloy4fun_models/trashltl/models/9/kJ8JRptcLyXTnfFA5.als | Kaixi26/org.alloytools.alloy | 0 | 1580 | open main
pred idkJ8JRptcLyXTnfFA5_prop10 {
always all f:Protected | always f in Protected
}
pred __repair { idkJ8JRptcLyXTnfFA5_prop10 }
check __repair { idkJ8JRptcLyXTnfFA5_prop10 <=> prop10o } |
same-origin-policy/src/model/analysis.als | cfbolz/500lines | 2 | 2516 | <filename>same-origin-policy/src/model/analysis.als
/**
* analysis.als
* End-to-end analysis of security properties
*/
module analysis
open flow
// General security properties
sig TrustedModule, MaliciousModule in DataflowModule {}
sig CriticalData, MaliciousData in Data {}
// No malicious module should be able to access private data
assert Confidentiality {
no m: DataflowModule - TrustedModule, t: Time |
some CriticalData & m.accesses.t
}
// No malicious data should ever flow into a trusted module
assert Integrity {
no u: TrustedModule, t: Time |
some MaliciousData & u.accesses.t
}
fact {
-- no malicious module begins with critical data
no m: MaliciousModule | some CriticalData & m.accesses.init
-- no trusted module begins with malicious data
no m: TrustedModule | some MaliciousData & m.accesses.init
-- no module is both trusted and malicious
no TrustedModule & MaliciousModule
-- every module is either trusted or malicious
DataflowModule = TrustedModule + MaliciousModule
-- no data is both critical and malicious
no CriticalData & MaliciousData
}
check Confidentiality for 3
check Integrity for 3
|
twap-parser/src/main/antlr/by/overpass/twap/parser/Twine.g4 | overpas/twine-plugin | 0 | 3674 | <filename>twap-parser/src/main/antlr/by/overpass/twap/parser/Twine.g4<gh_stars>0
grammar Twine;
@header{
package by.overpass.twap.parser;
}
twine
:
section+
;
section
:
section_title label+
;
section_title
:
'[[' identifier ']]'
;
label
:
label_title translation+ comment?
;
label_title
:
'[' identifier ']'
;
identifier
:
ID
;
translation
:
LOCALE TEXT
;
comment
:
COMMENT TEXT
;
COMMENT : 'comment' ;
LOCALE : [a-zA-Z][a-zA-Z] ;
ID : [a-zA-Z0-9_]+('.'[a-zA-Z0-9_]+)* ;
WS : [ \r\t\n]+ -> channel(HIDDEN) ;
TEXT: '='' '*.*?('\n'|EOF) ; |
modules/core/1bpp - Generate Table 2.asm | vladikcomper/md-modules | 9 | 23614 |
; ===============================================================
; ---------------------------------------------------------------
; Subroutine to generate 1bpp decode table
; ---------------------------------------------------------------
; INPUT:
; a1 Address for the generated table
; d4 .w Pixel index for bit #0
; d5 .w Pixel indec for bit #1
;
; USES:
; d0-d7
; ---------------------------------------------------------------
Generate1bppDecodeTable:
lsl.w #5, d5
lea @BaseDecodeTable(pc, d5.w), a2
lsl.w #5, d4
beq.s @DirectTransfer
lea @BaseDecodeTable(pc, d4.w), a3
movem.l (a2)+, d0-d3
movem.l $10(a3), d4-d7
swap d7
or.l d7, d0
swap d6
or.l d6, d1
swap d5
or.l d5, d2
swap d4
or.l d4, d3
movem.l d0-d3, (a0)
movem.l (a2)+, d0-d3
movem.l (a3), d4-d7
swap d7
or.l d7, d0
swap d6
or.l d6, d1
swap d5
or.l d5, d2
swap d4
or.l d4, d3
movem.l d0-d3, $10(a0)
rts
; ---------------------------------------------------------------
@DirectTransfer:
movem.l (a2), d0-d7
movem.l d0-d7, (a0)
rts
; ---------------------------------------------------------------
@BaseDecodeTable:
dc.w $0000, $0000, $0000, $0000, $0000, $0000, $0000, $0000, $0000, $0000, $0000, $0000, $0000, $0000, $0000, $0000
dc.w $0000, $0001, $0010, $0011, $0100, $0101, $0110, $0111, $1000, $1001, $1010, $1011, $1100, $1101, $1110, $1111
dc.w $0000, $0002, $0020, $0022, $0200, $0202, $0220, $0222, $2000, $2002, $2020, $2022, $2200, $2202, $2220, $2222
dc.w $0000, $0003, $0030, $0033, $0300, $0303, $0330, $0333, $3000, $3003, $3030, $3033, $3300, $3303, $3330, $3333
dc.w $0000, $0004, $0040, $0044, $0400, $0404, $0440, $0444, $4000, $4004, $4040, $4044, $4400, $4404, $4440, $4444
dc.w $0000, $0005, $0050, $0055, $0500, $0505, $0550, $0555, $5000, $5005, $5050, $5055, $5500, $5505, $5550, $5555
dc.w $0000, $0006, $0060, $0066, $0600, $0606, $0660, $0666, $6000, $6006, $6060, $6066, $6600, $6606, $6660, $6666
dc.w $0000, $0007, $0070, $0077, $0700, $0707, $0770, $0777, $7000, $7007, $7070, $7077, $7700, $7707, $7770, $7777
dc.w $0000, $0008, $0080, $0088, $0800, $0808, $0880, $0888, $8000, $8008, $8080, $8088, $8800, $8808, $8880, $8888
dc.w $0000, $0009, $0090, $0099, $0900, $0909, $0990, $0999, $9000, $9009, $9090, $9099, $9900, $9909, $9990, $9999
dc.w $0000, $000A, $00A0, $00AA, $0A00, $0A0A, $0AA0, $0AAA, $A000, $A00A, $A0A0, $A0AA, $AA00, $AA0A, $AAA0, $AAAA
dc.w $0000, $000B, $00B0, $00BB, $0B00, $0B0B, $0BB0, $0BBB, $B000, $B00B, $B0B0, $B0BB, $BB00, $BB0B, $BBB0, $BBBB
dc.w $0000, $000C, $00C0, $00CC, $0C00, $0C0C, $0CC0, $0CCC, $C000, $C00C, $C0C0, $C0CC, $CC00, $CC0C, $CCC0, $CCCC
dc.w $0000, $000D, $00D0, $00DD, $0D00, $0D0D, $0DD0, $0DDD, $D000, $D00D, $D0D0, $D0DD, $DD00, $DD0D, $DDD0, $DDDD
dc.w $0000, $000E, $00E0, $00EE, $0E00, $0E0E, $0EE0, $0EEE, $E000, $E00E, $E0E0, $E0EE, $EE00, $EE0E, $EEE0, $EEEE
dc.w $0000, $000F, $00F0, $00FF, $0F00, $0F0F, $0FF0, $0FFF, $F000, $F00F, $F0F0, $F0FF, $FF00, $FF0F, $FFF0, $FFFF
|
libsrc/stdio/ansi/bee/f_ansi_scrollup.asm | jpoikela/z88dk | 640 | 101501 | ;
; ANSI Video handling for the the MicroBEE
;
; <NAME> - 2016
;
; Handles colors referring to current PAPER/INK/etc. settings
;
; Scrollup
;
;
; $Id: f_ansi_scrollup.asm,v 1.2 2016-11-17 09:39:03 stefano Exp $
;
SECTION code_clib
PUBLIC ansi_SCROLLUP
EXTERN generic_console_scrollup
defc ansi_SCROLLUP = generic_console_scrollup
|
code/src/main/antlr/bad.g4 | marcpawl/gradleantlrbug | 0 | 5972 | <reponame>marcpawl/gradleantlrbug<filename>code/src/main/antlr/bad.g4<gh_stars>0
something that should cause an antlr failure
|
boot/stage2/GDT.asm | arushsharma24/KSOS | 87 | 91541 | ;GDT part
;global gdt_descriptor
null_segment:
dd 0
dd 0
code_segment:
dw 0xffff ;limit
dw 0 ;starting address
db 0
db 10011010b ;present|privilage 0|S=codedata or traps|1=code|0=not conforming|Readable|Accessed (some debug)
db 11001111b ;Granularity|32 bit code|is64?|Userbit|segment limit 4 more bits
db 0
data_segment:
dw 0xffff ;limit
dw 0 ;starting address
db 0
db 10010010b ;present|privilage 00|S=codedata or traps|1=code|0=not conforming|Readable|Accessed (some debug)
db 11001111b ;Granularity|32 bit code|is64?|Userbit|segment limit 4 more bits
db 0
GDT_end:
gdt_descriptor: ;16 bit size | 32 bit starting address
dw null_segment - GDT_end -1
dd null_segment; + 0x7c00 I did this when I was doing bakchodi
|
Driver/Printer/PrintCom/Color/Correct/correctLexTran.asm | steakknife/pcgeos | 504 | 95657 | COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Copyright (c) GeoWorks 1992 -- All Rights Reserved
PROJECT: PC GEOS
MODULE: Printer Drivers
FILE: correctLexTran.asm
AUTHOR: <NAME>, April 26 1995
REVISION HISTORY:
Name Date Description
---- ---- -----------
Dave 04/26/95 Initial revision
DESCRIPTION:
Color correction table generated for Lexmark CMY inks on transparancies
$Id: correctLexTran.asm,v 1.1 97/04/18 11:51:37 newdeal Exp $
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
CorrectLexTranInk segment resource
lexTranInkCorrection label ColorTransfer
; R G B
;RED = 00
byte 0x30, 0x00, 0x00 ; 0x00 0x00 0x00
byte 0x30, 0x60, 0xa0 ; 0x00 0x00 0x40
byte 0x40, 0x90, 0x3f ; 0x00 0x00 0x80
byte 0x50, 0x90, 0x3f ; 0x00 0x00 0xc0
byte 0x60, 0xa0, 0x00 ; 0x00 0x00 0xff
byte 0x40, 0x80, 0x40 ; 0x00 0x40 0x00
byte 0x20, 0xa0, 0x90 ; 0x00 0x40 0x40
byte 0x30, 0x90, 0x60 ; 0x00 0x40 0x80
byte 0x40, 0xa0, 0x3f ; 0x00 0x40 0xc0
byte 0x70, 0x70, 0x00 ; 0x00 0x40 0xff
byte 0x60, 0x70, 0x60 ; 0x00 0x80 0x00
byte 0x50, 0x7f, 0x90 ; 0x00 0x80 0x40
byte 0x40, 0x70, 0x60 ; 0x00 0x80 0x80
byte 0x50, 0x70, 0x3f ; 0x00 0x80 0xc0
byte 0x60, 0x70, 0x00 ; 0x00 0x80 0xff
byte 0x70, 0x3f, 0x60 ; 0x00 0xc0 0x00
byte 0x80, 0x3f, 0x80 ; 0x00 0xc0 0x40
byte 0x70, 0x3f, 0x60 ; 0x00 0xc0 0x80
byte 0x80, 0x3f, 0x30 ; 0x00 0xc0 0xc0
byte 0x90, 0x3f, 0x00 ; 0x00 0xc0 0xff
byte 0x90, 0x00, 0x20 ; 0x00 0xff 0x00
byte 0x90, 0x00, 0x70 ; 0x00 0xff 0x40
byte 0x90, 0x00, 0x50 ; 0x00 0xff 0x80
byte 0x90, 0x00, 0x30 ; 0x00 0xff 0xc0
byte 0xa0, 0x00, 0xf1 ; 0x00 0xff 0xff
;RED = 40
byte 0x60, 0x10, 0x00 ; 0x40 0x00 0x00
byte 0x60, 0x60, 0xbf ; 0x40 0x00 0x40
byte 0x40, 0x20, 0x7f ; 0x40 0x00 0x80
byte 0x30, 0x20, 0x3f ; 0x40 0x00 0xc0
byte 0x20, 0x60, 0x00 ; 0x40 0x00 0xff
byte 0x70, 0xa0, 0x10 ; 0x40 0x40 0x00
byte 0x60, 0x80, 0xb0 ; 0x40 0x40 0x40
byte 0x50, 0x70, 0x7f ; 0x40 0x40 0x80
byte 0x40, 0x70, 0x3f ; 0x40 0x40 0xc0
byte 0x30, 0x70, 0x00 ; 0x40 0x40 0xff
byte 0x60, 0x7f, 0x50 ; 0x40 0x80 0x00
byte 0x50, 0x60, 0xa0 ; 0x40 0x80 0x40
byte 0x40, 0x50, 0x70 ; 0x40 0x80 0x80
byte 0x30, 0x50, 0x3f ; 0x40 0x80 0xc0
byte 0x30, 0x60, 0x00 ; 0x40 0x80 0xff
byte 0x50, 0x3f, 0x30 ; 0x40 0xc0 0x00
byte 0x50, 0x3f, 0xa0 ; 0x40 0xc0 0x40
byte 0x40, 0x30, 0x70 ; 0x40 0xc0 0x80
byte 0x30, 0x30, 0x30 ; 0x40 0xc0 0xc0
byte 0x30, 0x30, 0x00 ; 0x40 0xc0 0xff
byte 0x40, 0x00, 0x50 ; 0x40 0xff 0x00
byte 0x40, 0x00, 0x80 ; 0x40 0xff 0x40
byte 0x40, 0x00, 0x60 ; 0x40 0xff 0x80
byte 0x30, 0x00, 0x30 ; 0x40 0xff 0xc0
byte 0x30, 0x00, 0x00 ; 0x40 0xff 0xff
;RED = 80
byte 0x50, 0x10, 0x10 ; 0x80 0x00 0x00
byte 0x30, 0x30, 0xa0 ; 0x80 0x00 0x40
byte 0x30, 0x50, 0x7f ; 0x80 0x00 0x80
byte 0x20, 0x50, 0x3f ; 0x80 0x00 0xc0
byte 0x20, 0x60, 0x00 ; 0x80 0x00 0xff
byte 0x50, 0x90, 0x10 ; 0x80 0x40 0x00
byte 0x30, 0x70, 0xb0 ; 0x80 0x40 0x40
byte 0x30, 0x70, 0x7f ; 0x80 0x40 0x80
byte 0x30, 0x80, 0x3f ; 0x80 0x40 0xc0
byte 0x30, 0x70, 0x00 ; 0x80 0x40 0xff
byte 0x50, 0x70, 0x50 ; 0x80 0x80 0x00
byte 0x50, 0x50, 0xa0 ; 0x80 0x80 0x40
byte 0x40, 0x40, 0x70 ; 0x80 0x80 0x80
byte 0x40, 0x50, 0x3f ; 0x80 0x80 0xc0
byte 0x30, 0x40, 0x00 ; 0x80 0x80 0xff
byte 0x40, 0x3f, 0x50 ; 0x80 0xc0 0x00
byte 0x40, 0x30, 0x70 ; 0x80 0xc0 0x40
byte 0x40, 0x30, 0x70 ; 0x80 0xc0 0x80
byte 0x30, 0x30, 0x3f ; 0x80 0xc0 0xc0
byte 0x20, 0x30, 0x00 ; 0x80 0xc0 0xff
byte 0x30, 0x00, 0x10 ; 0x80 0xff 0x00
byte 0x40, 0x00, 0x70 ; 0x80 0xff 0x40
byte 0x40, 0x00, 0x70 ; 0x80 0xff 0x80
byte 0x40, 0x00, 0x3f ; 0x80 0xff 0xc0
byte 0x30, 0x00, 0x00 ; 0x80 0xff 0xff
;RED = C0
byte 0x30, 0x20, 0x50 ; 0xc0 0x00 0x00
byte 0x10, 0x20, 0xbf ; 0xc0 0x00 0x40
byte 0x10, 0x60, 0x7f ; 0xc0 0x00 0x80
byte 0x00, 0x60, 0x3f ; 0xc0 0x00 0xc0
byte 0xf0, 0x10, 0x00 ; 0xc0 0x00 0xff
byte 0x30, 0x70, 0x40 ; 0xc0 0x40 0x00
byte 0x20, 0x50, 0xb0 ; 0xc0 0x40 0x40
byte 0x20, 0x70, 0x7f ; 0xc0 0x40 0x80
byte 0x20, 0x80, 0x3f ; 0xc0 0x40 0xc0
byte 0x10, 0x70, 0x00 ; 0xc0 0x40 0xff
byte 0x30, 0x60, 0x00 ; 0xc0 0x80 0x00
byte 0x20, 0x50, 0x90 ; 0xc0 0x80 0x40
byte 0x20, 0x50, 0x70 ; 0xc0 0x80 0x80
byte 0x10, 0x40, 0x30 ; 0xc0 0x80 0xc0
byte 0x10, 0x40, 0x00 ; 0xc0 0x80 0xff
byte 0x30, 0x30, 0x50 ; 0xc0 0xc0 0x00
byte 0x30, 0x30, 0x90 ; 0xc0 0xc0 0x40
byte 0x30, 0x30, 0x70 ; 0xc0 0xc0 0x80
byte 0x30, 0x30, 0x3f ; 0xc0 0xc0 0xc0
byte 0x20, 0x30, 0x00 ; 0xc0 0xc0 0xff
byte 0x30, 0x00, 0x00 ; 0xc0 0xff 0x00
byte 0x30, 0x00, 0x80 ; 0xc0 0xff 0x40
byte 0x30, 0x00, 0x50 ; 0xc0 0xff 0x80
byte 0x30, 0x00, 0x30 ; 0xc0 0xff 0xc0
byte 0x30, 0x00, 0x00 ; 0xc0 0xff 0xff
;RED = FF
byte 0x00, 0x10, 0x10 ; 0xff 0x00 0x00
byte 0x00, 0x00, 0xbf ; 0xff 0x00 0x40
byte 0xf1, 0x20, 0x7f ; 0xff 0x00 0x80
byte 0xf1, 0x60, 0x3f ; 0xff 0x00 0xc0
byte 0xe1, 0x70, 0x00 ; 0xff 0x00 0xff
byte 0x00, 0x70, 0x00 ; 0xff 0x40 0x00
byte 0x00, 0x50, 0xb0 ; 0xff 0x40 0x40
byte 0xf1, 0x60, 0x70 ; 0xff 0x40 0x80
byte 0xf1, 0x70, 0x3f ; 0xff 0x40 0xc0
byte 0xf1, 0x80, 0x00 ; 0xff 0x40 0xff
byte 0x00, 0x70, 0x00 ; 0xff 0x80 0x00
byte 0x00, 0x60, 0xa0 ; 0xff 0x80 0x40
byte 0xf1, 0x50, 0x70 ; 0xff 0x80 0x80
byte 0xf1, 0x50, 0x3f ; 0xff 0x80 0xc0
byte 0xf1, 0x60, 0x00 ; 0xff 0x80 0xff
byte 0xf1, 0x30, 0x50 ; 0xff 0xc0 0x00
byte 0x00, 0x30, 0xa0 ; 0xff 0xc0 0x40
byte 0xf1, 0x30, 0x60 ; 0xff 0xc0 0x80
byte 0xf1, 0x30, 0x30 ; 0xff 0xc0 0xc0
byte 0xf1, 0x30, 0x00 ; 0xff 0xc0 0xff
byte 0x00, 0x00, 0x10 ; 0xff 0xff 0x00
byte 0x00, 0x00, 0x70 ; 0xff 0xff 0x40
byte 0x00, 0x00, 0x60 ; 0xff 0xff 0x80
byte 0x00, 0x00, 0x30 ; 0xff 0xff 0xc0
byte 0x00, 0x00, 0x00 ; 0xff 0xff 0xff
CorrectLexTranInk ends
|
gyak/gyak1-2/signof.adb | balintsoos/LearnAda | 0 | 29983 | with Ada.Integer_Text_IO;
use Ada.Integer_Text_IO;
with Ada.Text_IO;
use Ada.Text_IO;
with Mat; -- use Mat;
procedure signOf is
N : Integer;
begin
Get( N );
Put( Mat.signof(N));
end signOf;
|
Practice/Assignments assembly class/13.asm | WardunIslam/CSE331L_Section_7_Summer_2020_NSU | 0 | 169325 | <reponame>WardunIslam/CSE331L_Section_7_Summer_2020_NSU
; You may customize this and other start-up templates;
; The location of this template is c:\emu8086\inc\0_com_template.txt
org 100h
L1: NOP
L2: MOV AX, 0F000H
MOV DS, AX
MOV BX, 0FFFFH
MOV DS:[BX], 0FFH
MOV BL, DS:[BX]
MOV AL, 00H
MOV CL, 08H
L3: RCL BL, 1
JNC L4
DEC CL
JNZ L3
JMP L5
L4: INC AL
DEC CL
JNZ L3
L5: HLT
ret
|
programs/oeis/028/A028994.asm | karttu/loda | 1 | 162140 | ; A028994: Even 10-gonal (or decagonal) numbers.
; 0,10,52,126,232,370,540,742,976,1242,1540,1870,2232,2626,3052,3510,4000,4522,5076,5662,6280,6930,7612,8326,9072,9850,10660,11502,12376,13282,14220,15190,16192,17226,18292,19390,20520,21682,22876,24102,25360,26650,27972,29326,30712,32130,33580,35062,36576,38122,39700,41310,42952,44626,46332,48070,49840,51642,53476,55342,57240,59170,61132,63126,65152,67210,69300,71422,73576,75762,77980,80230,82512,84826,87172,89550,91960,94402,96876,99382,101920,104490,107092,109726,112392,115090,117820,120582,123376,126202,129060,131950,134872,137826,140812,143830,146880,149962,153076,156222,159400,162610,165852,169126,172432,175770,179140,182542,185976,189442,192940,196470,200032,203626,207252,210910,214600,218322,222076,225862,229680,233530,237412,241326,245272,249250,253260,257302,261376,265482,269620,273790,277992,282226,286492,290790,295120,299482,303876,308302,312760,317250,321772,326326,330912,335530,340180,344862,349576,354322,359100,363910,368752,373626,378532,383470,388440,393442,398476,403542,408640,413770,418932,424126,429352,434610,439900,445222,450576,455962,461380,466830,472312,477826,483372,488950,494560,500202,505876,511582,517320,523090,528892,534726,540592,546490,552420,558382,564376,570402,576460,582550,588672,594826,601012,607230,613480,619762,626076,632422,638800,645210,651652,658126,664632,671170,677740,684342,690976,697642,704340,711070,717832,724626,731452,738310,745200,752122,759076,766062,773080,780130,787212,794326,801472,808650,815860,823102,830376,837682,845020,852390,859792,867226,874692,882190,889720,897282,904876,912502,920160,927850,935572,943326,951112,958930,966780,974662,982576,990522
mov $1,$0
mul $0,16
sub $0,6
mul $1,$0
|
src/Dodo/Binary/Flip.agda | sourcedennis/agda-dodo | 0 | 6675 | {-# OPTIONS --without-K --safe #-}
module Dodo.Binary.Flip where
-- Stdlib imports
open import Level using (Level; _⊔_)
open import Function.Base using (flip)
open import Relation.Binary using (Rel; REL)
open import Relation.Binary using (Symmetric)
-- Local imports
open import Dodo.Binary.Equality
-- # Operations
-- ## Operations: ⊆₂
module _ {a b ℓ₁ ℓ₂ : Level} {A : Set a} {B : Set b}
{P : REL A B ℓ₁} {Q : REL A B ℓ₂} where
flip-⊆₂ : P ⊆₂ Q → flip P ⊆₂ flip Q
flip-⊆₂ (⊆: P⊆Q) = ⊆: (flip P⊆Q)
module _ {a ℓ₁ : Level} {A : Set a} {P : Rel A ℓ₁} where
flip-sym-⊆₂ : Symmetric P → P ⊆₂ flip P
flip-sym-⊆₂ symP = ⊆: (λ _ _ → symP)
-- ## Operations: ⇔₂
module _ {a b ℓ₁ ℓ₂ : Level} {A : Set a} {B : Set b}
{P : REL A B ℓ₁} {Q : REL A B ℓ₂} where
flip-⇔₂ : P ⇔₂ Q → flip P ⇔₂ flip Q
flip-⇔₂ = ⇔₂-compose flip-⊆₂ flip-⊆₂
module _ {a ℓ₁ : Level} {A : Set a} {P : Rel A ℓ₁} where
flip-sym-⇔₂ : Symmetric P → P ⇔₂ flip P
flip-sym-⇔₂ symP = ⇔₂-intro (flip-sym-⊆₂ symP) (flip-sym-⊆₂ symP)
|
src/tools/diffdict.adb | spr93/whitakers-words | 204 | 5607 | <gh_stars>100-1000
-- WORDS, a Latin dictionary, by <NAME> (USAF, Retired)
--
-- Copyright <NAME> (1936–2010)
--
-- This is a free program, which means it is proper to copy it and pass
-- it on to your friends. Consider it a developmental item for which
-- there is no charge. However, just for form, it is Copyrighted
-- (c). Permission is hereby freely given for any and all use of program
-- and data. You can sell it as your own, but at least tell me.
--
-- This version is distributed without obligation, but the developer
-- would appreciate comments and suggestions.
--
-- All parts of the WORDS system, source code and data files, are made freely
-- available to anyone who wishes to use them, for whatever purpose.
procedure Diffdict is
begin
null;
-- Two DICTLINEs, sorted the same way
-- Read into memory arrays (because we have so much memory)
-- Compared for STEMS, PART, FLAGs, (||), MEAN
-- The difference generated and written to output file
-- Color coded, if possible
-- Two DICTLINEs can then be compared and corrections made
-- A second run with the corrections gives a benchmark
-- Another exercise some time later produces another difference file
-- The two difference files are then DIFFed giving the changes
-- made over time
end Diffdict;
|
alloy4fun_models/trashltl/models/11/8LB8dF8g85LjQpCGh.als | Kaixi26/org.alloytools.alloy | 0 | 1141 | <reponame>Kaixi26/org.alloytools.alloy<filename>alloy4fun_models/trashltl/models/11/8LB8dF8g85LjQpCGh.als
open main
pred id8LB8dF8g85LjQpCGh_prop12 {
eventually all f:File | f in Trash implies always f in Trash'
}
pred __repair { id8LB8dF8g85LjQpCGh_prop12 }
check __repair { id8LB8dF8g85LjQpCGh_prop12 <=> prop12o } |
cse341/assembly.asm | cosmicray001/academic | 2 | 101760 | <gh_stars>1-10
; I/O with correct sun out
.MODEL SMALL
.STACK 100H
.DATA
A DB ?
B DB ?
.CODE
MAIN PROC
MOV AX, @DATA
MOV DS, AX
MOV AH, 1
INT 21H
MOV A, AL
SUB A, 48
INT 21H
MOV B, AL
SUB B, 48
MOV BH, A
ADD BH, B
ADD BH, 48
MOV AH, 2
MOV DL, 0AH
INT 21H
MOV DL, 0DH
INT 21H
MOV DL, BH
INT 21H
MAIN ENDP
END MAIN
|
libsrc/_DEVELOPMENT/arch/zx/display/z80/asm_zx_pxy2saddr.asm | jpoikela/z88dk | 640 | 11537 | <filename>libsrc/_DEVELOPMENT/arch/zx/display/z80/asm_zx_pxy2saddr.asm
; ===============================================================
; Jun 2007
; ===============================================================
;
; void *zx_pxy2saddr(uchar x, uchar y)
;
; Screen address of byte containing pixel at coordinate x, y.
;
; ===============================================================
INCLUDE "config_private.inc"
SECTION code_clib
SECTION code_arch
PUBLIC asm_zx_pxy2saddr
PUBLIC asm0_zx_pxy2saddr
asm_zx_pxy2saddr:
; enter : l = x coordinate
; h = valid y coordinate
;
; exit : hl = screen address of byte containing pixel
; e = x coordinate
; d = y coordinate
;
; uses : af, de, hl
ld a,h
and $07
IF __USE_SPECTRUM_128_SECOND_DFILE
or $c0
ELSE
or $40
ENDIF
asm0_zx_pxy2saddr:
ld d,a
ld a,h
rra
rra
rra
and $18
or d
ld d,a
ld a,l
rra
rra
rra
and $1f
ld e,a
ld a,h
add a,a
add a,a
and $e0
or e
ld e,a
ex de,hl
ret
|
lib/sse/sha512_one_block_sse.asm | dalekzhangdong/intel-ipsec-mb | 1 | 105041 | ;;
;; Copyright (c) 2012-2020, Intel Corporation
;;
;; Redistribution and use in source and binary forms, with or without
;; modification, are permitted provided that the following conditions are met:
;;
;; * Redistributions of source code must retain the above copyright notice,
;; this list of conditions and the following disclaimer.
;; * Redistributions in binary form must reproduce the above copyright
;; notice, this list of conditions and the following disclaimer in the
;; documentation and/or other materials provided with the distribution.
;; * Neither the name of Intel Corporation nor the names of its contributors
;; may be used to endorse or promote products derived from this software
;; without specific prior written permission.
;;
;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
;; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
;; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
;; DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
;; FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
;; SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
;; CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
;; OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;;
; This code schedules 1 blocks at a time, with 4 lanes per block
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
%include "include/os.asm"
%include "include/clear_regs.asm"
%include "include/cet.inc"
%use smartalign
alignmode generic, nojmp
%define MOVDQ movdqu ;; assume buffers not aligned
%ifndef FUNC
%define FUNC sha512_block_sse
%endif
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Define Macros
; COPY_XMM_AND_BSWAP xmm, [mem], byte_flip_mask
; Load xmm with mem and byte swap each dword
%macro COPY_XMM_AND_BSWAP 3
MOVDQ %1, %2
pshufb %1, %3
%endmacro
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
%define X0 xmm4
%define X1 xmm5
%define X2 xmm6
%define X3 xmm7
%define X4 xmm8
%define X5 xmm9
%define X6 xmm10
%define X7 xmm11
%define XTMP0 xmm0
%define XTMP1 xmm1
%define XTMP2 xmm2
%define XTMP3 xmm3
%define XFER xmm13
%define BYTE_FLIP_MASK xmm12
%ifdef LINUX
%define CTX rsi ; 2nd arg
%define INP rdi ; 1st arg
%define SRND rdi ; clobbers INP
%define c rcx
%define d r8
%define e rdx
%else
%define CTX rdx ; 2nd arg
%define INP rcx ; 1st arg
%define SRND rcx ; clobbers INP
%define c rdi
%define d rsi
%define e r8
%endif
%define TBL rbp
%define a rax
%define b rbx
%define f r9
%define g r10
%define h r11
%define y0 r13
%define y1 r14
%define y2 r15
struc STACK
%ifndef LINUX
_XMM_SAVE: reso 8
%endif
_XFER: reso 1
endstruc
; rotate_Xs
; Rotate values of symbols X0...X7
%macro rotate_Xs 0
%xdefine X_ X0
%xdefine X0 X1
%xdefine X1 X2
%xdefine X2 X3
%xdefine X3 X4
%xdefine X4 X5
%xdefine X5 X6
%xdefine X6 X7
%xdefine X7 X_
%endm
; ROTATE_ARGS
; Rotate values of symbols a...h
%macro ROTATE_ARGS 0
%xdefine TMP_ h
%xdefine h g
%xdefine g f
%xdefine f e
%xdefine e d
%xdefine d c
%xdefine c b
%xdefine b a
%xdefine a TMP_
%endm
%macro TWO_ROUNDS_AND_SCHED 0
;; compute s0 four at a time and s1 two at a time
;; compute W[-16] + W[-7] 4 at a time
movdqa XTMP0, X5
mov y0, e ; y0 = e
mov y1, a ; y1 = a
ror y0, (41-18) ; y0 = e >> (41-18)
palignr XTMP0, X4, 8 ; XTMP0 = W[-7]
xor y0, e ; y0 = e ^ (e >> (41-18))
mov y2, f ; y2 = f
ror y1, (39-34) ; y1 = a >> (39-34)
xor y1, a ; y1 = a ^ (a >> (39-34)
movdqa XTMP1, X1
ror y0, (18-14) ; y0 = (e >> (18-14)) ^ (e >> (41-14))
xor y2, g ; y2 = f^g
paddq XTMP0, X0 ; XTMP0 = W[-7] + W[-16]
ror y1, (34-28) ; y1 = (a >> (34-28)) ^ (a >> (39-28))
xor y0, e ; y0 = e ^ (e >> (18-14)) ^ (e >> (41-14))
and y2, e ; y2 = (f^g)&e
;; compute s0
palignr XTMP1, X0, 8 ; XTMP1 = W[-15]
xor y1, a ; y1 = a ^ (a >> (34-28)) ^ (a >> (39-28))
xor y2, g ; y2 = CH = ((f^g)&e)^g
movdqa XTMP2, XTMP1 ; XTMP2 = W[-15]
ror y0, 14 ; y0 = S1 = (e>>14) & (e>>18) ^ (e>>41)
add y2, y0 ; y2 = S1 + CH
add y2, [rsp + _XFER + 0*8] ; y2 = k + w + S1 + CH
ror y1, 28 ; y1 = S0 = (a>>28) ^ (a>>34) ^ (a>>39)
movdqa XTMP3, XTMP1 ; XTMP3 = W[-15]
mov y0, a ; y0 = a
add h, y2 ; h = h + S1 + CH + k + w
psllq XTMP1, (64-1)
mov y2, a ; y2 = a
or y0, c ; y0 = a|c
psrlq XTMP2, 1
add d, h ; d = d + t1
and y2, c ; y2 = a&c
por XTMP1, XTMP2 ; XTMP1 = W[-15] ror 1
and y0, b ; y0 = (a|c)&b
add h, y1 ; h = t1 + S0
movdqa XTMP2, XTMP3 ; XTMP2 = W[-15]
psrlq XTMP2, 8
or y0, y2 ; y0 = MAJ = (a|c)&b)|(a&c)
add h, y0 ; h = t1 + S0 + MAJ
movdqa X0, XTMP3 ; X0 = W[-15]
psllq XTMP3, (64-8)
ROTATE_ARGS
pxor XTMP1, XTMP3
psrlq X0, 7 ; X0 = W[-15] >> 7
mov y0, e ; y0 = e
mov y1, a ; y1 = a
pxor XTMP1, XTMP2 ; XTMP1 = W[-15] ror 1 ^ W[-15] ror 8
ror y0, (41-18) ; y0 = e >> (41-18)
xor y0, e ; y0 = e ^ (e >> (41-18))
mov y2, f ; y2 = f
pxor XTMP1, X0 ; XTMP1 = s0
ror y1, (39-34) ; y1 = a >> (39-34)
xor y1, a ; y1 = a ^ (a >> (39-34)
;; compute s1
movdqa XTMP2, X7 ; XTMP2 = W[-2]
ror y0, (18-14) ; y0 = (e >> (18-14)) ^ (e >> (41-14))
xor y2, g ; y2 = f^g
paddq XTMP0, XTMP1 ; XTMP0 = W[-16] + W[-7] + s0
ror y1, (34-28) ; y1 = (a >> (34-28)) ^ (a >> (39-28))
xor y0, e ; y0 = e ^ (e >> (18-14)) ^ (e >> (41-14))
movdqa XTMP3, XTMP2 ; XTMP3 = W[-2]
movdqa X0, XTMP2 ; X0 = W[-2]
and y2, e ; y2 = (f^g)&e
ror y0, 14 ; y0 = S1 = (e>>14) & (e>>18) ^ (e>>41)
xor y1, a ; y1 = a ^ (a >> (34-28)) ^ (a >> (39-28))
psllq XTMP3, (64-19)
xor y2, g ; y2 = CH = ((f^g)&e)^g
add y2, y0 ; y2 = S1 + CH
add y2, [rsp + _XFER + 1*8] ; y2 = k + w + S1 + CH
psrlq X0, 19
ror y1, 28 ; y1 = S0 = (a>>28) ^ (a>>34) ^ (a>>39)
mov y0, a ; y0 = a
add h, y2 ; h = h + S1 + CH + k + w
por XTMP3, X0 ; XTMP3 = W[-2] ror 19
mov y2, a ; y2 = a
or y0, c ; y0 = a|c
movdqa X0, XTMP2 ; X0 = W[-2]
movdqa XTMP1, XTMP2 ; XTMP1 = W[-2]
add d, h ; d = d + t1
and y2, c ; y2 = a&c
psllq X0, (64-61)
and y0, b ; y0 = (a|c)&b
add h, y1 ; h = t1 + S0
psrlq XTMP1, 61
or y0, y2 ; y0 = MAJ = (a|c)&b)|(a&c)
add h, y0 ; h = t1 + S0 + MAJ
por X0, XTMP1 ; X0 = W[-2] ror 61
psrlq XTMP2, 6 ; XTMP2 = W[-2] >> 6
pxor XTMP2, XTMP3
pxor X0, XTMP2 ; X0 = s1
paddq X0, XTMP0 ; X0 = {W[1], W[0]}
ROTATE_ARGS
rotate_Xs
%endm
;; input is [rsp + _XFER + %1 * 8]
%macro DO_ROUND 1
mov y0, e ; y0 = e
ror y0, (41-18) ; y0 = e >> (41-18)
mov y1, a ; y1 = a
xor y0, e ; y0 = e ^ (e >> (41-18))
ror y1, (39-34) ; y1 = a >> (39-34)
mov y2, f ; y2 = f
xor y1, a ; y1 = a ^ (a >> (39-34)
ror y0, (18-14) ; y0 = (e >> (18-14)) ^ (e >> (41-14))
xor y2, g ; y2 = f^g
xor y0, e ; y0 = e ^ (e >> (18-14)) ^ (e >> (25-6))
ror y1, (34-28) ; y1 = (a >> (34-28)) ^ (a >> (39-28))
and y2, e ; y2 = (f^g)&e
xor y1, a ; y1 = a ^ (a >> (34-28)) ^ (a >> (39-28))
ror y0, 14 ; y0 = S1 = (e>>14) & (e>>18) ^ (e>>41)
xor y2, g ; y2 = CH = ((f^g)&e)^g
add y2, y0 ; y2 = S1 + CH
ror y1, 28 ; y1 = S0 = (a>>28) ^ (a>>34) ^ (a>>39)
add y2, [rsp + _XFER + %1*8] ; y2 = k + w + S1 + CH
mov y0, a ; y0 = a
add h, y2 ; h = h + S1 + CH + k + w
mov y2, a ; y2 = a
or y0, c ; y0 = a|c
add d, h ; d = d + t1
and y2, c ; y2 = a&c
and y0, b ; y0 = (a|c)&b
add h, y1 ; h = t1 + S0
or y0, y2 ; y0 = MAJ = (a|c)&b)|(a&c)
add h, y0 ; h = t1 + S0 + MAJ
ROTATE_ARGS
%endm
section .data
default rel
align 64
K512:
dq 0x428a2f98d728ae22,0x7137449123ef65cd
dq 0xb5c0fbcfec4d3b2f,0xe9b5dba58189dbbc
dq 0x3956c25bf348b538,0x59f111f1b605d019
dq 0x923f82a4af194f9b,0xab1c5ed5da6d8118
dq 0xd807aa98a3030242,0x12835b0145706fbe
dq 0x243185be4ee4b28c,0x550c7dc3d5ffb4e2
dq 0x72be5d74f27b896f,0x80deb1fe3b1696b1
dq 0x9bdc06a725c71235,0xc19bf174cf692694
dq 0xe49b69c19ef14ad2,0xefbe4786384f25e3
dq 0x0fc19dc68b8cd5b5,0x240ca1cc77ac9c65
dq 0x2de92c6f592b0275,0x4a7484aa6ea6e483
dq 0x5cb0a9dcbd41fbd4,0x76f988da831153b5
dq 0x983e5152ee66dfab,0xa831c66d2db43210
dq 0xb00327c898fb213f,0xbf597fc7beef0ee4
dq 0xc6e00bf33da88fc2,0xd5a79147930aa725
dq 0x06ca6351e003826f,0x142929670a0e6e70
dq 0x27b70a8546d22ffc,0x2e1b21385c26c926
dq 0x4d2c6dfc5ac42aed,0x53380d139d95b3df
dq 0x650a73548baf63de,0x766a0abb3c77b2a8
dq 0x81c2c92e47edaee6,0x92722c851482353b
dq 0xa2bfe8a14cf10364,0xa81a664bbc423001
dq 0xc24b8b70d0f89791,0xc76c51a30654be30
dq 0xd192e819d6ef5218,0xd69906245565a910
dq 0xf40e35855771202a,0x106aa07032bbd1b8
dq 0x19a4c116b8d2d0c8,0x1e376c085141ab53
dq 0x2748774cdf8eeb99,0x34b0bcb5e19b48a8
dq 0x391c0cb3c5c95a63,0x4ed8aa4ae3418acb
dq 0x5b9cca4f7763e373,0x682e6ff3d6b2b8a3
dq 0x748f82ee5defb2fc,0x78a5636f43172f60
dq 0x84c87814a1f0ab72,0x8cc702081a6439ec
dq 0x90befffa23631e28,0xa4506cebde82bde9
dq 0xbef9a3f7b2c67915,0xc67178f2e372532b
dq 0xca273eceea26619c,0xd186b8c721c0c207
dq 0xeada7dd6cde0eb1e,0xf57d4f7fee6ed178
dq 0x06f067aa72176fba,0x0a637dc5a2c898a6
dq 0x113f9804bef90dae,0x1b710b35131c471b
dq 0x28db77f523047d84,0x32caab7b40c72493
dq 0x3c9ebe0a15c9bebc,0x431d67c49c100d4c
dq 0x4cc5d4becb3e42b6,0x597f299cfc657e2a
dq 0x5fcb6fab3ad6faec,0x6c44198c4a475817
align 16
PSHUFFLE_BYTE_FLIP_MASK: ;ddq 0x08090a0b0c0d0e0f0001020304050607
dq 0x0001020304050607, 0x08090a0b0c0d0e0f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; void FUNC(void *input_data, UINT64 digest[8])
;; arg 1 : pointer to input data
;; arg 2 : pointer to digest
section .text
MKGLOBAL(FUNC,function,internal)
align 32
FUNC:
endbranch64
push rbx
%ifndef LINUX
push rsi
push rdi
%endif
push rbp
push r13
push r14
push r15
sub rsp,STACK_size
%ifndef LINUX
movdqa [rsp + _XMM_SAVE + 0*16],xmm6
movdqa [rsp + _XMM_SAVE + 1*16],xmm7
movdqa [rsp + _XMM_SAVE + 2*16],xmm8
movdqa [rsp + _XMM_SAVE + 3*16],xmm9
movdqa [rsp + _XMM_SAVE + 4*16],xmm10
movdqa [rsp + _XMM_SAVE + 5*16],xmm11
movdqa [rsp + _XMM_SAVE + 6*16],xmm12
movdqa [rsp + _XMM_SAVE + 7*16],xmm13
%endif
;; load initial digest
mov a, [8*0 + CTX]
mov b, [8*1 + CTX]
mov c, [8*2 + CTX]
mov d, [8*3 + CTX]
mov e, [8*4 + CTX]
mov f, [8*5 + CTX]
mov g, [8*6 + CTX]
mov h, [8*7 + CTX]
movdqa BYTE_FLIP_MASK, [rel PSHUFFLE_BYTE_FLIP_MASK]
lea TBL,[rel K512]
;; byte swap first 16 qwords
COPY_XMM_AND_BSWAP X0, [INP + 0*16], BYTE_FLIP_MASK
COPY_XMM_AND_BSWAP X1, [INP + 1*16], BYTE_FLIP_MASK
COPY_XMM_AND_BSWAP X2, [INP + 2*16], BYTE_FLIP_MASK
COPY_XMM_AND_BSWAP X3, [INP + 3*16], BYTE_FLIP_MASK
COPY_XMM_AND_BSWAP X4, [INP + 4*16], BYTE_FLIP_MASK
COPY_XMM_AND_BSWAP X5, [INP + 5*16], BYTE_FLIP_MASK
COPY_XMM_AND_BSWAP X6, [INP + 6*16], BYTE_FLIP_MASK
COPY_XMM_AND_BSWAP X7, [INP + 7*16], BYTE_FLIP_MASK
;; schedule 64 input qwords, by doing 4 iterations of 16 rounds
mov SRND, 4
align 16
loop1:
%assign i 0
%rep 7
movdqa XFER, X0
paddq XFER, [TBL + i*16]
movdqa [rsp + _XFER], XFER
TWO_ROUNDS_AND_SCHED
%assign i (i+1)
%endrep
movdqa XFER, X0
paddq XFER, [TBL + 7*16]
movdqa [rsp + _XFER], XFER
add TBL, 8*16
TWO_ROUNDS_AND_SCHED
sub SRND, 1
jne loop1
mov SRND, 2
loop2:
paddq X0, [TBL + 0*16]
movdqa [rsp + _XFER], X0
DO_ROUND 0
DO_ROUND 1
paddq X1, [TBL + 1*16]
movdqa [rsp + _XFER], X1
DO_ROUND 0
DO_ROUND 1
paddq X2, [TBL + 2*16]
movdqa [rsp + _XFER], X2
DO_ROUND 0
DO_ROUND 1
paddq X3, [TBL + 3*16]
movdqa [rsp + _XFER], X3
add TBL, 4*16
DO_ROUND 0
DO_ROUND 1
movdqa X0, X4
movdqa X1, X5
movdqa X2, X6
movdqa X3, X7
sub SRND, 1
jne loop2
add [8*0 + CTX], a
add [8*1 + CTX], b
add [8*2 + CTX], c
add [8*3 + CTX], d
add [8*4 + CTX], e
add [8*5 + CTX], f
add [8*6 + CTX], g
add [8*7 + CTX], h
done_hash:
%ifndef LINUX
movdqa xmm6,[rsp + _XMM_SAVE + 0*16]
movdqa xmm7,[rsp + _XMM_SAVE + 1*16]
movdqa xmm8,[rsp + _XMM_SAVE + 2*16]
movdqa xmm9,[rsp + _XMM_SAVE + 3*16]
movdqa xmm10,[rsp + _XMM_SAVE + 4*16]
movdqa xmm11,[rsp + _XMM_SAVE + 5*16]
movdqa xmm12,[rsp + _XMM_SAVE + 6*16]
movdqa xmm13,[rsp + _XMM_SAVE + 7*16]
%ifdef SAFE_DATA
;; Clear potential sensitive data stored in stack
clear_xmms_sse xmm0, xmm1, xmm2, xmm3, xmm4, xmm5
movdqa [rsp + _XMM_SAVE + 0 * 16], xmm0
movdqa [rsp + _XMM_SAVE + 1 * 16], xmm0
movdqa [rsp + _XMM_SAVE + 2 * 16], xmm0
movdqa [rsp + _XMM_SAVE + 3 * 16], xmm0
movdqa [rsp + _XMM_SAVE + 4 * 16], xmm0
movdqa [rsp + _XMM_SAVE + 5 * 16], xmm0
movdqa [rsp + _XMM_SAVE + 6 * 16], xmm0
movdqa [rsp + _XMM_SAVE + 7 * 16], xmm0
%endif
%else ;; LINUX
%ifdef SAFE_DATA
clear_all_xmms_sse_asm
%endif
%endif ;; LINUX
add rsp, STACK_size
pop r15
pop r14
pop r13
pop rbp
%ifndef LINUX
pop rdi
pop rsi
%endif
pop rbx
ret
%ifdef LINUX
section .note.GNU-stack noalloc noexec nowrite progbits
%endif
|
base/ntos/rtl/amd64/movemem.asm | npocmaka/Windows-Server-2003 | 17 | 178326 | <filename>base/ntos/rtl/amd64/movemem.asm<gh_stars>10-100
title "Memory functions"
;++
;
; Copyright (c) 2000 Microsoft Corporation
;
; Module Name:
;
; movemem.asm
;
; Abstract:
;
; This module implements functions to fill, copy , and compare blocks of
; memory.
;
; Author:
;
; <NAME> (davec) 6-Jul-2000
;
; Environment:
;
; Any mode.
;
;--
include ksamd64.inc
altentry RtlCopyMemoryAlternate
subttl "Compare Memory"
;++
;
; SIZE_T
; RtlCompareMemory (
; IN PVOID Source1,
; IN PVOID Source2,
; IN SIZE_T Length
; )
;
; Routine Description:
;
; This function compares two unaligned blocks of memory and returns the
; number of bytes that compared equal.
;
; Arguments:
;
; Source1 (rcx) - Supplies a pointer to the first block of memory to
; compare.
;
; Source2 (rdx) - Supplies a pointer to the second block of memory to
; compare.
;
; Length (r8) - Supplies the Length, in bytes, of the memory to be
; compared.
;
; Return Value:
;
; The number of bytes that compared equal is returned as the function
; value. If all bytes compared equal, then the length of the orginal
; block of memory is returned.
;
;--
NESTED_ENTRY RtlCompareMemory, _TEXT$00
push_reg rdi ; save nonvolatile registers
push_reg rsi ;
END_PROLOGUE
mov rsi, rcx ; set address of first string
mov rdi, rdx ; set address of second string
xor edx, ecx ; check if compatible alignment
and edx, 07h ;
jnz short RlCM50 ; if nz, incompatible alignment
cmp r8, 8 ; check if length to align
jb short RlCM50 ; if b, insufficient alignment length
;
; Buffer alignment is compatible and there are enough bytes for alignment.
;
mov r9, rdi ; copy destination address
neg ecx ; compute alignment length
and ecx, 07h ;
jz short RlCM10 ; if z, buffers already aligned
sub r8, rcx ; reduce count by align length
repe cmpsb ; compare bytes to alignment
jnz short RlCM30 ; if nz, not all bytes matched
RlCM10: mov rcx, r8 ;
and rcx, -8 ; check if any quarwords to compare
jz short RlCM20 ; if z, no quadwords to compare
sub r8, rcx ; reduce length by compare count
shr rcx, 3 ; compute number of quadwords
repe cmpsq ; compare quadwords
jz short RlCM20 ; if z, all quadwords compared
inc rcx ; increment remaining count
sub rsi, 8 ; back up source address
sub rdi, 8 ; back up destination address
shl rcx, 3 ; compute uncompared bytes
RlCM20: add r8, rcx ; compute residual bytes to compare
jz short RlCM40 ; if z, all bytes compared equal
mov rcx, r8 ; set remaining bytes to compare
repe cmpsb ; compare bytes
jz short RlCM40 ; if z, all byte compared equal
RlCM30: dec rdi ; back up destination address
RlCM40: sub rdi, r9 ; compute number of bytes matched
mov rax, rdi ;
pop rsi ; restore nonvolatile register
pop rdi ;
ret ; return
;
; Buffer alignment is incompatible or there is less than 8 bytes to compare.
;
RlCM50: test r8, r8 ; test if any bytes to compare
jz short RlCM60 ; if z, no bytes to compare
mov rcx, r8 ; set number of bytes to compare
repe cmpsb ; compare bytes
jz short RlCM60 ; if z, all bytes compared equal
inc rcx ; increment remaining count
sub r8, rcx ; compute number of bytes matched
RlCM60: mov rax, r8 ;
pop rsi ; restore nonvolatile register
pop rdi ;
ret ; return
NESTED_END RtlCompareMemory, _TEXT$00
subttl "Compare Memory 32-bits"
;++
;
; SIZE_T
; RtlCompareMemoryUlong (
; IN PVOID Source,
; IN SIZE_T Length,
; IN ULONG Pattern
; )
;
; Routine Description:
;
; This function compares a block of dword aligned memory with a specified
; pattern 32-bits at a time.
;
; N.B. The low two bits of the length are assumed to be zero and are
; ignored.
;
; Arguments:
;
; Source (rcx) - Supplies a pointer to the block of memory to compare.
;
; Length (rdx) - Supplies the length, in bytes, of the memory to compare. compare.
;
; Pattern (r8d) - Supplies the pattern to be compared against.
;
; Return Value:
;
; The number of bytes that compared equal is returned as the function
; value. If all bytes compared equal, then the length of the orginal
; block of memory is returned.
;
;--
NESTED_ENTRY RtlCompareMemoryUlong, _TEXT$00
push_reg rdi ; save nonvolatile register
END_PROLOGUE
mov rdi, rcx ; set destination address
shr rdx, 2 ; compute number of dwords
jz short RlCU10 ; if z, no dwords to compare
mov rcx, rdx ; set length of compare in dwords
mov eax, r8d ; set comparison pattern
repe scasd ; compare memory with pattern
jz short RlCU10 ; if z, all dwords compared
inc rcx ; increment remaining count
sub rdx, rcx ; compute number of bytes matched
RlCU10: lea rax, [rdx*4] ; compute successful compare in bytes
pop rdi ; restore nonvolatile register
ret ; return
NESTED_END RtlCompareMemoryUlong, _TEXT$00
subttl "Copy Memory"
;++
;
; VOID
; RtlCopyMemory (
; OUT VOID UNALIGNED *Destination,
; IN CONST VOID UNALIGNED * Sources,
; IN SIZE_T Length
; )
;
; Routine Description:
;
; This function copies nonoverlapping from one unaligned buffer to another.
;
; Arguments:
;
; Destination (rcx) - Supplies a pointer to the destination buffer.
;
; Sources (rdx) - Supplies a pointer to the source buffer.
;
; Length (r8) - Supplies the length, in bytes, of the copy operation.
;
; Return Value:
;
; None.
;
;--
NESTED_ENTRY RtlCopyMemory, _TEXT$00
push_reg rdi ; save nonvolatile registers
push_reg rsi ;
END_PROLOGUE
ALTERNATE_ENTRY RtlCopyMemoryAlternate
mov rdi, rcx ; set destination address
mov rsi, rdx ; set source address
;
; Check for quadword alignment compatibility.
;
xor edx, ecx ; check if compatible alignment
and edx, 07h ;
jnz short RlCP40 ; is nz, incompatible alignment
cmp r8, 8 ; check if 8 bytes to move
jb short RlCP20 ; if b, less than 8 bytes to move
;
; Buffer alignment is compatible and there are enough bytes for alignment.
;
neg ecx ; compute alignment length
and ecx, 07h ;
jz short RlCP10 ; if z, buffers already aligned
sub r8, rcx ; reduce count by align length
rep movsb ; move bytes to alignment
;
; Move 8-byte blocks.
;
RlCP10: mov rcx, r8 ; compute number of 8-byte blocks
and rcx, -8 ;
jz short RlCP20 ; if z, no 8-byte blocks
sub r8, rcx ; subtract 8-byte blocks from count
shr rcx, 3 ; compute number of 8-byte blocks
rep movsq ; move 8-byte blocks
;
; Move residual bytes.
;
RlCP20: test r8, r8 ; test if any bytes to move
jz short RlCP30 ; if z, no bytes to move
mov rcx, r8 ; set remaining byte to move
rep movsb ; move bytes to destination
RlCP30: pop rsi ; restore nonvolatile registers
pop rdi ;
ret ; return
;
; The source and destination are not quadword alignment compatible.
;
; Check for doubleword alignment compatibility.
;
RlCP40: and edx, 03h ; check if compatibile alignment
jnz short RlCP60 ; is nz, incompatible alignment
cmp r8, 4 ; check if 4 bytes to move
jb short RlCP20 ; if b, less than 4 bytes to move
;
; Buffer alignment is compatible and there are enough bytes for alignment.
;
neg ecx ; compute alignment length
and ecx, 03h ;
jz short RlCP50 ; if z, buffers already aligned
sub r8, rcx ; reduce count by align length
rep movsb ; move bytes to alignment
;
; Move 4-byte blocks.
;
RlCP50: mov rcx, r8 ; compute number of 4-byte blocks
and rcx, -4 ;
jz short RlCP20 ; if z, no 4-byte blocks
sub r8, rcx ; subtract 4-byte blocks from count
shr rcx, 2 ; compute number of 4-byte blocks
rep movsd ; move 4-byte blocks
jmp short RlCP20 ; finish in common code
;
; The source and destination are not doubleword alignment compatible.
;
; Check for word alignment compatibility.
;
RlCP60: and edx, 01h ; check if compatibile alignment
jnz short RlCP20 ; is nz, incompatible alignment
cmp r8, 2 ; check if 2 bytes to move
jb short RlCP20 ; if b, less than 2 bytes to move
;
; Buffer alignment is compatible and there are enough bytes for alignment.
;
neg ecx ; compute alignment length
and ecx, 01h ;
jz short RlCP70 ; if z, buffers already aligned
sub r8, rcx ; reduce count by align length
rep movsb ; move bytes to alignment
;
; Move 2-byte blocks.
;
RlCP70: mov rcx, r8 ; compute number of 2-byte blocks
and rcx, -2 ;
jz short RlCP20 ; if z, no 2-byte blocks
sub r8, rcx ; subtract 2-byte blocks from count
shr rcx, 1 ; compute number of 2-byte blocks
rep movsw ; move 2-byte blocks
jmp short RlCP20 ; finish in common code
NESTED_END RtlCopyMemory, _TEXT$00
subttl "Copy Memory NonTemporal"
;++
;
; VOID
; RtlCopyMemoryNonTemporal (
; OUT VOID UNALIGNED *Destination,
; IN CONST VOID UNALIGNED * Sources,
; IN SIZE_T Length
; )
;
; Routine Description:
;
; This function copies nonoverlapping from one buffer to another using
; nontemporal moves that do not polute the cache.
;
; Arguments:
;
; Destination (rcx) - Supplies a pointer to the destination buffer.
;
; Sources (rdx) - Supplies a pointer to the source buffer.
;
; Length (r8) - Supplies the length, in bytes, of the copy operation.
;
; Return Value:
;
; None.
;
;--
NESTED_ENTRY RtlCopyMemoryNonTemporal, _TEXT$00
push_reg rdi ; save nonvolatile registers
push_reg rsi ;
END_PROLOGUE
mov rdi, rcx ; set destination address
mov rsi, rdx ; set source address
cmp r8, 16 ; check if 16 bytes to move
jb RlNT50 ; if b, less than 16 bytes to move
;
; Align the destination to a 16-byte boundary.
;
neg ecx ; compute alignment length
and ecx, 0fh ;
jz short RlNT10 ; if z, destination already aligned
sub r8, rcx ; reduce count by align length
rep movsb ; move bytes to alignment
;
; Move 64-byte blocks.
;
RlNT10: mov rax, r8 ; compute number of 64-byte blocks
and rax, -64 ;
jz short RlNT30 ; if z, no 64-byte blocks to move
sub r8, rax ; subtract 64-byte blocks from count
RlNT20: prefetchnta 0[rsi] ; prefetch start of source block
prefetchnta 63[rsi] ; prefetch end source block
movdqu xmm0, [rsi] ; move 64-byte block
movdqu xmm1, 16[rsi] ;
movdqu xmm2, 32[rsi] ;
movdqu xmm3, 48[rsi] ;
movntdq [rdi], xmm0 ;
movntdq 16[rdi], xmm1 ;
movntdq 32[rdi], xmm2 ;
movntdq 48[rdi], xmm3 ;
add rdi, 64 ; advance destination address
add rsi, 64 ; advance source address
sub rax, 64 ; subtract number of bytes moved
jnz short RlNT20 ; if nz, more 64-byte blocks to move
;
; Move 16-byte blocks.
;
RlNT30: mov rax, r8 ; compute number of 16-byte blocks
and rax, -16 ;
jz short RlNT50 ; if z, no 16-byte blocks
sub r8, rax ; subract 16-byte blocks from count
RlNT40: movdqu xmm0, [rsi] ; move 16-byte block
movntdq [rdi], xmm0 ;
add rdi, 16 ; advance destination address
add rsi, 16 ; advance source address
sub rax, 16 ; subtract number of bytes moved
jnz short RlNT40 ; if nz, more 16-byte blocks to move
;
; Move residual bytes.
;
RlNT50: test r8, r8 ; test if any bytes to move
jz short RlNT60 ; if z, no bytes to move
mov rcx, r8 ; set residual bytes to move
rep movsb ; move residual bytes
RlNT60: sfence ; make sure all stores complete
pop rsi ; restore nonvolatile registers
pop rdi ;
ret ; return
NESTED_END RtlCopyMemoryNonTemporal, _TEXT$00
subttl "Fill Memory"
;++
;
; VOID
; RtlFillMemory (
; IN VOID UNALIGNED *Destination,
; IN SIZE_T Length,
; IN UCHAR Fill
; )
;
; Routine Description:
;
; This function fills a block of unaligned memory with a specified pattern.
;
; Arguments:
;
; Destination (rcx) - Supplies a pointer to the memory to fill.
;
; Length (rdx) - Supplies the length, in bytes, of the memory to fill.
;
; Fill (r8d) - Supplies the value to fill memory with.
;
; Return Value:
;
; None.
;
;--
NESTED_ENTRY RtlFillMemory, _TEXT$00
push_reg rdi ; save nonvolatile register
END_PROLOGUE
mov rdi, rcx ; set destination address
mov eax, r8d ; set fill pattern
cmp rdx, 8 ; check if 8 bytes to fill
jb short RlFM20 ; if b, less than 8 bytes to fill
;
; Fill alignment bytes.
;
neg ecx ; compute alignment length
and ecx, 07h ;
jz short RlFM10 ; if z, buffers already aligned
sub rdx, rcx ; reduce count by align length
rep stosb ; fill bytes to alignment
;
; Fill 8-byte blocks.
;
RlFM10: mov rcx, rdx ; compute number of 8-byte blocks
and rcx, -8 ;
jz short RlFM20 ; if z, no 8-byte blocks
sub rdx, rcx ; subtract 8-byte blocks from count
shr rcx, 3 ; compute number of 8-byte blocks
mov ah, al ; replicate pattern to dword
shl eax, 16 ;
mov al, r8b ;
mov ah, al ;
mov r9, rax ;
shl rax, 32 ;
or rax, r9 ;
rep stosq ; fill 8-byte blocks
;
; Fill residual bytes.
;
RlFM20: test rdx, rdx ; test if any bytes to fill
jz short RlFM30 ; if z, no bytes to fill
mov rcx, rdx ; set remaining byte to fill
rep stosb ; fill residual bytes
RlFM30: pop rdi ; restore nonvolatile register
ret ; return
NESTED_END RtlFillMemory, _TEXT$00
subttl "Move Memory"
;++
;
; VOID
; RtlMoveMemory (
; OUT VOID UNALIGNED *Destination,
; IN CONST VOID UNALIGNED * Sources,
; IN SIZE_T Length
; )
;
; Routine Description:
;
; This function copies from one unaligned buffer to another.
;
; Arguments:
;
; Destination (rcx) - Supplies a pointer to the destination buffer.
;
; Sources (rdx) - Supplies a pointer to the source buffer.
;
; Length (r8) - Supplies the length, in bytes, of the copy operation.
;
; Return Value:
;
; None.
;
;--
NESTED_ENTRY RtlMoveMemory, _TEXT$00
push_reg rdi ; save nonvolatile registers
push_reg rsi ;
END_PROLOGUE
cmp rcx, rdx ; check if possible buffer overlap
jbe RtlCopyMemoryAlternate ; if be, no overlap possible
mov rsi, rdx ; compute ending source address
add rsi, r8 ;
dec rsi ;
cmp rcx, rsi ; check for buffer overlap
ja RtlCopyMemoryAlternate ; if g, no overlap possible
mov rdi, rcx ; compute ending destination address
add rdi, r8 ;
dec rdi ;
mov rcx, r8 ; set count of bytes to move
std ; set direction flag
rep movsb ; move bytes backward to destination
cld ; clear direction flag
pop rsi ; restore nonvolatile registers
pop rdi ;
ret ; return
NESTED_END RtlMoveMemory, _TEXT$00
subttl "Prefetch Memory NonTemporal"
;++
;
; VOID
; RtlPrefetchMemoryNonTemporal (
; IN CONST PVOID Source,
; IN SIZE_T Length
; )
;
; Routine Description:
;
; This function prefetches memory at Source, for Length bytes into the
; closest cache to the processor.
;
; Arguments:
;
; Source (rcx) - Supplies a pointer to the memory to be prefetched.
;
; Length (rdx) - Supplies the length, in bytes, of the operation.
;
; Return Value:
;
; None.
;
;--
LEAF_ENTRY RtlPrefetchMemoryNonTemporal, _TEXT$00
RlPF10: prefetchnta 0[rcx] ; prefetch line
add rcx, 64 ; increment address to prefetch
sub rdx, 64 ; subtract number of bytes prefetched
ja RlPF10 ; if above zero, more bytes to move
ret ; return
LEAF_END RtlPrefetchMemoryNonTemporal, _TEXT$00
subttl "Zero Memory"
;++
;
; VOID
; RtlZeroMemory (
; IN VOID UNALIGNED *Destination,
; IN SIZE_T Length
; )
;
; Routine Description:
;
; This function fills a block of unaligned memory with zero.
;
; Arguments:
;
; Destination (rcx) - Supplies a pointer to the memory to fill.
;
; Length (rdx) - Supplies the length, in bytes, of the memory to fill.
;
; Return Value:
;
; None.
;
;--
LEAF_ENTRY RtlZeroMemory, _TEXT$00
xor r8, r8 ; set fill pattern
jmp RtlFillMemory ; finish in common code
LEAF_END RtlZeroMemory, _TEXT$00
end
|
Transynther/x86/_processed/NONE/_xt_/i9-9900K_12_0xca_notsx.log_8_673.asm | ljhsiun2/medusa | 9 | 161953 | .global s_prepare_buffers
s_prepare_buffers:
push %r12
push %r13
push %r14
push %r15
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_D_ht+0x1d424, %r14
nop
nop
nop
add %rdi, %rdi
mov (%r14), %r15w
nop
nop
add %rbx, %rbx
lea addresses_WC_ht+0xc10c, %rdx
nop
nop
nop
nop
add $28246, %r13
vmovups (%rdx), %ymm7
vextracti128 $1, %ymm7, %xmm7
vpextrq $1, %xmm7, %r12
nop
nop
nop
nop
add $27841, %rdx
lea addresses_A_ht+0x11d54, %rdi
nop
nop
nop
nop
nop
xor %r12, %r12
mov (%rdi), %r13
nop
xor $21156, %r12
lea addresses_WC_ht+0x6bc4, %rdi
nop
nop
nop
nop
and %r14, %r14
movb $0x61, (%rdi)
xor $14885, %r12
lea addresses_WC_ht+0x188bc, %rsi
lea addresses_UC_ht+0xb8d4, %rdi
clflush (%rdi)
nop
nop
nop
nop
add $12194, %r13
mov $18, %rcx
rep movsw
nop
nop
nop
nop
nop
cmp $51664, %rbx
lea addresses_UC_ht+0x18554, %rdi
clflush (%rdi)
nop
nop
nop
nop
cmp %r12, %r12
movb $0x61, (%rdi)
nop
nop
nop
nop
sub $45388, %r13
lea addresses_WC_ht+0x11d6d, %r14
nop
nop
inc %rdx
mov (%r14), %r15
nop
nop
xor %r13, %r13
lea addresses_WC_ht+0x3bd4, %r15
nop
nop
sub %r14, %r14
movups (%r15), %xmm1
vpextrq $1, %xmm1, %r12
nop
nop
nop
nop
sub %r14, %r14
lea addresses_normal_ht+0xa3b, %r13
nop
nop
nop
nop
nop
and %r12, %r12
mov (%r13), %r14d
nop
nop
nop
xor %rdi, %rdi
lea addresses_UC_ht+0xde54, %r15
nop
sub %r13, %r13
mov (%r15), %rsi
nop
and $58614, %rcx
lea addresses_normal_ht+0xbb54, %rbx
clflush (%rbx)
and $27938, %rsi
mov (%rbx), %r14
nop
nop
nop
nop
and $36659, %rsi
lea addresses_A_ht+0x19f54, %rsi
lea addresses_UC_ht+0x11b54, %rdi
clflush (%rdi)
and %r15, %r15
mov $30, %rcx
rep movsw
nop
sub $14425, %r15
lea addresses_WT_ht+0xd014, %r14
inc %rdx
mov (%r14), %r13d
nop
nop
nop
dec %r13
lea addresses_WT_ht+0x1066c, %rsi
lea addresses_D_ht+0xe5c, %rdi
nop
nop
nop
nop
and %rbx, %rbx
mov $123, %rcx
rep movsb
nop
xor %r12, %r12
lea addresses_normal_ht+0xed54, %rbx
nop
nop
nop
nop
nop
add $2821, %rcx
movb (%rbx), %r15b
nop
nop
nop
nop
nop
xor $3249, %rdx
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %r15
pop %r14
pop %r13
pop %r12
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r14
push %r9
push %rbp
push %rdi
push %rdx
// Load
lea addresses_US+0x16cf4, %r14
nop
add %rdx, %rdx
vmovups (%r14), %ymm6
vextracti128 $0, %ymm6, %xmm6
vpextrq $1, %xmm6, %r11
nop
nop
nop
nop
nop
cmp $3979, %r9
// Store
lea addresses_normal+0x11254, %r11
xor $60837, %rdi
movb $0x51, (%r11)
inc %r11
// Store
lea addresses_RW+0x26e4, %rdx
nop
nop
sub %r10, %r10
movl $0x51525354, (%rdx)
nop
nop
dec %r10
// Store
lea addresses_normal+0xc794, %r14
and %rdx, %rdx
mov $0x5152535455565758, %r9
movq %r9, (%r14)
nop
nop
nop
nop
xor $5036, %r11
// Store
lea addresses_WT+0x2c4, %rdx
nop
nop
dec %rbp
movl $0x51525354, (%rdx)
and %rdx, %rdx
// Store
lea addresses_US+0x1154, %r14
cmp %rbp, %rbp
movb $0x51, (%r14)
nop
nop
nop
nop
nop
sub %rbp, %rbp
// Store
lea addresses_normal+0x5964, %r11
clflush (%r11)
nop
nop
nop
nop
nop
sub %r14, %r14
movl $0x51525354, (%r11)
nop
nop
nop
cmp %r9, %r9
// Store
lea addresses_WC+0xad54, %rdi
add %r10, %r10
mov $0x5152535455565758, %r9
movq %r9, %xmm0
movups %xmm0, (%rdi)
// Exception!!!
nop
nop
nop
nop
nop
mov (0), %r14
nop
and $22072, %r11
// Store
mov $0x454, %rbp
nop
nop
nop
nop
and $38070, %rdx
mov $0x5152535455565758, %r11
movq %r11, (%rbp)
xor $14216, %r9
// Store
lea addresses_PSE+0xd8d4, %r10
nop
nop
nop
nop
and %r14, %r14
movl $0x51525354, (%r10)
nop
nop
nop
xor $60632, %r10
// Load
lea addresses_RW+0xcf4, %r9
nop
xor $56436, %r10
movb (%r9), %r11b
add $1308, %r14
// Faulty Load
lea addresses_D+0x4d54, %rdx
clflush (%rdx)
nop
cmp $1614, %rbp
movb (%rdx), %r10b
lea oracles, %rdi
and $0xff, %r10
shlq $12, %r10
mov (%rdi,%r10,1), %r10
pop %rdx
pop %rdi
pop %rbp
pop %r9
pop %r14
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_D', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 0}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_US', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 2}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_normal', 'NT': False, 'AVXalign': True, 'size': 1, 'congruent': 6}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_RW', 'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 4}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_normal', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 4}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WT', 'NT': True, 'AVXalign': False, 'size': 4, 'congruent': 4}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_US', 'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 8}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_normal', 'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 4}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WC', 'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 10}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_P', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 7}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_PSE', 'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 7}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_RW', 'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 4}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'type': 'addresses_D', 'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_D_ht', 'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 4}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_WC_ht', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 1}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_A_ht', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 10}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WC_ht', 'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 4}}
{'OP': 'REPM', 'src': {'same': True, 'congruent': 1, 'type': 'addresses_WC_ht'}, 'dst': {'same': False, 'congruent': 7, 'type': 'addresses_UC_ht'}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_UC_ht', 'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 11}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_WC_ht', 'NT': True, 'AVXalign': True, 'size': 8, 'congruent': 0}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_WC_ht', 'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 7}}
{'OP': 'LOAD', 'src': {'same': True, 'type': 'addresses_normal_ht', 'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 0}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_UC_ht', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 6}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_normal_ht', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 9}}
{'OP': 'REPM', 'src': {'same': True, 'congruent': 6, 'type': 'addresses_A_ht'}, 'dst': {'same': False, 'congruent': 9, 'type': 'addresses_UC_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_WT_ht', 'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 6}}
{'OP': 'REPM', 'src': {'same': True, 'congruent': 3, 'type': 'addresses_WT_ht'}, 'dst': {'same': False, 'congruent': 2, 'type': 'addresses_D_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_normal_ht', 'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 10}}
{'36': 8}
36 36 36 36 36 36 36 36
*/
|
src/asm/hello.asm | Bigsby/hellolanguages | 0 | 81543 | ; Define variables in the data section
SECTION .DATA
hello: db 'Hello world!',10
helloLen: equ $-hello
; Code goes in the text section
SECTION .TEXT
GLOBAL _start
_start:
mov eax,4 ; 'write' system call = 4
mov ebx,1 ; file descriptor 1 = STDOUT
mov ecx,hello ; string to write
mov edx,helloLen ; length of string to write
int 80h ; call the kernel
; Terminate program
mov eax,1 ; 'exit' system call
mov ebx,0 ; exit with error code 0
int 80h ; call the kernel
; global _main
; extern _printf
; section .text
; _main:
; push message
; call _printf
; add esp, 4
; ret
; message:
; db 'Hello, World!', 0
;> nasm -f win32 hello.asm && gcc hello.obj -o hello & hello.exe |
src/004/t_inv.adb | xeenta/learning-ada | 0 | 27176 | <gh_stars>0
with Ada.Text_IO; use Ada.Text_IO;
procedure T_Inv is
package Internal is
type Unknown is private with
Type_Invariant => Isnt_Bad_Luck (Unknown);
function Isnt_Bad_Luck
(S : Unknown) return Boolean;
procedure Assign (S : out Unknown;
D : in Integer);
function To_String (S : Unknown) return String;
private
type Unknown is new Integer;
end Internal;
package body Internal is
procedure Assign (S : out Unknown;
D : in Integer) is
P : constant Unknown := 13;
begin
-- This is ok: this intermediate value won't go outside here
S := P;
Put_Line ("It's ok " & Integer'Image (Integer (S)));
S := Unknown (D + 2 * Integer (P));
Put_Line ("And now?"); -- let's see what happens later
end Assign;
-- 13 is bad luck - indeed it's just like any other number, but
-- you know, people can believe it.
function Isnt_Bad_Luck (S : Unknown) return Boolean
is (S /= 13);
-- This helps
function To_String (S : Unknown) return String is
(Integer'Image (Integer (S)));
end Internal;
V : Internal.Unknown;
begin
Internal.Assign (V, 11);
Put_Line ("Here it is " & Internal.To_String (V));
Internal.Assign (V, -13);
Put_Line ("And another one " & Internal.To_String (V));
end T_Inv;
|
programs/oeis/120/A120147.asm | karttu/loda | 0 | 12421 | ; A120147: a(1)=23; a(n)=floor((47+sum(a(1) to a(n-1)))/2).
; 23,35,52,78,117,176,264,396,594,891,1336,2004,3006,4509,6764,10146,15219,22828,34242,51363,77045,115567,173351,260026,390039,585059,877588,1316382,1974573,2961860,4442790,6664185,9996277,14994416
add $0,1
mov $3,5
lpb $0,1
mov $2,2
sub $2,$0
sub $0,1
add $3,10
mov $1,$3
div $1,2
add $3,$1
add $1,$2
add $3,6
lpe
add $1,15
|
src/rejuvenation-simple_factory.ads | TNO/Rejuvenation-Ada | 0 | 29412 | with Ada.Containers.Vectors;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Ada.Text_IO; use Ada.Text_IO;
package Rejuvenation.Simple_Factory is
package Analysis_Units is new Ada.Containers.Vectors
(Positive, Analysis_Unit);
package Unbounded_Strings is new Ada.Containers.Vectors
(Positive, Unbounded_String);
Parse_Exception : exception;
procedure Put_Diagnostics (File : File_Type; Unit : Analysis_Unit) with
Pre => Is_Open (File) and then Ada.Text_IO.Mode (File) /= In_File;
procedure Put_Diagnostics (Unit : Analysis_Unit);
function Get_Ada_Source_Files_From_Project
(Project_Filename : String; Recursive : Boolean := True)
return Unbounded_Strings.Vector;
-- Return the file paths of all Ada files in the given project
-- When the project contains subprojects,
-- Ada files in those subprojects will be include based on the
-- value of the Recursive flag
-- Pre: Project_Filename points to an Ada project file
function Get_Ada_Source_Files_From_Directory
(Directory_Name : String; Recursive : Boolean := True)
return Unbounded_Strings.Vector;
-- Return the file paths of all Ada files in the given directory
-- When the directory contains subdirectories,
-- Ada files in those subdirectories will be include based on the
-- value of the Recursive flag
-- Pre: Directory_Name points to an Ada project file
function Analyze_Fragment
(Fragment : String; Rule : Grammar_Rule := Default_Grammar_Rule)
return Analysis_Unit;
-- Return the analysis unit of the given fragment of Ada code
-- Optionally a specific grammar rule can be specified.
-- Raises an exception if parsing fails.
function Analyze_File (Filename : String) return Analysis_Unit;
-- Return the analysis unit of the given Ada file
-- Pre: Filename points to an Ada file
function Analyze_File_In_Project
(Filename : String; Project_Filename : String) return Analysis_Unit;
-- Return the analysis unit of the given Ada file in the context
-- of the given project
-- Pre: Filename points to an Ada file
-- Pre: Project_Filename points to an Ada project file
function Analyze_Project
(Project_Filename : String; Recursive : Boolean := True)
return Analysis_Units.Vector;
-- Return the analysis units of all Ada files in the given project
-- When the project contains subprojects,
-- Ada files in those subprojects will be include based on the
-- value of the Recursive flag
-- Pre: Project_Filename points to an Ada project file
--
-- Current implementation doesn't work around libadalang limitation:
--
-- LIBADALANG.PROJECT_PROVIDER.UNSUPPORTED_VIEW_ERROR:
-- selected project is aggregate and has more than one sub-project
--
-- TODO: Make a workable / reasonable solution!
-- suggestions / background info:
--
-- The situation is more nuanced: even though indeed a given Libadalang
-- context cannot see whole aggregate projects when they contain
-- "conflicting" units, it is perfectly possible for a single command to
-- create one context per aggregated project and run your analysis on all
-- of them. This specific case is illustrated in our documentation with
-- an example: see
-- <https://docs.adacore.com/live/wave/libadalang/html/libadalang_ug/
-- examples/aggregate_projects.html
-- #creating-one-provide-context-for-each-aggregated-project>.
--
-- Note that because of the semantics of aggregate projects, it would
-- make no sense for a single Libadalang context to see units from all
-- aggregated projects at once without adding much complexity to the
-- Libadalang API. For instance, given that multiple units may define the
-- same type several times, the P_Referenced_Decl property would need to
-- be modified to return not "THE declaration" referenced by some
-- expression, but all declarations it may refer to (depending on the
-- "view" inside the aggregated project). This would be probably a great
-- burden for both us (Libadalang implementers) and all Libadalang users
-- (need to deal with a much more complex API even when not dealing with
-- aggregate projects).
end Rejuvenation.Simple_Factory;
|
tools/scitools/sample/mahjongg/screen.adb | brucegua/moocos | 1 | 28852 | <filename>tools/scitools/sample/mahjongg/screen.adb
WITH Text_IO; USE Text_IO;
PACKAGE BODY Screen IS
-- Implementation of package SCREEN
PACKAGE My_Int_IO IS NEW Text_IO.Integer_IO(INTEGER);
PROCEDURE Beep IS
BEGIN
Text_IO.Put (Item => ASCII.BEL);
END Beep;
PROCEDURE ClearScreen IS
BEGIN
Text_IO.Put (Item => ASCII.ESC);
Text_IO.Put (Item => "[2J");
END ClearScreen;
PROCEDURE MoveCursor (Row : Depth; Column : Width ) IS
BEGIN
Text_IO.Put (Item => ASCII.ESC);
Text_IO.Put ("[");
My_Int_IO.Put (Item => Row, Width => 1);
Text_IO.Put (Item => ';');
My_Int_IO.Put (Item => Column, Width => 1);
Text_IO.Put (Item => 'f');
END MoveCursor;
PROCEDURE SetAttribute (The_Attribute: Attribute) IS
BEGIN
Put (ASCII.ESC);
CASE The_Attribute IS
WHEN normal => Put ("[0m");
WHEN bold => Put ("[1m");
WHEN inverse => Put ("[7m");
WHEN blink => Put ("[5m");
END CASE;
END SetAttribute;
PROCEDURE SaveCursor IS
BEGIN
Text_IO.Put (Item => ASCII.ESC);
Text_IO.Put (Item => "7");
END SaveCursor;
PROCEDURE RestoreCursor IS
BEGIN
Text_IO.Put (Item => ASCII.ESC);
Text_IO.Put (Item => "8");
END RestoreCursor;
END Screen;
|
third_party/codecs/xvidcore/src/motion/x86_asm/sad_xmm.asm | Narflex/sagetv | 292 | 7518 | <gh_stars>100-1000
;/****************************************************************************
; *
; * XVID MPEG-4 VIDEO CODEC
; * - K7 optimized SAD operators -
; *
; * Copyright(C) 2001 <NAME> <<EMAIL>>
; * 2001-2008 <NAME> <<EMAIL>>
; * 2002 <NAME> <<EMAIL>>
; *
; * This program 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.
; *
; * 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 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
; *
; * $Id: sad_xmm.asm,v 1.15 2009-09-16 17:07:58 Isibaar Exp $
; *
; ***************************************************************************/
%include "nasm.inc"
;=============================================================================
; Read only data
;=============================================================================
DATA
ALIGN SECTION_ALIGN
mmx_one: times 4 dw 1
;=============================================================================
; Helper macros
;=============================================================================
%macro SAD_16x16_SSE 0
movq mm0, [_EAX]
psadbw mm0, [TMP1]
movq mm1, [_EAX+8]
add _EAX, TMP0
psadbw mm1, [TMP1+8]
paddusw mm5, mm0
add TMP1, TMP0
paddusw mm6, mm1
%endmacro
%macro SAD_8x8_SSE 0
movq mm0, [_EAX]
movq mm1, [_EAX+TMP0]
psadbw mm0, [TMP1]
psadbw mm1, [TMP1+TMP0]
add _EAX, _EBX
add TMP1, _EBX
paddusw mm5, mm0
paddusw mm6, mm1
%endmacro
%macro SADBI_16x16_SSE 0
movq mm0, [_EAX]
movq mm1, [_EAX+8]
movq mm2, [TMP1]
movq mm3, [TMP1+8]
pavgb mm2, [_EBX]
add TMP1, TMP0
pavgb mm3, [_EBX+8]
add _EBX, TMP0
psadbw mm0, mm2
add _EAX, TMP0
psadbw mm1, mm3
paddusw mm5, mm0
paddusw mm6, mm1
%endmacro
%macro SADBI_8x8_XMM 0
movq mm0, [_EAX]
movq mm1, [_EAX+TMP0]
movq mm2, [TMP1]
movq mm3, [TMP1+TMP0]
pavgb mm2, [_EBX]
lea TMP1, [TMP1+2*TMP0]
pavgb mm3, [_EBX+TMP0]
lea _EBX, [_EBX+2*TMP0]
psadbw mm0, mm2
lea _EAX, [_EAX+2*TMP0]
psadbw mm1, mm3
paddusw mm5, mm0
paddusw mm6, mm1
%endmacro
%macro MEAN_16x16_SSE 0
movq mm0, [_EAX]
movq mm1, [_EAX+8]
psadbw mm0, mm7
psadbw mm1, mm7
add _EAX, TMP0
paddw mm5, mm0
paddw mm6, mm1
%endmacro
%macro ABS_16x16_SSE 0
movq mm0, [_EAX]
movq mm1, [_EAX+8]
psadbw mm0, mm4
psadbw mm1, mm4
lea _EAX, [_EAX+TMP0]
paddw mm5, mm0
paddw mm6, mm1
%endmacro
;=============================================================================
; Code
;=============================================================================
TEXT
cglobal sad16_xmm
cglobal sad8_xmm
cglobal sad16bi_xmm
cglobal sad8bi_xmm
cglobal dev16_xmm
cglobal sad16v_xmm
;-----------------------------------------------------------------------------
;
; uint32_t sad16_xmm(const uint8_t * const cur,
; const uint8_t * const ref,
; const uint32_t stride,
; const uint32_t best_sad);
;
;-----------------------------------------------------------------------------
ALIGN SECTION_ALIGN
sad16_xmm:
mov _EAX, prm1 ; Src1
mov TMP1, prm2 ; Src2
mov TMP0, prm3 ; Stride
pxor mm5, mm5 ; accum1
pxor mm6, mm6 ; accum2
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
paddusw mm6,mm5
movd eax, mm6
ret
ENDFUNC
;-----------------------------------------------------------------------------
;
; uint32_t sad8_xmm(const uint8_t * const cur,
; const uint8_t * const ref,
; const uint32_t stride);
;
;-----------------------------------------------------------------------------
ALIGN SECTION_ALIGN
sad8_xmm:
mov _EAX, prm1 ; Src1
mov TMP1, prm2 ; Src2
mov TMP0, prm3 ; Stride
push _EBX
lea _EBX, [TMP0+TMP0]
pxor mm5, mm5 ; accum1
pxor mm6, mm6 ; accum2
SAD_8x8_SSE
SAD_8x8_SSE
SAD_8x8_SSE
movq mm0, [_EAX]
movq mm1, [_EAX+TMP0]
psadbw mm0, [TMP1]
psadbw mm1, [TMP1+TMP0]
pop _EBX
paddusw mm5,mm0
paddusw mm6,mm1
paddusw mm6,mm5
movd eax, mm6
ret
ENDFUNC
;-----------------------------------------------------------------------------
;
; uint32_t sad16bi_xmm(const uint8_t * const cur,
; const uint8_t * const ref1,
; const uint8_t * const ref2,
; const uint32_t stride);
;
;-----------------------------------------------------------------------------
ALIGN SECTION_ALIGN
sad16bi_xmm:
mov _EAX, prm1 ; Src
mov TMP1, prm2 ; Ref1
mov TMP0, prm4 ; Stride
push _EBX
%ifdef ARCH_IS_X86_64
mov _EBX, prm3
%else
mov _EBX, [_ESP+4+12] ; Ref2
%endif
pxor mm5, mm5 ; accum1
pxor mm6, mm6 ; accum2
SADBI_16x16_SSE
SADBI_16x16_SSE
SADBI_16x16_SSE
SADBI_16x16_SSE
SADBI_16x16_SSE
SADBI_16x16_SSE
SADBI_16x16_SSE
SADBI_16x16_SSE
SADBI_16x16_SSE
SADBI_16x16_SSE
SADBI_16x16_SSE
SADBI_16x16_SSE
SADBI_16x16_SSE
SADBI_16x16_SSE
SADBI_16x16_SSE
SADBI_16x16_SSE
paddusw mm6,mm5
movd eax, mm6
pop _EBX
ret
ENDFUNC
;-----------------------------------------------------------------------------
;
; uint32_t sad8bi_xmm(const uint8_t * const cur,
; const uint8_t * const ref1,
; const uint8_t * const ref2,
; const uint32_t stride);
;
;-----------------------------------------------------------------------------
ALIGN SECTION_ALIGN
sad8bi_xmm:
mov _EAX, prm1 ; Src
mov TMP1, prm2 ; Ref1
mov TMP0, prm4 ; Stride
push _EBX
%ifdef ARCH_IS_X86_64
mov _EBX, prm3
%else
mov _EBX, [_ESP+4+12] ; Ref2
%endif
pxor mm5, mm5 ; accum1
pxor mm6, mm6 ; accum2
.Loop:
SADBI_8x8_XMM
SADBI_8x8_XMM
SADBI_8x8_XMM
SADBI_8x8_XMM
paddusw mm6,mm5
movd eax, mm6
pop _EBX
ret
ENDFUNC
;-----------------------------------------------------------------------------
;
; uint32_t dev16_xmm(const uint8_t * const cur,
; const uint32_t stride);
;
;-----------------------------------------------------------------------------
ALIGN SECTION_ALIGN
dev16_xmm:
mov _EAX, prm1 ; Src
mov TMP0, prm2 ; Stride
pxor mm7, mm7 ; zero
pxor mm5, mm5 ; mean accums
pxor mm6, mm6
MEAN_16x16_SSE
MEAN_16x16_SSE
MEAN_16x16_SSE
MEAN_16x16_SSE
MEAN_16x16_SSE
MEAN_16x16_SSE
MEAN_16x16_SSE
MEAN_16x16_SSE
MEAN_16x16_SSE
MEAN_16x16_SSE
MEAN_16x16_SSE
MEAN_16x16_SSE
MEAN_16x16_SSE
MEAN_16x16_SSE
MEAN_16x16_SSE
MEAN_16x16_SSE
paddusw mm6, mm5
movq mm4, mm6
psllq mm4, 32
paddd mm4, mm6
psrld mm4, 8 ; /= (16*16)
packssdw mm4, mm4
packuswb mm4, mm4
; mm4 contains the mean
mov _EAX, prm1 ; Src
pxor mm5, mm5 ; sums
pxor mm6, mm6
ABS_16x16_SSE
ABS_16x16_SSE
ABS_16x16_SSE
ABS_16x16_SSE
ABS_16x16_SSE
ABS_16x16_SSE
ABS_16x16_SSE
ABS_16x16_SSE
ABS_16x16_SSE
ABS_16x16_SSE
ABS_16x16_SSE
ABS_16x16_SSE
ABS_16x16_SSE
ABS_16x16_SSE
ABS_16x16_SSE
ABS_16x16_SSE
paddusw mm6, mm5
movq mm7, mm6
psllq mm7, 32
paddd mm6, mm7
movd eax, mm6
ret
ENDFUNC
;-----------------------------------------------------------------------------
;int sad16v_xmm(const uint8_t * const cur,
; const uint8_t * const ref,
; const uint32_t stride,
; int* sad8);
;-----------------------------------------------------------------------------
ALIGN SECTION_ALIGN
sad16v_xmm:
mov _EAX, prm1 ; Src1
mov TMP1, prm2 ; Src2
mov TMP0, prm3 ; Stride
push _EBX
%ifdef ARCH_IS_X86_64
mov _EBX, prm4
%else
mov _EBX, [_ESP+4+16] ; sad ptr
%endif
pxor mm5, mm5 ; accum1
pxor mm6, mm6 ; accum2
pxor mm7, mm7 ; total
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
paddusw mm7, mm5
paddusw mm7, mm6
movd [_EBX], mm5
movd [_EBX+4], mm6
pxor mm5, mm5 ; accum1
pxor mm6, mm6 ; accum2
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
SAD_16x16_SSE
paddusw mm7, mm5
paddusw mm7, mm6
movd [_EBX+8], mm5
movd [_EBX+12], mm6
movd eax, mm7
pop _EBX
ret
ENDFUNC
NON_EXEC_STACK
|
weakening.agda | hazelgrove/hazelnut-dynamics-agda | 16 | 8360 | <reponame>hazelgrove/hazelnut-dynamics-agda<filename>weakening.agda
open import Nat
open import Prelude
open import core
open import contexts
open import lemmas-disjointness
open import exchange
-- this module contains all the proofs of different weakening structural
-- properties that we use for the hypothetical judgements
module weakening where
mutual
weaken-subst-Δ : ∀{Δ1 Δ2 Γ σ Γ'} → Δ1 ## Δ2
→ Δ1 , Γ ⊢ σ :s: Γ'
→ (Δ1 ∪ Δ2) , Γ ⊢ σ :s: Γ'
weaken-subst-Δ disj (STAId x) = STAId x
weaken-subst-Δ disj (STASubst subst x) = STASubst (weaken-subst-Δ disj subst) (weaken-ta-Δ1 disj x)
weaken-ta-Δ1 : ∀{Δ1 Δ2 Γ d τ} → Δ1 ## Δ2
→ Δ1 , Γ ⊢ d :: τ
→ (Δ1 ∪ Δ2) , Γ ⊢ d :: τ
weaken-ta-Δ1 disj TAConst = TAConst
weaken-ta-Δ1 disj (TAVar x₁) = TAVar x₁
weaken-ta-Δ1 disj (TALam x₁ wt) = TALam x₁ (weaken-ta-Δ1 disj wt)
weaken-ta-Δ1 disj (TAAp wt wt₁) = TAAp (weaken-ta-Δ1 disj wt) (weaken-ta-Δ1 disj wt₁)
weaken-ta-Δ1 {Δ1} {Δ2} {Γ} disj (TAEHole {u = u} {Γ' = Γ'} x x₁) = TAEHole (x∈∪l Δ1 Δ2 u _ x ) (weaken-subst-Δ disj x₁)
weaken-ta-Δ1 {Δ1} {Δ2} {Γ} disj (TANEHole {Γ' = Γ'} {u = u} x wt x₁) = TANEHole (x∈∪l Δ1 Δ2 u _ x) (weaken-ta-Δ1 disj wt) (weaken-subst-Δ disj x₁)
weaken-ta-Δ1 disj (TACast wt x) = TACast (weaken-ta-Δ1 disj wt) x
weaken-ta-Δ1 disj (TAFailedCast wt x x₁ x₂) = TAFailedCast (weaken-ta-Δ1 disj wt) x x₁ x₂
-- this is a little bit of a time saver. since ∪ is commutative on
-- disjoint contexts, and we need that premise anyway in both positions,
-- there's no real reason to repeat the inductive argument above
weaken-ta-Δ2 : ∀{Δ1 Δ2 Γ d τ} → Δ1 ## Δ2
→ Δ2 , Γ ⊢ d :: τ
→ (Δ1 ∪ Δ2) , Γ ⊢ d :: τ
weaken-ta-Δ2 {Δ1} {Δ2} {Γ} {d} {τ} disj D = tr (λ q → q , Γ ⊢ d :: τ) (∪comm Δ2 Δ1 (##-comm disj)) (weaken-ta-Δ1 (##-comm disj) D)
-- note that these statements are somewhat stronger than usual. this is
-- because we don't have implcit α-conversion. this reifies the
-- often-silent on paper assumption that if you collide with a bound
-- variable you can just α-convert it away and not worry.
mutual
weaken-synth : ∀{ x Γ e τ τ'} → freshh x e
→ Γ ⊢ e => τ
→ (Γ ,, (x , τ')) ⊢ e => τ
weaken-synth FRHConst SConst = SConst
weaken-synth (FRHAsc frsh) (SAsc x₁) = SAsc (weaken-ana frsh x₁)
weaken-synth {Γ = Γ} (FRHVar {x = x} x₁) (SVar {x = y} x₂) = SVar (x∈∪l Γ (■(x , _)) y _ x₂)
weaken-synth {Γ = Γ} (FRHLam2 x₁ frsh) (SLam x₂ wt) =
SLam (apart-extend1 Γ (flip x₁) x₂)
(exchange-synth {Γ = Γ} (flip x₁) ((weaken-synth frsh wt)))
weaken-synth FRHEHole SEHole = SEHole
weaken-synth (FRHNEHole frsh) (SNEHole x₁ wt) = SNEHole x₁ (weaken-synth frsh wt)
weaken-synth (FRHAp frsh frsh₁) (SAp x₁ wt x₂ x₃) = SAp x₁ (weaken-synth frsh wt) x₂ (weaken-ana frsh₁ x₃)
weaken-ana : ∀{x Γ e τ τ'} → freshh x e
→ Γ ⊢ e <= τ
→ (Γ ,, (x , τ')) ⊢ e <= τ
weaken-ana frsh (ASubsume x₁ x₂) = ASubsume (weaken-synth frsh x₁) x₂
weaken-ana {Γ = Γ} (FRHLam1 neq frsh) (ALam x₂ x₃ wt) =
ALam (apart-extend1 Γ (flip neq) x₂)
x₃
(exchange-ana {Γ = Γ} (flip neq) (weaken-ana frsh wt))
mutual
weaken-subst-Γ : ∀{ x Γ Δ σ Γ' τ} →
envfresh x σ →
Δ , Γ ⊢ σ :s: Γ' →
Δ , (Γ ,, (x , τ)) ⊢ σ :s: Γ'
weaken-subst-Γ {Γ = Γ} (EFId x₁) (STAId x₂) = STAId (λ x τ x₃ → x∈∪l Γ _ x τ (x₂ x τ x₃) )
weaken-subst-Γ {x = x} {Γ = Γ} (EFSubst x₁ efrsh x₂) (STASubst {y = y} {τ = τ'} subst x₃) =
STASubst (exchange-subst-Γ {Γ = Γ} (flip x₂) (weaken-subst-Γ {Γ = Γ ,, (y , τ')} efrsh subst))
(weaken-ta x₁ x₃)
weaken-ta : ∀{x Γ Δ d τ τ'} →
fresh x d →
Δ , Γ ⊢ d :: τ →
Δ , Γ ,, (x , τ') ⊢ d :: τ
weaken-ta _ TAConst = TAConst
weaken-ta {x} {Γ} {_} {_} {τ} {τ'} (FVar x₂) (TAVar x₃) = TAVar (x∈∪l Γ (■ (x , τ')) _ _ x₃)
weaken-ta {x = x} frsh (TALam {x = y} x₂ wt) with natEQ x y
weaken-ta (FLam x₁ x₂) (TALam x₃ wt) | Inl refl = abort (x₁ refl)
weaken-ta {Γ = Γ} {τ' = τ'} (FLam x₁ x₃) (TALam {x = y} x₄ wt) | Inr x₂ = TALam (apart-extend1 Γ (flip x₁) x₄) (exchange-ta-Γ {Γ = Γ} (flip x₁) (weaken-ta x₃ wt))
weaken-ta (FAp frsh frsh₁) (TAAp wt wt₁) = TAAp (weaken-ta frsh wt) (weaken-ta frsh₁ wt₁)
weaken-ta (FHole x₁) (TAEHole x₂ x₃) = TAEHole x₂ (weaken-subst-Γ x₁ x₃)
weaken-ta (FNEHole x₁ frsh) (TANEHole x₂ wt x₃) = TANEHole x₂ (weaken-ta frsh wt) (weaken-subst-Γ x₁ x₃)
weaken-ta (FCast frsh) (TACast wt x₁) = TACast (weaken-ta frsh wt) x₁
weaken-ta (FFailedCast frsh) (TAFailedCast wt x₁ x₂ x₃) = TAFailedCast (weaken-ta frsh wt) x₁ x₂ x₃
|
src/shaders/post_processing/gen5_6/Common/PL8x4_Save_NV12.asm | tizenorg/platform.upstream.libva-intel-driver | 0 | 245815 | <filename>src/shaders/post_processing/gen5_6/Common/PL8x4_Save_NV12.asm
/*
* All Video Processing kernels
* Copyright © <2010>, Intel Corporation.
*
* This program is licensed under the terms and conditions of the
* Eclipse Public License (EPL), version 1.0. The full text of the EPL is at
* http://www.opensource.org/licenses/eclipse-1.0.php.
*
*/
// Module name: PL8x4_Save_NV12.asm
//
// Save entire current planar frame data block of size 16x8
//---------------------------------------------------------------
// Symbols needed to be defined before including this module
//
// DWORD_ALIGNED_DEST: only if DEST_Y, DEST_U, DEST_V data are DWord aligned
// ORIX:
//---------------------------------------------------------------
#include "PL8x4_Save_NV12.inc"
mov (8) mMSGHDR<1>:ud rMSGSRC<8;8,1>:ud
#if !defined(SAVE_UV_ONLY)
// Save current planar frame Y block data (16x8) -------------------------------
mov (2) mMSGHDR.0<1>:d wORIX<2;2,1>:w // Block origin
mov (1) mMSGHDR.2<1>:ud nDPW_BLOCK_SIZE_Y:ud // Block width and height (16x8)
#endif
//Use the mask to determine which pixels shouldn't be over-written
and (1) acc0<1>:ud udBLOCK_MASK<0;1,0>:ud 0x00FFFFFF:ud
cmp.ge.f0.0 (1) dNULLREG acc0<0;1,0>:ud 0x00FFFFFF:ud //Check if all pixels in the block need to be modified
(f0.0) jmpi WritePlanarToDataPort
//If mask is not all 1's, then load the entire 16x8 block
//so that only those bytes may be modified that need to be (using the mask)
send (8) udSRC_Y(0)<1> mMSGHDR udDUMMY_NULL nDATAPORT_READ nDPMR_MSGDSC+nDPR_MSG_SIZE_Y+nBI_DESTINATION_Y:ud //16x8
asr (1) rMSGSRC.1<1>:ud wORIY<0;1,0>:w 1:w { NoDDClr } // U/V block origin should be half of Y's
mov (1) rMSGSRC.2<1>:ud nDPW_BLOCK_SIZE_UV:ud { NoDDChk } // Block width and height (16x4)
mov (8) mMSGHDR<1>:ud rMSGSRC<8;8,1>:ud //move message desrcptor to the message header
send (8) udSRC_U(0)<1> mMSGHDR udDUMMY_NULL nDATAPORT_READ nDPMR_MSGDSC+nDPR_MSG_SIZE_UV+nBI_DESTINATION_UV:ud
//Restore the origin information
mov (2) rMSGSRC.0<1>:ud wORIX<2;2,1>:w // Block origin
mov (1) rMSGSRC.2<1>:ud nDPW_BLOCK_SIZE_Y:ud // Block width and height (16x8)
mov (8) mMSGHDR<1>:ud rMSGSRC<8;8,1>:ud //move message desrcptor to the message header
//Merge the data
mov (1) f0.1:uw ubBLOCK_MASK_V:ub //Load the mask on flag reg
(f0.1) mov (8) rMASK_TEMP<1>:uw uwBLOCK_MASK_H:uw
(-f0.1) mov (8) rMASK_TEMP<1>:uw 0:uw
//convert the mask from 16bits to 8bits by selecting every other bit
mov (1) udMASK_TEMP1(0,0)<1> 0x00040001:ud
mov (1) udMASK_TEMP1(0,1)<1> 0x00400010:ud
mov (1) udMASK_TEMP1(0,2)<1> 0x04000100:ud
mov (1) udMASK_TEMP1(0,3)<1> 0x40001000:ud
//merge the loaded block with the current block
$for(0,0; <nY_NUM_OF_ROWS; 2,1) {
mov (1) f0.1:uw uwMASK_TEMP(0, %1)<0;1,0>
(-f0.1) mov (16) ubDEST_Y(0,%1*32)<2> ubSRC_Y(0,%1*16)
and.nz.f0.1 (8) wNULLREG uwMASK_TEMP(0,%1)<0;1,0> uwMASK_TEMP1(0,0) //change the mask by selecting every other bit
(-f0.1) mov (8) ubDEST_U(0, %2*16)<2> ub2SRC_U(0, %1*8)<16;8,2>
(-f0.1) mov (8) ubDEST_V(0, %2*16)<2> ub2SRC_U(0, %1*8+1)<16;8,2>
mov (1) f0.1:uw uwMASK_TEMP(0,1+%1)<0;1,0>
(-f0.1) mov (16) ubDEST_Y(0, (1+%1)*32)<2> ubSRC_Y(0, (1+%1)*16)
}
WritePlanarToDataPort:
#if !defined(SAVE_UV_ONLY)
$for(0,0; <nY_NUM_OF_ROWS; 2,1) {
mov (16) mubMSGPAYLOAD(%2,0)<1> ub2DEST_Y(%1)REGION(16,2)
mov (16) mubMSGPAYLOAD(%2,16)<1> ub2DEST_Y(%1+1)REGION(16,2)
}
send (8) dNULLREG mMSGHDR udDUMMY_NULL nDATAPORT_WRITE nDPMW_MSGDSC+nDPW_MSG_SIZE_Y+nBI_DESTINATION_Y:ud
#endif
//** Save 8x4 packed U and V -----------------------------------------------------
// we could write directly wORIX to mMSGHDR and then execute asr on it, that way we could
// avoid using rMSGSRC as a buffer and have one command less in code, but it is unknown whether
//it is possible to do asr on mMSGHDR so we use rMSGSRC.
mov (2) rMSGSRC.0<1>:d wORIX<2;2,1>:w // Block origin
asr (1) rMSGSRC.1<1>:d rMSGSRC.1<0;1,0>:d 1:w // U/V block origin should be half of Y's
mov (1) rMSGSRC.2<1>:ud nDPW_BLOCK_SIZE_UV:ud // U/V block width and height (16x4)
mov (8) mMSGHDR<1>:ud rMSGSRC<8;8,1>:ud
$for(0,0; <nY_NUM_OF_ROWS;4,1) {
mov (16) mubMSGPAYLOAD(%2,0)<2> ub2DEST_U(%2)REGION(16,2)
mov (16) mubMSGPAYLOAD(%2,1)<2> ub2DEST_V(%2)REGION(16,2)
}
send (8) dNULLREG mMSGHDR udDUMMY_NULL nDATAPORT_WRITE nDPMW_MSGDSC+nDPW_MSG_SIZE_UV+nBI_DESTINATION_UV:ud
// End of PL8x4_Save_NV12
|
alloy4fun_models/trainstlt/models/7/98AmQjMYQpv82X7RS.als | Kaixi26/org.alloytools.alloy | 0 | 3282 | open main
pred id98AmQjMYQpv82X7RS_prop8 {
always ( all tk:Track | some tk.signal and (tk.signal in Green) implies ( #pos.tk' = #pos.tk ) )
}
pred __repair { id98AmQjMYQpv82X7RS_prop8 }
check __repair { id98AmQjMYQpv82X7RS_prop8 <=> prop8o } |
base/mvdm/dos/v86/dev/keyboard/kdfdv.asm | npocmaka/Windows-Server-2003 | 17 | 177161 | <reponame>npocmaka/Windows-Server-2003<filename>base/mvdm/dos/v86/dev/keyboard/kdfdv.asm
PAGE ,132
TITLE PC DOS 3.3 Keyboard Definition File
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PC DOS 3.3 - NLS Support - Keyboard Defintion File
;; (c) Copyright IBM Corp 198?,...
;;
;; This file contains the keyboard tables for Spanish.
;;
;; Linkage Instructions:
;; Refer to KDF.ASM.
;;
;;
;; Author: <NAME> - IBM Canada Laboratory - May 1986
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
INCLUDE KEYBSHAR.INC ;;
INCLUDE POSTEQU.INC ;;
INCLUDE KEYBMAC.INC ;;
;;
PUBLIC DV_LOGIC ;;
PUBLIC DV_COMMON_XLAT ;;
;;
CODE SEGMENT PUBLIC 'CODE' ;;
ASSUME CS:CODE,DS:CODE ;;
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Standard translate table options are a liner search table
;; (TYPE_2_TAB) and ASCII entries ONLY (ASCII_ONLY)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
STANDARD_TABLE EQU TYPE_2_TAB+ASCII_ONLY
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;***************************************
;; DV State Logic
;;***************************************
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;
DV_LOGIC:
DW LOGIC_END-$ ;; length
;;
DW 0 ;; special features
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; COMMANDS START HERE
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; OPTIONS: If we find a scan match in
;; an XLATT or SET_FLAG operation then
;; exit from INT 9.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
OPTION EXIT_IF_FOUND ;;
;;
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Dead key definitions must come before
;; dead key translations to handle
;; dead key + dead key.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
IFF EITHER_ALT,NOT ;;
ANDF EITHER_CTL,NOT ;;
IFF EITHER_SHIFT ;;
SET_FLAG DEAD_UPPER ;;
ELSEF ;;
SET_FLAG DEAD_LOWER ;;
ENDIFF ;;
ENDIFF ;;
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ACUTE ACCENT TRANSLATIONS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
ACUTE_PROC: ;;
;;
IFF ACUTE,NOT ;;
GOTO DIARESIS_PROC ;;
ENDIFF ;;
;;
RESET_NLS ;;
IFF R_ALT_SHIFT,NOT ;;
XLATT ACUTE_SPACE ;;
ENDIFF ;;
IFF EITHER_CTL,NOT ;;
ANDF EITHER_ALT,NOT ;;
IFF EITHER_SHIFT ;;
IFF CAPS_STATE ;;
XLATT ACUTE_LOWER ;;
ELSEF ;;
XLATT ACUTE_UPPER ;;
ENDIFF ;;
ELSEF ;;
IFF CAPS_STATE ;;
XLATT ACUTE_UPPER ;;
ELSEF ;;
XLATT ACUTE_LOWER ;;
ENDIFF ;;
ENDIFF ;;
ENDIFF ;;
;;
INVALID_ACUTE: ;;
PUT_ERROR_CHAR ACUTE_LOWER ;; If we get here then either the XLATT
BEEP ;; failed or we are ina bad shift state.
GOTO NON_DEAD ;; Either is invalid so BEEP and fall
;; through to generate the second char.
;; Note that the dead key flag will be
;; reset before we get here.
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; DIARESIS ACCENT TRANSLATIONS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
DIARESIS_PROC: ;;
;;
IFF DIARESIS,NOT ;;
GOTO GRAVE_PROC ;;
ENDIFF ;;
;;
RESET_NLS ;;
IFF R_ALT_SHIFT,NOT ;;
XLATT DIARESIS_SPACE ;; exist for 437 so beep for
ENDIFF ;;
IFF EITHER_CTL,NOT ;;
ANDF EITHER_ALT,NOT ;;
IFF EITHER_SHIFT ;;
IFF CAPS_STATE ;;
XLATT DIARESIS_LOWER ;;
ELSEF ;;
XLATT DIARESIS_UPPER ;;
ENDIFF ;;
ELSEF ;;
IFF CAPS_STATE ;;
XLATT DIARESIS_UPPER ;;
ELSEF ;;
XLATT DIARESIS_LOWER ;;
ENDIFF ;;
ENDIFF ;;
ENDIFF ;;
;;
INVALID_DIARESIS: ;;
PUT_ERROR_CHAR DIARESIS_SPACE ;; standalone accent
BEEP ;; Invalid dead key combo.
GOTO NON_DEAD ;;
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; GRAVE ACCENT TRANSLATIONS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
GRAVE_PROC: ;;
;;
IFF GRAVE,NOT ;;
GOTO CIRCUMFLEX_PROC ;;
ENDIFF ;;
;;
RESET_NLS ;;
IFF R_ALT_SHIFT,NOT ;;
XLATT GRAVE_SPACE ;;
ENDIFF ;;
IFF EITHER_CTL,NOT ;;
ANDF EITHER_ALT,NOT ;;
IFF EITHER_SHIFT ;;
IFF CAPS_STATE ;;
XLATT GRAVE_LOWER ;;
ELSEF ;;
XLATT GRAVE_UPPER ;;
ENDIFF ;;
ELSEF ;;
IFF CAPS_STATE,NOT ;;
XLATT GRAVE_LOWER ;;
ELSEF ;;
XLATT GRAVE_UPPER ;;
ENDIFF ;;
ENDIFF ;;
ENDIFF ;;
;;
INVALID_GRAVE: ;;
PUT_ERROR_CHAR GRAVE_LOWER ;; standalone accent
BEEP ;; Invalid dead key combo.
GOTO NON_DEAD ;;
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; CIRCUMFLEX ACCENT TRANSLATIONS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
CIRCUMFLEX_PROC: ;;
;;
IFF CIRCUMFLEX,NOT ;;
GOTO NON_DEAD ;;
ENDIFF ;;
;;
RESET_NLS ;;
IFF R_ALT_SHIFT,NOT ;;
XLATT CIRCUMFLEX_SPACE ;;
ENDIFF ;;
IFF EITHER_CTL,NOT ;;
ANDF EITHER_ALT,NOT ;;
IFF EITHER_SHIFT ;;
IFF CAPS_STATE ;;
XLATT CIRCUMFLEX_LOWER ;;
ELSEF ;;
XLATT CIRCUMFLEX_UPPER ;;
ENDIFF ;;
ELSEF ;;
IFF CAPS_STATE,NOT ;;
XLATT CIRCUMFLEX_LOWER ;;
ELSEF ;;
XLATT CIRCUMFLEX_UPPER ;;
ENDIFF ;;
ENDIFF ;;
ENDIFF ;;
;;
INVALID_CIRCUMFLEX: ;;
PUT_ERROR_CHAR CIRCUMFLEX_LOWER ;; standalone accent
BEEP ;; Invalid dead key combo.
GOTO NON_DEAD ;;
;;
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Upper, lower and third shifts
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
NON_DEAD: ;;
;;
IFKBD G_KB+P12_KB ;; Avoid accidentally translating
ANDF LC_E0 ;; the "/" on the numeric pad of the
EXIT_STATE_LOGIC ;; G keyboard
ENDIFF ;;
;;***BD ADDED FOR ALT, CTRL CASES ;;
IFF EITHER_CTL,NOT ;;
IFF ALT_SHIFT ;; ALT - case
ANDF R_ALT_SHIFT,NOT ;;
XLATT ALT_CASE ;;
ENDIFF ;;
ELSEF ;;
IFF EITHER_ALT,NOT ;; CTRL - case
XLATT CTRL_CASE ;;
ENDIFF ;;
ENDIFF ;;
;;***BD END OF ADDITION
;;
IFF EITHER_ALT,NOT ;; Lower and upper case. Alphabetic
ANDF EITHER_CTL,NOT ;; keys are affected by CAPS LOCK.
IFF EITHER_SHIFT ;; Numeric keys are not.
;;***BD ADDED FOR NUMERIC PAD
IFF NUM_STATE,NOT ;;
XLATT NUMERIC_PAD ;;
ENDIFF ;;
;;***BD END OF ADDITION
XLATT NON_ALPHA_UPPER ;;
IFF CAPS_STATE ;;
XLATT ALPHA_LOWER ;;
ELSEF ;;
XLATT ALPHA_UPPER ;;
ENDIFF ;;
ELSEF ;;
;;***BD ADDED FOR NUMERIC PAD
IFF NUM_STATE ;;
XLATT NUMERIC_PAD ;;
ENDIFF ;;
;;***BD END OF ADDITION
XLATT NON_ALPHA_LOWER ;;
IFF CAPS_STATE ;;
XLATT ALPHA_UPPER ;;
ELSEF ;;
XLATT ALPHA_LOWER ;;
ENDIFF ;;
ENDIFF ;;
ELSEF ;;
IFF EITHER_SHIFT,NOT ;;
IFKBD XT_KB+AT_KB ;;
IFF EITHER_CTL ;;
ANDF ALT_SHIFT ;;
XLATT THIRD_SHIFT ;;
ENDIFF ;;
ELSEF ;;
IFF EITHER_CTL,NOT ;;
ANDF R_ALT_SHIFT ;;
XLATT THIRD_SHIFT ;;
ENDIFF ;;
ENDIFF ;;
ENDIFF ;;
ENDIFF ;;
;;
EXIT_STATE_LOGIC ;;
;;
LOGIC_END: ;;
;;
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;***************************************
;; DV Common Translate Section
;; This section contains translations for the lower 128 characters
;; only since these will never change from code page to code page.
;; In addition the dead key "Set Flag" tables are here since the
;; dead keys are on the same keytops for all code pages.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
PUBLIC DV_COMMON_XLAT ;;
DV_COMMON_XLAT: ;;
;;
DW COMMON_XLAT_END-$ ;; length of section
DW -1 ;; code page
;;
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;***************************************
;;***BD - ADDED FOR ALT CASE
;;******************************
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; CODE PAGE: Common
;; STATE: Alt Case
;; KEYBOARD TYPES: All
;; TABLE TYPE: Translate
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
DW COM_ALT_K2_END-$ ;; length of state section
DB ALT_CASE ;; State ID
DW ANY_KB ;; Keyboard Type
DB -1,-1 ;; Buffer entry for error character
;;
DW COM_ALT_K2_T1_END-$ ;; Size of xlat table
DB TYPE_2_TAB ;; xlat options:
DB 36 ;; number of entries
DB 0CH, 0, 01AH ;; Alt+{
DB 0DH, 0, 01BH ;; Alt+}
DB 010H, 0, 028H ;; Altl+"
DB 011H, 0, 033H ;; Altl+,
DB 012H, 0, 034H ;; Altl+.
DB 013H, 0, 019H ;; Altl+P
DB 014H, 0, 015H ;; Altl+Y
DB 015H, 0, 021H ;; Altl+F
DB 016H, 0, 022H ;; Altl+G
DB 017H, 0, 02EH ;; Altl+C
DB 018H, 0, 013H ;; Altl+R
DB 019H, 0, 026H ;; Altl+L
DB 01AH, 0, 035H ;; Altl+?
DB 01BH, 0, 0DH ;; Altl+=
DB 01EH, 0, 01EH ;; Altl+A
DB 01FH, 0, 018H ;; Altl+O
DB 020H, 0, 012H ;; Altl+E
DB 021H, 0, 016H ;; Altl+U
DB 022H, 0, 017H ;; Altl+I
DB 023H, 0, 020H ;; Altl+D
DB 024H, 0, 023H ;; Altl+H
DB 025H, 0, 014H ;; Altl+T
DB 026H, 0, 031H ;; Altl+N
DB 027H, 0, 01FH ;; Altl+S
DB 028H, 0, 0CH ;; Altl+-
DB 02BH, 0, 02BH ;; Altl+|
DB 02CH, 0, 027H ;; Altl+;
DB 02DH, 0, 010H ;; Altl+Q
DB 02EH, 0, 024H ;; Altl+J
DB 02FH, 0, 025H ;; Altl+K
DB 030H, 0, 02DH ;; Altl+X
DB 031H, 0, 030H ;; Altl+B
DB 032H, 0, 032H ;; Altl+M
DB 033H, 0, 011H ;; Altl+W
DB 034H, 0, 02FH ;; Altl+V
DB 035H, 0, 02CH ;; Altl+Z
COM_ALT_K2_T1_END: ;;
;;
DW 0 ;; Size of xlat table - null table
;;
COM_ALT_K2_END: ;;
;;
;;******************************
;;***BD - ADDED FOR CTRL CASE
;;******************************
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; CODE PAGE: Common
;; STATE: Ctrl Case
;; KEYBOARD TYPES: G_KB+P12_KB+AT
;; TABLE TYPE: Translate
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
DW COM_CTRL_K2_END-$ ;; length of state section
DB CTRL_CASE ;; State ID
DW G_KB+P12_KB+AT_KB ;; Keyboard Type
DB -1,-1 ;; Buffer entry for error character
;;
DW COM_CTRL_K2_T1_END-$ ;; Size of xlat table
DB TYPE_2_TAB ;; xlat options:
DB 36 ;; number of entries
DB 0CH, 01BH, 0CH ;; Ctrl+{
DB 0DH, 01DH, 0DH ;; Ctrl+}
DB 010H, 00H, 010H ;; Ctrl+"
DB 011H, 00H, 011H ;; Ctrl+,
DB 012H, 00H, 012H ;; Ctrl+.
DB 013H, 010H, 013H ;; Ctrl+P
DB 014H, 019H, 014H ;; Ctrl+Y
DB 015H, 06H, 015H ;; Ctrl+F
DB 016H, 07H, 016H ;; Ctrl+G
DB 017H, 03H, 017H ;; Ctrl+C
DB 018H, 012H, 018H ;; Ctrl+R
DB 019H, 0CH, 019H ;; Ctrl+L
DB 01AH, 00H, 01AH ;; Ctrl+?
DB 01BH, 00H, 01BH ;; Ctrl+=
DB 01EH, 01H, 01EH ;; Ctrl+A
DB 01FH, 0FH, 01FH ;; Ctrl+O
DB 020H, 05H, 020H ;; Ctrl+E
DB 021H, 015H, 021H ;; Ctrl+U
DB 022H, 09H, 022H ;; Ctrl+I
DB 023H, 04H, 023H ;; Ctrl+D
DB 024H, 08H, 024H ;; Ctrl+H
DB 025H, 014H, 025H ;; Ctrl+T
DB 026H, 0EH, 026H ;; Ctrl+N
DB 027H, 013H, 027H ;; Ctrl+S
DB 028H, 01FH, 028H ;; Ctrl+-
DB 02BH, 00H, 02BH ;; Ctrl+|
DB 02CH, 00H, 02CH ;; Ctrl+;
DB 02DH, 011H, 02DH ;; Ctrl+Q
DB 02EH, 0AH, 02EH ;; Ctrl+J
DB 02FH, 0BH, 02FH ;; Ctrl+K
DB 030H, 018H, 030H ;; Ctrl+X
DB 031H, 02H, 031H ;; Ctrl+B
DB 032H, 0DH, 032H ;; Ctrl+M
DB 033H, 017H, 033H ;; Ctrl+W
DB 034H, 016H, 034H ;; Ctrl+V
DB 035H, 01AH, 035H ;; Ctrl+Z
COM_CTRL_K2_T1_END: ;;
;;
DW 0 ;; Size of xlat table - null table
;;
COM_CTRL_K2_END: ;;
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; CODE PAGE: Common
;; STATE: Non-Alpha Lower Case
;; KEYBOARD TYPES: G_KB+P12_KB
;; TABLE TYPE: Translate
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
DW COM_NA_LO_K1_END-$ ;; length of state section
DB NON_ALPHA_LOWER ;; State ID
DW ANY_KB ;; Keyboard Type
DB -1,-1 ;; Buffer entry for error character
;;
DW COM_NA_LO_K1_T1_END-$ ;; Size of xlat table
DB STANDARD_TABLE ;; xlat options:
DB 9 ;; number of entries
DB 00CH,"[" ;; '
DB 00DH,']' ;; #
DB 010H,"'" ;; #
DB 011H,',' ;; #
DB 012H,'.' ;; #
DB 01AH,'/' ;; #
DB 01BH,'=' ;; #
DB 028H,'-' ;; #
DB 02CH,';' ;; #
COM_NA_LO_K1_T1_END: ;;
;;
DW 0 ;; Size of xlat table - null table
;;
COM_NA_LO_K1_END: ;;
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; CODE PAGE: Common
;; STATE: Non-Alpha Upper Case
;; KEYBOARD TYPES: G_KB+P12_KB+
;; TABLE TYPE: Translate
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
DW COM_NA_UP_K1_END-$ ;; length of state section
DB NON_ALPHA_UPPER ;; State ID
DW ANY_KB ;; Keyboard Type
DB -1,-1 ;; Buffer entry for error character
;;
DW COM_NA_UP_T1_K1_END-$ ;; Size of xlat table
DB STANDARD_TABLE ;; xlat options:
DB 9 ;; number of entries
DB 00CH,"{" ;; '
DB 00DH,'}' ;; #
DB 010H,'"' ;; #
DB 011H,'<' ;; #
DB 012H,'>' ;; #
DB 01AH,'?' ;; #
DB 01BH,'+' ;; #
DB 028H,'_' ;; #
DB 02CH,':' ;; #
COM_NA_UP_T1_K1_END: ;;
;;
DW 0 ;; Size of xlat table - null table
;;
COM_NA_UP_K1_END: ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; CODE PAGE: COMMON
;; STATE: Alpha Lower Case
;; KEYBOARD TYPES: All
;; TABLE TYPE: Translate
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
DW CPCOM_A_K1_LO_END-$ ;; length of state section
DB ALPHA_LOWER ;; State ID
DW ANY_KB ;; Keyboard Type
DB -1,-1 ;; Buffer entry for error character
;;
;;
DW CPCOM_A_LO_K1_T01_END-$ ;; Size of xlat table
DB STANDARD_TABLE ;; xlat options:
DB 26 ;; number of entries
DB 13H, 'p' ;; j
DB 14H, 'y' ;; l
DB 15H, 'f' ;; m
DB 16H, 'g' ;; f
DB 17H, 'c' ;; p
DB 18H, 'r' ;; p
DB 19H, 'l' ;; p
DB 1EH, 'a' ;; o
DB 1FH, 'o' ;; r
DB 20H, 'e' ;; s
DB 21H, 'u' ;; u
DB 22H, 'i' ;; y
DB 23H, 'd' ;; b
DB 24H, 'h' ;; b
DB 25H, 't' ;; b
DB 26H, 'n' ;; b
DB 27H, 's' ;; b
DB 2DH, 'q' ;; z
DB 2EH, 'j' ;; a
DB 2FH, 'k' ;; e
DB 30H, 'x' ;; h
DB 31H, 'b' ;; t
DB 32H, 'm' ;; d
DB 33H, 'w' ;; c
DB 34H, 'v' ;; k
DB 35H, 'z' ;; k
CPCOM_A_LO_K1_T01_END: ;;
;;
DW 0 ;; Size of xlat table - null table
;;
CPCOM_A_K1_LO_END: ;;
;;
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; CODE PAGE: COMMON
;; STATE: Alpha Upper Case
;; KEYBOARD TYPES: All
;; TABLE TYPE: Translate
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
DW CPCOM_A_K1_UP_END-$ ;; length of state section
DB ALPHA_UPPER ;; State ID
DW ANY_KB ;; Keyboard Type
DB -1,-1 ;; Buffer entry for error character
;;
DW CPCOM_A_UP_K1_T01_END-$ ;; Size of xlat table
DB STANDARD_TABLE ;; xlat options:
DB 26 ;; number of entries
DB 13H, 'P' ;; j
DB 14H, 'Y' ;; l
DB 15H, 'F' ;; m
DB 16H, 'G' ;; f
DB 17H, 'C' ;; p
DB 18H, 'R' ;; p
DB 19H, 'L' ;; p
DB 1EH, 'A' ;; o
DB 1FH, 'O' ;; r
DB 20H, 'E' ;; s
DB 21H, 'U' ;; u
DB 22H, 'I' ;; y
DB 23H, 'D' ;; b
DB 24H, 'H' ;; b
DB 25H, 'T' ;; b
DB 26H, 'N' ;; b
DB 27H, 'S' ;; b
DB 2DH, 'Q' ;; z
DB 2EH, 'J' ;; a
DB 2FH, 'K' ;; e
DB 30H, 'X' ;; h
DB 31H, 'B' ;; t
DB 32H, 'M' ;; d
DB 33H, 'W' ;; c
DB 34H, 'V' ;; k
DB 35H, 'Z' ;; k
CPCOM_A_UP_K1_T01_END: ;;
DW 0 ;; Size of xlat table - null table
;;
CPCOM_A_K1_UP_END: ;;
;;
DW 0 ;; LAST STATE
;;
COMMON_XLAT_END: ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
CODE ENDS ;;
END ;;
|
gtkada_backend/example/main.adb | Fabien-Chouteau/Giza | 7 | 5622 | with Giza.Timers; use Giza.Timers;
with Ada.Real_Time; use Ada.Real_Time;
with Timer_Callback;
use Timer_Callback;
with Giza.Windows; use Giza.Windows;
with Screen_Interface; use Screen_Interface;
with Giza.Widgets.Text; use Giza.Widgets.Text;
with Giza.GUI; use Giza.GUI;
with Giza.Colors; use Giza.Colors;
with Giza.Graphics;
procedure Main is
Main_W : constant Window_Ref := Create;
begin
Screen_Interface.Initialize;
Giza.GUI.Set_Context (Timer_Callback.My_Context'Access);
Giza.GUI.Set_Backend (Timer_Callback.My_Backend'Access);
My_Txt.Set_Foreground (Red);
My_Txt.Set_Background (Forest_Green);
My_Txt.Set_Size ((50, 50));
My_Txt.Set_Text (Timer_Callback.My_Str);
My_Button.Set_Foreground (Black);
My_Button.Set_Background (White);
My_Button.Set_Size ((50, 50));
My_Button.Set_Text (Timer_Callback.Str_Button);
My_Button.Set_Toggle (False);
My_Toggle.Set_Foreground (Medium_Orchid);
My_Toggle.Set_Background (White);
My_Toggle.Set_Size ((50, 50));
My_Toggle.Set_Text (Timer_Callback.Str_Toggle);
My_Toggle.Set_Toggle (True);
Main_W.Set_Size ((100, 100));
Main_W.Add_Child (My_Txt'Access, (0, 0));
Main_W.Add_Child (My_Button'Access, (0, 50));
Main_W.Add_Child (My_Toggle'Access, (50, 0));
Push (Main_W);
Push (ECW);
Set_Timer (Timer_Callback.My_Timer'Access, Clock + Seconds (2));
Event_Loop;
end Main;
|
Transynther/x86/_processed/NONE/_xt_/i7-8650U_0xd2.log_14708_1822.asm | ljhsiun2/medusa | 9 | 84592 | <gh_stars>1-10
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r12
push %r8
push %r9
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_A_ht+0xba4b, %r8
nop
nop
nop
and %rdi, %rdi
and $0xffffffffffffffc0, %r8
vmovntdqa (%r8), %ymm5
vextracti128 $0, %ymm5, %xmm5
vpextrq $1, %xmm5, %rcx
nop
nop
nop
and $36450, %rcx
lea addresses_normal_ht+0x146cb, %rsi
lea addresses_normal_ht+0x1bc4b, %rdi
nop
nop
nop
nop
nop
cmp $4586, %r9
mov $15, %rcx
rep movsw
nop
cmp %rcx, %rcx
lea addresses_WT_ht+0x12fab, %rsi
lea addresses_D_ht+0x364b, %rdi
nop
nop
nop
nop
nop
add $40844, %rdx
mov $125, %rcx
rep movsl
nop
nop
cmp $52141, %r9
lea addresses_A_ht+0xa4b, %rsi
nop
nop
nop
nop
dec %r8
movb $0x61, (%rsi)
nop
and %rdx, %rdx
lea addresses_WT_ht+0xafbd, %rsi
cmp %rdi, %rdi
movw $0x6162, (%rsi)
nop
nop
nop
dec %rcx
lea addresses_WC_ht+0xacab, %r9
nop
nop
xor $37246, %r12
mov $0x6162636465666768, %rdx
movq %rdx, %xmm0
vmovups %ymm0, (%r9)
nop
nop
nop
nop
nop
and %rsi, %rsi
lea addresses_UC_ht+0x814b, %rsi
lea addresses_WC_ht+0xa12e, %rdi
nop
nop
nop
and %r11, %r11
mov $118, %rcx
rep movsw
nop
nop
nop
nop
nop
sub $22726, %rsi
lea addresses_A_ht+0x174bb, %r11
nop
nop
nop
nop
sub %rdx, %rdx
movl $0x61626364, (%r11)
nop
nop
nop
inc %rdx
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %r9
pop %r8
pop %r12
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r14
push %rax
push %rdi
push %rdx
// Faulty Load
lea addresses_normal+0x264b, %rax
nop
nop
nop
sub %r11, %r11
mov (%rax), %edi
lea oracles, %rax
and $0xff, %rdi
shlq $12, %rdi
mov (%rax,%rdi,1), %rdi
pop %rdx
pop %rdi
pop %rax
pop %r14
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_normal', 'size': 16, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_normal', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'type': 'addresses_A_ht', 'size': 32, 'AVXalign': False, 'NT': True, 'congruent': 10, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_normal_ht', 'congruent': 5, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 9, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WT_ht', 'congruent': 3, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 11, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_A_ht', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 9, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'size': 2, 'AVXalign': False, 'NT': True, 'congruent': 1, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 5, 'same': True}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 7, 'same': True}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 0, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_A_ht', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 4, 'same': False}}
{'34': 14708}
34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34
*/
|
tmp1/c55x-sim2/foo/Debug/tasks_sysStk.asm | jwestmoreland/eZdsp-DBG-sim | 1 | 20880 | ;*******************************************************************************
;* TMS320C55x C/C++ Codegen PC v4.4.1 *
;* Date/Time created: Sat Oct 06 06:38:33 2018 *
;*******************************************************************************
.compiler_opts --hll_source=on --mem_model:code=flat --mem_model:data=large --object_format=coff --silicon_core_3_3 --symdebug:dwarf
.mmregs
.cpl_on
.arms_on
.c54cm_off
.asg AR6, FP
.asg XAR6, XFP
.asg DPH, MDP
.model call=c55_std
.model mem=large
.noremark 5002 ; code respects overwrite rules
;*******************************************************************************
;* GLOBAL FILE PARAMETERS *
;* *
;* Architecture : TMS320C55x *
;* Optimizing for : Speed *
;* Memory : Large Model (23-Bit Data Pointers) *
;* Calls : Normal Library ASM calls *
;* Debug Info : Standard TI Debug Information *
;*******************************************************************************
$C$DW$CU .dwtag DW_TAG_compile_unit
.dwattr $C$DW$CU, DW_AT_name("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$CU, DW_AT_producer("TMS320C55x C/C++ Codegen PC v4.4.1 Copyright (c) 1996-2012 Texas Instruments Incorporated")
.dwattr $C$DW$CU, DW_AT_TI_version(0x01)
.dwattr $C$DW$CU, DW_AT_comp_dir("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug")
;******************************************************************************
;* CINIT RECORDS *
;******************************************************************************
.sect ".cinit"
.align 1
.field 2,16
.field _wall_clk_ctr+0,24
.field 0,8
.field 0,32 ; _wall_clk_ctr @ 0
.sect ".cinit"
.align 1
.field 2,16
.field _pxCurrentTCB+0,24
.field 0,8
.field 0,32 ; _pxCurrentTCB @ 0
.sect ".cinit"
.align 1
.field 1,16
.field _uxDeletedTasksWaitingCleanUp+0,24
.field 0,8
.field 0,16 ; _uxDeletedTasksWaitingCleanUp @ 0
.sect ".cinit"
.align 1
.field 1,16
.field _uxCurrentNumberOfTasks+0,24
.field 0,8
.field 0,16 ; _uxCurrentNumberOfTasks @ 0
.sect ".cinit"
.align 1
.field 2,16
.field _xTickCount+0,24
.field 0,8
.field 0,32 ; _xTickCount @ 0
.sect ".cinit"
.align 1
.field 1,16
.field _uxTopReadyPriority+0,24
.field 0,8
.field 0,16 ; _uxTopReadyPriority @ 0
.sect ".cinit"
.align 1
.field 1,16
.field _xSchedulerRunning+0,24
.field 0,8
.field 0,16 ; _xSchedulerRunning @ 0
.sect ".cinit"
.align 1
.field 1,16
.field _uxPendedTicks+0,24
.field 0,8
.field 0,16 ; _uxPendedTicks @ 0
.sect ".cinit"
.align 1
.field 1,16
.field _xYieldPending+0,24
.field 0,8
.field 0,16 ; _xYieldPending @ 0
.sect ".cinit"
.align 1
.field 1,16
.field _xNumOfOverflows+0,24
.field 0,8
.field 0,16 ; _xNumOfOverflows @ 0
.sect ".cinit"
.align 1
.field 1,16
.field _uxTaskNumber+0,24
.field 0,8
.field 0,16 ; _uxTaskNumber @ 0
.sect ".cinit"
.align 1
.field 2,16
.field _xNextTaskUnblockTime+0,24
.field 0,8
.field 0,32 ; _xNextTaskUnblockTime @ 0
.sect ".cinit"
.align 1
.field 2,16
.field _xIdleTaskHandle+0,24
.field 0,8
.field 0,32 ; _xIdleTaskHandle @ 0
.sect ".cinit"
.align 1
.field 1,16
.field _uxSchedulerSuspended+0,24
.field 0,8
.field 0,16 ; _uxSchedulerSuspended @ 0
$C$DW$1 .dwtag DW_TAG_subprogram, DW_AT_name("memset")
.dwattr $C$DW$1, DW_AT_TI_symbol_name("_memset")
.dwattr $C$DW$1, DW_AT_type(*$C$DW$T$3)
.dwattr $C$DW$1, DW_AT_declaration
.dwattr $C$DW$1, DW_AT_external
$C$DW$2 .dwtag DW_TAG_formal_parameter
.dwattr $C$DW$2, DW_AT_type(*$C$DW$T$3)
$C$DW$3 .dwtag DW_TAG_formal_parameter
.dwattr $C$DW$3, DW_AT_type(*$C$DW$T$10)
$C$DW$4 .dwtag DW_TAG_formal_parameter
.dwattr $C$DW$4, DW_AT_type(*$C$DW$T$52)
.dwendtag $C$DW$1
$C$DW$5 .dwtag DW_TAG_subprogram, DW_AT_name("vPortYield")
.dwattr $C$DW$5, DW_AT_TI_symbol_name("_vPortYield")
.dwattr $C$DW$5, DW_AT_declaration
.dwattr $C$DW$5, DW_AT_external
$C$DW$6 .dwtag DW_TAG_subprogram, DW_AT_name("pxPortInitialiseStack")
.dwattr $C$DW$6, DW_AT_TI_symbol_name("_pxPortInitialiseStack")
.dwattr $C$DW$6, DW_AT_declaration
.dwattr $C$DW$6, DW_AT_external
$C$DW$7 .dwtag DW_TAG_formal_parameter
.dwattr $C$DW$7, DW_AT_type(*$C$DW$T$20)
$C$DW$8 .dwtag DW_TAG_formal_parameter
.dwattr $C$DW$8, DW_AT_type(*$C$DW$T$20)
$C$DW$9 .dwtag DW_TAG_formal_parameter
.dwattr $C$DW$9, DW_AT_type(*$C$DW$T$62)
$C$DW$10 .dwtag DW_TAG_formal_parameter
.dwattr $C$DW$10, DW_AT_type(*$C$DW$T$3)
.dwendtag $C$DW$6
$C$DW$11 .dwtag DW_TAG_subprogram, DW_AT_name("pvPortMalloc")
.dwattr $C$DW$11, DW_AT_TI_symbol_name("_pvPortMalloc")
.dwattr $C$DW$11, DW_AT_type(*$C$DW$T$3)
.dwattr $C$DW$11, DW_AT_declaration
.dwattr $C$DW$11, DW_AT_external
$C$DW$12 .dwtag DW_TAG_formal_parameter
.dwattr $C$DW$12, DW_AT_type(*$C$DW$T$52)
.dwendtag $C$DW$11
$C$DW$13 .dwtag DW_TAG_subprogram, DW_AT_name("vPortFree")
.dwattr $C$DW$13, DW_AT_TI_symbol_name("_vPortFree")
.dwattr $C$DW$13, DW_AT_declaration
.dwattr $C$DW$13, DW_AT_external
$C$DW$14 .dwtag DW_TAG_formal_parameter
.dwattr $C$DW$14, DW_AT_type(*$C$DW$T$3)
.dwendtag $C$DW$13
$C$DW$15 .dwtag DW_TAG_subprogram, DW_AT_name("xPortStartScheduler")
.dwattr $C$DW$15, DW_AT_TI_symbol_name("_xPortStartScheduler")
.dwattr $C$DW$15, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$15, DW_AT_declaration
.dwattr $C$DW$15, DW_AT_external
$C$DW$16 .dwtag DW_TAG_subprogram, DW_AT_name("vPortEndScheduler")
.dwattr $C$DW$16, DW_AT_TI_symbol_name("_vPortEndScheduler")
.dwattr $C$DW$16, DW_AT_declaration
.dwattr $C$DW$16, DW_AT_external
$C$DW$17 .dwtag DW_TAG_subprogram, DW_AT_name("vListInitialise")
.dwattr $C$DW$17, DW_AT_TI_symbol_name("_vListInitialise")
.dwattr $C$DW$17, DW_AT_declaration
.dwattr $C$DW$17, DW_AT_external
$C$DW$18 .dwtag DW_TAG_formal_parameter
.dwattr $C$DW$18, DW_AT_type(*$C$DW$T$67)
.dwendtag $C$DW$17
$C$DW$19 .dwtag DW_TAG_subprogram, DW_AT_name("vListInitialiseItem")
.dwattr $C$DW$19, DW_AT_TI_symbol_name("_vListInitialiseItem")
.dwattr $C$DW$19, DW_AT_declaration
.dwattr $C$DW$19, DW_AT_external
$C$DW$20 .dwtag DW_TAG_formal_parameter
.dwattr $C$DW$20, DW_AT_type(*$C$DW$T$70)
.dwendtag $C$DW$19
$C$DW$21 .dwtag DW_TAG_subprogram, DW_AT_name("vListInsert")
.dwattr $C$DW$21, DW_AT_TI_symbol_name("_vListInsert")
.dwattr $C$DW$21, DW_AT_declaration
.dwattr $C$DW$21, DW_AT_external
$C$DW$22 .dwtag DW_TAG_formal_parameter
.dwattr $C$DW$22, DW_AT_type(*$C$DW$T$67)
$C$DW$23 .dwtag DW_TAG_formal_parameter
.dwattr $C$DW$23, DW_AT_type(*$C$DW$T$70)
.dwendtag $C$DW$21
$C$DW$24 .dwtag DW_TAG_subprogram, DW_AT_name("vListInsertEnd")
.dwattr $C$DW$24, DW_AT_TI_symbol_name("_vListInsertEnd")
.dwattr $C$DW$24, DW_AT_declaration
.dwattr $C$DW$24, DW_AT_external
$C$DW$25 .dwtag DW_TAG_formal_parameter
.dwattr $C$DW$25, DW_AT_type(*$C$DW$T$67)
$C$DW$26 .dwtag DW_TAG_formal_parameter
.dwattr $C$DW$26, DW_AT_type(*$C$DW$T$70)
.dwendtag $C$DW$24
$C$DW$27 .dwtag DW_TAG_subprogram, DW_AT_name("uxListRemove")
.dwattr $C$DW$27, DW_AT_TI_symbol_name("_uxListRemove")
.dwattr $C$DW$27, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$27, DW_AT_declaration
.dwattr $C$DW$27, DW_AT_external
$C$DW$28 .dwtag DW_TAG_formal_parameter
.dwattr $C$DW$28, DW_AT_type(*$C$DW$T$70)
.dwendtag $C$DW$27
$C$DW$29 .dwtag DW_TAG_subprogram, DW_AT_name("vApplicationMallocFailedHook")
.dwattr $C$DW$29, DW_AT_TI_symbol_name("_vApplicationMallocFailedHook")
.dwattr $C$DW$29, DW_AT_declaration
.dwattr $C$DW$29, DW_AT_external
$C$DW$30 .dwtag DW_TAG_subprogram, DW_AT_name("vApplicationIdleHook")
.dwattr $C$DW$30, DW_AT_TI_symbol_name("_vApplicationIdleHook")
.dwattr $C$DW$30, DW_AT_declaration
.dwattr $C$DW$30, DW_AT_external
.global _wall_clk_ctr
.bss _wall_clk_ctr,2,0,2
$C$DW$31 .dwtag DW_TAG_variable, DW_AT_name("wall_clk_ctr")
.dwattr $C$DW$31, DW_AT_TI_symbol_name("_wall_clk_ctr")
.dwattr $C$DW$31, DW_AT_location[DW_OP_addr _wall_clk_ctr]
.dwattr $C$DW$31, DW_AT_type(*$C$DW$T$13)
.dwattr $C$DW$31, DW_AT_external
.global _stackStruct
.bss _stackStruct,2,0,2
$C$DW$32 .dwtag DW_TAG_variable, DW_AT_name("stackStruct")
.dwattr $C$DW$32, DW_AT_TI_symbol_name("_stackStruct")
.dwattr $C$DW$32, DW_AT_location[DW_OP_addr _stackStruct]
.dwattr $C$DW$32, DW_AT_type(*$C$DW$T$154)
.dwattr $C$DW$32, DW_AT_external
.global _pxCurrentTCB
.bss _pxCurrentTCB,2,0,2
$C$DW$33 .dwtag DW_TAG_variable, DW_AT_name("pxCurrentTCB")
.dwattr $C$DW$33, DW_AT_TI_symbol_name("_pxCurrentTCB")
.dwattr $C$DW$33, DW_AT_location[DW_OP_addr _pxCurrentTCB]
.dwattr $C$DW$33, DW_AT_type(*$C$DW$T$159)
.dwattr $C$DW$33, DW_AT_external
.bss _pxReadyTasksLists,50,0,2
$C$DW$34 .dwtag DW_TAG_variable, DW_AT_name("pxReadyTasksLists")
.dwattr $C$DW$34, DW_AT_TI_symbol_name("_pxReadyTasksLists")
.dwattr $C$DW$34, DW_AT_type(*$C$DW$T$162)
.dwattr $C$DW$34, DW_AT_location[DW_OP_addr _pxReadyTasksLists]
.bss _xDelayedTaskList1,10,0,2
$C$DW$35 .dwtag DW_TAG_variable, DW_AT_name("xDelayedTaskList1")
.dwattr $C$DW$35, DW_AT_TI_symbol_name("_xDelayedTaskList1")
.dwattr $C$DW$35, DW_AT_type(*$C$DW$T$65)
.dwattr $C$DW$35, DW_AT_location[DW_OP_addr _xDelayedTaskList1]
.bss _xDelayedTaskList2,10,0,2
$C$DW$36 .dwtag DW_TAG_variable, DW_AT_name("xDelayedTaskList2")
.dwattr $C$DW$36, DW_AT_TI_symbol_name("_xDelayedTaskList2")
.dwattr $C$DW$36, DW_AT_type(*$C$DW$T$65)
.dwattr $C$DW$36, DW_AT_location[DW_OP_addr _xDelayedTaskList2]
.bss _pxDelayedTaskList,2,0,2
$C$DW$37 .dwtag DW_TAG_variable, DW_AT_name("pxDelayedTaskList")
.dwattr $C$DW$37, DW_AT_TI_symbol_name("_pxDelayedTaskList")
.dwattr $C$DW$37, DW_AT_type(*$C$DW$T$161)
.dwattr $C$DW$37, DW_AT_location[DW_OP_addr _pxDelayedTaskList]
.bss _pxOverflowDelayedTaskList,2,0,2
$C$DW$38 .dwtag DW_TAG_variable, DW_AT_name("pxOverflowDelayedTaskList")
.dwattr $C$DW$38, DW_AT_TI_symbol_name("_pxOverflowDelayedTaskList")
.dwattr $C$DW$38, DW_AT_type(*$C$DW$T$161)
.dwattr $C$DW$38, DW_AT_location[DW_OP_addr _pxOverflowDelayedTaskList]
.bss _xPendingReadyList,10,0,2
$C$DW$39 .dwtag DW_TAG_variable, DW_AT_name("xPendingReadyList")
.dwattr $C$DW$39, DW_AT_TI_symbol_name("_xPendingReadyList")
.dwattr $C$DW$39, DW_AT_type(*$C$DW$T$65)
.dwattr $C$DW$39, DW_AT_location[DW_OP_addr _xPendingReadyList]
.bss _xTasksWaitingTermination,10,0,2
$C$DW$40 .dwtag DW_TAG_variable, DW_AT_name("xTasksWaitingTermination")
.dwattr $C$DW$40, DW_AT_TI_symbol_name("_xTasksWaitingTermination")
.dwattr $C$DW$40, DW_AT_type(*$C$DW$T$65)
.dwattr $C$DW$40, DW_AT_location[DW_OP_addr _xTasksWaitingTermination]
.bss _uxDeletedTasksWaitingCleanUp,1,0,0
$C$DW$41 .dwtag DW_TAG_variable, DW_AT_name("uxDeletedTasksWaitingCleanUp")
.dwattr $C$DW$41, DW_AT_TI_symbol_name("_uxDeletedTasksWaitingCleanUp")
.dwattr $C$DW$41, DW_AT_type(*$C$DW$T$33)
.dwattr $C$DW$41, DW_AT_location[DW_OP_addr _uxDeletedTasksWaitingCleanUp]
.bss _xSuspendedTaskList,10,0,2
$C$DW$42 .dwtag DW_TAG_variable, DW_AT_name("xSuspendedTaskList")
.dwattr $C$DW$42, DW_AT_TI_symbol_name("_xSuspendedTaskList")
.dwattr $C$DW$42, DW_AT_type(*$C$DW$T$65)
.dwattr $C$DW$42, DW_AT_location[DW_OP_addr _xSuspendedTaskList]
.bss _uxCurrentNumberOfTasks,1,0,0
$C$DW$43 .dwtag DW_TAG_variable, DW_AT_name("uxCurrentNumberOfTasks")
.dwattr $C$DW$43, DW_AT_TI_symbol_name("_uxCurrentNumberOfTasks")
.dwattr $C$DW$43, DW_AT_type(*$C$DW$T$33)
.dwattr $C$DW$43, DW_AT_location[DW_OP_addr _uxCurrentNumberOfTasks]
.bss _xTickCount,2,0,2
$C$DW$44 .dwtag DW_TAG_variable, DW_AT_name("xTickCount")
.dwattr $C$DW$44, DW_AT_TI_symbol_name("_xTickCount")
.dwattr $C$DW$44, DW_AT_type(*$C$DW$T$146)
.dwattr $C$DW$44, DW_AT_location[DW_OP_addr _xTickCount]
.bss _uxTopReadyPriority,1,0,0
$C$DW$45 .dwtag DW_TAG_variable, DW_AT_name("uxTopReadyPriority")
.dwattr $C$DW$45, DW_AT_TI_symbol_name("_uxTopReadyPriority")
.dwattr $C$DW$45, DW_AT_type(*$C$DW$T$33)
.dwattr $C$DW$45, DW_AT_location[DW_OP_addr _uxTopReadyPriority]
.bss _xSchedulerRunning,1,0,0
$C$DW$46 .dwtag DW_TAG_variable, DW_AT_name("xSchedulerRunning")
.dwattr $C$DW$46, DW_AT_TI_symbol_name("_xSchedulerRunning")
.dwattr $C$DW$46, DW_AT_type(*$C$DW$T$118)
.dwattr $C$DW$46, DW_AT_location[DW_OP_addr _xSchedulerRunning]
.bss _uxPendedTicks,1,0,0
$C$DW$47 .dwtag DW_TAG_variable, DW_AT_name("uxPendedTicks")
.dwattr $C$DW$47, DW_AT_TI_symbol_name("_uxPendedTicks")
.dwattr $C$DW$47, DW_AT_type(*$C$DW$T$33)
.dwattr $C$DW$47, DW_AT_location[DW_OP_addr _uxPendedTicks]
.bss _xYieldPending,1,0,0
$C$DW$48 .dwtag DW_TAG_variable, DW_AT_name("xYieldPending")
.dwattr $C$DW$48, DW_AT_TI_symbol_name("_xYieldPending")
.dwattr $C$DW$48, DW_AT_type(*$C$DW$T$118)
.dwattr $C$DW$48, DW_AT_location[DW_OP_addr _xYieldPending]
.bss _xNumOfOverflows,1,0,0
$C$DW$49 .dwtag DW_TAG_variable, DW_AT_name("xNumOfOverflows")
.dwattr $C$DW$49, DW_AT_TI_symbol_name("_xNumOfOverflows")
.dwattr $C$DW$49, DW_AT_type(*$C$DW$T$118)
.dwattr $C$DW$49, DW_AT_location[DW_OP_addr _xNumOfOverflows]
.bss _uxTaskNumber,1,0,0
$C$DW$50 .dwtag DW_TAG_variable, DW_AT_name("uxTaskNumber")
.dwattr $C$DW$50, DW_AT_TI_symbol_name("_uxTaskNumber")
.dwattr $C$DW$50, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$50, DW_AT_location[DW_OP_addr _uxTaskNumber]
.bss _xNextTaskUnblockTime,2,0,2
$C$DW$51 .dwtag DW_TAG_variable, DW_AT_name("xNextTaskUnblockTime")
.dwattr $C$DW$51, DW_AT_TI_symbol_name("_xNextTaskUnblockTime")
.dwattr $C$DW$51, DW_AT_type(*$C$DW$T$146)
.dwattr $C$DW$51, DW_AT_location[DW_OP_addr _xNextTaskUnblockTime]
.bss _xIdleTaskHandle,2,0,2
$C$DW$52 .dwtag DW_TAG_variable, DW_AT_name("xIdleTaskHandle")
.dwattr $C$DW$52, DW_AT_TI_symbol_name("_xIdleTaskHandle")
.dwattr $C$DW$52, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$52, DW_AT_location[DW_OP_addr _xIdleTaskHandle]
.bss _uxSchedulerSuspended,1,0,0
$C$DW$53 .dwtag DW_TAG_variable, DW_AT_name("uxSchedulerSuspended")
.dwattr $C$DW$53, DW_AT_TI_symbol_name("_uxSchedulerSuspended")
.dwattr $C$DW$53, DW_AT_type(*$C$DW$T$33)
.dwattr $C$DW$53, DW_AT_location[DW_OP_addr _uxSchedulerSuspended]
$C$DW$54 .dwtag DW_TAG_variable, DW_AT_name("usCriticalNesting")
.dwattr $C$DW$54, DW_AT_TI_symbol_name("_usCriticalNesting")
.dwattr $C$DW$54, DW_AT_type(*$C$DW$T$143)
.dwattr $C$DW$54, DW_AT_declaration
.dwattr $C$DW$54, DW_AT_external
; F:\t\cc5p5\ccsv5\tools\compiler\c5500_4.4.1\bin\acp55.exe -@f:\\AppData\\Local\\Temp\\0620412
.sect ".text"
.align 4
.global _xTaskCreate
$C$DW$55 .dwtag DW_TAG_subprogram, DW_AT_name("xTaskCreate")
.dwattr $C$DW$55, DW_AT_low_pc(_xTaskCreate)
.dwattr $C$DW$55, DW_AT_high_pc(0x00)
.dwattr $C$DW$55, DW_AT_TI_symbol_name("_xTaskCreate")
.dwattr $C$DW$55, DW_AT_external
.dwattr $C$DW$55, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$55, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$55, DW_AT_TI_begin_line(0x2f3)
.dwattr $C$DW$55, DW_AT_TI_begin_column(0x0d)
.dwattr $C$DW$55, DW_AT_TI_max_frame_size(0x16)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 761,column 2,is_stmt,address _xTaskCreate
.dwfde $C$DW$CIE, _xTaskCreate
$C$DW$56 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxTaskCode")
.dwattr $C$DW$56, DW_AT_TI_symbol_name("_pxTaskCode")
.dwattr $C$DW$56, DW_AT_type(*$C$DW$T$62)
.dwattr $C$DW$56, DW_AT_location[DW_OP_reg1]
$C$DW$57 .dwtag DW_TAG_formal_parameter, DW_AT_name("pcName")
.dwattr $C$DW$57, DW_AT_TI_symbol_name("_pcName")
.dwattr $C$DW$57, DW_AT_type(*$C$DW$T$77)
.dwattr $C$DW$57, DW_AT_location[DW_OP_reg17]
$C$DW$58 .dwtag DW_TAG_formal_parameter, DW_AT_name("usStackDepth")
.dwattr $C$DW$58, DW_AT_TI_symbol_name("_usStackDepth")
.dwattr $C$DW$58, DW_AT_type(*$C$DW$T$122)
.dwattr $C$DW$58, DW_AT_location[DW_OP_reg12]
$C$DW$59 .dwtag DW_TAG_formal_parameter, DW_AT_name("pvParameters")
.dwattr $C$DW$59, DW_AT_TI_symbol_name("_pvParameters")
.dwattr $C$DW$59, DW_AT_type(*$C$DW$T$57)
.dwattr $C$DW$59, DW_AT_location[DW_OP_reg19]
$C$DW$60 .dwtag DW_TAG_formal_parameter, DW_AT_name("uxPriority")
.dwattr $C$DW$60, DW_AT_TI_symbol_name("_uxPriority")
.dwattr $C$DW$60, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$60, DW_AT_location[DW_OP_reg13]
$C$DW$61 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxCreatedTask")
.dwattr $C$DW$61, DW_AT_TI_symbol_name("_pxCreatedTask")
.dwattr $C$DW$61, DW_AT_type(*$C$DW$T$80)
.dwattr $C$DW$61, DW_AT_location[DW_OP_reg21]
;*******************************************************************************
;* FUNCTION NAME: xTaskCreate *
;* *
;* Function Uses Regs : AC0,AC0,AC1,AC1,T0,T1,AR0,XAR0,AR1,XAR1,AR2,XAR2,AR3,*
;* XAR3,AR4,XAR4,SP,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 22 words *
;* (2 return address/alignment) *
;* (20 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_xTaskCreate:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-21, SP
.dwcfi cfa_offset, 22
$C$DW$62 .dwtag DW_TAG_variable, DW_AT_name("pxTaskCode")
.dwattr $C$DW$62, DW_AT_TI_symbol_name("_pxTaskCode")
.dwattr $C$DW$62, DW_AT_type(*$C$DW$T$62)
.dwattr $C$DW$62, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$63 .dwtag DW_TAG_variable, DW_AT_name("pcName")
.dwattr $C$DW$63, DW_AT_TI_symbol_name("_pcName")
.dwattr $C$DW$63, DW_AT_type(*$C$DW$T$77)
.dwattr $C$DW$63, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$64 .dwtag DW_TAG_variable, DW_AT_name("usStackDepth")
.dwattr $C$DW$64, DW_AT_TI_symbol_name("_usStackDepth")
.dwattr $C$DW$64, DW_AT_type(*$C$DW$T$122)
.dwattr $C$DW$64, DW_AT_location[DW_OP_bregx 0x24 4]
$C$DW$65 .dwtag DW_TAG_variable, DW_AT_name("pvParameters")
.dwattr $C$DW$65, DW_AT_TI_symbol_name("_pvParameters")
.dwattr $C$DW$65, DW_AT_type(*$C$DW$T$57)
.dwattr $C$DW$65, DW_AT_location[DW_OP_bregx 0x24 6]
$C$DW$66 .dwtag DW_TAG_variable, DW_AT_name("uxPriority")
.dwattr $C$DW$66, DW_AT_TI_symbol_name("_uxPriority")
.dwattr $C$DW$66, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$66, DW_AT_location[DW_OP_bregx 0x24 8]
$C$DW$67 .dwtag DW_TAG_variable, DW_AT_name("pxCreatedTask")
.dwattr $C$DW$67, DW_AT_TI_symbol_name("_pxCreatedTask")
.dwattr $C$DW$67, DW_AT_type(*$C$DW$T$80)
.dwattr $C$DW$67, DW_AT_location[DW_OP_bregx 0x24 10]
$C$DW$68 .dwtag DW_TAG_variable, DW_AT_name("pxNewTCB")
.dwattr $C$DW$68, DW_AT_TI_symbol_name("_pxNewTCB")
.dwattr $C$DW$68, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$68, DW_AT_location[DW_OP_bregx 0x24 12]
$C$DW$69 .dwtag DW_TAG_variable, DW_AT_name("xReturn")
.dwattr $C$DW$69, DW_AT_TI_symbol_name("_xReturn")
.dwattr $C$DW$69, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$69, DW_AT_location[DW_OP_bregx 0x24 14]
$C$DW$70 .dwtag DW_TAG_variable, DW_AT_name("pxStack")
.dwattr $C$DW$70, DW_AT_TI_symbol_name("_pxStack")
.dwattr $C$DW$70, DW_AT_type(*$C$DW$T$20)
.dwattr $C$DW$70, DW_AT_location[DW_OP_bregx 0x24 16]
$C$DW$71 .dwtag DW_TAG_variable, DW_AT_name("pxSysStack")
.dwattr $C$DW$71, DW_AT_TI_symbol_name("_pxSysStack")
.dwattr $C$DW$71, DW_AT_type(*$C$DW$T$20)
.dwattr $C$DW$71, DW_AT_location[DW_OP_bregx 0x24 18]
MOV XAR2, dbl(*SP(#10))
MOV T1, *SP(#8) ; |761|
MOV XAR1, dbl(*SP(#6))
MOV T0, *SP(#4) ; |761|
MOV XAR0, dbl(*SP(#2))
MOV AC0, dbl(*SP(#0)) ; |761|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 799,column 4,is_stmt
MOV *SP(#4), T0 ; |799|
$C$DW$72 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$72, DW_AT_low_pc(0x00)
.dwattr $C$DW$72, DW_AT_name("_pvPortMalloc")
.dwattr $C$DW$72, DW_AT_TI_call
CALL #_pvPortMalloc ; |799|
; call occurs [#_pvPortMalloc] ; |799|
MOV XAR0, dbl(*SP(#16))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 800,column 4,is_stmt
MOV *SP(#4), T0 ; |800|
$C$DW$73 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$73, DW_AT_low_pc(0x00)
.dwattr $C$DW$73, DW_AT_name("_pvPortMalloc")
.dwattr $C$DW$73, DW_AT_TI_call
CALL #_pvPortMalloc ; |800|
; call occurs [#_pvPortMalloc] ; |800|
MOV XAR0, dbl(*SP(#18))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 802,column 4,is_stmt
MOV dbl(*SP(#16)), XAR3
MOV XAR3, AC0
BCC $C$L2,AC0 == #0 ; |802|
; branchcc occurs ; |802|
MOV dbl(*SP(#18)), XAR3
MOV XAR3, AC0
BCC $C$L2,AC0 == #0 ; |802|
; branchcc occurs ; |802|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 805,column 5,is_stmt
MOV #50, T0 ; |805|
$C$DW$74 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$74, DW_AT_low_pc(0x00)
.dwattr $C$DW$74, DW_AT_name("_pvPortMalloc")
.dwattr $C$DW$74, DW_AT_TI_call
CALL #_pvPortMalloc ; |805|
; call occurs [#_pvPortMalloc] ; |805|
MOV XAR0, dbl(*SP(#12))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 807,column 5,is_stmt
MOV dbl(*SP(#12)), XAR3
MOV XAR3, AC0
BCC $C$L1,AC0 == #0 ; |807|
; branchcc occurs ; |807|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 810,column 6,is_stmt
MOV dbl(*SP(#12)), XAR2
MOV dbl(*SP(#16)), XAR3
MOV XAR3, dbl(*AR2(#26))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 811,column 6,is_stmt
MOV dbl(*SP(#12)), XAR2
MOV dbl(*SP(#18)), XAR3
MOV XAR3, dbl(*AR2(#28))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 812,column 5,is_stmt
B $C$L3 ; |812|
; branch occurs ; |812|
$C$L1:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 817,column 6,is_stmt
MOV dbl(*SP(#16)), XAR0
$C$DW$75 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$75, DW_AT_low_pc(0x00)
.dwattr $C$DW$75, DW_AT_name("_vPortFree")
.dwattr $C$DW$75, DW_AT_TI_call
CALL #_vPortFree ; |817|
; call occurs [#_vPortFree] ; |817|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 818,column 6,is_stmt
MOV dbl(*SP(#18)), XAR0
$C$DW$76 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$76, DW_AT_low_pc(0x00)
.dwattr $C$DW$76, DW_AT_name("_vPortFree")
.dwattr $C$DW$76, DW_AT_TI_call
CALL #_vPortFree ; |818|
; call occurs [#_vPortFree] ; |818|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 820,column 4,is_stmt
B $C$L3 ; |820|
; branch occurs ; |820|
$C$L2:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 823,column 5,is_stmt
MOV #0, AC0 ; |823|
MOV AC0, dbl(*SP(#12))
$C$L3:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 828,column 3,is_stmt
MOV dbl(*SP(#12)), XAR3
MOV XAR3, AC0
BCC $C$L4,AC0 == #0 ; |828|
; branchcc occurs ; |828|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 838,column 4,is_stmt
MOV uns(*SP(#4)), AC1 ; |838|
MOV dbl(*SP(#0)), AC0 ; |838|
MOV dbl(*SP(#2)), XAR0
MOV dbl(*SP(#6)), XAR1
MOV *SP(#8), T0 ; |838|
MOV dbl(*SP(#10)), XAR2
AMOV #0, XAR4 ; |838|
$C$DW$77 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$77, DW_AT_low_pc(0x00)
.dwattr $C$DW$77, DW_AT_name("_prvInitialiseNewTask")
.dwattr $C$DW$77, DW_AT_TI_call
CALL #_prvInitialiseNewTask ; |838|
; call occurs [#_prvInitialiseNewTask] ; |838|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 839,column 4,is_stmt
MOV dbl(*SP(#12)), XAR0
$C$DW$78 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$78, DW_AT_low_pc(0x00)
.dwattr $C$DW$78, DW_AT_name("_prvAddNewTaskToReadyList")
.dwattr $C$DW$78, DW_AT_TI_call
CALL #_prvAddNewTaskToReadyList ; |839|
; call occurs [#_prvAddNewTaskToReadyList] ; |839|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 840,column 4,is_stmt
MOV #1, *SP(#14) ; |840|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 841,column 3,is_stmt
B $C$L5 ; |841|
; branch occurs ; |841|
$C$L4:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 844,column 4,is_stmt
MOV #-1, *SP(#14) ; |844|
$C$L5:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 847,column 3,is_stmt
MOV *SP(#14), T0 ; |847|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 848,column 2,is_stmt
AADD #21, SP
.dwcfi cfa_offset, 1
$C$DW$79 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$79, DW_AT_low_pc(0x00)
.dwattr $C$DW$79, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$55, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$55, DW_AT_TI_end_line(0x350)
.dwattr $C$DW$55, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$55
.sect ".text"
.align 4
$C$DW$80 .dwtag DW_TAG_subprogram, DW_AT_name("prvInitialiseNewTask")
.dwattr $C$DW$80, DW_AT_low_pc(_prvInitialiseNewTask)
.dwattr $C$DW$80, DW_AT_high_pc(0x00)
.dwattr $C$DW$80, DW_AT_TI_symbol_name("_prvInitialiseNewTask")
.dwattr $C$DW$80, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$80, DW_AT_TI_begin_line(0x355)
.dwattr $C$DW$80, DW_AT_TI_begin_column(0x0d)
.dwattr $C$DW$80, DW_AT_TI_max_frame_size(0x16)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 861,column 1,is_stmt,address _prvInitialiseNewTask
.dwfde $C$DW$CIE, _prvInitialiseNewTask
$C$DW$81 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxTaskCode")
.dwattr $C$DW$81, DW_AT_TI_symbol_name("_pxTaskCode")
.dwattr $C$DW$81, DW_AT_type(*$C$DW$T$62)
.dwattr $C$DW$81, DW_AT_location[DW_OP_reg1]
$C$DW$82 .dwtag DW_TAG_formal_parameter, DW_AT_name("pcName")
.dwattr $C$DW$82, DW_AT_TI_symbol_name("_pcName")
.dwattr $C$DW$82, DW_AT_type(*$C$DW$T$77)
.dwattr $C$DW$82, DW_AT_location[DW_OP_reg17]
$C$DW$83 .dwtag DW_TAG_formal_parameter, DW_AT_name("ulStackDepth")
.dwattr $C$DW$83, DW_AT_TI_symbol_name("_ulStackDepth")
.dwattr $C$DW$83, DW_AT_type(*$C$DW$T$78)
.dwattr $C$DW$83, DW_AT_location[DW_OP_reg3]
$C$DW$84 .dwtag DW_TAG_formal_parameter, DW_AT_name("pvParameters")
.dwattr $C$DW$84, DW_AT_TI_symbol_name("_pvParameters")
.dwattr $C$DW$84, DW_AT_type(*$C$DW$T$57)
.dwattr $C$DW$84, DW_AT_location[DW_OP_reg19]
$C$DW$85 .dwtag DW_TAG_formal_parameter, DW_AT_name("uxPriority")
.dwattr $C$DW$85, DW_AT_TI_symbol_name("_uxPriority")
.dwattr $C$DW$85, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$85, DW_AT_location[DW_OP_reg12]
$C$DW$86 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxCreatedTask")
.dwattr $C$DW$86, DW_AT_TI_symbol_name("_pxCreatedTask")
.dwattr $C$DW$86, DW_AT_type(*$C$DW$T$80)
.dwattr $C$DW$86, DW_AT_location[DW_OP_reg21]
$C$DW$87 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxNewTCB")
.dwattr $C$DW$87, DW_AT_TI_symbol_name("_pxNewTCB")
.dwattr $C$DW$87, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$87, DW_AT_location[DW_OP_reg23]
$C$DW$88 .dwtag DW_TAG_formal_parameter, DW_AT_name("xRegions")
.dwattr $C$DW$88, DW_AT_TI_symbol_name("_xRegions")
.dwattr $C$DW$88, DW_AT_type(*$C$DW$T$87)
.dwattr $C$DW$88, DW_AT_location[DW_OP_reg25]
;*******************************************************************************
;* FUNCTION NAME: prvInitialiseNewTask *
;* *
;* Function Uses Regs : AC0,AC0,AC1,AC1,T0,T1,AR0,XAR0,AR1,XAR1,AR2,XAR2,AR3,*
;* XAR3,AR4,XAR4,SP,CARRY,TC1,M40,SATA,SATD,RDM,FRCT, *
;* SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 22 words *
;* (1 return address/alignment) *
;* (21 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_prvInitialiseNewTask:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-21, SP
.dwcfi cfa_offset, 22
$C$DW$89 .dwtag DW_TAG_variable, DW_AT_name("pxTaskCode")
.dwattr $C$DW$89, DW_AT_TI_symbol_name("_pxTaskCode")
.dwattr $C$DW$89, DW_AT_type(*$C$DW$T$62)
.dwattr $C$DW$89, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$90 .dwtag DW_TAG_variable, DW_AT_name("pcName")
.dwattr $C$DW$90, DW_AT_TI_symbol_name("_pcName")
.dwattr $C$DW$90, DW_AT_type(*$C$DW$T$77)
.dwattr $C$DW$90, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$91 .dwtag DW_TAG_variable, DW_AT_name("ulStackDepth")
.dwattr $C$DW$91, DW_AT_TI_symbol_name("_ulStackDepth")
.dwattr $C$DW$91, DW_AT_type(*$C$DW$T$78)
.dwattr $C$DW$91, DW_AT_location[DW_OP_bregx 0x24 4]
$C$DW$92 .dwtag DW_TAG_variable, DW_AT_name("pvParameters")
.dwattr $C$DW$92, DW_AT_TI_symbol_name("_pvParameters")
.dwattr $C$DW$92, DW_AT_type(*$C$DW$T$57)
.dwattr $C$DW$92, DW_AT_location[DW_OP_bregx 0x24 6]
$C$DW$93 .dwtag DW_TAG_variable, DW_AT_name("uxPriority")
.dwattr $C$DW$93, DW_AT_TI_symbol_name("_uxPriority")
.dwattr $C$DW$93, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$93, DW_AT_location[DW_OP_bregx 0x24 8]
$C$DW$94 .dwtag DW_TAG_variable, DW_AT_name("pxCreatedTask")
.dwattr $C$DW$94, DW_AT_TI_symbol_name("_pxCreatedTask")
.dwattr $C$DW$94, DW_AT_type(*$C$DW$T$80)
.dwattr $C$DW$94, DW_AT_location[DW_OP_bregx 0x24 10]
$C$DW$95 .dwtag DW_TAG_variable, DW_AT_name("pxNewTCB")
.dwattr $C$DW$95, DW_AT_TI_symbol_name("_pxNewTCB")
.dwattr $C$DW$95, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$95, DW_AT_location[DW_OP_bregx 0x24 12]
$C$DW$96 .dwtag DW_TAG_variable, DW_AT_name("xRegions")
.dwattr $C$DW$96, DW_AT_TI_symbol_name("_xRegions")
.dwattr $C$DW$96, DW_AT_type(*$C$DW$T$87)
.dwattr $C$DW$96, DW_AT_location[DW_OP_bregx 0x24 14]
$C$DW$97 .dwtag DW_TAG_variable, DW_AT_name("pxTopOfStack")
.dwattr $C$DW$97, DW_AT_TI_symbol_name("_pxTopOfStack")
.dwattr $C$DW$97, DW_AT_type(*$C$DW$T$20)
.dwattr $C$DW$97, DW_AT_location[DW_OP_bregx 0x24 16]
$C$DW$98 .dwtag DW_TAG_variable, DW_AT_name("pxTopOfSysStack")
.dwattr $C$DW$98, DW_AT_TI_symbol_name("_pxTopOfSysStack")
.dwattr $C$DW$98, DW_AT_type(*$C$DW$T$20)
.dwattr $C$DW$98, DW_AT_location[DW_OP_bregx 0x24 18]
$C$DW$99 .dwtag DW_TAG_variable, DW_AT_name("x")
.dwattr $C$DW$99, DW_AT_TI_symbol_name("_x")
.dwattr $C$DW$99, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$99, DW_AT_location[DW_OP_bregx 0x24 20]
MOV XAR4, dbl(*SP(#14))
MOV XAR3, dbl(*SP(#12))
MOV XAR2, dbl(*SP(#10))
MOV T0, *SP(#8) ; |861|
MOV XAR1, dbl(*SP(#6))
MOV AC1, dbl(*SP(#4)) ; |861|
MOV XAR0, dbl(*SP(#2))
MOV AC0, dbl(*SP(#0)) ; |861|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 866,column 2,is_stmt
$C$DW$100 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$100, DW_AT_low_pc(0x00)
.dwattr $C$DW$100, DW_AT_name("_pvPortMalloc")
.dwattr $C$DW$100, DW_AT_TI_call
CALL #_pvPortMalloc ; |866|
|| MOV #4, T0
; call occurs [#_pvPortMalloc] ; |866|
MOV XAR0, dbl(*(#_stackStruct))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 868,column 2,is_stmt
MOV dbl(*(#_stackStruct)), XAR3
MOV XAR3, AC0
BCC $C$L7,AC0 != #0 ; |868|
; branchcc occurs ; |868|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 870,column 2,is_stmt
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 871,column 3,is_stmt
$C$DW$101 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$101, DW_AT_low_pc(0x00)
.dwattr $C$DW$101, DW_AT_name("_vApplicationMallocFailedHook")
.dwattr $C$DW$101, DW_AT_TI_call
CALL #_vApplicationMallocFailedHook ; |871|
; call occurs [#_vApplicationMallocFailedHook] ; |871|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 872,column 9,is_stmt
$C$L6:
$C$DW$L$_prvInitialiseNewTask$3$B:
B $C$L6 ; |872|
; branch occurs ; |872|
$C$DW$L$_prvInitialiseNewTask$3$E:
$C$L7:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 890,column 2,is_stmt
MOV dbl(*SP(#2)), XAR3
MOV XAR3, AC0
BCC $C$L9,AC0 != #0 ; |890|
; branchcc occurs ; |890|
nop
bset INTM
$C$L8:
$C$DW$L$_prvInitialiseNewTask$6$B:
B $C$L8 ; |890|
; branch occurs ; |890|
$C$DW$L$_prvInitialiseNewTask$6$E:
$C$L9:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 896,column 3,is_stmt
MOV dbl(*SP(#12)), XAR3
MOV *SP(#5), T1 ; |896|
MOV #-23131, T0 ; |896|
MOV dbl(*AR3(#26)), XAR0
$C$DW$102 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$102, DW_AT_low_pc(0x00)
.dwattr $C$DW$102, DW_AT_name("_memset")
.dwattr $C$DW$102, DW_AT_TI_call
CALL #_memset ; |896|
; call occurs [#_memset] ; |896|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 897,column 3,is_stmt
MOV dbl(*SP(#12)), XAR3
MOV #-23131, T0 ; |897|
MOV *SP(#5), T1 ; |897|
MOV dbl(*AR3(#28)), XAR0
$C$DW$103 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$103, DW_AT_low_pc(0x00)
.dwattr $C$DW$103, DW_AT_name("_memset")
.dwattr $C$DW$103, DW_AT_TI_call
CALL #_memset ; |897|
; call occurs [#_memset] ; |897|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 907,column 3,is_stmt
MOV dbl(*SP(#12)), XAR3
MOV dbl(*SP(#4)), AC0 ; |907|
SUB #1, AC0 ; |907|
MOV AC0, AR1 ; |907|
MOV dbl(*AR3(#26)), XAR3
MOV XAR3, dbl(*SP(#16))
|| AADD AR1, AR3 ; |907|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 908,column 3,is_stmt
MOV #-1 << #16, AC1 ; |908|
MOV XAR3, AC0
OR #0xfffc, AC1, AC1 ; |908|
AND AC0, AC1 ; |908|
MOV AC1, dbl(*SP(#16))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 909,column 3,is_stmt
MOV dbl(*SP(#12)), XAR3
MOV dbl(*SP(#4)), AC0 ; |909|
SUB #1, AC0 ; |909|
MOV AC0, AR1 ; |909|
MOV dbl(*AR3(#28)), XAR3
MOV XAR3, dbl(*SP(#18))
|| AADD AR1, AR3 ; |909|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 910,column 3,is_stmt
MOV #-1 << #16, AC1 ; |910|
MOV XAR3, AC0
OR #0xfffc, AC1, AC1 ; |910|
AND AC0, AC1 ; |910|
MOV AC1, dbl(*SP(#18))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 912,column 3,is_stmt
MOV dbl(*SP(#16)), XAR3
MOV XAR3, AC0
AND #0x0003, AC0, AC0 ; |912|
MOV #0, AR1
BCC $C$L10,AC0 != #0 ; |912|
; branchcc occurs ; |912|
MOV #1, AR1
$C$L10:
BCC $C$L12,AR1 != #0 ; |912|
; branchcc occurs ; |912|
nop
bset INTM
$C$L11:
$C$DW$L$_prvInitialiseNewTask$11$B:
B $C$L11 ; |912|
; branch occurs ; |912|
$C$DW$L$_prvInitialiseNewTask$11$E:
$C$L12:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 913,column 3,is_stmt
MOV dbl(*SP(#18)), XAR3
MOV XAR3, AC0
AND #0x0003, AC0, AC0 ; |913|
MOV #0, AR1
BCC $C$L13,AC0 != #0 ; |913|
; branchcc occurs ; |913|
MOV #1, AR1
$C$L13:
BCC $C$L15,AR1 != #0 ; |913|
; branchcc occurs ; |913|
nop
bset INTM
$C$L14:
$C$DW$L$_prvInitialiseNewTask$16$B:
B $C$L14 ; |913|
; branch occurs ; |913|
$C$DW$L$_prvInitialiseNewTask$16$E:
$C$L15:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 919,column 4,is_stmt
MOV dbl(*SP(#12)), XAR2
MOV dbl(*SP(#16)), XAR3
MOV XAR3, dbl(*AR2(#38))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 920,column 4,is_stmt
MOV dbl(*SP(#12)), XAR2
MOV dbl(*SP(#18)), XAR3
MOV XAR3, dbl(*AR2(#40))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 941,column 7,is_stmt
MOV #0, *SP(#20) ; |941|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 941,column 30,is_stmt
MOV *SP(#20), AR1 ; |941|
|| MOV #8, AR2
CMPU AR1 >= AR2, TC1 ; |941|
BCC $C$L18,TC1 ; |941|
; branchcc occurs ; |941|
$C$L16:
$C$DW$L$_prvInitialiseNewTask$18$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 943,column 3,is_stmt
MOV *SP(#20), T0 ; |943|
MOV dbl(*SP(#2)), XAR3
MOV T0, AR1
MOV *AR3(T0), AR2 ; |943|
MOV dbl(*SP(#12)), XAR3
AADD AR1, AR3 ; |943|
MOV AR2, *AR3(#30) ; |943|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 948,column 3,is_stmt
MOV *SP(#20), T0 ; |948|
MOV dbl(*SP(#2)), XAR3
MOV *AR3(T0), AR1 ; |948|
BCC $C$L17,AR1 != #0 ; |948|
; branchcc occurs ; |948|
$C$DW$L$_prvInitialiseNewTask$18$E:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 950,column 4,is_stmt
B $C$L18 ; |950|
; branch occurs ; |950|
$C$L17:
$C$DW$L$_prvInitialiseNewTask$21$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 941,column 75,is_stmt
ADD #1, *SP(#20) ; |941|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 941,column 30,is_stmt
MOV *SP(#20), AR1 ; |941|
|| MOV #8, AR2
CMPU AR1 < AR2, TC1 ; |941|
BCC $C$L16,TC1 ; |941|
; branchcc occurs ; |941|
$C$DW$L$_prvInitialiseNewTask$21$E:
$C$L18:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 960,column 2,is_stmt
MOV dbl(*SP(#12)), XAR3
MOV #0, *AR3(#37) ; |960|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 964,column 2,is_stmt
MOV *SP(#8), AR1 ; |964|
|| MOV #5, AR2
CMPU AR1 < AR2, TC1 ; |964|
BCC $C$L19,TC1 ; |964|
; branchcc occurs ; |964|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 966,column 3,is_stmt
MOV #4, *SP(#8) ; |966|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 967,column 2,is_stmt
$C$L19:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 973,column 2,is_stmt
MOV dbl(*SP(#12)), XAR3
MOV *SP(#8), AR1 ; |973|
MOV AR1, *AR3(#24) ; |973|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 976,column 3,is_stmt
MOV dbl(*SP(#12)), XAR3
MOV *SP(#8), AR1 ; |976|
MOV AR1, *AR3(#43) ; |976|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 977,column 3,is_stmt
MOV dbl(*SP(#12)), XAR3
MOV #0, *AR3(#44) ; |977|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 981,column 2,is_stmt
MOV dbl(*SP(#12)), XAR0
AADD #4, AR0 ; |981|
$C$DW$104 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$104, DW_AT_low_pc(0x00)
.dwattr $C$DW$104, DW_AT_name("_vListInitialiseItem")
.dwattr $C$DW$104, DW_AT_TI_call
CALL #_vListInitialiseItem ; |981|
; call occurs [#_vListInitialiseItem] ; |981|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 982,column 2,is_stmt
MOV dbl(*SP(#12)), XAR0
AADD #14, AR0 ; |982|
$C$DW$105 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$105, DW_AT_low_pc(0x00)
.dwattr $C$DW$105, DW_AT_name("_vListInitialiseItem")
.dwattr $C$DW$105, DW_AT_TI_call
CALL #_vListInitialiseItem ; |982|
; call occurs [#_vListInitialiseItem] ; |982|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 986,column 2,is_stmt
MOV dbl(*SP(#12)), XAR2
MOV dbl(*SP(#12)), XAR3
MOV XAR3, dbl(*AR2(#10))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 989,column 2,is_stmt
MOV dbl(*SP(#12)), XAR3
MOV #5, AC0 ; |989|
SUB uns(*SP(#8)), AC0, AC0 ; |989|
MOV AC0, dbl(*AR3(#14)) ; |989|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 990,column 2,is_stmt
MOV dbl(*SP(#12)), XAR2
MOV dbl(*SP(#12)), XAR3
MOV XAR3, dbl(*AR2(#20))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 994,column 3,is_stmt
MOV dbl(*SP(#12)), XAR3
MOV #0, *AR3(#42) ; |994|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1017,column 3,is_stmt
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1032,column 3,is_stmt
MOV dbl(*SP(#12)), XAR3
MOV #0, AC0 ; |1032|
MOV AC0, dbl(*AR3(#46)) ; |1032|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1033,column 3,is_stmt
MOV dbl(*SP(#12)), XAR3
MOV #0, *AR3(#48) ; |1033|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1060,column 3,is_stmt
MOV dbl(*SP(#0)), AC0 ; |1060|
MOV dbl(*SP(#6)), XAR2
MOV dbl(*SP(#16)), XAR0
MOV dbl(*SP(#18)), XAR1
$C$DW$106 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$106, DW_AT_low_pc(0x00)
.dwattr $C$DW$106, DW_AT_name("_pxPortInitialiseStack")
.dwattr $C$DW$106, DW_AT_TI_call
CALL #_pxPortInitialiseStack ; |1060|
; call occurs [#_pxPortInitialiseStack] ; |1060|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1061,column 3,is_stmt
MOV dbl(*(#_stackStruct)), XAR3
MOV dbl(*SP(#12)), XAR2
MOV dbl(*AR3), dbl(*AR2)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1062,column 3,is_stmt
MOV dbl(*(#_stackStruct)), XAR3
MOV dbl(*AR3(short(#2))), XAR2
MOV dbl(*SP(#12)), XAR3
MOV XAR2, dbl(*AR3(short(#2)))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1066,column 2,is_stmt
MOV dbl(*SP(#10)), XAR3
MOV XAR3, AC0
BCC $C$L20,AC0 == #0 ; |1066|
; branchcc occurs ; |1066|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1070,column 3,is_stmt
MOV dbl(*SP(#10)), XAR2
MOV dbl(*SP(#12)), XAR3
MOV XAR3, dbl(*AR2)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1071,column 2,is_stmt
B $C$L20 ; |1071|
; branch occurs ; |1071|
$C$L20:
AADD #21, SP
.dwcfi cfa_offset, 1
$C$DW$107 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$107, DW_AT_low_pc(0x00)
.dwattr $C$DW$107, DW_AT_TI_return
RET
; return occurs
$C$DW$108 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$108, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L16:1:1538833113")
.dwattr $C$DW$108, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$108, DW_AT_TI_begin_line(0x3ad)
.dwattr $C$DW$108, DW_AT_TI_end_line(0x3bc)
$C$DW$109 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$109, DW_AT_low_pc($C$DW$L$_prvInitialiseNewTask$18$B)
.dwattr $C$DW$109, DW_AT_high_pc($C$DW$L$_prvInitialiseNewTask$18$E)
$C$DW$110 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$110, DW_AT_low_pc($C$DW$L$_prvInitialiseNewTask$21$B)
.dwattr $C$DW$110, DW_AT_high_pc($C$DW$L$_prvInitialiseNewTask$21$E)
.dwendtag $C$DW$108
$C$DW$111 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$111, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L14:1:1538833113")
.dwattr $C$DW$111, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$111, DW_AT_TI_begin_line(0x391)
.dwattr $C$DW$111, DW_AT_TI_end_line(0x391)
$C$DW$112 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$112, DW_AT_low_pc($C$DW$L$_prvInitialiseNewTask$16$B)
.dwattr $C$DW$112, DW_AT_high_pc($C$DW$L$_prvInitialiseNewTask$16$E)
.dwendtag $C$DW$111
$C$DW$113 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$113, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L11:1:1538833113")
.dwattr $C$DW$113, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$113, DW_AT_TI_begin_line(0x390)
.dwattr $C$DW$113, DW_AT_TI_end_line(0x390)
$C$DW$114 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$114, DW_AT_low_pc($C$DW$L$_prvInitialiseNewTask$11$B)
.dwattr $C$DW$114, DW_AT_high_pc($C$DW$L$_prvInitialiseNewTask$11$E)
.dwendtag $C$DW$113
$C$DW$115 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$115, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L8:1:1538833113")
.dwattr $C$DW$115, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$115, DW_AT_TI_begin_line(0x37a)
.dwattr $C$DW$115, DW_AT_TI_end_line(0x37a)
$C$DW$116 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$116, DW_AT_low_pc($C$DW$L$_prvInitialiseNewTask$6$B)
.dwattr $C$DW$116, DW_AT_high_pc($C$DW$L$_prvInitialiseNewTask$6$E)
.dwendtag $C$DW$115
$C$DW$117 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$117, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L6:1:1538833113")
.dwattr $C$DW$117, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$117, DW_AT_TI_begin_line(0x368)
.dwattr $C$DW$117, DW_AT_TI_end_line(0x368)
$C$DW$118 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$118, DW_AT_low_pc($C$DW$L$_prvInitialiseNewTask$3$B)
.dwattr $C$DW$118, DW_AT_high_pc($C$DW$L$_prvInitialiseNewTask$3$E)
.dwendtag $C$DW$117
.dwattr $C$DW$80, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$80, DW_AT_TI_end_line(0x434)
.dwattr $C$DW$80, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$80
.sect ".text"
.align 4
$C$DW$119 .dwtag DW_TAG_subprogram, DW_AT_name("prvAddNewTaskToReadyList")
.dwattr $C$DW$119, DW_AT_low_pc(_prvAddNewTaskToReadyList)
.dwattr $C$DW$119, DW_AT_high_pc(0x00)
.dwattr $C$DW$119, DW_AT_TI_symbol_name("_prvAddNewTaskToReadyList")
.dwattr $C$DW$119, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$119, DW_AT_TI_begin_line(0x437)
.dwattr $C$DW$119, DW_AT_TI_begin_column(0x0d)
.dwattr $C$DW$119, DW_AT_TI_max_frame_size(0x04)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1080,column 1,is_stmt,address _prvAddNewTaskToReadyList
.dwfde $C$DW$CIE, _prvAddNewTaskToReadyList
$C$DW$120 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxNewTCB")
.dwattr $C$DW$120, DW_AT_TI_symbol_name("_pxNewTCB")
.dwattr $C$DW$120, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$120, DW_AT_location[DW_OP_reg17]
;*******************************************************************************
;* FUNCTION NAME: prvAddNewTaskToReadyList *
;* *
;* Function Uses Regs : AC0,AC0,AR0,XAR0,AR1,XAR1,AR2,AR3,XAR3,SP,CARRY,TC1, *
;* M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 4 words *
;* (2 return address/alignment) *
;* (2 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_prvAddNewTaskToReadyList:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-3, SP
.dwcfi cfa_offset, 4
$C$DW$121 .dwtag DW_TAG_variable, DW_AT_name("pxNewTCB")
.dwattr $C$DW$121, DW_AT_TI_symbol_name("_pxNewTCB")
.dwattr $C$DW$121, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$121, DW_AT_location[DW_OP_bregx 0x24 0]
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1083,column 2,is_stmt
nop
bset INTM
ADD #1, *(#_usCriticalNesting) ; |1083|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1085,column 3,is_stmt
ADD #1, *(#_uxCurrentNumberOfTasks) ; |1085|
NOP
NOP
NOP
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1086,column 3,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV XAR3, AC0
BCC $C$L21,AC0 != #0 ; |1086|
; branchcc occurs ; |1086|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1090,column 4,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, dbl(*(#_pxCurrentTCB))
NOP
NOP
NOP
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1092,column 4,is_stmt
CMP *(#_uxCurrentNumberOfTasks) == #1, TC1 ; |1092|
BCC $C$L22,!TC1 ; |1092|
; branchcc occurs ; |1092|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1097,column 5,is_stmt
$C$DW$122 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$122, DW_AT_low_pc(0x00)
.dwattr $C$DW$122, DW_AT_name("_prvInitialiseTaskLists")
.dwattr $C$DW$122, DW_AT_TI_call
CALL #_prvInitialiseTaskLists ; |1097|
; call occurs [#_prvInitialiseTaskLists] ; |1097|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1098,column 4,is_stmt
B $C$L22 ; |1098|
; branch occurs ; |1098|
$C$L21:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1109,column 4,is_stmt
MOV *(#_xSchedulerRunning), AR1 ; |1109|
BCC $C$L22,AR1 != #0 ; |1109|
; branchcc occurs ; |1109|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1111,column 5,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV *AR3(#24), AR1 ; |1111|
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV *AR3(#24), AR2 ; |1111|
CMPU AR2 > AR1, TC1 ; |1111|
BCC $C$L22,TC1 ; |1111|
; branchcc occurs ; |1111|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1113,column 6,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, dbl(*(#_pxCurrentTCB))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1114,column 5,is_stmt
B $C$L22 ; |1114|
; branch occurs ; |1114|
$C$L22:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1126,column 3,is_stmt
ADD #1, *(#_uxTaskNumber) ; |1126|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1136,column 3,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV *(#_uxTopReadyPriority), AR1 ; |1136|
MOV *AR3(#24), AR2 ; |1136|
CMPU AR2 <= AR1, TC1 ; |1136|
BCC $C$L23,TC1 ; |1136|
; branchcc occurs ; |1136|
MOV *AR3(#24), AR1 ; |1136|
MOV AR1, *(#_uxTopReadyPriority) ; |1136|
$C$L23:
MPYMK *AR3(#24), #10, AC0 ; |1136|
MOV AC0, AR1 ; |1136|
AMOV #_pxReadyTasksLists, XAR0 ; |1136|
AADD AR1, AR0 ; |1136|
MOV dbl(*SP(#0)), XAR1
AADD #4, AR1 ; |1136|
$C$DW$123 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$123, DW_AT_low_pc(0x00)
.dwattr $C$DW$123, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$123, DW_AT_TI_call
CALL #_vListInsertEnd ; |1136|
; call occurs [#_vListInsertEnd] ; |1136|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1138,column 3,is_stmt
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1140,column 2,is_stmt
MOV *(#_usCriticalNesting), AR1 ; |1140|
BCC $C$L24,AR1 == #0 ; |1140|
; branchcc occurs ; |1140|
SUB #1, *(#_usCriticalNesting) ; |1140|
NOP
NOP
NOP
MOV *(#_usCriticalNesting), AR1 ; |1140|
BCC $C$L24,AR1 != #0 ; |1140|
; branchcc occurs ; |1140|
nop
bclr INTM
$C$L24:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1142,column 2,is_stmt
MOV *(#_xSchedulerRunning), AR1 ; |1142|
BCC $C$L25,AR1 == #0 ; |1142|
; branchcc occurs ; |1142|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1146,column 3,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV *AR3(#24), AR1 ; |1146|
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV *AR3(#24), AR2 ; |1146|
CMPU AR2 >= AR1, TC1 ; |1146|
BCC $C$L25,TC1 ; |1146|
; branchcc occurs ; |1146|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1148,column 4,is_stmt
$C$DW$124 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$124, DW_AT_low_pc(0x00)
.dwattr $C$DW$124, DW_AT_name("_vPortYield")
.dwattr $C$DW$124, DW_AT_TI_call
CALL #_vPortYield ; |1148|
; call occurs [#_vPortYield] ; |1148|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1149,column 3,is_stmt
B $C$L25 ; |1149|
; branch occurs ; |1149|
$C$L25:
AADD #3, SP
.dwcfi cfa_offset, 1
$C$DW$125 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$125, DW_AT_low_pc(0x00)
.dwattr $C$DW$125, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$119, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$119, DW_AT_TI_end_line(0x487)
.dwattr $C$DW$119, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$119
.sect ".text"
.align 4
.global _vTaskDelete
$C$DW$126 .dwtag DW_TAG_subprogram, DW_AT_name("vTaskDelete")
.dwattr $C$DW$126, DW_AT_low_pc(_vTaskDelete)
.dwattr $C$DW$126, DW_AT_high_pc(0x00)
.dwattr $C$DW$126, DW_AT_TI_symbol_name("_vTaskDelete")
.dwattr $C$DW$126, DW_AT_external
.dwattr $C$DW$126, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$126, DW_AT_TI_begin_line(0x48c)
.dwattr $C$DW$126, DW_AT_TI_begin_column(0x07)
.dwattr $C$DW$126, DW_AT_TI_max_frame_size(0x06)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1165,column 2,is_stmt,address _vTaskDelete
.dwfde $C$DW$CIE, _vTaskDelete
$C$DW$127 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTaskToDelete")
.dwattr $C$DW$127, DW_AT_TI_symbol_name("_xTaskToDelete")
.dwattr $C$DW$127, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$127, DW_AT_location[DW_OP_reg17]
;*******************************************************************************
;* FUNCTION NAME: vTaskDelete *
;* *
;* Function Uses Regs : AC0,AC0,AC1,AC1,T0,AR0,XAR0,AR1,XAR1,AR2,AR3,XAR3,SP,*
;* CARRY,TC1,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 6 words *
;* (2 return address/alignment) *
;* (4 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_vTaskDelete:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-5, SP
.dwcfi cfa_offset, 6
$C$DW$128 .dwtag DW_TAG_variable, DW_AT_name("xTaskToDelete")
.dwattr $C$DW$128, DW_AT_TI_symbol_name("_xTaskToDelete")
.dwattr $C$DW$128, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$128, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$129 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$129, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$129, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$129, DW_AT_location[DW_OP_bregx 0x24 2]
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1168,column 3,is_stmt
nop
bset INTM
ADD #1, *(#_usCriticalNesting) ; |1168|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1172,column 4,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L26,AC0 != #0 ; |1172|
; branchcc occurs ; |1172|
MOV dbl(*(#_pxCurrentTCB)), XAR3
$C$L26:
MOV XAR3, dbl(*SP(#2))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1175,column 4,is_stmt
MOV dbl(*SP(#2)), XAR0
AADD #4, AR0 ; |1175|
$C$DW$130 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$130, DW_AT_low_pc(0x00)
.dwattr $C$DW$130, DW_AT_name("_uxListRemove")
.dwattr $C$DW$130, DW_AT_TI_call
CALL #_uxListRemove ; |1175|
; call occurs [#_uxListRemove] ; |1175|
BCC $C$L27,T0 == #0 ; |1175|
; branchcc occurs ; |1175|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1178,column 4,is_stmt
$C$L27:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1185,column 4,is_stmt
MOV dbl(*SP(#2)), XAR3
MOV dbl(*AR3(#22)), XAR3
MOV XAR3, AC0
BCC $C$L28,AC0 == #0 ; |1185|
; branchcc occurs ; |1185|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1187,column 5,is_stmt
MOV dbl(*SP(#2)), XAR0
AADD #14, AR0 ; |1187|
$C$DW$131 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$131, DW_AT_low_pc(0x00)
.dwattr $C$DW$131, DW_AT_name("_uxListRemove")
.dwattr $C$DW$131, DW_AT_TI_call
CALL #_uxListRemove ; |1187|
; call occurs [#_uxListRemove] ; |1187|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1188,column 4,is_stmt
$C$L28:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1198,column 4,is_stmt
ADD #1, *(#_uxTaskNumber) ; |1198|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1200,column 4,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV XAR3, AC0
MOV dbl(*SP(#2)), XAR3
MOV XAR3, AC1
CMPU AC1 != AC0, TC1 ; |1200|
BCC $C$L29,TC1 ; |1200|
; branchcc occurs ; |1200|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1207,column 5,is_stmt
MOV dbl(*SP(#2)), XAR1
AMOV #_xTasksWaitingTermination, XAR0 ; |1207|
AADD #4, AR1 ; |1207|
$C$DW$132 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$132, DW_AT_low_pc(0x00)
.dwattr $C$DW$132, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$132, DW_AT_TI_call
CALL #_vListInsertEnd ; |1207|
; call occurs [#_vListInsertEnd] ; |1207|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1212,column 5,is_stmt
ADD #1, *(#_uxDeletedTasksWaitingCleanUp) ; |1212|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1220,column 4,is_stmt
B $C$L30 ; |1220|
; branch occurs ; |1220|
$C$L29:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1223,column 5,is_stmt
SUB #1, *(#_uxCurrentNumberOfTasks) ; |1223|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1224,column 5,is_stmt
MOV dbl(*SP(#2)), XAR0
$C$DW$133 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$133, DW_AT_low_pc(0x00)
.dwattr $C$DW$133, DW_AT_name("_prvDeleteTCB")
.dwattr $C$DW$133, DW_AT_TI_call
CALL #_prvDeleteTCB ; |1224|
; call occurs [#_prvDeleteTCB] ; |1224|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1228,column 5,is_stmt
$C$DW$134 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$134, DW_AT_low_pc(0x00)
.dwattr $C$DW$134, DW_AT_name("_prvResetNextTaskUnblockTime")
.dwattr $C$DW$134, DW_AT_TI_call
CALL #_prvResetNextTaskUnblockTime ; |1228|
; call occurs [#_prvResetNextTaskUnblockTime] ; |1228|
$C$L30:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1233,column 3,is_stmt
MOV *(#_usCriticalNesting), AR1 ; |1233|
BCC $C$L31,AR1 == #0 ; |1233|
; branchcc occurs ; |1233|
SUB #1, *(#_usCriticalNesting) ; |1233|
NOP
NOP
NOP
MOV *(#_usCriticalNesting), AR1 ; |1233|
BCC $C$L31,AR1 != #0 ; |1233|
; branchcc occurs ; |1233|
nop
bclr INTM
$C$L31:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1237,column 3,is_stmt
MOV *(#_xSchedulerRunning), AR1 ; |1237|
BCC $C$L35,AR1 == #0 ; |1237|
; branchcc occurs ; |1237|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1239,column 4,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV XAR3, AC0
MOV dbl(*SP(#2)), XAR3
MOV XAR3, AC1
CMPU AC1 != AC0, TC1 ; |1239|
BCC $C$L35,TC1 ; |1239|
; branchcc occurs ; |1239|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1241,column 5,is_stmt
MOV *(#_uxSchedulerSuspended), AR2 ; |1241|
MOV #0, AR1
BCC $C$L32,AR2 != #0 ; |1241|
; branchcc occurs ; |1241|
MOV #1, AR1
$C$L32:
BCC $C$L34,AR1 != #0 ; |1241|
; branchcc occurs ; |1241|
nop
bset INTM
$C$L33:
$C$DW$L$_vTaskDelete$19$B:
B $C$L33 ; |1241|
; branch occurs ; |1241|
$C$DW$L$_vTaskDelete$19$E:
$C$L34:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1242,column 5,is_stmt
$C$DW$135 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$135, DW_AT_low_pc(0x00)
.dwattr $C$DW$135, DW_AT_name("_vPortYield")
.dwattr $C$DW$135, DW_AT_TI_call
CALL #_vPortYield ; |1242|
; call occurs [#_vPortYield] ; |1242|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1243,column 4,is_stmt
B $C$L35 ; |1243|
; branch occurs ; |1243|
$C$L35:
AADD #5, SP
.dwcfi cfa_offset, 1
$C$DW$136 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$136, DW_AT_low_pc(0x00)
.dwattr $C$DW$136, DW_AT_TI_return
RET
; return occurs
$C$DW$137 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$137, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L33:1:1538833113")
.dwattr $C$DW$137, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$137, DW_AT_TI_begin_line(0x4d9)
.dwattr $C$DW$137, DW_AT_TI_end_line(0x4d9)
$C$DW$138 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$138, DW_AT_low_pc($C$DW$L$_vTaskDelete$19$B)
.dwattr $C$DW$138, DW_AT_high_pc($C$DW$L$_vTaskDelete$19$E)
.dwendtag $C$DW$137
.dwattr $C$DW$126, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$126, DW_AT_TI_end_line(0x4e1)
.dwattr $C$DW$126, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$126
.sect ".text"
.align 4
.global _vTaskDelayUntil
$C$DW$139 .dwtag DW_TAG_subprogram, DW_AT_name("vTaskDelayUntil")
.dwattr $C$DW$139, DW_AT_low_pc(_vTaskDelayUntil)
.dwattr $C$DW$139, DW_AT_high_pc(0x00)
.dwattr $C$DW$139, DW_AT_TI_symbol_name("_vTaskDelayUntil")
.dwattr $C$DW$139, DW_AT_external
.dwattr $C$DW$139, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$139, DW_AT_TI_begin_line(0x4e8)
.dwattr $C$DW$139, DW_AT_TI_begin_column(0x07)
.dwattr $C$DW$139, DW_AT_TI_max_frame_size(0x0c)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1257,column 2,is_stmt,address _vTaskDelayUntil
.dwfde $C$DW$CIE, _vTaskDelayUntil
$C$DW$140 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxPreviousWakeTime")
.dwattr $C$DW$140, DW_AT_TI_symbol_name("_pxPreviousWakeTime")
.dwattr $C$DW$140, DW_AT_type(*$C$DW$T$94)
.dwattr $C$DW$140, DW_AT_location[DW_OP_reg17]
$C$DW$141 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTimeIncrement")
.dwattr $C$DW$141, DW_AT_TI_symbol_name("_xTimeIncrement")
.dwattr $C$DW$141, DW_AT_type(*$C$DW$T$95)
.dwattr $C$DW$141, DW_AT_location[DW_OP_reg0]
;*******************************************************************************
;* FUNCTION NAME: vTaskDelayUntil *
;* *
;* Function Uses Regs : AC0,AC0,AC1,AC1,T0,AR0,XAR0,AR1,AR2,AR3,XAR3,SP, *
;* CARRY,TC1,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 12 words *
;* (2 return address/alignment) *
;* (10 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_vTaskDelayUntil:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-11, SP
.dwcfi cfa_offset, 12
$C$DW$142 .dwtag DW_TAG_variable, DW_AT_name("pxPreviousWakeTime")
.dwattr $C$DW$142, DW_AT_TI_symbol_name("_pxPreviousWakeTime")
.dwattr $C$DW$142, DW_AT_type(*$C$DW$T$94)
.dwattr $C$DW$142, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$143 .dwtag DW_TAG_variable, DW_AT_name("xTimeIncrement")
.dwattr $C$DW$143, DW_AT_TI_symbol_name("_xTimeIncrement")
.dwattr $C$DW$143, DW_AT_type(*$C$DW$T$95)
.dwattr $C$DW$143, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$144 .dwtag DW_TAG_variable, DW_AT_name("xTimeToWake")
.dwattr $C$DW$144, DW_AT_TI_symbol_name("_xTimeToWake")
.dwattr $C$DW$144, DW_AT_type(*$C$DW$T$37)
.dwattr $C$DW$144, DW_AT_location[DW_OP_bregx 0x24 4]
$C$DW$145 .dwtag DW_TAG_variable, DW_AT_name("xAlreadyYielded")
.dwattr $C$DW$145, DW_AT_TI_symbol_name("_xAlreadyYielded")
.dwattr $C$DW$145, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$145, DW_AT_location[DW_OP_bregx 0x24 6]
$C$DW$146 .dwtag DW_TAG_variable, DW_AT_name("xShouldDelay")
.dwattr $C$DW$146, DW_AT_TI_symbol_name("_xShouldDelay")
.dwattr $C$DW$146, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$146, DW_AT_location[DW_OP_bregx 0x24 7]
MOV AC0, dbl(*SP(#2)) ; |1257|
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1259,column 30,is_stmt
MOV #0, *SP(#7) ; |1259|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1261,column 3,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L37,AC0 != #0 ; |1261|
; branchcc occurs ; |1261|
nop
bset INTM
$C$L36:
$C$DW$L$_vTaskDelayUntil$3$B:
B $C$L36 ; |1261|
; branch occurs ; |1261|
$C$DW$L$_vTaskDelayUntil$3$E:
$C$L37:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1262,column 3,is_stmt
MOV dbl(*SP(#2)), AC0 ; |1262|
MOV #0, AR1
BCC $C$L38,AC0 == #0 ; |1262|
; branchcc occurs ; |1262|
MOV #1, AR1
$C$L38:
BCC $C$L40,AR1 != #0 ; |1262|
; branchcc occurs ; |1262|
nop
bset INTM
$C$L39:
$C$DW$L$_vTaskDelayUntil$8$B:
B $C$L39 ; |1262|
; branch occurs ; |1262|
$C$DW$L$_vTaskDelayUntil$8$E:
$C$L40:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1263,column 3,is_stmt
MOV *(#_uxSchedulerSuspended), AR2 ; |1263|
MOV #0, AR1
BCC $C$L41,AR2 != #0 ; |1263|
; branchcc occurs ; |1263|
MOV #1, AR1
$C$L41:
BCC $C$L43,AR1 != #0 ; |1263|
; branchcc occurs ; |1263|
nop
bset INTM
$C$L42:
$C$DW$L$_vTaskDelayUntil$13$B:
B $C$L42 ; |1263|
; branch occurs ; |1263|
$C$DW$L$_vTaskDelayUntil$13$E:
$C$L43:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1265,column 3,is_stmt
$C$DW$147 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$147, DW_AT_low_pc(0x00)
.dwattr $C$DW$147, DW_AT_name("_vTaskSuspendAll")
.dwattr $C$DW$147, DW_AT_TI_call
CALL #_vTaskSuspendAll ; |1265|
; call occurs [#_vTaskSuspendAll] ; |1265|
$C$DW$148 .dwtag DW_TAG_lexical_block, DW_AT_low_pc(0x00), DW_AT_high_pc(0x00)
$C$DW$149 .dwtag DW_TAG_variable, DW_AT_name("xConstTickCount")
.dwattr $C$DW$149, DW_AT_TI_symbol_name("_xConstTickCount")
.dwattr $C$DW$149, DW_AT_type(*$C$DW$T$95)
.dwattr $C$DW$149, DW_AT_location[DW_OP_bregx 0x24 8]
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1269,column 21,is_stmt
MOV dbl(*(#_xTickCount)), AC0 ; |1269|
MOV AC0, dbl(*SP(#8)) ; |1269|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1272,column 4,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV dbl(*SP(#2)), AC0 ; |1272|
ADD dbl(*AR3), AC0, AC0 ; |1272|
MOV AC0, dbl(*SP(#4)) ; |1272|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1274,column 4,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV dbl(*SP(#8)), AC1 ; |1274|
MOV dbl(*AR3), AC0 ; |1274|
CMPU AC1 >= AC0, TC1 ; |1274|
BCC $C$L44,TC1 ; |1274|
; branchcc occurs ; |1274|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1281,column 5,is_stmt
MOV dbl(*AR3), AC0 ; |1281|
MOV dbl(*SP(#4)), AC1 ; |1281|
CMPU AC1 >= AC0, TC1 ; |1281|
BCC $C$L46,TC1 ; |1281|
; branchcc occurs ; |1281|
MOV dbl(*SP(#8)), AC0 ; |1281|
MOV dbl(*SP(#4)), AC1 ; |1281|
CMPU AC1 <= AC0, TC1 ; |1281|
BCC $C$L46,TC1 ; |1281|
; branchcc occurs ; |1281|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1283,column 6,is_stmt
MOV #1, *SP(#7) ; |1283|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1284,column 5,is_stmt
B $C$L46 ; |1284|
; branch occurs ; |1284|
$C$L44:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1295,column 5,is_stmt
MOV dbl(*AR3), AC0 ; |1295|
MOV dbl(*SP(#4)), AC1 ; |1295|
CMPU AC1 < AC0, TC1 ; |1295|
BCC $C$L45,TC1 ; |1295|
; branchcc occurs ; |1295|
MOV dbl(*SP(#8)), AC0 ; |1295|
MOV dbl(*SP(#4)), AC1 ; |1295|
CMPU AC1 <= AC0, TC1 ; |1295|
BCC $C$L46,TC1 ; |1295|
; branchcc occurs ; |1295|
$C$L45:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1297,column 6,is_stmt
MOV #1, *SP(#7) ; |1297|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1298,column 5,is_stmt
$C$L46:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1306,column 4,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV dbl(*SP(#4)), AC0 ; |1306|
MOV AC0, dbl(*AR3) ; |1306|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1308,column 4,is_stmt
MOV *SP(#7), AR1 ; |1308|
BCC $C$L47,AR1 == #0 ; |1308|
; branchcc occurs ; |1308|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1314,column 5,is_stmt
MOV dbl(*SP(#8)), AC0 ; |1314|
SUB AC0, dbl(*SP(#4)), AC0 ; |1314|
$C$DW$150 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$150, DW_AT_low_pc(0x00)
.dwattr $C$DW$150, DW_AT_name("_prvAddCurrentTaskToDelayedList")
.dwattr $C$DW$150, DW_AT_TI_call
CALL #_prvAddCurrentTaskToDelayedList ; |1314|
|| MOV #0, T0
; call occurs [#_prvAddCurrentTaskToDelayedList] ; |1314|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1315,column 4,is_stmt
$C$L47:
.dwendtag $C$DW$148
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1321,column 3,is_stmt
$C$DW$151 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$151, DW_AT_low_pc(0x00)
.dwattr $C$DW$151, DW_AT_name("_xTaskResumeAll")
.dwattr $C$DW$151, DW_AT_TI_call
CALL #_xTaskResumeAll ; |1321|
; call occurs [#_xTaskResumeAll] ; |1321|
MOV T0, *SP(#6) ; |1321|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1325,column 3,is_stmt
MOV T0, AR1
BCC $C$L48,AR1 != #0 ; |1325|
; branchcc occurs ; |1325|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1327,column 4,is_stmt
$C$DW$152 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$152, DW_AT_low_pc(0x00)
.dwattr $C$DW$152, DW_AT_name("_vPortYield")
.dwattr $C$DW$152, DW_AT_TI_call
CALL #_vPortYield ; |1327|
; call occurs [#_vPortYield] ; |1327|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1328,column 3,is_stmt
B $C$L48 ; |1328|
; branch occurs ; |1328|
$C$L48:
AADD #11, SP
.dwcfi cfa_offset, 1
$C$DW$153 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$153, DW_AT_low_pc(0x00)
.dwattr $C$DW$153, DW_AT_TI_return
RET
; return occurs
$C$DW$154 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$154, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L42:1:1538833113")
.dwattr $C$DW$154, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$154, DW_AT_TI_begin_line(0x4ef)
.dwattr $C$DW$154, DW_AT_TI_end_line(0x4ef)
$C$DW$155 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$155, DW_AT_low_pc($C$DW$L$_vTaskDelayUntil$13$B)
.dwattr $C$DW$155, DW_AT_high_pc($C$DW$L$_vTaskDelayUntil$13$E)
.dwendtag $C$DW$154
$C$DW$156 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$156, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L39:1:1538833113")
.dwattr $C$DW$156, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$156, DW_AT_TI_begin_line(0x4ee)
.dwattr $C$DW$156, DW_AT_TI_end_line(0x4ee)
$C$DW$157 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$157, DW_AT_low_pc($C$DW$L$_vTaskDelayUntil$8$B)
.dwattr $C$DW$157, DW_AT_high_pc($C$DW$L$_vTaskDelayUntil$8$E)
.dwendtag $C$DW$156
$C$DW$158 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$158, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L36:1:1538833113")
.dwattr $C$DW$158, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$158, DW_AT_TI_begin_line(0x4ed)
.dwattr $C$DW$158, DW_AT_TI_end_line(0x4ed)
$C$DW$159 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$159, DW_AT_low_pc($C$DW$L$_vTaskDelayUntil$3$B)
.dwattr $C$DW$159, DW_AT_high_pc($C$DW$L$_vTaskDelayUntil$3$E)
.dwendtag $C$DW$158
.dwattr $C$DW$139, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$139, DW_AT_TI_end_line(0x535)
.dwattr $C$DW$139, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$139
.sect ".text"
.align 4
.global _vTaskDelay
$C$DW$160 .dwtag DW_TAG_subprogram, DW_AT_name("vTaskDelay")
.dwattr $C$DW$160, DW_AT_low_pc(_vTaskDelay)
.dwattr $C$DW$160, DW_AT_high_pc(0x00)
.dwattr $C$DW$160, DW_AT_TI_symbol_name("_vTaskDelay")
.dwattr $C$DW$160, DW_AT_external
.dwattr $C$DW$160, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$160, DW_AT_TI_begin_line(0x53c)
.dwattr $C$DW$160, DW_AT_TI_begin_column(0x07)
.dwattr $C$DW$160, DW_AT_TI_max_frame_size(0x04)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1341,column 2,is_stmt,address _vTaskDelay
.dwfde $C$DW$CIE, _vTaskDelay
$C$DW$161 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTicksToDelay")
.dwattr $C$DW$161, DW_AT_TI_symbol_name("_xTicksToDelay")
.dwattr $C$DW$161, DW_AT_type(*$C$DW$T$95)
.dwattr $C$DW$161, DW_AT_location[DW_OP_reg0]
;*******************************************************************************
;* FUNCTION NAME: vTaskDelay *
;* *
;* Function Uses Regs : AC0,AC0,T0,AR1,AR2,SP,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 4 words *
;* (1 return address/alignment) *
;* (3 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_vTaskDelay:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-3, SP
.dwcfi cfa_offset, 4
$C$DW$162 .dwtag DW_TAG_variable, DW_AT_name("xTicksToDelay")
.dwattr $C$DW$162, DW_AT_TI_symbol_name("_xTicksToDelay")
.dwattr $C$DW$162, DW_AT_type(*$C$DW$T$95)
.dwattr $C$DW$162, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$163 .dwtag DW_TAG_variable, DW_AT_name("xAlreadyYielded")
.dwattr $C$DW$163, DW_AT_TI_symbol_name("_xAlreadyYielded")
.dwattr $C$DW$163, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$163, DW_AT_location[DW_OP_bregx 0x24 2]
MOV AC0, dbl(*SP(#0)) ; |1341|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1342,column 13,is_stmt
MOV #0, *SP(#2) ; |1342|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1345,column 3,is_stmt
MOV dbl(*SP(#0)), AC0 ; |1345|
BCC $C$L52,AC0 == #0 ; |1345|
; branchcc occurs ; |1345|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1347,column 4,is_stmt
MOV *(#_uxSchedulerSuspended), AR2 ; |1347|
MOV #0, AR1
BCC $C$L49,AR2 != #0 ; |1347|
; branchcc occurs ; |1347|
MOV #1, AR1
$C$L49:
BCC $C$L51,AR1 != #0 ; |1347|
; branchcc occurs ; |1347|
nop
bset INTM
$C$L50:
$C$DW$L$_vTaskDelay$6$B:
B $C$L50 ; |1347|
; branch occurs ; |1347|
$C$DW$L$_vTaskDelay$6$E:
$C$L51:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1348,column 4,is_stmt
$C$DW$164 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$164, DW_AT_low_pc(0x00)
.dwattr $C$DW$164, DW_AT_name("_vTaskSuspendAll")
.dwattr $C$DW$164, DW_AT_TI_call
CALL #_vTaskSuspendAll ; |1348|
; call occurs [#_vTaskSuspendAll] ; |1348|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1359,column 5,is_stmt
MOV dbl(*SP(#0)), AC0 ; |1359|
$C$DW$165 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$165, DW_AT_low_pc(0x00)
.dwattr $C$DW$165, DW_AT_name("_prvAddCurrentTaskToDelayedList")
.dwattr $C$DW$165, DW_AT_TI_call
CALL #_prvAddCurrentTaskToDelayedList ; |1359|
|| MOV #0, T0
; call occurs [#_prvAddCurrentTaskToDelayedList] ; |1359|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1361,column 4,is_stmt
$C$DW$166 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$166, DW_AT_low_pc(0x00)
.dwattr $C$DW$166, DW_AT_name("_xTaskResumeAll")
.dwattr $C$DW$166, DW_AT_TI_call
CALL #_xTaskResumeAll ; |1361|
; call occurs [#_xTaskResumeAll] ; |1361|
MOV T0, *SP(#2) ; |1361|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1362,column 3,is_stmt
$C$L52:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1370,column 3,is_stmt
MOV *SP(#2), AR1 ; |1370|
BCC $C$L53,AR1 != #0 ; |1370|
; branchcc occurs ; |1370|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1372,column 4,is_stmt
$C$DW$167 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$167, DW_AT_low_pc(0x00)
.dwattr $C$DW$167, DW_AT_name("_vPortYield")
.dwattr $C$DW$167, DW_AT_TI_call
CALL #_vPortYield ; |1372|
; call occurs [#_vPortYield] ; |1372|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1373,column 3,is_stmt
B $C$L53 ; |1373|
; branch occurs ; |1373|
$C$L53:
AADD #3, SP
.dwcfi cfa_offset, 1
$C$DW$168 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$168, DW_AT_low_pc(0x00)
.dwattr $C$DW$168, DW_AT_TI_return
RET
; return occurs
$C$DW$169 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$169, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L50:1:1538833113")
.dwattr $C$DW$169, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$169, DW_AT_TI_begin_line(0x543)
.dwattr $C$DW$169, DW_AT_TI_end_line(0x543)
$C$DW$170 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$170, DW_AT_low_pc($C$DW$L$_vTaskDelay$6$B)
.dwattr $C$DW$170, DW_AT_high_pc($C$DW$L$_vTaskDelay$6$E)
.dwendtag $C$DW$169
.dwattr $C$DW$160, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$160, DW_AT_TI_end_line(0x562)
.dwattr $C$DW$160, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$160
.sect ".text"
.align 4
.global _eTaskGetState
$C$DW$171 .dwtag DW_TAG_subprogram, DW_AT_name("eTaskGetState")
.dwattr $C$DW$171, DW_AT_low_pc(_eTaskGetState)
.dwattr $C$DW$171, DW_AT_high_pc(0x00)
.dwattr $C$DW$171, DW_AT_TI_symbol_name("_eTaskGetState")
.dwattr $C$DW$171, DW_AT_external
.dwattr $C$DW$171, DW_AT_type(*$C$DW$T$46)
.dwattr $C$DW$171, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$171, DW_AT_TI_begin_line(0x569)
.dwattr $C$DW$171, DW_AT_TI_begin_column(0x0d)
.dwattr $C$DW$171, DW_AT_TI_max_frame_size(0x0e)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1386,column 2,is_stmt,address _eTaskGetState
.dwfde $C$DW$CIE, _eTaskGetState
$C$DW$172 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTask")
.dwattr $C$DW$172, DW_AT_TI_symbol_name("_xTask")
.dwattr $C$DW$172, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$172, DW_AT_location[DW_OP_reg17]
;*******************************************************************************
;* FUNCTION NAME: eTaskGetState *
;* *
;* Function Uses Regs : AC0,AC0,AC1,AC1,T0,AR0,XAR0,AR1,AR3,XAR3,SP,CARRY, *
;* TC1,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 14 words *
;* (2 return address/alignment) *
;* (12 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_eTaskGetState:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-13, SP
.dwcfi cfa_offset, 14
$C$DW$173 .dwtag DW_TAG_variable, DW_AT_name("xTask")
.dwattr $C$DW$173, DW_AT_TI_symbol_name("_xTask")
.dwattr $C$DW$173, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$173, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$174 .dwtag DW_TAG_variable, DW_AT_name("eReturn")
.dwattr $C$DW$174, DW_AT_TI_symbol_name("_eReturn")
.dwattr $C$DW$174, DW_AT_type(*$C$DW$T$46)
.dwattr $C$DW$174, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$175 .dwtag DW_TAG_variable, DW_AT_name("pxStateList")
.dwattr $C$DW$175, DW_AT_TI_symbol_name("_pxStateList")
.dwattr $C$DW$175, DW_AT_type(*$C$DW$T$129)
.dwattr $C$DW$175, DW_AT_location[DW_OP_bregx 0x24 4]
$C$DW$176 .dwtag DW_TAG_variable, DW_AT_name("pxDelayedList")
.dwattr $C$DW$176, DW_AT_TI_symbol_name("_pxDelayedList")
.dwattr $C$DW$176, DW_AT_type(*$C$DW$T$129)
.dwattr $C$DW$176, DW_AT_location[DW_OP_bregx 0x24 6]
$C$DW$177 .dwtag DW_TAG_variable, DW_AT_name("pxOverflowedDelayedList")
.dwattr $C$DW$177, DW_AT_TI_symbol_name("_pxOverflowedDelayedList")
.dwattr $C$DW$177, DW_AT_type(*$C$DW$T$129)
.dwattr $C$DW$177, DW_AT_location[DW_OP_bregx 0x24 8]
$C$DW$178 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$178, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$178, DW_AT_type(*$C$DW$T$158)
.dwattr $C$DW$178, DW_AT_location[DW_OP_bregx 0x24 10]
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1389,column 22,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, dbl(*SP(#10))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1391,column 3,is_stmt
MOV XAR3, AC0
BCC $C$L55,AC0 != #0 ; |1391|
; branchcc occurs ; |1391|
nop
bset INTM
$C$L54:
$C$DW$L$_eTaskGetState$3$B:
B $C$L54 ; |1391|
; branch occurs ; |1391|
$C$DW$L$_eTaskGetState$3$E:
$C$L55:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1393,column 3,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV XAR3, AC0
MOV dbl(*SP(#10)), XAR3
MOV XAR3, AC1
CMPU AC1 != AC0, TC1 ; |1393|
BCC $C$L56,TC1 ; |1393|
; branchcc occurs ; |1393|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1396,column 4,is_stmt
MOV #0, *SP(#2) ; |1396|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1397,column 3,is_stmt
B $C$L65 ; |1397|
; branch occurs ; |1397|
$C$L56:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1400,column 4,is_stmt
nop
bset INTM
ADD #1, *(#_usCriticalNesting) ; |1400|
NOP
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1402,column 5,is_stmt
MOV dbl(*AR3(#12)), XAR3
MOV XAR3, dbl(*SP(#4))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1403,column 5,is_stmt
MOV dbl(*(#_pxDelayedTaskList)), XAR3
MOV XAR3, dbl(*SP(#6))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1404,column 5,is_stmt
MOV dbl(*(#_pxOverflowDelayedTaskList)), XAR3
MOV XAR3, dbl(*SP(#8))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1406,column 4,is_stmt
MOV *(#_usCriticalNesting), AR1 ; |1406|
BCC $C$L57,AR1 == #0 ; |1406|
; branchcc occurs ; |1406|
SUB #1, *(#_usCriticalNesting) ; |1406|
NOP
NOP
NOP
MOV *(#_usCriticalNesting), AR1 ; |1406|
BCC $C$L57,AR1 != #0 ; |1406|
; branchcc occurs ; |1406|
nop
bclr INTM
$C$L57:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1408,column 4,is_stmt
MOV dbl(*SP(#6)), XAR3
MOV XAR3, AC0
MOV dbl(*SP(#4)), XAR3
MOV XAR3, AC1
CMPU AC1 == AC0, TC1 ; |1408|
BCC $C$L58,TC1 ; |1408|
; branchcc occurs ; |1408|
MOV dbl(*SP(#8)), XAR3
MOV XAR3, AC0
CMPU AC1 != AC0, TC1 ; |1408|
BCC $C$L59,TC1 ; |1408|
; branchcc occurs ; |1408|
$C$L58:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1412,column 5,is_stmt
MOV #2, *SP(#2) ; |1412|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1413,column 4,is_stmt
B $C$L65 ; |1413|
; branch occurs ; |1413|
$C$L59:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1416,column 10,is_stmt
AMOV #_xSuspendedTaskList, XAR3 ; |1416|
MOV XAR3, AC0
CMPU AC1 != AC0, TC1 ; |1416|
BCC $C$L62,TC1 ; |1416|
; branchcc occurs ; |1416|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1421,column 6,is_stmt
MOV dbl(*SP(#10)), XAR3
MOV dbl(*AR3(#22)), XAR3
MOV XAR3, AC0
BCC $C$L61,AC0 != #0 ; |1421|
; branchcc occurs ; |1421|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1429,column 8,is_stmt
MOV dbl(*SP(#10)), XAR3
CMP *AR3(#48) == #1, TC1 ; |1429|
BCC $C$L60,!TC1 ; |1429|
; branchcc occurs ; |1429|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1431,column 9,is_stmt
MOV #2, *SP(#2) ; |1431|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1432,column 8,is_stmt
B $C$L65 ; |1432|
; branch occurs ; |1432|
$C$L60:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1435,column 9,is_stmt
MOV #3, *SP(#2) ; |1435|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1443,column 6,is_stmt
B $C$L65 ; |1443|
; branch occurs ; |1443|
$C$L61:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1446,column 7,is_stmt
MOV #2, *SP(#2) ; |1446|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1448,column 5,is_stmt
B $C$L65 ; |1448|
; branch occurs ; |1448|
$C$L62:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1452,column 10,is_stmt
AMOV #_xTasksWaitingTermination, XAR3 ; |1452|
MOV XAR3, AC0
CMPU AC1 == AC0, TC1 ; |1452|
MOV dbl(*SP(#4)), XAR3
BCC $C$L63,TC1 ; |1452|
; branchcc occurs ; |1452|
MOV XAR3, AC0
BCC $C$L64,AC0 != #0 ; |1452|
; branchcc occurs ; |1452|
$C$L63:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1457,column 6,is_stmt
MOV #4, *SP(#2) ; |1457|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1458,column 5,is_stmt
B $C$L65 ; |1458|
; branch occurs ; |1458|
$C$L64:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1465,column 5,is_stmt
MOV #1, *SP(#2) ; |1465|
$C$L65:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1469,column 3,is_stmt
MOV *SP(#2), T0 ; |1469|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1470,column 2,is_stmt
AADD #13, SP
.dwcfi cfa_offset, 1
$C$DW$179 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$179, DW_AT_low_pc(0x00)
.dwattr $C$DW$179, DW_AT_TI_return
RET
; return occurs
$C$DW$180 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$180, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L54:1:1538833113")
.dwattr $C$DW$180, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$180, DW_AT_TI_begin_line(0x56f)
.dwattr $C$DW$180, DW_AT_TI_end_line(0x56f)
$C$DW$181 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$181, DW_AT_low_pc($C$DW$L$_eTaskGetState$3$B)
.dwattr $C$DW$181, DW_AT_high_pc($C$DW$L$_eTaskGetState$3$E)
.dwendtag $C$DW$180
.dwattr $C$DW$171, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$171, DW_AT_TI_end_line(0x5be)
.dwattr $C$DW$171, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$171
.sect ".text"
.align 4
.global _uxTaskPriorityGet
$C$DW$182 .dwtag DW_TAG_subprogram, DW_AT_name("uxTaskPriorityGet")
.dwattr $C$DW$182, DW_AT_low_pc(_uxTaskPriorityGet)
.dwattr $C$DW$182, DW_AT_high_pc(0x00)
.dwattr $C$DW$182, DW_AT_TI_symbol_name("_uxTaskPriorityGet")
.dwattr $C$DW$182, DW_AT_external
.dwattr $C$DW$182, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$182, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$182, DW_AT_TI_begin_line(0x5c5)
.dwattr $C$DW$182, DW_AT_TI_begin_column(0x0e)
.dwattr $C$DW$182, DW_AT_TI_max_frame_size(0x06)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1478,column 2,is_stmt,address _uxTaskPriorityGet
.dwfde $C$DW$CIE, _uxTaskPriorityGet
$C$DW$183 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTask")
.dwattr $C$DW$183, DW_AT_TI_symbol_name("_xTask")
.dwattr $C$DW$183, DW_AT_type(*$C$DW$T$107)
.dwattr $C$DW$183, DW_AT_location[DW_OP_reg17]
;*******************************************************************************
;* FUNCTION NAME: uxTaskPriorityGet *
;* *
;* Function Uses Regs : AC0,AC0,T0,AR0,XAR0,AR1,AR3,XAR3,SP,CARRY,M40,SATA, *
;* SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 6 words *
;* (1 return address/alignment) *
;* (5 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_uxTaskPriorityGet:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-5, SP
.dwcfi cfa_offset, 6
$C$DW$184 .dwtag DW_TAG_variable, DW_AT_name("xTask")
.dwattr $C$DW$184, DW_AT_TI_symbol_name("_xTask")
.dwattr $C$DW$184, DW_AT_type(*$C$DW$T$107)
.dwattr $C$DW$184, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$185 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$185, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$185, DW_AT_type(*$C$DW$T$157)
.dwattr $C$DW$185, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$186 .dwtag DW_TAG_variable, DW_AT_name("uxReturn")
.dwattr $C$DW$186, DW_AT_TI_symbol_name("_uxReturn")
.dwattr $C$DW$186, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$186, DW_AT_location[DW_OP_bregx 0x24 4]
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1482,column 3,is_stmt
nop
bset INTM
ADD #1, *(#_usCriticalNesting) ; |1482|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1486,column 4,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L66,AC0 != #0 ; |1486|
; branchcc occurs ; |1486|
MOV dbl(*(#_pxCurrentTCB)), XAR3
$C$L66:
MOV XAR3, dbl(*SP(#2))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1487,column 4,is_stmt
MOV *AR3(#24), AR1 ; |1487|
MOV AR1, *SP(#4) ; |1487|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1489,column 3,is_stmt
MOV *(#_usCriticalNesting), AR1 ; |1489|
BCC $C$L67,AR1 == #0 ; |1489|
; branchcc occurs ; |1489|
SUB #1, *(#_usCriticalNesting) ; |1489|
NOP
NOP
NOP
MOV *(#_usCriticalNesting), AR1 ; |1489|
BCC $C$L67,AR1 != #0 ; |1489|
; branchcc occurs ; |1489|
nop
bclr INTM
$C$L67:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1491,column 3,is_stmt
MOV *SP(#4), T0 ; |1491|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1492,column 2,is_stmt
AADD #5, SP
.dwcfi cfa_offset, 1
$C$DW$187 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$187, DW_AT_low_pc(0x00)
.dwattr $C$DW$187, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$182, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$182, DW_AT_TI_end_line(0x5d4)
.dwattr $C$DW$182, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$182
.sect ".text"
.align 4
.global _uxTaskPriorityGetFromISR
$C$DW$188 .dwtag DW_TAG_subprogram, DW_AT_name("uxTaskPriorityGetFromISR")
.dwattr $C$DW$188, DW_AT_low_pc(_uxTaskPriorityGetFromISR)
.dwattr $C$DW$188, DW_AT_high_pc(0x00)
.dwattr $C$DW$188, DW_AT_TI_symbol_name("_uxTaskPriorityGetFromISR")
.dwattr $C$DW$188, DW_AT_external
.dwattr $C$DW$188, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$188, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$188, DW_AT_TI_begin_line(0x5db)
.dwattr $C$DW$188, DW_AT_TI_begin_column(0x0e)
.dwattr $C$DW$188, DW_AT_TI_max_frame_size(0x08)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1500,column 2,is_stmt,address _uxTaskPriorityGetFromISR
.dwfde $C$DW$CIE, _uxTaskPriorityGetFromISR
$C$DW$189 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTask")
.dwattr $C$DW$189, DW_AT_TI_symbol_name("_xTask")
.dwattr $C$DW$189, DW_AT_type(*$C$DW$T$107)
.dwattr $C$DW$189, DW_AT_location[DW_OP_reg17]
;*******************************************************************************
;* FUNCTION NAME: uxTaskPriorityGetFromISR *
;* *
;* Function Uses Regs : AC0,AC0,T0,AR0,XAR0,AR1,AR3,XAR3,SP,M40,SATA,SATD, *
;* RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 8 words *
;* (2 return address/alignment) *
;* (6 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_uxTaskPriorityGetFromISR:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-7, SP
.dwcfi cfa_offset, 8
$C$DW$190 .dwtag DW_TAG_variable, DW_AT_name("xTask")
.dwattr $C$DW$190, DW_AT_TI_symbol_name("_xTask")
.dwattr $C$DW$190, DW_AT_type(*$C$DW$T$107)
.dwattr $C$DW$190, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$191 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$191, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$191, DW_AT_type(*$C$DW$T$157)
.dwattr $C$DW$191, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$192 .dwtag DW_TAG_variable, DW_AT_name("uxReturn")
.dwattr $C$DW$192, DW_AT_TI_symbol_name("_uxReturn")
.dwattr $C$DW$192, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$192, DW_AT_location[DW_OP_bregx 0x24 4]
$C$DW$193 .dwtag DW_TAG_variable, DW_AT_name("uxSavedInterruptState")
.dwattr $C$DW$193, DW_AT_TI_symbol_name("_uxSavedInterruptState")
.dwattr $C$DW$193, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$193, DW_AT_location[DW_OP_bregx 0x24 5]
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1522,column 3,is_stmt
MOV #0, *SP(#5) ; |1522|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1526,column 4,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L68,AC0 != #0 ; |1526|
; branchcc occurs ; |1526|
MOV dbl(*(#_pxCurrentTCB)), XAR3
$C$L68:
MOV XAR3, dbl(*SP(#2))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1527,column 4,is_stmt
MOV *AR3(#24), AR1 ; |1527|
MOV AR1, *SP(#4) ; |1527|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1529,column 3,is_stmt
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1531,column 3,is_stmt
MOV AR1, T0
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1532,column 2,is_stmt
AADD #7, SP
.dwcfi cfa_offset, 1
$C$DW$194 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$194, DW_AT_low_pc(0x00)
.dwattr $C$DW$194, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$188, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$188, DW_AT_TI_end_line(0x5fc)
.dwattr $C$DW$188, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$188
.sect ".text"
.align 4
.global _vTaskPrioritySet
$C$DW$195 .dwtag DW_TAG_subprogram, DW_AT_name("vTaskPrioritySet")
.dwattr $C$DW$195, DW_AT_low_pc(_vTaskPrioritySet)
.dwattr $C$DW$195, DW_AT_high_pc(0x00)
.dwattr $C$DW$195, DW_AT_TI_symbol_name("_vTaskPrioritySet")
.dwattr $C$DW$195, DW_AT_external
.dwattr $C$DW$195, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$195, DW_AT_TI_begin_line(0x603)
.dwattr $C$DW$195, DW_AT_TI_begin_column(0x07)
.dwattr $C$DW$195, DW_AT_TI_max_frame_size(0x0a)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1540,column 2,is_stmt,address _vTaskPrioritySet
.dwfde $C$DW$CIE, _vTaskPrioritySet
$C$DW$196 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTask")
.dwattr $C$DW$196, DW_AT_TI_symbol_name("_xTask")
.dwattr $C$DW$196, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$196, DW_AT_location[DW_OP_reg17]
$C$DW$197 .dwtag DW_TAG_formal_parameter, DW_AT_name("uxNewPriority")
.dwattr $C$DW$197, DW_AT_TI_symbol_name("_uxNewPriority")
.dwattr $C$DW$197, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$197, DW_AT_location[DW_OP_reg12]
;*******************************************************************************
;* FUNCTION NAME: vTaskPrioritySet *
;* *
;* Function Uses Regs : AC0,AC0,AC1,AC1,T0,AR0,XAR0,AR1,XAR1,AR2,AR3,XAR3,SP,*
;* CARRY,TC1,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 10 words *
;* (1 return address/alignment) *
;* (9 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_vTaskPrioritySet:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-9, SP
.dwcfi cfa_offset, 10
$C$DW$198 .dwtag DW_TAG_variable, DW_AT_name("xTask")
.dwattr $C$DW$198, DW_AT_TI_symbol_name("_xTask")
.dwattr $C$DW$198, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$198, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$199 .dwtag DW_TAG_variable, DW_AT_name("uxNewPriority")
.dwattr $C$DW$199, DW_AT_TI_symbol_name("_uxNewPriority")
.dwattr $C$DW$199, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$199, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$200 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$200, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$200, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$200, DW_AT_location[DW_OP_bregx 0x24 4]
$C$DW$201 .dwtag DW_TAG_variable, DW_AT_name("uxCurrentBasePriority")
.dwattr $C$DW$201, DW_AT_TI_symbol_name("_uxCurrentBasePriority")
.dwattr $C$DW$201, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$201, DW_AT_location[DW_OP_bregx 0x24 6]
$C$DW$202 .dwtag DW_TAG_variable, DW_AT_name("uxPriorityUsedOnEntry")
.dwattr $C$DW$202, DW_AT_TI_symbol_name("_uxPriorityUsedOnEntry")
.dwattr $C$DW$202, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$202, DW_AT_location[DW_OP_bregx 0x24 7]
$C$DW$203 .dwtag DW_TAG_variable, DW_AT_name("xYieldRequired")
.dwattr $C$DW$203, DW_AT_TI_symbol_name("_xYieldRequired")
.dwattr $C$DW$203, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$203, DW_AT_location[DW_OP_bregx 0x24 8]
MOV T0, *SP(#2) ; |1540|
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1543,column 13,is_stmt
MOV #0, *SP(#8) ; |1543|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1545,column 3,is_stmt
MOV *SP(#2), AR2 ; |1545|
|| MOV #5, AR3
CMPU AR2 >= AR3, TC1 ; |1545|
BCC $C$L69,TC1 ; |1545|
|| MOV #0, AR1
; branchcc occurs ; |1545|
MOV #1, AR1
$C$L69:
BCC $C$L71,AR1 != #0 ; |1545|
; branchcc occurs ; |1545|
nop
bset INTM
$C$L70:
$C$DW$L$_vTaskPrioritySet$5$B:
B $C$L70 ; |1545|
; branch occurs ; |1545|
$C$DW$L$_vTaskPrioritySet$5$E:
$C$L71:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1548,column 3,is_stmt
MOV *SP(#2), AR1 ; |1548|
|| MOV #5, AR2
CMPU AR1 < AR2, TC1 ; |1548|
BCC $C$L72,TC1 ; |1548|
; branchcc occurs ; |1548|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1550,column 4,is_stmt
MOV #4, *SP(#2) ; |1550|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1551,column 3,is_stmt
$C$L72:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1557,column 3,is_stmt
nop
bset INTM
ADD #1, *(#_usCriticalNesting) ; |1557|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1561,column 4,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L73,AC0 != #0 ; |1561|
; branchcc occurs ; |1561|
MOV dbl(*(#_pxCurrentTCB)), XAR3
$C$L73:
MOV XAR3, dbl(*SP(#4))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1567,column 5,is_stmt
MOV *AR3(#43), AR1 ; |1567|
MOV AR1, *SP(#6) ; |1567|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1575,column 4,is_stmt
MOV *SP(#6), AR2 ; |1575|
MOV *SP(#2), AR1 ; |1575|
CMPU AR2 == AR1, TC1 ; |1575|
BCC $C$L84,TC1 ; |1575|
; branchcc occurs ; |1575|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1579,column 5,is_stmt
MOV *SP(#2), AR2 ; |1579|
|| MOV AR2, AR1
CMPU AR2 <= AR1, TC1 ; |1579|
BCC $C$L74,TC1 ; |1579|
; branchcc occurs ; |1579|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1581,column 6,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV XAR3, AC0
MOV dbl(*SP(#4)), XAR3
MOV XAR3, AC1
CMPU AC1 == AC0, TC1 ; |1581|
BCC $C$L75,TC1 ; |1581|
; branchcc occurs ; |1581|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1586,column 7,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV *AR3(#24), AR1 ; |1586|
CMPU AR2 < AR1, TC1 ; |1586|
BCC $C$L75,TC1 ; |1586|
; branchcc occurs ; |1586|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1588,column 8,is_stmt
MOV #1, *SP(#8) ; |1588|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1589,column 7,is_stmt
B $C$L75 ; |1589|
; branch occurs ; |1589|
$C$L74:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1602,column 10,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV XAR3, AC0
MOV dbl(*SP(#4)), XAR3
MOV XAR3, AC1
CMPU AC1 != AC0, TC1 ; |1602|
BCC $C$L75,TC1 ; |1602|
; branchcc occurs ; |1602|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1607,column 6,is_stmt
MOV #1, *SP(#8) ; |1607|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1608,column 5,is_stmt
$C$L75:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1619,column 5,is_stmt
MOV dbl(*SP(#4)), XAR3
MOV *AR3(#24), AR1 ; |1619|
MOV AR1, *SP(#7) ; |1619|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1625,column 6,is_stmt
MOV dbl(*SP(#4)), XAR3
MOV *AR3(#43), AR2 ; |1625|
MOV *AR3(#24), AR1 ; |1625|
CMPU AR2 != AR1, TC1 ; |1625|
BCC $C$L76,TC1 ; |1625|
; branchcc occurs ; |1625|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1627,column 7,is_stmt
MOV *SP(#2), AR1 ; |1627|
MOV AR1, *AR3(#24) ; |1627|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1628,column 6,is_stmt
$C$L76:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1635,column 6,is_stmt
MOV dbl(*SP(#4)), XAR3
MOV *SP(#2), AR1 ; |1635|
MOV AR1, *AR3(#43) ; |1635|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1645,column 5,is_stmt
MOV dbl(*SP(#4)), XAR3
MOV #-32768 << #16, AC0 ; |1645|
MOV dbl(*AR3(#14)), AC1 ; |1645|
AND AC1, AC0 ; |1645|
BCC $C$L77,AC0 != #0 ; |1645|
; branchcc occurs ; |1645|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1647,column 6,is_stmt
MOV #5, AC0 ; |1647|
SUB uns(*SP(#2)), AC0, AC0 ; |1647|
MOV AC0, dbl(*AR3(#14)) ; |1647|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1648,column 5,is_stmt
$C$L77:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1658,column 5,is_stmt
MPYMK *SP(#7), #10, AC1 ; |1658|
MOV AC1, AR1 ; |1658|
AMOV #_pxReadyTasksLists, XAR3 ; |1658|
AADD AR1, AR3 ; |1658|
MOV XAR3, AC0
MOV dbl(*SP(#4)), XAR3
MOV dbl(*AR3(#12)), XAR3
MOV XAR3, AC1
CMPU AC1 != AC0, TC1 ; |1658|
BCC $C$L78,TC1 ; |1658|
; branchcc occurs ; |1658|
MOV #1, AR1
B $C$L79 ; |1658|
; branch occurs ; |1658|
$C$L78:
MOV #0, AR1
$C$L79:
BCC $C$L82,AR1 == #0 ; |1658|
; branchcc occurs ; |1658|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1663,column 6,is_stmt
MOV dbl(*SP(#4)), XAR0
AADD #4, AR0 ; |1663|
$C$DW$204 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$204, DW_AT_low_pc(0x00)
.dwattr $C$DW$204, DW_AT_name("_uxListRemove")
.dwattr $C$DW$204, DW_AT_TI_call
CALL #_uxListRemove ; |1663|
; call occurs [#_uxListRemove] ; |1663|
BCC $C$L80,T0 == #0 ; |1663|
; branchcc occurs ; |1663|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1669,column 6,is_stmt
$C$L80:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1674,column 6,is_stmt
MOV dbl(*SP(#4)), XAR3
MOV *(#_uxTopReadyPriority), AR1 ; |1674|
MOV *AR3(#24), AR2 ; |1674|
CMPU AR2 <= AR1, TC1 ; |1674|
BCC $C$L81,TC1 ; |1674|
; branchcc occurs ; |1674|
MOV *AR3(#24), AR1 ; |1674|
MOV AR1, *(#_uxTopReadyPriority) ; |1674|
$C$L81:
MPYMK *AR3(#24), #10, AC0 ; |1674|
MOV AC0, AR1 ; |1674|
AMOV #_pxReadyTasksLists, XAR0 ; |1674|
AADD AR1, AR0 ; |1674|
MOV dbl(*SP(#4)), XAR1
AADD #4, AR1 ; |1674|
$C$DW$205 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$205, DW_AT_low_pc(0x00)
.dwattr $C$DW$205, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$205, DW_AT_TI_call
CALL #_vListInsertEnd ; |1674|
; call occurs [#_vListInsertEnd] ; |1674|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1675,column 5,is_stmt
$C$L82:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1681,column 5,is_stmt
MOV *SP(#8), AR1 ; |1681|
BCC $C$L83,AR1 == #0 ; |1681|
; branchcc occurs ; |1681|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1683,column 6,is_stmt
$C$DW$206 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$206, DW_AT_low_pc(0x00)
.dwattr $C$DW$206, DW_AT_name("_vPortYield")
.dwattr $C$DW$206, DW_AT_TI_call
CALL #_vPortYield ; |1683|
; call occurs [#_vPortYield] ; |1683|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1684,column 5,is_stmt
$C$L83:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1692,column 5,is_stmt
$C$L84:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1695,column 3,is_stmt
MOV *(#_usCriticalNesting), AR1 ; |1695|
BCC $C$L85,AR1 == #0 ; |1695|
; branchcc occurs ; |1695|
SUB #1, *(#_usCriticalNesting) ; |1695|
NOP
NOP
NOP
MOV *(#_usCriticalNesting), AR1 ; |1695|
BCC $C$L85,AR1 != #0 ; |1695|
; branchcc occurs ; |1695|
nop
bclr INTM
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1696,column 2,is_stmt
$C$L85:
AADD #9, SP
.dwcfi cfa_offset, 1
$C$DW$207 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$207, DW_AT_low_pc(0x00)
.dwattr $C$DW$207, DW_AT_TI_return
RET
; return occurs
$C$DW$208 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$208, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L70:1:1538833113")
.dwattr $C$DW$208, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$208, DW_AT_TI_begin_line(0x609)
.dwattr $C$DW$208, DW_AT_TI_end_line(0x609)
$C$DW$209 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$209, DW_AT_low_pc($C$DW$L$_vTaskPrioritySet$5$B)
.dwattr $C$DW$209, DW_AT_high_pc($C$DW$L$_vTaskPrioritySet$5$E)
.dwendtag $C$DW$208
.dwattr $C$DW$195, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$195, DW_AT_TI_end_line(0x6a0)
.dwattr $C$DW$195, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$195
.sect ".text"
.align 4
.global _vTaskSuspend
$C$DW$210 .dwtag DW_TAG_subprogram, DW_AT_name("vTaskSuspend")
.dwattr $C$DW$210, DW_AT_low_pc(_vTaskSuspend)
.dwattr $C$DW$210, DW_AT_high_pc(0x00)
.dwattr $C$DW$210, DW_AT_TI_symbol_name("_vTaskSuspend")
.dwattr $C$DW$210, DW_AT_external
.dwattr $C$DW$210, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$210, DW_AT_TI_begin_line(0x6a7)
.dwattr $C$DW$210, DW_AT_TI_begin_column(0x07)
.dwattr $C$DW$210, DW_AT_TI_max_frame_size(0x06)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1704,column 2,is_stmt,address _vTaskSuspend
.dwfde $C$DW$CIE, _vTaskSuspend
$C$DW$211 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTaskToSuspend")
.dwattr $C$DW$211, DW_AT_TI_symbol_name("_xTaskToSuspend")
.dwattr $C$DW$211, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$211, DW_AT_location[DW_OP_reg17]
;*******************************************************************************
;* FUNCTION NAME: vTaskSuspend *
;* *
;* Function Uses Regs : AC0,AC0,AC1,AC1,T0,AR0,XAR0,AR1,XAR1,AR2,AR3,XAR3,SP,*
;* CARRY,TC1,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 6 words *
;* (2 return address/alignment) *
;* (4 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_vTaskSuspend:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-5, SP
.dwcfi cfa_offset, 6
$C$DW$212 .dwtag DW_TAG_variable, DW_AT_name("xTaskToSuspend")
.dwattr $C$DW$212, DW_AT_TI_symbol_name("_xTaskToSuspend")
.dwattr $C$DW$212, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$212, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$213 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$213, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$213, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$213, DW_AT_location[DW_OP_bregx 0x24 2]
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1707,column 3,is_stmt
nop
bset INTM
ADD #1, *(#_usCriticalNesting) ; |1707|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1711,column 4,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L86,AC0 != #0 ; |1711|
; branchcc occurs ; |1711|
MOV dbl(*(#_pxCurrentTCB)), XAR3
$C$L86:
MOV XAR3, dbl(*SP(#2))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1717,column 4,is_stmt
MOV dbl(*SP(#2)), XAR0
AADD #4, AR0 ; |1717|
$C$DW$214 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$214, DW_AT_low_pc(0x00)
.dwattr $C$DW$214, DW_AT_name("_uxListRemove")
.dwattr $C$DW$214, DW_AT_TI_call
CALL #_uxListRemove ; |1717|
; call occurs [#_uxListRemove] ; |1717|
BCC $C$L87,T0 == #0 ; |1717|
; branchcc occurs ; |1717|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1720,column 4,is_stmt
$C$L87:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1727,column 4,is_stmt
MOV dbl(*SP(#2)), XAR3
MOV dbl(*AR3(#22)), XAR3
MOV XAR3, AC0
BCC $C$L88,AC0 == #0 ; |1727|
; branchcc occurs ; |1727|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1729,column 5,is_stmt
MOV dbl(*SP(#2)), XAR0
AADD #14, AR0 ; |1729|
$C$DW$215 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$215, DW_AT_low_pc(0x00)
.dwattr $C$DW$215, DW_AT_name("_uxListRemove")
.dwattr $C$DW$215, DW_AT_TI_call
CALL #_uxListRemove ; |1729|
; call occurs [#_uxListRemove] ; |1729|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1730,column 4,is_stmt
$C$L88:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1736,column 4,is_stmt
MOV dbl(*SP(#2)), XAR1
AMOV #_xSuspendedTaskList, XAR0 ; |1736|
AADD #4, AR1 ; |1736|
$C$DW$216 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$216, DW_AT_low_pc(0x00)
.dwattr $C$DW$216, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$216, DW_AT_TI_call
CALL #_vListInsertEnd ; |1736|
; call occurs [#_vListInsertEnd] ; |1736|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1740,column 5,is_stmt
MOV dbl(*SP(#2)), XAR3
CMP *AR3(#48) == #1, TC1 ; |1740|
BCC $C$L89,!TC1 ; |1740|
; branchcc occurs ; |1740|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1744,column 6,is_stmt
MOV #0, *AR3(#48) ; |1744|
$C$L89:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1749,column 3,is_stmt
MOV *(#_usCriticalNesting), AR1 ; |1749|
BCC $C$L90,AR1 == #0 ; |1749|
; branchcc occurs ; |1749|
SUB #1, *(#_usCriticalNesting) ; |1749|
NOP
NOP
NOP
MOV *(#_usCriticalNesting), AR1 ; |1749|
BCC $C$L90,AR1 != #0 ; |1749|
; branchcc occurs ; |1749|
nop
bclr INTM
$C$L90:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1751,column 3,is_stmt
MOV *(#_xSchedulerRunning), AR1 ; |1751|
BCC $C$L91,AR1 == #0 ; |1751|
; branchcc occurs ; |1751|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1755,column 4,is_stmt
nop
bset INTM
ADD #1, *(#_usCriticalNesting) ; |1755|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1757,column 5,is_stmt
$C$DW$217 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$217, DW_AT_low_pc(0x00)
.dwattr $C$DW$217, DW_AT_name("_prvResetNextTaskUnblockTime")
.dwattr $C$DW$217, DW_AT_TI_call
CALL #_prvResetNextTaskUnblockTime ; |1757|
; call occurs [#_prvResetNextTaskUnblockTime] ; |1757|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1759,column 4,is_stmt
MOV *(#_usCriticalNesting), AR1 ; |1759|
BCC $C$L91,AR1 == #0 ; |1759|
; branchcc occurs ; |1759|
SUB #1, *(#_usCriticalNesting) ; |1759|
NOP
NOP
NOP
MOV *(#_usCriticalNesting), AR1 ; |1759|
BCC $C$L91,AR1 != #0 ; |1759|
; branchcc occurs ; |1759|
nop
bclr INTM
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1760,column 3,is_stmt
$C$L91:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1766,column 3,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV XAR3, AC0
MOV dbl(*SP(#2)), XAR3
MOV XAR3, AC1
CMPU AC1 != AC0, TC1 ; |1766|
BCC $C$L97,TC1 ; |1766|
; branchcc occurs ; |1766|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1768,column 4,is_stmt
MOV *(#_xSchedulerRunning), AR1 ; |1768|
BCC $C$L95,AR1 == #0 ; |1768|
; branchcc occurs ; |1768|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1771,column 5,is_stmt
MOV *(#_uxSchedulerSuspended), AR2 ; |1771|
MOV #0, AR1
BCC $C$L92,AR2 != #0 ; |1771|
; branchcc occurs ; |1771|
MOV #1, AR1
$C$L92:
BCC $C$L94,AR1 != #0 ; |1771|
; branchcc occurs ; |1771|
nop
bset INTM
$C$L93:
$C$DW$L$_vTaskSuspend$22$B:
B $C$L93 ; |1771|
; branch occurs ; |1771|
$C$DW$L$_vTaskSuspend$22$E:
$C$L94:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1772,column 5,is_stmt
$C$DW$218 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$218, DW_AT_low_pc(0x00)
.dwattr $C$DW$218, DW_AT_name("_vPortYield")
.dwattr $C$DW$218, DW_AT_TI_call
CALL #_vPortYield ; |1772|
; call occurs [#_vPortYield] ; |1772|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1773,column 4,is_stmt
B $C$L97 ; |1773|
; branch occurs ; |1773|
$C$L95:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1779,column 5,is_stmt
MOV *(#_uxCurrentNumberOfTasks), AR1 ; |1779|
MOV *(#_xSuspendedTaskList), AR2 ; |1779|
CMPU AR2 != AR1, TC1 ; |1779|
BCC $C$L96,TC1 ; |1779|
; branchcc occurs ; |1779|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1785,column 6,is_stmt
MOV #0, AC0 ; |1785|
MOV AC0, dbl(*(#_pxCurrentTCB))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1786,column 5,is_stmt
B $C$L97 ; |1786|
; branch occurs ; |1786|
$C$L96:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1789,column 6,is_stmt
$C$DW$219 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$219, DW_AT_low_pc(0x00)
.dwattr $C$DW$219, DW_AT_name("_vTaskSwitchContext")
.dwattr $C$DW$219, DW_AT_TI_call
CALL #_vTaskSwitchContext ; |1789|
; call occurs [#_vTaskSwitchContext] ; |1789|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1792,column 3,is_stmt
B $C$L97 ; |1792|
; branch occurs ; |1792|
$C$L97:
AADD #5, SP
.dwcfi cfa_offset, 1
$C$DW$220 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$220, DW_AT_low_pc(0x00)
.dwattr $C$DW$220, DW_AT_TI_return
RET
; return occurs
$C$DW$221 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$221, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L93:1:1538833113")
.dwattr $C$DW$221, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$221, DW_AT_TI_begin_line(0x6eb)
.dwattr $C$DW$221, DW_AT_TI_end_line(0x6eb)
$C$DW$222 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$222, DW_AT_low_pc($C$DW$L$_vTaskSuspend$22$B)
.dwattr $C$DW$222, DW_AT_high_pc($C$DW$L$_vTaskSuspend$22$E)
.dwendtag $C$DW$221
.dwattr $C$DW$210, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$210, DW_AT_TI_end_line(0x705)
.dwattr $C$DW$210, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$210
.sect ".text"
.align 4
$C$DW$223 .dwtag DW_TAG_subprogram, DW_AT_name("prvTaskIsTaskSuspended")
.dwattr $C$DW$223, DW_AT_low_pc(_prvTaskIsTaskSuspended)
.dwattr $C$DW$223, DW_AT_high_pc(0x00)
.dwattr $C$DW$223, DW_AT_TI_symbol_name("_prvTaskIsTaskSuspended")
.dwattr $C$DW$223, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$223, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$223, DW_AT_TI_begin_line(0x70c)
.dwattr $C$DW$223, DW_AT_TI_begin_column(0x14)
.dwattr $C$DW$223, DW_AT_TI_max_frame_size(0x08)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1805,column 2,is_stmt,address _prvTaskIsTaskSuspended
.dwfde $C$DW$CIE, _prvTaskIsTaskSuspended
$C$DW$224 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTask")
.dwattr $C$DW$224, DW_AT_TI_symbol_name("_xTask")
.dwattr $C$DW$224, DW_AT_type(*$C$DW$T$107)
.dwattr $C$DW$224, DW_AT_location[DW_OP_reg17]
;*******************************************************************************
;* FUNCTION NAME: prvTaskIsTaskSuspended *
;* *
;* Function Uses Regs : AC0,AC0,AC1,AC1,T0,AR0,XAR0,AR1,AR3,XAR3,SP,TC1,M40, *
;* SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 8 words *
;* (2 return address/alignment) *
;* (6 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_prvTaskIsTaskSuspended:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-7, SP
.dwcfi cfa_offset, 8
$C$DW$225 .dwtag DW_TAG_variable, DW_AT_name("xTask")
.dwattr $C$DW$225, DW_AT_TI_symbol_name("_xTask")
.dwattr $C$DW$225, DW_AT_type(*$C$DW$T$107)
.dwattr $C$DW$225, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$226 .dwtag DW_TAG_variable, DW_AT_name("xReturn")
.dwattr $C$DW$226, DW_AT_TI_symbol_name("_xReturn")
.dwattr $C$DW$226, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$226, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$227 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$227, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$227, DW_AT_type(*$C$DW$T$158)
.dwattr $C$DW$227, DW_AT_location[DW_OP_bregx 0x24 4]
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1806,column 13,is_stmt
MOV #0, *SP(#2) ; |1806|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1807,column 22,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, dbl(*SP(#4))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1813,column 3,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L99,AC0 != #0 ; |1813|
; branchcc occurs ; |1813|
nop
bset INTM
$C$L98:
$C$DW$L$_prvTaskIsTaskSuspended$3$B:
B $C$L98 ; |1813|
; branch occurs ; |1813|
$C$DW$L$_prvTaskIsTaskSuspended$3$E:
$C$L99:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1816,column 3,is_stmt
AMOV #_xSuspendedTaskList, XAR3 ; |1816|
MOV XAR3, AC0
MOV dbl(*SP(#4)), XAR3
MOV dbl(*AR3(#12)), XAR3
MOV XAR3, AC1
CMPU AC1 != AC0, TC1 ; |1816|
BCC $C$L100,TC1 ; |1816|
; branchcc occurs ; |1816|
MOV #1, AR1
B $C$L101 ; |1816|
; branch occurs ; |1816|
$C$L100:
MOV #0, AR1
$C$L101:
BCC $C$L106,AR1 == #0 ; |1816|
; branchcc occurs ; |1816|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1819,column 4,is_stmt
AMOV #_xPendingReadyList, XAR3 ; |1819|
MOV XAR3, AC0
MOV dbl(*SP(#4)), XAR3
MOV dbl(*AR3(#22)), XAR3
MOV XAR3, AC1
CMPU AC1 != AC0, TC1 ; |1819|
BCC $C$L102,TC1 ; |1819|
; branchcc occurs ; |1819|
MOV #1, AR1
B $C$L103 ; |1819|
; branch occurs ; |1819|
$C$L102:
MOV #0, AR1
$C$L103:
BCC $C$L106,AR1 != #0 ; |1819|
; branchcc occurs ; |1819|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1823,column 5,is_stmt
MOV dbl(*SP(#4)), XAR3
MOV dbl(*AR3(#22)), XAR3
MOV XAR3, AC0
BCC $C$L104,AC0 != #0 ; |1823|
; branchcc occurs ; |1823|
MOV #1, AR1
B $C$L105 ; |1823|
; branch occurs ; |1823|
$C$L104:
MOV #0, AR1
$C$L105:
BCC $C$L106,AR1 == #0 ; |1823|
; branchcc occurs ; |1823|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1825,column 6,is_stmt
MOV #1, *SP(#2) ; |1825|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1826,column 5,is_stmt
B $C$L106 ; |1826|
; branch occurs ; |1826|
$C$L106:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1842,column 3,is_stmt
MOV *SP(#2), T0 ; |1842|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1843,column 2,is_stmt
AADD #7, SP
.dwcfi cfa_offset, 1
$C$DW$228 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$228, DW_AT_low_pc(0x00)
.dwattr $C$DW$228, DW_AT_TI_return
RET
; return occurs
$C$DW$229 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$229, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L98:1:1538833113")
.dwattr $C$DW$229, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$229, DW_AT_TI_begin_line(0x715)
.dwattr $C$DW$229, DW_AT_TI_end_line(0x715)
$C$DW$230 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$230, DW_AT_low_pc($C$DW$L$_prvTaskIsTaskSuspended$3$B)
.dwattr $C$DW$230, DW_AT_high_pc($C$DW$L$_prvTaskIsTaskSuspended$3$E)
.dwendtag $C$DW$229
.dwattr $C$DW$223, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$223, DW_AT_TI_end_line(0x733)
.dwattr $C$DW$223, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$223
.sect ".text"
.align 4
.global _vTaskResume
$C$DW$231 .dwtag DW_TAG_subprogram, DW_AT_name("vTaskResume")
.dwattr $C$DW$231, DW_AT_low_pc(_vTaskResume)
.dwattr $C$DW$231, DW_AT_high_pc(0x00)
.dwattr $C$DW$231, DW_AT_TI_symbol_name("_vTaskResume")
.dwattr $C$DW$231, DW_AT_external
.dwattr $C$DW$231, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$231, DW_AT_TI_begin_line(0x73a)
.dwattr $C$DW$231, DW_AT_TI_begin_column(0x07)
.dwattr $C$DW$231, DW_AT_TI_max_frame_size(0x06)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1851,column 2,is_stmt,address _vTaskResume
.dwfde $C$DW$CIE, _vTaskResume
$C$DW$232 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTaskToResume")
.dwattr $C$DW$232, DW_AT_TI_symbol_name("_xTaskToResume")
.dwattr $C$DW$232, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$232, DW_AT_location[DW_OP_reg17]
;*******************************************************************************
;* FUNCTION NAME: vTaskResume *
;* *
;* Function Uses Regs : AC0,AC0,AC1,AC1,T0,AR0,XAR0,AR1,XAR1,AR2,AR3,XAR3,SP,*
;* CARRY,TC1,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 6 words *
;* (2 return address/alignment) *
;* (4 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_vTaskResume:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-5, SP
.dwcfi cfa_offset, 6
$C$DW$233 .dwtag DW_TAG_variable, DW_AT_name("xTaskToResume")
.dwattr $C$DW$233, DW_AT_TI_symbol_name("_xTaskToResume")
.dwattr $C$DW$233, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$233, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$234 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$234, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$234, DW_AT_type(*$C$DW$T$160)
.dwattr $C$DW$234, DW_AT_location[DW_OP_bregx 0x24 2]
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1852,column 16,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, dbl(*SP(#2))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1855,column 3,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L108,AC0 != #0 ; |1855|
; branchcc occurs ; |1855|
nop
bset INTM
$C$L107:
$C$DW$L$_vTaskResume$3$B:
B $C$L107 ; |1855|
; branch occurs ; |1855|
$C$DW$L$_vTaskResume$3$E:
$C$L108:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1859,column 3,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV XAR3, AC0
MOV dbl(*SP(#2)), XAR3
MOV XAR3, AC1
CMPU AC1 == AC0, TC1 ; |1859|
BCC $C$L111,TC1 ; |1859|
; branchcc occurs ; |1859|
MOV XAR3, AC0
BCC $C$L111,AC0 == #0 ; |1859|
; branchcc occurs ; |1859|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1861,column 4,is_stmt
nop
bset INTM
ADD #1, *(#_usCriticalNesting) ; |1861|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1863,column 5,is_stmt
$C$DW$235 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$235, DW_AT_low_pc(0x00)
.dwattr $C$DW$235, DW_AT_name("_prvTaskIsTaskSuspended")
.dwattr $C$DW$235, DW_AT_TI_call
CALL #_prvTaskIsTaskSuspended ; |1863|
; call occurs [#_prvTaskIsTaskSuspended] ; |1863|
BCC $C$L110,T0 == #0 ; |1863|
; branchcc occurs ; |1863|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1869,column 6,is_stmt
MOV dbl(*SP(#2)), XAR0
AADD #4, AR0 ; |1869|
$C$DW$236 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$236, DW_AT_low_pc(0x00)
.dwattr $C$DW$236, DW_AT_name("_uxListRemove")
.dwattr $C$DW$236, DW_AT_TI_call
CALL #_uxListRemove ; |1869|
; call occurs [#_uxListRemove] ; |1869|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1870,column 6,is_stmt
MOV dbl(*SP(#2)), XAR3
MOV *(#_uxTopReadyPriority), AR1 ; |1870|
MOV *AR3(#24), AR2 ; |1870|
CMPU AR2 <= AR1, TC1 ; |1870|
BCC $C$L109,TC1 ; |1870|
; branchcc occurs ; |1870|
MOV *AR3(#24), AR1 ; |1870|
MOV AR1, *(#_uxTopReadyPriority) ; |1870|
$C$L109:
MPYMK *AR3(#24), #10, AC0 ; |1870|
MOV AC0, AR1 ; |1870|
AMOV #_pxReadyTasksLists, XAR0 ; |1870|
AADD AR1, AR0 ; |1870|
MOV dbl(*SP(#2)), XAR1
AADD #4, AR1 ; |1870|
$C$DW$237 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$237, DW_AT_low_pc(0x00)
.dwattr $C$DW$237, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$237, DW_AT_TI_call
CALL #_vListInsertEnd ; |1870|
; call occurs [#_vListInsertEnd] ; |1870|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1873,column 6,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV *AR3(#24), AR1 ; |1873|
MOV dbl(*SP(#2)), XAR3
MOV *AR3(#24), AR2 ; |1873|
CMPU AR2 < AR1, TC1 ; |1873|
BCC $C$L110,TC1 ; |1873|
; branchcc occurs ; |1873|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1878,column 7,is_stmt
$C$DW$238 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$238, DW_AT_low_pc(0x00)
.dwattr $C$DW$238, DW_AT_name("_vPortYield")
.dwattr $C$DW$238, DW_AT_TI_call
CALL #_vPortYield ; |1878|
; call occurs [#_vPortYield] ; |1878|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1879,column 6,is_stmt
B $C$L110 ; |1879|
; branch occurs ; |1879|
$C$L110:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1890,column 4,is_stmt
MOV *(#_usCriticalNesting), AR1 ; |1890|
BCC $C$L111,AR1 == #0 ; |1890|
; branchcc occurs ; |1890|
SUB #1, *(#_usCriticalNesting) ; |1890|
NOP
NOP
NOP
MOV *(#_usCriticalNesting), AR1 ; |1890|
BCC $C$L111,AR1 != #0 ; |1890|
; branchcc occurs ; |1890|
nop
bclr INTM
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1891,column 3,is_stmt
B $C$L111 ; |1891|
; branch occurs ; |1891|
$C$L111:
AADD #5, SP
.dwcfi cfa_offset, 1
$C$DW$239 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$239, DW_AT_low_pc(0x00)
.dwattr $C$DW$239, DW_AT_TI_return
RET
; return occurs
$C$DW$240 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$240, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L107:1:1538833113")
.dwattr $C$DW$240, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$240, DW_AT_TI_begin_line(0x73f)
.dwattr $C$DW$240, DW_AT_TI_end_line(0x73f)
$C$DW$241 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$241, DW_AT_low_pc($C$DW$L$_vTaskResume$3$B)
.dwattr $C$DW$241, DW_AT_high_pc($C$DW$L$_vTaskResume$3$E)
.dwendtag $C$DW$240
.dwattr $C$DW$231, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$231, DW_AT_TI_end_line(0x768)
.dwattr $C$DW$231, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$231
.sect ".text"
.align 4
.global _xTaskResumeFromISR
$C$DW$242 .dwtag DW_TAG_subprogram, DW_AT_name("xTaskResumeFromISR")
.dwattr $C$DW$242, DW_AT_low_pc(_xTaskResumeFromISR)
.dwattr $C$DW$242, DW_AT_high_pc(0x00)
.dwattr $C$DW$242, DW_AT_TI_symbol_name("_xTaskResumeFromISR")
.dwattr $C$DW$242, DW_AT_external
.dwattr $C$DW$242, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$242, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$242, DW_AT_TI_begin_line(0x770)
.dwattr $C$DW$242, DW_AT_TI_begin_column(0x0d)
.dwattr $C$DW$242, DW_AT_TI_max_frame_size(0x08)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1905,column 2,is_stmt,address _xTaskResumeFromISR
.dwfde $C$DW$CIE, _xTaskResumeFromISR
$C$DW$243 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTaskToResume")
.dwattr $C$DW$243, DW_AT_TI_symbol_name("_xTaskToResume")
.dwattr $C$DW$243, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$243, DW_AT_location[DW_OP_reg17]
;*******************************************************************************
;* FUNCTION NAME: xTaskResumeFromISR *
;* *
;* Function Uses Regs : AC0,AC0,T0,AR0,XAR0,AR1,XAR1,AR2,AR3,XAR3,SP,TC1,M40,*
;* SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 8 words *
;* (1 return address/alignment) *
;* (7 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_xTaskResumeFromISR:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-7, SP
.dwcfi cfa_offset, 8
$C$DW$244 .dwtag DW_TAG_variable, DW_AT_name("xTaskToResume")
.dwattr $C$DW$244, DW_AT_TI_symbol_name("_xTaskToResume")
.dwattr $C$DW$244, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$244, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$245 .dwtag DW_TAG_variable, DW_AT_name("xYieldRequired")
.dwattr $C$DW$245, DW_AT_TI_symbol_name("_xYieldRequired")
.dwattr $C$DW$245, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$245, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$246 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$246, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$246, DW_AT_type(*$C$DW$T$160)
.dwattr $C$DW$246, DW_AT_location[DW_OP_bregx 0x24 4]
$C$DW$247 .dwtag DW_TAG_variable, DW_AT_name("uxSavedInterruptStatus")
.dwattr $C$DW$247, DW_AT_TI_symbol_name("_uxSavedInterruptStatus")
.dwattr $C$DW$247, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$247, DW_AT_location[DW_OP_bregx 0x24 6]
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1906,column 13,is_stmt
MOV #0, *SP(#2) ; |1906|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1907,column 16,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, dbl(*SP(#4))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1910,column 3,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L113,AC0 != #0 ; |1910|
; branchcc occurs ; |1910|
nop
bset INTM
$C$L112:
$C$DW$L$_xTaskResumeFromISR$3$B:
B $C$L112 ; |1910|
; branch occurs ; |1910|
$C$DW$L$_xTaskResumeFromISR$3$E:
$C$L113:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1930,column 3,is_stmt
MOV #0, *SP(#6) ; |1930|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1932,column 4,is_stmt
MOV dbl(*SP(#4)), XAR0
$C$DW$248 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$248, DW_AT_low_pc(0x00)
.dwattr $C$DW$248, DW_AT_name("_prvTaskIsTaskSuspended")
.dwattr $C$DW$248, DW_AT_TI_call
CALL #_prvTaskIsTaskSuspended ; |1932|
; call occurs [#_prvTaskIsTaskSuspended] ; |1932|
BCC $C$L117,T0 == #0 ; |1932|
; branchcc occurs ; |1932|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1937,column 5,is_stmt
MOV *(#_uxSchedulerSuspended), AR1 ; |1937|
BCC $C$L116,AR1 != #0 ; |1937|
; branchcc occurs ; |1937|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1941,column 6,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV *AR3(#24), AR1 ; |1941|
MOV dbl(*SP(#4)), XAR3
MOV *AR3(#24), AR2 ; |1941|
CMPU AR2 < AR1, TC1 ; |1941|
BCC $C$L114,TC1 ; |1941|
; branchcc occurs ; |1941|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1943,column 7,is_stmt
MOV #1, *SP(#2) ; |1943|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1944,column 6,is_stmt
$C$L114:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1950,column 6,is_stmt
MOV dbl(*SP(#4)), XAR0
AADD #4, AR0 ; |1950|
$C$DW$249 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$249, DW_AT_low_pc(0x00)
.dwattr $C$DW$249, DW_AT_name("_uxListRemove")
.dwattr $C$DW$249, DW_AT_TI_call
CALL #_uxListRemove ; |1950|
; call occurs [#_uxListRemove] ; |1950|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1951,column 6,is_stmt
MOV dbl(*SP(#4)), XAR3
MOV *(#_uxTopReadyPriority), AR1 ; |1951|
MOV *AR3(#24), AR2 ; |1951|
CMPU AR2 <= AR1, TC1 ; |1951|
BCC $C$L115,TC1 ; |1951|
; branchcc occurs ; |1951|
MOV *AR3(#24), AR1 ; |1951|
MOV AR1, *(#_uxTopReadyPriority) ; |1951|
$C$L115:
MPYMK *AR3(#24), #10, AC0 ; |1951|
MOV AC0, AR1 ; |1951|
AMOV #_pxReadyTasksLists, XAR0 ; |1951|
AADD AR1, AR0 ; |1951|
MOV dbl(*SP(#4)), XAR1
AADD #4, AR1 ; |1951|
$C$DW$250 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$250, DW_AT_low_pc(0x00)
.dwattr $C$DW$250, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$250, DW_AT_TI_call
CALL #_vListInsertEnd ; |1951|
; call occurs [#_vListInsertEnd] ; |1951|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1952,column 5,is_stmt
B $C$L117 ; |1952|
; branch occurs ; |1952|
$C$L116:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1958,column 6,is_stmt
MOV dbl(*SP(#4)), XAR1
AMOV #_xPendingReadyList, XAR0 ; |1958|
AADD #14, AR1 ; |1958|
$C$DW$251 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$251, DW_AT_low_pc(0x00)
.dwattr $C$DW$251, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$251, DW_AT_TI_call
CALL #_vListInsertEnd ; |1958|
; call occurs [#_vListInsertEnd] ; |1958|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1960,column 4,is_stmt
$C$L117:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1966,column 3,is_stmt
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1968,column 3,is_stmt
MOV *SP(#2), T0 ; |1968|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1969,column 2,is_stmt
AADD #7, SP
.dwcfi cfa_offset, 1
$C$DW$252 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$252, DW_AT_low_pc(0x00)
.dwattr $C$DW$252, DW_AT_TI_return
RET
; return occurs
$C$DW$253 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$253, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L112:1:1538833113")
.dwattr $C$DW$253, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$253, DW_AT_TI_begin_line(0x776)
.dwattr $C$DW$253, DW_AT_TI_end_line(0x776)
$C$DW$254 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$254, DW_AT_low_pc($C$DW$L$_xTaskResumeFromISR$3$B)
.dwattr $C$DW$254, DW_AT_high_pc($C$DW$L$_xTaskResumeFromISR$3$E)
.dwendtag $C$DW$253
.dwattr $C$DW$242, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$242, DW_AT_TI_end_line(0x7b1)
.dwattr $C$DW$242, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$242
.sect ".text"
.align 4
.global _vTaskStartScheduler
$C$DW$255 .dwtag DW_TAG_subprogram, DW_AT_name("vTaskStartScheduler")
.dwattr $C$DW$255, DW_AT_low_pc(_vTaskStartScheduler)
.dwattr $C$DW$255, DW_AT_high_pc(0x00)
.dwattr $C$DW$255, DW_AT_TI_symbol_name("_vTaskStartScheduler")
.dwattr $C$DW$255, DW_AT_external
.dwattr $C$DW$255, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$255, DW_AT_TI_begin_line(0x7b6)
.dwattr $C$DW$255, DW_AT_TI_begin_column(0x06)
.dwattr $C$DW$255, DW_AT_TI_max_frame_size(0x02)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 1975,column 1,is_stmt,address _vTaskStartScheduler
.dwfde $C$DW$CIE, _vTaskStartScheduler
;*******************************************************************************
;* FUNCTION NAME: vTaskStartScheduler *
;* *
;* Function Uses Regs : AC0,AC0,T0,T1,AR0,XAR0,AR1,XAR1,AR2,XAR2,SP,TC1,M40, *
;* SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 2 words *
;* (1 return address/alignment) *
;* (1 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_vTaskStartScheduler:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-1, SP
.dwcfi cfa_offset, 2
$C$DW$256 .dwtag DW_TAG_variable, DW_AT_name("xReturn")
.dwattr $C$DW$256, DW_AT_TI_symbol_name("_xReturn")
.dwattr $C$DW$256, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$256, DW_AT_location[DW_OP_bregx 0x24 0]
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2008,column 3,is_stmt
MOV #(_prvIdleTask >> 16) << #16, AC0 ; |2008|
AMOV #_xIdleTaskHandle, XAR2 ; |2008|
AMOV #0, XAR1 ; |2008|
AMOV #$C$FSL1, XAR0 ; |2008|
MOV #256, T0 ; |2008|
OR #(_prvIdleTask & 0xffff), AC0, AC0 ; |2008|
$C$DW$257 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$257, DW_AT_low_pc(0x00)
.dwattr $C$DW$257, DW_AT_name("_xTaskCreate")
.dwattr $C$DW$257, DW_AT_TI_call
CALL #_xTaskCreate ; |2008|
|| MOV #0, T1
; call occurs [#_xTaskCreate] ; |2008|
MOV T0, *SP(#0) ; |2008|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2030,column 2,is_stmt
CMP *SP(#0) == #1, TC1 ; |2030|
BCC $C$L118,!TC1 ; |2030|
; branchcc occurs ; |2030|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2046,column 3,is_stmt
nop
bset INTM
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2056,column 3,is_stmt
MOV #-1 << #16, AC0 ; |2056|
OR #0xffff, AC0, AC0 ; |2056|
MOV AC0, dbl(*(#_xNextTaskUnblockTime)) ; |2056|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2057,column 3,is_stmt
MOV #1, *(#_xSchedulerRunning) ; |2057|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2058,column 3,is_stmt
MOV #0, AC0 ; |2058|
MOV AC0, dbl(*(#_xTickCount)) ; |2058|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2072,column 3,is_stmt
$C$DW$258 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$258, DW_AT_low_pc(0x00)
.dwattr $C$DW$258, DW_AT_name("_xPortStartScheduler")
.dwattr $C$DW$258, DW_AT_TI_call
CALL #_xPortStartScheduler ; |2072|
; call occurs [#_xPortStartScheduler] ; |2072|
BCC $C$L121,T0 != #0 ; |2072|
; branchcc occurs ; |2072|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2076,column 3,is_stmt
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2081,column 2,is_stmt
B $C$L121 ; |2081|
; branch occurs ; |2081|
$C$L118:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2087,column 3,is_stmt
CMP *SP(#0) == #-1, TC1 ; |2087|
MOV #0, AR1
BCC $C$L119,TC1 ; |2087|
; branchcc occurs ; |2087|
MOV #1, AR1
$C$L119:
BCC $C$L121,AR1 != #0 ; |2087|
; branchcc occurs ; |2087|
nop
bset INTM
$C$L120:
$C$DW$L$_vTaskStartScheduler$8$B:
B $C$L120 ; |2087|
; branch occurs ; |2087|
$C$DW$L$_vTaskStartScheduler$8$E:
$C$L121:
AADD #1, SP
.dwcfi cfa_offset, 1
$C$DW$259 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$259, DW_AT_low_pc(0x00)
.dwattr $C$DW$259, DW_AT_TI_return
RET
; return occurs
$C$DW$260 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$260, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L120:1:1538833113")
.dwattr $C$DW$260, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$260, DW_AT_TI_begin_line(0x827)
.dwattr $C$DW$260, DW_AT_TI_end_line(0x827)
$C$DW$261 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$261, DW_AT_low_pc($C$DW$L$_vTaskStartScheduler$8$B)
.dwattr $C$DW$261, DW_AT_high_pc($C$DW$L$_vTaskStartScheduler$8$E)
.dwendtag $C$DW$260
.dwattr $C$DW$255, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$255, DW_AT_TI_end_line(0x82d)
.dwattr $C$DW$255, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$255
.sect ".text"
.align 4
.global _vTaskEndScheduler
$C$DW$262 .dwtag DW_TAG_subprogram, DW_AT_name("vTaskEndScheduler")
.dwattr $C$DW$262, DW_AT_low_pc(_vTaskEndScheduler)
.dwattr $C$DW$262, DW_AT_high_pc(0x00)
.dwattr $C$DW$262, DW_AT_TI_symbol_name("_vTaskEndScheduler")
.dwattr $C$DW$262, DW_AT_external
.dwattr $C$DW$262, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$262, DW_AT_TI_begin_line(0x830)
.dwattr $C$DW$262, DW_AT_TI_begin_column(0x06)
.dwattr $C$DW$262, DW_AT_TI_max_frame_size(0x02)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2097,column 1,is_stmt,address _vTaskEndScheduler
.dwfde $C$DW$CIE, _vTaskEndScheduler
;*******************************************************************************
;* FUNCTION NAME: vTaskEndScheduler *
;* *
;* Function Uses Regs : SP,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 2 words *
;* (2 return address/alignment) *
;* Min System Stack : 1 word *
;*******************************************************************************
_vTaskEndScheduler:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-1, SP
.dwcfi cfa_offset, 2
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2101,column 2,is_stmt
nop
bset INTM
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2102,column 2,is_stmt
MOV #0, *(#_xSchedulerRunning) ; |2102|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2103,column 2,is_stmt
$C$DW$263 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$263, DW_AT_low_pc(0x00)
.dwattr $C$DW$263, DW_AT_name("_vPortEndScheduler")
.dwattr $C$DW$263, DW_AT_TI_call
CALL #_vPortEndScheduler ; |2103|
; call occurs [#_vPortEndScheduler] ; |2103|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2104,column 1,is_stmt
AADD #1, SP
.dwcfi cfa_offset, 1
$C$DW$264 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$264, DW_AT_low_pc(0x00)
.dwattr $C$DW$264, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$262, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$262, DW_AT_TI_end_line(0x838)
.dwattr $C$DW$262, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$262
.sect ".text"
.align 4
.global _vTaskSuspendAll
$C$DW$265 .dwtag DW_TAG_subprogram, DW_AT_name("vTaskSuspendAll")
.dwattr $C$DW$265, DW_AT_low_pc(_vTaskSuspendAll)
.dwattr $C$DW$265, DW_AT_high_pc(0x00)
.dwattr $C$DW$265, DW_AT_TI_symbol_name("_vTaskSuspendAll")
.dwattr $C$DW$265, DW_AT_external
.dwattr $C$DW$265, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$265, DW_AT_TI_begin_line(0x83b)
.dwattr $C$DW$265, DW_AT_TI_begin_column(0x06)
.dwattr $C$DW$265, DW_AT_TI_max_frame_size(0x01)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2108,column 1,is_stmt,address _vTaskSuspendAll
.dwfde $C$DW$CIE, _vTaskSuspendAll
;*******************************************************************************
;* FUNCTION NAME: vTaskSuspendAll *
;* *
;* Function Uses Regs : SP,CARRY,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 1 word *
;* (1 return address/alignment) *
;* Min System Stack : 1 word *
;*******************************************************************************
_vTaskSuspendAll:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2113,column 2,is_stmt
ADD #1, *(#_uxSchedulerSuspended) ; |2113|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2114,column 1,is_stmt
$C$DW$266 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$266, DW_AT_low_pc(0x00)
.dwattr $C$DW$266, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$265, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$265, DW_AT_TI_end_line(0x842)
.dwattr $C$DW$265, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$265
.sect ".text"
.align 4
.global _xTaskResumeAll
$C$DW$267 .dwtag DW_TAG_subprogram, DW_AT_name("xTaskResumeAll")
.dwattr $C$DW$267, DW_AT_low_pc(_xTaskResumeAll)
.dwattr $C$DW$267, DW_AT_high_pc(0x00)
.dwattr $C$DW$267, DW_AT_TI_symbol_name("_xTaskResumeAll")
.dwattr $C$DW$267, DW_AT_external
.dwattr $C$DW$267, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$267, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$267, DW_AT_TI_begin_line(0x884)
.dwattr $C$DW$267, DW_AT_TI_begin_column(0x0c)
.dwattr $C$DW$267, DW_AT_TI_max_frame_size(0x06)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2181,column 1,is_stmt,address _xTaskResumeAll
.dwfde $C$DW$CIE, _xTaskResumeAll
;*******************************************************************************
;* FUNCTION NAME: xTaskResumeAll *
;* *
;* Function Uses Regs : AC0,AC0,T0,AR0,XAR0,AR1,XAR1,AR2,AR3,XAR3,SP,CARRY, *
;* TC1,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 6 words *
;* (2 return address/alignment) *
;* (4 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_xTaskResumeAll:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-5, SP
.dwcfi cfa_offset, 6
$C$DW$268 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$268, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$268, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$268, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$269 .dwtag DW_TAG_variable, DW_AT_name("xAlreadyYielded")
.dwattr $C$DW$269, DW_AT_TI_symbol_name("_xAlreadyYielded")
.dwattr $C$DW$269, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$269, DW_AT_location[DW_OP_bregx 0x24 2]
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2182,column 8,is_stmt
MOV #0, AC0 ; |2182|
MOV AC0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2183,column 12,is_stmt
MOV #0, *SP(#2) ; |2183|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2187,column 2,is_stmt
MOV *(#_uxSchedulerSuspended), AR1 ; |2187|
BCC $C$L123,AR1 != #0 ; |2187|
; branchcc occurs ; |2187|
nop
bset INTM
$C$L122:
$C$DW$L$_xTaskResumeAll$3$B:
B $C$L122 ; |2187|
; branch occurs ; |2187|
$C$DW$L$_xTaskResumeAll$3$E:
$C$L123:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2194,column 2,is_stmt
nop
bset INTM
ADD #1, *(#_usCriticalNesting) ; |2194|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2196,column 3,is_stmt
SUB #1, *(#_uxSchedulerSuspended) ; |2196|
NOP
NOP
NOP
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2198,column 3,is_stmt
MOV *(#_uxSchedulerSuspended), AR1 ; |2198|
BCC $C$L133,AR1 != #0 ; |2198|
; branchcc occurs ; |2198|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2200,column 4,is_stmt
MOV *(#_uxCurrentNumberOfTasks), AR1 ; |2200|
BCC $C$L133,AR1 == #0 ; |2200|
; branchcc occurs ; |2200|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2204,column 5,is_stmt
B $C$L126 ; |2204|
; branch occurs ; |2204|
$C$L124:
$C$DW$L$_xTaskResumeAll$7$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2206,column 6,is_stmt
MOV dbl(*(#(_xPendingReadyList+6))), XAR3
MOV dbl(*AR3(short(#6))), XAR3
MOV XAR3, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2207,column 6,is_stmt
MOV dbl(*SP(#0)), XAR0
AADD #14, AR0 ; |2207|
$C$DW$270 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$270, DW_AT_low_pc(0x00)
.dwattr $C$DW$270, DW_AT_name("_uxListRemove")
.dwattr $C$DW$270, DW_AT_TI_call
CALL #_uxListRemove ; |2207|
; call occurs [#_uxListRemove] ; |2207|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2208,column 6,is_stmt
MOV dbl(*SP(#0)), XAR0
AADD #4, AR0 ; |2208|
$C$DW$271 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$271, DW_AT_low_pc(0x00)
.dwattr $C$DW$271, DW_AT_name("_uxListRemove")
.dwattr $C$DW$271, DW_AT_TI_call
CALL #_uxListRemove ; |2208|
; call occurs [#_uxListRemove] ; |2208|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2209,column 6,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV *(#_uxTopReadyPriority), AR1 ; |2209|
MOV *AR3(#24), AR2 ; |2209|
CMPU AR2 <= AR1, TC1 ; |2209|
BCC $C$L125,TC1 ; |2209|
; branchcc occurs ; |2209|
$C$DW$L$_xTaskResumeAll$7$E:
$C$DW$L$_xTaskResumeAll$8$B:
MOV *AR3(#24), AR1 ; |2209|
MOV AR1, *(#_uxTopReadyPriority) ; |2209|
$C$DW$L$_xTaskResumeAll$8$E:
$C$L125:
$C$DW$L$_xTaskResumeAll$9$B:
MPYMK *AR3(#24), #10, AC0 ; |2209|
MOV AC0, AR1 ; |2209|
AMOV #_pxReadyTasksLists, XAR0 ; |2209|
AADD AR1, AR0 ; |2209|
MOV dbl(*SP(#0)), XAR1
AADD #4, AR1 ; |2209|
$C$DW$272 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$272, DW_AT_low_pc(0x00)
.dwattr $C$DW$272, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$272, DW_AT_TI_call
CALL #_vListInsertEnd ; |2209|
; call occurs [#_vListInsertEnd] ; |2209|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2213,column 6,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV *AR3(#24), AR1 ; |2213|
MOV dbl(*SP(#0)), XAR3
MOV *AR3(#24), AR2 ; |2213|
CMPU AR2 < AR1, TC1 ; |2213|
BCC $C$L126,TC1 ; |2213|
; branchcc occurs ; |2213|
$C$DW$L$_xTaskResumeAll$9$E:
$C$DW$L$_xTaskResumeAll$10$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2215,column 7,is_stmt
MOV #1, *(#_xYieldPending) ; |2215|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2216,column 6,is_stmt
$C$DW$L$_xTaskResumeAll$10$E:
$C$L126:
$C$DW$L$_xTaskResumeAll$11$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2204,column 12,is_stmt
MOV *(#_xPendingReadyList), AR1 ; |2204|
BCC $C$L127,AR1 != #0 ; |2204|
; branchcc occurs ; |2204|
$C$DW$L$_xTaskResumeAll$11$E:
$C$DW$L$_xTaskResumeAll$12$B:
MOV #1, AR1
B $C$L128 ; |2204|
; branch occurs ; |2204|
$C$DW$L$_xTaskResumeAll$12$E:
$C$L127:
$C$DW$L$_xTaskResumeAll$13$B:
MOV #0, AR1
$C$DW$L$_xTaskResumeAll$13$E:
$C$L128:
$C$DW$L$_xTaskResumeAll$14$B:
BCC $C$L124,AR1 == #0 ; |2204|
; branchcc occurs ; |2204|
$C$DW$L$_xTaskResumeAll$14$E:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2223,column 5,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L129,AC0 == #0 ; |2223|
; branchcc occurs ; |2223|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2231,column 6,is_stmt
$C$DW$273 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$273, DW_AT_low_pc(0x00)
.dwattr $C$DW$273, DW_AT_name("_prvResetNextTaskUnblockTime")
.dwattr $C$DW$273, DW_AT_TI_call
CALL #_prvResetNextTaskUnblockTime ; |2231|
; call occurs [#_prvResetNextTaskUnblockTime] ; |2231|
$C$L129:
$C$DW$274 .dwtag DW_TAG_lexical_block, DW_AT_low_pc(0x00), DW_AT_high_pc(0x00)
$C$DW$275 .dwtag DW_TAG_variable, DW_AT_name("uxPendedCounts")
.dwattr $C$DW$275, DW_AT_TI_symbol_name("_uxPendedCounts")
.dwattr $C$DW$275, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$275, DW_AT_location[DW_OP_bregx 0x24 3]
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2239,column 18,is_stmt
MOV *(#_uxPendedTicks), AR1 ; |2239|
MOV AR1, *SP(#3) ; |2239|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2241,column 6,is_stmt
BCC $C$L132,AR1 == #0 ; |2241|
; branchcc occurs ; |2241|
$C$L130:
$C$DW$L$_xTaskResumeAll$18$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2245,column 8,is_stmt
$C$DW$276 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$276, DW_AT_low_pc(0x00)
.dwattr $C$DW$276, DW_AT_name("_xTaskIncrementTick")
.dwattr $C$DW$276, DW_AT_TI_call
CALL #_xTaskIncrementTick ; |2245|
; call occurs [#_xTaskIncrementTick] ; |2245|
BCC $C$L131,T0 == #0 ; |2245|
; branchcc occurs ; |2245|
$C$DW$L$_xTaskResumeAll$18$E:
$C$DW$L$_xTaskResumeAll$19$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2247,column 9,is_stmt
MOV #1, *(#_xYieldPending) ; |2247|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2248,column 8,is_stmt
$C$DW$L$_xTaskResumeAll$19$E:
$C$L131:
$C$DW$L$_xTaskResumeAll$20$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2253,column 8,is_stmt
SUB #1, *SP(#3) ; |2253|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2254,column 16,is_stmt
MOV *SP(#3), AR1 ; |2254|
BCC $C$L130,AR1 != #0 ; |2254|
; branchcc occurs ; |2254|
$C$DW$L$_xTaskResumeAll$20$E:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2256,column 7,is_stmt
MOV #0, *(#_uxPendedTicks) ; |2256|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2257,column 6,is_stmt
$C$L132:
.dwendtag $C$DW$274
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2264,column 5,is_stmt
MOV *(#_xYieldPending), AR1 ; |2264|
BCC $C$L133,AR1 == #0 ; |2264|
; branchcc occurs ; |2264|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2268,column 7,is_stmt
MOV #1, *SP(#2) ; |2268|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2271,column 6,is_stmt
$C$DW$277 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$277, DW_AT_low_pc(0x00)
.dwattr $C$DW$277, DW_AT_name("_vPortYield")
.dwattr $C$DW$277, DW_AT_TI_call
CALL #_vPortYield ; |2271|
; call occurs [#_vPortYield] ; |2271|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2272,column 5,is_stmt
B $C$L133 ; |2272|
; branch occurs ; |2272|
$C$L133:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2284,column 2,is_stmt
MOV *(#_usCriticalNesting), AR1 ; |2284|
BCC $C$L134,AR1 == #0 ; |2284|
; branchcc occurs ; |2284|
SUB #1, *(#_usCriticalNesting) ; |2284|
NOP
NOP
NOP
MOV *(#_usCriticalNesting), AR1 ; |2284|
BCC $C$L134,AR1 != #0 ; |2284|
; branchcc occurs ; |2284|
nop
bclr INTM
$C$L134:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2286,column 2,is_stmt
MOV *SP(#2), T0 ; |2286|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2287,column 1,is_stmt
AADD #5, SP
.dwcfi cfa_offset, 1
$C$DW$278 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$278, DW_AT_low_pc(0x00)
.dwattr $C$DW$278, DW_AT_TI_return
RET
; return occurs
$C$DW$279 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$279, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L130:1:1538833113")
.dwattr $C$DW$279, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$279, DW_AT_TI_begin_line(0x8c3)
.dwattr $C$DW$279, DW_AT_TI_end_line(0x8ce)
$C$DW$280 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$280, DW_AT_low_pc($C$DW$L$_xTaskResumeAll$18$B)
.dwattr $C$DW$280, DW_AT_high_pc($C$DW$L$_xTaskResumeAll$18$E)
$C$DW$281 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$281, DW_AT_low_pc($C$DW$L$_xTaskResumeAll$19$B)
.dwattr $C$DW$281, DW_AT_high_pc($C$DW$L$_xTaskResumeAll$19$E)
$C$DW$282 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$282, DW_AT_low_pc($C$DW$L$_xTaskResumeAll$20$B)
.dwattr $C$DW$282, DW_AT_high_pc($C$DW$L$_xTaskResumeAll$20$E)
.dwendtag $C$DW$279
$C$DW$283 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$283, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L126:1:1538833113")
.dwattr $C$DW$283, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$283, DW_AT_TI_begin_line(0x89c)
.dwattr $C$DW$283, DW_AT_TI_end_line(0x8a8)
$C$DW$284 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$284, DW_AT_low_pc($C$DW$L$_xTaskResumeAll$11$B)
.dwattr $C$DW$284, DW_AT_high_pc($C$DW$L$_xTaskResumeAll$11$E)
$C$DW$285 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$285, DW_AT_low_pc($C$DW$L$_xTaskResumeAll$12$B)
.dwattr $C$DW$285, DW_AT_high_pc($C$DW$L$_xTaskResumeAll$12$E)
$C$DW$286 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$286, DW_AT_low_pc($C$DW$L$_xTaskResumeAll$13$B)
.dwattr $C$DW$286, DW_AT_high_pc($C$DW$L$_xTaskResumeAll$13$E)
$C$DW$287 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$287, DW_AT_low_pc($C$DW$L$_xTaskResumeAll$14$B)
.dwattr $C$DW$287, DW_AT_high_pc($C$DW$L$_xTaskResumeAll$14$E)
$C$DW$288 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$288, DW_AT_low_pc($C$DW$L$_xTaskResumeAll$7$B)
.dwattr $C$DW$288, DW_AT_high_pc($C$DW$L$_xTaskResumeAll$7$E)
$C$DW$289 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$289, DW_AT_low_pc($C$DW$L$_xTaskResumeAll$8$B)
.dwattr $C$DW$289, DW_AT_high_pc($C$DW$L$_xTaskResumeAll$8$E)
$C$DW$290 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$290, DW_AT_low_pc($C$DW$L$_xTaskResumeAll$10$B)
.dwattr $C$DW$290, DW_AT_high_pc($C$DW$L$_xTaskResumeAll$10$E)
$C$DW$291 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$291, DW_AT_low_pc($C$DW$L$_xTaskResumeAll$9$B)
.dwattr $C$DW$291, DW_AT_high_pc($C$DW$L$_xTaskResumeAll$9$E)
.dwendtag $C$DW$283
$C$DW$292 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$292, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L122:1:1538833113")
.dwattr $C$DW$292, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$292, DW_AT_TI_begin_line(0x88b)
.dwattr $C$DW$292, DW_AT_TI_end_line(0x88b)
$C$DW$293 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$293, DW_AT_low_pc($C$DW$L$_xTaskResumeAll$3$B)
.dwattr $C$DW$293, DW_AT_high_pc($C$DW$L$_xTaskResumeAll$3$E)
.dwendtag $C$DW$292
.dwattr $C$DW$267, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$267, DW_AT_TI_end_line(0x8ef)
.dwattr $C$DW$267, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$267
.sect ".text"
.align 4
.global _xTaskGetTickCount
$C$DW$294 .dwtag DW_TAG_subprogram, DW_AT_name("xTaskGetTickCount")
.dwattr $C$DW$294, DW_AT_low_pc(_xTaskGetTickCount)
.dwattr $C$DW$294, DW_AT_high_pc(0x00)
.dwattr $C$DW$294, DW_AT_TI_symbol_name("_xTaskGetTickCount")
.dwattr $C$DW$294, DW_AT_external
.dwattr $C$DW$294, DW_AT_type(*$C$DW$T$37)
.dwattr $C$DW$294, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$294, DW_AT_TI_begin_line(0x8f2)
.dwattr $C$DW$294, DW_AT_TI_begin_column(0x0c)
.dwattr $C$DW$294, DW_AT_TI_max_frame_size(0x04)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2291,column 1,is_stmt,address _xTaskGetTickCount
.dwfde $C$DW$CIE, _xTaskGetTickCount
;*******************************************************************************
;* FUNCTION NAME: xTaskGetTickCount *
;* *
;* Function Uses Regs : AC0,AC0,AR1,SP,CARRY,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 4 words *
;* (2 return address/alignment) *
;* (2 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_xTaskGetTickCount:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-3, SP
.dwcfi cfa_offset, 4
$C$DW$295 .dwtag DW_TAG_variable, DW_AT_name("xTicks")
.dwattr $C$DW$295, DW_AT_TI_symbol_name("_xTicks")
.dwattr $C$DW$295, DW_AT_type(*$C$DW$T$37)
.dwattr $C$DW$295, DW_AT_location[DW_OP_bregx 0x24 0]
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2295,column 2,is_stmt
nop
bset INTM
ADD #1, *(#_usCriticalNesting) ; |2295|
NOP
NOP
NOP
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2297,column 3,is_stmt
MOV dbl(*(#_xTickCount)), AC0 ; |2297|
MOV AC0, dbl(*SP(#0)) ; |2297|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2299,column 2,is_stmt
MOV *(#_usCriticalNesting), AR1 ; |2299|
BCC $C$L135,AR1 == #0 ; |2299|
; branchcc occurs ; |2299|
SUB #1, *(#_usCriticalNesting) ; |2299|
NOP
NOP
NOP
MOV *(#_usCriticalNesting), AR1 ; |2299|
BCC $C$L135,AR1 != #0 ; |2299|
; branchcc occurs ; |2299|
nop
bclr INTM
$C$L135:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2301,column 2,is_stmt
MOV dbl(*SP(#0)), AC0 ; |2301|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2302,column 1,is_stmt
AADD #3, SP
.dwcfi cfa_offset, 1
$C$DW$296 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$296, DW_AT_low_pc(0x00)
.dwattr $C$DW$296, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$294, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$294, DW_AT_TI_end_line(0x8fe)
.dwattr $C$DW$294, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$294
.sect ".text"
.align 4
.global _xTaskGetTickCountFromISR
$C$DW$297 .dwtag DW_TAG_subprogram, DW_AT_name("xTaskGetTickCountFromISR")
.dwattr $C$DW$297, DW_AT_low_pc(_xTaskGetTickCountFromISR)
.dwattr $C$DW$297, DW_AT_high_pc(0x00)
.dwattr $C$DW$297, DW_AT_TI_symbol_name("_xTaskGetTickCountFromISR")
.dwattr $C$DW$297, DW_AT_external
.dwattr $C$DW$297, DW_AT_type(*$C$DW$T$37)
.dwattr $C$DW$297, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$297, DW_AT_TI_begin_line(0x901)
.dwattr $C$DW$297, DW_AT_TI_begin_column(0x0c)
.dwattr $C$DW$297, DW_AT_TI_max_frame_size(0x04)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2306,column 1,is_stmt,address _xTaskGetTickCountFromISR
.dwfde $C$DW$CIE, _xTaskGetTickCountFromISR
;*******************************************************************************
;* FUNCTION NAME: xTaskGetTickCountFromISR *
;* *
;* Function Uses Regs : AC0,AC0,SP,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 4 words *
;* (1 return address/alignment) *
;* (3 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_xTaskGetTickCountFromISR:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-3, SP
.dwcfi cfa_offset, 4
$C$DW$298 .dwtag DW_TAG_variable, DW_AT_name("xReturn")
.dwattr $C$DW$298, DW_AT_TI_symbol_name("_xReturn")
.dwattr $C$DW$298, DW_AT_type(*$C$DW$T$37)
.dwattr $C$DW$298, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$299 .dwtag DW_TAG_variable, DW_AT_name("uxSavedInterruptStatus")
.dwattr $C$DW$299, DW_AT_TI_symbol_name("_uxSavedInterruptStatus")
.dwattr $C$DW$299, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$299, DW_AT_location[DW_OP_bregx 0x24 2]
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2326,column 2,is_stmt
MOV #0, *SP(#2) ; |2326|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2328,column 3,is_stmt
MOV dbl(*(#_xTickCount)), AC0 ; |2328|
MOV AC0, dbl(*SP(#0)) ; |2328|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2330,column 2,is_stmt
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2332,column 2,is_stmt
MOV dbl(*SP(#0)), AC0 ; |2332|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2333,column 1,is_stmt
AADD #3, SP
.dwcfi cfa_offset, 1
$C$DW$300 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$300, DW_AT_low_pc(0x00)
.dwattr $C$DW$300, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$297, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$297, DW_AT_TI_end_line(0x91d)
.dwattr $C$DW$297, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$297
.sect ".text"
.align 4
.global _uxTaskGetNumberOfTasks
$C$DW$301 .dwtag DW_TAG_subprogram, DW_AT_name("uxTaskGetNumberOfTasks")
.dwattr $C$DW$301, DW_AT_low_pc(_uxTaskGetNumberOfTasks)
.dwattr $C$DW$301, DW_AT_high_pc(0x00)
.dwattr $C$DW$301, DW_AT_TI_symbol_name("_uxTaskGetNumberOfTasks")
.dwattr $C$DW$301, DW_AT_external
.dwattr $C$DW$301, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$301, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$301, DW_AT_TI_begin_line(0x920)
.dwattr $C$DW$301, DW_AT_TI_begin_column(0x0d)
.dwattr $C$DW$301, DW_AT_TI_max_frame_size(0x01)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2337,column 1,is_stmt,address _uxTaskGetNumberOfTasks
.dwfde $C$DW$CIE, _uxTaskGetNumberOfTasks
;*******************************************************************************
;* FUNCTION NAME: uxTaskGetNumberOfTasks *
;* *
;* Function Uses Regs : T0,SP,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 1 word *
;* (1 return address/alignment) *
;* Min System Stack : 1 word *
;*******************************************************************************
_uxTaskGetNumberOfTasks:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2340,column 2,is_stmt
MOV *(#_uxCurrentNumberOfTasks), T0 ; |2340|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2341,column 1,is_stmt
$C$DW$302 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$302, DW_AT_low_pc(0x00)
.dwattr $C$DW$302, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$301, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$301, DW_AT_TI_end_line(0x925)
.dwattr $C$DW$301, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$301
.sect ".text"
.align 4
.global _pcTaskGetName
$C$DW$303 .dwtag DW_TAG_subprogram, DW_AT_name("pcTaskGetName")
.dwattr $C$DW$303, DW_AT_low_pc(_pcTaskGetName)
.dwattr $C$DW$303, DW_AT_high_pc(0x00)
.dwattr $C$DW$303, DW_AT_TI_symbol_name("_pcTaskGetName")
.dwattr $C$DW$303, DW_AT_external
.dwattr $C$DW$303, DW_AT_type(*$C$DW$T$150)
.dwattr $C$DW$303, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$303, DW_AT_TI_begin_line(0x928)
.dwattr $C$DW$303, DW_AT_TI_begin_column(0x07)
.dwattr $C$DW$303, DW_AT_TI_max_frame_size(0x06)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2345,column 1,is_stmt,address _pcTaskGetName
.dwfde $C$DW$CIE, _pcTaskGetName
$C$DW$304 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTaskToQuery")
.dwattr $C$DW$304, DW_AT_TI_symbol_name("_xTaskToQuery")
.dwattr $C$DW$304, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$304, DW_AT_location[DW_OP_reg17]
;*******************************************************************************
;* FUNCTION NAME: pcTaskGetName *
;* *
;* Function Uses Regs : AC0,AC0,AR0,XAR0,AR3,XAR3,SP,M40,SATA,SATD,RDM,FRCT, *
;* SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 6 words *
;* (2 return address/alignment) *
;* (4 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_pcTaskGetName:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-5, SP
.dwcfi cfa_offset, 6
$C$DW$305 .dwtag DW_TAG_variable, DW_AT_name("xTaskToQuery")
.dwattr $C$DW$305, DW_AT_TI_symbol_name("_xTaskToQuery")
.dwattr $C$DW$305, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$305, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$306 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$306, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$306, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$306, DW_AT_location[DW_OP_bregx 0x24 2]
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2350,column 2,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L136,AC0 != #0 ; |2350|
; branchcc occurs ; |2350|
MOV dbl(*(#_pxCurrentTCB)), XAR3
$C$L136:
MOV XAR3, dbl(*SP(#2))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2351,column 2,is_stmt
MOV XAR3, AC0
BCC $C$L138,AC0 != #0 ; |2351|
; branchcc occurs ; |2351|
nop
bset INTM
$C$L137:
$C$DW$L$_pcTaskGetName$5$B:
B $C$L137 ; |2351|
; branch occurs ; |2351|
$C$DW$L$_pcTaskGetName$5$E:
$C$L138:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2352,column 2,is_stmt
MOV dbl(*SP(#2)), XAR0
AADD #30, AR0 ; |2352|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2353,column 1,is_stmt
AADD #5, SP
.dwcfi cfa_offset, 1
$C$DW$307 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$307, DW_AT_low_pc(0x00)
.dwattr $C$DW$307, DW_AT_TI_return
RET
; return occurs
$C$DW$308 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$308, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L137:1:1538833113")
.dwattr $C$DW$308, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$308, DW_AT_TI_begin_line(0x92f)
.dwattr $C$DW$308, DW_AT_TI_end_line(0x92f)
$C$DW$309 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$309, DW_AT_low_pc($C$DW$L$_pcTaskGetName$5$B)
.dwattr $C$DW$309, DW_AT_high_pc($C$DW$L$_pcTaskGetName$5$E)
.dwendtag $C$DW$308
.dwattr $C$DW$303, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$303, DW_AT_TI_end_line(0x931)
.dwattr $C$DW$303, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$303
.sect ".text"
.align 4
.global _xTaskIncrementTick
$C$DW$310 .dwtag DW_TAG_subprogram, DW_AT_name("xTaskIncrementTick")
.dwattr $C$DW$310, DW_AT_low_pc(_xTaskIncrementTick)
.dwattr $C$DW$310, DW_AT_high_pc(0x00)
.dwattr $C$DW$310, DW_AT_TI_symbol_name("_xTaskIncrementTick")
.dwattr $C$DW$310, DW_AT_external
.dwattr $C$DW$310, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$310, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$310, DW_AT_TI_begin_line(0xa6f)
.dwattr $C$DW$310, DW_AT_TI_begin_column(0x0c)
.dwattr $C$DW$310, DW_AT_TI_max_frame_size(0x0c)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2672,column 1,is_stmt,address _xTaskIncrementTick
.dwfde $C$DW$CIE, _xTaskIncrementTick
;*******************************************************************************
;* FUNCTION NAME: xTaskIncrementTick *
;* *
;* Function Uses Regs : AC0,AC0,AC1,AC1,T0,AR0,XAR0,AR1,XAR1,AR2,AR3,XAR3,SP,*
;* CARRY,TC1,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 12 words *
;* (2 return address/alignment) *
;* (10 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_xTaskIncrementTick:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-11, SP
.dwcfi cfa_offset, 12
$C$DW$311 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$311, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$311, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$311, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$312 .dwtag DW_TAG_variable, DW_AT_name("xItemValue")
.dwattr $C$DW$312, DW_AT_TI_symbol_name("_xItemValue")
.dwattr $C$DW$312, DW_AT_type(*$C$DW$T$37)
.dwattr $C$DW$312, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$313 .dwtag DW_TAG_variable, DW_AT_name("xSwitchRequired")
.dwattr $C$DW$313, DW_AT_TI_symbol_name("_xSwitchRequired")
.dwattr $C$DW$313, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$313, DW_AT_location[DW_OP_bregx 0x24 4]
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2675,column 12,is_stmt
MOV #0, *SP(#4) ; |2675|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2677,column 6,is_stmt
MOV dbl(*(#_wall_clk_ctr)), AC0 ; |2677|
ADD #1, AC0 ; |2677|
MOV AC0, dbl(*(#_wall_clk_ctr)) ; |2677|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2683,column 2,is_stmt
MOV *(#_uxSchedulerSuspended), AR1 ; |2683|
BCC $C$L151,AR1 != #0 ; |2683|
; branchcc occurs ; |2683|
$C$DW$314 .dwtag DW_TAG_lexical_block, DW_AT_low_pc(0x00), DW_AT_high_pc(0x00)
$C$DW$315 .dwtag DW_TAG_variable, DW_AT_name("xConstTickCount")
.dwattr $C$DW$315, DW_AT_TI_symbol_name("_xConstTickCount")
.dwattr $C$DW$315, DW_AT_type(*$C$DW$T$95)
.dwattr $C$DW$315, DW_AT_location[DW_OP_bregx 0x24 6]
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2687,column 20,is_stmt
MOV dbl(*(#_xTickCount)), AC0 ; |2687|
ADD #1, AC0 ; |2687|
MOV AC0, dbl(*SP(#6)) ; |2687|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2691,column 3,is_stmt
MOV dbl(*SP(#6)), AC0 ; |2691|
MOV AC0, dbl(*(#_xTickCount)) ; |2691|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2693,column 3,is_stmt
MOV dbl(*SP(#6)), AC0 ; |2693|
BCC $C$L143,AC0 != #0 ; |2693|
; branchcc occurs ; |2693|
$C$DW$316 .dwtag DW_TAG_lexical_block, DW_AT_low_pc(0x00), DW_AT_high_pc(0x00)
$C$DW$317 .dwtag DW_TAG_variable, DW_AT_name("pxTemp")
.dwattr $C$DW$317, DW_AT_TI_symbol_name("_pxTemp")
.dwattr $C$DW$317, DW_AT_type(*$C$DW$T$66)
.dwattr $C$DW$317, DW_AT_location[DW_OP_bregx 0x24 8]
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2695,column 4,is_stmt
MOV dbl(*(#_pxDelayedTaskList)), XAR3
MOV *AR3, AR1 ; |2695|
BCC $C$L139,AR1 != #0 ; |2695|
; branchcc occurs ; |2695|
MOV #1, AR1
B $C$L140 ; |2695|
; branch occurs ; |2695|
$C$L139:
MOV #0, AR1
$C$L140:
BCC $C$L142,AR1 != #0 ; |2695|
; branchcc occurs ; |2695|
nop
bset INTM
$C$L141:
$C$DW$L$_xTaskIncrementTick$8$B:
B $C$L141 ; |2695|
; branch occurs ; |2695|
$C$DW$L$_xTaskIncrementTick$8$E:
$C$L142:
MOV dbl(*(#_pxDelayedTaskList)), XAR3
MOV XAR3, dbl(*SP(#8))
MOV dbl(*(#_pxOverflowDelayedTaskList)), XAR3
MOV XAR3, dbl(*(#_pxDelayedTaskList))
MOV dbl(*SP(#8)), XAR3
MOV XAR3, dbl(*(#_pxOverflowDelayedTaskList))
ADD #1, *(#_xNumOfOverflows) ; |2695|
$C$DW$318 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$318, DW_AT_low_pc(0x00)
.dwattr $C$DW$318, DW_AT_name("_prvResetNextTaskUnblockTime")
.dwattr $C$DW$318, DW_AT_TI_call
CALL #_prvResetNextTaskUnblockTime ; |2695|
; call occurs [#_prvResetNextTaskUnblockTime] ; |2695|
.dwendtag $C$DW$316
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2696,column 3,is_stmt
$C$L143:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2706,column 3,is_stmt
MOV dbl(*(#_xNextTaskUnblockTime)), AC0 ; |2706|
MOV dbl(*SP(#6)), AC1 ; |2706|
CMPU AC1 < AC0, TC1 ; |2706|
BCC $C$L152,TC1 ; |2706|
; branchcc occurs ; |2706|
$C$L144:
$C$DW$L$_xTaskIncrementTick$11$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2710,column 5,is_stmt
MOV dbl(*(#_pxDelayedTaskList)), XAR3
MOV *AR3, AR1 ; |2710|
BCC $C$L145,AR1 != #0 ; |2710|
; branchcc occurs ; |2710|
$C$DW$L$_xTaskIncrementTick$11$E:
$C$DW$L$_xTaskIncrementTick$12$B:
MOV #1, AR1
B $C$L146 ; |2710|
; branch occurs ; |2710|
$C$DW$L$_xTaskIncrementTick$12$E:
$C$L145:
$C$DW$L$_xTaskIncrementTick$13$B:
MOV #0, AR1
$C$DW$L$_xTaskIncrementTick$13$E:
$C$L146:
$C$DW$L$_xTaskIncrementTick$14$B:
BCC $C$L147,AR1 == #0 ; |2710|
; branchcc occurs ; |2710|
$C$DW$L$_xTaskIncrementTick$14$E:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2717,column 6,is_stmt
MOV #-1 << #16, AC0 ; |2717|
OR #0xffff, AC0, AC0 ; |2717|
MOV AC0, dbl(*(#_xNextTaskUnblockTime)) ; |2717|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2718,column 6,is_stmt
B $C$L152 ; |2718|
; branch occurs ; |2718|
$C$L147:
$C$DW$L$_xTaskIncrementTick$17$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2726,column 6,is_stmt
MOV dbl(*(#_pxDelayedTaskList)), XAR3
MOV dbl(*AR3(short(#6))), XAR3
MOV dbl(*AR3(short(#6))), XAR3
MOV XAR3, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2727,column 6,is_stmt
MOV dbl(*AR3(short(#4))), AC0 ; |2727|
MOV AC0, dbl(*SP(#2)) ; |2727|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2729,column 6,is_stmt
MOV dbl(*SP(#6)), AC1 ; |2729|
MOV dbl(*SP(#2)), AC0 ; |2729|
CMPU AC1 >= AC0, TC1 ; |2729|
BCC $C$L148,TC1 ; |2729|
; branchcc occurs ; |2729|
$C$DW$L$_xTaskIncrementTick$17$E:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2736,column 7,is_stmt
MOV dbl(*SP(#2)), AC0 ; |2736|
MOV AC0, dbl(*(#_xNextTaskUnblockTime)) ; |2736|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2737,column 7,is_stmt
B $C$L152 ; |2737|
; branch occurs ; |2737|
$C$L148:
$C$DW$L$_xTaskIncrementTick$20$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2745,column 6,is_stmt
MOV dbl(*SP(#0)), XAR0
AADD #4, AR0 ; |2745|
$C$DW$319 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$319, DW_AT_low_pc(0x00)
.dwattr $C$DW$319, DW_AT_name("_uxListRemove")
.dwattr $C$DW$319, DW_AT_TI_call
CALL #_uxListRemove ; |2745|
; call occurs [#_uxListRemove] ; |2745|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2749,column 6,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV dbl(*AR3(#22)), XAR3
MOV XAR3, AC0
BCC $C$L149,AC0 == #0 ; |2749|
; branchcc occurs ; |2749|
$C$DW$L$_xTaskIncrementTick$20$E:
$C$DW$L$_xTaskIncrementTick$21$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2751,column 7,is_stmt
MOV dbl(*SP(#0)), XAR0
AADD #14, AR0 ; |2751|
$C$DW$320 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$320, DW_AT_low_pc(0x00)
.dwattr $C$DW$320, DW_AT_name("_uxListRemove")
.dwattr $C$DW$320, DW_AT_TI_call
CALL #_uxListRemove ; |2751|
; call occurs [#_uxListRemove] ; |2751|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2752,column 6,is_stmt
$C$DW$L$_xTaskIncrementTick$21$E:
$C$L149:
$C$DW$L$_xTaskIncrementTick$22$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2760,column 6,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV *(#_uxTopReadyPriority), AR1 ; |2760|
MOV *AR3(#24), AR2 ; |2760|
CMPU AR2 <= AR1, TC1 ; |2760|
BCC $C$L150,TC1 ; |2760|
; branchcc occurs ; |2760|
$C$DW$L$_xTaskIncrementTick$22$E:
$C$DW$L$_xTaskIncrementTick$23$B:
MOV *AR3(#24), AR1 ; |2760|
MOV AR1, *(#_uxTopReadyPriority) ; |2760|
$C$DW$L$_xTaskIncrementTick$23$E:
$C$L150:
$C$DW$L$_xTaskIncrementTick$24$B:
MPYMK *AR3(#24), #10, AC0 ; |2760|
MOV AC0, AR1 ; |2760|
AMOV #_pxReadyTasksLists, XAR0 ; |2760|
AADD AR1, AR0 ; |2760|
MOV dbl(*SP(#0)), XAR1
AADD #4, AR1 ; |2760|
$C$DW$321 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$321, DW_AT_low_pc(0x00)
.dwattr $C$DW$321, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$321, DW_AT_TI_call
CALL #_vListInsertEnd ; |2760|
; call occurs [#_vListInsertEnd] ; |2760|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2770,column 7,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV *AR3(#24), AR1 ; |2770|
MOV dbl(*SP(#0)), XAR3
MOV *AR3(#24), AR2 ; |2770|
CMPU AR2 < AR1, TC1 ; |2770|
BCC $C$L144,TC1 ; |2770|
; branchcc occurs ; |2770|
$C$DW$L$_xTaskIncrementTick$24$E:
$C$DW$L$_xTaskIncrementTick$25$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2772,column 8,is_stmt
MOV #1, *SP(#4) ; |2772|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2773,column 7,is_stmt
B $C$L144 ; |2773|
; branch occurs ; |2773|
$C$DW$L$_xTaskIncrementTick$25$E:
.dwendtag $C$DW$314
$C$L151:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2817,column 3,is_stmt
ADD #1, *(#_uxPendedTicks) ; |2817|
$C$L152:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2830,column 3,is_stmt
MOV *(#_xYieldPending), AR1 ; |2830|
BCC $C$L153,AR1 == #0 ; |2830|
; branchcc occurs ; |2830|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2832,column 4,is_stmt
MOV #1, *SP(#4) ; |2832|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2833,column 3,is_stmt
$C$L153:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2841,column 2,is_stmt
MOV *SP(#4), T0 ; |2841|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2842,column 1,is_stmt
AADD #11, SP
.dwcfi cfa_offset, 1
$C$DW$322 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$322, DW_AT_low_pc(0x00)
.dwattr $C$DW$322, DW_AT_TI_return
RET
; return occurs
$C$DW$323 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$323, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L144:1:1538833113")
.dwattr $C$DW$323, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$323, DW_AT_TI_begin_line(0xa94)
.dwattr $C$DW$323, DW_AT_TI_end_line(0xadd)
$C$DW$324 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$324, DW_AT_low_pc($C$DW$L$_xTaskIncrementTick$11$B)
.dwattr $C$DW$324, DW_AT_high_pc($C$DW$L$_xTaskIncrementTick$11$E)
$C$DW$325 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$325, DW_AT_low_pc($C$DW$L$_xTaskIncrementTick$12$B)
.dwattr $C$DW$325, DW_AT_high_pc($C$DW$L$_xTaskIncrementTick$12$E)
$C$DW$326 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$326, DW_AT_low_pc($C$DW$L$_xTaskIncrementTick$13$B)
.dwattr $C$DW$326, DW_AT_high_pc($C$DW$L$_xTaskIncrementTick$13$E)
$C$DW$327 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$327, DW_AT_low_pc($C$DW$L$_xTaskIncrementTick$14$B)
.dwattr $C$DW$327, DW_AT_high_pc($C$DW$L$_xTaskIncrementTick$14$E)
$C$DW$328 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$328, DW_AT_low_pc($C$DW$L$_xTaskIncrementTick$17$B)
.dwattr $C$DW$328, DW_AT_high_pc($C$DW$L$_xTaskIncrementTick$17$E)
$C$DW$329 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$329, DW_AT_low_pc($C$DW$L$_xTaskIncrementTick$20$B)
.dwattr $C$DW$329, DW_AT_high_pc($C$DW$L$_xTaskIncrementTick$20$E)
$C$DW$330 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$330, DW_AT_low_pc($C$DW$L$_xTaskIncrementTick$21$B)
.dwattr $C$DW$330, DW_AT_high_pc($C$DW$L$_xTaskIncrementTick$21$E)
$C$DW$331 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$331, DW_AT_low_pc($C$DW$L$_xTaskIncrementTick$22$B)
.dwattr $C$DW$331, DW_AT_high_pc($C$DW$L$_xTaskIncrementTick$22$E)
$C$DW$332 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$332, DW_AT_low_pc($C$DW$L$_xTaskIncrementTick$23$B)
.dwattr $C$DW$332, DW_AT_high_pc($C$DW$L$_xTaskIncrementTick$23$E)
$C$DW$333 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$333, DW_AT_low_pc($C$DW$L$_xTaskIncrementTick$25$B)
.dwattr $C$DW$333, DW_AT_high_pc($C$DW$L$_xTaskIncrementTick$25$E)
$C$DW$334 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$334, DW_AT_low_pc($C$DW$L$_xTaskIncrementTick$24$B)
.dwattr $C$DW$334, DW_AT_high_pc($C$DW$L$_xTaskIncrementTick$24$E)
.dwendtag $C$DW$323
$C$DW$335 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$335, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L141:1:1538833113")
.dwattr $C$DW$335, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$335, DW_AT_TI_begin_line(0xa87)
.dwattr $C$DW$335, DW_AT_TI_end_line(0xa87)
$C$DW$336 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$336, DW_AT_low_pc($C$DW$L$_xTaskIncrementTick$8$B)
.dwattr $C$DW$336, DW_AT_high_pc($C$DW$L$_xTaskIncrementTick$8$E)
.dwendtag $C$DW$335
.dwattr $C$DW$310, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$310, DW_AT_TI_end_line(0xb1a)
.dwattr $C$DW$310, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$310
.sect ".text"
.align 4
.global _vTaskSwitchContext
$C$DW$337 .dwtag DW_TAG_subprogram, DW_AT_name("vTaskSwitchContext")
.dwattr $C$DW$337, DW_AT_low_pc(_vTaskSwitchContext)
.dwattr $C$DW$337, DW_AT_high_pc(0x00)
.dwattr $C$DW$337, DW_AT_TI_symbol_name("_vTaskSwitchContext")
.dwattr $C$DW$337, DW_AT_external
.dwattr $C$DW$337, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$337, DW_AT_TI_begin_line(0xb79)
.dwattr $C$DW$337, DW_AT_TI_begin_column(0x06)
.dwattr $C$DW$337, DW_AT_TI_max_frame_size(0x06)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2938,column 1,is_stmt,address _vTaskSwitchContext
.dwfde $C$DW$CIE, _vTaskSwitchContext
;*******************************************************************************
;* FUNCTION NAME: vTaskSwitchContext *
;* *
;* Function Uses Regs : AC0,AC0,AC1,AC1,T0,AR1,AR2,XAR2,AR3,XAR3,SP,CARRY, *
;* TC1,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 6 words *
;* (2 return address/alignment) *
;* (4 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_vTaskSwitchContext:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-5, SP
.dwcfi cfa_offset, 6
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2939,column 2,is_stmt
MOV *(#_uxSchedulerSuspended), AR1 ; |2939|
BCC $C$L154,AR1 == #0 ; |2939|
; branchcc occurs ; |2939|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2943,column 3,is_stmt
MOV #1, *(#_xYieldPending) ; |2943|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2944,column 2,is_stmt
B $C$L162 ; |2944|
; branch occurs ; |2944|
$C$L154:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2947,column 3,is_stmt
MOV #0, *(#_xYieldPending) ; |2947|
NOP
NOP
$C$DW$338 .dwtag DW_TAG_lexical_block, DW_AT_low_pc(0x00), DW_AT_high_pc(0x00)
$C$DW$339 .dwtag DW_TAG_variable, DW_AT_name("uxTopPriority")
.dwattr $C$DW$339, DW_AT_TI_symbol_name("_uxTopPriority")
.dwattr $C$DW$339, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$339, DW_AT_location[DW_OP_bregx 0x24 0]
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 2989,column 3,is_stmt
AMOV #_pxReadyTasksLists, XAR3 ; |2989|
MOV *(#_uxTopReadyPriority), AR1 ; |2989|
MOV AR1, *SP(#0) ; |2989|
B $C$L158 ; |2989|
; branch occurs ; |2989|
$C$L155:
$C$DW$L$_vTaskSwitchContext$4$B:
MOV *SP(#0), AR1 ; |2989|
BCC $C$L157,AR1 != #0 ; |2989|
; branchcc occurs ; |2989|
$C$DW$L$_vTaskSwitchContext$4$E:
nop
bset INTM
$C$L156:
$C$DW$L$_vTaskSwitchContext$6$B:
B $C$L156 ; |2989|
; branch occurs ; |2989|
$C$DW$L$_vTaskSwitchContext$6$E:
$C$L157:
$C$DW$L$_vTaskSwitchContext$7$B:
SUB #1, *SP(#0) ; |2989|
$C$DW$L$_vTaskSwitchContext$7$E:
$C$L158:
$C$DW$L$_vTaskSwitchContext$8$B:
MPYMK *SP(#0), #10, AC0 ; |2989|
MOV AC0, T0 ; |2989|
MOV *AR3(T0), AR1 ; |2989|
BCC $C$L159,AR1 != #0 ; |2989|
; branchcc occurs ; |2989|
$C$DW$L$_vTaskSwitchContext$8$E:
$C$DW$L$_vTaskSwitchContext$9$B:
MOV #1, AR1
B $C$L160 ; |2989|
; branch occurs ; |2989|
$C$DW$L$_vTaskSwitchContext$9$E:
$C$L159:
$C$DW$L$_vTaskSwitchContext$10$B:
MOV #0, AR1
$C$DW$L$_vTaskSwitchContext$10$E:
$C$L160:
$C$DW$L$_vTaskSwitchContext$11$B:
BCC $C$L155,AR1 != #0 ; |2989|
; branchcc occurs ; |2989|
$C$DW$L$_vTaskSwitchContext$11$E:
$C$DW$340 .dwtag DW_TAG_lexical_block, DW_AT_low_pc(0x00), DW_AT_high_pc(0x00)
$C$DW$341 .dwtag DW_TAG_variable, DW_AT_name("pxConstList")
.dwattr $C$DW$341, DW_AT_TI_symbol_name("_pxConstList")
.dwattr $C$DW$341, DW_AT_type(*$C$DW$T$67)
.dwattr $C$DW$341, DW_AT_location[DW_OP_bregx 0x24 2]
MPYMK *SP(#0), #10, AC0 ; |2989|
MOV AC0, AR1 ; |2989|
MOV XAR3, dbl(*SP(#2))
|| AADD AR1, AR3 ; |2989|
MOV dbl(*AR3(short(#2))), XAR3
MOV dbl(*AR3(short(#2))), XAR2
MOV dbl(*SP(#2)), XAR3
MOV XAR2, dbl(*AR3(short(#2)))
MOV dbl(*SP(#2)), XAR3
AADD #4, AR3 ; |2989|
MOV XAR3, AC0
MOV dbl(*SP(#2)), XAR3
MOV dbl(*AR3(short(#2))), XAR3
MOV XAR3, AC1
CMPU AC1 != AC0, TC1 ; |2989|
BCC $C$L161,TC1 ; |2989|
; branchcc occurs ; |2989|
MOV dbl(*SP(#2)), XAR3
MOV dbl(*AR3(short(#2))), XAR3
MOV dbl(*AR3(short(#2))), XAR2
MOV dbl(*SP(#2)), XAR3
MOV XAR2, dbl(*AR3(short(#2)))
$C$L161:
MOV dbl(*SP(#2)), XAR3
MOV dbl(*AR3(short(#2))), XAR3
MOV dbl(*AR3(short(#6))), XAR3
MOV XAR3, dbl(*(#_pxCurrentTCB))
.dwendtag $C$DW$340
MOV *SP(#0), AR1 ; |2989|
MOV AR1, *(#_uxTopReadyPriority) ; |2989|
.dwendtag $C$DW$338
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3007,column 1,is_stmt
$C$L162:
AADD #5, SP
.dwcfi cfa_offset, 1
$C$DW$342 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$342, DW_AT_low_pc(0x00)
.dwattr $C$DW$342, DW_AT_TI_return
RET
; return occurs
$C$DW$343 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$343, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L156:1:1538833113")
.dwattr $C$DW$343, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$343, DW_AT_TI_begin_line(0xbad)
.dwattr $C$DW$343, DW_AT_TI_end_line(0xbad)
$C$DW$344 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$344, DW_AT_low_pc($C$DW$L$_vTaskSwitchContext$6$B)
.dwattr $C$DW$344, DW_AT_high_pc($C$DW$L$_vTaskSwitchContext$6$E)
.dwendtag $C$DW$343
$C$DW$345 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$345, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L158:1:1538833113")
.dwattr $C$DW$345, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$345, DW_AT_TI_begin_line(0xbad)
.dwattr $C$DW$345, DW_AT_TI_end_line(0xbad)
$C$DW$346 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$346, DW_AT_low_pc($C$DW$L$_vTaskSwitchContext$8$B)
.dwattr $C$DW$346, DW_AT_high_pc($C$DW$L$_vTaskSwitchContext$8$E)
$C$DW$347 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$347, DW_AT_low_pc($C$DW$L$_vTaskSwitchContext$9$B)
.dwattr $C$DW$347, DW_AT_high_pc($C$DW$L$_vTaskSwitchContext$9$E)
$C$DW$348 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$348, DW_AT_low_pc($C$DW$L$_vTaskSwitchContext$10$B)
.dwattr $C$DW$348, DW_AT_high_pc($C$DW$L$_vTaskSwitchContext$10$E)
$C$DW$349 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$349, DW_AT_low_pc($C$DW$L$_vTaskSwitchContext$11$B)
.dwattr $C$DW$349, DW_AT_high_pc($C$DW$L$_vTaskSwitchContext$11$E)
$C$DW$350 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$350, DW_AT_low_pc($C$DW$L$_vTaskSwitchContext$4$B)
.dwattr $C$DW$350, DW_AT_high_pc($C$DW$L$_vTaskSwitchContext$4$E)
$C$DW$351 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$351, DW_AT_low_pc($C$DW$L$_vTaskSwitchContext$7$B)
.dwattr $C$DW$351, DW_AT_high_pc($C$DW$L$_vTaskSwitchContext$7$E)
.dwendtag $C$DW$345
.dwattr $C$DW$337, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$337, DW_AT_TI_end_line(0xbbf)
.dwattr $C$DW$337, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$337
.sect ".text"
.align 4
.global _vTaskPlaceOnEventList
$C$DW$352 .dwtag DW_TAG_subprogram, DW_AT_name("vTaskPlaceOnEventList")
.dwattr $C$DW$352, DW_AT_low_pc(_vTaskPlaceOnEventList)
.dwattr $C$DW$352, DW_AT_high_pc(0x00)
.dwattr $C$DW$352, DW_AT_TI_symbol_name("_vTaskPlaceOnEventList")
.dwattr $C$DW$352, DW_AT_external
.dwattr $C$DW$352, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$352, DW_AT_TI_begin_line(0xbc2)
.dwattr $C$DW$352, DW_AT_TI_begin_column(0x06)
.dwattr $C$DW$352, DW_AT_TI_max_frame_size(0x06)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3011,column 1,is_stmt,address _vTaskPlaceOnEventList
.dwfde $C$DW$CIE, _vTaskPlaceOnEventList
$C$DW$353 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxEventList")
.dwattr $C$DW$353, DW_AT_TI_symbol_name("_pxEventList")
.dwattr $C$DW$353, DW_AT_type(*$C$DW$T$67)
.dwattr $C$DW$353, DW_AT_location[DW_OP_reg17]
$C$DW$354 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTicksToWait")
.dwattr $C$DW$354, DW_AT_TI_symbol_name("_xTicksToWait")
.dwattr $C$DW$354, DW_AT_type(*$C$DW$T$95)
.dwattr $C$DW$354, DW_AT_location[DW_OP_reg0]
;*******************************************************************************
;* FUNCTION NAME: vTaskPlaceOnEventList *
;* *
;* Function Uses Regs : AC0,AC0,T0,AR0,XAR0,AR1,XAR1,AR3,XAR3,SP,M40,SATA, *
;* SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 6 words *
;* (2 return address/alignment) *
;* (4 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_vTaskPlaceOnEventList:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-5, SP
.dwcfi cfa_offset, 6
$C$DW$355 .dwtag DW_TAG_variable, DW_AT_name("pxEventList")
.dwattr $C$DW$355, DW_AT_TI_symbol_name("_pxEventList")
.dwattr $C$DW$355, DW_AT_type(*$C$DW$T$67)
.dwattr $C$DW$355, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$356 .dwtag DW_TAG_variable, DW_AT_name("xTicksToWait")
.dwattr $C$DW$356, DW_AT_TI_symbol_name("_xTicksToWait")
.dwattr $C$DW$356, DW_AT_type(*$C$DW$T$95)
.dwattr $C$DW$356, DW_AT_location[DW_OP_bregx 0x24 2]
MOV AC0, dbl(*SP(#2)) ; |3011|
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3012,column 2,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L164,AC0 != #0 ; |3012|
; branchcc occurs ; |3012|
nop
bset INTM
$C$L163:
$C$DW$L$_vTaskPlaceOnEventList$3$B:
B $C$L163 ; |3012|
; branch occurs ; |3012|
$C$DW$L$_vTaskPlaceOnEventList$3$E:
$C$L164:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3021,column 2,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR1
AADD #14, AR1 ; |3021|
$C$DW$357 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$357, DW_AT_low_pc(0x00)
.dwattr $C$DW$357, DW_AT_name("_vListInsert")
.dwattr $C$DW$357, DW_AT_TI_call
CALL #_vListInsert ; |3021|
; call occurs [#_vListInsert] ; |3021|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3023,column 2,is_stmt
MOV dbl(*SP(#2)), AC0 ; |3023|
|| MOV #1, T0
$C$DW$358 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$358, DW_AT_low_pc(0x00)
.dwattr $C$DW$358, DW_AT_name("_prvAddCurrentTaskToDelayedList")
.dwattr $C$DW$358, DW_AT_TI_call
CALL #_prvAddCurrentTaskToDelayedList ; |3023|
; call occurs [#_prvAddCurrentTaskToDelayedList] ; |3023|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3024,column 1,is_stmt
AADD #5, SP
.dwcfi cfa_offset, 1
$C$DW$359 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$359, DW_AT_low_pc(0x00)
.dwattr $C$DW$359, DW_AT_TI_return
RET
; return occurs
$C$DW$360 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$360, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L163:1:1538833113")
.dwattr $C$DW$360, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$360, DW_AT_TI_begin_line(0xbc4)
.dwattr $C$DW$360, DW_AT_TI_end_line(0xbc4)
$C$DW$361 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$361, DW_AT_low_pc($C$DW$L$_vTaskPlaceOnEventList$3$B)
.dwattr $C$DW$361, DW_AT_high_pc($C$DW$L$_vTaskPlaceOnEventList$3$E)
.dwendtag $C$DW$360
.dwattr $C$DW$352, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$352, DW_AT_TI_end_line(0xbd0)
.dwattr $C$DW$352, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$352
.sect ".text"
.align 4
.global _vTaskPlaceOnUnorderedEventList
$C$DW$362 .dwtag DW_TAG_subprogram, DW_AT_name("vTaskPlaceOnUnorderedEventList")
.dwattr $C$DW$362, DW_AT_low_pc(_vTaskPlaceOnUnorderedEventList)
.dwattr $C$DW$362, DW_AT_high_pc(0x00)
.dwattr $C$DW$362, DW_AT_TI_symbol_name("_vTaskPlaceOnUnorderedEventList")
.dwattr $C$DW$362, DW_AT_external
.dwattr $C$DW$362, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$362, DW_AT_TI_begin_line(0xbd3)
.dwattr $C$DW$362, DW_AT_TI_begin_column(0x06)
.dwattr $C$DW$362, DW_AT_TI_max_frame_size(0x08)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3028,column 1,is_stmt,address _vTaskPlaceOnUnorderedEventList
.dwfde $C$DW$CIE, _vTaskPlaceOnUnorderedEventList
$C$DW$363 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxEventList")
.dwattr $C$DW$363, DW_AT_TI_symbol_name("_pxEventList")
.dwattr $C$DW$363, DW_AT_type(*$C$DW$T$66)
.dwattr $C$DW$363, DW_AT_location[DW_OP_reg17]
$C$DW$364 .dwtag DW_TAG_formal_parameter, DW_AT_name("xItemValue")
.dwattr $C$DW$364, DW_AT_TI_symbol_name("_xItemValue")
.dwattr $C$DW$364, DW_AT_type(*$C$DW$T$95)
.dwattr $C$DW$364, DW_AT_location[DW_OP_reg0]
$C$DW$365 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTicksToWait")
.dwattr $C$DW$365, DW_AT_TI_symbol_name("_xTicksToWait")
.dwattr $C$DW$365, DW_AT_type(*$C$DW$T$95)
.dwattr $C$DW$365, DW_AT_location[DW_OP_reg3]
;*******************************************************************************
;* FUNCTION NAME: vTaskPlaceOnUnorderedEventList *
;* *
;* Function Uses Regs : AC0,AC0,AC1,AC1,T0,AR0,XAR0,AR1,XAR1,AR2,AR3,XAR3,SP,*
;* M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 8 words *
;* (2 return address/alignment) *
;* (6 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_vTaskPlaceOnUnorderedEventList:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-7, SP
.dwcfi cfa_offset, 8
$C$DW$366 .dwtag DW_TAG_variable, DW_AT_name("pxEventList")
.dwattr $C$DW$366, DW_AT_TI_symbol_name("_pxEventList")
.dwattr $C$DW$366, DW_AT_type(*$C$DW$T$66)
.dwattr $C$DW$366, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$367 .dwtag DW_TAG_variable, DW_AT_name("xItemValue")
.dwattr $C$DW$367, DW_AT_TI_symbol_name("_xItemValue")
.dwattr $C$DW$367, DW_AT_type(*$C$DW$T$95)
.dwattr $C$DW$367, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$368 .dwtag DW_TAG_variable, DW_AT_name("xTicksToWait")
.dwattr $C$DW$368, DW_AT_TI_symbol_name("_xTicksToWait")
.dwattr $C$DW$368, DW_AT_type(*$C$DW$T$95)
.dwattr $C$DW$368, DW_AT_location[DW_OP_bregx 0x24 4]
MOV AC1, dbl(*SP(#4)) ; |3028|
MOV AC0, dbl(*SP(#2)) ; |3028|
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3029,column 2,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L166,AC0 != #0 ; |3029|
; branchcc occurs ; |3029|
nop
bset INTM
$C$L165:
$C$DW$L$_vTaskPlaceOnUnorderedEventList$3$B:
B $C$L165 ; |3029|
; branch occurs ; |3029|
$C$DW$L$_vTaskPlaceOnUnorderedEventList$3$E:
$C$L166:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3033,column 2,is_stmt
MOV *(#_uxSchedulerSuspended), AR2 ; |3033|
MOV #0, AR1
BCC $C$L167,AR2 == #0 ; |3033|
; branchcc occurs ; |3033|
MOV #1, AR1
$C$L167:
BCC $C$L169,AR1 != #0 ; |3033|
; branchcc occurs ; |3033|
nop
bset INTM
$C$L168:
$C$DW$L$_vTaskPlaceOnUnorderedEventList$8$B:
B $C$L168 ; |3033|
; branch occurs ; |3033|
$C$DW$L$_vTaskPlaceOnUnorderedEventList$8$E:
$C$L169:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3038,column 2,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV dbl(*SP(#2)), AC0 ; |3038|
BSET @#31, AC0 ; |3038|
MOV AC0, dbl(*AR3(#14)) ; |3038|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3045,column 2,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR1
MOV dbl(*SP(#0)), XAR0
AADD #14, AR1 ; |3045|
$C$DW$369 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$369, DW_AT_low_pc(0x00)
.dwattr $C$DW$369, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$369, DW_AT_TI_call
CALL #_vListInsertEnd ; |3045|
; call occurs [#_vListInsertEnd] ; |3045|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3047,column 2,is_stmt
MOV dbl(*SP(#4)), AC0 ; |3047|
|| MOV #1, T0
$C$DW$370 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$370, DW_AT_low_pc(0x00)
.dwattr $C$DW$370, DW_AT_name("_prvAddCurrentTaskToDelayedList")
.dwattr $C$DW$370, DW_AT_TI_call
CALL #_prvAddCurrentTaskToDelayedList ; |3047|
; call occurs [#_prvAddCurrentTaskToDelayedList] ; |3047|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3048,column 1,is_stmt
AADD #7, SP
.dwcfi cfa_offset, 1
$C$DW$371 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$371, DW_AT_low_pc(0x00)
.dwattr $C$DW$371, DW_AT_TI_return
RET
; return occurs
$C$DW$372 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$372, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L168:1:1538833113")
.dwattr $C$DW$372, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$372, DW_AT_TI_begin_line(0xbd9)
.dwattr $C$DW$372, DW_AT_TI_end_line(0xbd9)
$C$DW$373 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$373, DW_AT_low_pc($C$DW$L$_vTaskPlaceOnUnorderedEventList$8$B)
.dwattr $C$DW$373, DW_AT_high_pc($C$DW$L$_vTaskPlaceOnUnorderedEventList$8$E)
.dwendtag $C$DW$372
$C$DW$374 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$374, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L165:1:1538833113")
.dwattr $C$DW$374, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$374, DW_AT_TI_begin_line(0xbd5)
.dwattr $C$DW$374, DW_AT_TI_end_line(0xbd5)
$C$DW$375 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$375, DW_AT_low_pc($C$DW$L$_vTaskPlaceOnUnorderedEventList$3$B)
.dwattr $C$DW$375, DW_AT_high_pc($C$DW$L$_vTaskPlaceOnUnorderedEventList$3$E)
.dwendtag $C$DW$374
.dwattr $C$DW$362, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$362, DW_AT_TI_end_line(0xbe8)
.dwattr $C$DW$362, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$362
.sect ".text"
.align 4
.global _xTaskRemoveFromEventList
$C$DW$376 .dwtag DW_TAG_subprogram, DW_AT_name("xTaskRemoveFromEventList")
.dwattr $C$DW$376, DW_AT_low_pc(_xTaskRemoveFromEventList)
.dwattr $C$DW$376, DW_AT_high_pc(0x00)
.dwattr $C$DW$376, DW_AT_TI_symbol_name("_xTaskRemoveFromEventList")
.dwattr $C$DW$376, DW_AT_external
.dwattr $C$DW$376, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$376, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$376, DW_AT_TI_begin_line(0xc0c)
.dwattr $C$DW$376, DW_AT_TI_begin_column(0x0c)
.dwattr $C$DW$376, DW_AT_TI_max_frame_size(0x06)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3085,column 1,is_stmt,address _xTaskRemoveFromEventList
.dwfde $C$DW$CIE, _xTaskRemoveFromEventList
$C$DW$377 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxEventList")
.dwattr $C$DW$377, DW_AT_TI_symbol_name("_pxEventList")
.dwattr $C$DW$377, DW_AT_type(*$C$DW$T$130)
.dwattr $C$DW$377, DW_AT_location[DW_OP_reg17]
;*******************************************************************************
;* FUNCTION NAME: xTaskRemoveFromEventList *
;* *
;* Function Uses Regs : AC0,AC0,T0,AR0,XAR0,AR1,XAR1,AR2,AR3,XAR3,SP,TC1,M40,*
;* SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 6 words *
;* (1 return address/alignment) *
;* (5 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_xTaskRemoveFromEventList:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-5, SP
.dwcfi cfa_offset, 6
$C$DW$378 .dwtag DW_TAG_variable, DW_AT_name("pxEventList")
.dwattr $C$DW$378, DW_AT_TI_symbol_name("_pxEventList")
.dwattr $C$DW$378, DW_AT_type(*$C$DW$T$130)
.dwattr $C$DW$378, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$379 .dwtag DW_TAG_variable, DW_AT_name("pxUnblockedTCB")
.dwattr $C$DW$379, DW_AT_TI_symbol_name("_pxUnblockedTCB")
.dwattr $C$DW$379, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$379, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$380 .dwtag DW_TAG_variable, DW_AT_name("xReturn")
.dwattr $C$DW$380, DW_AT_TI_symbol_name("_xReturn")
.dwattr $C$DW$380, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$380, DW_AT_location[DW_OP_bregx 0x24 4]
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3102,column 2,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV dbl(*AR3(short(#6))), XAR3
MOV dbl(*AR3(short(#6))), XAR3
MOV XAR3, dbl(*SP(#2))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3103,column 2,is_stmt
MOV XAR3, AC0
BCC $C$L171,AC0 != #0 ; |3103|
; branchcc occurs ; |3103|
nop
bset INTM
$C$L170:
$C$DW$L$_xTaskRemoveFromEventList$3$B:
B $C$L170 ; |3103|
; branch occurs ; |3103|
$C$DW$L$_xTaskRemoveFromEventList$3$E:
$C$L171:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3104,column 2,is_stmt
MOV dbl(*SP(#2)), XAR0
AADD #14, AR0 ; |3104|
$C$DW$381 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$381, DW_AT_low_pc(0x00)
.dwattr $C$DW$381, DW_AT_name("_uxListRemove")
.dwattr $C$DW$381, DW_AT_TI_call
CALL #_uxListRemove ; |3104|
; call occurs [#_uxListRemove] ; |3104|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3106,column 2,is_stmt
MOV *(#_uxSchedulerSuspended), AR1 ; |3106|
BCC $C$L173,AR1 != #0 ; |3106|
; branchcc occurs ; |3106|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3108,column 3,is_stmt
MOV dbl(*SP(#2)), XAR0
AADD #4, AR0 ; |3108|
$C$DW$382 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$382, DW_AT_low_pc(0x00)
.dwattr $C$DW$382, DW_AT_name("_uxListRemove")
.dwattr $C$DW$382, DW_AT_TI_call
CALL #_uxListRemove ; |3108|
; call occurs [#_uxListRemove] ; |3108|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3109,column 3,is_stmt
MOV dbl(*SP(#2)), XAR3
MOV *(#_uxTopReadyPriority), AR1 ; |3109|
MOV *AR3(#24), AR2 ; |3109|
CMPU AR2 <= AR1, TC1 ; |3109|
BCC $C$L172,TC1 ; |3109|
; branchcc occurs ; |3109|
MOV *AR3(#24), AR1 ; |3109|
MOV AR1, *(#_uxTopReadyPriority) ; |3109|
$C$L172:
MPYMK *AR3(#24), #10, AC0 ; |3109|
MOV AC0, AR1 ; |3109|
AMOV #_pxReadyTasksLists, XAR0 ; |3109|
AADD AR1, AR0 ; |3109|
MOV dbl(*SP(#2)), XAR1
AADD #4, AR1 ; |3109|
$C$DW$383 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$383, DW_AT_low_pc(0x00)
.dwattr $C$DW$383, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$383, DW_AT_TI_call
CALL #_vListInsertEnd ; |3109|
; call occurs [#_vListInsertEnd] ; |3109|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3110,column 2,is_stmt
B $C$L174 ; |3110|
; branch occurs ; |3110|
$C$L173:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3115,column 3,is_stmt
MOV dbl(*SP(#2)), XAR1
AMOV #_xPendingReadyList, XAR0 ; |3115|
AADD #14, AR1 ; |3115|
$C$DW$384 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$384, DW_AT_low_pc(0x00)
.dwattr $C$DW$384, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$384, DW_AT_TI_call
CALL #_vListInsertEnd ; |3115|
; call occurs [#_vListInsertEnd] ; |3115|
$C$L174:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3118,column 2,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV *AR3(#24), AR1 ; |3118|
MOV dbl(*SP(#2)), XAR3
MOV *AR3(#24), AR2 ; |3118|
CMPU AR2 <= AR1, TC1 ; |3118|
BCC $C$L175,TC1 ; |3118|
; branchcc occurs ; |3118|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3123,column 3,is_stmt
MOV #1, *SP(#4) ; |3123|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3127,column 3,is_stmt
MOV #1, *(#_xYieldPending) ; |3127|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3128,column 2,is_stmt
B $C$L176 ; |3128|
; branch occurs ; |3128|
$C$L175:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3131,column 3,is_stmt
MOV #0, *SP(#4) ; |3131|
$C$L176:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3148,column 2,is_stmt
MOV *SP(#4), T0 ; |3148|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3149,column 1,is_stmt
AADD #5, SP
.dwcfi cfa_offset, 1
$C$DW$385 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$385, DW_AT_low_pc(0x00)
.dwattr $C$DW$385, DW_AT_TI_return
RET
; return occurs
$C$DW$386 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$386, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L170:1:1538833113")
.dwattr $C$DW$386, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$386, DW_AT_TI_begin_line(0xc1f)
.dwattr $C$DW$386, DW_AT_TI_end_line(0xc1f)
$C$DW$387 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$387, DW_AT_low_pc($C$DW$L$_xTaskRemoveFromEventList$3$B)
.dwattr $C$DW$387, DW_AT_high_pc($C$DW$L$_xTaskRemoveFromEventList$3$E)
.dwendtag $C$DW$386
.dwattr $C$DW$376, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$376, DW_AT_TI_end_line(0xc4d)
.dwattr $C$DW$376, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$376
.sect ".text"
.align 4
.global _vTaskRemoveFromUnorderedEventList
$C$DW$388 .dwtag DW_TAG_subprogram, DW_AT_name("vTaskRemoveFromUnorderedEventList")
.dwattr $C$DW$388, DW_AT_low_pc(_vTaskRemoveFromUnorderedEventList)
.dwattr $C$DW$388, DW_AT_high_pc(0x00)
.dwattr $C$DW$388, DW_AT_TI_symbol_name("_vTaskRemoveFromUnorderedEventList")
.dwattr $C$DW$388, DW_AT_external
.dwattr $C$DW$388, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$388, DW_AT_TI_begin_line(0xc50)
.dwattr $C$DW$388, DW_AT_TI_begin_column(0x06)
.dwattr $C$DW$388, DW_AT_TI_max_frame_size(0x08)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3153,column 1,is_stmt,address _vTaskRemoveFromUnorderedEventList
.dwfde $C$DW$CIE, _vTaskRemoveFromUnorderedEventList
$C$DW$389 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxEventListItem")
.dwattr $C$DW$389, DW_AT_TI_symbol_name("_pxEventListItem")
.dwattr $C$DW$389, DW_AT_type(*$C$DW$T$34)
.dwattr $C$DW$389, DW_AT_location[DW_OP_reg17]
$C$DW$390 .dwtag DW_TAG_formal_parameter, DW_AT_name("xItemValue")
.dwattr $C$DW$390, DW_AT_TI_symbol_name("_xItemValue")
.dwattr $C$DW$390, DW_AT_type(*$C$DW$T$95)
.dwattr $C$DW$390, DW_AT_location[DW_OP_reg0]
;*******************************************************************************
;* FUNCTION NAME: vTaskRemoveFromUnorderedEventList *
;* *
;* Function Uses Regs : AC0,AC0,AR0,XAR0,AR1,XAR1,AR2,AR3,XAR3,SP,TC1,M40, *
;* SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 8 words *
;* (2 return address/alignment) *
;* (6 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_vTaskRemoveFromUnorderedEventList:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-7, SP
.dwcfi cfa_offset, 8
$C$DW$391 .dwtag DW_TAG_variable, DW_AT_name("pxEventListItem")
.dwattr $C$DW$391, DW_AT_TI_symbol_name("_pxEventListItem")
.dwattr $C$DW$391, DW_AT_type(*$C$DW$T$34)
.dwattr $C$DW$391, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$392 .dwtag DW_TAG_variable, DW_AT_name("xItemValue")
.dwattr $C$DW$392, DW_AT_TI_symbol_name("_xItemValue")
.dwattr $C$DW$392, DW_AT_type(*$C$DW$T$95)
.dwattr $C$DW$392, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$393 .dwtag DW_TAG_variable, DW_AT_name("pxUnblockedTCB")
.dwattr $C$DW$393, DW_AT_TI_symbol_name("_pxUnblockedTCB")
.dwattr $C$DW$393, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$393, DW_AT_location[DW_OP_bregx 0x24 4]
MOV AC0, dbl(*SP(#2)) ; |3153|
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3158,column 2,is_stmt
MOV *(#_uxSchedulerSuspended), AR2 ; |3158|
BCC $C$L177,AR2 == #0 ; |3158|
|| MOV #0, AR1
; branchcc occurs ; |3158|
MOV #1, AR1
$C$L177:
BCC $C$L179,AR1 != #0 ; |3158|
; branchcc occurs ; |3158|
nop
bset INTM
$C$L178:
$C$DW$L$_vTaskRemoveFromUnorderedEventList$5$B:
B $C$L178 ; |3158|
; branch occurs ; |3158|
$C$DW$L$_vTaskRemoveFromUnorderedEventList$5$E:
$C$L179:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3161,column 2,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV dbl(*SP(#2)), AC0 ; |3161|
BSET @#31, AC0 ; |3161|
MOV AC0, dbl(*AR3) ; |3161|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3165,column 2,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV dbl(*AR3(short(#6))), XAR3
MOV XAR3, dbl(*SP(#4))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3166,column 2,is_stmt
MOV XAR3, AC0
BCC $C$L181,AC0 != #0 ; |3166|
; branchcc occurs ; |3166|
nop
bset INTM
$C$L180:
$C$DW$L$_vTaskRemoveFromUnorderedEventList$8$B:
B $C$L180 ; |3166|
; branch occurs ; |3166|
$C$DW$L$_vTaskRemoveFromUnorderedEventList$8$E:
$C$L181:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3167,column 2,is_stmt
MOV dbl(*SP(#0)), XAR0
$C$DW$394 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$394, DW_AT_low_pc(0x00)
.dwattr $C$DW$394, DW_AT_name("_uxListRemove")
.dwattr $C$DW$394, DW_AT_TI_call
CALL #_uxListRemove ; |3167|
; call occurs [#_uxListRemove] ; |3167|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3172,column 2,is_stmt
MOV dbl(*SP(#4)), XAR0
AADD #4, AR0 ; |3172|
$C$DW$395 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$395, DW_AT_low_pc(0x00)
.dwattr $C$DW$395, DW_AT_name("_uxListRemove")
.dwattr $C$DW$395, DW_AT_TI_call
CALL #_uxListRemove ; |3172|
; call occurs [#_uxListRemove] ; |3172|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3173,column 2,is_stmt
MOV dbl(*SP(#4)), XAR3
MOV *(#_uxTopReadyPriority), AR1 ; |3173|
MOV *AR3(#24), AR2 ; |3173|
CMPU AR2 <= AR1, TC1 ; |3173|
BCC $C$L182,TC1 ; |3173|
; branchcc occurs ; |3173|
MOV *AR3(#24), AR1 ; |3173|
MOV AR1, *(#_uxTopReadyPriority) ; |3173|
$C$L182:
MPYMK *AR3(#24), #10, AC0 ; |3173|
MOV AC0, AR1 ; |3173|
AMOV #_pxReadyTasksLists, XAR0 ; |3173|
AADD AR1, AR0 ; |3173|
MOV dbl(*SP(#4)), XAR1
AADD #4, AR1 ; |3173|
$C$DW$396 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$396, DW_AT_low_pc(0x00)
.dwattr $C$DW$396, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$396, DW_AT_TI_call
CALL #_vListInsertEnd ; |3173|
; call occurs [#_vListInsertEnd] ; |3173|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3175,column 2,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV *AR3(#24), AR1 ; |3175|
MOV dbl(*SP(#4)), XAR3
MOV *AR3(#24), AR2 ; |3175|
CMPU AR2 <= AR1, TC1 ; |3175|
BCC $C$L183,TC1 ; |3175|
; branchcc occurs ; |3175|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3181,column 3,is_stmt
MOV #1, *(#_xYieldPending) ; |3181|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3183,column 1,is_stmt
$C$L183:
AADD #7, SP
.dwcfi cfa_offset, 1
$C$DW$397 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$397, DW_AT_low_pc(0x00)
.dwattr $C$DW$397, DW_AT_TI_return
RET
; return occurs
$C$DW$398 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$398, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L180:1:1538833113")
.dwattr $C$DW$398, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$398, DW_AT_TI_begin_line(0xc5e)
.dwattr $C$DW$398, DW_AT_TI_end_line(0xc5e)
$C$DW$399 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$399, DW_AT_low_pc($C$DW$L$_vTaskRemoveFromUnorderedEventList$8$B)
.dwattr $C$DW$399, DW_AT_high_pc($C$DW$L$_vTaskRemoveFromUnorderedEventList$8$E)
.dwendtag $C$DW$398
$C$DW$400 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$400, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L178:1:1538833113")
.dwattr $C$DW$400, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$400, DW_AT_TI_begin_line(0xc56)
.dwattr $C$DW$400, DW_AT_TI_end_line(0xc56)
$C$DW$401 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$401, DW_AT_low_pc($C$DW$L$_vTaskRemoveFromUnorderedEventList$5$B)
.dwattr $C$DW$401, DW_AT_high_pc($C$DW$L$_vTaskRemoveFromUnorderedEventList$5$E)
.dwendtag $C$DW$400
.dwattr $C$DW$388, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$388, DW_AT_TI_end_line(0xc6f)
.dwattr $C$DW$388, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$388
.sect ".text"
.align 4
.global _vTaskSetTimeOutState
$C$DW$402 .dwtag DW_TAG_subprogram, DW_AT_name("vTaskSetTimeOutState")
.dwattr $C$DW$402, DW_AT_low_pc(_vTaskSetTimeOutState)
.dwattr $C$DW$402, DW_AT_high_pc(0x00)
.dwattr $C$DW$402, DW_AT_TI_symbol_name("_vTaskSetTimeOutState")
.dwattr $C$DW$402, DW_AT_external
.dwattr $C$DW$402, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$402, DW_AT_TI_begin_line(0xc72)
.dwattr $C$DW$402, DW_AT_TI_begin_column(0x06)
.dwattr $C$DW$402, DW_AT_TI_max_frame_size(0x04)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3187,column 1,is_stmt,address _vTaskSetTimeOutState
.dwfde $C$DW$CIE, _vTaskSetTimeOutState
$C$DW$403 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxTimeOut")
.dwattr $C$DW$403, DW_AT_TI_symbol_name("_pxTimeOut")
.dwattr $C$DW$403, DW_AT_type(*$C$DW$T$104)
.dwattr $C$DW$403, DW_AT_location[DW_OP_reg17]
;*******************************************************************************
;* FUNCTION NAME: vTaskSetTimeOutState *
;* *
;* Function Uses Regs : AC0,AC0,AR0,XAR0,AR1,AR3,XAR3,SP,CARRY,M40,SATA,SATD,*
;* RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 4 words *
;* (2 return address/alignment) *
;* (2 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_vTaskSetTimeOutState:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-3, SP
.dwcfi cfa_offset, 4
$C$DW$404 .dwtag DW_TAG_variable, DW_AT_name("pxTimeOut")
.dwattr $C$DW$404, DW_AT_TI_symbol_name("_pxTimeOut")
.dwattr $C$DW$404, DW_AT_type(*$C$DW$T$104)
.dwattr $C$DW$404, DW_AT_location[DW_OP_bregx 0x24 0]
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3188,column 2,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L185,AC0 != #0 ; |3188|
; branchcc occurs ; |3188|
nop
bset INTM
$C$L184:
$C$DW$L$_vTaskSetTimeOutState$3$B:
B $C$L184 ; |3188|
; branch occurs ; |3188|
$C$DW$L$_vTaskSetTimeOutState$3$E:
$C$L185:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3189,column 2,is_stmt
nop
bset INTM
ADD #1, *(#_usCriticalNesting) ; |3189|
NOP
NOP
NOP
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3191,column 3,is_stmt
MOV *(#_xNumOfOverflows), AR1 ; |3191|
MOV AR1, *AR3 ; |3191|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3192,column 3,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV dbl(*(#_xTickCount)), AC0 ; |3192|
MOV AC0, dbl(*AR3(short(#2))) ; |3192|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3194,column 2,is_stmt
MOV *(#_usCriticalNesting), AR1 ; |3194|
BCC $C$L186,AR1 == #0 ; |3194|
; branchcc occurs ; |3194|
SUB #1, *(#_usCriticalNesting) ; |3194|
NOP
NOP
NOP
MOV *(#_usCriticalNesting), AR1 ; |3194|
BCC $C$L186,AR1 != #0 ; |3194|
; branchcc occurs ; |3194|
nop
bclr INTM
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3195,column 1,is_stmt
$C$L186:
AADD #3, SP
.dwcfi cfa_offset, 1
$C$DW$405 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$405, DW_AT_low_pc(0x00)
.dwattr $C$DW$405, DW_AT_TI_return
RET
; return occurs
$C$DW$406 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$406, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L184:1:1538833113")
.dwattr $C$DW$406, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$406, DW_AT_TI_begin_line(0xc74)
.dwattr $C$DW$406, DW_AT_TI_end_line(0xc74)
$C$DW$407 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$407, DW_AT_low_pc($C$DW$L$_vTaskSetTimeOutState$3$B)
.dwattr $C$DW$407, DW_AT_high_pc($C$DW$L$_vTaskSetTimeOutState$3$E)
.dwendtag $C$DW$406
.dwattr $C$DW$402, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$402, DW_AT_TI_end_line(0xc7b)
.dwattr $C$DW$402, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$402
.sect ".text"
.align 4
.global _vTaskInternalSetTimeOutState
$C$DW$408 .dwtag DW_TAG_subprogram, DW_AT_name("vTaskInternalSetTimeOutState")
.dwattr $C$DW$408, DW_AT_low_pc(_vTaskInternalSetTimeOutState)
.dwattr $C$DW$408, DW_AT_high_pc(0x00)
.dwattr $C$DW$408, DW_AT_TI_symbol_name("_vTaskInternalSetTimeOutState")
.dwattr $C$DW$408, DW_AT_external
.dwattr $C$DW$408, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$408, DW_AT_TI_begin_line(0xc7e)
.dwattr $C$DW$408, DW_AT_TI_begin_column(0x06)
.dwattr $C$DW$408, DW_AT_TI_max_frame_size(0x04)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3199,column 1,is_stmt,address _vTaskInternalSetTimeOutState
.dwfde $C$DW$CIE, _vTaskInternalSetTimeOutState
$C$DW$409 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxTimeOut")
.dwattr $C$DW$409, DW_AT_TI_symbol_name("_pxTimeOut")
.dwattr $C$DW$409, DW_AT_type(*$C$DW$T$104)
.dwattr $C$DW$409, DW_AT_location[DW_OP_reg17]
;*******************************************************************************
;* FUNCTION NAME: vTaskInternalSetTimeOutState *
;* *
;* Function Uses Regs : AC0,AC0,AR0,XAR0,AR1,AR3,XAR3,SP,M40,SATA,SATD,RDM, *
;* FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 4 words *
;* (2 return address/alignment) *
;* (2 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_vTaskInternalSetTimeOutState:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-3, SP
.dwcfi cfa_offset, 4
$C$DW$410 .dwtag DW_TAG_variable, DW_AT_name("pxTimeOut")
.dwattr $C$DW$410, DW_AT_TI_symbol_name("_pxTimeOut")
.dwattr $C$DW$410, DW_AT_type(*$C$DW$T$104)
.dwattr $C$DW$410, DW_AT_location[DW_OP_bregx 0x24 0]
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3201,column 2,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV *(#_xNumOfOverflows), AR1 ; |3201|
MOV AR1, *AR3 ; |3201|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3202,column 2,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV dbl(*(#_xTickCount)), AC0 ; |3202|
MOV AC0, dbl(*AR3(short(#2))) ; |3202|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3203,column 1,is_stmt
AADD #3, SP
.dwcfi cfa_offset, 1
$C$DW$411 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$411, DW_AT_low_pc(0x00)
.dwattr $C$DW$411, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$408, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$408, DW_AT_TI_end_line(0xc83)
.dwattr $C$DW$408, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$408
.sect ".text"
.align 4
.global _xTaskCheckForTimeOut
$C$DW$412 .dwtag DW_TAG_subprogram, DW_AT_name("xTaskCheckForTimeOut")
.dwattr $C$DW$412, DW_AT_low_pc(_xTaskCheckForTimeOut)
.dwattr $C$DW$412, DW_AT_high_pc(0x00)
.dwattr $C$DW$412, DW_AT_TI_symbol_name("_xTaskCheckForTimeOut")
.dwattr $C$DW$412, DW_AT_external
.dwattr $C$DW$412, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$412, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$412, DW_AT_TI_begin_line(0xc86)
.dwattr $C$DW$412, DW_AT_TI_begin_column(0x0c)
.dwattr $C$DW$412, DW_AT_TI_max_frame_size(0x0c)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3207,column 1,is_stmt,address _xTaskCheckForTimeOut
.dwfde $C$DW$CIE, _xTaskCheckForTimeOut
$C$DW$413 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxTimeOut")
.dwattr $C$DW$413, DW_AT_TI_symbol_name("_pxTimeOut")
.dwattr $C$DW$413, DW_AT_type(*$C$DW$T$104)
.dwattr $C$DW$413, DW_AT_location[DW_OP_reg17]
$C$DW$414 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxTicksToWait")
.dwattr $C$DW$414, DW_AT_TI_symbol_name("_pxTicksToWait")
.dwattr $C$DW$414, DW_AT_type(*$C$DW$T$94)
.dwattr $C$DW$414, DW_AT_location[DW_OP_reg19]
;*******************************************************************************
;* FUNCTION NAME: xTaskCheckForTimeOut *
;* *
;* Function Uses Regs : AC0,AC0,AC1,AC1,T0,AR0,XAR0,AR1,XAR1,AR2,AR3,XAR3,SP,*
;* CARRY,TC1,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 12 words *
;* (2 return address/alignment) *
;* (10 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_xTaskCheckForTimeOut:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-11, SP
.dwcfi cfa_offset, 12
$C$DW$415 .dwtag DW_TAG_variable, DW_AT_name("pxTimeOut")
.dwattr $C$DW$415, DW_AT_TI_symbol_name("_pxTimeOut")
.dwattr $C$DW$415, DW_AT_type(*$C$DW$T$104)
.dwattr $C$DW$415, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$416 .dwtag DW_TAG_variable, DW_AT_name("pxTicksToWait")
.dwattr $C$DW$416, DW_AT_TI_symbol_name("_pxTicksToWait")
.dwattr $C$DW$416, DW_AT_type(*$C$DW$T$94)
.dwattr $C$DW$416, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$417 .dwtag DW_TAG_variable, DW_AT_name("xReturn")
.dwattr $C$DW$417, DW_AT_TI_symbol_name("_xReturn")
.dwattr $C$DW$417, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$417, DW_AT_location[DW_OP_bregx 0x24 4]
MOV XAR1, dbl(*SP(#2))
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3210,column 2,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L188,AC0 != #0 ; |3210|
; branchcc occurs ; |3210|
nop
bset INTM
$C$L187:
$C$DW$L$_xTaskCheckForTimeOut$3$B:
B $C$L187 ; |3210|
; branch occurs ; |3210|
$C$DW$L$_xTaskCheckForTimeOut$3$E:
$C$L188:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3211,column 2,is_stmt
MOV dbl(*SP(#2)), XAR3
MOV XAR3, AC0
BCC $C$L190,AC0 != #0 ; |3211|
; branchcc occurs ; |3211|
nop
bset INTM
$C$L189:
$C$DW$L$_xTaskCheckForTimeOut$6$B:
B $C$L189 ; |3211|
; branch occurs ; |3211|
$C$DW$L$_xTaskCheckForTimeOut$6$E:
$C$L190:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3213,column 2,is_stmt
nop
bset INTM
ADD #1, *(#_usCriticalNesting) ; |3213|
NOP
NOP
NOP
$C$DW$418 .dwtag DW_TAG_lexical_block, DW_AT_low_pc(0x00), DW_AT_high_pc(0x00)
$C$DW$419 .dwtag DW_TAG_variable, DW_AT_name("xConstTickCount")
.dwattr $C$DW$419, DW_AT_TI_symbol_name("_xConstTickCount")
.dwattr $C$DW$419, DW_AT_type(*$C$DW$T$95)
.dwattr $C$DW$419, DW_AT_location[DW_OP_bregx 0x24 6]
$C$DW$420 .dwtag DW_TAG_variable, DW_AT_name("xElapsedTime")
.dwattr $C$DW$420, DW_AT_TI_symbol_name("_xElapsedTime")
.dwattr $C$DW$420, DW_AT_type(*$C$DW$T$95)
.dwattr $C$DW$420, DW_AT_location[DW_OP_bregx 0x24 8]
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3216,column 20,is_stmt
MOV dbl(*(#_xTickCount)), AC0 ; |3216|
MOV AC0, dbl(*SP(#6)) ; |3216|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3217,column 20,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV dbl(*AR3(short(#2))), AC0 ; |3217|
SUB AC0, dbl(*SP(#6)), AC0 ; |3217|
MOV AC0, dbl(*SP(#8)) ; |3217|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3231,column 4,is_stmt
MOV dbl(*SP(#2)), XAR3
MOV #-1 << #16, AC0 ; |3231|
OR #0xffff, AC0, AC0 ; |3231|
MOV dbl(*AR3), AC1 ; |3231|
CMPU AC1 != AC0, TC1 ; |3231|
BCC $C$L191,TC1 ; |3231|
; branchcc occurs ; |3231|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3236,column 5,is_stmt
MOV #0, *SP(#4) ; |3236|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3237,column 4,is_stmt
B $C$L194 ; |3237|
; branch occurs ; |3237|
$C$L191:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3241,column 3,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV *(#_xNumOfOverflows), AR2 ; |3241|
MOV *AR3, AR1 ; |3241|
CMP AR2 == AR1, TC1 ; |3241|
BCC $C$L192,TC1 ; |3241|
; branchcc occurs ; |3241|
MOV dbl(*AR3(short(#2))), AC0 ; |3241|
MOV dbl(*SP(#6)), AC1 ; |3241|
CMPU AC1 < AC0, TC1 ; |3241|
BCC $C$L192,TC1 ; |3241|
; branchcc occurs ; |3241|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3248,column 4,is_stmt
MOV #1, *SP(#4) ; |3248|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3249,column 3,is_stmt
B $C$L194 ; |3249|
; branch occurs ; |3249|
$C$L192:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3250,column 8,is_stmt
MOV dbl(*SP(#2)), XAR3
MOV dbl(*SP(#8)), AC1 ; |3250|
MOV dbl(*AR3), AC0 ; |3250|
CMPU AC1 >= AC0, TC1 ; |3250|
BCC $C$L193,TC1 ; |3250|
; branchcc occurs ; |3250|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3253,column 4,is_stmt
MOV dbl(*SP(#8)), AC0 ; |3253|
SUB AC0, dbl(*AR3), AC0 ; |3253|
MOV AC0, dbl(*AR3) ; |3253|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3254,column 4,is_stmt
MOV dbl(*SP(#0)), XAR0
$C$DW$421 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$421, DW_AT_low_pc(0x00)
.dwattr $C$DW$421, DW_AT_name("_vTaskInternalSetTimeOutState")
.dwattr $C$DW$421, DW_AT_TI_call
CALL #_vTaskInternalSetTimeOutState ; |3254|
; call occurs [#_vTaskInternalSetTimeOutState] ; |3254|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3255,column 4,is_stmt
MOV #0, *SP(#4) ; |3255|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3256,column 3,is_stmt
B $C$L194 ; |3256|
; branch occurs ; |3256|
$C$L193:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3259,column 4,is_stmt
MOV #0, AC0 ; |3259|
MOV AC0, dbl(*AR3) ; |3259|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3260,column 4,is_stmt
MOV #1, *SP(#4) ; |3260|
$C$L194:
.dwendtag $C$DW$418
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3263,column 2,is_stmt
MOV *(#_usCriticalNesting), AR1 ; |3263|
BCC $C$L195,AR1 == #0 ; |3263|
; branchcc occurs ; |3263|
SUB #1, *(#_usCriticalNesting) ; |3263|
NOP
NOP
NOP
MOV *(#_usCriticalNesting), AR1 ; |3263|
BCC $C$L195,AR1 != #0 ; |3263|
; branchcc occurs ; |3263|
nop
bclr INTM
$C$L195:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3265,column 2,is_stmt
MOV *SP(#4), T0 ; |3265|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3266,column 1,is_stmt
AADD #11, SP
.dwcfi cfa_offset, 1
$C$DW$422 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$422, DW_AT_low_pc(0x00)
.dwattr $C$DW$422, DW_AT_TI_return
RET
; return occurs
$C$DW$423 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$423, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L189:1:1538833113")
.dwattr $C$DW$423, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$423, DW_AT_TI_begin_line(0xc8b)
.dwattr $C$DW$423, DW_AT_TI_end_line(0xc8b)
$C$DW$424 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$424, DW_AT_low_pc($C$DW$L$_xTaskCheckForTimeOut$6$B)
.dwattr $C$DW$424, DW_AT_high_pc($C$DW$L$_xTaskCheckForTimeOut$6$E)
.dwendtag $C$DW$423
$C$DW$425 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$425, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L187:1:1538833113")
.dwattr $C$DW$425, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$425, DW_AT_TI_begin_line(0xc8a)
.dwattr $C$DW$425, DW_AT_TI_end_line(0xc8a)
$C$DW$426 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$426, DW_AT_low_pc($C$DW$L$_xTaskCheckForTimeOut$3$B)
.dwattr $C$DW$426, DW_AT_high_pc($C$DW$L$_xTaskCheckForTimeOut$3$E)
.dwendtag $C$DW$425
.dwattr $C$DW$412, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$412, DW_AT_TI_end_line(0xcc2)
.dwattr $C$DW$412, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$412
.sect ".text"
.align 4
.global _vTaskMissedYield
$C$DW$427 .dwtag DW_TAG_subprogram, DW_AT_name("vTaskMissedYield")
.dwattr $C$DW$427, DW_AT_low_pc(_vTaskMissedYield)
.dwattr $C$DW$427, DW_AT_high_pc(0x00)
.dwattr $C$DW$427, DW_AT_TI_symbol_name("_vTaskMissedYield")
.dwattr $C$DW$427, DW_AT_external
.dwattr $C$DW$427, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$427, DW_AT_TI_begin_line(0xcc5)
.dwattr $C$DW$427, DW_AT_TI_begin_column(0x06)
.dwattr $C$DW$427, DW_AT_TI_max_frame_size(0x01)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3270,column 1,is_stmt,address _vTaskMissedYield
.dwfde $C$DW$CIE, _vTaskMissedYield
;*******************************************************************************
;* FUNCTION NAME: vTaskMissedYield *
;* *
;* Function Uses Regs : SP,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 1 word *
;* (1 return address/alignment) *
;* Min System Stack : 1 word *
;*******************************************************************************
_vTaskMissedYield:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3271,column 2,is_stmt
MOV #1, *(#_xYieldPending) ; |3271|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3272,column 1,is_stmt
$C$DW$428 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$428, DW_AT_low_pc(0x00)
.dwattr $C$DW$428, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$427, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$427, DW_AT_TI_end_line(0xcc8)
.dwattr $C$DW$427, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$427
.sect ".text"
.align 4
$C$DW$429 .dwtag DW_TAG_subprogram, DW_AT_name("prvIdleTask")
.dwattr $C$DW$429, DW_AT_low_pc(_prvIdleTask)
.dwattr $C$DW$429, DW_AT_high_pc(0x00)
.dwattr $C$DW$429, DW_AT_TI_symbol_name("_prvIdleTask")
.dwattr $C$DW$429, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$429, DW_AT_TI_begin_line(0xcfc)
.dwattr $C$DW$429, DW_AT_TI_begin_column(0x08)
.dwattr $C$DW$429, DW_AT_TI_max_frame_size(0x04)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3325,column 1,is_stmt,address _prvIdleTask
.dwfde $C$DW$CIE, _prvIdleTask
$C$DW$430 .dwtag DW_TAG_formal_parameter, DW_AT_name("pvParameters")
.dwattr $C$DW$430, DW_AT_TI_symbol_name("_pvParameters")
.dwattr $C$DW$430, DW_AT_type(*$C$DW$T$3)
.dwattr $C$DW$430, DW_AT_location[DW_OP_reg17]
;*******************************************************************************
;* FUNCTION NAME: prvIdleTask *
;* *
;* Function Uses Regs : T2,AR0,XAR0,AR1,SP,TC1,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Save On Entry Regs : T2 *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 4 words *
;* (1 return address/alignment) *
;* (2 local values) *
;* (1 register save area) *
;* Min System Stack : 1 word *
;*******************************************************************************
_prvIdleTask:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
PSH T2
.dwcfi cfa_offset, 2
.dwcfi save_reg_to_mem, 14, -2
AADD #-2, SP
.dwcfi cfa_offset, 4
$C$DW$431 .dwtag DW_TAG_variable, DW_AT_name("pvParameters")
.dwattr $C$DW$431, DW_AT_TI_symbol_name("_pvParameters")
.dwattr $C$DW$431, DW_AT_type(*$C$DW$T$3)
.dwattr $C$DW$431, DW_AT_location[DW_OP_bregx 0x24 0]
MOV XAR0, dbl(*SP(#0))
|| MOV #1, T2
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3327,column 2,is_stmt
$C$L196:
$C$DW$L$_prvIdleTask$2$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3344,column 3,is_stmt
$C$DW$432 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$432, DW_AT_low_pc(0x00)
.dwattr $C$DW$432, DW_AT_name("_prvCheckTasksWaitingTermination")
.dwattr $C$DW$432, DW_AT_TI_call
CALL #_prvCheckTasksWaitingTermination ; |3344|
; call occurs [#_prvCheckTasksWaitingTermination] ; |3344|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3367,column 4,is_stmt
MOV *(#_pxReadyTasksLists), AR1 ; |3367|
CMPU AR1 <= T2, TC1 ; |3367|
BCC $C$L197,TC1 ; |3367|
; branchcc occurs ; |3367|
$C$DW$L$_prvIdleTask$2$E:
$C$DW$L$_prvIdleTask$3$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3369,column 5,is_stmt
$C$DW$433 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$433, DW_AT_low_pc(0x00)
.dwattr $C$DW$433, DW_AT_name("_vPortYield")
.dwattr $C$DW$433, DW_AT_TI_call
CALL #_vPortYield ; |3369|
; call occurs [#_vPortYield] ; |3369|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3370,column 4,is_stmt
$C$DW$L$_prvIdleTask$3$E:
$C$L197:
$C$DW$L$_prvIdleTask$4$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3387,column 4,is_stmt
$C$DW$434 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$434, DW_AT_low_pc(0x00)
.dwattr $C$DW$434, DW_AT_name("_vApplicationIdleHook")
.dwattr $C$DW$434, DW_AT_TI_call
CALL #_vApplicationIdleHook ; |3387|
; call occurs [#_vApplicationIdleHook] ; |3387|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3440,column 2,is_stmt
B $C$L196 ; |3440|
; branch occurs ; |3440|
$C$DW$L$_prvIdleTask$4$E:
.dwcfi cfa_offset, 2
.dwcfi restore_reg, 14
.dwcfi cfa_offset, 1
$C$DW$435 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$435, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L196:1:1538833113")
.dwattr $C$DW$435, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$435, DW_AT_TI_begin_line(0xd09)
.dwattr $C$DW$435, DW_AT_TI_end_line(0xd70)
$C$DW$436 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$436, DW_AT_low_pc($C$DW$L$_prvIdleTask$2$B)
.dwattr $C$DW$436, DW_AT_high_pc($C$DW$L$_prvIdleTask$2$E)
$C$DW$437 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$437, DW_AT_low_pc($C$DW$L$_prvIdleTask$3$B)
.dwattr $C$DW$437, DW_AT_high_pc($C$DW$L$_prvIdleTask$3$E)
$C$DW$438 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$438, DW_AT_low_pc($C$DW$L$_prvIdleTask$4$B)
.dwattr $C$DW$438, DW_AT_high_pc($C$DW$L$_prvIdleTask$4$E)
.dwendtag $C$DW$435
.dwattr $C$DW$429, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$429, DW_AT_TI_end_line(0xd71)
.dwattr $C$DW$429, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$429
.sect ".text"
.align 4
$C$DW$439 .dwtag DW_TAG_subprogram, DW_AT_name("prvInitialiseTaskLists")
.dwattr $C$DW$439, DW_AT_low_pc(_prvInitialiseTaskLists)
.dwattr $C$DW$439, DW_AT_high_pc(0x00)
.dwattr $C$DW$439, DW_AT_TI_symbol_name("_prvInitialiseTaskLists")
.dwattr $C$DW$439, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$439, DW_AT_TI_begin_line(0xdd3)
.dwattr $C$DW$439, DW_AT_TI_begin_column(0x0d)
.dwattr $C$DW$439, DW_AT_TI_max_frame_size(0x02)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3540,column 1,is_stmt,address _prvInitialiseTaskLists
.dwfde $C$DW$CIE, _prvInitialiseTaskLists
;*******************************************************************************
;* FUNCTION NAME: prvInitialiseTaskLists *
;* *
;* Function Uses Regs : AC0,AR0,XAR0,AR1,AR2,AR3,XAR3,SP,CARRY,TC1,M40,SATA, *
;* SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 2 words *
;* (1 return address/alignment) *
;* (1 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_prvInitialiseTaskLists:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-1, SP
.dwcfi cfa_offset, 2
$C$DW$440 .dwtag DW_TAG_variable, DW_AT_name("uxPriority")
.dwattr $C$DW$440, DW_AT_TI_symbol_name("_uxPriority")
.dwattr $C$DW$440, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$440, DW_AT_location[DW_OP_bregx 0x24 0]
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3543,column 7,is_stmt
MOV #0, *SP(#0) ; |3543|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3543,column 40,is_stmt
MOV *SP(#0), AR1 ; |3543|
|| MOV #5, AR2
CMPU AR1 >= AR2, TC1 ; |3543|
BCC $C$L199,TC1 ; |3543|
; branchcc occurs ; |3543|
$C$L198:
$C$DW$L$_prvInitialiseTaskLists$2$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3545,column 3,is_stmt
MPYMK *SP(#0), #10, AC0 ; |3545|
MOV AC0, AR1 ; |3545|
AMOV #_pxReadyTasksLists, XAR0 ; |3545|
AADD AR1, AR0 ; |3545|
$C$DW$441 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$441, DW_AT_low_pc(0x00)
.dwattr $C$DW$441, DW_AT_name("_vListInitialise")
.dwattr $C$DW$441, DW_AT_TI_call
CALL #_vListInitialise ; |3545|
; call occurs [#_vListInitialise] ; |3545|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3543,column 91,is_stmt
ADD #1, *SP(#0) ; |3543|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3543,column 40,is_stmt
MOV *SP(#0), AR1 ; |3543|
|| MOV #5, AR2
CMPU AR1 < AR2, TC1 ; |3543|
BCC $C$L198,TC1 ; |3543|
; branchcc occurs ; |3543|
$C$DW$L$_prvInitialiseTaskLists$2$E:
$C$L199:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3548,column 2,is_stmt
AMOV #_xDelayedTaskList1, XAR0 ; |3548|
$C$DW$442 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$442, DW_AT_low_pc(0x00)
.dwattr $C$DW$442, DW_AT_name("_vListInitialise")
.dwattr $C$DW$442, DW_AT_TI_call
CALL #_vListInitialise ; |3548|
; call occurs [#_vListInitialise] ; |3548|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3549,column 2,is_stmt
AMOV #_xDelayedTaskList2, XAR0 ; |3549|
$C$DW$443 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$443, DW_AT_low_pc(0x00)
.dwattr $C$DW$443, DW_AT_name("_vListInitialise")
.dwattr $C$DW$443, DW_AT_TI_call
CALL #_vListInitialise ; |3549|
; call occurs [#_vListInitialise] ; |3549|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3550,column 2,is_stmt
AMOV #_xPendingReadyList, XAR0 ; |3550|
$C$DW$444 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$444, DW_AT_low_pc(0x00)
.dwattr $C$DW$444, DW_AT_name("_vListInitialise")
.dwattr $C$DW$444, DW_AT_TI_call
CALL #_vListInitialise ; |3550|
; call occurs [#_vListInitialise] ; |3550|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3554,column 3,is_stmt
AMOV #_xTasksWaitingTermination, XAR0 ; |3554|
$C$DW$445 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$445, DW_AT_low_pc(0x00)
.dwattr $C$DW$445, DW_AT_name("_vListInitialise")
.dwattr $C$DW$445, DW_AT_TI_call
CALL #_vListInitialise ; |3554|
; call occurs [#_vListInitialise] ; |3554|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3560,column 3,is_stmt
AMOV #_xSuspendedTaskList, XAR0 ; |3560|
$C$DW$446 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$446, DW_AT_low_pc(0x00)
.dwattr $C$DW$446, DW_AT_name("_vListInitialise")
.dwattr $C$DW$446, DW_AT_TI_call
CALL #_vListInitialise ; |3560|
; call occurs [#_vListInitialise] ; |3560|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3566,column 2,is_stmt
AMOV #_xDelayedTaskList1, XAR3 ; |3566|
MOV XAR3, dbl(*(#_pxDelayedTaskList))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3567,column 2,is_stmt
AMOV #_xDelayedTaskList2, XAR3 ; |3567|
MOV XAR3, dbl(*(#_pxOverflowDelayedTaskList))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3568,column 1,is_stmt
AADD #1, SP
.dwcfi cfa_offset, 1
$C$DW$447 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$447, DW_AT_low_pc(0x00)
.dwattr $C$DW$447, DW_AT_TI_return
RET
; return occurs
$C$DW$448 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$448, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L198:1:1538833113")
.dwattr $C$DW$448, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$448, DW_AT_TI_begin_line(0xdd7)
.dwattr $C$DW$448, DW_AT_TI_end_line(0xdda)
$C$DW$449 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$449, DW_AT_low_pc($C$DW$L$_prvInitialiseTaskLists$2$B)
.dwattr $C$DW$449, DW_AT_high_pc($C$DW$L$_prvInitialiseTaskLists$2$E)
.dwendtag $C$DW$448
.dwattr $C$DW$439, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$439, DW_AT_TI_end_line(0xdf0)
.dwattr $C$DW$439, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$439
.sect ".text"
.align 4
$C$DW$450 .dwtag DW_TAG_subprogram, DW_AT_name("prvCheckTasksWaitingTermination")
.dwattr $C$DW$450, DW_AT_low_pc(_prvCheckTasksWaitingTermination)
.dwattr $C$DW$450, DW_AT_high_pc(0x00)
.dwattr $C$DW$450, DW_AT_TI_symbol_name("_prvCheckTasksWaitingTermination")
.dwattr $C$DW$450, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$450, DW_AT_TI_begin_line(0xdf3)
.dwattr $C$DW$450, DW_AT_TI_begin_column(0x0d)
.dwattr $C$DW$450, DW_AT_TI_max_frame_size(0x04)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3572,column 1,is_stmt,address _prvCheckTasksWaitingTermination
.dwfde $C$DW$CIE, _prvCheckTasksWaitingTermination
;*******************************************************************************
;* FUNCTION NAME: prvCheckTasksWaitingTermination *
;* *
;* Function Uses Regs : AR0,XAR0,AR1,AR3,XAR3,SP,CARRY,M40,SATA,SATD,RDM, *
;* FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 4 words *
;* (2 return address/alignment) *
;* (2 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_prvCheckTasksWaitingTermination:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-3, SP
.dwcfi cfa_offset, 4
$C$DW$451 .dwtag DW_TAG_lexical_block, DW_AT_low_pc(0x00), DW_AT_high_pc(0x00)
$C$DW$452 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$452, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$452, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$452, DW_AT_location[DW_OP_bregx 0x24 0]
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3582,column 10,is_stmt
MOV *(#_uxDeletedTasksWaitingCleanUp), AR1 ; |3582|
BCC $C$L202,AR1 == #0 ; |3582|
; branchcc occurs ; |3582|
$C$L200:
$C$DW$L$_prvCheckTasksWaitingTermination$2$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3584,column 4,is_stmt
nop
bset INTM
ADD #1, *(#_usCriticalNesting) ; |3584|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3586,column 5,is_stmt
MOV dbl(*(#(_xTasksWaitingTermination+6))), XAR3
MOV dbl(*AR3(short(#6))), XAR3
MOV XAR3, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3587,column 5,is_stmt
MOV dbl(*SP(#0)), XAR0
AADD #4, AR0 ; |3587|
$C$DW$453 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$453, DW_AT_low_pc(0x00)
.dwattr $C$DW$453, DW_AT_name("_uxListRemove")
.dwattr $C$DW$453, DW_AT_TI_call
CALL #_uxListRemove ; |3587|
; call occurs [#_uxListRemove] ; |3587|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3588,column 5,is_stmt
SUB #1, *(#_uxCurrentNumberOfTasks) ; |3588|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3589,column 5,is_stmt
SUB #1, *(#_uxDeletedTasksWaitingCleanUp) ; |3589|
NOP
NOP
NOP
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3591,column 4,is_stmt
MOV *(#_usCriticalNesting), AR1 ; |3591|
BCC $C$L201,AR1 == #0 ; |3591|
; branchcc occurs ; |3591|
$C$DW$L$_prvCheckTasksWaitingTermination$2$E:
$C$DW$L$_prvCheckTasksWaitingTermination$3$B:
SUB #1, *(#_usCriticalNesting) ; |3591|
NOP
NOP
NOP
MOV *(#_usCriticalNesting), AR1 ; |3591|
BCC $C$L201,AR1 != #0 ; |3591|
; branchcc occurs ; |3591|
$C$DW$L$_prvCheckTasksWaitingTermination$3$E:
$C$DW$L$_prvCheckTasksWaitingTermination$4$B:
nop
bclr INTM
$C$DW$L$_prvCheckTasksWaitingTermination$4$E:
$C$L201:
$C$DW$L$_prvCheckTasksWaitingTermination$5$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3593,column 4,is_stmt
MOV dbl(*SP(#0)), XAR0
$C$DW$454 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$454, DW_AT_low_pc(0x00)
.dwattr $C$DW$454, DW_AT_name("_prvDeleteTCB")
.dwattr $C$DW$454, DW_AT_TI_call
CALL #_prvDeleteTCB ; |3593|
; call occurs [#_prvDeleteTCB] ; |3593|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3582,column 10,is_stmt
MOV *(#_uxDeletedTasksWaitingCleanUp), AR1 ; |3582|
BCC $C$L200,AR1 != #0 ; |3582|
; branchcc occurs ; |3582|
$C$DW$L$_prvCheckTasksWaitingTermination$5$E:
.dwendtag $C$DW$451
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3597,column 1,is_stmt
$C$L202:
AADD #3, SP
.dwcfi cfa_offset, 1
$C$DW$455 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$455, DW_AT_low_pc(0x00)
.dwattr $C$DW$455, DW_AT_TI_return
RET
; return occurs
$C$DW$456 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$456, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L200:1:1538833113")
.dwattr $C$DW$456, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$456, DW_AT_TI_begin_line(0xdfe)
.dwattr $C$DW$456, DW_AT_TI_end_line(0xe0a)
$C$DW$457 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$457, DW_AT_low_pc($C$DW$L$_prvCheckTasksWaitingTermination$2$B)
.dwattr $C$DW$457, DW_AT_high_pc($C$DW$L$_prvCheckTasksWaitingTermination$2$E)
$C$DW$458 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$458, DW_AT_low_pc($C$DW$L$_prvCheckTasksWaitingTermination$3$B)
.dwattr $C$DW$458, DW_AT_high_pc($C$DW$L$_prvCheckTasksWaitingTermination$3$E)
$C$DW$459 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$459, DW_AT_low_pc($C$DW$L$_prvCheckTasksWaitingTermination$4$B)
.dwattr $C$DW$459, DW_AT_high_pc($C$DW$L$_prvCheckTasksWaitingTermination$4$E)
$C$DW$460 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$460, DW_AT_low_pc($C$DW$L$_prvCheckTasksWaitingTermination$5$B)
.dwattr $C$DW$460, DW_AT_high_pc($C$DW$L$_prvCheckTasksWaitingTermination$5$E)
.dwendtag $C$DW$456
.dwattr $C$DW$450, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$450, DW_AT_TI_end_line(0xe0d)
.dwattr $C$DW$450, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$450
.sect ".text"
.align 4
$C$DW$461 .dwtag DW_TAG_subprogram, DW_AT_name("prvTaskCheckFreeStackSpace")
.dwattr $C$DW$461, DW_AT_low_pc(_prvTaskCheckFreeStackSpace)
.dwattr $C$DW$461, DW_AT_high_pc(0x00)
.dwattr $C$DW$461, DW_AT_TI_symbol_name("_prvTaskCheckFreeStackSpace")
.dwattr $C$DW$461, DW_AT_type(*$C$DW$T$121)
.dwattr $C$DW$461, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$461, DW_AT_TI_begin_line(0xe95)
.dwattr $C$DW$461, DW_AT_TI_begin_column(0x20)
.dwattr $C$DW$461, DW_AT_TI_max_frame_size(0x06)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3734,column 2,is_stmt,address _prvTaskCheckFreeStackSpace
.dwfde $C$DW$CIE, _prvTaskCheckFreeStackSpace
$C$DW$462 .dwtag DW_TAG_formal_parameter, DW_AT_name("pucStackByte")
.dwattr $C$DW$462, DW_AT_TI_symbol_name("_pucStackByte")
.dwattr $C$DW$462, DW_AT_type(*$C$DW$T$116)
.dwattr $C$DW$462, DW_AT_location[DW_OP_reg17]
;*******************************************************************************
;* FUNCTION NAME: prvTaskCheckFreeStackSpace *
;* *
;* Function Uses Regs : AC0,AC0,T0,AR0,XAR0,AR1,AR2,AR3,XAR3,SP,CARRY,TC1, *
;* M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 6 words *
;* (2 return address/alignment) *
;* (4 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_prvTaskCheckFreeStackSpace:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-5, SP
.dwcfi cfa_offset, 6
$C$DW$463 .dwtag DW_TAG_variable, DW_AT_name("pucStackByte")
.dwattr $C$DW$463, DW_AT_TI_symbol_name("_pucStackByte")
.dwattr $C$DW$463, DW_AT_type(*$C$DW$T$116)
.dwattr $C$DW$463, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$464 .dwtag DW_TAG_variable, DW_AT_name("ulCount")
.dwattr $C$DW$464, DW_AT_TI_symbol_name("_ulCount")
.dwattr $C$DW$464, DW_AT_type(*$C$DW$T$28)
.dwattr $C$DW$464, DW_AT_location[DW_OP_bregx 0x24 2]
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3735,column 11,is_stmt
MOV #0, AC0 ; |3735|
MOV AC0, dbl(*SP(#2)) ; |3735|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3737,column 10,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV #42405, AR2 ; |3737|
MOV *AR3, AR1 ; |3737|
CMPU AR1 != AR2, TC1 ; |3737|
BCC $C$L204,TC1 ; |3737|
; branchcc occurs ; |3737|
$C$L203:
$C$DW$L$_prvTaskCheckFreeStackSpace$2$B:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3739,column 4,is_stmt
AMAR *AR3+
MOV XAR3, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3740,column 4,is_stmt
MOV dbl(*SP(#2)), AC0 ; |3740|
ADD #1, AC0 ; |3740|
MOV AC0, dbl(*SP(#2)) ; |3740|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3737,column 10,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV *AR3, AR1 ; |3737|
CMPU AR1 == AR2, TC1 ; |3737|
BCC $C$L203,TC1 ; |3737|
; branchcc occurs ; |3737|
$C$DW$L$_prvTaskCheckFreeStackSpace$2$E:
$C$L204:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3743,column 3,is_stmt
MOV dbl(*SP(#2)), AC0 ; |3743|
MOV AC0, dbl(*SP(#2)) ; |3743|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3745,column 3,is_stmt
MOV *SP(#3), T0 ; |3745|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3746,column 2,is_stmt
AADD #5, SP
.dwcfi cfa_offset, 1
$C$DW$465 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$465, DW_AT_low_pc(0x00)
.dwattr $C$DW$465, DW_AT_TI_return
RET
; return occurs
$C$DW$466 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$466, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L203:1:1538833113")
.dwattr $C$DW$466, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$466, DW_AT_TI_begin_line(0xe99)
.dwattr $C$DW$466, DW_AT_TI_end_line(0xe9d)
$C$DW$467 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$467, DW_AT_low_pc($C$DW$L$_prvTaskCheckFreeStackSpace$2$B)
.dwattr $C$DW$467, DW_AT_high_pc($C$DW$L$_prvTaskCheckFreeStackSpace$2$E)
.dwendtag $C$DW$466
.dwattr $C$DW$461, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$461, DW_AT_TI_end_line(0xea2)
.dwattr $C$DW$461, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$461
.sect ".text"
.align 4
.global _uxTaskGetStackHighWaterMark
$C$DW$468 .dwtag DW_TAG_subprogram, DW_AT_name("uxTaskGetStackHighWaterMark")
.dwattr $C$DW$468, DW_AT_low_pc(_uxTaskGetStackHighWaterMark)
.dwattr $C$DW$468, DW_AT_high_pc(0x00)
.dwattr $C$DW$468, DW_AT_TI_symbol_name("_uxTaskGetStackHighWaterMark")
.dwattr $C$DW$468, DW_AT_external
.dwattr $C$DW$468, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$468, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$468, DW_AT_TI_begin_line(0xea9)
.dwattr $C$DW$468, DW_AT_TI_begin_column(0x0e)
.dwattr $C$DW$468, DW_AT_TI_max_frame_size(0x08)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3754,column 2,is_stmt,address _uxTaskGetStackHighWaterMark
.dwfde $C$DW$CIE, _uxTaskGetStackHighWaterMark
$C$DW$469 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTask")
.dwattr $C$DW$469, DW_AT_TI_symbol_name("_xTask")
.dwattr $C$DW$469, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$469, DW_AT_location[DW_OP_reg17]
;*******************************************************************************
;* FUNCTION NAME: uxTaskGetStackHighWaterMark *
;* *
;* Function Uses Regs : AC0,AC0,T0,AR0,XAR0,AR3,XAR3,SP,M40,SATA,SATD,RDM, *
;* FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 8 words *
;* (1 return address/alignment) *
;* (7 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_uxTaskGetStackHighWaterMark:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-7, SP
.dwcfi cfa_offset, 8
$C$DW$470 .dwtag DW_TAG_variable, DW_AT_name("xTask")
.dwattr $C$DW$470, DW_AT_TI_symbol_name("_xTask")
.dwattr $C$DW$470, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$470, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$471 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$471, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$471, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$471, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$472 .dwtag DW_TAG_variable, DW_AT_name("pucEndOfStack")
.dwattr $C$DW$472, DW_AT_TI_symbol_name("_pucEndOfStack")
.dwattr $C$DW$472, DW_AT_type(*$C$DW$T$114)
.dwattr $C$DW$472, DW_AT_location[DW_OP_bregx 0x24 4]
$C$DW$473 .dwtag DW_TAG_variable, DW_AT_name("uxReturn")
.dwattr $C$DW$473, DW_AT_TI_symbol_name("_uxReturn")
.dwattr $C$DW$473, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$473, DW_AT_location[DW_OP_bregx 0x24 6]
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3759,column 3,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L205,AC0 != #0 ; |3759|
; branchcc occurs ; |3759|
MOV dbl(*(#_pxCurrentTCB)), XAR3
$C$L205:
MOV XAR3, dbl(*SP(#2))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3763,column 4,is_stmt
MOV dbl(*AR3(#26)), XAR3
MOV XAR3, dbl(*SP(#4))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3772,column 3,is_stmt
MOV dbl(*SP(#4)), XAR0
$C$DW$474 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$474, DW_AT_low_pc(0x00)
.dwattr $C$DW$474, DW_AT_name("_prvTaskCheckFreeStackSpace")
.dwattr $C$DW$474, DW_AT_TI_call
CALL #_prvTaskCheckFreeStackSpace ; |3772|
; call occurs [#_prvTaskCheckFreeStackSpace] ; |3772|
MOV T0, *SP(#6) ; |3772|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3774,column 3,is_stmt
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3775,column 2,is_stmt
AADD #7, SP
.dwcfi cfa_offset, 1
$C$DW$475 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$475, DW_AT_low_pc(0x00)
.dwattr $C$DW$475, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$468, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$468, DW_AT_TI_end_line(0xebf)
.dwattr $C$DW$468, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$468
.sect ".text"
.align 4
$C$DW$476 .dwtag DW_TAG_subprogram, DW_AT_name("prvDeleteTCB")
.dwattr $C$DW$476, DW_AT_low_pc(_prvDeleteTCB)
.dwattr $C$DW$476, DW_AT_high_pc(0x00)
.dwattr $C$DW$476, DW_AT_TI_symbol_name("_prvDeleteTCB")
.dwattr $C$DW$476, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$476, DW_AT_TI_begin_line(0xec6)
.dwattr $C$DW$476, DW_AT_TI_begin_column(0x0e)
.dwattr $C$DW$476, DW_AT_TI_max_frame_size(0x04)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3783,column 2,is_stmt,address _prvDeleteTCB
.dwfde $C$DW$CIE, _prvDeleteTCB
$C$DW$477 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxTCB")
.dwattr $C$DW$477, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$477, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$477, DW_AT_location[DW_OP_reg17]
;*******************************************************************************
;* FUNCTION NAME: prvDeleteTCB *
;* *
;* Function Uses Regs : AR0,XAR0,AR3,XAR3,SP,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 4 words *
;* (2 return address/alignment) *
;* (2 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_prvDeleteTCB:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-3, SP
.dwcfi cfa_offset, 4
$C$DW$478 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$478, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$478, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$478, DW_AT_location[DW_OP_bregx 0x24 0]
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3787,column 3,is_stmt
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3801,column 4,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV dbl(*AR3(#26)), XAR0
$C$DW$479 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$479, DW_AT_low_pc(0x00)
.dwattr $C$DW$479, DW_AT_name("_vPortFree")
.dwattr $C$DW$479, DW_AT_TI_call
CALL #_vPortFree ; |3801|
; call occurs [#_vPortFree] ; |3801|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3802,column 4,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV dbl(*AR3(#28)), XAR0
$C$DW$480 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$480, DW_AT_low_pc(0x00)
.dwattr $C$DW$480, DW_AT_name("_vPortFree")
.dwattr $C$DW$480, DW_AT_TI_call
CALL #_vPortFree ; |3802|
; call occurs [#_vPortFree] ; |3802|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3803,column 4,is_stmt
MOV dbl(*SP(#0)), XAR0
$C$DW$481 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$481, DW_AT_low_pc(0x00)
.dwattr $C$DW$481, DW_AT_name("_vPortFree")
.dwattr $C$DW$481, DW_AT_TI_call
CALL #_vPortFree ; |3803|
; call occurs [#_vPortFree] ; |3803|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3833,column 2,is_stmt
AADD #3, SP
.dwcfi cfa_offset, 1
$C$DW$482 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$482, DW_AT_low_pc(0x00)
.dwattr $C$DW$482, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$476, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$476, DW_AT_TI_end_line(0xef9)
.dwattr $C$DW$476, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$476
.sect ".text"
.align 4
$C$DW$483 .dwtag DW_TAG_subprogram, DW_AT_name("prvResetNextTaskUnblockTime")
.dwattr $C$DW$483, DW_AT_low_pc(_prvResetNextTaskUnblockTime)
.dwattr $C$DW$483, DW_AT_high_pc(0x00)
.dwattr $C$DW$483, DW_AT_TI_symbol_name("_prvResetNextTaskUnblockTime")
.dwattr $C$DW$483, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$483, DW_AT_TI_begin_line(0xefe)
.dwattr $C$DW$483, DW_AT_TI_begin_column(0x0d)
.dwattr $C$DW$483, DW_AT_TI_max_frame_size(0x04)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3839,column 1,is_stmt,address _prvResetNextTaskUnblockTime
.dwfde $C$DW$CIE, _prvResetNextTaskUnblockTime
;*******************************************************************************
;* FUNCTION NAME: prvResetNextTaskUnblockTime *
;* *
;* Function Uses Regs : AC0,AC0,AR1,AR3,XAR3,SP,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 4 words *
;* (2 return address/alignment) *
;* (2 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_prvResetNextTaskUnblockTime:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-3, SP
.dwcfi cfa_offset, 4
$C$DW$484 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$484, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$484, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$484, DW_AT_location[DW_OP_bregx 0x24 0]
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3842,column 2,is_stmt
MOV dbl(*(#_pxDelayedTaskList)), XAR3
MOV *AR3, AR1 ; |3842|
BCC $C$L206,AR1 != #0 ; |3842|
; branchcc occurs ; |3842|
MOV #1, AR1
B $C$L207 ; |3842|
; branch occurs ; |3842|
$C$L206:
MOV #0, AR1
$C$L207:
BCC $C$L208,AR1 == #0 ; |3842|
; branchcc occurs ; |3842|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3848,column 3,is_stmt
MOV #-1 << #16, AC0 ; |3848|
OR #0xffff, AC0, AC0 ; |3848|
MOV AC0, dbl(*(#_xNextTaskUnblockTime)) ; |3848|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3849,column 2,is_stmt
B $C$L209 ; |3849|
; branch occurs ; |3849|
$C$L208:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3856,column 3,is_stmt
MOV dbl(*(#_pxDelayedTaskList)), XAR3
MOV dbl(*AR3(short(#6))), XAR3
MOV dbl(*AR3(short(#6))), XAR3
MOV XAR3, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3857,column 3,is_stmt
MOV dbl(*AR3(short(#4))), AC0 ; |3857|
MOV AC0, dbl(*(#_xNextTaskUnblockTime)) ; |3857|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3859,column 1,is_stmt
$C$L209:
AADD #3, SP
.dwcfi cfa_offset, 1
$C$DW$485 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$485, DW_AT_low_pc(0x00)
.dwattr $C$DW$485, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$483, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$483, DW_AT_TI_end_line(0xf13)
.dwattr $C$DW$483, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$483
.sect ".text"
.align 4
.global _xTaskGetCurrentTaskHandle
$C$DW$486 .dwtag DW_TAG_subprogram, DW_AT_name("xTaskGetCurrentTaskHandle")
.dwattr $C$DW$486, DW_AT_low_pc(_xTaskGetCurrentTaskHandle)
.dwattr $C$DW$486, DW_AT_high_pc(0x00)
.dwattr $C$DW$486, DW_AT_TI_symbol_name("_xTaskGetCurrentTaskHandle")
.dwattr $C$DW$486, DW_AT_external
.dwattr $C$DW$486, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$486, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$486, DW_AT_TI_begin_line(0xf18)
.dwattr $C$DW$486, DW_AT_TI_begin_column(0x0f)
.dwattr $C$DW$486, DW_AT_TI_max_frame_size(0x04)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3865,column 2,is_stmt,address _xTaskGetCurrentTaskHandle
.dwfde $C$DW$CIE, _xTaskGetCurrentTaskHandle
;*******************************************************************************
;* FUNCTION NAME: xTaskGetCurrentTaskHandle *
;* *
;* Function Uses Regs : AR0,XAR0,AR3,XAR3,SP,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 4 words *
;* (2 return address/alignment) *
;* (2 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_xTaskGetCurrentTaskHandle:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-3, SP
.dwcfi cfa_offset, 4
$C$DW$487 .dwtag DW_TAG_variable, DW_AT_name("xReturn")
.dwattr $C$DW$487, DW_AT_TI_symbol_name("_xReturn")
.dwattr $C$DW$487, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$487, DW_AT_location[DW_OP_bregx 0x24 0]
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3871,column 3,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV XAR3, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3873,column 3,is_stmt
MOV dbl(*SP(#0)), XAR0
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3874,column 2,is_stmt
AADD #3, SP
.dwcfi cfa_offset, 1
$C$DW$488 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$488, DW_AT_low_pc(0x00)
.dwattr $C$DW$488, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$486, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$486, DW_AT_TI_end_line(0xf22)
.dwattr $C$DW$486, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$486
.sect ".text"
.align 4
.global _xTaskPriorityInherit
$C$DW$489 .dwtag DW_TAG_subprogram, DW_AT_name("xTaskPriorityInherit")
.dwattr $C$DW$489, DW_AT_low_pc(_xTaskPriorityInherit)
.dwattr $C$DW$489, DW_AT_high_pc(0x00)
.dwattr $C$DW$489, DW_AT_TI_symbol_name("_xTaskPriorityInherit")
.dwattr $C$DW$489, DW_AT_external
.dwattr $C$DW$489, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$489, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$489, DW_AT_TI_begin_line(0xf45)
.dwattr $C$DW$489, DW_AT_TI_begin_column(0x0d)
.dwattr $C$DW$489, DW_AT_TI_max_frame_size(0x06)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3910,column 2,is_stmt,address _xTaskPriorityInherit
.dwfde $C$DW$CIE, _xTaskPriorityInherit
$C$DW$490 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxMutexHolder")
.dwattr $C$DW$490, DW_AT_TI_symbol_name("_pxMutexHolder")
.dwattr $C$DW$490, DW_AT_type(*$C$DW$T$107)
.dwattr $C$DW$490, DW_AT_location[DW_OP_reg17]
;*******************************************************************************
;* FUNCTION NAME: xTaskPriorityInherit *
;* *
;* Function Uses Regs : AC0,AC0,AC1,AC1,T0,AR0,XAR0,AR1,XAR1,AR2,AR3,XAR3,SP,*
;* CARRY,TC1,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 6 words *
;* (1 return address/alignment) *
;* (5 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_xTaskPriorityInherit:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-5, SP
.dwcfi cfa_offset, 6
$C$DW$491 .dwtag DW_TAG_variable, DW_AT_name("pxMutexHolder")
.dwattr $C$DW$491, DW_AT_TI_symbol_name("_pxMutexHolder")
.dwattr $C$DW$491, DW_AT_type(*$C$DW$T$107)
.dwattr $C$DW$491, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$492 .dwtag DW_TAG_variable, DW_AT_name("pxMutexHolderTCB")
.dwattr $C$DW$492, DW_AT_TI_symbol_name("_pxMutexHolderTCB")
.dwattr $C$DW$492, DW_AT_type(*$C$DW$T$160)
.dwattr $C$DW$492, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$493 .dwtag DW_TAG_variable, DW_AT_name("xReturn")
.dwattr $C$DW$493, DW_AT_TI_symbol_name("_xReturn")
.dwattr $C$DW$493, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$493, DW_AT_location[DW_OP_bregx 0x24 4]
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3911,column 16,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, dbl(*SP(#2))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3912,column 13,is_stmt
MOV #0, *SP(#4) ; |3912|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3917,column 3,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L218,AC0 == #0 ; |3917|
; branchcc occurs ; |3917|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3922,column 4,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV *AR3(#24), AR1 ; |3922|
MOV dbl(*SP(#2)), XAR3
MOV *AR3(#24), AR2 ; |3922|
CMPU AR2 >= AR1, TC1 ; |3922|
BCC $C$L217,TC1 ; |3922|
; branchcc occurs ; |3922|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3927,column 5,is_stmt
MOV dbl(*AR3(#14)), AC1 ; |3927|
MOV #-32768 << #16, AC0 ; |3927|
AND AC1, AC0 ; |3927|
BCC $C$L210,AC0 != #0 ; |3927|
; branchcc occurs ; |3927|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3929,column 6,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV #5, AC0 ; |3929|
SUB uns(*AR3(#24)), AC0, AC0 ; |3929|
MOV dbl(*SP(#2)), XAR3
MOV AC0, dbl(*AR3(#14)) ; |3929|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3930,column 5,is_stmt
$C$L210:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3938,column 5,is_stmt
MOV dbl(*SP(#2)), XAR3
MPYMK *AR3(#24), #10, AC0 ; |3938|
MOV AC0, AR1 ; |3938|
AMOV #_pxReadyTasksLists, XAR3 ; |3938|
AADD AR1, AR3 ; |3938|
MOV XAR3, AC0
MOV dbl(*SP(#2)), XAR3
MOV dbl(*AR3(#12)), XAR3
MOV XAR3, AC1
CMPU AC1 != AC0, TC1 ; |3938|
BCC $C$L211,TC1 ; |3938|
; branchcc occurs ; |3938|
MOV #1, AR1
B $C$L212 ; |3938|
; branch occurs ; |3938|
$C$L211:
MOV #0, AR1
$C$L212:
BCC $C$L215,AR1 == #0 ; |3938|
; branchcc occurs ; |3938|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3940,column 6,is_stmt
MOV dbl(*SP(#2)), XAR0
AADD #4, AR0 ; |3940|
$C$DW$494 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$494, DW_AT_low_pc(0x00)
.dwattr $C$DW$494, DW_AT_name("_uxListRemove")
.dwattr $C$DW$494, DW_AT_TI_call
CALL #_uxListRemove ; |3940|
; call occurs [#_uxListRemove] ; |3940|
BCC $C$L213,T0 == #0 ; |3940|
; branchcc occurs ; |3940|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3943,column 6,is_stmt
$C$L213:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3950,column 6,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV *AR3(#24), AR1 ; |3950|
MOV dbl(*SP(#2)), XAR3
MOV AR1, *AR3(#24) ; |3950|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3951,column 6,is_stmt
MOV dbl(*SP(#2)), XAR3
MOV *(#_uxTopReadyPriority), AR1 ; |3951|
MOV *AR3(#24), AR2 ; |3951|
CMPU AR2 <= AR1, TC1 ; |3951|
BCC $C$L214,TC1 ; |3951|
; branchcc occurs ; |3951|
MOV *AR3(#24), AR1 ; |3951|
MOV AR1, *(#_uxTopReadyPriority) ; |3951|
$C$L214:
MPYMK *AR3(#24), #10, AC0 ; |3951|
MOV AC0, AR1 ; |3951|
AMOV #_pxReadyTasksLists, XAR0 ; |3951|
AADD AR1, AR0 ; |3951|
MOV dbl(*SP(#2)), XAR1
AADD #4, AR1 ; |3951|
$C$DW$495 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$495, DW_AT_low_pc(0x00)
.dwattr $C$DW$495, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$495, DW_AT_TI_call
CALL #_vListInsertEnd ; |3951|
; call occurs [#_vListInsertEnd] ; |3951|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3952,column 5,is_stmt
B $C$L216 ; |3952|
; branch occurs ; |3952|
$C$L215:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3956,column 6,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV *AR3(#24), AR1 ; |3956|
MOV dbl(*SP(#2)), XAR3
MOV AR1, *AR3(#24) ; |3956|
$C$L216:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3962,column 5,is_stmt
MOV #1, *SP(#4) ; |3962|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3963,column 4,is_stmt
B $C$L218 ; |3963|
; branch occurs ; |3963|
$C$L217:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3966,column 5,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV *AR3(#24), AR1 ; |3966|
MOV dbl(*SP(#2)), XAR3
MOV *AR3(#43), AR2 ; |3966|
CMPU AR2 >= AR1, TC1 ; |3966|
BCC $C$L218,TC1 ; |3966|
; branchcc occurs ; |3966|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3975,column 6,is_stmt
MOV #1, *SP(#4) ; |3975|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3976,column 5,is_stmt
B $C$L218 ; |3976|
; branch occurs ; |3976|
$C$L218:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3988,column 3,is_stmt
MOV *SP(#4), T0 ; |3988|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3989,column 2,is_stmt
AADD #5, SP
.dwcfi cfa_offset, 1
$C$DW$496 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$496, DW_AT_low_pc(0x00)
.dwattr $C$DW$496, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$489, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$489, DW_AT_TI_end_line(0xf95)
.dwattr $C$DW$489, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$489
.sect ".text"
.align 4
.global _xTaskPriorityDisinherit
$C$DW$497 .dwtag DW_TAG_subprogram, DW_AT_name("xTaskPriorityDisinherit")
.dwattr $C$DW$497, DW_AT_low_pc(_xTaskPriorityDisinherit)
.dwattr $C$DW$497, DW_AT_high_pc(0x00)
.dwattr $C$DW$497, DW_AT_TI_symbol_name("_xTaskPriorityDisinherit")
.dwattr $C$DW$497, DW_AT_external
.dwattr $C$DW$497, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$497, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$497, DW_AT_TI_begin_line(0xf9c)
.dwattr $C$DW$497, DW_AT_TI_begin_column(0x0d)
.dwattr $C$DW$497, DW_AT_TI_max_frame_size(0x06)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3997,column 2,is_stmt,address _xTaskPriorityDisinherit
.dwfde $C$DW$CIE, _xTaskPriorityDisinherit
$C$DW$498 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxMutexHolder")
.dwattr $C$DW$498, DW_AT_TI_symbol_name("_pxMutexHolder")
.dwattr $C$DW$498, DW_AT_type(*$C$DW$T$107)
.dwattr $C$DW$498, DW_AT_location[DW_OP_reg17]
;*******************************************************************************
;* FUNCTION NAME: xTaskPriorityDisinherit *
;* *
;* Function Uses Regs : AC0,AC0,AC1,AC1,T0,AR0,XAR0,AR1,XAR1,AR2,AR3,XAR3,SP,*
;* CARRY,TC1,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 6 words *
;* (1 return address/alignment) *
;* (5 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_xTaskPriorityDisinherit:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-5, SP
.dwcfi cfa_offset, 6
$C$DW$499 .dwtag DW_TAG_variable, DW_AT_name("pxMutexHolder")
.dwattr $C$DW$499, DW_AT_TI_symbol_name("_pxMutexHolder")
.dwattr $C$DW$499, DW_AT_type(*$C$DW$T$107)
.dwattr $C$DW$499, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$500 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$500, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$500, DW_AT_type(*$C$DW$T$160)
.dwattr $C$DW$500, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$501 .dwtag DW_TAG_variable, DW_AT_name("xReturn")
.dwattr $C$DW$501, DW_AT_TI_symbol_name("_xReturn")
.dwattr $C$DW$501, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$501, DW_AT_location[DW_OP_bregx 0x24 4]
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3998,column 16,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, dbl(*SP(#2))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 3999,column 13,is_stmt
MOV #0, *SP(#4) ; |3999|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4001,column 3,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L226,AC0 == #0 ; |4001|
; branchcc occurs ; |4001|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4007,column 4,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV XAR3, AC0
MOV dbl(*SP(#2)), XAR3
MOV XAR3, AC1
CMPU AC1 != AC0, TC1 ; |4007|
MOV #0, AR1
BCC $C$L219,TC1 ; |4007|
; branchcc occurs ; |4007|
MOV #1, AR1
$C$L219:
BCC $C$L221,AR1 != #0 ; |4007|
; branchcc occurs ; |4007|
nop
bset INTM
$C$L220:
$C$DW$L$_xTaskPriorityDisinherit$6$B:
B $C$L220 ; |4007|
; branch occurs ; |4007|
$C$DW$L$_xTaskPriorityDisinherit$6$E:
$C$L221:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4008,column 4,is_stmt
MOV *AR3(#44), AR1 ; |4008|
BCC $C$L223,AR1 != #0 ; |4008|
; branchcc occurs ; |4008|
nop
bset INTM
$C$L222:
$C$DW$L$_xTaskPriorityDisinherit$9$B:
B $C$L222 ; |4008|
; branch occurs ; |4008|
$C$DW$L$_xTaskPriorityDisinherit$9$E:
$C$L223:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4009,column 4,is_stmt
SUB #1, *AR3(#44) ; |4009|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4013,column 4,is_stmt
MOV dbl(*SP(#2)), XAR3
MOV *AR3(#24), AR2 ; |4013|
MOV *AR3(#43), AR1 ; |4013|
CMPU AR2 == AR1, TC1 ; |4013|
BCC $C$L226,TC1 ; |4013|
; branchcc occurs ; |4013|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4016,column 5,is_stmt
MOV *AR3(#44), AR1 ; |4016|
BCC $C$L226,AR1 != #0 ; |4016|
; branchcc occurs ; |4016|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4023,column 6,is_stmt
MOV dbl(*SP(#2)), XAR0
AADD #4, AR0 ; |4023|
$C$DW$502 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$502, DW_AT_low_pc(0x00)
.dwattr $C$DW$502, DW_AT_name("_uxListRemove")
.dwattr $C$DW$502, DW_AT_TI_call
CALL #_uxListRemove ; |4023|
; call occurs [#_uxListRemove] ; |4023|
BCC $C$L224,T0 == #0 ; |4023|
; branchcc occurs ; |4023|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4026,column 6,is_stmt
$C$L224:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4035,column 6,is_stmt
MOV dbl(*SP(#2)), XAR3
MOV *AR3(#43), AR1 ; |4035|
MOV AR1, *AR3(#24) ; |4035|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4040,column 6,is_stmt
MOV dbl(*SP(#2)), XAR3
MOV #5, AC0 ; |4040|
SUB uns(*AR3(#24)), AC0, AC0 ; |4040|
MOV AC0, dbl(*AR3(#14)) ; |4040|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4041,column 6,is_stmt
MOV dbl(*SP(#2)), XAR3
MOV *(#_uxTopReadyPriority), AR1 ; |4041|
MOV *AR3(#24), AR2 ; |4041|
CMPU AR2 <= AR1, TC1 ; |4041|
BCC $C$L225,TC1 ; |4041|
; branchcc occurs ; |4041|
MOV *AR3(#24), AR1 ; |4041|
MOV AR1, *(#_uxTopReadyPriority) ; |4041|
$C$L225:
MPYMK *AR3(#24), #10, AC0 ; |4041|
MOV AC0, AR1 ; |4041|
AMOV #_pxReadyTasksLists, XAR0 ; |4041|
AADD AR1, AR0 ; |4041|
MOV dbl(*SP(#2)), XAR1
AADD #4, AR1 ; |4041|
$C$DW$503 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$503, DW_AT_low_pc(0x00)
.dwattr $C$DW$503, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$503, DW_AT_TI_call
CALL #_vListInsertEnd ; |4041|
; call occurs [#_vListInsertEnd] ; |4041|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4051,column 6,is_stmt
MOV #1, *SP(#4) ; |4051|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4052,column 5,is_stmt
B $C$L226 ; |4052|
; branch occurs ; |4052|
$C$L226:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4068,column 3,is_stmt
MOV *SP(#4), T0 ; |4068|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4069,column 2,is_stmt
AADD #5, SP
.dwcfi cfa_offset, 1
$C$DW$504 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$504, DW_AT_low_pc(0x00)
.dwattr $C$DW$504, DW_AT_TI_return
RET
; return occurs
$C$DW$505 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$505, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L222:1:1538833113")
.dwattr $C$DW$505, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$505, DW_AT_TI_begin_line(0xfa8)
.dwattr $C$DW$505, DW_AT_TI_end_line(0xfa8)
$C$DW$506 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$506, DW_AT_low_pc($C$DW$L$_xTaskPriorityDisinherit$9$B)
.dwattr $C$DW$506, DW_AT_high_pc($C$DW$L$_xTaskPriorityDisinherit$9$E)
.dwendtag $C$DW$505
$C$DW$507 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$507, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L220:1:1538833113")
.dwattr $C$DW$507, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$507, DW_AT_TI_begin_line(0xfa7)
.dwattr $C$DW$507, DW_AT_TI_end_line(0xfa7)
$C$DW$508 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$508, DW_AT_low_pc($C$DW$L$_xTaskPriorityDisinherit$6$B)
.dwattr $C$DW$508, DW_AT_high_pc($C$DW$L$_xTaskPriorityDisinherit$6$E)
.dwendtag $C$DW$507
.dwattr $C$DW$497, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$497, DW_AT_TI_end_line(0xfe5)
.dwattr $C$DW$497, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$497
.sect ".text"
.align 4
.global _vTaskPriorityDisinheritAfterTimeout
$C$DW$509 .dwtag DW_TAG_subprogram, DW_AT_name("vTaskPriorityDisinheritAfterTimeout")
.dwattr $C$DW$509, DW_AT_low_pc(_vTaskPriorityDisinheritAfterTimeout)
.dwattr $C$DW$509, DW_AT_high_pc(0x00)
.dwattr $C$DW$509, DW_AT_TI_symbol_name("_vTaskPriorityDisinheritAfterTimeout")
.dwattr $C$DW$509, DW_AT_external
.dwattr $C$DW$509, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$509, DW_AT_TI_begin_line(0xfec)
.dwattr $C$DW$509, DW_AT_TI_begin_column(0x07)
.dwattr $C$DW$509, DW_AT_TI_max_frame_size(0x0a)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4077,column 2,is_stmt,address _vTaskPriorityDisinheritAfterTimeout
.dwfde $C$DW$CIE, _vTaskPriorityDisinheritAfterTimeout
$C$DW$510 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxMutexHolder")
.dwattr $C$DW$510, DW_AT_TI_symbol_name("_pxMutexHolder")
.dwattr $C$DW$510, DW_AT_type(*$C$DW$T$107)
.dwattr $C$DW$510, DW_AT_location[DW_OP_reg17]
$C$DW$511 .dwtag DW_TAG_formal_parameter, DW_AT_name("uxHighestPriorityWaitingTask")
.dwattr $C$DW$511, DW_AT_TI_symbol_name("_uxHighestPriorityWaitingTask")
.dwattr $C$DW$511, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$511, DW_AT_location[DW_OP_reg12]
;*******************************************************************************
;* FUNCTION NAME: vTaskPriorityDisinheritAfterTimeout *
;* *
;* Function Uses Regs : AC0,AC0,AC1,AC1,T0,AR0,XAR0,AR1,XAR1,AR2,AR3,XAR3,SP,*
;* CARRY,TC1,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 10 words *
;* (1 return address/alignment) *
;* (9 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_vTaskPriorityDisinheritAfterTimeout:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-9, SP
.dwcfi cfa_offset, 10
$C$DW$512 .dwtag DW_TAG_variable, DW_AT_name("pxMutexHolder")
.dwattr $C$DW$512, DW_AT_TI_symbol_name("_pxMutexHolder")
.dwattr $C$DW$512, DW_AT_type(*$C$DW$T$107)
.dwattr $C$DW$512, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$513 .dwtag DW_TAG_variable, DW_AT_name("uxHighestPriorityWaitingTask")
.dwattr $C$DW$513, DW_AT_TI_symbol_name("_uxHighestPriorityWaitingTask")
.dwattr $C$DW$513, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$513, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$514 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$514, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$514, DW_AT_type(*$C$DW$T$160)
.dwattr $C$DW$514, DW_AT_location[DW_OP_bregx 0x24 4]
$C$DW$515 .dwtag DW_TAG_variable, DW_AT_name("uxPriorityUsedOnEntry")
.dwattr $C$DW$515, DW_AT_TI_symbol_name("_uxPriorityUsedOnEntry")
.dwattr $C$DW$515, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$515, DW_AT_location[DW_OP_bregx 0x24 6]
$C$DW$516 .dwtag DW_TAG_variable, DW_AT_name("uxPriorityToUse")
.dwattr $C$DW$516, DW_AT_TI_symbol_name("_uxPriorityToUse")
.dwattr $C$DW$516, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$516, DW_AT_location[DW_OP_bregx 0x24 7]
$C$DW$517 .dwtag DW_TAG_variable, DW_AT_name("uxOnlyOneMutexHeld")
.dwattr $C$DW$517, DW_AT_TI_symbol_name("_uxOnlyOneMutexHeld")
.dwattr $C$DW$517, DW_AT_type(*$C$DW$T$137)
.dwattr $C$DW$517, DW_AT_location[DW_OP_bregx 0x24 8]
MOV T0, *SP(#2) ; |4077|
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4078,column 16,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, dbl(*SP(#4))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4080,column 20,is_stmt
MOV #1, *SP(#8) ; |4080|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4082,column 3,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L239,AC0 == #0 ; |4082|
; branchcc occurs ; |4082|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4086,column 4,is_stmt
MOV dbl(*SP(#4)), XAR3
MOV *AR3(#44), AR1 ; |4086|
BCC $C$L228,AR1 != #0 ; |4086|
; branchcc occurs ; |4086|
nop
bset INTM
$C$L227:
$C$DW$L$_vTaskPriorityDisinheritAfterTimeout$4$B:
B $C$L227 ; |4086|
; branch occurs ; |4086|
$C$DW$L$_vTaskPriorityDisinheritAfterTimeout$4$E:
$C$L228:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4092,column 4,is_stmt
MOV *SP(#2), AR1 ; |4092|
MOV *AR3(#43), AR2 ; |4092|
CMPU AR2 >= AR1, TC1 ; |4092|
BCC $C$L229,TC1 ; |4092|
; branchcc occurs ; |4092|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4094,column 5,is_stmt
MOV AR1, *SP(#7) ; |4094|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4095,column 4,is_stmt
B $C$L230 ; |4095|
; branch occurs ; |4095|
$C$L229:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4098,column 5,is_stmt
MOV *AR3(#43), AR1 ; |4098|
MOV AR1, *SP(#7) ; |4098|
$C$L230:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4102,column 4,is_stmt
MOV dbl(*SP(#4)), XAR3
MOV *AR3(#24), AR2 ; |4102|
CMPU AR2 == AR1, TC1 ; |4102|
BCC $C$L239,TC1 ; |4102|
; branchcc occurs ; |4102|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4108,column 5,is_stmt
MOV *SP(#8), AR1 ; |4108|
MOV *AR3(#44), AR2 ; |4108|
CMPU AR2 != AR1, TC1 ; |4108|
BCC $C$L239,TC1 ; |4108|
; branchcc occurs ; |4108|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4113,column 6,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV XAR3, AC0
MOV dbl(*SP(#4)), XAR3
MOV XAR3, AC1
CMPU AC1 == AC0, TC1 ; |4113|
MOV #0, AR1
BCC $C$L231,TC1 ; |4113|
; branchcc occurs ; |4113|
MOV #1, AR1
$C$L231:
BCC $C$L233,AR1 != #0 ; |4113|
; branchcc occurs ; |4113|
nop
bset INTM
$C$L232:
$C$DW$L$_vTaskPriorityDisinheritAfterTimeout$14$B:
B $C$L232 ; |4113|
; branch occurs ; |4113|
$C$DW$L$_vTaskPriorityDisinheritAfterTimeout$14$E:
$C$L233:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4119,column 6,is_stmt
MOV *AR3(#24), AR1 ; |4119|
MOV AR1, *SP(#6) ; |4119|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4120,column 6,is_stmt
MOV dbl(*SP(#4)), XAR3
MOV *SP(#7), AR1 ; |4120|
MOV AR1, *AR3(#24) ; |4120|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4124,column 6,is_stmt
MOV dbl(*SP(#4)), XAR3
MOV #-32768 << #16, AC0 ; |4124|
MOV dbl(*AR3(#14)), AC1 ; |4124|
AND AC1, AC0 ; |4124|
BCC $C$L234,AC0 != #0 ; |4124|
; branchcc occurs ; |4124|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4126,column 7,is_stmt
MOV #5, AC0 ; |4126|
SUB uns(*SP(#7)), AC0, AC0 ; |4126|
MOV AC0, dbl(*AR3(#14)) ; |4126|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4127,column 6,is_stmt
$C$L234:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4139,column 6,is_stmt
MPYMK *SP(#6), #10, AC1 ; |4139|
MOV AC1, AR1 ; |4139|
AMOV #_pxReadyTasksLists, XAR3 ; |4139|
AADD AR1, AR3 ; |4139|
MOV XAR3, AC0
MOV dbl(*SP(#4)), XAR3
MOV dbl(*AR3(#12)), XAR3
MOV XAR3, AC1
CMPU AC1 != AC0, TC1 ; |4139|
BCC $C$L235,TC1 ; |4139|
; branchcc occurs ; |4139|
MOV #1, AR1
B $C$L236 ; |4139|
; branch occurs ; |4139|
$C$L235:
MOV #0, AR1
$C$L236:
BCC $C$L239,AR1 == #0 ; |4139|
; branchcc occurs ; |4139|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4141,column 7,is_stmt
MOV dbl(*SP(#4)), XAR0
AADD #4, AR0 ; |4141|
$C$DW$518 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$518, DW_AT_low_pc(0x00)
.dwattr $C$DW$518, DW_AT_name("_uxListRemove")
.dwattr $C$DW$518, DW_AT_TI_call
CALL #_uxListRemove ; |4141|
; call occurs [#_uxListRemove] ; |4141|
BCC $C$L237,T0 == #0 ; |4141|
; branchcc occurs ; |4141|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4144,column 7,is_stmt
$C$L237:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4150,column 7,is_stmt
MOV dbl(*SP(#4)), XAR3
MOV *(#_uxTopReadyPriority), AR1 ; |4150|
MOV *AR3(#24), AR2 ; |4150|
CMPU AR2 <= AR1, TC1 ; |4150|
BCC $C$L238,TC1 ; |4150|
; branchcc occurs ; |4150|
MOV *AR3(#24), AR1 ; |4150|
MOV AR1, *(#_uxTopReadyPriority) ; |4150|
$C$L238:
MPYMK *AR3(#24), #10, AC0 ; |4150|
MOV AC0, AR1 ; |4150|
AMOV #_pxReadyTasksLists, XAR0 ; |4150|
AADD AR1, AR0 ; |4150|
MOV dbl(*SP(#4)), XAR1
AADD #4, AR1 ; |4150|
$C$DW$519 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$519, DW_AT_low_pc(0x00)
.dwattr $C$DW$519, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$519, DW_AT_TI_call
CALL #_vListInsertEnd ; |4150|
; call occurs [#_vListInsertEnd] ; |4150|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4151,column 6,is_stmt
B $C$L239 ; |4151|
; branch occurs ; |4151|
$C$L239:
AADD #9, SP
.dwcfi cfa_offset, 1
$C$DW$520 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$520, DW_AT_low_pc(0x00)
.dwattr $C$DW$520, DW_AT_TI_return
RET
; return occurs
$C$DW$521 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$521, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L232:1:1538833113")
.dwattr $C$DW$521, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$521, DW_AT_TI_begin_line(0x1011)
.dwattr $C$DW$521, DW_AT_TI_end_line(0x1011)
$C$DW$522 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$522, DW_AT_low_pc($C$DW$L$_vTaskPriorityDisinheritAfterTimeout$14$B)
.dwattr $C$DW$522, DW_AT_high_pc($C$DW$L$_vTaskPriorityDisinheritAfterTimeout$14$E)
.dwendtag $C$DW$521
$C$DW$523 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$523, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L227:1:1538833113")
.dwattr $C$DW$523, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$523, DW_AT_TI_begin_line(0xff6)
.dwattr $C$DW$523, DW_AT_TI_end_line(0xff6)
$C$DW$524 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$524, DW_AT_low_pc($C$DW$L$_vTaskPriorityDisinheritAfterTimeout$4$B)
.dwattr $C$DW$524, DW_AT_high_pc($C$DW$L$_vTaskPriorityDisinheritAfterTimeout$4$E)
.dwendtag $C$DW$523
.dwattr $C$DW$509, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$509, DW_AT_TI_end_line(0x104b)
.dwattr $C$DW$509, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$509
.sect ".text"
.align 4
.global _vTaskEnterCritical
$C$DW$525 .dwtag DW_TAG_subprogram, DW_AT_name("vTaskEnterCritical")
.dwattr $C$DW$525, DW_AT_low_pc(_vTaskEnterCritical)
.dwattr $C$DW$525, DW_AT_high_pc(0x00)
.dwattr $C$DW$525, DW_AT_TI_symbol_name("_vTaskEnterCritical")
.dwattr $C$DW$525, DW_AT_external
.dwattr $C$DW$525, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$525, DW_AT_TI_begin_line(0x1052)
.dwattr $C$DW$525, DW_AT_TI_begin_column(0x07)
.dwattr $C$DW$525, DW_AT_TI_max_frame_size(0x01)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4179,column 2,is_stmt,address _vTaskEnterCritical
.dwfde $C$DW$CIE, _vTaskEnterCritical
;*******************************************************************************
;* FUNCTION NAME: vTaskEnterCritical *
;* *
;* Function Uses Regs : AR1,AR3,XAR3,SP,CARRY,TC1,M40,SATA,SATD,RDM,FRCT, *
;* SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 1 word *
;* (1 return address/alignment) *
;* Min System Stack : 1 word *
;*******************************************************************************
_vTaskEnterCritical:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4180,column 3,is_stmt
nop
bset INTM
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4182,column 3,is_stmt
MOV *(#_xSchedulerRunning), AR1 ; |4182|
BCC $C$L240,AR1 == #0 ; |4182|
; branchcc occurs ; |4182|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4184,column 4,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
AADD #42, AR3 ; |4184|
ADD #1, *AR3 ; |4184|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4192,column 4,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
CMP *AR3(#42) == #1, TC1 ; |4192|
BCC $C$L240,TC1 ; |4192|
; branchcc occurs ; |4192|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4196,column 3,is_stmt
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4201,column 2,is_stmt
$C$L240:
$C$DW$526 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$526, DW_AT_low_pc(0x00)
.dwattr $C$DW$526, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$525, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$525, DW_AT_TI_end_line(0x1069)
.dwattr $C$DW$525, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$525
.sect ".text"
.align 4
.global _vTaskExitCritical
$C$DW$527 .dwtag DW_TAG_subprogram, DW_AT_name("vTaskExitCritical")
.dwattr $C$DW$527, DW_AT_low_pc(_vTaskExitCritical)
.dwattr $C$DW$527, DW_AT_high_pc(0x00)
.dwattr $C$DW$527, DW_AT_TI_symbol_name("_vTaskExitCritical")
.dwattr $C$DW$527, DW_AT_external
.dwattr $C$DW$527, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$527, DW_AT_TI_begin_line(0x1070)
.dwattr $C$DW$527, DW_AT_TI_begin_column(0x07)
.dwattr $C$DW$527, DW_AT_TI_max_frame_size(0x01)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4209,column 2,is_stmt,address _vTaskExitCritical
.dwfde $C$DW$CIE, _vTaskExitCritical
;*******************************************************************************
;* FUNCTION NAME: vTaskExitCritical *
;* *
;* Function Uses Regs : AR1,AR3,XAR3,SP,CARRY,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 1 word *
;* (1 return address/alignment) *
;* Min System Stack : 1 word *
;*******************************************************************************
_vTaskExitCritical:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4210,column 3,is_stmt
MOV *(#_xSchedulerRunning), AR1 ; |4210|
BCC $C$L241,AR1 == #0 ; |4210|
; branchcc occurs ; |4210|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4212,column 4,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV *AR3(#42), AR1 ; |4212|
BCC $C$L241,AR1 == #0 ; |4212|
; branchcc occurs ; |4212|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4214,column 5,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
AADD #42, AR3 ; |4214|
SUB #1, *AR3 ; |4214|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4216,column 5,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV *AR3(#42), AR1 ; |4216|
BCC $C$L241,AR1 != #0 ; |4216|
; branchcc occurs ; |4216|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4218,column 6,is_stmt
nop
bclr INTM
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4219,column 5,is_stmt
B $C$L241 ; |4219|
; branch occurs ; |4219|
$C$L241:
$C$DW$528 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$528, DW_AT_low_pc(0x00)
.dwattr $C$DW$528, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$527, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$527, DW_AT_TI_end_line(0x108a)
.dwattr $C$DW$527, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$527
.sect ".text"
.align 4
.global _uxTaskResetEventItemValue
$C$DW$529 .dwtag DW_TAG_subprogram, DW_AT_name("uxTaskResetEventItemValue")
.dwattr $C$DW$529, DW_AT_low_pc(_uxTaskResetEventItemValue)
.dwattr $C$DW$529, DW_AT_high_pc(0x00)
.dwattr $C$DW$529, DW_AT_TI_symbol_name("_uxTaskResetEventItemValue")
.dwattr $C$DW$529, DW_AT_external
.dwattr $C$DW$529, DW_AT_type(*$C$DW$T$37)
.dwattr $C$DW$529, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$529, DW_AT_TI_begin_line(0x118b)
.dwattr $C$DW$529, DW_AT_TI_begin_column(0x0c)
.dwattr $C$DW$529, DW_AT_TI_max_frame_size(0x04)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4492,column 1,is_stmt,address _uxTaskResetEventItemValue
.dwfde $C$DW$CIE, _uxTaskResetEventItemValue
;*******************************************************************************
;* FUNCTION NAME: uxTaskResetEventItemValue *
;* *
;* Function Uses Regs : AC0,AC0,AR3,XAR3,SP,CARRY,M40,SATA,SATD,RDM,FRCT, *
;* SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 4 words *
;* (2 return address/alignment) *
;* (2 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_uxTaskResetEventItemValue:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-3, SP
.dwcfi cfa_offset, 4
$C$DW$530 .dwtag DW_TAG_variable, DW_AT_name("uxReturn")
.dwattr $C$DW$530, DW_AT_TI_symbol_name("_uxReturn")
.dwattr $C$DW$530, DW_AT_type(*$C$DW$T$37)
.dwattr $C$DW$530, DW_AT_location[DW_OP_bregx 0x24 0]
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4495,column 2,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV dbl(*AR3(#14)), AC0 ; |4495|
MOV AC0, dbl(*SP(#0)) ; |4495|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4499,column 2,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV #5, AC0 ; |4499|
SUB uns(*AR3(#24)), AC0, AC0 ; |4499|
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV AC0, dbl(*AR3(#14)) ; |4499|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4501,column 2,is_stmt
MOV dbl(*SP(#0)), AC0 ; |4501|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4502,column 1,is_stmt
AADD #3, SP
.dwcfi cfa_offset, 1
$C$DW$531 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$531, DW_AT_low_pc(0x00)
.dwattr $C$DW$531, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$529, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$529, DW_AT_TI_end_line(0x1196)
.dwattr $C$DW$529, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$529
.sect ".text"
.align 4
.global _pvTaskIncrementMutexHeldCount
$C$DW$532 .dwtag DW_TAG_subprogram, DW_AT_name("pvTaskIncrementMutexHeldCount")
.dwattr $C$DW$532, DW_AT_low_pc(_pvTaskIncrementMutexHeldCount)
.dwattr $C$DW$532, DW_AT_high_pc(0x00)
.dwattr $C$DW$532, DW_AT_TI_symbol_name("_pvTaskIncrementMutexHeldCount")
.dwattr $C$DW$532, DW_AT_external
.dwattr $C$DW$532, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$532, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$532, DW_AT_TI_begin_line(0x119b)
.dwattr $C$DW$532, DW_AT_TI_begin_column(0x0f)
.dwattr $C$DW$532, DW_AT_TI_max_frame_size(0x01)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4508,column 2,is_stmt,address _pvTaskIncrementMutexHeldCount
.dwfde $C$DW$CIE, _pvTaskIncrementMutexHeldCount
;*******************************************************************************
;* FUNCTION NAME: pvTaskIncrementMutexHeldCount *
;* *
;* Function Uses Regs : AC0,AC0,AR0,XAR0,AR3,XAR3,SP,CARRY,M40,SATA,SATD,RDM,*
;* FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 1 word *
;* (1 return address/alignment) *
;* Min System Stack : 1 word *
;*******************************************************************************
_pvTaskIncrementMutexHeldCount:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4511,column 3,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV XAR3, AC0
BCC $C$L242,AC0 == #0 ; |4511|
; branchcc occurs ; |4511|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4513,column 4,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
AADD #44, AR3 ; |4513|
ADD #1, *AR3 ; |4513|
$C$L242:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4516,column 3,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR0
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4517,column 2,is_stmt
$C$DW$533 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$533, DW_AT_low_pc(0x00)
.dwattr $C$DW$533, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$532, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$532, DW_AT_TI_end_line(0x11a5)
.dwattr $C$DW$532, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$532
.sect ".text"
.align 4
.global _ulTaskNotifyTake
$C$DW$534 .dwtag DW_TAG_subprogram, DW_AT_name("ulTaskNotifyTake")
.dwattr $C$DW$534, DW_AT_low_pc(_ulTaskNotifyTake)
.dwattr $C$DW$534, DW_AT_high_pc(0x00)
.dwattr $C$DW$534, DW_AT_TI_symbol_name("_ulTaskNotifyTake")
.dwattr $C$DW$534, DW_AT_external
.dwattr $C$DW$534, DW_AT_type(*$C$DW$T$28)
.dwattr $C$DW$534, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$534, DW_AT_TI_begin_line(0x11ac)
.dwattr $C$DW$534, DW_AT_TI_begin_column(0x0b)
.dwattr $C$DW$534, DW_AT_TI_max_frame_size(0x08)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4525,column 2,is_stmt,address _ulTaskNotifyTake
.dwfde $C$DW$CIE, _ulTaskNotifyTake
$C$DW$535 .dwtag DW_TAG_formal_parameter, DW_AT_name("xClearCountOnExit")
.dwattr $C$DW$535, DW_AT_TI_symbol_name("_xClearCountOnExit")
.dwattr $C$DW$535, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$535, DW_AT_location[DW_OP_reg12]
$C$DW$536 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTicksToWait")
.dwattr $C$DW$536, DW_AT_TI_symbol_name("_xTicksToWait")
.dwattr $C$DW$536, DW_AT_type(*$C$DW$T$37)
.dwattr $C$DW$536, DW_AT_location[DW_OP_reg0]
;*******************************************************************************
;* FUNCTION NAME: ulTaskNotifyTake *
;* *
;* Function Uses Regs : AC0,AC0,T0,AR1,AR3,XAR3,SP,CARRY,M40,SATA,SATD,RDM, *
;* FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 8 words *
;* (2 return address/alignment) *
;* (6 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_ulTaskNotifyTake:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-7, SP
.dwcfi cfa_offset, 8
$C$DW$537 .dwtag DW_TAG_variable, DW_AT_name("xClearCountOnExit")
.dwattr $C$DW$537, DW_AT_TI_symbol_name("_xClearCountOnExit")
.dwattr $C$DW$537, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$537, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$538 .dwtag DW_TAG_variable, DW_AT_name("xTicksToWait")
.dwattr $C$DW$538, DW_AT_TI_symbol_name("_xTicksToWait")
.dwattr $C$DW$538, DW_AT_type(*$C$DW$T$37)
.dwattr $C$DW$538, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$539 .dwtag DW_TAG_variable, DW_AT_name("ulReturn")
.dwattr $C$DW$539, DW_AT_TI_symbol_name("_ulReturn")
.dwattr $C$DW$539, DW_AT_type(*$C$DW$T$28)
.dwattr $C$DW$539, DW_AT_location[DW_OP_bregx 0x24 4]
MOV AC0, dbl(*SP(#2)) ; |4525|
MOV T0, *SP(#0) ; |4525|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4528,column 3,is_stmt
nop
bset INTM
ADD #1, *(#_usCriticalNesting) ; |4528|
NOP
NOP
NOP
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4531,column 4,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV dbl(*AR3(#46)), AC0 ; |4531|
BCC $C$L243,AC0 != #0 ; |4531|
; branchcc occurs ; |4531|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4534,column 5,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV #1, *AR3(#48) ; |4534|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4536,column 5,is_stmt
MOV dbl(*SP(#2)), AC0 ; |4536|
BCC $C$L243,AC0 == #0 ; |4536|
; branchcc occurs ; |4536|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4538,column 6,is_stmt
MOV dbl(*SP(#2)), AC0 ; |4538|
$C$DW$540 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$540, DW_AT_low_pc(0x00)
.dwattr $C$DW$540, DW_AT_name("_prvAddCurrentTaskToDelayedList")
.dwattr $C$DW$540, DW_AT_TI_call
CALL #_prvAddCurrentTaskToDelayedList ; |4538|
|| MOV #1, T0
; call occurs [#_prvAddCurrentTaskToDelayedList] ; |4538|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4545,column 6,is_stmt
$C$DW$541 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$541, DW_AT_low_pc(0x00)
.dwattr $C$DW$541, DW_AT_name("_vPortYield")
.dwattr $C$DW$541, DW_AT_TI_call
CALL #_vPortYield ; |4545|
; call occurs [#_vPortYield] ; |4545|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4546,column 5,is_stmt
B $C$L243 ; |4546|
; branch occurs ; |4546|
$C$L243:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4557,column 3,is_stmt
MOV *(#_usCriticalNesting), AR1 ; |4557|
BCC $C$L244,AR1 == #0 ; |4557|
; branchcc occurs ; |4557|
SUB #1, *(#_usCriticalNesting) ; |4557|
NOP
NOP
NOP
MOV *(#_usCriticalNesting), AR1 ; |4557|
BCC $C$L244,AR1 != #0 ; |4557|
; branchcc occurs ; |4557|
nop
bclr INTM
$C$L244:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4559,column 3,is_stmt
nop
bset INTM
ADD #1, *(#_usCriticalNesting) ; |4559|
NOP
NOP
NOP
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4562,column 4,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV dbl(*AR3(#46)), AC0 ; |4562|
MOV AC0, dbl(*SP(#4)) ; |4562|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4564,column 4,is_stmt
MOV dbl(*SP(#4)), AC0 ; |4564|
BCC $C$L246,AC0 == #0 ; |4564|
; branchcc occurs ; |4564|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4566,column 5,is_stmt
MOV *SP(#0), AR1 ; |4566|
BCC $C$L245,AR1 == #0 ; |4566|
; branchcc occurs ; |4566|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4568,column 6,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV #0, AC0 ; |4568|
MOV AC0, dbl(*AR3(#46)) ; |4568|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4569,column 5,is_stmt
B $C$L246 ; |4569|
; branch occurs ; |4569|
$C$L245:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4572,column 6,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV dbl(*SP(#4)), AC0 ; |4572|
SUB #1, AC0 ; |4572|
MOV AC0, dbl(*AR3(#46)) ; |4572|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4574,column 4,is_stmt
$C$L246:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4580,column 4,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV #0, *AR3(#48) ; |4580|
NOP
NOP
NOP
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4582,column 3,is_stmt
MOV *(#_usCriticalNesting), AR1 ; |4582|
BCC $C$L247,AR1 == #0 ; |4582|
; branchcc occurs ; |4582|
SUB #1, *(#_usCriticalNesting) ; |4582|
NOP
NOP
NOP
MOV *(#_usCriticalNesting), AR1 ; |4582|
BCC $C$L247,AR1 != #0 ; |4582|
; branchcc occurs ; |4582|
nop
bclr INTM
$C$L247:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4584,column 3,is_stmt
MOV dbl(*SP(#4)), AC0 ; |4584|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4585,column 2,is_stmt
AADD #7, SP
.dwcfi cfa_offset, 1
$C$DW$542 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$542, DW_AT_low_pc(0x00)
.dwattr $C$DW$542, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$534, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$534, DW_AT_TI_end_line(0x11e9)
.dwattr $C$DW$534, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$534
.sect ".text"
.align 4
.global _xTaskNotifyWait
$C$DW$543 .dwtag DW_TAG_subprogram, DW_AT_name("xTaskNotifyWait")
.dwattr $C$DW$543, DW_AT_low_pc(_xTaskNotifyWait)
.dwattr $C$DW$543, DW_AT_high_pc(0x00)
.dwattr $C$DW$543, DW_AT_TI_symbol_name("_xTaskNotifyWait")
.dwattr $C$DW$543, DW_AT_external
.dwattr $C$DW$543, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$543, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$543, DW_AT_TI_begin_line(0x11f0)
.dwattr $C$DW$543, DW_AT_TI_begin_column(0x0d)
.dwattr $C$DW$543, DW_AT_TI_max_frame_size(0x0a)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4593,column 2,is_stmt,address _xTaskNotifyWait
.dwfde $C$DW$CIE, _xTaskNotifyWait
$C$DW$544 .dwtag DW_TAG_formal_parameter, DW_AT_name("ulBitsToClearOnEntry")
.dwattr $C$DW$544, DW_AT_TI_symbol_name("_ulBitsToClearOnEntry")
.dwattr $C$DW$544, DW_AT_type(*$C$DW$T$28)
.dwattr $C$DW$544, DW_AT_location[DW_OP_reg0]
$C$DW$545 .dwtag DW_TAG_formal_parameter, DW_AT_name("ulBitsToClearOnExit")
.dwattr $C$DW$545, DW_AT_TI_symbol_name("_ulBitsToClearOnExit")
.dwattr $C$DW$545, DW_AT_type(*$C$DW$T$28)
.dwattr $C$DW$545, DW_AT_location[DW_OP_reg3]
$C$DW$546 .dwtag DW_TAG_formal_parameter, DW_AT_name("pulNotificationValue")
.dwattr $C$DW$546, DW_AT_TI_symbol_name("_pulNotificationValue")
.dwattr $C$DW$546, DW_AT_type(*$C$DW$T$133)
.dwattr $C$DW$546, DW_AT_location[DW_OP_reg17]
$C$DW$547 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTicksToWait")
.dwattr $C$DW$547, DW_AT_TI_symbol_name("_xTicksToWait")
.dwattr $C$DW$547, DW_AT_type(*$C$DW$T$37)
.dwattr $C$DW$547, DW_AT_location[DW_OP_reg6]
;*******************************************************************************
;* FUNCTION NAME: xTaskNotifyWait *
;* *
;* Function Uses Regs : AC0,AC0,AC1,AC1,AC2,AC2,T0,AR0,XAR0,AR1,AR2,XAR2,AR3,*
;* XAR3,SP,CARRY,TC1,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 10 words *
;* (1 return address/alignment) *
;* (9 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_xTaskNotifyWait:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-9, SP
.dwcfi cfa_offset, 10
$C$DW$548 .dwtag DW_TAG_variable, DW_AT_name("ulBitsToClearOnEntry")
.dwattr $C$DW$548, DW_AT_TI_symbol_name("_ulBitsToClearOnEntry")
.dwattr $C$DW$548, DW_AT_type(*$C$DW$T$28)
.dwattr $C$DW$548, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$549 .dwtag DW_TAG_variable, DW_AT_name("ulBitsToClearOnExit")
.dwattr $C$DW$549, DW_AT_TI_symbol_name("_ulBitsToClearOnExit")
.dwattr $C$DW$549, DW_AT_type(*$C$DW$T$28)
.dwattr $C$DW$549, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$550 .dwtag DW_TAG_variable, DW_AT_name("pulNotificationValue")
.dwattr $C$DW$550, DW_AT_TI_symbol_name("_pulNotificationValue")
.dwattr $C$DW$550, DW_AT_type(*$C$DW$T$133)
.dwattr $C$DW$550, DW_AT_location[DW_OP_bregx 0x24 4]
$C$DW$551 .dwtag DW_TAG_variable, DW_AT_name("xTicksToWait")
.dwattr $C$DW$551, DW_AT_TI_symbol_name("_xTicksToWait")
.dwattr $C$DW$551, DW_AT_type(*$C$DW$T$37)
.dwattr $C$DW$551, DW_AT_location[DW_OP_bregx 0x24 6]
$C$DW$552 .dwtag DW_TAG_variable, DW_AT_name("xReturn")
.dwattr $C$DW$552, DW_AT_TI_symbol_name("_xReturn")
.dwattr $C$DW$552, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$552, DW_AT_location[DW_OP_bregx 0x24 8]
MOV AC2, dbl(*SP(#6)) ; |4593|
MOV XAR0, dbl(*SP(#4))
MOV AC1, dbl(*SP(#2)) ; |4593|
MOV AC0, dbl(*SP(#0)) ; |4593|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4596,column 3,is_stmt
nop
bset INTM
ADD #1, *(#_usCriticalNesting) ; |4596|
NOP
NOP
NOP
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4599,column 4,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
CMP *AR3(#48) == #2, TC1 ; |4599|
BCC $C$L248,TC1 ; |4599|
; branchcc occurs ; |4599|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4604,column 5,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
AADD #46, AR3 ; |4604|
|| MOV dbl(*SP(#0)), AC0 ; |4604|
MOV dbl(*AR3), AC1 ; |4604|
|| NOT AC0, AC0 ; |4604|
AND AC1, AC0 ; |4604|
MOV AC0, dbl(*AR3) ; |4604|
NOP
NOP
NOP
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4607,column 5,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV #1, *AR3(#48) ; |4607|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4609,column 5,is_stmt
MOV dbl(*SP(#6)), AC0 ; |4609|
BCC $C$L248,AC0 == #0 ; |4609|
; branchcc occurs ; |4609|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4611,column 6,is_stmt
MOV dbl(*SP(#6)), AC0 ; |4611|
$C$DW$553 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$553, DW_AT_low_pc(0x00)
.dwattr $C$DW$553, DW_AT_name("_prvAddCurrentTaskToDelayedList")
.dwattr $C$DW$553, DW_AT_TI_call
CALL #_prvAddCurrentTaskToDelayedList ; |4611|
|| MOV #1, T0
; call occurs [#_prvAddCurrentTaskToDelayedList] ; |4611|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4618,column 6,is_stmt
$C$DW$554 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$554, DW_AT_low_pc(0x00)
.dwattr $C$DW$554, DW_AT_name("_vPortYield")
.dwattr $C$DW$554, DW_AT_TI_call
CALL #_vPortYield ; |4618|
; call occurs [#_vPortYield] ; |4618|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4619,column 5,is_stmt
B $C$L248 ; |4619|
; branch occurs ; |4619|
$C$L248:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4630,column 3,is_stmt
MOV *(#_usCriticalNesting), AR1 ; |4630|
BCC $C$L249,AR1 == #0 ; |4630|
; branchcc occurs ; |4630|
SUB #1, *(#_usCriticalNesting) ; |4630|
NOP
NOP
NOP
MOV *(#_usCriticalNesting), AR1 ; |4630|
BCC $C$L249,AR1 != #0 ; |4630|
; branchcc occurs ; |4630|
nop
bclr INTM
$C$L249:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4632,column 3,is_stmt
nop
bset INTM
ADD #1, *(#_usCriticalNesting) ; |4632|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4636,column 4,is_stmt
MOV dbl(*SP(#4)), XAR3
MOV XAR3, AC0
BCC $C$L250,AC0 == #0 ; |4636|
; branchcc occurs ; |4636|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4640,column 5,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV dbl(*SP(#4)), XAR2
AADD #46, AR3 ; |4640|
MOV dbl(*AR3), dbl(*AR2) ; |4640|
$C$L250:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4647,column 4,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
CMP *AR3(#48) == #2, TC1 ; |4647|
BCC $C$L251,TC1 ; |4647|
; branchcc occurs ; |4647|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4650,column 5,is_stmt
MOV #0, *SP(#8) ; |4650|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4651,column 4,is_stmt
B $C$L252 ; |4651|
; branch occurs ; |4651|
$C$L251:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4656,column 5,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
AADD #46, AR3 ; |4656|
|| MOV dbl(*SP(#2)), AC0 ; |4656|
MOV dbl(*AR3), AC1 ; |4656|
|| NOT AC0, AC0 ; |4656|
AND AC1, AC0 ; |4656|
MOV AC0, dbl(*AR3) ; |4656|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4657,column 5,is_stmt
MOV #1, *SP(#8) ; |4657|
$C$L252:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4660,column 4,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV #0, *AR3(#48) ; |4660|
NOP
NOP
NOP
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4662,column 3,is_stmt
MOV *(#_usCriticalNesting), AR1 ; |4662|
BCC $C$L253,AR1 == #0 ; |4662|
; branchcc occurs ; |4662|
SUB #1, *(#_usCriticalNesting) ; |4662|
NOP
NOP
NOP
MOV *(#_usCriticalNesting), AR1 ; |4662|
BCC $C$L253,AR1 != #0 ; |4662|
; branchcc occurs ; |4662|
nop
bclr INTM
$C$L253:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4664,column 3,is_stmt
MOV *SP(#8), T0 ; |4664|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4665,column 2,is_stmt
AADD #9, SP
.dwcfi cfa_offset, 1
$C$DW$555 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$555, DW_AT_low_pc(0x00)
.dwattr $C$DW$555, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$543, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$543, DW_AT_TI_end_line(0x1239)
.dwattr $C$DW$543, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$543
.sect ".text"
.align 4
.global _xTaskGenericNotify
$C$DW$556 .dwtag DW_TAG_subprogram, DW_AT_name("xTaskGenericNotify")
.dwattr $C$DW$556, DW_AT_low_pc(_xTaskGenericNotify)
.dwattr $C$DW$556, DW_AT_high_pc(0x00)
.dwattr $C$DW$556, DW_AT_TI_symbol_name("_xTaskGenericNotify")
.dwattr $C$DW$556, DW_AT_external
.dwattr $C$DW$556, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$556, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$556, DW_AT_TI_begin_line(0x1240)
.dwattr $C$DW$556, DW_AT_TI_begin_column(0x0d)
.dwattr $C$DW$556, DW_AT_TI_max_frame_size(0x0e)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4673,column 2,is_stmt,address _xTaskGenericNotify
.dwfde $C$DW$CIE, _xTaskGenericNotify
$C$DW$557 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTaskToNotify")
.dwattr $C$DW$557, DW_AT_TI_symbol_name("_xTaskToNotify")
.dwattr $C$DW$557, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$557, DW_AT_location[DW_OP_reg17]
$C$DW$558 .dwtag DW_TAG_formal_parameter, DW_AT_name("ulValue")
.dwattr $C$DW$558, DW_AT_TI_symbol_name("_ulValue")
.dwattr $C$DW$558, DW_AT_type(*$C$DW$T$28)
.dwattr $C$DW$558, DW_AT_location[DW_OP_reg0]
$C$DW$559 .dwtag DW_TAG_formal_parameter, DW_AT_name("eAction")
.dwattr $C$DW$559, DW_AT_TI_symbol_name("_eAction")
.dwattr $C$DW$559, DW_AT_type(*$C$DW$T$51)
.dwattr $C$DW$559, DW_AT_location[DW_OP_reg12]
$C$DW$560 .dwtag DW_TAG_formal_parameter, DW_AT_name("pulPreviousNotificationValue")
.dwattr $C$DW$560, DW_AT_TI_symbol_name("_pulPreviousNotificationValue")
.dwattr $C$DW$560, DW_AT_type(*$C$DW$T$133)
.dwattr $C$DW$560, DW_AT_location[DW_OP_reg19]
;*******************************************************************************
;* FUNCTION NAME: xTaskGenericNotify *
;* *
;* Function Uses Regs : AC0,AC0,AC1,AC1,T0,AR0,XAR0,AR1,XAR1,AR2,XAR2,AR3, *
;* XAR3,SP,CARRY,TC1,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 14 words *
;* (2 return address/alignment) *
;* (12 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_xTaskGenericNotify:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-13, SP
.dwcfi cfa_offset, 14
$C$DW$561 .dwtag DW_TAG_variable, DW_AT_name("xTaskToNotify")
.dwattr $C$DW$561, DW_AT_TI_symbol_name("_xTaskToNotify")
.dwattr $C$DW$561, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$561, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$562 .dwtag DW_TAG_variable, DW_AT_name("ulValue")
.dwattr $C$DW$562, DW_AT_TI_symbol_name("_ulValue")
.dwattr $C$DW$562, DW_AT_type(*$C$DW$T$28)
.dwattr $C$DW$562, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$563 .dwtag DW_TAG_variable, DW_AT_name("eAction")
.dwattr $C$DW$563, DW_AT_TI_symbol_name("_eAction")
.dwattr $C$DW$563, DW_AT_type(*$C$DW$T$51)
.dwattr $C$DW$563, DW_AT_location[DW_OP_bregx 0x24 4]
$C$DW$564 .dwtag DW_TAG_variable, DW_AT_name("pulPreviousNotificationValue")
.dwattr $C$DW$564, DW_AT_TI_symbol_name("_pulPreviousNotificationValue")
.dwattr $C$DW$564, DW_AT_type(*$C$DW$T$133)
.dwattr $C$DW$564, DW_AT_location[DW_OP_bregx 0x24 6]
$C$DW$565 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$565, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$565, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$565, DW_AT_location[DW_OP_bregx 0x24 8]
$C$DW$566 .dwtag DW_TAG_variable, DW_AT_name("xReturn")
.dwattr $C$DW$566, DW_AT_TI_symbol_name("_xReturn")
.dwattr $C$DW$566, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$566, DW_AT_location[DW_OP_bregx 0x24 10]
$C$DW$567 .dwtag DW_TAG_variable, DW_AT_name("ucOriginalNotifyState")
.dwattr $C$DW$567, DW_AT_TI_symbol_name("_ucOriginalNotifyState")
.dwattr $C$DW$567, DW_AT_type(*$C$DW$T$30)
.dwattr $C$DW$567, DW_AT_location[DW_OP_bregx 0x24 11]
MOV XAR1, dbl(*SP(#6))
MOV T0, *SP(#4) ; |4673|
MOV AC0, dbl(*SP(#2)) ; |4673|
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4675,column 13,is_stmt
MOV #1, *SP(#10) ; |4675|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4678,column 3,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L255,AC0 != #0 ; |4678|
; branchcc occurs ; |4678|
nop
bset INTM
$C$L254:
$C$DW$L$_xTaskGenericNotify$3$B:
B $C$L254 ; |4678|
; branch occurs ; |4678|
$C$DW$L$_xTaskGenericNotify$3$E:
$C$L255:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4679,column 3,is_stmt
MOV XAR3, dbl(*SP(#8))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4681,column 3,is_stmt
nop
bset INTM
ADD #1, *(#_usCriticalNesting) ; |4681|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4683,column 4,is_stmt
MOV dbl(*SP(#6)), XAR3
MOV XAR3, AC0
BCC $C$L256,AC0 == #0 ; |4683|
; branchcc occurs ; |4683|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4685,column 5,is_stmt
MOV dbl(*SP(#8)), XAR3
MOV dbl(*SP(#6)), XAR2
AADD #46, AR3 ; |4685|
MOV dbl(*AR3), dbl(*AR2) ; |4685|
$C$L256:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4688,column 4,is_stmt
MOV dbl(*SP(#8)), XAR3
MOV *AR3(#48), AR1 ; |4688|
MOV AR1, *SP(#11) ; |4688|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4690,column 4,is_stmt
MOV dbl(*SP(#8)), XAR3
MOV #2, *AR3(#48) ; |4690|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4692,column 4,is_stmt
B $C$L265 ; |4692|
; branch occurs ; |4692|
$C$L257:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4695,column 6,is_stmt
MOV dbl(*SP(#8)), XAR3
MOV dbl(*SP(#2)), AC0 ; |4695|
MOV dbl(*AR3(#46)), AC1 ; |4695|
OR AC1, AC0 ; |4695|
MOV AC0, dbl(*AR3(#46)) ; |4695|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4696,column 11,is_stmt
B $C$L267 ; |4696|
; branch occurs ; |4696|
$C$L258:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4699,column 6,is_stmt
MOV dbl(*SP(#8)), XAR3
MOV dbl(*AR3(#46)), AC0 ; |4699|
ADD #1, AC0 ; |4699|
MOV AC0, dbl(*AR3(#46)) ; |4699|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4700,column 11,is_stmt
B $C$L267 ; |4700|
; branch occurs ; |4700|
$C$L259:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4703,column 6,is_stmt
MOV dbl(*SP(#8)), XAR3
MOV dbl(*SP(#2)), AC0 ; |4703|
MOV AC0, dbl(*AR3(#46)) ; |4703|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4704,column 11,is_stmt
B $C$L267 ; |4704|
; branch occurs ; |4704|
$C$L260:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4707,column 6,is_stmt
CMP *SP(#11) == #2, TC1 ; |4707|
BCC $C$L261,TC1 ; |4707|
; branchcc occurs ; |4707|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4709,column 7,is_stmt
MOV dbl(*SP(#8)), XAR3
MOV dbl(*SP(#2)), AC0 ; |4709|
MOV AC0, dbl(*AR3(#46)) ; |4709|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4710,column 6,is_stmt
B $C$L267 ; |4710|
; branch occurs ; |4710|
$C$L261:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4714,column 7,is_stmt
MOV #0, *SP(#10) ; |4714|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4716,column 11,is_stmt
B $C$L267 ; |4716|
; branch occurs ; |4716|
$C$L262:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4727,column 6,is_stmt
MOV dbl(*SP(#8)), XAR3
MOV #-1 << #16, AC0 ; |4727|
OR #0xffff, AC0, AC0 ; |4727|
MOV dbl(*AR3(#46)), AC1 ; |4727|
CMPU AC1 != AC0, TC1 ; |4727|
MOV #0, AR1
BCC $C$L263,TC1 ; |4727|
; branchcc occurs ; |4727|
MOV #1, AR1
$C$L263:
BCC $C$L267,AR1 != #0 ; |4727|
; branchcc occurs ; |4727|
nop
bset INTM
$C$L264:
$C$DW$L$_xTaskGenericNotify$19$B:
B $C$L264 ; |4727|
; branch occurs ; |4727|
$C$DW$L$_xTaskGenericNotify$19$E:
$C$L265:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4692,column 4,is_stmt
MOV *SP(#4), AR1 ; |4692|
|| MOV #2, AR2
CMP AR1 > AR2, TC1 ; |4692|
BCC $C$L266,TC1 ; |4692|
; branchcc occurs ; |4692|
CMP AR1 == AR2, TC1 ; |4692|
BCC $C$L258,TC1 ; |4692|
; branchcc occurs ; |4692|
BCC $C$L267,AR1 == #0 ; |4692|
; branchcc occurs ; |4692|
MOV #1, AR2
CMP AR1 == AR2, TC1 ; |4692|
BCC $C$L257,TC1 ; |4692|
; branchcc occurs ; |4692|
B $C$L262 ; |4692|
; branch occurs ; |4692|
$C$L266:
MOV #3, AR2
CMP AR1 == AR2, TC1 ; |4692|
BCC $C$L259,TC1 ; |4692|
; branchcc occurs ; |4692|
MOV #4, AR2
CMP AR1 == AR2, TC1 ; |4692|
BCC $C$L260,TC1 ; |4692|
; branchcc occurs ; |4692|
B $C$L262 ; |4692|
; branch occurs ; |4692|
$C$L267:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4736,column 4,is_stmt
CMP *SP(#11) == #1, TC1 ; |4736|
BCC $C$L272,!TC1 ; |4736|
; branchcc occurs ; |4736|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4738,column 5,is_stmt
MOV dbl(*SP(#8)), XAR0
AADD #4, AR0 ; |4738|
$C$DW$568 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$568, DW_AT_low_pc(0x00)
.dwattr $C$DW$568, DW_AT_name("_uxListRemove")
.dwattr $C$DW$568, DW_AT_TI_call
CALL #_uxListRemove ; |4738|
; call occurs [#_uxListRemove] ; |4738|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4739,column 5,is_stmt
MOV dbl(*SP(#8)), XAR3
MOV *(#_uxTopReadyPriority), AR1 ; |4739|
MOV *AR3(#24), AR2 ; |4739|
CMPU AR2 <= AR1, TC1 ; |4739|
BCC $C$L268,TC1 ; |4739|
; branchcc occurs ; |4739|
MOV *AR3(#24), AR1 ; |4739|
MOV AR1, *(#_uxTopReadyPriority) ; |4739|
$C$L268:
MPYMK *AR3(#24), #10, AC0 ; |4739|
MOV AC0, AR1 ; |4739|
AMOV #_pxReadyTasksLists, XAR0 ; |4739|
AADD AR1, AR0 ; |4739|
MOV dbl(*SP(#8)), XAR1
AADD #4, AR1 ; |4739|
$C$DW$569 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$569, DW_AT_low_pc(0x00)
.dwattr $C$DW$569, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$569, DW_AT_TI_call
CALL #_vListInsertEnd ; |4739|
; call occurs [#_vListInsertEnd] ; |4739|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4742,column 5,is_stmt
MOV dbl(*SP(#8)), XAR3
MOV dbl(*AR3(#22)), XAR3
MOV XAR3, AC0
MOV #0, AR1
BCC $C$L269,AC0 != #0 ; |4742|
; branchcc occurs ; |4742|
MOV #1, AR1
$C$L269:
BCC $C$L271,AR1 != #0 ; |4742|
; branchcc occurs ; |4742|
nop
bset INTM
$C$L270:
$C$DW$L$_xTaskGenericNotify$36$B:
B $C$L270 ; |4742|
; branch occurs ; |4742|
$C$DW$L$_xTaskGenericNotify$36$E:
$C$L271:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4760,column 5,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV *AR3(#24), AR1 ; |4760|
MOV dbl(*SP(#8)), XAR3
MOV *AR3(#24), AR2 ; |4760|
CMPU AR2 <= AR1, TC1 ; |4760|
BCC $C$L272,TC1 ; |4760|
; branchcc occurs ; |4760|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4764,column 6,is_stmt
$C$DW$570 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$570, DW_AT_low_pc(0x00)
.dwattr $C$DW$570, DW_AT_name("_vPortYield")
.dwattr $C$DW$570, DW_AT_TI_call
CALL #_vPortYield ; |4764|
; call occurs [#_vPortYield] ; |4764|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4765,column 5,is_stmt
B $C$L272 ; |4765|
; branch occurs ; |4765|
$C$L272:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4776,column 3,is_stmt
MOV *(#_usCriticalNesting), AR1 ; |4776|
BCC $C$L273,AR1 == #0 ; |4776|
; branchcc occurs ; |4776|
SUB #1, *(#_usCriticalNesting) ; |4776|
NOP
NOP
NOP
MOV *(#_usCriticalNesting), AR1 ; |4776|
BCC $C$L273,AR1 != #0 ; |4776|
; branchcc occurs ; |4776|
nop
bclr INTM
$C$L273:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4778,column 3,is_stmt
MOV *SP(#10), T0 ; |4778|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4779,column 2,is_stmt
AADD #13, SP
.dwcfi cfa_offset, 1
$C$DW$571 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$571, DW_AT_low_pc(0x00)
.dwattr $C$DW$571, DW_AT_TI_return
RET
; return occurs
$C$DW$572 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$572, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L270:1:1538833113")
.dwattr $C$DW$572, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$572, DW_AT_TI_begin_line(0x1286)
.dwattr $C$DW$572, DW_AT_TI_end_line(0x1286)
$C$DW$573 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$573, DW_AT_low_pc($C$DW$L$_xTaskGenericNotify$36$B)
.dwattr $C$DW$573, DW_AT_high_pc($C$DW$L$_xTaskGenericNotify$36$E)
.dwendtag $C$DW$572
$C$DW$574 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$574, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L264:1:1538833113")
.dwattr $C$DW$574, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$574, DW_AT_TI_begin_line(0x1277)
.dwattr $C$DW$574, DW_AT_TI_end_line(0x1277)
$C$DW$575 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$575, DW_AT_low_pc($C$DW$L$_xTaskGenericNotify$19$B)
.dwattr $C$DW$575, DW_AT_high_pc($C$DW$L$_xTaskGenericNotify$19$E)
.dwendtag $C$DW$574
$C$DW$576 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$576, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L254:1:1538833113")
.dwattr $C$DW$576, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$576, DW_AT_TI_begin_line(0x1246)
.dwattr $C$DW$576, DW_AT_TI_end_line(0x1246)
$C$DW$577 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$577, DW_AT_low_pc($C$DW$L$_xTaskGenericNotify$3$B)
.dwattr $C$DW$577, DW_AT_high_pc($C$DW$L$_xTaskGenericNotify$3$E)
.dwendtag $C$DW$576
.dwattr $C$DW$556, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$556, DW_AT_TI_end_line(0x12ab)
.dwattr $C$DW$556, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$556
.sect ".text"
.align 4
.global _xTaskGenericNotifyFromISR
$C$DW$578 .dwtag DW_TAG_subprogram, DW_AT_name("xTaskGenericNotifyFromISR")
.dwattr $C$DW$578, DW_AT_low_pc(_xTaskGenericNotifyFromISR)
.dwattr $C$DW$578, DW_AT_high_pc(0x00)
.dwattr $C$DW$578, DW_AT_TI_symbol_name("_xTaskGenericNotifyFromISR")
.dwattr $C$DW$578, DW_AT_external
.dwattr $C$DW$578, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$578, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$578, DW_AT_TI_begin_line(0x12b2)
.dwattr $C$DW$578, DW_AT_TI_begin_column(0x0d)
.dwattr $C$DW$578, DW_AT_TI_max_frame_size(0x10)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4787,column 2,is_stmt,address _xTaskGenericNotifyFromISR
.dwfde $C$DW$CIE, _xTaskGenericNotifyFromISR
$C$DW$579 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTaskToNotify")
.dwattr $C$DW$579, DW_AT_TI_symbol_name("_xTaskToNotify")
.dwattr $C$DW$579, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$579, DW_AT_location[DW_OP_reg17]
$C$DW$580 .dwtag DW_TAG_formal_parameter, DW_AT_name("ulValue")
.dwattr $C$DW$580, DW_AT_TI_symbol_name("_ulValue")
.dwattr $C$DW$580, DW_AT_type(*$C$DW$T$28)
.dwattr $C$DW$580, DW_AT_location[DW_OP_reg0]
$C$DW$581 .dwtag DW_TAG_formal_parameter, DW_AT_name("eAction")
.dwattr $C$DW$581, DW_AT_TI_symbol_name("_eAction")
.dwattr $C$DW$581, DW_AT_type(*$C$DW$T$51)
.dwattr $C$DW$581, DW_AT_location[DW_OP_reg12]
$C$DW$582 .dwtag DW_TAG_formal_parameter, DW_AT_name("pulPreviousNotificationValue")
.dwattr $C$DW$582, DW_AT_TI_symbol_name("_pulPreviousNotificationValue")
.dwattr $C$DW$582, DW_AT_type(*$C$DW$T$133)
.dwattr $C$DW$582, DW_AT_location[DW_OP_reg19]
$C$DW$583 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxHigherPriorityTaskWoken")
.dwattr $C$DW$583, DW_AT_TI_symbol_name("_pxHigherPriorityTaskWoken")
.dwattr $C$DW$583, DW_AT_type(*$C$DW$T$109)
.dwattr $C$DW$583, DW_AT_location[DW_OP_reg21]
;*******************************************************************************
;* FUNCTION NAME: xTaskGenericNotifyFromISR *
;* *
;* Function Uses Regs : AC0,AC0,AC1,AC1,T0,AR0,XAR0,AR1,XAR1,AR2,XAR2,AR3, *
;* XAR3,SP,CARRY,TC1,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 16 words *
;* (1 return address/alignment) *
;* (15 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_xTaskGenericNotifyFromISR:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-15, SP
.dwcfi cfa_offset, 16
$C$DW$584 .dwtag DW_TAG_variable, DW_AT_name("xTaskToNotify")
.dwattr $C$DW$584, DW_AT_TI_symbol_name("_xTaskToNotify")
.dwattr $C$DW$584, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$584, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$585 .dwtag DW_TAG_variable, DW_AT_name("ulValue")
.dwattr $C$DW$585, DW_AT_TI_symbol_name("_ulValue")
.dwattr $C$DW$585, DW_AT_type(*$C$DW$T$28)
.dwattr $C$DW$585, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$586 .dwtag DW_TAG_variable, DW_AT_name("eAction")
.dwattr $C$DW$586, DW_AT_TI_symbol_name("_eAction")
.dwattr $C$DW$586, DW_AT_type(*$C$DW$T$51)
.dwattr $C$DW$586, DW_AT_location[DW_OP_bregx 0x24 4]
$C$DW$587 .dwtag DW_TAG_variable, DW_AT_name("pulPreviousNotificationValue")
.dwattr $C$DW$587, DW_AT_TI_symbol_name("_pulPreviousNotificationValue")
.dwattr $C$DW$587, DW_AT_type(*$C$DW$T$133)
.dwattr $C$DW$587, DW_AT_location[DW_OP_bregx 0x24 6]
$C$DW$588 .dwtag DW_TAG_variable, DW_AT_name("pxHigherPriorityTaskWoken")
.dwattr $C$DW$588, DW_AT_TI_symbol_name("_pxHigherPriorityTaskWoken")
.dwattr $C$DW$588, DW_AT_type(*$C$DW$T$109)
.dwattr $C$DW$588, DW_AT_location[DW_OP_bregx 0x24 8]
$C$DW$589 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$589, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$589, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$589, DW_AT_location[DW_OP_bregx 0x24 10]
$C$DW$590 .dwtag DW_TAG_variable, DW_AT_name("ucOriginalNotifyState")
.dwattr $C$DW$590, DW_AT_TI_symbol_name("_ucOriginalNotifyState")
.dwattr $C$DW$590, DW_AT_type(*$C$DW$T$30)
.dwattr $C$DW$590, DW_AT_location[DW_OP_bregx 0x24 12]
$C$DW$591 .dwtag DW_TAG_variable, DW_AT_name("xReturn")
.dwattr $C$DW$591, DW_AT_TI_symbol_name("_xReturn")
.dwattr $C$DW$591, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$591, DW_AT_location[DW_OP_bregx 0x24 13]
$C$DW$592 .dwtag DW_TAG_variable, DW_AT_name("uxSavedInterruptStatus")
.dwattr $C$DW$592, DW_AT_TI_symbol_name("_uxSavedInterruptStatus")
.dwattr $C$DW$592, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$592, DW_AT_location[DW_OP_bregx 0x24 14]
MOV XAR2, dbl(*SP(#8))
MOV XAR1, dbl(*SP(#6))
MOV T0, *SP(#4) ; |4787|
MOV AC0, dbl(*SP(#2)) ; |4787|
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4790,column 13,is_stmt
MOV #1, *SP(#13) ; |4790|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4793,column 3,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L275,AC0 != #0 ; |4793|
; branchcc occurs ; |4793|
nop
bset INTM
$C$L274:
$C$DW$L$_xTaskGenericNotifyFromISR$3$B:
B $C$L274 ; |4793|
; branch occurs ; |4793|
$C$DW$L$_xTaskGenericNotifyFromISR$3$E:
$C$L275:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4813,column 3,is_stmt
MOV XAR3, dbl(*SP(#10))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4815,column 3,is_stmt
MOV #0, *SP(#14) ; |4815|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4817,column 4,is_stmt
MOV dbl(*SP(#6)), XAR3
MOV XAR3, AC0
BCC $C$L276,AC0 == #0 ; |4817|
; branchcc occurs ; |4817|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4819,column 5,is_stmt
MOV dbl(*SP(#10)), XAR3
MOV dbl(*SP(#6)), XAR2
AADD #46, AR3 ; |4819|
MOV dbl(*AR3), dbl(*AR2) ; |4819|
$C$L276:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4822,column 4,is_stmt
MOV dbl(*SP(#10)), XAR3
MOV *AR3(#48), AR1 ; |4822|
MOV AR1, *SP(#12) ; |4822|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4823,column 4,is_stmt
MOV dbl(*SP(#10)), XAR3
MOV #2, *AR3(#48) ; |4823|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4825,column 4,is_stmt
B $C$L285 ; |4825|
; branch occurs ; |4825|
$C$L277:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4828,column 6,is_stmt
MOV dbl(*SP(#10)), XAR3
MOV dbl(*SP(#2)), AC0 ; |4828|
MOV dbl(*AR3(#46)), AC1 ; |4828|
OR AC1, AC0 ; |4828|
MOV AC0, dbl(*AR3(#46)) ; |4828|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4829,column 11,is_stmt
B $C$L287 ; |4829|
; branch occurs ; |4829|
$C$L278:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4832,column 6,is_stmt
MOV dbl(*SP(#10)), XAR3
MOV dbl(*AR3(#46)), AC0 ; |4832|
ADD #1, AC0 ; |4832|
MOV AC0, dbl(*AR3(#46)) ; |4832|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4833,column 11,is_stmt
B $C$L287 ; |4833|
; branch occurs ; |4833|
$C$L279:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4836,column 6,is_stmt
MOV dbl(*SP(#10)), XAR3
MOV dbl(*SP(#2)), AC0 ; |4836|
MOV AC0, dbl(*AR3(#46)) ; |4836|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4837,column 11,is_stmt
B $C$L287 ; |4837|
; branch occurs ; |4837|
$C$L280:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4840,column 6,is_stmt
CMP *SP(#12) == #2, TC1 ; |4840|
BCC $C$L281,TC1 ; |4840|
; branchcc occurs ; |4840|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4842,column 7,is_stmt
MOV dbl(*SP(#10)), XAR3
MOV dbl(*SP(#2)), AC0 ; |4842|
MOV AC0, dbl(*AR3(#46)) ; |4842|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4843,column 6,is_stmt
B $C$L287 ; |4843|
; branch occurs ; |4843|
$C$L281:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4847,column 7,is_stmt
MOV #0, *SP(#13) ; |4847|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4849,column 11,is_stmt
B $C$L287 ; |4849|
; branch occurs ; |4849|
$C$L282:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4860,column 6,is_stmt
MOV dbl(*SP(#10)), XAR3
MOV #-1 << #16, AC0 ; |4860|
OR #0xffff, AC0, AC0 ; |4860|
MOV dbl(*AR3(#46)), AC1 ; |4860|
CMPU AC1 != AC0, TC1 ; |4860|
MOV #0, AR1
BCC $C$L283,TC1 ; |4860|
; branchcc occurs ; |4860|
MOV #1, AR1
$C$L283:
BCC $C$L287,AR1 != #0 ; |4860|
; branchcc occurs ; |4860|
nop
bset INTM
$C$L284:
$C$DW$L$_xTaskGenericNotifyFromISR$19$B:
B $C$L284 ; |4860|
; branch occurs ; |4860|
$C$DW$L$_xTaskGenericNotifyFromISR$19$E:
$C$L285:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4825,column 4,is_stmt
MOV *SP(#4), AR1 ; |4825|
|| MOV #2, AR2
CMP AR1 > AR2, TC1 ; |4825|
BCC $C$L286,TC1 ; |4825|
; branchcc occurs ; |4825|
CMP AR1 == AR2, TC1 ; |4825|
BCC $C$L278,TC1 ; |4825|
; branchcc occurs ; |4825|
BCC $C$L287,AR1 == #0 ; |4825|
; branchcc occurs ; |4825|
MOV #1, AR2
CMP AR1 == AR2, TC1 ; |4825|
BCC $C$L277,TC1 ; |4825|
; branchcc occurs ; |4825|
B $C$L282 ; |4825|
; branch occurs ; |4825|
$C$L286:
MOV #3, AR2
CMP AR1 == AR2, TC1 ; |4825|
BCC $C$L279,TC1 ; |4825|
; branchcc occurs ; |4825|
MOV #4, AR2
CMP AR1 == AR2, TC1 ; |4825|
BCC $C$L280,TC1 ; |4825|
; branchcc occurs ; |4825|
B $C$L282 ; |4825|
; branch occurs ; |4825|
$C$L287:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4868,column 4,is_stmt
CMP *SP(#12) == #1, TC1 ; |4868|
BCC $C$L295,!TC1 ; |4868|
; branchcc occurs ; |4868|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4871,column 5,is_stmt
MOV dbl(*SP(#10)), XAR3
MOV dbl(*AR3(#22)), XAR3
MOV XAR3, AC0
MOV #0, AR1
BCC $C$L288,AC0 != #0 ; |4871|
; branchcc occurs ; |4871|
MOV #1, AR1
$C$L288:
BCC $C$L290,AR1 != #0 ; |4871|
; branchcc occurs ; |4871|
nop
bset INTM
$C$L289:
$C$DW$L$_xTaskGenericNotifyFromISR$34$B:
B $C$L289 ; |4871|
; branch occurs ; |4871|
$C$DW$L$_xTaskGenericNotifyFromISR$34$E:
$C$L290:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4873,column 5,is_stmt
MOV *(#_uxSchedulerSuspended), AR1 ; |4873|
BCC $C$L292,AR1 != #0 ; |4873|
; branchcc occurs ; |4873|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4875,column 6,is_stmt
MOV dbl(*SP(#10)), XAR0
AADD #4, AR0 ; |4875|
$C$DW$593 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$593, DW_AT_low_pc(0x00)
.dwattr $C$DW$593, DW_AT_name("_uxListRemove")
.dwattr $C$DW$593, DW_AT_TI_call
CALL #_uxListRemove ; |4875|
; call occurs [#_uxListRemove] ; |4875|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4876,column 6,is_stmt
MOV dbl(*SP(#10)), XAR3
MOV *(#_uxTopReadyPriority), AR1 ; |4876|
MOV *AR3(#24), AR2 ; |4876|
CMPU AR2 <= AR1, TC1 ; |4876|
BCC $C$L291,TC1 ; |4876|
; branchcc occurs ; |4876|
MOV *AR3(#24), AR1 ; |4876|
MOV AR1, *(#_uxTopReadyPriority) ; |4876|
$C$L291:
MPYMK *AR3(#24), #10, AC0 ; |4876|
MOV AC0, AR1 ; |4876|
AMOV #_pxReadyTasksLists, XAR0 ; |4876|
AADD AR1, AR0 ; |4876|
MOV dbl(*SP(#10)), XAR1
AADD #4, AR1 ; |4876|
$C$DW$594 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$594, DW_AT_low_pc(0x00)
.dwattr $C$DW$594, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$594, DW_AT_TI_call
CALL #_vListInsertEnd ; |4876|
; call occurs [#_vListInsertEnd] ; |4876|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4877,column 5,is_stmt
B $C$L293 ; |4877|
; branch occurs ; |4877|
$C$L292:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4882,column 6,is_stmt
MOV dbl(*SP(#10)), XAR1
AMOV #_xPendingReadyList, XAR0 ; |4882|
AADD #14, AR1 ; |4882|
$C$DW$595 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$595, DW_AT_low_pc(0x00)
.dwattr $C$DW$595, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$595, DW_AT_TI_call
CALL #_vListInsertEnd ; |4882|
; call occurs [#_vListInsertEnd] ; |4882|
$C$L293:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4885,column 5,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV *AR3(#24), AR1 ; |4885|
MOV dbl(*SP(#10)), XAR3
MOV *AR3(#24), AR2 ; |4885|
CMPU AR2 <= AR1, TC1 ; |4885|
BCC $C$L295,TC1 ; |4885|
; branchcc occurs ; |4885|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4889,column 6,is_stmt
MOV dbl(*SP(#8)), XAR3
MOV XAR3, AC0
BCC $C$L294,AC0 == #0 ; |4889|
; branchcc occurs ; |4889|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4891,column 7,is_stmt
MOV #1, *AR3 ; |4891|
$C$L294:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4897,column 6,is_stmt
MOV #1, *(#_xYieldPending) ; |4897|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4898,column 5,is_stmt
$C$L295:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4905,column 3,is_stmt
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4907,column 3,is_stmt
MOV *SP(#13), T0 ; |4907|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4908,column 2,is_stmt
AADD #15, SP
.dwcfi cfa_offset, 1
$C$DW$596 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$596, DW_AT_low_pc(0x00)
.dwattr $C$DW$596, DW_AT_TI_return
RET
; return occurs
$C$DW$597 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$597, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L289:1:1538833113")
.dwattr $C$DW$597, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$597, DW_AT_TI_begin_line(0x1307)
.dwattr $C$DW$597, DW_AT_TI_end_line(0x1307)
$C$DW$598 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$598, DW_AT_low_pc($C$DW$L$_xTaskGenericNotifyFromISR$34$B)
.dwattr $C$DW$598, DW_AT_high_pc($C$DW$L$_xTaskGenericNotifyFromISR$34$E)
.dwendtag $C$DW$597
$C$DW$599 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$599, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L284:1:1538833113")
.dwattr $C$DW$599, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$599, DW_AT_TI_begin_line(0x12fc)
.dwattr $C$DW$599, DW_AT_TI_end_line(0x12fc)
$C$DW$600 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$600, DW_AT_low_pc($C$DW$L$_xTaskGenericNotifyFromISR$19$B)
.dwattr $C$DW$600, DW_AT_high_pc($C$DW$L$_xTaskGenericNotifyFromISR$19$E)
.dwendtag $C$DW$599
$C$DW$601 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$601, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L274:1:1538833113")
.dwattr $C$DW$601, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$601, DW_AT_TI_begin_line(0x12b9)
.dwattr $C$DW$601, DW_AT_TI_end_line(0x12b9)
$C$DW$602 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$602, DW_AT_low_pc($C$DW$L$_xTaskGenericNotifyFromISR$3$B)
.dwattr $C$DW$602, DW_AT_high_pc($C$DW$L$_xTaskGenericNotifyFromISR$3$E)
.dwendtag $C$DW$601
.dwattr $C$DW$578, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$578, DW_AT_TI_end_line(0x132c)
.dwattr $C$DW$578, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$578
.sect ".text"
.align 4
.global _vTaskNotifyGiveFromISR
$C$DW$603 .dwtag DW_TAG_subprogram, DW_AT_name("vTaskNotifyGiveFromISR")
.dwattr $C$DW$603, DW_AT_low_pc(_vTaskNotifyGiveFromISR)
.dwattr $C$DW$603, DW_AT_high_pc(0x00)
.dwattr $C$DW$603, DW_AT_TI_symbol_name("_vTaskNotifyGiveFromISR")
.dwattr $C$DW$603, DW_AT_external
.dwattr $C$DW$603, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$603, DW_AT_TI_begin_line(0x1333)
.dwattr $C$DW$603, DW_AT_TI_begin_column(0x07)
.dwattr $C$DW$603, DW_AT_TI_max_frame_size(0x0a)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4916,column 2,is_stmt,address _vTaskNotifyGiveFromISR
.dwfde $C$DW$CIE, _vTaskNotifyGiveFromISR
$C$DW$604 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTaskToNotify")
.dwattr $C$DW$604, DW_AT_TI_symbol_name("_xTaskToNotify")
.dwattr $C$DW$604, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$604, DW_AT_location[DW_OP_reg17]
$C$DW$605 .dwtag DW_TAG_formal_parameter, DW_AT_name("pxHigherPriorityTaskWoken")
.dwattr $C$DW$605, DW_AT_TI_symbol_name("_pxHigherPriorityTaskWoken")
.dwattr $C$DW$605, DW_AT_type(*$C$DW$T$109)
.dwattr $C$DW$605, DW_AT_location[DW_OP_reg19]
;*******************************************************************************
;* FUNCTION NAME: vTaskNotifyGiveFromISR *
;* *
;* Function Uses Regs : AC0,AC0,AR0,XAR0,AR1,XAR1,AR2,AR3,XAR3,SP,CARRY,TC1, *
;* M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 10 words *
;* (2 return address/alignment) *
;* (8 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_vTaskNotifyGiveFromISR:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-9, SP
.dwcfi cfa_offset, 10
$C$DW$606 .dwtag DW_TAG_variable, DW_AT_name("xTaskToNotify")
.dwattr $C$DW$606, DW_AT_TI_symbol_name("_xTaskToNotify")
.dwattr $C$DW$606, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$606, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$607 .dwtag DW_TAG_variable, DW_AT_name("pxHigherPriorityTaskWoken")
.dwattr $C$DW$607, DW_AT_TI_symbol_name("_pxHigherPriorityTaskWoken")
.dwattr $C$DW$607, DW_AT_type(*$C$DW$T$109)
.dwattr $C$DW$607, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$608 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$608, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$608, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$608, DW_AT_location[DW_OP_bregx 0x24 4]
$C$DW$609 .dwtag DW_TAG_variable, DW_AT_name("ucOriginalNotifyState")
.dwattr $C$DW$609, DW_AT_TI_symbol_name("_ucOriginalNotifyState")
.dwattr $C$DW$609, DW_AT_type(*$C$DW$T$30)
.dwattr $C$DW$609, DW_AT_location[DW_OP_bregx 0x24 6]
$C$DW$610 .dwtag DW_TAG_variable, DW_AT_name("uxSavedInterruptStatus")
.dwattr $C$DW$610, DW_AT_TI_symbol_name("_uxSavedInterruptStatus")
.dwattr $C$DW$610, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$610, DW_AT_location[DW_OP_bregx 0x24 7]
MOV XAR1, dbl(*SP(#2))
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4921,column 3,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L297,AC0 != #0 ; |4921|
; branchcc occurs ; |4921|
nop
bset INTM
$C$L296:
$C$DW$L$_vTaskNotifyGiveFromISR$3$B:
B $C$L296 ; |4921|
; branch occurs ; |4921|
$C$DW$L$_vTaskNotifyGiveFromISR$3$E:
$C$L297:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4941,column 3,is_stmt
MOV XAR3, dbl(*SP(#4))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4943,column 3,is_stmt
MOV #0, *SP(#7) ; |4943|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4945,column 4,is_stmt
MOV dbl(*SP(#4)), XAR3
MOV *AR3(#48), AR1 ; |4945|
MOV AR1, *SP(#6) ; |4945|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4946,column 4,is_stmt
MOV dbl(*SP(#4)), XAR3
MOV #2, *AR3(#48) ; |4946|
NOP
NOP
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4950,column 4,is_stmt
MOV dbl(*SP(#4)), XAR3
MOV dbl(*AR3(#46)), AC0 ; |4950|
ADD #1, AC0 ; |4950|
MOV AC0, dbl(*AR3(#46)) ; |4950|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4956,column 4,is_stmt
CMP *SP(#6) == #1, TC1 ; |4956|
BCC $C$L305,!TC1 ; |4956|
; branchcc occurs ; |4956|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4959,column 5,is_stmt
MOV dbl(*SP(#4)), XAR3
MOV dbl(*AR3(#22)), XAR3
MOV XAR3, AC0
MOV #0, AR1
BCC $C$L298,AC0 != #0 ; |4959|
; branchcc occurs ; |4959|
MOV #1, AR1
$C$L298:
BCC $C$L300,AR1 != #0 ; |4959|
; branchcc occurs ; |4959|
nop
bset INTM
$C$L299:
$C$DW$L$_vTaskNotifyGiveFromISR$9$B:
B $C$L299 ; |4959|
; branch occurs ; |4959|
$C$DW$L$_vTaskNotifyGiveFromISR$9$E:
$C$L300:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4961,column 5,is_stmt
MOV *(#_uxSchedulerSuspended), AR1 ; |4961|
BCC $C$L302,AR1 != #0 ; |4961|
; branchcc occurs ; |4961|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4963,column 6,is_stmt
MOV dbl(*SP(#4)), XAR0
AADD #4, AR0 ; |4963|
$C$DW$611 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$611, DW_AT_low_pc(0x00)
.dwattr $C$DW$611, DW_AT_name("_uxListRemove")
.dwattr $C$DW$611, DW_AT_TI_call
CALL #_uxListRemove ; |4963|
; call occurs [#_uxListRemove] ; |4963|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4964,column 6,is_stmt
MOV dbl(*SP(#4)), XAR3
MOV *(#_uxTopReadyPriority), AR1 ; |4964|
MOV *AR3(#24), AR2 ; |4964|
CMPU AR2 <= AR1, TC1 ; |4964|
BCC $C$L301,TC1 ; |4964|
; branchcc occurs ; |4964|
MOV *AR3(#24), AR1 ; |4964|
MOV AR1, *(#_uxTopReadyPriority) ; |4964|
$C$L301:
MPYMK *AR3(#24), #10, AC0 ; |4964|
MOV AC0, AR1 ; |4964|
AMOV #_pxReadyTasksLists, XAR0 ; |4964|
AADD AR1, AR0 ; |4964|
MOV dbl(*SP(#4)), XAR1
AADD #4, AR1 ; |4964|
$C$DW$612 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$612, DW_AT_low_pc(0x00)
.dwattr $C$DW$612, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$612, DW_AT_TI_call
CALL #_vListInsertEnd ; |4964|
; call occurs [#_vListInsertEnd] ; |4964|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4965,column 5,is_stmt
B $C$L303 ; |4965|
; branch occurs ; |4965|
$C$L302:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4970,column 6,is_stmt
MOV dbl(*SP(#4)), XAR1
AMOV #_xPendingReadyList, XAR0 ; |4970|
AADD #14, AR1 ; |4970|
$C$DW$613 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$613, DW_AT_low_pc(0x00)
.dwattr $C$DW$613, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$613, DW_AT_TI_call
CALL #_vListInsertEnd ; |4970|
; call occurs [#_vListInsertEnd] ; |4970|
$C$L303:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4973,column 5,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV *AR3(#24), AR1 ; |4973|
MOV dbl(*SP(#4)), XAR3
MOV *AR3(#24), AR2 ; |4973|
CMPU AR2 <= AR1, TC1 ; |4973|
BCC $C$L305,TC1 ; |4973|
; branchcc occurs ; |4973|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4977,column 6,is_stmt
MOV dbl(*SP(#2)), XAR3
MOV XAR3, AC0
BCC $C$L304,AC0 == #0 ; |4977|
; branchcc occurs ; |4977|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4979,column 7,is_stmt
MOV #1, *AR3 ; |4979|
$C$L304:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4985,column 6,is_stmt
MOV #1, *(#_xYieldPending) ; |4985|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 4986,column 5,is_stmt
B $C$L305 ; |4986|
; branch occurs ; |4986|
$C$L305:
AADD #9, SP
.dwcfi cfa_offset, 1
$C$DW$614 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$614, DW_AT_low_pc(0x00)
.dwattr $C$DW$614, DW_AT_TI_return
RET
; return occurs
$C$DW$615 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$615, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L299:1:1538833113")
.dwattr $C$DW$615, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$615, DW_AT_TI_begin_line(0x135f)
.dwattr $C$DW$615, DW_AT_TI_end_line(0x135f)
$C$DW$616 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$616, DW_AT_low_pc($C$DW$L$_vTaskNotifyGiveFromISR$9$B)
.dwattr $C$DW$616, DW_AT_high_pc($C$DW$L$_vTaskNotifyGiveFromISR$9$E)
.dwendtag $C$DW$615
$C$DW$617 .dwtag DW_TAG_TI_loop
.dwattr $C$DW$617, DW_AT_name("F:\eZdsp_DBG\tmp1\c55x-sim2\foo\Debug\tasks_sysStk.asm:$C$L296:1:1538833113")
.dwattr $C$DW$617, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$617, DW_AT_TI_begin_line(0x1339)
.dwattr $C$DW$617, DW_AT_TI_end_line(0x1339)
$C$DW$618 .dwtag DW_TAG_TI_loop_range
.dwattr $C$DW$618, DW_AT_low_pc($C$DW$L$_vTaskNotifyGiveFromISR$3$B)
.dwattr $C$DW$618, DW_AT_high_pc($C$DW$L$_vTaskNotifyGiveFromISR$3$E)
.dwendtag $C$DW$617
.dwattr $C$DW$603, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$603, DW_AT_TI_end_line(0x1382)
.dwattr $C$DW$603, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$603
.sect ".text"
.align 4
.global _xTaskNotifyStateClear
$C$DW$619 .dwtag DW_TAG_subprogram, DW_AT_name("xTaskNotifyStateClear")
.dwattr $C$DW$619, DW_AT_low_pc(_xTaskNotifyStateClear)
.dwattr $C$DW$619, DW_AT_high_pc(0x00)
.dwattr $C$DW$619, DW_AT_TI_symbol_name("_xTaskNotifyStateClear")
.dwattr $C$DW$619, DW_AT_external
.dwattr $C$DW$619, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$619, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$619, DW_AT_TI_begin_line(0x138a)
.dwattr $C$DW$619, DW_AT_TI_begin_column(0x0d)
.dwattr $C$DW$619, DW_AT_TI_max_frame_size(0x06)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5003,column 2,is_stmt,address _xTaskNotifyStateClear
.dwfde $C$DW$CIE, _xTaskNotifyStateClear
$C$DW$620 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTask")
.dwattr $C$DW$620, DW_AT_TI_symbol_name("_xTask")
.dwattr $C$DW$620, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$620, DW_AT_location[DW_OP_reg17]
;*******************************************************************************
;* FUNCTION NAME: xTaskNotifyStateClear *
;* *
;* Function Uses Regs : AC0,AC0,T0,AR0,XAR0,AR1,AR3,XAR3,SP,CARRY,TC1,M40, *
;* SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 6 words *
;* (1 return address/alignment) *
;* (5 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_xTaskNotifyStateClear:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-5, SP
.dwcfi cfa_offset, 6
$C$DW$621 .dwtag DW_TAG_variable, DW_AT_name("xTask")
.dwattr $C$DW$621, DW_AT_TI_symbol_name("_xTask")
.dwattr $C$DW$621, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$621, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$622 .dwtag DW_TAG_variable, DW_AT_name("pxTCB")
.dwattr $C$DW$622, DW_AT_TI_symbol_name("_pxTCB")
.dwattr $C$DW$622, DW_AT_type(*$C$DW$T$83)
.dwattr $C$DW$622, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$623 .dwtag DW_TAG_variable, DW_AT_name("xReturn")
.dwattr $C$DW$623, DW_AT_TI_symbol_name("_xReturn")
.dwattr $C$DW$623, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$623, DW_AT_location[DW_OP_bregx 0x24 4]
MOV XAR0, dbl(*SP(#0))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5009,column 3,is_stmt
MOV dbl(*SP(#0)), XAR3
MOV XAR3, AC0
BCC $C$L306,AC0 != #0 ; |5009|
; branchcc occurs ; |5009|
MOV dbl(*(#_pxCurrentTCB)), XAR3
$C$L306:
MOV XAR3, dbl(*SP(#2))
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5011,column 3,is_stmt
nop
bset INTM
ADD #1, *(#_usCriticalNesting) ; |5011|
NOP
NOP
NOP
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5013,column 4,is_stmt
CMP *AR3(#48) == #2, TC1 ; |5013|
BCC $C$L307,!TC1 ; |5013|
; branchcc occurs ; |5013|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5015,column 5,is_stmt
MOV #0, *AR3(#48) ; |5015|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5016,column 5,is_stmt
MOV #1, *SP(#4) ; |5016|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5017,column 4,is_stmt
B $C$L308 ; |5017|
; branch occurs ; |5017|
$C$L307:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5020,column 5,is_stmt
MOV #0, *SP(#4) ; |5020|
$C$L308:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5023,column 3,is_stmt
MOV *(#_usCriticalNesting), AR1 ; |5023|
BCC $C$L309,AR1 == #0 ; |5023|
; branchcc occurs ; |5023|
SUB #1, *(#_usCriticalNesting) ; |5023|
NOP
NOP
NOP
MOV *(#_usCriticalNesting), AR1 ; |5023|
BCC $C$L309,AR1 != #0 ; |5023|
; branchcc occurs ; |5023|
nop
bclr INTM
$C$L309:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5025,column 3,is_stmt
MOV *SP(#4), T0 ; |5025|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5026,column 2,is_stmt
AADD #5, SP
.dwcfi cfa_offset, 1
$C$DW$624 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$624, DW_AT_low_pc(0x00)
.dwattr $C$DW$624, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$619, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$619, DW_AT_TI_end_line(0x13a2)
.dwattr $C$DW$619, DW_AT_TI_end_column(0x02)
.dwendentry
.dwendtag $C$DW$619
.sect ".text"
.align 4
$C$DW$625 .dwtag DW_TAG_subprogram, DW_AT_name("prvAddCurrentTaskToDelayedList")
.dwattr $C$DW$625, DW_AT_low_pc(_prvAddCurrentTaskToDelayedList)
.dwattr $C$DW$625, DW_AT_high_pc(0x00)
.dwattr $C$DW$625, DW_AT_TI_symbol_name("_prvAddCurrentTaskToDelayedList")
.dwattr $C$DW$625, DW_AT_TI_begin_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$625, DW_AT_TI_begin_line(0x13a8)
.dwattr $C$DW$625, DW_AT_TI_begin_column(0x0d)
.dwattr $C$DW$625, DW_AT_TI_max_frame_size(0x0a)
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5033,column 1,is_stmt,address _prvAddCurrentTaskToDelayedList
.dwfde $C$DW$CIE, _prvAddCurrentTaskToDelayedList
$C$DW$626 .dwtag DW_TAG_formal_parameter, DW_AT_name("xTicksToWait")
.dwattr $C$DW$626, DW_AT_TI_symbol_name("_xTicksToWait")
.dwattr $C$DW$626, DW_AT_type(*$C$DW$T$37)
.dwattr $C$DW$626, DW_AT_location[DW_OP_reg0]
$C$DW$627 .dwtag DW_TAG_formal_parameter, DW_AT_name("xCanBlockIndefinitely")
.dwattr $C$DW$627, DW_AT_TI_symbol_name("_xCanBlockIndefinitely")
.dwattr $C$DW$627, DW_AT_type(*$C$DW$T$111)
.dwattr $C$DW$627, DW_AT_location[DW_OP_reg12]
;*******************************************************************************
;* FUNCTION NAME: prvAddCurrentTaskToDelayedList *
;* *
;* Function Uses Regs : AC0,AC0,AC1,AC1,T0,AR0,XAR0,AR1,XAR1,AR3,XAR3,SP, *
;* CARRY,TC1,M40,SATA,SATD,RDM,FRCT,SMUL *
;* Stack Frame : Compact (No Frame Pointer, w/ debug) *
;* Total Frame Size : 10 words *
;* (2 return address/alignment) *
;* (8 local values) *
;* Min System Stack : 1 word *
;*******************************************************************************
_prvAddCurrentTaskToDelayedList:
.dwcfi cfa_offset, 1
.dwcfi save_reg_to_mem, 91, -1
AADD #-9, SP
.dwcfi cfa_offset, 10
$C$DW$628 .dwtag DW_TAG_variable, DW_AT_name("xTicksToWait")
.dwattr $C$DW$628, DW_AT_TI_symbol_name("_xTicksToWait")
.dwattr $C$DW$628, DW_AT_type(*$C$DW$T$37)
.dwattr $C$DW$628, DW_AT_location[DW_OP_bregx 0x24 0]
$C$DW$629 .dwtag DW_TAG_variable, DW_AT_name("xCanBlockIndefinitely")
.dwattr $C$DW$629, DW_AT_TI_symbol_name("_xCanBlockIndefinitely")
.dwattr $C$DW$629, DW_AT_type(*$C$DW$T$111)
.dwattr $C$DW$629, DW_AT_location[DW_OP_bregx 0x24 2]
$C$DW$630 .dwtag DW_TAG_variable, DW_AT_name("xTimeToWake")
.dwattr $C$DW$630, DW_AT_TI_symbol_name("_xTimeToWake")
.dwattr $C$DW$630, DW_AT_type(*$C$DW$T$37)
.dwattr $C$DW$630, DW_AT_location[DW_OP_bregx 0x24 4]
$C$DW$631 .dwtag DW_TAG_variable, DW_AT_name("xConstTickCount")
.dwattr $C$DW$631, DW_AT_TI_symbol_name("_xConstTickCount")
.dwattr $C$DW$631, DW_AT_type(*$C$DW$T$95)
.dwattr $C$DW$631, DW_AT_location[DW_OP_bregx 0x24 6]
MOV T0, *SP(#2) ; |5033|
MOV AC0, dbl(*SP(#0)) ; |5033|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5035,column 18,is_stmt
MOV dbl(*(#_xTickCount)), AC0 ; |5035|
MOV AC0, dbl(*SP(#6)) ; |5035|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5048,column 2,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR0
AADD #4, AR0 ; |5048|
$C$DW$632 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$632, DW_AT_low_pc(0x00)
.dwattr $C$DW$632, DW_AT_name("_uxListRemove")
.dwattr $C$DW$632, DW_AT_TI_call
CALL #_uxListRemove ; |5048|
; call occurs [#_uxListRemove] ; |5048|
BCC $C$L310,T0 == #0 ; |5048|
; branchcc occurs ; |5048|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5053,column 2,is_stmt
$C$L310:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5061,column 3,is_stmt
MOV #-1 << #16, AC0 ; |5061|
MOV dbl(*SP(#0)), AC1 ; |5061|
OR #0xffff, AC0, AC0 ; |5061|
CMPU AC1 != AC0, TC1 ; |5061|
BCC $C$L311,TC1 ; |5061|
; branchcc occurs ; |5061|
MOV *SP(#2), AR1 ; |5061|
BCC $C$L311,AR1 == #0 ; |5061|
; branchcc occurs ; |5061|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5066,column 4,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR1
AMOV #_xSuspendedTaskList, XAR0 ; |5066|
AADD #4, AR1 ; |5066|
$C$DW$633 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$633, DW_AT_low_pc(0x00)
.dwattr $C$DW$633, DW_AT_name("_vListInsertEnd")
.dwattr $C$DW$633, DW_AT_TI_call
CALL #_vListInsertEnd ; |5066|
; call occurs [#_vListInsertEnd] ; |5066|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5067,column 3,is_stmt
B $C$L313 ; |5067|
; branch occurs ; |5067|
$C$L311:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5073,column 4,is_stmt
MOV dbl(*SP(#0)), AC0 ; |5073|
ADD dbl(*SP(#6)), AC0, AC0 ; |5073|
MOV AC0, dbl(*SP(#4)) ; |5073|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5076,column 4,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR3
MOV dbl(*SP(#4)), AC0 ; |5076|
MOV AC0, dbl(*AR3(short(#4))) ; |5076|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5078,column 4,is_stmt
MOV dbl(*SP(#4)), AC1 ; |5078|
MOV dbl(*SP(#6)), AC0 ; |5078|
CMPU AC1 >= AC0, TC1 ; |5078|
BCC $C$L312,TC1 ; |5078|
; branchcc occurs ; |5078|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5082,column 5,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR1
MOV dbl(*(#_pxOverflowDelayedTaskList)), XAR0
AADD #4, AR1 ; |5082|
$C$DW$634 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$634, DW_AT_low_pc(0x00)
.dwattr $C$DW$634, DW_AT_name("_vListInsert")
.dwattr $C$DW$634, DW_AT_TI_call
CALL #_vListInsert ; |5082|
; call occurs [#_vListInsert] ; |5082|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5083,column 4,is_stmt
B $C$L313 ; |5083|
; branch occurs ; |5083|
$C$L312:
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5088,column 5,is_stmt
MOV dbl(*(#_pxCurrentTCB)), XAR1
MOV dbl(*(#_pxDelayedTaskList)), XAR0
AADD #4, AR1 ; |5088|
$C$DW$635 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$635, DW_AT_low_pc(0x00)
.dwattr $C$DW$635, DW_AT_name("_vListInsert")
.dwattr $C$DW$635, DW_AT_TI_call
CALL #_vListInsert ; |5088|
; call occurs [#_vListInsert] ; |5088|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5093,column 5,is_stmt
MOV dbl(*(#_xNextTaskUnblockTime)), AC0 ; |5093|
MOV dbl(*SP(#4)), AC1 ; |5093|
CMPU AC1 >= AC0, TC1 ; |5093|
BCC $C$L313,TC1 ; |5093|
; branchcc occurs ; |5093|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5095,column 6,is_stmt
MOV dbl(*SP(#4)), AC0 ; |5095|
MOV AC0, dbl(*(#_xNextTaskUnblockTime)) ; |5095|
.dwpsn file "../FreeRTOS/Source/tasks_sysStk.c",line 5096,column 5,is_stmt
B $C$L313 ; |5096|
; branch occurs ; |5096|
$C$L313:
AADD #9, SP
.dwcfi cfa_offset, 1
$C$DW$636 .dwtag DW_TAG_TI_branch
.dwattr $C$DW$636, DW_AT_low_pc(0x00)
.dwattr $C$DW$636, DW_AT_TI_return
RET
; return occurs
.dwattr $C$DW$625, DW_AT_TI_end_file("../FreeRTOS/Source/tasks_sysStk.c")
.dwattr $C$DW$625, DW_AT_TI_end_line(0x1415)
.dwattr $C$DW$625, DW_AT_TI_end_column(0x01)
.dwendentry
.dwendtag $C$DW$625
;*******************************************************************************
;* FAR STRINGS *
;*******************************************************************************
.sect ".const:.string"
.align 2
$C$FSL1: .string "IDLE",0
;******************************************************************************
;* UNDEFINED EXTERNAL REFERENCES *
;******************************************************************************
.global _memset
.global _vPortYield
.global _pxPortInitialiseStack
.global _pvPortMalloc
.global _vPortFree
.global _xPortStartScheduler
.global _vPortEndScheduler
.global _vListInitialise
.global _vListInitialiseItem
.global _vListInsert
.global _vListInsertEnd
.global _uxListRemove
.global _vApplicationMallocFailedHook
.global _vApplicationIdleHook
.global _usCriticalNesting
;*******************************************************************************
;* TYPE INFORMATION *
;*******************************************************************************
$C$DW$T$45 .dwtag DW_TAG_enumeration_type
.dwattr $C$DW$T$45, DW_AT_byte_size(0x01)
$C$DW$637 .dwtag DW_TAG_enumerator, DW_AT_name("eRunning"), DW_AT_const_value(0x00)
$C$DW$638 .dwtag DW_TAG_enumerator, DW_AT_name("eReady"), DW_AT_const_value(0x01)
$C$DW$639 .dwtag DW_TAG_enumerator, DW_AT_name("eBlocked"), DW_AT_const_value(0x02)
$C$DW$640 .dwtag DW_TAG_enumerator, DW_AT_name("eSuspended"), DW_AT_const_value(0x03)
$C$DW$641 .dwtag DW_TAG_enumerator, DW_AT_name("eDeleted"), DW_AT_const_value(0x04)
$C$DW$642 .dwtag DW_TAG_enumerator, DW_AT_name("eInvalid"), DW_AT_const_value(0x05)
.dwendtag $C$DW$T$45
$C$DW$T$46 .dwtag DW_TAG_typedef, DW_AT_name("eTaskState")
.dwattr $C$DW$T$46, DW_AT_type(*$C$DW$T$45)
.dwattr $C$DW$T$46, DW_AT_language(DW_LANG_C)
$C$DW$T$50 .dwtag DW_TAG_enumeration_type
.dwattr $C$DW$T$50, DW_AT_byte_size(0x01)
$C$DW$643 .dwtag DW_TAG_enumerator, DW_AT_name("eNoAction"), DW_AT_const_value(0x00)
$C$DW$644 .dwtag DW_TAG_enumerator, DW_AT_name("eSetBits"), DW_AT_const_value(0x01)
$C$DW$645 .dwtag DW_TAG_enumerator, DW_AT_name("eIncrement"), DW_AT_const_value(0x02)
$C$DW$646 .dwtag DW_TAG_enumerator, DW_AT_name("eSetValueWithOverwrite"), DW_AT_const_value(0x03)
$C$DW$647 .dwtag DW_TAG_enumerator, DW_AT_name("eSetValueWithoutOverwrite"), DW_AT_const_value(0x04)
.dwendtag $C$DW$T$50
$C$DW$T$51 .dwtag DW_TAG_typedef, DW_AT_name("eNotifyAction")
.dwattr $C$DW$T$51, DW_AT_type(*$C$DW$T$50)
.dwattr $C$DW$T$51, DW_AT_language(DW_LANG_C)
$C$DW$T$3 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$3, DW_AT_address_class(0x17)
$C$DW$648 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$648, DW_AT_type(*$C$DW$T$3)
$C$DW$T$57 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$57, DW_AT_type(*$C$DW$648)
$C$DW$T$60 .dwtag DW_TAG_subroutine_type
.dwattr $C$DW$T$60, DW_AT_language(DW_LANG_C)
$C$DW$649 .dwtag DW_TAG_formal_parameter
.dwattr $C$DW$649, DW_AT_type(*$C$DW$T$3)
.dwendtag $C$DW$T$60
$C$DW$T$61 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$61, DW_AT_type(*$C$DW$T$60)
.dwattr $C$DW$T$61, DW_AT_address_class(0x20)
$C$DW$T$62 .dwtag DW_TAG_typedef, DW_AT_name("TaskFunction_t")
.dwattr $C$DW$T$62, DW_AT_type(*$C$DW$T$61)
.dwattr $C$DW$T$62, DW_AT_language(DW_LANG_C)
$C$DW$T$4 .dwtag DW_TAG_base_type
.dwattr $C$DW$T$4, DW_AT_encoding(DW_ATE_boolean)
.dwattr $C$DW$T$4, DW_AT_name("bool")
.dwattr $C$DW$T$4, DW_AT_byte_size(0x01)
$C$DW$T$5 .dwtag DW_TAG_base_type
.dwattr $C$DW$T$5, DW_AT_encoding(DW_ATE_signed_char)
.dwattr $C$DW$T$5, DW_AT_name("signed char")
.dwattr $C$DW$T$5, DW_AT_byte_size(0x01)
$C$DW$T$6 .dwtag DW_TAG_base_type
.dwattr $C$DW$T$6, DW_AT_encoding(DW_ATE_unsigned_char)
.dwattr $C$DW$T$6, DW_AT_name("unsigned char")
.dwattr $C$DW$T$6, DW_AT_byte_size(0x01)
$C$DW$T$30 .dwtag DW_TAG_typedef, DW_AT_name("uint8_t")
.dwattr $C$DW$T$30, DW_AT_type(*$C$DW$T$6)
.dwattr $C$DW$T$30, DW_AT_language(DW_LANG_C)
$C$DW$T$114 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$114, DW_AT_type(*$C$DW$T$30)
.dwattr $C$DW$T$114, DW_AT_address_class(0x17)
$C$DW$650 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$650, DW_AT_type(*$C$DW$T$30)
$C$DW$T$31 .dwtag DW_TAG_volatile_type
.dwattr $C$DW$T$31, DW_AT_type(*$C$DW$650)
$C$DW$651 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$651, DW_AT_type(*$C$DW$T$30)
$C$DW$T$115 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$115, DW_AT_type(*$C$DW$651)
$C$DW$T$116 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$116, DW_AT_type(*$C$DW$T$115)
.dwattr $C$DW$T$116, DW_AT_address_class(0x17)
$C$DW$T$7 .dwtag DW_TAG_base_type
.dwattr $C$DW$T$7, DW_AT_encoding(DW_ATE_signed_char)
.dwattr $C$DW$T$7, DW_AT_name("wchar_t")
.dwattr $C$DW$T$7, DW_AT_byte_size(0x01)
$C$DW$T$8 .dwtag DW_TAG_base_type
.dwattr $C$DW$T$8, DW_AT_encoding(DW_ATE_signed)
.dwattr $C$DW$T$8, DW_AT_name("short")
.dwattr $C$DW$T$8, DW_AT_byte_size(0x01)
$C$DW$T$43 .dwtag DW_TAG_typedef, DW_AT_name("BaseType_t")
.dwattr $C$DW$T$43, DW_AT_type(*$C$DW$T$8)
.dwattr $C$DW$T$43, DW_AT_language(DW_LANG_C)
$C$DW$652 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$652, DW_AT_type(*$C$DW$T$43)
$C$DW$T$111 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$111, DW_AT_type(*$C$DW$652)
$C$DW$653 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$653, DW_AT_type(*$C$DW$T$43)
$C$DW$T$118 .dwtag DW_TAG_volatile_type
.dwattr $C$DW$T$118, DW_AT_type(*$C$DW$653)
$C$DW$T$109 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$109, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$T$109, DW_AT_address_class(0x17)
$C$DW$T$9 .dwtag DW_TAG_base_type
.dwattr $C$DW$T$9, DW_AT_encoding(DW_ATE_unsigned)
.dwattr $C$DW$T$9, DW_AT_name("unsigned short")
.dwattr $C$DW$T$9, DW_AT_byte_size(0x01)
$C$DW$T$25 .dwtag DW_TAG_typedef, DW_AT_name("UBaseType_t")
.dwattr $C$DW$T$25, DW_AT_type(*$C$DW$T$9)
.dwattr $C$DW$T$25, DW_AT_language(DW_LANG_C)
$C$DW$654 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$654, DW_AT_type(*$C$DW$T$25)
$C$DW$T$33 .dwtag DW_TAG_volatile_type
.dwattr $C$DW$T$33, DW_AT_type(*$C$DW$654)
$C$DW$655 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$655, DW_AT_type(*$C$DW$T$25)
$C$DW$T$137 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$137, DW_AT_type(*$C$DW$655)
$C$DW$T$10 .dwtag DW_TAG_base_type
.dwattr $C$DW$T$10, DW_AT_encoding(DW_ATE_signed)
.dwattr $C$DW$T$10, DW_AT_name("int")
.dwattr $C$DW$T$10, DW_AT_byte_size(0x01)
$C$DW$T$11 .dwtag DW_TAG_base_type
.dwattr $C$DW$T$11, DW_AT_encoding(DW_ATE_unsigned)
.dwattr $C$DW$T$11, DW_AT_name("unsigned int")
.dwattr $C$DW$T$11, DW_AT_byte_size(0x01)
$C$DW$T$19 .dwtag DW_TAG_typedef, DW_AT_name("StackType_t")
.dwattr $C$DW$T$19, DW_AT_type(*$C$DW$T$11)
.dwattr $C$DW$T$19, DW_AT_language(DW_LANG_C)
$C$DW$656 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$656, DW_AT_type(*$C$DW$T$19)
$C$DW$T$22 .dwtag DW_TAG_volatile_type
.dwattr $C$DW$T$22, DW_AT_type(*$C$DW$656)
$C$DW$T$23 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$23, DW_AT_type(*$C$DW$T$22)
.dwattr $C$DW$T$23, DW_AT_address_class(0x17)
$C$DW$T$20 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$20, DW_AT_type(*$C$DW$T$19)
.dwattr $C$DW$T$20, DW_AT_address_class(0x17)
$C$DW$657 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$657, DW_AT_type(*$C$DW$T$11)
$C$DW$T$143 .dwtag DW_TAG_volatile_type
.dwattr $C$DW$T$143, DW_AT_type(*$C$DW$657)
$C$DW$T$52 .dwtag DW_TAG_typedef, DW_AT_name("size_t")
.dwattr $C$DW$T$52, DW_AT_type(*$C$DW$T$11)
.dwattr $C$DW$T$52, DW_AT_language(DW_LANG_C)
$C$DW$T$121 .dwtag DW_TAG_typedef, DW_AT_name("uint16_t")
.dwattr $C$DW$T$121, DW_AT_type(*$C$DW$T$11)
.dwattr $C$DW$T$121, DW_AT_language(DW_LANG_C)
$C$DW$658 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$658, DW_AT_type(*$C$DW$T$121)
$C$DW$T$122 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$122, DW_AT_type(*$C$DW$658)
$C$DW$T$12 .dwtag DW_TAG_base_type
.dwattr $C$DW$T$12, DW_AT_encoding(DW_ATE_signed)
.dwattr $C$DW$T$12, DW_AT_name("long")
.dwattr $C$DW$T$12, DW_AT_byte_size(0x02)
$C$DW$T$13 .dwtag DW_TAG_base_type
.dwattr $C$DW$T$13, DW_AT_encoding(DW_ATE_unsigned)
.dwattr $C$DW$T$13, DW_AT_name("unsigned long")
.dwattr $C$DW$T$13, DW_AT_byte_size(0x02)
$C$DW$T$37 .dwtag DW_TAG_typedef, DW_AT_name("TickType_t")
.dwattr $C$DW$T$37, DW_AT_type(*$C$DW$T$13)
.dwattr $C$DW$T$37, DW_AT_language(DW_LANG_C)
$C$DW$659 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$659, DW_AT_type(*$C$DW$T$37)
$C$DW$T$95 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$95, DW_AT_type(*$C$DW$659)
$C$DW$660 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$660, DW_AT_type(*$C$DW$T$37)
$C$DW$T$146 .dwtag DW_TAG_volatile_type
.dwattr $C$DW$T$146, DW_AT_type(*$C$DW$660)
$C$DW$T$93 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$93, DW_AT_type(*$C$DW$T$37)
.dwattr $C$DW$T$93, DW_AT_address_class(0x17)
$C$DW$661 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$661, DW_AT_type(*$C$DW$T$93)
$C$DW$T$94 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$94, DW_AT_type(*$C$DW$661)
$C$DW$T$28 .dwtag DW_TAG_typedef, DW_AT_name("uint32_t")
.dwattr $C$DW$T$28, DW_AT_type(*$C$DW$T$13)
.dwattr $C$DW$T$28, DW_AT_language(DW_LANG_C)
$C$DW$T$133 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$133, DW_AT_type(*$C$DW$T$28)
.dwattr $C$DW$T$133, DW_AT_address_class(0x17)
$C$DW$662 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$662, DW_AT_type(*$C$DW$T$28)
$C$DW$T$29 .dwtag DW_TAG_volatile_type
.dwattr $C$DW$T$29, DW_AT_type(*$C$DW$662)
$C$DW$663 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$663, DW_AT_type(*$C$DW$T$28)
$C$DW$T$78 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$78, DW_AT_type(*$C$DW$663)
$C$DW$T$14 .dwtag DW_TAG_base_type
.dwattr $C$DW$T$14, DW_AT_encoding(DW_ATE_signed)
.dwattr $C$DW$T$14, DW_AT_name("long long")
.dwattr $C$DW$T$14, DW_AT_byte_size(0x04)
.dwattr $C$DW$T$14, DW_AT_bit_size(0x28)
.dwattr $C$DW$T$14, DW_AT_bit_offset(0x18)
$C$DW$T$15 .dwtag DW_TAG_base_type
.dwattr $C$DW$T$15, DW_AT_encoding(DW_ATE_unsigned)
.dwattr $C$DW$T$15, DW_AT_name("unsigned long long")
.dwattr $C$DW$T$15, DW_AT_byte_size(0x04)
.dwattr $C$DW$T$15, DW_AT_bit_size(0x28)
.dwattr $C$DW$T$15, DW_AT_bit_offset(0x18)
$C$DW$T$16 .dwtag DW_TAG_base_type
.dwattr $C$DW$T$16, DW_AT_encoding(DW_ATE_float)
.dwattr $C$DW$T$16, DW_AT_name("float")
.dwattr $C$DW$T$16, DW_AT_byte_size(0x02)
$C$DW$T$17 .dwtag DW_TAG_base_type
.dwattr $C$DW$T$17, DW_AT_encoding(DW_ATE_float)
.dwattr $C$DW$T$17, DW_AT_name("double")
.dwattr $C$DW$T$17, DW_AT_byte_size(0x02)
$C$DW$T$18 .dwtag DW_TAG_base_type
.dwattr $C$DW$T$18, DW_AT_encoding(DW_ATE_float)
.dwattr $C$DW$T$18, DW_AT_name("long double")
.dwattr $C$DW$T$18, DW_AT_byte_size(0x02)
$C$DW$T$26 .dwtag DW_TAG_base_type
.dwattr $C$DW$T$26, DW_AT_encoding(DW_ATE_signed_char)
.dwattr $C$DW$T$26, DW_AT_name("signed char")
.dwattr $C$DW$T$26, DW_AT_byte_size(0x01)
$C$DW$T$27 .dwtag DW_TAG_array_type
.dwattr $C$DW$T$27, DW_AT_type(*$C$DW$T$26)
.dwattr $C$DW$T$27, DW_AT_language(DW_LANG_C)
.dwattr $C$DW$T$27, DW_AT_byte_size(0x08)
$C$DW$664 .dwtag DW_TAG_subrange_type
.dwattr $C$DW$664, DW_AT_upper_bound(0x07)
.dwendtag $C$DW$T$27
$C$DW$665 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$665, DW_AT_type(*$C$DW$T$26)
$C$DW$T$75 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$75, DW_AT_type(*$C$DW$665)
$C$DW$T$76 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$76, DW_AT_type(*$C$DW$T$75)
.dwattr $C$DW$T$76, DW_AT_address_class(0x17)
$C$DW$666 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$666, DW_AT_type(*$C$DW$T$76)
$C$DW$T$77 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$77, DW_AT_type(*$C$DW$666)
$C$DW$T$150 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$150, DW_AT_type(*$C$DW$T$26)
.dwattr $C$DW$T$150, DW_AT_address_class(0x17)
$C$DW$T$21 .dwtag DW_TAG_structure_type
.dwattr $C$DW$T$21, DW_AT_name("tagSTACKSTRUCT")
.dwattr $C$DW$T$21, DW_AT_byte_size(0x04)
$C$DW$667 .dwtag DW_TAG_member
.dwattr $C$DW$667, DW_AT_type(*$C$DW$T$20)
.dwattr $C$DW$667, DW_AT_name("pxTopOfStack")
.dwattr $C$DW$667, DW_AT_TI_symbol_name("_pxTopOfStack")
.dwattr $C$DW$667, DW_AT_data_member_location[DW_OP_plus_uconst 0x0]
.dwattr $C$DW$667, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$668 .dwtag DW_TAG_member
.dwattr $C$DW$668, DW_AT_type(*$C$DW$T$20)
.dwattr $C$DW$668, DW_AT_name("pxTopOfSysStack")
.dwattr $C$DW$668, DW_AT_TI_symbol_name("_pxTopOfSysStack")
.dwattr $C$DW$668, DW_AT_data_member_location[DW_OP_plus_uconst 0x2]
.dwattr $C$DW$668, DW_AT_accessibility(DW_ACCESS_public)
.dwendtag $C$DW$T$21
$C$DW$T$154 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$154, DW_AT_type(*$C$DW$T$21)
.dwattr $C$DW$T$154, DW_AT_address_class(0x17)
$C$DW$T$32 .dwtag DW_TAG_structure_type
.dwattr $C$DW$T$32, DW_AT_name("tskTaskControlBlock")
.dwattr $C$DW$T$32, DW_AT_byte_size(0x32)
$C$DW$669 .dwtag DW_TAG_member
.dwattr $C$DW$669, DW_AT_type(*$C$DW$T$23)
.dwattr $C$DW$669, DW_AT_name("pxTopOfStack")
.dwattr $C$DW$669, DW_AT_TI_symbol_name("_pxTopOfStack")
.dwattr $C$DW$669, DW_AT_data_member_location[DW_OP_plus_uconst 0x0]
.dwattr $C$DW$669, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$670 .dwtag DW_TAG_member
.dwattr $C$DW$670, DW_AT_type(*$C$DW$T$23)
.dwattr $C$DW$670, DW_AT_name("pxTopOfSysStack")
.dwattr $C$DW$670, DW_AT_TI_symbol_name("_pxTopOfSysStack")
.dwattr $C$DW$670, DW_AT_data_member_location[DW_OP_plus_uconst 0x2]
.dwattr $C$DW$670, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$671 .dwtag DW_TAG_member
.dwattr $C$DW$671, DW_AT_type(*$C$DW$T$24)
.dwattr $C$DW$671, DW_AT_name("xStateListItem")
.dwattr $C$DW$671, DW_AT_TI_symbol_name("_xStateListItem")
.dwattr $C$DW$671, DW_AT_data_member_location[DW_OP_plus_uconst 0x4]
.dwattr $C$DW$671, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$672 .dwtag DW_TAG_member
.dwattr $C$DW$672, DW_AT_type(*$C$DW$T$24)
.dwattr $C$DW$672, DW_AT_name("xEventListItem")
.dwattr $C$DW$672, DW_AT_TI_symbol_name("_xEventListItem")
.dwattr $C$DW$672, DW_AT_data_member_location[DW_OP_plus_uconst 0xe]
.dwattr $C$DW$672, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$673 .dwtag DW_TAG_member
.dwattr $C$DW$673, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$673, DW_AT_name("uxPriority")
.dwattr $C$DW$673, DW_AT_TI_symbol_name("_uxPriority")
.dwattr $C$DW$673, DW_AT_data_member_location[DW_OP_plus_uconst 0x18]
.dwattr $C$DW$673, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$674 .dwtag DW_TAG_member
.dwattr $C$DW$674, DW_AT_type(*$C$DW$T$20)
.dwattr $C$DW$674, DW_AT_name("pxStack")
.dwattr $C$DW$674, DW_AT_TI_symbol_name("_pxStack")
.dwattr $C$DW$674, DW_AT_data_member_location[DW_OP_plus_uconst 0x1a]
.dwattr $C$DW$674, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$675 .dwtag DW_TAG_member
.dwattr $C$DW$675, DW_AT_type(*$C$DW$T$20)
.dwattr $C$DW$675, DW_AT_name("pxSysStack")
.dwattr $C$DW$675, DW_AT_TI_symbol_name("_pxSysStack")
.dwattr $C$DW$675, DW_AT_data_member_location[DW_OP_plus_uconst 0x1c]
.dwattr $C$DW$675, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$676 .dwtag DW_TAG_member
.dwattr $C$DW$676, DW_AT_type(*$C$DW$T$27)
.dwattr $C$DW$676, DW_AT_name("pcTaskName")
.dwattr $C$DW$676, DW_AT_TI_symbol_name("_pcTaskName")
.dwattr $C$DW$676, DW_AT_data_member_location[DW_OP_plus_uconst 0x1e]
.dwattr $C$DW$676, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$677 .dwtag DW_TAG_member
.dwattr $C$DW$677, DW_AT_type(*$C$DW$T$20)
.dwattr $C$DW$677, DW_AT_name("pxEndOfStack")
.dwattr $C$DW$677, DW_AT_TI_symbol_name("_pxEndOfStack")
.dwattr $C$DW$677, DW_AT_data_member_location[DW_OP_plus_uconst 0x26]
.dwattr $C$DW$677, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$678 .dwtag DW_TAG_member
.dwattr $C$DW$678, DW_AT_type(*$C$DW$T$20)
.dwattr $C$DW$678, DW_AT_name("pxEndOfSysStack")
.dwattr $C$DW$678, DW_AT_TI_symbol_name("_pxEndOfSysStack")
.dwattr $C$DW$678, DW_AT_data_member_location[DW_OP_plus_uconst 0x28]
.dwattr $C$DW$678, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$679 .dwtag DW_TAG_member
.dwattr $C$DW$679, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$679, DW_AT_name("uxCriticalNesting")
.dwattr $C$DW$679, DW_AT_TI_symbol_name("_uxCriticalNesting")
.dwattr $C$DW$679, DW_AT_data_member_location[DW_OP_plus_uconst 0x2a]
.dwattr $C$DW$679, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$680 .dwtag DW_TAG_member
.dwattr $C$DW$680, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$680, DW_AT_name("uxBasePriority")
.dwattr $C$DW$680, DW_AT_TI_symbol_name("_uxBasePriority")
.dwattr $C$DW$680, DW_AT_data_member_location[DW_OP_plus_uconst 0x2b]
.dwattr $C$DW$680, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$681 .dwtag DW_TAG_member
.dwattr $C$DW$681, DW_AT_type(*$C$DW$T$25)
.dwattr $C$DW$681, DW_AT_name("uxMutexesHeld")
.dwattr $C$DW$681, DW_AT_TI_symbol_name("_uxMutexesHeld")
.dwattr $C$DW$681, DW_AT_data_member_location[DW_OP_plus_uconst 0x2c]
.dwattr $C$DW$681, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$682 .dwtag DW_TAG_member
.dwattr $C$DW$682, DW_AT_type(*$C$DW$T$29)
.dwattr $C$DW$682, DW_AT_name("ulNotifiedValue")
.dwattr $C$DW$682, DW_AT_TI_symbol_name("_ulNotifiedValue")
.dwattr $C$DW$682, DW_AT_data_member_location[DW_OP_plus_uconst 0x2e]
.dwattr $C$DW$682, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$683 .dwtag DW_TAG_member
.dwattr $C$DW$683, DW_AT_type(*$C$DW$T$31)
.dwattr $C$DW$683, DW_AT_name("ucNotifyState")
.dwattr $C$DW$683, DW_AT_TI_symbol_name("_ucNotifyState")
.dwattr $C$DW$683, DW_AT_data_member_location[DW_OP_plus_uconst 0x30]
.dwattr $C$DW$683, DW_AT_accessibility(DW_ACCESS_public)
.dwendtag $C$DW$T$32
$C$DW$T$47 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$47, DW_AT_type(*$C$DW$T$32)
.dwattr $C$DW$T$47, DW_AT_address_class(0x17)
$C$DW$T$48 .dwtag DW_TAG_typedef, DW_AT_name("TaskHandle_t")
.dwattr $C$DW$T$48, DW_AT_type(*$C$DW$T$47)
.dwattr $C$DW$T$48, DW_AT_language(DW_LANG_C)
$C$DW$684 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$684, DW_AT_type(*$C$DW$T$48)
$C$DW$T$107 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$107, DW_AT_type(*$C$DW$684)
$C$DW$T$79 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$79, DW_AT_type(*$C$DW$T$48)
.dwattr $C$DW$T$79, DW_AT_address_class(0x17)
$C$DW$685 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$685, DW_AT_type(*$C$DW$T$79)
$C$DW$T$80 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$80, DW_AT_type(*$C$DW$685)
$C$DW$T$81 .dwtag DW_TAG_typedef, DW_AT_name("tskTCB")
.dwattr $C$DW$T$81, DW_AT_type(*$C$DW$T$32)
.dwattr $C$DW$T$81, DW_AT_language(DW_LANG_C)
$C$DW$T$82 .dwtag DW_TAG_typedef, DW_AT_name("TCB_t")
.dwattr $C$DW$T$82, DW_AT_type(*$C$DW$T$81)
.dwattr $C$DW$T$82, DW_AT_language(DW_LANG_C)
$C$DW$686 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$686, DW_AT_type(*$C$DW$T$82)
$C$DW$T$156 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$156, DW_AT_type(*$C$DW$686)
$C$DW$T$157 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$157, DW_AT_type(*$C$DW$T$156)
.dwattr $C$DW$T$157, DW_AT_address_class(0x17)
$C$DW$687 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$687, DW_AT_type(*$C$DW$T$157)
$C$DW$T$158 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$158, DW_AT_type(*$C$DW$687)
$C$DW$T$83 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$83, DW_AT_type(*$C$DW$T$82)
.dwattr $C$DW$T$83, DW_AT_address_class(0x17)
$C$DW$688 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$688, DW_AT_type(*$C$DW$T$83)
$C$DW$T$159 .dwtag DW_TAG_volatile_type
.dwattr $C$DW$T$159, DW_AT_type(*$C$DW$688)
$C$DW$689 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$689, DW_AT_type(*$C$DW$T$83)
$C$DW$T$160 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$160, DW_AT_type(*$C$DW$689)
$C$DW$T$36 .dwtag DW_TAG_structure_type
.dwattr $C$DW$T$36, DW_AT_name("xLIST")
.dwattr $C$DW$T$36, DW_AT_byte_size(0x0a)
$C$DW$690 .dwtag DW_TAG_member
.dwattr $C$DW$690, DW_AT_type(*$C$DW$T$33)
.dwattr $C$DW$690, DW_AT_name("uxNumberOfItems")
.dwattr $C$DW$690, DW_AT_TI_symbol_name("_uxNumberOfItems")
.dwattr $C$DW$690, DW_AT_data_member_location[DW_OP_plus_uconst 0x0]
.dwattr $C$DW$690, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$691 .dwtag DW_TAG_member
.dwattr $C$DW$691, DW_AT_type(*$C$DW$T$34)
.dwattr $C$DW$691, DW_AT_name("pxIndex")
.dwattr $C$DW$691, DW_AT_TI_symbol_name("_pxIndex")
.dwattr $C$DW$691, DW_AT_data_member_location[DW_OP_plus_uconst 0x2]
.dwattr $C$DW$691, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$692 .dwtag DW_TAG_member
.dwattr $C$DW$692, DW_AT_type(*$C$DW$T$35)
.dwattr $C$DW$692, DW_AT_name("xListEnd")
.dwattr $C$DW$692, DW_AT_TI_symbol_name("_xListEnd")
.dwattr $C$DW$692, DW_AT_data_member_location[DW_OP_plus_uconst 0x4]
.dwattr $C$DW$692, DW_AT_accessibility(DW_ACCESS_public)
.dwendtag $C$DW$T$36
$C$DW$T$65 .dwtag DW_TAG_typedef, DW_AT_name("List_t")
.dwattr $C$DW$T$65, DW_AT_type(*$C$DW$T$36)
.dwattr $C$DW$T$65, DW_AT_language(DW_LANG_C)
$C$DW$693 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$693, DW_AT_type(*$C$DW$T$65)
$C$DW$T$128 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$128, DW_AT_type(*$C$DW$693)
$C$DW$T$129 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$129, DW_AT_type(*$C$DW$T$128)
.dwattr $C$DW$T$129, DW_AT_address_class(0x17)
$C$DW$694 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$694, DW_AT_type(*$C$DW$T$129)
$C$DW$T$130 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$130, DW_AT_type(*$C$DW$694)
$C$DW$T$66 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$66, DW_AT_type(*$C$DW$T$65)
.dwattr $C$DW$T$66, DW_AT_address_class(0x17)
$C$DW$695 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$695, DW_AT_type(*$C$DW$T$66)
$C$DW$T$67 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$67, DW_AT_type(*$C$DW$695)
$C$DW$696 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$696, DW_AT_type(*$C$DW$T$66)
$C$DW$T$161 .dwtag DW_TAG_volatile_type
.dwattr $C$DW$T$161, DW_AT_type(*$C$DW$696)
$C$DW$T$162 .dwtag DW_TAG_array_type
.dwattr $C$DW$T$162, DW_AT_type(*$C$DW$T$65)
.dwattr $C$DW$T$162, DW_AT_language(DW_LANG_C)
.dwattr $C$DW$T$162, DW_AT_byte_size(0x32)
$C$DW$697 .dwtag DW_TAG_subrange_type
.dwattr $C$DW$697, DW_AT_upper_bound(0x04)
.dwendtag $C$DW$T$162
$C$DW$T$39 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$39, DW_AT_type(*$C$DW$T$36)
.dwattr $C$DW$T$39, DW_AT_address_class(0x17)
$C$DW$T$40 .dwtag DW_TAG_structure_type
.dwattr $C$DW$T$40, DW_AT_name("xLIST_ITEM")
.dwattr $C$DW$T$40, DW_AT_byte_size(0x0a)
$C$DW$698 .dwtag DW_TAG_member
.dwattr $C$DW$698, DW_AT_type(*$C$DW$T$37)
.dwattr $C$DW$698, DW_AT_name("xItemValue")
.dwattr $C$DW$698, DW_AT_TI_symbol_name("_xItemValue")
.dwattr $C$DW$698, DW_AT_data_member_location[DW_OP_plus_uconst 0x0]
.dwattr $C$DW$698, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$699 .dwtag DW_TAG_member
.dwattr $C$DW$699, DW_AT_type(*$C$DW$T$38)
.dwattr $C$DW$699, DW_AT_name("pxNext")
.dwattr $C$DW$699, DW_AT_TI_symbol_name("_pxNext")
.dwattr $C$DW$699, DW_AT_data_member_location[DW_OP_plus_uconst 0x2]
.dwattr $C$DW$699, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$700 .dwtag DW_TAG_member
.dwattr $C$DW$700, DW_AT_type(*$C$DW$T$38)
.dwattr $C$DW$700, DW_AT_name("pxPrevious")
.dwattr $C$DW$700, DW_AT_TI_symbol_name("_pxPrevious")
.dwattr $C$DW$700, DW_AT_data_member_location[DW_OP_plus_uconst 0x4]
.dwattr $C$DW$700, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$701 .dwtag DW_TAG_member
.dwattr $C$DW$701, DW_AT_type(*$C$DW$T$3)
.dwattr $C$DW$701, DW_AT_name("pvOwner")
.dwattr $C$DW$701, DW_AT_TI_symbol_name("_pvOwner")
.dwattr $C$DW$701, DW_AT_data_member_location[DW_OP_plus_uconst 0x6]
.dwattr $C$DW$701, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$702 .dwtag DW_TAG_member
.dwattr $C$DW$702, DW_AT_type(*$C$DW$T$39)
.dwattr $C$DW$702, DW_AT_name("pvContainer")
.dwattr $C$DW$702, DW_AT_TI_symbol_name("_pvContainer")
.dwattr $C$DW$702, DW_AT_data_member_location[DW_OP_plus_uconst 0x8]
.dwattr $C$DW$702, DW_AT_accessibility(DW_ACCESS_public)
.dwendtag $C$DW$T$40
$C$DW$T$24 .dwtag DW_TAG_typedef, DW_AT_name("ListItem_t")
.dwattr $C$DW$T$24, DW_AT_type(*$C$DW$T$40)
.dwattr $C$DW$T$24, DW_AT_language(DW_LANG_C)
$C$DW$T$34 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$34, DW_AT_type(*$C$DW$T$24)
.dwattr $C$DW$T$34, DW_AT_address_class(0x17)
$C$DW$703 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$703, DW_AT_type(*$C$DW$T$34)
$C$DW$T$70 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$70, DW_AT_type(*$C$DW$703)
$C$DW$T$38 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$38, DW_AT_type(*$C$DW$T$40)
.dwattr $C$DW$T$38, DW_AT_address_class(0x17)
$C$DW$T$41 .dwtag DW_TAG_structure_type
.dwattr $C$DW$T$41, DW_AT_name("xMEMORY_REGION")
.dwattr $C$DW$T$41, DW_AT_byte_size(0x06)
$C$DW$704 .dwtag DW_TAG_member
.dwattr $C$DW$704, DW_AT_type(*$C$DW$T$3)
.dwattr $C$DW$704, DW_AT_name("pvBaseAddress")
.dwattr $C$DW$704, DW_AT_TI_symbol_name("_pvBaseAddress")
.dwattr $C$DW$704, DW_AT_data_member_location[DW_OP_plus_uconst 0x0]
.dwattr $C$DW$704, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$705 .dwtag DW_TAG_member
.dwattr $C$DW$705, DW_AT_type(*$C$DW$T$28)
.dwattr $C$DW$705, DW_AT_name("ulLengthInBytes")
.dwattr $C$DW$705, DW_AT_TI_symbol_name("_ulLengthInBytes")
.dwattr $C$DW$705, DW_AT_data_member_location[DW_OP_plus_uconst 0x2]
.dwattr $C$DW$705, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$706 .dwtag DW_TAG_member
.dwattr $C$DW$706, DW_AT_type(*$C$DW$T$28)
.dwattr $C$DW$706, DW_AT_name("ulParameters")
.dwattr $C$DW$706, DW_AT_TI_symbol_name("_ulParameters")
.dwattr $C$DW$706, DW_AT_data_member_location[DW_OP_plus_uconst 0x4]
.dwattr $C$DW$706, DW_AT_accessibility(DW_ACCESS_public)
.dwendtag $C$DW$T$41
$C$DW$T$84 .dwtag DW_TAG_typedef, DW_AT_name("MemoryRegion_t")
.dwattr $C$DW$T$84, DW_AT_type(*$C$DW$T$41)
.dwattr $C$DW$T$84, DW_AT_language(DW_LANG_C)
$C$DW$707 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$707, DW_AT_type(*$C$DW$T$84)
$C$DW$T$85 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$85, DW_AT_type(*$C$DW$707)
$C$DW$T$86 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$86, DW_AT_type(*$C$DW$T$85)
.dwattr $C$DW$T$86, DW_AT_address_class(0x17)
$C$DW$708 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$708, DW_AT_type(*$C$DW$T$86)
$C$DW$T$87 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$87, DW_AT_type(*$C$DW$708)
$C$DW$T$42 .dwtag DW_TAG_structure_type
.dwattr $C$DW$T$42, DW_AT_name("xMINI_LIST_ITEM")
.dwattr $C$DW$T$42, DW_AT_byte_size(0x06)
$C$DW$709 .dwtag DW_TAG_member
.dwattr $C$DW$709, DW_AT_type(*$C$DW$T$37)
.dwattr $C$DW$709, DW_AT_name("xItemValue")
.dwattr $C$DW$709, DW_AT_TI_symbol_name("_xItemValue")
.dwattr $C$DW$709, DW_AT_data_member_location[DW_OP_plus_uconst 0x0]
.dwattr $C$DW$709, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$710 .dwtag DW_TAG_member
.dwattr $C$DW$710, DW_AT_type(*$C$DW$T$38)
.dwattr $C$DW$710, DW_AT_name("pxNext")
.dwattr $C$DW$710, DW_AT_TI_symbol_name("_pxNext")
.dwattr $C$DW$710, DW_AT_data_member_location[DW_OP_plus_uconst 0x2]
.dwattr $C$DW$710, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$711 .dwtag DW_TAG_member
.dwattr $C$DW$711, DW_AT_type(*$C$DW$T$38)
.dwattr $C$DW$711, DW_AT_name("pxPrevious")
.dwattr $C$DW$711, DW_AT_TI_symbol_name("_pxPrevious")
.dwattr $C$DW$711, DW_AT_data_member_location[DW_OP_plus_uconst 0x4]
.dwattr $C$DW$711, DW_AT_accessibility(DW_ACCESS_public)
.dwendtag $C$DW$T$42
$C$DW$T$35 .dwtag DW_TAG_typedef, DW_AT_name("MiniListItem_t")
.dwattr $C$DW$T$35, DW_AT_type(*$C$DW$T$42)
.dwattr $C$DW$T$35, DW_AT_language(DW_LANG_C)
$C$DW$T$44 .dwtag DW_TAG_structure_type
.dwattr $C$DW$T$44, DW_AT_name("xTIME_OUT")
.dwattr $C$DW$T$44, DW_AT_byte_size(0x04)
$C$DW$712 .dwtag DW_TAG_member
.dwattr $C$DW$712, DW_AT_type(*$C$DW$T$43)
.dwattr $C$DW$712, DW_AT_name("xOverflowCount")
.dwattr $C$DW$712, DW_AT_TI_symbol_name("_xOverflowCount")
.dwattr $C$DW$712, DW_AT_data_member_location[DW_OP_plus_uconst 0x0]
.dwattr $C$DW$712, DW_AT_accessibility(DW_ACCESS_public)
$C$DW$713 .dwtag DW_TAG_member
.dwattr $C$DW$713, DW_AT_type(*$C$DW$T$37)
.dwattr $C$DW$713, DW_AT_name("xTimeOnEntering")
.dwattr $C$DW$713, DW_AT_TI_symbol_name("_xTimeOnEntering")
.dwattr $C$DW$713, DW_AT_data_member_location[DW_OP_plus_uconst 0x2]
.dwattr $C$DW$713, DW_AT_accessibility(DW_ACCESS_public)
.dwendtag $C$DW$T$44
$C$DW$T$102 .dwtag DW_TAG_typedef, DW_AT_name("TimeOut_t")
.dwattr $C$DW$T$102, DW_AT_type(*$C$DW$T$44)
.dwattr $C$DW$T$102, DW_AT_language(DW_LANG_C)
$C$DW$T$103 .dwtag DW_TAG_pointer_type
.dwattr $C$DW$T$103, DW_AT_type(*$C$DW$T$102)
.dwattr $C$DW$T$103, DW_AT_address_class(0x17)
$C$DW$714 .dwtag DW_TAG_TI_far_type
.dwattr $C$DW$714, DW_AT_type(*$C$DW$T$103)
$C$DW$T$104 .dwtag DW_TAG_const_type
.dwattr $C$DW$T$104, DW_AT_type(*$C$DW$714)
.dwattr $C$DW$CU, DW_AT_language(DW_LANG_C)
;***************************************************************
;* DWARF CIE ENTRIES *
;***************************************************************
$C$DW$CIE .dwcie 91
.dwcfi cfa_register, 36
.dwcfi cfa_offset, 0
.dwcfi undefined, 0
.dwcfi undefined, 1
.dwcfi undefined, 2
.dwcfi undefined, 3
.dwcfi undefined, 4
.dwcfi undefined, 5
.dwcfi undefined, 6
.dwcfi undefined, 7
.dwcfi undefined, 8
.dwcfi undefined, 9
.dwcfi undefined, 10
.dwcfi undefined, 11
.dwcfi undefined, 12
.dwcfi undefined, 13
.dwcfi same_value, 14
.dwcfi same_value, 15
.dwcfi undefined, 16
.dwcfi undefined, 17
.dwcfi undefined, 18
.dwcfi undefined, 19
.dwcfi undefined, 20
.dwcfi undefined, 21
.dwcfi undefined, 22
.dwcfi undefined, 23
.dwcfi undefined, 24
.dwcfi undefined, 25
.dwcfi same_value, 26
.dwcfi same_value, 27
.dwcfi same_value, 28
.dwcfi same_value, 29
.dwcfi same_value, 30
.dwcfi same_value, 31
.dwcfi undefined, 32
.dwcfi undefined, 33
.dwcfi undefined, 34
.dwcfi undefined, 35
.dwcfi undefined, 36
.dwcfi undefined, 37
.dwcfi undefined, 38
.dwcfi undefined, 39
.dwcfi undefined, 40
.dwcfi undefined, 41
.dwcfi undefined, 42
.dwcfi undefined, 43
.dwcfi undefined, 44
.dwcfi undefined, 45
.dwcfi undefined, 46
.dwcfi undefined, 47
.dwcfi undefined, 48
.dwcfi undefined, 49
.dwcfi undefined, 50
.dwcfi undefined, 51
.dwcfi undefined, 52
.dwcfi undefined, 53
.dwcfi undefined, 54
.dwcfi undefined, 55
.dwcfi undefined, 56
.dwcfi undefined, 57
.dwcfi undefined, 58
.dwcfi undefined, 59
.dwcfi undefined, 60
.dwcfi undefined, 61
.dwcfi undefined, 62
.dwcfi undefined, 63
.dwcfi undefined, 64
.dwcfi undefined, 65
.dwcfi undefined, 66
.dwcfi undefined, 67
.dwcfi undefined, 68
.dwcfi undefined, 69
.dwcfi undefined, 70
.dwcfi undefined, 71
.dwcfi undefined, 72
.dwcfi undefined, 73
.dwcfi undefined, 74
.dwcfi undefined, 75
.dwcfi undefined, 76
.dwcfi undefined, 77
.dwcfi undefined, 78
.dwcfi undefined, 79
.dwcfi undefined, 80
.dwcfi undefined, 81
.dwcfi undefined, 82
.dwcfi undefined, 83
.dwcfi undefined, 84
.dwcfi undefined, 85
.dwcfi undefined, 86
.dwcfi undefined, 87
.dwcfi undefined, 88
.dwcfi undefined, 89
.dwcfi undefined, 90
.dwcfi undefined, 91
.dwendentry
;***************************************************************
;* DWARF REGISTER MAP *
;***************************************************************
$C$DW$715 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AC0")
.dwattr $C$DW$715, DW_AT_location[DW_OP_reg0]
$C$DW$716 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AC0")
.dwattr $C$DW$716, DW_AT_location[DW_OP_reg1]
$C$DW$717 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AC0_G")
.dwattr $C$DW$717, DW_AT_location[DW_OP_reg2]
$C$DW$718 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AC1")
.dwattr $C$DW$718, DW_AT_location[DW_OP_reg3]
$C$DW$719 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AC1")
.dwattr $C$DW$719, DW_AT_location[DW_OP_reg4]
$C$DW$720 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AC1_G")
.dwattr $C$DW$720, DW_AT_location[DW_OP_reg5]
$C$DW$721 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AC2")
.dwattr $C$DW$721, DW_AT_location[DW_OP_reg6]
$C$DW$722 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AC2")
.dwattr $C$DW$722, DW_AT_location[DW_OP_reg7]
$C$DW$723 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AC2_G")
.dwattr $C$DW$723, DW_AT_location[DW_OP_reg8]
$C$DW$724 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AC3")
.dwattr $C$DW$724, DW_AT_location[DW_OP_reg9]
$C$DW$725 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AC3")
.dwattr $C$DW$725, DW_AT_location[DW_OP_reg10]
$C$DW$726 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AC3_G")
.dwattr $C$DW$726, DW_AT_location[DW_OP_reg11]
$C$DW$727 .dwtag DW_TAG_TI_assign_register, DW_AT_name("T0")
.dwattr $C$DW$727, DW_AT_location[DW_OP_reg12]
$C$DW$728 .dwtag DW_TAG_TI_assign_register, DW_AT_name("T1")
.dwattr $C$DW$728, DW_AT_location[DW_OP_reg13]
$C$DW$729 .dwtag DW_TAG_TI_assign_register, DW_AT_name("T2")
.dwattr $C$DW$729, DW_AT_location[DW_OP_reg14]
$C$DW$730 .dwtag DW_TAG_TI_assign_register, DW_AT_name("T3")
.dwattr $C$DW$730, DW_AT_location[DW_OP_reg15]
$C$DW$731 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AR0")
.dwattr $C$DW$731, DW_AT_location[DW_OP_reg16]
$C$DW$732 .dwtag DW_TAG_TI_assign_register, DW_AT_name("XAR0")
.dwattr $C$DW$732, DW_AT_location[DW_OP_reg17]
$C$DW$733 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AR1")
.dwattr $C$DW$733, DW_AT_location[DW_OP_reg18]
$C$DW$734 .dwtag DW_TAG_TI_assign_register, DW_AT_name("XAR1")
.dwattr $C$DW$734, DW_AT_location[DW_OP_reg19]
$C$DW$735 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AR2")
.dwattr $C$DW$735, DW_AT_location[DW_OP_reg20]
$C$DW$736 .dwtag DW_TAG_TI_assign_register, DW_AT_name("XAR2")
.dwattr $C$DW$736, DW_AT_location[DW_OP_reg21]
$C$DW$737 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AR3")
.dwattr $C$DW$737, DW_AT_location[DW_OP_reg22]
$C$DW$738 .dwtag DW_TAG_TI_assign_register, DW_AT_name("XAR3")
.dwattr $C$DW$738, DW_AT_location[DW_OP_reg23]
$C$DW$739 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AR4")
.dwattr $C$DW$739, DW_AT_location[DW_OP_reg24]
$C$DW$740 .dwtag DW_TAG_TI_assign_register, DW_AT_name("XAR4")
.dwattr $C$DW$740, DW_AT_location[DW_OP_reg25]
$C$DW$741 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AR5")
.dwattr $C$DW$741, DW_AT_location[DW_OP_reg26]
$C$DW$742 .dwtag DW_TAG_TI_assign_register, DW_AT_name("XAR5")
.dwattr $C$DW$742, DW_AT_location[DW_OP_reg27]
$C$DW$743 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AR6")
.dwattr $C$DW$743, DW_AT_location[DW_OP_reg28]
$C$DW$744 .dwtag DW_TAG_TI_assign_register, DW_AT_name("XAR6")
.dwattr $C$DW$744, DW_AT_location[DW_OP_reg29]
$C$DW$745 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AR7")
.dwattr $C$DW$745, DW_AT_location[DW_OP_reg30]
$C$DW$746 .dwtag DW_TAG_TI_assign_register, DW_AT_name("XAR7")
.dwattr $C$DW$746, DW_AT_location[DW_OP_reg31]
$C$DW$747 .dwtag DW_TAG_TI_assign_register, DW_AT_name("FP")
.dwattr $C$DW$747, DW_AT_location[DW_OP_regx 0x20]
$C$DW$748 .dwtag DW_TAG_TI_assign_register, DW_AT_name("XFP")
.dwattr $C$DW$748, DW_AT_location[DW_OP_regx 0x21]
$C$DW$749 .dwtag DW_TAG_TI_assign_register, DW_AT_name("PC")
.dwattr $C$DW$749, DW_AT_location[DW_OP_regx 0x22]
$C$DW$750 .dwtag DW_TAG_TI_assign_register, DW_AT_name("SP")
.dwattr $C$DW$750, DW_AT_location[DW_OP_regx 0x23]
$C$DW$751 .dwtag DW_TAG_TI_assign_register, DW_AT_name("XSP")
.dwattr $C$DW$751, DW_AT_location[DW_OP_regx 0x24]
$C$DW$752 .dwtag DW_TAG_TI_assign_register, DW_AT_name("BKC")
.dwattr $C$DW$752, DW_AT_location[DW_OP_regx 0x25]
$C$DW$753 .dwtag DW_TAG_TI_assign_register, DW_AT_name("BK03")
.dwattr $C$DW$753, DW_AT_location[DW_OP_regx 0x26]
$C$DW$754 .dwtag DW_TAG_TI_assign_register, DW_AT_name("BK47")
.dwattr $C$DW$754, DW_AT_location[DW_OP_regx 0x27]
$C$DW$755 .dwtag DW_TAG_TI_assign_register, DW_AT_name("ST0")
.dwattr $C$DW$755, DW_AT_location[DW_OP_regx 0x28]
$C$DW$756 .dwtag DW_TAG_TI_assign_register, DW_AT_name("ST1")
.dwattr $C$DW$756, DW_AT_location[DW_OP_regx 0x29]
$C$DW$757 .dwtag DW_TAG_TI_assign_register, DW_AT_name("ST2")
.dwattr $C$DW$757, DW_AT_location[DW_OP_regx 0x2a]
$C$DW$758 .dwtag DW_TAG_TI_assign_register, DW_AT_name("ST3")
.dwattr $C$DW$758, DW_AT_location[DW_OP_regx 0x2b]
$C$DW$759 .dwtag DW_TAG_TI_assign_register, DW_AT_name("MDP")
.dwattr $C$DW$759, DW_AT_location[DW_OP_regx 0x2c]
$C$DW$760 .dwtag DW_TAG_TI_assign_register, DW_AT_name("MDP05")
.dwattr $C$DW$760, DW_AT_location[DW_OP_regx 0x2d]
$C$DW$761 .dwtag DW_TAG_TI_assign_register, DW_AT_name("MDP67")
.dwattr $C$DW$761, DW_AT_location[DW_OP_regx 0x2e]
$C$DW$762 .dwtag DW_TAG_TI_assign_register, DW_AT_name("BRC0")
.dwattr $C$DW$762, DW_AT_location[DW_OP_regx 0x2f]
$C$DW$763 .dwtag DW_TAG_TI_assign_register, DW_AT_name("RSA0")
.dwattr $C$DW$763, DW_AT_location[DW_OP_regx 0x30]
$C$DW$764 .dwtag DW_TAG_TI_assign_register, DW_AT_name("RSA0_H")
.dwattr $C$DW$764, DW_AT_location[DW_OP_regx 0x31]
$C$DW$765 .dwtag DW_TAG_TI_assign_register, DW_AT_name("REA0")
.dwattr $C$DW$765, DW_AT_location[DW_OP_regx 0x32]
$C$DW$766 .dwtag DW_TAG_TI_assign_register, DW_AT_name("REA0_H")
.dwattr $C$DW$766, DW_AT_location[DW_OP_regx 0x33]
$C$DW$767 .dwtag DW_TAG_TI_assign_register, DW_AT_name("BRS1")
.dwattr $C$DW$767, DW_AT_location[DW_OP_regx 0x34]
$C$DW$768 .dwtag DW_TAG_TI_assign_register, DW_AT_name("BRC1")
.dwattr $C$DW$768, DW_AT_location[DW_OP_regx 0x35]
$C$DW$769 .dwtag DW_TAG_TI_assign_register, DW_AT_name("RSA1")
.dwattr $C$DW$769, DW_AT_location[DW_OP_regx 0x36]
$C$DW$770 .dwtag DW_TAG_TI_assign_register, DW_AT_name("RSA1_H")
.dwattr $C$DW$770, DW_AT_location[DW_OP_regx 0x37]
$C$DW$771 .dwtag DW_TAG_TI_assign_register, DW_AT_name("REA1")
.dwattr $C$DW$771, DW_AT_location[DW_OP_regx 0x38]
$C$DW$772 .dwtag DW_TAG_TI_assign_register, DW_AT_name("REA1_H")
.dwattr $C$DW$772, DW_AT_location[DW_OP_regx 0x39]
$C$DW$773 .dwtag DW_TAG_TI_assign_register, DW_AT_name("CSR")
.dwattr $C$DW$773, DW_AT_location[DW_OP_regx 0x3a]
$C$DW$774 .dwtag DW_TAG_TI_assign_register, DW_AT_name("RPTC")
.dwattr $C$DW$774, DW_AT_location[DW_OP_regx 0x3b]
$C$DW$775 .dwtag DW_TAG_TI_assign_register, DW_AT_name("CDP")
.dwattr $C$DW$775, DW_AT_location[DW_OP_regx 0x3c]
$C$DW$776 .dwtag DW_TAG_TI_assign_register, DW_AT_name("XCDP")
.dwattr $C$DW$776, DW_AT_location[DW_OP_regx 0x3d]
$C$DW$777 .dwtag DW_TAG_TI_assign_register, DW_AT_name("TRN0")
.dwattr $C$DW$777, DW_AT_location[DW_OP_regx 0x3e]
$C$DW$778 .dwtag DW_TAG_TI_assign_register, DW_AT_name("TRN1")
.dwattr $C$DW$778, DW_AT_location[DW_OP_regx 0x3f]
$C$DW$779 .dwtag DW_TAG_TI_assign_register, DW_AT_name("BSA01")
.dwattr $C$DW$779, DW_AT_location[DW_OP_regx 0x40]
$C$DW$780 .dwtag DW_TAG_TI_assign_register, DW_AT_name("BSA23")
.dwattr $C$DW$780, DW_AT_location[DW_OP_regx 0x41]
$C$DW$781 .dwtag DW_TAG_TI_assign_register, DW_AT_name("BSA45")
.dwattr $C$DW$781, DW_AT_location[DW_OP_regx 0x42]
$C$DW$782 .dwtag DW_TAG_TI_assign_register, DW_AT_name("BSA67")
.dwattr $C$DW$782, DW_AT_location[DW_OP_regx 0x43]
$C$DW$783 .dwtag DW_TAG_TI_assign_register, DW_AT_name("BSAC")
.dwattr $C$DW$783, DW_AT_location[DW_OP_regx 0x44]
$C$DW$784 .dwtag DW_TAG_TI_assign_register, DW_AT_name("CARRY")
.dwattr $C$DW$784, DW_AT_location[DW_OP_regx 0x45]
$C$DW$785 .dwtag DW_TAG_TI_assign_register, DW_AT_name("TC1")
.dwattr $C$DW$785, DW_AT_location[DW_OP_regx 0x46]
$C$DW$786 .dwtag DW_TAG_TI_assign_register, DW_AT_name("TC2")
.dwattr $C$DW$786, DW_AT_location[DW_OP_regx 0x47]
$C$DW$787 .dwtag DW_TAG_TI_assign_register, DW_AT_name("M40")
.dwattr $C$DW$787, DW_AT_location[DW_OP_regx 0x48]
$C$DW$788 .dwtag DW_TAG_TI_assign_register, DW_AT_name("SXMD")
.dwattr $C$DW$788, DW_AT_location[DW_OP_regx 0x49]
$C$DW$789 .dwtag DW_TAG_TI_assign_register, DW_AT_name("ARMS")
.dwattr $C$DW$789, DW_AT_location[DW_OP_regx 0x4a]
$C$DW$790 .dwtag DW_TAG_TI_assign_register, DW_AT_name("C54CM")
.dwattr $C$DW$790, DW_AT_location[DW_OP_regx 0x4b]
$C$DW$791 .dwtag DW_TAG_TI_assign_register, DW_AT_name("SATA")
.dwattr $C$DW$791, DW_AT_location[DW_OP_regx 0x4c]
$C$DW$792 .dwtag DW_TAG_TI_assign_register, DW_AT_name("SATD")
.dwattr $C$DW$792, DW_AT_location[DW_OP_regx 0x4d]
$C$DW$793 .dwtag DW_TAG_TI_assign_register, DW_AT_name("RDM")
.dwattr $C$DW$793, DW_AT_location[DW_OP_regx 0x4e]
$C$DW$794 .dwtag DW_TAG_TI_assign_register, DW_AT_name("FRCT")
.dwattr $C$DW$794, DW_AT_location[DW_OP_regx 0x4f]
$C$DW$795 .dwtag DW_TAG_TI_assign_register, DW_AT_name("SMUL")
.dwattr $C$DW$795, DW_AT_location[DW_OP_regx 0x50]
$C$DW$796 .dwtag DW_TAG_TI_assign_register, DW_AT_name("INTM")
.dwattr $C$DW$796, DW_AT_location[DW_OP_regx 0x51]
$C$DW$797 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AR0LC")
.dwattr $C$DW$797, DW_AT_location[DW_OP_regx 0x52]
$C$DW$798 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AR1LC")
.dwattr $C$DW$798, DW_AT_location[DW_OP_regx 0x53]
$C$DW$799 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AR2LC")
.dwattr $C$DW$799, DW_AT_location[DW_OP_regx 0x54]
$C$DW$800 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AR3LC")
.dwattr $C$DW$800, DW_AT_location[DW_OP_regx 0x55]
$C$DW$801 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AR4LC")
.dwattr $C$DW$801, DW_AT_location[DW_OP_regx 0x56]
$C$DW$802 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AR5LC")
.dwattr $C$DW$802, DW_AT_location[DW_OP_regx 0x57]
$C$DW$803 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AR6LC")
.dwattr $C$DW$803, DW_AT_location[DW_OP_regx 0x58]
$C$DW$804 .dwtag DW_TAG_TI_assign_register, DW_AT_name("AR7LC")
.dwattr $C$DW$804, DW_AT_location[DW_OP_regx 0x59]
$C$DW$805 .dwtag DW_TAG_TI_assign_register, DW_AT_name("CDPLC")
.dwattr $C$DW$805, DW_AT_location[DW_OP_regx 0x5a]
$C$DW$806 .dwtag DW_TAG_TI_assign_register, DW_AT_name("CIE_RETA")
.dwattr $C$DW$806, DW_AT_location[DW_OP_regx 0x5b]
.dwendtag $C$DW$CU
|
data/baseStats_original/jynx.asm | adhi-thirumala/EvoYellow | 16 | 89351 | <filename>data/baseStats_original/jynx.asm<gh_stars>10-100
db DEX_JYNX ; pokedex id
db 65 ; base hp
db 50 ; base attack
db 35 ; base defense
db 95 ; base speed
db 95 ; base special
db ICE ; species type 1
db PSYCHIC ; species type 2
db 45 ; catch rate
db 137 ; base exp yield
INCBIN "pic/ymon/jynx.pic",0,1 ; 66, sprite dimensions
dw JynxPicFront
dw JynxPicBack
; attacks known at lvl 0
db POUND
db LOVELY_KISS
db 0
db 0
db 0 ; growth rate
; learnset
tmlearn 1,5,6,8
tmlearn 9,10,11,12,13,14,15
tmlearn 17,18,19,20
tmlearn 29,30,31,32
tmlearn 33,34,35,40
tmlearn 44,46
tmlearn 50
db BANK(JynxPicFront)
|
lib/src/os/Linux/startup/xstartx.asm | zanud/xds-2.60 | 21 | 91652 | <gh_stars>10-100
; COPYRIGHT (c) 1997 xTech Ltd. All Rights Reserved.
; COPYRIGHT (c) 2002, 2003 Excelsior LLC. All Rights Reserved.
;
; PE DLL initialization/termination routine
cpu 386
bits 32
section .data use32 public align=4 public 'DATA'
myHandle: dd 0
finals: dd 0 ; DLL FINALLY list head
O2modules: dd 0 ; O2 type descriptors from modules of this DLL
extern SUPPRESS_XDSLIB_FINALIZATION
; Representation of the Dl_info structure
info : dd 0 ; File name of defining object.
dd 0 ; Load address of that object.
dd 0 ; Name of nearest symbol.
dd 0 ; Exact value of nearest symbol.
section .text use32 public align=4 public 'CODE'
;EXPORT
;------
global _init
global _fini
global xDLLinit
global X2C_FINALLY
global X2C_INIT_HISTORY
global X2C_MODULE
global X2C_GetMyHandle
;//////////////////////// Entry point /////////////////////////////
extern _dllmain
extern X2C_EXITDLL
extern _IO_printf
;PROCEDURE ["C"] X2C_DISABLE_COMPONENT ( component :xmRTS.X2C_MD );
extern X2C_DISABLE_COMPONENT
;PROCEDURE ["C"] X2C_HISTORY_REG (hmod, someAddr :ADDRESS);
extern X2C_HISTORY_REG
;PROCEDURE ["C"] X2C_EXIT_HISTORY ( hmod :ADDRESS );
extern X2C_EXIT_HISTORY
;PROCEDURE ["C"] X2C_EXIT_PROFILER (isExe: BOOLEAN);
extern X2C_EXIT_PROFILER
;PROCEDURE ["C"] X2C_FINALIZE_RT ();
extern X2C_FINALIZE_RT
extern xosMalloc_init
extern dlopen
extern dladdr
extern dlclose
..start:
xDLLinit:
_init:
push info
push _init
call dladdr
add esp, 8
push dword 1
push dword [info]
call dlopen
add esp, 8
mov [myHandle], eax
push eax
call dlclose
add esp, 4
call xosMalloc_init ; initialize malloc/free as soon as possible
push dword xDLLinit ; arbitrary addr from this code segment
push dword [myHandle]
call X2C_HISTORY_REG ; register before _dllmain to may work when DLL initialization
sub esp, -08H
call _dllmain
mov eax, 1 ; rc is always TRUE
ret
_fini:
push 00H
call X2C_EXIT_PROFILER
push dword finals
call X2C_EXITDLL
add esp, 8
cmp byte [SUPPRESS_XDSLIB_FINALIZATION], 0
jne nofinalize
push dword [myHandle]
call X2C_EXIT_HISTORY ;unregister
push dword [O2modules]
call X2C_DISABLE_COMPONENT ;invalidate O2 types
add esp, 8
call X2C_FINALIZE_RT
nofinalize:
mov eax, 1 ; rc is always TRUE
ret
;xDLLinit endp
;////////////////////////// Finalization //////////////////////////
;PROCEDURE ["C"] X2C_FINALDLL ( VAR finalHead :ADDRESS; proc :PROC );
extern X2C_FINALDLL
;PROCEDURE ["C"] X2C_FINALLY ( p :PROC );
X2C_FINALLY:
mov eax, [esp+4]
push eax
push dword finals
call X2C_FINALDLL
sub esp, -08H
ret
;X2C_FINALLY endp
;///////////////////////////// History ///////////////////////////////
;PROCEDURE ["C"] X2C_HISTORY_ON ();
extern X2C_HISTORY_ON
;PROCEDURE ["C"] X2C_INIT_HISTORY();
X2C_INIT_HISTORY:
jmp X2C_HISTORY_ON ; to make showable
;X2C_INIT_HISTORY endp
;////////////////////// O2 modules unloading support /////////////////////
extern X2C_MODULEDLL
;PROCEDURE X2C_MODULEDLL (VAR component :xmRTS.X2C_MD;
; md :xmRTS.X2C_MD
; hmod :ADDRESS );
;PROCEDURE ["C"] X2C_MODULE ( md :xmRTS.X2C_MD );
X2C_MODULE:
push dword [myHandle]
mov eax, [esp+8] ;md
push eax
push dword O2modules
call X2C_MODULEDLL
sub esp, -0CH
ret
;X2C_MODULE endp
;////////////////////// DLLRTS support ///////////////////////////////////
;PROCEDURE ["C"] / X2C_GetMyHandle(): ADDRESS;
X2C_GetMyHandle:
mov eax, [myHandle]
ret
|
tests/nonsmoke/functional/CompileTests/experimental_ada_tests/tests/while_loop_statement.adb | ouankou/rose | 488 | 7593 | <gh_stars>100-1000
procedure While_Loop_Statement is
begin
while True loop
null;
end loop;
end While_Loop_Statement;
|
alloy4fun_models/trashltl/models/11/EsFt3yWwPtnzyHPJS.als | Kaixi26/org.alloytools.alloy | 0 | 2100 | <reponame>Kaixi26/org.alloytools.alloy
open main
pred idEsFt3yWwPtnzyHPJS_prop12 {
some f:File | eventually f in Trash implies always f in Trash
}
pred __repair { idEsFt3yWwPtnzyHPJS_prop12 }
check __repair { idEsFt3yWwPtnzyHPJS_prop12 <=> prop12o } |
src/test/ref/cstyle-decl-var-multiple.asm | jbrandwood/kickc | 2 | 166380 | <gh_stars>1-10
// Test legal definition of multiple local variables with the same name
// Commodore 64 PRG executable file
.file [name="cstyle-decl-var-multiple.prg", type="prg", segments="Program"]
.segmentdef Program [segments="Basic, Code, Data"]
.segmentdef Basic [start=$0801]
.segmentdef Code [start=$80d]
.segmentdef Data [startAfter="Code"]
.segment Basic
:BasicUpstart(main)
.label SCREEN = $400
.segment Code
// And a little code using them
main: {
.label c1 = 2
lda #0
sta.z c1
tay
__b1:
ldx #0
__b2:
// SCREEN[idx++] = '*'
lda #'*'
sta SCREEN,y
// SCREEN[idx++] = '*';
iny
// for( char c: 0..10)
inx
cpx #$b
bne __b2
inc.z c1
lda #$b
cmp.z c1
bne __b1
// }
rts
}
|
linear_algebra/jacobi_eigen.ads | jscparker/math_packages | 30 | 17865 | <filename>linear_algebra/jacobi_eigen.ads
--------------------------------------------------------------------------
-- package Jacobi_Eigen, Jacobi iterative eigen-decomposition
-- Copyright (C) 2008-2018 <NAME>
--
-- Permission to use, copy, modify, and/or distribute this software for any
-- purpose with or without fee is hereby granted, provided that the above
-- copyright notice and this permission notice appear in all copies.
-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-- ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-- OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
---------------------------------------------------------------------------
-- package Jacobi_Eigen
--
-- Jacobi's iterative algorithm for eigen-decomposition of
-- square real-valued symmetric matrices.
--
-- The Jacobi method converges quadratically and with high
-- reliability, but it is usually several times slower than the
-- standard Golub-Reinsch algorithm (unless the matrix is small).
-- Jacobi is usually best if accuracy and reliability are more
-- important than speed.
--
-- procedure Eigen_Decompose
--
-- Works on arbitrary diagonal blocks of input matrix. For other blocks just
-- copy the matrix to desired position; copy overhead is negligible compared
-- to the O(N^3) running time of the decomposition.
--
-- Procedure Eigen_Decompose is based on the Heinz Rutishauser ALGOL routine.
-- If you want to see the original program in its full glory, you should
-- be able to find it by googling "Rutishauser, Jacobi, Algol, ethistory".
-- It was written over half a century ago! Changes are few:
-- Slightly different calculation of the rotation angles.
-- Also a bit more care in avoiding overflows; the test suite
-- caught a few of them in the original routine.
--
generic
type Real is digits <>;
type Index is range <>;
type Matrix is array (Index, Index) of Real;
package Jacobi_Eigen is
type Col_Vector is array(Index) of Real;
-- procedure Eigen_Decompose
--
-- Standard Jacobi iterative eigendecomposition. The routine returns
-- eigenvectors and eigenvalues of any real-valued square symmetric matrix.
--
-- The orthonormal (unordered) eigenvectors are the Columns of Q.
-- The orthonormal (unordered) eigenvectors are returned as the Rows of Q'=Q_tr.
-- Eigenvals (returned in array Eigenvals) are ordered the same as Eigvecs in Q.
-- So A = QEQ'. The diagonal elements of diagonal matrix E are the eigvals.
-- The routine performs the eigen-decomposition on arbitrary square
-- diagonal blocks of matrix A.
-- It is assumed the blocks are symmetric.
-- The upper left corner of the square matrix is (Start_Col, Start_Col).
-- The lower rgt corner of the square matrix is (Final_Col, Final_Col).
-- Matrix A doesn't need to be positive definite, or semi-definite.
-- If Eigenvectors_Desired = False, then Q_tr is not calculated.
--
-- Routine only sees and operates on the upper triangle of matrix.
--
-- Input matrix A is destroyed. Save a copy of A if you need it.
--
-- Eigenvectors of A are returned as the ROWS of matrix: Q_tr
--
-- so Q_tr * A * Q = Diagonal_Eigs
--
procedure Eigen_Decompose
(A : in out Matrix; -- destroyed
Q_tr : out Matrix; -- rows of Q_tr are the eigvecs
Eigenvals : out Col_Vector;
No_of_Sweeps_Performed : out Natural;
Total_No_of_Rotations : out Natural;
Start_Col : in Index := Index'First;
Final_Col : in Index := Index'Last;
Eigenvectors_Desired : in Boolean := True);
procedure Sort_Eigs
(Eigenvals : in out Col_Vector;
Q_tr : in out Matrix; -- rows of Q_tr are the eigvecs
Start_Col : in Index := Index'First;
Final_Col : in Index := Index'Last;
Sort_Eigvecs_Also : in Boolean := True);
Standard_Threshold_Policy : constant Boolean := True;
-- True is faster.
-- False sometimes improves accuracy if the matrix is badly scaled.
end Jacobi_Eigen;
|
libsrc/_DEVELOPMENT/adt/ba_stack/c/sccz80/ba_stack_top.asm | jpoikela/z88dk | 640 | 160685 |
; int ba_stack_top(ba_stack_t *s)
SECTION code_clib
SECTION code_adt_ba_stack
PUBLIC ba_stack_top
EXTERN asm_ba_stack_top
defc ba_stack_top = asm_ba_stack_top
; SDCC bridge for Classic
IF __CLASSIC
PUBLIC _ba_stack_top
defc _ba_stack_top = ba_stack_top
ENDIF
|
programs/oeis/226/A226276.asm | neoneye/loda | 22 | 61 | ; A226276: Period 4: repeat [8, 4, 4, 4].
; 8,4,4,4,8,4,4,4,8,4,4,4,8,4,4,4,8,4,4,4,8,4,4,4,8,4,4,4,8,4,4,4,8,4,4,4,8,4,4,4,8,4,4,4,8,4,4,4,8,4,4,4,8,4,4,4,8,4,4,4,8,4,4,4,8,4,4,4,8,4,4,4,8,4,4,4,8,4,4,4,8,4,4,4
mod $0,4
pow $1,$0
mul $1,4
add $1,4
mov $0,$1
|
test/Succeed/Issue1652-3.agda | KDr2/agda | 0 | 10042 | <filename>test/Succeed/Issue1652-3.agda
{- Example by <NAME>, 17-11-2015 -}
{-# OPTIONS --rewriting --cubical-compatible #-}
open import Agda.Primitive
postulate
_↦_ : ∀ {i} {A : Set i} → A → A → Set i
idr : ∀ {i} {A : Set i} {a : A} → a ↦ a
{-# BUILTIN REWRITE _↦_ #-}
infixr 3 _==_
data _==_ {i} {A : Set i} (a : A) : A → Set i where
idp : a == a
PathOver : ∀ {i j} {A : Set i} (B : A → Set j)
{x y : A} (p : x == y) (u : B x) (v : B y) → Set j
PathOver B idp u v = (u == v)
syntax PathOver B p u v =
u == v [ B ↓ p ]
postulate
PathOver-rewr : ∀ {i j} {A : Set i} {B : Set j} {x y : A} (p : x == y) (u v : B) →
(PathOver (λ _ → B) p u v) ↦ (u == v)
{-# REWRITE PathOver-rewr #-}
ap : ∀ {i j} {A : Set i} {B : A → Set j} (f : (a : A) → B a) {x y : A}
→ (p : x == y) → PathOver B p (f x) (f y)
ap f idp = idp
module _ {i j k} {A : Set i} {B : Set j} {C : Set k} (g : B → C) (f : A → B) where
∘ap : {x y : A} (p : x == y) →
ap g (ap f p) ↦ ap (λ x → g (f x)) p
∘ap idp = idr
{-# REWRITE ∘ap #-}
ap∘ : {x y : A} (p : x == y) →
ap (λ x → g (f x)) p ↦ ap g (ap f p)
ap∘ p = idr
|
commands/media/spotify/spotify-now-playing-url.applescript | jdmcd/script-commands | 0 | 2813 | #!/usr/bin/osascript
# Required parameters:
# @raycast.schemaVersion 1
# @raycast.title Copy Current Playing Song URL
# @raycast.mode silent
# Optional parameters:
# @raycast.icon images/spotify-logo.png
# @raycast.packageName Spotify
# Documentation:
# @raycast.author <NAME>
# @raycast.authorURL https://github.com/jacc
# @raycast.description Get link to current Spotify playing song
tell application "Spotify"
set spotifyURL to spotify url of the current track
end tell
set AppleScript's text item delimiters to ":"
set idPart to third text item of spotifyURL
set the clipboard to ("https://open.spotify.com/track/" & idPart)
|
programs/oeis/301/A301684.asm | neoneye/loda | 0 | 241874 | <reponame>neoneye/loda
; A301684: Coordination sequence for node of type V2 in "krg" 2-D tiling (or net).
; 1,4,8,12,18,22,28,34,36,42,48,50,56,62,64,70,76,78,84,90,92,98,104,106,112,118,120,126,132,134,140,146,148,154,160,162,168,174,176,182,188,190,196,202,204,210,216,218,224,230,232,238,244,246,252,258,260,266,272,274,280,286,288,294,300,302,308,314,316,322,328,330,336,342,344,350,356,358,364,370,372,378,384,386,392,398,400,406,412,414,420,426,428,434,440,442,448,454,456,462
mov $3,2
mov $5,$0
lpb $3
mov $0,$5
sub $3,1
add $0,$3
trn $0,1
seq $0,301685 ; Partial sums of A301684.
mov $2,$3
mul $2,$0
add $1,$2
mov $4,$0
lpe
min $5,1
mul $5,$4
sub $1,$5
mov $0,$1
|
programs/oeis/199/A199555.asm | neoneye/loda | 22 | 165127 | ; A199555: 7*8^n+1.
; 8,57,449,3585,28673,229377,1835009,14680065,117440513,939524097,7516192769,60129542145,481036337153,3848290697217,30786325577729,246290604621825,1970324836974593,15762598695796737,126100789566373889,1008806316530991105,8070450532247928833,64563604257983430657,516508834063867445249,4132070672510939561985,33056565380087516495873,264452523040700131966977,2115620184325601055735809,16924961474604808445886465,135399691796838467567091713,1083197534374707740536733697,8665580274997661924293869569,69324642199981295394350956545,554597137599850363154807652353,4436777100798802905238461218817,35494216806390423241907689750529,283953734451123385935261518004225,2271629875608987087482092144033793,18173039004871896699856737152270337,145384312038975173598853897218162689
mov $1,8
pow $1,$0
mul $1,14
sub $1,6
div $1,2
add $1,4
mov $0,$1
|
benchmark/agda-ocaml/Fold0.agda | agda/agda-ocaml | 48 | 11344 | <reponame>agda/agda-ocaml<gh_stars>10-100
module Fold where
open import Prelude
myfold : {ac b : Set} -> (ac -> b -> ac) -> ac -> List b -> ac
#ifdef strict
myfold = foldl!
#else
myfold = foldl
#endif
|
src/aco-od.adb | jonashaggstrom/ada-canopen | 0 | 25712 | with ACO.OD_Types.Entries;
with Ada.Tags;
with Interfaces;
package body ACO.OD is
use ACO.OD_Types.Entries;
use Interfaces;
function Object
(This : Object_Dictionary'Class;
Index : Object_Index)
return Object_Ref
is
(This.Objects (This.Index_Map (Index)));
function Object_Exist
(This : Object_Dictionary'Class;
Index : Object_Index) return Boolean
is (This.Index_Map (Index) /= No_Index);
function Entry_Exist
(This : Object_Dictionary'Class;
Index : Object_Index;
Subindex : Object_Subindex) return Boolean
is
Arr_Idx : constant Index_Type := This.Index_Map (Index);
begin
return Arr_Idx /= No_Index and then
Subindex in This.Objects (Arr_Idx).Entries'Range;
end Entry_Exist;
function Maximum_Nof_Entries
(This : Object_Dictionary;
Index : Object_Index)
return Natural
is (This.Object (Index).Entries'Length);
function Is_Entry_Compatible
(This : Object_Dictionary;
An_Entry : Entry_Base'Class;
Index : Object_Index;
Subindex : Object_Subindex)
return Boolean
is
use type Ada.Tags.Tag;
OD_Entry : constant Entry_Ref := This.Object (Index).Entries (Subindex);
begin
return OD_Entry'Tag = An_Entry'Tag;
end Is_Entry_Compatible;
function Is_Entry_Writable
(This : Object_Dictionary;
Index : Entry_Index)
return Boolean
is
begin
if This.Entry_Exist (Index.Object, Index.Sub) then
return This.Object (Index.Object).Entries (Index.Sub).Is_Writable;
else
return False;
end if;
end Is_Entry_Writable;
function Is_Entry_Readable
(This : Object_Dictionary;
Index : Entry_Index)
return Boolean
is
begin
if This.Entry_Exist (Index.Object, Index.Sub) then
return This.Object (Index.Object).Entries (Index.Sub).Is_Readable;
else
return False;
end if;
end Is_Entry_Readable;
function Get_Entry
(This : Object_Dictionary;
Index : Object_Index;
Subindex : Object_Subindex) return Entry_Base'Class
is
(This.Object (Index).Entries (Subindex).all);
procedure Set_Entry
(This : in out Object_Dictionary;
New_Entry : in Entry_Base'Class;
Index : in Object_Index;
Subindex : in Object_Subindex;
Silently : in Boolean := False)
is
begin
This.Object (Index).Entries (Subindex).all := New_Entry;
if not Silently then
This.Events.Node_Events.Put
((Event => ACO.Events.OD_Entry_Update,
Index => (Index, Subindex)));
end if;
end Set_Entry;
procedure Set_Node_State
(This : in out Object_Dictionary;
Node_State : in ACO.States.State)
is
Prev : ACO.States.State;
begin
Prev := This.Node_State;
This.Node_State := Node_State;
This.Events.Node_Events.Put
((Event => ACO.Events.State_Transition,
State => (Previous => Prev, Current => Node_State)));
end Set_Node_State;
function Get_Node_State (This : Object_Dictionary) return ACO.States.State is
(This.Node_State);
function Get_Hbt_Node_Id (Reg : U32) return ACO.Messages.Node_Nr is
(ACO.Messages.Node_Nr (Shift_Right (Reg, 16) and 16#FF#));
function Get_Hbt_Slave_Subindex
(This : Object_Dictionary;
Node_Id : ACO.Messages.Node_Nr)
return Object_Subindex
is
Object : constant Object_Ref := This.Object (Heartbeat_Consumer_Index);
begin
for I in 1 .. Object.Entries'Last loop
declare
E_Ref : constant Entry_Ref := Object.Entries (I);
Reg : constant U32 := Entry_U32 (E_Ref.all).Read;
use type ACO.Messages.Node_Nr;
begin
if Get_Hbt_Node_Id (Reg) = Node_Id then
return Object_Subindex (I);
end if;
end;
end loop;
return 0; -- First entry is always max subindex, not slave data
end Get_Hbt_Slave_Subindex;
procedure Set_Heartbeat_Consumer_Period
(This : in out Object_Dictionary;
Node_Id : in ACO.Messages.Node_Nr;
Period : in Natural)
is
function Set_Hbt_Period (Reg : U32; Period : Natural) return U32 is
((Reg and 16#FFFF0000#) or (U32 (Period) and 16#FFFF#));
Subindex : Object_Subindex;
E : Entry_U32;
begin
Subindex := This.Get_Hbt_Slave_Subindex (Node_Id);
if This.Entry_Exist (Heartbeat_Consumer_Index, Subindex) then
E := Entry_U32 (This.Get_Entry (Heartbeat_Consumer_Index, Subindex));
E.Write (Set_Hbt_Period (E.Read, Period));
This.Set_Entry (E, Heartbeat_Consumer_Index, Subindex);
end if;
end Set_Heartbeat_Consumer_Period;
function Get_Heartbeat_Consumer_Period
(This : Object_Dictionary;
Node_Id : ACO.Messages.Node_Nr)
return Natural
is
function Get_Hbt_Period (Reg : U32) return Natural is
(Natural (Reg and 16#FFFF#));
Subindex : Object_Subindex;
Reg : U32;
begin
Subindex := This.Get_Hbt_Slave_Subindex (Node_Id);
if This.Entry_Exist (Heartbeat_Consumer_Index, Subindex) then
Reg := Entry_U32 (This.Get_Entry (Heartbeat_Consumer_Index, Subindex)).Read;
return Get_Hbt_Period (Reg);
else
return 0;
end if;
end Get_Heartbeat_Consumer_Period;
procedure Set_Heartbeat_Producer_Period
(This : in out Object_Dictionary;
Period : in Natural)
is
E : Entry_U16;
begin
E.Write (U16 (Period));
This.Set_Entry (E, Heartbeat_Producer_Index, 0);
end Set_Heartbeat_Producer_Period;
function Get_Heartbeat_Producer_Period
(This : Object_Dictionary)
return Natural
is
Period : U16;
begin
if This.Entry_Exist (Heartbeat_Producer_Index, 0) then
Period := Entry_U16 (This.Get_Entry (Heartbeat_Producer_Index, 0)).Read;
return Natural (Period);
else
return 0;
end if;
end Get_Heartbeat_Producer_Period;
procedure Set_Communication_Cycle_Period
(This : in out Object_Dictionary;
Period_Ms : in Natural)
is
Period_s : constant Float := Float(Period_Ms)/1000.0;
E : Entry_Dur;
begin
E.Write (Dur (Duration(Period_s)));
This.Set_Entry (E, Comm_Cycle_Period_Index, 0);
end Set_Communication_Cycle_Period;
procedure Set_Communication_Cycle_Period
(This : in out Object_Dictionary;
Period_Dur : in Duration)
is
E : Entry_Dur;
begin
E.Write (Dur (Period_Dur));
This.Set_Entry (E, Comm_Cycle_Period_Index, 0);
end Set_Communication_Cycle_Period;
function Get_Communication_Cycle_Period
(This : Object_Dictionary)
return Natural
is
Period : Dur;
begin
Period := Entry_Dur (This.Get_Entry (Comm_Cycle_Period_Index, 0)).Read;
return Natural (Period);
end Get_Communication_Cycle_Period;
function Get_Communication_Cycle_Period
(This : Object_Dictionary)
return Duration
is
Stored_Dur : Dur;
Period_Dur : Duration;
begin
Stored_Dur := Entry_Dur(This.Get_Entry (Comm_Cycle_Period_Index, 0)).Read;
Period_Dur := Duration(Stored_Dur);
return Period_Dur;
end Get_Communication_Cycle_Period;
procedure Set_Sync_Counter_Overflow
(This : in out Object_Dictionary;
Period : in Natural)
is
E : Entry_U8;
begin
E.Write (U8 (Period));
This.Set_Entry (E, Sync_Counter_Overflow_Index, 0);
end Set_Sync_Counter_Overflow;
function Get_Sync_Counter_Overflow
(This : Object_Dictionary)
return Natural
is
Period : U8;
begin
Period := Entry_U8 (This.Get_Entry (Sync_Counter_Overflow_Index, 0)).Read;
return Natural (Period);
end Get_Sync_Counter_Overflow;
function Get_SDO_Server_Parameters
(This : Object_Dictionary)
return ACO.SDO_Sessions.SDO_Parameter_Array
is
J : Object_Index := SDO_Server_Base_Index;
begin
while This.Object_Exist (J) loop
J := J + 1;
end loop;
declare
use ACO.Messages, ACO.SDO_Sessions;
Result : SDO_Parameter_Array (0 .. Natural (J - SDO_Server_Base_Index) - 1);
begin
J := SDO_Server_Base_Index;
for I in Result'Range loop
Result (I) :=
(CAN_Id_C2S =>
Id_Type (Entry_U32 (This.Get_Entry (J, 1)).Read and 16#7FF#),
CAN_Id_S2C =>
Id_Type (Entry_U32 (This.Get_Entry (J, 2)).Read and 16#7FF#),
Node =>
Node_Nr (Entry_U8 (This.Get_Entry (J, 3)).Read and 16#7F#));
J := J + 1;
end loop;
return Result;
end;
end Get_SDO_Server_Parameters;
function Get_SDO_Client_Parameters
(This : Object_Dictionary)
return ACO.SDO_Sessions.SDO_Parameter_Array
is
J : Object_Index := SDO_Client_Base_Index;
begin
while This.Object_Exist (J) loop
J := J + 1;
end loop;
declare
use ACO.Messages, ACO.SDO_Sessions;
Result : SDO_Parameter_Array (0 .. Natural (J - SDO_Client_Base_Index) - 1);
begin
J := SDO_Client_Base_Index;
for I in Result'Range loop
Result (I) :=
(CAN_Id_C2S =>
Id_Type (Entry_U32 (This.Get_Entry (J, 1)).Read and 16#7FF#),
CAN_Id_S2C =>
Id_Type (Entry_U32 (This.Get_Entry (J, 2)).Read and 16#7FF#),
Node =>
Node_Nr (Entry_U8 (This.Get_Entry (J, 3)).Read and 16#7F#));
J := J + 1;
end loop;
return Result;
end;
end Get_SDO_Client_Parameters;
end ACO.OD;
|
orka_simd/src/x86/generic/orka-simd-sse-singles-arithmetic.adb | onox/orka | 52 | 21609 | -- SPDX-License-Identifier: Apache-2.0
--
-- Copyright (c) 2016 onox <<EMAIL>>
--
-- 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.
with Orka.SIMD.SSE.Singles.Compare;
with Orka.SIMD.SSE.Singles.Logical;
with Orka.SIMD.SSE.Singles.Swizzle;
package body Orka.SIMD.SSE.Singles.Arithmetic is
function "*" (Left, Right : m128_Array) return m128_Array is
Result : m128_Array;
begin
for I in Index_Homogeneous'Range loop
Result (I) := Left * Right (I);
end loop;
return Result;
end "*";
function "*" (Left : m128_Array; Right : m128) return m128 is
use SIMD.SSE.Singles.Swizzle;
Mask_0_0_0_0 : constant Unsigned_32 := 0 or 0 * 4 or 0 * 16 or 0 * 64;
Mask_1_1_1_1 : constant Unsigned_32 := 1 or 1 * 4 or 1 * 16 or 1 * 64;
Mask_2_2_2_2 : constant Unsigned_32 := 2 or 2 * 4 or 2 * 16 or 2 * 64;
Mask_3_3_3_3 : constant Unsigned_32 := 3 or 3 * 4 or 3 * 16 or 3 * 64;
XXXX, YYYY, ZZZZ, WWWW, M0, M1, M2, M3 : m128;
begin
XXXX := Shuffle (Right, Right, Mask_0_0_0_0);
YYYY := Shuffle (Right, Right, Mask_1_1_1_1);
ZZZZ := Shuffle (Right, Right, Mask_2_2_2_2);
WWWW := Shuffle (Right, Right, Mask_3_3_3_3);
M0 := XXXX * Left (X);
M1 := YYYY * Left (Y);
M2 := ZZZZ * Left (Z);
M3 := WWWW * Left (W);
M0 := M0 + M1;
M2 := M2 + M3;
return M0 + M2;
end "*";
function Divide_Or_Zero (Left, Right : m128) return m128 is
use SIMD.SSE.Singles.Compare;
use SIMD.SSE.Singles.Logical;
-- Create a mask with all 1's for each element that is non-zero
Zero : constant m128 := (0.0, 0.0, 0.0, 0.0);
Mask : constant m128 := Zero /= Right;
Normalized : constant m128 := Left / Right;
begin
-- Any element in Right that is zero will result in a
-- corresponding element consisting of all 0's in the Mask.
-- This will avoid the divide-by-zero exception when dividing.
return Mask and Normalized;
end Divide_Or_Zero;
function "abs" (Elements : m128) return m128 is
use SIMD.SSE.Singles.Logical;
begin
return And_Not ((-0.0, -0.0, -0.0, -0.0), Elements);
end "abs";
function Sum (Elements : m128) return Float_32 is
use SIMD.SSE.Singles.Swizzle;
-- From https://stackoverflow.com/a/35270026
Mask_1_0_3_2 : constant Unsigned_32 := 1 or 0 * 4 or 3 * 16 or 2 * 64;
-- Elements: X Y Z W
-- Shuffled: Y X W Z
-- --------------- +
-- Sum: X+Y X+Y Z+W Z+W
Shuffled : constant m128 := Shuffle (Elements, Elements, Mask_1_0_3_2);
Sum : constant m128 := Elements + Shuffled;
-- Sum: X+Y X+Y Z+W Z+W
-- Move: Z+W Z+W W Z
-- --------------- +
-- New sum: X+Y+Z+W . . .
Result : constant m128 := Move_HL (Shuffled, Sum) + Sum;
begin
return Result (X);
end Sum;
end Orka.SIMD.SSE.Singles.Arithmetic;
|
bb-runtimes/arm/sam/samv71/svd/i-sam.ads | JCGobbi/Nucleo-STM32G474RE | 0 | 432 | <gh_stars>0
--
-- Copyright (C) 2019, AdaCore
--
-- This spec has been automatically generated from ATSAMV71Q21.svd
pragma Ada_2012;
pragma Style_Checks (Off);
with System;
-- Microchip ATSAMV71Q21 Microcontroller
package Interfaces.SAM is
pragma Preelaborate;
pragma No_Elaboration_Code_All;
---------------
-- Base type --
---------------
type UInt32 is new Interfaces.Unsigned_32;
type UInt16 is new Interfaces.Unsigned_16;
type Byte is new Interfaces.Unsigned_8;
type Bit is mod 2**1
with Size => 1;
type UInt2 is mod 2**2
with Size => 2;
type UInt3 is mod 2**3
with Size => 3;
type UInt4 is mod 2**4
with Size => 4;
type UInt5 is mod 2**5
with Size => 5;
type UInt6 is mod 2**6
with Size => 6;
type UInt7 is mod 2**7
with Size => 7;
type UInt9 is mod 2**9
with Size => 9;
type UInt10 is mod 2**10
with Size => 10;
type UInt11 is mod 2**11
with Size => 11;
type UInt12 is mod 2**12
with Size => 12;
type UInt13 is mod 2**13
with Size => 13;
type UInt14 is mod 2**14
with Size => 14;
type UInt15 is mod 2**15
with Size => 15;
type UInt17 is mod 2**17
with Size => 17;
type UInt18 is mod 2**18
with Size => 18;
type UInt19 is mod 2**19
with Size => 19;
type UInt20 is mod 2**20
with Size => 20;
type UInt21 is mod 2**21
with Size => 21;
type UInt22 is mod 2**22
with Size => 22;
type UInt23 is mod 2**23
with Size => 23;
type UInt24 is mod 2**24
with Size => 24;
type UInt25 is mod 2**25
with Size => 25;
type UInt26 is mod 2**26
with Size => 26;
type UInt27 is mod 2**27
with Size => 27;
type UInt28 is mod 2**28
with Size => 28;
type UInt29 is mod 2**29
with Size => 29;
type UInt30 is mod 2**30
with Size => 30;
type UInt31 is mod 2**31
with Size => 31;
--------------------
-- Base addresses --
--------------------
ACC_Base : constant System.Address :=
System'To_Address (16#40044000#);
AES_Base : constant System.Address :=
System'To_Address (16#4006C000#);
AFEC0_Base : constant System.Address :=
System'To_Address (16#4003C000#);
AFEC1_Base : constant System.Address :=
System'To_Address (16#40064000#);
CHIPID_Base : constant System.Address :=
System'To_Address (16#400E0940#);
DACC_Base : constant System.Address :=
System'To_Address (16#40040000#);
EFC_Base : constant System.Address :=
System'To_Address (16#400E0C00#);
GMAC_Base : constant System.Address :=
System'To_Address (16#40050000#);
GPBR_Base : constant System.Address :=
System'To_Address (16#400E1890#);
HSMCI_Base : constant System.Address :=
System'To_Address (16#40000000#);
ICM_Base : constant System.Address :=
System'To_Address (16#40048000#);
ISI_Base : constant System.Address :=
System'To_Address (16#4004C000#);
MATRIX_Base : constant System.Address :=
System'To_Address (16#40088000#);
MCAN0_Base : constant System.Address :=
System'To_Address (16#40030000#);
MCAN1_Base : constant System.Address :=
System'To_Address (16#40034000#);
MLB_Base : constant System.Address :=
System'To_Address (16#40068000#);
PIOA_Base : constant System.Address :=
System'To_Address (16#400E0E00#);
PIOB_Base : constant System.Address :=
System'To_Address (16#400E1000#);
PIOC_Base : constant System.Address :=
System'To_Address (16#400E1200#);
PIOD_Base : constant System.Address :=
System'To_Address (16#400E1400#);
PIOE_Base : constant System.Address :=
System'To_Address (16#400E1600#);
PMC_Base : constant System.Address :=
System'To_Address (16#400E0600#);
PWM0_Base : constant System.Address :=
System'To_Address (16#40020000#);
PWM1_Base : constant System.Address :=
System'To_Address (16#4005C000#);
QSPI_Base : constant System.Address :=
System'To_Address (16#4007C000#);
RSTC_Base : constant System.Address :=
System'To_Address (16#400E1800#);
RSWDT_Base : constant System.Address :=
System'To_Address (16#400E1900#);
RTC_Base : constant System.Address :=
System'To_Address (16#400E1860#);
RTT_Base : constant System.Address :=
System'To_Address (16#400E1830#);
SDRAMC_Base : constant System.Address :=
System'To_Address (16#40084000#);
SMC_Base : constant System.Address :=
System'To_Address (16#40080000#);
SPI0_Base : constant System.Address :=
System'To_Address (16#40008000#);
SPI1_Base : constant System.Address :=
System'To_Address (16#40058000#);
SSC_Base : constant System.Address :=
System'To_Address (16#40004000#);
SUPC_Base : constant System.Address :=
System'To_Address (16#400E1810#);
TC0_Base : constant System.Address :=
System'To_Address (16#4000C000#);
TC1_Base : constant System.Address :=
System'To_Address (16#40010000#);
TC2_Base : constant System.Address :=
System'To_Address (16#40014000#);
TC3_Base : constant System.Address :=
System'To_Address (16#40054000#);
TRNG_Base : constant System.Address :=
System'To_Address (16#40070000#);
TWIHS0_Base : constant System.Address :=
System'To_Address (16#40018000#);
TWIHS1_Base : constant System.Address :=
System'To_Address (16#4001C000#);
TWIHS2_Base : constant System.Address :=
System'To_Address (16#40060000#);
UART0_Base : constant System.Address :=
System'To_Address (16#400E0800#);
UART1_Base : constant System.Address :=
System'To_Address (16#400E0A00#);
UART2_Base : constant System.Address :=
System'To_Address (16#400E1A00#);
UART3_Base : constant System.Address :=
System'To_Address (16#400E1C00#);
UART4_Base : constant System.Address :=
System'To_Address (16#400E1E00#);
USART0_Base : constant System.Address :=
System'To_Address (16#40024000#);
USART1_Base : constant System.Address :=
System'To_Address (16#40028000#);
USART2_Base : constant System.Address :=
System'To_Address (16#4002C000#);
USBHS_Base : constant System.Address :=
System'To_Address (16#40038000#);
UTMI_Base : constant System.Address :=
System'To_Address (16#400E0400#);
WDT_Base : constant System.Address :=
System'To_Address (16#400E1850#);
XDMAC_Base : constant System.Address :=
System'To_Address (16#40078000#);
LOCKBIT_Base : constant System.Address :=
System'To_Address (16#0#);
SystemControl_Base : constant System.Address :=
System'To_Address (16#E000E000#);
SysTick_Base : constant System.Address :=
System'To_Address (16#E000E010#);
NVIC_Base : constant System.Address :=
System'To_Address (16#E000E100#);
MPU_Base : constant System.Address :=
System'To_Address (16#E000ED90#);
FPU_Base : constant System.Address :=
System'To_Address (16#E000EF34#);
end Interfaces.SAM;
|
programs/oeis/173/A173235.asm | neoneye/loda | 22 | 167103 | <filename>programs/oeis/173/A173235.asm
; A173235: a(n) = n^(n-1) + n - 1.
; 1,3,11,67,629,7781,117655,2097159,43046729,1000000009,25937424611,743008370699,23298085122493,793714773254157,29192926025390639,1152921504606846991,48661191875666868497,2185911559738696531985,104127350297911241532859
mov $2,1
add $2,$0
pow $2,$0
add $0,$2
|
internal/grammar/AnnotationGrammar.g4 | speechly/nlu-rule-parser | 21 | 4724 | grammar AnnotationGrammar;
/*
* Parser Rules
*/
annotation : utterance+ EOF ;
utterance : (reply)+ END*;
reply : WHITESPACE* intent_name (text | entity)+ ;
text : (WORD | WHITESPACE)+ ;
entity : entity_value entity_name ;
entity_value : OPEN_SB text CLOSE_SB ;
entity_name : OPEN_PAREN WORD CLOSE_PAREN ;
intent_name : INTENT_NAME_START WORD WHITESPACE* ;
/*
* Lexer Rules
*/
INTENT_NAME_START : '*' ;
OPEN_PAREN : '(' ;
CLOSE_PAREN : ')' ;
OPEN_SB : '[' ;
CLOSE_SB : ']' ;
WORD : ~('['|']'|'('|')'|' '|'*'|'\n'|'\t')+ ;
END : WHITESPACE* '\n'+ ;
WHITESPACE : (' ' | '\t')+ ;
|
FinalProject.asm | abdukarima/Comp.-Arch-Org-project.- | 1 | 83332 | .data
w: .asciiz "w"
r: .asciiz "r"
bigr: .asciiz "R"
bigw: .asciiz "W"
rowOne: .asciiz "row 1: "
columnOne: .asciiz "column 1: "
rowTwo: .asciiz "row 2: "
columnTwo: .asciiz "column 2: "
wrongColor: .asciiz "error: (r1,c1) either has wrong color or no game piece \n"
impossible: .asciiz "error: illegal move or jump \n"
redWins: .asciiz "Red wins!"
whiteWins: .asciiz "White wins!"
userPrompt: .asciiz "Enter 0 to go first, or 1 to go second: "
nl: .asciiz "\n"
.globl main
.code
main:
addi $sp,$sp,-384 # stores 2D jump array, 24 * 4 * 4 = 384
mov $t0,$sp
mov $s6,$sp
setZeroJump: #initialize 2D jump array to all zeroes
sw $0,0($t0)
addi $t0,$t0,4
blt $t0,96,setZeroJump
addi $sp,$sp,-384 # stores 2D move array, 24 * 4 * 4 = 384
mov $t0,$sp
mov $s7,$sp
setZeroMove: #initialize 2D move array to all zeroes
sw $0,0($t0)
addi $t0,$t0,4
blt $t0,96,setZeroMove
jal board
la $a0,userPrompt
syscall $print_string
syscall $read_int
mov $s1,$v0
li $s2,6 # $s2 = redPieceCount
li $s3,6 # $s3 = whitePieceCount
loop:
la $a0,nl
syscall $print_string
jal displayBoard
addi $sp,$sp,-20
beq $s1,0,userTurn
getValid:
mov $a1,$s0 #$a1 = $s0 = board pointer
mov $a2,$s6 #$a2 is pointer to *tupleList
li $a3,1
jal getValidJumps
beq $v1,$0,noJumps
j tryAgain
noJumps:
mov $a1,$s0 #$a1 = $s0 = board pointer
mov $a2,$s7 #$a2 is pointer to *tupleList
li $a3,1
jal getValidMoves
j movesLFSR
tryAgain:
syscall $random
mov $a1,$v0 #sets initial LFSR state to the random number
li $t4,0 # count = 0
li $t5,0 #set inital LSB to zero
randomNum:
jal LFSR
or $t5,$t5,$t2 # add new LSB to previous total
sll $t5,$t5,1 # shift LSB to the left 1, store result in $s1
addi $t4,$t4,1 #increment count by 1
blt $t4,4,randomNum #calls state = LFSR(state) 4 times
jal LFSR #calls state one last time, to add the last LSB
or $t5,$t5,$t2
rem $t5,$t5,$v1
mov $a1,$s6
mov $a2,$t5 #pass random 0-23 LFSR number to printTuples
j afterRandom
movesLFSR:
syscall $random
mov $a1,$v0 #sets initial LFSR state to the random number
li $t4,0 # count = 0
li $t5,0 #set inital LSB to zero
randomNumber:
jal LFSR
or $t5,$t5,$t2 # add new LSB to previous total
sll $t5,$t5,1 # shift LSB to the left 1, store result in $s1
addi $t4,$t4,1 #increment count by 1
blt $t4,4,randomNumber #calls state = LFSR(state) 4 times
jal LFSR #calls state one last time, to add the last LSB
or $t5,$t5,$t2
rem $t5,$t5,$v1
mov $a1,$s7
mov $a2,$t5 #pass random 0-23 LFSR number to printTuples
afterRandom:
jal passTuples
j afterComputer
userTurn:
sw $s0,16($sp)
la $a0,rowOne
syscall $print_string
syscall $read_int
mov $t0,$v0 # $t0 = r1
sw $v0,12($sp)
la $a0,columnOne
syscall $print_string
syscall $read_int
mov $t1,$v0 # $t1 = c1
sw $v0,8($sp)
la $a0,rowTwo
syscall $print_string
syscall $read_int
sw $v0,4($sp)
la $a0,columnTwo
syscall $print_string
syscall $read_int
sw $v0,0($sp)
afterComputer:
lw $t0,12($sp)
lw $t1,8($sp)
sub $t0,$0,$t0
addi $t0,$t0,5
mul $t0,$t0,6
add $t1,$t0,$t1
mul $t1,$t1,4 # ((5-row)*6 + column) * 4 = $t1
add $t1,$s0,$t1 # add $s0 board pointer to coordinate to find array offset
lw $s4,0($t1) # $s4 = the value of the game piece at (r1,c1)
sub $t3,$s4,1 # 1 - 1 = 0 (checks if red)
beq $t3,$s1,currentColor
sub $t3,$s4,5 # 5 - 5 = 0 (checks if red king)
beq $t3,$s1,currentColor
sub $t3,$s4,2 # 3 - 2 = 1 (checks if white)
beq $t3,$s1,currentColor
sub $t3,$s4,6 # 7 - 6 = 1 (checks if white king)
beq $t3,$s1,currentColor
la $a0,wrongColor
syscall $print_string
addi $sp,$sp,20
j loop
currentColor:
jal isValidJump
beq $v1,1,jump
jal isValidMove
beq $v1,1,moveGamePiece
la $a0,impossible
syscall $print_string
addi $sp,$sp,20
j loop
jump:
lw $t0,12($sp) # $t0 = r1
lw $t1,8($sp) # $t1 = c1
lw $t2,4($sp) # $t2 = r2
lw $t3,0($sp) # $t3 = c2
sub $t4,$0,$t2
addi $t4,$t4,5
mul $t4,$t4,6
add $t4,$t4,$t3
mul $t4,$t4,4 # ((5-row)*6 + column) * 4 = $t4
add $t4,$s0,$t4 # add $s0 board pointer to coordinate to find array offset
sw $s4,0($t4) # moving value ($s4) of game piece at coord (r1,c1) to new coord (r2,c2)
sub $t4,$0,$t0
addi $t4,$t4,5
mul $t4,$t4,6
add $t4,$t4,$t1
mul $t4,$t4,4 # ((5-row)*6 + column) * 4 = $t4
add $t4,$s0,$t4 # add $s0 board pointer to coordinate to find array offset
sw $0,0($t4) # delete game piece from (r1,c1)
add $t4,$t0,$t2
div $t4,$t4,2 # $t4 = rm
add $t5,$t1,$t3
div $t5,$t5,2 # $t5 = cm
sub $t4,$0,$t4
addi $t4,$t4,5
mul $t4,$t4,6
add $t5,$t4,$t5
mul $t5,$t5,4 # ((5-row)*6 + column) * 4 = $t5
add $t5,$s0,$t5 # add $s0 board pointer to coordinate to find array offset
sw $0,0($t5) # delete game piece from (rm,cm)
beq $s1,0,decrementWhite #if $s1 = 0, then color = red, so the red piece removes the white piece
decrementRed:
addi $s2,$s2,-1
j kingMeCheckJump
decrementWhite:
addi $s3,$s3,-1
kingMeCheckJump:
beq $s1,0,kingMeCheckRedJump
beq $s1,1,kingMeCheckWhiteJump
j exitCheck
kingMeCheckRedJump:
beq $t2,5,kingMeRedJump
j exitCheck
kingMeCheckWhiteJump:
beq $t2,0,kingMeWhiteJump
j exitCheck
kingMeRedJump:
sub $t4,$0,$t2 # $t2 = r2
addi $t4,$t4,5
mul $t4,$t4,6
add $t4,$t4,$t3 # $t3 = c2
mul $t4,$t4,4
add $t4,$s0,$t4
li $t5,5 # $t5 = 5 = red king
sw $t5,0($t4) # convert (r2,c2) to a red king
j exitCheck
kingMeWhiteJump:
sub $t4,$0,$t2 # $t2 = r2
addi $t4,$t4,5
mul $t4,$t4,6
add $t4,$t4,$t3 # $t3 = c2
mul $t4,$t4,4
add $t4,$s0,$t4
li $t5,7 # $t5 = 7 = white king
sw $t5,0($t4) # convert (r2,c2) to a white king
j exitCheck
moveGamePiece:
lw $t0,12($sp) # $t0 = r1
lw $t1,8($sp) # $t1 = c1
lw $t2,4($sp) # $t2 = r2
lw $t3,0($sp) # $t3 = c2
sub $t4,$0,$t2
addi $t4,$t4,5
mul $t4,$t4,6
add $t4,$t4,$t3
mul $t4,$t4,4 # ((5-row)*6 + column) * 4 = $t4
add $t4,$s0,$t4 # add $s0 board pointer to coordinate to find array offset
sw $s4,0($t4) # moving value ($s4) of game piece at coord (r1,c1) to new coord (r2,c2)
sub $t4,$0,$t0
addi $t4,$t4,5
mul $t4,$t4,6
add $t4,$t4,$t1
mul $t4,$t4,4 # ((5-row)*6 + column) * 4 = $t4
add $t4,$s0,$t4 # add $s0 board pointer to coordinate to find array offset
sw $0,0($t4) # delete game piece from (r1,c1)
beq $s1,0,kingMeCheckRedMove
kingMeCheckWhiteMove:
beq $t2,0,kingMeWhiteMove
j changeColor
kingMeCheckRedMove:
beq $t2,5,kingMeRedMove
j changeColor
kingMeRedMove:
sub $t4,$0,$t2 # $t2 = r2
addi $t4,$t4,5
mul $t4,$t4,6
add $t4,$t4,$t3 # $t3 = c2
mul $t4,$t4,4
add $t4,$s0,$t4
li $t5,5 # $t5 = 5 = red king
sw $t5,0($t4) # convert (r2,c2) to a red king
j changeColor
kingMeWhiteMove:
sub $t4,$0,$t2 # $t2 = r2
addi $t4,$t4,5
mul $t4,$t4,6
add $t4,$t4,$t3 # $t3 = c2
mul $t4,$t4,4
add $t4,$s0,$t4
li $t5,7 # $t5 = 7 = white king
sw $t5,0($t4) # convert (r2,c2) to a white king
j changeColor
exitCheck:
beq $s2,0,winnerWhite
beq $s3,0,winnerRed
j changeColor
changeColor:
addi $sp,$sp,20
beq $s1,0,whitesTurn
j redsTurn
whitesTurn:
li $s1,1
j loop
redsTurn:
li $s1,0
j loop
winnerRed:
la $a0,redWins
syscall $print_string
j exit
winnerWhite:
la $a0,whiteWins
syscall $print_string
exit:
syscall $exit
LFSR: # state = (state >> 1) ^ (-(state & 0x00000001) & taps)
li $t0,0xCA000 # taps = x^20 + x^19 + x^16 + x^14 + 1 = 1100 1010 0000 0000 0000 = 0xCA000
srl $t1,$a1,1
andi $t2,$a1,0x00000001 # $t2 = LSB = state & 0x00000001
neg $t3,$t2
and $t3,$t3,$t0
xor $a1,$t1,$t3
jr $ra
passTuples:
sw $s0,16($sp)
mul $t1,$a2,16
add $t1,$a1,$t1
lw $t2,0($t1)
sw $t2,12($sp)
mul $t1,$a2,4 # (row * 4 + column) * 4 = $t1
addi $t1,$t1,1
mul $t1,$t1,4
add $t1,$a1,$t1
lw $t3,0($t1)
sw $t3,8($sp)
mul $t1,$a2,4
addi $t1,$t1,2
mul $t1,$t1,4
add $t1,$a1,$t1
lw $t4,0($t1)
add $t2,$t2,$t4 # add the offset for r2 and c2
sw $t2,4($sp)
mul $t1,$a2,4
addi $t1,$t1,3
mul $t1,$t1,4
add $t1,$a1,$t1
lw $t4,0($t1)
add $t3,$t3,$t4
sw $t3,0($sp)
jr $ra
getValidJumps: # (int *board, int *tupleList, int color)
addi $sp,$sp,-8
sw $a3,4($sp)
sw $ra,0($sp)
li $t0,0 # $t0 = total
li $t1,0 # $t1 = r1
j tuplesJumpTest1
tuplesJumpLoop1:
li $t2,0 # $t2 = c1
j tuplesJumpTest2
tuplesJumpLoop2:
li $t3,-2 # $t3 = r2
j tuplesJumpTest3
tuplesJumpLoop3:
li $t4,-2 # $t4 = c2
j tuplesJumpTest4
tuplesJumpLoop4:
addi $sp,$sp,-40 #allocate space for the 5 arguments for isValidMove, and the 5 temporary variables
sw $t0,36($sp)
sw $t1,32($sp)
sw $t2,28($sp)
sw $t3,24($sp)
sw $t4,20($sp)
sw $s0,16($sp) #16 + 384 ???????????
sw $t1,12($sp)
sw $t2,8($sp)
add $t5,$t1,$t3 #add row1 + row2 offset together to pass to isValidMove
sw $t5,4($sp)
add $t5,$t2,$t4
sw $t5,0($sp) #use $s0 instead of $sp, since $s0 refers to board pointer
sub $t4,$0,$t1
addi $t4,$t4,5
mul $t4,$t4,6
add $t5,$t4,$t2
mul $t5,$t5,4 # ((5-row)*6 + column) * 4 = $t1
add $t4,$s0,$t5
lw $t4,0($t4) # $t4 = the stack offset to store the value
sub $t5,$t4,1 #1-1= 0
beq $t5,$a3,checkJumpColor
sub $t5,$t4,5 #5-5=0
beq $t5,$a3,checkJumpColor
sub $t5,$t4,2 #3 - 2 =1
beq $t5,$a3,checkJumpColor
sub $t5,$t4,6 #7 - 6 = 1
beq $t5,$a3,checkJumpColor
j tuplesJumpNext
checkJumpColor:
jal isValidJump
# addi $sp,$sp,20 #deallocate space for the 5 arguments for isValidMove
mov $a2,$s6 # move pointer to validJumps array to $a2
lw $t0,36($sp)
lw $t1,32($sp)
lw $t2,28($sp)
lw $t3,24($sp)
lw $t4,20($sp)
beq $v1,1,tuplesJumpStorage
j tuplesJumpNext
tuplesJumpStorage: # (total)*4 + column) * 4 = $a1
mul $t5,$t0,16
add $t5,$a2,$t5
sw $t1,0($t5)
mul $t5,$t0,4
addi $t5,$t5,1
mul $t5,$t5,4
add $t5,$a2,$t5
sw $t2,0($t5)
mul $t5,$t0,4
addi $t5,$t5,2
mul $t5,$t5,4
add $t5,$a2,$t5
sw $t3,0($t5)
mul $t5,$t0,4
addi $t5,$t5,3
mul $t5,$t5,4
add $t5,$a2,$t5
sw $t4,0($t5)
addi $t0,$t0,1
beq $t0,24,tuplesJumpEnd
tuplesJumpNext:
addi $sp,$sp,40 #deallocate space for the 10 arguments for isValidMove
lw $a3,4($sp)
addi $t4,$t4,4
tuplesJumpTest4:
ble $t4,2,tuplesJumpLoop4
addi $t3,$t3,4
tuplesJumpTest3:
ble $t3,2,tuplesJumpLoop3
addi $t2,$t2,1
tuplesJumpTest2:
blt $t2,6,tuplesJumpLoop2
addi $t1,$t1,1
tuplesJumpTest1:
blt $t1,6,tuplesJumpLoop1
tuplesJumpEnd:
lw $ra,0($sp)
addi $sp,$sp,8
mov $v1,$t0
jr $ra
getValidMoves: # (int *board, int *tupleList, int color)
addi $sp,$sp,-8
sw $a3,4($sp) #store color=0 in 4($sp)
sw $ra,0($sp) #$s0 stores board pointer, $s1 is already in use by other functions, $s2 stores tuplesPointer
li $t0,0 # $t0 = total
li $t1,0 # $t1 = r1
j tuplesTest1
tuplesLoop1:
li $t2,0 # $t2 = c1
j tuplesTest2
tuplesLoop2:
li $t3,-1 # $t3 = r2
j tuplesTest3
tuplesLoop3:
li $t4,-1 # $t4 = c2
j tuplesTest4
tuplesLoop4:
addi $sp,$sp,-40 #allocate space for the 5 arguments for isValidMove, and the 5 temporary variables
sw $t0,36($sp)
sw $t1,32($sp)
sw $t2,28($sp)
sw $t3,24($sp)
sw $t4,20($sp)
sw $s0,16($sp) #16 + 384 ???????????
sw $t1,12($sp)
sw $t2,8($sp)
add $t5,$t1,$t3 #add row1 + row2 offset together to pass to isValidMove
sw $t5,4($sp)
add $t5,$t2,$t4
sw $t5,0($sp) #use $s0 instead of $sp, since $s0 refers to board pointer
sub $t4,$0,$t1
addi $t4,$t4,5
mul $t4,$t4,6
add $t5,$t4,$t2
mul $t5,$t5,4 # ((5-row)*6 + column) * 4 = $t1
add $t4,$s0,$t5
lw $t4,0($t4) # $t4 = the stack offset to store the value
sub $t5,$t4,1 #1-1= 0
beq $t5,$a3,checkColor
sub $t5,$t4,5 #5-5=0
beq $t5,$a3,checkColor
sub $t5,$t4,2 #3 - 2 =1
beq $t5,$a3,checkColor
sub $t5,$t4,6 #7 - 6 = 1
beq $t5,$a3,checkColor
j tuplesNext
checkColor:
jal isValidMove
mov $a2,$s7 # move pointer to tupleList to $a2
lw $t0,36($sp)
lw $t1,32($sp)
lw $t2,28($sp)
lw $t3,24($sp)
lw $t4,20($sp)
beq $v1,1,tuplesStorage
j tuplesNext
tuplesStorage: # (total)*4 + column) * 4 = $a1
mul $t5,$t0,16
add $t5,$a2,$t5
sw $t1,0($t5)
mul $t5,$t0,4
addi $t5,$t5,1
mul $t5,$t5,4
add $t5,$a2,$t5
sw $t2,0($t5)
mul $t5,$t0,4
addi $t5,$t5,2
mul $t5,$t5,4
add $t5,$a2,$t5
sw $t3,0($t5)
mul $t5,$t0,4
addi $t5,$t5,3
mul $t5,$t5,4
add $t5,$a2,$t5
sw $t4,0($t5)
addi $t0,$t0,1
beq $t0,24,tuplesEnd
tuplesNext:
addi $sp,$sp,40 #deallocate space for the 10 arguments for isValidMove
lw $a3,4($sp)
addi $t4,$t4,2
tuplesTest4:
ble $t4,1,tuplesLoop4
addi $t3,$t3,2
tuplesTest3:
ble $t3,1,tuplesLoop3
addi $t2,$t2,1
tuplesTest2:
blt $t2,6,tuplesLoop2
addi $t1,$t1,1
tuplesTest1:
blt $t1,6,tuplesLoop1
tuplesEnd:
lw $ra,0($sp)
addi $sp,$sp,8
mov $v1,$t0
jr $ra
isValidJump:
lw $s0,16($sp) # load pointer to checkerBoard in $s0
lw $t1,12($sp) # load the 2 pairs of coordinates in $t0 to $t3
lw $t2,8($sp)
lw $t3,4($sp)
lw $t4,0($sp)
mov $a1,$t1 #check each pair of coords for validity
mov $a2,$t2
addi $sp,$sp,-4
sw $ra,0($sp)
jal isLegalPosition
beq $v1,0,badJump
mov $a1,$t3
mov $a2,$t4
jal isLegalPosition
beq $v1,0,badJump
sub $t5,$0,$t1
addi $t5,$t5,5
mul $t5,$t5,6
add $t5,$t5,$t2
mul $t5,$t5,4 # ((5-row)*6 + column) * 4 = $t5
add $t5,$s0,$t5
lw $t5,0($t5) # $t4 = the stack offset to store the value
li $v1,1
beq $t5,1,redJump
beq $t5,3,whiteJump
beq $t5,5,redKingJump
beq $t5,7,whiteKingJump
j badJump
redJump:
sub $t5,$t1,$t3
bne $t5,-2,badJump # (r1-r2)==-2)
sub $t5,$t2,$t4
abs $t5,$t5
bne $t5,2,badJump # abs(c1-c2)==2
sub $t5,$0,$t3
addi $t5,$t5,5
mul $t5,$t5,6
add $t5,$t5,$t4
mul $t5,$t5,4 # ((5-row)*6 + column) * 4 = $t5
add $t5,$s0,$t5
lw $t5,0($t5) # $t4 = the stack offset to store the value
bne $t5,0,badJump # !board[r2][c2]
add $t5,$t1,$t3
srl $t5,$t5,1
add $t6,$t2,$t4
srl $t6,$t6,1
sub $t5,$0,$t5
addi $t5,$t5,5
mul $t5,$t5,6
add $t6,$t5,$t6
mul $t6,$t6,4 # ((5-row)*6 + column) * 4 = $t5
add $t6,$s0,$t6
lw $t6,0($t6) # $t4 = the stack offset to store the value
bne $t6,3,badJumpTestRed # (board[rm][cm]==3)
j finish
badJumpTestRed:
bne $t6,7,badJump # (board[rm][cm]==7)
j finish
badJumpTestWhite:
bne $t6,5,badJump
j finish
whiteJump:
sub $t5,$t1,$t3
bne $t5,2,badJump # (r1-r2)==-2)
sub $t5,$t2,$t4
abs $t5,$t5
bne $t5,2,badJump # abs(c1-c2)==2
sub $t5,$0,$t3
addi $t5,$t5,5
mul $t5,$t5,6
add $t5,$t5,$t4
mul $t5,$t5,4 # ((5-row)*6 + column) * 4 = $t5
add $t5,$s0,$t5
lw $t5,0($t5) # $t4 = the stack offset to store the value
bne $t5,0,badJump # !board[r2][c2]
add $t5,$t1,$t3
srl $t5,$t5,1
add $t6,$t2,$t4
srl $t6,$t6,1
sub $t5,$0,$t5
addi $t5,$t5,5
mul $t5,$t5,6
add $t6,$t5,$t6
mul $t6,$t6,4 # ((5-row)*6 + column) * 4 = $t5
add $t6,$s0,$t6
lw $t6,0($t6) # $t4 = the stack offset to store the value
bne $t6,1,badJumpTestWhite # (board[rm][cm]==3)
j finish
redKingJump:
sub $t5,$t1,$t3
abs $t5,$t5
bne $t5,2,badJump # (r1-r2)==-2)
sub $t5,$t2,$t4
abs $t5,$t5
bne $t5,2,badJump # abs(c1-c2)==2
sub $t5,$0,$t3
addi $t5,$t5,5
mul $t5,$t5,6
add $t5,$t5,$t4
mul $t5,$t5,4 # ((5-row)*6 + column) * 4 = $t5
add $t5,$s0,$t5
lw $t5,0($t5) # $t4 = the stack offset to store the value
bne $t5,0,badJump # !board[r2][c2]
add $t5,$t1,$t3
srl $t5,$t5,1
add $t6,$t2,$t4
srl $t6,$t6,1
sub $t5,$0,$t5
addi $t5,$t5,5
mul $t5,$t5,6
add $t6,$t5,$t6
mul $t6,$t6,4 # ((5-row)*6 + column) * 4 = $t5
add $t6,$s0,$t6
lw $t6,0($t6) # $t4 = the stack offset to store the value
bne $t6,3,badJumpTestRed # (board[rm][cm]==3)
j finish
whiteKingJump:
sub $t5,$t1,$t3
abs $t5,$t5
bne $t5,2,badJump # (r1-r2)==-2)
sub $t5,$t2,$t4
abs $t5,$t5
bne $t5,2,badJump # abs(c1-c2)==2
sub $t5,$0,$t3
addi $t5,$t5,5
mul $t5,$t5,6
add $t5,$t5,$t4
mul $t5,$t5,4 # ((5-row)*6 + column) * 4 = $t5
add $t5,$s0,$t5
lw $t5,0($t5) # $t4 = the stack offset to store the value
bne $t5,0,badJump # !board[r2][c2]
add $t5,$t1,$t3
srl $t5,$t5,1
add $t6,$t2,$t4
srl $t6,$t6,1
sub $t5,$0,$t5
addi $t5,$t5,5
mul $t5,$t5,6
add $t6,$t5,$t6
mul $t6,$t6,4 # ((5-row)*6 + column) * 4 = $t5
add $t6,$s0,$t6
lw $t6,0($t6) # $t4 = the stack offset to store the value
bne $t6,1,badJumpTestWhite # (board[rm][cm]==3)
j finish
badJump:
li $v1,0
finish:
lw $ra,0($sp)
addi $sp,$sp,4
jr $ra
isValidMove:
lw $s0,16($sp) # load pointer to checkerBoard in $s0
lw $t1,12($sp) # load the 2 pairs of coordinates in $t0 to $t3
lw $t2,8($sp)
lw $t3,4($sp)
lw $t4,0($sp)
mov $a1,$t1 #check each pair of coords for validity
mov $a2,$t2
addi $sp,$sp,-4
sw $ra,0($sp)
jal isLegalPosition
beq $v1,0,invalidMove
mov $a1,$t3
mov $a2,$t4
jal isLegalPosition
beq $v1,0,invalidMove
sub $t5,$0,$t1
addi $t5,$t5,5
mul $t5,$t5,6
add $t5,$t5,$t2
mul $t5,$t5,4 # ((5-row)*6 + column) * 4 = $t1
add $t5,$s0,$t5
lw $t5,0($t5) # $t0 = the stack offset to store the value
li $v1,1
beq $t5,1,red
beq $t5,3,white
beq $t5,5,redKing
beq $t5,7,whiteKing
j invalidMove
red:
sub $t5,$t1,$t3
bne $t5,-1,invalidMove
sub $t5,$t2,$t4
abs $t5,$t5
bne $t5,1,invalidMove
j emptySpaceCheck
white:
sub $t5,$t1,$t3
bne $t5,1,invalidMove
sub $t5,$t2,$t4
abs $t5,$t5
bne $t5,1,invalidMove
j emptySpaceCheck
redKing:
sub $t5,$t1,$t3
abs $t5,$t5
bne $t5,1,invalidMove
sub $t5,$t2,$t4
abs $t5,$t5
bne $t5,1,invalidMove
j emptySpaceCheck
whiteKing:
sub $t5,$t1,$t3
abs $t5,$t5
bne $t5,1,invalidMove
sub $t5,$t2,$t4
abs $t5,$t5
bne $t5,1,invalidMove
emptySpaceCheck:
sub $t3,$0,$t3
addi $t3,$t3,5
mul $t3,$t3,6
add $t4,$t3,$t4
mul $t4,$t4,4 # ((5-row)*6 + column) * 4 = $t1
add $t4,$s0,$t4
lw $t4,0($t4) # $t2 = the stack offset to load the value
bne $t4,0,invalidMove
j end
invalidMove:
li $v1,0
end:
lw $ra,0($sp)
addi $sp,$sp,4
jr $ra
isLegalPosition:
blt $a1,0,illegal
blt $a2,0,illegal
bgt $a1,5,illegal
bgt $a2,5,illegal
add $t0,$a1,$a2
rem $t0,$t0,2
beq $t0,0,illegal #if the sum is even, it's a black square
li $v1,1
j next
illegal:
li $v1,0
next:
jr $ra
board:
addi $sp,$sp,-144 # (36 * 4) bytes of memory
mov $s0,$sp # store pointer to board in $s0
mov $s1,$ra
li $t3,1 # $t3 = red piece value
li $t1,0 # $t1 = row
j redTest1
redLoop1:
li $t2,0 # $t2 = column
j redTest2
redLoop2:
mov $a1,$t1
mov $a2,$t2
jal isLegalPosition
beq $v1,1,addRed
j skipAddRed
addRed: # ((5-row)*6 + column) * 4 = $t1
sub $t4,$0,$t1
addi $t4,$t4,5
mul $t4,$t4,6
add $t5,$t4,$t2
mul $t5,$t5,4 # ((5-row)*6 + column) * 4 = $t1
add $t5,$s0,$t5
sw $t3,0($t5) # $t0 = the stack offset to store the value
skipAddRed:
addi $t2,$t2,1
redTest2:
blt $t2,6,redLoop2
addi $t1,$t1,1
redTest1:
ble $t1,1,redLoop1
li $t3,3 # $t3 = red piece value
li $t1,4 # $t1 = row
j whiteTest1
whiteLoop1:
li $t2,0 # $t2 = column
j whiteTest2
whiteLoop2:
mov $a1,$t1
mov $a2,$t2
jal isLegalPosition
beq $v1,1,addWhite
j skipAddWhite
addWhite: # ((5-row)*6 + column) * 4 = $t1
sub $t4,$0,$t1
addi $t4,$t4,5
mul $t4,$t4,6
add $t5,$t4,$t2
mul $t5,$t5,4 # ((5-row)*6 + column) * 4 = $t1
add $t5,$s0,$t5
sw $t3,0($t5) # $t0 = the stack offset to store the value
skipAddWhite:
addi $t2,$t2,1
whiteTest2:
blt $t2,6,whiteLoop2
addi $t1,$t1,1
whiteTest1:
ble $t1,5,whiteLoop1
mov $ra,$s1
jr $ra
displayBoard:
li $t0,0 # $t0 = count1 = 0
iloop:
li $t1,0 # $t1 = count2 = 0
jloop:
add $t2,$t0,$t1
rem $t2,$t2,2
bne $t2,0,else #else print black square
lw $a0,0($sp)
beq $a0,3,lowercaseW
beq $a0,1,lowercaseR
beq $a0,5,capitalR
beq $a0,7,capitalW
li $a0,32 #print white square
syscall $print_char
j jtest
lowercaseW:
la $a0,w
syscall $print_string
j jtest
lowercaseR:
la $a0,r
syscall $print_string
j jtest
capitalR:
la $a0,bigr
syscall $print_string
j jtest
capitalW:
la $a0,bigw
syscall $print_string
j jtest
else:
li $a0,219 #print black square
syscall $print_char
jtest:
addi $t1,$t1,1 #increment count2 by 1
addi $sp,$sp,4
blt $t1,6,jloop
la $a0,nl
syscall $print_string
addi $t0,$t0,1 # increment count1 by 1
itest:
blt $t0,6,iloop
mov $sp,$s0
jr $ra
|
data/pokemon/dex_entries/ninetales.asm | AtmaBuster/pokeplat-gen2 | 6 | 171688 | <filename>data/pokemon/dex_entries/ninetales.asm
db "FOX@" ; species name
db "It is said to live"
next "a thousand years,"
next "and each of its"
page "tails is loaded"
next "with supernatural"
next "powers.@"
|
3-mid/impact/source/3d/math/impact-d3-vector.adb | charlie5/lace | 20 | 13188 | with impact.d3.min_max;
-- with math; --.Algebra.linear.d3;
package body impact.d3.Vector
--
--
--
is
function x (Self : in Vector_3) return Real
is
begin
return Self (1);
end x;
function y (Self : in Vector_3) return Real
is
begin
return Self (2);
end y;
function z (Self : in Vector_3) return Real
is
begin
return Self (3);
end z;
function dot (Left, Right : in Vector_3) return Real
is
begin
return Left (1) * Right (1)
+ Left (2) * Right (2)
+ Left (3) * Right (3);
end dot;
function cross (Left, Right : in Vector_3) return Vector_3
is
begin
return (Left (2) * Right (3) - Left (3) * Right (2),
Left (3) * Right (1) - Left (1) * Right (3),
Left (1) * Right (2) - Left (2) * Right (1));
end cross;
function length2 (Self : in Vector_3) return Real
is
begin
return dot (Self, Self);
end length2;
function length (Self : in Vector_3) return Real
is
use math.Functions;
begin
return sqRt (length2 (Self));
end length;
function distance2 (Left, Right : in Vector_3) return Real
is
begin
return length2 (Right - Left);
end distance2;
function distance (Left, Right : in Vector_3) return Real
is
begin
return length (Right - Left);
end distance;
function safeNormalize (Self : access Vector_3) return Vector_3
is
absVec : Vector_3 := absolute (Self.all);
maxIndex : constant math.Index := maxAxis (absVec);
begin
if absVec (maxIndex) > 0.0 then
Self.all := Self.all / absVec (maxIndex);
Self.all := Self.all / length (Self.all);
return Self.all;
end if;
Self.all := (1.0, 0.0, 0.0);
return Self.all;
end safeNormalize;
function Normalize (Self : access Vector_3) return Vector_3
is
begin
Self.all := Self.all / length (Self.all);
return Self.all;
end Normalize;
function Normalized (Self : in Vector_3) return Vector_3
is
begin
return Self / length (Self);
end Normalized;
procedure Normalize (Self : in out Vector_3)
is
begin
Self := Normalized (Self);
end Normalize;
function absolute (Self : in Vector_3) return Vector_3
is
begin
return abs (Self);
end absolute;
function minAxis (Self : in Vector_3) return math.Index
is
begin
if Self (1) < Self (2) then
if Self (1) < Self (3) then
return 1;
else
return 3;
end if;
elsif Self (2) < Self (3) then
return 2;
else
return 3;
end if;
end minAxis;
function maxAxis (Self : in Vector_3) return math.Index
is
begin
if Self (1) < Self (2) then
if Self (2) < Self (3) then
return 3;
else
return 2;
end if;
elsif Self (1) < Self (3) then
return 3;
else
return 1;
end if;
end maxAxis;
function rotate (Self : in Vector_3; wAxis : in Vector_3;
Angle : in Real ) return Vector_3
is
use math.Functions;
o : constant Vector_3 := wAxis * dot (wAxis, Self); -- wAxis must be a unit lenght vector
x : constant Vector_3 := Self - o;
y : constant Vector_3 := cross (wAxis, Self);
begin
return o + x * Cos (angle) + y * Sin (angle);
end rotate;
function Angle (Left, Right : in Vector_3) return Real
is
use math.Functions;
s : constant Real := sqRt (length2 (Left) * length2 (Right));
begin
pragma Assert (s /= 0.0);
return arcCos (dot (Left, Right) / s);
end Angle;
function Triple (V1, V2, V3 : in Vector_3) return Real
is
begin
return V1 (1) * (V2 (2) * V3 (3) - V2 (3) * V3 (2))
+ V1 (2) * (V2 (3) * V3 (1) - V2 (1) * V3 (3))
+ V1 (3) * (V2 (1) * V3 (2) - V2 (2) * V3 (1));
end Triple;
function furthestAxis (Self : in Vector_3) return math.Index
is
begin
return minAxis (absolute (Self));
end furthestAxis;
function closestAxis (Self : in Vector_3) return math.Index
is
begin
return maxAxis (absolute (Self));
end closestAxis;
procedure setInterpolate3 (Self : in out Vector_3; V1, V2 : in Vector_3;
rt : in Real)
is
s : constant Real := 1.0 - rt;
begin
Self (1) := s * V1 (1) + rt * V2 (1);
Self (2) := s * V1 (2) + rt * V2 (2);
Self (3) := s * V1 (3) + rt * V2 (3);
-- don't do the unused w component
-- m_co[3] = s * v0[3] + rt * v1[3];
end setInterpolate3;
function lerp (V1, V2 : in Vector_3; t : in Real) return Vector_3
is
begin
return (V1 (1) + (V2 (1) - V1 (1)) * t,
V1 (2) + (V2 (2) - V1 (2)) * t,
V1 (3) + (V2 (3) - V1 (3)) * t);
end lerp;
function Scaled (Self : in Vector_3; By : in Vector_3) return Vector_3
is
begin
return (Self (1) * By (1),
Self (2) * By (2),
Self (3) * By (3));
end Scaled;
function invScaled (Self : in Vector_3; By : in Vector_3) return Vector_3
is
begin
return (Self (1) / By (1),
Self (2) / By (2),
Self (3) / By (3));
end invScaled;
-- function "*" (L : in math.Vector_3; R : in math.Real) return math.Vector_3
-- is
-- begin
-- return (L (1) * R,
-- L (2) * R,
-- L (3) * R);
-- end;
function Scale (Self : access Vector_3; By : in Vector_3) return Vector_3
is
begin
Self.all := Scaled (Self.all, By);
return Self.all;
end Scale;
procedure setMax (Self : in out Vector_3; Other : in Vector_3)
is
begin
Self := (Real'Max (Self (1), Other (1)),
Real'Max (Self (2), Other (2)),
Real'Max (Self (3), Other (3)));
end setMax;
procedure setMin (Self : in out Vector_3; Other : in Vector_3)
is
begin
Self := (Real'Min (Self (1), Other (1)),
Real'Min (Self (2), Other (2)),
Real'Min (Self (3), Other (3)));
end setMin;
procedure getSkewSymmetricMatrix (Self : in Vector_3; V1, V2, V3 : out Vector_3)
is
begin
v1 := ( 0.0, -Self (3), Self (2));
v2 := (Self (3), 0.0, -Self (1));
v3 := (-Self (2), Self (1), 0.0);
end getSkewSymmetricMatrix;
procedure setZero (Self : out Vector_3)
is
begin
Self := (0.0, 0.0, 0.0);
end setZero;
function isZero (Self : in Vector_3) return Boolean
is
begin
return Self (1) = 0.0 and then Self (2) = 0.0 and then Self (3) = 0.0;
end isZero;
function fuzzyZero (Self : in Vector_3) return Boolean
is
use impact.d3.Scalar;
begin
return length2 (Self) < SIMD_EPSILON;
end fuzzyZero;
--- Vector_4
--
function absolute4 (Self : in Vector_4) return Vector_4
is
use math.Vectors;
begin
return abs (Self);
end absolute4;
function maxAxis4 (Self : in Vector_4) return math.Index
is
maxIndex : math.Index := -1;
maxVal : Real := Real'First; -- -BT_LARGE_FLOAT;
begin
if Self (1) > maxVal then
maxIndex := 1;
maxVal := Self (1);
end if;
if Self (2) > maxVal then
maxIndex := 2;
maxVal := Self (2);
end if;
if Self (3) > maxVal then
maxIndex := 3;
maxVal := Self (3);
end if;
if Self (4) > maxVal then
maxIndex := 4;
maxVal := Self (4);
end if;
return maxIndex;
end maxAxis4;
function minAxis4 (Self : in Vector_4) return math.Index
is
minIndex : math.Index := -1;
minVal : Real := Real'Last; -- BT_LARGE_FLOAT;
begin
if Self (1) < minVal then
minIndex := 1;
minVal := Self (1);
end if;
if Self (2) < minVal then
minIndex := 2;
minVal := Self (2);
end if;
if Self (3) < minVal then
minIndex := 3;
minVal := Self (3);
end if;
if Self (4) < minVal then
minIndex := 4;
minVal := Self (4);
end if;
return minIndex;
end minAxis4;
function closestAxis4 (Self : in Vector_4) return math.Index
is
begin
return maxAxis4 (absolute4 (Self));
end closestAxis4;
procedure btPlaneSpace1 (n : in Vector_3; p, q : out Vector_3)
is
use impact.d3.Scalar;
a, k : Real;
begin
if abs n (3) > SIMDSQRT12 then -- choose p in y-z plane
a := n (2) * n (2) + n (3) * n (3);
k := btRecipSqrt (a);
p (1) := 0.0;
p (2) := -n (3) * k;
p (3) := n (2) * k;
-- set q = n x p
q (1) := a * k;
q (2) := -n (1) * p (3);
q (3) := n (1) * p (2);
else -- choose p in x-y plane
a := n (1) * n (1) + n (2) * n (2);
k := btRecipSqrt (a);
p (1) := -n (2) * k;
p (2) := n (1) * k;
p (3) := 0.0;
-- set q = n x p
q (1) := -n (3) * p (2);
q (2) := n (3) * p (1);
q (3) := a * k;
end if;
end btPlaneSpace1;
end impact.d3.Vector;
|
tests/modules/dirModule_basics.asm | fengjixuchui/sjasmplus | 220 | 170269 | <gh_stars>100-1000
OPT --syntax=abfw
MODULE module1
Fn1: ret
MODULE nestedModule
; check labels composing after MODULE
.localWithoutNonLocal1:
Fn1.n: ldir
.local1:
@GlobalLabel1:
.localAfterGlobal1: ; should be <modules>.Global... according to docs (a bit illogical)
ENDMODULE
MODULE nested.Invalid.Name
Fn1.nin cpl
; ENDMODULE (not needed, because the module was not created)
ENDMODULE
; check labels composing after ENDMODULE
.localWithoutNonLocal2:
NonLocal2:
.local2:
; some error states
MODULE 1nvalid name
Fn1nvalid: daa
ENDMODULE
MODULE missingEndModule
Fn2: nop
|
src/TP4/Calculette.g4 | hanzopgp/TPLanguageTheory | 0 | 6749 | <filename>src/TP4/Calculette.g4
grammar Calculette;
@parser::members {
private int evalexpr (int x, String op, int y) {
if ( op.equals("*") ){
return x * y;
} else if ( op.equals("/") ){
return x / y;
} else if ( op.equals("+") ){
return x + y;
} else if ( op.equals("-") ){
return x - y;
} else {
System.err.println("Opérateur arithmétique incorrect : '" + op + "'");
throw new IllegalArgumentException("Opérateur arithmétique incorrect : '" + op + "'");
}
}
}
start: a = expr EOF {System.out.println($a.val);};
expr
returns[ int val ]:
'(' a = expr ')'
{$val = $a.val;}
| b = expr
op = ('/' | '*')
c = expr
{$val = evalexpr($b.val, $op.text, $c.val);}
| d = expr
op2 = ('+' | '-')
e = expr
{$val = evalexpr($d.val, $op2.text, $e.val);}
| op3 = ('-' | '+')
f = expr
{$val = evalexpr(0, $op3.text, $f.val);}
| g = ENTIER
{$val = Integer.parseInt($g.text);};
NEWLINE: '\r'? '\n' -> skip;
WS: (' ' | '\t')+ -> skip;
ENTIER: ('0' ..'9')+;
UNMATCH: . -> skip; |
oeis/075/A075140.asm | neoneye/loda-programs | 11 | 82804 | ; A075140: Denominator of the generalized harmonic number H(n,5,2).
; Submitted by <NAME>
; 2,14,84,1428,15708,141372,1130976,41846112,5978016,280966752,3652567776,69398787744,2151362420064,144141282144288,144141282144288,1008988975010016,41368547975410656,1199687891286909024
add $0,1
mov $1,1
mov $2,1
lpb $0
sub $0,1
add $2,1
mul $3,$2
add $3,$1
mul $1,$2
add $2,4
lpe
gcd $3,$1
div $1,$3
mov $0,$1
|
oeis/252/A252631.asm | neoneye/loda-programs | 11 | 247062 | <gh_stars>10-100
; A252631: Numbers n such that the heptagonal number H(n) is equal to the sum of the hexagonal numbers X(m), X(m+1), X(m+2) and X(m+3) for some m.
; Submitted by <NAME>
; 92,29524,9506540,3061076260,985657049084,317378508728692,102194894153589644,32906438538947136580,10595771014646824389020,3411805360277738506127764,1098590730238417152148750892,353742803331410045253391659364,113904084081983796154439965564220,36676761331595450951684415520019380,11809803244689653222646227357480676044,3802719968028736742241133524693257666692,1224464019902008541348422348723871487998684,394273611688478721577449755155561925877909460,126954878499670246339397472737742216261198847340
add $0,1
mov $2,4
mov $3,$0
mul $3,4
mov $5,53
lpb $3
add $1,$5
mul $5,$4
add $5,$2
mov $2,$1
mul $1,4
sub $3,1
lpe
mov $0,$5
sub $0,917
div $0,10
add $0,92
|
src/FRP/LTL/RSet.agda | agda/agda-frp-ltl | 21 | 5357 | module FRP.LTL.RSet where
open import FRP.LTL.RSet.Core public using ( RSet ; ⟨_⟩ ; ⟦_⟧ )
-- Propositional logic
open import FRP.LTL.RSet.Unit public using ( T )
open import FRP.LTL.RSet.Empty public using ( F )
open import FRP.LTL.RSet.Product public using ( _∧_ ; fst ; snd ; _&&&_ )
open import FRP.LTL.RSet.Sum public using ( _∨_ )
open import FRP.LTL.RSet.Stateless public using ( _⇒_ )
-- LTL
open import FRP.LTL.RSet.Next public using ( ○ )
open import FRP.LTL.RSet.Future public using ( ◇ )
open import FRP.LTL.RSet.Globally public using ( □ ; [_] )
open import FRP.LTL.RSet.Until public using ( _U_ )
open import FRP.LTL.RSet.Causal public using ( _⊵_ ; arr ; identity ; _⋙_ )
open import FRP.LTL.RSet.Decoupled public using ( _▹_ )
|
binary-diagnostic/binary_ascii_to_int64.asm | schuler-henry/snp-assembler | 0 | 95871 | <filename>binary-diagnostic/binary_ascii_to_int64.asm
;----------------------------------------------------------------------------
; binary_ascii_to_int64.asm - convert ascii binary to integer
;----------------------------------------------------------------------------
;
; DHBW Ravensburg - <NAME>
;
; Vorlesung Systemnahe Programmierung (SNP)
;
;----------------------------------------------------------------------------
;
; Architecture: x86-64
; Language: NASM Assembly Language
;
; Author: <NAME>
;
;----------------------------------------------------------------------------
;-----------------------------------------------------------------------------
; Section TEXT
;-----------------------------------------------------------------------------
SECTION .text
global binary_ascii_to_int:function
binary_ascii_to_int:
; rsi: ascii binary number
; rdi: integer return value
; esp+8: ascii binary length
push rbp
mov rbp,rsp
push rcx
mov rcx,0
loop:
shl rdi,1
cmp BYTE [rsi+rcx],'0'
je is_zero
is_one:
inc rdi
is_zero:
inc rcx
cmp rcx,[rbp+16]
jb loop
pop rcx
pop rbp
ret
|
source/xml/sax/xml-sax-simple_readers-scanner-actions.adb | svn2github/matreshka | 24 | 15794 | ------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- XML Processor --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2010-2014, <NAME> <<EMAIL>> --
-- 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 Vadim Godunko, IE 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. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
with Matreshka.Internals.Strings.Configuration;
with Matreshka.Internals.Strings.Operations;
with Matreshka.Internals.Unicode.Characters.Latin;
with XML.SAX.Simple_Readers.Callbacks;
with XML.SAX.Simple_Readers.Scanner.Tables;
package body XML.SAX.Simple_Readers.Scanner.Actions is
use Matreshka.Internals.Strings.Configuration;
use Matreshka.Internals.Unicode;
use Matreshka.Internals.Unicode.Characters.Latin;
use Matreshka.Internals.Utf16;
use Matreshka.Internals.XML;
use Matreshka.Internals.XML.Entity_Tables;
use Matreshka.Internals.XML.Symbol_Tables;
procedure Resolve_Symbol
(Self : in out Simple_Reader'Class;
Trim_Left : Natural;
Trim_Right : Natural;
Trim_Whitespace : Boolean;
Can_Be_Qname : Boolean;
Not_Qname : Boolean;
Error : out Boolean;
Symbol : out Matreshka.Internals.XML.Symbol_Identifier);
-- Converts name to symbol. Trim_Left, Trim_Right, Trim_Whitespace can be
-- used to trim several characters from head of tail of matched substring,
-- and to trim leading whitespaces. Not_Qname specify that resolved name
-- is not a qualified name at all (it is enumeration element of attribute
-- of non-NOTATION type). Can_Be_Qname specify that resolved name is
-- qualified name when namespace processing is enabled. Subprogram sets
-- Error when error is detected and Symbol when symbol is resolved.
procedure Character_Reference_To_Code_Point
(Self : in out Simple_Reader'Class;
Hex : Boolean;
Code : out Code_Point;
Valid : out Boolean);
-- Converts scanned character reference to code point. Reports errors to
-- application is any and sets Valid to False. Otherwise sets Code to
-- referenced code point and sets Valid to True.
---------------------------------------
-- Character_Reference_To_Code_Point --
---------------------------------------
procedure Character_Reference_To_Code_Point
(Self : in out Simple_Reader'Class;
Hex : Boolean;
Code : out Code_Point;
Valid : out Boolean)
is
Zero_Fixup : constant := Digit_Zero;
Upper_Fixup : constant := Latin_Capital_Letter_A - 16#0A#;
Lower_Fixup : constant := Latin_Small_Letter_A - 16#0A#;
FP : Utf16_String_Index := Self.Scanner_State.YY_Base_Position;
LP : Utf16_String_Index := Self.Scanner_State.YY_Current_Position;
Aux : Code_Unit_32 := 0;
D : Code_Point;
begin
-- NOTE: Sequences of leading and trailing character always fixed:
-- "&#" for decimal representation and "&#x" for hexadecimal
-- representation for the leading sequence of characters and ";" for
-- trailing; thus we can just add/subtract required number of code point
-- positions instead of doing more expensive iteration with analysis of
-- UTF-16 code units.
--
-- Actual value has limited character set ([0-9] or [0-9a-fA-F]), all
-- of characters is on BMP also, thus expensive decoding can be omitted
-- also.
if Hex then
-- Trim three leading characters and trailing character.
FP := FP + 3;
LP := LP - 1;
while FP < LP loop
D := Code_Point (Self.Scanner_State.Data.Value (FP));
FP := FP + 1;
if D in Latin_Capital_Letter_A .. Latin_Capital_Letter_F then
Aux := (Aux * 16) + D - Upper_Fixup;
elsif D in Latin_Small_Letter_A .. Latin_Small_Letter_F then
Aux := (Aux * 16) + D - Lower_Fixup;
else
Aux := (Aux * 16) + D - Zero_Fixup;
end if;
-- Check whether collected code is inside range of Unicode code
-- points. Then it is outside reset to maximum value and exit
-- the loop. Error will be reported later in this subprogram.
if Aux not in Code_Point then
Aux := Code_Unit_32'Last;
exit;
end if;
end loop;
else
-- Trim two leading characters and trailing character.
FP := FP + 2;
LP := LP - 1;
while FP < LP loop
D := Code_Point (Self.Scanner_State.Data.Value (FP));
FP := FP + 1;
Aux := (Aux * 10) + D - Zero_Fixup;
-- Check whether collected code is inside range of Unicode code
-- points. Then it is outside reset to maximum value and exit
-- the loop. Error will be reported later in this subprogram.
if Aux not in Code_Point then
Aux := Code_Unit_32'Last;
exit;
end if;
end loop;
end if;
-- [XML1.0/1.1 4.1 WFC: Legal Character]
--
-- "Characters referred to using character references MUST match the
-- production for Char."
--
-- Check whether character reference is resolved into valid character.
case Self.Version is
when XML_1_0 =>
-- [XML1.0 2.2 Characters]
--
-- [2] Char ::=
-- #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD]
-- | [#x10000-#x10FFFF]
Valid :=
Aux = 16#0009#
or Aux = 16#000A#
or Aux = 16#000D#
or Aux in 16#0020# .. 16#D7FF#
or Aux in 16#E000# .. 16#FFFD#
or Aux in 16#1_0000# .. 16#10_FFFF#;
when XML_1_1 =>
-- [XML1.1 2.2 Characters]
--
-- [2] Char ::=
-- [#x1-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
Valid :=
Aux in 16#0001# .. 16#D7FF#
or Aux in 16#E000# .. 16#FFFD#
or Aux in 16#1_0000# .. 16#10_FFFF#;
end case;
if not Valid then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML 4.1 WFC: Legal Character] character reference refers to"
& " invalid character"));
Self.Error_Reported := True;
else
Code := Aux;
end if;
end Character_Reference_To_Code_Point;
----------------------------------------
-- On_Asterisk_In_Content_Declaration --
----------------------------------------
function On_Asterisk_In_Content_Declaration
(Self : in out Simple_Reader'Class) return Token is
begin
if Self.Whitespace_Matched then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML [47], [48], [51]] illegal whitespace before asterisk"));
return Error;
else
return Token_Asterisk;
end if;
end On_Asterisk_In_Content_Declaration;
-----------------------------------------------------
-- On_Attribute_Name_In_Attribute_List_Declaration --
-----------------------------------------------------
function On_Attribute_Name_In_Attribute_List_Declaration
(Self : in out Simple_Reader'Class) return Token
is
Qname_Error : Boolean;
begin
-- [53] AttDef ::= S Name S AttType S DefaultDecl
--
-- Checks whitespace before the attribute name is present.
if not Self.Whitespace_Matched then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML [53] AttDef]"
& " no whitespace before attribute name"));
return Error;
end if;
Self.Whitespace_Matched := False;
Resolve_Symbol
(Self, 0, 0, False, True, False, Qname_Error, Self.YYLVal.Symbol);
if Qname_Error then
return Error;
else
Enter_Start_Condition (Self, Tables.ATTLIST_TYPE);
return Token_Name;
end if;
end On_Attribute_Name_In_Attribute_List_Declaration;
-----------------------
-- On_Attribute_Type --
-----------------------
function On_Attribute_Type
(Self : in out Simple_Reader'Class;
Type_Token : Token) return Token is
begin
-- Checks ithat whitespace before attribute type keyword is detected
-- and report error when check fail.
if not Self.Whitespace_Matched then
-- XXX This is recoverable error.
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("whitespace required before attribute type"));
return Error;
end if;
Self.Whitespace_Matched := False;
return Type_Token;
end On_Attribute_Type;
---------------------------------------
-- On_Attribute_Value_Character_Data --
---------------------------------------
procedure On_Attribute_Value_Character_Data
(Self : in out Simple_Reader'Class)
is
Next : Utf16_String_Index := Self.Scanner_State.YY_Base_Position;
Code : Code_Point;
begin
-- Allocates buffer of necessary size to avoid memory reallocation. It
-- can be larger when needed if attribute value normalization is
-- activated, but usually not too large.
Matreshka.Internals.Strings.Mutate
(Self.Character_Data,
Self.Character_Data.Unused
+ Self.Scanner_State.YY_Current_Position
- Self.Scanner_State.YY_Base_Position
+ 1);
-- Two mostly equivalent paths are separated, because they are on the
-- performance critical path.
if Self.Normalize_Value then
-- Normalization is required for attribute's value.
while Next /= Self.Scanner_State.YY_Current_Position loop
Unchecked_Next (Self.Scanner_State.Data.Value, Next, Code);
-- It can be reasonable to implement this step of normalization
-- on SIMD.
if Code = Character_Tabulation
or Code = Line_Feed
or Code = Carriage_Return
then
Code := Space;
end if;
if Code = Space then
if not Self.Space_Before then
Unchecked_Store
(Self.Character_Data.Value,
Self.Character_Data.Unused,
Code);
Self.Character_Data.Length := Self.Character_Data.Length + 1;
Self.Space_Before := True;
end if;
else
Unchecked_Store
(Self.Character_Data.Value,
Self.Character_Data.Unused,
Code);
Self.Character_Data.Length := Self.Character_Data.Length + 1;
Self.Space_Before := False;
end if;
end loop;
else
-- XXX Can be optimized by adding special operation Append_Slice.
while Next /= Self.Scanner_State.YY_Current_Position loop
Unchecked_Next (Self.Scanner_State.Data.Value, Next, Code);
-- It can be reasonable to implement this step of normalization
-- on SIMD.
if Code = Character_Tabulation
or Code = Line_Feed
or Code = Carriage_Return
then
Code := Space;
end if;
Unchecked_Store
(Self.Character_Data.Value,
Self.Character_Data.Unused,
Code);
Self.Character_Data.Length := Self.Character_Data.Length + 1;
end loop;
end if;
end On_Attribute_Value_Character_Data;
----------------------------------------
-- On_Attribute_Value_Close_Delimiter --
----------------------------------------
function On_Attribute_Value_Close_Delimiter
(Self : in out Simple_Reader'Class) return Boolean
is
-- NOTE: Attribute value delimiter can be ' or " and both are
-- represented as single UTF-16 code unit, thus expensive UTF-16
-- decoding can be avoided.
Delimiter : constant Matreshka.Internals.Unicode.Code_Point
:= Code_Point
(Self.Scanner_State.Data.Value
(Self.Scanner_State.YY_Base_Position));
begin
if Self.Scanner_State.Delimiter /= Delimiter then
Matreshka.Internals.Strings.Operations.Unterminated_Append
(Self.Character_Data, Delimiter);
return False;
else
if Self.Normalize_Value and then Self.Space_Before then
-- One space character is at the end of the prepared string, it
-- must be removed from the result.
Self.Character_Data.Length := Self.Character_Data.Length - 1;
Self.Character_Data.Unused := Self.Character_Data.Unused - 1;
end if;
String_Handler.Fill_Null_Terminator (Self.Character_Data);
Matreshka.Internals.Strings.Reference (Self.Character_Data);
Set_String_Internal
(Item => Self.YYLVal,
String => Self.Character_Data,
Is_Whitespace => False);
Reset_Whitespace_Matched (Self);
Pop_Start_Condition (Self);
return True;
end if;
end On_Attribute_Value_Close_Delimiter;
-------------------------------------------
-- On_Attribute_Value_In_XML_Declaration --
-------------------------------------------
function On_Attribute_Value_In_XML_Declaration
(Self : in out Simple_Reader'Class) return Token is
begin
Set_String_Internal
(Item => Self.YYLVal,
String => YY_Text (Self, 1, 1),
Is_Whitespace => False);
Reset_Whitespace_Matched (Self);
return Token_String_Segment;
end On_Attribute_Value_In_XML_Declaration;
---------------------------------------
-- On_Attribute_Value_Open_Delimiter --
---------------------------------------
function On_Attribute_Value_Open_Delimiter
(Self : in out Simple_Reader'Class;
State : Interfaces.Unsigned_32) return Boolean is
begin
if not Self.Whitespace_Matched then
-- XXX This is recoverable error.
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("whitespace required before default value"));
return False;
end if;
On_Attribute_Value_Open_Delimiter (Self, State);
return True;
end On_Attribute_Value_Open_Delimiter;
---------------------------------------
-- On_Attribute_Value_Open_Delimiter --
---------------------------------------
procedure On_Attribute_Value_Open_Delimiter
(Self : in out Simple_Reader'Class;
State : Interfaces.Unsigned_32) is
begin
-- NOTE: Attribute value delimiter can be ' or " and both are
-- represented as single UTF-16 code unit, thus expensive UTF-16
-- decoding can be avoided.
Self.Scanner_State.Delimiter :=
Code_Point
(Self.Scanner_State.Data.Value (Self.Scanner_State.YY_Base_Position));
Matreshka.Internals.Strings.Operations.Reset (Self.Character_Data);
case Self.Version is
when XML_1_0 =>
Push_And_Enter_Start_Condition
(Self, State, Tables.ATTRIBUTE_VALUE_10);
when XML_1_1 =>
Push_And_Enter_Start_Condition
(Self, State, Tables.ATTRIBUTE_VALUE_11);
end case;
end On_Attribute_Value_Open_Delimiter;
--------------
-- On_CDATA --
--------------
function On_CDATA (Self : in out Simple_Reader'Class) return Token is
begin
-- Segment of CDATA section (production [20]) optionally terminated by
-- end of CDATA section mark (production [21]).
if Self.Scanner_State.YY_Current_Position
- Self.Scanner_State.YY_Base_Position >= 3
and then (Code_Point
(Self.Scanner_State.Data.Value
(Self.Scanner_State.YY_Current_Position - 1))
= Greater_Than_Sign
and Code_Point
(Self.Scanner_State.Data.Value
(Self.Scanner_State.YY_Current_Position - 2))
= Right_Square_Bracket
and Code_Point
(Self.Scanner_State.Data.Value
(Self.Scanner_State.YY_Current_Position - 3))
= Right_Square_Bracket)
then
-- Character data ends with ']]>', move backward before end of CDATA
-- section literal. End of CDATA section literal will be processed
-- on next cycle.
YY_Move_Backward (Self);
YY_Move_Backward (Self);
YY_Move_Backward (Self);
end if;
Matreshka.Internals.Strings.Operations.Copy_Slice
(Self.Character_Data,
Self.Scanner_State.Data,
Self.Scanner_State.YY_Base_Position,
Self.Scanner_State.YY_Current_Position
- Self.Scanner_State.YY_Base_Position,
Self.Scanner_State.YY_Current_Index
- Self.Scanner_State.YY_Base_Index);
Matreshka.Internals.Strings.Reference (Self.Character_Data);
Set_String_Internal
(Item => Self.YYLVal,
String => Self.Character_Data,
Is_Whitespace => False);
return Token_String_Segment;
end On_CDATA;
-----------------------
-- On_Character_Data --
-----------------------
function On_Character_Data
(Self : in out Simple_Reader'Class) return Token
is
C : constant Code_Point
:= Code_Point
(Self.Scanner_State.Data.Value
(Self.Scanner_State.YY_Current_Position - 1));
begin
if Self.Element_Names.Is_Empty then
-- Document content not entered.
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("Text may not appear after the root element"));
Self.Error_Reported := True;
return Error;
end if;
if C = Less_Than_Sign or C = Ampersand then
-- Matched string end with '<' or '&' which is start character of
-- tag or reference accordingly.
YY_Move_Backward (Self);
elsif C = Greater_Than_Sign
and then Self.Scanner_State.YY_Current_Position
- Self.Scanner_State.YY_Base_Position >= 3
and then (Code_Point
(Self.Scanner_State.Data.Value
(Self.Scanner_State.YY_Current_Position - 2))
= Right_Square_Bracket
and Code_Point
(Self.Scanner_State.Data.Value
(Self.Scanner_State.YY_Current_Position - 3))
= Right_Square_Bracket)
then
-- Matched string ends with literal ']]>' which is invalid in
-- character data.
if Self.Scanner_State.YY_Current_Position
- Self.Scanner_State.YY_Base_Position = 3
then
-- Exactly ']]>' found.
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[[14] CharData]"
& " Text may not contain a literal ']]>' sequence"));
Self.Error_Reported := True;
return Error;
else
-- String ends with ']]>', move backward to report character data
-- in this cycle and report error in next cycle.
YY_Move_Backward (Self);
YY_Move_Backward (Self);
YY_Move_Backward (Self);
end if;
end if;
Matreshka.Internals.Strings.Operations.Copy_Slice
(Self.Character_Data,
Self.Scanner_State.Data,
Self.Scanner_State.YY_Base_Position,
Self.Scanner_State.YY_Current_Position
- Self.Scanner_State.YY_Base_Position,
Self.Scanner_State.YY_Current_Index
- Self.Scanner_State.YY_Base_Index);
Matreshka.Internals.Strings.Reference (Self.Character_Data);
Set_String_Internal
(Item => Self.YYLVal,
String => Self.Character_Data,
Is_Whitespace => False);
return Token_String_Segment;
end On_Character_Data;
----------------------------
-- On_Character_Reference --
----------------------------
function On_Character_Reference
(Self : in out Simple_Reader'Class;
Hex : Boolean) return Token
is
Code : Code_Point;
Valid : Boolean;
begin
Character_Reference_To_Code_Point (Self, Hex, Code, Valid);
if not Valid then
return Error;
end if;
-- XXX Whitespace must be detected and reported in token.
if not Matreshka.Internals.Strings.Can_Be_Reused
(Self.Character_Buffer, 2)
then
-- Preallocated buffer can't be reused for some reason (most
-- probably because application made copy of the previous character
-- reference), so new buffer need to be preallocated. Requested
-- size of the buffer is maximum number of UTF-16 code unit to
-- store one Unicode code point.
Matreshka.Internals.Strings.Dereference (Self.Character_Buffer);
Self.Character_Buffer := Matreshka.Internals.Strings.Allocate (2);
end if;
Self.Character_Buffer.Unused := 0;
Self.Character_Buffer.Length := 1;
Matreshka.Internals.Utf16.Unchecked_Store
(Self.Character_Buffer.Value,
Self.Character_Buffer.Unused,
Code);
Matreshka.Internals.Strings.Reference (Self.Character_Buffer);
Set_String_Internal
(Item => Self.YYLVal,
String => Self.Character_Buffer,
Is_Whitespace => False);
return Token_String_Segment;
end On_Character_Reference;
-----------------------------------------------
-- On_Character_Reference_In_Attribute_Value --
-----------------------------------------------
function On_Character_Reference_In_Attribute_Value
(Self : in out Simple_Reader'Class;
Hex : Boolean) return Boolean
is
Code : Code_Point;
Valid : Boolean;
begin
Character_Reference_To_Code_Point (Self, Hex, Code, Valid);
if not Valid then
return False;
end if;
if Self.Normalize_Value then
if Code = Space then
if not Self.Space_Before then
Matreshka.Internals.Strings.Operations.Unterminated_Append
(Self.Character_Data, Code);
Self.Space_Before := True;
end if;
else
Matreshka.Internals.Strings.Operations.Unterminated_Append
(Self.Character_Data, Code);
Self.Space_Before := False;
end if;
else
Matreshka.Internals.Strings.Operations.Unterminated_Append
(Self.Character_Data, Code);
end if;
return True;
end On_Character_Reference_In_Attribute_Value;
-----------------------
-- On_Close_Of_CDATA --
-----------------------
function On_Close_Of_CDATA
(Self : in out Simple_Reader'Class) return Token is
begin
Pop_Start_Condition (Self);
return Token_CData_Close;
end On_Close_Of_CDATA;
-------------------------------------
-- On_Close_Of_Conditional_Section --
-------------------------------------
function On_Close_Of_Conditional_Section
(Self : in out Simple_Reader'Class) return Token is
begin
if Self.Conditional_Depth = 0 then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("']]>' doesn't close conditional section"));
return Error;
end if;
Self.Conditional_Depth := Self.Conditional_Depth - 1;
if Self.Ignore_Depth /= 0 then
Self.Ignore_Depth := Self.Ignore_Depth - 1;
end if;
if Self.Ignore_Depth /= 0 then
case Self.Version is
when XML_1_0 =>
Enter_Start_Condition (Self, Tables.CONDITIONAL_IGNORE_10);
when XML_1_1 =>
Enter_Start_Condition (Self, Tables.CONDITIONAL_IGNORE_11);
end case;
else
case Self.Version is
when XML_1_0 =>
Enter_Start_Condition (Self, Tables.DOCTYPE_INTSUBSET_10);
when XML_1_1 =>
Enter_Start_Condition (Self, Tables.DOCTYPE_INTSUBSET_11);
end case;
end if;
return Token_Conditional_Close;
end On_Close_Of_Conditional_Section;
-----------------------------
-- On_Close_Of_Declaration --
-----------------------------
function On_Close_Of_Declaration
(Self : in out Simple_Reader'Class) return Token is
begin
case Self.Version is
when XML_1_0 =>
Enter_Start_Condition (Self, Tables.DOCTYPE_INTSUBSET_10);
when XML_1_1 =>
Enter_Start_Condition (Self, Tables.DOCTYPE_INTSUBSET_11);
end case;
return Token_Close;
end On_Close_Of_Declaration;
-------------------------------------------
-- On_Close_Of_Document_Type_Declaration --
-------------------------------------------
function On_Close_Of_Document_Type_Declaration
(Self : in out Simple_Reader'Class) return Boolean
is
Success : Boolean;
pragma Unreferenced (Success);
begin
if Self.External_Subset_Entity /= No_Entity
and Self.Validation.Load_DTD
and not Self.External_Subset_Done
then
-- External subset is declared, need to be loaded and not processed,
-- push it into the scanner stack to process before reporting of
-- close of document type declaration.
Self.External_Subset_Done := True;
YY_Move_Backward (Self);
Success :=
Scanner.Push_Entity
(Self => Self,
Entity => Self.External_Subset_Entity,
In_Document_Type => True,
In_Literal => False);
-- XXX Error processing is not implemented.
return False;
else
case Self.Version is
when XML_1_0 =>
Enter_Start_Condition (Self, Tables.DOCUMENT_10);
when XML_1_1 =>
Enter_Start_Condition (Self, Tables.DOCUMENT_11);
end case;
return True;
end if;
end On_Close_Of_Document_Type_Declaration;
-----------------------------------
-- On_Close_Of_Empty_Element_Tag --
-----------------------------------
function On_Close_Of_Empty_Element_Tag
(Self : in out Simple_Reader'Class) return Token is
begin
case Self.Version is
when XML_1_0 =>
Enter_Start_Condition (Self, Tables.DOCUMENT_10);
when XML_1_1 =>
if Is_Internal_General_Entity
(Self.Entities, Self.Scanner_State.Entity)
then
-- Character references are resolved when replacement text of
-- internal general entity is constructed. In XML 1.1 character
-- references can refer to restricted characters which is not
-- valid in text, but valid in replacement text.
Enter_Start_Condition (Self, Tables.DOCUMENT_U11);
else
Enter_Start_Condition (Self, Tables.DOCUMENT_11);
end if;
end case;
return Token_Empty_Close;
end On_Close_Of_Empty_Element_Tag;
----------------------------------------
-- On_Close_Of_Processing_Instruction --
----------------------------------------
function On_Close_Of_Processing_Instruction
(Self : in out Simple_Reader'Class;
Is_Empty : Boolean) return Token is
begin
if Is_Empty then
Set_String_Internal
(Item => Self.YYLVal,
String => Matreshka.Internals.Strings.Shared_Empty'Access,
Is_Whitespace => False);
else
if not Self.Whitespace_Matched then
raise Program_Error
with "no whitespace before processing instruction data";
-- XXX This is recoverable error.
end if;
Set_String_Internal
(Item => Self.YYLVal,
String => YY_Text (Self, 0, 2),
Is_Whitespace => False);
end if;
Pop_Start_Condition (Self);
return Token_Pi_Close;
end On_Close_Of_Processing_Instruction;
---------------------
-- On_Close_Of_Tag --
---------------------
function On_Close_Of_Tag
(Self : in out Simple_Reader'Class) return Token is
begin
case Self.Version is
when XML_1_0 =>
Enter_Start_Condition (Self, Tables.DOCUMENT_10);
when XML_1_1 =>
if Is_Internal_General_Entity
(Self.Entities, Self.Scanner_State.Entity)
then
-- Character references are resolved when replacement text of
-- internal general entity is constructed. In XML 1.1 character
-- references can refer to restricted characters which is not
-- valid in text, but valid in replacement text.
Enter_Start_Condition (Self, Tables.DOCUMENT_U11);
else
Enter_Start_Condition (Self, Tables.DOCUMENT_11);
end if;
end case;
return Token_Close;
end On_Close_Of_Tag;
-----------------------------------------
-- On_Close_Of_XML_Or_Text_Declaration --
-----------------------------------------
function On_Close_Of_XML_Or_Text_Declaration
(Self : in out Simple_Reader'Class) return Token is
begin
Set_String_Internal
(Item => Self.YYLVal,
String => Matreshka.Internals.Strings.Shared_Empty'Access,
Is_Whitespace => False);
if Self.Scanner_State.Entity /= No_Entity then
-- End of text declaration of the external entity is reached,
-- save current position to start from it next time entity is
-- referenced.
Set_First_Position
(Self.Entities,
Self.Scanner_State.Entity,
Self.Scanner_State.YY_Current_Position);
end if;
Pop_Start_Condition (Self);
return Token_Pi_Close;
end On_Close_Of_XML_Or_Text_Declaration;
-------------------------------------------------
-- On_Close_Parenthesis_In_Content_Declaration --
-------------------------------------------------
function On_Close_Parenthesis_In_Content_Declaration
(Self : in out Simple_Reader'Class) return Token is
begin
-- Whitespace can't be present between close parenthesis and
-- multiplicity indicator if any, so reset whitespace matching flag.
Self.Whitespace_Matched := False;
return Token_Close_Parenthesis;
end On_Close_Parenthesis_In_Content_Declaration;
------------------------------------------------
-- On_Close_Parenthesis_In_Notation_Attribute --
------------------------------------------------
function On_Close_Parenthesis_In_Notation_Attribute
(Self : in out Simple_Reader'Class) return Token is
begin
-- Resets whitespace matching flag.
Self.Whitespace_Matched := False;
return Token_Close_Parenthesis;
end On_Close_Parenthesis_In_Notation_Attribute;
--------------------------------------
-- On_Conditional_Section_Directive --
--------------------------------------
procedure On_Conditional_Section_Directive
(Self : in out Simple_Reader'Class;
Include : Boolean) is
begin
-- XXX Syntax check must be added!
Self.Conditional_Directive := True;
Self.Conditional_Depth := Self.Conditional_Depth + 1;
if Self.Ignore_Depth /= 0 or not Include then
Self.Ignore_Depth := Self.Ignore_Depth + 1;
end if;
end On_Conditional_Section_Directive;
----------------------------------------------
-- On_Content_Of_Ignore_Conditional_Section --
----------------------------------------------
procedure On_Content_Of_Ignore_Conditional_Section
(Self : in out Simple_Reader'Class) is
begin
YY_Move_Backward (Self);
YY_Move_Backward (Self);
YY_Move_Backward (Self);
end On_Content_Of_Ignore_Conditional_Section;
----------------------------
-- On_Default_Declaration --
----------------------------
function On_Default_Declaration
(Self : in out Simple_Reader'Class;
State : Interfaces.Unsigned_32;
Default_Token : Token) return Token is
begin
-- Checks ithat whitespace before attribute type keyword is detected
-- and report error when check fail.
if not Self.Whitespace_Matched then
-- XXX This is recoverable error.
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("whitespace required before default declaration"));
return Error;
end if;
Self.Whitespace_Matched := False;
Enter_Start_Condition (Self, State);
return Default_Token;
end On_Default_Declaration;
---------------------------------------------------
-- On_Element_Name_In_Attribute_List_Declaration --
---------------------------------------------------
function On_Element_Name_In_Attribute_List_Declaration
(Self : in out Simple_Reader'Class) return Token
is
Qname_Error : Boolean;
begin
-- [XML [52]] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>'
--
-- Checks whitespace before the element name is present.
if not Self.Whitespace_Matched then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML [52] AttlistDecl]"
& " no whitespace before element's name"));
return Error;
end if;
Self.Whitespace_Matched := False;
Resolve_Symbol
(Self, 0, 0, False, True, False, Qname_Error, Self.YYLVal.Symbol);
if Qname_Error then
return Error;
else
Enter_Start_Condition (Self, Tables.ATTLIST_DECL);
return Token_Name;
end if;
end On_Element_Name_In_Attribute_List_Declaration;
-------------------------
-- On_Encoding_Keyword --
-------------------------
function On_Encoding_Keyword
(Self : in out Simple_Reader'Class) return Token is
begin
if not Self.Whitespace_Matched then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("no whitespace before 'encoding'"));
Self.Error_Reported := True;
-- XXX This is recoverable error.
return Error;
else
return Token_Encoding;
end if;
end On_Encoding_Keyword;
-------------------------------------
-- On_Entity_Value_Close_Delimiter --
-------------------------------------
function On_Entity_Value_Close_Delimiter
(Self : in out Simple_Reader'Class) return Token
is
-- NOTE: Entity value delimiter can be ' or " and both are
-- represented as single UTF-16 code unit, thus expensive UTF-16
-- decoding can be avoided.
Delimiter : constant Matreshka.Internals.Unicode.Code_Point
:= Code_Point
(Self.Scanner_State.Data.Value
(Self.Scanner_State.YY_Base_Position));
begin
if Self.Scanner_State.In_Literal
or else Self.Scanner_State.Delimiter /= Delimiter
then
Set_String_Internal
(Item => Self.YYLVal,
String => YY_Text (Self),
Is_Whitespace => False);
return Token_String_Segment;
else
Enter_Start_Condition (Self, Tables.ENTITY_DEF);
return Token_Value_Close;
end if;
end On_Entity_Value_Close_Delimiter;
------------------------------------
-- On_Entity_Value_Open_Delimiter --
------------------------------------
function On_Entity_Value_Open_Delimiter
(Self : in out Simple_Reader'Class) return Token is
begin
-- NOTE: Entity value delimiter can be ' or " and both are
-- represented as single UTF-16 code unit, thus expensive UTF-16
-- decoding can be avoided.
Self.Scanner_State.Delimiter :=
Code_Point
(Self.Scanner_State.Data.Value (Self.Scanner_State.YY_Base_Position));
if not Self.Whitespace_Matched then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[[71] GEDecl, [72] PEDecl]"
& " no whitespace before entity value"));
return Error;
end if;
Self.Whitespace_Matched := False;
case Self.Version is
when XML_1_0 =>
Enter_Start_Condition (Self, Tables.ENTITY_VALUE_10);
when XML_1_1 =>
Enter_Start_Condition (Self, Tables.ENTITY_VALUE_11);
end case;
return Token_Value_Open;
end On_Entity_Value_Open_Delimiter;
----------------------------------------------------
-- On_General_Entity_Reference_In_Attribute_Value --
----------------------------------------------------
function On_General_Entity_Reference_In_Attribute_Value
(Self : in out Simple_Reader'Class) return Boolean
is
Qualified_Name : Symbol_Identifier;
Qname_Error : Boolean;
Entity : Entity_Identifier;
State : Scanner_State_Information;
begin
Resolve_Symbol
(Self, 1, 1, False, False, False, Qname_Error, Qualified_Name);
if Qname_Error then
return False;
end if;
Entity := General_Entity (Self.Symbols, Qualified_Name);
-- [XML1.1 4.1 WFC: Entity Declared]
--
-- "In a document without any DTD, a document with only an internal
-- DTD subset which contains no parameter entity references, or a
-- document with "standalone='yes'", for an entity reference that
-- does not occur within the external subset or a parameter entity,
-- the Name given in the entity reference MUST match that in an
-- entity declaration that does not occur within the external subset
-- or a parameter entity, except that well-formed documents need not
-- declare any of the following entities: amp, lt, gt, apos, quot.
-- The declaration of a general entity MUST precede any reference
-- to it which appears in a default value in an attribute-list
-- declaration.
--
-- Note that non-validating processors are not obligated to to read
-- and process entity declarations occurring in parameter entities
-- or in the external subset; for such documents, the rule that an
-- entity must be declared is a well-formedness constraint only if
-- standalone='yes'."
--
-- Check whether entity is declared.
--
-- XXX This is probably too strong check, need to be arranged with
-- standalone documents and validation.
if Entity = No_Entity then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML1.1 4.1 WFC: Entity Declared]"
& " general entity must be declared"));
return False;
elsif Enclosing_Entity (Self.Entities, Entity) = No_Entity then
-- All predefined entities doesn't have enclosing entity.
null;
elsif Self.Is_Standalone
and not Is_Parameter_Entity (Self.Entities, Self.Scanner_State.Entity)
and not Is_External_Subset (Self.Entities, Self.Scanner_State.Entity)
and not Is_Document_Entity
(Self.Entities, Enclosing_Entity (Self.Entities, Entity))
then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML1.1 4.1 WFC: Entity Declared]"
& " general entity must not be declared externally"));
return False;
end if;
-- [XML1.1 4.1 WFC: Parsed Entity]
--
-- "An entity reference MUST NOT contain the name of an unparsed
-- entity. Unparsed entities may be referred to only in attribute
-- values declared to be of type ENTITY or ENTITIES."
--
-- Check whether referenced entity is not unparsed external general
-- entity. XXX Attribute's value type must be checked also.
if Is_External_Unparsed_General_Entity (Self.Entities, Entity) then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML1.1 4.1 WFC: Parsed Entity]"
& " an entity reference must not contain the name of an"
& " unparsed entity"));
return False;
end if;
-- [XML1.1 3.1 WFC: No External Entity References]
--
-- "Attribute values MUST NOT contain direct or indirect entity
-- references to external entities."
--
-- Check whether referenced entity is not parsed external general
-- entity.
if Is_External_Parsed_General_Entity (Self.Entities, Entity) then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML1.1 3.1 WFC: No External Entity References]"
& " attribute value must not contain entity reference to"
& " external entity"));
return False;
end if;
-- [XML1.1 4.1 WFC: No Recursion]
--
-- "A parsed entity MUST NOT contain a recursive reference to itself,
-- either directly or indirectly."
--
-- Check whether there is no replacement text of the same entity in the
-- scanner stack.
if Self.Scanner_State.Entity = Entity then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML1.1 4.1 WFC: No Recursion]"
& " parsed entity must not containt a direct recursive"
& " reference to itself"));
return False;
end if;
for J in 1 .. Integer (Self.Scanner_Stack.Length) loop
State := Self.Scanner_Stack.Element (J);
if State.Entity = Entity then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML1.1 4.1 WFC: No Recursion]"
& " parsed entity must not containt a indirect recursive"
& " reference to itself"));
return False;
end if;
end loop;
return
Push_Entity
(Self => Self,
Entity => Entity,
In_Document_Type => False,
In_Literal => True);
end On_General_Entity_Reference_In_Attribute_Value;
-----------------------------------------------------
-- On_General_Entity_Reference_In_Document_Content --
-----------------------------------------------------
function On_General_Entity_Reference_In_Document_Content
(Self : in out Simple_Reader'Class) return Token
is
Qualified_Name : Symbol_Identifier;
Qname_Error : Boolean;
Entity : Entity_Identifier;
State : Scanner_State_Information;
Deep : Natural;
begin
Resolve_Symbol
(Self, 1, 1, False, False, False, Qname_Error, Qualified_Name);
if Qname_Error then
return Error;
end if;
-- [1] document ::=
-- ( prolog element Misc* ) - ( Char* RestrictedChar Char* )
--
-- [39] element ::= EmptyElemTag | STag content ETag
--
-- [43] content ::=
-- CharData?
-- ((element | Reference | CDSect | PI | Comment) CharData?)*
--
-- Check that entity is referenced inside element content.
if Self.Element_Names.Is_Empty then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("entity reference must be in content of element"));
return Error;
end if;
Entity := General_Entity (Self.Symbols, Qualified_Name);
-- [XML1.1 4.1 WFC: Entity Declared]
--
-- "In a document without any DTD, a document with only an internal
-- DTD subset which contains no parameter entity references, or a
-- document with "standalone='yes'", for an entity reference that
-- does not occur within the external subset or a parameter entity,
-- the Name given in the entity reference MUST match that in an
-- entity declaration that does not occur within the external subset
-- or a parameter entity, except that well-formed documents need not
-- declare any of the following entities: amp, lt, gt, apos, quot.
-- The declaration of a general entity MUST precede any reference
-- to it which appears in a default value in an attribute-list
-- declaration.
--
-- Note that non-validating processors are not obligated to to read
-- and process entity declarations occurring in parameter entities
-- or in the external subset; for such documents, the rule that an
-- entity must be declared is a well-formedness constraint only if
-- standalone='yes'."
--
-- Check whether entity is declared.
--
-- XXX This is probably too strong check, need to be arranged with
-- standalone documents and validation.
if Entity = No_Entity then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML1.1 4.1 WFC: Entity Declared]"
& " general entity must be declared"));
return Error;
elsif Enclosing_Entity (Self.Entities, Entity) = No_Entity then
-- All predefined entities doesn't have enclosing entity.
null;
elsif Self.Is_Standalone
and not Is_Parameter_Entity (Self.Entities, Self.Scanner_State.Entity)
and not Is_External_Subset (Self.Entities, Self.Scanner_State.Entity)
and not Is_Document_Entity
(Self.Entities, Enclosing_Entity (Self.Entities, Entity))
then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML1.1 4.1 WFC: Entity Declared]"
& " general entity must not be declared externally"));
return Error;
end if;
-- [XML1.1 4.1 WFC: Parsed Entity]
--
-- "An entity reference MUST NOT contain the name of an unparsed
-- entity. Unparsed entities may be referred to only in attribute
-- values declared to be of type ENTITY or ENTITIES."
--
-- Check whether referenced entity is not unparsed external general
-- entity.
if Is_External_Unparsed_General_Entity (Self.Entities, Entity) then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML1.1 4.1 WFC: Parsed Entity]"
& " an entity reference must not contain the name of an"
& " unparsed entity"));
return Error;
end if;
-- [XML1.1 4.1 WFC: No Recursion]
--
-- "A parsed entity MUST NOT contain a recursive reference to itself,
-- either directly or indirectly."
--
-- Check whether there is no replacement text of the same entity in the
-- scanner stack.
if Self.Scanner_State.Entity = Entity then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML1.1 4.1 WFC: No Recursion]"
& " parsed entity must not containt a direct recursive"
& " reference to itself"));
return Error;
end if;
for J in 1 .. Integer (Self.Scanner_Stack.Length) loop
State := Self.Scanner_Stack.Element (J);
if State.Entity = Entity then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML1.1 4.1 WFC: No Recursion]"
& " parsed entity must not containt a indirect recursive"
& " reference to itself"));
return Error;
end if;
end loop;
Deep := Integer (Self.Scanner_Stack.Length);
if not Push_Entity
(Self => Self,
Entity => Entity,
In_Document_Type => False,
In_Literal => False)
then
return Error;
elsif Deep = Integer (Self.Scanner_Stack.Length) then
-- Entity doesn't pushed in stack because its replacement text
-- is empty.
return End_Of_Input;
else
Self.Scanner_State.Start_Issued := True;
return Token_Entity_Start;
end if;
end On_General_Entity_Reference_In_Document_Content;
-------------------------------------------------
-- On_General_Entity_Reference_In_Entity_Value --
-------------------------------------------------
function On_General_Entity_Reference_In_Entity_Value
(Self : in out Simple_Reader'Class) return Token
is
Qualified_Name : Symbol_Identifier;
Qname_Error : Boolean;
begin
Resolve_Symbol
(Self, 1, 1, False, False, False, Qname_Error, Qualified_Name);
if Qname_Error then
return Error;
else
Set_String_Internal
(Item => Self.YYLVal,
String => YY_Text (Self),
Is_Whitespace => False);
return Token_String_Segment;
end if;
end On_General_Entity_Reference_In_Entity_Value;
------------------------------------------
-- On_Less_Than_Sign_In_Attribute_Value --
------------------------------------------
function On_Less_Than_Sign_In_Attribute_Value
(Self : in out Simple_Reader'Class) return Token is
begin
-- [3.1 WFC: No < in Attribute Values]
--
-- "The replacement text of any entity referred to directly or
-- indirectly in an attribute value MUST NOT contain a <."
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[3.1 WFC: No < in Attribute Values]"
& " '<' can't be used in attribute value"));
Self.Error_Reported := True;
return Error;
end On_Less_Than_Sign_In_Attribute_Value;
----------------------------------------------------
-- On_Name_In_Attribute_List_Declaration_Notation --
----------------------------------------------------
function On_Name_In_Attribute_List_Declaration_Notation
(Self : in out Simple_Reader'Class) return Token
is
Qname_Error : Boolean;
begin
-- [XMLNS 7]
--
-- "It follows that in a namespace-well-formed document:
--
-- - All element and attribute names contain either zero or one colon;
--
-- - No entity names, processing instruction targets, or notation
-- names contain any colons."
--
-- This code is used to handle names in both NOTATION and enumeration
-- attribute declarations, thus it must distinguish colon handling.
Resolve_Symbol
(Self,
0,
0,
False,
True,
not Self.Notation_Attribute,
Qname_Error,
Self.YYLVal.Symbol);
if Qname_Error then
return Error;
else
return Token_Name;
end if;
end On_Name_In_Attribute_List_Declaration_Notation;
------------------------------------
-- On_Name_In_Element_Declaration --
------------------------------------
function On_Name_In_Element_Declaration
(Self : in out Simple_Reader'Class) return Token
is
Qname_Error : Boolean;
begin
-- Production [45] requires whitespace after name and before content
-- specification, so whitespace indicator is reset here.
Self.Whitespace_Matched := False;
Resolve_Symbol
(Self, 0, 0, False, True, False, Qname_Error, Self.YYLVal.Symbol);
if Qname_Error then
return Error;
else
Enter_Start_Condition (Self, Tables.ELEMENT_DECL);
return Token_Name;
end if;
end On_Name_In_Element_Declaration;
---------------------------------------------
-- On_Name_In_Element_Declaration_Children --
---------------------------------------------
function On_Name_In_Element_Declaration_Children
(Self : in out Simple_Reader'Class) return Token
is
Qname_Error : Boolean;
begin
-- Production [48] checks that no whitespace separates Name from
-- following multiplicity indicator, so whitespace indicator must be
-- reset here.
Self.Whitespace_Matched := False;
Resolve_Symbol
(Self, 0, 0, False, True, False, Qname_Error, Self.YYLVal.Symbol);
if Qname_Error then
return Error;
else
return Token_Name;
end if;
end On_Name_In_Element_Declaration_Children;
----------------------------------
-- On_Name_In_Element_Start_Tag --
----------------------------------
function On_Name_In_Element_Start_Tag
(Self : in out Simple_Reader'Class) return Token
is
Qname_Error : Boolean;
begin
if not Self.Whitespace_Matched then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("whitespace is missing before attribute name"));
-- XXX It is recoverable error.
return Error;
end if;
Resolve_Symbol
(Self, 0, 0, False, True, False, Qname_Error, Self.YYLVal.Symbol);
if Qname_Error then
return Error;
else
return Token_Name;
end if;
end On_Name_In_Element_Start_Tag;
-----------------------------------
-- On_Name_In_Entity_Declaration --
-----------------------------------
function On_Name_In_Entity_Declaration
(Self : in out Simple_Reader'Class) return Token
is
Qname_Error : Boolean;
begin
-- [XML1.1 4.2]
--
-- [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>'
-- [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>'
--
-- Check whether whitespace is present before the name.
if not Self.Whitespace_Matched then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML1.1 4.2 productions [71], [72]]"
& " whitespace must be present before the name"));
-- XXX This is recoverable error.
return Error;
end if;
Resolve_Symbol
(Self, 0, 0, False, False, False, Qname_Error, Self.YYLVal.Symbol);
if Qname_Error then
return Error;
else
Self.Whitespace_Matched := False;
Enter_Start_Condition (Self, Tables.ENTITY_DEF);
return Token_Name;
end if;
end On_Name_In_Entity_Declaration;
--------------------------------------------
-- On_Name_In_Entity_Declaration_Notation --
--------------------------------------------
function On_Name_In_Entity_Declaration_Notation
(Self : in out Simple_Reader'Class) return Token
is
Qname_Error : Boolean;
begin
-- [XML1.1 4.2.2]
--
-- [76] NDataDecl ::= S 'NDATA' S Name
--
-- Check whether whitespace is present before the name.
if not Self.Whitespace_Matched then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML1.1 4.2 production [76]]"
& " whitespace must be present before the name of notation"));
-- XXX This is recoverable error.
return Error;
end if;
Resolve_Symbol
(Self, 0, 0, False, False, False, Qname_Error, Self.YYLVal.Symbol);
if Qname_Error then
return Error;
else
Enter_Start_Condition (Self, Tables.ENTITY_DEF);
return Token_Name;
end if;
end On_Name_In_Entity_Declaration_Notation;
--------------
-- On_NDATA --
--------------
function On_NDATA (Self : in out Simple_Reader'Class) return Token is
begin
if not Self.Whitespace_Matched then
-- XXX This is recoverable error.
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("whitespace required before NDATA"));
Self.Error_Reported := True;
return Error;
else
Self.Whitespace_Matched := False;
Enter_Start_Condition (Self, Tables.ENTITY_NDATA);
return Token_Ndata;
end if;
end On_NDATA;
---------------------------
-- On_No_XML_Declaration --
---------------------------
procedure On_No_XML_Declaration (Self : in out Simple_Reader'Class) is
begin
-- Move scanner's position back to the start of the document or external
-- parsed entity. Entity's XML version and encoding are set up
-- automatically.
YY_Move_Backward (Self);
Pop_Start_Condition (Self);
end On_No_XML_Declaration;
-------------------------------------------
-- On_Open_Of_Attribute_List_Declaration --
-------------------------------------------
function On_Open_Of_Attribute_List_Declaration
(Self : in out Simple_Reader'Class) return Token is
begin
Enter_Start_Condition (Self, Tables.ATTLIST_NAME);
Self.Whitespace_Matched := False;
return Token_Attlist_Decl_Open;
end On_Open_Of_Attribute_List_Declaration;
----------------------
-- On_Open_Of_CDATA --
----------------------
function On_Open_Of_CDATA
(Self : in out Simple_Reader'Class) return Token
is
Condition : Interfaces.Unsigned_32;
begin
case Start_Condition (Self) is
when Tables.DOCUMENT_10 =>
Condition := Tables.CDATA_10;
when Tables.DOCUMENT_11 =>
Condition := Tables.CDATA_11;
when Tables.DOCUMENT_U11 =>
Condition := Tables.CDATA_U11;
when others =>
raise Program_Error;
end case;
Push_Current_And_Enter_Start_Condition (Self, Condition);
return Token_CData_Open;
end On_Open_Of_CDATA;
------------------------------------
-- On_Open_Of_Conditional_Section --
------------------------------------
function On_Open_Of_Conditional_Section
(Self : in out Simple_Reader'Class) return Token is
begin
-- [XML [28b], [31]] Conditional section can be present only in external
-- subset of DTD.
if Is_Document_Entity (Self.Entities, Self.Scanner_State.Entity) then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML [28b], [31]]"
& " conditional sections may only appear in the external"
& " DTD subset"));
return Error;
end if;
if Self.Ignore_Depth = 0 then
Enter_Start_Condition (Self, Tables.CONDITIONAL_DIRECTIVE);
Self.Conditional_Directive := False;
else
Self.Conditional_Depth := Self.Conditional_Depth + 1;
Self.Ignore_Depth := Self.Ignore_Depth + 1;
Self.Conditional_Directive := True;
end if;
return Token_Conditional_Open;
end On_Open_Of_Conditional_Section;
--------------------------------------------
-- On_Open_Of_Conditional_Section_Content --
--------------------------------------------
function On_Open_Of_Conditional_Section_Content
(Self : in out Simple_Reader'Class) return Boolean is
begin
-- XXX Syntax rules must be checked!
if not Self.Conditional_Directive then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("conditional directive is missing"));
return False;
end if;
if Self.Ignore_Depth /= 0 then
case Self.Version is
when XML_1_0 =>
Enter_Start_Condition (Self, Tables.CONDITIONAL_IGNORE_10);
when XML_1_1 =>
Enter_Start_Condition (Self, Tables.CONDITIONAL_IGNORE_11);
end case;
else
case Self.Version is
when XML_1_0 =>
Enter_Start_Condition (Self, Tables.DOCTYPE_INTSUBSET_10);
when XML_1_1 =>
Enter_Start_Condition (Self, Tables.DOCTYPE_INTSUBSET_11);
end case;
end if;
return True;
end On_Open_Of_Conditional_Section_Content;
------------------------------------------
-- On_Open_Of_Document_Type_Declaration --
------------------------------------------
function On_Open_Of_Document_Type_Declaration
(Self : in out Simple_Reader'Class) return Token
is
Qname_Error : Boolean;
begin
Resolve_Symbol
(Self, 10, 0, True, True, False, Qname_Error, Self.YYLVal.Symbol);
if Qname_Error then
return Error;
else
Enter_Start_Condition (Self, Tables.DOCTYPE_EXTINT);
return Token_Doctype_Decl_Open;
end if;
end On_Open_Of_Document_Type_Declaration;
------------------------------------
-- On_Open_Of_Element_Declaration --
------------------------------------
function On_Open_Of_Element_Declaration
(Self : in out Simple_Reader'Class) return Token is
begin
Enter_Start_Condition (Self, Tables.ELEMENT_NAME);
return Token_Element_Decl_Open;
end On_Open_Of_Element_Declaration;
------------------------
-- On_Open_Of_End_Tag --
------------------------
function On_Open_Of_End_Tag
(Self : in out Simple_Reader'Class) return Token
is
Qname_Error : Boolean;
begin
Resolve_Symbol
(Self, 2, 0, False, True, False, Qname_Error, Self.YYLVal.Symbol);
if Qname_Error then
return Error;
else
Enter_Start_Condition (Self, Tables.ELEMENT_START);
return Token_End_Open;
end if;
end On_Open_Of_End_Tag;
--------------------------------
-- On_Open_Of_Internal_Subset --
--------------------------------
function On_Open_Of_Internal_Subset
(Self : in out Simple_Reader'Class) return Token is
begin
case Self.Version is
when XML_1_0 =>
Enter_Start_Condition (Self, Tables.DOCTYPE_INTSUBSET_10);
when XML_1_1 =>
Enter_Start_Condition (Self, Tables.DOCTYPE_INTSUBSET_11);
end case;
return Token_Internal_Subset_Open;
end On_Open_Of_Internal_Subset;
-------------------------------------
-- On_Open_Of_Notation_Declaration --
-------------------------------------
function On_Open_Of_Notation_Declaration
(Self : in out Simple_Reader'Class) return Token
is
Qname_Error : Boolean;
begin
Resolve_Symbol
(Self, 10, 0, True, False, False, Qname_Error, Self.YYLVal.Symbol);
if Qname_Error then
return Error;
else
Push_Current_And_Enter_Start_Condition (Self, Tables.NOTATION_DECL);
return Token_Notation_Decl_Open;
end if;
end On_Open_Of_Notation_Declaration;
---------------------------------------
-- On_Open_Of_Processing_Instruction --
---------------------------------------
function On_Open_Of_Processing_Instruction
(Self : in out Simple_Reader'Class) return Token
is
Qname_Error : Boolean;
begin
Resolve_Symbol
(Self, 2, 0, False, False, False, Qname_Error, Self.YYLVal.Symbol);
if Qname_Error then
return Error;
else
Push_And_Enter_Start_Condition
(Self, Start_Condition (Self), Tables.PI);
Reset_Whitespace_Matched (Self);
return Token_Pi_Open;
end if;
end On_Open_Of_Processing_Instruction;
--------------------------
-- On_Open_Of_Start_Tag --
--------------------------
function On_Open_Of_Start_Tag
(Self : in out Simple_Reader'Class) return Token
is
Qname_Error : Boolean;
begin
Resolve_Symbol
(Self, 1, 0, False, True, False, Qname_Error, Self.YYLVal.Symbol);
if Qname_Error then
return Error;
else
Enter_Start_Condition (Self, Tables.ELEMENT_START);
return Token_Element_Open;
end if;
end On_Open_Of_Start_Tag;
----------------------------------------
-- On_Open_Of_XML_Or_Text_Declaration --
----------------------------------------
function On_Open_Of_XML_Or_Text_Declaration
(Self : in out Simple_Reader'Class) return Token is
begin
Self.Whitespace_Matched := False;
Push_And_Enter_Start_Condition
(Self, Start_Condition (Self), Tables.XML_DECL);
return Token_Xml_Decl_Open;
end On_Open_Of_XML_Or_Text_Declaration;
------------------------------------------------
-- On_Open_Parenthesis_In_Content_Declaration --
------------------------------------------------
function On_Open_Parenthesis_In_Content_Declaration
(Self : in out Simple_Reader'Class) return Token
is
use type Interfaces.Unsigned_32;
begin
if Start_Condition (Self) = Tables.ELEMENT_DECL then
-- Check whitespace from rule [45] elementdecl. This subprogram
-- changes scanner's start condition, so handing of nested
-- declarations skip check below.
if not Self.Whitespace_Matched then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML [45]] no whitespace after name"));
return Error;
end if;
Enter_Start_Condition (Self, Tables.ELEMENT_CHILDREN);
end if;
return Token_Open_Parenthesis;
end On_Open_Parenthesis_In_Content_Declaration;
-----------------------------------------------
-- On_Open_Parenthesis_In_Notation_Attribute --
-----------------------------------------------
function On_Open_Parenthesis_In_Notation_Attribute
(Self : in out Simple_Reader'Class) return Token is
begin
-- Checks ithat whitespace before open parenthesis is detected
-- and report error when check fail.
if not Self.Whitespace_Matched then
-- XXX This is recoverable error.
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("whitespace required before open parenthesis"));
return Error;
end if;
return Token_Open_Parenthesis;
end On_Open_Parenthesis_In_Notation_Attribute;
-----------------------------------------------------------
-- On_Parameter_Entity_Reference_In_Document_Declaration --
-----------------------------------------------------------
function On_Parameter_Entity_Reference_In_Document_Declaration
(Self : in out Simple_Reader'Class) return Token
is
Qualified_Name : Symbol_Identifier;
Qname_Error : Boolean;
Entity : Entity_Identifier;
Deep : Natural;
begin
Resolve_Symbol
(Self, 1, 1, False, False, False, Qname_Error, Qualified_Name);
if Qname_Error then
return Error;
end if;
Entity := Parameter_Entity (Self.Symbols, Qualified_Name);
if Entity = No_Entity then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("parameter entity must be declared"));
return Error;
end if;
Deep := Integer (Self.Scanner_Stack.Length);
if not Push_Entity
(Self => Self,
Entity => Entity,
In_Document_Type => False,
In_Literal => False)
then
return Error;
elsif Deep = Integer (Self.Scanner_Stack.Length) then
-- Entity doesn't pushed in stack because its replacement text
-- is empty.
return End_Of_Input;
else
Self.Scanner_State.Start_Issued := True;
return Token_Entity_Start;
end if;
end On_Parameter_Entity_Reference_In_Document_Declaration;
---------------------------------------------------
-- On_Parameter_Entity_Reference_In_Entity_Value --
---------------------------------------------------
function On_Parameter_Entity_Reference_In_Entity_Value
(Self : in out Simple_Reader'Class) return Boolean
is
Qualified_Name : Symbol_Identifier;
Qname_Error : Boolean;
Entity : Entity_Identifier;
begin
Resolve_Symbol
(Self, 1, 1, False, False, False, Qname_Error, Qualified_Name);
if Qname_Error then
return False;
else
Entity := Parameter_Entity (Self.Symbols, Qualified_Name);
-- XML WFC: PEs in Internal Subset
--
-- "In the internal DTD subset, parameter-entity references MUST NOT
-- occur within markup declarations; they may occur where markup
-- declarations can occur. (This does not apply to references that
-- occur in external parameter entities or to the external subset.)"
--
-- Check whether parameter entity reference doesn't occure in the
-- entity value of the entity declared in internal subset.
if Is_Document_Entity (Self.Entities, Self.Scanner_State.Entity) then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML 2.8 WFC: PEs in Internal Subset]"
& " parameter-entity reference in internal subset must not"
& " occur within markup declaration"));
return False;
end if;
-- XML VC: Entity Declared
--
-- "In a document with an external subset or parameter entity
-- references with "standalone='no'", the Name given in the entity
-- reference MUST match that in an entity declaration. For
-- interoperability, valid documents SHOULD declare the entities amp,
-- lt, gt, apos, quot, in the form specified in 4.6 Predefined
-- Entities. The declaration of a parameter entity MUST precede any
-- reference to it. Similarly, the declaration of a general entity
-- MUST precede any attribute-list declaration containing a default
-- value with a direct or indirect reference to that general entity."
--
-- XXX Parameter entity must not be declared at the point of
-- reference, except in some conditions in validating mode; so,
-- check below must be improved, as well as behavior in
-- non-validating mode must be checked.
if Entity = No_Entity then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("parameter entity must be declared"));
return False;
end if;
return
Push_Entity
(Self => Self,
Entity => Entity,
In_Document_Type => False,
In_Literal => True);
end if;
end On_Parameter_Entity_Reference_In_Entity_Value;
---------------------------------------------------------
-- On_Parameter_Entity_Reference_In_Markup_Declaration --
---------------------------------------------------------
function On_Parameter_Entity_Reference_In_Markup_Declaration
(Self : in out Simple_Reader'Class) return Boolean
is
Qualified_Name : Symbol_Identifier;
Qname_Error : Boolean;
Entity : Entity_Identifier;
begin
Resolve_Symbol
(Self, 1, 1, False, False, False, Qname_Error, Qualified_Name);
if Qname_Error then
return False;
else
-- [XML 2.8] WFC: PEs in Internal Subset
--
-- "In the internal DTD subset, parameter-entity references MUST NOT
-- occur within markup declarations; they may occur where markup
-- declarations can occur. (This does not apply to references that
-- occur in external parameter entities or to the external subset.)"
--
-- Check whether external subset is processed.
if not Self.External_Subset_Done then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML 2.8 WFC: PEs in Internal Subset]"
& " parameter-entity reference in internal subset must not"
& " occur within markup declaration"));
return False;
end if;
Entity := Parameter_Entity (Self.Symbols, Qualified_Name);
if Entity = No_Entity then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("parameter entity must be declared"));
return False;
end if;
return
Push_Entity
(Self => Self,
Entity => Entity,
In_Document_Type => False,
In_Literal => True);
end if;
end On_Parameter_Entity_Reference_In_Markup_Declaration;
---------------------
-- On_Percent_Sign --
---------------------
function On_Percent_Sign
(Self : in out Simple_Reader'Class) return Token is
begin
if not Self.Whitespace_Matched then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("no whitespace before percent"));
Self.Error_Reported := True;
-- XXX This is recoverable error.
return Error;
else
Self.Whitespace_Matched := False;
return Token_Percent;
end if;
end On_Percent_Sign;
------------------------------------
-- On_Plus_In_Content_Declaration --
------------------------------------
function On_Plus_In_Content_Declaration
(Self : in out Simple_Reader'Class) return Token is
begin
if Self.Whitespace_Matched then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML [47], [48]] illegal whitespace before plus"));
return Error;
else
return Token_Plus;
end if;
end On_Plus_In_Content_Declaration;
-----------------------
-- On_Public_Literal --
-----------------------
function On_Public_Literal
(Self : in out Simple_Reader'Class) return Token
is
Next : Utf16_String_Index
:= Self.Scanner_State.YY_Base_Position + 1;
-- Skip literal open delimiter.
Code : Code_Point;
Space_Before : Boolean := True;
begin
if not Self.Whitespace_Matched then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[[75] ExternalID, [83] PublicID]"
& " whitespace is required before pubid literal"));
return Error;
end if;
Self.Whitespace_Matched := False;
Enter_Start_Condition (Self, Tables.EXTERNAL_ID_SYS);
-- [XML 4.2.2] External Entities
--
-- "[Definition: In addition to a system identifier, an external
-- identifier may include a public identifier.] An XML processor
-- attempting to retrieve the entity's content may use any combination
-- of the public and system identifiers as well as additional
-- information outside the scope of this specification to try to
-- generate an alternative URI reference. If the processor is unable to
-- do so, it MUST use the URI reference specified in the system literal.
-- Before a match is attempted, all strings of white space in the public
-- identifier MUST be normalized to single space characters (#x20), and
-- leading and trailing white space MUST be removed."
--
-- Normalize public identifier.
Matreshka.Internals.Strings.Operations.Reset (Self.Character_Data);
while Next /= Self.Scanner_State.YY_Current_Position - 1 loop
-- Exclude literal close delimiter.
Unchecked_Next (Self.Scanner_State.Data.Value, Next, Code);
-- It can be reasonable to implement this step of normalization on
-- SIMD.
if Code = Character_Tabulation
or Code = Line_Feed
or Code = Carriage_Return
then
Code := Space;
end if;
if Code = Space then
if not Space_Before then
Matreshka.Internals.Strings.Operations.Unterminated_Append
(Self.Character_Data, Code);
Space_Before := True;
end if;
else
Matreshka.Internals.Strings.Operations.Unterminated_Append
(Self.Character_Data, Code);
Space_Before := False;
end if;
end loop;
if Space_Before and Self.Character_Data.Unused /= 0 then
-- Remove traling space.
Self.Character_Data.Length := Self.Character_Data.Length - 1;
Self.Character_Data.Unused := Self.Character_Data.Unused - 1;
end if;
String_Handler.Fill_Null_Terminator (Self.Character_Data);
Matreshka.Internals.Strings.Reference (Self.Character_Data);
Set_String_Internal
(Item => Self.YYLVal,
String => Self.Character_Data,
Is_Whitespace => False);
return Token_Public_Literal;
end On_Public_Literal;
---------------------------------------------
-- On_Question_Mark_In_Content_Declaration --
---------------------------------------------
function On_Question_Mark_In_Content_Declaration
(Self : in out Simple_Reader'Class) return Token is
begin
if Self.Whitespace_Matched then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[XML [47], [48]] illegal whitespace before question mark"));
return Error;
else
return Token_Question;
end if;
end On_Question_Mark_In_Content_Declaration;
---------------------------
-- On_Standalone_Keyword --
---------------------------
function On_Standalone_Keyword
(Self : in out Simple_Reader'Class) return Token is
begin
if not Self.Whitespace_Matched then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("no whitespace before 'standalone'"));
Self.Error_Reported := True;
-- XXX This is recoverable error.
return Error;
else
return Token_Standalone;
end if;
end On_Standalone_Keyword;
----------------------------------------
-- On_System_Keyword_In_Document_Type --
----------------------------------------
function On_System_Keyword_In_Document_Type
(Self : in out Simple_Reader'Class) return Token is
begin
Reset_Whitespace_Matched (Self);
Push_And_Enter_Start_Condition
(Self, Tables.DOCTYPE_INT, Tables.EXTERNAL_ID_SYS);
return Token_System;
end On_System_Keyword_In_Document_Type;
---------------------------------------------
-- On_System_Keyword_In_Entity_Or_Notation --
---------------------------------------------
function On_System_Keyword_In_Entity_Or_Notation
(Self : in out Simple_Reader'Class) return Token is
begin
Reset_Whitespace_Matched (Self);
Push_Current_And_Enter_Start_Condition (Self, Tables.EXTERNAL_ID_SYS);
return Token_System;
end On_System_Keyword_In_Entity_Or_Notation;
-----------------------
-- On_System_Literal --
-----------------------
function On_System_Literal
(Self : in out Simple_Reader'Class) return Token is
begin
if not Self.Whitespace_Matched then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[[75] ExternalID]"
& " whitespace is required before system literal"));
return Error;
end if;
Self.Whitespace_Matched := False;
Pop_Start_Condition (Self);
Set_String_Internal
(Item => Self.YYLVal,
String => YY_Text (Self, 1, 1),
Is_Whitespace => False);
return Token_System_Literal;
end On_System_Literal;
-----------------------------
-- On_Unexpected_Character --
-----------------------------
function On_Unexpected_Character
(Self : in out Simple_Reader'Class) return Token is
begin
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String ("unexpected character"));
return Error;
end On_Unexpected_Character;
------------------------
-- On_Version_Keyword --
------------------------
function On_Version_Keyword
(Self : in out Simple_Reader'Class) return Token is
begin
if not Self.Whitespace_Matched then
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("no whitespace before 'version'"));
Self.Error_Reported := True;
-- XXX This is recoverable error.
return Error;
else
return Token_Version;
end if;
end On_Version_Keyword;
-------------------------------
-- On_Whitespace_In_Document --
-------------------------------
function On_Whitespace_In_Document
(Self : in out Simple_Reader'Class) return Boolean
is
C : constant Code_Point
:= Code_Point
(Self.Scanner_State.Data.Value
(Self.Scanner_State.YY_Current_Position - 1));
begin
if C = Less_Than_Sign or C = Ampersand then
-- Move back when trailing context is available.
YY_Move_Backward (Self);
end if;
if Self.Element_Names.Is_Empty then
-- Document content not entered.
return False;
else
Matreshka.Internals.Strings.Operations.Copy_Slice
(Self.Character_Data,
Self.Scanner_State.Data,
Self.Scanner_State.YY_Base_Position,
Self.Scanner_State.YY_Current_Position
- Self.Scanner_State.YY_Base_Position,
Self.Scanner_State.YY_Current_Index
- Self.Scanner_State.YY_Base_Index);
Matreshka.Internals.Strings.Reference (Self.Character_Data);
Set_String_Internal
(Item => Self.YYLVal,
String => Self.Character_Data,
Is_Whitespace => True);
return True;
end if;
end On_Whitespace_In_Document;
---------------------------------------------
-- On_Whitespace_In_Processing_Instruction --
---------------------------------------------
procedure On_Whitespace_In_Processing_Instruction
(Self : in out Simple_Reader'Class) is
begin
-- Whitespace between processing instruction's target and data are
-- required, so set flag which indicates their presence.
Self.Whitespace_Matched := True;
case Self.Version is
when XML_1_0 =>
Enter_Start_Condition (Self, Tables.PI_DATA_10);
when XML_1_1 =>
Enter_Start_Condition (Self, Tables.PI_DATA_11);
end case;
end On_Whitespace_In_Processing_Instruction;
--------------------
-- Resolve_Symbol --
--------------------
procedure Resolve_Symbol
(Self : in out Simple_Reader'Class;
Trim_Left : Natural;
Trim_Right : Natural;
Trim_Whitespace : Boolean;
Can_Be_Qname : Boolean;
Not_Qname : Boolean;
Error : out Boolean;
Symbol : out Matreshka.Internals.XML.Symbol_Identifier)
is
-- Trailing and leading character as well as whitespace characters
-- belongs to BMP and don't require expensive UTF-16 decoding.
FP : Utf16_String_Index
:= Self.Scanner_State.YY_Base_Position
+ Utf16_String_Index (Trim_Left);
FI : Positive
:= Self.Scanner_State.YY_Base_Index + Trim_Left;
LP : constant Utf16_String_Index
:= Self.Scanner_State.YY_Current_Position
- Utf16_String_Index (Trim_Right);
LI : constant Positive
:= Self.Scanner_State.YY_Current_Index - Trim_Right;
C : Code_Point;
E : Matreshka.Internals.XML.Symbol_Tables.Qualified_Name_Errors;
begin
if Trim_Whitespace then
loop
C := Code_Point (Self.Scanner_State.Data.Value (FP));
exit when
C /= Space
and then C /= Character_Tabulation
and then C /= Carriage_Return
and then C /= Line_Feed;
FP := FP + 1;
FI := FI + 1;
end loop;
end if;
Matreshka.Internals.XML.Symbol_Tables.Insert
(Self.Symbols,
Self.Scanner_State.Data,
FP,
LP - FP,
LI - FI,
Self.Namespaces.Enabled,
E,
Symbol);
Error := False;
if Self.Namespaces.Enabled and not Not_Qname then
case E is
when Valid =>
if not Can_Be_Qname
and Local_Name (Self.Symbols, Symbol) /= Symbol
then
Error := True;
Symbol := No_Symbol;
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[NSXML1.1] qualified name must not be used here"));
end if;
when Colon_At_Start =>
Error := True;
Symbol := No_Symbol;
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[NSXML1.1]"
& " qualified name must not start with colon character"));
when Colon_At_End =>
Error := True;
Symbol := No_Symbol;
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[NSXML1.1]"
& " qualified name must not end with colon character"));
when Multiple_Colons =>
Error := True;
Symbol := No_Symbol;
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[NSXML1.1]"
& " qualified name must not contain more than one colon"
& " character"));
when First_Character_Is_Not_NS_Name_Start_Char =>
Error := True;
Symbol := No_Symbol;
Callbacks.Call_Fatal_Error
(Self,
League.Strings.To_Universal_String
("[NSXML1.1] first character of local name is invalid"));
end case;
end if;
end Resolve_Symbol;
end XML.SAX.Simple_Readers.Scanner.Actions;
|
oap-template/src/main/antlr4/TemplateGrammarExpression.g4 | juangentile/oap | 0 | 737 | parser grammar TemplateGrammarExpression;
options {
language=Java;
tokenVocab=TemplateLexerExpression;
superClass = TemplateGrammarAdaptor;
}
@header {
package oap.template;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
}
@parser::members {
public TemplateGrammarExpression(TokenStream input, Map<String, List<Method>> builtInFunction, ErrorStrategy errorStrategy) {
this(input);
this.builtInFunction = builtInFunction;
this.errorStrategy = errorStrategy;
}
}
expression[TemplateType parentType] returns [MaxMin ast]
locals [String comment = null; ]
: (BLOCK_COMMENT { $comment = $BLOCK_COMMENT.text; })? exps[parentType] { $ast = $exps.ast; } orExps[parentType, $ast] { $ast = $orExps.ast; } defaultValue? function? {
if( $function.ctx != null ) {
$ast.addToBottomChildrenAndSet( $function.func );
}
$ast.addLeafs( () -> getAst($ast.bottom.type, null, false, $defaultValue.ctx != null ? $defaultValue.v : null) );
if( $comment != null ) {
$ast.setTop( new AstComment( parentType, $comment ) );
}
}
;
defaultValue returns [String v]
: DQUESTION defaultValueType { $v = $defaultValueType.v; }
;
defaultValueType returns [String v]
: SSTRING { $v = sStringToDString( $SSTRING.text ); }
| DSTRING { $v = $DSTRING.text; }
| longRule { $v = $longRule.text; }
| FLOAT { $v = $FLOAT.text; }
| BOOLEAN { $v = $BOOLEAN.text; }
;
longRule
: MINUS? DECDIGITS
;
function returns [Ast func]
: SEMI ID LPAREN functionArgs? RPAREN { $func = getFunction( $ID.text, $functionArgs.ctx != null ? $functionArgs.ret : List.of() ); }
;
functionArgs returns [ArrayList<String> ret = new ArrayList<>()]
: functionArg { $ret.add( $functionArg.ret ); } ( COMMA functionArg { $ret.add( $functionArg.ret ); } )*
;
functionArg returns [String ret]
: DECDIGITS { $ret = $DECDIGITS.text; }
| SSTRING { $ret = sStringToDString( $SSTRING.text ); }
| DSTRING { $ret = $DSTRING.text; }
;
orExps [TemplateType parentType, MaxMin firstAst] returns [MaxMin ast]
locals [ArrayList<MaxMin> list = new ArrayList<>();]
: (PIPE exps[parentType] { $list.add(firstAst); $list.add($exps.ast); } ( PIPE exps[parentType] {$list.add($exps.ast);})*) {
if( $list.isEmpty() ) $ast = firstAst;
else {
var or = new AstOr(parentType);
for( var item : $list) {
item.addToBottomChildrenAndSet(getAst(item.bottom.type, null, false));
}
or.addTry($list);
$ast = new MaxMin(or);
}
}
| { $ast = firstAst; }
;
exps [TemplateType parentType] returns [MaxMin ast]
: (exp[parentType] { $ast = $exp.ast; }
(DOT exp[$ast.bottom.type] {$ast.addToBottomChildrenAndSet($exp.ast);})*)
DOT? concatenation[$ast.bottom.type]? { if( $concatenation.ctx != null ) $ast.addToBottomChildrenAndSet( $concatenation.ast ); }
math[$ast.bottom.type]? { if( $math.ctx != null ) $ast.addToBottomChildrenAndSet( $math.ast ); }
| concatenation[parentType] { $ast = new MaxMin( $concatenation.ast ); }
;
exp[TemplateType parentType] returns [MaxMin ast]
: (ID LPAREN RPAREN) { $ast = getAst($parentType, $ID.text, true); }
| ID { $ast = getAst($parentType, $ID.text, false); }
;
concatenation[TemplateType parentType] returns [AstConcatenation ast]
: LBRACE citems[parentType] { $ast = new AstConcatenation(parentType, $citems.list); } RBRACE
;
citems[TemplateType parentType] returns [ArrayList<Ast> list = new ArrayList<Ast>()]
: citem[parentType] { $list.add($citem.ast.top); $citem.ast.addToBottomChildrenAndSet(getAst($citem.ast.bottom.type, null, false)); }
( COMMA citem[parentType] { $list.add($citem.ast.top); $citem.ast.addToBottomChildrenAndSet(getAst($citem.ast.bottom.type, null, false)); } )*
;
citem[TemplateType parentType] returns [MaxMin ast]
: ID { $ast = getAst($parentType, $ID.text, false); }
| DSTRING { $ast = new MaxMin(new AstText(sdStringToString($DSTRING.text))); }
| SSTRING { $ast = new MaxMin(new AstText(sdStringToString($SSTRING.text))); }
| DECDIGITS { $ast = new MaxMin(new AstText(String.valueOf($DECDIGITS.text))); }
| FLOAT { $ast = new MaxMin(new AstText(String.valueOf($FLOAT.text))); }
;
math[TemplateType parentType] returns [MaxMin ast]
: mathOperation number { $ast = new MaxMin(new AstMath($parentType, $mathOperation.text, $number.text)); }
;
number:
| DECDIGITS
| FLOAT
;
mathOperation
: STAR
| SLASH
| PERCENT
| PLUS
| MINUS
;
|
test/Succeed/Shadow.agda | shlevy/agda | 1,989 | 4469 | <filename>test/Succeed/Shadow.agda
-- Shadowing is allowed.
module Shadow where
module M (A : Set) where
id : Set -> Set
id A = A
|
programs/oeis/054/A054008.asm | neoneye/loda | 22 | 18493 | ; A054008: n read modulo (number of divisors of n).
; 0,0,1,1,1,2,1,0,0,2,1,0,1,2,3,1,1,0,1,2,1,2,1,0,1,2,3,4,1,6,1,2,1,2,3,0,1,2,3,0,1,2,1,2,3,2,1,8,1,2,3,4,1,6,3,0,1,2,1,0,1,2,3,1,1,2,1,2,1,6,1,0,1,2,3,4,1,6,1,0,1,2,1,0,1,2,3,0,1,6,3,2,1,2,3,0,1,2,3,1
mov $1,$0
add $0,1
seq $1,5 ; d(n) (also called tau(n) or sigma_0(n)), the number of divisors of n.
mod $0,$1
add $0,9
mul $0,2
sub $0,18
div $0,2
|
oeis/017/A017719.asm | neoneye/loda-programs | 11 | 13970 | ; A017719: Binomial coefficients C(n,55).
; 1,56,1596,30856,455126,5461512,55525372,491796152,3872894697,27540584512,179013799328,1074082795968,5996962277488,31368725759168,154603005527328,721480692460864,3201570572795084,13559593014190944,54991682779774384,214178132931752864,803167998494073240,2906703232645217440,10173461314258261040,34501303587484537440,113566790975469935740,363413731121503794368,1132173546955454128608,3438452994457305131328,10192557090712725925008,29523268814478240610368,83649261641021681729376
add $0,55
bin $0,55
|
experiments/test-suite/mutation-based/10/9/nqueens.als | kaiyuanw/AlloyFLCore | 1 | 1667 | <filename>experiments/test-suite/mutation-based/10/9/nqueens.als<gh_stars>1-10
pred test62 {
some disj Queen0, Queen1, Queen2: Queen {
Queen = Queen0 + Queen1 + Queen2
row = Queen0->7 + Queen1->6 + Queen2->5
col = Queen0->2 + Queen1->2 + Queen2->2
}
}
run test62 for 4 expect 0
pred test36 {
some disj Queen0, Queen1, Queen2: Queen {
Queen = Queen0 + Queen1 + Queen2
row = Queen0->2 + Queen1->1 + Queen2->0
col = Queen0->2 + Queen1->1 + Queen2->0
nothreat[Queen2,Queen1]
}
}
run test36 for 4 expect 0
pred test41 {
some disj Queen0, Queen1, Queen2, Queen3: Queen {
Queen = Queen0 + Queen1 + Queen2 + Queen3
row = Queen0->3 + Queen1->0 + Queen2->3 + Queen3->0
col = Queen0->2 + Queen1->0 + Queen2->3 + Queen3->0
nothreat[Queen3,Queen2]
}
}
run test41 for 4 expect 0
pred test57 {
some disj Queen0, Queen1: Queen {
Queen = Queen0 + Queen1
row = Queen0->5 + Queen1->6
col = Queen0->-7 + Queen1->-8
}
}
run test57 for 4 expect 0
pred test18 {
some disj Queen0, Queen1, Queen2, Queen3: Queen {
Queen = Queen0 + Queen1 + Queen2 + Queen3
row = Queen0->2 + Queen1->3 + Queen2->0 + Queen3->0
col = Queen0->3 + Queen1->1 + Queen2->1 + Queen3->0
nothreat[Queen3,Queen2]
}
}
run test18 for 4 expect 0
pred test17 {
some disj Queen0, Queen1, Queen2, Queen3: Queen {
Queen = Queen0 + Queen1 + Queen2 + Queen3
row = Queen0->3 + Queen1->2 + Queen2->2 + Queen3->3
col = Queen0->0 + Queen1->0 + Queen2->0 + Queen3->3
nothreat[Queen3,Queen2]
}
}
run test17 for 4 expect 1
pred test48 {
some disj Queen0, Queen1, Queen2, Queen3: Queen {
Queen = Queen0 + Queen1 + Queen2 + Queen3
row = Queen0->3 + Queen1->0 + Queen2->2 + Queen3->0
col = Queen0->2 + Queen1->0 + Queen2->3 + Queen3->0
nothreat[Queen3,Queen2]
}
}
run test48 for 4 expect 1
|
lib/am335x_sdk/ti/drv/pruss/example/apps/sorte/firmware/src/slave/sync.asm | brandonbraun653/Apollo | 2 | 29617 | ; Copyright (C) 2017 Texas Instruments Incorporated - http://www.ti.com/
;
; 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 Texas Instruments Incorporated nor the names of
; its contributors may be used to endorse or promote products derived
; from this software without specific prior written permission.
;
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;
; file: sync.asm
;
; brief: contains the timer synchronization state implementation
;
; Version Description Author
; 0.1 Created <NAME>
;include section
.include "../include/macros/macros.inc"
.include "../include/icss/icss_regs.inc"
.include "../include/protocol/sorte_pru_slave_register.inc"
.include "../include/protocol/sorte_host_interface.inc"
.include "../include/protocol/sorte_packet_definition.inc"
.include "../include/protocol/sorte_slave_cfg.inc"
.include "../include/protocol/sorte_state_define.inc"
.global FN_SYNC_STATE
.global FN1_SYNC_HANDLER
.global STATE_MACHINE_RETURN
; entry point called by main state machine for SYNC state
; will get IEP timestamp from the sync frame (at label SYNC_TYPE_OKAY) and forward frame to next slave device.
FN_SYNC_STATE:
; SYNC header parsing
; set pointer to first byte of the frame
ldi R1.b0, &R2.b0
; DA (1)
M_XIN_L2_BANK0 SYNC_DA, 1
SYNC_DA:
mvib R30.b0, *R1.b0++
M_PUSH_BYTE
; SA (2)
M_XIN_L2_BANK0 SYNC_SA, 2
SYNC_SA:
mvib R30.b0, *R1.b0++
M_PUSH_BYTE
; TYPE (3)
M_XIN_L2_BANK0 SYNC_TYPE, 3
SYNC_TYPE:
mvib R30.b0, *R1.b0++
M_PUSH_BYTE
SYNC_TYPE_OKAY:
; get rx frame timestamp for SOF and save to shared memory
; set flag to this can be processed at the end of the frame
.if $defined(PRU0)
lbco &TEMP_REG_1, ICSS_IEP_CONST, ICSS_IEP_CAPR0_REG, 4
.else
lbco &TEMP_REG_1, ICSS_IEP_CONST, ICSS_IEP_CAPR2_REG, 4
.endif
sbco &TEMP_REG_1, ICSS_SHARED_RAM_CONST, SYNC_TS, 4
set DEVICE_STATUS, DEVICE_STATUS, NEW_SYNC_FRAME_FLAG
; Status (4)
M_XIN_L2_BANK0 SYNC_STATUS, 4
SYNC_STATUS:
mvib R30.b0, *R1.b0++
qbbc SYNC_STATUS_2, DEVICE_STATUS, LAST_DEVICE_FLAG
set R30.b0, R30.b0, 0 ; bit 0 set to ST_LAST
SYNC_STATUS_2:
qbbc SYNC_STATUS_3, DEVICE_STATUS, RX_FRAME_CRC_ERROR
set R30.b0, R30.b0, 2 ; bit 2 ST_ERROR_BIT
clr DEVICE_STATUS, DEVICE_STATUS, RX_FRAME_CRC_ERROR
SYNC_STATUS_3:
M_PUSH_BYTE
; store frame status in registers
mov FRAME_STATUS, R30.b0
; State change flag set?
qbbc SYNC_STATUS_4, R30.b0, ST_STATECHANGE_BIT; ST_STATE_CHANGE
; initiate state change switch
ldi PROTOCOL_STATE, IOEX_STATE
set DEVICE_STATUS, DEVICE_STATUS, SWITCH_PORT_CONFIG
; master port need to change cycle time after CMP[0] event
;set DEVICE_STATUS, DEVICE_STATUS, NEW_CYCLE_TIME_FLAG
SYNC_STATUS_4:
; SYNC_DELAY_FIELD_LOWER (5,6)
M_XIN_L2_BANK0 SYNC_DELAY_FIELD_LOW, 6
SYNC_DELAY_FIELD_LOW:
sbco &R3.w0, ICSS_SHARED_RAM_CONST, SYNC_DELAY, 2
lbco &TEMP_REG_5.w2, ICSS_SHARED_RAM_CONST, LINE_DELAY_NEXT, 2 ; note: load 16 bit to 32 bit register for ADC
ldi TEMP_REG_2.w2, 320+35 ; PRU internal delay ToDo: replace with constant
add TEMP_REG_6, TEMP_REG_5.w2, TEMP_REG_2.w2
add TEMP_REG_6, TEMP_REG_6, R3.w0
mov R30.w0, TEMP_REG_6.w0
M_PUSH_WORD
; SYNC_DELAY_FIELD_UPPER (7,8)
M_XIN_L2_BANK0 SYNC_DELAY_FIELD_HIGH, 8
SYNC_DELAY_FIELD_HIGH:
sbco &R3.w2, ICSS_SHARED_RAM_CONST, SYNC_DELAY+2, 2
add R30.w0, TEMP_REG_6.w2, R3.w2
M_PUSH_WORD
; SYNC_LINE_DELAY_PREVIOUS (9,10)
M_XIN_L2_BANK0 SYNC_LINE_DELAY_UPPER, 10
SYNC_LINE_DELAY_UPPER:
; add to line delay previous the bridge delay and line delay next
ldi TEMP_REG_1.w2, 320+35 ; PRU internal delay ToDo: replace with constant
add R30.w0, TEMP_REG_1.w2, TEMP_REG_5.w2
;add R30.w0, TEMP_REG_1.w0, TEMP_REG_5.w2
add R30.w0, R30.w0, R4.w0
M_PUSH_WORD
sbco &R4.w0, ICSS_SHARED_RAM_CONST, LINE_DELAY_PREVIOUS, 2
; push CRC32
M_CMD16 (D_PUSH_CRC_MSWORD_CMD | D_PUSH_CRC_LSWORD_CMD | D_TX_EOF)
set DEVICE_STATUS, DEVICE_STATUS, RX_IGNORE_TO_EOF
jmp STATE_MACHINE_RETURN
;**************************
; SYNC Handler Function
;**************************
; called from state.asm when NEW_SYNC_FRAME_FLAG is set.
; syncronizing the SLAVE;s IEP timer to the MASTER's IEP timer.
FN1_SYNC_HANDLER:
qbeq SYNC_HANDLER_INIT, SYNC_STATE_REG, 0
add SYNC_STATE_REG, SYNC_STATE_REG, 1
qba SYNC_HANDLER_AVERAGE
SYNC_HANDLER_INIT:
lbco &TEMP_REG_1, ICSS_SHARED_RAM_CONST, SYNC_DELAY, 8 ; SYNC_DELAY + SYNC_TS (TEMP_REG_2)
lbco &TEMP_REG_3, ICSS_IEP_CONST, ICSS_IEP_COUNT_REG, 4
sub TEMP_REG_2, TEMP_REG_3, TEMP_REG_2
add TEMP_REG_1, TEMP_REG_1, TEMP_REG_2
add TEMP_REG_1, TEMP_REG_1, (12+3+12) * 5 ; fixed time to access IEP register with calculations
sbco &TEMP_REG_1, ICSS_IEP_CONST, ICSS_IEP_COUNT_REG, 4
add SYNC_STATE_REG, SYNC_STATE_REG, 1
RET1
SYNC_HANDLER_AVERAGE:
lbco &TEMP_REG_1, ICSS_SHARED_RAM_CONST, SYNC_DELAY, 8 ; SYNC_DELAY + SYNC_TS (TEMP_REG_2)
lbco &TEMP_REG_3, ICSS_SHARED_RAM_CONST, SYNC_TS_AVERAGE, 4
sub TEMP_REG_1, TEMP_REG_1, TEMP_REG_2
add TEMP_REG_3, TEMP_REG_3, TEMP_REG_1
sbco &TEMP_REG_3, ICSS_SHARED_RAM_CONST, SYNC_TS_AVERAGE, 4
;qbne SYNC_HANDLER_AVERAGE_DONE, SYNC_STATE_REG, 9 ; 8 averaging
qbne SYNC_HANDLER_AVERAGE_DONE, SYNC_STATE_REG, 17 ; 16 averaging
;qbne SYNC_HANDLER_AVERAGE_DONE, SYNC_STATE_REG, 2 ; no averaging
;SYNC_HANDLER_AVERAGE_PROCESSING:
; init parameters and registers
zero &TEMP_REG_1, 4
sbco &TEMP_REG_1, ICSS_SHARED_RAM_CONST, SYNC_TS_AVERAGE, 4
; set back sync counter to 1
ldi SYNC_STATE_REG, 1
; compensation count init to 6
ldi TEMP_REG_1.b0, 0x06
; check if positive or negative
qbbc SYNC_HANDLER_AV_POSITIVE, TEMP_REG_3, 31
;SYNC_HANDLER_AV_NEGATIVE:
not TEMP_REG_3, TEMP_REG_3
add TEMP_REG_3, TEMP_REG_3, 1
; compensation count set to 4
ldi TEMP_REG_1.b0, 0x04
SYNC_HANDLER_AV_POSITIVE:
;lsr TEMP_REG_3, TEMP_REG_3, 3 ; divide by 8
lsr TEMP_REG_3, TEMP_REG_3, 4 ; divide by 16
; threshold value if >5ns
;qbge SYNC_HANDLER_AVERAGE_DONE, TEMP_REG_3, 5
; set compensation count value
sbco &TEMP_REG_1.b0, ICSS_IEP_CONST, ICSS_IEP_GLOBAL_CFG_REG + 1, 1
sbco &TEMP_REG_3.w0, ICSS_IEP_CONST, ICSS_IEP_COMPEN_REG, 2
; debug
mov TEMP_REG_2.b3, TEMP_REG_1.b0
sbco &TEMP_REG_2.b3, ICSS_SHARED_RAM_CONST, DEBUG_SYNC_MEASUREMENT, 4 ; store the compnesation count value and 3 bytes of the compensation value
SYNC_HANDLER_AVERAGE_DONE:
RET1
|
sbsext/ut/parn.asm | olifink/smsqe | 0 | 169122 | <gh_stars>0
* Check number of parameters 1985 <NAME> QJUMP
*
section utils
*
xdef ut_parn check d1/8 parameters
xdef ut_par0 check none
xdef ut_par1 check one
xdef ut_par2 check two
*
include dev8_sbsext_ext_keys
*
ut_par2
moveq #$10,d0 2 parameters
bra.s ut_parn
ut_par1
moveq #$08,d0 1 parameter
bra.s ut_parn
ut_par0
moveq #$00,d0 no parameters
ut_parn
add.l a3,d0 number + bottom pointer
sub.l a5,d0 less top
beq.s utp_rts ... should be zero
*
moveq #err.bp,d0 error
addq.l #4,sp ... remove return
utp_rts
rts
end
|
Cubical/HITs/RPn/Base.agda | borsiemir/cubical | 0 | 4818 | {-
A defintion of the real projective spaces following:
[BR17] <NAME>, <NAME>, The real projective spaces in homotopy type theory.
(2017) https://arxiv.org/abs/1704.05770
-}
{-# OPTIONS --cubical --safe #-}
module Cubical.HITs.RPn.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Equiv.Properties
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Univalence
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Bundle
open import Cubical.Foundations.SIP
open import Cubical.Structures.Pointed
open import Cubical.Structures.TypeEqvTo
open import Cubical.Data.Bool
open import Cubical.Data.Nat hiding (elim)
open import Cubical.Data.NatMinusOne
open import Cubical.Data.Sigma
open import Cubical.Data.Unit
open import Cubical.Data.Empty as ⊥ hiding (elim)
open import Cubical.Data.Sum as ⊎ hiding (elim)
open import Cubical.Data.Prod renaming (_×_ to _×'_; _×Σ_ to _×_; swapΣEquiv to swapEquiv)
hiding (swapEquiv)
open import Cubical.HITs.PropositionalTruncation as PropTrunc hiding (elim)
open import Cubical.HITs.Sn
open import Cubical.HITs.Susp
open import Cubical.HITs.Join
open import Cubical.HITs.Pushout
open import Cubical.HITs.Pushout.Flattening
private
variable
ℓ ℓ' ℓ'' : Level
-- Definition II.1 in [BR17], see also Cubical.Foundations.Bundle
2-EltType₀ = TypeEqvTo ℓ-zero Bool -- Σ[ X ∈ Type₀ ] ∥ X ≃ Bool ∥
2-EltPointed₀ = PointedEqvTo ℓ-zero Bool -- Σ[ X ∈ Type₀ ] X × ∥ X ≃ Bool ∥
Bool* : 2-EltType₀
Bool* = Bool , ∣ idEquiv _ ∣
-- Our first goal is to 'lift' `_⊕_ : Bool → Bool ≃ Bool` to a function `_⊕_ : A → A ≃ Bool`
-- for any 2-element type (A, ∣e∣).
-- `isContr-BoolPointedIso` and `isContr-2-EltPointed-iso` are contained in the proof
-- of Lemma II.2 in [BR17], though we prove `isContr-BoolPointedIso` more directly
-- with ⊕ -- [BR17] proves it for just the x = false case and uses notEquiv to get
-- the x = true case.
-- (λ y → x ⊕ y) is the unqiue pointed isomorphism (Bool , false) ≃ (Bool , x)
isContr-BoolPointedIso : ∀ x → isContr ((Bool , false) ≃[ pointed-iso ] (Bool , x))
fst (isContr-BoolPointedIso x) = ((λ y → x ⊕ y) , isEquiv-⊕ x) , ⊕-comm x false
snd (isContr-BoolPointedIso x) (e , p)
= ΣProp≡ (λ e → isSetBool (equivFun e false) x)
(ΣProp≡ isPropIsEquiv (funExt λ { false → ⊕-comm x false ∙ sym p
; true → ⊕-comm x true ∙ sym q }))
where q : e .fst true ≡ not x
q with dichotomyBool (invEq e (not x))
... | inl q = invEq≡→equivFun≡ e q
... | inr q = ⊥.rec (not≢const x (sym (invEq≡→equivFun≡ e q) ∙ p))
-- Since isContr is a mere proposition, we can eliminate a witness ∣e∣ : ∥ X ≃ Bool ∥ to get
-- that there is therefore a unique pointed isomorphism (Bool , false) ≃ (X , x) for any
-- 2-element pointed type (X , x, ∣e∣).
isContr-2-EltPointed-iso : (X∙ : 2-EltPointed₀)
→ isContr ((Bool , false , ∣ idEquiv Bool ∣) ≃[ PointedEqvTo-iso Bool ] X∙)
isContr-2-EltPointed-iso (X , x , ∣e∣)
= PropTrunc.rec isPropIsContr
(λ e → J (λ X∙ _ → isContr ((Bool , false) ≃[ pointed-iso ] X∙))
(isContr-BoolPointedIso (e .fst x))
(sym (pointed-sip _ _ (e , refl))))
∣e∣
-- This unique isomorphism must be _⊕_ 'lifted' to X. This idea is alluded to at the end of the
-- proof of Theorem III.4 in [BR17], where the authors reference needing ⊕-comm.
module ⊕* (X : 2-EltType₀) where
_⊕*_ : typ X → typ X → Bool
y ⊕* z = invEquiv (fst (fst (isContr-2-EltPointed-iso (fst X , y , snd X)))) .fst z
-- we've already shown that this map is an equivalence on the right
isEquivʳ : (y : typ X) → isEquiv (y ⊕*_)
isEquivʳ y = invEquiv (fst (fst (isContr-2-EltPointed-iso (fst X , y , snd X)))) .snd
Equivʳ : typ X → typ X ≃ Bool
Equivʳ y = (y ⊕*_) , isEquivʳ y
-- any mere proposition that holds for (Bool, _⊕_) holds for (typ X, _⊕*_)
-- this amounts to just carefully unfolding the PropTrunc.elim and J in isContr-2-EltPointed-iso
elim : ∀ {ℓ'} (P : (A : Type₀) (_⊕'_ : A → A → Bool) → Type ℓ') (propP : ∀ A _⊕'_ → isProp (P A _⊕'_))
→ P Bool _⊕_ → P (typ X) _⊕*_
elim {ℓ'} P propP r = PropTrunc.elim {P = λ ∣e∣ → P (typ X) (R₁ ∣e∣)} (λ _ → propP _ _)
(λ e → EquivJ (λ A e → P A (R₂ A e)) r e)
(snd X)
where R₁ : ∥ fst X ≃ Bool ∥ → typ X → typ X → Bool
R₁ ∣e∣ y = invEq (fst (fst (isContr-2-EltPointed-iso (fst X , y , ∣e∣))))
R₂ : (B : Type₀) → B ≃ Bool → B → B → Bool
R₂ A e y = invEq (fst (fst (J (λ A∙ _ → isContr ((Bool , false) ≃[ pointed-iso ] A∙))
(isContr-BoolPointedIso (e .fst y))
(sym (pointed-sip (A , y) (Bool , e .fst y) (e , refl))))))
-- as a consequence, we get that ⊕* is commutative, and is therefore also an equivalence on the left
comm : (y z : typ X) → y ⊕* z ≡ z ⊕* y
comm = elim (λ A _⊕'_ → (x y : A) → x ⊕' y ≡ y ⊕' x)
(λ _ _ → isPropPi (λ _ → isPropPi (λ _ → isSetBool _ _)))
⊕-comm
isEquivˡ : (y : typ X) → isEquiv (_⊕* y)
isEquivˡ y = subst isEquiv (funExt (λ z → comm y z)) (isEquivʳ y)
Equivˡ : typ X → typ X ≃ Bool
Equivˡ y = (_⊕* y) , isEquivˡ y
-- Lemma II.2 in [BR17], though we do not use it here
-- Note: Lemma II.3 is `pointed-sip`, used in `PointedEqvTo-sip`
isContr-2-EltPointed : isContr (2-EltPointed₀)
fst isContr-2-EltPointed = (Bool , false , ∣ idEquiv Bool ∣)
snd isContr-2-EltPointed A∙ = PointedEqvTo-sip Bool _ A∙ (fst (isContr-2-EltPointed-iso A∙))
--------------------------------------------------------------------------------
-- Now we mutually define RP n and its double cover (Definition III.1 in [BR17]),
-- and show that the total space of this double cover is S n (Theorem III.4).
RP : ℕ₋₁ → Type₀
cov⁻¹ : (n : ℕ₋₁) → RP n → 2-EltType₀ -- (see Cubical.Foundations.Bundle)
RP neg1 = ⊥
RP (ℕ→ℕ₋₁ n) = Pushout (pr (cov⁻¹ (-1+ n))) (λ _ → tt)
{-
tt
Total (cov⁻¹ (n-1)) — — — > Unit
| ∙
pr | ∙ inr
| ∙
V V
RP (n-1) ∙ ∙ ∙ ∙ ∙ ∙ > RP n := Pushout pr (const tt)
inl
-}
cov⁻¹ neg1 x = Bool*
cov⁻¹ (ℕ→ℕ₋₁ n) (inl x) = cov⁻¹ (-1+ n) x
cov⁻¹ (ℕ→ℕ₋₁ n) (inr _) = Bool*
cov⁻¹ (ℕ→ℕ₋₁ n) (push (x , y) i) = ua ((λ z → y ⊕* z) , ⊕*.isEquivʳ (cov⁻¹ (-1+ n) x) y) i , ∣p∣ i
where open ⊕* (cov⁻¹ (-1+ n) x)
∣p∣ = isProp→PathP (λ i → squash {A = ua (⊕*.Equivʳ (cov⁻¹ (-1+ n) x) y) i ≃ Bool})
(str (cov⁻¹ (-1+ n) x)) (∣ idEquiv _ ∣)
{-
tt
Total (cov⁻¹ (n-1)) — — — > Unit
| |
pr | // ua α // | Bool
| |
V V
RP (n-1) - - - - - - > Type
cov⁻¹ (n-1)
where α : ∀ (x : Total (cov⁻¹ (n-1))) → cov⁻¹ (n-1) (pr x) ≃ Bool
α (x , y) = (λ z → y ⊕* z) , ⊕*.isEquivʳ y
-}
TotalCov≃Sn : ∀ n → Total (cov⁻¹ n) ≃ S n
TotalCov≃Sn neg1 = isoToEquiv (iso (λ { () }) (λ { () }) (λ { () }) (λ { () }))
TotalCov≃Sn (ℕ→ℕ₋₁ n) =
Total (cov⁻¹ (ℕ→ℕ₋₁ n)) ≃⟨ i ⟩
Pushout Σf Σg ≃⟨ ii ⟩
join (Total (cov⁻¹ (-1+ n))) Bool ≃⟨ iii ⟩
S (ℕ→ℕ₋₁ n) ■
where
{-
(i) First we want to show that `Total (cov⁻¹ (ℕ→ℕ₋₁ n))` is equivalent to a pushout.
We do this using the flattening lemma, which states:
Given f,g,F,G,e such that the following square commutes:
g
A — — — — > C Define: E : Pushout f g → Type
| | E (inl b) = F b
f | ua e | G E (inr c) = G c
V V E (push a i) = ua (e a) i
B — — — — > Type
F
Then, the total space `Σ (Pushout f g) E` is the following pushout:
Σg := (g , e a)
Σ[ a ∈ A ] F (f a) — — — — — — — — > Σ[ c ∈ C ] G c
| ∙
Σf := (f , id) | ∙
V V
Σ[ b ∈ B ] F b ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ > Σ (Pushout f g) E
In our case, setting `f = pr (cov⁻¹ (n-1))`, `g = λ _ → tt`, `F = cov⁻¹ (n-1)`, `G = λ _ → Bool`,
and `e = λ (x , y) → ⊕*.Equivʳ (cov⁻¹ (n-1) x) y` makes E equal (up to funExt) to `cov⁻¹ n`.
Thus the flattening lemma gives us that `Total (cov⁻¹ n) ≃ Pushout Σf Σg`.
-}
open FlatteningLemma {- f = -} (λ x → pr (cov⁻¹ (-1+ n)) x) {- g = -} (λ _ → tt)
{- F = -} (λ x → typ (cov⁻¹ (-1+ n) x)) {- G = -} (λ _ → Bool)
{- e = -} (λ { (x , y) → ⊕*.Equivʳ (cov⁻¹ (-1+ n) x) y })
hiding (Σf ; Σg)
cov⁻¹≃E : ∀ x → typ (cov⁻¹ (ℕ→ℕ₋₁ n) x) ≃ E x
cov⁻¹≃E (inl x) = idEquiv _
cov⁻¹≃E (inr x) = idEquiv _
cov⁻¹≃E (push a i) = idEquiv _
-- for easier reference, we copy these definitons here
Σf : Σ[ x ∈ Total (cov⁻¹ (-1+ n)) ] typ (cov⁻¹ (-1+ n) (fst x)) → Total (cov⁻¹ (-1+ n))
Σg : Σ[ x ∈ Total (cov⁻¹ (-1+ n)) ] typ (cov⁻¹ (-1+ n) (fst x)) → Unit × Bool
Σf ((x , y) , z) = (x , z) -- ≡ (f a , x)
Σg ((x , y) , z) = (tt , y ⊕* z) -- ≡ (g a , (e a) .fst x)
where open ⊕* (cov⁻¹ (-1+ n) x)
i : Total (cov⁻¹ (ℕ→ℕ₋₁ n)) ≃ Pushout Σf Σg
i = (Σ[ x ∈ RP (ℕ→ℕ₋₁ n) ] typ (cov⁻¹ (ℕ→ℕ₋₁ n) x)) ≃⟨ congΣEquiv cov⁻¹≃E ⟩
(Σ[ x ∈ RP (ℕ→ℕ₋₁ n) ] E x) ≃⟨ flatten ⟩
Pushout Σf Σg ■
{-
(ii) Next we want to show that `Pushout Σf Σg` is equivalent to `join (Total (cov⁻¹ (n-1))) Bool`.
Since both are pushouts, this can be done by defining a diagram equivalence:
Σf Σg
Total (cov⁻¹ (n-1)) < — — Σ[ x ∈ Total (cov⁻¹ (n-1)) ] cov⁻¹ (n-1) (pr x) — — > Unit × Bool
| ∙ |
id |≃ u ∙≃ snd |≃
V V V
Total (cov⁻¹ (n-1)) < — — — — — — — Total (cov⁻¹ (n-1)) × Bool — — — — — — — — — > Bool
proj₁ proj₂
where the equivalence u above must therefore satisfy: `u .fst x ≡ (Σf x , snd (Σg x))`
Unfolding this, we get: `u .fst ((x , y) , z) ≡ ((x , z) , (y ⊕* z))`
It suffices to show that the map y ↦ y ⊕* z is an equivalence, since we can then express u as
the following composition of equivalences:
((x , y) , z) ↦ (x , (y , z)) ↦ (x , (z , y)) ↦ (x , (z , y ⊕* z)) ↦ ((x , z) , y ⊕* z)
This was proved above by ⊕*.isEquivˡ.
-}
u : ∀ {n} → (Σ[ x ∈ Total (cov⁻¹ n) ] typ (cov⁻¹ n (fst x))) ≃ (Total (cov⁻¹ n) ×' Bool)
u {n} = Σ[ x ∈ Total (cov⁻¹ n) ] typ (cov⁻¹ n (fst x)) ≃⟨ assocΣ ⟩
Σ[ x ∈ RP n ] (typ (cov⁻¹ n x)) × (typ (cov⁻¹ n x)) ≃⟨ congΣEquiv (λ x → swapEquiv _ _) ⟩
Σ[ x ∈ RP n ] (typ (cov⁻¹ n x)) × (typ (cov⁻¹ n x)) ≃⟨ congΣEquiv (λ x → congΣEquiv (λ y →
⊕*.Equivˡ (cov⁻¹ n x) y)) ⟩
Σ[ x ∈ RP n ] (typ (cov⁻¹ n x)) × Bool ≃⟨ invEquiv assocΣ ⟩
Total (cov⁻¹ n) × Bool ≃⟨ invEquiv A×B≃A×ΣB ⟩
Total (cov⁻¹ n) ×' Bool ■
H : ∀ x → u .fst x ≡ (Σf x , snd (Σg x))
H x = refl
nat : 3-span-equiv (3span Σf Σg) (3span {A2 = Total (cov⁻¹ (-1+ n)) ×' Bool} proj₁ proj₂)
nat = record { e0 = idEquiv _ ; e2 = u ; e4 = ΣUnit _
; H1 = λ x → cong proj₁ (H x)
; H3 = λ x → cong proj₂ (H x) }
ii : Pushout Σf Σg ≃ join (Total (cov⁻¹ (-1+ n))) Bool
ii = compEquiv (pathToEquiv (spanEquivToPushoutPath nat)) (joinPushout≃join _ _)
{-
(iii) Finally, it's trivial to show that `join (Total (cov⁻¹ (n-1))) Bool` is equivalent to
`Susp (Total (cov⁻¹ (n-1)))`. Induction then gives us that `Susp (Total (cov⁻¹ (n-1)))`
is equivalent to `S n`, which completes the proof.
-}
iii : join (Total (cov⁻¹ (-1+ n))) Bool ≃ S (ℕ→ℕ₋₁ n)
iii = join (Total (cov⁻¹ (-1+ n))) Bool ≃⟨ invEquiv Susp≃joinBool ⟩
Susp (Total (cov⁻¹ (-1+ n))) ≃⟨ congSuspEquiv (TotalCov≃Sn (-1+ n)) ⟩
S (ℕ→ℕ₋₁ n) ■
-- the usual covering map S n → RP n, with fibers exactly cov⁻¹
cov : (n : ℕ₋₁) → S n → RP n
cov n = pr (cov⁻¹ n) ∘ invEq (TotalCov≃Sn n)
fibcov≡cov⁻¹ : ∀ n (x : RP n) → fiber (cov n) x ≡ cov⁻¹ n x .fst
fibcov≡cov⁻¹ n x =
fiber (cov n) x ≡[ i ]⟨ fiber {A = ua e i} (pr (cov⁻¹ n) ∘ ua-unglue e i) x ⟩
fiber (pr (cov⁻¹ n)) x ≡⟨ ua (fibPrEquiv (cov⁻¹ n) x) ⟩
cov⁻¹ n x .fst ∎
where e = invEquiv (TotalCov≃Sn n)
--------------------------------------------------------------------------------
-- Finally, we state the trivial equivalences for RP 0 and RP 1 (Example III.3 in [BR17])
RP0≃Unit : RP 0 ≃ Unit
RP0≃Unit = isoToEquiv (iso (λ _ → tt) (λ _ → inr tt) (λ _ → refl) (λ { (inr tt) → refl }))
RP1≡S1 : RP 1 ≡ S 1
RP1≡S1 = Pushout {A = Total (cov⁻¹ 0)} {B = RP 0} (pr (cov⁻¹ 0)) (λ _ → tt) ≡⟨ i ⟩
Pushout {A = Total (cov⁻¹ 0)} {B = Unit} (λ _ → tt) (λ _ → tt) ≡⟨ ii ⟩
Pushout {A = S 0} {B = Unit} (λ _ → tt) (λ _ → tt) ≡⟨ PushoutSusp≡Susp ⟩
S 1 ∎
where i = λ i → Pushout {A = Total (cov⁻¹ 0)}
{B = ua RP0≃Unit i}
(λ x → ua-gluePt RP0≃Unit i (pr (cov⁻¹ 0) x))
(λ _ → tt)
ii = λ j → Pushout {A = ua (TotalCov≃Sn 0) j} (λ _ → tt) (λ _ → tt)
|
data/pokemon/base_stats/sinnoh/mime_jr.asm | Dev727/ancientplatinum | 0 | 17017 | <reponame>Dev727/ancientplatinum
db 0 ; 439 DEX NO
db 20, 25, 45, 60, 70, 90
; hp atk def spd sat sdf
db PSYCHIC, PSYCHIC ; type
db 145 ; catch rate
db 78 ; base exp
db NO_ITEM, NO_ITEM ; items
db GENDER_F50 ; gender ratio
db 100 ; unknown 1
db 25 ; step cycles to hatch
db 5 ; unknown 2
INCBIN "gfx/pokemon/sinnoh/mime_jr/front.dimensions"
db 0, 0, 0, 0 ; padding
db GROWTH_MEDIUM_FAST ; growth rate
dn EGG_NONE, EGG_NONE ; egg groups
; tm/hm learnset
tmhm
; end
|
oeis/019/A019618.asm | neoneye/loda-programs | 11 | 99413 | ; A019618: Expansion of 1/((1-4*x)*(1-7*x)*(1-10*x)).
; Submitted by <NAME>
; 1,21,303,3745,42711,464961,4918663,51086385,524227671,5336085601,54018566823,544793838225,5480212349431,55028108373441,551863246323783,5529708675105265,55374624529091991,554289026917064481,5546689809273133543,55493495148326663505,555121131971945559351,5552514587538254574721,55534268767706324660103,555406547993698443168945,5554512502434905784375511,55548254182960407219400161,555504445944387117450887463,5555197788265366889816557585,55553051184476196499357284471,555538024957807888578066516801
mov $1,1
mov $2,1
mov $3,2
lpb $0
sub $0,1
mul $1,10
mul $3,7
add $3,2
add $1,$3
mul $2,4
add $2,1
sub $1,$2
lpe
mov $0,$1
|
oeis/237/A237872.asm | neoneye/loda-programs | 11 | 92509 | ; A237872: Numerator of Sum_{i=1..n} n^i/i.
; Submitted by <NAME>
; 1,4,33,292,10085,48756,2827293,257063528,13779684369,70889442280,72634140523901,314690934778068,140915129117772841,5533416685634616884,251767541303505518145,55644156684309383260624,7481965178603932789388755,197615257214234578768279728,12865281289979788129710899087,16104004084096489076569824691540,216433192558329419930624658880659,2394870291874831420670096541770052,221404744854308366451956709390772166681,2160229347852417038116179599870346522936,1323276867988920893154116808792403203571675
add $0,1
mov $2,1
mov $3,$0
lpb $3
mul $1,$3
mul $1,$0
mov $4,$3
add $4,1
mul $2,$4
add $1,$2
sub $3,1
lpe
gcd $2,$1
mul $1,$0
div $1,$2
mov $0,$1
|
Layer3Sprites/sprite_routines.asm | ped7g/EliteNext | 0 | 243473 |
galactic_cursor_sprite equ 0
galactic_cursor_sprite1 equ galactic_cursor_sprite+1
galactic_cursor_sprite2 equ galactic_cursor_sprite1+2
galactic_hyper_sprite equ galactic_cursor_sprite2+1
galactic_hyper_sprite1 equ galactic_hyper_sprite+1
galactic_hyper_sprite2 equ galactic_hyper_sprite1+1
local_cursor_sprite equ galactic_hyper_sprite2+1
local_cursor_sprite1 equ local_cursor_sprite+1
local_cursor_sprite2 equ local_cursor_sprite1+1
local_hyper_sprite equ local_cursor_sprite2+1
local_hyper_sprite1 equ local_hyper_sprite+1
local_hyper_sprite2 equ local_hyper_sprite1+2
reticlule_sprite1 equ local_hyper_sprite2+1
reticlule_sprite2 equ reticlule_sprite1+1
reticlule_sprite3 equ reticlule_sprite2+1
reticlule_sprite4 equ reticlule_sprite3+1
laser_sprite1 equ reticlule_sprite4+1
laser_sprite2 equ laser_sprite1 +1
laser_sprite3 equ laser_sprite2 +1
laser_sprite4 equ laser_sprite3 +1
laser_sprite5 equ laser_sprite4 +1
laser_sprite6 equ laser_sprite5 +1
laser_sprite7 equ laser_sprite6 +1
laser_sprite8 equ laser_sprite7 +1
laser_sprite9 equ laser_sprite8 +1
laser_sprite10 equ laser_sprite9 +1
laser_sprite11 equ laser_sprite10 +1
laser_sprite12 equ laser_sprite11 +1
laser_sprite13 equ laser_sprite12 +1
laser_sprite14 equ laser_sprite13 +1
laser_sprite15 equ laser_sprite14 +1
laser_sprite16 equ laser_sprite15 +1
compass_sun equ laser_sprite16 +1
compass_station equ compass_sun +1
glactic_pattern_1 equ 0
glactic_hyper_pattern_1 equ 2
local_pattern_1 equ 4
local_hyper_pattern_1 equ 6
reticule_pattern_1 equ 12
reticule_pattern_2 equ 13
laser_pattern_1 equ 14
laser_pattern_2 equ 15
laser_pattern_3 equ 16
laser_pattern_4 equ 17
laser_pattern_5 equ 18
laser_pattern_6 equ 19
laser_pattern_7 equ 20
laser_pattern_8 equ 21
compass_sun_infront equ 22
compass_sun_behind equ 23
compass_station_infront equ 24
compass_station_behind equ 25
spritecursoroffset equ 17
; " sprite_big BC = rowcol, D = sprite nbr , E= , pattern"
sprite_big:
.SetAnchor:
ld a,d ; a = sprite nbr, bug fix?
push af ; save id for next few
push de
nextreg SPRITE_PORT_INDEX_REGISTER,a ; set up sprite id
; write out X position bits 1 to 8
ld a,c
ld hl,spritecursoroffset
add hl,a ; hl = full x position
ld a,l
nextreg SPRITE_PORT_ATTR0_REGISTER,a ; Set up lower x cc
; write out Y position bits 1 to 8
ex de,hl ; de = full x position
ld a,b
ld hl,spritecursoroffset
add hl,a
ld a,l ; hl = full y position
nextreg SPRITE_PORT_ATTR1_REGISTER,a ; lower y coord on screen
; write out MSB of X as its an anchor
ld a,d ; de = MSB of X (hl bit 0)
nextreg SPRITE_PORT_ATTR2_REGISTER,a ; lower y
; write out sprite pattern
pop de ; de = pattern and sprite nbr
ld a,e
or %11000000 ;
nextreg SPRITE_PORT_ATTR3_REGISTER,a ; visible 5 bytes pattern e
; write out msb of y in h must be bit 0 only
ld a,%00000000 ; big unified composite
or h ; MSB Y
nextreg SPRITE_PORT_ATTR4_REGISTER,a ; visible 5 bytes pattern e
.BigSprite1:
pop af
inc a
push af
nextreg SPRITE_PORT_INDEX_REGISTER,a
ld a,16
nextreg SPRITE_PORT_ATTR0_REGISTER,a ; lower x
xor a
nextreg SPRITE_PORT_ATTR1_REGISTER,a ; lower y
nextreg SPRITE_PORT_ATTR2_REGISTER,a ; relative setup
ld a,%11000001 ; relative and 4 bytes of data, pattern 1
nextreg SPRITE_PORT_ATTR3_REGISTER,a
ld a,%01000001 ; big unified composite
nextreg SPRITE_PORT_ATTR4_REGISTER,a ; visible 5 bytes pattern e
.BigSprite2:
pop af
inc a
nextreg SPRITE_PORT_INDEX_REGISTER,a
xor a
nextreg SPRITE_PORT_ATTR0_REGISTER,a ; lower x
ld a,16
nextreg SPRITE_PORT_ATTR1_REGISTER,a ; lower y
xor a
nextreg SPRITE_PORT_ATTR2_REGISTER,a ; relative setup
ld a,%11000010 ; relative and 4 bytes of data, pattern 2
nextreg SPRITE_PORT_ATTR3_REGISTER,a
ld a,%01000001 ; big unified composite
nextreg SPRITE_PORT_ATTR4_REGISTER,a ; visible 5 bytes pattern e
ret
single_sprite: ld a,d ; a = sprite nbr, bug fix?
push af ; save id for next few
push de
nextreg SPRITE_PORT_INDEX_REGISTER,a ; set up sprite id
; write out X position bits 1 to 8
ld a,c
ld hl,spritecursoroffset
add hl,a ; hl = full x position
ld a,l
nextreg SPRITE_PORT_ATTR0_REGISTER,a ; Set up lower x cc
; write out Y position bits 1 to 8
ex de,hl ; de = full x position
ld a,b
ld hl,spritecursoroffset
add hl,a
ld a,l ; hl = full y position
nextreg SPRITE_PORT_ATTR1_REGISTER,a ; lower y coord on screen
; write out MSB of X as its an anchor
ld a,d ; de = MSB of X (hl bit 0)
nextreg SPRITE_PORT_ATTR2_REGISTER,a ; lower y
; write out sprite pattern
pop de ; de = pattern and sprite nbr
ld a,e
or %10000000 ;
nextreg SPRITE_PORT_ATTR3_REGISTER,a ; visible 5 bytes pattern e
ret
sprite_galactic_cursor:
; ">sprite_galactic_cursor BC = rowcol"
ld d,galactic_cursor_sprite
ld e,0
ld a,b
add a,galactic_chart_y_offset
ld b,a
call sprite_big:
ret
sprite_galactic_hyper_cursor:
; "> sprite_galactic_hyper_cursorBC = rowcol"
ld a,b
add a,galactic_chart_y_offset
ld b,a
ld d,galactic_hyper_sprite
ld e,3
call sprite_big:
ret
sprite_ghc_move:
ld a,galactic_hyper_sprite
nextreg SPRITE_PORT_INDEX_REGISTER,a ; set up sprite id
; write out X position bits 1 to 8
ld a,c
ld hl,spritecursoroffset
add hl,a ; hl = full x position
ld a,l
nextreg SPRITE_PORT_ATTR0_REGISTER,a ; Set up lower x cc
; write out Y position bits 1 to 8
ex de,hl ; de = full x position
ld a,b
add a,galactic_chart_y_offset
ld b,a
ld a,b
ld hl,spritecursoroffset
add hl,a
ld a,l ; hl = full y position
nextreg SPRITE_PORT_ATTR1_REGISTER,a ; lower y coord on screen
; write out MSB of X as its an anchor
ld a,d ; de = MSB of X (hl bit 0)
nextreg SPRITE_PORT_ATTR2_REGISTER,a ; lower y
; write out msb of y in h must be bit 0 only
ld a,%00000000 ; big unified composite
or d ; MSB Y
nextreg SPRITE_PORT_ATTR4_REGISTER,a ; visible 5 bytes pattern e
ret
sprite_lhc_move:
ld a,local_hyper_sprite
nextreg SPRITE_PORT_INDEX_REGISTER,a ; set up sprite id
; write out X position bits 1 to 8
ld a,c
ld hl,spritecursoroffset
add hl,a ; hl = full x position
ld a,l
nextreg SPRITE_PORT_ATTR0_REGISTER,a ; Set up lower x cc
; write out Y position bits 1 to 8
ex de,hl ; de = full x position
ld a,b
ld hl,spritecursoroffset
add hl,a
ld a,l ; hl = full y position
nextreg SPRITE_PORT_ATTR1_REGISTER,a ; lower y coord on screen
; write out MSB of X as its an anchor
ld a,d ; de = MSB of X (hl bit 0)
nextreg SPRITE_PORT_ATTR2_REGISTER,a ; lower y
; write out msb of y in h must be bit 0 only
ld a,%00000000 ; big unified composite
or d ; MSB Y
nextreg SPRITE_PORT_ATTR4_REGISTER,a ; visible 5 bytes pattern e
ret
; "sprite_local_cursor BC = rowcol"
sprite_local_cursor: ld d,local_cursor_sprite
ld e,6
call sprite_big
ret
; "sprite_local_hyper_cursor BC = rowcol"
sprite_local_hyper_cursor: ld d,local_hyper_sprite
ld e,9
call sprite_big
ret
compass_offset equ 4
compass_sun_move: ld a,compass_sun
nextreg SPRITE_PORT_INDEX_REGISTER,a ; set up sprite id
; write out X position bits 1 to 8
ld a,c
ld hl,compass_offset
add hl,a ; hl = full x position
ld a,l
nextreg SPRITE_PORT_ATTR0_REGISTER,a ; Set up lower x cc
; write out Y position bits 1 to 8
ex de,hl ; de = full x position
ld a,b
ld hl,compass_offset
add hl,a
ld a,l ; hl = full y position
nextreg SPRITE_PORT_ATTR1_REGISTER,a ; lower y coord on screen
; write out MSB of X as its an anchor
ld a,d ; de = MSB of X (hl bit 0)
nextreg SPRITE_PORT_ATTR2_REGISTER,a ; lower y
ret
compass_station_move: ld a,compass_station
nextreg SPRITE_PORT_INDEX_REGISTER,a ; set up sprite id
; write out X position bits 1 to 8
ld a,c
ld hl,compass_offset
add hl,a ; hl = full x position
ld a,l
nextreg SPRITE_PORT_ATTR0_REGISTER,a ; Set up lower x cc
; write out Y position bits 1 to 8
ex de,hl ; de = full x position
ld a,b
ld hl,compass_offset
add hl,a
ld a,l ; hl = full y position
nextreg SPRITE_PORT_ATTR1_REGISTER,a ; lower y coord on screen
; write out MSB of X as its an anchor
ld a,d ; de = MSB of X (hl bit 0)
nextreg SPRITE_PORT_ATTR2_REGISTER,a ; lower y
ret
sprite_reticule: ld a,reticlule_sprite1
nextreg SPRITE_PORT_INDEX_REGISTER,a ; select left hand side
ld a,(13*8) + 32
nextreg SPRITE_PORT_ATTR0_REGISTER,a ; Set up lower x pos as 136 (104 + 32 border)
ld a,(7 * 8) + 32 + 13 + 32
nextreg SPRITE_PORT_ATTR1_REGISTER,a ; lower y coord on screen
xor a
nextreg SPRITE_PORT_ATTR2_REGISTER,a ; attribute 2
ld a,reticule_pattern_2 | %10000000
nextreg SPRITE_PORT_ATTR3_REGISTER,a ; visible 5 bytes pattern left reticule
.rightReticule ld a,reticlule_sprite2
nextreg SPRITE_PORT_INDEX_REGISTER,a ; select left hand side
ld a,(17*8) + 32 -2
nextreg SPRITE_PORT_ATTR0_REGISTER,a ; Set up lower x pos as 136 (104 + 32 border)
ld a,(7 * 8) + 32 + 13 + 32
nextreg SPRITE_PORT_ATTR1_REGISTER,a ; lower y coord on screen
ld a,%00001000
nextreg SPRITE_PORT_ATTR2_REGISTER,a ; attribute 2 including mirroring horizontal
ld a,reticule_pattern_2 | %10000000
nextreg SPRITE_PORT_ATTR3_REGISTER,a ; visible 5 bytes pattern left reticule
.topReticule ld a,reticlule_sprite3
nextreg SPRITE_PORT_INDEX_REGISTER,a ; select left hand side
ld a,(16*8) + 32 -1
nextreg SPRITE_PORT_ATTR0_REGISTER,a ; Set up lower x pos as 136 (104 + 32 border)
ld a,(5 * 8) + 32 +4 + 32
nextreg SPRITE_PORT_ATTR1_REGISTER,a ; lower y coord on screen
xor a
nextreg SPRITE_PORT_ATTR2_REGISTER,a ; attribute 2
ld a,reticule_pattern_1 | %10000000
nextreg SPRITE_PORT_ATTR3_REGISTER,a ; visible 5 bytes pattern left reticule
.bottomReticule ld a,reticlule_sprite4
nextreg SPRITE_PORT_INDEX_REGISTER,a ; select left hand side
ld a,(16*8) + 32 -1
nextreg SPRITE_PORT_ATTR0_REGISTER,a ; Set up lower x pos as 136 (104 + 32 border)
ld a,(9 * 8) + 32 +5 + 32
nextreg SPRITE_PORT_ATTR1_REGISTER,a ; lower y coord on screen
ld a,%00000100
nextreg SPRITE_PORT_ATTR2_REGISTER,a ; attribute 2 including mirroring vertical
ld a,reticule_pattern_1 | %10000000
nextreg SPRITE_PORT_ATTR3_REGISTER,a ; visible 5 bytes pattern left reticule
ret
laserbasex equ 7
laserbasey equ 14
ShowSprite MACRO spritenbr, patternnbr
ld a, spritenbr
nextreg SPRITE_PORT_INDEX_REGISTER,a
ld a,patternnbr | %10000000
nextreg SPRITE_PORT_ATTR3_REGISTER,a
ENDM
LeftLaser: MACRO xoffset, yoffset, spriteL, patternL
ld a, spriteL
nextreg SPRITE_PORT_INDEX_REGISTER,a ; select left hand side
ld a,((laserbasex + xoffset) *8) + 32
nextreg SPRITE_PORT_ATTR0_REGISTER,a ; Set up lower x pos as 136 (104 + 32 border)
ld a,((laserbasey -yoffset) * 8) + 32 -1
nextreg SPRITE_PORT_ATTR1_REGISTER,a ; lower y coord on screen
xor a
nextreg SPRITE_PORT_ATTR2_REGISTER,a ; attribute 2
ld a, patternL | %00000000 ; hidden by default
nextreg SPRITE_PORT_ATTR3_REGISTER,a
ENDM
RightLaser: MACRO xoffset, yoffset, spriteL, patternL
ld a, spriteL
nextreg SPRITE_PORT_INDEX_REGISTER,a ; select left hand side
ld a,(((30-laserbasex) - xoffset) *8) + 32 -2
nextreg SPRITE_PORT_ATTR0_REGISTER,a ; Set up lower x pos as 136 (104 + 32 border)
ld a,((laserbasey -yoffset) * 8) + 32 -1
nextreg SPRITE_PORT_ATTR1_REGISTER,a ; lower y coord on screen
ld a,%00001000
nextreg SPRITE_PORT_ATTR2_REGISTER,a ; attribute 2
ld a, patternL | %00000000 ; hidden by default
nextreg SPRITE_PORT_ATTR3_REGISTER,a
ENDM
show_compass_sun_infront:ShowSprite compass_sun, compass_sun_infront
ret
show_compass_sun_behind: ShowSprite compass_sun, compass_sun_behind
ret
show_compass_station_infront: ShowSprite compass_station, compass_station_infront
ret
show_compass_statin_behind: ShowSprite compass_station, compass_station_behind
ret
sprite_laser: LeftLaser 0,0,laser_sprite1 ,laser_pattern_1
LeftLaser 2,0,laser_sprite2 ,laser_pattern_2
LeftLaser 2,2,laser_sprite3 ,laser_pattern_3
LeftLaser 4,1,laser_sprite4 ,laser_pattern_4
LeftLaser 3,3,laser_sprite5 ,laser_pattern_5
LeftLaser 5,3,laser_sprite6 ,laser_pattern_6
LeftLaser 6,5,laser_sprite7 ,laser_pattern_7
LeftLaser 8,5,laser_sprite8 ,laser_pattern_8
RightLaser 0,0,laser_sprite9 ,laser_pattern_1
RightLaser 2,0,laser_sprite10,laser_pattern_2
RightLaser 2,2,laser_sprite11,laser_pattern_3
RightLaser 4,1,laser_sprite12,laser_pattern_4
RightLaser 3,3,laser_sprite13,laser_pattern_5
RightLaser 5,3,laser_sprite14,laser_pattern_6
RightLaser 6,5,laser_sprite15,laser_pattern_7
RightLaser 8,5,laser_sprite16,laser_pattern_8
ret
; Need simple show updates just to update the show attribute
sprite_laser_show: ShowSprite laser_sprite1 ,laser_pattern_1
ShowSprite laser_sprite2 ,laser_pattern_2
ShowSprite laser_sprite3 ,laser_pattern_3
ShowSprite laser_sprite4 ,laser_pattern_4
ShowSprite laser_sprite5 ,laser_pattern_5
ShowSprite laser_sprite6 ,laser_pattern_6
ShowSprite laser_sprite7 ,laser_pattern_7
ShowSprite laser_sprite8 ,laser_pattern_8
ShowSprite laser_sprite9 ,laser_pattern_1
ShowSprite laser_sprite10,laser_pattern_2
ShowSprite laser_sprite11,laser_pattern_3
ShowSprite laser_sprite12,laser_pattern_4
ShowSprite laser_sprite13,laser_pattern_5
ShowSprite laser_sprite14,laser_pattern_6
ShowSprite laser_sprite15,laser_pattern_7
ShowSprite laser_sprite16,laser_pattern_8
ret
sprite_galactic_hide:
nextreg SPRITE_PORT_INDEX_REGISTER,galactic_cursor_sprite
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,galactic_cursor_sprite1
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,galactic_cursor_sprite2
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
ret
sprite_galactic_hyper_hide:
nextreg SPRITE_PORT_INDEX_REGISTER,galactic_hyper_sprite
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,galactic_hyper_sprite1
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,galactic_hyper_sprite2
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
ret
sprite_local_hide:
nextreg SPRITE_PORT_INDEX_REGISTER,local_cursor_sprite
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,local_cursor_sprite1
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,local_cursor_sprite2
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
ret
sprite_local_hyper_hide:
nextreg SPRITE_PORT_INDEX_REGISTER,local_hyper_sprite
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,local_hyper_sprite1
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,local_hyper_sprite2
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
ret
sprite_reticule_hide:
nextreg SPRITE_PORT_INDEX_REGISTER,reticlule_sprite1
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,reticlule_sprite2
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,reticlule_sprite3
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,reticlule_sprite4
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
ret
sprite_laser_hide:
nextreg SPRITE_PORT_INDEX_REGISTER,laser_sprite1
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,laser_sprite2
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,laser_sprite3
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,laser_sprite4
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,laser_sprite5
nextreg SPRITE_PORT_ATTR3_REGISTER,$0
nextreg SPRITE_PORT_INDEX_REGISTER,laser_sprite6
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,laser_sprite7
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,laser_sprite8
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,laser_sprite9
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,laser_sprite10
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,laser_sprite11
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,laser_sprite12
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,laser_sprite13
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,laser_sprite14
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,laser_sprite15
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,laser_sprite16
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
ret
sprite_compass_hide:
nextreg SPRITE_PORT_INDEX_REGISTER,compass_sun
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
nextreg SPRITE_PORT_INDEX_REGISTER,compass_station
nextreg SPRITE_PORT_ATTR3_REGISTER,$00
ret
sprite_cls_cursors:
call sprite_galactic_hide
call sprite_galactic_hyper_hide
call sprite_local_hide
call sprite_local_hyper_hide
call sprite_reticule_hide
;call sprite_laser_hide
;call sprite_compass_hide
ret
init_sprites:
call sprite_cls_cursors
nextreg SPRITE_LAYERS_SYSTEM_REGISTER,$63
ret
|
etude/etude6.als | nishio/learning_alloy | 1 | 3437 | <reponame>nishio/learning_alloy<filename>etude/etude6.als
open named_man_ja [Man]
open named_woman_ja [Woman]
//open util/ordering[Event]
abstract sig Person {
events: set Event,
states: some State
}
abstract sig Man extends Person {
}
abstract sig Woman extends Person {
}
abstract sig State {
}
sig Married extends State {}
sig NotMarried extends State {}
abstract sig Event {
state_change : State -> State
}
sig Marriage extends Event{
}
sig Divorce extends Event{
}
fact {
// すべてのイベントは2人に関係している
all e: Event | #{e.~events} = 2
// すべてのイベントは1人の男性(と1人の女性)に関係している
all e: Event | #{e.~events & Man} = 1
all p: Person | #(p.states) = #(p.events) + 1
all s: State | #(s.~states) = 1
all e: Event | #(e.state_change) = 2
all e: Event | no e.state_change & iden
}
run {
// all p: Person | some p.events // すべての人がイベントを持っている
#Man = 1
#Woman = 1
#Event = 2
} for 15
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.