package io.netty.util.internal;

import io.netty.util.internal.logging.InternalLogger;
import io.netty.util.internal.logging.InternalLoggerFactory;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import java.util.concurrent.atomic.AtomicLongFieldUpdater;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
import org.snmp4j.util.SnmpConfigurator;
import sun.misc.Unsafe;

/* JADX INFO: loaded from: classes.dex */
final class PlatformDependent0 {
    private static final long ADDRESS_FIELD_OFFSET;
    private static final long BYTE_ARRAY_BASE_OFFSET;
    private static final Constructor<?> DIRECT_BUFFER_CONSTRUCTOR;
    static final int HASH_CODE_ASCII_SEED = -1028477387;
    static final int HASH_CODE_C1 = 461845907;
    static final int HASH_CODE_C2 = 461845907;
    private static final boolean UNALIGNED;
    static final Unsafe UNSAFE;
    private static final long UNSAFE_COPY_THRESHOLD = 1048576;
    private static final InternalLogger logger = InternalLoggerFactory.getInstance((Class<?>) PlatformDependent0.class);

    static {
        Field declaredField;
        Unsafe unsafe;
        long jAllocateMemory;
        Constructor<?> declaredConstructor;
        boolean zMatches;
        ByteBuffer byteBufferAllocateDirect = ByteBuffer.allocateDirect(1);
        try {
            declaredField = Buffer.class.getDeclaredField(SnmpConfigurator.O_ADDRESS);
            declaredField.setAccessible(true);
        } catch (Throwable unused) {
        }
        if (declaredField.getLong(byteBufferAllocateDirect) == 0) {
            declaredField = null;
        }
        logger.debug("java.nio.Buffer.address: {}", declaredField != null ? "available" : "unavailable");
        if (declaredField != null) {
            try {
                Field declaredField2 = Unsafe.class.getDeclaredField("theUnsafe");
                declaredField2.setAccessible(true);
                unsafe = (Unsafe) declaredField2.get(null);
                logger.debug("sun.misc.Unsafe.theUnsafe: {}", unsafe != null ? "available" : "unavailable");
                if (unsafe != null) {
                    try {
                        unsafe.getClass().getDeclaredMethod("copyMemory", Object.class, Long.TYPE, Object.class, Long.TYPE, Long.TYPE);
                        logger.debug("sun.misc.Unsafe.copyMemory: available");
                    } catch (NoSuchMethodError e2) {
                        logger.debug("sun.misc.Unsafe.copyMemory: unavailable");
                        throw e2;
                    } catch (NoSuchMethodException e3) {
                        logger.debug("sun.misc.Unsafe.copyMemory: unavailable");
                        throw e3;
                    }
                }
            } catch (Throwable unused2) {
                unsafe = null;
            }
        } else {
            unsafe = null;
        }
        UNSAFE = unsafe;
        if (unsafe == null) {
            ADDRESS_FIELD_OFFSET = -1L;
            BYTE_ARRAY_BASE_OFFSET = -1L;
            UNALIGNED = false;
            DIRECT_BUFFER_CONSTRUCTOR = null;
        } else {
            try {
                declaredConstructor = byteBufferAllocateDirect.getClass().getDeclaredConstructor(Long.TYPE, Integer.TYPE);
                declaredConstructor.setAccessible(true);
                jAllocateMemory = UNSAFE.allocateMemory(1L);
                try {
                    declaredConstructor.newInstance(Long.valueOf(jAllocateMemory), 1);
                    if (jAllocateMemory != -1) {
                        UNSAFE.freeMemory(jAllocateMemory);
                    }
                } catch (Throwable unused3) {
                    if (jAllocateMemory != -1) {
                        UNSAFE.freeMemory(jAllocateMemory);
                    }
                    declaredConstructor = null;
                }
            } catch (Throwable unused4) {
                jAllocateMemory = -1;
            }
            DIRECT_BUFFER_CONSTRUCTOR = declaredConstructor;
            ADDRESS_FIELD_OFFSET = objectFieldOffset(declaredField);
            BYTE_ARRAY_BASE_OFFSET = UNSAFE.arrayBaseOffset(byte[].class);
            try {
                Method declaredMethod = Class.forName("java.nio.Bits", false, ClassLoader.getSystemClassLoader()).getDeclaredMethod("unaligned", new Class[0]);
                declaredMethod.setAccessible(true);
                zMatches = Boolean.TRUE.equals(declaredMethod.invoke(null, new Object[0]));
            } catch (Throwable unused5) {
                zMatches = SystemPropertyUtil.get("os.arch", "").matches("^(i[3-6]86|x86(_64)?|x64|amd64)$");
            }
            UNALIGNED = zMatches;
            logger.debug("java.nio.Bits.unaligned: {}", Boolean.valueOf(zMatches));
        }
        logger.debug("java.nio.DirectByteBuffer.<init>(long, int): {}", DIRECT_BUFFER_CONSTRUCTOR == null ? "unavailable" : "available");
    }

