types.nr 5.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142
  1. .bp
  2. .P1 "TYPE REPRESENTATIONS"
  3. .PP
  4. The representations used for typed objects are not precisely
  5. specified by EM.
  6. Sometimes we only specify that a typed object occupies a
  7. certain amount of space and state no further restrictions.
  8. If one wants to have a different representation of the value of
  9. an object on the stack one has to use a convert instruction
  10. in most cases.
  11. We do specify some relations between the representations of
  12. types.
  13. This allows some intermixed use of operators for different types
  14. on the same object(s).
  15. For example, the instruction ZER pushes signed and
  16. unsigned integers with the value zero and empty sets.
  17. ZER has as only argument the size of the object.
  18. .QQ
  19. The representation of floating point numbers is a good example,
  20. it allows widely varying implementations.
  21. The only ways to create floating point numbers are via
  22. initialization and via conversions from integer numbers.
  23. Only by using conversions to integers and comparing
  24. two floating point numbers with each other, can these numbers
  25. be converted to human readable output.
  26. Implementations may use base 10, base 2 or any other
  27. base for exponents, and have freedom in choosing the range of
  28. exponent and mantissa.
  29. .QQ
  30. Other types are more precisely described.
  31. In the following paragraphs a description will be given of the
  32. restrictions imposed on the representation of the types used.
  33. A number \fBn\fP used in these paragraphs indicates the size of
  34. the object in \fIbits\fP.
  35. .P2 "Unsigned integers"
  36. .PP
  37. The range of unsigned integers is 0..
  38. .Ex 2 "\fBn\fP" -1.
  39. A binary representation is assumed.
  40. The order of the bits within an object is knowingly left
  41. unspecified.
  42. Discussing bit order within each 8-bit byte is academic,
  43. so the only real freedom of this specification lies in the byte
  44. order.
  45. We really do not care whether an implementation of a 4-byte
  46. integer has its bytes in a particular order of significance.
  47. This of course means that some sequences of instructions have
  48. unpredictable effects.
  49. For example:
  50. .DS
  51. LOC 258 ; STL 0 ; LAL 0 ; LOI 1 ( wordsize >=2 )
  52. .DE
  53. The value on the stack after executing this sequence
  54. can be anything,
  55. but will most likely be 1 or 2.
  56. .QQ
  57. Conversion between unsigned integers of different sizes have to
  58. be done with explicit convert instructions.
  59. One cannot simply pad an unsigned integer with zero's at either end
  60. and expect a correct result.
  61. .QQ
  62. We assume existence of at least single word unsigned arithmetic
  63. in any implementation.
  64. .P2 "Signed Integers"
  65. .PP
  66. The range of signed integers is
  67. .Ex \-2 "\fBn\fP\-1" ~..
  68. .Ex 2 "\fBn\fP\-1" \-1,
  69. in other words the range of signed integers of \fBn\fP bits
  70. using two's complement arithmetic.
  71. The representation is the same as for unsigned integers except the range
  72. .Ex 2 "\fBn\fP\-1" ~..
  73. .Ex 2 "\fBn\fP" \-1
  74. is mapped on the
  75. range
  76. .Ex \-2 "\fBn\fP\-1" ~..~\-1.
  77. In other words, the most significant bit is used as sign bit.
  78. The convert instructions between signed and unsigned integers
  79. of the same size can be used to catch errors.
  80. .QQ
  81. The value
  82. .Ex \-2 "\fBn\fP\-1"
  83. is used for undefined
  84. signed integers.
  85. EM implementations should trap when this value is used in an
  86. operation on signed integers.
  87. The instruction mask, accessed with SIM and LIM \-~see chapter 9~\-,
  88. can be used to disable such traps.
  89. .QQ
  90. We assume existence of at least single word signed arithmetic
  91. in any implementation.
  92. .P2 "Floating point values"
  93. .PP
  94. Floating point values must have a signed mantissa and a signed
  95. exponent.
  96. Although no base is specified, base 2 is the normal choice,
  97. because the FEF instruction pushes the exponent in base 2.
  98. .QQ
  99. The implementation of floating point arithmetic is optional.
  100. The compilers currently in use have runtime parameters for the
  101. size of the floating point values they should use.
  102. Common choices are 4 and/or 8 bytes.
  103. .P2 Pointers
  104. .PP
  105. EM has two kinds of pointers: for instruction and for data
  106. space.
  107. Each kind can only be used for its own space, conversion between
  108. these two subtypes is impossible.
  109. We assume that pointers have a range from 0 upwards.
  110. Any implementation may have holes in the pointer range between
  111. fragments.
  112. One can of course not expect to be able to address two megabyte
  113. of memory using a 2-byte pointer.
  114. Normally, a 2-byte pointer allows up to 65536 bytes of
  115. addressable memory.
  116. .QQ
  117. Pointer representation has one restriction.
  118. The pointer with the same representation as the integer zero of
  119. the same size should be invalid.
  120. Some languages and/or runtime systems represent the nil
  121. pointer as zero.
  122. .P2 "Bit sets"
  123. .PP
  124. All bit sets of size \fBn\fP are subsets of the set
  125. {~i~|~i>=0,~i<\fBn\fP~}.
  126. A bit set contains a bit for each element showing its
  127. presence or absence.
  128. Bit sets are subdivided into words.
  129. The word with the lowest EM address governs the subset
  130. {~i~|~i>=0,~i<\fBm\fP~}, where \fBm\fP is the number of bits in
  131. a word.
  132. The next higher words each govern the next higher \fBm\fP set elements.
  133. The relation between a set with size of
  134. a word and an unsigned integer word is that
  135. the value of the unsigned integer is the summation of the
  136. 2\v'-0.5m'i\v'0.5m' where i is in the set.
  137. .QQ
  138. Example: a 2-word bit set (wordsize 2) containing the
  139. elements 1, 6, 8, 15, 18, 21, 27 and 28 is composed of two
  140. integers, e.g. at addresses 40 and 42.
  141. The word at 40 contains the value 33090 (or~\-32446),
  142. the word at 42 contains the value 6180.