emmmmmmm try to fix?

src/compiler/translator/ir/src/builder.rs

@@ -2794,35 +2794,57 @@ impl Builder {
 
 // Atomic counter operations
 pub fn built_in_atomiccounteradd(&mut self) {
-    self.built_in_binary_instruction_from_stack_with_pointer_lhs(BinaryOpCode::AtomicCounterAdd);
+    self.built_in_instruction_from_stack_with_pointer_args(
+        BuiltInOpCode::AtomicCounterAdd,
+        1, 1, 0,
+    );
 }
 pub fn built_in_atomiccountersubtract(&mut self) {
-    self.built_in_binary_instruction_from_stack_with_pointer_lhs(BinaryOpCode::AtomicCounterSubtract);
+    self.built_in_instruction_from_stack_with_pointer_args(
+        BuiltInOpCode::AtomicCounterSubtract,
+        1, 1, 0,
+    );
 }
 pub fn built_in_atomiccountermin(&mut self) {
-    self.built_in_binary_instruction_from_stack_with_pointer_lhs(BinaryOpCode::AtomicCounterMin);
+    self.built_in_instruction_from_stack_with_pointer_args(
+        BuiltInOpCode::AtomicCounterMin,
+        1, 1, 0,
+    );
 }
 pub fn built_in_atomiccountermax(&mut self) {
-    self.built_in_binary_instruction_from_stack_with_pointer_lhs(BinaryOpCode::AtomicCounterMax);
+    self.built_in_instruction_from_stack_with_pointer_args(
+        BuiltInOpCode::AtomicCounterMax,
+        1, 1, 0,
+    );
 }
 pub fn built_in_atomiccounterand(&mut self) {
-    self.built_in_binary_instruction_from_stack_with_pointer_lhs(BinaryOpCode::AtomicCounterAnd);
+    self.built_in_instruction_from_stack_with_pointer_args(
+        BuiltInOpCode::AtomicCounterAnd,
+        1, 1, 0,
+    );
 }
 pub fn built_in_atomiccounteror(&mut self) {
-    self.built_in_binary_instruction_from_stack_with_pointer_lhs(BinaryOpCode::AtomicCounterOr);
+    self.built_in_instruction_from_stack_with_pointer_args(
+        BuiltInOpCode::AtomicCounterOr,
+        1, 1, 0,
+    );
 }
 pub fn built_in_atomiccounterxor(&mut self) {
-    self.built_in_binary_instruction_from_stack_with_pointer_lhs(BinaryOpCode::AtomicCounterXor);
+    self.built_in_instruction_from_stack_with_pointer_args(
+        BuiltInOpCode::AtomicCounterXor,
+        1, 1, 0,
+    );
 }
 pub fn built_in_atomiccounterexchange(&mut self) {
-    self.built_in_binary_instruction_from_stack_with_pointer_lhs(BinaryOpCode::AtomicCounterExchange);
+    self.built_in_instruction_from_stack_with_pointer_args(
+        BuiltInOpCode::AtomicCounterExchange,
+        1, 1, 0,
+    );
 }
 pub fn built_in_atomiccountercompswap(&mut self) {
     self.built_in_instruction_from_stack_with_pointer_args(
         BuiltInOpCode::AtomicCounterCompSwap,
-        1,  // first pointer arg count
-        2,  // value arg count
-        0,  // last pointer arg count
+        1, 2, 0,
     );
 }
 

src/compiler/translator/ir/src/debug.rs

@@ -704,6 +704,16 @@ fn built_in_opcode_str(op: BuiltInOpCode) -> &'static str {
         BuiltInOpCode::InterpolateAtCenter => "InterpolateAtCenter",
         BuiltInOpCode::Saturate => "Saturate",
         BuiltInOpCode::LoopForwardProgress => "LoopForwardProgress",
+        BuiltInOpCode::AtomicCounterAdd => "AtomicCounterAdd",
+BuiltInOpCode::AtomicCounterSubtract => "AtomicCounterSubtract",
+BuiltInOpCode::AtomicCounterMin => "AtomicCounterMin",
+BuiltInOpCode::AtomicCounterMax => "AtomicCounterMax",
+BuiltInOpCode::AtomicCounterAnd => "AtomicCounterAnd",
+BuiltInOpCode::AtomicCounterOr => "AtomicCounterOr",
+BuiltInOpCode::AtomicCounterXor => "AtomicCounterXor",
+BuiltInOpCode::AtomicCounterExchange => "AtomicCounterExchange",
+BuiltInOpCode::AtomicCounterCompSwap => "AtomicCounterCompSwap",
+
     }
 }
 

