Skip to content

Commit 628c1e5

Browse files
dgarskedgarske
committed
Fix g++ compiler implicit cast warnings
1 parent 6deef7c commit 628c1e5

1 file changed

Lines changed: 51 additions & 45 deletions

File tree

‎wolfcrypt/src/port/intel/quickassist.c‎

Lines changed: 51 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -473,11 +473,11 @@ int IntelQaHardwareStart(const char* process_name, int limitDevAccess)
473473
}
474474

475475
#if defined(HAVE_ECC) && defined(HAVE_ECC_DHE)
476-
g_qatEcdhY = XMALLOC(MAX_ECC_BYTES, NULL, DYNAMIC_TYPE_ASYNC_NUMA);
476+
g_qatEcdhY = (Cpa8U*)XMALLOC(MAX_ECC_BYTES, NULL, DYNAMIC_TYPE_ASYNC_NUMA);
477477
if (g_qatEcdhY == NULL) {
478478
ret = MEMORY_E; goto error;
479479
}
480-
g_qatEcdhCofactor1 = XMALLOC(MAX_ECC_BYTES, NULL, DYNAMIC_TYPE_ASYNC_NUMA);
480+
g_qatEcdhCofactor1 = (Cpa8U*)XMALLOC(MAX_ECC_BYTES, NULL, DYNAMIC_TYPE_ASYNC_NUMA);
481481
if (g_qatEcdhCofactor1 == NULL) {
482482
ret = MEMORY_E; goto error;
483483
}
@@ -731,7 +731,7 @@ int IntelQaDevCopy(WC_ASYNC_DEV* src, WC_ASYNC_DEV* dst)
731731
if (isHash) {
732732
/* need to duplicate tmpIn */
733733
if (src->qat.op.hash.tmpIn) {
734-
dst->qat.op.hash.tmpIn = XMALLOC(src->qat.op.hash.tmpInBufSz,
734+
dst->qat.op.hash.tmpIn = (byte*)XMALLOC(src->qat.op.hash.tmpInBufSz,
735735
src->heap, DYNAMIC_TYPE_ASYNC_NUMA);
736736
if (dst->qat.op.hash.tmpIn == NULL) {
737737
return MEMORY_E;
@@ -1431,7 +1431,7 @@ int IntelQaRsaKeyGen(WC_ASYNC_DEV* dev, RsaKey* key, int keyBits, long e,
14311431
privateKey,
14321432
publicKey);
14331433
} while (IntelQaHandleCpaStatus(dev, status, &ret, 0,
1434-
callback, &retryCount));
1434+
(void*)callback, &retryCount));
14351435

14361436
exit:
14371437

@@ -1562,11 +1562,11 @@ int IntelQaRsaPrivate(WC_ASYNC_DEV* dev,
15621562
}
15631563

15641564
opData->inputData.dataLenInBytes = inLen;
1565-
opData->inputData.pData = XREALLOC((byte*)in, inLen, dev->heap,
1565+
opData->inputData.pData = (Cpa8U*)XREALLOC((byte*)in, inLen, dev->heap,
15661566
DYNAMIC_TYPE_ASYNC_NUMA);
15671567

15681568
outBuf->dataLenInBytes = *outLen;
1569-
outBuf->pData = XREALLOC(out, *outLen, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
1569+
outBuf->pData = (Cpa8U*)XREALLOC(out, *outLen, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
15701570

15711571
/* check allocations */
15721572
if (opData->inputData.pData == NULL || outBuf->pData == NULL) {
@@ -1592,8 +1592,8 @@ int IntelQaRsaPrivate(WC_ASYNC_DEV* dev,
15921592
dev,
15931593
opData,
15941594
outBuf);
1595-
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_RSA_ASYNC, callback,
1596-
&retryCount));
1595+
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_RSA_ASYNC,
1596+
(void*)callback, &retryCount));
15971597

15981598
if (ret == WC_PENDING_E)
15991599
return ret;
@@ -1667,11 +1667,11 @@ int IntelQaRsaCrtPrivate(WC_ASYNC_DEV* dev,
16671667
*outLen = inLen;
16681668

16691669
opData->inputData.dataLenInBytes = inLen;
1670-
opData->inputData.pData = XREALLOC((byte*)in, inLen, dev->heap,
1670+
opData->inputData.pData = (Cpa8U*)XREALLOC((byte*)in, inLen, dev->heap,
16711671
DYNAMIC_TYPE_ASYNC_NUMA);
16721672

16731673
outBuf->dataLenInBytes = *outLen;
1674-
outBuf->pData = XREALLOC(out, *outLen, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
1674+
outBuf->pData = (Cpa8U*)XREALLOC(out, *outLen, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
16751675

16761676
/* check allocations */
16771677
if (opData->inputData.pData == NULL || outBuf->pData == NULL) {
@@ -1697,8 +1697,8 @@ int IntelQaRsaCrtPrivate(WC_ASYNC_DEV* dev,
16971697
dev,
16981698
opData,
16991699
outBuf);
1700-
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_RSA_ASYNC, callback,
1701-
&retryCount));
1700+
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_RSA_ASYNC,
1701+
(void*)callback, &retryCount));
17021702

17031703
if (ret == WC_PENDING_E)
17041704
return ret;
@@ -1823,11 +1823,11 @@ int IntelQaRsaPublic(WC_ASYNC_DEV* dev,
18231823
*outLen = n->len;
18241824

18251825
opData->inputData.dataLenInBytes = inLen;
1826-
opData->inputData.pData = XREALLOC((byte*)in, inLen, dev->heap,
1826+
opData->inputData.pData = (Cpa8U*)XREALLOC((byte*)in, inLen, dev->heap,
18271827
DYNAMIC_TYPE_ASYNC_NUMA);
18281828

18291829
outBuf->dataLenInBytes = *outLen;
1830-
outBuf->pData = XREALLOC(out, *outLen, dev->heap,
1830+
outBuf->pData = (Cpa8U*)XREALLOC(out, *outLen, dev->heap,
18311831
DYNAMIC_TYPE_ASYNC_NUMA64);
18321832

18331833
/* check allocations */
@@ -1850,8 +1850,8 @@ int IntelQaRsaPublic(WC_ASYNC_DEV* dev,
18501850
dev,
18511851
opData,
18521852
outBuf);
1853-
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_RSA_ASYNC, callback,
1854-
&retryCount));
1853+
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_RSA_ASYNC,
1854+
(void*)callback, &retryCount));
18551855

18561856
if (ret == WC_PENDING_E)
18571857
return ret;
@@ -1963,11 +1963,12 @@ int IntelQaRsaExptMod(WC_ASYNC_DEV* dev,
19631963
}
19641964

19651965
opData->base.dataLenInBytes = inLen;
1966-
opData->base.pData = XREALLOC((byte*)in, inLen, dev->heap,
1966+
opData->base.pData = (Cpa8U*)XREALLOC((byte*)in, inLen, dev->heap,
19671967
DYNAMIC_TYPE_ASYNC_NUMA);
19681968

19691969
target->dataLenInBytes = *outLen;
1970-
target->pData = XREALLOC(out, *outLen, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
1970+
target->pData = (Cpa8U*)XREALLOC(out, *outLen, dev->heap,
1971+
DYNAMIC_TYPE_ASYNC_NUMA);
19711972

19721973
/* check allocations */
19731974
if (opData->base.pData == NULL || target->pData == NULL) {
@@ -1987,7 +1988,7 @@ int IntelQaRsaExptMod(WC_ASYNC_DEV* dev,
19871988
opData,
19881989
target);
19891990
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_EXPTMOD_ASYNC,
1990-
callback, &retryCount));
1991+
(void*)callback, &retryCount));
19911992

