Hasty Briefsbeta

All tags

#c++

159 stories total

Bilingual

Hardening Mode for the Compiler
9 months ago
- Joint proposal from AaronBallman, shafik, Endill, and cor3ntin to improve C and C++ program safety and security.
- Current mechanisms for safety and security in Clang are scattered and poorly documented, making them hard to use.
- Proposal to unify existing mechanisms into an easy-to-use hardened mode for users.
- User expectations need to shift: breaking changes in compiler releases for safety are a feature, not a bug.
- GCC's -fhardened mode is referenced as prior art, but Clang may differ in implementation.
- Goals include enabling various flags (-f, -m, -D, -W) and macros automatically, requiring modern language standards, and passing linker flags.
- Multiple approaches proposed: config file, new driver mode, orthogonal flags, or a single flag for hardening.
- Community feedback sought on high-level direction before proceeding with detailed proposals.
Compiler Bug Causes Compiler Bug: How a 12-Year-Old G++ Bug Took Down Solidity
9 months ago
- Solc (Solidity compiler) crashes on valid code due to a combination of bugs in G++, Boost, and C++20.
- The issue stems from a 12-year-old G++ bug in overload resolution, favoring non-member functions incorrectly.
- C++20's symmetric comparison feature causes infinite recursion when combined with Boost's outdated comparison pattern.
- Boost versions before 1.75 have a problematic operator== implementation that triggers recursive rewrites in C++20.
- The crash occurs in Solidity when processing compile-time rational comparisons, like T[0].
- Affected environments include G++ < 14, Boost < 1.75, and C++20-enabled builds.
- Recommendations: Update Boost to ≥ 1.75 or use G++ v14+ to avoid the issue.
- This highlights the fragility of build stacks and the importance of testing under multiple compiler and library versions.
Highway, a C++ library that provides portable SIMD/vector intrinsics
9 months ago
- Highway is a C++ library offering portable SIMD/vector intrinsics.
- It focuses on efficient and performance-portable vector software.
- Provides API synopsis, high-level overview, and quick reference.
- Discusses static vs. dynamic dispatch and headers.
- Includes notation, vector and tag types, and unspecified vector types usage.
- Covers targets, operations, and preprocessor macros.
- Details advanced macros and detecting supported targets.
- Explains advanced configuration macros and compiler support.
- Includes type traits and memory allocation.
- Offers tips for speeding up code on older x86 platforms.
- Shares design philosophy and frequently asked questions.
- Details Highway implementation specifics and release testing process.
Proxy 4: The Next Leap in C++ Polymorphism
8 months ago
- Proxy 4 is a production-grade, modern C++ library for runtime polymorphism, now mature after years of use in the Windows OS codebase.
- Proxy enables polymorphic code without inheritance or traditional virtual functions, offering portability, flexibility in object lifetimes, and high performance.
- New features in Proxy 4 include composable facade capabilities (skills), easy borrowing and weak references (proxy_view and weak_proxy), and shared ownership APIs (make_proxy_shared).
- Proxy 4 introduces smarter dispatch and conversion, recursive facade patterns, and quality improvements like bitwise trivially relocatable support and C++20 modules.
- Major version compatibility guidelines are provided for upgrading from Proxy 3 to Proxy 4, ensuring smooth transitions for large codebases.
- Proxy 4 is header-only, cross-platform, and supports GCC, Clang, MSVC, and NVIDIA HPC compilers, with improved diagnostics and debugging experience.
Stepanov's biggest blunder? The curious case of adjacent difference
8 months ago
- std::adjacent_difference in C++ computes differences between adjacent elements and copies the first element unmodified, which limits its practicality due to type mismatches.
- The design choice to preserve the first element was deliberate to maintain symmetry with std::partial_sum, allowing reconstruction of the original sequence.
- Discrete calculus connects std::adjacent_difference and std::partial_sum to the fundamental theorem of calculus, illustrating differentiation and integration concepts.
- The article critiques the design of std::adjacent_difference for being less generic and breaking symmetry with continuous calculus derivatives.
- The q programming language's deltas function offers a more flexible approach by allowing a seed value, maintaining symmetry without type constraints.
Shared_ptr<T>: the (not always) atomic reference counted smart pointer
8 months ago
- shared_ptr<T> in GNU's libstdc++ optimizes reference counting by checking if pthread_create is imported, using atomic operations only if necessary.
- The optimization was discovered during a micro-benchmark comparing Rust's Arc::clone with C++'s shared_ptr<T>, where C++ was unexpectedly faster due to non-atomic increments.
- The safety of this optimization is generally sound but could break in rare cases like statically compiled binaries loading shared libraries without pthread symbols.
- Other C++ implementations like libcxx and VisualC++ handle atomic operations differently, with libcxx allowing compile-time thread disabling.
- Rust's Arc cannot adopt this optimization as it explicitly guarantees atomic operations, differentiating it from Rc which is non-atomic.
How is Ultrassembler so fast?
8 months ago
- Ultrassembler is a high-performance RISC-V assembler library designed for integration within C++ projects, avoiding the inefficiency of external assembler calls.
- It outperforms existing assemblers like GNU as and llvm-mc by 10-20 times in speed, processing approximately 1000 CPU instructions per RISC-V instruction assembled.
- Key optimizations include zero-overhead exception handling for error reporting, fast data structures for instruction and register lookup, and preallocated memory pools to minimize syscall overhead.
- Value speculation and smart search algorithms reduce parsing time, while compile-time templates ensure efficient immediate value verification.
- Memory-friendly struct organization, inline functions, and minimized string operations further enhance performance.
- Link-time optimization and compiler flag adjustments strip unnecessary overhead, making Ultrassembler exceptionally fast and efficient.
We need to seriously think about what to do with C++ modules
8 months ago
- C++ modules should demonstrate a 5× to 10× compilation speedup to justify their existence; otherwise, they should be removed from the standard.
- The primary goal of C++ modules was faster compilation times, but focus has shifted to build isolation (preventing macro leakage, etc.), which is less critical for most developers.
- C++ modules were accepted into C++20 despite warnings about implementation difficulties, leading to a lack of functional implementations years later.
- Modules require tight integration between compilers and build systems, but the lack of a unified approach has resulted in fragmented and inefficient implementations.
- The design of C++ modules was overly ambitious and lacked real-world testing, leading to complexity and poor performance.
- An iterative approach to module development, starting with small-scale prototypes, would have been more effective.
- The 'import std' initiative aims to improve compilation speed by replacing standard library headers with modules, but gains may only match precompiled headers (10-20% speedup).
- A custom standard library experiment showed a 4× compilation speedup, suggesting 5× is a reasonable target for modules.
- Using modules introduces disadvantages like code rewrites, loss of portability, and increased build complexity.
- The C++ committee's focus should be on features that provide clear benefits without excessive trade-offs.
C++: Strongly Happens Before?
8 months ago
- The article discusses the concept of 'Strongly Happens Before' introduced in C++20 to address issues in the memory model.
- It presents a simple program with multiple threads using different memory orders (seq_cst, release, relaxed) to illustrate potential execution scenarios.
- The article explains modification order and coherence rules in C++ to analyze the program's behavior.
- It highlights a cycle in the execution graph that makes the program's behavior invalid under the 'happens before' relation but valid under 'strongly happens before'.
- The article explores why certain architectures like Power allow such executions and the trade-offs involved in fixing the standard versus implementations.
- It provides a detailed analysis of Power architecture's memory model and synchronization constructs (sync, lwsync).
- The article defines 'strongly happens before' and explains how it resolves the cycle in the execution graph.
- It concludes by emphasizing the complexity of mixing memory orders and provides resources for further reading.
The repercussions of a typo in C++ & Rust
8 months ago
- Missing an ampersand in C++ can lead to copying data instead of passing by reference, causing performance issues.
- Rust's defaults prevent such mistakes by moving objects by default unless they implement the Copy trait.
- C++ requires vigilance and tooling to catch these issues, whereas Rust's compiler enforces correct behavior.
- Rust's 'pass by value' behavior differs from C++ by moving objects, which is more efficient for large objects.
- Rust's type system prevents accidental copying, making it harder to introduce performance bugs.
- C++ can also prevent copying with explicit constructors and rules, but it's more cumbersome than Rust's approach.
- Rust's defaults reduce mental burden and let the compiler handle optimizations and correctness checks.
Declarative GUI Toolkit Slint 1.13 released
8 months ago
- Slint 1.13 introduces live-preview for Rust and C++ development, allowing UI updates without restarting the application.
- Live-preview can be enabled via environment variables (SLINT_LIVE_PREVIEW=1) and specific build system features.
- The update includes an interactive outline panel in the live-preview, enhancing UI element management.
- New language features include local variables (let), key event interception, and syntactic sugar for callbacks.
- Timer component now has explicit helper functions (start, stop, restart), improving usability.
- Added conic gradients (@conic-gradient) for advanced visual effects like pie charts and color wheels.
- Various fixes and improvements across platforms, including native context menus on Windows and better Python support.
- Encourages community engagement through GitHub stars, Mattermost chat, and project sharing.
C++26: Erroneous Behaviour
8 months ago
- C++ conferences frequently discuss safety, highlighting the need for improvements in both safety and the language's reputation.
- Undefined behavior is a major issue affecting software safety and stability, with uninitialized variables being a common problem.
- C++26 introduces 'erroneous behavior' for uninitialized reads, replacing undefined behavior with a well-defined but incorrect behavior that compilers can diagnose.
- Compilers like clang and gcc already have techniques to identify uninitialized reads, but erroneous behavior makes it practical by ensuring diagnostics.
- Uninitialized objects will be initialized to an implementation-specific value under erroneous behavior, with compilers encouraged to diagnose such issues.
- The [[indeterminate]] attribute allows deliberate uninitialized variables, but using them without initialization results in undefined behavior.
- Erroneous behavior applies to automatic storage duration variables, but dynamic storage and pointers also pose uninitialized variable risks.
- Function parameters can also be marked with [[indeterminate]], affecting their behavior when uninitialized.
- As of January 2025, no compilers support erroneous behavior, but it represents a significant step forward in C++ safety.
Show HN: C++ library for reading MacBook lid angle sensor data
8 months ago
- A C++ library for reading MacBook lid angle sensor data, reverse-engineered from HID device specifications.
- Features direct access to MacBook's built-in lid angle sensor with real-time precise angle measurements (0-360 degree range).
- High-performance C++14 implementation with comprehensive exception handling and a clean, easy-to-use API.
- Supports CMake build system and includes example programs for basic and continuous angle monitoring.
- Compatible with MacBook Pro 16-inch (2019) and newer models, including M2/M3/M4 series, with some restrictions on M1 MacBook Air/Pro.
- Device identification via Apple VID=0x05AC, PID=0x8104, using HID usage: Sensor page (0x0020), Orientation usage (0x008A).
- Data format includes a 16-bit angle value with 0.01-degree precision.
- Requires macOS 10.15 or later, Xcode Command Line Tools, and CMake 3.15 or later.
- Includes troubleshooting tips for common issues like device compatibility, sensor unavailability, and system permissions.
- Based on the original Lid Angle Sensor project by Sam Gold, extending functionality to C++ developers.
Automate compile_flags for C/C++ projects on the Zig build system
8 months ago
- Zig's build system for C/C++ projects lacks editor support for include paths and code intelligence.
- compile_flagz automatically generates compile_flags.txt from build.zig to solve this issue.
- The tool helps editors find include paths, enabling better code completion and navigation.
- Example use case: ROLLER, a decompilation project for the game Fatal Racing (Whiplash).
- Zig's build system simplifies cross-compilation but lacks IDE integration for C/C++ projects.
- compile_flagz generates compile_flags.txt, which language servers like clangd use for project settings.
- Setup involves adding compile_flagz as a dependency and configuring include paths in build.zig.
- Future plans include supporting additional compiler flags like -isystem, -std, and -D.
- The tool improves the development experience for C/C++ projects using Zig's build system.
A polyglot's guide to multiple-dispatch
8 months ago
- Introduction to multiple dispatch as an advanced abstraction technique in programming languages.
- Explanation of single dispatch vs. multiple dispatch, with examples in C++.
- Demonstration of a failed attempt to implement multiple dispatch in C++ using overloading.
- Presentation of the visitor pattern as a solution for multiple dispatch in C++.
- Discussion on symmetry and base-class defaults in multiple dispatch implementations.
- Critique of the visitor-based approach for being intrusive and hard to maintain.
- Introduction of a brute-force approach using dynamic_cast for multiple dispatch.
- Mention of Andrei Alexandrescu's work on automating multiple dispatch with templates.
- Overview of Bjarne Stroustrup's proposal for language-level support of multiple dispatch in C++.
- Conclusion highlighting the trade-offs of different multiple dispatch solutions in C++ and teaser for future articles on other languages.
Safe C++ proposal is not being continued
8 months ago
- The Safe C++ proposal aimed to introduce a safe subset of C++ with guarantees similar to Rust, without breaking existing code.
- Safe C++ required explicit opt-in via safe contexts, allowing incremental adoption while maintaining backward compatibility.
- The proposal faced unresolved issues, such as error reporting for borrow checking and interaction with templates.
- The Safety and Security working group decided to prioritize 'Profiles' over Safe C++, leading to its discontinuation.
- Profiles impose compile-time constraints on C++ usage to ensure safety, without introducing new language constructs.
- Profiles are seen as a more pragmatic and adoptable approach compared to the ambitious Safe C++ proposal.
- The C++ community showed resistance to adopting Rust-like safety models, preferring incremental improvements via Profiles.
- Profiles aim to standardize existing informal safety practices in C++, focusing on constraints rather than new semantics.
- While Profiles may offer weaker guarantees than Safe C++, they represent a realistic path forward for C++ safety.
Lexy: A parser combinator library for C++17
8 months ago
- Lexy is a parser combinator library for C++17 and onwards.
- Allows writing parsers using a convenient C++ DSL.
- Provides full control similar to handwritten parsers without manual work.
- No implicit backtracking or lookahead; user-specified conditions.
- Supports manual parsing integration and tracing for debugging.
- Easily integrated with pure C++ DSL and minimal standard library dependencies.
- Designed for text with Unicode support and automatic whitespace skipping.
- Features for programming languages like keyword parsing and error recovery.
- Supports binary input parsing with bytes, bits, and blobs.
- Comparison with other parsers like Boost.Spirit and PEGTL.
- Compilation times and error messages discussed.
- Benchmarks available for performance comparison.
- Documentation and tutorials available at lexy.foonathan.net.
Velox: A composable and extensible C++ execution engine library
8 months ago
- Velox is an open-source C++ library for building high-performance data processing components.
- It supports various analytical workloads including batch, interactive, stream processing, and AI/ML.
- Developed by Meta in partnership with companies like IBM, Intel, and Microsoft.
- Velox does not include a SQL parser or optimizer; it's designed for integration into other compute engines.
- Key components include Type system, Vector memory layout, Expression Eval, Functions, Operators, I/O connectors, and Resource Management.
- Extensible for custom types, functions, operators, file formats, storage adapters, and network serializers.
- Supports multiple compilers and platforms with specific version requirements.
- Includes setup scripts for macOS, Ubuntu, and CentOS to simplify dependency installation.
- Can be built and tested using Docker for convenience.
- Licensed under Apache 2.0, with community engagement via Slack, GitHub Issues, and Discussions.
How to join or concat ranges, C++26
8 months ago
- Modern C++ enhances range manipulation with new adaptors like `std::ranges::concat_view`, `std::ranges::join_view`, and `std::ranges::join_with_view`.
- `std::ranges::concat_view` (C++26) concatenates multiple independent ranges into one sequence, preserving structure and supporting random access if all ranges do.
- `std::ranges::join_view` (C++20) flattens a single range of ranges into a single sequence, removing nested boundaries without random access support.
- `std::ranges::join_with_view` (C++23) flattens a range of ranges while inserting a delimiter between sub-ranges, useful for formatting strings.
- Examples demonstrate practical uses, such as combining reversed vectors, filtering transactions, and formatting strings with separators.
- Comparison table highlights key differences: `concat_view` for independent ranges, `join_view` for flattening, and `join_with_view` for delimited flattening.
- Encourages reader engagement by asking about their range usage and favorite views/algorithms.
FakeIt: C++ Mocking Made Easy
8 months ago
- FakeIt is a simple mocking framework for C++ supporting GCC, Clang, and MS Visual C++.
- Written in C++11, it can test both C++11 and C++ projects.
- Provides a simple API with expressive Arrange-Act-Assert syntax.
- Supports mocking classes or spying existing objects in one line.
- No limitation on the number of method arguments and supports dynamic casting.
- Pre-configured for major unit testing frameworks like GoogleTest, MSTest, Boost.Test, etc.
- Header-only framework, packaged as a single header file for easy integration.
- Includes pre-packaged versions for different unit testing frameworks.
- Supports installation via CMake, Conan, and vcpkg.
- Has limitations: no support for multiple or virtual inheritance, not thread-safe, and specific compiler optimizations required.

first prev3next

About|Login

#c++

Hardening Mode for the Compiler

Compiler Bug Causes Compiler Bug: How a 12-Year-Old G++ Bug Took Down Solidity

Highway, a C++ library that provides portable SIMD/vector intrinsics

Proxy 4: The Next Leap in C++ Polymorphism

Stepanov's biggest blunder? The curious case of adjacent difference

Shared_ptr<T>: the (not always) atomic reference counted smart pointer

How is Ultrassembler so fast?

We need to seriously think about what to do with C++ modules

C++: Strongly Happens Before?

The repercussions of a typo in C++ & Rust

Declarative GUI Toolkit Slint 1.13 released

C++26: Erroneous Behaviour

Show HN: C++ library for reading MacBook lid angle sensor data

Automate compile_flags for C/C++ projects on the Zig build system

A polyglot's guide to multiple-dispatch

Safe C++ proposal is not being continued

Lexy: A parser combinator library for C++17

Velox: A composable and extensible C++ execution engine library

How to join or concat ranges, C++26

FakeIt: C++ Mocking Made Easy