Driss-A-Blog

Big Red

Avi — 2010-02-11T19:39:59-05:00

Verizon is Big Red?

It's a hilarious self-aware parody, and I love the kissing couple homage in the hotel lobby scenes. If you dig around, you'll find the original commercial this is based off of:

Not only is half of it a shot-for-shot remake, the music is note-for-note the same. I didn't realize (until digging around) that you can date these ads by the music (this one and that one share the music and are from the '80s, while this one is much newer, this one goes for a harder rock sound, and this one is a horrible retro abomination).

--Avi

Fish and chips in the city

Avi — 2009-12-29T14:25:01-05:00

Happy 150th to you!

There haven't been too many good places I've been to here in NYC. Here's a brief overview:

Arthur Treacher's
251 E 14th St
★☆☆☆☆
A sad joke. The fish is a rectangular block that mocks the natural shape and taste of fish.

One and One
76 1 Ave
★★★☆☆
The fish is good, but someone there needs to take Batter 101. Presentation is nice but the slightest touch causes the fish to fall to pieces and the batter to slide off. Redemption comes from the 2-for-1 special on Sunday nights at 7pm.

A Salt & Battery
112 Greenwich Ave
★★★★☆
The star off isn't from the awful name, but the prices. The meal is good, but rather expensive. And how can you sell fish and chips separately?

Chipshop
129 Atlantic Ave, Brooklyn
★★★★★
Yes, to get awesome fish and chips you have to go to Brooklyn. Suck it up. The price is reasonable, the serving size is large, and the taste is great.

--Avi

New Wicks Work!

Shira — 2009-12-18T01:13:51-05:00

Happy Chanukah! Chodesh Tov! Shabbat Shalom!

I started using a new kind of wick about four nights ago, and it's working out well. It's the type with a metal tab at the bottom with a wick sticking straight up. You fill the little glass with oil, drop the wick in - make sure there's some wick above the oil - and light. Thank goodness.

All is well here. Hope all is well with everyone out there.
Shira

--Shira

Unhappy Wicks

Shira — 2009-12-13T23:22:14-05:00

I've been lighting oil for the last few years (at least) and I haven't had this kind of a problem yet. My wicks keep drowning themselves. I can't figure it out - they can't be that unhappy.

It's the third night of Chanukah - and they did it again. I had changed the oil (in case it really was the oil) but I'm thinking it's the wicks. I used these wicks last year, so I didn't expect trouble. Tomorrow I'm going wick shopping - we'll try something else.

I didn't want to change the oil and the wick at the same time, otherwise I wouldn't know what worked. So one thing at a time - oil today - we'll try wicks tomorrow.

I'll let you know!
Shira

--Shira

Happy Chanukah!

Shira — 2009-12-11T01:00:37-05:00

Just thought I'd stop by and give a short update on my life.

I'm in Toronto (shockingly enough) and thank G-d all is going well.

Immigration Front - we've received a notice that Jeff has given the okay to be my sponsor. The rest of the permanent residency application has been forwarded to the Canadian Consulate in Buffalo, New York to be reviewed.

The Apartment - it's finally shaping up. We're due to put up pictures (hopefully) this week. Yay!

My Writings - not to worry, I'm still involved. I have two websites:
http://shiradrissman.com - political musings
http://shiradrissman.org - Jewish musings - new article up on Chanukah!

That's my life. I'm still not allowed to work, but various projects are keeping me busy and out of trouble.

Wishing everyone a very Happy Chanukah!
Shira

--Shira

What the bleep?

Avi — 2009-12-07T10:20:21-05:00

What the Bleep Do We Know!?
★☆☆☆☆

Twenty two minutes into the movie I learned a new logical technique I'm calling Advanced Logical Bullshitting. It goes something like this:

Make a bad analogy: “In empty space, matter flits in and out of existence. Kinda like thoughts do.”
Turn it into a simile: “Matter is like thought.”
Assume it to be literal truth: “Therefore, we've established that thoughts create matter.”

