From f05b0d35d2fbe51be9961ce8ce8031f840295c68 Mon Sep 17 00:00:00 2001 From: Colin Cross Date: Thu, 14 Jul 2022 18:10:34 -0700 Subject: [PATCH] Add riscv64-linux-android support Add barebones riscv64-linux-android support. This should be enough to add riscv64-specific entries to Android.bp files, but can't actually compile anything until there are riscv64 toolchains. Test: arch_test.go Change-Id: I0dcc7e797d9352dd38243be908a7f19004ff3db1 --- android/arch.go | 11 +- android/arch_test.go | 1 + bazel/configurability.go | 14 +- bp2build/build_conversion_test.go | 5 + bp2build/cc_library_static_conversion_test.go | 20 +++ cc/config/Android.bp | 1 + cc/config/riscv64_device.go | 140 ++++++++++++++++++ rust/config/Android.bp | 1 + rust/config/riscv64_device.go | 91 ++++++++++++ 9 files changed, 274 insertions(+), 10 deletions(-) create mode 100644 cc/config/riscv64_device.go create mode 100644 rust/config/riscv64_device.go diff --git a/android/arch.go b/android/arch.go index 9bc9d8924..75ee922fb 100644 --- a/android/arch.go +++ b/android/arch.go @@ -147,10 +147,11 @@ const COMMON_VARIANT = "common" var ( archTypeList []ArchType - Arm = newArch("arm", "lib32") - Arm64 = newArch("arm64", "lib64") - X86 = newArch("x86", "lib32") - X86_64 = newArch("x86_64", "lib64") + Arm = newArch("arm", "lib32") + Arm64 = newArch("arm64", "lib64") + Riscv64 = newArch("riscv64", "lib64") + X86 = newArch("x86", "lib32") + X86_64 = newArch("x86_64", "lib64") Common = ArchType{ Name: COMMON_VARIANT, @@ -318,7 +319,7 @@ var ( Windows = newOsType("windows", Host, true, X86, X86_64) // Android is the OS for target devices that run all of Android, including the Linux kernel // and the Bionic libc runtime. - Android = newOsType("android", Device, false, Arm, Arm64, X86, X86_64) + Android = newOsType("android", Device, false, Arm, Arm64, Riscv64, X86, X86_64) // CommonOS is a pseudo OSType for a common OS variant, which is OsType agnostic and which // has dependencies on all the OS variants. diff --git a/android/arch_test.go b/android/arch_test.go index 6814f8a7d..46c018a0a 100644 --- a/android/arch_test.go +++ b/android/arch_test.go @@ -596,6 +596,7 @@ func TestArchProperties(t *testing.T) { arm64: { a: ["arm64"], }, + riscv64: { a: ["riscv64"] }, x86: { a: ["x86"] }, x86_64: { a: ["x86_64"] }, }, diff --git a/bazel/configurability.go b/bazel/configurability.go index b6bbd67c4..a93aa000a 100644 --- a/bazel/configurability.go +++ b/bazel/configurability.go @@ -23,10 +23,11 @@ import ( const ( // ArchType names in arch.go - archArm = "arm" - archArm64 = "arm64" - archX86 = "x86" - archX86_64 = "x86_64" + archArm = "arm" + archArm64 = "arm64" + archRiscv64 = "riscv64" + archX86 = "x86" + archX86_64 = "x86_64" // OsType names in arch.go OsAndroid = "android" @@ -39,6 +40,7 @@ const ( // Targets in arch.go osArchAndroidArm = "android_arm" osArchAndroidArm64 = "android_arm64" + osArchAndroidRiscv64 = "android_riscv64" osArchAndroidX86 = "android_x86" osArchAndroidX86_64 = "android_x86_64" osArchDarwinArm64 = "darwin_arm64" @@ -99,6 +101,7 @@ func createPlatformArchMap() map[string]string { "arm64": { "dotprod", }, + "riscv64": {}, "x86": { "ssse3", "sse4", @@ -164,6 +167,7 @@ var ( platformOsArchMap = map[string]string{ osArchAndroidArm: "//build/bazel/platforms/os_arch:android_arm", osArchAndroidArm64: "//build/bazel/platforms/os_arch:android_arm64", + osArchAndroidRiscv64: "//build/bazel/platforms/os_arch:android_riscv64", osArchAndroidX86: "//build/bazel/platforms/os_arch:android_x86", osArchAndroidX86_64: "//build/bazel/platforms/os_arch:android_x86_64", osArchDarwinArm64: "//build/bazel/platforms/os_arch:darwin_arm64", @@ -187,7 +191,7 @@ var ( // TODO(cparsons): Source from arch.go; this task is nontrivial, as it currently results // in a cyclic dependency. osToArchMap = map[string][]string{ - OsAndroid: {archArm, archArm64, archX86, archX86_64}, + OsAndroid: {archArm, archArm64, archRiscv64, archX86, archX86_64}, osLinux: {archX86, archX86_64}, osLinuxMusl: {archX86, archX86_64}, osDarwin: {archArm64, archX86_64}, diff --git a/bp2build/build_conversion_test.go b/bp2build/build_conversion_test.go index d513d04d9..c1fb800b0 100644 --- a/bp2build/build_conversion_test.go +++ b/bp2build/build_conversion_test.go @@ -369,6 +369,7 @@ custom { x86_64: { arch_paths: ["x86_64.txt"] }, arm: { arch_paths: ["arm.txt"] }, arm64: { arch_paths: ["arm64.txt"] }, + riscv64: { arch_paths: ["riscv64.txt"] }, }, target: { linux: { arch_paths: ["linux.txt"] }, @@ -401,6 +402,10 @@ custom { "arm64.txt", "lib64.txt", ], + "//build/bazel/platforms/arch:riscv64": [ + "riscv64.txt", + "lib64.txt", + ], "//build/bazel/platforms/arch:x86": [ "x86.txt", "lib32.txt", diff --git a/bp2build/cc_library_static_conversion_test.go b/bp2build/cc_library_static_conversion_test.go index e3ea9a07c..b47d1f1f1 100644 --- a/bp2build/cc_library_static_conversion_test.go +++ b/bp2build/cc_library_static_conversion_test.go @@ -836,6 +836,10 @@ cc_library_static { "not-for-lib32.c", "for-lib64.c", ], + "//build/bazel/platforms/arch:riscv64": [ + "not-for-lib32.c", + "for-lib64.c", + ], "//build/bazel/platforms/arch:x86": [ "not-for-lib64.c", "for-lib32.c", @@ -867,6 +871,7 @@ func TestCcLibrarySTaticArchMultilibSrcsExcludeSrcs(t *testing.T) { "for-lib64.c": "", "not-for-arm.c": "", "not-for-arm64.c": "", + "not-for-riscv64.c": "", "not-for-x86.c": "", "not-for-x86_64.c": "", "not-for-lib32.c": "", @@ -881,6 +886,7 @@ cc_library_static { arch: { arm: { srcs: ["for-arm.c"], exclude_srcs: ["not-for-arm.c"] }, arm64: { srcs: ["for-arm64.c"], exclude_srcs: ["not-for-arm64.c"] }, + riscv64: { srcs: ["for-riscv64.c"], exclude_srcs: ["not-for-riscv64.c"] }, x86: { srcs: ["for-x86.c"], exclude_srcs: ["not-for-x86.c"] }, x86_64: { srcs: ["for-x86_64.c"], exclude_srcs: ["not-for-x86_64.c"] }, }, @@ -896,6 +902,7 @@ cc_library_static { "//build/bazel/platforms/arch:arm": [ "not-for-arm64.c", "not-for-lib64.c", + "not-for-riscv64.c", "not-for-x86.c", "not-for-x86_64.c", "for-arm.c", @@ -904,15 +911,26 @@ cc_library_static { "//build/bazel/platforms/arch:arm64": [ "not-for-arm.c", "not-for-lib32.c", + "not-for-riscv64.c", "not-for-x86.c", "not-for-x86_64.c", "for-arm64.c", "for-lib64.c", ], + "//build/bazel/platforms/arch:riscv64": [ + "not-for-arm.c", + "not-for-arm64.c", + "not-for-lib32.c", + "not-for-x86.c", + "not-for-x86_64.c", + "for-riscv64.c", + "for-lib64.c", + ], "//build/bazel/platforms/arch:x86": [ "not-for-arm.c", "not-for-arm64.c", "not-for-lib64.c", + "not-for-riscv64.c", "not-for-x86_64.c", "for-x86.c", "for-lib32.c", @@ -921,6 +939,7 @@ cc_library_static { "not-for-arm.c", "not-for-arm64.c", "not-for-lib32.c", + "not-for-riscv64.c", "not-for-x86.c", "for-x86_64.c", "for-lib64.c", @@ -930,6 +949,7 @@ cc_library_static { "not-for-arm64.c", "not-for-lib32.c", "not-for-lib64.c", + "not-for-riscv64.c", "not-for-x86.c", "not-for-x86_64.c", ], diff --git a/cc/config/Android.bp b/cc/config/Android.bp index 64a121e30..fdc94ada8 100644 --- a/cc/config/Android.bp +++ b/cc/config/Android.bp @@ -21,6 +21,7 @@ bootstrap_go_package { "arm_device.go", "arm64_device.go", + "riscv64_device.go", "x86_device.go", "x86_64_device.go", diff --git a/cc/config/riscv64_device.go b/cc/config/riscv64_device.go new file mode 100644 index 000000000..d8918f164 --- /dev/null +++ b/cc/config/riscv64_device.go @@ -0,0 +1,140 @@ +// Copyright 2022 Google Inc. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package config + +import ( + "fmt" + "strings" + + "android/soong/android" +) + +var ( + riscv64Cflags = []string{ + // Help catch common 32/64-bit errors. + "-Werror=implicit-function-declaration", + } + + riscv64ArchVariantCflags = map[string][]string{} + + riscv64Ldflags = []string{ + "-Wl,--hash-style=gnu", + "-Wl,-z,separate-code", + } + + riscv64Lldflags = append(riscv64Ldflags, + "-Wl,-z,max-page-size=4096") + + riscv64Cppflags = []string{} + + riscv64CpuVariantCflags = map[string][]string{} +) + +const () + +func init() { + + exportedVars.ExportStringListStaticVariable("Riscv64Ldflags", riscv64Ldflags) + exportedVars.ExportStringListStaticVariable("Riscv64Lldflags", riscv64Lldflags) + + exportedVars.ExportStringListStaticVariable("Riscv64Cflags", riscv64Cflags) + exportedVars.ExportStringListStaticVariable("Riscv64Cppflags", riscv64Cppflags) + + exportedVars.ExportVariableReferenceDict("Riscv64ArchVariantCflags", riscv64ArchVariantCflagsVar) + exportedVars.ExportVariableReferenceDict("Riscv64CpuVariantCflags", riscv64CpuVariantCflagsVar) + exportedVars.ExportVariableReferenceDict("Riscv64CpuVariantLdflags", riscv64CpuVariantLdflags) +} + +var ( + riscv64ArchVariantCflagsVar = map[string]string{} + + riscv64CpuVariantCflagsVar = map[string]string{} + + riscv64CpuVariantLdflags = map[string]string{} +) + +type toolchainRiscv64 struct { + toolchainBionic + toolchain64Bit + + ldflags string + lldflags string + toolchainCflags string +} + +func (t *toolchainRiscv64) Name() string { + return "riscv64" +} + +func (t *toolchainRiscv64) IncludeFlags() string { + return "" +} + +func (t *toolchainRiscv64) ClangTriple() string { + return "riscv64-linux-android" +} + +func (t *toolchainRiscv64) Cflags() string { + return "${config.Riscv64Cflags}" +} + +func (t *toolchainRiscv64) Cppflags() string { + return "${config.Riscv64Cppflags}" +} + +func (t *toolchainRiscv64) Ldflags() string { + return t.ldflags +} + +func (t *toolchainRiscv64) Lldflags() string { + return t.lldflags +} + +func (t *toolchainRiscv64) ToolchainCflags() string { + return t.toolchainCflags +} + +func (toolchainRiscv64) LibclangRuntimeLibraryArch() string { + return "riscv64" +} + +func riscv64ToolchainFactory(arch android.Arch) Toolchain { + switch arch.ArchVariant { + case "": + default: + panic(fmt.Sprintf("Unknown Riscv64 architecture version: %q", arch.ArchVariant)) + } + + toolchainCflags := []string{riscv64ArchVariantCflagsVar[arch.ArchVariant]} + toolchainCflags = append(toolchainCflags, + variantOrDefault(riscv64CpuVariantCflagsVar, arch.CpuVariant)) + + extraLdflags := variantOrDefault(riscv64CpuVariantLdflags, arch.CpuVariant) + return &toolchainRiscv64{ + ldflags: strings.Join([]string{ + "${config.Riscv64Ldflags}", + extraLdflags, + }, " "), + lldflags: strings.Join([]string{ + "${config.Riscv64Lldflags}", + extraLdflags, + }, " "), + toolchainCflags: strings.Join(toolchainCflags, " "), + } +} + +func init() { + registerToolchainFactory(android.Android, android.Riscv64, riscv64ToolchainFactory) +} diff --git a/rust/config/Android.bp b/rust/config/Android.bp index be73d69eb..79ea7a174 100644 --- a/rust/config/Android.bp +++ b/rust/config/Android.bp @@ -15,6 +15,7 @@ bootstrap_go_package { "arm64_device.go", "global.go", "lints.go", + "riscv64_device.go", "toolchain.go", "darwin_host.go", "x86_linux_bionic_host.go", diff --git a/rust/config/riscv64_device.go b/rust/config/riscv64_device.go new file mode 100644 index 000000000..3b41a10ad --- /dev/null +++ b/rust/config/riscv64_device.go @@ -0,0 +1,91 @@ +// Copyright 2022 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package config + +import ( + "strings" + + "android/soong/android" +) + +var ( + Riscv64RustFlags = []string{} + Riscv64ArchFeatureRustFlags = map[string][]string{"": {}} + Riscv64LinkFlags = []string{} + + Riscv64ArchVariantRustFlags = map[string][]string{} +) + +func init() { + registerToolchainFactory(android.Android, android.Riscv64, Riscv64ToolchainFactory) + + pctx.StaticVariable("Riscv64ToolchainRustFlags", strings.Join(Riscv64RustFlags, " ")) + pctx.StaticVariable("Riscv64ToolchainLinkFlags", strings.Join(Riscv64LinkFlags, " ")) + + for variant, rustFlags := range Riscv64ArchVariantRustFlags { + pctx.StaticVariable("Riscv64"+variant+"VariantRustFlags", + strings.Join(rustFlags, " ")) + } + +} + +type toolchainRiscv64 struct { + toolchain64Bit + toolchainRustFlags string +} + +func (t *toolchainRiscv64) RustTriple() string { + return "riscv64-linux-android" +} + +func (t *toolchainRiscv64) ToolchainLinkFlags() string { + // Prepend the lld flags from cc_config so we stay in sync with cc + return "${config.DeviceGlobalLinkFlags} ${cc_config.Riscv64Lldflags} ${config.Riscv64ToolchainLinkFlags}" +} + +func (t *toolchainRiscv64) ToolchainRustFlags() string { + return t.toolchainRustFlags +} + +func (t *toolchainRiscv64) RustFlags() string { + return "${config.Riscv64ToolchainRustFlags}" +} + +func (t *toolchainRiscv64) Supported() bool { + return true +} + +func (toolchainRiscv64) LibclangRuntimeLibraryArch() string { + return "riscv64" +} + +func Riscv64ToolchainFactory(arch android.Arch) Toolchain { + archVariant := arch.ArchVariant + + toolchainRustFlags := []string{ + "${config.Riscv64ToolchainRustFlags}", + "${config.Riscv64" + archVariant + "VariantRustFlags}", + } + + toolchainRustFlags = append(toolchainRustFlags, deviceGlobalRustFlags...) + + for _, feature := range arch.ArchFeatures { + toolchainRustFlags = append(toolchainRustFlags, Riscv64ArchFeatureRustFlags[feature]...) + } + + return &toolchainRiscv64{ + toolchainRustFlags: strings.Join(toolchainRustFlags, " "), + } +}