19921993
if (ret == WC_PENDING_E)
19931994
return ret;
@@ -2336,9 +2337,10 @@ static int IntelQaSymCipher(WC_ASYNC_DEV* dev, byte* out, const byte* in,
23362337
opData = &ctx->opData;
23372338
bufferList = &dev->qat.op.cipher.bufferList;
23382339
flatBuffer = &dev->qat.op.cipher.flatBuffer;
2339-
metaBuf = XMALLOC(metaSize, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2340-
dataBuf = XREALLOC((byte*)in, dataLen, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2341-
ivBuf = XREALLOC((byte*)iv, AES_BLOCK_SIZE, dev->heap,
2340+
metaBuf = (Cpa8U*)XMALLOC(metaSize, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2341+
dataBuf = (Cpa8U*)XREALLOC((byte*)in, dataLen, dev->heap,
2342+
DYNAMIC_TYPE_ASYNC_NUMA);
2343+
ivBuf = (Cpa8U*)XREALLOC((byte*)iv, AES_BLOCK_SIZE, dev->heap,
23422344
DYNAMIC_TYPE_ASYNC_NUMA);
23432345

23442346
/* check allocations */
@@ -2354,7 +2356,7 @@ static int IntelQaSymCipher(WC_ASYNC_DEV* dev, byte* out, const byte* in,
23542356
(authInSzAligned % AES_BLOCK_SIZE);
23552357
}
23562358

2357-
authInBuf = XREALLOC((byte*)authIn, authInSzAligned, dev->heap,
2359+
authInBuf = (Cpa8U*)XREALLOC((byte*)authIn, authInSzAligned, dev->heap,
23582360
DYNAMIC_TYPE_ASYNC_NUMA);
23592361
if (authInBuf == NULL) {
23602362
ret = MEMORY_E; goto exit;
@@ -2459,7 +2461,7 @@ static int IntelQaSymCipher(WC_ASYNC_DEV* dev, byte* out, const byte* in,
24592461
bufferList,
24602462
NULL);
24612463
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_CIPHER_ASYNC,
2462-
callback, &retryCount));
2464+
(void*)callback, &retryCount));
24632465

24642466
if (ret == WC_PENDING_E)
24652467
return ret;
@@ -2856,7 +2858,8 @@ static int IntelQaSymHashCache(WC_ASYNC_DEV* dev, byte* out, const byte* in,
28562858
/* allocate buffer list */
28572859
bufferListSize = sizeof(CpaBufferList) +
28582860
(bufferCount * sizeof(CpaFlatBuffer)) + metaSize;
2859-
srcList = XMALLOC(bufferListSize, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2861+
srcList = (CpaBufferList*)XMALLOC(bufferListSize, dev->heap,
2862+
DYNAMIC_TYPE_ASYNC_NUMA);
28602863
if (srcList == NULL) {
28612864
ret = MEMORY_E; goto exit;
28622865
}
@@ -2879,7 +2882,8 @@ static int IntelQaSymHashCache(WC_ASYNC_DEV* dev, byte* out, const byte* in,
28792882
/* build output */
28802883
if (out) {
28812884
/* use blockSize for alloc, but we are only returning digestSize */
2882-
digestBuf = XMALLOC(blockSize, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2885+
digestBuf = (Cpa8U*)XMALLOC(blockSize, dev->heap,
2886+
DYNAMIC_TYPE_ASYNC_NUMA);
28832887
if (digestBuf == NULL) {
28842888
ret = MEMORY_E; goto exit;
28852889
}
@@ -2924,8 +2928,8 @@ static int IntelQaSymHashCache(WC_ASYNC_DEV* dev, byte* out, const byte* in,
29242928
srcList,
29252929
srcList,
29262930
NULL);
2927-
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_HASH_ASYNC, callback,
2928-
&retryCount));
2931+
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_HASH_ASYNC,
2932+
(void*)callback, &retryCount));
29292933

29302934
if (ret == WC_PENDING_E)
29312935
return ret;
@@ -3448,7 +3452,7 @@ int IntelQaSymSha3(WC_ASYNC_DEV* dev, byte* out, const byte* in, word32 sz)
34483452
int ret;
34493453
CpaCySymHashAlgorithm hashAlgorithm;
34503454

3451-
ret = IntelQaHmacGetType(macType, &hashAlgorithm);
3455+
ret = IntelQaHmacGetType(macType, (word32*)&hashAlgorithm);
34523456
if (ret != 0)
34533457
return ret;
34543458

@@ -3625,7 +3629,7 @@ int IntelQaEccPointMul(WC_ASYNC_DEV* dev, WC_BIGINT* k,
36253629
pXk,
36263630
pYk);
36273631
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_ECMUL_ASYNC,
3628-
callback, &retryCount));
3632+
(void*)callback, &retryCount));
36293633

