herb

MacroModel · MacroModel · commit f8509f6675ed · 2025-11-21T06:08:03.000Z
diff --git a/HERBCEPTION_IMPLEMENTATION_SUMMARY.md b/HERBCEPTION_IMPLEMENTATION_SUMMARY.md
@@ -0,0 +1,121 @@
+# Herbception Implementation in LLVM
+
+## Overview
+This document summarizes the implementation of herbception (P0709R4) in LLVM/Clang, a zero-overhead deterministic exception mechanism using carry flag for error propagation.
+
+## Design Decisions
+
+### 1. Syntax
+- **`herbthrows`/`herbthrows(bool)`**: Function exception specification for herbception
+  - `herbthrows` or `herbthrows(true)`: Function can throw herbceptions
+  - `herbthrows(false)`: Function cannot throw herbceptions  
+- **`herbthrow (domain_ptr) (value)`**: Throw a herbception with domain and error value
+- **`herbcatch (type var)`**: Catch herbceptions after try-catch blocks
+- **Coexistence**: `herbthrows` and `noexcept` are independent - functions can use both
+
+### 2. Error Representation
+- **Domain**: Pointer to global object (ensures uniqueness across static libraries)
+- **Value**: `size_t` user-defined error code
+- **Default type**: `std::error` with `void* domain` and `size_t value`
+- **Custom types**: Support via conversion operator `operator herbthrows(void*, size_t)`
+
+### 3. x86-64 ABI
+- **RAX**: Domain pointer
+- **RDX**: Error value  
+- **CF=1**: Indicates error occurred
+- **Control flow**: `jc error_handler` for error path (cold path)
+- **Propagation**: Maintain CF=1 for automatic error propagation
+
+## Implementation Status
+
+### ✅ Completed
+
+#### 1. Frontend - Keywords and Tokens
+- Added `herbthrows`, `herbthrow`, `herbcatch` keywords to `TokenKinds.def`
+- Updated exception specification types in `ExceptionSpecificationType.h`
+- Added helper functions `isHerbThrowsSpec()`, `isComputedHerbThrows()`
+
+#### 2. AST Nodes
+- **`HerbThrowExpr`**: AST node for herbthrow expressions in `ExprCXX.h`
+- **`HerbCatchStmt`**: AST node for herbcatch statements in `StmtCXX.h`
+- Added statement classes to `StmtNodes.td`
+- Added bitfields to `Stmt.h` for herbthrow expressions
+
+#### 3. Parser
+- **`ParseHerbThrowExpression()`**: Parses `herbthrow (domain) (value)` in `ParseExprCXX.cpp`
+- Modified `tryParseExceptionSpecification()` to handle `herbthrows` in `ParseDeclCXX.cpp`
+- Added herbthrow handling to expression parser in `ParseExpr.cpp`
+- Added declaration to `Parser.h`
+
+#### 4. Semantic Analysis
+- **`ActOnHerbThrow()`**: Semantic action for herbthrow in `SemaExprCXX.cpp`
+  - Validates domain is pointer type
+  - Validates value convertible to size_t
+  - Checks function can throw herbceptions
+- Added declaration to `Sema.h`
+
+### 🔄 In Progress
+
+#### 5. CodeGen - LLVM IR Generation
+Need to implement in `CGException.cpp`:
+- Generate carry flag check/set instructions
+- Use RAX/RDX for domain/value passing
+- Generate `jc` for error path branching
+
+### ⏳ Pending
+
+#### 6. X86 Backend
+- Modify X86 instruction selection to preserve carry flag
+- Add intrinsics for `setc`/`jc` if needed
+- Ensure calling convention respects RAX/RDX/CF usage
+
+#### 7. herbcatch Implementation  
+- Parse herbcatch blocks following try-catch
+- Generate CF check before herbcatch entry
+- Load domain/value from RAX/RDX
+
+#### 8. Runtime Support
+- Define `std::error` type structure
+- Implement domain generation mechanism
+- Add conversion operator support
+
+#### 9. Testing
+- Unit tests for parser
+- Semantic analysis tests
+- CodeGen tests
+- End-to-end execution tests
+
+## File Changes Summary
+
+### Modified Files
+1. `clang/include/clang/Basic/TokenKinds.def` - Added keywords
+2. `clang/include/clang/Basic/ExceptionSpecificationType.h` - Added EST types
+3. `clang/include/clang/Basic/StmtNodes.td` - Added statement nodes
+4. `clang/include/clang/AST/ExprCXX.h` - Added HerbThrowExpr
+5. `clang/include/clang/AST/StmtCXX.h` - Added HerbCatchStmt  
+6. `clang/include/clang/AST/Stmt.h` - Added bitfields
+7. `clang/include/clang/Parse/Parser.h` - Added ParseHerbThrowExpression
+8. `clang/include/clang/Sema/Sema.h` - Added ActOnHerbThrow
+9. `clang/lib/Parse/ParseDeclCXX.cpp` - Handle herbthrows spec
+10. `clang/lib/Parse/ParseExprCXX.cpp` - Parse herbthrow expression
+11. `clang/lib/Parse/ParseExpr.cpp` - Recognize herbthrow
+12. `clang/lib/Sema/SemaExprCXX.cpp` - Implement ActOnHerbThrow
+
+### Test File
+- `test_herbception.cpp` - Example usage demonstrating syntax
+
+## Next Steps
+
+1. **Complete CodeGen**: Implement LLVM IR generation for herbthrow/herbcatch
+2. **X86 Backend**: Add carry flag handling in instruction selection
+3. **Runtime Library**: Create minimal runtime for std::error
+4. **Testing**: Comprehensive test suite
+5. **Optimization**: Inline error checks, optimize propagation paths
+
+## Notes
+
+- The implementation maintains complete separation between C++ exceptions and herbceptions
+- Functions can support both exception models simultaneously
+- Zero-overhead when no errors occur (just CF check)
+- Deterministic, no hidden control flow
+- Compatible with static libraries, no DLL boundary issues
diff --git a/clang/include/clang/AST/ExprCXX.h b/clang/include/clang/AST/ExprCXX.h
@@ -1261,6 +1261,58 @@ class CXXThrowExpr : public Expr {
   }
 };
 
