The Curious Engineer

All blogs / Compilers

Embedded in Academia

blog.regehr.org

John Regehr, Professor of Computer Science, University of Utah, USA

CompilersTesting / QAPerformance / optimizationEssays / personal

’10’15’20’25
Posts
499 from 11 Feb 2010 to 4 Sep 2024
Posting
quiet since 2024
Kind
personal blog
Feed
https://blog.regehr.org/feed

2024 2

  1. Looking for Missed Alarm Bugs in a Formal Verification Tool
  2. Dataflow Analyses and Compiler Optimizations that Use Them, for Free

2023 1

  1. Why Do Peephole Optimizations Work?

2022 2

  1. Formal-Methods-Based Bugfinding for LLVM’s AArch64 Backend
  2. High-Throughput, Formal-Methods-Assisted Fuzzing for LLVM

2021 2

  1. A Close Look at a Spinlock
  2. llvm-reduce

2020 10

  1. Responsible and Effective Bugfinding
  2. Alive2 Part 3: Things You Can and Can’t Do with Undef in LLVM
  3. The Gods Pocket Peak Trail
  4. You Might as Well Be a Great Copy Editor
  5. The Saturation Effect in Fuzzing
  6. Alive2 Part 2: Tracking miscompilations in LLVM using its own unit tests
  7. Sid’s Mountain Backpacking Loop
  8. Alive2 Part 1: Introduction
  9. Precision Opportunities for Demanded Bits in LLVM
  10. Testing Dataflow Analyses for Precision and Soundness

2019 8

  1. Helping Generative Fuzzers Avoid Looking Only Where the Light is Good, Part 1
  2. Write Fuzzable Code
  3. Design and Evolution of C-Reduce (Part 2)
  4. Design and Evolution of C-Reduce (Part 1)
  5. It’s Time for a Modern Synthesis Kernel
  6. Floating the Dirty Devil River
  7. Verifying Popcount
  8. Explaining Code using ASCII Art

2018 17

  1. Walking or Biking to NSF
  2. Synthesizing Constants
  3. Learning When Values are Changed by Implicit Integer Casts
  4. What’s the difference between an integer and a pointer?
  5. Future Directions for Optimizing Compilers
  6. How LLVM Optimizes a Function
  7. How Clang Compiles a Function
  8. Software Engineering Takeaways
  9. High Desert Camping
  10. Paths to External Engagement in Computer Science Research
  11. Closing the Loop: The Importance of External Engagement in Computer Science Research
  12. The Basic Toolbox
  13. Strange Rocks 2018 Edition
  14. Trust Boundaries in Software Systems
  15. Stories Behind Papers: Integer Overflow
  16. A Conversation about Teaching Software Engineering
  17. Some Goals for High-impact Verified Compiler Research

2017 22

  1. The Real Problem with the US News Rankings
  2. The Dreaded Practice Talk
  3. Undefined Behavior in 2017
  4. The Zion Subway
  5. Pointer Overflow Checking is in LLVM
  6. Compiler Optimizations are Awesome
  7. Translation Validation of Bounded Exhaustive Test Cases
  8. Spring 2017
  9. Taming Undefined Behavior in LLVM
  10. Fun at the UNIX Terminal Part 1
  11. Elk and Arch
  12. Do Expressive Programming Languages Always Have Undefined Behavior?
  13. Mapping Mountains on Exoplanets
  14. Teaching Python Informally to Kids
  15. Undefined Behavior != Unsafe Programming
  16. Nine Mile Canyon
  17. Detecting Strict Aliasing Violations in the Wild
  18. A Quick Look at the SoftIron OverDrive 1000
  19. Introduction to Precision Farming
  20. Zion NP and Environs in Winter
  21. Testing LLVM
  22. A Tourist’s Guide to the LLVM Source Code

2016 23

  1. Undefined Behavior: Not Just for Programming Languages
  2. Principles for Undefined Behavior in Programming Language Design
  3. Vigorous Public Debates in Academic Computer Science
  4. Advanced Compilers Weeks 3-5
  5. Advanced Compilers Weeks 1 and 2
  6. Solutions to Integer Overflow
  7. Compilation and Hyperthreading
  8. Isolating a Free-Range Miscompilation
  9. Obelisk
  10. A Month of Invalid GCC Bug Reports, and How to Eliminate Some of Them
  11. Perseids
  12. C-Reduce 2.5
  13. Pointer Overflow Checking
  14. Teaching C
  15. Checking Up on Dataflow Analyses
  16. Efficient Integer Overflow Checking in LLVM
  17. Happy Canyon
  18. SQLite with a Fine-Toothed Comb
  19. The Strict Aliasing Situation is Pretty Bad
  20. A Variable Argument Hazard
  21. Python Exercises for Kids
  22. Planning for Disaster
  23. Do Fiddly Buffer Overruns Matter?

