Refactor how bp2build gets arch-specific props.
Then plumb them to LabelAttribute. This refactoring is required because the previous implementation did not handle properties in shards other than the first one (e.g. version_script) well. In addition, it also makes the code paths between bp2build and analysis more similar. Bug: 186650430 Test: Presubmits. Change-Id: Ic4393e8ae47f4e88816bf45c89399efd61494d22
This commit is contained in:
Lukacs T. Berki
449
android/arch.go
449
android/arch.go
@@ -1014,35 +1014,19 @@ func initArchModule(m Module) {
|
||||
base.customizableProperties = m.GetProperties()
|
||||
}
|
||||
|
||||
// appendProperties squashes properties from the given field of the given src property struct
|
||||
// into the dst property struct. Returns the reflect.Value of the field in the src property
|
||||
// struct to be used for further appendProperties calls on fields of that property struct.
|
||||
func (m *ModuleBase) appendProperties(ctx BottomUpMutatorContext,
|
||||
dst interface{}, src reflect.Value, field, srcPrefix string) reflect.Value {
|
||||
|
||||
// Step into non-nil pointers to structs in the src value.
|
||||
if src.Kind() == reflect.Ptr {
|
||||
if src.IsNil() {
|
||||
return src
|
||||
}
|
||||
src = src.Elem()
|
||||
}
|
||||
|
||||
// Find the requested field in the src struct.
|
||||
src = src.FieldByName(field)
|
||||
if !src.IsValid() {
|
||||
ctx.ModuleErrorf("field %q does not exist", srcPrefix)
|
||||
return src
|
||||
}
|
||||
|
||||
// Save the value of the field in the src struct to return.
|
||||
ret := src
|
||||
|
||||
func maybeBlueprintEmbed(src reflect.Value) reflect.Value {
|
||||
// If the value of the field is a struct (as opposed to a pointer to a struct) then step
|
||||
// into the BlueprintEmbed field.
|
||||
if src.Kind() == reflect.Struct {
|
||||
src = src.FieldByName("BlueprintEmbed")
|
||||
return src.FieldByName("BlueprintEmbed")
|
||||
} else {
|
||||
return src
|
||||
}
|
||||
}
|
||||
|
||||
// Merges the property struct in srcValue into dst.
|
||||
func mergePropertyStruct(ctx BaseMutatorContext, dst interface{}, srcValue reflect.Value) {
|
||||
src := maybeBlueprintEmbed(srcValue).Interface()
|
||||
|
||||
// order checks the `android:"variant_prepend"` tag to handle properties where the
|
||||
// arch-specific value needs to come before the generic value, for example for lists of
|
||||
@@ -1058,7 +1042,7 @@ func (m *ModuleBase) appendProperties(ctx BottomUpMutatorContext,
|
||||
}
|
||||
|
||||
// Squash the located property struct into the destination property struct.
|
||||
err := proptools.ExtendMatchingProperties([]interface{}{dst}, src.Interface(), nil, order)
|
||||
err := proptools.ExtendMatchingProperties([]interface{}{dst}, src, nil, order)
|
||||
if err != nil {
|
||||
if propertyErr, ok := err.(*proptools.ExtendPropertyError); ok {
|
||||
ctx.PropertyErrorf(propertyErr.Property, "%s", propertyErr.Err.Error())
|
||||
@@ -1066,8 +1050,29 @@ func (m *ModuleBase) appendProperties(ctx BottomUpMutatorContext,
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ret
|
||||
// Returns the immediate child of the input property struct that corresponds to
|
||||
// the sub-property "field".
|
||||
func getChildPropertyStruct(ctx BaseMutatorContext,
|
||||
src reflect.Value, field, userFriendlyField string) reflect.Value {
|
||||
|
||||
// Step into non-nil pointers to structs in the src value.
|
||||
if src.Kind() == reflect.Ptr {
|
||||
if src.IsNil() {
|
||||
return src
|
||||
}
|
||||
src = src.Elem()
|
||||
}
|
||||
|
||||
// Find the requested field in the src struct.
|
||||
src = src.FieldByName(proptools.FieldNameForProperty(field))
|
||||
if !src.IsValid() {
|
||||
ctx.ModuleErrorf("field %q does not exist", userFriendlyField)
|
||||
return src
|
||||
}
|
||||
|
||||
return src
|
||||
}
|
||||
|
||||
// Squash the appropriate OS-specific property structs into the matching top level property structs
|
||||
@@ -1094,7 +1099,8 @@ func (m *ModuleBase) setOSProperties(ctx BottomUpMutatorContext) {
|
||||
if os.Class == Host {
|
||||
field := "Host"
|
||||
prefix := "target.host"
|
||||
m.appendProperties(ctx, genProps, targetProp, field, prefix)
|
||||
hostProperties := getChildPropertyStruct(ctx, targetProp, field, prefix)
|
||||
mergePropertyStruct(ctx, genProps, hostProperties)
|
||||
}
|
||||
|
||||
// Handle target OS generalities of the form:
|
||||
@@ -1106,13 +1112,15 @@ func (m *ModuleBase) setOSProperties(ctx BottomUpMutatorContext) {
|
||||
if os.Linux() {
|
||||
field := "Linux"
|
||||
prefix := "target.linux"
|
||||
m.appendProperties(ctx, genProps, targetProp, field, prefix)
|
||||
linuxProperties := getChildPropertyStruct(ctx, targetProp, field, prefix)
|
||||
mergePropertyStruct(ctx, genProps, linuxProperties)
|
||||
}
|
||||
|
||||
if os.Bionic() {
|
||||
field := "Bionic"
|
||||
prefix := "target.bionic"
|
||||
m.appendProperties(ctx, genProps, targetProp, field, prefix)
|
||||
bionicProperties := getChildPropertyStruct(ctx, targetProp, field, prefix)
|
||||
mergePropertyStruct(ctx, genProps, bionicProperties)
|
||||
}
|
||||
|
||||
// Handle target OS properties in the form:
|
||||
@@ -1129,12 +1137,14 @@ func (m *ModuleBase) setOSProperties(ctx BottomUpMutatorContext) {
|
||||
// },
|
||||
field := os.Field
|
||||
prefix := "target." + os.Name
|
||||
m.appendProperties(ctx, genProps, targetProp, field, prefix)
|
||||
osProperties := getChildPropertyStruct(ctx, targetProp, field, prefix)
|
||||
mergePropertyStruct(ctx, genProps, osProperties)
|
||||
|
||||
if os.Class == Host && os != Windows {
|
||||
field := "Not_windows"
|
||||
prefix := "target.not_windows"
|
||||
m.appendProperties(ctx, genProps, targetProp, field, prefix)
|
||||
notWindowsProperties := getChildPropertyStruct(ctx, targetProp, field, prefix)
|
||||
mergePropertyStruct(ctx, genProps, notWindowsProperties)
|
||||
}
|
||||
|
||||
// Handle 64-bit device properties in the form:
|
||||
@@ -1154,17 +1164,189 @@ func (m *ModuleBase) setOSProperties(ctx BottomUpMutatorContext) {
|
||||
if ctx.Config().Android64() {
|
||||
field := "Android64"
|
||||
prefix := "target.android64"
|
||||
m.appendProperties(ctx, genProps, targetProp, field, prefix)
|
||||
android64Properties := getChildPropertyStruct(ctx, targetProp, field, prefix)
|
||||
mergePropertyStruct(ctx, genProps, android64Properties)
|
||||
} else {
|
||||
field := "Android32"
|
||||
prefix := "target.android32"
|
||||
m.appendProperties(ctx, genProps, targetProp, field, prefix)
|
||||
android32Properties := getChildPropertyStruct(ctx, targetProp, field, prefix)
|
||||
mergePropertyStruct(ctx, genProps, android32Properties)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Returns the struct containing the properties specific to the given
|
||||
// architecture type. These look like this in Blueprint files:
|
||||
// arch: {
|
||||
// arm64: {
|
||||
// key: value,
|
||||
// },
|
||||
// },
|
||||
// This struct will also contain sub-structs containing to the architecture/CPU
|
||||
// variants and features that themselves contain properties specific to those.
|
||||
func getArchTypeStruct(ctx BaseMutatorContext, archProperties interface{}, archType ArchType) reflect.Value {
|
||||
archPropValues := reflect.ValueOf(archProperties).Elem()
|
||||
archProp := archPropValues.FieldByName("Arch").Elem()
|
||||
prefix := "arch." + archType.Name
|
||||
archStruct := getChildPropertyStruct(ctx, archProp, archType.Name, prefix)
|
||||
return archStruct
|
||||
}
|
||||
|
||||
// Returns the struct containing the properties specific to a given multilib
|
||||
// value. These look like this in the Blueprint file:
|
||||
// multilib: {
|
||||
// lib32: {
|
||||
// key: value,
|
||||
// },
|
||||
// },
|
||||
func getMultilibStruct(ctx BaseMutatorContext, archProperties interface{}, archType ArchType) reflect.Value {
|
||||
archPropValues := reflect.ValueOf(archProperties).Elem()
|
||||
multilibProp := archPropValues.FieldByName("Multilib").Elem()
|
||||
multilibProperties := getChildPropertyStruct(ctx, multilibProp, archType.Multilib, "multilib."+archType.Multilib)
|
||||
return multilibProperties
|
||||
}
|
||||
|
||||
// Returns the structs corresponding to the properties specific to the given
|
||||
// architecture and OS in archProperties.
|
||||
func getArchProperties(ctx BaseMutatorContext, archProperties interface{}, arch Arch, os OsType, nativeBridgeEnabled bool) []reflect.Value {
|
||||
result := make([]reflect.Value, 0)
|
||||
archPropValues := reflect.ValueOf(archProperties).Elem()
|
||||
|
||||
targetProp := archPropValues.FieldByName("Target").Elem()
|
||||
|
||||
archType := arch.ArchType
|
||||
|
||||
if arch.ArchType != Common {
|
||||
archStruct := getArchTypeStruct(ctx, archProperties, arch.ArchType)
|
||||
result = append(result, archStruct)
|
||||
|
||||
// Handle arch-variant-specific properties in the form:
|
||||
// arch: {
|
||||
// arm: {
|
||||
// variant: {
|
||||
// key: value,
|
||||
// },
|
||||
// },
|
||||
// },
|
||||
v := variantReplacer.Replace(arch.ArchVariant)
|
||||
if v != "" {
|
||||
prefix := "arch." + archType.Name + "." + v
|
||||
variantProperties := getChildPropertyStruct(ctx, archStruct, v, prefix)
|
||||
result = append(result, variantProperties)
|
||||
}
|
||||
|
||||
// Handle cpu-variant-specific properties in the form:
|
||||
// arch: {
|
||||
// arm: {
|
||||
// variant: {
|
||||
// key: value,
|
||||
// },
|
||||
// },
|
||||
// },
|
||||
if arch.CpuVariant != arch.ArchVariant {
|
||||
c := variantReplacer.Replace(arch.CpuVariant)
|
||||
if c != "" {
|
||||
prefix := "arch." + archType.Name + "." + c
|
||||
cpuVariantProperties := getChildPropertyStruct(ctx, archStruct, c, prefix)
|
||||
result = append(result, cpuVariantProperties)
|
||||
}
|
||||
}
|
||||
|
||||
// Handle arch-feature-specific properties in the form:
|
||||
// arch: {
|
||||
// arm: {
|
||||
// feature: {
|
||||
// key: value,
|
||||
// },
|
||||
// },
|
||||
// },
|
||||
for _, feature := range arch.ArchFeatures {
|
||||
prefix := "arch." + archType.Name + "." + feature
|
||||
featureProperties := getChildPropertyStruct(ctx, archStruct, feature, prefix)
|
||||
result = append(result, featureProperties)
|
||||
}
|
||||
|
||||
multilibProperties := getMultilibStruct(ctx, archProperties, archType)
|
||||
result = append(result, multilibProperties)
|
||||
|
||||
// Handle combined OS-feature and arch specific properties in the form:
|
||||
// target: {
|
||||
// bionic_x86: {
|
||||
// key: value,
|
||||
// },
|
||||
// }
|
||||
if os.Linux() {
|
||||
field := "Linux_" + arch.ArchType.Name
|
||||
userFriendlyField := "target.linux_" + arch.ArchType.Name
|
||||
linuxProperties := getChildPropertyStruct(ctx, targetProp, field, userFriendlyField)
|
||||
result = append(result, linuxProperties)
|
||||
}
|
||||
|
||||
if os.Bionic() {
|
||||
field := "Bionic_" + archType.Name
|
||||
userFriendlyField := "target.bionic_" + archType.Name
|
||||
bionicProperties := getChildPropertyStruct(ctx, targetProp, field, userFriendlyField)
|
||||
result = append(result, bionicProperties)
|
||||
}
|
||||
|
||||
// Handle combined OS and arch specific properties in the form:
|
||||
// target: {
|
||||
// linux_glibc_x86: {
|
||||
// key: value,
|
||||
// },
|
||||
// linux_glibc_arm: {
|
||||
// key: value,
|
||||
// },
|
||||
// android_arm {
|
||||
// key: value,
|
||||
// },
|
||||
// android_x86 {
|
||||
// key: value,
|
||||
// },
|
||||
// },
|
||||
field := os.Field + "_" + archType.Name
|
||||
userFriendlyField := "target." + os.Name + "_" + archType.Name
|
||||
osArchProperties := getChildPropertyStruct(ctx, targetProp, field, userFriendlyField)
|
||||
result = append(result, osArchProperties)
|
||||
}
|
||||
|
||||
// Handle arm on x86 properties in the form:
|
||||
// target {
|
||||
// arm_on_x86 {
|
||||
// key: value,
|
||||
// },
|
||||
// arm_on_x86_64 {
|
||||
// key: value,
|
||||
// },
|
||||
// },
|
||||
if os.Class == Device {
|
||||
if arch.ArchType == X86 && (hasArmAbi(arch) ||
|
||||
hasArmAndroidArch(ctx.Config().Targets[Android])) {
|
||||
field := "Arm_on_x86"
|
||||
userFriendlyField := "target.arm_on_x86"
|
||||
armOnX86Properties := getChildPropertyStruct(ctx, targetProp, field, userFriendlyField)
|
||||
result = append(result, armOnX86Properties)
|
||||
}
|
||||
if arch.ArchType == X86_64 && (hasArmAbi(arch) ||
|
||||
hasArmAndroidArch(ctx.Config().Targets[Android])) {
|
||||
field := "Arm_on_x86_64"
|
||||
userFriendlyField := "target.arm_on_x86_64"
|
||||
armOnX8664Properties := getChildPropertyStruct(ctx, targetProp, field, userFriendlyField)
|
||||
result = append(result, armOnX8664Properties)
|
||||
}
|
||||
if os == Android && nativeBridgeEnabled {
|
||||
userFriendlyField := "Native_bridge"
|
||||
prefix := "target.native_bridge"
|
||||
nativeBridgeProperties := getChildPropertyStruct(ctx, targetProp, userFriendlyField, prefix)
|
||||
result = append(result, nativeBridgeProperties)
|
||||
}
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
// Squash the appropriate arch-specific property structs into the matching top level property
|
||||
// structs based on the CompileTarget value that was annotated on the variant.
|
||||
func (m *ModuleBase) setArchProperties(ctx BottomUpMutatorContext) {
|
||||
@@ -1176,144 +1358,15 @@ func (m *ModuleBase) setArchProperties(ctx BottomUpMutatorContext) {
|
||||
if m.archProperties[i] == nil {
|
||||
continue
|
||||
}
|
||||
for _, archProperties := range m.archProperties[i] {
|
||||
archPropValues := reflect.ValueOf(archProperties).Elem()
|
||||
|
||||
archProp := archPropValues.FieldByName("Arch").Elem()
|
||||
multilibProp := archPropValues.FieldByName("Multilib").Elem()
|
||||
targetProp := archPropValues.FieldByName("Target").Elem()
|
||||
propStructs := make([]reflect.Value, 0)
|
||||
for _, archProperty := range m.archProperties[i] {
|
||||
propStructShard := getArchProperties(ctx, archProperty, arch, os, m.Target().NativeBridge == NativeBridgeEnabled)
|
||||
propStructs = append(propStructs, propStructShard...)
|
||||
}
|
||||
|
||||
// Handle arch-specific properties in the form:
|
||||
// arch: {
|
||||
// arm64: {
|
||||
// key: value,
|
||||
// },
|
||||
// },
|
||||
t := arch.ArchType
|
||||
|
||||
if arch.ArchType != Common {
|
||||
field := proptools.FieldNameForProperty(t.Name)
|
||||
prefix := "arch." + t.Name
|
||||
archStruct := m.appendProperties(ctx, genProps, archProp, field, prefix)
|
||||
|
||||
// Handle arch-variant-specific properties in the form:
|
||||
// arch: {
|
||||
// variant: {
|
||||
// key: value,
|
||||
// },
|
||||
// },
|
||||
v := variantReplacer.Replace(arch.ArchVariant)
|
||||
if v != "" {
|
||||
field := proptools.FieldNameForProperty(v)
|
||||
prefix := "arch." + t.Name + "." + v
|
||||
m.appendProperties(ctx, genProps, archStruct, field, prefix)
|
||||
}
|
||||
|
||||
// Handle cpu-variant-specific properties in the form:
|
||||
// arch: {
|
||||
// variant: {
|
||||
// key: value,
|
||||
// },
|
||||
// },
|
||||
if arch.CpuVariant != arch.ArchVariant {
|
||||
c := variantReplacer.Replace(arch.CpuVariant)
|
||||
if c != "" {
|
||||
field := proptools.FieldNameForProperty(c)
|
||||
prefix := "arch." + t.Name + "." + c
|
||||
m.appendProperties(ctx, genProps, archStruct, field, prefix)
|
||||
}
|
||||
}
|
||||
|
||||
// Handle arch-feature-specific properties in the form:
|
||||
// arch: {
|
||||
// feature: {
|
||||
// key: value,
|
||||
// },
|
||||
// },
|
||||
for _, feature := range arch.ArchFeatures {
|
||||
field := proptools.FieldNameForProperty(feature)
|
||||
prefix := "arch." + t.Name + "." + feature
|
||||
m.appendProperties(ctx, genProps, archStruct, field, prefix)
|
||||
}
|
||||
|
||||
// Handle multilib-specific properties in the form:
|
||||
// multilib: {
|
||||
// lib32: {
|
||||
// key: value,
|
||||
// },
|
||||
// },
|
||||
field = proptools.FieldNameForProperty(t.Multilib)
|
||||
prefix = "multilib." + t.Multilib
|
||||
m.appendProperties(ctx, genProps, multilibProp, field, prefix)
|
||||
}
|
||||
|
||||
// Handle combined OS-feature and arch specific properties in the form:
|
||||
// target: {
|
||||
// bionic_x86: {
|
||||
// key: value,
|
||||
// },
|
||||
// }
|
||||
if os.Linux() && arch.ArchType != Common {
|
||||
field := "Linux_" + arch.ArchType.Name
|
||||
prefix := "target.linux_" + arch.ArchType.Name
|
||||
m.appendProperties(ctx, genProps, targetProp, field, prefix)
|
||||
}
|
||||
|
||||
if os.Bionic() && arch.ArchType != Common {
|
||||
field := "Bionic_" + t.Name
|
||||
prefix := "target.bionic_" + t.Name
|
||||
m.appendProperties(ctx, genProps, targetProp, field, prefix)
|
||||
}
|
||||
|
||||
// Handle combined OS and arch specific properties in the form:
|
||||
// target: {
|
||||
// linux_glibc_x86: {
|
||||
// key: value,
|
||||
// },
|
||||
// linux_glibc_arm: {
|
||||
// key: value,
|
||||
// },
|
||||
// android_arm {
|
||||
// key: value,
|
||||
// },
|
||||
// android_x86 {
|
||||
// key: value,
|
||||
// },
|
||||
// },
|
||||
if arch.ArchType != Common {
|
||||
field := os.Field + "_" + t.Name
|
||||
prefix := "target." + os.Name + "_" + t.Name
|
||||
m.appendProperties(ctx, genProps, targetProp, field, prefix)
|
||||
}
|
||||
|
||||
// Handle arm on x86 properties in the form:
|
||||
// target {
|
||||
// arm_on_x86 {
|
||||
// key: value,
|
||||
// },
|
||||
// arm_on_x86_64 {
|
||||
// key: value,
|
||||
// },
|
||||
// },
|
||||
if os.Class == Device {
|
||||
if arch.ArchType == X86 && (hasArmAbi(arch) ||
|
||||
hasArmAndroidArch(ctx.Config().Targets[Android])) {
|
||||
field := "Arm_on_x86"
|
||||
prefix := "target.arm_on_x86"
|
||||
m.appendProperties(ctx, genProps, targetProp, field, prefix)
|
||||
}
|
||||
if arch.ArchType == X86_64 && (hasArmAbi(arch) ||
|
||||
hasArmAndroidArch(ctx.Config().Targets[Android])) {
|
||||
field := "Arm_on_x86_64"
|
||||
prefix := "target.arm_on_x86_64"
|
||||
m.appendProperties(ctx, genProps, targetProp, field, prefix)
|
||||
}
|
||||
if os == Android && m.Target().NativeBridge == NativeBridgeEnabled {
|
||||
field := "Native_bridge"
|
||||
prefix := "target.native_bridge"
|
||||
m.appendProperties(ctx, genProps, targetProp, field, prefix)
|
||||
}
|
||||
}
|
||||
for _, propStruct := range propStructs {
|
||||
mergePropertyStruct(ctx, genProps, propStruct)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1810,7 +1863,7 @@ func (m *ModuleBase) getMultilibPropertySet(propertySet interface{}, archType Ar
|
||||
// For example: `arch: { x86: { Foo: ["bar"] } }, multilib: { lib32: {` Foo: ["baz"] } }`
|
||||
// will result in `Foo: ["bar", "baz"]` being returned for architecture x86, if the given
|
||||
// propertyset contains `Foo []string`.
|
||||
func (m *ModuleBase) GetArchProperties(propertySet interface{}) map[ArchType]interface{} {
|
||||
func (m *ModuleBase) GetArchProperties(ctx BaseMutatorContext, propertySet interface{}) map[ArchType]interface{} {
|
||||
// Return value of the arch types to the prop values for that arch.
|
||||
archToProp := map[ArchType]interface{}{}
|
||||
|
||||
@@ -1819,27 +1872,47 @@ func (m *ModuleBase) GetArchProperties(propertySet interface{}) map[ArchType]int
|
||||
return archToProp
|
||||
}
|
||||
|
||||
// For each arch (x86, arm64, etc.),
|
||||
dstType := reflect.ValueOf(propertySet).Type()
|
||||
var archProperties []interface{}
|
||||
|
||||
// First find the property set in the module that corresponds to the requested
|
||||
// one. m.archProperties[i] corresponds to m.generalProperties[i].
|
||||
for i, generalProp := range m.generalProperties {
|
||||
srcType := reflect.ValueOf(generalProp).Type()
|
||||
if srcType == dstType {
|
||||
archProperties = m.archProperties[i]
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if archProperties == nil {
|
||||
// This module does not have the property set requested
|
||||
return archToProp
|
||||
}
|
||||
|
||||
// For each arch type (x86, arm64, etc.)
|
||||
for _, arch := range ArchTypeList() {
|
||||
// Find arch-specific properties matching that property set type. For example, any
|
||||
// matching properties under `arch { x86 { ... } }`.
|
||||
archPropertySet := m.getArchPropertySet(propertySet, arch)
|
||||
|
||||
// Find multilib-specific properties matching that property set type. For example, any
|
||||
// matching properties under `multilib { lib32 { ... } }` for x86, as x86 is 32-bit.
|
||||
multilibPropertySet := m.getMultilibPropertySet(propertySet, arch)
|
||||
|
||||
// Append the multilibPropertySet to archPropertySet. This combines the
|
||||
// arch and multilib properties into a single property struct.
|
||||
err := proptools.ExtendMatchingProperties([]interface{}{archPropertySet}, multilibPropertySet, nil, proptools.OrderAppend)
|
||||
if err != nil {
|
||||
// archPropertySet and multilibPropertySet must be of the same type, or
|
||||
// something horrible went wrong.
|
||||
panic(err)
|
||||
// Arch properties are sometimes sharded (see createArchPropTypeDesc() ).
|
||||
// Iterate over ever shard and extract a struct with the same type as the
|
||||
// input one that contains the data specific to that arch.
|
||||
propertyStructs := make([]reflect.Value, 0)
|
||||
for _, archProperty := range archProperties {
|
||||
archTypeStruct := getArchTypeStruct(ctx, archProperty, arch)
|
||||
multilibStruct := getMultilibStruct(ctx, archProperty, arch)
|
||||
propertyStructs = append(propertyStructs, archTypeStruct, multilibStruct)
|
||||
}
|
||||
|
||||
archToProp[arch] = archPropertySet
|
||||
// Create a new instance of the requested property set
|
||||
value := reflect.New(reflect.ValueOf(propertySet).Elem().Type()).Interface()
|
||||
|
||||
// Merge all the structs together
|
||||
for _, propertyStruct := range propertyStructs {
|
||||
mergePropertyStruct(ctx, value, propertyStruct)
|
||||
}
|
||||
|
||||
archToProp[arch] = value
|
||||
}
|
||||
|
||||
return archToProp
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user