Quelle  riscv64_device.go   Sprache: unbekannt

// 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.
  // Common to all LP64 architectures.
  "-Werror=implicit-function-declaration",

  // For stack allocations larger than a page, touch each page immediately
  // to ensure we hit the guard page on stack overflow.
  // Common to all LP64 architectures.
  "-fstack-clash-protection",

  // This is already the driver's Android default, but duplicated here (and
  // below) for ease of experimentation with additional extensions.
  "-march=rv64gcv_zba_zbb_zbs_zvbb",
  // TODO: remove when qemu V works (https://gitlab.com/qemu-project/qemu/-/issues/1976)
  // (Note that we'll probably want to wait for berberis to be good enough
  // that most people don't care about qemu's V performance either!)
  "-mno-implicit-float",
 }

 riscv64ArchVariantCflags = map[string][]string{}

 riscv64Ldflags = []string{
  // This is already the driver's Android default, but duplicated here (and
  // above) for ease of experimentation with additional extensions.
  "-march=rv64gcv_zba_zbb_zbs_zvbb",
  "-Wl,-z,max-page-size=4096",
 }

 riscv64Cppflags = []string{}

 riscv64CpuVariantCflags = map[string][]string{}
)

const ()

func init() {

 pctx.StaticVariable("Riscv64Ldflags", strings.Join(riscv64Ldflags, " "))

 pctx.StaticVariable("Riscv64Cflags", strings.Join(riscv64Cflags, " "))
 pctx.StaticVariable("Riscv64Cppflags", strings.Join(riscv64Cppflags, " "))
}

var (
 riscv64ArchVariantCflagsVar = map[string]string{}

 riscv64CpuVariantCflagsVar = map[string]string{}

 riscv64CpuVariantLdflags = map[string]string{}
)

type toolchainRiscv64 struct {
 toolchainBionic
 toolchain64Bit

 ldflags         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(ctx ToolchainFlagsContext) FlagsWithDeps {
 return FlagsWithDeps{
  Flags: t.ldflags,
 }
}

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,
  }, " "),
  toolchainCflags: strings.Join(toolchainCflags, " "),
 }
}

func init() {
 registerToolchainFactory(android.Android, android.Riscv64, riscv64ToolchainFactory)
}