2015 25

  1. The Problem with Friendly C
  2. Reducers are Fuzzers
  3. Latency Numbers Every Professor Should Know
  4. Multi-Version Execution Defeats a Compiler-Bug-Based Backdoor
  5. Testcase Reduction for Non-Preprocessed C and C++
  6. A Few Pictures
  7. Classic Bug Reports
  8. API Fuzzing vs. File Fuzzing: A Cautionary Tale
  9. Comments on a Formal Verification of PolarSSL
  10. Secret Coders
  11. Sabbatical at TrustInSoft
  12. A Few Synthesizing Superoptimizer Results
  13. Nibble Sort Denouement
  14. Defending Against Compiler-Based Backdoors
  15. Generating a Random Program vs. Generating All Programs
  16. What afl-fuzz Is Bad At
  17. UB Canaries
  18. Inexpensive CPU Monster
  19. Booster Test
  20. Adandoned Mineshaft
  21. Instruction Synthesis is Fun and Weird
  22. Static Analysis Benchmarks
  23. Nibble Sort Programming Contest
  24. Buying Into Open Source Security
  25. Testing with Pictures

2014 44

  1. Inversions in Computing
  2. Souper Results 2
  3. Partial Evaluation and Immutable Servers
  4. Inward vs. Outward Facing Research
  5. Fall in City Creek Canyon
  6. Fun with Shellshock
  7. Proposal for a Friendly Dialect of C
  8. Atomic Accidents
  9. Non-Transparent Memory Safety
  10. Reviewing Research Papers Efficiently
  11. ALIVe: Automatic LLVM InstCombine Verifier
  12. Broads Fork
  13. Finding Compiler Bugs by Removing Dead Code
  14. We Need Hardware Traps for Integer Overflow
  15. A Guide to Better Scripty Code for Academics
  16. Early Superoptimizer Results
  17. This Is Not a Defect
  18. Cedar Mesa
  19. Too Much Milk: The Secret Origin Story
  20. Hints for Computer System Design
  21. How Should You Write a Fast Integer Overflow Check?
  22. Testing with Small Capacities
  23. Find the Integer Bug
  24. Research Advice from Alan Adler
  25. A New Development for Coverity and Heartbleed
  26. Heartbleed and Static Analysis
  27. xv6
  28. Automated Reasoning About LLVM Optimizations and Undefined Behavior
  29. That Was Easy
  30. Reproducibility in Computer Systems Research
  31. Let’s Work on an LLVM Superoptimizer
  32. Writing Solid Code Weeks 7 and 8
  33. Paranoid Programming
  34. Writing Solid Code Weeks 5 and 6 — The Plot Thickens
  35. What I Accomplished in Grad School
  36. Assertions Are Pessimistic, Assumptions Are Optimistic
  37. Scary Compiler Code Motion
  38. Use of Assertions
  39. Writing Solid Code Week 4
  40. Automatically Entering the Grand C++ Error Explosion Competition
  41. Writing Solid Code Week 3
  42. Status of Software Testing
  43. Writing Solid Code Week 2
  44. Writing Solid Code Week 1