    private PlatformDependent0() {
    }

    static int addressSize() {
        return UNSAFE.addressSize();
    }

    static ByteBuffer allocateDirectNoCleaner(int i2) {
        return newDirectBuffer(UNSAFE.allocateMemory(i2), i2);
    }

    static long allocateMemory(long j2) {
        return UNSAFE.allocateMemory(j2);
    }

    static long byteArrayBaseOffset() {
        return BYTE_ARRAY_BASE_OFFSET;
    }

    static void copyMemory(long j2, long j3, long j4) {
        while (j4 > 0) {
            long jMin = Math.min(j4, UNSAFE_COPY_THRESHOLD);
            UNSAFE.copyMemory(j2, j3, jMin);
            j4 -= jMin;
            j2 += jMin;
            j3 += jMin;
        }
    }

    static long directBufferAddress(ByteBuffer byteBuffer) {
        return getLong(byteBuffer, ADDRESS_FIELD_OFFSET);
    }

    static boolean equals(byte[] bArr, int i2, byte[] bArr2, int i3, int i4) {
        long j2 = BYTE_ARRAY_BASE_OFFSET;
        long j3 = ((long) i2) + j2;
        long j4 = j2 + ((long) i3);
        int i5 = i4 & 7;
        long j5 = ((long) i5) + j3;
        long j6 = i4;
        long j7 = (j3 - 8) + j6;
        long j8 = (j4 - 8) + j6;
        while (j7 >= j5) {
            if (UNSAFE.getLong(bArr, j7) != UNSAFE.getLong(bArr2, j8)) {
                return false;
            }
            j7 -= 8;
            j8 -= 8;
        }
        switch (i5) {
            case 1:
                return UNSAFE.getByte(bArr, j3) == UNSAFE.getByte(bArr2, j4);
            case 2:
                return UNSAFE.getChar(bArr, j3) == UNSAFE.getChar(bArr2, j4);
            case 3:
                return UNSAFE.getChar(bArr, j3 + 1) == UNSAFE.getChar(bArr2, 1 + j4) && UNSAFE.getByte(bArr, j3) == UNSAFE.getByte(bArr2, j4);
            case 4:
                return UNSAFE.getInt(bArr, j3) == UNSAFE.getInt(bArr2, j4);
            case 5:
                return UNSAFE.getInt(bArr, j3 + 1) == UNSAFE.getInt(bArr2, 1 + j4) && UNSAFE.getByte(bArr, j3) == UNSAFE.getByte(bArr2, j4);
            case 6:
                return UNSAFE.getInt(bArr, j3 + 2) == UNSAFE.getInt(bArr2, 2 + j4) && UNSAFE.getChar(bArr, j3) == UNSAFE.getChar(bArr2, j4);
            case 7:
                return UNSAFE.getInt(bArr, j3 + 3) == UNSAFE.getInt(bArr2, 3 + j4) && UNSAFE.getChar(bArr, j3 + 1) == UNSAFE.getChar(bArr2, 1 + j4) && UNSAFE.getByte(bArr, j3) == UNSAFE.getByte(bArr2, j4);
            default:
                return true;
        }
    }

