Quelle  riscv64_device.go   Sprache: unbekannt

// 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"

 cc_config "android/soong/cc/config"
)

var (
 Riscv64RustFlags = []string{
  "-C force-frame-pointers=y",
 }
 Riscv64ArchFeatureRustFlags = map[string][]string{
  "riscv64": {
   "-C target-feature=+V,+Zba,+Zbb,+Zbs",
  },
 }
 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
 cc_toolchain       cc_config.Toolchain
}

func (t *toolchainRiscv64) RustTriple() string {
 return "riscv64-linux-android"
}

func (t *toolchainRiscv64) ToolchainLinkFlags(ctx ToolchainFlagsContext) cc_config.FlagsWithDeps {
 // Prepend the lld flags from cc_config so we stay in sync with cc
 deviceGlobalLinkFlags := cc_config.FlagsWithDeps{
  Flags: "${config.DeviceGlobalLinkFlags}",
 }
 riscv64ToolchainLinkFlags := cc_config.FlagsWithDeps{
  Flags: "${config.Riscv64ToolchainLinkFlags}",
 }
 ccFlags := t.cc_toolchain.Ldflags(ctx)
 ccFlags.Flags = strings.ReplaceAll(ccFlags.Flags, "${config.", "${cc_config.")
 return deviceGlobalLinkFlags.Append(ccFlags).Append(riscv64ToolchainLinkFlags)
}

func (t *toolchainRiscv64) ToolchainRustFlags(ctx ToolchainFlagsContext) cc_config.FlagsWithDeps {
 return cc_config.FlagsWithDeps{
  Flags: 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]...)
 }

 cc_toolchain := cc_config.FindToolchain(android.Android, arch, false)
 return &toolchainRiscv64{
  toolchainRustFlags: strings.Join(toolchainRustFlags, " "),
  cc_toolchain:       cc_toolchain,
 }
}