implement sizeof and alignof operator

compiler/semmagic.nim

@@ -326,13 +326,19 @@ proc magicsAfterOverloadResolution(c: PContext, n: PNode,
       # TODO there is no proper way to find out if a type cannot be queried for the size.
       let size = getSize(c.config, n[1].typ)
       # We just assume here that the type might come from the c backend
-      if size > 0:
+      if size == szImportedType:
+        # Forward to the c code generation to emit a `sizeof` in the C code.
+        result = n
+      elif size >= 0:
         result = newIntNode(nkIntLit, size)
         result.info = n.info
         result.typ = n.typ
       else:
-        # Forward to the c code generation to emit a `sizeof` in the C code.
-        result = n
+
+        localError(c.config, n.info, "cannot evaluate 'sizeof' because its type is not defined completely")
+
+        result = nil
+
 
   of mAlignOf:
     result = newIntNode(nkIntLit, getAlign(c.config, n[1].typ))

compiler/sizealignoffsetimpl.nim

@@ -3,9 +3,9 @@ proc align(address, alignment: BiggestInt): BiggestInt =
   result = (address + (alignment - 1)) and not (alignment - 1)
 
 const
-  szNonConcreteType* = -3
+  szImportedType*     = -3
   szIllegalRecursion* = -2
-  szUnknownSize* = -1
+  szUncomputedSize*   = -1
 
 proc computeSizeAlign(conf: ConfigRef; typ: PType): void
 
@@ -115,7 +115,7 @@ proc computeObjectOffsetsFoldFunction(conf: ConfigRef; n: PNode, initialOffset:
 
   else:
     result.align = 1
-    result.offset  = szNonConcreteType
+    result.offset  = szImportedType
 
 
 var recDepth = 0
@@ -162,20 +162,28 @@ proc computePackedObjectOffsetsFoldFunction(conf: ConfigRef; n: PNode, initialOf
     result = n.sym.offset + n.sym.typ.size
 
   else:
-    result = szNonConcreteType
+    result = szImportedType
 
 # TODO this one needs an alignment map of the individual types
 
-proc computeSizeAlign(conf: ConfigRef; typ: PType): void =
+proc computeSizeAlign(conf: ConfigRef; typ: PType) =
   ## computes and sets ``size`` and ``align`` members of ``typ``
 
-  let hasSize = typ.size >= 0
-  let hasAlign = typ.align >= 0
+  let hasSize  = typ.size  >= 0 or typ.size == szImportedType
+  let hasAlign = typ.align >= 0 or typ.size == szImportedType
 
   if hasSize and hasAlign:
     # nothing to do, size and align already computed
     return
 
+  if typ.sym != nil and typ.sym.flags * {sfCompilerProc, sfImportc} == {sfImportc} and
+     typ.kind == tyObject:
+    echo "setting type as imported type"
+    debug(typ.sym)
+    typ.size  = szImportedType
+    typ.align = szImportedType
+    return
+
   # This function can only calculate both, size and align at the same time.
   # If one of them is already set this value is stored here and reapplied
   let revertSize = typ.size
@@ -260,8 +268,8 @@ proc computeSizeAlign(conf: ConfigRef; typ: PType): void =
 
   of tySet:
     if typ.sons[0].kind == tyGenericParam:
-      typ.size  = szUnknownSize
-      typ.align = szUnknownSize # in original version this was 1
+      typ.size  = szUncomputedSize
+      typ.align = szUncomputedSize # in original version this was 1
     else:
       length = lengthOrd(conf, typ.sons[0])
       if length <= 8:
@@ -370,8 +378,8 @@ proc computeSizeAlign(conf: ConfigRef; typ: PType): void =
       typ.size = typ.lastSon.size
       typ.align = typ.lastSon.align
     else:
-      typ.size = szUnknownSize
-      typ.align = szUnknownSize
+      typ.size = szUncomputedSize
+      typ.align = szUncomputedSize
 
   of tyTypeDesc:
     computeSizeAlign(conf, typ.base)
@@ -389,8 +397,8 @@ proc computeSizeAlign(conf: ConfigRef; typ: PType): void =
       typ.size = typ.lastSon.size
       typ.align = typ.lastSon.align
     else:
-      typ.size = szUnknownSize
-      typ.align = szUnknownSize
+      typ.size = szUncomputedSize
+      typ.align = szUncomputedSize
   else:
-    typ.size  = szUnknownSize
-    typ.align = szUnknownSize
+    typ.size  = szUncomputedSize
+    typ.align = szUncomputedSize

compiler/types.nim

@@ -1273,16 +1273,11 @@ proc getReturnType*(s: PSym): PType =
 
 proc getAlign*(conf: ConfigRef; typ: PType): BiggestInt =
   computeSizeAlign(conf, typ)
-
   result = typ.align
-  if result < 0:
-    internalError(conf, "getAlign: " & $typ.kind)
 
 proc getSize*(conf: ConfigRef; typ: PType): BiggestInt =
   computeSizeAlign(conf, typ)
   result = typ.size
-  if result < 0:
-    internalError(conf, "getSize: " & $typ.kind)
 
 proc containsGenericTypeIter(t: PType, closure: RootRef): bool =
   case t.kind

compiler/vmgen.nim

@@ -1223,6 +1223,8 @@ proc genMagic(c: PCtx; n: PNode; dest: var TDest; m: TMagic) =
       # produces a value
     else:
       globalError(c.config, n.info, "expandToAst requires a call expression")
+  of mSizeOf, mAlignOf:
+    globalError(c.config, n.info, "cannot evaluate 'sizeof/alignof' because its type is not defined completely")
   of mRunnableExamples:
     discard "just ignore any call to runnableExamples"
   else:

lib/posix/posix_other.nim

@@ -475,7 +475,6 @@ type
     sin_family*: TSa_Family ## AF_INET.
     sin_port*: InPort      ## Port number.
     sin_addr*: InAddr      ## IP address.
-    sin_zero: array[16 - 2 - 2 - 4, uint8]
 
   In6Addr* {.importc: "struct in6_addr", pure, final,
               header: "<netinet/in.h>".} = object ## struct in6_addr

lib/system.nim

@@ -613,7 +613,7 @@ proc unsafeNew*[T](a: var ref T, size: Natural) {.magic: "New", noSideEffect.}
   ## of the passed ``size``. This should only be used for optimization
   ## purposes when you know what you're doing!
 
-proc sizeof*[T](x: T): int {.magic: "SizeOf", noSideEffect, compileTime.}
+proc sizeof*[T](x: T): int {.magic: "SizeOf", noSideEffect.}
   ## returns the size of ``x`` in bytes. Since this is a low-level proc,
   ## its usage is discouraged - using ``new`` for the most cases suffices
   ## that one never needs to know ``x``'s size. As a special semantic rule,
@@ -630,16 +630,15 @@ proc sizeof*[T](x: T): int {.magic: "SizeOf", noSideEffect, compileTime.}
 
 when defined(nimHasalignOf):
   proc alignof*[T](x: T): int {.magic: "AlignOf", noSideEffect.}
-  when defined(nimtypedescfixed):
-    proc alignof*(x: typedesc): int {.magic: "AlignOf", noSideEffect.}
+  proc alignof*(x: typedesc): int {.magic: "AlignOf", noSideEffect.}
 
   proc offsetOfDotExpr(typeAccess: typed): int {.magic: "OffsetOf", noSideEffect, compileTime.}
 
-  template offsetOf*[T](t : typedesc[T]; member: untyped): int =
+  template offsetOf*[T](t: typedesc[T]; member: untyped): int =
     var tmp: T
     offsetOfDotExpr(tmp.member)
 
-  template offsetOf*[T](value : T; member: untyped): int =
+  template offsetOf*[T](value: T; member: untyped): int =
     offsetOfDotExpr(value.member)
 
   #proc offsetOf*(memberaccess: typed): int {.magic: "OffsetOf", noSideEffect.}

lib/system/alloc.nim

@@ -73,8 +73,8 @@ type
     next, prev: PBigChunk    # chunks of the same (or bigger) size
     data: AlignType      # start of usable memory
 
-template smallChunkOverhead: int = sizeof(SmallChunk)-sizeof(AlignType)
-template bigChunkOverhead:   int = sizeof(BigChunk)-sizeof(AlignType)
+template smallChunkOverhead(): untyped = sizeof(SmallChunk)-sizeof(AlignType)
+template bigChunkOverhead(): untyped = sizeof(BigChunk)-sizeof(AlignType)
 
 # ------------- chunk table ---------------------------------------------------
 # We use a PtrSet of chunk starts and a table[Page, chunksize] for chunk
@@ -371,7 +371,7 @@ iterator elements(t: IntSet): int {.inline.} =
       r = r.next
 
 proc isSmallChunk(c: PChunk): bool {.inline.} =
-  return c.size <= SmallChunkSize-smallChunkOverhead
+  return c.size <= SmallChunkSize-smallChunkOverhead()
 
 proc chunkUnused(c: PChunk): bool {.inline.} =
   result = (c.prevSize and 1) == 0
@@ -748,7 +748,7 @@ proc rawAlloc(a: var MemRegion, requestedSize: int): pointer =
   var size = roundup(requestedSize, MemAlign)
   sysAssert(size >= requestedSize, "insufficient allocated size!")
   #c_fprintf(stdout, "alloc; size: %ld; %ld\n", requestedSize, size)
-  if size <= SmallChunkSize-smallChunkOverhead:
+  if size <= SmallChunkSize-smallChunkOverhead():
     # allocate a small block: for small chunks, we use only its next pointer
     var s = size div MemAlign
     var c = a.freeSmallChunks[s]
@@ -758,7 +758,7 @@ proc rawAlloc(a: var MemRegion, requestedSize: int): pointer =
       sysAssert c.size == PageSize, "rawAlloc 3"
       c.size = size
       c.acc = size
-      c.free = SmallChunkSize - smallChunkOverhead - size
+      c.free = SmallChunkSize - smallChunkOverhead() - size
       c.next = nil
       c.prev = nil
       listAdd(a.freeSmallChunks[s], c)
@@ -771,7 +771,7 @@ proc rawAlloc(a: var MemRegion, requestedSize: int): pointer =
       #  c_fprintf(stdout, "csize: %lld; size %lld\n", c.size, size)
       sysAssert c.size == size, "rawAlloc 6"
       if c.freeList == nil:
-        sysAssert(c.acc + smallChunkOverhead + size <= SmallChunkSize,
+        sysAssert(c.acc + smallChunkOverhead() + size <= SmallChunkSize,
                   "rawAlloc 7")
         result = cast[pointer](cast[ByteAddress](addr(c.data)) +% c.acc)
         inc(c.acc, size)
@@ -787,7 +787,7 @@ proc rawAlloc(a: var MemRegion, requestedSize: int): pointer =
       sysAssert(allocInv(a), "rawAlloc: before listRemove test")
       listRemove(a.freeSmallChunks[s], c)
       sysAssert(allocInv(a), "rawAlloc: end listRemove test")
-    sysAssert(((cast[ByteAddress](result) and PageMask) - smallChunkOverhead) %%
+    sysAssert(((cast[ByteAddress](result) and PageMask) - smallChunkOverhead()) %%
                size == 0, "rawAlloc 21")
     sysAssert(allocInv(a), "rawAlloc: end small size")
     inc a.occ, size
@@ -846,11 +846,11 @@ proc rawDealloc(a: var MemRegion, p: pointer) =
       inc(c.free, s)
     else:
       inc(c.free, s)
-      if c.free == SmallChunkSize-smallChunkOverhead:
+      if c.free == SmallChunkSize-smallChunkOverhead():
         listRemove(a.freeSmallChunks[s div MemAlign], c)
         c.size = SmallChunkSize
         freeBigChunk(a, cast[PBigChunk](c))
-    sysAssert(((cast[ByteAddress](p) and PageMask) - smallChunkOverhead) %%
+    sysAssert(((cast[ByteAddress](p) and PageMask) - smallChunkOverhead()) %%
                s == 0, "rawDealloc 2")
   else:
     # set to 0xff to check for usage after free bugs:
@@ -874,7 +874,7 @@ proc isAllocatedPtr(a: MemRegion, p: pointer): bool =
       if isSmallChunk(c):
         var c = cast[PSmallChunk](c)
         var offset = (cast[ByteAddress](p) and (PageSize-1)) -%
-                     smallChunkOverhead
+                     smallChunkOverhead()
         result = (c.acc >% offset) and (offset %% c.size == 0) and
           (cast[ptr FreeCell](p).zeroField >% 1)
       else:
@@ -892,7 +892,7 @@ proc interiorAllocatedPtr(a: MemRegion, p: pointer): pointer =
       if isSmallChunk(c):
         var c = cast[PSmallChunk](c)
         var offset = (cast[ByteAddress](p) and (PageSize-1)) -%
-                     smallChunkOverhead
+                     smallChunkOverhead()
         if c.acc >% offset:
           sysAssert(cast[ByteAddress](addr(c.data)) +% offset ==
                     cast[ByteAddress](p), "offset is not what you think it is")
@@ -927,7 +927,7 @@ proc ptrSize(p: pointer): int =
   sysAssert(not chunkUnused(c), "ptrSize")
   result = c.size -% sizeof(FreeCell)
   if not isSmallChunk(c):
-    dec result, bigChunkOverhead
+    dec result, bigChunkOverhead()
 
 proc alloc(allocator: var MemRegion, size: Natural): pointer {.gcsafe.} =
   result = rawAlloc(allocator, size+sizeof(FreeCell))

tests/misc/tsizeof.nim

@@ -2,8 +2,6 @@ discard """
   output: "OK"
 """
 
-# TODO test with small sized kind
-
 type
   TMyEnum = enum
     tmOne, tmTwo, tmThree, tmFour

tests/misc/tsizeof2.nim

@@ -0,0 +1,11 @@
+discard """
+errormsg: "cannot evaluate 'sizeof/alignof' because its type is not defined completely"
+line: 9
+"""
+
+type
+  MyStruct {.importc: "MyStruct".} = object
+
+const i = sizeof(MyStruct)
+
+echo i