; boot.asm
; bin version
; assemble with: nasm -w+all -f bin testNASM.asm -o testNASM.bin -l testNASM.lst > output.txt
; because–whether in jest or in all seriousness–words [“what’s in a name/word. A rose by any other name would smell as sweet.”] that violate Moses’ “10 commandments” [people like to blame by association even though it’s really
; association is not absolute knowledge because it is ultimately knowable only between God and one’s conscience at last: To^nAn was not aware of them the words–and hence could not ordinarily be blamed for them–until neighbors
; [4/3/2014 going with mother and saw mr. and mrs. green ~ able farmers across from dda.’t’s house …] and the Salvation Army suggested it to him and then he is ordinarily blameable by association even though association is no evidence … and anyway To^nAn would be the first
; to admit that he did use a fire thrower on house flies in a most unconscious way …] found their way
; into the programming language [API’s layer] of the operating systems of Microsoft, Apple [not the original Macintosh presided over mainly with Steve Job based on Motorola cpu MacOS 1-9 pre MacOS-X], Cell Phones [android, etc.]
; To^nAn decides to try to write an API programming language layer [Microsoft, Apple, Android, etc. could simply do a “search and replace” all the objectionable words that violate the “10 commandments” and instantly their
; programs would be “10-commandment-conforming”:
; supposedly ye^’n bought a mobile home … here’s a song about the cat Moses … sea of mexico instead of red sea … to escape from vegas if not from egypt … blue cross blue shield black nurse flashes cleopatra eyes 4/2/2014 …
; “Joshua Kadison – Jesse” [4/29/2014 jesse ~ jesus is father of biblical david; it turns out ye^’n resembles russian-parentage jesse friend of audrey thie^n hu+o+ng]
; From a phone booth in Vegas, Jesse calls at five am, [see note 3.4.2014 “why did you call …”; see use of “jmp” or “call” and “ret” below …]
;To tell me how she’s tired, of all of them.
;She says, “Baby I’ve been thinkin’ ’bout a trailer by the sea.
;We could goto Mexico, you, the cat, and me.
;We’ll drink Taquilla, and look for seashells, now doesn’t that sound sweet?”
;Oh Jesse, you always do this, everytime I get back on my feet.
;Oh Jesse, paint you pictures, ’bout how it’s gonna be.
;By now I should know better, your dreams are never free. [news report of voyager 1 moving beyond boundaries of solar system:
;the principal investigator would resemble ba’c Tue^. trai or anh Tu+` from last year’s visit to Pleasanton,CA …. Dr. Edward Stone receives an award …]
;But tell me all about, our little trailer by the sea.
;Oh Jesse, you can always sell any dream to me.
;Oh Jesse, you can always sell any dream to me.
;She asked me the cat’s been, I said, “Moses, he’s just fine.
;But used to think about you, all of the time.
;We finally took your pictures, down from off the wall.
;Oh Jesse, how do you always seem to know just when to call?”.
;She says, “Get your sutff together, bring Moses and drive real fast.”
;And I listened to her promise, I swear to God this time it’s gonna last.
;Oh Jesse, paint you pictures, ’bout how it’s gonna be.
;By now I should know better, your dreams are never free.
;But tell me all about, our little trailer by the sea.
;Oh Jesse, you can always sell any dream to me.
;Oh Jesse, you can always sell any dream to me.
;I’ll love in the sunshine, lay you down in the warm, white sand.
;And who know, maybe this time, things wil turn out just the way you planned.
;Oh Jesse, paint you pictures, ’bout how it’s gonna be.
;By now I should know better, your dreams are never free.
;But tell me all about, our little trailer by the sea.
;Oh Jesse, you can always sell any dream to me.
;Oh Jesse, you can always sell any dream to me
; http://youtu.be/upJxt64uRWg
; no new or “golden” technologies must be invented … one uses the same “common” technology in much the same manner that one uses a “common” sun and a “common” rain … indeed, it
; would seem silly to “copyright” the words of Moses’ “10 commandment” …which is essentially all that it would entail … it would seem even more silly to “copyright” the words ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’
; or to expect fame and fortune and gold from the words ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’ … http://www.scoutsongs.com/lyrics/onetinsoldier.html… even though in some sense “golden” are those words ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’ …]
; that will not violate Moses’ “10 commandments” … [even though it is layered over a layer that disobeys Moses … the Ultimate++ IDE tries to obey Moses … http://www.ultimatepp.org/… without inventing any new technologies … being thus only responsible for its own layer: to each his/her own “added-value” marginal-economic layer/vhd’s
; where vhd’s = virtual hard disk … virtual ~ ghost …: Ultimate++ IDE tries to provide a layer that invents no new technologies but that conforms to Moses “10 commandment” language/vocabulary on top of a layer that violates Moses “10 commandment” language/vocabulary]… or in fact rather an API that is centered on/around [ba` No^.i ba` Ngoa.i’s ddi’ch/dda.m] ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’ ….
; there is room for both in the same way that there are seasons of the sun winter, spring, summer, autumn, …
; And she said, hey ramblin’ boy, why don’t you settle down
; 4/4/2014 co^ Be^ telephoned saying she return with Dave Lowe the car to To^nDDi.nh and Die^~m and was invited to stay the night in mother’s room since Ye^’n has returned with Gia Ba?o to stay in the “New York” [Tri.nh Co^ng So+n ca’t bu.i song on SBTN] room and they had banana for breakfast today before returning home to Hawaii or going to China …
; Dave Loggins’ song “Please come to Boston” …. Boston Marathon horror last year … hometown of chu’ Kha … us-europe financial aid to ukraine this year … mr. arsen resemblance interviewed on pbs buddha … dr. scholls [shore: year of the horse, movie giant “that child is an entirely different man that does not want to ride horses but wants to be a doctor”]
; Please come to Boston for the springtime
; I’m stayin’ here with some friends and they’ve got lotsa room
; You can sell your paintings on the sidewalk
; By a café here I hope to be workin’ soon
; Please come to Boston
; She said “No, would you come home to me”
; And she said, “Hey ramblin’ boy now won’t cha settle down
; Boston ain’t your kinda town
; There ain’t no gold and there ain’t nobody like me
; I’m the number one fan of the man from Tennessee” [visit ba’c tha’i ba’c thie^.p who used to have a job in tennessee yesterday: big boy {rain dance with captain america} nino {don’t know how it got this crazy but the children look naked while contemporary/peers seems all right} hanmi {} kimnhung {favorite mo.i/indian: ha~y chi.u kho’ nha^~n na.i la`m thi.t ddi}: ]
; http://www.lyricsmania.com/please_come_to_boston_lyrics_dave_loggins.html
; as pointed out in other notes, each has a distinct responsibility in the same way as distinct zero-footprint path
; to a computer operating system which shines the same light on different responsibilites in the same way as it shines and rains on everyone …
; Should To^nAn failed perhaps because of one threat or another or because of one thing/obstacle or another … because of rush or prolonging or whatnot … because of no force or force … To^nAn would
; be contented [previous year’s visit to Pleasanton, CA with Whitney Houston and her song “if I fail if I succeed …”] merely [4/15/2014: CBS or NBC tv news “so then it’s only a goal …[don’t have to rush] …” or some such] in having the “intention” [Plato’s “ideal” … “idea”… 4/7/2014 all neighbors have shown their faces/presences except for Italian/Roman/Y’ Alex Tribuzio;
; and though people jealous of “intention” have often cited out of context or with insufficient explanatory context “the road to hell is paved with good intentions”
; or “Machiavellian end/intention justifies the means” but Rod Stewart sings of his “intentional” heart “… and in my heart you will always be forever young …”] of trying for ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’ …
; because everything is
; but a crutch [to^nddi.nh’s stereo: crutchfield electronics] to remind oneself/ourself of the intention ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’ …
; And, afterall, when you have achieved the goal of ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’
; you wouldn’t know anyway–because its achievement is characterized by “see/hear/say no evil; have eyes/ears/mouths but as though cannot see/hear/say”– that
; you have achieved ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’ … so that it seems like an impossible goal/intention/dream like baiting a horse
; forward by dangling a carrot on a stick in front of it … a goal it could never reached though could be seen/contemplated/intentioned … this goal of
; ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’ …
;
;
; “I Write The Songs”
; BARRY MANILOW [David Lowe and co^ Be^ came for U’ Ly` Vie^.t Linh “violet” –“ay, every inch a king/royal” … To^nAn’s purple suit–and Odi–also “ay, every inch a king/royal”– …] LYRICS
; I’ve been alive forever
; And I wrote the very first song
; I put the words and the melodies together
; I am music
; And I write the songs
; [don’t know about manilow, though since it’s universal surely he and everyone would too, tbut to^nan writes ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’ …]
; I write the songs that make the whole world sing
; I write the songs of love and special things
; I write the songs that make the young girls cry
; I write the songs, I write the songs
; My home lies deep within you
; And I’ve got my own place in your soul
; Now when I look out through your eyes
; I’m young again, even tho’ I’m very old
; I write the songs that make the whole world sing
; I write the songs of love and special things
; I write the songs that make the young girls cry
; I write the songs, I write the songs
; Oh, my music makes you dance and gives you spirit to take a chance
; And I wrote some rock ‘n roll so you can move
; Music fills your heart, well that’s a real fine place to start
; It’s from me, it’s for you
; It’s from you, it’s for me
; It’s a worldwide symphony
; I write the songs that make the whole world sing
; I write the songs of love and special things
; I write the songs that make the young girls cry
; I write the songs, I write the songs
; I write the songs that make the whole world sing
; I write the songs of love and special things
; I write the songs that make the young girls cry
; I write the songs, I write the songs
; I am music and I write the songs
;Thanks to robin for correcting these lyrics.
;Writer(s): Bruce Johnston
; Copyright: Artists-music Inc.
;http://www.azlyrics.com/lyrics/barrymanilow/iwritethesongs.html
; song “I hope when you decide, kindness will be your guide …”:
; “I did not program you, you program you: cha me. sinh con tro+`i sinh ti’nh/compute/program/ddi.nh:
; I program/vote/ba^`u{di` ba co^ Die^~m’s pregnancy}/wish/love/aim/nail/ddi.nh ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’, and
; Everything/All/Allah/Nature/God programs/votes/ba^`u{di` ba co^ die^~m’s pregnancy}/wishes/loves/aims/nails/ddi.nh ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’, and
; the rest, what’s in between God and I is you is up to you … hopefully you too will program along with God and I for
; ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’ ….
; 3/31/2014: supposedly Mr. Le^~ reports Ni Su+ Vie^n Lu+o+ng is supposedly staying in the hospital possibly for tai bie^’n ma.ch na~o …
; Ni Su+ Vie^n Lu+o+ng is associated with striking compassion into To^nan’s heart …
; To^n An does not remember exactly but perhaps she was present when the maid–co^ be^ said con co^ Va^n was main chef
; instead of kitchen helper or sous chef as ba’c Ca^`n said–was cutting chicken throat [the birds, specifically the
; doves, Hitchcock movie “The Birds”, that came to our house to be fed by To^nAn when ba` Ngoa.i was here were
; supposedly to remind To^nAn that mother had chicken noodle soup–Dave Lowe said he likes chicken porridge–when
; she was pregnant with To^nAn …: Devadatta would violate Moses’ “10 commandments” but the Buddha would un-violate it … again there is room
; for both violation and un-violation of Moses “10 commandments” even as there are seasons of the sun, winter, spring, summer, autumn …
; as Ecclesiastes would say … “there is a time for un-Moses and a time for Moses …for Noble Truth of Suffering and Noble Truth of Wellness …” …
; co’ lu’c khu`ng-me^-kho^ng-ti?nh co’ lu’c ti?nh/normal …] in front of To^nAn for the whole family’s supper [SBTN reporter Va.n Ly’ would
; say that no one is singly [unless that one is one’s self: because blaming everyone is equivalent to blaming one’s self] responsible for anyone’s
; death because each death is caused/programmed by va.n ly’ by all/Allah/God by
; everyone by every/all reasons–in particular by/because of “muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well”]
; before she becomes a buddhist nun …
; shortly before she becomes a buddhist nun and ever after she took to^nan to vie^.n ho’a dda.o or some such to teach him to obey/observe [obeah in movie
; “The wide Sargasso Sea” … “Tua^’n [the cha`m or champa is associated with Hindu temples {even though it has been compared to So+n Tinh Thu?y Tinh, Johny-come-lately Christians and Muslims are welcomed … cha`m/champa and malaysia and indonesia ..}: tu a^’n ddo^. … try india…] tra`ng trai nu+o+’c Vie^.t” was a
; novel in ba’c Tue^.’s library that To^nAn did not have time to borrow and read
; because we have to immigrate to the United States: jamaican wedding of Odi and U’ Ly` with lots of people with British appearance: movie “do the right thing” … to^n ddi.nh and dave lowe or aunts said something about “… fever” … movie “jungle fever” viewed together with “do the right thing”] the Bible’s “10 commandments” to “free” tha? the animals … fishes and birds ….
; between I and God, you are “free” because it’s up to you what you do/program/vote/figure/wish/love/aim in between ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’
; and ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’ … co^ Hie^n telephoned after Mr. Le^~ telephoned …
; Because of the “free” clause in “I only fix the boundary condition [to use the terminology of differential equations; 4/3/2014 SBTN Die^.u Quye^n, supposedly a math teacher, says “Happy Birthday” to her hubby, Tru’c Ho^`, … ho^` ~ ca’o ~ defer ~ boundary/wall/gia …] ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’ and God only fixes the boundary condition ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’,
; and because what you do–including what you do to me and to God–in between these boundary conditions of ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’ is up to you and you alone,
; I and God accepted–“que? ca`n” father depending on Mr. Le^~ thus freeing To^nAn from any dde do.a threats … 4/2/2014 father said something suggesting he is
; ba` no^.i ddi’ch and therefore has he has said ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’–before hand all the possibly bad things possibly good things that you might “freely” do to me [including turning me kho^ng ti?nh from ti?nh or turning any intentions of mine upside down inside out including–not that it can be turned upside down– the intention ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’] and to God in between my and God’s boundary conditions of
; ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’ …
; 3/31/2014 To^n DDu+’c telephoned after To^n DDi.nh telephoned after anh Huy telephoned about Nguye^n’s child becoming a doctor and getting married in los angeles, california or las vegas
; the Supreme’s song “Why don’t you be a man about it
;And set me free? (Ooh-ooh-ooh)
; [u’ ly`’s husband odi [President Obama scheduled to be in Ann Arbor 4/3/2014] was ta`o tha’o [“tao xuo^’ng tha’o go+~ “free” he^’t mo.i ra(‘c ro^’i cho ca’c ngu+o+i va` la`m ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well'”]
; at “bi`nh minh qua’n”: he offered to^nan to serve to^nan soup and did so, but to^n an saw that there was a bowl of soup someone –perhaps to^n ddi.nh–had made right by him and so replied “oh seems that I have soup, please have that one for yourself”, so odi retrieved
; the bowl of soup he served to^nan and have it himself … it’s sort of like jerk but not jerk not jerk but jerk ga^`n bu`n ma` cha(?ng ho^i tanh mu`i bu`n … transaction of … a bowl of soup … that becomes the boundary condition for all other transactions… something
; seems to have been exchanged but it was not in fact exchanged…to^nan recalls how malcolm x was “not the cheating kind” … so “children”/”adults”/”boys and girls” go ahead and have your sweets and eat it too … go ahead and have your [“love with no committment” … John Mellencamp’s song “Paper on Fire”] fun …]
;Now, you don’t care a thing about me
;You’re just using me (Ooh-ooh-ooh)
;Go on, get out, get out of my life
;And let me sleep at night (Ooh-ooh-ooh)
;’Cause you don’t really love me
;You just keep me hangin’ on ” http://www.azlyrics.com/lyrics/supremes/youkeepmehanginon.html
; Eternity [“no man is an island” John Donne] for everyone means everyone could only have the bond/freedom/love at best of the [“see/hear/say no evil”] Middle Path of Biblical “in the image”
; in Eternity, each sets the [mathematical] “boundary condition” [see “bound” instruction below …. yesterday 4/1/2014: orange man by paul moody’s former house …
; “The Voice”
; moody blues
;Won’t you take me back to school [gia ba?o wanting to go back, or rather to start/go, to school]
; I need to learn the golden rule [ghen ty. or chi? cho?–imitation is the sincerest form of flattery 4/4/2014 Inside Edition James Frankel life imitates art–or wanting to be taught by the one you’re jealous of … same …]
; Won’t you lay it on the line
; I need to hear it just one more time
; Oh won’t you tell me again
; Can you feel it
; Won’t you tell me again
; Tonight
; Each and every heart it seems
; Is bounded [c.f. cpu instruction “bound” below] by a world of dreams
; Each and every rising sun
; Is greeted by a lonely one
; Oh won’t you tell me again
; Can you feel it
; Oh won’t you tell me again
; Tonight
; http://www.azlyrics.com/lyrics/moodyblues/thevoice.html
; today 4/2/2014: co^ Be^ telephoned for To^nDDi.nh’s telephoned to inquire
; after the whereabout of mathematician David Lowe who is visiting his daughter in Sacramento–the anthropology professor Rappaport is
; big on “sacraments” and on Gregory Bateson … a doll-phi-n of a girl nurse came today for Blue Cross Blue Shield to
; inquire after mother and father health and have a picture of all of us for her brother who marries a Vietnamese girl and have
; two children “we’re close enough to have children” … looking for passage from Gregory Bateson … movie “The book thief” resembling Anne Frank was on
; our flight home from California … that says we should make peace
; with Germany … the SBTN TV says “you bi. pha.t” … kho^ng ti`m tha^’y ddu+o+.c no’ … that passage …not remembering kho^ng nho+’ …
; liquor store guy suggestive of ba’c Tue^. trai came out and threw a cigarette butt at To^nAn’s focus car as we drove passed him … cho pha’t lu+?a/minh … while
; woman tending roasted chicken was dancing and woman suggestive of Mrs. Alicia Renfrew at Sam’s Club turned on personal heater at Sam’s Club … representing sunshine … also Steve Job and
; the “greens” neighbors and people wearing green/blue at Sam’s Club representing farmers … tomorrow mother will go to sinai grace hospital near adult independence place near Ford Motor Co.
; in Dearborn tomorrow which would summarizes note 3.21.2014 as well as summarizing ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well’ ….] or bonding/freedom boundaries for the others so that each
; can live together eternally with the others by staying in each “zero-footprint path” …
; from Programmer’s Reference Manual
; The features of the architecture that permit the 80386 to work equally well with 32-bit and 16-bit address and operand sizes include: • The D-bit (default bit) of code-segment descriptors, which determines the default choice of operand-size and address-size for the instructions of a code segment. (In real-address mode and V86 mode, which do not use descriptors, the default is 16 bits.) A code segment whose D-bit is set is known as a USE32 segment; a code segment whose D-bit is zero is a USE16 segment. The D-bit eliminates the need to encode the operand size and address size in instructions when all instructions use operands and effective addresses of the same size.
;• Instruction prefixes that explicitly override the default choice of operand size and address size (available in protected mode as well as in real-address mode and V86 mode).
;• Separate 32-bit and 16-bit gates for intersegment control transfers (including call gates, interrupt gates, and trap gates). The operand size for the control transfer is determined by the type of gate, not by the D-bit or prefix of the transfer instruction.
;• Registers that can be used both for 32-bit and 16-bit operands and effective-address calculations.
;• The B-bit (big bit) of data-segment descriptors, which determines the size of stack pointer (32-bit ESP or 16-bit SP) used by the CPU for implicit stack references.
; from Programmer’s Reference Manual:
; The elements of an instruction, in order of occurrence are as follows:
;• Prefixes — one or more bytes preceding an instruction that modify the operation of the instruction. The following types of prefixes can be used by applications programs: 1.Segment override — explicitly specifies which segment register an instruction should use, thereby overriding the default segment-register selection used by the 80386 for that instruction.
;2.Address size — switches between 32-bit and 16-bit address generation.
;3.Operand size — switches between 32-bit and 16-bit operands.
;4.Repeat — used with a string instruction to cause the instruction to act on each element of the string.
;• Opcode — specifies the operation performed by the instruction. Some operations have several different opcodes, each specifying a different variant of the operation.
;• Register specifier — an instruction may specify one or two register operands. Register specifiers may occur either in the same byte as the opcode or in the same byte as the addressing-mode specifier.
;• Addressing-mode specifier — when present, specifies whether an operand is a register or memory location; if in memory, specifies whether a displacement, a base register, an index register, and scaling are to be used.
;• SIB (scale, index, base) byte — when the addressing-mode specifier indicates that an index register will be used to compute the address of an operand, an SIB byte is included in the instruction to encode the base register, the index register, and a scaling factor.
;• Displacement — when the addressing-mode specifier indicates that a displacement will be used to compute the address of an operand, the displacement is encoded in the instruction. A displacement is a signed integer of 32, 16, or eight bits. The eight-bit form is used in the common case when the displacement is sufficiently small. The processor extends an eight-bit displacement to 16 or 32 bits, taking into account the sign.
;• Immediate operand — when present, directly provides the value of an operand of the instruction. Immediate operands may be 8, 16, or 32 bits wide. In cases where an eight-bit immediate operand is combined in some way with a 16- or 32-bit operand, the processor automatically extends the size of the eight-bit operand, taking into account the sign.
;;from NASM manual:
; The BITS directive specifies whether NASM should generate code designed to run on a processor operating in 16-bit mode, 32-bit mode or 64-bit mode.
; You do not need to specify BITS 32 merely in order to use 32-bit instructions in a 16-bit DOS program; if you do, the assembler will generate incorrect code because it will be writing code targeted at a 32-bit platform, to be run on a 16-bit one:
; When NASM is in BITS 16 mode, instructions which use 32-bit data are prefixed with an 0x66 byte, and those referring to 32-bit addresses have an 0x67 prefix. In BITS 32 mode, the reverse is true: 32-bit instructions require no prefixes, whereas instructions using 16-bit data need an 0x66 and those working on 16-bit addresses need an 0x67.
; When NASM is in BITS 64 mode, most instructions operate the same as they do for BITS 32 mode.
[BITS 16]
; from the Programmer’s Reference Manual
;The segment containing the currently executing sequence of instructions is known as the current code segment;
;it is specified by means of the CS register. The 80386 fetches all instructions from this code segment, using
;as an offset the contents of the instruction pointer. CS is changed implicitly as the result of intersegment
;control-transfer instructions (for example, CALL and JMP), interrupts, and exceptions.
;The instruction pointer register (EIP) contains the offset address, relative to the start of the current code
;segment, of the next sequential instruction to be executed. The instruction pointer is not directly visible
;to the programmer; it is controlled implicitly by control-transfer instructions, interrupts, and exceptions.
;As Figure 2-9 shows, the low-order 16 bits of EIP is named IP and can be used by the processor as a unit.
;This feature is useful when executing instructions designed for the 8086 and 80286 processors.
; from http://wiki.osdev.org/Babystep2:
; In real mode, addresses are calculated as segment * 16 + offset. Since offset can be much larger than 16, there are many pairs
; of segment and offset that point to the same address.
; In real mode, addresses are calculated as segment * 16 + offset. Since offset can be much larger than 16, there are many pairs
; of segment and offset that point to the same address. For instance, some say that the bootloader is is loaded at 0000:7C00,
; while others say 07C0:0000. This is in fact the same address: 16 * 0x0000 + 0x7C00 = 16 * 0x07C0 + 0x0000 = 0x7C00.
; It doesn’t matter if you use 0000:7c00 or 07c0:0000, but if you use ORG you need to be aware of what’s happening
; from http://www.supernovah.com/Tutorials/BootSector2.php:
;The BIOS does not load the boot sector to a random spot in memory. The BIOS will always load the boot sector starting at the memory location 0x7C00.
; from http://www.supernovah.com/Tutorials/BootSector2.php
;As stated earlier, we cannot be sure if the BIOS set us up with the starting address of 0x7C0:0x0 or 0x0:0x7C00.
;We will use the second segment offset pair to execute our boot sector so we know for sure how the CPU will access
;our code. To do this, our very first instruction will be a far jump that simply jumps to the next instruction.
;The trick is, if we specify a segment, even if it is 0x0, the jmp will be a far jump and the CS register will be
;loaded with the value 0x0 and the IP register will be loaded with the address of the next instruction to be
;executed.
;[BITS 16]
;[ORG 0x7C00]
;jmp 0x0:Start
;Start:
; This code will set the CS segment to 0x0, set the IP register to the the very next instruction which will be slightly past 0x7C00, ….
; universal-loop
; {
; start-ORG-nguye^n-thu?y [4/2/2014 woman at Sam’s Club moved near woman resembling thi’m hoa`ng; 4/20/2014 Nhạc “24 Giờ Phép”, Tác giả: Trúc Phương … “Từ xa tôi về phép hai mươi bốn giờ /
; Tìm người thương trong người thương / Chuyện buồn dương gian lẩn mất / Ðưa ta đi về nguyên thủy loài người”]: maintain-gi`n-giu+~ba?o-to^`n (“muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well”); // in “gia ba?o”, “ba?o” ~ maintain as in “ba?o thu?/to^`n” …
; try/if ;// tin messages …. the try/if is the “gia” of “gia ba?o” …
; maintain-gi`n-giu+~-ba?o-to^`n (“muo^n loa`i va` messageA va` messageB va` messageNEW va` tinLA`NH [co^ Be^’s leg etc.] va`… ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well”); // the message “stack” is loaded or push-pop with messages …; // push-and-pop-or-sent-and-receive (&messageNEW-hay-tinLA`NH); // tin and shakespeare’s version of “all roads lead to rome”: “doubt thou the stars are fire doubt truth to be a liar but never doubt I loved ‘muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well'”: 1/19/2014 Sunday Service … Gospel ~ Good News Tin La\nh …”Gia Ba?o”: the “gia” attempts to reach an agreement with the “ba?o” …// salinger on internet news: push/pop/create stack/heap by an expansion assignment (“muo^n loa`i” <= "muo^n loa`i va` messageA va` messageB va` messageC va` ….")
; ;catch/else ;// unmaintainable tin/messages or kho' tin hay kho^ng tin no messages … SBTN Uye^n Thi. commercial for MBR [master boot record] "kho' tin nhu+ng co' tha^.t …"
; ; go-to-jump-tro+?-ve^` start-ORG-nguye^n-thu?y: maintain-gi`n-giu+~-ba?o-to^`n ("muo^n loa`i ddu+o+.c so^'ng la^u bi`nh thu+o+`ng; everyone live long and well");
; go-to-jump-tro+?-ve^` start-ORG-nguye^n-thu?y: maintain-gi`n-giu+~-ba?o-to^`n ("muo^n loa`i ddu+o+.c so^'ng la^u bi`nh thu+o+`ng; everyone live long and well");
; }
; irish-catholic Pat Benatar song "heartbreaker, dreammaker, don't you mess around with me …" ….
; perhaps "there's beggary in a love that can be reckoned" when love is unconditional–gia ba?o chu' hoa`ng to^n an hoa`ng phi hu`ng and 10 commandments–but
; the ten commandments say there's a love that's conditional … and the 10 commandments describe the limits or conditions of that love …
; from http://wiki.osdev.org/Babystep2:
;some say that the bootloader is loaded at [metaphorical address] 0000:7C00, while others say 07C0:0000.
;This is in fact the same [real] address: 16 * 0x0000 + 0x7C00 = 16 * 0x07C0 + 0x0000 = 0x7C00.
;%define ORIGIN ; ….. comment this out to use "org 0" instead of "org 0x07C0" …
; test segment:offset scheme
;%assign ORIGIN 0x0
;%assign ORIGIN 0x7c00
%assign ORIGIN 0x7990 ; 3/6/2014 home alone with mother …
;%ifdef ORIGIN
%if ORIGIN = 0x7c00
[ORG 0x7c00]
%define PROGRAMSEGMENT 0x0
;segment .text align=16
; segment:offset … ds:offset or cs:offset … 0:offset-from-0x7COO … that is, labels in code following is addressed as 0:0x7C00+offset-from-start-of-file
;Following code will set the CS segment to 0x0, set the IP register to the the very next instruction which will be slightly past 0x7C00, ….
jmp 0x0:start ; set up the ip stack pointer and cs segment register implicitly via jmp instruction
; jmp start ; set up the ip stack pointer and cs segment register implicitly via jmp instruction
;%else ;
%elif ORIGIN = 0x0
[ORG 0]
%define PROGRAMSEGMENT 0x07C0
;segment .text align=16
; segment:offset … ds:offset or cs:offset … 0x07C0:offset-from-0 … that is, labels in the code following is addressed as 0x07C0:0+offset-from-start-of-file
;Following code will set the CS segment to 0x07C0, set the IP register to the the very next instruction which will be slightly past 0x0, ….
jmp 0x07C0:start ; set up the ip stack pointer and cs segment register implicitly via jmp instruction
; jmp start ; set up the ip stack pointer and cs segment register implicitly via jmp instruction
; from http://wiki.osdev.org/Babystep2:
; In real mode, addresses are calculated as segment * 16 + offset. Since offset can be much larger than 16, there are many pairs
; of segment and offset that point to the same address.
; (0x07c00 – 0x07cf) / 0x10 = (7431) / 0x10 = 743.1
; (0x07c00 – 0x03e7) / 0x10 =
; (0x07c00 – 0x7990) / 0x10 = 0x0270 / 0x10 = 0x0027
; 31744 – 31120
%elif ORIGIN = 0x7990 ; grateful for hexadecimal conversion from http://www.mathsisfun.com/binary-decimal-hexadecimal-converter.html and hex calculator from http://www.miniwebtool.com/hex-calculator/?number1=270&operate=1&number2=7990
[ORG 0x7990]
%define PROGRAMSEGMENT 0x0027
;segment .text align=16
; segment:offset … ds:offset or cs:offset … 0x0027:offset-from-0x7990 … that is, labels in code following is addressed as 0:0x7990+offset-from-start-of-file
;Following code will set the CS segment to 0x0027, set the IP register to the the very next instruction which will be slightly past 0x7990, ….
jmp 0x0027:start ; set up the ip stack pointer and cs segment register implicitly via jmp instruction
; jmp start ; set up the ip stack pointer and cs segment register implicitly via jmp instruction
;%endif ; ORIGIN
%endif; ORIGIN
;%ifdef ORIGIN
%if ORIGIN = 0x7c00
%define MEMORYSEGMENTREALLOWBOUND 0x7C00 ; 31744
;%else
%elif ORIGIN = 0x0
%define MEMORYSEGMENTREALLOWBOUND 0x0000 ; 0
%elif ORIGIN = 0x7990 ; grateful for hexadecimal conversion from http://www.mathsisfun.com/binary-decimal-hexadecimal-converter.html and hex calculator from http://www.miniwebtool.com/hex-calculator/?number1=270&operate=1&number2=7990
%define MEMORYSEGMENTREALLOWBOUND 0x0027 ; 39
%endif ; ORIGIN
%define SEGMENTSIZE 512
%define MEMORYSEGMENTREALUPPERBOUND MEMORYSEGMENTREALLOWBOUND + SEGMENTSIZE
; there was a program on the internet [e.g. http://frz.ir/dl/tuts/8086_Assembly.pdf%5D written entirely
; using NASM pseudo-op "db". For example,
; dw 0xfeeb will generate the same bit patterns as jmp $ in the binary file. The interrupt table and stacksegment and datasegment with pseudo-opcodes db, dw etc. here
; was "jmp-ed" over …
%define TRYIVT ; try out ivt codes … comment this out to exclude ivt codes
%ifdef TRYIVT
; interrupts are a type of messages "muo^n loa`i va` messageA va` messageB va` messageNEW va` tinLA`NH va`… ddu+o+.c so^'ng la^u bi`nh thu+o+`ng; everyone live long and well"
; and the interrupt table [of outgoing becauses/answers/responses {do tha'i … } to incoming messages] is placed as close to the origin nguye^n thu?y 0x0:0x0 as possible with/by the BIOS
; girl immitating the suprememes pointing fingers on our trip to san francisco:
; I know, I know you must follow the sun
;Wherever it leads
;But remember
;If you should fall short of your desires
;Remember life holds for you one guarantee
;You'll always have me
; And if you should miss my lovin
;One of these old days
;If you should ever miss the arms
;That used to hold you so close, or the lips
;That used to touch you so tenderly
;Just remember what I told you
;The day I set you free
;
;Ain't no mountain high enough
;Ain't no valley low enough
;Ain't no river wild enough
;To keep me from you
; http://youtu.be/VqW2XigtDEU
; 3/22/2014 ye^'n returned, chu' ha^n telephoned after vu~ng ta^`u restaurant Glady Knights and the Pip–a couple of days ago van wilder II peep/pip/nhi`nh/ and Charles dickens Great Expectation pip–Midnight Train to Georgia: note 2.9.2014 porn left la for the desert of las vegas …
; universal-loop
; {
; start-ORG-nguye^n-thu?y: maintain-gi`n-giu+~ba?o-to^`n ("muo^n loa`i ddu+o+.c so^'ng la^u bi`nh thu+o+`ng; everyone live long and well"); // in "gia ba?o", "ba?o" ~ maintain as in "ba?o thu?/to^`n" …
; try/if ;// tin messages …. the try/if is the "gia" of "gia ba?o" …
; maintain-gi`n-giu+~-ba?o-to^`n ("muo^n loa`i va` messageA va` messageB va` messageNEW va` tinLA`NH va`… ddu+o+.c so^'ng la^u bi`nh thu+o+`ng; everyone live long and well"); // the message "stack" is loaded or push-pop with messages …; // push-and-pop-or-sent-and-receive (&messageNEW-hay-tinLA`NH); // tin and shakespeare's version of "all roads lead to rome": "doubt thou the stars are fire doubt truth to be a liar but never doubt I loved 'muo^n loa`i ddu+o+.c so^'ng la^u bi`nh thu+o+`ng; everyone live long and well'": 1/19/2014 Sunday Service … Gospel ~ Good News Tin La\nh …"Gia Ba?o": the "gia" attempts to reach an agreement with the "ba?o" …// salinger on internet news: push/pop/create stack/heap by an expansion assignment ("muo^n loa`i" MEMORYSEGMENTREALLOWBOUND) \
& (REALADDRESS(SEGMENTADDRESSTOVERIFY,OFFSETADDRESSTOVERIFY) < MEMORYSEGMENTREALUPPERBOUND)
; generate some virtual segment:offset address for use with a real address …
; TO DO: align the generated addresses to "natural" byte boundaries …
; %define GENERATESEGMENTADDRESS(REALADDRESSNO, &GENSEGMENTNO, &GENOFFSETNO) …………….
; %define GENERATEVIRTUALSEGMENTADDRESS(REALADDRESSNO, VIRTUALOFFSETADDRESSINPUT) (REALADDRESSNO – VIRTUALOFFSETADDRESSINPUT)/16
; %define GENERATEOFFSETNO(REALADDRESSNO, VIRTUALSEGMENTADDRESSINPUT) (REALADDRESSNO – VIRTUALSEGMENTADDRESSINPUT * 16)
; from http://geezer.osdevbrasil.net/johnfine/segments.htm:
;The way it really works
; Each segment register is really four registers: A selector register
;A base register
;A limit register
;An attribute register
;
;In all modes, every access to memory that uses a segment register uses the base, limit, and attribute portions of the segment register and does not use the selector portion.
;Every direct access to a segment register (PUSHing it on the stack, MOVing it to a general register etc.) uses only the selector portion. The base, limit, and attribute portions are either very hard or impossible to read (depending on CPU type). They are often called the "hidden" part of the segment register because they are so hard to read.
;Intel documentation refers to the hidden part of the segment register as a "descriptor cache". This name obscures the actual behavior of the "hidden" part.
; In real mode (or V86 mode), when you write any 16-bit value to a segment register, the value you write goes into the selector and 16 times that value goes into the base. The limit and attribute are not changed.
;In pmode, any write to a segment register causes a descriptor to be fetched from the GDT or LDT and unpacked into the base, limit and attribute portion of the segment register. (Special exception for the NULL Selector).
;When the CPU switchs between real mode and pmode, the segment registers do not automatically change. The selectors still contain the exact bit pattern that was loaded into them in the previous mode. The hidden parts still contain the values they contained before, so the segment registers can still be used to access whatever segments they refered to before the switch.
;Writes to a segment register
;When I refer to "writing to a segment register", I mean any action that puts a 16-bit value into a segment register.
;The obvious example is something like:
; MOV DS,AX
;However the same rules apply to many other situations, including: POP to a segment register.
;FAR JMP or CALL puts a value in CS.
;IRET or FAR RET puts a value in CS.
;Both hardware and software interrupts put a value in CS.
;A ring transition puts a value in both SS and CS.
;A task switch loads all the segment registers from a TSS.
; from the Programmer's Reference Manual
;The segment containing the currently executing sequence of instructions is known as the current code segment;
;it is specified by means of the CS register. The 80386 fetches all instructions from this code segment, using
;as an offset the contents of the instruction pointer. CS is changed implicitly as the result of intersegment
;control-transfer instructions (for example, CALL and JMP), interrupts, and exceptions.
main:
; to use the stack, use "call" and "ret" instead of "jmp"
;jmp screensetup ; or just let the program flows, without the jmp, to instructions that follow
; call screensetup
call word screensetup
; call clearscreenpixels
call word clearscreenpixels
; mov [spprevious], SP
; … some operation …
; mov [spnew], SP
; mov word [spcounter + 2 * 0], spprevious – spnew
; mov [spprevious], SP
;bound SP, [wstacklowerbound + 4 + 4 ;
;bound SP, [wstacklowerboundaddress]
; 3/29/2014 wedding of u' ly`: co^ Tu' complained that DDu`m and his Mie^n wife don't say hello kho^ng cha`o …
%define SAYHELLO 1
%ifdef SAYHELLO
; call sayhello
call word sayhello
%endif ; SAYHELLO
; mov [spnew], SP
; mov word [spcounter + 2 * 1], spprevious – spnew
;THE BEATLES LYRICS
;"All You Need Is Love"
; Nothing you can make that can't be made
; No one you can save that can't be saved
; Nothing you can do but you can learn how to be you in time
; It's easy
; All you need is love
; All you need is love
; All you need is love, love
; Love is all you need
; Love, love, love
; Love, love, love
; Love, love, love
; …
; http://www.azlyrics.com/lyrics/beatles/allyouneedislove.html
; To^n DDi.nh said "you know that they're always trying to 'push the envelope' ….": the stack and heap are sort of "envelopes" that programs "push" …
; http://forums.devshed.com/programming-42/asm-bound-instruction-handling-interrupt-5-a-107376.html
; SAFEWAY grocery …
%define TESTSAFEINSTRUCTIONS
%macro SAFECALLORIGINAL 1
; cmp SP, stacksegment
; jl safecallinterrupt
; safecallinterrupt int 5
bound SP, wstacklowerbound + 4 + 4 ;
call %1
%endmacro ; SAFECALLORIGINAL 1
%define USEONLYBP
%macro SAFECALL 2
%ifdef USEONLYBP
mov BP, SP
cmp BP, stacksegment + 20 ; wstacklowerbound ; cmp does a sub BP, stacksegment + 20
;;bound BL, [wstacklowerbound]
jg %%safetocall
%else
mov BP, SP
mov AX, BP
sub AX, stacksegment
cmp AX, 20 ;cmp BP, stacksegment + 20 ; wstacklowerbound ; cmp does a sub BP, stacksegment + 20
;jg safetopush00
;;ja safetopush00
ja %%safetocall
%endif ; USEONLYBP
add byte [bboundsexceeded], 1
%define TESTBOUNDMANUALLY
%ifdef TESTBOUNDMANUALLY
int 5
%else
; 4/5/2014 seems that internally "bound" instruction uses "signed" comparisons before calling int 5 … so …
; from Programmer's Reference Manual: "BOUND ensures that a signed array index is within the limits …"
;bound BP, [wstacklowerbound] ; valid for NASM
%define USESIGNEDARRAYINDEXFORSTACKBOUNDS
%ifdef USESIGNEDARRAYINDEXFORSTACKBOUNDS ; =< stacksegment + 20
; convert BP from raw "address" to "signed array index" using stacksegment as zero 0 reference index
sub BP, stacksegment ; =< 20
%endif ; USESIGNEDARRAYINDEXFORSTACKBOUNDS
bound BP, [wboundlowerbound] ; valid for NASM ; < 20
;bound ax, wstacklowerbound ; invalid for NASM
;bound ax, bx ; invalid for NASM, of course
%endif ; TESTBOUNDMANUALLY
;%define MANAGEBOUNDEXCEEDEDBYEXTENDORCREATENEWSTACKSEGMENT
%ifdef MANAGEBOUNDEXCEEDEDBYEXTENDORCREATENEWSTACKSEGMENT
; mov AX, 0x0027
; mov SS,AX
;;mov SP, 0x0027 + stacktop
; mov SP, stacktop
%endif ; MANAGEBOUNDEXCEEDEDBYEXTENDORCREATENEWSTACKSEGMENT
jmp %%finishsafecall
%%safetocall:
;call byte testcall ; NASM error "mismatch in operand size"
;call word testcall ; all right
;call dword testcall ; all right
;testcall:
call %1 %2 ; call [operand size: "word" or "dword"] [operand]
%%finishsafecall:
%endmacro ; SAFECALL 2
%macro SAFEPUSHORIGINAL 1
;;wstacklowerbound dw 0 ; equ stacksegment
;;wstackupperbound dw 0 ; equ stacktop
;;mov ax, stacksegment
;;mov [wstacklowerbound], ax
;;mov ax, stacktop
;;mov [wstackupperbound], ax
; bound SP, [wstacklowerbound]
; mov BP, SP
; bound BP, [wstacklowerbound]
bound BP, wstacklowerbound
push %1
; cmp SP, stacksegment
; jl safepushinterrupt
; safepushinterrupt int 5
; bound SP, wstacklowerbound + 4 + 4 ;
;; mov byte [ES:600],'a'
;; cmp dword [bwasinterrupted], 1
;; je returnfromservicingpush
;; mov byte [ES:602],'b'
;; cmp SP, stacksegment + 10
;cmp SP, stacksegment
;jb safepushinterrupt ; unsigned transfer
;jl safepushinterrupt ; signed transfer
;ja safepushinterrupt ; unsigned transfer
;jg safepushinterrupt ; signed transfer
;; ja safetopush
;; mov byte [ES:604],'c'
;; mov dword [bwasinterrupted], 1
;; int 5
;; jmp returnfromservicingpush
;;safetopush:
;; mov byte [ES:606],'d'
;; add dword [bnumberofpushrequired], 1
;; push %1
;;returnfromservicingpush:
;; mov byte [ES:610],'e'
;; nop ; no operation … can be commented out …
;safepushinterrupt: int 5
; from https://courses.engr.illinois.edu/ece390/books/artofasm/CH06/CH06-5.html#HEADING5-171
; cmp reg, LowerBound
; jl OutOfBounds
; cmp reg, UpperBound
; jg OutOfBounds
;On the 80486 and Pentium/586 chips, the sequence above only requires four clock cycles assuming you can use the immediate addressing mode and the branches are not taken; the bound instruction requires 7-8 clock cycles under similar circumstances and also assuming the memory operands are in the cache.
%endmacro ; SAFEPUSHORIGINAL 1
%macro SAFEPUSH 2
%ifdef USEONLYBP
mov BP, SP
cmp BP, stacksegment + 20 ; wstacklowerbound ; cmp does a sub BP, stacksegment + 20
;;bound BL, [wstacklowerbound]
jg %%safetopush
;ja %%safetopush
%else
mov BP, SP
mov AX, BP
sub AX, stacksegment
cmp AX, 20 ;cmp BP, stacksegment + 20 ; wstacklowerbound ; cmp does a sub BP, stacksegment + 20
;jg safetopush00
;;ja safetopush00
ja %%safetopush
%endif ; USEONLYBP
add byte [bboundsexceeded], 1
;%define TESTBOUNDMANUALLY
%ifdef TESTBOUNDMANUALLY
int 5
%else
; 4/5/2014 seems that internally "bound" instruction uses "signed" comparisons before calling int 5 … so …
; from Programmer's Reference Manual: "BOUND ensures that a signed array index is within the limits …"
;bound BP, [wstacklowerbound] ; valid for NASM
%ifdef USESIGNEDARRAYINDEXFORSTACKBOUNDS ; =< stacksegment + 20
; convert BP from raw "address" to "signed array index" using stacksegment as zero 0 reference index
sub BP, stacksegment ; =< 20
%endif ; USESIGNEDARRAYINDEXFORSTACKBOUNDS
bound BP, [wboundlowerbound] ; valid for NASM ; 20
%ifdef USESTACTOPREFERENCE
mov BP, SP
mov AX, stacktop
sub AX, BP
cmp AX, 20
%endif ; USESTACTOPREFERENCE
mov BP, SP
mov AX, BP
sub AX, stacksegment
;cmp AX, 20 ;cmp BP, stacksegment + 20 ; wstacklowerbound ; cmp does a sub BP, stacksegment + 20
cmp AX, stacksize; 64 …
;jg safetopush00
;;ja safetopush00
;ja %%safetopop
jb %%safetopop
%endif ; USEONLYBP
;%define TESTBOUNDMANUALLY
%ifdef TESTBOUNDMANUALLY
int 5
%else
; 4/5/2014 seems that internally “bound” instruction uses “signed” comparisons before calling int 5 … so …
; from Programmer’s Reference Manual: “BOUND ensures that a signed array index is within the limits …”
;bound BP, [wstacklowerbound] ; valid for NASM
%ifdef USESIGNEDARRAYINDEXFORSTACKBOUNDS ; =< stacksegment + 20
; convert BP from raw "address" to "signed array index" using stacksegment as zero 0 reference index
sub BP, stacksegment ; =< 20
%endif ; USESIGNEDARRAYINDEXFORSTACKBOUNDS
bound BP, [wboundlowerbound] ; valid for NASM ; 20
%ifdef USESTACTOPREFERENCE
mov BP, SP
mov AX, stacktop
sub AX, BP
cmp AX, 20
%endif ; USESTACTOPREFERENCE
mov BP, SP
mov AX, BP
sub AX, stacksegment
;cmp AX, 20 ;cmp BP, stacksegment + 20 ; wstacklowerbound ; cmp does a sub BP, stacksegment + 20
cmp AX, stacksize; 64 …
;jg safetopush00
;;ja safetopush00
;ja %%safetopop
jb %%safetoreturn
%endif ; USEONLYBP
;%define TESTBOUNDMANUALLY
%ifdef TESTBOUNDMANUALLY
int 5
%else
; 4/5/2014 seems that internally “bound” instruction uses “signed” comparisons before calling int 5 … so …
; from Programmer’s Reference Manual: “BOUND ensures that a signed array index is within the limits …”
;bound BP, [wstacklowerbound] ; valid for NASM
%ifdef USESIGNEDARRAYINDEXFORSTACKBOUNDS ; =< stacksegment + 20
; convert BP from raw "address" to "signed array index" using stacksegment as zero 0 reference index
sub BP, stacksegment ; =< 20
%endif ; USESIGNEDARRAYINDEXFORSTACKBOUNDS
bound BP, [wboundlowerbound] ; valid for NASM ; 20
%ifdef USESTACTOPREFERENCE
mov BP, SP
mov AX, stacktop
sub AX, BP
cmp AX, 20
%endif ; USESTACTOPREFERENCE
mov BP, SP
mov AX, BP
sub AX, stacksegment
;cmp AX, 20 ;cmp BP, stacksegment + 20 ; wstacklowerbound ; cmp does a sub BP, stacksegment + 20
cmp AX, stacksize; 64 …
;jg safetopush00
;;ja safetopush00
;ja %%safetopop
jb %%safetoireturn
%endif ; USEONLYBP
;%define TESTBOUNDMANUALLY
%ifdef TESTBOUNDMANUALLY
int 5
%else
; 4/5/2014 seems that internally “bound” instruction uses “signed” comparisons before calling int 5 … so …
; from Programmer’s Reference Manual: “BOUND ensures that a signed array index is within the limits …”
;bound BP, [wstacklowerbound] ; valid for NASM
%ifdef USESIGNEDARRAYINDEXFORSTACKBOUNDS ; =< stacksegment + 20
; convert BP from raw "address" to "signed array index" using stacksegment as zero 0 reference index
sub BP, stacksegment ; =< 20
%endif ; USESIGNEDARRAYINDEXFORSTACKBOUNDS
bound BP, [wboundlowerbound] ; valid for NASM ; < 20
;bound ax, wstacklowerbound ; invalid for NASM
;bound ax, bx ; invalid for NASM, of course
%endif ; TESTBOUNDMANUALLY
;%define MANAGEBOUNDEXCEEDEDBYEXTENDORCREATENEWSTACKSEGMENT
%ifdef MANAGEBOUNDEXCEEDEDBYEXTENDORCREATENEWSTACKSEGMENT
; mov AX, 0x0027
; mov SS,AX
;;mov SP, 0x0027 + stacktop
; mov SP, stacktop
%endif ; MANAGEBOUNDEXCEEDEDBYEXTENDORCREATENEWSTACKSEGMENT
jmp %%finishsafeireturn
%%safetoireturn:
; from http://faydoc.tripod.com/cpu/ret.htm
; ret opcode:
;C2 iw RET imm16 Near return to calling procedure and pop imm16 bytes from stack
;CA iw RET imm16 Far return to calling procedure and pop imm16 bytes from stack
;ret byte '' ; NASM error "mismatch in operand size"
;ret dword '' ; NASM error "mismatch in operand size"
;;ret word '' ; all right
;ret %1 %2 ; ret [operand size: "word"] [operand]
iret
%%finishsafeireturn:
%endmacro ; SAFEIRET 2
; from http://www.mactech.com/macintosh-c/classic-chap01-1.html
; Macintosh Protection mechanism for the stack: "… every sixtieth of a second an Operating System task checks whether the stack has moved into the heap. If it has, the task, known as the stack sniffer, generates a system error …"
; Intel implements push-pop-able stack data structures such as IDT, GDT etc. defining limits for protection purposes …
; from Programmer's Reference Manual
;6.2 Overview of 80386 Protection Mechanisms
;Protection in the 80386 has five aspects: 1. Type checking
;2. Limit checking
;3. Restriction of addressable domain
;4. Restriction of procedure entry points
;5. Restriction of instruction set
;The protection hardware of the 80386 is an integral part of the memory management hardware. Protection applies both to segment translation and to page translation.
;Each reference to memory is checked by the hardware to verify that it satisfies the protection criteria. All these checks are made before the memory cycle is started; any violation prevents that cycle from starting and results in an exception. Since the checks are performed concurrently with address formation, there is no performance penalty.
;Invalid attempts to access memory result in an exception. Refer to Chapter 9 for an explanation of the exception mechanism . The present chapter defines the protection violations that lead to exceptions.
;The concept of "privilege" is central to several aspects of protection (numbers 3, 4, and 5 in the preceeding list). Applied to procedures, privilege is the degree to which the procedure can be trusted not to make a mistake that might affect other procedures or data. Applied to data, privilege is the degree of protection that a data structure should have from less trusted procedures.
;The concept of privilege applies both to segment protection and to page protection.
%ifdef TRYIVT
call changeivt.loadorgbiosivtwithbiosivt
call changeivt.loadivtwithbiosivt
;call changeivt.loadivtwithorgbiosivt
;Setting:
;mov ax, [intnum*4] ; offset
;mov ax [intnum*4+2] ; segment
; pbs "peg and cat" …. suggestively similar "peg and cat" bedding at baby r us 3/13/2014
; substitute custom interrupt numbers 5 and 9 into new ivt table created by cloning from original BIOS ivt table: neighbor dude with custom truck 3/13/2014
call changeivt.insertcustominterruptsintoivt
call changeivt.setivt
; test custom interrupt numbers 5 and 9 … here …
;;int 5 ; manual interrupt
;;int 9 ; manual interrupt
; test safe stack calls SAFECALLS's with int 5 here ………
; ………
;wstacklowerbound dw 0 ; equ stacksegment
;wstackupperbound dw 0 ; equ stacktop
; push and pop are sort of "messages" "tin la`nh" to the stack which might try to see if it can complies with the messages maintaining "muo^n loa`i va` messageA va` messageB va` messageNEW va` tinLA`NH [co^ Be^'s leg etc.] va`… ddu+o+.c so^'ng la^u bi`nh thu+o+`ng; everyone live long and well" with for example
; the "bound" instruction if not it will bolt out and return to "muo^n loa`i ddu+o+.c so^'ng la^u bi`nh thu+o+`ng; everyone live long and well"
; universal-loop
; {
; start-ORG-nguye^n-thu?y [4/2/2014 woman at Sam's Club moved near woman resembling thi'm hoa`ng]: maintain-gi`n-giu+~ba?o-to^`n ("muo^n loa`i ddu+o+.c so^'ng la^u bi`nh thu+o+`ng; everyone live long and well"); // in "gia ba?o", "ba?o" ~ maintain as in "ba?o thu?/to^`n" …
; try/if ;// tin messages …. the try/if is the "gia" of "gia ba?o" …
; maintain-gi`n-giu+~-ba?o-to^`n ("muo^n loa`i va` messageA va` messageB va` messageNEW va` tinLA`NH [co^ Be^'s leg etc.] va`… ddu+o+.c so^'ng la^u bi`nh thu+o+`ng; everyone live long and well"); // the message "stack" is loaded or push-pop with messages …; // push-and-pop-or-sent-and-receive (&messageNEW-hay-tinLA`NH); // tin and shakespeare's version of "all roads lead to rome": "doubt thou the stars are fire doubt truth to be a liar but never doubt I loved 'muo^n loa`i ddu+o+.c so^'ng la^u bi`nh thu+o+`ng; everyone live long and well'": 1/19/2014 Sunday Service … Gospel ~ Good News Tin La\nh …"Gia Ba?o": the "gia" attempts to reach an agreement with the "ba?o" …// salinger on internet news: push/pop/create stack/heap by an expansion assignment ("muo^n loa`i" <= "muo^n loa`i va` messageA va` messageB va` messageC va` ….")
; ;catch/else ;// unmaintainable tin/messages or kho' tin hay kho^ng tin no messages … SBTN Uye^n Thi. commercial for MBR [master boot record] "kho' tin nhu+ng co' tha^.t …"
; ; go-to-jump-tro+?-ve^` start-ORG-nguye^n-thu?y: maintain-gi`n-giu+~-ba?o-to^`n ("muo^n loa`i ddu+o+.c so^'ng la^u bi`nh thu+o+`ng; everyone live long and well");
; go-to-jump-tro+?-ve^` start-ORG-nguye^n-thu?y: maintain-gi`n-giu+~-ba?o-to^`n ("muo^n loa`i ddu+o+.c so^'ng la^u bi`nh thu+o+`ng; everyone live long and well");
; }
; NOTE: of course, the address of the top and bottom of the stack and of the SP pointer could be converted to "signed array indices" for use by "bound" instruction …
; for example: let stacksegment have index 0, stacktop has index = stacksize, and SP has index = SP – stacksegment within the range [0, stacksize]
; initialize/reinitialize bounds
%define USESIGNEDARRAYINDEXFORSTACKBOUNDS
%ifdef USESIGNEDARRAYINDEXFORSTACKBOUNDS
; stacksegment = 0
mov word [wstacklowerbound], 0 + 20 + 1 ; 20
mov word [wboundlowerbound], 0 + 20 + 1 ; 20
mov word [wstackupperbound], stacksize ; 64
mov word [wboundupperbound], stacksize ; 64
; stacktop = 64 bytes
%else
mov ax, stacksegment + 20 + 1
mov [wstacklowerbound], ax
mov [wboundlowerbound], ax
mov ax, stacktop + 1
mov [wstackupperbound], ax
mov [wboundupperbound], ax
%endif ; USESIGNEDARRAYINDEXFORSTACKBOUNDS
;%define TESTBOUNDINSTRUCTION
%ifdef TESTBOUNDINSTRUCTION
;test the "bound" instruction:
mov ax, 10
mov [wboundupperbound], ax
mov ax, 7
mov [wboundlowerbound], ax
mov ax, 3
bound ax, [wboundlowerbound]
; bound ax, wstacklowerbound
hlt
; from Programmer's Reference Manual
; HALT stops instruction execution and places the 80386 in a HALT state. An enabled interrupt, NMI, or a reset will resume execution. If an interrupt (including NMI) is used to resume execution after HLT, the saved CS:IP (or CS:EIP) value points to the instruction following HLT.
%endif ; TESTBOUNDINSTRUCTION
;; xor cx, cx
;mov cx, 64 ; 64
;; mov cx, stacksize
;;stackoverloadloop:
;; ;push ' '
;; add byte [bnumberofpushrequired], 1
;SAFEPUSH ' '
;; bound SP, [wstacklowerbound]
;; cmp SP, [wstacklowerbound]
;; jg safetopush
;int 5
;; jmp finishtestinterrupt5
;; safetopush: push word ' '
;; safetopush: nop
;; cmp dword [winterrupt5count], 0
;; jg finishtestinterrupt5
;; loop stackoverloadloop
;;finishtestinterrupt5:
;; nop
;mov bx, 2000
;mov cx, 21
;printloop:
; add bx, 2
; mov byte [ES:bx], 'q'
;loop printloop
;mov ax, 21
;mov [bnumberofpushrequired], ax
; 4/27/2014 PBS P.Allen Smith's Home had fun with this in terms of a "bloopers" segment at the end of show …
;%define FIRSTTRYTOTESTSAFEINTERRUPT5
;%define SECONDTRYTOTESTSAFEINTERRUPT5
%define THIRDTRYTOTESTSAFEINTERRUPT5
%ifdef FIRSTTRYTOTESTSAFEINTERRUPT5
jmp firsttrytotestsafeinterrupt5
%elifdef SECONDTRYTOTESTSAFEINTERRUPT5
jmp secondtrytotestsafeinterrupt5
%elifdef THIRDTRYTOTESTSAFEINTERRUPT5
jmp thirdtrytotestsafeinterrupt5
%endif ; TRYTOTESTSAFEINTERRUPT5
thirdtrytotestsafeinterrupt5:
; print out initial BP value as a "signed array index" …
mov BP, SP
mov AX, BP
sub AX, stacksegment
mov DI, 114
call out2hex ; print out is 0x3E = 62 …. stack is used by "call main" … 2 out 64 bytes …
xor cx, cx
mov cx, stacksize
stackoverloadloop000:
SAFEPUSH word, ' '
cmp byte [bboundsexceeded], 0
jne finishtestinterrupt500
;jne continuestackoverloadloop000 ; if this is commented in instead of above then interrupt5count print out instead of 0x01 will be 2B = 32 + 11 = 43, 43 + 21 = 64
;cmp byte [winterrupt5count], 1
;cmp word [winterrupt5count], 0
;jg finishtestinterrupt500
add byte [bnumberofpushrequired], 1 ; print out gives 0x15 = 21 which is 21 * 2 = 42 bytes so that 42 + 20 + 2 = 64 bytes …; had "push dword ' '" been used, print out would have been 0x0B ~ 11 or 11 * 4 = 44 bytes and 64 – 44 = 20
;continuestackoverloadloop000:
loop stackoverloadloop000
finishtestinterrupt500:
xor cx, cx
;mov byte cl, [bnumberofpushrequired]
movsx cx, [bnumberofpushrequired]
unpushloop000:
SAFEPOP word, ax
;pop word ax
loop unpushloop000
jmp continueinterrupttests
;
; end thirdtrytotestsafeinterrupt5
secondtrytotestsafeinterrupt5:
; print out initial BP value as a "signed array index" …
mov BP, SP
mov AX, BP
sub AX, stacksegment
mov DI, 996
call out2hex ; print out is 0x3E = 62 …. stack is used by "call main" … 2 out 64 bytes …
xor cx, cx
mov cx, stacksize
mov bx, 1000
stackoverloadloop0:
cmp byte [bboundsexceeded], 0
jne finishtestinterrupt50
;SAFEPUSH word, ' '
mov BP, SP
mov AX, BP
sub AX, stacksegment
cmp AX, 20 ;cmp BP, stacksegment + 20 ; wstacklowerbound ; cmp does a sub BP, stacksegment + 20
;jg safetopush00
ja safetopush00
add byte [bboundsexceeded], 1
int 5
jmp finishsafepush00
safetopush00:
add byte [bnumberofpushrequired], 1 ; print out gives 0x15 = 21 which is 21 * 2 = 42 bytes so that 42 + 20 + 2 = 64 bytes …; had "push dword ' '" been used, print out would have been 0x0B ~ 11 or 11 * 4 = 44 bytes and 64 – 44 = 20
push word ' '
add bx, 2
mov byte [ES:bx], 'p'
;mov byte [es:bboundsexceeded], 'p'
finishsafepush00:
loop stackoverloadloop0
finishtestinterrupt50:
;hlt
;jmp hltcontinue
; 4/20/2014 bought a bunch of LED lightbulbs from Home Depot, Lowes, Wal-Mart … to conform to new law requiring low wattage lighting
; the following out2hex' printouts are similar to "lightbulbs" to figure out what's wrong/right …
; an internet article on assembly programming suggests to sprinkle them–mov byte [ES:bx], 'q' etc.– liberally around your codes to see what's going on to have a feel for what's up …
mov BP, SP
mov AX, BP
sub AX, stacksegment
mov DI, 1962
call out2hex ; print out gives 0x15 = 21 which is 21 * 2 = 42 bytes so that 42 + 20 + 2 = 64 bytes …; had "push dword ' '" been used, print out would have been 0x0B ~ 11 or 11 * 4 = 44 bytes and 64 – 44 = 20
;mov AX, [bnumberofpushrequired]
;mov al, [bnumberofpushrequired]
movsx AX, [bnumberofpushrequired]
mov DI, 1970
call out2hex ; print out gives 0x15 = 21 which is 21 * 2 = 42 bytes so that 42 + 20 + 2 = 64 bytes …; had "push dword ' '" been used, print out would have been 0x0B ~ 11 or 11 * 4 = 44 bytes and 64 – 44 = 20
xor cx, cx
;mov cx, [bnumberofpushrequired]
;mov cl, [bnumberofpushrequired]
movsx cx, [bnumberofpushrequired]
;mov cx, 21
mov AX, cx
mov DI, 1974
call out2hex ; print out gives 0x15 = 21 which is 21 * 2 = 42 bytes so that 42 + 20 + 2 = 64 bytes …; had "push dword ' '" been used, print out would have been 0x0B ~ 11 or 11 * 4 = 44 bytes and 64 – 44 = 20
mov bx, 2000
;mov DI, 1990
; 4/22/2014 father telephoned anh ba(`ng chi. trang … mother gives blueberry yogurt [india indian girl wearing "fit" jean at mcdonald a couple of days ago]…. and tv has jennifer aniston
; [whose appearance seems to be "stretched" beyond recognition of her "Friends" character for this ad] on tv commercial for aveeno: get a lot of sleep and drink a lot of water … country … count r you …
; also, Mechanics of waves: "How does an assembly instruction turn into voltage changes on the CPU?" http://stackoverflow.com/questions/3706022/how-does-an-assembly-instruction-turn-into-voltage-changes-on-the-cpu
; 4/22/2014 from Programmer's Reference Manual
; …. The type conversion instructions convert bytes into words, words into doublewords, and doublewords into 64-bit items (quad-words). These instructions are especially useful for converting signed integers, because they automatically fill the extra bits of the larger item with the value of the sign bit of the smaller item. This kind of conversion, illustrated by Figure 3-5, is called sign extension.
; MOVSX reads the contents of the effective address or register as a byte or a word, sign-extends the value to the operand-size attribute of the instruction (16 or 32 bits), and stores the result in the destination register.
mov cx, 21 ; all right when cx is set by hand …
;mov cx, [bnumberofpushrequired] ; error … when cx is set by memory … variable "bnumberofpushrequired" is "byte" size while cx register size is word …
;mov byte cx, [bnumberofpushrequired] ; error … and besides cause NASM warning "register size specification ignored" …
;mov cl, [bnumberofpushrequired] ; all right … when cx is set by memory … answer to "Use user's input as loop counter" by Michael http://stackoverflow.com/users/1524450/michael …
movsx cx, [bnumberofpushrequired] ; all right …
; one might perhaps also try cbw sign extension ..
;mov al, [bnumberofpushrequired]
;cbw
;mov cx, ax
; 4/3/2014 not unpush-ing caused error until To^nAn remembers how the water fountain was topped with boyscout fleur-de-lis flower symbol at third nursery we visited in California before co^ Be^ uncle David Lowe came and before we return home to Michinga: "leave campground as you found it"
unpushloop00:
; in what follows if the "pop's" are not matched to the "push's" above then error will result … for example interrupt 9 might go on forever …
;pop ax ; no error …. regardless of corresponding "push" ….
pop word ax ; no error…. regardless of corresponding "push" ….
; SAFEPOP word, ax
add bx, 2
mov byte [ES:bx], 'q'
;mov AX, cx
;add DI, 4
;call out2hex ; print out gives 0x15 = 21 which is 21 * 2 = 42 bytes so that 42 + 20 + 2 = 64 bytes …; had "push dword ' '" been used, print out would have been 0x0B ~ 11 or 11 * 4 = 44 bytes and 64 – 44 = 20
;cmp cx, 21 – 3
;jl outofloop
;mov AX, cx
;mov DI, bx
;call out2hex ; print out gives 0x15 = 21 which is 21 * 2 = 42 bytes so that 42 + 20 + 2 = 64 bytes …; had "push dword ' '" been used, print out would have been 0x0B ~ 11 or 11 * 4 = 44 bytes and 64 – 44 = 20
;add bx, 2
;mov byte [ES:bx + 2000], '*'
;mov bx, cx
;mul bx, 2
;mov byte [ES:bx + 2000], '*'
;mov al, 2
;mul cx ; ax = cx*2
;mov bx, ax ; bx = cx*2
;mov di, [1700 + bx] ; print out ax = cx*2 at 1700 + cx*2
;call out2hex
;mov byte [ES:bx + 2000], '*' ; print out '*' at 2000 + cx*2
;SAFEPOP word, ax
;pop dword eax ; no error…. regardless of corresponding "push" ….
;pop dword ax ; NASM warning "register size specification ignored"…. regardless of corresponding "push" ….
;pop byte ax ; NASM warning "register size specification ignored"…. regardless of corresponding "push" ….
;pop byte ah ; NASM error "invalid combination of opcode and operands"…. regardless of corresponding "push" ….
loop unpushloop00
outofloop:
add bx, 2
mov byte [ES:bx], 'Q'
add bx, 2
mov BP, SP
mov AX, BP
sub AX, stacksegment
mov DI, bx
;mov DI, 1966
;mov DI, 1954
call out2hex ; print out is 0x3E = 62 …. stack is used by "call main" … 2 out 64 bytes …
;hlt
;jmp hltcontinue
jmp continueinterrupttests
; end secondtrytotestsafeinterrupt5
firsttrytotestsafeinterrupt5:
;jmp waitforinterrupts
; print out initial BP value as a "signed array index" …
;mov BP, SP
;mov AX, BP
;sub AX, stacksegment
;mov DI, 114
;call out2hex ; print out is 0x3E = 62 …. stack is used by "call main" … 2 out 64 bytes …
xor cx, cx
;mov cx, 64 ; 64
mov cx, stacksize
stackoverloadloop:
mov BP, SP
;;mov [wstackpointer], SP ; SP ~ (stacktop – amount that have been pushed)
; mov bx, sp ; sp ~ stacktop – amount that have been pushed
;mov BL, [BP]
;cmp BL, [wstacklowerbound]
;%define WHATISBP0
%ifdef WHATISBP0
cmp BP, 0
jne bpisnotzero
bpiszero:
mov byte [ES:360], '0'
jmp donecomparingbp
bpisnotzero:
cmp BP, 0
jl bpislessthanzero
mov byte [ES:362], 'G'
jmp donecomparingbp
bpislessthanzero:
mov byte [ES:364], 'L'
jmp donecomparingbp
donecomparingbp:
nop
%endif ; WHATISBP0
; reserve/allow some bytes, … say 20 bytes … e.g. for interrupt service routines that will service out of bound conditions …
cmp BP, stacksegment + 20 ; wstacklowerbound ; cmp does a sub BP, stacksegment + 20
;;bound BL, [wstacklowerbound]
jg safetopush
; 4/2/2014: SBTN ba?o cha^u is in flower on black while die^.u quye^n is tulip colors: San Jose calendar for this month says "nothing is too difficult for those with a will":
; 4/3/2014: mother is going to sinai grace hospital to have a cancer test [a test of the conditional/unconditional bound/will/love of God of "muo^n loa`i ddu+o+.c so^'ng la^u bi`nh thu+o+`ng; everyone live long and well" …] today ….
;%define TESTBOUNDMANUALLY
%ifdef TESTBOUNDMANUALLY
int 5
%else
; 4/5/2014 seems that internally "bound" instruction uses "signed" comparisons before calling int 5 … so …
; from Programmer's Reference Manual: "BOUND ensures that a signed array index is within the limits …"
;bound BP, [wstacklowerbound] ; valid for NASM
%ifdef USESIGNEDARRAYINDEXFORSTACKBOUNDS ; =< stacksegment + 20
; convert BP from raw "address" to "signed array index" using stacksegment as zero 0 reference index
sub BP, stacksegment ; =< 20
%endif ; USESIGNEDARRAYINDEXFORSTACKBOUNDS
bound BP, [wboundlowerbound] ; valid for NASM ; < 20
;bound ax, wstacklowerbound ; invalid for NASM
;bound ax, bx ; invalid for NASM, of course
%endif ; TESTBOUNDMANUALLY
;%define MANAGEBOUNDEXCEEDEDBYEXTENDORCREATENEWSTACKSEGMENT
%ifdef MANAGEBOUNDEXCEEDEDBYEXTENDORCREATENEWSTACKSEGMENT
; mov AX, 0x0027
; mov SS,AX
;;mov SP, 0x0027 + stacktop
; mov SP, stacktop
%endif ; MANAGEBOUNDEXCEEDEDBYEXTENDORCREATENEWSTACKSEGMENT
jmp finishtestinterrupt5
safetopush:
add byte [bnumberofpushrequired], 1 ; print out gives 0x15 = 21 which is 21 * 2 = 42 bytes so that 42 + 20 + 2 = 64 bytes …; had "push dword ' '" been used, print out would have been 0x0B ~ 11 or 11 * 4 = 44 bytes and 64 – 44 = 20
%ifdef TESTBOUNDMANUALLY
; push byte ' ' ; NASM "signed byte value exceeds bounds" error
push byte ' ' ; no errors
%else
;IF StackAddrSize = 16
;THEN
; IF OperandSize = 16 THEN
; SP := SP – 2; ; NOTE: 2 bytes
; (SS:SP) := (SOURCE); (* word assignment *)
; ELSE ; presumably "ELSE IF OperandSize = 32"
; SP := SP – 4; ; NOTE: 4 bytes
; (SS:SP) := (SOURCE); (* dword assignment *)
; FI;
;ELSE (* StackAddrSize = 32 *)
; IF OperandSize = 16
; THEN
; ESP := ESP – 2;
; (SS:ESP) := (SOURCE); (* word assignment *)
; ELSE ; presumably "ELSE IF OperandSize = 32"
; ESP := ESP – 4;
; (SS:ESP) := (SOURCE); (* dword assignment *)
; FI;
;FI;
; from http://courses.engr.illinois.edu/ece390/books/artofasm/CH06/CH06-1.html#HEADING1-160
; All pushes and pops are 16 or 32 bit operations. There is no (easy) way to push a single eight bit [one byte] value onto the stack. To push an eight bit value you would need to load it into the H.O. byte of a 16 bit register, push that register, and then add one to the stack pointer. On all processors except the 8088, this would slow future stack access since sp now contains an odd address, misaligning any further pushes and pops. Therefore, most programs push or pop 16 bits, even when dealing with eight bit values.
; Although it is relatively safe to push an eight bit [one byte] memory variable, be careful when popping the stack to an eight bit memory location. Pushing an eight bit variable with push word ptr ByteVar pushes two bytes, the byte in the variable ByteVar and the byte immediately following it. Your code can simply ignore the extra byte this instruction pushes onto the stack. Popping such values is not quite so straight forward. Generally, it doesn't hurt if you push these two bytes. However, it can be a disaster if you pop a value and wipe out the following byte in memory. There are only two solutions to this problem. First, you could pop the 16 bit value into a register like ax and then store the L.O. byte of that register into the byte variable. The second solution is to reserve an extra byte of padding after the byte variable to hold the whole word you will pop. Most programs use the former approach.
;%define TESTPUSHBYTE
%define TESTPUSHWORD
;%define TESTPUSHDWORD
;%define TESTSAFEINSTRUCTIONS
;%define TESTSAFEINSTRUCTIONlocal
%ifdef TESTPUSHBYTE
; pop byte ' ' ; yes one can pop before push
;push byte '' ; no errors ; supposedly SP increases by 2 as though pushing 'xx' instead of ''
;push byte ' ' ; NASM "signed byte value exceeds bounds" error;
push byte ' ' ; no errors
%elifdef TESTPUSHDWORD
;push dword ' ' ; no errors ; supposedly SP increases by 4 as though pushing 'xxxx' instead of 'x'
;push dword ' ' ; no errors ; supposedly SP increases by 4 as though pushing 'xxxx' instead of 'xx'
;push dword ' ' ; no errors ; supposedly SP increases by 4 as though pushing 'xxxx' instead of 'xxx'
;push dword ' ' ; NASM warning "character constant too long" and "dword data exceed bounds …
push dword ' ' ; no errors
%elifdef TESTPUSHWORD ; TESTPUSHWORD
;push word '' ; no errors ; supposedly SP increases by 2 as though pushing 'xx' instead of ''
;push word ' ' ; no errors ; supposedly SP increases by 2 as though pushing 'xx' instead of 'x'
;push word ' ' ; NASM "word data exceeds bounds" error
push word ' ' ; no errors
%elifdef TESTSAFEINSTRUCTIONSlocal
;SAFEPUSH byte, ' '
SAFEPUSH word, ' '
;SAFEPUSH dword, ' '
%endif ; TESTPUSHBYTE
;"Ready For Love"
;BAD COMPANY
; Now I'm on my feet again
; Better things are bound to happen [bound for glory: bound instruction]
; All my dues surely must be paid
; Many miles and many tears
; Times were hard but now they're changing
; You should know that I'm not afraid
; Ooh, I want you to stay
; Ooh, I want you today
;Writer(s): Mick Ralphs
; Copyright: WB Music Corp.
; bound BP, [wstacklowerbound]
; from Programmer's Reference Manual
; The BOUND instruction includes two operands. The first operand specifies the register being tested. The second operand contains the effective relative address of the two signed BOUND limit values. The BOUND instruction assumes that the upper limit and lower limit are in adjacent memory locations. These limit values cannot be register operands; if they are, an invalid opcode exception occurs.
;BOUND is useful for checking array bounds before using a new index value to access an element within the array. BOUND provides a simple way to check the value of an index register before the program overwrites information in a location beyond the limit of the array.
;The block of memory that specifies the lower and upper limits of an array might typically reside just before the array itself. This makes the array bounds accessible at a constant offset from the beginning of the array. Because the address of the array will already be present in a register, this practice avoids extra calculations to obtain the effective address of the array bounds.
;The upper and lower limit values may each be a word or a doubleword.
;IF (LeftSRC [RightSRC + OperandSize/8])
; (* Under lower bound or over upper bound *)
;THEN Interrupt 5;
;FI;
; BOUND ensures that a signed array index is within the limits specified by a block of memory consisting of an upper and a lower bound. Each bound uses one word for an operand-size attribute of 16 bits and a doubleword for an operand-size attribute of 32 bits. The first operand (a register) must be greater than or equal to the first bound in memory (lower bound), and less than or equal to the second bound in memory (upper bound). If the register is not within bounds, an Interrupt 5 occurs; the return EIP points to the BOUND instruction.
;The bounds limit data structure is usually placed just before the array itself, making the limits addressable via a constant offset from the beginning of the array.
; from https://courses.engr.illinois.edu/ece390/books/artofasm/CH06/CH06-5.html#HEADING5-171
;The fourth software interrupt, provided by 80286 and later processors, is the bound instruction. This instruction takes the form bound reg, mem
;and executes the following algorithm: if (reg [mem+sizeof(reg)]) then int 5
;[mem] denotes the contents of the memory location mem and sizeof(reg) is two or four depending on whether the register is 16 or 32 bits wide. The memory operand must be twice the size of the register operand. The bound instruction compares the values using a signed integer comparison.
; Intel’s designers added the bound instruction to allow a quick check of the range of a value in a register. This is useful in Pascal, for example, which checking array bounds validity and when checking to see if a subrange integer is within an allowable range. There are two problems with this instruction, however. On 80486 and Pentium/586 processors, the bound instruction is generally slower than the sequence of instructions it would replace: cmp reg, LowerBound
; jl OutOfBounds
; cmp reg, UpperBound
; jg OutOfBounds
;On the 80486 and Pentium/586 chips, the sequence above only requires four clock cycles assuming you can use the immediate addressing mode and the branches are not taken; the bound instruction requires 7-8 clock cycles under similar circumstances and also assuming the memory operands are in the cache.
; A second problem with the bound instruction is that it executes an int 5 if the specified register is out of range. IBM, in their infinite wisdom, decided to use the int 5 interrupt handler routine to print the screen. Therefore, if you execute a bound instruction and the value is out of range, the system will, by default, print a copy of the screen to the printer. If you replace the default int 5 handler with one of your own, pressing the PrtSc key will transfer control to your bound instruction handler. Although there are ways around this problem, most people don’t bother since the bound instruction is so slow.
; from http://faydoc.tripod.com/cpu/bound.htm
; Description
; Determines if the first operand (array index) is within the bounds of an array specified the second operand (bounds operand). The array index is a signed integer located in a register. The bounds operand is a memory location that contains a pair of signed doubleword-integers (when the operand-size attribute is 32) or a pair of signed word-integers (when the operand-size attribute is 16). The first doubleword (or word) is the lower bound of the array and the second doubleword (or word) is the upper bound of the array. The array index must be greater than or equal to the lower bound and less than or equal to the upper bound plus the operand size in bytes. If the index is not within bounds, a BOUND range exceeded exception (#BR) is signaled. (When a this exception is generated, the saved return instruction pointer points to the BOUND instruction.)
; The bounds limit data structure (two words or doublewords containing the lower and upper limits of the array) is usually placed just before the array itself, making the limits addressable via a constant offset from the beginning of the array. Because the address of the array already will be present in a register, this practice avoids extra bus cycles to obtain the effective address of the array bounds.
; from http://www.plantation-productions.com/Webster/www.artofasm.com/DOS/ch17/CH17-2.html#HEADING2-27
; Like into, the bound instruction will cause a conditional exception. If the specified register is outside the specified bounds, the bound instruction is equivalent to an int 5 instruction; if the register is within the specified bounds, the bound instruction is effectively a nop.
; The return address that bound pushes is the address of the bound instruction itself, not the instruction following bound. If you return from the exception without modifying the value in the register (or adjusting the bounds), you will generate an infinite loop because the code will reexecute the bound instruction and repeat this process over and over again.
; Warning: IBM, in their infinite wisdom, decided to use int 5 as the print screen operation. The default int 5 handler will dump the current contents of the screen to the printer. This has two implications for those who would like to use the bound instruction in their programs. First, if you do not install your own int 5 handler and you execute a bound instruction that generates a bound exception, you will cause the machine to print the contents of the screen. Second, if you press the PrtSc key with your int 5 handler installed, BIOS will invoke your handler. The former case is a programming error, but this latter case means you have to make your bounds exception handler a little smarter. It should look at the byte pointed at by the return address. If this is an int 5 instruction opcode (0cdh), then you need to call the original int 5 handler, or simply return from interrupt (do you want them pressing the PrtSc key at that point?). If it is not an int 5 opcode, then this exception was probably raised by the bound instruction. Note that when executing a bound instruction the return address may not be pointing directly at a bound opcode (0c2h). It may be pointing at a prefix byte to the bound instruction (e.g., segment, addressing mode, or size override). Therefore, it is best to check for the int 5 opcode.
; test the “bound” instruction:
; mov ax, 3
; mov [wstackupperbound], ax
; mov ax, 1
; mov [wstacklowerbound], ax
; mov ax, 0
; ;bound ax, [wstacklowerbound]
; bound ax, wstacklowerbound
; push ‘ ‘
%endif ; TESTBOUNDMANUALLY
loop stackoverloadloop
finishtestinterrupt5:
xor cx, cx
;mov cx, [bnumberofpushrequired]
movsx cx, [bnumberofpushrequired] ; 4/27/2014 see above, all right …
; from http://www.ece.msstate.edu/~reese/EE3724/lectures/stack/stack.pdf
; Stack Overflow, Underflow
;• If you keep pushing data on the stack without
;taking data off the stack, then the stack can
;eventually grow larger than your allocated space
;– Can begin writing to memory area that your code is in
;or other non-stack data
;– This is called stack OVERFLOW
;• If you take off more data than you placed on the
;stack, then stack pointer can increment past the
;‘start’ of the stack. This is stack UNDERFLOW.
;• Bottom line: You should allocate sufficient
;memory for your stack needs, and pop off the
;same amout of data as pushed in.
; for example, to experience underflow add 10 more pops beyond numberofpushrequired …
;add cx, 10
; 4/3/2014 not unpush-ing caused error until To^nAn remembers how the water fountain was topped with boyscout fleur-de-lis flower symbol at third nursery we visited in California before co^ Be^ uncle David Lowe came and before we return home to Michinga: “leave campground as you found it”
unpushloop:
; in what follows if the “pop’s” are not matched to the “push’s” above then error will result … for example interrupt 9 might go on forever …
;pop ax ; no error …. regardless of corresponding “push” ….
pop word ax ; no error…. regardless of corresponding “push” ….
;pop dword eax ; no error…. regardless of corresponding “push” ….
;pop dword ax ; NASM warning “register size specification ignored”…. regardless of corresponding “push” ….
;pop byte ax ; NASM warning “register size specification ignored”…. regardless of corresponding “push” ….
;pop byte ah ; NASM error “invalid combination of opcode and operands”…. regardless of corresponding “push” ….
loop unpushloop
nop
continueinterrupttests:
; nop
; test int 9 here ………………..
; automatic interrupt: keyboard presses will create int 9 …
; test: however ctr-alt-del will have no effect on custom interrupt int 9 …
;;mov ax, [binterrupt9count]
;;mov [bpreviousinterrupt9count], ax
;xor cx, cx
; print out initial BP value as a “signed array index” …
mov BP, SP
mov AX, BP
sub AX, stacksegment
mov DI, 120
call out2hex ; print out is 0x3E = 62 …. stack is used by “call main” … 2 out 64 bytes …
;mov bx, 660
waitforinterrupts:
; cmp [bpreviousinterrupt9count], [binterrupt9count]
;SAFEPUSH ‘ ‘
;;cmp SP, stacksegment + 10
;;ja safetopush
;;notsafetopush: int 5
;;safetopush: push ‘ ‘
;mov byte [ES:660 + [binterrupt9count]], ‘!’
; add bx, [binterrupt9count]
; mov byte [ES:bx], ‘!’
cmp byte [binterrupt9count], 10 ; key press wait loop … each press-release generates 2 interrupts …
;mov byte [ES:760 + [binterrupt9count], ‘i’
; mov byte [ES:bx + 100], ‘i’
jne waitforinterrupts
;jg waitforinterrupts
;loopne waitforinterrupts
; xor cx, cx
;WaitforData: in al, 64h ;Read kbd status port.
; test al, 10b ;Data in buffer?
; loopz WaitforData ;Wait until data available.
hltcontinue:
; restore original interrupt vector table from BIOS with original interrupt numbers 5 and 9 service routines
; call changeivt.loadivtwithorgbiosivt
call changeivt.loadbiosivtwithorgbiosivt
call changeivt.setorgivt
; ctr-alt-del should have an effect again here ………….
jmp seeyoulater
%endif ; TRYIVT
%ifdef TRYIVTORIG
; cli ; disable interrupts during change of interrupt vector table
;; call changeivt.loadorgbiosivtwithbiosivt
;call changeivt.loadivtwithbiosivt
;; call changeivt.loadivtwithorgbiosivt
;Setting:
;mov ax, [intnum*4] ; offset
;mov ax [intnum*4+2] ; segment
; pbs “peg and cat” …. suggestively similar “peg and cat” bedding at baby r us 3/13/2014
; substitute custom interrupt numbers 5 and 9 into new ivt table created by cloning from original BIOS ivt table: neighbor dude with custom truck 3/13/2014
; address of BIOS interrupts routines
interrupt5segment dw 0
interrupt5offset dw 0
interrupt9segment dw 0
interrupt9offset dw 0
mov ax, 0x0
mov gs, ax
mov ax, [gs:5*4] ; [0x0:5*4]
mov [interrupt5offset], ax
mov ax, [gs:5*4+2] ; [0x0:5*4+2]
mov [interrupt5segment], ax
mov ax, [gs:9*4] ; [0x0:9*4]
mov [interrupt5offset], ax
mov ax, [gs:9*4+2] ; [0x0:9*4+2]
mov [interrupt5segment], ax
; mov dword [interrupt5serviceroutine], [0x0:5*4]
; mov dword [interrupt9serviceroutine], [0x0:9*4]
cli ; pause interrupts
mov AX, safeinterrupt5sr ; offset
; mov dword [ivt + 5*4], AX
mov [gs:5*4], AX
mov AX, PROGRAMSEGMENT ; segment
; mov dword [ivt + 5*4+2], AX
mov [gs:5*4+2], AX
mov AX, safeinterrupt9sr ; offset
; mov dword [ivt + 9*4], AX
mov [gs:9*4], AX
mov AX, PROGRAMSEGMENT ; segment
; mov dword [ivt + 9*4+2], AX
mov [gs:9*4+2], AX
sti ; re-enable interrupts
;call changeivt.loadbiosivtwithivt
;; call changeivt.setivt ; inform processor where new ivt table is …
;sti ; re-enable interrupts
; test custom interrupt numbers 5 and 9 … here …
int 5
int 9
; restore original interrupt vector table from BIOS with original interrupt numbers 5 and 9
; call changeivt.loadivtwithorgbiosivt
;; call changeivt.loadbiosivtwithorgbiosivt
;; call changeivt.setorgivt
cli ; pause interrupts
mov ax, [interrupt5offset]
mov [gs:5*4], ax
mov ax, [interrupt5segment]
mov [gs:5*4+2], ax
mov ax, [interrupt9offset]
mov [gs:9*4], ax
mov ax, [interrupt9segment]
mov [gs:9*4+2], ax
sti ; re-enable interrupts
;sti ; re-enable interrupts
%endif ; TRYIVTORIG
;%define TRYIVT 1 ; non-zero
%ifdef TRYIVT
; from Programmer’s Reference Manual
;IF PE = 0
;THEN GOTO REAL-ADDRESS-MODE;
;ELSE GOTO PROTECTED-MODE;
;FI;
;REAL-ADDRESS-MODE:
; Push (FLAGS);
; IF = 0; (* Clear interrupt flag *)
; TF = 0; (* Clear trap flag *)
; Push(CS);
; Push(IP);
; (* No error codes are pushed *)
; CS := IDT[Interrupt number * 4].selector;
; IP := IDT[Interrupt number * 4].offset;
;interrupts are a type of (messageA + messageB + messageC + messageD + tinLa`nh + …):
; from http://wiki.osdev.org/Interrupt_Vector_Table
; The IVT is typically located at 0000:0000H, and is 400H bytes in size (4 bytes for each interrupt). Although the default address can be changed using the LIDT instruction on newer CPUs, this is usually not done because it is both inconvenient and incompatible with other implementations and/or older software (e.g. MS-DOS programs). However, note that the code must remain in the first MiB of RAM.
; format of the ivt table entries [1024/4=256 entries] is
; +———–+———–+
; | Segment | Offset |
; +———–+———–+
; 4 2 0
; from https://www.uop.edu.jo/issa/Assembly/programming.pdf
;ivt table is 1k in real mode, 2k in protected mode
;ivt entry is 4 bytes in real mode, 8 bytes in protected mode
;size of the pointer to ivt table is 4 bytes for addresses from 00000000 to 000003FF, is 8 bytes in protected mode
;%define BIVTSTART 0x0; Start of BIOS ivt data area
;struc tBIOSIVT ; its structure
; .SEGMENT RESW 1
; .OFFSET RESW 1
;endstruc
; the ivt table defined in the data segment “datasegment” above
;;.ivt: times 1024 db 0 ; interrupt vector table: reserve space to push-pop BIOS’ ivt table
;;.ivtend:
;;fourcxvar dw 0
;; mov ax, 0x0
;; mov gs, ax
;; mov ax, [gs:5*4] ; [0x0:5*4]
;; mov [interrupt5offset], ax
;; mov ax, [gs:5*4+2] ; [0x0:5*4+2]
;; mov [interrupt5segment], ax
; from NASM manual:
;3.3 Effective Addresses
;An effective address is any operand to an instruction which references memory. Effective addresses, in NASM, have a very simple syntax: they consist of an expression evaluating to the desired address, enclosed in square brackets. For example:
;wordvar dw 123
; mov ax,[wordvar]
; mov ax,[wordvar+1]
; mov ax,[es:wordvar+bx] ; this is gives no error
; however:
; mov ax,[es:wordvar+cx] ; this gives “invalid effective address” error
; mov ax,[es:wordvar+2*bx] ; this gives “invalid effective address” error
; mov ax,[es:wordvar+10*bx] ; this gives “invalid effective address” error
; mov ax,[es:wordvar+4*bx] ; this gives “invalid effective address” error
; mov eax,[es:wordvar+4*ebx] ; this gives no error
; mov eax,[es:wordvar+10*ebx] ; this gives “invalid effective address” error
; also segment registers:
; mov gs, 0x0 ; “immediate” gives error
; mov gs, [worvar] ; “memory” is all right
; mov gs, ax ; “register” is all right
; from http://www.supernovah.com/Tutorials/Assembly3.php:
;16-bit Real Mode Addressing
;Non Memory Addressing Modes
;The non memory addressing modes in 16 bits are the same as 32-bit non memory addressing modes except that you can only use 16-bit registers or smaller. Also the largest displacement in 16-bit addresses can be at most 16 bits.
;Memory Addressing Modes
;In 16-bit real mode we can address memory using 16-bit or 8-bit registers. The addressing modes in 16 bits are much more restrictive than in 32 bits. The table below lists the components that can make up a 16-bit address.
;Displacement Base Index Scale
;no disp BX SI None
;8-bit disp BP DI
;16-bit disp
;32-bit Protected Mode Addressing
;Non Memory Addressing Modes
;These addressing modes do not access memory. These modes will work with either static data or registers.
;Memory Addressing Modes
;These addressing modes perform memory operations such as reading from and writing to memory. Because of the memory access, it is often slower than using the non memory addressing modes. Of course a program could not rely on immediate and register addressing modes alone, therefore the processor allows you to access memory in many different ways. Most instructions will only allow one operand to use a memory addressing mode while the other operand must use either the immediate or register addressing mode.
;Memory addresses are composed of several different components. The table below lists the components that can make up a memory address.
;Displacement Base Index Scale
;no disp EAX EAX 1
;16-bit disp EBX EBX 2
;32-bit disp ECX ECX 4
; EDX EDX 8
; ESI ESI
; EDI EDI
; EBP EBP
; ESP
; from Programmer’s Reference Manual:
;Figure 2-10. Effective Address Computation
; SEGMENT + BASE + (INDEX * SCALE) + DISPLACEMENT
;
; + +
; | — | + + + +
; + + | EAX | | EAX | | 1 |
; | CS | | ECX | | ECX | | | + +
; | SS | | EDX | | EDX | | 2 | | NO DISPLACEMENT |
; -| DS |- + -| EBX |- + -| EBX |- * -| |- + -| 8-BIT DISPLACEMENT |-
; | ES | | ESP | | — | | 4 | | 32-BIT DISPLACEMENT |
; | FS | | EBP | | EBP | | | + +
; | GS | | ESI | | ESI | | 6 |
; + + | EDI | | EDI | + +
; + + + +
; from http://faydoc.tripod.com/cpu/loop.htm
;Performs a loop operation using the ECX or CX register as a counter. Each time the LOOP instruction is executed, the count register is decremented, then checked for 0. If the count is 0, the loop is terminated and program execution continues with the instruction following the LOOP instruction. If the count is not zero, a near jump is performed to the destination (target) operand, which is presumably the instruction at the beginning of the loop. If the address-size attribute is 32 bits, the ECX register is used as the count register; otherwise the CX register is used.
; The target instruction is specified with a relative offset (a signed offset relative to the current value of the instruction pointer in the EIP register). This offset is generally specified as a label in assembly code, but at the machine code level, it is encoded as a signed, 8-bit immediate value, which is added to the instruction pointer. Offsets of –128 to +127 are allowed with this instruction.
; Some forms of the loop instruction (LOOPcc) also accept the ZF flag as a condition for terminating the loop before the count reaches zero. With these forms of the instruction, a condition code (cc) is associated with each instruction to indicate the condition being tested for. Here, the LOOPcc instruction itself does not affect the state of the ZF flag; the ZF flag is changed by other instructions in the loop.
changeivt:
.loadorgbiosivtwithbiosivt:
xor ax, ax ; segment of original BIOS IVT table is 0x0
mov gs, ax ; segment of original BIOS IVT table is 0x0
mov bx, 1024 ; setup loop counter
mov cx, 512 ; //1024 = 512 * sizeof(word) … setup loop counter
; loop instruction involves cx but 16 bit effective address requires bx …
.looploadorgbiosivtwithbiosivt:
mov word ax, [gs:bx] ; 16 bit effective address requires loop counter to use bx or bp instead of cx etc.
mov word [orgbiosivt + bx], ax
;mov dword [orgbiosivt + cx*4], [es:4*di]
sub bx, 2
loop .looploadorgbiosivtwithbiosivt
mov ax, [gs:0000]
mov [orgbiosivt + 0], ax ; since “loop” exists when CX is 0, 0th entry must be done manually
jmp .exitchangeivt
.loadbiosivtwithorgbiosivt:
xor ax, ax ; segment of original BIOS IVT table is 0x0
mov gs, ax ; segment of original BIOS IVT table is 0x0
mov bx, 1024 ; setup loop counter
mov cx, 512 ; //1024 = 512 * sizeof(word) … setup loop counter
.looploadbiosivtwithorigbiosivt:
mov word ax, [orgbiosivt + bx]
mov word [gs:bx], ax
sub bx, 2
loop .looploadbiosivtwithorigbiosivt
mov word ax, [orgbiosivt + 0] ; since “loop” exists when CX is 0, 0th entry must be done manually
mov word [gs:0], ax
jmp .exitchangeivt
.loadivtwithorgbiosivt:
xor ax, ax ; segment of original BIOS IVT table is 0x0
mov gs, ax ; segment of original BIOS IVT table is 0x0
mov bx, 1024 ; //1024 = 512 * sizeof(word) … setup loop counter
mov cx, 512 ; setup loop counter
.looploadivtwithorgbiosivt:
mov word ax, [orgbiosivt + bx]
mov word [ivt + bx], ax
sub bx, 2
loop .looploadivtwithorgbiosivt
mov word ax, [orgbiosivt + 0] ; since “loop” exists when CX is 0, 0th entry must be done manually
mov word [ivt + 0], ax
jmp .exitchangeivt
.loadivtwithbiosivt:
xor ax, ax ; segment of original BIOS IVT table is 0x0
mov gs, ax ; segment of original BIOS IVT table is 0x0
mov bx, 1024 ; //1024 = 512 * sizeof(word) … setup loop counter
mov cx, 512 ; setup loop counter
.looploadivtwithbiosivt:
mov word ax, [gs:bx] ; 16 bit effective address requires loop counter to use bx or bp instead of cx etc.
mov word [ivt + bx], ax
sub bx, 2
loop .looploadivtwithbiosivt
mov word ax, [gs:0] ; since “loop” exists when CX is 0, 0th entry must be done manually
mov word [ivt + 0], ax
jmp .exitchangeivt
.loadbiosivtwithivt:
xor ax, ax ; segment of original BIOS IVT table is 0x0
mov gs, ax ; segment of original BIOS IVT table is 0x0
mov bx, 1024 ; //1024 = 512 * sizeof(word) … setup loop counter
mov cx, 512 ; setup loop counter
.looploadbiosivtwithivt:
mov word ax, [ivt + bx]
mov word [gs:bx], ax
sub bx, 2
loop .looploadbiosivtwithivt
mov word ax, [ivt + 0] ; since “loop” exists when CX is 0, 0th entry must be done manually
mov word [gs:0], ax
jmp .exitchangeivt
.exitchangeivt:
ret
; from http://wiki.osdev.org/GDT_Tutorial
;gdtr DW 0 ; For limit storage
; DD 0 ; For base storage
;GDT:
;GDT_end:
;setGdt:
; xor EAX, EAX ; zero EAX register for use as scratch
; mov AX, DS ; the data segment “datasegment”
; shl EAX, 4 ; The linear address should here be computed as segment * 16 + offset. shift left 4 ~ multiply by 16
; add EAX, ”GDT” ; add offset to GDT structure in segment “datasegment”
; mov [gdtr + 2], eax ; initialize gdtr’s base storage to segment:offset address of GDT structure
; mov EAX, ”GDT_end”
; sub EAX, ”GDT” ; size of GDT structure = GDT end – GDT begin
; mov [gdtr], AX ; initialize gdtr’s to size of GDT structure = GDT end – GDT begin
; lgdt [gdtr] ; set the gdt with lgdt
; ret
; the idt or ivt table defined in the data segment “datasegment” above
;;.ivt: times 1024 db 0 ; interrupt vector table: reserve space to push-pop BIOS’ ivt table
;;.ivtend:
;;ivtend:
;; interrup descriptor table
;idt:
;idt_end:
;the idtr or ivtr structures defined in the data segment “datasegment” above:
;idtr DW 0 ; For limit storage
; DD 0 ; For base storage
;ivtr DW 0 ; For limit storage
; DD 0 ; For base storage
;.setidt: ; set the interrupt descriptor table IDT
.setivt: ; set the interrupt vector table IVT
xor EAX, EAX ; zero EAX register for use as scratch
mov AX, DS ; the data segment “datasegment”
shl EAX, 4 ; The linear address should here be computed as segment * 16 + offset. shift left 4 ~ multiply by 16
; add EAX, idt ; add offset to IDT structure in segment “datasegment”
add EAX, ivt ; add offset to IVT structure in segment “datasegment”
; mov [idtr + 2], eax ; initialize gdtr’s base storage to segment:offset address of IDT structure
mov [ivtr + 2], eax ; initialize ivtr’s base storage to segment:offset address of IVT structure
; mov EAX, idt_end
mov EAX, ivtend
; sub EAX, idt ; size of GDT structure = IDT end – IDT begin
sub EAX, ivt ; size of IDT structure = IVT end – IVT begin
; mov [idtr], AX ; initialize gdtr’s to size of IDT structure = IDT end – IDT begin
mov [ivtr], AX ; initialize ivtr’s to size of IVT structure = IVT end – IVT begin
; lgdt [idtr] ; set the idt with lgdt
;lgdt [ivtr] ; set the ivt with lgdt
lidt [ivtr] ; set the ivt with lgdt
; from Programmer’s Reference Manual
; IF instruction = LIDT
;THEN
; IF OperandSize = 16
; THEN IDTR.Limit:Base := m16:24 (* 24 bits of base loaded *)
; ELSE IDTR.Limit:Base := m16:32
; FI;
;ELSE (* instruction = LGDT *)
; IF OperandSize = 16
; THEN GDTR.Limit:Base := m16:24 (* 24 bits of base loaded *)
; ELSE GDTR.Limit:Base := m16:32;
; FI;
;FI;
;.exit:
;ret
jmp .exitchangeivt
.setorgivt: ; set the interrupt vector table IVT
xor EAX, EAX ; zero EAX register for use as scratch
; mov AX, DS ; the data segment “datasegment”
mov AX, 0x0 ; the data segment “datasegment”
shl EAX, 4 ; The linear address should here be computed as segment * 16 + offset. shift left 4 ~ multiply by 16
; add EAX, idt ; add offset to IDT structure in segment “datasegment”
; add EAX, ivt ; add offset to IVT structure in segment “datasegment”
add EAX, 0x0 ; add offset to IVT structure in segment “datasegment”
; mov [idtr + 2], eax ; initialize gdtr’s base storage to segment:offset address of IDT structure
mov [orgbiosivtr + 2], eax ; initialize ivtr’s base storage to segment:offset address of IVT structure
; mov EAX, idt_end
mov EAX, orgbiosivtend
; sub EAX, idt ; size of GDT structure = IDT end – IDT begin
sub EAX, orgbiosivt ; size of IVT structure = IVT end – IVT begin
; mov [idtr], AX ; initialize gdtr’s to size of IDT structure = IDT end – IDT begin
; mov [ivtr], AX ; initialize ivtr’s to size of IVT structure = IVT end – IVT begin
mov AX, 400h ; initialize size of ivtr to … size of original BIOS IVT structure
mov [orgbiosivtr], AX ; initialize original BIOS ivtr’s to size of original IVT structure = IVT end – IVT begin
; lgdt [idtr] ; set the idt with lgdt
;lgdt [orgbiosivtr] ; set the ivt with lgdt
lidt [orgbiosivtr] ; set the ivt with lgdt
; from Programmer’s Reference Manual
; IF instruction = LIDT
;THEN
; IF OperandSize = 16
; THEN IDTR.Limit:Base := m16:24 (* 24 bits of base loaded *)
; ELSE IDTR.Limit:Base := m16:32
; FI;
;ELSE (* instruction = LGDT *)
; IF OperandSize = 16
; THEN GDTR.Limit:Base := m16:24 (* 24 bits of base loaded *)
; ELSE GDTR.Limit:Base := m16:32;
; FI;
;FI;
;.exit:
;ret
jmp .exitchangeivt
; pbs “peg and cat” …. suggestively similar “peg and cat” bedding at baby r us 3/13/2014
; substitute custom interrupt numbers 5 and 9 into new ivt table created by cloning from original BIOS ivt table: neighbor dude with custom truck 3/13/2014
.insertcustominterruptsintoivt:
cli ; pause interrupts
mov AX, safeinterrupt5sr ; offset
; mov dword [ivt + 5*4], AX
;; mov [gs:5*4], AX ; insert offset part of address of custom interrupt service routine into BIOS ivt
mov [ivt + 5*4], AX ; insert offset part of address of custom interrupt service routine into ivt
mov AX, PROGRAMSEGMENT ; segment
; mov dword [ivt + 5*4+2], AX
;; mov [gs:5*4+2], AX ; insert segment part of address of custom interrup service routine into BIOS ivt
mov [ivt + 5*4+2], AX ; insert segment part of address of custom interrup service routine into ivt
mov AX, safeinterrupt9sr ; offset
; mov dword [ivt + 9*4], AX
;; mov [gs:9*4], AX ; insert offset part of address of custom interrupt service routine into BIOS ivt
mov [ivt + 9*4], AX ; insert offset part of address of custom interrupt service routine into ivt
mov AX, PROGRAMSEGMENT ; segment
; mov dword [ivt + 9*4+2], AX
;; mov [gs:9*4+2], AX ; insert segment part of address of custom interrupt service routine into BIOS ivt
mov [ivt + 9*4+2], AX ; insert segment part of address of custom interrupt service routine into ivt
sti ; re-enable interrupts
jmp .exitchangeivt
;;.removecustominterruptsfromivt
; restore original interrupt vector table from BIOS with original interrupt numbers 5 and 9
; call changeivt.loadivtwithorgbiosivt
;; call changeivt.loadbiosivtwithorgbiosivt
;; call changeivt.setorgivt
;; cli ; pause interrupts
;; mov ax, [interrupt5offset]
;; mov [gs:5*4], ax
;; mov ax, [interrupt5segment]
;; mov [gs:5*4+2], ax
;; mov ax, [interrupt9offset]
;; mov [gs:9*4], ax
;; mov ax, [interrupt9segment]
;; mov [gs:9*4+2], ax
;; sti ; re-enable interrupts
;sti ; re-enable interrupts
;; jmp .exitchangeivt
%endif ; TRYIVT
; gia ba?o suggested for balance to “say hello”:
seeyoulater:
; call exit
call word exit
; call hang
call word hang
ret ; return
; from http://www.supernovah.com/Tutorials/BootSector4.php:
;Video Memory
;As previously stated, what is printed to the screen is simply controlled by a special section of memory called
;the video memory (or VGA memory). This section of memory is then periodically copied to the video device
;memory which is then presented to the screen by the Digital Analog Converter (DAC). Currently we are in text
;mode 03h which is a form of EGA. The video memory for text mode 3h begins at 0xB8000. Text mode 03h is 80 characters wide
;and 25 characters tall. This gives us 2000 total characters (80 * 25). Each character consists of 2 bytes which
;yields 4000 bytes of memory in total. So this means that text mode 03h stores it’s video information (the information that is
;printed to the screen) at the memory address 0xB8000 and it takes up 4000 bytes of memory.
;Printing Character to the Screen
;The first we must do in order to print character to the screen is to get a segment register setup that points
;to the memory location 0xB8000 [= 753664 = 47104 * 16]. Remember that segments in real mode have the lower four bits implicitly
;set to zero and because each hex digit represents four bits we can easily drop the right most zero on the
;memory address when storing it in a segment register. We will use the ES segment register because we
;still want to access our data with the DS segment so we don’t run into problems when using instructions that
;implicitly use the DS segment by default.
;mov AX,0xB800 ;// = 47104
;mov ES,AX
;screen output …
;for the screen, the messages in (“muo^n loa`i” <= "muo^n loa`i va` messageA va` messageB va` messageC va` ….") are pixels …
;("muo^n loa`i va` pixel1 va` pixel2 va` … ddu+o+.c so^'ng la^u bi`nh thu+o+`ng; everyone live long and well")
screensetup: ; point ES to video memory
.setupvideosegment:
mov AX,0xB800 ;// = 47104
mov ES,AX
; to use the stack, use "call" and "ret" instead of "jmp"
; or just let the program flows, without the jmp, to instructions that follow
;jmp clearscreenpixels
ret ; return
; from http://staff.ustc.edu.cn/~xyfeng/research/cos/resources/machine/mem.htm:
;0x0000:0x0000 1024 bytes Interrupt Vector Table
;0x0040:0x0000 256 bytes BIOS Data Area
;0x0050:0x0000 ? Free memory
;0x07C0:0x0000 512 bytes Boot sector code
;0x07E0:0x0000 ? Free memory
;0xA000:0x0000 64 Kb Graphics Video Memory
;0xB000:0x0000 32 Kb Monochrome Text Video Memory
;0xB800:0x0000 32 Kb Color Text Video Memory
;0xC000:0x0000 256 Kb1 ROM Code Memory
;0xFFFF:0x0000 16 bytes More BIOS data
;Clearing the Background
;Clearing the background is rather trivial. The goal is to set all of the attribute bytes to the background color
;you wish to clear it to. The basic idea is to create a loop that will set every other byte, starting at the first
;attribute byte, to the background color we wish to clear to. We must also be sure to only clear all of the attributes that
;are used to represent the string. In other words, be sure not to go past the last attribute byte. The last attribute byte is
;found at 80 * 25 * 2 – 1. The 80 is the width and the 25 is the height. The 2 is there because two bytes make up each
;character; one for the character and one for the attribute. Finally the 1 is subtracted because our first attribute byte is
;actually the second byte at the beginning The 1 simply takes into account that we start our count at one instead of zero.
;The right most hex digit sets the lower four bits of the attribute byte. The lower four bits control the character color while the upper
;four bits (the left most hex digit) control the background color and flash bit. We set the background and flash bits (upper four bits) to 0h
; because 0h corresponds to the color black with no flashing.
;color index hex 64-color palette index
;Black 0 00h 0
;Blue 1 01h 1
;Green 2 02h 2
;Cyan 3 03h 3
;Red 4 04h 4
;Magenta 5 05h 5
;Brown 6 06h 20
;Light Gray 7 07h 7
;Dark Gray 8 08h 56
;Bright Blue 9 09h 57
;Bright Green 10 0Ah 58
;Bright Cyan 11 0Bh 59
;Bright Red 12 0Ch 60
;Bright Magenta 13 0Dh 61
;Bright Yellow 14 0Eh 62
;Bright White 15 0Fh 63
; from http://gd.tuwien.ac.at/languages/c/programming-bbrown/advcw2.htm and
;offset = (( row * 0x50 + column ) * 2 ) + ( pagenum * 0x1000 )
clearscreenpixels:
mov CX,0x50 * 25 * 2 – 1
mov BX,1
.Loopthroughscreenpixels:
cmp BX,CX
ja .finishclearscreenpixels ;CF = 0 and ZF = 0
;ja Loads EIP with the specified address, if first operand of previous CMP instruction is greater than the second. ja is the same as jg, except that it performs an unsigned comparison.
mov byte [ES:BX],70h ;Set background to light gray
;and the text to black
;with no flashing text
add BX,2
jmp .Loopthroughscreenpixels ; jmp Loads EIP with the specified address
.finishclearscreenpixels:
; to use the stack, use "call" and "ret" instead of "jmp"
; or just let the program flows, without the jmp, to instructions that follow
;jmp exit
;jmp sayhello
ret
%ifdef SAYHELLO
sayhello:
mov byte [ES:0],'h'
mov byte [ES:2],'o'
mov byte [ES:4],'p'
mov byte [ES:6],'e'
mov byte [ES:8],' '
mov byte [ES:10],'w'
mov byte [ES:12],'e'
mov byte [ES:14],'l'
mov byte [ES:16],'l'
; from NASM manual
; wordvar dw 123
; mov ax,[wordvar]
; mov ax,[wordvar+1]
; mov ax,[es:wordvar+bx]
; test stacksegment ; stack ~ buffer … to^nan does not have enough fat/buffer on him
; xor bl, bl
; from http://www.supernovah.com/Tutorials/Assembly4.php:
;When the processor pushes data onto the stack it does the following operations:
;1.Subtract 4 from SP or ESP
;2.Move the source data to the memory location [SS:SP] or [SS:ESP]
; push dword 117 ;Push the value 117 as a dword onto the stack
; push dword [0x500] ;Push the value at the memory location 0x500 onto the stack
; push byte 'H' ;Push the value 117 as a dword onto the stack ; nasm gives no error with the "byte" specification, see http://f.osdev.org/viewtopic.php?f=1&t=13399
; push byte 'o' ;Push the value 117 as a dword onto the stack
; push byte 'p' ;Push the value 117 as a dword onto the stack
; push byte 'e' ;Push the value 117 as a dword onto the stack
; push byte 'W' ;Push the value 117 as a dword onto the stack
; push byte 'e' ;Push the value 117 as a dword onto the stack
; push byte 'l' ;Push the value 117 as a dword onto the stack
; from http://www.supernovah.com/Tutorials/BootSector4.php:
; When the processor pushes data onto the stack it does the following operations:
;1.Subtract 4 from SP or ESP
;2.Move the source data to the memory location [SS:SP] or [SS:ESP]
; NOTE: if StackAddrSize = 16 then use SP
; else if StackAddrSize = 32 then use ESP
; from Programmer's Reference Manual
;IF StackAddrSize = 16
;THEN
; IF OperandSize = 16 THEN
; SP := SP – 2;
; (SS:SP) := (SOURCE); (* word assignment *)
; ELSE
; SP := SP – 4;
; (SS:SP) := (SOURCE); (* dword assignment *)
; FI;
;ELSE (* StackAddrSize = 32 *)
; IF OperandSize = 16
; THEN
; ESP := ESP – 2;
; (SS:ESP) := (SOURCE); (* word assignment *)
; ELSE
; ESP := ESP – 4;
; (SS:ESP) := (SOURCE); (* dword assignment *)
; FI;
;FI;
; thus, …
; push word ….. subtracts 2 from SP or ESP
; push dword ….. subtracts 4 from SP or ESP
; mov [spprevious], SP
; … some operation …
; mov [spnew], SP
; mov word [spcounter + 2 * 0], spprevious – spnew
; mov [spprevious], SP
; 4/15/2014 from http://en.wikipedia.org/wiki/Endianness#History
; The terms endian and endianness, refer to how bytes of a data word are ordered within memory.
;Each byte of memory is associated with an index, called its address, which indicates its position. Bytes of a single data word (such as a 32 bit integer datatype) are generally stored in consecutive memory addresses (a 32 bit int needs 4 such locations). Big-endian systems are systems in which the most significant byte (see Most significant bit) of the word is stored in the smallest address given and the least significant byte is stored in the largest. In contrast, little endian systems are those in which the least significant byte is stored in the smallest address. Say the data word was "0A 0B 0C 0D" (a set of 4 bytes) and memory addresses starting at a with offsets 0, 1, 2 and 3 are given. Then, in big endian systems, byte 0A is placed in offset 0, 0B in 1, 0C in 2 and 0D in 3. In little-endian systems, the order is the reverse of it.
;Computer memory consists of a sequence of cells, usually bytes, and each cell has a number called its address that programs use to refer to it. If total number of bytes in memory is n then bytes addresses would be enumerated 0 to n-1. Multi-byte CPU registers are stored in memory as a simple concatenation of bytes. The simple forms are:[6]
;increasing numeric significance with increasing memory addresses (or increasing time), known as little-endian, and
;decreasing numeric significance with increasing memory addresses (or increasing time), known as big-endian[7]
;The Intel x86 and x86-64 series of processors use the little-endian format, and for this reason, the little-endian format is also known as the Intel convention. Other well-known little-endian processor architectures are the 6502 (including 65802, 65C816), Z80 (including Z180, eZ80 etc.), MCS-48, 8051, DEC Alpha, Altera Nios II, Atmel AVR, VAX, and, largely, PDP-11.
;The Motorola 6800 and 68k series of processors use the big-endian format, and for this reason, the big-endian format is also known as the Motorola convention. Other well-known processors that use the big-endian format include the Xilinx Microblaze, SuperH, IBM POWER, Atmel AVR32, and System/360 and its successors such as System/370, ESA/390, and z/Architecture. The PDP-10 also used big-endian addressing for byte-oriented instructions.
;SPARC historically used big-endian until version 9, which is bi-endian, similarly the ARM architecture was little-endian before version 3 when it became bi-endian, and the PowerPC and Power Architecture descendants of POWER are also bi-endian.
; …..
; Etymology[edit]
; Wikisource has original text related to this article:
;Gulliver's Travels (Part I, Chapter IV)
;In 1726, Jonathan Swift described in his satirical novel Gulliver’s Travels tensions in Lilliput and Blefuscu: whereas royal edict in Lilliput requires cracking open one's soft-boiled egg at the small end, inhabitants of the rival kingdom of Blefuscu crack theirs at the big end (giving them the moniker Big-endians).[1][2] The terms little-endian and endianness have a similar intent.[3]
;Danny Cohen's "On Holy Wars and a Plea for Peace" published in 1980[2] ends with: "Swift's point is that the difference between breaking the egg at the little-end and breaking it at the big-end is trivial. Therefore, he suggests, that everyone does it in his own preferred way. We agree that the difference between sending eggs with the little- or the big-end first is trivial, but we insist that everyone must do it in the same way, to avoid anarchy. Since the difference is trivial we may choose either way, but a decision must be made."
;This trivial difference was the reason for a hundred-years war between the fictional kingdoms. It is widely assumed that Swift was either alluding to the historic War of the Roses or – more likely – parodying through oversimplification the religious discord in England and Scotland brought about by the conflicts between the Roman Catholics (Big Endians) on the one side and the Anglicans and Presbyterians (Little Endians) on the other.
; from NASM manual
;A character constant with more than one byte will be arranged with little-endian order in mind: if you code
; mov eax,'abcd'
;then the constant generated is not 0x61626364, but 0x64636261, so that if you were then to store the value into memory, it would read abcd rather than dcba. This is also the sense of character constants understood by the Pentium's CPUID instruction.
; … db 0x55 ; just the byte 0x55
; NOTE:
;mov stacktop, SP ; invalid combination of opcode and operands
;mov BP, SP ; valid
;stackdata dw 0 ; valid
;mov ax, [bp] ; valid
;mov [stackdata], ax ; valid
;wstackpointer dw 0
;mov [wstackpointer], SP ; valid
; mov [stackdata], [[wstackpointer]] ; effectively data on stack is accessed thus …
mov BP, SP
;;mov [wstackpointer], SP ; SP ~ (stacktop – amount that have been pushed)
; push 'H ' ;Push the value 117 as a dword onto the stack
push word 'H ' ;Push the value 117 as a dword onto the stack
;pushd 'H ' ;Push the value 117 as a dword onto the stack
;pushw 'H ' ;Push the value 117 as a dword onto the stack
;push word 'H ' ;Push the value 117 as a dword onto the stack
;push dword 'H ' ;Push the value 117 as a dword onto the stack
; mov [spnew], SP
; mov word [spcounter + 2 * 2], spprevious – spnew
; mov bx, sp ; sp ~ stacktop – amount that have been pushed
; 3/27/2014: co^ Tu' chu' Ha?i came today and To^nAn figures out to use BL register together with BP and SP register to get at the data on the stack by dereferencing register SP …
mov BL, [BP – 2]
;;mov byte al, [wstackpointer – 2]
mov byte [ES:260], BL ; 'H '
;; mov [wstackpointer], SP ; SP ~ (stacktop – amount that have been pushed)
;; push 'O ' ;Push the value 117 as a dword onto the stack
push word 'O ' ;Push the value 117 as a dword onto the stack
;; mov byte bl, [wstackpointer – 2 + 1]
;; mov byte [ES:262], bl ; 'O '
;; mov [wstackpointer], SP ; SP ~ (stacktop – amount that have been pushed)
;; push 'P ' ;Push the value 117 as a dword onto the stack
push word 'P ' ;Push the value 117 as a dword onto the stack
;; mov byte bl, [wstackpointer – 2 + 1]
;; mov byte [ES:264], bl ; 'O '
;; mov [wstackpointer], SP ; SP ~ (stacktop – amount that have been pushed)
;; push 'E ' ;Push the value 117 as a dword onto the stack
push word 'E ' ;Push the value 117 as a dword onto the stack
;; mov byte bl, [wstackpointer – 2 + 1]
;; mov byte [ES:266], bl ; 'E '
;; mov [wstackpointer], SP ; SP ~ (stacktop – amount that have been pushed)
;; push 'W ' ;Push the value 117 as a dword onto the stack
push word 'W ' ;Push the value 117 as a dword onto the stack
;; mov byte bl, [wstackpointer – 2 + 1]
;; mov byte [ES:270], bl ; 'W '
;; mov [wstackpointer], SP ; SP ~ (stacktop – amount that have been pushed)
;; push 'E ' ;Push the value 117 as a dword onto the stack
push word 'E ' ;Push the value 117 as a dword onto the stack
;; mov byte bl, [wstackpointer – 2 + 1]
;; mov byte [ES:272], bl ; 'E '
;; mov [wstackpointer], SP ; SP ~ (stacktop – amount that have been pushed)
;; push 'L ' ;Push the value 117 as a dword onto the stack
push word 'L ' ;Push the value 117 as a dword onto the stack
;; mov byte bl, [wstackpointer – 2 + 1]
;; mov byte [ES:274], bl ; 'L '
;stacktop = stacksegment – datasegment + 64
; xor bl, bl
; mov byte bl, [0 + stacksegment – datasegment + 64 – 0] ; 'l'
; mov byte [ES:30], bl
; mov byte bl, [0 + stacksegment – datasegment + 64 – 1] ; 'e'
; mov byte [ES:32], bl
; mov byte bl, [0 + stacksegment – datasegment + 64 – 2] ; 'W'
; mov byte [ES:34], bl
; mov byte bl, [0 + stacksegment – datasegment + 64 – 3] ; 'e'
; mov byte [ES:36], bl
xor bl, bl
; STACK states at various points …
; *****************
; *****************
; *****************
; *****************
; ***************** << SP
; ***************** 2 bytes after call main
; *****************
; *****************
; *****************
; ***************** << SP
; ***************** + 2 bytes after call sayhello
; *****************
; ***************** 2 bytes after call main
; *****************
; ***************** <Convert Character to Number!
; mov i,al
;
; MOV AH, 2 ;
; MOV DL, i ; Print Character.
; INT 21H ;
; mov [spprevious], SP
; … some operation …
; mov [spnew], SP
; mov word [spcounter + 2 * 0], spprevious – spnew
; xor bl, bl
; mov byte bl, [spcounter + 2 * 0]
; mov byte [ES:76], bl
; mov byte bl, [spcounter + 2 * 1]
; mov byte [ES:7], bl
; mov byte bl, [spcounter + 2 * 2]
; mov byte [ES:], bl
xor bl, bl
;pop byte bl; nasm gives error: invalid combination of opcode and operands
pop bx; ‘L ‘
;mov byte bl, [stacktop – 0]
;pop byte bl; nasm gives error: invalid combination of opcode and operands
mov byte [ES:56], bl
;mov byte bl, [stacktop – 4]
;pop byte bl; nasm gives error: invalid combination of opcode and operands
pop bx; ‘E ‘
mov byte [ES:54], bl
;mov byte bl, [stacktop – 8]
;pop byte bl; nasm gives error: invalid combination of opcode and operands
pop bx; ‘W ‘
mov byte [ES:52], bl
;mov byte bl, [stacktop – 12]
;pop byte bl; nasm gives error: invalid combination of opcode and operands
pop bx; ‘E ‘
mov byte [ES:46], bl
;mov byte bl, [stacktop – 16]
;pop byte bl; nasm gives error: invalid combination of opcode and operands
pop bx; ‘P ‘
mov byte [ES:44], bl
;mov byte bl, [stacktop – 20]
;pop byte bl; nasm gives error: invalid combination of opcode and operands
pop bx; ‘O ‘
mov byte [ES:42], bl
;mov byte bl, [stacktop – 24]
;pop byte bl; nasm gives error: invalid combination of opcode and operands
pop bx; ‘H ‘
mov byte [ES:40], bl
; test datasegment
xor bl, bl
mov byte bl, [datasegment]
; mov byte bl, [0]
; mov byte bl, [DS:0]
mov byte [ES:20], bl
mov byte bl, [datasegment + 1]
; mov byte bl, [1]
mov byte [ES:22], bl
mov byte bl, [datasegment + 2]
; mov byte bl, [2]
mov byte [ES:24], bl
mov byte bl, [datasegment + 3]
; mov byte bl, [3]
mov byte [ES:26], bl
mov byte bl, [datasegment + 4]
; mov byte bl, [4]
mov byte [ES:28], bl
mov byte bl, [datasegment + 5]
; mov byte bl, [5]
mov byte [ES:30], bl
mov byte bl, [datasegment + 6]
; mov byte bl, [6]
mov byte [ES:32], bl
mov byte bl, [datasegment + 7]
; mov byte bl, [7]
mov byte [ES:34], bl
; mov byte [ES:16], [datasegment + 1]
; to use the stack, use “call” and “ret” instead of “jmp”
; or just let the program flows, without the jmp, to instructions that follow
;jmp exit
ret ; sayhello
;%macro OUTPUTHEXNUMBER 0
; following code for input/output numbers is from http://www.ece.msstate.edu/~janem/ECE3724/S03/Presentations/number_io.ppt
;Output an 8 bit number in Hex Format
;•Two Hex characters in 8-bits. Want to work with each set of 4-bits individually.
;•Each Hex character represents 4-bits in a number.
;◦0000 = ‘0’ (ASCII code = 30h)
;◦0001 = ‘1’ (ASCII code = 31h)
;◦1001 = ‘9’ (ASCII code = 39h)
;◦……
;◦1010 = ‘A’ (ASCII code = 41h)
;◦1011 = ‘B’ (ASCII code = 42h)
;◦……
;◦1111 = ‘F’ (ASCII code) = 46h ).
;•If 4-bits is between 0-9, then ASCII = 30h + 4bits
;•If 4-bits is between A-F, then ASCII = 37h + 4bits
;%macro DISPLAYREGISTERCHARACTERS 2 ; expects AL, DI loaded with appropriate values …
displaycharacter: ; expects AL, DI loaded with appropriate values …
; 4/27/2014 uses BX as scratch …
%ifdef TESTSAFEINSTRUCTIONS
SAFEPUSH word, BX
%else
push BX
%endif ; TESTSAFEINSTRUCTIONS
xor BL, BL
;mov byte BL, al ;
;; mov byte BL, %1 ; %1 = r/mm = register/memory containing character
mov byte BL, AL ; %1 = r/mm = register/memory containing character
;; mov byte [ES:300], BL ; ‘H ‘
mov byte [ES:DI], BL ; ‘H ‘ ; %2 = character screen position
%ifdef TESTSAFEINSTRUCTIONS
SAFEPOP word, BX
SAFERET ; displaycharacter
%else
pop BX
ret ; displaycharacter
%endif ; TESTSAFEINSTRUCTIONS
;%endmacro ; DISPLAYCHARACTER
;Displacement Base Index Scale
;no disp BX SI None
;8-bit disp BP DI
;16-bit disp
;%macro DISPLAYREGISTERCHARACTERS 2 ; expects AL, DI loaded with appropriate values …
displaycharacterhigh: ; expects AL, DI loaded with appropriate values …
; 4/27/2014 uses BX as scratch …
%ifdef TESTSAFEINSTRUCTIONS
SAFEPUSH word, BX
%else
push BX
%endif ; TESTSAFEINSTRUCTIONS
xor BH, BH
;mov byte BL, al ;
;; mov byte BL, %1 ; %1 = r/mm = register/memory containing character
mov byte BH, AH ; %1 = r/mm = register/memory containing character
;; mov byte [ES:300], BL ; ‘H ‘
mov byte [ES:DI], BH ; ‘H ‘ ; %2 = character screen position
%ifdef TESTSAFEINSTRUCTIONS
SAFEPOP word, BX
SAFERET ; displaycharacterhigh
%else
pop BX
ret ; displaycharacterhigh
%endif ; TESTSAFEINSTRUCTIONS
;%endmacro ; DISPLAYCHARACTER
; from http://faydoc.tripod.com/cpu/jmp.htm :
;Description
; Transfers program control to a different point in the instruction stream without recording return information. The destination (target) operand specifies the address of the instruction being jumped to. This operand can be an immediate value, a general-purpose register, or a memory location.
;
;This instruction can be used to execute four different types of jumps:
; Near jump A jump to an instruction within the current code segment (the segment currently pointed to by the CS register), sometimes referred to as an intrasegment jump.
; Short jump A near jump where the jump range is limited to –128 to +127 from the current EIP value.
; Far jump A jump to an instruction located in a different segment than the current code segment but at the same privilege level, sometimes referred to as an intersegment jump.
; Task switch A jump to an instruction located in a different task.
;
;A task switch can only be executed in protected mode (see Chapter 6, Task Management, in the Intel Architecture Software Developer’s Manual, Volume 3, for information on performing task switches with the JMP instruction).
;%macro OUT1HEXMACRO 1
out1hex:
; output value in ‘al’ as 1 hex character
; expects AL, DI loaded with appropriate values …
; 4/27/2014 uses BX as scratch …
cmp AL, 0x09 ; is 4-bit value above 9 – i.e. a “number” 0-9
;jg skip ; jg “jump if greater” is signed, ja “jump if above” is unsigned
;•If 4-bits is between A-F, then ASCII = 37h + 4bits
ja isCharacter ; if “greater than”, then must be a character
; ISCHARACTERMACRO %1 ; if “greater than”, then must be a character
add AL, 0x30 ;•If 4-bits is between 0-9, then ASCII = 30h + 4bits
%ifdef TESTSAFEINSTRUCTIONS
SAFECALL word, displaycharacter
%else
call displaycharacter
;DISPLAYREGISTERCHARACTERS AL, DI
%endif ; %ifdef TESTSAFEINSTRUCTIONS
jmp finishout1hex
;ret
;%endmacro ; OUT1HEXMACRO
out1hexhigh:
; output value in ‘ah’ as 1 hex character
; expects AL, DI loaded with appropriate values …
; 4/27/2014 uses BX as scratch …
cmp AH, 0x09 ; is 4-bit value above 9 – i.e. a “number” 0-9
;jg skip ; jg “jump if greater” is signed, ja “jump if above” is unsigned
;•If 4-bits is between A-F, then ASCII = 37h + 4bits
ja isCharacter ; if “greater than”, then must be a character
add AH, 0x30 ;•If 4-bits is between 0-9, then ASCII = 30h + 4bits
%ifdef TESTSAFEINSTRUCTIONS
SAFECALL word, displaycharacterhigh
%else
call displaycharacterhigh
;; DISPLAYREGISTERCHARACTERS AH, DI
%endif ; %ifdef TESTSAFEINSTRUCTIONS
;; ret ; or use jmp finishout1hex below
jmp finishout1hex
;%macro ISCHARACTERMACRO 1
isCharacter:
add AL, 0x37 ;•If 4-bits is between A-F, then ASCII = 37h + 4bits
%ifdef TESTSAFEINSTRUCTIONS
SAFECALL word, displaycharacter
%else
call displaycharacter
;DISPLAYREGISTERCHARACTERS AL, DI
%endif ; %ifdef TESTSAFEINSTRUCTIONS
jmp finishout1hex
finishout1hex:
%ifdef TESTSAFEINSTRUCTIONS
SAFERET ; ischaracter, out1hex, out1hexhigh
%else
ret ; ischaracter, out1hex, out1hexhigh
%endif ; TESTSAFEINSTRUCTIONS
;%endmacro ; ISCHARACTERMACRO
;%macro OUT2HEXMACRO 1
out2hex: ; output value in ‘al’ as 2 hex character
; expects AL, DI loaded with appropriate values …
; 4/27/2014 uses BX as scratch …
;push byte AL ; save al
;push word AX ; save al
;push dword EAX ; save al
%ifdef TESTSAFEINSTRUCTIONS
SAFEPUSH word, AX
%else
push AX ; save al
%endif ; TESTSAFEINSTRUCTIONS
shr AL, 4 ; get most sig. 4 bits into lower
;;mov DI, 300 ; screen position to print out character
%ifdef TESTSAFEINSTRUCTIONS
SAFECALL word, out1hex
%else
call out1hex ; print most sig. hex digit
; OUT1HEXMACRO %1 ; print most sig. hex digit
%endif ; %ifdef TESTSAFEINSTRUCTIONS
%ifdef TESTSAFEINSTRUCTIONS
SAFEPOP word, AX
%else
pop AX ; get back original al
%endif ; TESTSAFEINSTRUCTIONS
and AL, 0x0F ; upper 4 bits = 0 – working with low 4 bits
;;mov DI, 302 ; screen position to print out character
add DI, 2 ; move screen position one over
%ifdef TESTSAFEINSTRUCTIONS
SAFECALL word, out1hex
%else
call out1hex ; print least sig. hex digit
; OUT1HEXMACRO %1 + 1 ; print least sig. hex digit
%endif ; %ifdef TESTSAFEINSTRUCTIONS
%ifdef TESTSAFEINSTRUCTIONS
SAFERET ; out2hex
%else
ret ; out2hex
%endif ; TESTSAFEINSTRUCTIONS
;%endmacro ; OUT2HEXMACRO
out4hex: ; output value in ‘ax’ as 2 hex character
;out16bithex: ; output value in ‘ax’ as 2 hex character
%ifdef TESTSAFEINSTRUCTIONS
SAFEPUSH word, AX
%else
; push AX ; save ax, ah, al
push AX ; save ax, ah, al
%endif ; TESTSAFEINSTRUCTIONS
shr AH, 4 ; get most sig. 4 bits into lower
%ifdef TESTSAFEINSTRUCTIONS
SAFECALL word, out1hexhigh
%else
; OUT1HEXMACRO %1 ; print most sig. hex digit
call out1hexhigh ; print most sig. hex digit
%endif ;%ifdef TESTSAFEINSTRUCTIONS
%ifdef TESTSAFEINSTRUCTIONS
SAFEPOP word, AX
%else
pop AX ; get back original ax, ah, al
%endif ; TESTSAFEINSTRUCTIONS
and AH, 0x0F ; upper 4 bits = 0 – working with low 4 bits
;;mov DI, 302 ; screen position to print out character
add DI, 2 ; move screen position one over
%ifdef TESTSAFEINSTRUCTIONS
SAFECALL word, out1hexhigh
%else
call out1hexhigh ; print least sig. hex digit
%endif ;%ifdef TESTSAFEINSTRUCTIONS
; OUT1HEXMACRO %1 + 1 ; print least sig. hex digit
%ifdef TESTSAFEINSTRUCTIONS
SAFEPUSH word, AX
%else
push AX ; save ax, ah, al
%endif ; TESTSAFEINSTRUCTIONS
shr AL, 4 ; get most sig. 4 bits into lower
%ifdef TESTSAFEINSTRUCTIONS
SAFECALL word, out1hex
%else
call out1hex ; print most sig. hex digit
%endif ; TESTSAFEINSTRUCTIONS
%ifdef TESTSAFEINSTRUCTIONS
SAFEPOP word, AX
%else
pop AX ; get back original al
%endif ; TESTSAFEINSTRUCTIONS
and AL, 0x0F ; upper 4 bits = 0 – working with low 4 bits
;;mov DI, 302 ; screen position to print out character
add DI, 2 ; move screen position one over
%ifdef TESTSAFEINSTRUCTIONS
SAFECALL word, out1hex
%else
call out1hex ; print least sig. hex digit
; OUT1HEXMACRO %1 + 1 ; print least sig. hex digit
%endif ; %ifdef TESTSAFEINSTRUCTIONS
%ifdef TESTSAFEINSTRUCTIONS
SAFERET ; out4hex
%else
ret ; out4hex
%endif ; TESTSAFEINSTRUCTIONS
;out32bithex:
; push EAX ; save EAX
; shr EAX, 16 ; get the most sig. 16 bits into lower
; call out4hex ;
; pop EAX ; restore EAX
; ;push EAX ; save EAX
; call out4hex
; ;pop EAX ; restore EAX
; ret ; out4hex
;%endmacro ; OUTPUTHEXNUMBER
; test interrupt-support stack boundaries
; from http://www.eecg.toronto.edu/~amza/www.mindsec.com/files/x86regs.html
;SS:EBP EBP BP : Stack Base pointer register
; Holds the base address of the [current] stack [frame]
;SS:ESP ESP SP : Stack pointer register
; Holds the top address of the stack
; from NASM manual:
;4.3 Multi-Line Macros: %macro
;Multi-line macros are much more like the type of macro seen in MASM and TASM: a multi-line macro definition in NASM looks something like this.
;%macro prologue 1
; push ebp
; mov ebp,esp
; sub esp,%1
;%endmacro
; from Programmer’s Reference Manual:
;1.The stack pointer (ESP) register. ESP points to the top of the push-down stack (TOS). It is referenced implicitly by PUSH and POP operations, subroutine calls and returns, and interrupt operations. When an item is pushed onto the stack (see Figure 2-7 ), the processor decrements ESP, then writes the item at the new TOS. When an item is popped off the stack, the processor copies it from TOS, then increments ESP. In other words, the stack grows down in memory toward lesser addresses.
; BOUND instruction:
;62 /r BOUND r16,m16&16 10 Check if r16 is within bounds
; (passes test)
;62 /r BOUND r32,m32&32 10 Check if r32 is within bounds
; (passes test)
;IF (LeftSRC [RightSRC + OperandSize/8])
; (* Under lower bound or over upper bound *)
;THEN Interrupt 5;
;FI;
; note: because “int #” instruction will use stack to store CS:IP and FLAGS,
; Push (FLAGS);
; Push(CS);
; Push(IP);
; have to allow on the stack for that much room 32 bits + 32 bits = 4 bytes + 4 bytes …
; from Programmer’s Reference Manual for INT instruction:
; REAL-ADDRESS-MODE:
; Push (FLAGS);
; IF = 0; (* Clear interrupt flag *)
; TF = 0; (* Clear trap flag *)
; Push(CS);
; Push(IP);
; (* No error codes are pushed *)
; CS := IDT[Interrupt number * 4].selector;
; IP := IDT[Interrupt number * 4].offset;
; from Programmer’s Reference Manual
; IRET (Return From Interrupt) returns control to an interrupted procedure. IRET differs from RET in that it also pops the flags from the stack into the flags register. The flags are stored on the stack by the interrupt mechanism.
%endif ; SAYHELLO
; SAFEWAY grocery …
;;%macro SAFECALL 1
; cmp SP, stacksegment
; jl safecallinterrupt
; safecallinterrupt int 5
;; bound SP, wstacklowerbound + 4 + 4 ;
;; call %1
;;%endmacro
;;%macro SAFEPUSH 1
; cmp SP, stacksegment
; jl safecallinterrupt
; safepushinterrupt int 5
;; bound SP, wstacklowerbound + 4 + 4 ;
;; push %1
;;%endmacro
;;%macro SAFEPOP 1
; cmp SP, stacksegment
; jl safecallinterrupt
; safepopinterrupt int 5
;; bound SP, wstacklowerbound + 4 + 4 ;
;; pop %1
;;%endmacro
;;%macro SAFERET 1
; cmp SP, stacksegment
; jl safecallinterrupt
; saferetinterrupt int 5
;; bound SP, wstacklowerbound + 4 + 4 ;
;; ret %1
;;%endmacro
; from http://www.mactech.com/macintosh-c/classic-chap01-1.html
; Macintosh Protection mechanism for the stack: “… every sixtieth of a second an Operating System task checks whether the stack has moved into the heap. If it has, the task, known as the stack sniffer, generates a system error …”
; Intel implements push-pop-able stack data structures such as IDT, GDT etc. defining limits for protection purposes …
; from Programmer’s Reference Manual
;6.2 Overview of 80386 Protection Mechanisms
;Protection in the 80386 has five aspects: 1. Type checking
;2. Limit checking
;3. Restriction of addressable domain
;4. Restriction of procedure entry points
;5. Restriction of instruction set
;The protection hardware of the 80386 is an integral part of the memory management hardware. Protection applies both to segment translation and to page translation.
;Each reference to memory is checked by the hardware to verify that it satisfies the protection criteria. All these checks are made before the memory cycle is started; any violation prevents that cycle from starting and results in an exception. Since the checks are performed concurrently with address formation, there is no performance penalty.
;Invalid attempts to access memory result in an exception. Refer to Chapter 9 for an explanation of the exception mechanism . The present chapter defines the protection violations that lead to exceptions.
;The concept of “privilege” is central to several aspects of protection (numbers 3, 4, and 5 in the preceeding list). Applied to procedures, privilege is the degree to which the procedure can be trusted not to make a mistake that might affect other procedures or data. Applied to data, privilege is the degree of protection that a data structure should have from less trusted procedures.
;The concept of privilege applies both to segment protection and to page protection.
;%macro SAFEINT5 0
; my/your own custom interrupt 5 service routine
safeinterrupt5sr:
;cmp byte [winterrupt5count], 1
;je safeinterrupt5return
;mov byte [bwasinterrupted], 1
;add byte [winterrupt5count], 1
add word [winterrupt5count], 1
%define WHATISBP
%ifdef WHATISBP
; from Programmer’s Reference Manual
; CMP (Compare) subtracts the source operand from the destination operand. It updates OF, SF, ZF, AF, PF, and CF but does not alter the source and destination operands. A subsequent Jcc or
cmp BP, 0
jne bpisnotzero
bpiszero:
mov byte [ES:360], ‘0’
jmp donecomparingbp
bpisnotzero:
cmp BP, 0
;jl bpislessthanzero ; ; using jl will branch to give ‘L’, implying bpislessthanzero
;mov byte [ES:362], ‘G’
jb bpislessthanzero ; ; using jb will give ‘A’, implying bp is greater than zero
mov byte [ES:362], ‘A’
jmp donecomparingbp
bpislessthanzero:
;mov byte [ES:364], ‘L’
mov byte [ES:364], ‘B’
jmp donecomparingbp
donecomparingbp:
;hlt ; comment in to debug
nop
%endif ; WHATISBP
; because “bound” instruction uses “signed” values [jl vs. jb in WHATISBP test above] absolute lower bound is not “0” …
; … something to do with “two-complements” and “sign extension” … http://en.wikipedia.org/wiki/Signed_number_representations …
; from Pavel Šimerda website pavlix.net in Prague, Czech Republic @ http://stackoverflow.com/questions/19464202/how-does-c-complier-handle-unsigned-and-signed-integer-why-the-assembly-code-fo
;It’s quite easy. Operations like addition and subtraction don’t need any adjustment for signed types in two’s complement arithmetic. Just perform a mind experiment and imagine an algorithm using just the following mathematical operations:
;•increment by one
;•decrement by one
;•compare with zero
;Addition is just taking items one by one from one heap and putting them to the other heap until the first one is empty. Subtraction is taking from both of them at once, until the subtracted one is empty. In modular arithmetics, you just just treat the smallest value as the largest value plus one and it works. Two’s complement is just a modular arithmetic where the smallest value is negative.
;If you want to see any difference, I recommend you to try operations that aren’t safe with respect to overflow. One example is comparison (a < b).
; from http://en.wikipedia.org/wiki/Signed_number_representations
; Two's complement is the easiest to implement in hardware, which may be the ultimate reason for its widespread popularity[citation needed]. Processors on the early mainframes often consisted of thousands of transistors – eliminating a significant number of transistors was a significant cost savings. Mainframes such as the IBM System/360, the GE-600 series,[1] and the PDP-6 and PDP-10 used two's complement, as did minicomputers such as the PDP-5 and PDP-8 and the PDP-11 and VAX. The architects of the early integrated circuit-based CPUs (Intel 8080, etc.) chose to use two's complement math. As IC technology advanced, virtually all adopted two's complement technology. x86,[2] m68k, Power Architecture,[3] MIPS, SPARC, ARM, Itanium, PA-RISC, and DEC Alpha processors are all two's complement.
; NOTE: of course, the address of the top and bottom of the stack and of the SP pointer could be converted to "signed array indices" for use by "bound" instruction …
; for example: let stacksegment have index 0, stacktop has index = stacksize, and SP has index = SP – stacksegment within the range [0, stacksize]
;sub BP, stacksegment
;bound BP, [wstacklowerbound] ; wstacklowerbound = 0, wstackupperbound = stacksize
mov [wbasepointer], BP
;%define FIXNOBOUNDS
;%define FIXBOUNDSUSINGABSOLUTEBOUNDS
%define FIXOUNDSUSINGRELATIVEBOUNDS
%ifdef FIXBOUNDSUSINGABSOLUTEBOUNDS
%ifdef USESIGNEDARRAYINDEXFORSTACKBOUNDS
mov word [wboundlowerbound], 0
mov word [wboundupperbound], stacksize
%else
;mov word [wboundlowerbound], 0 ; set [cannot-be-exceeded absolute] lower bound for "bound" instruction so that "iret" from "bound" instruction will not cause infinite loop …
mov word [wboundlowerbound], -32767 ; set [cannot-be-exceeded absolute] lower bound for "bound" instruction so that "iret" from "bound" instruction will not cause infinite loop …
;mov word [wboundupperbound], 32767 ; set [cannot-be-exceeded absolute] upper bound for "bound" instruction so that "iret" from "bound" instruction will not cause infinite loop …
mov word [wboundupperbound], 65535 ; set [cannot-be-exceeded absolute] upper bound for "bound" instruction so that "iret" from "bound" instruction will not cause infinite loop …
%endif ; USESIGNEDARRAYINDEXFORSTACKBOUNDS
%elif FIXBOUNDSUSINGRELATIVEBOUNDS
%ifdef USESIGNEDARRAYINDEXFORSTACKBOUNDS
; globals wboundlowerbound and wboundupperbound can be kept for re-use by another "bound" instruction test, SP itself will not be changed, BP is "scratched" …
;mov word [wboundlowerbound], BP-1 ; set [relatively lower] lower bound for "bound" instruction so that it will so that "iret" from "bound" instruction will not cause infinite loop …
;mov word [wboundupperbound], BP+1 ; set [relatively lower] upper bound for "bound" instruction so that it will so that "iret" from "bound" instruction will not cause infinite loop …
;mov word BP, [wboundupperbound] – 1 ; set BP so that it will be [relatively lower] than upper bound for "bound" instruction so that it will so that "iret" from "bound" instruction will not cause infinite loop …
;mov word BP, [wboundlowerbound] + 1 ; set BP so that it will be [relatively higher] than lower bound for "bound" instruction so that it will so that "iret" from "bound" instruction will not cause infinite loop …
testandchangeBPlowerbound:
cmp BP, [wboundlowerbound]
jg testandchangeBPupperbound
mov BP, [wboundlowerbound]
add BP, 1
testandchangeBPupperbound:
cmp BP, [wboundupperbound]
jl exitchangeBP
mov BP, [wboundupperbound]
sub BP, 1
exitchangeBP:
%else
; 4/27/2014 this program uses BP with instruction bound: bound BP, [wboundlowerbound] ; valid for NASM ; < 20
; globals wboundlowerbound and wboundupperbound can be kept for re-use by another "bound" instruction test, SP itself will not be changed, BP is "scratched" …
;mov word [wboundlowerbound], BP-1 ; set [relatively lower] lower bound for "bound" instruction so that it will so that "iret" from "bound" instruction will not cause infinite loop …
;mov word [wboundupperbound], BP+1 ; set [relatively lower] upper bound for "bound" instruction so that it will so that "iret" from "bound" instruction will not cause infinite loop …
;mov word BP, [wboundupperbound] – 1 ; set BP so that it will be [relatively lower] than upper bound for "bound" instruction so that it will so that "iret" from "bound" instruction will not cause infinite loop …
;mov word BP, [wboundlowerbound] + 1 ; set BP so that it will be [relatively higher] than lower bound for "bound" instruction so that it will so that "iret" from "bound" instruction will not cause infinite loop …
testandchangeBPlowerbound:
cmp BP, [wboundlowerbound]
jg testandchangeBPupperbound
mov BP, [wboundlowerbound]
add BP, 1
testandchangeBPupperbound:
cmp BP, [wboundupperbound]
jl exitchangeBP
mov BP, [wboundupperbound]
sub BP, 1
exitchangeBP:
%endif ; USESIGNEDARRAYINDEXFORSTACKBOUNDS
%elif FIXNOBOUNDS
%endif ; USEABSOLUTEBOUNDS
; from http://en.wikipedia.org/wiki/16-bit
; A 16-bit integer can store 216 (or 65,536) distinct values. In an unsigned representation, these values are the integers between 0 and 65,535; using two's complement, possible values range from −32,768 to 32,767. Hence, a processor with 16-bit memory addresses can directly access 64 KiB of byte-addressable memory.
;push bx
;push ax
;xor bl, bl
xor al, al
; mov byte bl, [stacktop – 4 * 2 + 2] ; four routines were called: call main, call screensetup, call clearscreenpixels, call sayhello of which only two routines were left opened on the stack by the time this point is reached
;mov byte bl, 'I' ; four routines were called: call main, call screensetup, call clearscreenpixels, call sayhello of which only two routines were left opened on the stack by the time this point is reached
mov byte al, 'I' ; four routines were called: call main, call screensetup, call clearscreenpixels, call sayhello of which only two routines were left opened on the stack by the time this point is reached
;pop byte bl; nasm gives error: invalid combination of opcode and operands
;pop bx;
;mov byte [ES:90], bl ; 'I '
mov byte [ES:90], al ; 'I '
;mov byte bl, 'N' ; four routines were called: call main, call screensetup, call clearscreenpixels, call sayhello of which only two routines were left opened on the stack by the time this point is reached
mov byte al, 'N' ; four routines were called: call main, call screensetup, call clearscreenpixels, call sayhello of which only two routines were left opened on the stack by the time this point is reached
;mov byte [ES:92], bl ; 'N '
mov byte [ES:92], al ; 'N '
;mov byte bl, 'T' ; four routines were called: call main, call screensetup, call clearscreenpixels, call sayhello of which only two routines were left opened on the stack by the time this point is reached
mov byte al, 'T' ; four routines were called: call main, call screensetup, call clearscreenpixels, call sayhello of which only two routines were left opened on the stack by the time this point is reached
;mov byte [ES:94], bl ; 'T '
mov byte [ES:94], al ; 'T '
;mov byte bl, '5' ; four routines were called: call main, call screensetup, call clearscreenpixels, call sayhello of which only two routines were left opened on the stack by the time this point is reached
mov byte al, '5' ; four routines were called: call main, call screensetup, call clearscreenpixels, call sayhello of which only two routines were left opened on the stack by the time this point is reached
;mov byte [ES:96], bl ; '5 '
mov byte [ES:96], al ; '5 '
;mov al, [winterrupt5count]
mov ax, [winterrupt5count] ; print out interrupt5count
mov DI, 100 ; screen position to print out character
%ifdef TESTSAFEINSTRUCTIONS
SAFECALL word, out2hex
%else
call out2hex
%endif ; %ifdef TESTSAFEINSTRUCTIONS
mov al, [bnumberofpushrequired] ; print out number of push required ..
mov DI, 104 ; screen position to print out character
%ifdef TESTSAFEINSTRUCTIONS
SAFECALL word, out2hex
%else
call out2hex
%endif ; %ifdef TESTSAFEINSTRUCTIONS
%ifdef USESIGNEDARRAYINDEXFORSTACKBOUNDS
;mov al, [wbasepointer]
mov AX, BP ; print out the altered BP …
mov DI, 110 ; screen position to print out character
%ifdef TESTSAFEINSTRUCTIONS
SAFECALL word, out2hex
%else
call out2hex
%endif ; %ifdef TESTSAFEINSTRUCTIONS
%endif ; %ifdef USESIGNEDARRAYINDEXFORSTACKBOUNDS
;OUT2HEXMACRO 100
safeinterrupt5return:
; pop bx
; from Programmer's Reference Manual
; IRET (Return From Interrupt) returns control to an interrupted procedure. IRET differs from RET in that it also pops the flags from the stack into the flags register. The flags are stored on the stack by the interrupt mechanism.
%ifdef TESTSAFEINSTRUCTIONS
SAFEIRET
%else
;ret
iret
%endif ; TESTSAFEINSTRUCTIONS
;%endmacro ; SAFEINT5
;%macro SAFEINT9 0
; my/your own custom interrupt 9 service routine
safeinterrupt9sr:
add byte [binterrupt9count], 1
xor bl, bl
; mov byte bl, [stacktop – 4 * 2 + 2] ; four routines were called: call main, call screensetup, call clearscreenpixels, call sayhello of which only two routines were left opened on the stack by the time this point is reached
mov byte bl, 'I' ; four routines were called: call main, call screensetup, call clearscreenpixels, call sayhello of which only two routines were left opened on the stack by the time this point is reached
;pop byte bl; nasm gives error: invalid combination of opcode and operands
;pop bx;
mov byte [ES:130], bl ; 'I '
mov byte bl, 'N' ; four routines were called: call main, call screensetup, call clearscreenpixels, call sayhello of which only two routines were left opened on the stack by the time this point is reached
mov byte [ES:132], bl ; 'N '
mov byte bl, 'T' ; four routines were called: call main, call screensetup, call clearscreenpixels, call sayhello of which only two routines were left opened on the stack by the time this point is reached
mov byte [ES:134], bl ; 'T '
mov byte bl, '9' ; four routines were called: call main, call screensetup, call clearscreenpixels, call sayhello of which only two routines were left opened on the stack by the time this point is reached
mov byte [ES:136], bl ; '9 '
mov al, [binterrupt9count]
mov DI, 140 ; screen position to print out character
%ifdef TESTSAFEINSTRUCTIONS
SAFECALL word, out2hex
%else
call out2hex
;OUT2HEXMACRO 120
%endif ; %ifdef TESTSAFEINSTRUCTIONS
%ifdef TESTSAFEINSTRUCTIONS
SAFECALL word, safeinterrupt9sr2
%else
call safeinterrupt9sr2
%endif ; %ifdef TESTSAFEINSTRUCTIONS
; from Programmer's Reference Manual
; IRET (Return From Interrupt) returns control to an interrupted procedure. IRET differs from RET in that it also pops the flags from the stack into the flags register. The flags are stored on the stack by the interrupt mechanism.
%ifdef TESTSAFEINSTRUCTIONS
SAFEIRET
%else
;ret
iret
%endif ; TESTSAFEINSTRUCTIONS
;%endmacro ; SAFEINT9
;%macro SAFEINT9 0
;keyboard input …
;for the screen, the messages in ("muo^n loa`i" “I read all of Intel x86(32bit) programmers manual, but did not found the magic number 0x7C00.”
;Yes. ”0x7C00 is NOT related to x86 CPU” . It’s natural that you couldn’t find out it in cpu specifications from intel. Then, you wonder, “Who decided it ?”
;”2nd” , you may wonder:
;>”0x7C00 is 32KiB – 1024B at decimal number. What’s this number means ?”
;Anyone decided it. But, why he/she decided such a halfway address?
;Hum…There’re TWO questions(mysteries) arround the magic number “0x7C00”.
;+ Who decided “0x7C00” ?
;+ What “0x7C00 = 32KiB – 1024B” means ?
;Okay, let’s dive into the secret of BIOS for “IBM PC 5150”, ancestor of modern x86(32bit) PCs, with me…!!
;#more||
;* “0x7C00″ First appeared in IBM PC 5150 ROM BIOS INT 19h handler.
;Wandering arround the history of x86 IBM Compatible PC, you know ”IBM PC 5150” is the ancestor of modern x86(32bit) IBM PC/AT Compatible PCs.
;This PC was released at 1981 August, with Intel 8088(16bit) and 16KiB RAM(for minimum memory model). BIOS and Microsoft BASIC was stored in ROM.
;When power on, BIOS processes “POST”(Power On Self Test) procedure, and after, ”call INT 19h” .
;In INT 19h handler, BIOS checks that PC has any of floppy/hard/fixed diskette or not have.
;If PC has any of available diskkete, BIOS loads a first sector(512B) of diskette into 0x7C00.
;Now, you understand why you couldn’t find out this magic number in x86 documents. ”This magic number belongs to BIOS specification.”
;* The origin of 0x7C00
;Stories surrounding IBM PC DOS, Microsoft, and SCP’s 86-DOS are famous stories. See: [[“A Short History of MS-DOS”>http://www.patersontech.com/dos/Byte/History.html%5D%5D.
;SCP’s “86-DOS”(at 1980) is the reference OS for IBM PC DOS 1.0.
;86-DOS(early called “QDOS”) is CP/M compatible OS for 8086/8088 cpu. At 1979, Digital Research Inc didn’t have developed CP/M for 8086/8088 cpu yet.
;SCP sold two S-100 bus board, one is 8086 CPU board, two is “CPU Monitor” rom board.
;”CPU Monitor” program provided bootloader and debugger. ”This “CPU Monitor” bootloader loaded MBR into “0x200”, NOT “0x7C00″” . In 1981, IBM PC DOS was the NEXT CP/M like OS for 8086/8088.
;So, I told you that “0x7C00 ”FIRST appeared” in IBM PC 5150 ROM BIOS”.
;Previous one, SCP’s CPU Monitor bootloader loads into 0x200, not 0x7C00.
;** Why that CPU Monitor’s bootloader loeded MBR into “0x200” ?
;There’re THREE reasons about “0x200”.
;+ 8086 Interrupts Vector use 0x0 – 0x3FF.
;+ 86-DOS was loaded from 0x400.
;+ 86-DOS didn’t use interrupts vectors between 0x200 – 0x3FF.
;These reasons mean 0x200 – 0x3FF needed to be reserved and couldn’t be in the way of an OS, no matter where 86-DOS or user application wanted to load.
;So Tim Paterson (86-DOS developer) chose 0x200 for MBR load address.
;* Q:Who decided “0x7C00″ ? – A: IBM PC 5150 BIOS Developer Team.
;”0x7C00” was decided by IBM PC 5150 BIOS developer team (Dr. David Bradley).
;As mentioned above, this magic number was born at 1981 and “IBM PC/AT Compat” PC/BIOS vendors did not change this value for BIOS and OS’s backward compatibility.
;Not Intel(8086/8088 vendor) nor Microsoft(OS vendor) decided it.
;* Q:What “0x7C00 = 32KiB – 1024B” means ? A: Affected by OS requirements and CPU memory layout.
;IBM PC 5150 minimum memory model had only 16KiB RAM. So, you may have a question.
;>”Could minimum memory model (16KiB) load OS from diskette ? BIOS loads MBR into 32KiB – 1024B address, but physical RAM is not enough…”
;No, that case was ”out of consideration” . One of IBM PC 5150 ROM BIOS Developer Team Members, Dr. David Bradley says:
;>”DOS 1.0 required a minimum of 32KB, so we weren’t concerned about attempting a boot in 16KB.”
;(Note: DOS 1.0 required 16KiB minimum ? or 32KiB ? I couldn’t find out which correct. But, at least, in 1981’s early BIOS development, they supposed that 32KiB is DOS minimum requirements.)
;BIOS developer team decided 0x7C00 because:
;+ They wanted to leave as much room as possible for the OS to load itself within the 32KiB.
;+ 8086/8088 used 0x0 – 0x3FF for interrupts vector, and BIOS data area was after it.
;+ The boot sector was 512 bytes, and stack/data area for boot program needed more 512 bytes.
;+ So, 0x7C00, the last 1024B of 32KiB was chosen.
;
;Once OS loaded and started, boot sector is never used until power reset. So, OS and application can use the last 1024B of 32KiB freely.
;After OS loaded, memory layout will be:
;#pre||>
;+——————— 0x0
;| Interrupts vectors
;+——————— 0x400
;| BIOS data area
;+——————— 0x5??
;| OS load area
;+——————— 0x7C00
;| Boot sector
;+——————— 0x7E00
;| Boot data/stack
;+——————— 0x7FFF
;| (not used)
;+——————— (…)
;||<
;That are the origin and reasons of "0x7C00", the magic number survived for about three decades in PC/AT Compat BIOS INT 19h handler.
;* References
;86-DOS related:
;- "8086 Monitor Instruction Manual"(MON 86 – V1.4)
;- "86-DOS(TM) User's Manual Version 0.3"
;- "86-DOS(TM) Programmer's Manual Version 0.3"
;- "86-DOS(TM) Instruction Manual Version ??"
;IBM PC 5150 related:
;- "IBM Personal Computer Hardware Reference Library", "Technical Reference" (IBM Personal Computer Technical Reference manual)
;- "IBM Personal Computer XT Hardware Reference Library", "Technical Reference" (IBM Personal Computer XT Technical Reference manual)
;Intel 8086/8088 data sheets:
;- "8086 16-BIT HMOS MICROPROCESSOR"
;- "M80C86/M80C86-2 16-BIT CHMOS MICROPROCESSOR"
;- "8088 8-BIT HMOS MICROPROCESSOR"
;CP/M related:
;- The Unofficial CP/M Web Site
;– http://www.cpm.z80.de/
;- CP/M Internals : Oscar Vermeulen Personal Web Site
;– http://www.dcast.vbox.co.uk/cpm.html
;- Digital Research – CP/M
;– http://www.digitalresearch.biz/CPM.HTM
;- CP/M Main Page
;– http://www.seasip.demon.co.uk/Cpm/
;86-DOS related:
;- Origins of DOS – Paterson Technology
;– http://www.patersontech.com/dos/
;- 86-DOS Resource Website
;– http://www.86dos.org/index.htm
;- DosMan Drivel
;– http://dosmandrivel.blogspot.com/
;And all related Wikipedia pages.
;* Special Thanks To…
;Special Thanks To:
;- Tim Peterson
;- David Bradley
;for japanese article, see:
;"Assembler/なぜx86ではMBRが"0x7C00"にロードされるのか？(完全版)"
;http://www.glamenv-septzen.net/view/614
;NOTE:
; from arpaci dusseau http://pages.cs.wisc.edu/~remzi/OSTEP/vm-segmentation.pdf
;an idea was born, and it is called segmenta-
;tion. It is quite an old idea, going at least as far back as the very early
;1960’s [H61, G62]. The idea is simple: instead of having just one base
;and bounds pair in our MMU, why not have a base and bounds pair per
;logical segment of the address space?
;[G62] “Fact Segmentation”
;M. N. Greenfield
;Proceedings of the SJCC, Volume 21, May 1962
;Another early paper on segmentation; so early that it has no references to other work.
;[H61] “Program Organization and Record Keeping for Dynamic Storage”
;A. W. Holt
;Communications of the ACM, Volume 4, Issue 10, October 1961
;An incredibly early and difficult to read paper about segmentation and some of its uses.
; from http://en.wikipedia.org/wiki/THE_multiprogramming_system
; The THE multiprogramming system was a computer operating system designed by a team led by Edsger W. Dijkstra, described in monographs in 1965-66[1] and published in 1968.[2] Dijkstra never named the system; "THE" is simply the abbreviation of "Technische Hogeschool Eindhoven", then the name (in Dutch) of the Eindhoven University of Technology of the Netherlands. The THE system was primarily a batch system[3] that supported multitasking; it was not designed as a multi-user operating system. It was much like the SDS 940, but "the set of processes in the THE system was static".[3]
;The THE system apparently introduced the first forms of software-based memory segmentation (the Electrologica X8 did not support hardware-based memory management),[3] freeing programmers from being forced to use actual physical locations on the drum memory. It did this by using a modified ALGOL compiler (the only programming language supported by Dijkstra's system) to "automatically generate calls to system routines, which made sure the requested information was in memory, swapping if necessary".[3]
; from http://www.oocities.org/timessquare/2795/Files/asmtut.txt
;The problem is to access a whole
;megabyte 20 bits are needed. Registers only have 16 bits and they
;didn't want to use two because that would be 32 bits and they
;thought that this would be too much for anyone. They came up with
;what they thought was a clever way to solve this problem: segments
;and offsets. This is a way to do the addressing with two registers
;but not 32 bits.
;OFFSET = SEGMENT * 16
;SEGMENT = OFFSET / 16 (the lower 4 bits are lost)
;One register contains the segment and another register contains the
;offset. If you put the two registers together you get a 20-bit
;address.
;SEGMENT 0010010000010000—-
;OFFSET —-0100100000100010
;20-bit Address 00101000100100100010
; ====== DS ======
; ====== SI ======
;Notice that DS and SI overlap. This is how DS:SI is used to make a
;20 bit address. The segment is in DS and the offset is in SI. The
;standard notation for a Segment/Offset pair is: SEGMENT:OFFSET
; from NASM manual:
;NASM gives special treatment to symbols beginning with a period. A label beginning with a single period is treated as a local label, which means that it is associated with the previous non-local label. So, for example:
;label1 ; some code
;.loop
; ; some more code
; jne .loop
; ret
;label2 ; some code
;.loop
; ; some more code
; jne .loop
; ret
;In the above code fragment, each JNE instruction jumps to the line immediately before it, because the two definitions of .loop are kept separate by virtue of each being associated with the previous non-local label.
;from http://wiki.osdev.org/Interrupts
; if IRQ 6 is sent to the PIC by a device, the PIC would tell the CPU to service INT 0Eh, which presumably has code for interacting with whatever device sent the interrupt in the first place. Of course, there can be trouble when two or more devices share an IRQ; if you wonder how this works, check out Plug and Play.
; from http://www.techmasala.com/2006/03/31/foundation-stone-3-bios-part-2-the-interrupt-vector-table/:
;Foundation stone #3 – BIOS part 2 – The interrupt vector table
;by Ramesh on Friday,March 31, 2006 @ 9:50 am
;In my post Foundation stone #2 we saw that BIOS is the one that takes in charge when you switch on your PC. After collecting the inventory of available and properly working hardware, the BIOS sets up what is called as the Interrupts area. An interrupt is a signal to the processor that there is something that needs its attention. As such each and every piece of hardware that is put together in your PC is useless unless it is orchestrated well. Take for example the keyboard, if the attention is not given at the right time when you press a key and reciprocated accordingly wherever you are then you can call the thing that is sitting in front of you as dumb
;So when the BIOS is done with the inventory of hardware, it initializes a memory space of 1024 bytes starting at 0000:0000h (this is a representation of memory location in the form of segment:offset in hexadecimal). An interrupt is a small routine or code that has the necessary details of the interrupt and occupies 4 bytes. So starting at memory location 0000:0000h interrupts are stored. So a total of 256 interrupts can be stored in a the allotted 1024 bytes but all is not being initialized by the BIOS. There are different types of interrupts, hardware interrupts, software interrupts, user interrupts and so on. The BIOS fills up the hardware interrupts and the software interrupts are mostly added by the OS.
;The Interrupt Vector Table (IVT) is a mapping of the interrupt number and the memory location in the form of segment:offset. This memory location contains the interrupt code for that particular interrupt. It is the responsibility of the OS to keep track of the IVT and monitor for interrupt and notify the processor. So what happens when you press a key or release a key, the keyboard send signals that contain information on what key was pressed or released. This gets stored in the memory location assigned for the keyboard interrupt (traditionally interrupt 09h is for keyboard). The OS which is constantly looking for these interrupts immediately captures the information and sends it for processing accordingly. The interrupt number and other details could differ from one BIOS manufacturer to other. You can get a lot of information about BIOS and interrupts from the BIOS central site.
; conventionally [c.f. http://en.wikipedia.org/wiki/Conventional_memory, http://en.wikipedia.org/wiki/Power-on_self-test%5D people agree upon the following memory map … from http://www.supernovah.com/Tutorials/Assembly2.php:
;Default Memory
;When the computer boots, the BIOS loads the memory with a lot of different data. This data resides in different places throughout memory and we are only left with 630Kb of memory to work with in the middle of everything. Here is a table showing the map of the memory directly after the computer boots:
;All ranges are inclusive
;Address Range (in hex) Size Type Description
;0 – 3FF 1Kb Ram Real Mode Interrupt Vector Table (IVT)
;400 – 4FF 256 bytes Ram BIOS Data Area (BDA)
;500 – 9FBFF 630Kb Ram Free Memory
;9FC00 – 9FFFF 1Kb Ram Extended BIOS Area (EBDA)
;A0000 – BFFFF 128Kb Video Ram VGA Frame Buffer
;C0000 – C7FFF 32Kb Rom Video Bios
;C8000 – EFFFF 160kb Rom Misc.
;F0000 – FFFFF 64Kb
; from NASM manual
;Multi-line macros are much more like the type of macro seen in MASM and TASM: a multi-line macro definition in NASM looks something like this.
;%macro prologue 1
; push ebp
; mov ebp,esp
; sub esp,%1
;%endmacro
; from http://www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm:
;The SHR/SLR instructions
;format:
;SHR destination,1
;SHR destination,CL
; SHL destination,1
; SHL destination,CL
;SHR shifts the destination right bitwise either 1 position or a number of positions determined by the current value of the CL register. SHL shifts the destination left bitwise either 1 position or a number of positions determined by the current value of the CL register. The vacant positions are filled by zeros.
;example:
;shr ax,1
; shl ax,1
;The first example effectively divides ax by 2 and the second example effectively multiplies ax by 2. These commands are faster than using DIV and MUL for arithmetic involving powers of 2.
;****************************
; from Intel Programmer's Reference Manual
;10.1 Processor State After Reset
;The contents of EAX depend upon the results of the power-up self test. The self-test may be requested externally by assertion of BUSY# at the end of RESET. The EAX register holds zero if the 80386 passed the test. A nonzero value in EAX after self-test indicates that the particular 80386 unit is faulty. If the self-test is not requested, the contents of EAX after RESET is undefined.
;DX holds a component identifier and revision number after RESET as Figure 10-1 illustrates. DH contains 3, which indicates an 80386 component. DL contains a unique identifier of the revision level.
;Control register zero (CR0) contains the values shown in Figure 10-2 . The ET bit of CR0 is set if an 80387 is present in the configuration (according to the state of the ERROR# pin after RESET). If ET is reset, the configuration either contains an 80287 or does not contain a coprocessor. A software test is required to distinguish between these latter two possibilities.
;The remaining registers and flags are set as follows:
; EFLAGS =00000002H
; IP =0000FFF0H
; CS selector =000H
; DS selector =0000H
; ES selector =0000H
; SS selector =0000H
; FS selector =0000H
; GS selector =0000H
; IDTR:
; base =0
; limit =03FFH
;All registers not mentioned above are undefined.
;These settings imply that the processor begins in real-address mode with interrupts disabled.
;10.2 Software Initialization for Real-Address Mode
;In real-address mode a few structures must be initialized before a program can take advantage of all the features available in this mode.
;10.2.1 Stack
;No instructions that use the stack can be used until the stack-segment register (SS) has been loaded. SS must point to an area in RAM.
;10.2.2 Interrupt Table
;The initial state of the 80386 leaves interrupts disabled; however, the processor will still attempt to access the interrupt table if an exception or nonmaskable interrupt (NMI) occurs. Initialization software should take one of the following actions: Change the limit value in the IDTR to zero. This will cause a shutdown if an exception or nonmaskable interrupt occurs. (Refer to the 80386 Hardware Reference Manual to see how shutdown is signalled externally.)
; Put pointers to valid interrupt handlers in all positions of the interrupt table that might be used by exceptions or interrupts.
; Change the IDTR to point to a valid interrupt table.
;
;10.2.3 First Instructions
;After RESET, address lines A{31-20} are automatically asserted for instruction fetches. This fact, together with the initial values of CS:IP, causes instruction execution to begin at physical address FFFFFFF0H. Near (intrasegment) forms of control transfer instructions may be used to pass control to other addresses in the upper 64K bytes of the address space. The first far (intersegment) JMP or CALL instruction causes A{31-20} to drop low, and the 80386 continues executing instructions in the lower one megabyte of physical memory. This automatic assertion of address lines A{31-20} allows systems designers to use a ROM at the high end of the address space to initialize the system.
; from http://en.wikipedia.org/wiki/Interrupt_descriptor_table
;In the 8086 processor, the IDT resides at a fixed location in memory from address 0x0000 to 0x03ff, and consists of 256 four-byte real mode pointers (256 × 4 = 1024 bytes of memory). In the 80286 and later, the size and locations of the IDT can be changed in the same way as it is done in protected mode, though it does not change the format of it. A real mode pointer is defined as a 16-bit segment address and a 16-bit offset into that segment. A segment address is expanded internally by the processor to 20 bits thus limiting real mode interrupt handlers to the first 1 megabyte of addressable memory. The first 32 vectors are reserved for the processor's internal exceptions, and hardware interrupts may be mapped to any of the vectors by way of a programmable interrupt controller.
; A commonly used x86 real mode interrupt is INT 10, the Video BIOS code to handle primitive screen drawing functions such as pixel drawing and changing the screen resolution.
; from http://software.intel.com/en-us/articles/introduction-to-x64-assembly
; XOR EAX, EAX ; zero out eax
; MOV ECX, 10 ; loop 10 times
;Label: ; this is a label in assembly
; INX EAX ; increment eax
; LOOP Label ; decrement ECX, loop if not 0
; from https://courses.engr.illinois.edu/ece390/books/artofasm/CH06/CH06-5.html#HEADING5-294
; mov ecx, 255
;ArrayLp: mov Array[ecx], cl
; loop ArrayLp
; mov Array[0], 0
;The last instruction is necessary because the loop does not repeat when cx is zero. Therefore, the last element of the array that this loop processes is Array[1], hence the last instruction.
; The loop instruction does not affect any flags.
; 2.17.2014 chu' Ha^n telephoned about obtaining literature on American Philosophy and on US Census Data particularly
; US Census Data on black population expansion into US and into the world …
; following day: couple resembling co^ Be^ and David Lowe seen at Post Office when we tried to mail chu' Kha's preserved fruit to father in Michigan
; from http://randomascii.wordpress.com/2012/12/29/the-surprising-subtleties-of-zeroing-a-register/
; also see http://navet.ics.hawaii.edu/~casanova/courses/ics312_spring14/slides/ics312_bits_2.pdf
;Tabula rasa
;The x86 instruction set does not have a special purpose instruction for zeroing a register. An obvious way of dealing with this would be to move a constant zero into the register, like this:
;mov eax, 0
;That works, and it is fast. Benchmarking this will typically show that it has a latency of one Sandybridge diecycle the result can be used in a subsequent instruction on the next cycle. Benchmarking will also show that this has a throughput of three-per-cycle. The Sandybridge documentation says that this is the maximum integer throughput possible, and yet we can do better.
;Its too big
;The x86 instruction used to load a constant value such as zero into eax consists of a one-byte opcode (0xB8) and the constant to be loaded. The problem, in this scenario, is that eax is a 32-bit register, so the constant is 32-bits, so we end up with a five-byte instruction:
;B8 00 00 00 00 mov eax, 0
;Instruction size does not directly affect performance you can create lots of benchmarks that will prove that it is harmless but in most real programs the size of the code does have an effect on performance. The cost is extremely difficult to measure, but it appears that instruction-cache misses cost 10% or more of performance on many real programs. All else being equal, reducing instruction sizes will reduce i-cache misses, and therefore improve performance to some unknown degree.
;Smaller alternatives
;Many RISC architectures have a zero register in order to optimize this particular case, but x86 does not. The recommended alternative for years has been to use xor eax, eax. Any register exclusive ored with itself gives zero, and this instruction is just two bytes long:
;33 C0 xor eax, eax
;Careful micro-benchmarking will show that this instruction has the same one-cycle latency and three-per-cycle throughput of mov eax, 0 and it is 60% smaller (and recommended by Intel), so all is well.
;Suspicious minds
;If you really understand how CPUs work then you should be concerned with possible problems with using xor eax, eax to zero the eax register. One of the main limitations on CPU performance is data dependencies. While a Sandybridge processor can potentially execute three integer instructions on each cycle, in practice its performance tends to be lower because most instructions depend on the results of previous instructions, and are therefore serialized. The xor eax, eax instruction is at risk for such serialization because it uses eax as an input. Therefore it cannot (in theory) execute until the last instruction that wrote to eax completes. For example, consider this code fragment below:
;1: add eax, 1
;2: mov ebx, eax
;3: xor eax, eax
;4: add eax, ecx
;Careful micro-benchmarking will show that this instruction has the same one-cycle latency and three-per-cycle throughput of mov eax, 0 and it is 60% smaller (and recommended by Intel), so all is well.
;Ideally we would like our awesome out-of-order processor to execute instructions 1 and 3 in parallel. There is a literal data dependency between them, but a sufficiently advanced processor could detect that this dependency is artificial. The result of the xor instruction doesnt depend on the value of eax, it will always be zero.
;It turns out that for x86 processors have for years handled xor of a register with itself specially. Every out-of-order Intel and AMD processor that I am aware of can detect that there is not really a data dependency and it can execute instructions 1 and 3 in parallel. Which is great. The CPUs use register renaming to create a new eax for the sequence of instructions starting with instruction 3.
; from http://stackoverflow.com/questions/4909563/why-should-code-be-aligned-to-even-address-boundaries-on-x86
;Because the (16 bit) processor can fetch values from memory only at even addresses, due to its particular layout: it is divided in two "banks" of 1 byte each, so half of the data bus is connected to the first bank and the other half to the other bank. Now, suppose these banks are aligned (as in my picture), the processor can fetch values that are on the same "row".
; bank 1 bank 2
;+——–+——–+
;| 8 bit | 8 bit |
;+——–+——–+
;| | |
;+——–+——–+
;| 4 | 5 | >> dENarixs OS Project
;UIN: 30796163
; from http://devdocs.inightmare.org/x86-assembly-changing-interrupt-vector-table/
;(x86 Assembly) Changing Interrupt Vector Table
;(This tutorial was originally written in 2004 and featured in http://asm.inightmare.org/)
;Another thing I want to write tutorial is about changing interrupts. There are two ways you can do that using DOS interrupts and modifying interrupt vector table directly. Both ways are pretty simple, you need to know these DOS interrupts (int 21h):
;Function
;What does it do?
;Parameters
;AH = 25h Set interrupt vector AL – interrupt number to change
; DS:DX – pointer to interrupt function
;AH = 35h Get interrupt vector. Gets address of currently set interrupt. AL – interrupt number
; Returns:
; ES:BX – pointer to interrupt
;AH = 4Ch Exits DOS program 😉 AL – exit code (not sure what it does)
;It’s pretty simple, just take a look at the sample code here.
;The other way to make your own interrupt is to modify interrupt vector table directly. It’s mapped from 0000:0000 to 0000:0400h in memory. The structure is very simple:
;Offset
;Segment
;Int 0
;(Offset 0000)
;(Offset 0002)
;Int 1
;(Offset 0004)
;(Offset 0006)
;Int 2
;(Offset 0008)
;(Offset 0010)
;…
;…
;So getting interrupt offset is:
;mov ax, [intnum*4]
;And segment:
;mov ax [intnum*4+2]
;Setting:
;mov ax, [intnum*4] ; offset
;mov ax [intnum*4+2] ; segment
;Well and how to call the interrupt, I think we all know:
;int intnum
;Everything is pretty simple. NASM source code:
;DOS interrupt version – here
; Direct modifiying of intvec table – here
; from http://asm.inightmare.org/ints_vec.asm
; org 100h
;xor ax, ax
;mov es, ax
; Save interrupt address so we can restore it later
;mov bx, [es:69h*4]
;mov [old_int_off], bx
;mov bx, [es:69h*4+2]
;mov [old_int_seg], bx
; modify interrupt vector table on 0x69th entry to point to our interrupt
;mov dx, int_prog
;mov [es:69h*4], dx
;mov ax, cs
;mov [es:69h*4+2], ax
;nop
;int 69h ; execute our interrupt
;restore old interrupt
;mov ax, [old_int_seg]
;mov [es:69h*4+2], ax
;mov dx, [old_int_off]
;mov [es:69h*4], dx
;mov ax, 0x4c00 ; Exit
;int 21h
; Our interrupt just prints some text 🙂
;int_prog:
;pusha ; save old registers, just incase 😉
;mov ah, 9
;mov dx, our_text
;int 21h
;popa
;iret
;our_text db “Bleh… $”
;old_int_seg dw 0
;old_int_off dw 0
; from http://www.ece.msstate.edu/~janem/ECE3724/S03/Presentations/number_io.ppt
;This is the html version of the file http://www.ece.msstate.edu/~janem/ECE3724/S03/Presentations/number_io.ppt.
;Google automatically generates html versions of documents as we crawl the web.
;1
;Ways to Handle I/O (Input/Ouput)
;•For Output
;◦Use Irvine16 Functions
;◾Writechar, WriteBin, WriteInt, Writehex, Writestring
;◦Use DOS (Int 21h) Functions – (Table C-2)
;◾2 – write char, 6 – write char, 9- write string (Table C-3)
;◦Use Video BIOS (Int 10h) Functions
;◾9 – write char and attribute, 0A- write char, …
;•For Input
;◦Use Irvine16 Functions
;◾Readchar, Readint, ReadHex, Readstring
;◦Use DOS (Int 21h) Functions (Table C-2)
;◾1 – read char, 6 – read char, 7- read char
;◦Use Keyboard BIOS (Int 16h) Functions (Table C-5)
;◾10 – wait for key
;2
;Input/Output of Numbers
;•A common task is to input or output numbers in ASCII format
;•Output tasks:
;◦Output an 8-bit value as ASCII string in HEX format
;◦Output an 8-bit value as a ASCII string in BINARY format (see ‘pbin.asm’ example on WWW page)
;◦Output an 8-bit value as ASCII string in DECIMAL format
;•Input tasks:
;◦Input a string representing an 8-bit number in Hex format
;◦Input a string representing an two digit decimal number (unsigned)
;
;3
;Output an 8 bit number in Hex Format
;•Two Hex characters in 8-bits. Want to work with each set of 4-bits individually.
;•Each Hex character represents 4-bits in a number.
;◦0000 = ‘0’ (ASCII code = 30h)
;◦0001 = ‘1’ (ASCII code = 31h)
;◦1001 = ‘9’ (ASCII code = 39h)
;◦……
;◦1010 = ‘A’ (ASCII code = 41h)
;◦1011 = ‘B’ (ASCII code = 42h)
;◦……
;◦1111 = ‘F’ (ASCII code) = 46h ).
;•If 4-bits is between 0-9, then ASCII = 30h + 4bits
;•If 4-bits is between A-F, then ASCII = 37h + 4bits
;4
;Output an 8 bit number in Hex Format
;Approach: Write a subroutine called ‘Out1Hex’. This will output the lower 4 bits of register ‘AL’ as an Hex digit to the screen.
;To output an 8-bit value, the main routine(out2hex) will call ‘Out1Hex’ twice 1) for the most significant HEX digit, and
; 2) for the least significant Hex digit.
; out2hex proc
;; output value in ‘al’ as 2 hex character
; push ax ; save al
; shr al, 4 ; get most sig. 4 bits into lower
; call Out1Hex ; print most sig. hex digit
; pop ax ; get back original al
; and al, 0x0Fh ; upper 4 bits = 0 – working with low 4 bits
; call Out1Hex ; print least sig. hex digit
; out2hex endp
;5
;Out1Hex
;Pseudo code for Out1Hex:
;
; if ( AL > 09H) jump to SKIP
; AL = AL + 30H
; Use Int21H, function2 to print character
; return
;
; skip: AL = AL + 37H
; Use Int21H, function2 to print character
; return
;
;
;6
; from Programmer’s Reference Manual
; CMP (Compare) subtracts the source operand from the destination operand. It updates OF, SF, ZF, AF, PF, and CF but does not alter the source and destination operands. A subsequent Jcc or SETcc instruction can test the appropriate flags.
; from
;Out1Hex
;A procedure to convert a 4-bit hex number to ASCII and print the character to the screen.
;Out1hex proc
;Cmp al, 9 ;is 4-bit value above 9?
;Ja ischar ;if so, must be a character
;Add al, 30h ;if not, add 30h for conversion
;Jmp printit ;go to print label
;Ischar: add al, 37h ;was character – add 37h for ;conversion
;Printit: mov dl, al ;printing a character to screen
;Mov ah,2 ;using int 21h, function 2.
;Int 21h
;Ret ;return to main procedure
;Out1hex endp
;End Main
;7
;Output a 16-bit hex number? 32 bits?
;•How would you print out a 16 bit value?
;◦Call Out1Hex 4 times.
;◦Each call would have to have the 4 bits in the lower four bits of AL
;◦You would have to start with the Most significant bits
;◦After saving the value, use shr instruction to get the correct bits.
;•How would you printout a 32-bit value?
;◦Call ‘Out1Hex’ 8 times – once for each 4 bits of the 32-bit value.
;8
;Output an 8-bit number in Decimal Format
;•How would you output a number in Decimal format?
;•Assume that AL contains a value between 0 and 99 and you want to print this out as a decimal value
;•The value of the first digit is ‘AL divided by 10’ (quotient value of AL/10).
;•The value of the 2nd digit is REMAINDER of AL divided by 10!!
;9
;Out1Dec
;A procedure to convert an 8-bit unsigned decimal number stored in AL to ASCII and print the character to the screen.
;Out1Dec Proc
;Push ax ;save value
;And ah, ah ;clear ah
;Div 10 ;divide value by 10 (quotient in AL, ;remainder in AH)
;Add al, 30h ;convert 10’s digit to ASCII
;Call printchar
;Mov al, ah ;get 1’s digit
;Add al, 30h ;convert to ASCII
;Call printchar
;Out1Dec Endp
;10
;Input an 8-bit number in HEX format
;•An 8-bit hex number will require two ASCII characters to represent it
;•Need to get 4-bit value of digit from ASCII character code
;•If ASCII is between 30H and 39H (‘0’ and ‘9’), then four-bit value is ASCII value – 30H.
;•If ASCII is between 41H and 46H (‘A’ and ‘F’), then four-bit value is ASCII value – 37H
;11
;Input an 8-bit number in HEX format
;Assume AX has the two ASCII digits that represent a HEX number
;Example: AX = 4335 h, AH = 43h = ‘C’, AL=35h = ‘5’.
;Want to convert this to AL = C5h.
; in2hex proc
; push ax ;; save AX
; mov al,ah ;; get most sig. char into AL
; call inhex ;; convert ASCII hex code in AL to 4 bit value
; mov bl, al ;; save in BL
; pop ax ;; get AX back
; call inhex ;; convert ASCII hex code in AL to 4-bit value
; shl bl,4 ;; shift bl to left to move lower 4bit to upper
; or al, bl ;; combine upper and lower bits, AL has value!
; ret
; in2hex endp
;12
;inhex Subroutine
;Want to convert the ASCII code in AL that is a HEX digit to its 4-bit value
; Pseudo code: if (AL > 39h) jump to skip
; AL = AL – 30h
; return
; skip: AL = AL – 37H
; return
;13
;Input an 8-bit number in Decimal format
;Assume AX has the two ASCII digits that represent a DECIMAL number
;Example: AX = 3731 h, AH = 38h = ‘7’, AL=31h = ‘1’.
;Want to convert this to AL = 71 (decimal) = 47h !!
; Approach:
; a. Convert the most significant ASCII digit to its four bit value.
; b. Multiply this by 10 and save.
; c. Convert the least significant ASCII digit to its four bit value and ADD it to the value produced in ‘b’!!
; 71 = 7 * 10 + 1 = 71 = 47 h.
someone said thanks on earth’s day 2014 a few days ago …
chaos and butterfly effect … “Pray tell who’s the pot and who’s the potter,” Omar Khayam’s Rubayat … in the end everyone’s acts–ours and the weather’s etc.– are all dictated by “muo^n loa`i ddu+o+.c so^’ng la^u bi`nh thu+o+`ng; everyone live long and well” …
{“may the “crutch-less” force be with you”: one of ddu+’c of dda.t’s action figure … if you fold his wings/cape he appears to be holding his crotches … when ddu+’c bought his new focus car … perhaps chu’ ha^n could use one …}
;
same as k400/kr400 Logitech keyboard mouse is two-colored …
on amazon.com this live mouse trap cost the same amount –$12.00 dollars–as …
because it was bone-dried …Katie’s Naturally Nutty family 
Changes in air and soil temperatures during the period from March, 1996, to April, 1996, and October, 1996, to March, 1997. Soil temperatures were measured 10 cm beneath the surface of the soil.
: [“Three cups of tea”: “cheezali?” “what the hell” “mr david is sucked into mortenson’s orbit …”]… yesterday sbtn ba?o cha^u die^.u quye^n in cancer-fighting pink … beware of beauty that attracts thu hu’t unwanted attention and cancer ~ ung ~ thu is “cheezali” “che^ gia ddi`nh structure va` virgin trinh ha?” [to^n an would try to moderate to Middle Path the beauty of the elder Russian customer resembling the star of dr. zhivago to be the equal of the younger Siberian bagger at Nino … ]…. “sa(‘c la` kho^ng; kho^ng la` sa(‘c” “beauty is nothing; nothing is beauty” “repulsion/attraction is no; no is repulsion/attraction” “chaotic strange attractor” … 
stoppauseplayfastforwardrewindejectrecorddotnet 