I'm not joking. That's the actual argument made by the movie 22 minutes in. That was enough for me; I turned it off.

This seriously angers me. I've seen girls on Facebook who list “Quantum Physics” under “Interests.” Nuh, uh, honey. Not with nothing else in your profile listing the slightest bit of scientific interest. (And no, random quotes from Einstein about God don't count.)

If you want to claim that you create your own reality through your thoughts, fine. That was done in the 70s by Jane Roberts and her Seth books. But don't defend it by making a mockery of logic and science.

--Avi

Dubai

Avi — 2009-11-27T00:10:54-05:00

Bounce a check in Dubai and you go to jail.

Bounce a check and you're Dubai, well, too bad.

--Avi

NSRectFill() and +[NSColor clearColor]

Avi — 2009-10-09T14:55:20-05:00

I'm reading a code review from a colleague when I see this:

[[NSColor clearColor] set]; NSRectFill(rect);

Ouch. I see that's broken, but only because I made the same mistake yesterday. What's wrong?

+[NSColor clearColor] is actually black with an alpha 0. That would be fine but for a subtle fact about NSRectFill(): it ignores alpha. Really! The code, as written above, will fill the specified rectangle with black.

What's going on here? NSRectFill() uses the compositing mode NSCompositeCopy, which ignores alpha. If you want alpha, you must say:

[[NSColor clearColor] set]; NSRectFillUsingOperation(rect, NSCompositeSourceOver);

A quick one-liner, but too easy to get wrong.

--Avi

CrossFitting

Avi — 2009-09-08T21:22:48-05:00

I learned about CrossFit from the My Fat Ass challenge that I did with some friends of mine (we hope to be restarting it soon). I'd had mixed results from doing P90X (mostly involving knees feeling like they were going to tear), and so the opportunity to do things under professional supervision was appealing.

So I joined up at CrossFit Virtuosity and started on their Foundations classes. Once I've got the basic form down I hope to move up to the “regular” classes. But I got a taste of that yesterday when we had a joint Labor Day class.

Warmup was tossing a medicine ball back and forth between partners. Then we split off into teams of 6, leaders selected by jumping onto a platform. Keith had a gleeful smile as he scribbled the task on the board:

Team workout
Sandbag sprints (each member)
100 pullups (per team; each member must do at least one)
100 wheelbarrow pushups (per team; each member must do at least one)
Overhead kettlebell carry (each member; 16kg, one roundtrip per arm)
3000m row (per team; each member must participate)

