/*

 * Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved.

 * Copyright (c) 2016, 2019 SAP SE. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "precompiled.hpp"

#include "jvm.h"

#include "asm/assembler.inline.hpp"

#include "compiler/disassembler.hpp"

#include "code/compiledIC.hpp"

#include "memory/resourceArea.hpp"

#include "runtime/java.hpp"

#include "runtime/stubCodeGenerator.hpp"

# include <sys/sysinfo.h>

bool VM_Version::_is_determine_features_test_running  = false;

const char*   VM_Version::_model_string;

unsigned long VM_Version::_features[_features_buffer_len]           = {0, 0, 0, 0};

unsigned long VM_Version::_cipher_features[_features_buffer_len]    = {0, 0, 0, 0};

unsigned long VM_Version::_msgdigest_features[_features_buffer_len] = {0, 0, 0, 0};

unsigned int  VM_Version::_nfeatures                                = 0;

unsigned int  VM_Version::_ncipher_features                         = 0;

unsigned int  VM_Version::_nmsgdigest_features                      = 0;

static const char* z_gen[]     = {"  ",   "G1",   "G2", "G3",    "G4",     "G5",      "G6",   "G7"   };

static const char* z_machine[] = {"  ", "2064", "2084", "2094",  "2097",   "2817",    "  ",   "2964" };

static const char* z_name[]    = {"  ", "z900", "z990", "z9 EC", "z10 EC", "z196 EC", "ec12", "z13"  };

void VM_Version::initialize() {

  determine_features();      // Get processor capabilities.

  set_features_string();     // Set a descriptive feature indication.

  if (Verbose) {

    print_features();

  }

  intx cache_line_size = Dcache_lineSize(0);

#ifdef COMPILER2

  MaxVectorSize = 8;

#endif

  if (has_PrefetchRaw()) {

    if (FLAG_IS_DEFAULT(AllocatePrefetchStyle)) {  // not preset

      // 0 = no prefetch.

      // 1 = Prefetch instructions for each allocation.

      // 2 = Use TLAB watermark to gate allocation prefetch.

      AllocatePrefetchStyle = 1;

    }

    if (AllocatePrefetchStyle > 0) {  // Prefetching turned on at all?

      // Distance to prefetch ahead of allocation pointer.

      if (FLAG_IS_DEFAULT(AllocatePrefetchDistance) || (AllocatePrefetchDistance < 0)) {  // not preset

        AllocatePrefetchDistance = 0;

      }

      // Number of lines to prefetch ahead of allocation pointer.

      if (FLAG_IS_DEFAULT(AllocatePrefetchLines) || (AllocatePrefetchLines <= 0)) {      // not preset

        AllocatePrefetchLines = 3;

      }

      // Step size in bytes of sequential prefetch instructions.

      if (FLAG_IS_DEFAULT(AllocatePrefetchStepSize) || (AllocatePrefetchStepSize <= 0)) { // not preset

        FLAG_SET_DEFAULT(AllocatePrefetchStepSize, cache_line_size);

      } else if (AllocatePrefetchStepSize < cache_line_size) {

        FLAG_SET_DEFAULT(AllocatePrefetchStepSize, cache_line_size);

      } else {

        FLAG_SET_DEFAULT(AllocatePrefetchStepSize, cache_line_size);

      }

    } else {

      FLAG_SET_DEFAULT(AllocatePrefetchStyle, 0);

      AllocatePrefetchDistance = 0;

      AllocatePrefetchLines    = 0;

      // Can't be zero. Will SIGFPE during constraints checking.

      FLAG_SET_DEFAULT(AllocatePrefetchStepSize, cache_line_size);

    }

  } else {

    FLAG_SET_DEFAULT(AllocatePrefetchStyle, 0);

    AllocatePrefetchDistance = 0;

    AllocatePrefetchLines    = 0;

    // Can't be zero. Will SIGFPE during constraints checking.

    FLAG_SET_DEFAULT(AllocatePrefetchStepSize, cache_line_size);

  }

  // TODO:

  // On z/Architecture, cache line size is significantly large (256 bytes). Do we really need

  // to keep contended members that far apart? Performance tests are required.

  if (FLAG_IS_DEFAULT(ContendedPaddingWidth) && (cache_line_size > ContendedPaddingWidth)) {

    ContendedPaddingWidth = cache_line_size;

  }

  // On z/Architecture, the CRC32/CRC32C intrinsics are implemented "by hand".

  // TODO: Provide implementation based on the vector instructions available from z13.

  // Note: The CHECKSUM instruction, which has been there since the very beginning

  //       (of z/Architecture), computes "some kind of" a checksum.

  //       It has nothing to do with the CRC32 algorithm.

  if (FLAG_IS_DEFAULT(UseCRC32Intrinsics)) {

    FLAG_SET_DEFAULT(UseCRC32Intrinsics, true);

  }

  if (FLAG_IS_DEFAULT(UseCRC32CIntrinsics)) {

    FLAG_SET_DEFAULT(UseCRC32CIntrinsics, true);

  }

  // TODO: Provide implementation.

  if (UseAdler32Intrinsics) {

    warning("Adler32Intrinsics not available on this CPU.");

    FLAG_SET_DEFAULT(UseAdler32Intrinsics, false);

  }

  // On z/Architecture, we take UseAES as the general switch to enable/disable the AES intrinsics.

  // The specific, and yet to be defined, switches UseAESxxxIntrinsics will then be set

  // depending on the actual machine capabilities.

  // Explicitly setting them via CmdLine option takes precedence, of course.

  // TODO: UseAESIntrinsics must be made keylength specific.

  // As of March 2015 and Java8, only AES128 is supported by the Java Cryptographic Extensions.

  // Therefore, UseAESIntrinsics is of minimal use at the moment.

  if (FLAG_IS_DEFAULT(UseAES) && has_Crypto_AES()) {

    FLAG_SET_DEFAULT(UseAES, true);

  }

  if (UseAES && !has_Crypto_AES()) {

    warning("AES instructions are not available on this CPU");

    FLAG_SET_DEFAULT(UseAES, false);

  }

  if (UseAES) {

    if (FLAG_IS_DEFAULT(UseAESIntrinsics)) {

      FLAG_SET_DEFAULT(UseAESIntrinsics, true);

    }

  }

  if (UseAESIntrinsics && !has_Crypto_AES()) {

    warning("AES intrinsics are not available on this CPU");

    FLAG_SET_DEFAULT(UseAESIntrinsics, false);

  }

  if (UseAESIntrinsics && !UseAES) {

    warning("AES intrinsics require UseAES flag to be enabled. Intrinsics will be disabled.");

    FLAG_SET_DEFAULT(UseAESIntrinsics, false);

  }

  // TODO: implement AES/CTR intrinsics

  if (UseAESCTRIntrinsics) {

    warning("AES/CTR intrinsics are not available on this CPU");

    FLAG_SET_DEFAULT(UseAESCTRIntrinsics, false);

  }

  if (FLAG_IS_DEFAULT(UseGHASHIntrinsics) && has_Crypto_GHASH()) {

    FLAG_SET_DEFAULT(UseGHASHIntrinsics, true);

  }

  if (UseGHASHIntrinsics && !has_Crypto_GHASH()) {

    warning("GHASH intrinsics are not available on this CPU");

    FLAG_SET_DEFAULT(UseGHASHIntrinsics, false);

  }

  if (FLAG_IS_DEFAULT(UseFMA)) {

    FLAG_SET_DEFAULT(UseFMA, true);

  }

  // On z/Architecture, we take UseSHA as the general switch to enable/disable the SHA intrinsics.

  // The specific switches UseSHAxxxIntrinsics will then be set depending on the actual

  // machine capabilities.

  // Explicitly setting them via CmdLine option takes precedence, of course.

  if (FLAG_IS_DEFAULT(UseSHA) && has_Crypto_SHA()) {

    FLAG_SET_DEFAULT(UseSHA, true);

  }

  if (UseSHA && !has_Crypto_SHA()) {

    warning("SHA instructions are not available on this CPU");

    FLAG_SET_DEFAULT(UseSHA, false);

  }

  if (UseSHA && has_Crypto_SHA1()) {

    if (FLAG_IS_DEFAULT(UseSHA1Intrinsics)) {

      FLAG_SET_DEFAULT(UseSHA1Intrinsics, true);

    }

  } else if (UseSHA1Intrinsics) {

    warning("Intrinsics for SHA-1 crypto hash functions not available on this CPU.");

    FLAG_SET_DEFAULT(UseSHA1Intrinsics, false);

  }

  if (UseSHA && has_Crypto_SHA256()) {

    if (FLAG_IS_DEFAULT(UseSHA256Intrinsics)) {

      FLAG_SET_DEFAULT(UseSHA256Intrinsics, true);

    }

  } else if (UseSHA256Intrinsics) {

    warning("Intrinsics for SHA-224 and SHA-256 crypto hash functions not available on this CPU.");

    FLAG_SET_DEFAULT(UseSHA256Intrinsics, false);

  }

  if (UseSHA && has_Crypto_SHA512()) {

    if (FLAG_IS_DEFAULT(UseSHA512Intrinsics)) {

      FLAG_SET_DEFAULT(UseSHA512Intrinsics, true);

    }

  } else if (UseSHA512Intrinsics) {

    warning("Intrinsics for SHA-384 and SHA-512 crypto hash functions not available on this CPU.");

    FLAG_SET_DEFAULT(UseSHA512Intrinsics, false);

  }

  if (!(UseSHA1Intrinsics || UseSHA256Intrinsics || UseSHA512Intrinsics)) {

    FLAG_SET_DEFAULT(UseSHA, false);

  }

#ifdef COMPILER2

  if (FLAG_IS_DEFAULT(UseMultiplyToLenIntrinsic)) {

    FLAG_SET_DEFAULT(UseMultiplyToLenIntrinsic, true);

  }

  if (FLAG_IS_DEFAULT(UseMontgomeryMultiplyIntrinsic)) {

    FLAG_SET_DEFAULT(UseMontgomeryMultiplyIntrinsic, true);

  }

  if (FLAG_IS_DEFAULT(UseMontgomerySquareIntrinsic)) {

    FLAG_SET_DEFAULT(UseMontgomerySquareIntrinsic, true);

  }

#endif

  if (FLAG_IS_DEFAULT(UsePopCountInstruction)) {

    FLAG_SET_DEFAULT(UsePopCountInstruction, true);

  }

  // z/Architecture supports 8-byte compare-exchange operations

  // (see Atomic::cmpxchg)

  // and 'atomic long memory ops' (see Unsafe_GetLongVolatile).

  _supports_cx8 = true;

  _supports_atomic_getadd4 = VM_Version::has_LoadAndALUAtomicV1();

  _supports_atomic_getadd8 = VM_Version::has_LoadAndALUAtomicV1();

  // z/Architecture supports unaligned memory accesses.

  // Performance penalty is negligible. An additional tick or so

  // is lost if the accessed data spans a cache line boundary.

  // Unaligned accesses are not atomic, of course.

  if (FLAG_IS_DEFAULT(UseUnalignedAccesses)) {

    FLAG_SET_DEFAULT(UseUnalignedAccesses, true);

  }

}

void VM_Version::set_features_string() {

  unsigned int ambiguity = 0;

  _model_string = z_name[0];

  if (is_z13()) {

    _features_string = "System z G7-z13  (LDISP_fast, ExtImm, PCrel Load/Store, CmpB, Cond Load/Store, Interlocked Update, TxM, VectorInstr)";

    _model_string = z_name[7];

    ambiguity++;

  }

  if (is_ec12()) {

    _features_string = "System z G6-EC12 (LDISP_fast, ExtImm, PCrel Load/Store, CmpB, Cond Load/Store, Interlocked Update, TxM)";

    _model_string = z_name[6];

    ambiguity++;

  }

  if (is_z196()) {

    _features_string = "System z G5-z196 (LDISP_fast, ExtImm, PCrel Load/Store, CmpB, Cond Load/Store, Interlocked Update)";

    _model_string = z_name[5];

    ambiguity++;

  }

  if (is_z10()) {

    _features_string = "System z G4-z10  (LDISP_fast, ExtImm, PCrel Load/Store, CmpB)";

    _model_string = z_name[4];

    ambiguity++;

  }

  if (is_z9()) {

    _features_string = "System z G3-z9   (LDISP_fast, ExtImm), out-of-support as of 2016-04-01";

    _model_string = z_name[3];

    ambiguity++;

  }

  if (is_z990()) {

    _features_string = "System z G2-z990 (LDISP_fast), out-of-support as of 2014-07-01";

    _model_string = z_name[2];

    ambiguity++;

  }

  if (is_z900()) {

    _features_string = "System z G1-z900 (LDISP), out-of-support as of 2014-07-01";

    _model_string = z_name[1];

    ambiguity++;

  }

  if (ambiguity == 0) {

    _features_string = "z/Architecture (unknown generation)";

  } else if (ambiguity > 1) {

    tty->print_cr("*** WARNING *** Ambiguous z/Architecture detection, ambiguity = %d", ambiguity);

    tty->print_cr("                oldest detected generation is %s", _features_string);

    _features_string = "z/Architecture (ambiguous detection)";

  }

  if (has_Crypto_AES()) {

    char buf[256];

    assert(strlen(_features_string) + 4 + 3*4 + 1 < sizeof(buf), "increase buffer size");

    jio_snprintf(buf, sizeof(buf), "%s aes%s%s%s", // String 'aes' must be surrounded by spaces so that jtreg tests recognize it.

                 _features_string,

                 has_Crypto_AES128() ? " 128" : "",

                 has_Crypto_AES192() ? " 192" : "",

                 has_Crypto_AES256() ? " 256" : "");

    _features_string = os::strdup(buf);

  }

  if (has_Crypto_SHA()) {

    char buf[256];

    assert(strlen(_features_string) + 4 + 2 + 2*4 + 6 + 1 < sizeof(buf), "increase buffer size");

    // String 'sha1' etc must be surrounded by spaces so that jtreg tests recognize it.

    jio_snprintf(buf, sizeof(buf), "%s %s%s%s%s",

                 _features_string,

                 has_Crypto_SHA1()   ? " sha1"   : "",

                 has_Crypto_SHA256() ? " sha256" : "",

                 has_Crypto_SHA512() ? " sha512" : "",

                 has_Crypto_GHASH()  ? " ghash"  : "");

    if (has_Crypto_AES()) { os::free((void *)_features_string); }

    _features_string = os::strdup(buf);

  }

}

// featureBuffer - bit array indicating availability of various features

// featureNum    - bit index of feature to be tested

//                 Featurenum < 0 requests test for any nonzero bit in featureBuffer.

// bufLen        - length of featureBuffer in bits

bool VM_Version::test_feature_bit(unsigned long* featureBuffer, int featureNum, unsigned int bufLen) {

  assert(bufLen > 0,             "buffer len must be positive");

  assert((bufLen & 0x0007) == 0, "unaligned buffer len");

  assert(((intptr_t)featureBuffer&0x0007) == 0, "unaligned feature buffer");

  if (featureNum < 0) {

    // Any bit set at all?

    bool anyBit = false;

    for (size_t i = 0; i < bufLen/(8*sizeof(long)); i++) {

      anyBit = anyBit || (featureBuffer[i] != 0);

    }

    return anyBit;

  } else {

    assert((unsigned int)featureNum < bufLen,    "feature index out of range");

    unsigned char* byteBuffer = (unsigned char*)featureBuffer;

    int   byteIndex  = featureNum/(8*sizeof(char));

    int   bitIndex   = featureNum%(8*sizeof(char));

    // Indexed bit set?

    return (byteBuffer[byteIndex] & (1U<<(7-bitIndex))) != 0;

  }

}

void VM_Version::print_features_internal(const char* text, bool print_anyway) {

  tty->print_cr("%s %s",       text, features_string());

  tty->print("%s", text);

  for (unsigned int i = 0; i < _nfeatures; i++) {

    tty->print("  0x%16.16lx", _features[i]);

  }

  tty->cr();

  if (Verbose || print_anyway) {

    // z900

    if (has_long_displacement()        ) tty->print_cr("available: %s", "LongDispFacility");

    // z990

    if (has_long_displacement_fast()   ) tty->print_cr("available: %s", "LongDispFacilityHighPerf");

    if (has_ETF2() && has_ETF3()       ) tty->print_cr("available: %s", "ETF2 and ETF3");

    if (has_Crypto()                   ) tty->print_cr("available: %s", "CryptoFacility");

    // z9

    if (has_extended_immediate()       ) tty->print_cr("available: %s", "ExtImmedFacility");

    if (has_StoreFacilityListExtended()) tty->print_cr("available: %s", "StoreFacilityListExtended");

    if (has_StoreClockFast()           ) tty->print_cr("available: %s", "StoreClockFast");

    if (has_ETF2Enhancements()         ) tty->print_cr("available: %s", "ETF2 Enhancements");

    if (has_ETF3Enhancements()         ) tty->print_cr("available: %s", "ETF3 Enhancements");

    if (has_HFPUnnormalized()          ) tty->print_cr("available: %s", "HFPUnnormalizedFacility");

    if (has_HFPMultiplyAndAdd()        ) tty->print_cr("available: %s", "HFPMultiplyAndAddFacility");

    // z10

    if (has_ParsingEnhancements()      ) tty->print_cr("available: %s", "Parsing Enhancements");

    if (has_ExtractCPUtime()           ) tty->print_cr("available: %s", "ExtractCPUTime");

    if (has_CompareSwapStore()         ) tty->print_cr("available: %s", "CompareSwapStore");

    if (has_GnrlInstrExtensions()      ) tty->print_cr("available: %s", "General Instruction Extensions");

    if (has_CompareBranch()            ) tty->print_cr("  available: %s", "Compare and Branch");

    if (has_CompareTrap()              ) tty->print_cr("  available: %s", "Compare and Trap");

    if (has_RelativeLoadStore()        ) tty->print_cr("  available: %s", "Relative Load/Store");

    if (has_MultiplySingleImm32()      ) tty->print_cr("  available: %s", "MultiplySingleImm32");

    if (has_Prefetch()                 ) tty->print_cr("  available: %s", "Prefetch");

    if (has_MoveImmToMem()             ) tty->print_cr("  available: %s", "Direct Moves Immediate to Memory");

    if (has_MemWithImmALUOps()         ) tty->print_cr("  available: %s", "Direct ALU Ops Memory .op. Immediate");

    if (has_ExtractCPUAttributes()     ) tty->print_cr("  available: %s", "Extract CPU Atributes");

    if (has_ExecuteExtensions()        ) tty->print_cr("available: %s", "ExecuteExtensions");

    if (has_FPSupportEnhancements()    ) tty->print_cr("available: %s", "FPSupportEnhancements");

    if (has_DecimalFloatingPoint()     ) tty->print_cr("available: %s", "DecimalFloatingPoint");

    // z196

    if (has_DistinctOpnds()            ) tty->print_cr("available: %s", "Distinct Operands");

    if (has_InterlockedAccessV1()      ) tty->print_cr("  available: %s", "InterlockedAccess V1 (fast)");

    if (has_PopCount()                 ) tty->print_cr("  available: %s", "PopCount");

    if (has_LoadStoreConditional()     ) tty->print_cr("  available: %s", "LoadStoreConditional");

    if (has_HighWordInstr()            ) tty->print_cr("  available: %s", "HighWord Instructions");

    if (has_FastSync()                 ) tty->print_cr("  available: %s", "FastSync (bcr 14,0)");

    if (has_AtomicMemWithImmALUOps()   ) tty->print_cr("available: %s", "Atomic Direct ALU Ops Memory .op. Immediate");

    if (has_FPExtensions()             ) tty->print_cr("available: %s", "Floatingpoint Extensions");

    if (has_CryptoExt3()               ) tty->print_cr("available: %s", "Crypto Extensions 3");

    if (has_CryptoExt4()               ) tty->print_cr("available: %s", "Crypto Extensions 4");

    // EC12

    if (has_MiscInstrExt()             ) tty->print_cr("available: %s", "Miscelaneous Instruction Extensions");

    if (has_ExecutionHint()            ) tty->print_cr("  available: %s", "Execution Hints (branch prediction)");

    if (has_ProcessorAssist()          ) tty->print_cr("  available: %s", "Processor Assists");

    if (has_LoadAndTrap()              ) tty->print_cr("  available: %s", "Load and Trap");

    if (has_TxMem()                    ) tty->print_cr("available: %s", "Transactional Memory");

    if (has_InterlockedAccessV2()      ) tty->print_cr("  available: %s", "InterlockedAccess V2 (fast)");

    if (has_DFPZonedConversion()       ) tty->print_cr("  available: %s", "DFP Zoned Conversions");

    // z13

    if (has_LoadStoreConditional2()    ) tty->print_cr("available: %s", "Load/Store Conditional 2");

    if (has_CryptoExt5()               ) tty->print_cr("available: %s", "Crypto Extensions 5");

    if (has_DFPPackedConversion()      ) tty->print_cr("available: %s", "DFP Packed Conversions");

    if (has_VectorFacility()           ) tty->print_cr("available: %s", "Vector Facility");

    // test switches

    if (has_TestFeature1Impl()         ) tty->print_cr("available: %s", "TestFeature1Impl");

    if (has_TestFeature2Impl()         ) tty->print_cr("available: %s", "TestFeature2Impl");

    if (has_TestFeature4Impl()         ) tty->print_cr("available: %s", "TestFeature4Impl");

    if (has_TestFeature8Impl()         ) tty->print_cr("available: %s", "TestFeature8Impl");

    if (has_Crypto()) {

      tty->cr();

      tty->print_cr("detailed availability of %s capabilities:", "CryptoFacility");

      if (test_feature_bit(&_cipher_features[0], -1, 2*Cipher::_featureBits)) {

        tty->cr();

        tty->print_cr("  available: %s", "Message Cipher Functions");

      }

      if (test_feature_bit(&_cipher_features[0], -1, (int)Cipher::_featureBits)) {

        tty->print_cr("    available Crypto Features of KM  (Cipher Message):");

        for (unsigned int i = 0; i < Cipher::_featureBits; i++) {

          if (test_feature_bit(&_cipher_features[0], i, (int)Cipher::_featureBits)) {

            switch (i) {

              case Cipher::_Query:              tty->print_cr("      available: KM   Query");                  break;

              case Cipher::_DEA:                tty->print_cr("      available: KM   DEA");                    break;

              case Cipher::_TDEA128:            tty->print_cr("      available: KM   TDEA-128");               break;

              case Cipher::_TDEA192:            tty->print_cr("      available: KM   TDEA-192");               break;

              case Cipher::_EncryptedDEA:       tty->print_cr("      available: KM   Encrypted DEA");          break;

              case Cipher::_EncryptedDEA128:    tty->print_cr("      available: KM   Encrypted DEA-128");      break;

              case Cipher::_EncryptedDEA192:    tty->print_cr("      available: KM   Encrypted DEA-192");      break;

              case Cipher::_AES128:             tty->print_cr("      available: KM   AES-128");                break;

              case Cipher::_AES192:             tty->print_cr("      available: KM   AES-192");                break;

              case Cipher::_AES256:             tty->print_cr("      available: KM   AES-256");                break;

              case Cipher::_EnccryptedAES128:   tty->print_cr("      available: KM   Encrypted-AES-128");      break;

              case Cipher::_EnccryptedAES192:   tty->print_cr("      available: KM   Encrypted-AES-192");      break;

              case Cipher::_EnccryptedAES256:   tty->print_cr("      available: KM   Encrypted-AES-256");      break;

              case Cipher::_XTSAES128:          tty->print_cr("      available: KM   XTS-AES-128");            break;

              case Cipher::_XTSAES256:          tty->print_cr("      available: KM   XTS-AES-256");            break;

              case Cipher::_EncryptedXTSAES128: tty->print_cr("      available: KM   XTS-Encrypted-AES-128");  break;

              case Cipher::_EncryptedXTSAES256: tty->print_cr("      available: KM   XTS-Encrypted-AES-256");  break;

              default: tty->print_cr("      available: unknown KM  code %d", i);      break;

            }

          }

        }

      }

      if (test_feature_bit(&_cipher_features[2], -1, (int)Cipher::_featureBits)) {

        tty->print_cr("    available Crypto Features of KMC (Cipher Message with Chaining):");

        for (unsigned int i = 0; i < Cipher::_featureBits; i++) {

            if (test_feature_bit(&_cipher_features[2], i, (int)Cipher::_featureBits)) {

            switch (i) {

              case Cipher::_Query:              tty->print_cr("      available: KMC  Query");                  break;

              case Cipher::_DEA:                tty->print_cr("      available: KMC  DEA");                    break;

              case Cipher::_TDEA128:            tty->print_cr("      available: KMC  TDEA-128");               break;

              case Cipher::_TDEA192:            tty->print_cr("      available: KMC  TDEA-192");               break;

              case Cipher::_EncryptedDEA:       tty->print_cr("      available: KMC  Encrypted DEA");          break;

              case Cipher::_EncryptedDEA128:    tty->print_cr("      available: KMC  Encrypted DEA-128");      break;

              case Cipher::_EncryptedDEA192:    tty->print_cr("      available: KMC  Encrypted DEA-192");      break;

              case Cipher::_AES128:             tty->print_cr("      available: KMC  AES-128");                break;

              case Cipher::_AES192:             tty->print_cr("      available: KMC  AES-192");                break;

              case Cipher::_AES256:             tty->print_cr("      available: KMC  AES-256");                break;

              case Cipher::_EnccryptedAES128:   tty->print_cr("      available: KMC  Encrypted-AES-128");      break;

              case Cipher::_EnccryptedAES192:   tty->print_cr("      available: KMC  Encrypted-AES-192");      break;

              case Cipher::_EnccryptedAES256:   tty->print_cr("      available: KMC  Encrypted-AES-256");      break;

              case Cipher::_PRNG:               tty->print_cr("      available: KMC  PRNG");                   break;

              default: tty->print_cr("      available: unknown KMC code %d", i);      break;

            }

          }

        }

      }

      if (test_feature_bit(&_msgdigest_features[0], -1, 2*MsgDigest::_featureBits)) {

        tty->cr();

        tty->print_cr("  available: %s", "Message Digest Functions for SHA");

      }

      if (test_feature_bit(&_msgdigest_features[0], -1, (int)MsgDigest::_featureBits)) {

        tty->print_cr("    available Features of KIMD (Msg Digest):");

        for (unsigned int i = 0; i < MsgDigest::_featureBits; i++) {

            if (test_feature_bit(&_msgdigest_features[0], i, (int)MsgDigest::_featureBits)) {

            switch (i) {

              case MsgDigest::_Query:  tty->print_cr("      available: KIMD Query");   break;

              case MsgDigest::_SHA1:   tty->print_cr("      available: KIMD SHA-1");   break;

              case MsgDigest::_SHA256: tty->print_cr("      available: KIMD SHA-256"); break;

              case MsgDigest::_SHA512: tty->print_cr("      available: KIMD SHA-512"); break;

              case MsgDigest::_GHASH:  tty->print_cr("      available: KIMD GHASH");   break;

              default: tty->print_cr("      available: unknown code %d", i);  break;

            }

          }

        }

      }

      if (test_feature_bit(&_msgdigest_features[2], -1, (int)MsgDigest::_featureBits)) {

        tty->print_cr("    available Features of KLMD (Msg Digest):");

        for (unsigned int i = 0; i < MsgDigest::_featureBits; i++) {

          if (test_feature_bit(&_msgdigest_features[2], i, (int)MsgDigest::_featureBits)) {

            switch (i) {

              case MsgDigest::_Query:  tty->print_cr("      available: KLMD Query");   break;

              case MsgDigest::_SHA1:   tty->print_cr("      available: KLMD SHA-1");   break;

              case MsgDigest::_SHA256: tty->print_cr("      available: KLMD SHA-256"); break;

              case MsgDigest::_SHA512: tty->print_cr("      available: KLMD SHA-512"); break;

              default: tty->print_cr("      available: unknown code %d", i);  break;

            }

          }

        }

      }

    }

    if (ContendedPaddingWidth > 0) {

      tty->cr();

      tty->print_cr("ContendedPaddingWidth " INTX_FORMAT, ContendedPaddingWidth);

    }

  }