refactor(capi+go): use a single option for enabling all condition optimizations

Author: plusvic

capi/include/yara_x.h

@@ -41,11 +41,11 @@
 // errors instead of warnings.
 #define YRX_ERROR_ON_SLOW_LOOP 8
 
-// Flag passed to [`yrx_compiler_create`] for enabling hoisting. This
-// is a compiler optimization that moves invariant expressions out of
-// loops, improving performance during the evaluation of rule conditions
-// that contains loops.
-#define YRX_ENABLE_HOISTING 16
+// Flag passed to [`yrx_compiler_create`] for enabling optimizations.
+// With this flag the compiler tries to optimize rule conditions by applying
+// techniques like common subexpression elimination (CSE) and loop-invariant
+// code motion (LICM).
+#define YRX_ENABLE_CONDITION_OPTIMIZATION 16
 
 // Types of metadata values.
 typedef enum YRX_METADATA_TYPE {

capi/src/compiler.rs

@@ -40,19 +40,20 @@ pub const YRX_ERROR_ON_SLOW_PATTERN: u32 = 4;
 /// errors instead of warnings.
 pub const YRX_ERROR_ON_SLOW_LOOP: u32 = 8;
 
-/// Flag passed to [`yrx_compiler_create`] for enabling hoisting. This
-/// is a compiler optimization that moves invariant expressions out of
-/// loops, improving performance during the evaluation of rule conditions
-/// that contains loops.
-pub const YRX_ENABLE_HOISTING: u32 = 16;
+/// Flag passed to [`yrx_compiler_create`] for enabling optimizations.
+/// With this flag the compiler tries to optimize rule conditions by applying
+/// techniques like common subexpression elimination (CSE) and loop-invariant
+/// code motion (LICM).
+pub const YRX_ENABLE_CONDITION_OPTIMIZATION: u32 = 16;
 
 fn _yrx_compiler_create<'a>(flags: u32) -> yara_x::Compiler<'a> {
     let mut compiler = yara_x::Compiler::new();
     if flags & YRX_RELAXED_RE_SYNTAX != 0 {
         compiler.relaxed_re_syntax(true);
     }
-    if flags & YRX_ENABLE_HOISTING != 0 {
+    if flags & YRX_ENABLE_CONDITION_OPTIMIZATION != 0 {
         compiler.hoisting(true);
+        compiler.common_subexpression_elimination(true);
     }
     if flags & YRX_COLORIZE_ERRORS != 0 {
         compiler.colorize_errors(true);

go/compiler.go

@@ -97,13 +97,13 @@ func RelaxedReSyntax(yes bool) CompileOption {
 	}
 }
 
-// Hoisting is an option for [NewCompiler] and [Compile] that enables a
-// compiler optimization that moves invariant expressions out of loops,
-// improving performance during the evaluation of rule conditions that
-// contains loops.
-func Hoisting(yes bool) CompileOption {
+// ConditionOptimization is an option for [NewCompiler] and [Compile] that
+// enables the optimization of rule conditions. When this is true the compiler
+// applies techniques like common subexpression elimination (CSE) and
+// loop-invariant code motion (LICM).
+func ConditionOptimization(yes bool) CompileOption {
 	return func(c *Compiler) error {
-		c.hoisting = yes
+		c.conditionOptimization = yes
 		return nil
 	}
 }
@@ -237,15 +237,15 @@ type bannedModule struct {
 
 // Compiler represent a YARA compiler.
 type Compiler struct {
-	cCompiler          *C.YRX_COMPILER
-	relaxedReSyntax    bool
-	hoisting           bool
-	errorOnSlowPattern bool
-	errorOnSlowLoop    bool
-	ignoredModules     map[string]bool
-	bannedModules      map[string]bannedModule
-	vars               map[string]interface{}
-	features           []string
+	cCompiler             *C.YRX_COMPILER
+	relaxedReSyntax       bool
+	conditionOptimization bool
+	errorOnSlowPattern    bool
+	errorOnSlowLoop       bool
+	ignoredModules        map[string]bool
+	bannedModules         map[string]bannedModule
+	vars                  map[string]interface{}
+	features              []string
 }
 
 // NewCompiler creates a new compiler.
@@ -268,8 +268,8 @@ func NewCompiler(opts ...CompileOption) (*Compiler, error) {
 		flags |= C.YRX_RELAXED_RE_SYNTAX
 	}
 
-	if c.hoisting {
-		flags |= C.YRX_ENABLE_HOISTING
+	if c.conditionOptimization {
+		flags |= C.YRX_ENABLE_CONDITION_OPTIMIZATION
 	}
 
 	if c.errorOnSlowPattern {

go/compiler_test.go

@@ -54,10 +54,10 @@ func TestRelaxedReSyntax(t *testing.T) {
 	assert.Len(t, scanResults.MatchingRules(), 1)
 }
 
-func TestHoisting(t *testing.T) {
+func TestConditionOptimization(t *testing.T) {
 	_, err := Compile(`
 		rule test { condition: true }`,
-		Hoisting(true))
+		ConditionOptimization(true))
 	assert.NoError(t, err)
 }