x86-64 System V abi - argument classification for parameter passing

See the gcc implementation.

Clarification for Point 1 (in response to the comment saying "eight is a typo and should be two instead"):

1. If the size of an object is larger than eight eightbytes, or it contains unaligned fields, it has class MEMORY.

      /* On x86-64 we pass structures larger than 64 bytes on the stack.  */
      if (bytes > 64)
        return 0;

The function returns the number of registers to use for parameters, and zero means memory should be used instead.

(Later, after the analysis, if there are more than two eightbytes, registers are used only if the first is SSE and the rest are SSEUP, as pointed out in 5.(c):

(c) If the size of the aggregate exceeds two eightbytes and the first eightbyte isn't SSE or any other eightbyte isn't SSEUP, the whole argument is passed in memory.)

Q1. In point (3), by "each is classified separately", do authors mean "each eightbyte"?

Yes. In the code, each eightbyte is called a word.

Each eightbyte gets initialized to class NO_CLASS.

  int words = CEIL (bytes + (bit_offset % 64) / 8, UNITS_PER_WORD);
  // ...
      for (i = 0; i < words; i++)
        classes[i] = X86_64_NO_CLASS;

Q2. In point (4), by "Each field of an object", do they mean "each field of an eightbyte that is a result of (separation in) point (3)?

No, they mean each field of a struct/class, or union, or array elements. These are handled in a couple of places in the code, but you will see for loops like:

          for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))

This is why it is recursive. The fields themselves can be aggregate types. The entire logic is applied starting with each field, and the recursive function:

• either returns 0, meaning the whole thing is passed in memory,
• or it returns the number of registers (eightbytes) that would be used and the classes of each one (recursion through the nested fields will terminate at fields with non-aggregate types).

                      num = classify_argument (TYPE_MODE (type), type,
                                               subclasses,
                                               (int_bit_position (field)
                                               + bit_offset) % 512);
                      if (!num)
                        return 0;

Q3. In point (4), by "two fields" in "always two fields are considered", do they mean two successive fields?

I don't think "fields" is accurate here. And not successive. What it is doing is merging the classes determined so far for each word, with the classes recursively determined for the fields that correspond to the same words. See below:

                      pos = (int_bit_position (field)
                            + (bit_offset % 64)) / 8 / 8;
                      for (i = 0; i < num && (i + pos) < words; i++)
                        classes[i + pos]
                          = merge_classes (subclasses[i], classes[i + pos]);

Starting from pos (the eightbyte that this field is in) each class gets merged with the subclass determined by the recursive call for the field.

Q4. In point (4), by "the resulting class", do they mean the class of the object, or of the eightbyte, or of the second considered field, or of something else?

This is now describing the merge_classes function, which takes the two classes and returns the merged class for the eightbyte. We are iterating over fields but classes are for eightbytes.

In the last case, where is the resulting class used?

Each class will determine the type of the corresponding register (GPR/SSE/X87 etc.).

Q5. In point (4), what if there is only one field? Or an even number of fields?

I hope "two field" is answered at this point. If, say, a struct has one field, the class will be initialized for that eightbyte as NO_CLASS, then for the field it will be determined as, say, INTEGER. Then at merge, the class will become INTEGER.

Q6. In point (5), "one of the classes" of a field, or of an eightbyte?

Of an eightbyte. Classes are always referring to an eightbyte.