36303634
if (ret == WC_PENDING_E)
36313635
return ret;
@@ -3787,7 +3791,7 @@ int IntelQaEcdh(WC_ASYNC_DEV* dev, WC_BIGINT* k, WC_BIGINT* xG,
37873791
(void)cofactor;
37883792

37893793
pXk->dataLenInBytes = q->len; /* bytes key size / 8 (aligned) */
3790-
pXk->pData = XREALLOC(out, pXk->dataLenInBytes, dev->heap,
3794+
pXk->pData = (Cpa8U*)XREALLOC(out, pXk->dataLenInBytes, dev->heap,
37913795
DYNAMIC_TYPE_ASYNC_NUMA);
37923796
pYk->dataLenInBytes = q->len;
37933797
pYk->pData = g_qatEcdhY;
@@ -3807,7 +3811,7 @@ int IntelQaEcdh(WC_ASYNC_DEV* dev, WC_BIGINT* k, WC_BIGINT* xG,
38073811
pXk,
38083812
pYk);
38093813
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_ECDHE_ASYNC,
3810-
callback, &retryCount));
3814+
(void*)callback, &retryCount));
38113815

38123816
if (ret == WC_PENDING_E)
38133817
return ret;
@@ -3945,9 +3949,9 @@ int IntelQaEcdsaSign(WC_ASYNC_DEV* dev,
39453949

39463950
pR->dataLenInBytes = n->len; /* bytes key size / 8 (aligned) */
39473951
pS->dataLenInBytes = n->len;
3948-
pR->pData = XREALLOC(r->buf, pR->dataLenInBytes, dev->heap,
3952+
pR->pData = (Cpa8U*)XREALLOC(r->buf, pR->dataLenInBytes, dev->heap,
39493953
DYNAMIC_TYPE_ASYNC_NUMA);
3950-
pS->pData = XREALLOC(s->buf, pS->dataLenInBytes, dev->heap,
3954+
pS->pData = (Cpa8U*)XREALLOC(s->buf, pS->dataLenInBytes, dev->heap,
39513955
DYNAMIC_TYPE_ASYNC_NUMA);
39523956

39533957
if (pR->pData == NULL || pS->pData == NULL) {
@@ -3969,7 +3973,7 @@ int IntelQaEcdsaSign(WC_ASYNC_DEV* dev,
39693973
pR,
39703974
pS);
39713975
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_ECDSA_ASYNC,
3972-
callback, &retryCount));
3976+
(void*)callback, &retryCount));
39733977

