// Test with make test.
func PrintfTests() {
	var b bool
	var i int
	var r rune
	var s string
	var x float64
	var p *int
	var imap map[int]int
	var fslice []float64
	var c complex64
	// Some good format/argtypes
	fmt.Printf("")
	fmt.Printf("%b %b %b", 3, i, x)
	fmt.Printf("%c %c %c %c", 3, i, 'x', r)
	fmt.Printf("%d %d %d", 3, i, imap)
	fmt.Printf("%e %e %e %e", 3e9, x, fslice, c)
	fmt.Printf("%E %E %E %E", 3e9, x, fslice, c)

//
// This represents the type information with OpDef::ArgDef and any type-related
// context.
class ArgType {
 public:
  ArgType() = default;
  ArgType(const ArgType& other) = default;
  static ArgType CreateInput(const OpDef::ArgDef& arg_def);
  static ArgType CreateInputRef(const OpDef::ArgDef& arg_def);
  static ArgType CreateOutput(const OpDef::ArgDef& arg_def);

  const tensorflow::DataType data_type() const { return data_type_; }

namespace tensorflow {
namespace generator {

ArgType ArgType::CreateInput(const OpDef::ArgDef& arg_def) {
  return ArgType(arg_def, kInput);
}

ArgType ArgType::CreateInputRef(const OpDef::ArgDef& arg_def) {
  return ArgType(arg_def, kInputRef);
}

ArgType ArgType::CreateOutput(const OpDef::ArgDef& arg_def) {
  return ArgType(arg_def, kOutput);
}

ArgType::ArgType(const OpDef::ArgDef& arg_def, Kind kind)

namespace generator {

ArgSpec::ArgSpec(const OpDef::ArgDef& arg_def, ArgType arg_type, int position)
    : name_(arg_def.name()),
      description_(arg_def.description()),
      arg_type_(arg_type),
      position_(position) {}

ArgSpec ArgSpec::CreateInput(const OpDef::ArgDef& arg_def, int position) {
  if (arg_def.is_ref()) {
    return ArgSpec(arg_def, ArgType::CreateInputRef(arg_def), position);
  } else {

		off := a.BitFields.ParseSigned(i) << a.Shift
		neg := int64(-1) << (int(a.Shift) + a.BitFields.NumBits())
		return Offset(neg | off)
	}
}

type ArgType int8

const (
	TypeUnknown      ArgType = iota
	TypePCRel                // PC-relative address
	TypeLabel                // absolute address
	TypeReg                  // integer register

  const string& description() const { return description_; }
  const ArgType arg_type() const { return arg_type_; }
  const int position() const { return position_; }

 private:
  explicit ArgSpec(const OpDef::ArgDef& arg_def, ArgType arg_type,
                   int position);

  string name_;
  string description_;
  ArgType arg_type_;
  int position_;
};

}  // namespace generator

#include "tensorflow/core/platform/types.h"

namespace tensorflow {
namespace generator {
namespace cpp {

class ArgTypeView {
 public:
  explicit ArgTypeView(ArgType arg_type);

  string TypeName() const;

 private:
  ArgType arg_type_;
};

}  // namespace cpp
}  // namespace generator
}  // namespace tensorflow

      arg.setType(resultType);
    }
    llvm::SmallVector<Type, 8> arg_types;
    for (auto arg : func.getArguments()) arg_types.push_back(arg.getType());
    func.setType(
        FunctionType::get(func.getContext(), arg_types,
                          func.front().getTerminator()->getOperandTypes()));
    return WalkResult::advance();
  });

// prepareArg checks if value can be used as an argument of type argType, and
// converts an invalid value to appropriate zero if possible.
func prepareArg(value reflect.Value, argType reflect.Type) (reflect.Value, error) {
	if !value.IsValid() {
		if !canBeNil(argType) {
			return reflect.Value{}, fmt.Errorf("value is nil; should be of type %s", argType)
		}
		value = reflect.Zero(argType)
	}
	if value.Type().AssignableTo(argType) {

  *fbody = flr->GetFunctionBody(handle);
  CHECK(*fbody);  // Can't be nullptr since we just instantiated it.
  const DataTypeVector& arg_types = (*fbody)->arg_types;
  std::vector<bool> const_args(arg_types.size());
  // If we can't analyze the const args. Bail out.
  TF_RETURN_IF_ERROR(
      BackwardsConstAnalysis(*((*fbody)->graph), &const_args,