2013 59

  1. Finding Wrong-Code Bugs in the Wild
  2. Reading Iain Banks, Part 1
  3. C-Reduce and Frama-C
  4. Informative Assertion Failures
  5. Safe, Efficient, and Portable Rotate in C/C++
  6. Integer Undefined Behaviors in Open Source Crypto Libraries
  7. A New Compiler Fuzzing Paper
  8. Producing Good Software From Academia
  9. Trust, But Verify
  10. Sometimes Compilers are Cute
  11. Irreducible Test Cases
  12. Any Way You Want
  13. A Few Panoramas
  14. Fuzzer Puzzle
  15. Levels of Fuzzing
  16. Guidelines for Research on Finding Bugs
  17. Are Compilers Getting More or Less Reliable?
  18. Jay
  19. Great Salt Lake Desert Road Trip
  20. Counting to 4 Billion Really Fast
  21. FizzBuzz Bugs
  22. Do Not Just Run a Few More Reps
  23. A Few Good Books
  24. According to Googer
  25. Mt Washington
  26. Cheating at Research
  27. C-Reduce 2.1
  28. Finding Undefined Behavior Bugs by Finding Dead Code
  29. What Other Dynamic Checkers for C/C++ are Needed?
  30. Integer Undefined Behavior Detection using Clang 3.3
  31. Type Punning, Strict Aliasing, and Optimization
  32. Funniest Computer Book?
  33. Crashy Compiler Flags
  34. MSCS
  35. Computer Science Culture Clash
  36. Foothill Sunset
  37. Procedural Decomposition
  38. Memory Safe C/C++: Time to Flip the Switch
  39. Reading Code
  40. Labyrinth Rims
  41. Fuzzers Need Taming
  42. Stochastic Superoptimization
  43. Exhaustive Testing is Not a Proof of Correctness
  44. Proofs from Tests
  45. str2long Contest Results Part 1
  46. A Quick Coding Contest: Convert String to Integer Without Overflow
  47. Four Books on Debugging
  48. Around Zion National Park
  49. Undefined Behavior Executed by Coq
  50. Catching Integer Errors with Clang
  51. How to Fuzz an ADT Implementation
  52. Simplest Program Showing the Difference Between Sequential Consistency and TSO
  53. Use of Goto in Systems Code
  54. Nobody Expects the Spanish Inquisition, or INT_MIN to be Divided by -1
  55. C and C++ Aren’t Future Proof
  56. The Space Child’s Mother Goose
  57. Hiding Bugs from Branch Coverage
  58. When Software Ages Badly
  59. Peeking into the Trash

2012 80

  1. Operant Conditioning by Software Bugs
  2. Is the Browser the New OS?
  3. Software Testing Using Easy Cases
  4. Oracles for Random Testing
  5. How Does Formal Verification Affect Software Testing?
  6. Raspberry Rockets
  7. Minimum Pubs for a PhD in CS?
  8. Gaining Confidence in Confidence Intervals
  9. Spiral Jetty
  10. A Few Thoughts on Scratch
  11. Fastest FizzBuzz
  12. Writing Solid Code
  13. Around Hanksville Utah
  14. How Did Software Get So Reliable Without Proof?
  15. EMSOFT 2012
  16. University Economics and the End of Large Classes
  17. Of Course It’s an Interview
  18. Economics of University Teaching
  19. Modern Dataflow Frameworks Wanted
  20. Capitol Reef Rock Art
  21. Book Review: The Shadow Scholar
  22. Certifying Compilers Using Random Testing
  23. What’s Operating Systems Research About?
  24. A Utah Salmon Run
  25. ARM Math Quirks on Raspberry Pi
  26. Blogspam Poems
  27. Thoughts on Embedded Development Boards
  28. High-Resolution Timing on the Raspberry Pi
  29. The Citation Telephone Game
  30. Trilobite Day Trip
  31. The Hidden Cost of Compiler Bugs
  32. Utah Eye Candy
  33. Core Question
  34. Cyber War
  35. It’s Time to Get Serious About Exploiting Undefined Behavior
  36. Undefined Behavior Consequences Contest Winners
  37. Twenty Years of Linux
  38. Anniversary Hike
  39. Contest: Craziest Compiler Output due to Undefined Behavior
  40. Parallelizing Delta Debugging
  41. Scooping and New Publication Models
  42. When is Undefined Behavior OK?
  43. Academic Attention for Undefined Behavior
  44. The PhD Grind, and Why Research Isn’t Like Sex
  45. Maybird
  46. Burning in a Module with Random Unit Testing
  47. Slightly More Sensible Signed Left-Shifts in C11 and C++11
  48. The Central Limit Theorem Makes Random Testing Hard
  49. 1500+ Bugs from One Fuzzer
  50. PLDI in Beijing
  51. Announcing C-Reduce: A Better Test-Case Reducer for C/C++ Compiler Debugging
  52. Street Fighting Computer Science
  53. Academic Bug-Finding Projects in the Long Run
  54. Damn You, Zork II
  55. Recording a Class at Udacity
  56. Why Isn’t C Memory Safe Yet?
  57. The Last Mile for a Verification Problem
  58. When Will Software Verification Matter?
  59. Software Testing Using Function/Inverse Pairs
  60. Udacity Visit
  61. Harris Wash, Zebra and Tunnel Slot Canyons
  62. Does Portable Byte-Order Code Optimize?
  63. 57 Small Programs that Crash Compilers
  64. New Paper on Test-Case Reduction
  65. Happy Canyon
  66. The Photography Contest
  67. Integer Overflow Paper
  68. How Many C Programs Are There?
  69. Bonneville Salt Flats and Silver Island Mountains
  70. C Puzzle: Double Trouble
  71. C99 Language Lawyer Needed
  72. Randomly Testing a Static Analyzer
  73. Avoidable Failures of Peer Review
  74. Tricking a Whitebox Testcase Generator
  75. Discovering New Instructions
  76. Wanted: Epitaphs for Hot Topics
  77. It’s All About Interfaces
  78. Fixing Computers
  79. Can Simplicity Scale?
  80. NSF Data Management Plans