39743978
if (ret == WC_PENDING_E)
39753979
return ret;
@@ -4094,7 +4098,7 @@ int IntelQaEcdsaVerify(WC_ASYNC_DEV* dev, WC_BIGINT* m,
40944098
opData,
40954099
verifyStatus);
40964100
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_ECDSA_ASYNC,
4097-
callback, &retryCount));
4101+
(void*)callback, &retryCount));
40984102

40994103
if (ret == WC_PENDING_E)
41004104
return ret;
@@ -4215,7 +4219,8 @@ int IntelQaDhKeyGen(WC_ASYNC_DEV* dev, WC_BIGINT* p, WC_BIGINT* g,
42154219
ret = BAD_FUNC_ARG; goto exit;
42164220
}
42174221
pOut->dataLenInBytes = p->len;
4218-
pOut->pData = XREALLOC(pub, p->len, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
4222+
pOut->pData = (Cpa8U*)XREALLOC(pub, p->len, dev->heap,
4223+
DYNAMIC_TYPE_ASYNC_NUMA);
42194224
if (pOut->pData == NULL) {
42204225
ret = MEMORY_E; goto exit;
42214226
}
@@ -4233,8 +4238,8 @@ int IntelQaDhKeyGen(WC_ASYNC_DEV* dev, WC_BIGINT* p, WC_BIGINT* g,
42334238
dev,
42344239
opData,
42354240
pOut);
4236-
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_DH_ASYNC, callback,
4237-
&retryCount));
4241+
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_DH_ASYNC,
4242+
(void*)callback, &retryCount));
42384243

42394244
if (ret == WC_PENDING_E)
42404245
return ret;
@@ -4366,13 +4371,14 @@ int IntelQaDhAgree(WC_ASYNC_DEV* dev, WC_BIGINT* p,
43664371
}
43674372

43684373
opData->remoteOctetStringPV.dataLenInBytes = pubSz;
4369-
opData->remoteOctetStringPV.pData = XREALLOC((byte*)otherPub, pubSz,
4374+
opData->remoteOctetStringPV.pData = (Cpa8U*)XREALLOC((byte*)otherPub, pubSz,
43704375
dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
43714376
opData->privateValueX.dataLenInBytes = privSz;
4372-
opData->privateValueX.pData = XREALLOC((byte*)priv, privSz, dev->heap,
4373-
DYNAMIC_TYPE_ASYNC_NUMA);
4377+
opData->privateValueX.pData = (Cpa8U*)XREALLOC((byte*)priv, privSz,
4378+
dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
43744379
pOut->dataLenInBytes = p->len;
4375-
pOut->pData = XREALLOC(agree, p->len, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
4380+
pOut->pData = (Cpa8U*)XREALLOC(agree, p->len, dev->heap,
4381+
DYNAMIC_TYPE_ASYNC_NUMA);
43764382

43774383
if (opData->remoteOctetStringPV.pData == NULL ||
43784384
opData->privateValueX.pData == NULL || pOut->pData == NULL) {
@@ -4391,8 +4397,8 @@ int IntelQaDhAgree(WC_ASYNC_DEV* dev, WC_BIGINT* p,
43914397
dev,
43924398
opData,
43934399
pOut);
4394-
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_DH_ASYNC, callback,
4395-
&retryCount));
4400+
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_DH_ASYNC,
4401+
(void*)callback, &retryCount));
43964402

43974403
if (ret == WC_PENDING_E)
43984404
return ret;

0 commit comments

Comments
 (0)