Intel vs AT&T syntax

There're two popular assembly syntaxes: Intel and AT&T. Intel syntax is popular in Windows world. In Linux, AT&T syntax is more popular though GAS (Gnu Assembler) supports both.

The following lists some major differences of the two syntaxes:

1. AT&T prefixes register with % sign
   * Intel:
      eax, ebx, ecx,...
   * AT&T:
      prefix by % sign: %eax, %ebx, %ecx,...
   
   
2. AT&T prefixes immediate value with $ sign, Intel is not
   * Intel: 10, 80h
   * AT&T: $10, $0x80
   
   
3. AT&T and Intel syntax use opposite instruction operands
   * Intel:      mnemonic destination, source 
      Ex:         mov eax, 100
   * AT&T:  mnemonic source, destination
      Ex:        movl $100, %eax
   
   
4. AT&T suffixes instruction to specify instruction's operand size (1 byte: b, 2 bytes: w, 4 bytes: l) but Intel uses directive before operands (1 byte: byte ptr, 2 bytes: word ptr, 4 bytes: dword ptr)
   * Intel:
      mov al, byte ptr foo
   * AT&T:
      movb foo, %al
   
   

Assembly Language

Assembly can be seen as machine language but in symbols/mnemonics instead of 0s or 1s. So one can make use of any aspect of computer's power if writing programs in assembly.

Assembly is specific to machine architecture. IA32 (also called x86, i386) is the most popular architecture for PC.

1. Register
   Can be classified in 4 types:
   - general purpose (eax, ebx, ecx, edx)
   - pointer/index (esp, ebp, esi, edi)
   - instruction pointer (eip)
   - flags (eflags)
   
   These are all 32 bits. Each register contains 8-bit and 16-bit parts. Ex: eax (32 bits), ax (16 bits), ah (8 bits), al (8bits).
   
   
2. Instruction
   - arithmetic/logic: add, sub, and, or,...
   - control: jmp,..
   - data movement: mov,..
   
   
3. Operand
   - register: operand value is contained in register
   - immediate: operand value is a constant
   - memory: operand value is in memory
   
   
4. Addressing mode
   Addressing mode is the way to specify a memory address.
   - absolute:
     address = a value
   - register:
     address = register content
   - displacement:
     address = register content + a value
   - indexed:
     address = register content + a value + another register content (index) * another value (scale)
   
   
5. Subroutine
   - subroutine is a set of instructions
   - parameters passed to subroutine are usually pushed on stack
   

Some notes on QEMU

I am finding a computer emulator so that I can use to experiment some low-level softwares. There are two prominent free and open-source emulators: Bochs and QEMU. Bochs seems more popular but lacks of documentation. So I have decided to use QEMU because it's quite simple to use and well documented.

1. Installation (on Ubuntu)
    $ sudo apt-get install qemu

2. Start emulator
    $ qemu [options] [disk_image] 
       --> This means start an emulator with specified options and disk_image (usually contains OS)

    Ex:
      $ qemu linux.img
             --> Start an emulator with default options and its hard disk contains linux.img

    There are lots of options which specify how your emulated computer could be such as what type of its cpu, hard disk, video card, sound card,... You can get more details on each option in QEMU documentation.

3. Monitoring
    QEMU provides a way to monitoring your emulator in which you can inspect your emulator, control it, change its devices, query its status,...

    You can switch back and forth between the emulator and its monitor with keystrokes: Ctrl+Alt+2 and Ctrl+Alt+1

    Some monitoring commands:
    (qemu) help or ? [cmd] 
    (qemu) change device setting
    (qemu) x/fmt addr
           Virtual memory dump starting at addr
    (qemu) xp/fmt addr
           Physical memory dump starting at addr 
    ...

Use helpers in controller

Rails applied Restful as part of its design.

To follow Restful, you should:

1. Model your web app as resources
2. Manipulate your app's resources through a conventional interface

Ex:
- if you have Product resource then urls to CRUD (Create, Edit, Update, Delete) this resource would be:

Action	Urls	Web Method	Restful Interface
Create	/products	POST	products_url
Edit	/products/1/edit	POST	edit_product_url
Update	/products	PUT	product_url
Delete	/products	DELETE	product_url

Then to get links to delete/edit a product through Restful interface, we can use link_to method as below:

link_to 'Edit', edit_product_path(product)

link_to 'Remove', product_path(product), :confirm => 'Are you sure?', 
        :method => :delete

By default, you can only use above interfaces in View layer. How can we use those in Controller layer?

• In Rails 2, call through @template variable
  @template.link_to('Edit', edit_product_path(product))

• In Rails 3, call through view_context method
  view_context.link_to('Delete', product_path(product), :confirm => 'Are you sure?', :method => :delete)

References

[1] http://stackoverflow.com/questions/3300582/rails-3-template-variable-inside-controllers-is-nil

[2] http://railscasts.com/episodes/132-helpers-outside-views