Reduce the number of allocations

Signed-off-by: Alessandro Sorniotti <aso@zurich.ibm.com>

Author: ale-linux

driver/amcl/fp256bn.go

@@ -21,15 +21,15 @@ import (
 /*********************************************************************/
 
 type fp256bnGt struct {
-	*FP256BN.FP12
+	FP256BN.FP12
 }
 
 func (a *fp256bnGt) Exp(x driver.Zr) driver.Gt {
-	return &fp256bnGt{a.FP12.Pow(bigToMiraclBIGCore(x.(*common.BaseZr).Int))}
+	return &fp256bnGt{*a.FP12.Pow(bigToMiraclBIGCore(&x.(*common.BaseZr).Int))}
 }
 
 func (a *fp256bnGt) Equals(b driver.Gt) bool {
-	return a.FP12.Equals(b.(*fp256bnGt).FP12)
+	return a.FP12.Equals(&b.(*fp256bnGt).FP12)
 }
 
 func (a *fp256bnGt) IsUnity() bool {
@@ -41,7 +41,7 @@ func (a *fp256bnGt) Inverse() {
 }
 
 func (a *fp256bnGt) Mul(b driver.Gt) {
-	a.FP12.Mul(b.(*fp256bnGt).FP12)
+	a.FP12.Mul(&b.(*fp256bnGt).FP12)
 }
 
 func (b *fp256bnGt) ToString() string {
@@ -57,37 +57,37 @@ func (b *fp256bnGt) Bytes() []byte {
 /*********************************************************************/
 
 func NewFp256bn() *Fp256bn {
-	return &Fp256bn{&common.CurveBase{Modulus: &modulusBig}}
+	return &Fp256bn{common.CurveBase{Modulus: modulusBig}}
 }
 
 type Fp256bn struct {
-	*common.CurveBase
+	common.CurveBase
 }
 
 func (*Fp256bn) Pairing(a driver.G2, b driver.G1) driver.Gt {
-	return &fp256bnGt{FP256BN.Ate(a.(*fp256bnG2).ECP2, b.(*fp256bnG1).ECP)}
+	return &fp256bnGt{*FP256BN.Ate(&a.(*fp256bnG2).ECP2, &b.(*fp256bnG1).ECP)}
 }
 
 func (*Fp256bn) Pairing2(p2a, p2b driver.G2, p1a, p1b driver.G1) driver.Gt {
-	return &fp256bnGt{FP256BN.Ate2(p2a.(*fp256bnG2).ECP2, p1a.(*fp256bnG1).ECP, p2b.(*fp256bnG2).ECP2, p1b.(*fp256bnG1).ECP)}
+	return &fp256bnGt{*FP256BN.Ate2(&p2a.(*fp256bnG2).ECP2, &p1a.(*fp256bnG1).ECP, &p2b.(*fp256bnG2).ECP2, &p1b.(*fp256bnG1).ECP)}
 }
 
 func (*Fp256bn) FExp(e driver.Gt) driver.Gt {
-	return &fp256bnGt{FP256BN.Fexp(e.(*fp256bnGt).FP12)}
+	return &fp256bnGt{*FP256BN.Fexp(&e.(*fp256bnGt).FP12)}
 }
 
 func (*Fp256bn) GenG1() driver.G1 {
-	return &fp256bnG1{FP256BN.NewECPbigs(FP256BN.NewBIGints(FP256BN.CURVE_Gx), FP256BN.NewBIGints(FP256BN.CURVE_Gy))}
+	return &fp256bnG1{*FP256BN.NewECPbigs(FP256BN.NewBIGints(FP256BN.CURVE_Gx), FP256BN.NewBIGints(FP256BN.CURVE_Gy))}
 }
 
 func (*Fp256bn) GenG2() driver.G2 {
-	return &fp256bnG2{FP256BN.NewECP2fp2s(
+	return &fp256bnG2{*FP256BN.NewECP2fp2s(
 		FP256BN.NewFP2bigs(FP256BN.NewBIGints(FP256BN.CURVE_Pxa), FP256BN.NewBIGints(FP256BN.CURVE_Pxb)),
 		FP256BN.NewFP2bigs(FP256BN.NewBIGints(FP256BN.CURVE_Pya), FP256BN.NewBIGints(FP256BN.CURVE_Pyb)))}
 }
 
 func (p *Fp256bn) GenGt() driver.Gt {
-	return &fp256bnGt{FP256BN.Fexp(FP256BN.Ate(p.GenG2().(*fp256bnG2).ECP2, p.GenG1().(*fp256bnG1).ECP))}
+	return &fp256bnGt{*FP256BN.Fexp(FP256BN.Ate(&p.GenG2().(*fp256bnG2).ECP2, &p.GenG1().(*fp256bnG1).ECP))}
 }
 
 func (p *Fp256bn) CoordinateByteSize() int {
@@ -115,11 +115,11 @@ func (p *Fp256bn) ScalarByteSize() int {
 }
 
 func (p *Fp256bn) NewG1() driver.G1 {
-	return &fp256bnG1{FP256BN.NewECP()}
+	return &fp256bnG1{*FP256BN.NewECP()}
 }
 
 func (p *Fp256bn) NewG2() driver.G2 {
-	return &fp256bnG2{FP256BN.NewECP2()}
+	return &fp256bnG2{*FP256BN.NewECP2()}
 }
 
 func bigToMiraclBIGCore(bi *big.Int) *FP256BN.BIG {
@@ -137,65 +137,65 @@ func bigToMiraclBIGCore(bi *big.Int) *FP256BN.BIG {
 }
 
 func (p *Fp256bn) NewG1FromBytes(b []byte) driver.G1 {
-	return &fp256bnG1{FP256BN.ECP_fromBytes(b)}
+	return &fp256bnG1{*FP256BN.ECP_fromBytes(b)}
 }
 
 func (p *Fp256bn) NewG2FromBytes(b []byte) driver.G2 {
-	return &fp256bnG2{FP256BN.ECP2_fromBytes(b)}
+	return &fp256bnG2{*FP256BN.ECP2_fromBytes(b)}
 }
 
 func (p *Fp256bn) NewG1FromCompressed(b []byte) driver.G1 {
-	return &fp256bnG1{FP256BN.ECP_fromBytes(b)}
+	return &fp256bnG1{*FP256BN.ECP_fromBytes(b)}
 }
 
 func (p *Fp256bn) NewG2FromCompressed(b []byte) driver.G2 {
-	return &fp256bnG2{FP256BN.ECP2_fromBytes(b)}
+	return &fp256bnG2{*FP256BN.ECP2_fromBytes(b)}
 }
 
 func (p *Fp256bn) NewGtFromBytes(b []byte) driver.Gt {
-	return &fp256bnGt{FP256BN.FP12_fromBytes(b)}
+	return &fp256bnGt{*FP256BN.FP12_fromBytes(b)}
 }
 
 func (p *Fp256bn) HashToG1(data []byte) driver.G1 {
-	return &fp256bnG1{FP256BN.Bls_hash(string(data))}
+	return &fp256bnG1{*FP256BN.Bls_hash(string(data))}
 }
 
 func (p *Fp256bn) HashToG1WithDomain(data, domain []byte) driver.G1 {
 	mac := hmac.New(sha256.New, domain)
 	mac.Write(data)
-	return &fp256bnG1{FP256BN.Bls_hash(string(mac.Sum(nil)))}
+	return &fp256bnG1{*FP256BN.Bls_hash(string(mac.Sum(nil)))}
 }
 
 /*********************************************************************/
 
 type fp256bnG1 struct {
-	*FP256BN.ECP
+	FP256BN.ECP
 }
 
 func (e *fp256bnG1) Clone(a driver.G1) {
-	e.ECP.Copy(a.(*fp256bnG1).ECP)
+	e.ECP.Copy(&a.(*fp256bnG1).ECP)
 }
 
 func (e *fp256bnG1) Copy() driver.G1 {
 	c := FP256BN.NewECP()
-	c.Copy(e.ECP)
-	return &fp256bnG1{c}
+	c.Copy(&e.ECP)
+	return &fp256bnG1{*c}
 }
 
 func (e *fp256bnG1) Add(a driver.G1) {
-	e.ECP.Add(a.(*fp256bnG1).ECP)
+	e.ECP.Add(&a.(*fp256bnG1).ECP)
 }
 
 func (e *fp256bnG1) Mul(a driver.Zr) driver.G1 {
-	return &fp256bnG1{FP256BN.G1mul(e.ECP, bigToMiraclBIGCore(a.(*common.BaseZr).Int))}
+	return &fp256bnG1{*FP256BN.G1mul(&e.ECP, bigToMiraclBIGCore(&a.(*common.BaseZr).Int))}
 }
 
 func (e *fp256bnG1) Mul2(ee driver.Zr, Q driver.G1, f driver.Zr) driver.G1 {
-	return &fp256bnG1{e.ECP.Mul2(bigToMiraclBIGCore(ee.(*common.BaseZr).Int), Q.(*fp256bnG1).ECP, bigToMiraclBIGCore(f.(*common.BaseZr).Int))}
+	return &fp256bnG1{*e.ECP.Mul2(bigToMiraclBIGCore(&ee.(*common.BaseZr).Int), &Q.(*fp256bnG1).ECP, bigToMiraclBIGCore(&f.(*common.BaseZr).Int))}
 }
 
 func (e *fp256bnG1) Equals(a driver.G1) bool {
-	return e.ECP.Equals(a.(*fp256bnG1).ECP)
+	return e.ECP.Equals(&a.(*fp256bnG1).ECP)
 }
 
 func (e *fp256bnG1) IsInfinity() bool {
@@ -215,7 +215,7 @@ func (e *fp256bnG1) Compressed() []byte {
 }
 
 func (e *fp256bnG1) Sub(a driver.G1) {
-	e.ECP.Sub(a.(*fp256bnG1).ECP)
+	e.ECP.Sub(&a.(*fp256bnG1).ECP)
 }
 
 var g1StrRegexp *regexp.Regexp = regexp.MustCompile(`^\(([0-9a-f]+),([0-9a-f]+)\)$`)
@@ -234,33 +234,33 @@ func (e *fp256bnG1) Neg() {
 /*********************************************************************/
 
 type fp256bnG2 struct {
-	*FP256BN.ECP2
+	FP256BN.ECP2
 }
 
 func (e *fp256bnG2) Equals(a driver.G2) bool {
-	return e.ECP2.Equals(a.(*fp256bnG2).ECP2)
+	return e.ECP2.Equals(&a.(*fp256bnG2).ECP2)
 }
 
 func (e *fp256bnG2) Clone(a driver.G2) {
-	e.ECP2.Copy(a.(*fp256bnG2).ECP2)
+	e.ECP2.Copy(&a.(*fp256bnG2).ECP2)
 }
 
 func (e *fp256bnG2) Copy() driver.G2 {
 	c := FP256BN.NewECP2()
-	c.Copy(e.ECP2)
-	return &fp256bnG2{c}
+	c.Copy(&e.ECP2)
+	return &fp256bnG2{*c}
 }
 
 func (e *fp256bnG2) Add(a driver.G2) {
-	e.ECP2.Add(a.(*fp256bnG2).ECP2)
+	e.ECP2.Add(&a.(*fp256bnG2).ECP2)
 }
 
 func (e *fp256bnG2) Sub(a driver.G2) {
-	e.ECP2.Sub(a.(*fp256bnG2).ECP2)
+	e.ECP2.Sub(&a.(*fp256bnG2).ECP2)
 }
 
 func (e *fp256bnG2) Mul(a driver.Zr) driver.G2 {
-	return &fp256bnG2{e.ECP2.Mul(bigToMiraclBIGCore(a.(*common.BaseZr).Int))}
+	return &fp256bnG2{*e.ECP2.Mul(bigToMiraclBIGCore(&a.(*common.BaseZr).Int))}
 }
 
 func (e *fp256bnG2) Affine() {

driver/amcl/fp256bn_miracl.go

@@ -25,15 +25,15 @@ func init() {
 /*********************************************************************/
 
 type fp256bnMiraclGt struct {
-	*FP256BN.FP12
+	FP256BN.FP12
 }
 
 func (a *fp256bnMiraclGt) Exp(x driver.Zr) driver.Gt {
-	return &fp256bnMiraclGt{a.FP12.Pow(bigToMiraclBIG(x.(*common.BaseZr).Int))}
+	return &fp256bnMiraclGt{*a.FP12.Pow(bigToMiraclBIG(&x.(*common.BaseZr).Int))}
 }
 
 func (a *fp256bnMiraclGt) Equals(b driver.Gt) bool {
-	return a.FP12.Equals(b.(*fp256bnMiraclGt).FP12)
+	return a.FP12.Equals(&b.(*fp256bnMiraclGt).FP12)
 }
 
 func (a *fp256bnMiraclGt) IsUnity() bool {
@@ -45,7 +45,7 @@ func (a *fp256bnMiraclGt) Inverse() {
 }
 
 func (a *fp256bnMiraclGt) Mul(b driver.Gt) {
-	a.FP12.Mul(b.(*fp256bnMiraclGt).FP12)
+	a.FP12.Mul(&b.(*fp256bnMiraclGt).FP12)
 }
 
 func (b *fp256bnMiraclGt) ToString() string {
@@ -61,27 +61,27 @@ func (b *fp256bnMiraclGt) Bytes() []byte {
 /*********************************************************************/
 
 func NewFp256Miraclbn() *Fp256Miraclbn {
-	return &Fp256Miraclbn{&common.CurveBase{Modulus: &modulusBig}}
+	return &Fp256Miraclbn{common.CurveBase{Modulus: modulusBig}}
 }
 
 type Fp256Miraclbn struct {
-	*common.CurveBase
+	common.CurveBase
 }
 
 func (*Fp256Miraclbn) Pairing(a driver.G2, b driver.G1) driver.Gt {
-	return &fp256bnMiraclGt{FP256BN.Ate(a.(*fp256bnMiraclG2).ECP2, b.(*fp256bnMiraclG1).ECP)}
+	return &fp256bnMiraclGt{*FP256BN.Ate(a.(*fp256bnMiraclG2).ECP2, &b.(*fp256bnMiraclG1).ECP)}
 }
 
 func (*Fp256Miraclbn) Pairing2(p2a, p2b driver.G2, p1a, p1b driver.G1) driver.Gt {
-	return &fp256bnMiraclGt{FP256BN.Ate2(p2a.(*fp256bnMiraclG2).ECP2, p1a.(*fp256bnMiraclG1).ECP, p2b.(*fp256bnMiraclG2).ECP2, p1b.(*fp256bnMiraclG1).ECP)}
+	return &fp256bnMiraclGt{*FP256BN.Ate2(p2a.(*fp256bnMiraclG2).ECP2, &p1a.(*fp256bnMiraclG1).ECP, p2b.(*fp256bnMiraclG2).ECP2, &p1b.(*fp256bnMiraclG1).ECP)}
 }
 
 func (*Fp256Miraclbn) FExp(e driver.Gt) driver.Gt {
-	return &fp256bnMiraclGt{FP256BN.Fexp(e.(*fp256bnMiraclGt).FP12)}
+	return &fp256bnMiraclGt{*FP256BN.Fexp(&e.(*fp256bnMiraclGt).FP12)}
 }
 
 func (*Fp256Miraclbn) GenG1() driver.G1 {
-	return &fp256bnMiraclG1{FP256BN.NewECPbigs(FP256BN.NewBIGints(FP256BN.CURVE_Gx), FP256BN.NewBIGints(FP256BN.CURVE_Gy))}
+	return &fp256bnMiraclG1{*FP256BN.NewECPbigs(FP256BN.NewBIGints(FP256BN.CURVE_Gx), FP256BN.NewBIGints(FP256BN.CURVE_Gy))}
 }
 
 func (*Fp256Miraclbn) GenG2() driver.G2 {
@@ -91,7 +91,7 @@ func (*Fp256Miraclbn) GenG2() driver.G2 {
 }
 
 func (p *Fp256Miraclbn) GenGt() driver.Gt {
-	return &fp256bnMiraclGt{FP256BN.Fexp(FP256BN.Ate(p.GenG2().(*fp256bnMiraclG2).ECP2, p.GenG1().(*fp256bnMiraclG1).ECP))}
+	return &fp256bnMiraclGt{*FP256BN.Fexp(FP256BN.Ate(p.GenG2().(*fp256bnMiraclG2).ECP2, &p.GenG1().(*fp256bnMiraclG1).ECP))}
 }
 
 func (p *Fp256Miraclbn) CoordinateByteSize() int {
@@ -119,7 +119,7 @@ func (p *Fp256Miraclbn) ScalarByteSize() int {
 }
 
 func (p *Fp256Miraclbn) NewG1() driver.G1 {
-	return &fp256bnMiraclG1{FP256BN.NewECP()}
+	return &fp256bnMiraclG1{*FP256BN.NewECP()}
 }
 
 func (p *Fp256Miraclbn) NewG2() driver.G2 {
@@ -141,63 +141,63 @@ func bigToMiraclBIG(bi *big.Int) *FP256BN.BIG {
 }
 
 func (p *Fp256Miraclbn) NewG1FromBytes(b []byte) driver.G1 {
-	return &fp256bnMiraclG1{FP256BN.ECP_fromBytes(b)}
+	return &fp256bnMiraclG1{*FP256BN.ECP_fromBytes(b)}
 }
 
 func (p *Fp256Miraclbn) NewG2FromBytes(b []byte) driver.G2 {
 	return &fp256bnMiraclG2{FP256BN.ECP2_fromBytes(b)}
 }
 
 func (p *Fp256Miraclbn) NewG1FromCompressed(b []byte) driver.G1 {
-	return &fp256bnMiraclG1{FP256BN.ECP_fromBytes(b)}
+	return &fp256bnMiraclG1{*FP256BN.ECP_fromBytes(b)}
 }
 
 func (p *Fp256Miraclbn) NewG2FromCompressed(b []byte) driver.G2 {
 	return &fp256bnMiraclG2{FP256BN.ECP2_fromBytes(b)}
 }
 
 func (p *Fp256Miraclbn) NewGtFromBytes(b []byte) driver.Gt {
-	return &fp256bnMiraclGt{FP256BN.FP12_fromBytes(b)}
+	return &fp256bnMiraclGt{*FP256BN.FP12_fromBytes(b)}
 }
 
 func (p *Fp256Miraclbn) HashToG1(data []byte) driver.G1 {
-	return &fp256bnMiraclG1{bls_hash_to_point_miracl(data, []byte{})}
+	return &fp256bnMiraclG1{*bls_hash_to_point_miracl(data, []byte{})}
 }
 
 func (p *Fp256Miraclbn) HashToG1WithDomain(data, domain []byte) driver.G1 {
-	return &fp256bnMiraclG1{bls_hash_to_point_miracl(data, domain)}
+	return &fp256bnMiraclG1{*bls_hash_to_point_miracl(data, domain)}
 }
 
 /*********************************************************************/
 
 type fp256bnMiraclG1 struct {
-	*FP256BN.ECP
+	FP256BN.ECP
 }
 
 func (e *fp256bnMiraclG1) Clone(a driver.G1) {
-	e.ECP.Copy(a.(*fp256bnMiraclG1).ECP)
+	e.ECP.Copy(&a.(*fp256bnMiraclG1).ECP)
 }
 
 func (e *fp256bnMiraclG1) Copy() driver.G1 {
 	c := FP256BN.NewECP()
-	c.Copy(e.ECP)
-	return &fp256bnMiraclG1{c}
+	c.Copy(&e.ECP)
+	return &fp256bnMiraclG1{*c}
 }
 
 func (e *fp256bnMiraclG1) Add(a driver.G1) {
-	e.ECP.Add(a.(*fp256bnMiraclG1).ECP)
+	e.ECP.Add(&a.(*fp256bnMiraclG1).ECP)
 }
 
 func (e *fp256bnMiraclG1) Mul(a driver.Zr) driver.G1 {
-	return &fp256bnMiraclG1{FP256BN.G1mul(e.ECP, bigToMiraclBIG(a.(*common.BaseZr).Int))}
+	return &fp256bnMiraclG1{*FP256BN.G1mul(&e.ECP, bigToMiraclBIG(&a.(*common.BaseZr).Int))}
 }
 
 func (e *fp256bnMiraclG1) Mul2(ee driver.Zr, Q driver.G1, f driver.Zr) driver.G1 {
-	return &fp256bnMiraclG1{e.ECP.Mul2(bigToMiraclBIG(ee.(*common.BaseZr).Int), Q.(*fp256bnMiraclG1).ECP, bigToMiraclBIG(f.(*common.BaseZr).Int))}
+	return &fp256bnMiraclG1{*e.ECP.Mul2(bigToMiraclBIG(&ee.(*common.BaseZr).Int), &Q.(*fp256bnMiraclG1).ECP, bigToMiraclBIG(&f.(*common.BaseZr).Int))}
 }
 
 func (e *fp256bnMiraclG1) Equals(a driver.G1) bool {
-	return e.ECP.Equals(a.(*fp256bnMiraclG1).ECP)
+	return e.ECP.Equals(&a.(*fp256bnMiraclG1).ECP)
 }
 
 func (e *fp256bnMiraclG1) IsInfinity() bool {
@@ -217,7 +217,7 @@ func (e *fp256bnMiraclG1) Compressed() []byte {
 }
 
 func (e *fp256bnMiraclG1) Sub(a driver.G1) {
-	e.ECP.Sub(a.(*fp256bnMiraclG1).ECP)
+	e.ECP.Sub(&a.(*fp256bnMiraclG1).ECP)
 }
 
 func (b *fp256bnMiraclG1) String() string {
@@ -259,7 +259,7 @@ func (e *fp256bnMiraclG2) Sub(a driver.G2) {
 }
 
 func (e *fp256bnMiraclG2) Mul(a driver.Zr) driver.G2 {
-	return &fp256bnMiraclG2{e.ECP2.Mul(bigToMiraclBIG(a.(*common.BaseZr).Int))}
+	return &fp256bnMiraclG2{e.ECP2.Mul(bigToMiraclBIG(&a.(*common.BaseZr).Int))}
 }
 
 func (e *fp256bnMiraclG2) Affine() {