+/// Represents a herbthrow expression for herbception.
+///
+/// This handles 'herbthrow (domain) (value)' expressions.
+/// Both domain and value expressions must be present.
+class HerbThrowExpr : public Expr {
+  friend class ASTStmtReader;
+
+  /// The domain expression (should evaluate to a pointer).
+  Stmt *Domain;
+  
+  /// The value expression (should evaluate to size_t).
+  Stmt *Value;
+
+public:
+  // \p Ty is the void type which is used as the result type of the
+  // expression. The \p Loc is the location of the herbthrow keyword.
+  // \p Domain is the domain pointer expression and \p Value is the error value.
+  HerbThrowExpr(Expr *Domain, Expr *Value, QualType Ty, SourceLocation Loc)
+      : Expr(HerbThrowExprClass, Ty, VK_PRValue, OK_Ordinary), 
+        Domain(Domain), Value(Value) {
+    HerbThrowExprBits.ThrowLoc = Loc;
+    setDependence(computeDependence(this));
+  }
+  HerbThrowExpr(EmptyShell Empty) : Expr(HerbThrowExprClass, Empty) {}
+
+  const Expr *getDomainExpr() const { return cast<Expr>(Domain); }
+  Expr *getDomainExpr() { return cast<Expr>(Domain); }
+  
+  const Expr *getValueExpr() const { return cast<Expr>(Value); }
+  Expr *getValueExpr() { return cast<Expr>(Value); }
+
+  SourceLocation getThrowLoc() const { return HerbThrowExprBits.ThrowLoc; }
+
+  SourceLocation getBeginLoc() const { return getThrowLoc(); }
+  SourceLocation getEndLoc() const LLVM_READONLY {
+    return getValueExpr()->getEndLoc();
+  }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == HerbThrowExprClass;
+  }
+
+  // Iterators
+  child_range children() {
+    return child_range(&Domain, &Value + 1);
+  }
+
+  const_child_range children() const {
+    return const_child_range(&Domain, &Value + 1);
+  }
+};
+
 /// A default argument (C++ [dcl.fct.default]).
 ///
 /// This wraps up a function call argument that was created from the