2011 118

  1. Proposal to Stress-Test Implementations of C++11 Concurrency
  2. What PC-lint is Really For: Enforcing Language Dialects
  3. Book Beginnings
  4. Bit Puzzle Results
  5. Mount Olympus
  6. A Bit Puzzle
  7. A Different Approach to System Security
  8. Android Projects Retrospective
  9. Pluggable Domain-Specific Testcase Reducers
  10. How Integers Should Work (In Systems Programming Languages)
  11. How Should Integers Work?
  12. The Art and Science of Testcase Reduction for Compiler Bugs
  13. Csmith 2.1 Released
  14. Perverse Incentives in Academia
  15. Towards Tinkers
  16. Black Friday on Wednesday
  17. Putting Oneself Through College
  18. Open Access Fees
  19. Making the Sentence Structure of Paragraphs Apparent
  20. The Children of the Sky
  21. Fall
  22. Career Advice I’ve Received
  23. Advice for Assistant Professors
  24. Chimney Canyon
  25. Draft Paper about Better Fuzzing
  26. Draft Paper about Integer Overflow
  27. Hacked
  28. Overflows in SafeInt
  29. Better Random Testing by Leaving Features Out
  30. Google House
  31. Fuzzing Linux Kernel Modules?
  32. Online University
  33. Mt Nebo
  34. Hello Android
  35. A Fire Upon The Deep — Retrospective and E-book
  36. When to Teach C++?
  37. Box Elder Peak
  38. C No Evil
  39. Testing Commercial Compilers
  40. Fall on Snow
  41. Open Proposals (or: Take My Idea — Please)
  42. Isolation with a Very Small TCB
  43. Proposal for Automated Compiler Bug Reports
  44. ISSTA 2011
  45. Split Vote
  46. Review Correlation Again
  47. Red Baldy Again
  48. What’s Fun About Teaching
  49. Lake Blanche
  50. Does a Simulation Really Need to Be Run?
  51. Why Verify Software?
  52. SLC Sunset
  53. Do Small-RAM Devices Have a Future?
  54. Embrace WTF
  55. Safe From Compiler Bugs?
  56. Continuous Paper Reviewing (Wonkish)
  57. Squeezing a CS Research Idea
  58. Iterating Over The Full Range
  59. Size Matters
  60. Externally Relevant Open Problems in Computer Science
  61. What I Want From a Bibliography System
  62. Publishing for Impact
  63. A Day in the West Desert
  64. Generalizing and Criticizing Delta Debugging
  65. Polar Bears 2011
  66. An Executable Semantics For C Is Useful
  67. Antelope Island
  68. Uninitialized Variables
  69. Value Loss Coverage
  70. How Much and What to Read?
  71. Csmith Released
  72. Finding Integer Undefined Behaviors Using Clang 2.9
  73. Preemption vs. Event Ordering
  74. Goblin Valley and Capitol Reef
  75. Volatile Bugs, Three Years Later
  76. Who Fuzzes the Fuzzer?
  77. One Day of Winter and Three Days of Spring in the Fins
  78. Software Bugs and Scientific Progress
  79. Proposal for a CompCert Superoptimizer
  80. Peer Review Poker
  81. Finding and Understanding Bugs in C Compilers
  82. Race Condition vs. Data Race
  83. Guidelines for Teaching Assistants
  84. The Simplest Queue?
  85. Negative Correlation Achieved
  86. The Little C Function From Hell
  87. Better Testing With Undefined Behavior Coverage
  88. Undefined Integer Behaviors in Student Code, Part 2
  89. How to Write a C/C++ Compiler That Respects Volatile
  90. Life With BibTeX
  91. Differential Whitebox Testing Is Good
  92. Quality Not Quantity?
  93. Visualizing A Few More Math Bugs
  94. Visualizing Math Bugs
  95. A Few Thoughts About Path Coverage
  96. Undefined Integer Behaviors in Student Code, Part 1
  97. Should Software Evolve?
  98. Random Testing Gets No Respect
  99. Two Rules for Random Testing
  100. Probabilities in Random Testing
  101. Outgunned
  102. The Day I Learned To Love Perl
  103. Cryptocontributions, Blogs, and How Science Works
  104. Csmith @ PLDI
  105. Who Verifies the Verifiers?
  106. The Piano Test for Program Verification
  107. Elk and Winter Light
  108. Good Book: Idaho Falls
  109. Good Book: Space Systems Failures
  110. The Synergy Between Delta Debugging and Compiler Optimization
  111. The 5+5 Commandments of a Ph.D.
  112. Gear for Getting Outside in Winter
  113. The Future of Software System Correctness
  114. Almost Everything in Subversion
  115. Snowy Foothills
  116. A Critical Look at the SCADE Compiler Verification Kit
  117. Grading on a Curve
  118. On the Synergy Between Facebook and CAN Bus Error Confinement