I did surprisingly-well on the sprints (surprising to me, anyway), did some pullups (not very many), more pushups, and I hung in there with the kettlebell (my left arm doesn't like doing that).

The last part was the row, and we all did 500m (except for one team member who did 250m). I had 2250–2750 and it winded me. I powered through it, kept excellent pace, and just about collapsed after. Spent 5 minutes just breathing through the pain. Then when I didn't feel like gasping any more, every muscle in my body just hurt. So I laid down for a while longer. Eventually I got up and started walking and talking. We'd lost by 24s, but had made a major comeback.

One thing I realized was that CrossFit is essentially all nerds. I never thought I'd be talking about web browsers and coding and hacking with gym mates, but I was pleasantly surprised.

And I'm finding myself eerily looking forward to the next time. Strange, huh?

(more photos...)

--Avi

Adventures in Immigration

Shira — 2009-08-17T17:22:47-05:00

Immigration to Canada is no simple thing, even for an American. One would think, "Hey! I'm an American - here I am." Nope, that doesn't happen sorry to say.

I've been working on my permanent residency papers. Which means that I've been given 6 months to get the papers and information collected that will allow me to continue living in Canada. My 6 month deadline is approaching at the end of September.

Here is the excitement so far.

About two weeks ago Jeff and I went to go get my fingerprints taken. I needed three sets - one to send to the FBI, one set to the State of Michigan, and the third set to the State of New York. Basically I would send to any place I've lived in the last 10 years. Thankfully I haven't been that many places. We found an official place that would take my fingerprints and went to see what we would find. We found a nice lady who was quite efficient at taking fingerprints. It makes sense since she said she sees about 20 people a day.

Next part of the big excitement was today. My medical exam. Nothing tremendous, just exhausting. I knew in advance that the appointment was supposedly going to take two hours, but I didn't know how it was going to be broken down.

We got to the doctor's office at 10:45am where they sent us two buildings over. We walked over. It was hot. With the humidity built in - it's around 100 degrees today. I had blood taken, HIV and whatever else they wanted to know about. She did an okay job taking the blood, but I'll have a bruise where they took it.

We headed back to the doctor's office where they sent us to the basement of the same building to get an x-ray of my lungs. There was a long line ahead of us. That actually turned out to be useful since they didn't accept credit or debit - only cash or check, which we didn't have on us. We took about 15 minutes to find a bank in the area and return, and we still waited. In the meantime, we texted Talya and smiled at little children. I finally got called in and x-rayed.

We returned a third time to the doctor's office. I met the doctor, nice enough lady, and answered her questions. I got to tell her about my gallbladder surgery and ACL surgery. That being said, she told me that I am unremarkable. I'm quite happy to be unremarkable medically.

Then we went home and had lunch. After lunch I laid down for almost two hours. I'm feeling better now.

So the major stuff is out of the way. We're waiting for the FBI, the States of Michigan and New York to send my criminal record (nothing there) back to me. The doctor's office will ship my records directly to the Canadian immigration people. And I have some more papers to fill out in the meantime. When I get all my records shipped to me - I collect it all and ship it along... and wait at least six months to hear from them.

We're also going to fill out work permit forms at the same time to try to allow me to work while we're waiting to hear about permanent residency. Yay!

In the meantime, I'm writing on my blog and puttering around the house. Good fun had by all.

--Shira

Replacement foam earpads

Avi — 2009-07-27T21:02:57-05:00

One of the fun things about using earbuds is having to occasionally replace the foam pads.

Option #1: Go to Radio Shack. Get a 4-pack for $4 plus tax. Bought this twice already. Ow.

Option #2: eBay seller ZanyZap's 450-pack for $9. Shipped.

Hmmm...

--Avi

Appreciation time

Avi — 2009-06-23T11:32:41-05:00

http://twitter.com/aviappreciates

--Avi

Can't get an iPhone?

Avi — 2009-06-21T15:35:06-05:00

I'm giving up and getting an iPhone. Well, trying to, anyway. I was halfway through my order when I punched in my current phone number and got a notice that it was ineligible for transfer. I did a live chat with an agent:

Rene: Does your number belong to a different state than the one you are in?
Avi: yes
Avi: why would that matter?
Rene: That matters because there is a Federal Law by the FCC that prevents the transfer of numbers from state to state.

Seriously? I can't take my number with me because I live in a different state?

Rene: You would have to get a new number. Would that be alright with you?
Avi: Ugh
Avi: no, I've had that # for nine years
Rene: I am sorry about that.
Rene: What would you like to do?
Rene: Sometimes change is good.

Sometimes change is good?! I'm already starting to dread working with AT&T...

--Avi

Reverse-Engineering in OS X on x86

Avi — 2009-05-16T15:15:14-05:00

The other day at work I had a task: to figure out how to change the displayed title of a minimized window in the Dock without actually changing the window's title. (Please trust that I had a very good reason for wanting to do this.)

While there are some excellent articles about how to reverse-engineer under OS X, they're all PowerPC-based. And even though the future of the Mac is x86, it seems like people have lots of anxiety about having to work with it.

I think the problem is not a lack of documentation on x86 assembly, but a surfeit of it. Most of it is Windows- or DOS-centric, usually with the wrong syntax (Intel syntax vs the AT&T syntax that GCC uses), and with the aim of teaching how to write it. But reading x86 assembly really isn't that hard. If all you want to do is learn how to read the code generated by GCC, it's probably just as easy as PowerPC.

The other day I took notes of my discoveries. Let's touch on two functions, both in PowerPC and x86 flavors. For those of you who only know PowerPC assembly, I hope you'll be pleasantly surprised.

Before we begin, I'm going to assume that you're comfortable with assembly in general (though not necessarily with any particular one). If you have the latest developer tools, launch Shark (in /Developer/Applications/Performance Tools) and in the Help menu you can access various ISA references. In addition, Apple has ABI documentation for both the PowerPC and x86. I'm going to go over each function twice (once for PowerPC and once for x86); feel free to skim the PowerPC version if you're accustomed to it. And finally, this is only for the 32-bit version of each platform; things change even more with 64 bits.

SetWindowTitleWithCFString

The trail always begins with a public call that uses the SPI that you want to figure out. In this case, I chose SetWindowTitleWithCFString because it has to somehow set the title of a window even if it's minimized. I went with Carbon because sometimes the dynamic nature of Objective C with Cocoa makes tracing code harder.

PowerPC

<+0>:	mflr    r0          // save linkage
<+4>:	stmw    r30,-8(r1)  // stash r30, r31
<+8>:	mr      r30,r4      // save r4 (new title)
<+12>:	stw     r0,8(r1)    // make stack frame
<+16>:	stwu    r1,-80(r1)  // make stack frame

This is the prologue of the function. The PowerPC doesn't have a dedicated stack pointer (convention is to use r1 for that), so the common way of implementing branches by pushing the PC onto the stack doesn't work. Instead, the PowerPC has a link register and a command bl to branch and put the old PC value into the link register. Thus, almost every function starts with mflr r0, to pull the old PC into a usable register. Then in <+4> we save off some registers that we're going to smash. Every function needs scratch registers to hold local variables, and usually the high-numbered registers are used. The stmw (store multiple words) instruction is useful for ditching many high registers on the stack. Then in <+12> we drop the old PC onto the stack and allocate 80 bytes on the stack.

A note on parameter passing. Integer-sized parameters (the only kind we'll be dealing with today) are passed into a function starting with r3 and going up through the registers. Return values are returned in r3. So we see that in <+8> we stick away the pointer to the new name in r30 (whose previous value was stored on the stack earlier).

<+20>:	bl      0x92881384 <_Z13GetWindowDataP15OpaqueWindowPtr>
<+24>:	li      r0,-5600    // errInvalidWindowRef
<+28>:	cmpwi   cr7,r3,0    // if no window data, bail
<+32>:	beq-    cr7,0x928d2ae0 <+60>
<+36>:	cmpwi   cr7,r30,0   // if no string to set, bail
<+40>:	li      r0,-50      // paramErr
<+44>:	beq-    cr7,0x928d2ae0 <+60>
<+48>:	mr      r4,r30

This is where we must start making inferences as to what the code is doing. Fortunately, we have the symbols so it's not too hard. We see that we use the WindowRef as a parameter to a C++ function GetWindowData(OpaqueWindowPtr), as the WindowRef was passed in as r3 and r3 wasn't altered before the call. In addition, note that the function return value, being in r3, will overwrite the WindowRef value which wasn't saved in a high register. That's fine, as the WindowRef was just an index into a table and won't be needed further.

At this point we run some checks. We compare both r3 and r30 to zero and if either are we jump to the end with r0 set to the appropriate error code. (The end of the function will move r0 into r3 for return.)

The PowerPC condition register has eight condition sets. Why are we using cr7 here? Probably because cr7 is volatile and we can get away with not saving/restoring it.

<+52>:	bl      0x928d2af8 <_ZN10WindowData14SetTitleCommonEPK10__CFString>
<+56>:	li      r0,0        // return noErr
<+60>:	addi    r1,r1,80    // tear down stack frame and return
<+64>:	mr      r3,r0
<+68>:	lwz     r0,8(r1)
<+72>:	lmw     r30,-8(r1)
<+76>:	mtlr    r0
<+80>:	blr

The rest is pretty simple. We call a member function WindowData::SetTitleCommon(CFString*), and then do common tear down. We restore the stack pointer, put the return value into r3, restore the registers, move the old PC back into the link register, and branch to the link register (blr), returning us to our caller.

x86

The PowerPC register file is really easy: r0, r1, r2 ... r31. x86 has fewer registers and they've historically had different roles (accumulator, base, source index, destination index, and so on). Seriously, forget about that. There are eight registers you care about. eax, ebx, ecx, edx, esi, and edi are all general-purpose registers. esp is the stack pointer. ebp is the frame pointer. That's it.

PowerPC assembly reads right-to-left (except for stores). x86 AT&T syntax in general reads left to right.

<+0>:	push   %ebp             // make stack frame
<+1>:	mov    %esp,%ebp        // make stack frame
<+3>:	push   %esi             // stash %esi
<+4>:	sub    $0x14,%esp       // make stack frame

x86 is stack-based. Parameters to a function are put at the top of the stack, with the rightmost parameters with the highest addresses. To execute the function, the call instruction was used. It pushes the PC onto the stack, so even before we hit <+0> the parameters are four bytes above the stack pointer. In <+0> we save off the old stack frame value and in <+1> we establish our stack frame. At this point ebp is fixed for the entire function. In <+3> we save the old values of registers we're going to use, and in <+4> we allocate space on the stack.

This is a perfect example of an ideal stack frame. ebp is the frame pointer. It points (to the stack) at the old frame pointer. ebp+4 is the IP of the function that called us. ebp+8 is the first parameter passed in, ebp+12 is the second, etc. Immediately below ebp are the values saved from the registers, which will be restored before the return. And below that is a bunch of stack space used for either register spillage or calling subsequent functions. One interesting note is that rarely are parameters pushed onto the stack for a call. The stack pointer doesn't move once we make it past the prologue. We just set the memory right above esp (the stack pointer) and make the call.

<+7>:	mov    0x8(%ebp),%eax   // get WindowRef in %eax
<+10>:	mov    0xc(%ebp),%esi   // get new title in %esi

The parameters are passed on the stack. Since fiddling in memory is slow, we pull the values into registers. It's actually pretty analogous to how things go in PowerPC. There, lower registers like r3 are reused for parameter passing so important values are kept in the high registers. On x86 the parameters go on the stack and values are kept in registers (while they can). Why eax and esi? Why not?

<+13>:	mov    %eax,(%esp)      // put WindowRef on the stack
<+16>:	call   0x92dfb8f6 <_Z13GetWindowDataP15OpaqueWindowPtr>

With the PowerPC, you can tell how many parameters a function has by how many registers starting with r3 are loaded. Here, just look at the register indirect addressing with esp.

<+21>:	mov    %eax,%edx        // stick WindowData into %edx
<+23>:	mov    $0xffffea20,%eax // errInvalidWindowRef
<+28>:	test   %edx,%edx        // if no window data, bail
<+30>:	je     0x92e4bb04 <+54>
<+32>:	test   %esi,%esi        // if no string to set, bail
<+34>:	mov    $0xffce,%ax      // paramErr
<+38>:	je     0x92e4bb04 <+54>

Return values come back from functions in eax, but otherwise this is pretty much the same. The only thing of interest to note is the clever use of the peculiar register structure. In <+23> the constant 0xffffea20 is loaded into eax. But on <+34> the constant 0xffce is loaded in ax. But since ax is just an alias for the lower 16 bits of eax, the upper half of the word is left as 0xffff and we get the full constant 0xffffffce in eax. Why do this? Because loading a 32 bit constant takes 5 bytes while loading a 16 bit constant only takes 4.

<+40>:	mov    %esi,0x4(%esp)   // load new title as param 2
<+44>:	mov    %edx,(%esp)      // load WindowData as param 1
<+47>:	call   0x92e4bb0c <_ZN10WindowData14SetTitleCommonEPK10__CFString>
<+52>:	xor    %eax,%eax        // return noErr

Same stuff as before. The one note is the zeroing of eax with an xor. Just a fancy trick as the generated code is faster and smaller than the equivalent mov $0x0,%eax.

<+54>:	add    $0x14,%esp       // tear down stack frame and return
<+57>:	pop    %esi
<+58>:	leave  
<+59>:	ret    
<+60>:	nop    
<+61>:	nop

Mirror image of the stack frame creation.

UpdateDockTitle

That wasn't so hard, was it? Whether stack- or register-based, it's basically the same.

At this point I'd like to talk about UpdateDockTitle. There are a few tricks that are in here, and so I'll focus the commentary on those more.

PowerPC

<+0>:	mflr    r0               // save linkage
<+4>:	stmw    r28,-16(r1)      // stash r28, r29, r30, r31
<+8>:	mr      r30,r3           // save r3 (WindowData)
<+12>:	bcl-    20,4*cr7+so,0x928d2bd4 <+16>
<+16>:	mflr    r31            // get ip in r31

Whoa... what?

Short story: <+12> is an unconditional branch-and-link.

Long story: On the PowerPC, instructions like bge, etc. are just aliases to a more primitive branch instruction, bc (branch conditional). In this case, the first parameter is 20 (0b10100), which indicates “branch always”. Since it's always going to branch, the second parameter doesn't matter, so it was set to all 1 bits (which translates to 4*cr7+so).

Why do this? Because we're going to need to access some PC-relative data, and the PowerPC chip has no PC-relative addressing mode. And the register move instructions can't access the PC register. Therefore we cheat in a way by taking an unconditional jump to the next address. Since it's a branch and link, the link register is filled with the next address (which in this case equals the address just jumped to) which can be moved to a normal register.

Why branch-conditional with a condition “branch always”? The b opcode only provides absolute addressing. Only bc has relative addressing.

<+20>:	stw     r0,8(r1)
<+24>:	stwu    r1,-80(r1)     // make stack frame
<+28>:	addis   r28,r31,3533 
<+32>:	bl      0x928d2c50 <_Z15GetTitleForDockP10WindowData>
<+36>:	lbz     r0,-3364(r28)  // haul initialization boolean into r0

This is where intuition comes in. We're hauling in some random byte from some PC-relative address. (lbz is load byte and zero, which loads one byte from memory and clears the high bits.) What's byte sized? A bool. Why a bool? Bools are flags. And with the value of the byte gating the call to RegisterAsDockClientPriv, it's a safe bet that it's an initialization flag.

<+40>:	mr      r29,r3         // stash new title into r29
<+44>:	cmpwi   cr7,r0,0       // was initialized?
<+48>:	bne-    cr7,0x928d2c04 <+64> // if so, skip
<+52>:	bl      0x9287f864 <_Z24RegisterAsDockClientPrivv> // else initialize
<+56>:	li      r0,1           // and set flag
<+60>:	stb     r0,-3364(r28)  //   as being intialized
<+64>:	mr      r3,r30
<+68>:	mr      r4,r29
<+72>:	bl      0x928d2c68 <SyncPlatformWindowTitle> // call with (WindowData, new title)
<+76>:	lwz     r0,344(r30)    // pull (WindowData + 344)
<+80>:	andis.  r2,r0,64       // and pull a flag bit out of it (minimized?)

More intuition here. r30 contains a pointer to the WindowData class instance, and we're accessing some word 344 bytes in. We don't care about the destination register (we don't touch r2 again this function) but don't miss the name of the opcode: “andis.” Remember that the period means to update cr0.

Once again, this is obviously a flag (bit-sized this time). But what does it mean? Context tells us that we only call CoreDockSetItemTitle when it's set. Thus, guessing that it's the is-minimized flag is safe.

<+84>:	beq-    0x928d2c38 <+116> // if not minimized, skip this step
<+88>:	addi    r1,r1,80
<+92>:	lwz     r3,196(r30) // load WID

How do I know that WindowData+196 is the CoreGraphics WID? I used Quartz Debug to look at the window list for a sample app. The app only had one window, and the listed WID matched.

<+96>:	mr      r4,r29 // load new title
<+100>:	lwz     r0,8(r1)
<+104>:	lmw     r28,-16(r1) // tear down stack frame
<+108>:	mtlr    r0
<+112>:	b       0x92b58ce4 <dyld_stub_CoreDockSetItemTitle>

Note that we're tearing down the stack twice. In this case we're tail calling CoreDockSetItemTitle so that it's as if our caller called them directly. This is equivalent to the code return CoreDockSetItemTitle(wid, newTitle). Note from the setup of r3 and r4 that we can deduce the parameter types. Can we figure out the return type, though? Not really. The calling code ignores it, so we can ignore it too.

<+116>:	addi    r1,r1,80
<+120>:	li      r3,0
<+124>:	lwz     r0,8(r1)
<+128>:	lmw     r28,-16(r1)
<+132>:	mtlr    r0
<+136>:	blr

x86

<+0>:	push   %ebp                   // make stack frame
<+1>:	mov    %esp,%ebp
<+3>:	sub    $0x28,%esp
<+6>:	mov    %ebx,-0xc(%ebp)        // save %ebx
<+9>:	call   0x92e4bbe4 <+14>
<+14>:	pop    %ebx                 // IP > %ebx

We're doing the same trick here to get the PC into a register and I'm a bit stumped as to why. From what I know, the x86 has PC-relative addressing, and surely there's got to be a better way to get the PC into a normal register. Right?

<+15>:	mov    %esi,-0x8(%ebp)      // save %esi
<+18>:	mov    0x8(%ebp),%esi       // WindowData > %esi
<+21>:	mov    %edi,-0x4(%ebp)      // save %edi

This almost looks like it was compiled by a different compiler. In the previous function, edi and esi are pushed, and then the stack pointer dropped. Here, we create the stack space and then move the contents of three registers (edi, esi, and ebx). I suspect that things changes once we also have to save ebx, though I don't know why.

<+24>:	mov    %esi,%eax            // %esi (WindowData) > %eax
<+26>:	call   0x92e4bc40 <_Z15GetTitleForDockP10WindowData>

Whoa. If we're calling a function we need to set the parameter via stack-relative addressing off esp. What's going on here?

The point of an ABI is that it's a documented way for functions to call each other. But if a function, say GetTitleForDock(WindowData*), is a short one that's not public and is only used under controlled circumstances, why worry about setting up the stack? In this particular case, GetTitleForDock happens to be a nine-instruction routine. Not worth the hassle of a stack frame, so it's reasonable to pass in the one parameter in eax.

<+31>:	cmpb   $0x0,0xd51a36c(%ebx) // test initialization boolean
<+38>:	mov    %eax,%edi            // window title > %edi
<+40>:	jne    0x92e4bc0c <+54> // if initialized, skip
<+42>:	call   0x92df9fe0 <_Z24RegisterAsDockClientPrivv> // else initialize
<+47>:	movb   $0x1,0xd51a36c(%ebx) // and set flag as being initialized
<+54>:	mov    %edi,0x4(%esp)       // new title (param 2)
<+58>:	mov    %esi,(%esp)          // WindowData (param 1)
<+61>:	call   0x92e4bc52 <SyncPlatformWindowTitle>
<+66>:	xor    %eax,%eax            // clear %eax (noErr?)
<+68>:	testb  $0x2,0x159(%esi)     // test flag (WindowData + 0x159) (minimized?)
<+75>:	je     0x92e4bc35 <+95> // if not minimized, skip this step
<+77>:	mov    %edi,0x4(%esp)       // new title (param 2)
<+81>:	mov    0xc4(%esi),%eax      // (WindowData + 0xC4) WID
<+87>:	mov    %eax,(%esp)          // (param 1)
<+90>:	call   0xa0a52ad1 <dyld_stub_CoreDockSetItemTitle>
<+95>:	mov    -0xc(%ebp),%ebx
<+98>:	mov    -0x8(%ebp),%esi
<+101>:	mov    -0x4(%ebp),%edi
<+104>:	leave  
<+105>:	ret

Conclusion

Yes, x86 assembly sucks. Having only two parameters rather than three for an opcode is a pain. Having only six general-purpose registers for use instead of twenty or so is a real pain.

But really, come on. You're not writing it. You're reading it.

It's compiler-generated. Nothing fancy.

Hold your horror. x86 isn't that bad.

--Avi

In the beginning...

Talya — 2009-05-14T15:49:47-05:00

My mom has always said that each person consists of four parts: the emotional, the physical, the mental, and the physical, and that you need to "feed" each part in order to stay balanced. I work out regularly, I read all the time and learn a lot practicing law, I look over myself emotionally, but I have been negligent with my spiritual side. I have had a rough go of things the past two and a half years, and decided that I had reached the last straw. Though I understand that I'm not truly in control of my life (G-d is), I do have some say in the matter, and thus, decided 2009 was my year, the year where I regain control of my life and who I really am. I started studying Torah (Old Testament) with Rabbi Shea Werner this week.

Rabbi Werner and I read the first sentence of Bereshis and the commentary by Rashi. We learned that the first sentence and Parshas Bereshis is at the beginning of the Torah for several reasons. It’s not just establishing the fundamentals and starting the story at the beginning. It’s more than just an answer to why the Land of Israel belongs to the Jewish people (Hashem created it and can give it to, or take it away from, whomever he’d like). Rather, it’s an answer to the question of Why with a capital W. Why are we here? What are the Jewish people supposed to accomplish? How do we go about doing that?

Bereshis exemplifies the end goal of the entire Torah, to transform and elevate the physical world with the spiritual holiness of the universe through Torah and mitzvot (commandments). It is also a microcosm of the rest of the Torah and of the past, present, and future. Since Hashem created the Land of Israel (as well as the rest of the world) and gave it first to other nations, physical conquering doesn’t matter; we see it happen all the time – the physical is not what’s important. But just as Hashem wanted to give the Land first to other people, he also wanted us to go in afterwards and take it from them. The Jewish people came into possession of it (when Hashem gave it to us) when it was merely physical (though there is a specific reason why the Land of Israel in particular was given to us), and we worked hard to elevate the Land. It was an example of what the Jewish people are supposed to do, supposed to end up doing – being a conduit, taking the physical (whether or not others are controlling it), bringing holiness from the universe to it through Torah and mitzvot, and thus, elevating it and everything around us... bringing us and others closer to our Creator.

The Jewish people went into Israel where others were, took it, and cleaned and elevated it to a godly level. We are also supposed to do that with the rest of the world (it is possible to spiritually elevate something without physically taking possession of it, but Bereshis demonstrates that we can if we need to, and, in fact, are supposed to). That’s why the Land HAD to be occupied by other people first. It had to be shown to the Jewish people (as well as others) that possession and the physical is (1) dictated by Hashem; (2) trumped by the spiritual; and (3) that the Jewish people were/are supposed to proactively step in and be the cause of the change (and not feel fear or guilt about that role). Had the Jewish people already been in Israel, the lesson would have been lost. Bereshis would not have reflected, and been a microcosm for, what has to continue happening. You can’t get to the end of something without knowing what the end is, and you cannot do a job if you are not informed as to how to do it. Bereshis demonstrates exactly what the end is supposed to be, and how the Jewish people are supposed to do it.

--Talya