diff --git a/clang/include/clang/AST/Stmt.h b/clang/include/clang/AST/Stmt.h
@@ -844,6 +844,17 @@ class alignas(void *) Stmt {
     SourceLocation ThrowLoc;
   };
 
+  class HerbThrowExprBitfields {
+    friend class ASTStmtReader;
+    friend class HerbThrowExpr;
+
+    LLVM_PREFERRED_TYPE(ExprBitfields)
+    unsigned : NumExprBits;
+
+    /// The location of the "herbthrow".
+    SourceLocation ThrowLoc;
+  };
+
   class CXXDefaultArgExprBitfields {
     friend class ASTStmtReader;
     friend class CXXDefaultArgExpr;
@@ -1353,6 +1364,7 @@ class alignas(void *) Stmt {
     CXXNullPtrLiteralExprBitfields CXXNullPtrLiteralExprBits;
     CXXThisExprBitfields CXXThisExprBits;
     CXXThrowExprBitfields CXXThrowExprBits;
+    HerbThrowExprBitfields HerbThrowExprBits;
     CXXDefaultArgExprBitfields CXXDefaultArgExprBits;
     CXXDefaultInitExprBitfields CXXDefaultInitExprBits;
     CXXScalarValueInitExprBitfields CXXScalarValueInitExprBits;
diff --git a/clang/include/clang/AST/StmtCXX.h b/clang/include/clang/AST/StmtCXX.h
@@ -63,6 +63,48 @@ class CXXCatchStmt : public Stmt {
   friend class ASTStmtReader;
 };
 
+/// HerbCatchStmt - A herbcatch handler for herbception.
+///
+/// HerbCatchStmt is used for catching herbceptions (herb exceptions).
+/// It follows try-catch blocks and catches errors propagated via carry flag.
+class HerbCatchStmt : public Stmt {
+  SourceLocation CatchLoc;
+  /// The exception-declaration for herbception (always ::std::error or user type).
+  VarDecl *ExceptionDecl;
+  /// The handler block.
+  Stmt *HandlerBlock;
+
+public:
+  HerbCatchStmt(SourceLocation catchLoc, VarDecl *exDecl, Stmt *handlerBlock)
+  : Stmt(HerbCatchStmtClass), CatchLoc(catchLoc), ExceptionDecl(exDecl),
+    HandlerBlock(handlerBlock) {}
+
+  HerbCatchStmt(EmptyShell Empty)
+  : Stmt(HerbCatchStmtClass), ExceptionDecl(nullptr), HandlerBlock(nullptr) {}
+
+  SourceLocation getBeginLoc() const LLVM_READONLY { return CatchLoc; }
+  SourceLocation getEndLoc() const LLVM_READONLY {
+    return HandlerBlock->getEndLoc();
+  }
+
+  SourceLocation getCatchLoc() const { return CatchLoc; }
+  VarDecl *getExceptionDecl() const { return ExceptionDecl; }
+  QualType getCaughtType() const;
+  Stmt *getHandlerBlock() const { return HandlerBlock; }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == HerbCatchStmtClass;
+  }
+
+  child_range children() { return child_range(&HandlerBlock, &HandlerBlock+1); }
+
+  const_child_range children() const {
+    return const_child_range(&HandlerBlock, &HandlerBlock + 1);
+  }
+
+  friend class ASTStmtReader;
+};
+
 /// CXXTryStmt - A C++ try block, including all handlers.
 ///
 class CXXTryStmt final : public Stmt,
diff --git a/clang/include/clang/Basic/ExceptionSpecificationType.h b/clang/include/clang/Basic/ExceptionSpecificationType.h
@@ -29,7 +29,11 @@ enum ExceptionSpecificationType {
   EST_NoexceptTrue,     ///< noexcept(expression), evals to 'true'
   EST_Unevaluated,      ///< not evaluated yet, for special member function
   EST_Uninstantiated,   ///< not instantiated yet
-  EST_Unparsed          ///< not parsed yet
+  EST_Unparsed,         ///< not parsed yet
+  EST_HerbThrows,       ///< herbthrows
+  EST_HerbThrowsFalse,  ///< herbthrows(false)
+  EST_HerbThrowsTrue,   ///< herbthrows(true) or herbthrows
+  EST_HerbThrowsDependent ///< herbthrows(expression), value-dependent
 };
 
 inline bool isDynamicExceptionSpec(ExceptionSpecificationType ESpecType) {
@@ -55,6 +59,14 @@ inline bool isExplicitThrowExceptionSpec(ExceptionSpecificationType ESpecType) {
          ESpecType == EST_NoexceptFalse;
 }
 
+inline bool isHerbThrowsSpec(ExceptionSpecificationType ESpecType) {
+  return ESpecType >= EST_HerbThrows && ESpecType <= EST_HerbThrowsDependent;
+}
+
+inline bool isComputedHerbThrows(ExceptionSpecificationType ESpecType) {
+  return ESpecType == EST_HerbThrowsDependent;
+}
+
 /// Possible results from evaluation of a noexcept expression.
 enum CanThrowResult {
   CT_Cannot,
diff --git a/clang/include/clang/Basic/StmtNodes.td b/clang/include/clang/Basic/StmtNodes.td
@@ -51,6 +51,7 @@ def ObjCAutoreleasePoolStmt : StmtNode<Stmt>;
 
 // C++ statements
 def CXXCatchStmt : StmtNode<Stmt>;
+def HerbCatchStmt : StmtNode<Stmt>;
 def CXXTryStmt : StmtNode<Stmt>;
 def CXXForRangeStmt : StmtNode<Stmt>;
 
@@ -134,6 +135,7 @@ def CXXBoolLiteralExpr : StmtNode<Expr>;
 def CXXNullPtrLiteralExpr : StmtNode<Expr>;
 def CXXThisExpr : StmtNode<Expr>;
 def CXXThrowExpr : StmtNode<Expr>;
+def HerbThrowExpr : StmtNode<Expr>;
 def CXXDefaultArgExpr : StmtNode<Expr>;
 def CXXDefaultInitExpr : StmtNode<Expr>;
 def CXXScalarValueInitExpr : StmtNode<Expr>;
diff --git a/clang/include/clang/Basic/TokenKinds.def b/clang/include/clang/Basic/TokenKinds.def
@@ -379,6 +379,9 @@ KEYWORD(this                        , KEYCXX)
 KEYWORD(throw                       , KEYCXX)
 KEYWORD(true                        , BOOLSUPPORT|KEYC23)
 KEYWORD(try                         , KEYCXX)
+KEYWORD(herbthrows                  , KEYCXX)
+KEYWORD(herbthrow                   , KEYCXX)
+KEYWORD(herbcatch                   , KEYCXX)
 KEYWORD(typename                    , KEYCXX)
 KEYWORD(typeid                      , KEYCXX)
 KEYWORD(using                       , KEYCXX)
diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h
@@ -4769,6 +4769,14 @@ class Parser : public CodeCompletionHandler {
   ///         'throw' assignment-expression[opt]
   /// \endverbatim
   ExprResult ParseThrowExpression();
+  
+  /// ParseHerbThrowExpression - This handles the herbthrow expression.
+  /// 
+  /// \verbatim
+  ///       herbthrow-expression:
+  ///         'herbthrow' '(' expression ')' '(' expression ')'
+  /// \endverbatim
+  ExprResult ParseHerbThrowExpression();
 
   //===--------------------------------------------------------------------===//
   // C++ 2.13.5: C++ Boolean Literals
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
@@ -8471,6 +8471,10 @@ class Sema final : public SemaBase {
   ExprResult ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *expr);
   ExprResult BuildCXXThrow(SourceLocation OpLoc, Expr *Ex,
                            bool IsThrownVarInScope);
+  
+  //// ActOnHerbThrow - Parse herbthrow expressions.
+  ExprResult ActOnHerbThrow(Scope *S, SourceLocation OpLoc, 
+                           Expr *DomainExpr, Expr *ValueExpr);
 
   /// CheckCXXThrowOperand - Validate the operand of a throw.
   bool CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ThrowTy, Expr *E);
diff --git a/clang/lib/Parse/ParseDeclCXX.cpp b/clang/lib/Parse/ParseDeclCXX.cpp
@@ -3992,7 +3992,8 @@ ExceptionSpecificationType Parser::tryParseExceptionSpecification(
 
   // Handle delayed parsing of exception-specifications.
   if (Delayed) {
-    if (Tok.isNot(tok::kw_throw) && Tok.isNot(tok::kw_noexcept))
+    if (Tok.isNot(tok::kw_throw) && Tok.isNot(tok::kw_noexcept) && 
+        Tok.isNot(tok::kw_herbthrows))
       return EST_None;
 
     // Consume and cache the starting token.
@@ -4035,6 +4036,47 @@ ExceptionSpecificationType Parser::tryParseExceptionSpecification(
            "Produced different number of exception types and ranges.");
   }
 
+  // Check for herbthrows specification.
+  if (Tok.is(tok::kw_herbthrows)) {
+    SourceLocation HerbThrowsLoc = ConsumeToken();
+    ExceptionSpecificationType HerbThrowsType = EST_HerbThrowsTrue;
+    
+    // Check for optional (bool) parameter
+    if (Tok.is(tok::l_paren)) {
+      BalancedDelimiterTracker T(*this, tok::l_paren);
+      T.consumeOpen();
+      
+      // Parse the boolean expression
+      EnterExpressionEvaluationContext ConstantEvaluated(
+          Actions, Sema::ExpressionEvaluationContext::ConstantEvaluated);
+      ExprResult HerbThrowsExpr = ParseConstantExpressionInExprEvalContext();
+      
+      T.consumeClose();
+      if (!HerbThrowsExpr.isInvalid()) {
+        // Determine if it's true/false/dependent
+        bool Value;
+        if (!HerbThrowsExpr.get()->isValueDependent() &&
+            HerbThrowsExpr.get()->EvaluateAsBooleanCondition(Value, Actions.Context)) {
+          HerbThrowsType = Value ? EST_HerbThrowsTrue : EST_HerbThrowsFalse;
+        } else {
+          HerbThrowsType = EST_HerbThrowsDependent;
+          NoexceptExpr = HerbThrowsExpr; // Store the expression for later evaluation
+        }
+        SpecificationRange = SourceRange(HerbThrowsLoc, T.getCloseLocation());
+      }
+    } else {
+      // Bare herbthrows is equivalent to herbthrows(true)
+      SpecificationRange = SourceRange(HerbThrowsLoc, HerbThrowsLoc);
+    }
+    
+    if (Result == EST_None) {
+      Result = HerbThrowsType;
+    } else {
+      // Can't combine herbthrows with other exception specs
+      Diag(HerbThrowsLoc, diag::err_dynamic_and_noexcept_specification);
+    }
+  }
+
   // If there's no noexcept specification, we're done.
   if (Tok.isNot(tok::kw_noexcept))
     return Result;
diff --git a/clang/lib/Parse/ParseExpr.cpp b/clang/lib/Parse/ParseExpr.cpp
diff --git a/clang/lib/Parse/ParseExprCXX.cpp b/clang/lib/Parse/ParseExprCXX.cpp
diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp
diff --git a/test_herbception.cpp b/test_herbception.cpp
