Return to QUAD CVS log

Up to [CSRG BSD Unix] / 43BSDReno / libexec / pcc / ccom.vax

Annotation of 43BSDReno/libexec/pcc/ccom.vax/QUAD, revision 1.1

1.1     ! root        1: Tweaking the PCC to provide 64-bit integers
        !             2: -------------------------------------------
        !             3: 
        !             4: A 64-bit integer data type would be nice to have to implement data
        !             5: structures such as millisecond time values, multi-gigabyte disk
        !             6: addresses and so on.
        !             7: 
        !             8: Since the number of bits in the type field of the compiler type word is
        !             9: only 16 and all 16 types are used, it makes sense to pick a type which
        !            10: is not useful and overload it for the 64-bit type.  Thus we'll use LONG
        !            11: and ULONG types to represent signed and unsigned 64-bit integers
        !            12: internally.  Externally we must provide some name other than 'long' for
        !            13: the type or else all hell will break loose with standard width
        !            14: definitions; it's been suggested that we use 'quad', following its use
        !            15: in VAX assembler.  (I suppose a flag could be used to signal the
        !            16: compiler that 'long' really should be 64 bits, so we can eventually
        !            17: convert existing code to appropriately handle three integer sizes in
        !            18: legal C.)
        !            19: 
        !            20: Data structures
        !            21: ---------------
        !            22: 
        !            23: It's probably simplest to just punt on quad constants for the time
        !            24: being.  This would eliminate the only situation in which the compiler's
        !            25: own data structures would need to be adjusted to handle 64-bit
        !            26: integers.  Once the compiler has been bootstrapped for 64-bit
        !            27: variables, 64-bit constants should follow with reasonable ease.
        !            28: 
        !            29: Parameters in header files
        !            30: --------------------------
        !            31: 
        !            32: The size and alignment of LONG and ULONG will need to change in
        !            33: macdefs.h.  This shouldn't cause any problems (famous last words).
        !            34: 
        !            35: Algorithm changes, file by file
        !            36: -------------------------------
        !            37: 
        !            38: cgram.y
        !            39:        The production for switch statements may need to change if we
        !            40:        want to allow quad type switch expressions.  Do PDP-11
        !            41:        compilers permit long switch expressions?  I doubt it...
        !            42: pftn.c
        !            43:     dclstruct
        !            44:        We will probably have to permit quad size enums eventually.
        !            45:        Since the plan is to hold off on quad size constants, we can
        !            46:        punt for now.
        !            47: code.c
        !            48:     type_move
        !            49:        MOVL must become MOVQ.  Since this code is intended for
        !            50:        handling register variables, and we likely won't allow register
        !            51:        quads, we don't need to worry too hard about this.
        !            52: local.c
        !            53:     clocal
        !            54:        PCONV and SCONV code may need be changed to know about quads.
        !            55:        The SCONV code is primarily concerned with constants (again).
        !            56:     cisreg
        !            57:        LONG and ULONG will no longer be permitted types for register
        !            58:        variables.
        !            59:     ctype
        !            60:        This routine converts 'unsupported' types into INT; now that
        !            61:        LONG and ULONG have a separate meaning from INT, the routine
        !            62:        becomes an identity function.
        !            63:     tlen
        !            64:        LONG and ULONG now have size 2.  Cthulhu knows how much code
        !            65:        assumes int types will always fit in 1 register.
        !            66: local2.c
        !            67:     tlen
        !            68:        Same as the first pass tlen.
        !            69:     prtype
        !            70:        Prints the letter ([blwfd]) which is appended to VAX
        !            71:        instructions for operations of a particular type.  We need to
        !            72:        add 'q' for LONG and ULONG, although we won't be using prtype
        !            73:        very much!
        !            74:     zzzcode
        !            75:        The tough code generation issues get tougher...  The 'A'
        !            76:        conversion code gets considerably more complex.  The 'C' stack
        !            77:        count code needs a little adjustment to work from SZINT instead
        !            78:        of SZLONG.
        !            79:     collapsible
        !            80:        Again, conversions are a lot tougher with quads.
        !            81:     shumul
        !            82:        Pointers and arrays of quads need to be handled right.
        !            83: order.c
        !            84:     setbin
        !            85:     setasop
        !            86:        It won't be quite so simple to rewrite quads into register to
        !            87:        make a stuck tree work.
        !            88:     sucomp
        !            89:        We need to take another look at the special case hacking for
        !            90:        various flavors of integers.
        !            91: stab.c
        !            92:     inittypes
        !            93:        Add the 'quad' type.  Does dbx know what to do with 64-bit
        !            94:        integers?  I sure doubt it.
        !            95: table.c
        !            96:     Oof.  Here is where the real work is.  We get to use EMUL to
        !            97:     calculate 64-bit products (the architecture handbook conveniently
        !            98:     provides the algorithm) and other kinds of fun.

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.