SSO: better switch to enable it

compiler/ccgcalls.nim

@@ -230,11 +230,11 @@ proc genOpenArraySlice(p: BProc; q: PNode; formalType, destType: PType; prepareF
   of tyString, tySequence:
     let atyp = skipTypes(a.t, abstractInst)
     if formalType.skipTypes(abstractInst).kind in {tyVar} and atyp.kind == tyString and
-        optSeqDestructors in p.config.globalOptions and not p.config.isDefined("nimsso"):
+        optSeqDestructors in p.config.globalOptions and not p.config.usesSso():
       let bra = byRefLoc(p, a)
       p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimPrepareStrMutationV2"),
         bra)
-    if p.config.isDefined("nimsso") and
+    if p.config.usesSso() and
         skipTypes(a.t, abstractVar + abstractInst).kind == tyString:
       let strPtr = if atyp.kind in {tyVar} and not compileToCpp(p.module): ra
                    else: addrLoc(p.config, a)
@@ -296,11 +296,11 @@ proc openArrayLoc(p: BProc, formalType: PType, n: PNode; result: var Builder) =
     of tyString, tySequence:
       let ntyp = skipTypes(n.typ, abstractInst)
       if formalType.skipTypes(abstractInst).kind in {tyVar} and ntyp.kind == tyString and
-          optSeqDestructors in p.config.globalOptions and not p.config.isDefined("nimsso"):
+          optSeqDestructors in p.config.globalOptions and not p.config.usesSso():
         let bra = byRefLoc(p, a)
         p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimPrepareStrMutationV2"),
           bra)
-      if p.config.isDefined("nimsso") and
+      if p.config.usesSso() and
           skipTypes(n.typ, abstractVar + abstractInst).kind == tyString:
         if ntyp.kind in {tyVar} and not compileToCpp(p.module):
           let ra = a.rdLoc
@@ -335,7 +335,7 @@ proc openArrayLoc(p: BProc, formalType: PType, n: PNode; result: var Builder) =
         let ra = a.rdLoc
         var t = TLoc(snippet: cDeref(ra))
         let lt = lenExpr(p, t)
-        if p.config.isDefined("nimsso"):
+        if p.config.usesSso():
           result.add(cCall(cgsymValue(p.module, "nimStrData"), ra))
           result.addArgumentSeparator()
           result.add(cCall(cgsymValue(p.module, "nimStrLen"), t.snippet))
@@ -370,7 +370,7 @@ proc expressionsNeedsTmp(p: BProc, a: TLoc): TLoc =
 proc genArgStringToCString(p: BProc, n: PNode; result: var Builder; needsTmp: bool) {.inline.} =
   var a = initLocExpr(p, n[0])
   let tmp = withTmpIfNeeded(p, a, needsTmp)
-  let ra = if p.config.isDefined("nimsso"): byRefLoc(p, tmp) else: tmp.rdLoc
+  let ra = if p.config.usesSso(): byRefLoc(p, tmp) else: tmp.rdLoc
   result.addCall(cgsymValue(p.module, "nimToCStringConv"), ra)
 
 proc genArg(p: BProc, n: PNode, param: PSym; call: PNode; result: var Builder; needsTmp = false) =

compiler/ccgexprs.nim

@@ -322,7 +322,7 @@ proc genOpenArrayConv(p: BProc; d: TLoc; a: TLoc; flags: TAssignmentFlags) =
         bra)
     let rd = d.rdLoc
     let la = lenExpr(p, a)
-    if p.config.isDefined("nimsso"):
+    if p.config.usesSso():
       let bra = byRefLoc(p, a)
       p.s(cpsStmts).addFieldAssignment(rd, "Field0",
         cCall(cgsymValue(p.module, "nimStrData"), bra))
@@ -963,7 +963,7 @@ proc genDeref(p: BProc, e: PNode, d: var TLoc) =
 
 proc cowBracket(p: BProc; n: PNode) =
   if n.kind == nkBracketExpr and optSeqDestructors in p.config.globalOptions and
-      not p.config.isDefined("nimsso"):
+      not p.config.usesSso():
     let strCandidate = n[0]
     if strCandidate.typ.skipTypes(abstractInst).kind == tyString:
       var a: TLoc = initLocExpr(p, strCandidate)
@@ -989,7 +989,7 @@ proc genAddr(p: BProc, e: PNode, d: var TLoc) =
     # bug #19497
     d.lode = e
   else:
-    let ssoStrSub = p.config.isDefined("nimsso") and e[0].kind == nkBracketExpr and
+    let ssoStrSub = p.config.usesSso() and e[0].kind == nkBracketExpr and
         e[0][0].typ.skipTypes(abstractVar).kind == tyString
     var a: TLoc = initLocExpr(p, e[0], if ssoStrSub: {lfEnforceDeref, lfPrepareForMutation} else: {})
     if e[0].kind in {nkHiddenStdConv, nkHiddenSubConv, nkConv} and not ignoreConv(e[0]):
@@ -1318,7 +1318,7 @@ proc genSeqElem(p: BProc, n, x, y: PNode, d: var TLoc) =
   if skipTypes(a.t, abstractVar).kind in {tyRef, tyPtr}:
     a.snippet = cDeref(a.snippet)
 
-  if p.config.isDefined("nimsso") and ty.kind == tyString:
+  if p.config.usesSso() and ty.kind == tyString:
     let bra = byRefLoc(p, a)
     if lfPrepareForMutation in d.flags:
       # Use nimStrAtMutV3 to get a mutable reference (char*) to the element.
@@ -2150,7 +2150,7 @@ proc genRepr(p: BProc, e: PNode, d: var TLoc) =
       putIntoDest(p, b, e, ra & cArgumentSeparator & ra & "Len_0", a.storage)
     of tyString, tySequence:
       let la = lenExpr(p, a)