2010 86

  1. Benchmarking Short Codes on Modern Processors
  2. A Quick Update to Comparing Compiler Optimizations
  3. Sometimes the Name Is the Contribution
  4. Comparing Compiler Optimizations
  5. Taking Grants for Granted
  6. The Official Utah State Firearm
  7. Interviewing PhD Students
  8. Wanted: Invariant-Based Synchronization
  9. Wanted: One RSS Feed Per Conference
  10. November Snowshoeing
  11. Angel’s Landing
  12. Staying Sane in Academia
  13. Some Good and Bad Things About Academia
  14. Reviewers Get Worse Over Time
  15. Computer Systems Evaluation Mistake #1
  16. Independence in N-Version Programming
  17. Compiler Bug-Finding Project Milestones
  18. Counting Compiler Crashes
  19. Non-deterministic Compilers?
  20. A Quick Look at Code Size
  21. GCC Summit Talk
  22. Verifying a Driver
  23. Maze Rejection #2
  24. More Saturating Arithmetic
  25. Fun With Saturating Arithmetic
  26. Volatile Structs Are Broken
  27. Conference Hijacking
  28. Late Summer in Heaven
  29. Why Not Mix Signed and Unsigned Values in C/C++?
  30. Giving a Talk at the GCC Summit
  31. Fun With Shift Optimizations
  32. Strange Utah
  33. Static Analysis Fatigue
  34. Sensor Network Technology in Vinge’s A Deepness in the Sky
  35. Going Going Gone
  36. What Blogs Are Good For
  37. The Future of Compiler Correctness
  38. The Future of Compiler Optimization
  39. Poll: Do You Want Compiler Bugs to Be Quiet or Loud?
  40. Timpanogos
  41. Ten Years in Utah
  42. Knowing When to Quit
  43. A Guide to Undefined Behavior in C and C++, Part 3
  44. Borah Peak in 30 Hours
  45. Running an Electronic Program Committee Meeting
  46. Is Attending Meetings a Signaling Behavior?
  47. A Guide to Undefined Behavior in C and C++, Part 2
  48. Red Baldy
  49. Why Would Researchers Oppose Open Access?
  50. Grandview Peak
  51. A Guide to Undefined Behavior in C and C++, Part 1
  52. How to Debug
  53. I Can Solve the World’s Debugging Problems
  54. The Truth About the Life of the Mind
  55. The Big Lie About the Life of the Mind
  56. Why Take an Embedded Systems Course?
  57. An Epidemic of Rat Farming
  58. Self-Checking Projects
  59. White Baldy
  60. INT_MIN % -1 = ?
  61. Why Take a Compiler Course?
  62. Good Fun and Bad Weather on Mount Baker
  63. Why Take an Operating Systems Course?
  64. Flower Power
  65. Compilers and Termination Revisited
  66. Book Review: Street-Fighting Mathematics
  67. Book Review: Pale Fire
  68. Book Review: Surviving Your Stupid Stupid Decision to go to Grad School
  69. How to Get a Grant (from NSF, for Computer Scientists)
  70. Book Review: Sustainable Energy — Without the Hot Air
  71. C Compilers Disprove Fermat’s Last Theorem
  72. Into the Brooks Range, Part 3
  73. Into the Brooks Range, Part 2
  74. Into the Brooks Range, Part 1
  75. Straight Man
  76. Margin in Software Systems
  77. Picking a Research Topic in Computer Systems
  78. The Compiler Doesn’t Care About Your Intent
  79. C and C++ Make It Hard to Read a Register for Its Side Effects
  80. Computer Science Fiction
  81. 200 Compiler Bugs
  82. How to Evaluate a Computer Systems Research Paper
  83. 50 Vertical Miles
  84. Nine ways to break your systems code using volatile
  85. Is That a Compiler Bug?
  86. TRIGA