    static int equalsConstantTime(byte[] bArr, int i2, byte[] bArr2, int i3, int i4) {
        long j2 = BYTE_ARRAY_BASE_OFFSET;
        long j3 = ((long) i2) + j2;
        long j4 = j2 + ((long) i3);
        int i5 = i4 & 7;
        long j5 = ((long) i5) + j3;
        long j6 = i4;
        long j7 = (j3 - 8) + j6;
        long j8 = (j4 - 8) + j6;
        long j9 = 0;
        while (j7 >= j5) {
            j9 |= UNSAFE.getLong(bArr, j7) ^ UNSAFE.getLong(bArr2, j8);
            j7 -= 8;
            j8 -= 8;
        }
        switch (i5) {
            case 1:
                return ConstantTimeUtils.equalsConstantTime(((long) (UNSAFE.getByte(bArr, j3) ^ UNSAFE.getByte(bArr2, j4))) | j9, 0L);
            case 2:
                return ConstantTimeUtils.equalsConstantTime(((long) (UNSAFE.getChar(bArr, j3) ^ UNSAFE.getChar(bArr2, j4))) | j9, 0L);
            case 3:
                return ConstantTimeUtils.equalsConstantTime(((long) (UNSAFE.getByte(bArr, j3) ^ UNSAFE.getByte(bArr2, j4))) | ((long) (UNSAFE.getChar(bArr, j3 + 1) ^ UNSAFE.getChar(bArr2, 1 + j4))) | j9, 0L);
            case 4:
                return ConstantTimeUtils.equalsConstantTime(((long) (UNSAFE.getInt(bArr, j3) ^ UNSAFE.getInt(bArr2, j4))) | j9, 0L);
            case 5:
                return ConstantTimeUtils.equalsConstantTime(((long) (UNSAFE.getByte(bArr, j3) ^ UNSAFE.getByte(bArr2, j4))) | ((long) (UNSAFE.getInt(bArr, j3 + 1) ^ UNSAFE.getInt(bArr2, 1 + j4))) | j9, 0L);
            case 6:
                return ConstantTimeUtils.equalsConstantTime(((long) (UNSAFE.getChar(bArr, j3) ^ UNSAFE.getChar(bArr2, j4))) | ((long) (UNSAFE.getInt(bArr, j3 + 2) ^ UNSAFE.getInt(bArr2, 2 + j4))) | j9, 0L);
            case 7:
                return ConstantTimeUtils.equalsConstantTime(((long) (UNSAFE.getByte(bArr, j3) ^ UNSAFE.getByte(bArr2, j4))) | ((long) (UNSAFE.getChar(bArr, j3 + 1) ^ UNSAFE.getChar(bArr2, 1 + j4))) | j9 | ((long) (UNSAFE.getInt(bArr, j3 + 3) ^ UNSAFE.getInt(bArr2, 3 + j4))), 0L);
            default:
                return ConstantTimeUtils.equalsConstantTime(j9, 0L);
        }
    }

    static void freeDirectBuffer(ByteBuffer byteBuffer) {
        Cleaner0.freeDirectBuffer(byteBuffer);
    }

    static void freeMemory(long j2) {
        UNSAFE.freeMemory(j2);
    }

    static byte getByte(long j2) {
        return UNSAFE.getByte(j2);
    }