-      if p.config.isDefined("nimsso") and
+      if p.config.usesSso() and
           skipTypes(a.t, abstractVarRange).kind == tyString:
         let bra = byRefLoc(p, a)
         putIntoDest(p, b, e,
@@ -2743,7 +2743,7 @@ proc genConv(p: BProc, e: PNode, d: var TLoc) =
 
 proc convStrToCStr(p: BProc, n: PNode, d: var TLoc) =
   var a: TLoc = initLocExpr(p, n[0])
-  let arg = if p.config.isDefined("nimsso"): byRefLoc(p, a) else: rdLoc(a)
+  let arg = if p.config.usesSso(): byRefLoc(p, a) else: rdLoc(a)
   putIntoDest(p, d, n,
     cgCall(p, "nimToCStringConv", arg),
     a.storage)
@@ -2822,7 +2822,7 @@ proc genMove(p: BProc; n: PNode; d: var TLoc) =
     var src: TLoc = initLocExpr(p, n[2])
     let destVal = rdLoc(a)
     let srcVal = rdLoc(src)
-    if p.config.isDefined("nimsso") and
+    if p.config.usesSso() and
         n[1].typ.skipTypes(abstractVar).kind == tyString:
       # SmallString: destroy dst then struct-copy src; no .p field aliasing needed
       genStmts(p, n[3])
@@ -2871,7 +2871,7 @@ proc genDestroy(p: BProc; n: PNode) =
     case t.kind
     of tyString:
       var a: TLoc = initLocExpr(p, arg)
-      if p.config.isDefined("nimsso"):
+      if p.config.usesSso():
         # SmallString: delegate to nimDestroyStrV1 (rc-based, handles static strings)
         p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimDestroyStrV1"), rdLoc(a))
       else:
@@ -4243,7 +4243,7 @@ proc genBracedInit(p: BProc, n: PNode; isConst: bool; optionalType: PType; resul
       genConstObjConstr(p, n, isConst, result)
     of tyString, tyCstring:
       if optSeqDestructors in p.config.globalOptions and n.kind != nkNilLit and ty == tyString:
-        if p.config.isDefined("nimsso"):
+        if p.config.usesSso():
           genStringLiteralV3Const(p.module, n, isConst, result)
         else:
           genStringLiteralV2Const(p.module, n, isConst, result)

compiler/ccgliterals.nim

@@ -22,7 +22,7 @@ template detectVersion(field, corename) =
     result = 1
 
 proc detectStrVersion(m: BModule): int =
-  if m.g.config.isDefined("nimsso") and
+  if m.g.config.usesSso() and
       m.g.config.selectedGC in {gcArc, gcOrc, gcYrc, gcAtomicArc, gcHooks}:
     result = 3
   else:

compiler/ccgstmts.nim

@@ -1940,7 +1940,7 @@ proc genAsgn(p: BProc, e: PNode, fastAsgn: bool) =
   elif optFieldCheck in p.options and isDiscriminantField(e[0]):
     genLineDir(p, e)
     asgnFieldDiscriminant(p, e)
-  elif p.config.isDefined("nimsso") and e[0].kind == nkBracketExpr and
+  elif p.config.usesSso() and e[0].kind == nkBracketExpr and
       e[0][0].typ.skipTypes(abstractVar).kind == tyString:
     # nimsso: s[i] = c  →  nimStrPutV3(&s, i, c)  (handles COW internally)
     genLineDir(p, e)

compiler/cgen.nim

@@ -389,7 +389,7 @@ proc lenField(p: BProc, val: Rope): Rope {.inline.} =
 
 proc lenExpr(p: BProc; a: TLoc): Rope =
   if optSeqDestructors in p.config.globalOptions:
-    if p.config.isDefined("nimsso") and a.lode != nil and a.t != nil and
+    if p.config.usesSso() and a.lode != nil and a.t != nil and
         a.t.skipTypes(abstractInst).kind == tyString:
       result = cCall(cgsymValue(p.module, "nimStrLen"), rdLoc(a))
     else:
@@ -534,7 +534,7 @@ proc resetLoc(p: BProc, loc: var TLoc) =
 
     let atyp = skipTypes(loc.t, abstractInst)
     let rl = rdLoc(loc)
-    if typ.kind == tyString and p.config.isDefined("nimsso"):
+    if typ.kind == tyString and p.config.usesSso():
       # SmallString zero state: bytes=0 (slen=0 in low byte, all inline chars zeroed)
       if atyp.kind in {tyVar, tyLent}:
         p.s(cpsStmts).addAssignment(derefField(rl, "bytes"), cIntValue(0))
@@ -592,7 +592,7 @@ proc constructLoc(p: BProc, loc: var TLoc, isTemp = false) =
   let typ = loc.t
   if optSeqDestructors in p.config.globalOptions and skipTypes(typ, abstractInst + {tyStatic}).kind in {tyString, tySequence}:
     let rl = rdLoc(loc)
-    if skipTypes(typ, abstractInst + {tyStatic}).kind == tyString and p.config.isDefined("nimsso"):
+    if skipTypes(typ, abstractInst + {tyStatic}).kind == tyString and p.config.usesSso():
       # SmallString zero state: bytes=0 (slen=0 in low byte, all inline chars zeroed)
       p.s(cpsStmts).addFieldAssignment(rl, "bytes", cIntValue(0))
       p.s(cpsStmts).addFieldAssignment(rl, "more", NimNil)

compiler/commands.nim

@@ -250,6 +250,7 @@ const
   errGuiConsoleOrLibExpectedButXFound = "'gui', 'console', 'lib' or 'staticlib' expected, but '$1' found"
   errInvalidExceptionSystem = "'goto', 'setjmp', 'cpp' or 'quirky' expected, but '$1' found"
   errInvalidFeatureButXFound = Feature.toSeq.map(proc(val:Feature): string = "'$1'" % $val).join(", ") & " expected, but '$1' found"
+  errDefaultOrSsoExpectedButXFound = "'default' or 'sso' expected, but '$1' found"
 
 template warningOptionNoop(switch: string) =
   warningDeprecated(conf, info, "'$#' is deprecated, now a noop" % switch)
@@ -306,6 +307,13 @@ proc testCompileOptionArg*(conf: ConfigRef; switch, arg: string, info: TLineInfo
     else:
       result = false
       localError(conf, info, errInvalidExceptionSystem % arg)
+  of "strings":
+    case arg.normalize
+    of "default": result = conf.selectedStrings == stringDefault
+    of "sso": result = conf.selectedStrings == stringSso
+    else:
+      result = false
+      localError(conf, info, errDefaultOrSsoExpectedButXFound % arg)
   of "experimental":
     try:
       result = conf.features.contains parseEnum[Feature](arg)
@@ -750,6 +758,17 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
     processMemoryManagementOption(switch, arg, pass, info, conf)
   of "mm":
     processMemoryManagementOption(switch, arg, pass, info, conf)
+  of "strings":
+    expectArg(conf, switch, arg, pass, info)
+    if pass in {passCmd2, passPP}:
+      case arg.normalize
+      of "default":
+        conf.selectedStrings = stringDefault
+      of "sso":
+        conf.selectedStrings = stringSso
+        defineSymbol(conf.symbols, "nimsso")
+      else:
+        localError(conf, info, errDefaultOrSsoExpectedButXFound % arg)
   of "warnings", "w":
     if processOnOffSwitchOrList(conf, {optWarns}, arg, pass, info): listWarnings(conf)
   of "warning": processSpecificNote(arg, wWarning, pass, info, switch, conf)

compiler/liftdestructors.nim

@@ -732,7 +732,7 @@ proc fillStrOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   of attachedAsgn, attachedDeepCopy, attachedDup:
     body.add callCodegenProc(c.g, "nimAsgnStrV2", c.info, genAddr(c, x), y)
   of attachedSink:
-    if c.g.config.isDefined("nimsso"):
+    if c.g.config.usesSso():
       # SmallString: destroy old dst, then bit-copy src (no rc increment — this is a move).
       # No .p aliasing check needed; rc-based destroy handles COW sharing correctly.
       doAssert t.destructor != nil

compiler/nim.nim

@@ -121,6 +121,11 @@ proc handleCmdLine(cache: IdentCache; conf: ConfigRef) =
         conf.cmd in {cmdGendepend, cmdNifC, cmdIc, cmdM}:
       initOrcDefines(conf)
 
+  if conf.selectedStrings == stringSso and
+      conf.selectedGC notin {gcArc, gcOrc, gcYrc, gcAtomicArc}:
+    rawMessage(conf, errGenerated,
+      "--strings:sso requires --mm:arc, --mm:orc, --mm:yrc, or --mm:atomicArc")
+
   mainCommand(graph)
   if conf.hasHint(hintGCStats): echo(GC_getStatistics())
   #echo(GC_getStatistics())

compiler/options.nim

@@ -267,6 +267,10 @@ type
     ccNone, ccGcc, ccNintendoSwitch, ccLLVM_Gcc, ccCLang, ccBcc, ccVcc,
     ccTcc, ccEnv, ccIcl, ccIcc, ccClangCl, ccHipcc, ccNvcc
 
+  StringsMode* = enum
+    stringDefault = "default"
+    stringSso = "sso"
+
   ExceptionSystem* = enum
     excNone,   # no exception system selected yet
     excSetjmp, # setjmp based exception handling
@@ -366,6 +370,7 @@ type
     implicitCmd*: bool # whether some flag triggered an implicit `command`
     selectedGC*: TGCMode       # the selected GC (+)
     exc*: ExceptionSystem
+    selectedStrings*: StringsMode
     hintProcessingDots*: bool # true for dots, false for filenames
     verbosity*: int            # how verbose the compiler is
     numberOfProcessors*: int   # number of processors
@@ -698,6 +703,7 @@ template quitOrRaise*(conf: ConfigRef, msg = "") =
 
 proc importantComments*(conf: ConfigRef): bool {.inline.} = conf.cmd in cmdDocLike + {cmdIdeTools}
 proc usesWriteBarrier*(conf: ConfigRef): bool {.inline.} = conf.selectedGC >= gcRefc
+proc usesSso*(conf: ConfigRef): bool {.inline.} = conf.selectedStrings == stringSso
 
 template compilationCachePresent*(conf: ConfigRef): untyped =
   false

lib/system/strs_v3.nim

@@ -504,18 +504,57 @@ proc setLengthStr(s: var SmallString; newLen: int; zeroing: bool) =
   let slen = ssLen(s)
   let curLen = if slen > PayloadSize: s.more.fullLen else: slen
   if newLen == curLen: return
-  if newLen <= 0:
-    # Pattern 's.setLen 0' is common for avoiding allocations; do NOT free the buffer.
+  if newLen < curLen:
+    # Shrinking:
     if slen > PayloadSize:
       if slen == HeapSlen and s.more.rc == 1:
-        s.more.fullLen = 0
-        s.more.data[0] = '\0'
+        # Unique heap block: keep the buffer allocated to avoid alloc/dealloc
+        # ping-pong when callers shrink then grow (e.g. setLen(0) + add loops).
+        s.more.fullLen = newLen
+        s.more.data[newLen] = '\0'
       else:
-        # shared or static block: detach and go back to empty inline
-        nimDestroyStrV1(s)
-        s.bytes = 0  # slen=0, all inline chars zeroed
+        # shared or static block: detach and go back to inline
+        if newLen <= 0:
+          nimDestroyStrV1(s)
+          s.bytes = 0
+        else:
+          let old = s.more
+          let inl = inlinePtr(s)
+          copyMem(inl, addr old.data[0], newLen)
+          inl[newLen] = '\0'
+          if slen == HeapSlen and atomicSubFetch(old.rc, 1) == 0:
+            dealloc(old)
+          if newLen < AlwaysAvail:
+            when system.cpuEndian == littleEndian:
+              let keepBits = (newLen + 1) * 8
+              let charMask = ((uint(1) shl keepBits) - 1'u) and not 0xFF'u
+              s.bytes = (s.bytes and charMask) or uint(newLen)
+            else:
+              let discardBits = (AlwaysAvail - newLen) * 8
+              let slenBit = 8 * (sizeof(uint) - 1)
+              let charMask = not ((uint(1) shl discardBits) - 1'u) and not (0xFF'u shl slenBit)
+              s.bytes = (s.bytes and charMask) or (uint(newLen) shl slenBit)
+          else:
+            setSSLen(s, newLen)
     else:
-      s.bytes = 0  # slen=0, all inline chars zeroed (SWAR safe)
+      # inline/medium shrink
+      if newLen <= 0:
+        s.bytes = 0
+      else:
+        let inl = inlinePtr(s)
+        inl[newLen] = '\0'
+        if newLen < AlwaysAvail:
+          when system.cpuEndian == littleEndian:
+            let keepBits = (newLen + 1) * 8
+            let charMask = ((uint(1) shl keepBits) - 1'u) and not 0xFF'u
+            s.bytes = (s.bytes and charMask) or uint(newLen)
+          else:
+            let discardBits = (AlwaysAvail - newLen) * 8
+            let slenBit = 8 * (sizeof(uint) - 1)
+            let charMask = not ((uint(1) shl discardBits) - 1'u) and not (0xFF'u shl slenBit)
+            s.bytes = (s.bytes and charMask) or (uint(newLen) shl slenBit)
+        else:
+          setSSLen(s, newLen)
     return
   if slen <= PayloadSize:
     if newLen <= PayloadSize:
@@ -564,34 +603,11 @@ proc setLengthStr(s: var SmallString; newLen: int; zeroing: bool) =
       s.more = p
       setSSLen(s, HeapSlen)
   else:
-    # currently long
-    if newLen <= PayloadSize:
-      # shrink back to inline/medium
-      let old = s.more
-      let inl = inlinePtr(s)
-      copyMem(inl, addr old.data[0], newLen)
-      inl[newLen] = '\0'
-      if slen == HeapSlen and atomicSubFetch(old.rc, 1) == 0:
-        dealloc(old)
-      # Zero padding bytes in `bytes` for SWAR invariant
-      if newLen < AlwaysAvail:
-        when system.cpuEndian == littleEndian:
-          let keepBits = (newLen + 1) * 8
-          let charMask = ((uint(1) shl keepBits) - 1'u) and not 0xFF'u
-          s.bytes = (s.bytes and charMask) or uint(newLen)
-        else:
-          let discardBits = (AlwaysAvail - newLen) * 8
-          let slenBit = 8 * (sizeof(uint) - 1)
-          let charMask = not ((uint(1) shl discardBits) - 1'u) and not (0xFF'u shl slenBit)
-          s.bytes = (s.bytes and charMask) or (uint(newLen) shl slenBit)
-      else:
-        setSSLen(s, newLen)
-    else:
-      # long -> long
-      ensureUniqueLong(s, curLen, newLen) # sets fullLen = newLen
-      if newLen > curLen:
-        zeroMem(addr s.more.data[curLen], newLen - curLen)
-      s.more.data[newLen] = '\0'
+    # currently long: grow within the heap buffer (shrinking already returned above)
+    ensureUniqueLong(s, curLen, newLen) # sets fullLen = newLen
+    if zeroing and newLen > curLen:
+      zeroMem(addr s.more.data[curLen], newLen - curLen)
+    s.more.data[newLen] = '\0'
 
 proc setLengthStrV2(s: var SmallString; newLen: int) {.compilerRtl.} =
   ## Sets the length of `s` to `newLen`, zeroing new bytes on growth.

tests/stdlib/tstring.nim

@@ -1,5 +1,5 @@
 discard """
-  matrix: "--backend:c --mm:refc; --backend:c --mm:orc; --backend:c --mm:orc -d:nimsso; --backend:cpp --mm:refc; --backend:cpp --mm:orc; --backend:js --mm:refc; --backend:js --mm:orc"
+  matrix: "--backend:c --mm:refc; --backend:c --mm:orc; --backend:c --mm:orc --strings:sso; --backend:cpp --mm:refc; --backend:cpp --mm:orc; --backend:js --mm:refc; --backend:js --mm:orc"
 """
 
 from std/sequtils import toSeq, map

tests/system/tnimsso.nim

@@ -1,5 +1,5 @@
 discard """
-  matrix: "-d:nimsso"
+  matrix: "--strings:sso --mm:orc"
   targets: "c cpp"
 """