src/compiler/translator/ir/src/instruction.rs

@@ -2974,6 +2974,8 @@ mod const_fold {
             | BuiltInOpCode::Saturate => {
                 panic!("Internal error: Unexpected built-ins to constant-fold")
             }
+
+            _ => None,
         };
 
         fold(ir_meta, &operands, result_type_id)
@@ -4036,7 +4038,16 @@ pub mod precision {
                     BuiltInOpCode::ImageAtomicCompSwap |
                     BuiltInOpCode::SamplePosition |
                     BuiltInOpCode::InterpolateAtCenter |
-                    BuiltInOpCode::Saturate => {
+                    BuiltInOpCode::Saturate | 
+                    BuiltInOpCode::AtomicCounterAdd |
+                    BuiltInOpCode::AtomicCounterSubtract |
+                    BuiltInOpCode::AtomicCounterMin |
+                    BuiltInOpCode::AtomicCounterMax |
+                    BuiltInOpCode::AtomicCounterAnd |
+                    BuiltInOpCode::AtomicCounterOr |
+                    BuiltInOpCode::AtomicCounterXor |
+                    BuiltInOpCode::AtomicCounterExchange |
+                    BuiltInOpCode::AtomicCounterCompSwap => {
                         propagate_to_ids(&mut params.iter_mut(), precision, to_propagate);
                     },
                     BuiltInOpCode::TextureSize => {

src/compiler/translator/ir/src/ir.rs

@@ -578,6 +578,15 @@ impl BuiltInOpCode {
             | BuiltInOpCode::TexelFetch
             | BuiltInOpCode::TexelFetchOffset
             | BuiltInOpCode::AtomicCompSwap
+            | BuiltInOpCode::AtomicCounterAdd
+            | BuiltInOpCode::AtomicCounterSubtract
+            | BuiltInOpCode::AtomicCounterMin
+            | BuiltInOpCode::AtomicCounterMax
+            | BuiltInOpCode::AtomicCounterAnd
+            | BuiltInOpCode::AtomicCounterOr
+            | BuiltInOpCode::AtomicCounterXor
+            | BuiltInOpCode::AtomicCounterExchange
+            | BuiltInOpCode::AtomicCounterCompSwap
             | BuiltInOpCode::ImageStore
             | BuiltInOpCode::ImageLoad
             | BuiltInOpCode::ImageAtomicAdd

src/compiler/translator/ir/src/output/glsl.rs

@@ -1227,6 +1227,15 @@ impl ast::Target for Generator {
             BuiltInOpCode::BeginFragmentShaderOrderingINTEL => "beginFragmentShaderOrderingINTEL",
             BuiltInOpCode::BeginInvocationInterlockARB => "beginInvocationInterlockARB",
             BuiltInOpCode::EndInvocationInterlockARB => "endInvocationInterlockARB",
+            BuiltInOpCode::AtomicCounterAdd => "atomicCounterAdd",
+BuiltInOpCode::AtomicCounterSubtract => "atomicCounterSubtract",
+BuiltInOpCode::AtomicCounterMin => "atomicCounterMin",
+BuiltInOpCode::AtomicCounterMax => "atomicCounterMax",
+BuiltInOpCode::AtomicCounterAnd => "atomicCounterAnd",
+BuiltInOpCode::AtomicCounterOr => "atomicCounterOr",
+BuiltInOpCode::AtomicCounterXor => "atomicCounterXor",
+BuiltInOpCode::AtomicCounterExchange => "atomicCounterExchange",
+BuiltInOpCode::AtomicCounterCompSwap => "atomicCounterCompSwap",
             BuiltInOpCode::PixelLocalStoreANGLE
             | BuiltInOpCode::SubpassLoad
             | BuiltInOpCode::NumSamples

src/compiler/translator/ir/src/output/ir_to_legacy.cpp

@@ -1627,6 +1627,34 @@ TIntermTyped *built_in_texturegatheroffset(TCompiler *compiler,
     return BuiltIn(compiler, builtIn, args, kNoVersionOverride);
 }
 
+TIntermTyped *built_in_atomiccounteradd(TCompiler *compiler, rust::Slice<const Expression> args) {
+    return BuiltIn(compiler, "atomicCounterAdd", args, kNoVersionOverride);
+}
+TIntermTyped *built_in_atomiccountersubtract(TCompiler *compiler, rust::Slice<const Expression> args) {
+    return BuiltIn(compiler, "atomicCounterSubtract", args, kNoVersionOverride);
+}
+TIntermTyped *built_in_atomiccountermin(TCompiler *compiler, rust::Slice<const Expression> args) {
+    return BuiltIn(compiler, "atomicCounterMin", args, kNoVersionOverride);
+}
+TIntermTyped *built_in_atomiccountermax(TCompiler *compiler, rust::Slice<const Expression> args) {
+    return BuiltIn(compiler, "atomicCounterMax", args, kNoVersionOverride);
+}
+TIntermTyped *built_in_atomiccounterand(TCompiler *compiler, rust::Slice<const Expression> args) {
+    return BuiltIn(compiler, "atomicCounterAnd", args, kNoVersionOverride);
+}
+TIntermTyped *built_in_atomiccounteror(TCompiler *compiler, rust::Slice<const Expression> args) {
+    return BuiltIn(compiler, "atomicCounterOr", args, kNoVersionOverride);
+}
+TIntermTyped *built_in_atomiccounterxor(TCompiler *compiler, rust::Slice<const Expression> args) {
+    return BuiltIn(compiler, "atomicCounterXor", args, kNoVersionOverride);
+}
+TIntermTyped *built_in_atomiccounterexchange(TCompiler *compiler, rust::Slice<const Expression> args) {
+    return BuiltIn(compiler, "atomicCounterExchange", args, kNoVersionOverride);
+}
+TIntermTyped *built_in_atomiccountercompswap(TCompiler *compiler, rust::Slice<const Expression> args) {
+    return BuiltIn(compiler, "atomicCounterCompSwap", args, kNoVersionOverride);
+}
+
 void branch_discard(TIntermBlock *block)
 {
     block->appendStatement(new TIntermBranch(EOpKill, nullptr));

src/compiler/translator/ir/src/output/ir_to_legacy.h

@@ -334,6 +334,15 @@ TIntermTyped *built_in_texturegather(TCompiler *compiler, rust::Slice<const Expr
 TIntermTyped *built_in_texturegatheroffset(TCompiler *compiler,
                                            rust::Slice<const Expression> args,
                                            bool isOffsetArray);
+TIntermTyped *built_in_atomiccounteradd(TCompiler *compiler, rust::Slice<const Expression> args);
+TIntermTyped *built_in_atomiccountersubtract(TCompiler *compiler, rust::Slice<const Expression> args);
+TIntermTyped *built_in_atomiccountermin(TCompiler *compiler, rust::Slice<const Expression> args);
+TIntermTyped *built_in_atomiccountermax(TCompiler *compiler, rust::Slice<const Expression> args);
+TIntermTyped *built_in_atomiccounterand(TCompiler *compiler, rust::Slice<const Expression> args);
+TIntermTyped *built_in_atomiccounteror(TCompiler *compiler, rust::Slice<const Expression> args);
+TIntermTyped *built_in_atomiccounterxor(TCompiler *compiler, rust::Slice<const Expression> args);
+TIntermTyped *built_in_atomiccounterexchange(TCompiler *compiler, rust::Slice<const Expression> args);
+TIntermTyped *built_in_atomiccountercompswap(TCompiler *compiler, rust::Slice<const Expression> args);
 
 void branch_discard(TIntermBlock *block);
 void branch_return_value(TIntermBlock *block, const Expression &value);

src/compiler/translator/ir/src/output/legacy.rs

@@ -2913,6 +2913,34 @@ impl ast::Target for Generator<'_> {
                 BuiltInOpCode::Saturate => {
                     (Some(ffi::built_in_saturate(self.legacy_compiler, &args)), None)
                 }
+                BuiltInOpCode::AtomicCounterAdd => {
+    (Some(ffi::built_in_atomiccounteradd(self.legacy_compiler, &args)), None)
+}
+BuiltInOpCode::AtomicCounterSubtract => {
+    (Some(ffi::built_in_atomiccountersubtract(self.legacy_compiler, &args)), None)
+}
+BuiltInOpCode::AtomicCounterMin => {
+    (Some(ffi::built_in_atomiccountermin(self.legacy_compiler, &args)), None)
+}
+BuiltInOpCode::AtomicCounterMax => {
+    (Some(ffi::built_in_atomiccountermax(self.legacy_compiler, &args)), None)
+}
+BuiltInOpCode::AtomicCounterAnd => {
+    (Some(ffi::built_in_atomiccounterand(self.legacy_compiler, &args)), None)
+}
+BuiltInOpCode::AtomicCounterOr => {
+    (Some(ffi::built_in_atomiccounteror(self.legacy_compiler, &args)), None)
+}
+BuiltInOpCode::AtomicCounterXor => {
+    (Some(ffi::built_in_atomiccounterxor(self.legacy_compiler, &args)), None)
+}
+BuiltInOpCode::AtomicCounterExchange => {
+    (Some(ffi::built_in_atomiccounterexchange(self.legacy_compiler, &args)), None)
+}
+BuiltInOpCode::AtomicCounterCompSwap => {
+    (Some(ffi::built_in_atomiccountercompswap(self.legacy_compiler, &args)), None)
+}
+
             }
         };
         if let Some(result) = result {

src/libANGLE/Context.cpp

@@ -4368,6 +4368,7 @@ void Context::initCaps()
     *extensions            = mSupportedExtensions;
 
     // GLES1 emulation: Initialize caps (Table 6.20 / 6.22 in the ES 1.1 spec)
+    if (getClientVersion() < Version(2, 0)) {
     caps->maxMultitextureUnits          = 4;
     caps->maxClipPlanes                 = 6;
     caps->maxLights                     = 8;
@@ -4378,6 +4379,7 @@ void Context::initCaps()
     caps->maxSmoothPointSize            = 1.0f;
     caps->minSmoothLineWidth            = 1.0f;
     caps->maxSmoothLineWidth            = 1.0f;
+    }
 
     caps->maxDebugMessageLength   = 1024;
     caps->maxDebugLoggedMessages  = 1024;

src/libANGLE/State.cpp

@@ -468,7 +468,10 @@ void PrivateState::initialize(Context *context)
     mNoUnclampedBlendColor = context->getLimitations().noUnclampedBlendColor;
 
     // GLES1 emulation: Initialize state for GLES1 if version applies
-    mGLES1State.initialize(context, this);
+    if (context->getClientVersion() < Version(2, 0))
+    {
+        mGLES1State.initialize(context, this);
+    }
 }
 
 void PrivateState::initializeForCapture(const Context *context)
@@ -1479,7 +1482,7 @@ void PrivateState::setEnableFeature(GLenum feature, bool enabled)
             return;
         case GL_COLOR_LOGIC_OP:
             setLogicOpEnabled(enabled);
-            break;
+            return;
         case GL_PRIMITIVE_RESTART_FIXED_INDEX:
             setPrimitiveRestart(enabled);
             return;