    static ClassLoader getClassLoader(final Class<?> cls) {
        return System.getSecurityManager() == null ? cls.getClassLoader() : (ClassLoader) AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() { // from class: io.netty.util.internal.PlatformDependent0.1
            /* JADX WARN: Can't rename method to resolve collision */
            @Override // java.security.PrivilegedAction
            public ClassLoader run() {
                return cls.getClassLoader();
            }
        });
    }

    static ClassLoader getContextClassLoader() {
        return System.getSecurityManager() == null ? Thread.currentThread().getContextClassLoader() : (ClassLoader) AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() { // from class: io.netty.util.internal.PlatformDependent0.2
            /* JADX WARN: Can't rename method to resolve collision */
            @Override // java.security.PrivilegedAction
            public ClassLoader run() {
                return Thread.currentThread().getContextClassLoader();
            }
        });
    }

    static int getInt(Object obj, long j2) {
        return UNSAFE.getInt(obj, j2);
    }

    private static long getLong(Object obj, long j2) {
        return UNSAFE.getLong(obj, j2);
    }

    static Object getObject(Object obj, long j2) {
        return UNSAFE.getObject(obj, j2);
    }

    static Object getObjectVolatile(Object obj, long j2) {
        return UNSAFE.getObjectVolatile(obj, j2);
    }

    static short getShort(long j2) {
        return UNSAFE.getShort(j2);
    }

    static ClassLoader getSystemClassLoader() {
        return System.getSecurityManager() == null ? ClassLoader.getSystemClassLoader() : (ClassLoader) AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() { // from class: io.netty.util.internal.PlatformDependent0.3
            /* JADX WARN: Can't rename method to resolve collision */
            @Override // java.security.PrivilegedAction
            public ClassLoader run() {
                return ClassLoader.getSystemClassLoader();
            }
        });
    }

    static boolean hasDirectBufferNoCleanerConstructor() {
        return DIRECT_BUFFER_CONSTRUCTOR != null;
    }

    static boolean hasUnsafe() {
        return UNSAFE != null;
    }

    static int hashCodeAscii(byte[] bArr, int i2, int i3) {
        int iHashCodeAsciiSanitize;
        int iHashCodeAsciiSanitize2;
        long j2 = BYTE_ARRAY_BASE_OFFSET + ((long) i2);
        int i4 = i3 & 7;
        long j3 = ((long) i4) + j2;
        int iHashCodeAsciiCompute = HASH_CODE_ASCII_SEED;
        for (long j4 = (j2 - 8) + ((long) i3); j4 >= j3; j4 -= 8) {
            iHashCodeAsciiCompute = hashCodeAsciiCompute(UNSAFE.getLong(bArr, j4), iHashCodeAsciiCompute);
        }
        switch (i4) {
            case 1:
                iHashCodeAsciiSanitize = iHashCodeAsciiCompute * 461845907;
                iHashCodeAsciiSanitize2 = hashCodeAsciiSanitize(UNSAFE.getByte(bArr, j2));
                break;
            case 2:
                iHashCodeAsciiSanitize = iHashCodeAsciiCompute * 461845907;
                iHashCodeAsciiSanitize2 = hashCodeAsciiSanitize(UNSAFE.getShort(bArr, j2));
                break;
            case 3:
                iHashCodeAsciiSanitize = ((iHashCodeAsciiCompute * 461845907) + hashCodeAsciiSanitize(UNSAFE.getByte(bArr, j2))) * 461845907;
                iHashCodeAsciiSanitize2 = hashCodeAsciiSanitize(UNSAFE.getShort(bArr, j2 + 1));
                break;
            case 4:
                iHashCodeAsciiSanitize = iHashCodeAsciiCompute * 461845907;
                iHashCodeAsciiSanitize2 = hashCodeAsciiSanitize(UNSAFE.getInt(bArr, j2));
                break;
            case 5:
                iHashCodeAsciiSanitize = ((iHashCodeAsciiCompute * 461845907) + hashCodeAsciiSanitize(UNSAFE.getByte(bArr, j2))) * 461845907;
                iHashCodeAsciiSanitize2 = hashCodeAsciiSanitize(UNSAFE.getInt(bArr, j2 + 1));
                break;
            case 6:
                iHashCodeAsciiSanitize = ((iHashCodeAsciiCompute * 461845907) + hashCodeAsciiSanitize(UNSAFE.getShort(bArr, j2))) * 461845907;
                iHashCodeAsciiSanitize2 = hashCodeAsciiSanitize(UNSAFE.getInt(bArr, j2 + 2));
                break;
            case 7:
                iHashCodeAsciiSanitize = ((((iHashCodeAsciiCompute * 461845907) + hashCodeAsciiSanitize(UNSAFE.getByte(bArr, j2))) * 461845907) + hashCodeAsciiSanitize(UNSAFE.getShort(bArr, 1 + j2))) * 461845907;
                iHashCodeAsciiSanitize2 = hashCodeAsciiSanitize(UNSAFE.getInt(bArr, j2 + 3));
                break;
            default:
                return iHashCodeAsciiCompute;
        }
        return iHashCodeAsciiSanitize + iHashCodeAsciiSanitize2;
    }

    static int hashCodeAsciiCompute(long j2, int i2) {
        return (i2 * 461845907) + (hashCodeAsciiSanitize((int) j2) * 461845907) + ((int) ((j2 & 2242545357458243584L) >>> 32));
    }

    static int hashCodeAsciiSanitize(byte b) {
        return b & 31;
    }

    static int hashCodeAsciiSanitize(int i2) {
        return i2 & 522133279;
    }

    static int hashCodeAsciiSanitize(short s) {
        return s & 7967;
    }

    static boolean isUnaligned() {
        return UNALIGNED;
    }

    static <T> AtomicIntegerFieldUpdater<T> newAtomicIntegerFieldUpdater(Class<? super T> cls, String str) throws Exception {
        return new UnsafeAtomicIntegerFieldUpdater(UNSAFE, cls, str);
    }

    static <T> AtomicLongFieldUpdater<T> newAtomicLongFieldUpdater(Class<? super T> cls, String str) throws Exception {
        return new UnsafeAtomicLongFieldUpdater(UNSAFE, cls, str);
    }

    static <U, W> AtomicReferenceFieldUpdater<U, W> newAtomicReferenceFieldUpdater(Class<? super U> cls, String str) throws Exception {
        return new UnsafeAtomicReferenceFieldUpdater(UNSAFE, cls, str);
    }

    private static ByteBuffer newDirectBuffer(long j2, int i2) {
        try {
            return (ByteBuffer) DIRECT_BUFFER_CONSTRUCTOR.newInstance(Long.valueOf(j2), Integer.valueOf(i2));
        } catch (Throwable th) {
            if (th instanceof Error) {
                throw th;
            }
            throw new Error(th);
        }
    }

    static long objectFieldOffset(Field field) {
        return UNSAFE.objectFieldOffset(field);
    }

    static void putByte(long j2, byte b) {
        UNSAFE.putByte(j2, b);
    }

    static void putInt(long j2, int i2) {
        UNSAFE.putInt(j2, i2);
    }

    static void putLong(long j2, long j3) {
        UNSAFE.putLong(j2, j3);
    }

    static void putOrderedObject(Object obj, long j2, Object obj2) {
        UNSAFE.putOrderedObject(obj, j2, obj2);
    }

    static void putShort(long j2, short s) {
        UNSAFE.putShort(j2, s);
    }

    static ByteBuffer reallocateDirectNoCleaner(ByteBuffer byteBuffer, int i2) {
        return newDirectBuffer(UNSAFE.reallocateMemory(directBufferAddress(byteBuffer), i2), i2);
    }

    static void setMemory(long j2, long j3, byte b) {
        UNSAFE.setMemory(j2, j3, b);
    }

    static void throwException(Throwable th) {
        UNSAFE.throwException((Throwable) ObjectUtil.checkNotNull(th, "cause"));
    }

    static boolean unalignedAccess() {
        return UNALIGNED;
    }

    static byte getByte(byte[] bArr, int i2) {
        return UNSAFE.getByte(bArr, BYTE_ARRAY_BASE_OFFSET + ((long) i2));
    }

    static int getInt(long j2) {
        return UNSAFE.getInt(j2);
    }

    static long getLong(long j2) {
        return UNSAFE.getLong(j2);
    }

    static short getShort(byte[] bArr, int i2) {
        return UNSAFE.getShort(bArr, BYTE_ARRAY_BASE_OFFSET + ((long) i2));
    }

    static void putByte(byte[] bArr, int i2, byte b) {
        UNSAFE.putByte(bArr, BYTE_ARRAY_BASE_OFFSET + ((long) i2), b);
    }

    static void putInt(byte[] bArr, int i2, int i3) {
        UNSAFE.putInt(bArr, BYTE_ARRAY_BASE_OFFSET + ((long) i2), i3);
    }

    static void putLong(byte[] bArr, int i2, long j2) {
        UNSAFE.putLong(bArr, ((long) i2) + BYTE_ARRAY_BASE_OFFSET, j2);
    }

    static void putShort(byte[] bArr, int i2, short s) {
        UNSAFE.putShort(bArr, BYTE_ARRAY_BASE_OFFSET + ((long) i2), s);
    }

    static void setMemory(Object obj, long j2, long j3, byte b) {
        UNSAFE.setMemory(obj, j2, j3, b);
    }

    static void copyMemory(Object obj, long j2, Object obj2, long j3, long j4) {
        long j5 = j2;
        long j6 = j3;
        long j7 = j4;
        while (j7 > 0) {
            long jMin = Math.min(j7, UNSAFE_COPY_THRESHOLD);
            UNSAFE.copyMemory(obj, j5, obj2, j6, jMin);
            j7 -= jMin;
            j5 += jMin;
            j6 += jMin;
        }
    }

    static int getInt(byte[] bArr, int i2) {
        return UNSAFE.getInt(bArr, BYTE_ARRAY_BASE_OFFSET + ((long) i2));
    }

    static long getLong(byte[] bArr, int i2) {
        return UNSAFE.getLong(bArr, BYTE_ARRAY_BASE_OFFSET + ((long) i2));
    }
}